* [PATCH v1 1/5] IIO: core: Introduce read_raw_multi
@ 2014-02-23 19:50 Srinivas Pandruvada
2014-02-23 19:50 ` [PATCH v1 2/5] IIO: core: Modify scan element type Srinivas Pandruvada
` (4 more replies)
0 siblings, 5 replies; 11+ messages in thread
From: Srinivas Pandruvada @ 2014-02-23 19:50 UTC (permalink / raw)
To: jic23; +Cc: linux-iio, Srinivas Pandruvada
This callback is introduced to overcome some limitations of existing
read_raw callback. The functionality of both existing read_raw and
read_raw_multi is similar, both are used to request values from the
device. The current read_raw callback allows only two return values.
The new read_raw_multi allows returning multiple values. Instead of
passing just address of val and val2, it passes length and pointer
to values. Depending on the type and length of passed buffer, iio
client drivers can return multiple values.
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
drivers/iio/iio_core.h | 2 +-
drivers/iio/industrialio-core.c | 51 +++++++++++++++++++++++-----------------
drivers/iio/industrialio-event.c | 6 +++--
drivers/iio/inkern.c | 15 ++++++++++--
include/linux/iio/iio.h | 16 +++++++++++++
5 files changed, 63 insertions(+), 27 deletions(-)
diff --git a/drivers/iio/iio_core.h b/drivers/iio/iio_core.h
index f6db6af..4172f22 100644
--- a/drivers/iio/iio_core.h
+++ b/drivers/iio/iio_core.h
@@ -35,7 +35,7 @@ int __iio_add_chan_devattr(const char *postfix,
struct list_head *attr_list);
void iio_free_chan_devattr_list(struct list_head *attr_list);
-ssize_t iio_format_value(char *buf, unsigned int type, int val, int val2);
+ssize_t iio_format_value(char *buf, unsigned int type, int *val);
/* Event interface flags */
#define IIO_BUSY_BIT_POS 1
diff --git a/drivers/iio/industrialio-core.c b/drivers/iio/industrialio-core.c
index acc911a..b1225a4 100644
--- a/drivers/iio/industrialio-core.c
+++ b/drivers/iio/industrialio-core.c
@@ -373,41 +373,42 @@ EXPORT_SYMBOL_GPL(iio_enum_write);
* @buf: The buffer to which the formated value gets written
* @type: One of the IIO_VAL_... constants. This decides how the val and val2
* parameters are formatted.
- * @val: First part of the value, exact meaning depends on the type parameter.
- * @val2: Second part of the value, exact meaning depends on the type parameter.
+ * @vals: pointer to the values, exact meaning depends on the type parameter.
*/
-ssize_t iio_format_value(char *buf, unsigned int type, int val, int val2)
+ssize_t iio_format_value(char *buf, unsigned int type, int *vals)
{
unsigned long long tmp;
bool scale_db = false;
switch (type) {
case IIO_VAL_INT:
- return sprintf(buf, "%d\n", val);
+ return sprintf(buf, "%d\n", vals[0]);
case IIO_VAL_INT_PLUS_MICRO_DB:
scale_db = true;
case IIO_VAL_INT_PLUS_MICRO:
- if (val2 < 0)
- return sprintf(buf, "-%ld.%06u%s\n", abs(val), -val2,
+ if (vals[1] < 0)
+ return sprintf(buf, "-%ld.%06u%s\n", abs(vals[0]),
+ -vals[1],
scale_db ? " dB" : "");
else
- return sprintf(buf, "%d.%06u%s\n", val, val2,
+ return sprintf(buf, "%d.%06u%s\n", vals[0], vals[1],
scale_db ? " dB" : "");
case IIO_VAL_INT_PLUS_NANO:
- if (val2 < 0)
- return sprintf(buf, "-%ld.%09u\n", abs(val), -val2);
+ if (vals[1] < 0)
+ return sprintf(buf, "-%ld.%09u\n", abs(vals[0]),
+ -vals[1]);
else
- return sprintf(buf, "%d.%09u\n", val, val2);
+ return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
case IIO_VAL_FRACTIONAL:
- tmp = div_s64((s64)val * 1000000000LL, val2);
- val2 = do_div(tmp, 1000000000LL);
- val = tmp;
- return sprintf(buf, "%d.%09u\n", val, val2);
+ tmp = div_s64((s64)vals[0] * 1000000000LL, vals[1]);
+ vals[1] = do_div(tmp, 1000000000LL);
+ vals[0] = tmp;
+ return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
case IIO_VAL_FRACTIONAL_LOG2:
- tmp = (s64)val * 1000000000LL >> val2;
- val2 = do_div(tmp, 1000000000LL);
- val = tmp;
- return sprintf(buf, "%d.%09u\n", val, val2);
+ tmp = (s64)vals[0] * 1000000000LL >> vals[1];
+ vals[1] = do_div(tmp, 1000000000LL);
+ vals[0] = tmp;
+ return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
default:
return 0;
}
@@ -419,14 +420,20 @@ static ssize_t iio_read_channel_info(struct device *dev,
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
- int val, val2;
- int ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
- &val, &val2, this_attr->address);
+ int vals[INDIO_MAX_RAW_ELEMENTS];
+ int ret;
+
+ if (indio_dev->info->read_raw_multi)
+ ret = indio_dev->info->read_raw_multi(indio_dev, this_attr->c,
+ INDIO_MAX_RAW_ELEMENTS, vals, this_attr->address);
+ else
+ ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
+ &vals[0], &vals[1], this_attr->address);
if (ret < 0)
return ret;
- return iio_format_value(buf, ret, val, val2);
+ return iio_format_value(buf, ret, vals);
}
/**
diff --git a/drivers/iio/industrialio-event.c b/drivers/iio/industrialio-event.c
index c9c1419..0f7f78e 100644
--- a/drivers/iio/industrialio-event.c
+++ b/drivers/iio/industrialio-event.c
@@ -272,7 +272,7 @@ static ssize_t iio_ev_value_show(struct device *dev,
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
- int val, val2;
+ int val, val2, val_arr[2];
int ret;
ret = indio_dev->info->read_event_value(indio_dev,
@@ -281,7 +281,9 @@ static ssize_t iio_ev_value_show(struct device *dev,
&val, &val2);
if (ret < 0)
return ret;
- return iio_format_value(buf, ret, val, val2);
+ val_arr[0] = val;
+ val_arr[1] = val2;
+ return iio_format_value(buf, ret, val_arr);
}
static ssize_t iio_ev_value_store(struct device *dev,
diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c
index 0cf5f8e..6a93d57 100644
--- a/drivers/iio/inkern.c
+++ b/drivers/iio/inkern.c
@@ -417,12 +417,23 @@ static int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
enum iio_chan_info_enum info)
{
int unused;
+ int vals[INDIO_MAX_RAW_ELEMENTS];
+ int ret;
if (val2 == NULL)
val2 = &unused;
- return chan->indio_dev->info->read_raw(chan->indio_dev, chan->channel,
- val, val2, info);
+ if (chan->indio_dev->info->read_raw_multi) {
+ ret = chan->indio_dev->info->read_raw_multi(chan->indio_dev,
+ chan->channel, INDIO_MAX_RAW_ELEMENTS,
+ vals, info);
+ *val = vals[0];
+ *val2 = vals[1];
+ } else
+ ret = chan->indio_dev->info->read_raw(chan->indio_dev,
+ chan->channel, val, val2, info);
+
+ return ret;
}
int iio_read_channel_raw(struct iio_channel *chan, int *val)
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index 75a8a20..ddf9f60 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -284,6 +284,8 @@ static inline s64 iio_get_time_ns(void)
#define INDIO_ALL_BUFFER_MODES \
(INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE)
+#define INDIO_MAX_RAW_ELEMENTS 4
+
struct iio_trigger; /* forward declaration */
struct iio_dev;
@@ -298,6 +300,14 @@ struct iio_dev;
* 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.
+ * @read_raw_multi: function to return values 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. vals pointer
+ * contain the elements making up the returned value.
+ * val_len specifies maximum number of elements
+ * vals pointer can contain. In contrast to to read_raw
+ * device can return multiple values not just two.
* @write_raw: function to write a value to the device.
* Parameters are the same as for read_raw.
* @write_raw_get_fmt: callback function to query the expected
@@ -324,6 +334,12 @@ struct iio_info {
int *val2,
long mask);
+ int (*read_raw_multi)(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int val_len,
+ int *vals,
+ long mask);
+
int (*write_raw)(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int val,
--
1.8.3.2
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH v1 2/5] IIO: core: Modify scan element type
2014-02-23 19:50 [PATCH v1 1/5] IIO: core: Introduce read_raw_multi Srinivas Pandruvada
@ 2014-02-23 19:50 ` Srinivas Pandruvada
2014-02-23 19:50 ` [PATCH v1 3/5] IIO: core: Introduce Quaternion types Srinivas Pandruvada
` (3 subsequent siblings)
4 siblings, 0 replies; 11+ messages in thread
From: Srinivas Pandruvada @ 2014-02-23 19:50 UTC (permalink / raw)
To: jic23; +Cc: linux-iio, Srinivas Pandruvada
The current scan element type uses the following format:
[be|le]:[s|u]bits/storagebits[>>shift].
To specify multiple elements in this type, added a repeat value.
So new format is:
[be|le]:([s|u]bits/storagebits){repeat}[>>shift].
Here repeat is specifying how may times, real/storage bits are repeating.
When repeat is value is 0 or 1, then repeat value is not used in the format,
and it will be same as existing format.
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
drivers/iio/industrialio-buffer.c | 41 +++++++++++++++++++++++++++++++++------
include/linux/iio/iio.h | 9 +++++++++
2 files changed, 44 insertions(+), 6 deletions(-)
diff --git a/drivers/iio/industrialio-buffer.c b/drivers/iio/industrialio-buffer.c
index c67d83b..598eacd 100644
--- a/drivers/iio/industrialio-buffer.c
+++ b/drivers/iio/industrialio-buffer.c
@@ -150,7 +150,16 @@ static ssize_t iio_show_fixed_type(struct device *dev,
type = IIO_BE;
#endif
}
- return sprintf(buf, "%s:%c%d/%d>>%u\n",
+ if (this_attr->c->scan_type.repeat > 1)
+ return sprintf(buf, "%s:(%c%d/%d){%d}>>%u\n",
+ iio_endian_prefix[type],
+ this_attr->c->scan_type.sign,
+ this_attr->c->scan_type.realbits,
+ this_attr->c->scan_type.storagebits,
+ this_attr->c->scan_type.repeat,
+ this_attr->c->scan_type.shift);
+ else
+ return sprintf(buf, "%s:%c%d/%d>>%u\n",
iio_endian_prefix[type],
this_attr->c->scan_type.sign,
this_attr->c->scan_type.realbits,
@@ -475,14 +484,22 @@ static int iio_compute_scan_bytes(struct iio_dev *indio_dev,
for_each_set_bit(i, mask,
indio_dev->masklength) {
ch = iio_find_channel_from_si(indio_dev, i);
- length = ch->scan_type.storagebits / 8;
+ if (ch->scan_type.repeat > 1)
+ length = ch->scan_type.storagebits / 8 *
+ ch->scan_type.repeat;
+ else
+ length = ch->scan_type.storagebits / 8;
bytes = ALIGN(bytes, length);
bytes += length;
}
if (timestamp) {
ch = iio_find_channel_from_si(indio_dev,
indio_dev->scan_index_timestamp);
- length = ch->scan_type.storagebits / 8;
+ if (ch->scan_type.repeat > 1)
+ length = ch->scan_type.storagebits / 8 *
+ ch->scan_type.repeat;
+ else
+ length = ch->scan_type.storagebits / 8;
bytes = ALIGN(bytes, length);
bytes += length;
}
@@ -961,7 +978,11 @@ static int iio_buffer_update_demux(struct iio_dev *indio_dev,
indio_dev->masklength,
in_ind + 1);
ch = iio_find_channel_from_si(indio_dev, in_ind);
- length = ch->scan_type.storagebits/8;
+ if (ch->scan_type.repeat > 1)
+ length = ch->scan_type.storagebits / 8 *
+ ch->scan_type.repeat;
+ else
+ length = ch->scan_type.storagebits / 8;
/* Make sure we are aligned */
in_loc += length;
if (in_loc % length)
@@ -973,7 +994,11 @@ static int iio_buffer_update_demux(struct iio_dev *indio_dev,
goto error_clear_mux_table;
}
ch = iio_find_channel_from_si(indio_dev, in_ind);
- length = ch->scan_type.storagebits/8;
+ if (ch->scan_type.repeat > 1)
+ length = ch->scan_type.storagebits / 8 *
+ ch->scan_type.repeat;
+ else
+ length = ch->scan_type.storagebits / 8;
if (out_loc % length)
out_loc += length - out_loc % length;
if (in_loc % length)
@@ -994,7 +1019,11 @@ static int iio_buffer_update_demux(struct iio_dev *indio_dev,
}
ch = iio_find_channel_from_si(indio_dev,
indio_dev->scan_index_timestamp);
- length = ch->scan_type.storagebits/8;
+ if (ch->scan_type.repeat > 1)
+ length = ch->scan_type.storagebits / 8 *
+ ch->scan_type.repeat;
+ else
+ length = ch->scan_type.storagebits / 8;
if (out_loc % length)
out_loc += length - out_loc % length;
if (in_loc % length)
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index ddf9f60..3f1a83c 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -177,6 +177,14 @@ struct iio_event_spec {
* shift: Shift right by this before masking out
* realbits.
* endianness: little or big endian
+ * repeat: No. of times real/storage bits repeats.
+ * By default, when repeat is set to 0
+ * repeat value is treated as 1. When
+ * repeat value is 0 or 1, then there is
+ * no change in existing scan element
+ * type, in sysfs. When set to more than
+ * 1, then the type element in sysfs will
+ * show repeat value.
* @info_mask_separate: What information is to be exported that is specific to
* this channel.
* @info_mask_shared_by_type: What information is to be exported that is shared
@@ -219,6 +227,7 @@ struct iio_chan_spec {
u8 realbits;
u8 storagebits;
u8 shift;
+ u8 repeat;
enum iio_endian endianness;
} scan_type;
long info_mask_separate;
--
1.8.3.2
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH v1 3/5] IIO: core: Introduce Quaternion types
2014-02-23 19:50 [PATCH v1 1/5] IIO: core: Introduce read_raw_multi Srinivas Pandruvada
2014-02-23 19:50 ` [PATCH v1 2/5] IIO: core: Modify scan element type Srinivas Pandruvada
@ 2014-02-23 19:50 ` Srinivas Pandruvada
2014-02-23 19:50 ` [PATCH v1 4/5] iio: hid-sensors: Added device rotation support Srinivas Pandruvada
` (2 subsequent siblings)
4 siblings, 0 replies; 11+ messages in thread
From: Srinivas Pandruvada @ 2014-02-23 19:50 UTC (permalink / raw)
To: jic23; +Cc: linux-iio, Srinivas Pandruvada
Introduced IIO_VAL_QUATERNION and its formatting. Format used here:
x:y:z:w
In addition IIO_QUAT_ROT is added to the channel type and name.
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
drivers/iio/industrialio-core.c | 4 ++++
include/linux/iio/types.h | 2 ++
2 files changed, 6 insertions(+)
diff --git a/drivers/iio/industrialio-core.c b/drivers/iio/industrialio-core.c
index b1225a4..69aaa7a 100644
--- a/drivers/iio/industrialio-core.c
+++ b/drivers/iio/industrialio-core.c
@@ -70,6 +70,7 @@ static const char * const iio_chan_type_name_spec[] = {
[IIO_CCT] = "cct",
[IIO_PRESSURE] = "pressure",
[IIO_HUMIDITYRELATIVE] = "humidityrelative",
+ [IIO_QUAT_ROT] = "rotquaternion",
};
static const char * const iio_modifier_names[] = {
@@ -409,6 +410,9 @@ ssize_t iio_format_value(char *buf, unsigned int type, int *vals)
vals[1] = do_div(tmp, 1000000000LL);
vals[0] = tmp;
return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
+ case IIO_VAL_QUATERNION:
+ return sprintf(buf, "%d:%d:%d:%d\n", vals[0], vals[1], vals[2],
+ vals[3]);
default:
return 0;
}
diff --git a/include/linux/iio/types.h b/include/linux/iio/types.h
index 084d882..256ad2d 100644
--- a/include/linux/iio/types.h
+++ b/include/linux/iio/types.h
@@ -30,6 +30,7 @@ enum iio_chan_type {
IIO_CCT,
IIO_PRESSURE,
IIO_HUMIDITYRELATIVE,
+ IIO_QUAT_ROT,
};
enum iio_modifier {
@@ -79,6 +80,7 @@ enum iio_event_direction {
#define IIO_VAL_INT_PLUS_MICRO 2
#define IIO_VAL_INT_PLUS_NANO 3
#define IIO_VAL_INT_PLUS_MICRO_DB 4
+#define IIO_VAL_QUATERNION 5
#define IIO_VAL_FRACTIONAL 10
#define IIO_VAL_FRACTIONAL_LOG2 11
--
1.8.3.2
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH v1 4/5] iio: hid-sensors: Added device rotation support
2014-02-23 19:50 [PATCH v1 1/5] IIO: core: Introduce read_raw_multi Srinivas Pandruvada
2014-02-23 19:50 ` [PATCH v1 2/5] IIO: core: Modify scan element type Srinivas Pandruvada
2014-02-23 19:50 ` [PATCH v1 3/5] IIO: core: Introduce Quaternion types Srinivas Pandruvada
@ 2014-02-23 19:50 ` Srinivas Pandruvada
2014-02-23 19:50 ` [PATCH v1 5/5] iio: Added ABI description for quaternion Srinivas Pandruvada
2014-03-29 11:15 ` [PATCH v1 1/5] IIO: core: Introduce read_raw_multi Jonathan Cameron
4 siblings, 0 replies; 11+ messages in thread
From: Srinivas Pandruvada @ 2014-02-23 19:50 UTC (permalink / raw)
To: jic23; +Cc: linux-iio, Srinivas Pandruvada
Added usage id processing for device rotation. This uses IIO
interfaces for triggered buffer to present data to user
mode.This uses HID sensor framework for registering callback
events from the sensor hub.
Data is exported to user space in the form of quaternion rotation
format.
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
drivers/iio/orientation/Kconfig | 11 +
drivers/iio/orientation/Makefile | 1 +
drivers/iio/orientation/hid-sensor-rotation.c | 358 ++++++++++++++++++++++++++
include/linux/hid-sensor-ids.h | 1 +
4 files changed, 371 insertions(+)
create mode 100644 drivers/iio/orientation/hid-sensor-rotation.c
diff --git a/drivers/iio/orientation/Kconfig b/drivers/iio/orientation/Kconfig
index 58c62c8..da8bd8a 100644
--- a/drivers/iio/orientation/Kconfig
+++ b/drivers/iio/orientation/Kconfig
@@ -16,4 +16,15 @@ config HID_SENSOR_INCLINOMETER_3D
Say yes here to build support for the HID SENSOR
Inclinometer 3D.
+config HID_SENSOR_DEVICE_ROTATION
+ depends on HID_SENSOR_HUB
+ select IIO_BUFFER
+ select IIO_TRIGGERED_BUFFER
+ select HID_SENSOR_IIO_COMMON
+ select HID_SENSOR_IIO_TRIGGER
+ tristate "HID Device Rotation"
+ help
+ Say yes here to build support for the HID SENSOR
+ device rotation.
+
endmenu
diff --git a/drivers/iio/orientation/Makefile b/drivers/iio/orientation/Makefile
index 2c97572..4734dab 100644
--- a/drivers/iio/orientation/Makefile
+++ b/drivers/iio/orientation/Makefile
@@ -4,3 +4,4 @@
# When adding new entries keep the list in alphabetical order
obj-$(CONFIG_HID_SENSOR_INCLINOMETER_3D) += hid-sensor-incl-3d.o
+obj-$(CONFIG_HID_SENSOR_DEVICE_ROTATION) += hid-sensor-rotation.o
diff --git a/drivers/iio/orientation/hid-sensor-rotation.c b/drivers/iio/orientation/hid-sensor-rotation.c
new file mode 100644
index 0000000..419fa40
--- /dev/null
+++ b/drivers/iio/orientation/hid-sensor-rotation.c
@@ -0,0 +1,358 @@
+/*
+ * HID Sensors Driver
+ * Copyright (c) 2014, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ */
+
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/slab.h>
+#include <linux/hid-sensor-hub.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
+#include "../common/hid-sensors/hid-sensor-trigger.h"
+
+#define MAX_QUATERNION_COMP 4
+
+struct dev_rot_state {
+ struct hid_sensor_hub_callbacks callbacks;
+ struct hid_sensor_common common_attributes;
+ struct hid_sensor_hub_attribute_info quaternion;
+ u32 sampled_vals[MAX_QUATERNION_COMP];
+};
+
+/* Channel definitions */
+static const struct iio_chan_spec dev_rot_channels[] = {
+ {
+ .type = IIO_QUAT_ROT,
+ .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
+ BIT(IIO_CHAN_INFO_SCALE) |
+ BIT(IIO_CHAN_INFO_SAMP_FREQ) |
+ BIT(IIO_CHAN_INFO_HYSTERESIS) |
+ BIT(IIO_CHAN_INFO_RAW),
+ }
+};
+
+/* Adjust channel real bits based on report descriptor */
+static void dev_rot_adjust_channel_bit_mask(struct iio_chan_spec *chan,
+ int size)
+{
+ chan->scan_type.sign = 's';
+ /* Real storage bits will change based on the report desc. */
+ chan->scan_type.realbits = size * 8;
+ /* Maximum size of a sample to capture is u32 */
+ chan->scan_type.storagebits = sizeof(u32) * 8;
+ chan->scan_type.repeat = MAX_QUATERNION_COMP;
+}
+
+/* Channel read_raw handler */
+static int dev_rot_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int size, int *vals,
+ long mask)
+{
+ struct dev_rot_state *rot_state = iio_priv(indio_dev);
+ int ret_type;
+ int i;
+
+ vals[0] = 0;
+ vals[1] = 0;
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ if (size >= MAX_QUATERNION_COMP) {
+ for (i = 0; i < MAX_QUATERNION_COMP; ++i)
+ vals[i] = rot_state->sampled_vals[i];
+ ret_type = IIO_VAL_QUATERNION;
+ } else
+ ret_type = -EINVAL;
+ break;
+ case IIO_CHAN_INFO_SCALE:
+ vals[0] = rot_state->quaternion.units;
+ ret_type = IIO_VAL_INT;
+ break;
+ case IIO_CHAN_INFO_OFFSET:
+ vals[1] = hid_sensor_convert_exponent(
+ rot_state->quaternion.unit_expo);
+ ret_type = IIO_VAL_INT;
+ break;
+ case IIO_CHAN_INFO_SAMP_FREQ:
+ ret_type = hid_sensor_read_samp_freq_value(
+ &rot_state->common_attributes, &vals[0], &vals[1]);
+ break;
+ case IIO_CHAN_INFO_HYSTERESIS:
+ ret_type = hid_sensor_read_raw_hyst_value(
+ &rot_state->common_attributes, &vals[0], &vals[1]);
+ break;
+ default:
+ ret_type = -EINVAL;
+ break;
+ }
+
+ return ret_type;
+}
+
+/* Channel write_raw handler */
+static int dev_rot_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int val,
+ int val2,
+ long mask)
+{
+ struct dev_rot_state *rot_state = iio_priv(indio_dev);
+ int ret;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_SAMP_FREQ:
+ ret = hid_sensor_write_samp_freq_value(
+ &rot_state->common_attributes, val, val2);
+ break;
+ case IIO_CHAN_INFO_HYSTERESIS:
+ ret = hid_sensor_write_raw_hyst_value(
+ &rot_state->common_attributes, val, val2);
+ break;
+ default:
+ ret = -EINVAL;
+ }
+
+ return ret;
+}
+
+static const struct iio_info dev_rot_info = {
+ .driver_module = THIS_MODULE,
+ .read_raw_multi = &dev_rot_read_raw,
+ .write_raw = &dev_rot_write_raw,
+};
+
+/* Function to push data to buffer */
+static void hid_sensor_push_data(struct iio_dev *indio_dev, u8 *data, int len)
+{
+ dev_dbg(&indio_dev->dev, "hid_sensor_push_data >>\n");
+ iio_push_to_buffers(indio_dev, (u8 *)data);
+ dev_dbg(&indio_dev->dev, "hid_sensor_push_data <<\n");
+
+}
+
+/* Callback handler to send event after all samples are received and captured */
+static int dev_rot_proc_event(struct hid_sensor_hub_device *hsdev,
+ unsigned usage_id,
+ void *priv)
+{
+ struct iio_dev *indio_dev = platform_get_drvdata(priv);
+ struct dev_rot_state *rot_state = iio_priv(indio_dev);
+
+ dev_dbg(&indio_dev->dev, "dev_rot_proc_event [%d]\n",
+ rot_state->common_attributes.data_ready);
+
+ if (rot_state->common_attributes.data_ready)
+ hid_sensor_push_data(indio_dev,
+ (u8 *)rot_state->sampled_vals,
+ sizeof(rot_state->sampled_vals));
+
+ return 0;
+}
+
+/* Capture samples in local storage */
+static int dev_rot_capture_sample(struct hid_sensor_hub_device *hsdev,
+ unsigned usage_id,
+ size_t raw_len, char *raw_data,
+ void *priv)
+{
+ struct iio_dev *indio_dev = platform_get_drvdata(priv);
+ struct dev_rot_state *rot_state = iio_priv(indio_dev);
+
+ if (usage_id == HID_USAGE_SENSOR_ORIENT_QUATERNION) {
+ memcpy(rot_state->sampled_vals, raw_data,
+ sizeof(rot_state->sampled_vals));
+ dev_dbg(&indio_dev->dev, "Recd Quat len:%lu::%lu\n", raw_len,
+ sizeof(rot_state->sampled_vals));
+ }
+
+ return 0;
+}
+
+/* Parse report which is specific to an usage id*/
+static int dev_rot_parse_report(struct platform_device *pdev,
+ struct hid_sensor_hub_device *hsdev,
+ struct iio_chan_spec *channels,
+ unsigned usage_id,
+ struct dev_rot_state *st)
+{
+ int ret;
+
+ ret = sensor_hub_input_get_attribute_info(hsdev,
+ HID_INPUT_REPORT,
+ usage_id,
+ HID_USAGE_SENSOR_ORIENT_QUATERNION,
+ &st->quaternion);
+ if (ret)
+ return ret;
+ dev_rot_adjust_channel_bit_mask(&channels[0],
+ st->quaternion.size / MAX_QUATERNION_COMP);
+
+ dev_dbg(&pdev->dev, "dev_rot %x:%x\n", st->quaternion.index,
+ st->quaternion.report_id);
+
+ dev_dbg(&pdev->dev, "dev_rot: attrib size %d\n",
+ st->quaternion.size);
+
+ /* Set Sensitivity field ids, when there is no individual modifier */
+ if (st->common_attributes.sensitivity.index < 0) {
+ sensor_hub_input_get_attribute_info(hsdev,
+ HID_FEATURE_REPORT, usage_id,
+ HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
+ HID_USAGE_SENSOR_DATA_ORIENTATION,
+ &st->common_attributes.sensitivity);
+ dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
+ st->common_attributes.sensitivity.index,
+ st->common_attributes.sensitivity.report_id);
+ }
+ return 0;
+}
+
+/* Function to initialize the processing for usage id */
+static int hid_dev_rot_probe(struct platform_device *pdev)
+{
+ int ret;
+ static char *name = "dev_rotation";
+ struct iio_dev *indio_dev;
+ struct dev_rot_state *rot_state;
+ struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
+ struct iio_chan_spec *channels;
+
+ indio_dev = devm_iio_device_alloc(&pdev->dev,
+ sizeof(struct dev_rot_state));
+ if (indio_dev == NULL)
+ return -ENOMEM;
+
+ platform_set_drvdata(pdev, indio_dev);
+
+ rot_state = iio_priv(indio_dev);
+ rot_state->common_attributes.hsdev = hsdev;
+ rot_state->common_attributes.pdev = pdev;
+
+ ret = hid_sensor_parse_common_attributes(hsdev,
+ HID_USAGE_SENSOR_DEVICE_ORIENTATION,
+ &rot_state->common_attributes);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to setup common attributes\n");
+ return ret;
+ }
+
+ channels = kmemdup(dev_rot_channels, sizeof(dev_rot_channels),
+ GFP_KERNEL);
+ if (!channels) {
+ dev_err(&pdev->dev, "failed to duplicate channels\n");
+ return -ENOMEM;
+ }
+
+ ret = dev_rot_parse_report(pdev, hsdev, channels,
+ HID_USAGE_SENSOR_DEVICE_ORIENTATION, rot_state);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to setup attributes\n");
+ goto error_free_dev_mem;
+ }
+
+ indio_dev->channels = channels;
+ indio_dev->num_channels = ARRAY_SIZE(dev_rot_channels);
+ indio_dev->dev.parent = &pdev->dev;
+ indio_dev->info = &dev_rot_info;
+ indio_dev->name = name;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+
+ ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
+ NULL, NULL);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to initialize trigger buffer\n");
+ goto error_free_dev_mem;
+ }
+ rot_state->common_attributes.data_ready = false;
+ ret = hid_sensor_setup_trigger(indio_dev, name,
+ &rot_state->common_attributes);
+ if (ret) {
+ dev_err(&pdev->dev, "trigger setup failed\n");
+ goto error_unreg_buffer_funcs;
+ }
+
+ ret = iio_device_register(indio_dev);
+ if (ret) {
+ dev_err(&pdev->dev, "device register failed\n");
+ goto error_remove_trigger;
+ }
+
+ rot_state->callbacks.send_event = dev_rot_proc_event;
+ rot_state->callbacks.capture_sample = dev_rot_capture_sample;
+ rot_state->callbacks.pdev = pdev;
+ ret = sensor_hub_register_callback(hsdev,
+ HID_USAGE_SENSOR_DEVICE_ORIENTATION,
+ &rot_state->callbacks);
+ if (ret) {
+ dev_err(&pdev->dev, "callback reg failed\n");
+ goto error_iio_unreg;
+ }
+
+ return 0;
+
+error_iio_unreg:
+ iio_device_unregister(indio_dev);
+error_remove_trigger:
+ hid_sensor_remove_trigger(&rot_state->common_attributes);
+error_unreg_buffer_funcs:
+ iio_triggered_buffer_cleanup(indio_dev);
+error_free_dev_mem:
+ kfree(indio_dev->channels);
+ return ret;
+}
+
+/* Function to deinitialize the processing for usage id */
+static int hid_dev_rot_remove(struct platform_device *pdev)
+{
+ struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
+ struct iio_dev *indio_dev = platform_get_drvdata(pdev);
+ struct dev_rot_state *rot_state = iio_priv(indio_dev);
+
+ sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_DEVICE_ORIENTATION);
+ iio_device_unregister(indio_dev);
+ hid_sensor_remove_trigger(&rot_state->common_attributes);
+ iio_triggered_buffer_cleanup(indio_dev);
+ kfree(indio_dev->channels);
+
+ return 0;
+}
+
+static struct platform_device_id hid_dev_rot_ids[] = {
+ {
+ /* Format: HID-SENSOR-usage_id_in_hex_lowercase */
+ .name = "HID-SENSOR-20008a",
+ },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(platform, hid_dev_rot_ids);
+
+static struct platform_driver hid_dev_rot_platform_driver = {
+ .id_table = hid_dev_rot_ids,
+ .driver = {
+ .name = KBUILD_MODNAME,
+ .owner = THIS_MODULE,
+ },
+ .probe = hid_dev_rot_probe,
+ .remove = hid_dev_rot_remove,
+};
+module_platform_driver(hid_dev_rot_platform_driver);
+
+MODULE_DESCRIPTION("HID Sensor Device Rotation");
+MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
+MODULE_LICENSE("GPL");
diff --git a/include/linux/hid-sensor-ids.h b/include/linux/hid-sensor-ids.h
index beaf965..3fc44a0 100644
--- a/include/linux/hid-sensor-ids.h
+++ b/include/linux/hid-sensor-ids.h
@@ -66,6 +66,7 @@
#define HID_USAGE_SENSOR_ORIENT_TILT_Y 0x200480
#define HID_USAGE_SENSOR_ORIENT_TILT_Z 0x200481
+#define HID_USAGE_SENSOR_DEVICE_ORIENTATION 0x20008A
#define HID_USAGE_SENSOR_ORIENT_ROTATION_MATRIX 0x200482
#define HID_USAGE_SENSOR_ORIENT_QUATERNION 0x200483
#define HID_USAGE_SENSOR_ORIENT_MAGN_FLUX 0x200484
--
1.8.3.2
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH v1 5/5] iio: Added ABI description for quaternion
2014-02-23 19:50 [PATCH v1 1/5] IIO: core: Introduce read_raw_multi Srinivas Pandruvada
` (2 preceding siblings ...)
2014-02-23 19:50 ` [PATCH v1 4/5] iio: hid-sensors: Added device rotation support Srinivas Pandruvada
@ 2014-02-23 19:50 ` Srinivas Pandruvada
2014-03-29 11:15 ` [PATCH v1 1/5] IIO: core: Introduce read_raw_multi Jonathan Cameron
4 siblings, 0 replies; 11+ messages in thread
From: Srinivas Pandruvada @ 2014-02-23 19:50 UTC (permalink / raw)
To: jic23; +Cc: linux-iio, Srinivas Pandruvada
Added documentation for reading quaternion components for 3D rotations.
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
Documentation/ABI/testing/sysfs-bus-iio | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/Documentation/ABI/testing/sysfs-bus-iio b/Documentation/ABI/testing/sysfs-bus-iio
index 6e02c50..8daa91a 100644
--- a/Documentation/ABI/testing/sysfs-bus-iio
+++ b/Documentation/ABI/testing/sysfs-bus-iio
@@ -891,3 +891,12 @@ Contact: linux-iio@vger.kernel.org
Description:
This attribute is used to get/set the integration time in
seconds.
+
+What: /sys/bus/iio/devices/iio:deviceX/in_rotquaternion_raw
+KernelVersion: 3.15
+Contact: linux-iio@vger.kernel.org
+Description:
+ Raw value of quaternion components using a format
+ x:y:z:w. Here x, y, and z component represents the axis about
+ which a rotation will occur and w component represents the
+ amount of rotation.
--
1.8.3.2
^ permalink raw reply related [flat|nested] 11+ messages in thread
* Re: [PATCH v1 1/5] IIO: core: Introduce read_raw_multi
2014-02-23 19:50 [PATCH v1 1/5] IIO: core: Introduce read_raw_multi Srinivas Pandruvada
` (3 preceding siblings ...)
2014-02-23 19:50 ` [PATCH v1 5/5] iio: Added ABI description for quaternion Srinivas Pandruvada
@ 2014-03-29 11:15 ` Jonathan Cameron
2014-04-04 21:38 ` Srinivas Pandruvada
4 siblings, 1 reply; 11+ messages in thread
From: Jonathan Cameron @ 2014-03-29 11:15 UTC (permalink / raw)
To: Srinivas Pandruvada; +Cc: linux-iio
On 23/02/14 19:50, Srinivas Pandruvada wrote:
> This callback is introduced to overcome some limitations of existing
> read_raw callback. The functionality of both existing read_raw and
> read_raw_multi is similar, both are used to request values from the
> device. The current read_raw callback allows only two return values.
> The new read_raw_multi allows returning multiple values. Instead of
> passing just address of val and val2, it passes length and pointer
> to values. Depending on the type and length of passed buffer, iio
> client drivers can return multiple values.
>
> Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
Hi Srinivas.
Whilst it wasn't the most in depth of discussions, I think the outcome
of the 'how to handle quaternion sysfs naming' element of the
thread.
[RFC] IIO: New interfaces for 'interesting' channel types.
was that we should do them as a modifier instead of a new channel type.
e.g.
in_rot_quaternion_raw
etc.
Could you convert this driver over and repost?
If you disagree, then feel free to contribute to that discussion and
we'll continue from there.
Sorry this took so long to sort out, I was hoping for a few more inputs
but there we are...
Jonathan
> ---
> drivers/iio/iio_core.h | 2 +-
> drivers/iio/industrialio-core.c | 51 +++++++++++++++++++++++-----------------
> drivers/iio/industrialio-event.c | 6 +++--
> drivers/iio/inkern.c | 15 ++++++++++--
> include/linux/iio/iio.h | 16 +++++++++++++
> 5 files changed, 63 insertions(+), 27 deletions(-)
>
> diff --git a/drivers/iio/iio_core.h b/drivers/iio/iio_core.h
> index f6db6af..4172f22 100644
> --- a/drivers/iio/iio_core.h
> +++ b/drivers/iio/iio_core.h
> @@ -35,7 +35,7 @@ int __iio_add_chan_devattr(const char *postfix,
> struct list_head *attr_list);
> void iio_free_chan_devattr_list(struct list_head *attr_list);
>
> -ssize_t iio_format_value(char *buf, unsigned int type, int val, int val2);
> +ssize_t iio_format_value(char *buf, unsigned int type, int *val);
>
> /* Event interface flags */
> #define IIO_BUSY_BIT_POS 1
> diff --git a/drivers/iio/industrialio-core.c b/drivers/iio/industrialio-core.c
> index acc911a..b1225a4 100644
> --- a/drivers/iio/industrialio-core.c
> +++ b/drivers/iio/industrialio-core.c
> @@ -373,41 +373,42 @@ EXPORT_SYMBOL_GPL(iio_enum_write);
> * @buf: The buffer to which the formated value gets written
> * @type: One of the IIO_VAL_... constants. This decides how the val and val2
> * parameters are formatted.
> - * @val: First part of the value, exact meaning depends on the type parameter.
> - * @val2: Second part of the value, exact meaning depends on the type parameter.
> + * @vals: pointer to the values, exact meaning depends on the type parameter.
> */
> -ssize_t iio_format_value(char *buf, unsigned int type, int val, int val2)
> +ssize_t iio_format_value(char *buf, unsigned int type, int *vals)
> {
> unsigned long long tmp;
> bool scale_db = false;
>
> switch (type) {
> case IIO_VAL_INT:
> - return sprintf(buf, "%d\n", val);
> + return sprintf(buf, "%d\n", vals[0]);
> case IIO_VAL_INT_PLUS_MICRO_DB:
> scale_db = true;
> case IIO_VAL_INT_PLUS_MICRO:
> - if (val2 < 0)
> - return sprintf(buf, "-%ld.%06u%s\n", abs(val), -val2,
> + if (vals[1] < 0)
> + return sprintf(buf, "-%ld.%06u%s\n", abs(vals[0]),
> + -vals[1],
> scale_db ? " dB" : "");
> else
> - return sprintf(buf, "%d.%06u%s\n", val, val2,
> + return sprintf(buf, "%d.%06u%s\n", vals[0], vals[1],
> scale_db ? " dB" : "");
> case IIO_VAL_INT_PLUS_NANO:
> - if (val2 < 0)
> - return sprintf(buf, "-%ld.%09u\n", abs(val), -val2);
> + if (vals[1] < 0)
> + return sprintf(buf, "-%ld.%09u\n", abs(vals[0]),
> + -vals[1]);
> else
> - return sprintf(buf, "%d.%09u\n", val, val2);
> + return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
> case IIO_VAL_FRACTIONAL:
> - tmp = div_s64((s64)val * 1000000000LL, val2);
> - val2 = do_div(tmp, 1000000000LL);
> - val = tmp;
> - return sprintf(buf, "%d.%09u\n", val, val2);
> + tmp = div_s64((s64)vals[0] * 1000000000LL, vals[1]);
> + vals[1] = do_div(tmp, 1000000000LL);
> + vals[0] = tmp;
> + return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
> case IIO_VAL_FRACTIONAL_LOG2:
> - tmp = (s64)val * 1000000000LL >> val2;
> - val2 = do_div(tmp, 1000000000LL);
> - val = tmp;
> - return sprintf(buf, "%d.%09u\n", val, val2);
> + tmp = (s64)vals[0] * 1000000000LL >> vals[1];
> + vals[1] = do_div(tmp, 1000000000LL);
> + vals[0] = tmp;
> + return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
> default:
> return 0;
> }
> @@ -419,14 +420,20 @@ static ssize_t iio_read_channel_info(struct device *dev,
> {
> struct iio_dev *indio_dev = dev_to_iio_dev(dev);
> struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
> - int val, val2;
> - int ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
> - &val, &val2, this_attr->address);
> + int vals[INDIO_MAX_RAW_ELEMENTS];
> + int ret;
> +
> + if (indio_dev->info->read_raw_multi)
> + ret = indio_dev->info->read_raw_multi(indio_dev, this_attr->c,
> + INDIO_MAX_RAW_ELEMENTS, vals, this_attr->address);
> + else
> + ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
> + &vals[0], &vals[1], this_attr->address);
>
> if (ret < 0)
> return ret;
>
> - return iio_format_value(buf, ret, val, val2);
> + return iio_format_value(buf, ret, vals);
> }
>
> /**
> diff --git a/drivers/iio/industrialio-event.c b/drivers/iio/industrialio-event.c
> index c9c1419..0f7f78e 100644
> --- a/drivers/iio/industrialio-event.c
> +++ b/drivers/iio/industrialio-event.c
> @@ -272,7 +272,7 @@ static ssize_t iio_ev_value_show(struct device *dev,
> {
> struct iio_dev *indio_dev = dev_to_iio_dev(dev);
> struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
> - int val, val2;
> + int val, val2, val_arr[2];
> int ret;
>
> ret = indio_dev->info->read_event_value(indio_dev,
> @@ -281,7 +281,9 @@ static ssize_t iio_ev_value_show(struct device *dev,
> &val, &val2);
> if (ret < 0)
> return ret;
> - return iio_format_value(buf, ret, val, val2);
> + val_arr[0] = val;
> + val_arr[1] = val2;
> + return iio_format_value(buf, ret, val_arr);
> }
>
> static ssize_t iio_ev_value_store(struct device *dev,
> diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c
> index 0cf5f8e..6a93d57 100644
> --- a/drivers/iio/inkern.c
> +++ b/drivers/iio/inkern.c
> @@ -417,12 +417,23 @@ static int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
> enum iio_chan_info_enum info)
> {
> int unused;
> + int vals[INDIO_MAX_RAW_ELEMENTS];
> + int ret;
>
> if (val2 == NULL)
> val2 = &unused;
>
> - return chan->indio_dev->info->read_raw(chan->indio_dev, chan->channel,
> - val, val2, info);
> + if (chan->indio_dev->info->read_raw_multi) {
> + ret = chan->indio_dev->info->read_raw_multi(chan->indio_dev,
> + chan->channel, INDIO_MAX_RAW_ELEMENTS,
> + vals, info);
> + *val = vals[0];
> + *val2 = vals[1];
> + } else
> + ret = chan->indio_dev->info->read_raw(chan->indio_dev,
> + chan->channel, val, val2, info);
> +
> + return ret;
> }
>
> int iio_read_channel_raw(struct iio_channel *chan, int *val)
> diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
> index 75a8a20..ddf9f60 100644
> --- a/include/linux/iio/iio.h
> +++ b/include/linux/iio/iio.h
> @@ -284,6 +284,8 @@ static inline s64 iio_get_time_ns(void)
> #define INDIO_ALL_BUFFER_MODES \
> (INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE)
>
> +#define INDIO_MAX_RAW_ELEMENTS 4
> +
> struct iio_trigger; /* forward declaration */
> struct iio_dev;
>
> @@ -298,6 +300,14 @@ struct iio_dev;
> * 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.
> + * @read_raw_multi: function to return values 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. vals pointer
> + * contain the elements making up the returned value.
> + * val_len specifies maximum number of elements
> + * vals pointer can contain. In contrast to to read_raw
> + * device can return multiple values not just two.
> * @write_raw: function to write a value to the device.
> * Parameters are the same as for read_raw.
> * @write_raw_get_fmt: callback function to query the expected
> @@ -324,6 +334,12 @@ struct iio_info {
> int *val2,
> long mask);
>
> + int (*read_raw_multi)(struct iio_dev *indio_dev,
> + struct iio_chan_spec const *chan,
> + int val_len,
> + int *vals,
> + long mask);
> +
> int (*write_raw)(struct iio_dev *indio_dev,
> struct iio_chan_spec const *chan,
> int val,
>
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH v1 1/5] IIO: core: Introduce read_raw_multi
2014-03-29 11:15 ` [PATCH v1 1/5] IIO: core: Introduce read_raw_multi Jonathan Cameron
@ 2014-04-04 21:38 ` Srinivas Pandruvada
2014-04-05 10:07 ` Jonathan Cameron
0 siblings, 1 reply; 11+ messages in thread
From: Srinivas Pandruvada @ 2014-04-04 21:38 UTC (permalink / raw)
To: Jonathan Cameron; +Cc: linux-iio
On 03/29/2014 04:15 AM, Jonathan Cameron wrote:
> On 23/02/14 19:50, Srinivas Pandruvada wrote:
>> This callback is introduced to overcome some limitations of existing
>> read_raw callback. The functionality of both existing read_raw and
>> read_raw_multi is similar, both are used to request values from the
>> device. The current read_raw callback allows only two return values.
>> The new read_raw_multi allows returning multiple values. Instead of
>> passing just address of val and val2, it passes length and pointer
>> to values. Depending on the type and length of passed buffer, iio
>> client drivers can return multiple values.
>>
>> Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
> Hi Srinivas.
>
> Whilst it wasn't the most in depth of discussions, I think the outcome
> of the 'how to handle quaternion sysfs naming' element of the
> thread.
> [RFC] IIO: New interfaces for 'interesting' channel types.
>
> was that we should do them as a modifier instead of a new channel type.
> e.g.
>
> in_rot_quaternion_raw
> etc.
>
> Could you convert this driver over and repost?
>
> If you disagree, then feel free to contribute to that discussion and
> we'll continue from there.
>
> Sorry this took so long to sort out, I was hoping for a few more inputs
> but there we are...
>
Hi Jonathan,
I have resubmitted with the modifier for quaternion dropping this patch.
I only allow buffered mode as without this patch representing in raw mode
all four component is not possible. Current applications only is using
buffer mode.
So I can wait for core support something similar to this patch.
Thanks,
Srinivas
> Jonathan
>> ---
>> drivers/iio/iio_core.h | 2 +-
>> drivers/iio/industrialio-core.c | 51
>> +++++++++++++++++++++++-----------------
>> drivers/iio/industrialio-event.c | 6 +++--
>> drivers/iio/inkern.c | 15 ++++++++++--
>> include/linux/iio/iio.h | 16 +++++++++++++
>> 5 files changed, 63 insertions(+), 27 deletions(-)
>>
>> diff --git a/drivers/iio/iio_core.h b/drivers/iio/iio_core.h
>> index f6db6af..4172f22 100644
>> --- a/drivers/iio/iio_core.h
>> +++ b/drivers/iio/iio_core.h
>> @@ -35,7 +35,7 @@ int __iio_add_chan_devattr(const char *postfix,
>> struct list_head *attr_list);
>> void iio_free_chan_devattr_list(struct list_head *attr_list);
>>
>> -ssize_t iio_format_value(char *buf, unsigned int type, int val, int
>> val2);
>> +ssize_t iio_format_value(char *buf, unsigned int type, int *val);
>>
>> /* Event interface flags */
>> #define IIO_BUSY_BIT_POS 1
>> diff --git a/drivers/iio/industrialio-core.c
>> b/drivers/iio/industrialio-core.c
>> index acc911a..b1225a4 100644
>> --- a/drivers/iio/industrialio-core.c
>> +++ b/drivers/iio/industrialio-core.c
>> @@ -373,41 +373,42 @@ EXPORT_SYMBOL_GPL(iio_enum_write);
>> * @buf: The buffer to which the formated value gets written
>> * @type: One of the IIO_VAL_... constants. This decides how the
>> val and val2
>> * parameters are formatted.
>> - * @val: First part of the value, exact meaning depends on the type
>> parameter.
>> - * @val2: Second part of the value, exact meaning depends on the
>> type parameter.
>> + * @vals: pointer to the values, exact meaning depends on the type
>> parameter.
>> */
>> -ssize_t iio_format_value(char *buf, unsigned int type, int val, int
>> val2)
>> +ssize_t iio_format_value(char *buf, unsigned int type, int *vals)
>> {
>> unsigned long long tmp;
>> bool scale_db = false;
>>
>> switch (type) {
>> case IIO_VAL_INT:
>> - return sprintf(buf, "%d\n", val);
>> + return sprintf(buf, "%d\n", vals[0]);
>> case IIO_VAL_INT_PLUS_MICRO_DB:
>> scale_db = true;
>> case IIO_VAL_INT_PLUS_MICRO:
>> - if (val2 < 0)
>> - return sprintf(buf, "-%ld.%06u%s\n", abs(val), -val2,
>> + if (vals[1] < 0)
>> + return sprintf(buf, "-%ld.%06u%s\n", abs(vals[0]),
>> + -vals[1],
>> scale_db ? " dB" : "");
>> else
>> - return sprintf(buf, "%d.%06u%s\n", val, val2,
>> + return sprintf(buf, "%d.%06u%s\n", vals[0], vals[1],
>> scale_db ? " dB" : "");
>> case IIO_VAL_INT_PLUS_NANO:
>> - if (val2 < 0)
>> - return sprintf(buf, "-%ld.%09u\n", abs(val), -val2);
>> + if (vals[1] < 0)
>> + return sprintf(buf, "-%ld.%09u\n", abs(vals[0]),
>> + -vals[1]);
>> else
>> - return sprintf(buf, "%d.%09u\n", val, val2);
>> + return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
>> case IIO_VAL_FRACTIONAL:
>> - tmp = div_s64((s64)val * 1000000000LL, val2);
>> - val2 = do_div(tmp, 1000000000LL);
>> - val = tmp;
>> - return sprintf(buf, "%d.%09u\n", val, val2);
>> + tmp = div_s64((s64)vals[0] * 1000000000LL, vals[1]);
>> + vals[1] = do_div(tmp, 1000000000LL);
>> + vals[0] = tmp;
>> + return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
>> case IIO_VAL_FRACTIONAL_LOG2:
>> - tmp = (s64)val * 1000000000LL >> val2;
>> - val2 = do_div(tmp, 1000000000LL);
>> - val = tmp;
>> - return sprintf(buf, "%d.%09u\n", val, val2);
>> + tmp = (s64)vals[0] * 1000000000LL >> vals[1];
>> + vals[1] = do_div(tmp, 1000000000LL);
>> + vals[0] = tmp;
>> + return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
>> default:
>> return 0;
>> }
>> @@ -419,14 +420,20 @@ static ssize_t iio_read_channel_info(struct
>> device *dev,
>> {
>> struct iio_dev *indio_dev = dev_to_iio_dev(dev);
>> struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
>> - int val, val2;
>> - int ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
>> - &val, &val2, this_attr->address);
>> + int vals[INDIO_MAX_RAW_ELEMENTS];
>> + int ret;
>> +
>> + if (indio_dev->info->read_raw_multi)
>> + ret = indio_dev->info->read_raw_multi(indio_dev, this_attr->c,
>> + INDIO_MAX_RAW_ELEMENTS, vals, this_attr->address);
>> + else
>> + ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
>> + &vals[0], &vals[1], this_attr->address);
>>
>> if (ret < 0)
>> return ret;
>>
>> - return iio_format_value(buf, ret, val, val2);
>> + return iio_format_value(buf, ret, vals);
>> }
>>
>> /**
>> diff --git a/drivers/iio/industrialio-event.c
>> b/drivers/iio/industrialio-event.c
>> index c9c1419..0f7f78e 100644
>> --- a/drivers/iio/industrialio-event.c
>> +++ b/drivers/iio/industrialio-event.c
>> @@ -272,7 +272,7 @@ static ssize_t iio_ev_value_show(struct device *dev,
>> {
>> struct iio_dev *indio_dev = dev_to_iio_dev(dev);
>> struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
>> - int val, val2;
>> + int val, val2, val_arr[2];
>> int ret;
>>
>> ret = indio_dev->info->read_event_value(indio_dev,
>> @@ -281,7 +281,9 @@ static ssize_t iio_ev_value_show(struct device *dev,
>> &val, &val2);
>> if (ret < 0)
>> return ret;
>> - return iio_format_value(buf, ret, val, val2);
>> + val_arr[0] = val;
>> + val_arr[1] = val2;
>> + return iio_format_value(buf, ret, val_arr);
>> }
>>
>> static ssize_t iio_ev_value_store(struct device *dev,
>> diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c
>> index 0cf5f8e..6a93d57 100644
>> --- a/drivers/iio/inkern.c
>> +++ b/drivers/iio/inkern.c
>> @@ -417,12 +417,23 @@ static int iio_channel_read(struct iio_channel
>> *chan, int *val, int *val2,
>> enum iio_chan_info_enum info)
>> {
>> int unused;
>> + int vals[INDIO_MAX_RAW_ELEMENTS];
>> + int ret;
>>
>> if (val2 == NULL)
>> val2 = &unused;
>>
>> - return chan->indio_dev->info->read_raw(chan->indio_dev,
>> chan->channel,
>> - val, val2, info);
>> + if (chan->indio_dev->info->read_raw_multi) {
>> + ret = chan->indio_dev->info->read_raw_multi(chan->indio_dev,
>> + chan->channel, INDIO_MAX_RAW_ELEMENTS,
>> + vals, info);
>> + *val = vals[0];
>> + *val2 = vals[1];
>> + } else
>> + ret = chan->indio_dev->info->read_raw(chan->indio_dev,
>> + chan->channel, val, val2, info);
>> +
>> + return ret;
>> }
>>
>> int iio_read_channel_raw(struct iio_channel *chan, int *val)
>> diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
>> index 75a8a20..ddf9f60 100644
>> --- a/include/linux/iio/iio.h
>> +++ b/include/linux/iio/iio.h
>> @@ -284,6 +284,8 @@ static inline s64 iio_get_time_ns(void)
>> #define INDIO_ALL_BUFFER_MODES \
>> (INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE)
>>
>> +#define INDIO_MAX_RAW_ELEMENTS 4
>> +
>> struct iio_trigger; /* forward declaration */
>> struct iio_dev;
>>
>> @@ -298,6 +300,14 @@ struct iio_dev;
>> * 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.
>> + * @read_raw_multi: function to return values 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. vals pointer
>> + * contain the elements making up the returned value.
>> + * val_len specifies maximum number of elements
>> + * vals pointer can contain. In contrast to to read_raw
>> + * device can return multiple values not just two.
>> * @write_raw: function to write a value to the device.
>> * Parameters are the same as for read_raw.
>> * @write_raw_get_fmt: callback function to query the expected
>> @@ -324,6 +334,12 @@ struct iio_info {
>> int *val2,
>> long mask);
>>
>> + int (*read_raw_multi)(struct iio_dev *indio_dev,
>> + struct iio_chan_spec const *chan,
>> + int val_len,
>> + int *vals,
>> + long mask);
>> +
>> int (*write_raw)(struct iio_dev *indio_dev,
>> struct iio_chan_spec const *chan,
>> int val,
>>
>
>
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH v1 1/5] IIO: core: Introduce read_raw_multi
2014-04-04 21:38 ` Srinivas Pandruvada
@ 2014-04-05 10:07 ` Jonathan Cameron
2014-04-07 16:05 ` [PATCH] iio: Add Freescale MMA8452Q 3-axis accelerometer driver gmane
0 siblings, 1 reply; 11+ messages in thread
From: Jonathan Cameron @ 2014-04-05 10:07 UTC (permalink / raw)
To: Srinivas Pandruvada; +Cc: linux-iio
On 04/04/14 22:38, Srinivas Pandruvada wrote:
> On 03/29/2014 04:15 AM, Jonathan Cameron wrote:
>> On 23/02/14 19:50, Srinivas Pandruvada wrote:
>>> This callback is introduced to overcome some limitations of existing
>>> read_raw callback. The functionality of both existing read_raw and
>>> read_raw_multi is similar, both are used to request values from the
>>> device. The current read_raw callback allows only two return values.
>>> The new read_raw_multi allows returning multiple values. Instead of
>>> passing just address of val and val2, it passes length and pointer
>>> to values. Depending on the type and length of passed buffer, iio
>>> client drivers can return multiple values.
>>>
>>> Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
>> Hi Srinivas.
>>
>> Whilst it wasn't the most in depth of discussions, I think the outcome
>> of the 'how to handle quaternion sysfs naming' element of the
>> thread.
>> [RFC] IIO: New interfaces for 'interesting' channel types.
>>
>> was that we should do them as a modifier instead of a new channel type.
>> e.g.
>>
>> in_rot_quaternion_raw
>> etc.
>>
>> Could you convert this driver over and repost?
>>
>> If you disagree, then feel free to contribute to that discussion and
>> we'll continue from there.
>>
>> Sorry this took so long to sort out, I was hoping for a few more inputs
>> but there we are...
>>
> Hi Jonathan,
>
> I have resubmitted with the modifier for quaternion dropping this patch.
> I only allow buffered mode as without this patch representing in raw mode
> all four component is not possible. Current applications only is using buffer mode.
> So I can wait for core support something similar to this patch.
>
> Thanks,
> Srinivas
Hi Srinivas,
I'm a bit lost on this. I was quite happy with this patch and can't immediately
see why the change to using a modifier requires dropping it?
It just makes for slightly different handling in the read_raw_multi call inside
the driver itself...
or am I missing something...
Jonathan
>
>
>
>
>> Jonathan
>>> ---
>>> drivers/iio/iio_core.h | 2 +-
>>> drivers/iio/industrialio-core.c | 51 +++++++++++++++++++++++-----------------
>>> drivers/iio/industrialio-event.c | 6 +++--
>>> drivers/iio/inkern.c | 15 ++++++++++--
>>> include/linux/iio/iio.h | 16 +++++++++++++
>>> 5 files changed, 63 insertions(+), 27 deletions(-)
>>>
>>> diff --git a/drivers/iio/iio_core.h b/drivers/iio/iio_core.h
>>> index f6db6af..4172f22 100644
>>> --- a/drivers/iio/iio_core.h
>>> +++ b/drivers/iio/iio_core.h
>>> @@ -35,7 +35,7 @@ int __iio_add_chan_devattr(const char *postfix,
>>> struct list_head *attr_list);
>>> void iio_free_chan_devattr_list(struct list_head *attr_list);
>>>
>>> -ssize_t iio_format_value(char *buf, unsigned int type, int val, int val2);
>>> +ssize_t iio_format_value(char *buf, unsigned int type, int *val);
>>>
>>> /* Event interface flags */
>>> #define IIO_BUSY_BIT_POS 1
>>> diff --git a/drivers/iio/industrialio-core.c b/drivers/iio/industrialio-core.c
>>> index acc911a..b1225a4 100644
>>> --- a/drivers/iio/industrialio-core.c
>>> +++ b/drivers/iio/industrialio-core.c
>>> @@ -373,41 +373,42 @@ EXPORT_SYMBOL_GPL(iio_enum_write);
>>> * @buf: The buffer to which the formated value gets written
>>> * @type: One of the IIO_VAL_... constants. This decides how the val and val2
>>> * parameters are formatted.
>>> - * @val: First part of the value, exact meaning depends on the type parameter.
>>> - * @val2: Second part of the value, exact meaning depends on the type parameter.
>>> + * @vals: pointer to the values, exact meaning depends on the type parameter.
>>> */
>>> -ssize_t iio_format_value(char *buf, unsigned int type, int val, int val2)
>>> +ssize_t iio_format_value(char *buf, unsigned int type, int *vals)
>>> {
>>> unsigned long long tmp;
>>> bool scale_db = false;
>>>
>>> switch (type) {
>>> case IIO_VAL_INT:
>>> - return sprintf(buf, "%d\n", val);
>>> + return sprintf(buf, "%d\n", vals[0]);
>>> case IIO_VAL_INT_PLUS_MICRO_DB:
>>> scale_db = true;
>>> case IIO_VAL_INT_PLUS_MICRO:
>>> - if (val2 < 0)
>>> - return sprintf(buf, "-%ld.%06u%s\n", abs(val), -val2,
>>> + if (vals[1] < 0)
>>> + return sprintf(buf, "-%ld.%06u%s\n", abs(vals[0]),
>>> + -vals[1],
>>> scale_db ? " dB" : "");
>>> else
>>> - return sprintf(buf, "%d.%06u%s\n", val, val2,
>>> + return sprintf(buf, "%d.%06u%s\n", vals[0], vals[1],
>>> scale_db ? " dB" : "");
>>> case IIO_VAL_INT_PLUS_NANO:
>>> - if (val2 < 0)
>>> - return sprintf(buf, "-%ld.%09u\n", abs(val), -val2);
>>> + if (vals[1] < 0)
>>> + return sprintf(buf, "-%ld.%09u\n", abs(vals[0]),
>>> + -vals[1]);
>>> else
>>> - return sprintf(buf, "%d.%09u\n", val, val2);
>>> + return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
>>> case IIO_VAL_FRACTIONAL:
>>> - tmp = div_s64((s64)val * 1000000000LL, val2);
>>> - val2 = do_div(tmp, 1000000000LL);
>>> - val = tmp;
>>> - return sprintf(buf, "%d.%09u\n", val, val2);
>>> + tmp = div_s64((s64)vals[0] * 1000000000LL, vals[1]);
>>> + vals[1] = do_div(tmp, 1000000000LL);
>>> + vals[0] = tmp;
>>> + return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
>>> case IIO_VAL_FRACTIONAL_LOG2:
>>> - tmp = (s64)val * 1000000000LL >> val2;
>>> - val2 = do_div(tmp, 1000000000LL);
>>> - val = tmp;
>>> - return sprintf(buf, "%d.%09u\n", val, val2);
>>> + tmp = (s64)vals[0] * 1000000000LL >> vals[1];
>>> + vals[1] = do_div(tmp, 1000000000LL);
>>> + vals[0] = tmp;
>>> + return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
>>> default:
>>> return 0;
>>> }
>>> @@ -419,14 +420,20 @@ static ssize_t iio_read_channel_info(struct device *dev,
>>> {
>>> struct iio_dev *indio_dev = dev_to_iio_dev(dev);
>>> struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
>>> - int val, val2;
>>> - int ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
>>> - &val, &val2, this_attr->address);
>>> + int vals[INDIO_MAX_RAW_ELEMENTS];
>>> + int ret;
>>> +
>>> + if (indio_dev->info->read_raw_multi)
>>> + ret = indio_dev->info->read_raw_multi(indio_dev, this_attr->c,
>>> + INDIO_MAX_RAW_ELEMENTS, vals, this_attr->address);
>>> + else
>>> + ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
>>> + &vals[0], &vals[1], this_attr->address);
>>>
>>> if (ret < 0)
>>> return ret;
>>>
>>> - return iio_format_value(buf, ret, val, val2);
>>> + return iio_format_value(buf, ret, vals);
>>> }
>>>
>>> /**
>>> diff --git a/drivers/iio/industrialio-event.c b/drivers/iio/industrialio-event.c
>>> index c9c1419..0f7f78e 100644
>>> --- a/drivers/iio/industrialio-event.c
>>> +++ b/drivers/iio/industrialio-event.c
>>> @@ -272,7 +272,7 @@ static ssize_t iio_ev_value_show(struct device *dev,
>>> {
>>> struct iio_dev *indio_dev = dev_to_iio_dev(dev);
>>> struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
>>> - int val, val2;
>>> + int val, val2, val_arr[2];
>>> int ret;
>>>
>>> ret = indio_dev->info->read_event_value(indio_dev,
>>> @@ -281,7 +281,9 @@ static ssize_t iio_ev_value_show(struct device *dev,
>>> &val, &val2);
>>> if (ret < 0)
>>> return ret;
>>> - return iio_format_value(buf, ret, val, val2);
>>> + val_arr[0] = val;
>>> + val_arr[1] = val2;
>>> + return iio_format_value(buf, ret, val_arr);
>>> }
>>>
>>> static ssize_t iio_ev_value_store(struct device *dev,
>>> diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c
>>> index 0cf5f8e..6a93d57 100644
>>> --- a/drivers/iio/inkern.c
>>> +++ b/drivers/iio/inkern.c
>>> @@ -417,12 +417,23 @@ static int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
>>> enum iio_chan_info_enum info)
>>> {
>>> int unused;
>>> + int vals[INDIO_MAX_RAW_ELEMENTS];
>>> + int ret;
>>>
>>> if (val2 == NULL)
>>> val2 = &unused;
>>>
>>> - return chan->indio_dev->info->read_raw(chan->indio_dev, chan->channel,
>>> - val, val2, info);
>>> + if (chan->indio_dev->info->read_raw_multi) {
>>> + ret = chan->indio_dev->info->read_raw_multi(chan->indio_dev,
>>> + chan->channel, INDIO_MAX_RAW_ELEMENTS,
>>> + vals, info);
>>> + *val = vals[0];
>>> + *val2 = vals[1];
>>> + } else
>>> + ret = chan->indio_dev->info->read_raw(chan->indio_dev,
>>> + chan->channel, val, val2, info);
>>> +
>>> + return ret;
>>> }
>>>
>>> int iio_read_channel_raw(struct iio_channel *chan, int *val)
>>> diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
>>> index 75a8a20..ddf9f60 100644
>>> --- a/include/linux/iio/iio.h
>>> +++ b/include/linux/iio/iio.h
>>> @@ -284,6 +284,8 @@ static inline s64 iio_get_time_ns(void)
>>> #define INDIO_ALL_BUFFER_MODES \
>>> (INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE)
>>>
>>> +#define INDIO_MAX_RAW_ELEMENTS 4
>>> +
>>> struct iio_trigger; /* forward declaration */
>>> struct iio_dev;
>>>
>>> @@ -298,6 +300,14 @@ struct iio_dev;
>>> * 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.
>>> + * @read_raw_multi: function to return values 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. vals pointer
>>> + * contain the elements making up the returned value.
>>> + * val_len specifies maximum number of elements
>>> + * vals pointer can contain. In contrast to to read_raw
>>> + * device can return multiple values not just two.
>>> * @write_raw: function to write a value to the device.
>>> * Parameters are the same as for read_raw.
>>> * @write_raw_get_fmt: callback function to query the expected
>>> @@ -324,6 +334,12 @@ struct iio_info {
>>> int *val2,
>>> long mask);
>>>
>>> + int (*read_raw_multi)(struct iio_dev *indio_dev,
>>> + struct iio_chan_spec const *chan,
>>> + int val_len,
>>> + int *vals,
>>> + long mask);
>>> +
>>> int (*write_raw)(struct iio_dev *indio_dev,
>>> struct iio_chan_spec const *chan,
>>> int val,
>>>
>>
>>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-iio" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] iio: Add Freescale MMA8452Q 3-axis accelerometer driver
2014-04-05 10:07 ` Jonathan Cameron
@ 2014-04-07 16:05 ` gmane
2014-04-07 16:26 ` Jonathan Cameron
0 siblings, 1 reply; 11+ messages in thread
From: gmane @ 2014-04-07 16:05 UTC (permalink / raw)
To: linux-iio; +Cc: Jonathan Cameron, pmeerw
Hi,
I just stumbled across this [1] and was wondering if this patch made it
into some tree.
Regards,
Robert
[1] http://thread.gmane.org/gmane.linux.kernel.iio/10876
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] iio: Add Freescale MMA8452Q 3-axis accelerometer driver
2014-04-07 16:05 ` [PATCH] iio: Add Freescale MMA8452Q 3-axis accelerometer driver gmane
@ 2014-04-07 16:26 ` Jonathan Cameron
2014-04-07 16:32 ` Peter Meerwald
0 siblings, 1 reply; 11+ messages in thread
From: Jonathan Cameron @ 2014-04-07 16:26 UTC (permalink / raw)
To: gmane, linux-iio; +Cc: pmeerw
Nope. I guess Peter never had a chance to get back to it. I had forgotten about it entirely...
On April 7, 2014 5:05:36 PM GMT+01:00, gmane@reliableembeddedsystems.com wrote:
>Hi,
>
>I just stumbled across this [1] and was wondering if this patch made it
>
>into some tree.
>
>Regards,
>
>Robert
>
>[1] http://thread.gmane.org/gmane.linux.kernel.iio/10876
>--
>To unsubscribe from this list: send the line "unsubscribe linux-iio" in
>the body of a message to majordomo@vger.kernel.org
>More majordomo info at http://vger.kernel.org/majordomo-info.html
--
Sent from my Android phone with K-9 Mail. Please excuse my brevity.
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH] iio: Add Freescale MMA8452Q 3-axis accelerometer driver
2014-04-07 16:26 ` Jonathan Cameron
@ 2014-04-07 16:32 ` Peter Meerwald
0 siblings, 0 replies; 11+ messages in thread
From: Peter Meerwald @ 2014-04-07 16:32 UTC (permalink / raw)
To: Jonathan Cameron; +Cc: gmane, linux-iio
Hi,
> Nope. I guess Peter never had a chance to get back to it. I had forgotten about it entirely...
I think there were some minor comments; I'll try to clean them up and
resubmit shortly
regards, p.
> >I just stumbled across this [1] and was wondering if this patch made it
> >
> >into some tree.
> >
> >Regards,
> >
> >Robert
> >
> >[1] http://thread.gmane.org/gmane.linux.kernel.iio/10876
> >--
> >To unsubscribe from this list: send the line "unsubscribe linux-iio" in
> >the body of a message to majordomo@vger.kernel.org
> >More majordomo info at http://vger.kernel.org/majordomo-info.html
>
>
--
Peter Meerwald
+43-664-2444418 (mobile)
^ permalink raw reply [flat|nested] 11+ messages in thread
end of thread, other threads:[~2014-04-07 16:32 UTC | newest]
Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-02-23 19:50 [PATCH v1 1/5] IIO: core: Introduce read_raw_multi Srinivas Pandruvada
2014-02-23 19:50 ` [PATCH v1 2/5] IIO: core: Modify scan element type Srinivas Pandruvada
2014-02-23 19:50 ` [PATCH v1 3/5] IIO: core: Introduce Quaternion types Srinivas Pandruvada
2014-02-23 19:50 ` [PATCH v1 4/5] iio: hid-sensors: Added device rotation support Srinivas Pandruvada
2014-02-23 19:50 ` [PATCH v1 5/5] iio: Added ABI description for quaternion Srinivas Pandruvada
2014-03-29 11:15 ` [PATCH v1 1/5] IIO: core: Introduce read_raw_multi Jonathan Cameron
2014-04-04 21:38 ` Srinivas Pandruvada
2014-04-05 10:07 ` Jonathan Cameron
2014-04-07 16:05 ` [PATCH] iio: Add Freescale MMA8452Q 3-axis accelerometer driver gmane
2014-04-07 16:26 ` Jonathan Cameron
2014-04-07 16:32 ` Peter Meerwald
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.