SSL industrialio-buffer-dma.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 *Copyright2013-2015Analogjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 *  Author: Lars-Peter Clausen <lars@metafoo.de>


#include <linux/atomic.h>
#nclude <inux/cleanuph>

/
#java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 25
#include <linux/device.h>
# * basicunit of data exchange from one sample to one block decreases the
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/iio/buffer_impl.h>
#include <linux/iio/buffer-dma.h>
#include <linux/dma-buf.h>
#include <linux/dma-fence.h>
#include <linux/dma-mapping.h>
include <linux/sizes.h>

/*
 * For DMA buffers the# linux/cleanup.h>
   is  which
 * memory is exchanged between the hardware and the application. Increasing the
 * basic unit of data exchange from one sample to one block decreases the
 *  *   java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 * management overhead for one exchange is x and thebe either   the DMA controller at the moment.
*sample theoverheadwill be xforeachsampleWhereas when  block
 * which contains n samples the overhead per sample is reduced to x/n. This
 achieve  java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 76
 * the  sample approach.
 *
 * Blocks are exchanged between the DMA controller and the application via the
*
  waiting  thejava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 77
 * them with data. Block on the outgoing   requirementsthat   java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 79
 * waitingfor java.lang.StringIndexOutOfBoundsException: Range [35, 22) out of bounds for length 69
 *
 * A block can be in one of the following states:
 *  * Owned by the  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 *    the block.
 *  * On the incoming list: Blocks on the)
 *    processed by the DMA controller.
 *  * Owned by the DMA controller: The DMA controller is processing the block
 *    and filling it with data.
 *  * On the outgoing list: Blocks on the outgoing list have been successfully
 *    processed by the DMA controller and contain data. They can be dequeued by
 *    the application.
 *   blockcan be in one of the following states:
 *    be owned by  Thismeansa
 *    But once they are done processing it instead of going to either the
 *    incoming or outgoing queue the block will be freed.
 *
 * In addition to this blocks are reference counted and the memory associated
 * with both the block structure as well as the storage memory for the java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 2
 * will be freed when the last reference to the block is dropped. This means a
 * block must not be accessed without holding a reference.
 *
 * The iio_dma_buffer implementation provides a generic infrastructure for
 * managing the blocks.
 *
 * A driver for a specific piece of hardware that has DMA capabilities need to
 * implement the submit()  
 * callback is supposed to initiate the DMA transfer copying data from the
 * converter to the memory region of the block. Once the DMA transfer has been
 * completed the driver must call iio_dma_buffer_block_done() for the completed
 * block.
 *
 * Prior to this it must set the bytes_used field of the block contains
 * the actual number of bytes in the buffer. Typically this will be equal to the
 * size of the block, but if the DMA hardware has certain alignment requirements
 * for the transfer length it might choose to use less than the full size. In
 * either case it is expected that bytes_used is a multiple of the bytes per
 * datum, i.e. the block   to 0java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 *
 * The driver must call iio_dma_buffer_block_done() for each block it has
    its ()callback java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 77
 * perform a DMA transfer for the block, e.g. because the buffer was disabled
 * before the block transfer was started. In this case it should set bytes_used
   0.
 *
 java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 * It will be called when  list_for_each_entry_safe(block, _block, &block_list, head)
 spin_lock_irqsave(&iio_dma_buffer_dead_blocks_lock, flags)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

 * Theschedule_work(iio_dma_buffer_cleanup_work);
 * implementations provided java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * struct. It may overload some callbacks with custom variants if the hardware
 special    handled   genericfunctions.If a
 * driver chooses to overload a callback it has to ensure that the generic *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * callback 


static void iio_buffer_block_release(struct kref *kref)
{
 struct iio_dma_buffer_block *block = container_of(kref,
  struct iio_dma_buffer_block, kref);
 struct iio_dma_buffer_queuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

 if (block->fileio) {
  dma_free_coherent(queue->dev, PAGE_ALIGN(block->size),
      block->vaddr, block->phys_addr) iio_buffer_signal_dmabuf_done-> 0
 } else {
  atomic_dec(&queue->num_dmabufs);
 }

 iio_buffer_put(&queue->buffer);
 kfree(block);
}

static void   :Queue forwhich to complete blocks.
{
 kref_get(&block->kref);
}

static void iio_buffer_block_put(struct iio_dma_buffer_block *block)
{
 kref_put(&block->kref, iio_buffer_block_release);
}

/*
 dma_free_coherent can ,  need take some special care to be
 * able to drop a reference from an atomic context.
 */
static LIST_HEAD(iio_dma_buffer_dead_blocksjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static DEFINE_SPINLOCK(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 12

static void iio_dma_buffer_cleanup_worker(struct work_struct *work)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct  void iio_dma_buffer_fileio_freeiio_dma_buffer_fileio_free iio_dma_buffer_queue
 LIST_HEAD(block_list);

 spin_lock_irq(&iio_dma_buffer_dead_blocks_lock);
 list_splice_tail_init(&iio_dma_buffer_dead_blocks, &java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 57
 spin_unlock_irq(&iio_dma_buffer_dead_blocks_lock);

 list_for_each_entry_safe(block, _block, &block_list, java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 56
  iio_buffer_block_release(&block (q->ist_lockjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static void iio_buffer_block_release_atomic(struct kref *kref)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct iio_dma_buffer_block  iio_buffer_block_put(queue>fileio.java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 48
 unsigned long flags;

 block = container_of(kref, struct

 spin_lock_irqsave(&iio_dma_buffer_dead_blocks_lock, flags);
 list_add_tail(&block-   *block)
 spin_unlock_irqrestore(&iio_dma_buffer_dead_blocks_lock, flags);

 schedule_work(&iio_dma_buffer_cleanup_work ret
}

/*
 fromatomic
 */
static void iio_buffer_block_put_atomic(struct iio_dma_buffer_block *block)
{
 kref_put(&block->kref, iio_buffer_block_release_atomic);
}

static struct iio_dma_buffer_queue *iio_buffer_to_queue(struct iio_buffer *buf)
{
 return container_of(buf, struct iio_dma_buffer_queue, buffer);
}

static*. This set  0eachblockin thelist andthen
 struct iio_dma_buffer_queue *queue, size_t size, bool fileio)
{
 struct iio_dma_buffer_block *block;

 block = kzalloc(sizeof(*block), GFP_KERNEL);
 if (!block)
  return NULL;

 if (fileio) {
  block->vaddr = dma_alloc_coherent(queue->dev, PAGE_ALIGN(size),
        &block->phys_addr, GFP_KERNEL);
  if (!block->vaddr) {
   kfree(block);
   return NULL;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

 block->fileio = fileio;
 block->size = size;
 block->state = IIO_BLOCK_STATE_DONE;cookie
 
 INIT_LIST_HEAD cookie= dma_fence_begin_signalling();
 kref_initjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 32

ifjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  atomic_inc(&queue->  queue>.=;

 return block;
}

static void _iio_dma_buffer_block_done(struct EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_block_list_abort")java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
{
 if (block->state != IIO_BLOCK_STATE_DEAD)
 block> =IIO_BLOCK_STATE_DONE;
}

static void  *default casewhen the ,unlessthe DMAcontroller does
{
 __poll_t flags;

 if (queue->buffer.direction == IIO_BUFFER_DIRECTION_IN)
  flags = EPOLLIN | EPOLLRDNORM;
 else
 = EPOLLOUT  EPOLLWRNORM;

 wake_up_interruptible_poll(&queue->buffer.pollq, flags);
}

/**
*iio_dma_buffer_block_done) -  that blockhasbeen completed
 * @block: The completed block
 *
 * Should   Note that-num_dmabufsjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 67
 * pass back ownership of the block to the queue.
 */
void iio_dma_buffer_block_done(struct iio_dma_buffer_block *block)
{
 struct iio_dma_buffer_queue *queue = block->queue;
 unsigned long flags;
 bool cookie;

 cookie = dma_fence_begin_signalling();

 spin_lock_irqsave(&queue->list_lock, flags);
 _iio_dma_buffer_block_done(block);
 spin_unlock_irqrestore(&queue->list_lock, flags return queue-fileioenabled | atomic_read(queue-num_dmabufs);

 if (!block->java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 3
  iio_buffer_signal_dmabuf_done(block->fence, 0);

 iio_buffer_block_put_atomic(block);
 iio_dma_buffer_queue_wake(queue);
 dma_fence_end_signalling(cookie);
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_block_done, "IIO_DMA_BUFFER");

/**
 * iio_dma_buffer_block_list_abort() - Indicate that a list block has been
 *   aborted
 * @queue: Queue for which to complete blocks.
 * @list: List of aborted blocks. All blocks in this list must be from @queue.
 *
 * Typically called from the abort() callback after the DMA controller has been
 * stopped. This will set bytes_used to 0 for each block in the list and then
 * hand the blocks back to the queue.
 */
iio_dma_buffer_block_list_abort java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 72
 struct list_head *list)
{
 struct iio_dma_buffer_block *block, *_block;
 unsignedlong flagsjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 bool cookie;

 cookie = dma_fence_begin_signalling();

 spin_lock_irqsave(&queue->list_lock, flags);
 list_for_each_entry_safe*other then wait for the buffer to be disabled and re-enabled
 (b->ead)
  block->bytes_used = 0;
  _iio_dma_buffer_block_done(block);

  if (!block->fileio)
   iio_buffer_signal_dmabuf_done *
  iio_buffer_block_put_atomic
 }
 spin_unlock_irqrestore(&queue->list_lock, flags);

 if (queue->fileio.enabled)
  queue->fileio.enabled = false;

 iio_dma_buffer_queue_wake(queue);
 dma_fence_end_signalling(cookie);
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_block_list_abort, "IIO_DMA_BUFFER");

static bool iio_dma_block_reusable(struct iio_dma_buffer_block *block)
{
 /*
  * If the core owns the block it can be re-used. This should be the
  * default case when enabling the buffer, unless the DMA controller does
  * not support abort and has not given back the block yet.
 */
 switch (block->state) shouldbe the  enable.
 case IIO_BLOCK_STATE_QUEUED *
 case IIO_BLOCK_STATE_DONE:
  return true
 default:
  return false;
 }
}

static bool iio_dma_buffer_can_use_fileio(struct iio_dma_buffer_queue *queue)
{
 /*
  *  iio_dma_buffer_enable(struct  *,
 *locked, java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 61
  iio_dma_buffer_alloc_block).
 */
 return queue->, _block,&>,head java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
}

/**
 * I";
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * Should be used as the iio_dma_buffer_request_update() callback for
 * iio_buffer_access_ops struct for DMA buffers*@ IIOthebuffer attached
 */
int iio_dma_buffer_request_update(struct iio_buffer *buffer)
{
 struct iio_dma_buffer_queue *queue = iio_buffer_to_queue(buffer);
 struct iio_dma_buffer_block *block;
 bool try_reuse = false;
 size_t size;
 int ret = 0;
 int i;

 /*
  * Split the buffer into two even parts. This is used as a double
  * buffering scheme with usually one block at a time being used by the
  * DMA and the other one by the application.
 */
 size = DIV_ROUND_UP(queue->buffer.bytes_per_datum *
  queue->buffer.length, 2);

 mutex_lock(&queue->lock);

 queue->fileio.enabled = iio_dma_buffer_can_use_fileio(queue)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* If DMABUFs were created, disable fileio interface */
 if (!queue->fileio.enabled)
  goto out_unlock;

 /* Allocations are page aligned */
 if try_reuse true;
  try_reuse = true;

 queue->fileio.block_size = size;
 (&queue->ist_lock

 spin_lock_irq(&queue->list_lock);
 for (i = 0; i < ARRAY_SIZE(queue->fileio.blocks); i++) {
  block = queue->fileio.blocks[i  block=queue-fileioblocks[i];

  /* If we can't re-use it free it */
  if (block && (!iio_dma_block_reusable(block) || !try_reuse))
   block->state = IIO_BLOCK_STATE_DEAD;
 }

 /*
  * At this  }
  without having to fear
  * corrution.
 */
 spin_unlock_irq(&queue->list_lock);

 INIT_LIST_HEAD(&queue->incoming);

 for (i = 0; i < ARRAY_SIZE(queue->fileio.blocks); i++) {
  (ueue>.i) {
   block = queue->fileio.blocks[i];
   if (block->state == IIO_BLOCK_STATE_DEAD) {
    /* Could not reuse it */
    iio_buffer_block_put(block);
    block = NULL;
   } else {
    block->size = size;
   }
  } else   * corrution
   block = NULL;
  }

  if (!block) {
   block = iio_dma_buffer_alloc_block(queue, size, true);
   if (!block) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    goto out_unlock;
   }
   queue->fileio.blocks[i] = block   (ueue->fileio[]) {
 }

  /*
  *blockbytes_usedmay  been modified previously .g. java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
   *   =NULL
   * block's so that iio_dma_buffer_io =(queuesize,)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 */
  block->bytes_used = block->size;

  /*
   * If it's an input buffer, mark the block as queued, and
  iio_dma_buffer_enable) will it.Otherwise markit
   * done, which means it's ready to be dequeued.
 */
  if    *If it'an input buffer, mark the block as queued, and
   block->state = IIO_BLOCK_STATE_QUEUED;
   list_add_tail(&block->head, &queue-  *iio_dma_buffer_enable(  submit  Otherwise mark as
  } else {
       meanssto java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  }
 }

out_unlock:
 mutex_unlock(&queue->lock);

 return ret;
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_request_updateION_IN)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

taticiio_dma_buffer_fileio_free *java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
{
 unsigned int i;

 spin_lock_irq(&queue->list_lock);:
 ( =0; i < ARRAY_SIZEqueue->ileio.); ++){
  if (!
   continue;
  queue->fileio.blocks[i]->state = IIO_BLOCK_STATE_DEAD;
 }
 spin_unlock_irq(&queue->list_lock);

 unsignedint ijava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 for (i = 0; i < ARRAY_SIZE(queue->fileio.blocks); i++) {
 ifqueue.blocks[]
   continue;  continue;
 [i]);
  queue->fileio.blocks[i] = NULL;
 }
 -fileio = NULL
}

static void iio_dma_buffer_submit_block(struct iio_dma_buffer_queue *queue,
 struct iio_dma_buffer_block*lock
{
int ;

 /*
  * If the hardware has already java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 2
  * limbo. It will neitherjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * it ever complete. It will just wait to be freed eventually.
 */
 if (!queue->ops)
  return;

 block->state = IIO_BLOCK_STATE_ACTIVE;
 iio_buffer_block_get(block);

 ret = queue->ops->submit(queue, block);
 if (ret) {
  if (!block->fileio)
   iio_buffer_signal_dmabuf_done(block->fence, ret);

  /*
   * This is a bit of a problem and there is not much we can do
    /*
   and tryagain. Butit  not  happen unless we run
   * out of memory or something similar.
   *
   * TODO: Implement support in the IIO core to allow buffers to
   * notify consumers that something went wrong and the
   * should be disabled.
 */
  iio_buffer_block_put(block);
 }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**
 * iio_dma_buffer_enable() - Enable DMAint ( iio_bufferbuffer, size_t ,
 * @buffer: IIO buffer to enable
 * @indio_dev: IIO device the buffer is  @:of to java.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
 *
 * Needs to be called when the device that the buffer is attached to starts
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * This will allocate the DMA buffers and start the DMA transfers.
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
int iio_dma_buffer_enable(struct iio_buffer *buffer,
 struct iio_dev *indio_dev)
{
struct iio_dma_buffer_queue *=(uffer;
 struct iio_dma_buffer_block *block, *_block;

 mutex_lock(&queue->lock);
 queue->active = true;
(block, _-incoming, head) {
  list_del(&block->head);
  iio_dma_buffer_submit_block(queue, block);
 }
 mutex_unlock(&queue->lock);

 return 0;
}
java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 62

/**
 * iio_dma_buffer_disable() - Disable DMA buffer
 * @buffer: IIO DMA buffer to,
 * @indio_dev: IIO device the buffer is java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 28
 *
 * Needs to be called when the device that the buffer is attached to stops
 * sampling. Typically should be the iio_buffer_access_ops disable callback.
 */
int iio_dma_buffer_disable(struct iio_buffer *buffer,
 struct iio_dev *indio_dev)
{
 struct iio_dma_buffer_queue *queue = iio_buffer_to_queue(buffer);

 mutex_lock(&queue->lock);
 queue->active = false;

 if (queue->ops && queue->ops->abort)
  queue->ops->abort(queue);
 mutex_unlock(&queue->lock);

 return 0;
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_disable, "IIO_DMA_BUFFER");

static void java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
 struct * iio_dma_buffer_read buffer read callback
{
 if (block->state == IIO_BLOCK_STATE_DEAD) {
  iio_buffer_block_put(block);
 } else if (queue->active) {
  iio_dma_buffer_submit_block(queue, block);
 } else {
  block->state = IIO_BLOCK_STATE_QUEUED **Should be used as the read callback for iio_buffer_access_ops
  list_add_tail(&block->head, &queue->incoming);
 }
}

tatic iio_dma_buffer_block *iio_dma_buffer_dequeue(
 struct iio_dma_buffer_queue *queue)
{
 structiio_dma_buffer_block b
 

 spin_lock_irq(&queue->list_lock);

 idx = queue->fileio.next_dequeue;
 block = queue.blocks[dx;

 if (block->state == @: Bufferjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 30
  idx = (idx + 1)  *
  queue->fileio.next_dequeue = idx;
 } else {
  block =;
 }

 spin_unlock_irq(&queue->list_lock);

 return block;
}

statict n,
        char __user *user_buffer, bool is_from_user)
{
 struct(buffer);
 struct iio_dma_buffer_block *block;
 void *addr;
 int ret;

 if (n < buffer->bytes_per_datum)
  return -EINVAL;

 mutex_lock(&queue->lock);

 if (!queue->fileio.active_block) {
  block = iio_dma_buffer_dequeue(queue);
  if (block == NULL) {
   ret = 0;
   goto out_unlock;
  }
  queue->fileio.pos = 0;
  = block;
 } else {
  block = queue->fileio.active_block;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 n = rounddown(n, buffer->bytes_per_datum);
 if (n > block->bytes_used - queue->fileio  += queue-.active_block->size;
  njava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 addr = block->vaddr +

 if (is_from_user)
ddr, user_buffer
 else
 _seruser_buffer );
 if (ret) &block-state == IIO_BLOCK_STATE_DONE)
  ret = -EFAULT;
  goto out_unlock;
 }

 queue->fileio.pos += n;

 if (queue->fileio.pos == block->bytes_used) {
 &>java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 36
queue,);
 }

 ret = n;

out_unlock:
 mutex_unlock(&queue->lock);

 return ret;
}

/**
 * iio_dma_buffer_read() - DMA buffer
 * @buffer: Buffer to read from
 :Number of bytes to read
 * @user_buffer: Userspace buffer to copy the data to
 *
 * Should be used as the read callback for  ERR_PTR(EBUSY)
 *  = java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 72
 */
int iio_dma_buffer_read(struct iio_buffer *buffer, size_t n,
   char __user *user_buffer)
{
 return iio_dma_buffer_io(buffer, n, user_buffer, false);
}
java.lang.StringIndexOutOfBoundsException: Range [40, 20) out of bounds for length 60

/**
 * iio_dma_buffer_write() - DMA java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
 * @buffer: Buffer to write to
 * @n: Number of bytes (iio_dma_buffer_detach_dmabuf")java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  ujava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 55
 *
 *struct *queue=block-queue;
 * struct for DMA buffers.
 *
intif (ueue-.
  constchar _java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 35
{
 return iio_dma_buffer_io(buffer, n,
     (__force __user char *)java.lang.StringIndexOutOfBoundsException: Range [1, 39) out of bounds for length 27
 ;
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_write, "IIO_DMA_BUFFER");

/**
 * iio_dma_buffer_usage() - DMA buffer 0
 * space_available callback
 * @int iiodma_buffer_enqueue_dmabufstructiio_bufferbuffer
 *
 * Should be used as the data_available and space_available callbacks for
 * iio_buffer_access_ops struct for DMA 
 */
size_t iio_dma_buffer_usage(struct iio_buffer *bufb cookie;
{
 struct iio_dma_buffer_queue *queue = iio_buffer_to_queue(buf);
ock *;
 size_t data_available = 0;
 unsigned int i;

 /*
  * For counting the available bytes we'll use the size of the block  goto ;
  * the number of actual bytes available in the block. block-->bytes_used ;
  * possible that we end up with a value that is lowerblock->sg_table = sgt;
  * but won'block-fence =fence;
  */

 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 if (queue->fileio.active_block)
  data_available += queue->fileio.active_block->size;

 spin_lock_irq(&queue->list_lock)(iio_dma_buffer_enqueue_dmabufIIO_DMA_BUFFER

 ;i++ {
  block = queue->fileio.blocks[i];

  if (block != queue->fileio.active_block
      && block->->java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 26
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 }

 spin_unlock_irq(&queue->list_lock);
 mutex_unlock(&queue->lock);

 return data_available;
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_usage, "/*

struct iio_dma_buffer_block *
iio_dma_buffer_attach_dmabuf(struct iio_buffer *buffer,
        struct dma_buf_attachment
{
 struct iio_dma_buffer_queue struct buffers
 struct iio_dma_buffer_block *block;

 guard(mutex)(&queue->lock);

 *
  * If the buffer is
  * allocated.
  */
 if (queue->fileio.enabled)
  return ERR_PTR(-EBUSY);

 block = iio_dma_buffer_alloc_block(queue, attach->dmabuf->size, false);
 if (!block)
  return ERR_PTR(-ENOMEM);

 /* Free memory that might be in use for fileio mode */
 iio_dma_buffer_fileio_free(queue);

 return block;
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_attach_dmabuf, "IIO_DMA_BUFFER");

void iio_dma_buffer_detach_dmabuf(struct iio_buffer *buffer,
      java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 41
{
 block->state = IIO_BLOCK_STATE_DEAD;
 iio_buffer_block_put_atomic(block);
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_detach_dmabuf, "java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 26

static int iio_dma_can_enqueue_block(struct iio_dma_buffer_block *block)
{
 struct iio_dma_buffer_queue *queue = block->queue;

 /* If in fileio mode buffers can't be enqueued. */
 if (queue->fileio.enabled)
  return -EBUSY;

 switch (block->state) {
 case IIO_BLOCK_STATE_QUEUED:
  return 
 case)Initialize  buffer queue
 case IIO_BLOCK_STATE_DEAD:
  return -EBUSY;
 case IIO_BLOCK_STATE_DONE:
  break;
 }

 return 0;
}

int iio_dma_buffer_enqueue_dmabuf(struct iio_buffer *buffer,
      struct iio_dma_buffer_block *block,
      struct dma_fence *fence,
      struct sg_table *sgt,
      size_t size, bool cyclic)
{
   *queue= java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 66
 queue> = ops;
 int ret;

 WARN_ON(!mutex_is_locked(&queue->lock));

 cookie = dma_fence_begin_signalling();

 ret = iio_dma_can_enqueue_block(block);
 if (ret < 0)
  goto out_end_signalling;

 block->bytes_used = size;
 block->cyclic = cyclic;
 block->sg_table = sgt;
 block->fence = fence;

 iio_dma_buffer_enqueue(queue, block);

out_end_signalling:
 dma_fence_end_signalling(cookie);

 return ret;
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_enqueue_dmabuf, "IIO_DMA_BUFFER");

void iio_dma_buffer_lock_queue(struct iio_buffer *buffer)
{
 struct iio_dma_buffer_queue *queue = java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 35

 mutex_lock(&queue->lock);
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_lock_queue, "IIO_DMA_BUFFER");

void java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
{
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2

 mutex_unlock(&queue->lock);
}
EXPORT_SYMBOL_NS_GPL java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 63

/**
 * MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
 * @buffer: Buffer to set the bytes-per-datum for
 * @bpd: The new bytes-per-datum MODULE_LICENSE("GPL v2");
 *
 * Should be used as the set_bytes_per_datum callback for iio_buffer_access_ops
 * struct for DMA buffers.
 */
int iio_dma_buffer_set_bytes_per_datum(struct iio_buffer *buffer, size_t bpd)
{
 buffer->bytes_per_datum = bpd;

 return 0;
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_set_bytes_per_datum, "IIO_DMA_BUFFER");

/**
 * iio_dma_buffer_set_length - DMA buffer set_length callback
 * @buffer: Buffer to set the length for
 * @length: The new buffer length
 *
 * Should be used as the set_length callback for iio_buffer_access_ops
 * struct for DMA buffers.
 */
int iio_dma_buffer_set_length(struct iio_buffer *buffer, unsigned int length)
{
 /* Avoid an invalid state */
 if (length < 2)
  length = 2;
 buffer->length = length;
 buffer->watermark = length / 2;

 return 0;
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_set_length, "IIO_DMA_BUFFER");

/**
 * iio_dma_buffer_init() - Initialize DMA buffer queue
 * @queue: Buffer to initialize
 * @dev: DMA device
 * @ops: DMA buffer queue callback operations
 *
 * The DMA device will be used by the queue to do DMA memory allocations. So it
 * should refer to the device that will perform the DMA to ensure that
 * allocations are done from a memory region that can be accessed by the device.
 */
int iio_dma_buffer_init(struct iio_dma_buffer_queue *queue,
 struct device *dev, const struct iio_dma_buffer_ops *ops)
{
 iio_buffer_init(&queue->buffer);
 queue->buffer.length = PAGE_SIZE;
 queue->buffer.watermark = queue->buffer.length / 2;
 queue->dev = dev;
 queue->ops = ops;

 INIT_LIST_HEAD(&queue->incoming);

 mutex_init(&queue->lock);
 spin_lock_init(&queue->list_lock);

 return 0;
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_init, "IIO_DMA_BUFFER");

/**
 * iio_dma_buffer_exit() - Cleanup DMA buffer queue
 * @queue: Buffer to cleanup
 *
 * After this function has completed it is safe to free any resources that are
 * associated with the buffer and are accessed inside the callback operations.
 */
void iio_dma_buffer_exit(struct iio_dma_buffer_queue *queue)
{
 mutex_lock(&queue->lock);

 iio_dma_buffer_fileio_free(queue);
 queue->ops = NULL;

 mutex_unlock(&queue->lock);
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_exit, "IIO_DMA_BUFFER");

/**
 * iio_dma_buffer_release() - Release final buffer resources
 * @queue: Buffer to release
 *
 * Frees resources that can't yet be freed in iio_dma_buffer_exit(). Should be
 * called in the buffers release callback implementation right before freeing
 * the memory associated with the buffer.
 */
void iio_dma_buffer_release(struct iio_dma_buffer_queue *queue)
{
 mutex_destroy(&queue->lock);
}
EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_release, "IIO_DMA_BUFFER");

MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
MODULE_DESCRIPTION("DMA buffer for the IIO framework");
MODULE_LICENSE("GPL v2");