mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
staging:iio: allow channels to be set up using a table of iio_channel_spec structures.
V8: Add missing address in IIO_CHAN macro. Spotted by Michael Hennerich. V7: Document additions to iio_dev structure. V6: Fixup the docs for iio_chan_spec structure. V5: Actually have the macro handle the _input type channels (oops) V4: Add ability to do, _input and modified channel naming in a coherent fashion. Scrap all the messy IIO_CHAN_* macros and move to only one. V3: Added more types - intensity and light. V2: Various fixes - some thanks to Arnd. Bug fix for unregistering of event attr group Changed iio_read_channel_info to have two part value - use for raw value read as well. constify the channelspec structures raw write support for calibbias and similar Additional strings for buidling attribute names. Signed-off-by: Jonathan Cameron <jic23@cam.ac.uk> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
parent
32890b9830
commit
1d892719e7
6 changed files with 1161 additions and 54 deletions
|
@ -91,6 +91,9 @@ struct iio_event_interface {
|
|||
void *private;
|
||||
char _name[35];
|
||||
char _attrname[20];
|
||||
|
||||
struct list_head event_attr_list;
|
||||
struct list_head dev_attr_list;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
@ -26,6 +26,161 @@
|
|||
|
||||
struct iio_dev;
|
||||
|
||||
/* naughty temporary hack to match these against the event version
|
||||
- need to flattern these together */
|
||||
enum iio_chan_type {
|
||||
/* Need this here for now to support buffer events
|
||||
* set to 0 to avoid changes to ring_generic.c */
|
||||
IIO_BUFFER = 0,
|
||||
|
||||
/* real channel types */
|
||||
IIO_IN,
|
||||
IIO_ACCEL,
|
||||
IIO_IN_DIFF,
|
||||
IIO_GYRO,
|
||||
IIO_MAGN,
|
||||
IIO_LIGHT,
|
||||
IIO_INTENSITY,
|
||||
IIO_PROXIMITY,
|
||||
IIO_TEMP,
|
||||
IIO_INCLI,
|
||||
IIO_ROT,
|
||||
IIO_ANGL,
|
||||
IIO_TIMESTAMP,
|
||||
};
|
||||
|
||||
#define IIO_MOD_X 0
|
||||
#define IIO_MOD_LIGHT_BOTH 0
|
||||
#define IIO_MOD_Y 1
|
||||
#define IIO_MOD_LIGHT_IR 1
|
||||
#define IIO_MOD_Z 2
|
||||
#define IIO_MOD_X_AND_Y 3
|
||||
#define IIO_MOD_X_ANX_Z 4
|
||||
#define IIO_MOD_Y_AND_Z 5
|
||||
#define IIO_MOD_X_AND_Y_AND_Z 6
|
||||
#define IIO_MOD_X_OR_Y 7
|
||||
#define IIO_MOD_X_OR_Z 8
|
||||
#define IIO_MOD_Y_OR_Z 9
|
||||
#define IIO_MOD_X_OR_Y_OR_Z 10
|
||||
|
||||
/* Could add the raw attributes as well - allowing buffer only devices */
|
||||
enum iio_chan_info_enum {
|
||||
IIO_CHAN_INFO_SCALE_SHARED,
|
||||
IIO_CHAN_INFO_SCALE_SEPARATE,
|
||||
IIO_CHAN_INFO_OFFSET_SHARED,
|
||||
IIO_CHAN_INFO_OFFSET_SEPARATE,
|
||||
IIO_CHAN_INFO_CALIBSCALE_SHARED,
|
||||
IIO_CHAN_INFO_CALIBSCALE_SEPARATE,
|
||||
IIO_CHAN_INFO_CALIBBIAS_SHARED,
|
||||
IIO_CHAN_INFO_CALIBBIAS_SEPARATE
|
||||
};
|
||||
|
||||
/**
|
||||
* struct iio_chan_spec - specification of a single channel
|
||||
* @type: What type of measurement is the channel making.
|
||||
* @channel: What number or name do we wish to asign the channel.
|
||||
* @channel2: If there is a second number for a differential
|
||||
* channel then this is it. If modified is set then the
|
||||
* value here specifies the modifier.
|
||||
* @address: Driver specific identifier.
|
||||
* @scan_index: Monotonic index to give ordering in scans when read
|
||||
* from a buffer.
|
||||
* @scan_type: Sign: 's' or 'u' to specify signed or unsigned
|
||||
* realbits: Number of valid bits of data
|
||||
* storage_bits: Realbits + padding
|
||||
* shift: Shift right by this before masking out
|
||||
* realbits.
|
||||
* @info_mask: What information is to be exported about this channel.
|
||||
* This includes calibbias, scale etc.
|
||||
* @event_mask: What events can this channel produce.
|
||||
* @extend_name: Allows labeling of channel attributes with an
|
||||
* informative name. Note this has no effect codes etc,
|
||||
* unlike modifiers.
|
||||
* @processed_val: Flag to specify the data access attribute should be
|
||||
* *_input rather than *_raw.
|
||||
* @modified: Does a modifier apply to this channel. What these are
|
||||
* depends on the channel type. Modifier is set in
|
||||
* channel2. Examples are IIO_MOD_X for axial sensors about
|
||||
* the 'x' axis.
|
||||
* @indexed: Specify the channel has a numerical index. If not,
|
||||
* the value in channel will be suppressed for attribute
|
||||
* but not for event codes. Typically set it to 0 when
|
||||
* the index is false.
|
||||
* @shared_handler: Single handler for the events registered.
|
||||
*/
|
||||
struct iio_chan_spec {
|
||||
enum iio_chan_type type;
|
||||
int channel;
|
||||
int channel2;
|
||||
unsigned long address;
|
||||
int scan_index;
|
||||
struct {
|
||||
char sign;
|
||||
u8 realbits;
|
||||
u8 storagebits;
|
||||
u8 shift;
|
||||
} scan_type;
|
||||
const long info_mask;
|
||||
const long event_mask;
|
||||
const char *extend_name;
|
||||
unsigned processed_val:1;
|
||||
unsigned modified:1;
|
||||
unsigned indexed:1;
|
||||
/* TODO: investigate pushing shared event handling out to
|
||||
* the drivers */
|
||||
struct iio_event_handler_list *shared_handler;
|
||||
};
|
||||
/* Meant for internal use only */
|
||||
void __iio_device_attr_deinit(struct device_attribute *dev_attr);
|
||||
int __iio_device_attr_init(struct device_attribute *dev_attr,
|
||||
const char *postfix,
|
||||
struct iio_chan_spec const *chan,
|
||||
ssize_t (*readfunc)(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
char *buf),
|
||||
ssize_t (*writefunc)(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
const char *buf,
|
||||
size_t len),
|
||||
bool generic);
|
||||
#define IIO_ST(si, rb, sb, sh) \
|
||||
{ .sign = si, .realbits = rb, .storagebits = sb, .shift = sh }
|
||||
|
||||
#define IIO_CHAN(_type, _mod, _indexed, _proc, _name, _chan, _chan2, \
|
||||
_inf_mask, _address, _si, _stype, _event_mask, \
|
||||
_handler) \
|
||||
{ .type = _type, \
|
||||
.modified = _mod, \
|
||||
.indexed = _indexed, \
|
||||
.processed_val = _proc, \
|
||||
.extend_name = _name, \
|
||||
.channel = _chan, \
|
||||
.channel2 = _chan2, \
|
||||
.info_mask = _inf_mask, \
|
||||
.address = _address, \
|
||||
.scan_index = _si, \
|
||||
.scan_type = _stype, \
|
||||
.event_mask = _event_mask, \
|
||||
.shared_handler = _handler }
|
||||
|
||||
#define IIO_CHAN_SOFT_TIMESTAMP(_si) \
|
||||
{ .type = IIO_TIMESTAMP, .channel = -1, \
|
||||
.scan_index = _si, .scan_type = IIO_ST('s', 64, 64, 0) }
|
||||
|
||||
int __iio_add_chan_devattr(const char *postfix,
|
||||
const char *group,
|
||||
struct iio_chan_spec const *chan,
|
||||
ssize_t (*func)(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
char *buf),
|
||||
ssize_t (*writefunc)(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
const char *buf,
|
||||
size_t len),
|
||||
int mask,
|
||||
bool generic,
|
||||
struct device *dev,
|
||||
struct list_head *attr_list);
|
||||
/**
|
||||
* iio_get_time_ns() - utility function to get a time stamp for events etc
|
||||
**/
|
||||
|
@ -70,7 +225,8 @@ void iio_remove_event_from_list(struct iio_event_handler_list *el,
|
|||
|
||||
/* Vast majority of this is set by the industrialio subsystem on a
|
||||
* call to iio_device_register. */
|
||||
|
||||
#define IIO_VAL_INT 1
|
||||
#define IIO_VAL_INT_PLUS_MICRO 2
|
||||
/**
|
||||
* struct iio_dev - industrial I/O device
|
||||
* @id: [INTERN] used to identify device internally
|
||||
|
@ -93,6 +249,24 @@ void iio_remove_event_from_list(struct iio_event_handler_list *el,
|
|||
* @available_scan_masks: [DRIVER] optional array of allowed bitmasks
|
||||
* @trig: [INTERN] current device trigger (ring buffer modes)
|
||||
* @pollfunc: [DRIVER] function run on trigger being received
|
||||
* @channels: [DRIVER] channel specification structure table
|
||||
* @num_channels: [DRIVER] number of chanels specified in @channels.
|
||||
* @channel_attr_list: [INTERN] keep track of automatically created channel
|
||||
* attributes.
|
||||
* @name: [DRIVER] name of the device.
|
||||
* @read_raw: [DRIVER] function to request a value from the device.
|
||||
* mask specifies which value. Note 0 means a reading of
|
||||
* the channel in question. Return value will specify the
|
||||
* type of value returned by the device. val and val2 will
|
||||
* contain the elements making up the returned value.
|
||||
* @write_raw: [DRIVER] function to write a value to the device.
|
||||
* Parameters are the same as for read_raw.
|
||||
* @read_event_config: [DRIVER] find out if the event is enabled.
|
||||
* @write_event_config: [DRIVER] set if the event is enabled.
|
||||
* @read_event_value: [DRIVER] read a value associated with the event. Meaning
|
||||
* is event dependant. event_code specifies which event.
|
||||
* @write_event_value: [DRIVER] write the value associate with the event.
|
||||
* Meaning is event dependent.
|
||||
**/
|
||||
struct iio_dev {
|
||||
int id;
|
||||
|
@ -116,6 +290,38 @@ struct iio_dev {
|
|||
u32 *available_scan_masks;
|
||||
struct iio_trigger *trig;
|
||||
struct iio_poll_func *pollfunc;
|
||||
|
||||
struct iio_chan_spec const *channels;
|
||||
int num_channels;
|
||||
struct list_head channel_attr_list;
|
||||
|
||||
char *name; /*device name - IMPLEMENT */
|
||||
int (*read_raw)(struct iio_dev *indio_dev,
|
||||
struct iio_chan_spec const *chan,
|
||||
int *val,
|
||||
int *val2,
|
||||
long mask);
|
||||
|
||||
int (*write_raw)(struct iio_dev *indio_dev,
|
||||
struct iio_chan_spec const *chan,
|
||||
int val,
|
||||
int val2,
|
||||
long mask);
|
||||
|
||||
int (*read_event_config)(struct iio_dev *indio_dev,
|
||||
int event_code);
|
||||
|
||||
int (*write_event_config)(struct iio_dev *indio_dev,
|
||||
int event_code,
|
||||
struct iio_event_handler_list *listel,
|
||||
int state);
|
||||
|
||||
int (*read_event_value)(struct iio_dev *indio_dev,
|
||||
int event_code,
|
||||
int *val);
|
||||
int (*write_event_value)(struct iio_dev *indio_dev,
|
||||
int event_code,
|
||||
int val);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
@ -44,6 +44,44 @@ struct bus_type iio_bus_type = {
|
|||
};
|
||||
EXPORT_SYMBOL(iio_bus_type);
|
||||
|
||||
static const char * const iio_chan_type_name_spec_shared[] = {
|
||||
[IIO_TIMESTAMP] = "timestamp",
|
||||
[IIO_ACCEL] = "accel",
|
||||
[IIO_IN] = "in",
|
||||
[IIO_IN_DIFF] = "in-in",
|
||||
[IIO_GYRO] = "gyro",
|
||||
[IIO_TEMP] = "temp",
|
||||
[IIO_MAGN] = "magn",
|
||||
[IIO_INCLI] = "incli",
|
||||
[IIO_ROT] = "rot",
|
||||
[IIO_INTENSITY] = "intensity",
|
||||
[IIO_LIGHT] = "illuminance",
|
||||
[IIO_ANGL] = "angl",
|
||||
};
|
||||
|
||||
static const char * const iio_chan_type_name_spec_complex[] = {
|
||||
[IIO_IN_DIFF] = "in%d-in%d",
|
||||
};
|
||||
|
||||
static const char * const iio_modifier_names_light[] = {
|
||||
[IIO_MOD_LIGHT_BOTH] = "both",
|
||||
[IIO_MOD_LIGHT_IR] = "ir",
|
||||
};
|
||||
|
||||
static const char * const iio_modifier_names_axial[] = {
|
||||
[IIO_MOD_X] = "x",
|
||||
[IIO_MOD_Y] = "y",
|
||||
[IIO_MOD_Z] = "z",
|
||||
};
|
||||
|
||||
/* relies on pairs of these shared then separate */
|
||||
static const char * const iio_chan_info_postfix[] = {
|
||||
[IIO_CHAN_INFO_SCALE_SHARED/2] = "scale",
|
||||
[IIO_CHAN_INFO_OFFSET_SHARED/2] = "offset",
|
||||
[IIO_CHAN_INFO_CALIBSCALE_SHARED/2] = "calibscale",
|
||||
[IIO_CHAN_INFO_CALIBBIAS_SHARED/2] = "calibbias",
|
||||
};
|
||||
|
||||
void __iio_change_event(struct iio_detected_event_list *ev,
|
||||
int ev_code,
|
||||
s64 timestamp)
|
||||
|
@ -488,24 +526,375 @@ static void __exit iio_exit(void)
|
|||
bus_unregister(&iio_bus_type);
|
||||
}
|
||||
|
||||
static int iio_device_register_sysfs(struct iio_dev *dev_info)
|
||||
static ssize_t iio_read_channel_info(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
int ret = 0;
|
||||
struct iio_dev *indio_dev = dev_get_drvdata(dev);
|
||||
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
|
||||
int val, val2;
|
||||
int ret = indio_dev->read_raw(indio_dev, this_attr->c,
|
||||
&val, &val2, this_attr->address);
|
||||
|
||||
ret = sysfs_create_group(&dev_info->dev.kobj, dev_info->attrs);
|
||||
if (ret) {
|
||||
dev_err(dev_info->dev.parent,
|
||||
"Failed to register sysfs hooks\n");
|
||||
goto error_ret;
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (ret == IIO_VAL_INT)
|
||||
return sprintf(buf, "%d\n", val);
|
||||
else if (ret == IIO_VAL_INT_PLUS_MICRO) {
|
||||
if (val2 < 0)
|
||||
return sprintf(buf, "-%d.%06u\n", val, -val2);
|
||||
else
|
||||
return sprintf(buf, "%d.%06u\n", val, val2);
|
||||
} else
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ssize_t iio_write_channel_info(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
const char *buf,
|
||||
size_t len)
|
||||
{
|
||||
struct iio_dev *indio_dev = dev_get_drvdata(dev);
|
||||
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
|
||||
int ret, integer = 0, micro = 0, micro_mult = 100000;
|
||||
bool integer_part = true, negative = false;
|
||||
|
||||
/* Assumes decimal - precision based on number of digits */
|
||||
if (!indio_dev->write_raw)
|
||||
return -EINVAL;
|
||||
if (buf[0] == '-') {
|
||||
negative = true;
|
||||
buf++;
|
||||
}
|
||||
while (*buf) {
|
||||
if ('0' <= *buf && *buf <= '9') {
|
||||
if (integer_part)
|
||||
integer = integer*10 + *buf - '0';
|
||||
else {
|
||||
micro += micro_mult*(*buf - '0');
|
||||
if (micro_mult == 1)
|
||||
break;
|
||||
micro_mult /= 10;
|
||||
}
|
||||
} else if (*buf == '\n') {
|
||||
if (*(buf + 1) == '\0')
|
||||
break;
|
||||
else
|
||||
return -EINVAL;
|
||||
} else if (*buf == '.') {
|
||||
integer_part = false;
|
||||
} else {
|
||||
return -EINVAL;
|
||||
}
|
||||
buf++;
|
||||
}
|
||||
if (negative) {
|
||||
if (integer)
|
||||
integer = -integer;
|
||||
else
|
||||
micro = -micro;
|
||||
}
|
||||
|
||||
ret = indio_dev->write_raw(indio_dev, this_attr->c,
|
||||
integer, micro, this_attr->address);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
static int __iio_build_postfix(struct iio_chan_spec const *chan,
|
||||
bool generic,
|
||||
const char *postfix,
|
||||
char **result)
|
||||
{
|
||||
char *all_post;
|
||||
/* 3 options - generic, extend_name, modified - if generic, extend_name
|
||||
* and modified cannot apply.*/
|
||||
|
||||
if (generic || (!chan->modified && !chan->extend_name)) {
|
||||
all_post = kasprintf(GFP_KERNEL, "%s", postfix);
|
||||
} else if (chan->modified) {
|
||||
const char *intermediate;
|
||||
switch (chan->type) {
|
||||
case IIO_INTENSITY:
|
||||
intermediate
|
||||
= iio_modifier_names_light[chan->channel2];
|
||||
break;
|
||||
case IIO_ACCEL:
|
||||
case IIO_GYRO:
|
||||
case IIO_MAGN:
|
||||
case IIO_INCLI:
|
||||
case IIO_ROT:
|
||||
case IIO_ANGL:
|
||||
intermediate
|
||||
= iio_modifier_names_axial[chan->channel2];
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
if (chan->extend_name)
|
||||
all_post = kasprintf(GFP_KERNEL, "%s_%s_%s",
|
||||
intermediate,
|
||||
chan->extend_name,
|
||||
postfix);
|
||||
else
|
||||
all_post = kasprintf(GFP_KERNEL, "%s_%s",
|
||||
intermediate,
|
||||
postfix);
|
||||
} else
|
||||
all_post = kasprintf(GFP_KERNEL, "%s_%s", chan->extend_name,
|
||||
postfix);
|
||||
if (all_post == NULL)
|
||||
return -ENOMEM;
|
||||
*result = all_post;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __iio_device_attr_init(struct device_attribute *dev_attr,
|
||||
const char *postfix,
|
||||
struct iio_chan_spec const *chan,
|
||||
ssize_t (*readfunc)(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
char *buf),
|
||||
ssize_t (*writefunc)(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
const char *buf,
|
||||
size_t len),
|
||||
bool generic)
|
||||
{
|
||||
int ret;
|
||||
char *name_format, *full_postfix;
|
||||
sysfs_attr_init(&dev_attr->attr);
|
||||
ret = __iio_build_postfix(chan, generic, postfix, &full_postfix);
|
||||
if (ret)
|
||||
goto error_ret;
|
||||
|
||||
/* Special case for types that uses both channel numbers in naming */
|
||||
if (chan->type == IIO_IN_DIFF && !generic)
|
||||
name_format
|
||||
= kasprintf(GFP_KERNEL, "%s_%s",
|
||||
iio_chan_type_name_spec_complex[chan->type],
|
||||
full_postfix);
|
||||
else if (generic || !chan->indexed)
|
||||
name_format
|
||||
= kasprintf(GFP_KERNEL, "%s_%s",
|
||||
iio_chan_type_name_spec_shared[chan->type],
|
||||
full_postfix);
|
||||
else
|
||||
name_format
|
||||
= kasprintf(GFP_KERNEL, "%s%d_%s",
|
||||
iio_chan_type_name_spec_shared[chan->type],
|
||||
chan->channel,
|
||||
full_postfix);
|
||||
|
||||
if (name_format == NULL) {
|
||||
ret = -ENOMEM;
|
||||
goto error_free_full_postfix;
|
||||
}
|
||||
dev_attr->attr.name = kasprintf(GFP_KERNEL,
|
||||
name_format,
|
||||
chan->channel,
|
||||
chan->channel2);
|
||||
if (dev_attr->attr.name == NULL) {
|
||||
ret = -ENOMEM;
|
||||
goto error_free_name_format;
|
||||
}
|
||||
|
||||
if (readfunc) {
|
||||
dev_attr->attr.mode |= S_IRUGO;
|
||||
dev_attr->show = readfunc;
|
||||
}
|
||||
|
||||
if (writefunc) {
|
||||
dev_attr->attr.mode |= S_IWUSR;
|
||||
dev_attr->store = writefunc;
|
||||
}
|
||||
kfree(name_format);
|
||||
kfree(full_postfix);
|
||||
|
||||
return 0;
|
||||
|
||||
error_free_name_format:
|
||||
kfree(name_format);
|
||||
error_free_full_postfix:
|
||||
kfree(full_postfix);
|
||||
error_ret:
|
||||
return ret;
|
||||
}
|
||||
|
||||
void __iio_device_attr_deinit(struct device_attribute *dev_attr)
|
||||
{
|
||||
kfree(dev_attr->attr.name);
|
||||
}
|
||||
|
||||
int __iio_add_chan_devattr(const char *postfix,
|
||||
const char *group,
|
||||
struct iio_chan_spec const *chan,
|
||||
ssize_t (*readfunc)(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
char *buf),
|
||||
ssize_t (*writefunc)(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
const char *buf,
|
||||
size_t len),
|
||||
int mask,
|
||||
bool generic,
|
||||
struct device *dev,
|
||||
struct list_head *attr_list)
|
||||
{
|
||||
int ret;
|
||||
struct iio_dev_attr *iio_attr, *t;
|
||||
|
||||
iio_attr = kzalloc(sizeof *iio_attr, GFP_KERNEL);
|
||||
if (iio_attr == NULL) {
|
||||
ret = -ENOMEM;
|
||||
goto error_ret;
|
||||
}
|
||||
ret = __iio_device_attr_init(&iio_attr->dev_attr,
|
||||
postfix, chan,
|
||||
readfunc, writefunc, generic);
|
||||
if (ret)
|
||||
goto error_iio_dev_attr_free;
|
||||
iio_attr->c = chan;
|
||||
iio_attr->address = mask;
|
||||
list_for_each_entry(t, attr_list, l)
|
||||
if (strcmp(t->dev_attr.attr.name,
|
||||
iio_attr->dev_attr.attr.name) == 0) {
|
||||
if (!generic)
|
||||
dev_err(dev, "tried to double register : %s\n",
|
||||
t->dev_attr.attr.name);
|
||||
ret = -EBUSY;
|
||||
goto error_device_attr_deinit;
|
||||
}
|
||||
|
||||
ret = sysfs_add_file_to_group(&dev->kobj,
|
||||
&iio_attr->dev_attr.attr, group);
|
||||
if (ret < 0)
|
||||
goto error_device_attr_deinit;
|
||||
|
||||
list_add(&iio_attr->l, attr_list);
|
||||
|
||||
return 0;
|
||||
|
||||
error_device_attr_deinit:
|
||||
__iio_device_attr_deinit(&iio_attr->dev_attr);
|
||||
error_iio_dev_attr_free:
|
||||
kfree(iio_attr);
|
||||
error_ret:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int iio_device_add_channel_sysfs(struct iio_dev *dev_info,
|
||||
struct iio_chan_spec const *chan)
|
||||
{
|
||||
int ret, i;
|
||||
|
||||
|
||||
if (chan->channel < 0)
|
||||
return 0;
|
||||
if (chan->processed_val)
|
||||
ret = __iio_add_chan_devattr("input", NULL, chan,
|
||||
&iio_read_channel_info,
|
||||
NULL,
|
||||
0,
|
||||
0,
|
||||
&dev_info->dev,
|
||||
&dev_info->channel_attr_list);
|
||||
else
|
||||
ret = __iio_add_chan_devattr("raw", NULL, chan,
|
||||
&iio_read_channel_info,
|
||||
NULL,
|
||||
0,
|
||||
0,
|
||||
&dev_info->dev,
|
||||
&dev_info->channel_attr_list);
|
||||
if (ret)
|
||||
goto error_ret;
|
||||
|
||||
for_each_set_bit(i, &chan->info_mask, sizeof(long)*8) {
|
||||
ret = __iio_add_chan_devattr(iio_chan_info_postfix[i/2],
|
||||
NULL, chan,
|
||||
&iio_read_channel_info,
|
||||
&iio_write_channel_info,
|
||||
(1 << i),
|
||||
!(i%2),
|
||||
&dev_info->dev,
|
||||
&dev_info->channel_attr_list);
|
||||
if (ret == -EBUSY && (i%2 == 0)) {
|
||||
ret = 0;
|
||||
continue;
|
||||
}
|
||||
if (ret < 0)
|
||||
goto error_ret;
|
||||
}
|
||||
error_ret:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void iio_device_remove_and_free_read_attr(struct iio_dev *dev_info,
|
||||
struct iio_dev_attr *p)
|
||||
{
|
||||
sysfs_remove_file_from_group(&dev_info->dev.kobj,
|
||||
&p->dev_attr.attr, NULL);
|
||||
kfree(p->dev_attr.attr.name);
|
||||
kfree(p);
|
||||
}
|
||||
|
||||
static int iio_device_register_sysfs(struct iio_dev *dev_info)
|
||||
{
|
||||
int i, ret = 0;
|
||||
struct iio_dev_attr *p, *n;
|
||||
|
||||
if (dev_info->attrs) {
|
||||
ret = sysfs_create_group(&dev_info->dev.kobj, dev_info->attrs);
|
||||
if (ret) {
|
||||
dev_err(dev_info->dev.parent,
|
||||
"Failed to register sysfs hooks\n");
|
||||
goto error_ret;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* New channel registration method - relies on the fact a group does
|
||||
* not need to be initialized if it is name is NULL.
|
||||
*/
|
||||
INIT_LIST_HEAD(&dev_info->channel_attr_list);
|
||||
if (dev_info->channels)
|
||||
for (i = 0; i < dev_info->num_channels; i++) {
|
||||
ret = iio_device_add_channel_sysfs(dev_info,
|
||||
&dev_info
|
||||
->channels[i]);
|
||||
if (ret < 0)
|
||||
goto error_clear_attrs;
|
||||
}
|
||||
|
||||
return 0;
|
||||
error_clear_attrs:
|
||||
list_for_each_entry_safe(p, n,
|
||||
&dev_info->channel_attr_list, l) {
|
||||
list_del(&p->l);
|
||||
iio_device_remove_and_free_read_attr(dev_info, p);
|
||||
}
|
||||
if (dev_info->attrs)
|
||||
sysfs_remove_group(&dev_info->dev.kobj, dev_info->attrs);
|
||||
error_ret:
|
||||
return ret;
|
||||
|
||||
}
|
||||
|
||||
static void iio_device_unregister_sysfs(struct iio_dev *dev_info)
|
||||
{
|
||||
sysfs_remove_group(&dev_info->dev.kobj, dev_info->attrs);
|
||||
|
||||
struct iio_dev_attr *p, *n;
|
||||
list_for_each_entry_safe(p, n, &dev_info->channel_attr_list, l) {
|
||||
list_del(&p->l);
|
||||
iio_device_remove_and_free_read_attr(dev_info, p);
|
||||
}
|
||||
|
||||
if (dev_info->attrs)
|
||||
sysfs_remove_group(&dev_info->dev.kobj, dev_info->attrs);
|
||||
}
|
||||
|
||||
/* Return a negative errno on failure */
|
||||
|
@ -552,8 +941,277 @@ static void iio_device_unregister_id(struct iio_dev *dev_info)
|
|||
iio_free_ida_val(&iio_ida, dev_info->id);
|
||||
}
|
||||
|
||||
static const char * const iio_ev_type_text[] = {
|
||||
[IIO_EV_TYPE_THRESH] = "thresh",
|
||||
[IIO_EV_TYPE_MAG] = "mag",
|
||||
[IIO_EV_TYPE_ROC] = "roc"
|
||||
};
|
||||
|
||||
static const char * const iio_ev_dir_text[] = {
|
||||
[IIO_EV_DIR_EITHER] = "either",
|
||||
[IIO_EV_DIR_RISING] = "rising",
|
||||
[IIO_EV_DIR_FALLING] = "falling"
|
||||
};
|
||||
|
||||
static ssize_t iio_ev_state_store(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
const char *buf,
|
||||
size_t len)
|
||||
{
|
||||
struct iio_dev *indio_dev = dev_get_drvdata(dev);
|
||||
struct iio_event_attr *this_attr = to_iio_event_attr(attr);
|
||||
int ret;
|
||||
unsigned long val;
|
||||
ret = strict_strtoul(buf, 10, &val);
|
||||
if (ret || val < 0 || val > 1)
|
||||
return -EINVAL;
|
||||
|
||||
ret = indio_dev->write_event_config(indio_dev, this_attr->mask,
|
||||
this_attr->listel,
|
||||
val);
|
||||
return (ret < 0) ? ret : len;
|
||||
}
|
||||
|
||||
static ssize_t iio_ev_state_show(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
struct iio_dev *indio_dev = dev_get_drvdata(dev);
|
||||
struct iio_event_attr *this_attr = to_iio_event_attr(attr);
|
||||
int val = indio_dev->read_event_config(indio_dev, this_attr->mask);
|
||||
|
||||
if (val < 0)
|
||||
return val;
|
||||
else
|
||||
return sprintf(buf, "%d\n", val);
|
||||
}
|
||||
|
||||
static ssize_t iio_ev_value_show(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
struct iio_dev *indio_dev = dev_get_drvdata(dev);
|
||||
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
|
||||
int val, ret;
|
||||
|
||||
ret = indio_dev->read_event_value(indio_dev,
|
||||
this_attr->address, &val);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return sprintf(buf, "%d\n", val);
|
||||
}
|
||||
|
||||
static ssize_t iio_ev_value_store(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
const char *buf,
|
||||
size_t len)
|
||||
{
|
||||
struct iio_dev *indio_dev = dev_get_drvdata(dev);
|
||||
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
|
||||
unsigned long val;
|
||||
int ret;
|
||||
|
||||
ret = strict_strtoul(buf, 10, &val);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = indio_dev->write_event_value(indio_dev, this_attr->address,
|
||||
val);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
static int __iio_add_chan_event_attr(const char *postfix,
|
||||
const char *group,
|
||||
struct iio_chan_spec const *chan,
|
||||
unsigned int mask,
|
||||
struct device *dev,
|
||||
struct list_head *attr_list)
|
||||
{
|
||||
char *name_format, *full_postfix;
|
||||
int ret;
|
||||
struct iio_event_attr *iio_ev_attr;
|
||||
|
||||
iio_ev_attr = kzalloc(sizeof *iio_ev_attr, GFP_KERNEL);
|
||||
if (iio_ev_attr == NULL) {
|
||||
ret = -ENOMEM;
|
||||
goto error_ret;
|
||||
}
|
||||
|
||||
sysfs_attr_init(&iio_ev_attr->dev_attr.attr);
|
||||
ret = __iio_build_postfix(chan, 0, postfix, &full_postfix);
|
||||
if (ret)
|
||||
goto error_ret;
|
||||
/* Special case for types that uses both channel numbers in naming */
|
||||
if (chan->type == IIO_IN_DIFF)
|
||||
name_format
|
||||
= kasprintf(GFP_KERNEL, "%s_%s",
|
||||
iio_chan_type_name_spec_complex[chan->type],
|
||||
full_postfix);
|
||||
else if (!chan->indexed)
|
||||
name_format
|
||||
= kasprintf(GFP_KERNEL, "%s_%s",
|
||||
iio_chan_type_name_spec_shared[chan->type],
|
||||
full_postfix);
|
||||
else
|
||||
name_format
|
||||
= kasprintf(GFP_KERNEL, "%s%d_%s",
|
||||
iio_chan_type_name_spec_shared[chan->type],
|
||||
chan->channel,
|
||||
full_postfix);
|
||||
if (name_format == NULL) {
|
||||
ret = -ENOMEM;
|
||||
goto error_free_attr;
|
||||
}
|
||||
|
||||
iio_ev_attr->dev_attr.attr.name = kasprintf(GFP_KERNEL,
|
||||
name_format,
|
||||
chan->channel,
|
||||
chan->channel2);
|
||||
if (iio_ev_attr->dev_attr.attr.name == NULL) {
|
||||
ret = -ENOMEM;
|
||||
goto error_free_name_format;
|
||||
}
|
||||
|
||||
iio_ev_attr->dev_attr.attr.mode = S_IRUGO | S_IWUSR;
|
||||
iio_ev_attr->dev_attr.show = &iio_ev_state_show;
|
||||
iio_ev_attr->dev_attr.store = &iio_ev_state_store;
|
||||
iio_ev_attr->mask = mask;
|
||||
iio_ev_attr->listel = chan->shared_handler;
|
||||
ret = sysfs_add_file_to_group(&dev->kobj,
|
||||
&iio_ev_attr->dev_attr.attr,
|
||||
group);
|
||||
if (ret < 0)
|
||||
goto error_free_name;
|
||||
list_add(&iio_ev_attr->l, attr_list);
|
||||
kfree(name_format);
|
||||
return 0;
|
||||
|
||||
error_free_name:
|
||||
kfree(iio_ev_attr->dev_attr.attr.name);
|
||||
error_free_name_format:
|
||||
kfree(name_format);
|
||||
error_free_attr:
|
||||
kfree(iio_ev_attr);
|
||||
error_ret:
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
static int iio_device_add_event_sysfs(struct iio_dev *dev_info,
|
||||
struct iio_chan_spec const *chan)
|
||||
{
|
||||
|
||||
int ret = 0, i, mask;
|
||||
char *postfix;
|
||||
if (!chan->event_mask)
|
||||
return 0;
|
||||
|
||||
for_each_set_bit(i, &chan->event_mask, sizeof(chan->event_mask)*8) {
|
||||
postfix = kasprintf(GFP_KERNEL, "%s_%s_en",
|
||||
iio_ev_type_text[i/IIO_EV_TYPE_MAX],
|
||||
iio_ev_dir_text[i%IIO_EV_TYPE_MAX]);
|
||||
if (postfix == NULL) {
|
||||
ret = -ENOMEM;
|
||||
goto error_ret;
|
||||
}
|
||||
switch (chan->type) {
|
||||
/* Switch this to a table at some point */
|
||||
case IIO_IN:
|
||||
mask = IIO_UNMOD_EVENT_CODE(chan->type, chan->channel,
|
||||
i/IIO_EV_TYPE_MAX,
|
||||
i%IIO_EV_TYPE_MAX);
|
||||
break;
|
||||
case IIO_ACCEL:
|
||||
mask = IIO_MOD_EVENT_CODE(chan->type, 0, chan->channel,
|
||||
i/IIO_EV_TYPE_MAX,
|
||||
i%IIO_EV_TYPE_MAX);
|
||||
break;
|
||||
case IIO_IN_DIFF:
|
||||
mask = IIO_MOD_EVENT_CODE(chan->type, chan->channel,
|
||||
chan->channel2,
|
||||
i/IIO_EV_TYPE_MAX,
|
||||
i%IIO_EV_TYPE_MAX);
|
||||
break;
|
||||
default:
|
||||
printk(KERN_INFO "currently unhandled type of event\n");
|
||||
}
|
||||
ret = __iio_add_chan_event_attr(postfix,
|
||||
NULL,
|
||||
chan,
|
||||
mask,
|
||||
/*HACK. - limits us to one
|
||||
event interface - fix by
|
||||
extending the bitmask - but
|
||||
how far*/
|
||||
&dev_info->event_interfaces[0]
|
||||
.dev,
|
||||
&dev_info->event_interfaces[0].
|
||||
event_attr_list);
|
||||
kfree(postfix);
|
||||
if (ret)
|
||||
goto error_ret;
|
||||
|
||||
postfix = kasprintf(GFP_KERNEL, "%s_%s_value",
|
||||
iio_ev_type_text[i/IIO_EV_TYPE_MAX],
|
||||
iio_ev_dir_text[i%IIO_EV_TYPE_MAX]);
|
||||
if (postfix == NULL) {
|
||||
ret = -ENOMEM;
|
||||
goto error_ret;
|
||||
}
|
||||
ret = __iio_add_chan_devattr(postfix, NULL, chan,
|
||||
iio_ev_value_show,
|
||||
iio_ev_value_store,
|
||||
mask,
|
||||
0,
|
||||
&dev_info->event_interfaces[0]
|
||||
.dev,
|
||||
&dev_info->event_interfaces[0]
|
||||
.dev_attr_list);
|
||||
kfree(postfix);
|
||||
if (ret)
|
||||
goto error_ret;
|
||||
|
||||
}
|
||||
|
||||
error_ret:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline void __iio_remove_all_event_sysfs(struct iio_dev *dev_info,
|
||||
const char *groupname,
|
||||
int num)
|
||||
{
|
||||
struct iio_dev_attr *p, *n;
|
||||
struct iio_event_attr *q, *m;
|
||||
list_for_each_entry_safe(p, n,
|
||||
&dev_info->event_interfaces[num].
|
||||
dev_attr_list, l) {
|
||||
sysfs_remove_file_from_group(&dev_info
|
||||
->event_interfaces[num].dev.kobj,
|
||||
&p->dev_attr.attr,
|
||||
groupname);
|
||||
kfree(p->dev_attr.attr.name);
|
||||
kfree(p);
|
||||
}
|
||||
list_for_each_entry_safe(q, m,
|
||||
&dev_info->event_interfaces[num].
|
||||
event_attr_list, l) {
|
||||
sysfs_remove_file_from_group(&dev_info
|
||||
->event_interfaces[num].dev.kobj,
|
||||
&q->dev_attr.attr,
|
||||
groupname);
|
||||
kfree(q->dev_attr.attr.name);
|
||||
kfree(q);
|
||||
}
|
||||
}
|
||||
|
||||
static inline int __iio_add_event_config_attrs(struct iio_dev *dev_info, int i)
|
||||
{
|
||||
int j;
|
||||
int ret;
|
||||
/*p for adding, q for removing */
|
||||
struct attribute **attrp, **attrq;
|
||||
|
@ -561,23 +1219,42 @@ static inline int __iio_add_event_config_attrs(struct iio_dev *dev_info, int i)
|
|||
if (dev_info->event_conf_attrs && dev_info->event_conf_attrs[i].attrs) {
|
||||
attrp = dev_info->event_conf_attrs[i].attrs;
|
||||
while (*attrp) {
|
||||
ret = sysfs_add_file_to_group(&dev_info->dev.kobj,
|
||||
ret = sysfs_add_file_to_group(&dev_info
|
||||
->event_interfaces[0]
|
||||
.dev.kobj,
|
||||
*attrp,
|
||||
dev_info
|
||||
->event_attrs[i].name);
|
||||
NULL);
|
||||
if (ret)
|
||||
goto error_ret;
|
||||
attrp++;
|
||||
}
|
||||
}
|
||||
INIT_LIST_HEAD(&dev_info->event_interfaces[0].event_attr_list);
|
||||
INIT_LIST_HEAD(&dev_info->event_interfaces[0].dev_attr_list);
|
||||
/* Dynically created from the channels array */
|
||||
if (dev_info->channels) {
|
||||
for (j = 0; j < dev_info->num_channels; j++) {
|
||||
ret = iio_device_add_event_sysfs(dev_info,
|
||||
&dev_info
|
||||
->channels[j]);
|
||||
if (ret)
|
||||
goto error_clear_attrs;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
||||
error_clear_attrs:
|
||||
__iio_remove_all_event_sysfs(dev_info,
|
||||
NULL,
|
||||
i);
|
||||
error_ret:
|
||||
attrq = dev_info->event_conf_attrs[i].attrs;
|
||||
while (attrq != attrp) {
|
||||
sysfs_remove_file_from_group(&dev_info->dev.kobj,
|
||||
*attrq,
|
||||
dev_info->event_attrs[i].name);
|
||||
sysfs_remove_file_from_group(&dev_info
|
||||
->event_interfaces[0]
|
||||
.dev.kobj,
|
||||
*attrq,
|
||||
NULL);
|
||||
attrq++;
|
||||
}
|
||||
|
||||
|
@ -588,15 +1265,18 @@ static inline int __iio_remove_event_config_attrs(struct iio_dev *dev_info,
|
|||
int i)
|
||||
{
|
||||
struct attribute **attrq;
|
||||
|
||||
__iio_remove_all_event_sysfs(dev_info,
|
||||
NULL,
|
||||
i);
|
||||
if (dev_info->event_conf_attrs
|
||||
&& dev_info->event_conf_attrs[i].attrs) {
|
||||
attrq = dev_info->event_conf_attrs[i].attrs;
|
||||
while (*attrq) {
|
||||
sysfs_remove_file_from_group(&dev_info->dev.kobj,
|
||||
sysfs_remove_file_from_group(&dev_info
|
||||
->event_interfaces[0]
|
||||
.dev.kobj,
|
||||
*attrq,
|
||||
dev_info
|
||||
->event_attrs[i].name);
|
||||
NULL);
|
||||
attrq++;
|
||||
}
|
||||
}
|
||||
|
@ -650,10 +1330,12 @@ static int iio_device_register_eventset(struct iio_dev *dev_info)
|
|||
|
||||
dev_set_drvdata(&dev_info->event_interfaces[i].dev,
|
||||
(void *)dev_info);
|
||||
ret = sysfs_create_group(&dev_info
|
||||
->event_interfaces[i]
|
||||
.dev.kobj,
|
||||
&dev_info->event_attrs[i]);
|
||||
|
||||
if (dev_info->event_attrs != NULL)
|
||||
ret = sysfs_create_group(&dev_info
|
||||
->event_interfaces[i]
|
||||
.dev.kobj,
|
||||
&dev_info->event_attrs[i]);
|
||||
|
||||
if (ret) {
|
||||
dev_err(&dev_info->dev,
|
||||
|
@ -676,7 +1358,8 @@ static int iio_device_register_eventset(struct iio_dev *dev_info)
|
|||
i = dev_info->num_interrupt_lines - 1;
|
||||
error_remove_sysfs_interfaces:
|
||||
for (j = 0; j < i; j++)
|
||||
sysfs_remove_group(&dev_info
|
||||
if (dev_info->event_attrs != NULL)
|
||||
sysfs_remove_group(&dev_info
|
||||
->event_interfaces[j].dev.kobj,
|
||||
&dev_info->event_attrs[j]);
|
||||
error_free_setup_ev_ints:
|
||||
|
@ -696,10 +1379,13 @@ static void iio_device_unregister_eventset(struct iio_dev *dev_info)
|
|||
|
||||
if (dev_info->num_interrupt_lines == 0)
|
||||
return;
|
||||
for (i = 0; i < dev_info->num_interrupt_lines; i++)
|
||||
sysfs_remove_group(&dev_info
|
||||
->event_interfaces[i].dev.kobj,
|
||||
&dev_info->event_attrs[i]);
|
||||
for (i = 0; i < dev_info->num_interrupt_lines; i++) {
|
||||
__iio_remove_event_config_attrs(dev_info, i);
|
||||
if (dev_info->event_attrs != NULL)
|
||||
sysfs_remove_group(&dev_info
|
||||
->event_interfaces[i].dev.kobj,
|
||||
&dev_info->event_attrs[i]);
|
||||
}
|
||||
|
||||
for (i = 0; i < dev_info->num_interrupt_lines; i++)
|
||||
iio_free_ev_int(&dev_info->event_interfaces[i]);
|
||||
|
|
|
@ -233,9 +233,162 @@ void iio_ring_buffer_init(struct iio_ring_buffer *ring,
|
|||
}
|
||||
EXPORT_SYMBOL(iio_ring_buffer_init);
|
||||
|
||||
int iio_ring_buffer_register(struct iio_ring_buffer *ring, int id)
|
||||
static ssize_t iio_show_scan_index(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
|
||||
return sprintf(buf, "%u\n", this_attr->c->scan_index);
|
||||
}
|
||||
|
||||
static ssize_t iio_show_fixed_type(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
|
||||
return sprintf(buf, "%c%d/%d>>%u\n",
|
||||
this_attr->c->scan_type.sign,
|
||||
this_attr->c->scan_type.realbits,
|
||||
this_attr->c->scan_type.storagebits,
|
||||
this_attr->c->scan_type.shift);
|
||||
}
|
||||
|
||||
static int __iio_add_chan_scan_elattr(const char *postfix,
|
||||
const char *group,
|
||||
const struct iio_chan_spec *chan,
|
||||
struct device *dev,
|
||||
struct list_head *attr_list)
|
||||
{
|
||||
int ret;
|
||||
struct iio_scan_el *scan_el;
|
||||
|
||||
scan_el = kzalloc(sizeof *scan_el, GFP_KERNEL);
|
||||
if (scan_el == NULL) {
|
||||
ret = -ENOMEM;
|
||||
goto error_ret;
|
||||
}
|
||||
if (chan->type != IIO_TIMESTAMP)
|
||||
ret = __iio_device_attr_init(&scan_el->dev_attr, postfix, chan,
|
||||
iio_scan_el_show,
|
||||
iio_scan_el_store, 0);
|
||||
else /*
|
||||
* Timestamp handled separately because it simplifies a lot of
|
||||
* drivers by ensuring they don't have to know its magic index
|
||||
*/
|
||||
ret = __iio_device_attr_init(&scan_el->dev_attr, postfix, chan,
|
||||
iio_scan_el_ts_show,
|
||||
iio_scan_el_ts_store, 0);
|
||||
if (ret)
|
||||
goto error_free_scan_el;
|
||||
|
||||
scan_el->number = chan->scan_index;
|
||||
|
||||
ret = sysfs_add_file_to_group(&dev->kobj,
|
||||
&scan_el->dev_attr.attr,
|
||||
group);
|
||||
if (ret < 0)
|
||||
goto error_device_attr_deinit;
|
||||
|
||||
list_add(&scan_el->l, attr_list);
|
||||
|
||||
return 0;
|
||||
error_device_attr_deinit:
|
||||
__iio_device_attr_deinit(&scan_el->dev_attr);
|
||||
error_free_scan_el:
|
||||
kfree(scan_el);
|
||||
error_ret:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int iio_ring_add_channel_sysfs(struct iio_ring_buffer *ring,
|
||||
const struct iio_chan_spec *chan)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = __iio_add_chan_devattr("index", "scan_elements",
|
||||
chan,
|
||||
&iio_show_scan_index,
|
||||
NULL,
|
||||
0,
|
||||
0,
|
||||
&ring->dev,
|
||||
&ring->scan_el_dev_attr_list);
|
||||
if (ret)
|
||||
goto error_ret;
|
||||
|
||||
ret = __iio_add_chan_devattr("type", "scan_elements",
|
||||
chan,
|
||||
&iio_show_fixed_type,
|
||||
NULL,
|
||||
0,
|
||||
0,
|
||||
&ring->dev,
|
||||
&ring->scan_el_dev_attr_list);
|
||||
|
||||
if (ret)
|
||||
goto error_ret;
|
||||
|
||||
ret = __iio_add_chan_scan_elattr("en", "scan_elements",
|
||||
chan, &ring->dev,
|
||||
&ring->scan_el_en_attr_list);
|
||||
|
||||
error_ret:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void iio_ring_remove_and_free_scan_el_attr(struct iio_ring_buffer *ring,
|
||||
struct iio_scan_el *p)
|
||||
{
|
||||
sysfs_remove_file_from_group(&ring->dev.kobj,
|
||||
&p->dev_attr.attr, "scan_elements");
|
||||
kfree(p->dev_attr.attr.name);
|
||||
kfree(p);
|
||||
}
|
||||
|
||||
static void iio_ring_remove_and_free_scan_dev_attr(struct iio_ring_buffer *ring,
|
||||
struct iio_dev_attr *p)
|
||||
{
|
||||
sysfs_remove_file_from_group(&ring->dev.kobj,
|
||||
&p->dev_attr.attr, "scan_elements");
|
||||
kfree(p->dev_attr.attr.name);
|
||||
kfree(p);
|
||||
}
|
||||
|
||||
static struct attribute *iio_scan_el_dummy_attrs[] = {
|
||||
NULL
|
||||
};
|
||||
|
||||
static struct attribute_group iio_scan_el_dummy_group = {
|
||||
.name = "scan_elements",
|
||||
.attrs = iio_scan_el_dummy_attrs
|
||||
};
|
||||
|
||||
static void __iio_ring_attr_cleanup(struct iio_ring_buffer *ring)
|
||||
{
|
||||
struct iio_dev_attr *p, *n;
|
||||
struct iio_scan_el *q, *m;
|
||||
int anydynamic = !(list_empty(&ring->scan_el_dev_attr_list) &&
|
||||
list_empty(&ring->scan_el_en_attr_list));
|
||||
list_for_each_entry_safe(p, n,
|
||||
&ring->scan_el_dev_attr_list, l)
|
||||
iio_ring_remove_and_free_scan_dev_attr(ring, p);
|
||||
list_for_each_entry_safe(q, m,
|
||||
&ring->scan_el_en_attr_list, l)
|
||||
iio_ring_remove_and_free_scan_el_attr(ring, q);
|
||||
|
||||
if (ring->scan_el_attrs)
|
||||
sysfs_remove_group(&ring->dev.kobj,
|
||||
ring->scan_el_attrs);
|
||||
else if (anydynamic)
|
||||
sysfs_remove_group(&ring->dev.kobj,
|
||||
&iio_scan_el_dummy_group);
|
||||
}
|
||||
|
||||
int iio_ring_buffer_register_ex(struct iio_ring_buffer *ring, int id,
|
||||
const struct iio_chan_spec *channels,
|
||||
int num_channels)
|
||||
{
|
||||
int ret, i;
|
||||
|
||||
ring->id = id;
|
||||
|
||||
|
@ -268,9 +421,28 @@ int iio_ring_buffer_register(struct iio_ring_buffer *ring, int id)
|
|||
"Failed to add sysfs scan elements\n");
|
||||
goto error_free_ring_buffer_event_chrdev;
|
||||
}
|
||||
} else if (channels) {
|
||||
ret = sysfs_create_group(&ring->dev.kobj,
|
||||
&iio_scan_el_dummy_group);
|
||||
if (ret)
|
||||
goto error_free_ring_buffer_event_chrdev;
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
||||
INIT_LIST_HEAD(&ring->scan_el_dev_attr_list);
|
||||
INIT_LIST_HEAD(&ring->scan_el_en_attr_list);
|
||||
if (channels) {
|
||||
/* new magic */
|
||||
for (i = 0; i < num_channels; i++) {
|
||||
ret = iio_ring_add_channel_sysfs(ring, &channels[i]);
|
||||
if (ret < 0)
|
||||
goto error_cleanup_dynamic;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
error_cleanup_dynamic:
|
||||
__iio_ring_attr_cleanup(ring);
|
||||
error_free_ring_buffer_event_chrdev:
|
||||
__iio_free_ring_buffer_event_chrdev(ring);
|
||||
error_remove_device:
|
||||
|
@ -278,14 +450,17 @@ int iio_ring_buffer_register(struct iio_ring_buffer *ring, int id)
|
|||
error_ret:
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL(iio_ring_buffer_register_ex);
|
||||
|
||||
int iio_ring_buffer_register(struct iio_ring_buffer *ring, int id)
|
||||
{
|
||||
return iio_ring_buffer_register_ex(ring, id, NULL, 0);
|
||||
}
|
||||
EXPORT_SYMBOL(iio_ring_buffer_register);
|
||||
|
||||
void iio_ring_buffer_unregister(struct iio_ring_buffer *ring)
|
||||
{
|
||||
if (ring->scan_el_attrs)
|
||||
sysfs_remove_group(&ring->dev.kobj,
|
||||
ring->scan_el_attrs);
|
||||
|
||||
__iio_ring_attr_cleanup(ring);
|
||||
__iio_free_ring_buffer_access_chrdev(ring);
|
||||
__iio_free_ring_buffer_event_chrdev(ring);
|
||||
device_del(&ring->dev);
|
||||
|
@ -540,4 +715,3 @@ ssize_t iio_scan_el_ts_store(struct device *dev,
|
|||
return ret ? ret : len;
|
||||
}
|
||||
EXPORT_SYMBOL(iio_scan_el_ts_store);
|
||||
|
||||
|
|
|
@ -140,6 +140,8 @@ struct iio_ring_buffer {
|
|||
int (*predisable)(struct iio_dev *);
|
||||
int (*postdisable)(struct iio_dev *);
|
||||
|
||||
struct list_head scan_el_dev_attr_list;
|
||||
struct list_head scan_el_en_attr_list;
|
||||
};
|
||||
|
||||
/**
|
||||
|
@ -177,6 +179,7 @@ struct iio_scan_el {
|
|||
struct device_attribute dev_attr;
|
||||
unsigned int number;
|
||||
unsigned int label;
|
||||
struct list_head l;
|
||||
|
||||
int (*set_state)(struct iio_scan_el *scanel,
|
||||
struct iio_dev *dev_info,
|
||||
|
@ -430,6 +433,14 @@ static inline void iio_put_ring_buffer(struct iio_ring_buffer *ring)
|
|||
**/
|
||||
int iio_ring_buffer_register(struct iio_ring_buffer *ring, int id);
|
||||
|
||||
/** iio_ring_buffer_register_ex() - register the buffer with IIO core
|
||||
* @ring: the buffer to be registered
|
||||
* @id: the id of the buffer (typically 0)
|
||||
**/
|
||||
int iio_ring_buffer_register_ex(struct iio_ring_buffer *ring, int id,
|
||||
const struct iio_chan_spec *channels,
|
||||
int num_channels);
|
||||
|
||||
/**
|
||||
* iio_ring_buffer_unregister() - unregister the buffer from IIO core
|
||||
* @ring: the buffer to be unregistered
|
||||
|
@ -481,6 +492,15 @@ static inline int iio_ring_buffer_register(struct iio_ring_buffer *ring, int id)
|
|||
{
|
||||
return 0;
|
||||
};
|
||||
|
||||
static inline int iio_ring_buffer_register_ex(struct iio_ring_buffer *ring,
|
||||
int id,
|
||||
struct iio_chan_spec *channels,
|
||||
int num_channels)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void iio_ring_buffer_unregister(struct iio_ring_buffer *ring)
|
||||
{};
|
||||
|
||||
|
|
|
@ -24,6 +24,7 @@ struct iio_event_attr {
|
|||
struct device_attribute dev_attr;
|
||||
int mask;
|
||||
struct iio_event_handler_list *listel;
|
||||
struct list_head l;
|
||||
};
|
||||
|
||||
#define to_iio_event_attr(_dev_attr) \
|
||||
|
@ -34,11 +35,14 @@ struct iio_event_attr {
|
|||
* @dev_attr: underlying device attribute
|
||||
* @address: associated register address
|
||||
* @val2: secondary attribute value
|
||||
* @l: list head for maintaining list of dynamically created attrs.
|
||||
*/
|
||||
struct iio_dev_attr {
|
||||
struct device_attribute dev_attr;
|
||||
int address;
|
||||
int val2;
|
||||
struct list_head l;
|
||||
struct iio_chan_spec const *c;
|
||||
};
|
||||
|
||||
#define to_iio_dev_attr(_dev_attr) \
|
||||
|
@ -259,26 +263,28 @@ struct iio_const_attr {
|
|||
#define IIO_EVENT_ATTR_DATA_RDY(_show, _store, _mask, _handler) \
|
||||
IIO_EVENT_ATTR(data_rdy, _show, _store, _mask, _handler)
|
||||
|
||||
#define IIO_EV_CLASS_BUFFER 0
|
||||
#define IIO_EV_CLASS_IN 1
|
||||
#define IIO_EV_CLASS_ACCEL 2
|
||||
#define IIO_EV_CLASS_GYRO 3
|
||||
#define IIO_EV_CLASS_MAGN 4
|
||||
#define IIO_EV_CLASS_LIGHT 5
|
||||
#define IIO_EV_CLASS_PROXIMITY 6
|
||||
#define IIO_EV_CLASS_TEMP 7
|
||||
/* must match our channel defs */
|
||||
#define IIO_EV_CLASS_IN IIO_IN
|
||||
#define IIO_EV_CLASS_IN_DIFF IIO_IN_DIFF
|
||||
#define IIO_EV_CLASS_ACCEL IIO_ACCEL
|
||||
#define IIO_EV_CLASS_GYRO IIO_GYRO
|
||||
#define IIO_EV_CLASS_MAGN IIO_MAGN
|
||||
#define IIO_EV_CLASS_LIGHT IIO_LIGHT
|
||||
#define IIO_EV_CLASS_PROXIMITY IIO_PROXIMITY
|
||||
#define IIO_EV_CLASS_TEMP IIO_TEMP
|
||||
#define IIO_EV_CLASS_BUFFER IIO_BUFFER
|
||||
|
||||
#define IIO_EV_MOD_X 0
|
||||
#define IIO_EV_MOD_Y 1
|
||||
#define IIO_EV_MOD_Z 2
|
||||
#define IIO_EV_MOD_X_AND_Y 3
|
||||
#define IIO_EV_MOD_X_ANX_Z 4
|
||||
#define IIO_EV_MOD_Y_AND_Z 5
|
||||
#define IIO_EV_MOD_X_AND_Y_AND_Z 6
|
||||
#define IIO_EV_MOD_X_OR_Y 7
|
||||
#define IIO_EV_MOD_X_OR_Z 8
|
||||
#define IIO_EV_MOD_Y_OR_Z 9
|
||||
#define IIO_EV_MOD_X_OR_Y_OR_Z 10
|
||||
#define IIO_EV_MOD_X IIO_MOD_X
|
||||
#define IIO_EV_MOD_Y IIO_MOD_Y
|
||||
#define IIO_EV_MOD_Z IIO_MOD_Z
|
||||
#define IIO_EV_MOD_X_AND_Y IIO_MOD_X_AND_Y
|
||||
#define IIO_EV_MOD_X_ANX_Z IIO_MOD_X_AND_Z
|
||||
#define IIO_EV_MOD_Y_AND_Z IIO_MOD_Y_AND_Z
|
||||
#define IIO_EV_MOD_X_AND_Y_AND_Z IIO_MOD_X_AND_Y_AND_Z
|
||||
#define IIO_EV_MOD_X_OR_Y IIO_MOD_X_OR_Y
|
||||
#define IIO_EV_MOD_X_OR_Z IIO_MOD_X_OR_Z
|
||||
#define IIO_EV_MOD_Y_OR_Z IIO_MOD_Y_OR_Z
|
||||
#define IIO_EV_MOD_X_OR_Y_OR_Z IIO_MOD_X_OR_Y_OR_Z
|
||||
|
||||
#define IIO_EV_TYPE_THRESH 0
|
||||
#define IIO_EV_TYPE_MAG 1
|
||||
|
@ -288,6 +294,10 @@ struct iio_const_attr {
|
|||
#define IIO_EV_DIR_RISING 1
|
||||
#define IIO_EV_DIR_FALLING 2
|
||||
|
||||
#define IIO_EV_TYPE_MAX 8
|
||||
#define IIO_EV_BIT(type, direction) \
|
||||
(1 << (type*IIO_EV_TYPE_MAX + direction))
|
||||
|
||||
#define IIO_EVENT_CODE(channelclass, orient_bit, number, \
|
||||
modifier, type, direction) \
|
||||
(channelclass | (orient_bit << 8) | ((number) << 9) | \
|
||||
|
@ -304,6 +314,14 @@ struct iio_const_attr {
|
|||
#define IIO_BUFFER_EVENT_CODE(code) \
|
||||
(IIO_EV_CLASS_BUFFER | (code << 8))
|
||||
|
||||
#define IIO_EVENT_CODE_EXTRACT_DIR(mask) ((mask >> 24) & 0xf)
|
||||
|
||||
/* Event code number extraction depends on which type of event we have.
|
||||
* Perhaps review this function in the future*/
|
||||
#define IIO_EVENT_CODE_EXTRACT_NUM(mask) ((mask >> 9) & 0x0f)
|
||||
|
||||
#define IIO_EVENT_CODE_EXTRACT_MODIFIER(mask) ((mask >> 13) & 0x7)
|
||||
|
||||
/**
|
||||
* IIO_EVENT_ATTR_RING_50_FULL - ring buffer event to indicate 50% full
|
||||
* @_show: output method for the attribute
|
||||
|
|
Loading…
Reference in a new issue