drivers/staging/iio/chrdev.h

   1 /* The industrial I/O core - character device related
   2  *
   3  * Copyright (c) 2008 Jonathan Cameron
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  */
   9
  10 #ifndef _IIO_CHRDEV_H_
  11 #define _IIO_CHRDEV_H_
  12 struct iio_dev;
  13
  14 /**
  15  * struct iio_handler - Structure used to specify file operations
  16  *                      for a particular chrdev
  17  * @chrdev:     character device structure
  18  * @id:         the location in the handler table - used for deallocation.
  19  * @flags:      file operations related flags including busy flag.
  20  * @private:    handler specific data used by the fileops registered with
  21  *              the chrdev.
  22  */
  23 struct iio_handler {
  24         struct cdev     chrdev;
  25         int             id;
  26         unsigned long   flags;
  27         void            *private;
  28 };
  29
  30 #define iio_cdev_to_handler(cd)                         \
  31         container_of(cd, struct iio_handler, chrdev)
  32
  33 /**
  34  * struct iio_event_data - The actual event being pushed to userspace
  35  * @id:         event identifier
  36  * @timestamp:  best estimate of time of event occurrence (often from
  37  *              the interrupt handler)
  38  */
  39 struct iio_event_data {
  40         int     id;
  41         s64     timestamp;
  42 };
  43
  44 /**
  45  * struct iio_detected_event_list - list element for events that have occurred
  46  * @list:               linked list header
  47  * @ev:                 the event itself
  48  * @shared_pointer:     used when the event is shared - i.e. can be escallated
  49  *                      on demand (eg ring buffer 50%->100% full)
  50  */
  51 struct iio_detected_event_list {
  52         struct list_head                list;
  53         struct iio_event_data           ev;
  54         struct iio_shared_ev_pointer    *shared_pointer;
  55 };
  56 /**
  57  * struct iio_shared_ev_pointer - allows shared events to identify if currently
  58  *                              in the detected event list
  59  * @ev_p:       pointer to detected event list element (null if not in list)
  60  * @lock:       protect this element to prevent simultaneous edit and remove
  61  */
  62 struct iio_shared_ev_pointer {
  63         struct iio_detected_event_list  *ev_p;
  64         spinlock_t                      lock;
  65 };
  66
  67 /**
  68  * struct iio_event_interface - chrdev interface for an event line
  69  * @dev:                device assocated with event interface
  70  * @handler:            fileoperations and related control for the chrdev
  71  * @wait:               wait queue to allow blocking reads of events
  72  * @event_list_lock:    mutex to protect the list of detected events
  73  * @det_events:         list of detected events
  74  * @max_events:         maximum number of events before new ones are dropped
  75  * @current_events:     number of events in detected list
  76  * @owner:              ensure the driver module owns the file, not iio
  77  * @private:            driver specific data
  78  * @_name:              used internally to store the sysfs name for minor id
  79  *                      attribute
  80  * @_attrname:          the event interface's attribute name
  81  */
  82 struct iio_event_interface {
  83         struct device                           dev;
  84         struct iio_handler                      handler;
  85         wait_queue_head_t                       wait;
  86         struct mutex                            event_list_lock;
  87         struct iio_detected_event_list          det_events;
  88         int                                     max_events;
  89         int                                     current_events;
  90         struct module                           *owner;
  91         void                                    *private;
  92         char                                    _name[35];
  93         char                                    _attrname[20];
  94 };
  95
  96 /**
  97  * struct iio_event_handler_list - element in list of handlers for events
  98  * @list:               list header
  99  * @refcount:           as the handler may be shared between multiple device
 100  *                      side events, reference counting ensures clean removal
 101  * @exist_lock:         prevents race conditions related to refcount usage.
 102  * @handler:            event handler function - called on event if this
 103  *                      event_handler is enabled.
 104  *
 105  * Each device has one list of these per interrupt line.
 106  **/
 107 struct iio_event_handler_list {
 108         struct list_head        list;
 109         int                     refcount;
 110         struct mutex            exist_lock;
 111         int (*handler)(struct iio_dev *dev_info, int index, s64 timestamp,
 112                        int no_test);
 113 };
 114
 115 #endif