cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

iio_simple_dummy_buffer.c (3008B)

      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * Copyright (c) 2011 Jonathan Cameron
      4 *
      5 * Buffer handling elements of industrial I/O reference driver.
      6 * Uses the kfifo buffer.
      7 *
      8 * To test without hardware use the sysfs trigger.
      9 */
     10
     11#include <linux/kernel.h>
     12#include <linux/export.h>
     13#include <linux/slab.h>
     14#include <linux/interrupt.h>
     15#include <linux/irq.h>
     16#include <linux/bitmap.h>
     17
     18#include <linux/iio/iio.h>
     19#include <linux/iio/buffer.h>
     20#include <linux/iio/trigger_consumer.h>
     21#include <linux/iio/triggered_buffer.h>
     22
     23#include "iio_simple_dummy.h"
     24
     25/* Some fake data */
     26
     27static const s16 fakedata[] = {
     28	[DUMMY_INDEX_VOLTAGE_0] = 7,
     29	[DUMMY_INDEX_DIFFVOLTAGE_1M2] = -33,
     30	[DUMMY_INDEX_DIFFVOLTAGE_3M4] = -2,
     31	[DUMMY_INDEX_ACCELX] = 344,
     32};
     33
     34/**
     35 * iio_simple_dummy_trigger_h() - the trigger handler function
     36 * @irq: the interrupt number
     37 * @p: private data - always a pointer to the poll func.
     38 *
     39 * This is the guts of buffered capture. On a trigger event occurring,
     40 * if the pollfunc is attached then this handler is called as a threaded
     41 * interrupt (and hence may sleep). It is responsible for grabbing data
     42 * from the device and pushing it into the associated buffer.
     43 */
     44static irqreturn_t iio_simple_dummy_trigger_h(int irq, void *p)
     45{
     46	struct iio_poll_func *pf = p;
     47	struct iio_dev *indio_dev = pf->indio_dev;
     48	int i = 0, j;
     49	u16 *data;
     50
     51	data = kmalloc(indio_dev->scan_bytes, GFP_KERNEL);
     52	if (!data)
     53		goto done;
     54
     55	/*
     56	 * Three common options here:
     57	 * hardware scans:
     58	 *   certain combinations of channels make up a fast read. The capture
     59	 *   will consist of all of them. Hence we just call the grab data
     60	 *   function and fill the buffer without processing.
     61	 * software scans:
     62	 *   can be considered to be random access so efficient reading is just
     63	 *   a case of minimal bus transactions.
     64	 * software culled hardware scans:
     65	 *   occasionally a driver may process the nearest hardware scan to avoid
     66	 *   storing elements that are not desired. This is the fiddliest option
     67	 *   by far.
     68	 * Here let's pretend we have random access. And the values are in the
     69	 * constant table fakedata.
     70	 */
     71	for_each_set_bit(j, indio_dev->active_scan_mask, indio_dev->masklength)
     72		data[i++] = fakedata[j];
     73
     74	iio_push_to_buffers_with_timestamp(indio_dev, data,
     75					   iio_get_time_ns(indio_dev));
     76
     77	kfree(data);
     78
     79done:
     80	/*
     81	 * Tell the core we are done with this trigger and ready for the
     82	 * next one.
     83	 */
     84	iio_trigger_notify_done(indio_dev->trig);
     85
     86	return IRQ_HANDLED;
     87}
     88
     89static const struct iio_buffer_setup_ops iio_simple_dummy_buffer_setup_ops = {
     90};
     91
     92int iio_simple_dummy_configure_buffer(struct iio_dev *indio_dev)
     93{
     94	return iio_triggered_buffer_setup(indio_dev, NULL,
     95					  iio_simple_dummy_trigger_h,
     96					  &iio_simple_dummy_buffer_setup_ops);
     97}
     98
     99/**
    100 * iio_simple_dummy_unconfigure_buffer() - release buffer resources
    101 * @indio_dev: device instance state
    102 */
    103void iio_simple_dummy_unconfigure_buffer(struct iio_dev *indio_dev)
    104{
    105	iio_triggered_buffer_cleanup(indio_dev);
    106}