LXR linux/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*/
  23struct 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_dev_attr - iio specific device attribute
  34 * @dev_attr:   underlying device attribute
  35 * @address:    associated register address
  36 * @val2:       secondary attribute value
  37 */
  38struct iio_dev_attr {
  39        struct device_attribute dev_attr;
  40        int address;
  41        int val2;
  42};
  43
  44#define to_iio_dev_attr(_dev_attr)                              \
  45        container_of(_dev_attr, struct iio_dev_attr, dev_attr)
  46
  47ssize_t iio_read_const_attr(struct device *dev,
  48                            struct device_attribute *attr,
  49                            char *len);
  50
  51/**
  52 * struct iio_const_attr - constant device specific attribute
  53 *                         often used for things like available modes
  54 * @string:     attribute string
  55 * @dev_attr:   underlying device attribute
  56 */
  57struct iio_const_attr {
  58        const char *string;
  59        struct device_attribute dev_attr;
  60};
  61
  62#define to_iio_const_attr(_dev_attr) \
  63        container_of(_dev_attr, struct iio_const_attr, dev_attr)
  64
  65/* Some attributes will be hard coded (device dependent) and not require an
  66   address, in these cases pass a negative */
  67#define IIO_ATTR(_name, _mode, _show, _store, _addr)            \
  68        { .dev_attr = __ATTR(_name, _mode, _show, _store),      \
  69          .address = _addr }
  70
  71#define IIO_DEVICE_ATTR(_name, _mode, _show, _store, _addr)     \
  72        struct iio_dev_attr iio_dev_attr_##_name                \
  73        = IIO_ATTR(_name, _mode, _show, _store, _addr)
  74
  75#define IIO_DEVICE_ATTR_NAMED(_vname, _name, _mode, _show, _store, _addr) \
  76        struct iio_dev_attr iio_dev_attr_##_vname                       \
  77        = IIO_ATTR(_name, _mode, _show, _store, _addr)
  78
  79#define IIO_DEVICE_ATTR_2(_name, _mode, _show, _store, _addr, _val2)    \
  80        struct iio_dev_attr iio_dev_attr_##_name                        \
  81        = IIO_ATTR_2(_name, _mode, _show, _store, _addr, _val2)
  82
  83#define IIO_CONST_ATTR(_name, _string)                                  \
  84        struct iio_const_attr iio_const_attr_##_name                    \
  85        = { .string = _string,                                          \
  86            .dev_attr = __ATTR(_name, S_IRUGO, iio_read_const_attr, NULL)}
  87
  88#define IIO_CONST_ATTR_NAMED(_vname, _name, _string)                    \
  89        struct iio_const_attr iio_const_attr_##_vname                   \
  90        = { .string = _string,                                          \
  91            .dev_attr = __ATTR(_name, S_IRUGO, iio_read_const_attr, NULL)}
  92/* Generic attributes of onetype or another */
  93
  94/**
  95 * IIO_DEV_ATTR_REV - revision number for the device
  96 * @_show: output method for the attribute
  97 *
  98 * Very much device dependent.
  99 **/
 100#define IIO_DEV_ATTR_REV(_show)                 \
 101        IIO_DEVICE_ATTR(revision, S_IRUGO, _show, NULL, 0)
 102
 103/**
 104 * IIO_DEV_ATTR_NAME - chip type dependent identifier
 105 * @_show: output method for the attribute
 106 **/
 107#define IIO_DEV_ATTR_NAME(_show)                                \
 108        IIO_DEVICE_ATTR(name, S_IRUGO, _show, NULL, 0)
 109
 110/**
 111 * IIO_DEV_ATTR_RESET: resets the device
 112 **/
 113#define IIO_DEV_ATTR_RESET(_store)                      \
 114        IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, _store, 0)
 115
 116/**
 117 * IIO_CONST_ATTR_NAME - constant identifier
 118 * @_string: the name
 119 **/
 120#define IIO_CONST_ATTR_NAME(_string)                            \
 121        IIO_CONST_ATTR(name, _string)
 122
 123/**
 124 * IIO_DEV_ATTR_SAMP_FREQ - sets any internal clock frequency
 125 * @_mode: sysfs file mode/permissions
 126 * @_show: output method for the attribute
 127 * @_store: input method for the attribute
 128 **/
 129#define IIO_DEV_ATTR_SAMP_FREQ(_mode, _show, _store)                    \
 130        IIO_DEVICE_ATTR(sampling_frequency, _mode, _show, _store, 0)
 131
 132/**
 133 * IIO_DEV_ATTR_AVAIL_SAMP_FREQ - list available sampling frequencies
 134 * @_show: output method for the attribute
 135 *
 136 * May be mode dependent on some devices
 137 **/
 138/* Deprecated */
 139#define IIO_DEV_ATTR_AVAIL_SAMP_FREQ(_show)                             \
 140        IIO_DEVICE_ATTR(available_sampling_frequency, S_IRUGO, _show, NULL, 0)
 141
 142#define IIO_DEV_ATTR_SAMP_FREQ_AVAIL(_show)                             \
 143        IIO_DEVICE_ATTR(sampling_frequency_available, S_IRUGO, _show, NULL, 0)
 144/**
 145 * IIO_CONST_ATTR_AVAIL_SAMP_FREQ - list available sampling frequencies
 146 * @_string: frequency string for the attribute
 147 *
 148 * Constant version
 149 **/
 150#define IIO_CONST_ATTR_SAMP_FREQ_AVAIL(_string)                 \
 151        IIO_CONST_ATTR(sampling_frequency_available, _string)
 152
 153/**
 154 * IIO_DEV_ATTR_SW_RING_ENABLE - enable software ring buffer
 155 * @_show: output method for the attribute
 156 * @_store: input method for the attribute
 157 *
 158 * Success may be dependent on attachment of trigger previously.
 159 **/
 160#define IIO_DEV_ATTR_SW_RING_ENABLE(_show, _store)                      \
 161        IIO_DEVICE_ATTR(sw_ring_enable, S_IRUGO | S_IWUSR, _show, _store, 0)
 162
 163/**
 164 * IIO_DEV_ATTR_HW_RING_ENABLE - enable hardware ring buffer
 165 * @_show: output method for the attribute
 166 * @_store: input method for the attribute
 167 *
 168 * This is a different attribute from the software one as one can envision
 169 * schemes where a combination of the two may be used.
 170 **/
 171#define IIO_DEV_ATTR_HW_RING_ENABLE(_show, _store)                      \
 172        IIO_DEVICE_ATTR(hw_ring_enable, S_IRUGO | S_IWUSR, _show, _store, 0)
 173
 174#define IIO_DEV_ATTR_TEMP_RAW(_show)                    \
 175        IIO_DEVICE_ATTR(temp_raw, S_IRUGO, _show, NULL, 0)
 176
 177#define IIO_CONST_ATTR_TEMP_OFFSET(_string)             \
 178        IIO_CONST_ATTR(temp_offset, _string)
 179
 180#define IIO_CONST_ATTR_TEMP_SCALE(_string)              \
 181        IIO_CONST_ATTR(temp_scale, _string)
 182
 183/**
 184 * IIO_EVENT_SH - generic shared event handler
 185 * @_name: event name
 186 * @_handler: handler function to be called
 187 *
 188 * This is used in cases where more than one event may result from a single
 189 * handler.  Often the case that some alarm register must be read and multiple
 190 * alarms may have been triggered.
 191 **/
 192#define IIO_EVENT_SH(_name, _handler)                                   \
 193        static struct iio_event_handler_list                            \
 194        iio_event_##_name = {                                           \
 195                .handler = _handler,                                    \
 196                .refcount = 0,                                          \
 197                .exist_lock = __MUTEX_INITIALIZER(iio_event_##_name     \
 198                                                  .exist_lock),         \
 199                .list = {                                               \
 200                        .next = &iio_event_##_name.list,                \
 201                        .prev = &iio_event_##_name.list,                \
 202                },                                                      \
 203        };
 204
 205/**
 206 * IIO_EVENT_ATTR_SH - generic shared event attribute
 207 * @_name: event name
 208 * @_ev_list: event handler list
 209 * @_show: output method for the attribute
 210 * @_store: input method for the attribute
 211 * @_mask: mask used when detecting the event
 212 *
 213 * An attribute with an associated IIO_EVENT_SH
 214 **/
 215#define IIO_EVENT_ATTR_SH(_name, _ev_list, _show, _store, _mask)        \
 216        static struct iio_event_attr                                    \
 217        iio_event_attr_##_name                                          \
 218        = { .dev_attr = __ATTR(_name, S_IRUGO | S_IWUSR,                \
 219                               _show, _store),                          \
 220            .mask = _mask,                                              \
 221            .listel = &_ev_list };
 222
 223#define IIO_EVENT_ATTR_NAMED_SH(_vname, _name, _ev_list, _show, _store, _mask) \
 224        static struct iio_event_attr                                    \
 225        iio_event_attr_##_vname                                         \
 226        = { .dev_attr = __ATTR(_name, S_IRUGO | S_IWUSR,                \
 227                               _show, _store),                          \
 228            .mask = _mask,                                              \
 229            .listel = &_ev_list };
 230
 231/**
 232 * IIO_EVENT_ATTR - non-shared event attribute
 233 * @_name: event name
 234 * @_show: output method for the attribute
 235 * @_store: input method for the attribute
 236 * @_mask: mask used when detecting the event
 237 * @_handler: handler function to be called
 238 **/
 239#define IIO_EVENT_ATTR(_name, _show, _store, _mask, _handler)           \
 240        IIO_EVENT_SH(_name, _handler);                                  \
 241        static struct                                                   \
 242        iio_event_attr                                                  \
 243        iio_event_attr_##_name                                          \
 244        = { .dev_attr = __ATTR(_name, S_IRUGO | S_IWUSR,                \
 245                               _show, _store),                          \
 246            .mask = _mask,                                              \
 247            .listel = &iio_event_##_name };                             \
 248
 249/**
 250 * IIO_EVENT_ATTR_DATA_RDY - event driven by data ready signal
 251 * @_show: output method for the attribute
 252 * @_store: input method for the attribute
 253 * @_mask: mask used when detecting the event
 254 * @_handler: handler function to be called
 255 *
 256 * Not typically implemented in devices where full triggering support
 257 * has been implemented.
 258 **/
 259#define IIO_EVENT_ATTR_DATA_RDY(_show, _store, _mask, _handler) \
 260        IIO_EVENT_ATTR(data_rdy, _show, _store, _mask, _handler)
 261
 262#define IIO_EV_CLASS_BUFFER             0
 263#define IIO_EV_CLASS_IN                 1
 264#define IIO_EV_CLASS_ACCEL              2
 265#define IIO_EV_CLASS_GYRO               3
 266#define IIO_EV_CLASS_MAGN               4
 267#define IIO_EV_CLASS_LIGHT              5
 268#define IIO_EV_CLASS_PROXIMITY          6
 269
 270#define IIO_EV_MOD_X                    0
 271#define IIO_EV_MOD_Y                    1
 272#define IIO_EV_MOD_Z                    2
 273#define IIO_EV_MOD_X_AND_Y              3
 274#define IIO_EV_MOD_X_ANX_Z              4
 275#define IIO_EV_MOD_Y_AND_Z              5
 276#define IIO_EV_MOD_X_AND_Y_AND_Z        6
 277#define IIO_EV_MOD_X_OR_Y               7
 278#define IIO_EV_MOD_X_OR_Z               8
 279#define IIO_EV_MOD_Y_OR_Z               9
 280#define IIO_EV_MOD_X_OR_Y_OR_Z          10
 281
 282#define IIO_EV_TYPE_THRESH              0
 283#define IIO_EV_TYPE_MAG                 1
 284#define IIO_EV_TYPE_ROC                 2
 285
 286#define IIO_EV_DIR_EITHER               0
 287#define IIO_EV_DIR_RISING               1
 288#define IIO_EV_DIR_FALLING              2
 289
 290#define IIO_EVENT_CODE(channelclass, orient_bit, number,                \
 291                       modifier, type, direction)                       \
 292        (channelclass | (orient_bit << 8) | ((number) << 9) |           \
 293         ((modifier) << 13) | ((type) << 16) | ((direction) << 24))
 294
 295#define IIO_MOD_EVENT_CODE(channelclass, number, modifier,              \
 296                           type, direction)                             \
 297        IIO_EVENT_CODE(channelclass, 1, number, modifier, type, direction)
 298
 299#define IIO_UNMOD_EVENT_CODE(channelclass, number, type, direction)     \
 300        IIO_EVENT_CODE(channelclass, 0, number, 0, type, direction)
 301
 302
 303#define IIO_BUFFER_EVENT_CODE(code)             \
 304        (IIO_EV_CLASS_BUFFER | (code << 8))
 305
 306/**
 307 * IIO_EVENT_ATTR_RING_50_FULL - ring buffer event to indicate 50% full
 308 * @_show: output method for the attribute
 309 * @_store: input method for the attribute
 310 * @_mask: mask used when detecting the event
 311 * @_handler: handler function to be called
 312 **/
 313#define IIO_EVENT_ATTR_RING_50_FULL(_show, _store, _mask, _handler)     \
 314        IIO_EVENT_ATTR(ring_50_full, _show, _store, _mask, _handler)
 315
 316/**
 317 * IIO_EVENT_ATTR_RING_50_FULL_SH - shared ring event to indicate 50% full
 318 * @_evlist: event handler list
 319 * @_show: output method for the attribute
 320 * @_store: input method for the attribute
 321 * @_mask: mask used when detecting the event
 322 **/
 323#define IIO_EVENT_ATTR_RING_50_FULL_SH(_evlist, _show, _store, _mask)   \
 324        IIO_EVENT_ATTR_SH(ring_50_full, _evlist, _show, _store, _mask)
 325
 326/**
 327 * IIO_EVENT_ATTR_RING_75_FULL_SH - shared ring event to indicate 75% full
 328 * @_evlist: event handler list
 329 * @_show: output method for the attribute
 330 * @_store: input method for the attribute
 331 * @_mask: mask used when detecting the event
 332 **/
 333#define IIO_EVENT_ATTR_RING_75_FULL_SH(_evlist, _show, _store, _mask)   \
 334        IIO_EVENT_ATTR_SH(ring_75_full, _evlist, _show, _store, _mask)
 335
 336#define IIO_EVENT_CODE_RING_50_FULL     IIO_BUFFER_EVENT_CODE(0)
 337#define IIO_EVENT_CODE_RING_75_FULL     IIO_BUFFER_EVENT_CODE(1)
 338#define IIO_EVENT_CODE_RING_100_FULL    IIO_BUFFER_EVENT_CODE(2)
 339
 340#endif /* _INDUSTRIAL_IO_SYSFS_H_ */
 341