drivers/staging/iio/sysfs.h

   1 /* The industrial I/O core
   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  * General attributes
  10  */
  11
  12 #ifndef _INDUSTRIAL_IO_SYSFS_H_
  13 #define _INDUSTRIAL_IO_SYSFS_H_
  14
  15 #include "iio.h"
  16
  17 /**
  18  * struct iio_event_attr - event control attribute
  19  * @dev_attr:   underlying device attribute
  20  * @mask:       mask for the event when detecting
  21  * @listel:     list header to allow addition to list of event handlers
  22 */
  23 struct iio_event_attr {
  24         struct device_attribute dev_attr;
  25         int mask;
  26         struct iio_event_handler_list *listel;
  27 };
  28
  29 #define to_iio_event_attr(_dev_attr) \
  30         container_of(_dev_attr, struct iio_event_attr, dev_attr)
  31
  32 /**
  33  * struct iio_chrdev_minor_attr - simple attribute to allow reading of chrdev
  34  *                              minor number
  35  * @dev_attr:   underlying device attribute
  36  * @minor:      the minor number
  37  */
  38 struct iio_chrdev_minor_attr {
  39         struct device_attribute dev_attr;
  40         int minor;
  41 };
  42
  43 void
  44 __init_iio_chrdev_minor_attr(struct iio_chrdev_minor_attr *minor_attr,
  45                            const char *name,
  46                            struct module *owner,
  47                            int id);
  48
  49
  50 #define to_iio_chrdev_minor_attr(_dev_attr) \
  51         container_of(_dev_attr, struct iio_chrdev_minor_attr, dev_attr);
  52
  53 /**
  54  * struct iio_dev_attr - iio specific device attribute
  55  * @dev_attr:   underlying device attribute
  56  * @address:    associated register address
  57  * @val2:       secondary attribute value
  58  */
  59 struct iio_dev_attr {
  60         struct device_attribute dev_attr;
  61         int address;
  62         int val2;
  63 };
  64
  65 #define to_iio_dev_attr(_dev_attr)                              \
  66         container_of(_dev_attr, struct iio_dev_attr, dev_attr)
  67
  68 ssize_t iio_read_const_attr(struct device *dev,
  69                             struct device_attribute *attr,
  70                             char *len);
  71
  72 /**
  73  * struct iio_const_attr - constant device specific attribute
  74  *                         often used for things like available modes
  75  * @string:     attribute string
  76  * @dev_attr:   underlying device attribute
  77  */
  78 struct iio_const_attr {
  79         const char *string;
  80         struct device_attribute dev_attr;
  81 };
  82
  83 #define to_iio_const_attr(_dev_attr) \
  84         container_of(_dev_attr, struct iio_const_attr, dev_attr)
  85
  86 /* Some attributes will be hard coded (device dependent) and not require an
  87    address, in these cases pass a negative */
  88 #define IIO_ATTR(_name, _mode, _show, _store, _addr)            \
  89         { .dev_attr = __ATTR(_name, _mode, _show, _store),      \
  90           .address = _addr }
  91
  92 #define IIO_ATTR_2(_name, _mode, _show, _store, _addr, _val2)   \
  93         { .dev_attr = __ATTR(_name, _mode, _show, _store),      \
  94                         .address = _addr,                       \
  95                         .val2 = _val2 }
  96
  97 #define IIO_DEVICE_ATTR(_name, _mode, _show, _store, _addr)     \
  98         struct iio_dev_attr iio_dev_attr_##_name                \
  99         = IIO_ATTR(_name, _mode, _show, _store, _addr)
 100
 101 #define IIO_DEVICE_ATTR_NAMED(_vname, _name, _mode, _show, _store, _addr) \
 102         struct iio_dev_attr iio_dev_attr_##_vname                       \
 103         = IIO_ATTR(_name, _mode, _show, _store, _addr)
 104
 105 #define IIO_DEVICE_ATTR_2(_name, _mode, _show, _store, _addr, _val2)    \
 106         struct iio_dev_attr iio_dev_attr_##_name                        \
 107         = IIO_ATTR_2(_name, _mode, _show, _store, _addr, _val2)
 108
 109 #define IIO_CONST_ATTR(_name, _string)                                  \
 110         struct iio_const_attr iio_const_attr_##_name                    \
 111         = { .string = _string,                                          \
 112             .dev_attr = __ATTR(_name, S_IRUGO, iio_read_const_attr, NULL)}
 113
 114 /* Generic attributes of onetype or another */
 115
 116 /**
 117  * IIO_DEV_ATTR_REV - revision number for the device
 118  * @_show: output method for the attribute
 119  *
 120  * Very much device dependent.
 121  **/
 122 #define IIO_DEV_ATTR_REV(_show)                 \
 123         IIO_DEVICE_ATTR(revision, S_IRUGO, _show, NULL, 0)
 124
 125 /**
 126  * IIO_DEV_ATTR_NAME - chip type dependent identifier
 127  * @_show: output method for the attribute
 128  **/
 129 #define IIO_DEV_ATTR_NAME(_show)                                \
 130         IIO_DEVICE_ATTR(name, S_IRUGO, _show, NULL, 0)
 131
 132 /**
 133  * IIO_DEV_ATTR_SAMP_FREQ - sets any internal clock frequency
 134  * @_mode: sysfs file mode/permissions
 135  * @_show: output method for the attribute
 136  * @_store: input method for the attribute
 137  **/
 138 #define IIO_DEV_ATTR_SAMP_FREQ(_mode, _show, _store)                    \
 139         IIO_DEVICE_ATTR(sampling_frequency, _mode, _show, _store, 0)
 140
 141 /**
 142  * IIO_DEV_ATTR_AVAIL_SAMP_FREQ - list available sampling frequencies
 143  * @_show: output method for the attribute
 144  *
 145  * May be mode dependent on some devices
 146  **/
 147 /* Deprecated */
 148 #define IIO_DEV_ATTR_AVAIL_SAMP_FREQ(_show)                             \
 149         IIO_DEVICE_ATTR(available_sampling_frequency, S_IRUGO, _show, NULL, 0)
 150
 151 #define IIO_DEV_ATTR_SAMP_FREQ_AVAIL(_show)                             \
 152         IIO_DEVICE_ATTR(sampling_frequency_available, S_IRUGO, _show, NULL, 0)
 153 /**
 154  * IIO_CONST_ATTR_AVAIL_SAMP_FREQ - list available sampling frequencies
 155  * @_string: frequency string for the attribute
 156  *
 157  * Constant version
 158  **/
 159 /* Deprecated */
 160 #define IIO_CONST_ATTR_AVAIL_SAMP_FREQ(_string)                 \
 161         IIO_CONST_ATTR(available_sampling_frequency, _string)
 162
 163 #define IIO_CONST_ATTR_SAMP_FREQ_AVAIL(_string)                 \
 164         IIO_CONST_ATTR(sampling_frequency_available, _string)
 165
 166 /**
 167  * IIO_DEV_ATTR_SCAN_MODE - select a scan mode
 168  * @_mode: sysfs file mode/permissions
 169  * @_show: output method for the attribute
 170  * @_store: input method for the attribute
 171  *
 172  * This is used when only certain combinations of inputs may be read in one
 173  * scan.
 174  **/
 175 #define IIO_DEV_ATTR_SCAN_MODE(_mode, _show, _store)            \
 176         IIO_DEVICE_ATTR(scan_mode, _mode, _show, _store, 0)
 177
 178 /**
 179  * IIO_DEV_ATTR_AVAIL_SCAN_MODES - list available scan modes
 180  * @_show: output method for the attribute
 181  **/
 182 #define IIO_DEV_ATTR_AVAIL_SCAN_MODES(_show)                            \
 183         IIO_DEVICE_ATTR(available_scan_modes, S_IRUGO, _show, NULL, 0)
 184
 185 /**
 186  * IIO_DEV_ATTR_SCAN - result of scan of multiple channels
 187  * @_show: output method for the attribute
 188  **/
 189 #define IIO_DEV_ATTR_SCAN(_show)                \
 190         IIO_DEVICE_ATTR(scan, S_IRUGO, _show, NULL, 0);
 191
 192 /**
 193  * IIO_DEV_ATTR_INPUT - direct read of a single input channel
 194  * @_number: input channel number
 195  * @_show: output method for the attribute
 196  **/
 197 #define IIO_DEV_ATTR_INPUT(_number, _show)                              \
 198         IIO_DEVICE_ATTR(in##_number, S_IRUGO, _show, NULL, _number)
 199
 200 /**
 201  * IIO_DEV_ATTR_SW_RING_ENABLE - enable software ring buffer
 202  * @_show: output method for the attribute
 203  * @_store: input method for the attribute
 204  *
 205  * Success may be dependent on attachment of trigger previously.
 206  **/
 207 #define IIO_DEV_ATTR_SW_RING_ENABLE(_show, _store)                      \
 208         IIO_DEVICE_ATTR(sw_ring_enable, S_IRUGO | S_IWUSR, _show, _store, 0)
 209
 210 /**
 211  * IIO_DEV_ATTR_HW_RING_ENABLE - enable hardware ring buffer
 212  * @_show: output method for the attribute
 213  * @_store: input method for the attribute
 214  *
 215  * This is a different attribute from the software one as one can envision
 216  * schemes where a combination of the two may be used.
 217  **/
 218 #define IIO_DEV_ATTR_HW_RING_ENABLE(_show, _store)                      \
 219         IIO_DEVICE_ATTR(hw_ring_enable, S_IRUGO | S_IWUSR, _show, _store, 0)
 220
 221 /**
 222  * IIO_DEV_ATTR_BPSE - set number of bits per scan element
 223  * @_mode: sysfs file mode/permissions
 224  * @_show: output method for the attribute
 225  * @_store: input method for the attribute
 226  **/
 227 #define IIO_DEV_ATTR_BPSE(_mode, _show, _store)         \
 228         IIO_DEVICE_ATTR(bpse, _mode, _show, _store, 0)
 229
 230 /**
 231  * IIO_DEV_ATTR_BPSE_AVAILABLE - number of bits per scan element supported
 232  * @_show: output method for the attribute
 233  **/
 234 #define IIO_DEV_ATTR_BPSE_AVAILABLE(_show)                              \
 235         IIO_DEVICE_ATTR(bpse_available, S_IRUGO, _show, NULL, 0)
 236
 237 /**
 238  * IIO_DEV_ATTR_TEMP - many sensors have auxiliary temperature sensors
 239  * @_show: output method for the attribute
 240  **/
 241 #define IIO_DEV_ATTR_TEMP(_show)                        \
 242         IIO_DEVICE_ATTR(temp, S_IRUGO, _show, NULL, 0)
 243
 244 #define IIO_DEV_ATTR_TEMP_RAW(_show)                    \
 245         IIO_DEVICE_ATTR(temp_raw, S_IRUGO, _show, NULL, 0)
 246
 247 /**
 248  * IIO_EVENT_SH - generic shared event handler
 249  * @_name: event name
 250  * @_handler: handler function to be called
 251  *
 252  * This is used in cases where more than one event may result from a single
 253  * handler.  Often the case that some alarm register must be read and multiple
 254  * alarms may have been triggered.
 255  **/
 256 #define IIO_EVENT_SH(_name, _handler)                                   \
 257         static struct iio_event_handler_list                            \
 258         iio_event_##_name = {                                           \
 259                 .handler = _handler,                                    \
 260                 .refcount = 0,                                          \
 261                 .exist_lock = __MUTEX_INITIALIZER(iio_event_##_name     \
 262                                                   .exist_lock),         \
 263                 .list = {                                               \
 264                         .next = &iio_event_##_name.list,                \
 265                         .prev = &iio_event_##_name.list,                \
 266                 },                                                      \
 267         };
 268
 269 /**
 270  * IIO_EVENT_ATTR_SH - generic shared event attribute
 271  * @_name: event name
 272  * @_ev_list: event handler list
 273  * @_show: output method for the attribute
 274  * @_store: input method for the attribute
 275  * @_mask: mask used when detecting the event
 276  *
 277  * An attribute with an associated IIO_EVENT_SH
 278  **/
 279 #define IIO_EVENT_ATTR_SH(_name, _ev_list, _show, _store, _mask)        \
 280         static struct iio_event_attr                                    \
 281         iio_event_attr_##_name                                          \
 282         = { .dev_attr = __ATTR(_name, S_IRUGO | S_IWUSR,                \
 283                                _show, _store),                          \
 284             .mask = _mask,                                              \
 285             .listel = &_ev_list };
 286
 287 /**
 288  * IIO_EVENT_ATTR - non-shared event attribute
 289  * @_name: event name
 290  * @_show: output method for the attribute
 291  * @_store: input method for the attribute
 292  * @_mask: mask used when detecting the event
 293  * @_handler: handler function to be called
 294  **/
 295 #define IIO_EVENT_ATTR(_name, _show, _store, _mask, _handler)           \
 296         static struct iio_event_handler_list                            \
 297         iio_event_##_name = {                                           \
 298                 .handler = _handler,                                    \
 299         };                                                              \
 300         static struct                                                   \
 301         iio_event_attr                                                  \
 302         iio_event_attr_##_name                                          \
 303         = { .dev_attr = __ATTR(_name, S_IRUGO | S_IWUSR,                \
 304                                _show, _store),                          \
 305             .mask = _mask,                                              \
 306             .listel = &iio_event_##_name };                             \
 307
 308 /**
 309  * IIO_EVENT_ATTR_DATA_RDY - event driven by data ready signal
 310  * @_show: output method for the attribute
 311  * @_store: input method for the attribute
 312  * @_mask: mask used when detecting the event
 313  * @_handler: handler function to be called
 314  *
 315  * Not typically implemented in devices where full triggering support
 316  * has been implemented.
 317  **/
 318 #define IIO_EVENT_ATTR_DATA_RDY(_show, _store, _mask, _handler) \
 319         IIO_EVENT_ATTR(data_rdy, _show, _store, _mask, _handler)
 320
 321 #define IIO_EVENT_CODE_DATA_RDY         100
 322 #define IIO_EVENT_CODE_RING_BASE        200
 323 #define IIO_EVENT_CODE_ACCEL_BASE       300
 324 #define IIO_EVENT_CODE_GYRO_BASE        400
 325 #define IIO_EVENT_CODE_ADC_BASE         500
 326 #define IIO_EVENT_CODE_MISC_BASE        600
 327
 328 #define IIO_EVENT_CODE_DEVICE_SPECIFIC  1000
 329
 330 /**
 331  * IIO_EVENT_ATTR_RING_50_FULL - ring buffer event to indicate 50% full
 332  * @_show: output method for the attribute
 333  * @_store: input method for the attribute
 334  * @_mask: mask used when detecting the event
 335  * @_handler: handler function to be called
 336  **/
 337 #define IIO_EVENT_ATTR_RING_50_FULL(_show, _store, _mask, _handler)     \
 338         IIO_EVENT_ATTR(ring_50_full, _show, _store, _mask, _handler)
 339
 340 /**
 341  * IIO_EVENT_ATTR_RING_50_FULL_SH - shared ring event to indicate 50% full
 342  * @_evlist: event handler list
 343  * @_show: output method for the attribute
 344  * @_store: input method for the attribute
 345  * @_mask: mask used when detecting the event
 346  **/
 347 #define IIO_EVENT_ATTR_RING_50_FULL_SH(_evlist, _show, _store, _mask)   \
 348         IIO_EVENT_ATTR_SH(ring_50_full, _evlist, _show, _store, _mask)
 349
 350 /**
 351  * IIO_EVENT_ATTR_RING_75_FULL_SH - shared ring event to indicate 75% full
 352  * @_evlist: event handler list
 353  * @_show: output method for the attribute
 354  * @_store: input method for the attribute
 355  * @_mask: mask used when detecting the event
 356  **/
 357 #define IIO_EVENT_ATTR_RING_75_FULL_SH(_evlist, _show, _store, _mask)   \
 358         IIO_EVENT_ATTR_SH(ring_75_full, _evlist, _show, _store, _mask)
 359
 360 #define IIO_EVENT_CODE_RING_50_FULL     IIO_EVENT_CODE_RING_BASE
 361 #define IIO_EVENT_CODE_RING_75_FULL     (IIO_EVENT_CODE_RING_BASE + 1)
 362 #define IIO_EVENT_CODE_RING_100_FULL    (IIO_EVENT_CODE_RING_BASE + 2)
 363
 364 #endif /* _INDUSTRIAL_IO_SYSFS_H_ */