* [PATCH 1/6] staging:iio:adis16350 add non burst buffer fill and fix burst logic
2010-09-11 14:58 [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features Jonathan Cameron
@ 2010-09-11 14:58 ` Jonathan Cameron
2010-09-11 14:58 ` [PATCH 2/6] staging:iio:adis16350 move datardy trigger to straight interrupt Jonathan Cameron
` (5 subsequent siblings)
6 siblings, 0 replies; 12+ messages in thread
From: Jonathan Cameron @ 2010-09-11 14:58 UTC (permalink / raw)
To: linux-iio; +Cc: Michael.Hennerich, Robin.Getz, manuel.stahl, Jonathan Cameron
If the adis16350 etc support burst mode it is undocumented and does
not seem to work. Hence this adds an alternate read function.
It also fixes the logic for cases where not all channels are
present in the burst path.
Signed-off-by: Jonathan Cameron <jic23@cam.ac.uk>
---
drivers/staging/iio/imu/adis16350.h | 2 +
drivers/staging/iio/imu/adis16350_core.c | 9 ++--
drivers/staging/iio/imu/adis16350_ring.c | 75 +++++++++++++++++++++++++++---
3 files changed, 75 insertions(+), 11 deletions(-)
diff --git a/drivers/staging/iio/imu/adis16350.h b/drivers/staging/iio/imu/adis16350.h
index b00001e..07d3eeb 100644
--- a/drivers/staging/iio/imu/adis16350.h
+++ b/drivers/staging/iio/imu/adis16350.h
@@ -107,6 +107,7 @@
* @tx: transmit buffer
* @rx: recieve buffer
* @buf_lock: mutex to protect tx and rx
+ * @burst_available: does the device support burst reading
**/
struct adis16350_state {
struct spi_device *us;
@@ -117,6 +118,7 @@ struct adis16350_state {
u8 *tx;
u8 *rx;
struct mutex buf_lock;
+ unsigned int burst_available:1;
};
int adis16350_set_irq(struct device *dev, bool enable);
diff --git a/drivers/staging/iio/imu/adis16350_core.c b/drivers/staging/iio/imu/adis16350_core.c
index cc33843..d8181f9 100644
--- a/drivers/staging/iio/imu/adis16350_core.c
+++ b/drivers/staging/iio/imu/adis16350_core.c
@@ -615,6 +615,7 @@ static int __devinit adis16350_probe(struct spi_device *spi)
}
st->us = spi;
mutex_init(&st->buf_lock);
+ st->burst_available = spi_get_device_id(spi)->driver_data;
/* setup the industrialio driver allocated elements */
st->indio_dev = iio_allocate_device();
if (st->indio_dev == NULL) {
@@ -722,10 +723,10 @@ static const struct spi_device_id adis16350_id[] = {
{"adis16350", 0},
{"adis16354", 0},
{"adis16355", 0},
- {"adis16360", 0},
- {"adis16362", 0},
- {"adis16364", 0},
- {"adis16365", 0},
+ {"adis16360", 1},
+ {"adis16362", 1},
+ {"adis16364", 1},
+ {"adis16365", 1},
{}
};
diff --git a/drivers/staging/iio/imu/adis16350_ring.c b/drivers/staging/iio/imu/adis16350_ring.c
index aefbae5..1970247 100644
--- a/drivers/staging/iio/imu/adis16350_ring.c
+++ b/drivers/staging/iio/imu/adis16350_ring.c
@@ -126,6 +126,56 @@ static int adis16350_spi_read_burst(struct device *dev, u8 *rx)
return ret;
}
+static const u16 read_all_tx_array[] = {
+ be16_to_cpu(ADIS16350_READ_REG(ADIS16350_SUPPLY_OUT)),
+ be16_to_cpu(ADIS16350_READ_REG(ADIS16350_XGYRO_OUT)),
+ be16_to_cpu(ADIS16350_READ_REG(ADIS16350_YGYRO_OUT)),
+ be16_to_cpu(ADIS16350_READ_REG(ADIS16350_ZGYRO_OUT)),
+ be16_to_cpu(ADIS16350_READ_REG(ADIS16350_XACCL_OUT)),
+ be16_to_cpu(ADIS16350_READ_REG(ADIS16350_YACCL_OUT)),
+ be16_to_cpu(ADIS16350_READ_REG(ADIS16350_ZACCL_OUT)),
+ be16_to_cpu(ADIS16350_READ_REG(ADIS16350_XTEMP_OUT)),
+ be16_to_cpu(ADIS16350_READ_REG(ADIS16350_YTEMP_OUT)),
+ be16_to_cpu(ADIS16350_READ_REG(ADIS16350_ZTEMP_OUT)),
+ be16_to_cpu(ADIS16350_READ_REG(ADIS16350_AUX_ADC)),
+};
+
+static int adis16350_spi_read_all(struct device *dev, u16 *rx_array)
+{
+ struct iio_dev *indio_dev = dev_get_drvdata(dev);
+ struct adis16350_state *st = iio_dev_get_devdata(indio_dev);
+
+ struct spi_message msg;
+ int i, j = 0, ret;
+ struct spi_transfer *xfers;
+
+ xfers = kzalloc(sizeof(*xfers)*
+ st->indio_dev->ring->scan_count + 1,
+ GFP_KERNEL);
+ if (xfers == NULL)
+ return -ENOMEM;
+
+ for (i = 0; i < ARRAY_SIZE(read_all_tx_array); i++)
+ if (st->indio_dev->ring->scan_mask & (1 << i)) {
+ xfers[j].tx_buf = &read_all_tx_array[i];
+ xfers[j].bits_per_word = 16;
+ xfers[j].len = 2;
+ xfers[j + 1].rx_buf = rx_array + j;
+ j++;
+ }
+ xfers[j].bits_per_word = 16;
+ xfers[j].len = 2;
+
+ spi_message_init(&msg);
+ for (j = 0; j < st->indio_dev->ring->scan_count + 1; j++)
+ spi_message_add_tail(&xfers[j], &msg);
+
+ ret = spi_sync(st->us, &msg);
+ kfree(xfers);
+
+ return ret;
+}
+
/* Whilst this makes a lot of calls to iio_sw_ring functions - it is to device
* specific to be rolled into the core.
*/
@@ -136,22 +186,33 @@ static void adis16350_trigger_bh_to_ring(struct work_struct *work_s)
work_trigger_to_ring);
struct iio_ring_buffer *ring = st->indio_dev->ring;
- int i = 0;
+ int i = 0, j = 0;
s16 *data;
size_t datasize = ring->access.get_bytes_per_datum(ring);
- data = kmalloc(datasize , GFP_KERNEL);
+ data = kmalloc(datasize, GFP_KERNEL);
if (data == NULL) {
dev_err(&st->us->dev, "memory alloc failed in ring bh");
return;
}
- if (ring->scan_count)
- if (adis16350_spi_read_burst(&st->indio_dev->dev, st->rx) >= 0)
+ if (ring->scan_count) {
+ if (st->burst_available) {
+ if (adis16350_spi_read_burst(&st->indio_dev->dev,
+ st->rx) < 0)
+ return;
+ for (; i < ring->scan_count; i++)
+ if (st->indio_dev->ring->scan_mask & (1 << i))
+ data[j++] = le16_to_cpup(
+ (__le16 *)&(st->rx[i*2]));
+ } else {
+ if (adis16350_spi_read_all(&st->indio_dev->dev,
+ (u16 *)st->rx) < 0)
+ return;
for (; i < ring->scan_count; i++)
- data[i] = be16_to_cpup(
- (__be16 *)&(st->rx[i*2]));
-
+ data[i] = *(u16 *)&(st->rx[i*2]);
+ }
+ }
/* Guaranteed to be aligned with 8 byte boundary */
if (ring->scan_timestamp)
*((s64 *)(data + ((i + 3)/4)*4)) = st->last_timestamp;
--
1.7.2.2
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH 2/6] staging:iio:adis16350 move datardy trigger to straight interrupt.
2010-09-11 14:58 [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features Jonathan Cameron
2010-09-11 14:58 ` [PATCH 1/6] staging:iio:adis16350 add non burst buffer fill and fix burst logic Jonathan Cameron
@ 2010-09-11 14:58 ` Jonathan Cameron
2010-09-11 14:58 ` [PATCH 3/6] staging:iio:adis16350 Add optional event support Jonathan Cameron
` (4 subsequent siblings)
6 siblings, 0 replies; 12+ messages in thread
From: Jonathan Cameron @ 2010-09-11 14:58 UTC (permalink / raw)
To: linux-iio; +Cc: Michael.Hennerich, Robin.Getz, manuel.stahl, Jonathan Cameron
The use of the interface for the trigger was lifted from the
lis3l02dq. There it is needed because the same physical line
is used for data ready and event interrupts. Her it isn't
so we can simplify things.
Signed-off-by: Jonathan Cameron <jic23@cam.ac.uk>
---
drivers/staging/iio/imu/adis16350_core.c | 27 ++----------------
drivers/staging/iio/imu/adis16350_trigger.c | 40 +++++++++++----------------
2 files changed, 19 insertions(+), 48 deletions(-)
diff --git a/drivers/staging/iio/imu/adis16350_core.c b/drivers/staging/iio/imu/adis16350_core.c
index d8181f9..e500a5c 100644
--- a/drivers/staging/iio/imu/adis16350_core.c
+++ b/drivers/staging/iio/imu/adis16350_core.c
@@ -583,14 +583,6 @@ static const struct attribute_group adis16350_attribute_group = {
.attrs = adis16350_attributes,
};
-static struct attribute *adis16350_event_attributes[] = {
- NULL,
-};
-
-static struct attribute_group adis16350_event_attribute_group = {
- .attrs = adis16350_event_attributes,
-};
-
static int __devinit adis16350_probe(struct spi_device *spi)
{
int ret, regdone = 0;
@@ -624,8 +616,6 @@ static int __devinit adis16350_probe(struct spi_device *spi)
}
st->indio_dev->dev.parent = &spi->dev;
- st->indio_dev->num_interrupt_lines = 1;
- st->indio_dev->event_attrs = &adis16350_event_attribute_group;
st->indio_dev->attrs = &adis16350_attribute_group;
st->indio_dev->dev_data = (void *)(st);
st->indio_dev->driver_module = THIS_MODULE;
@@ -647,17 +637,9 @@ static int __devinit adis16350_probe(struct spi_device *spi)
}
if (spi->irq) {
- ret = iio_register_interrupt_line(spi->irq,
- st->indio_dev,
- 0,
- IRQF_TRIGGER_RISING,
- "adis16350");
- if (ret)
- goto error_uninitialize_ring;
-
ret = adis16350_probe_trigger(st->indio_dev);
if (ret)
- goto error_unregister_line;
+ goto error_uninitialize_ring;
}
/* Get the device into a sane initial state */
@@ -667,10 +649,8 @@ static int __devinit adis16350_probe(struct spi_device *spi)
return 0;
error_remove_trigger:
- adis16350_remove_trigger(st->indio_dev);
-error_unregister_line:
if (spi->irq)
- iio_unregister_interrupt_line(st->indio_dev, 0);
+ adis16350_remove_trigger(st->indio_dev);
error_uninitialize_ring:
iio_ring_buffer_unregister(st->indio_dev->ring);
error_unreg_ring_funcs:
@@ -702,9 +682,8 @@ static int adis16350_remove(struct spi_device *spi)
flush_scheduled_work();
- adis16350_remove_trigger(indio_dev);
if (spi->irq)
- iio_unregister_interrupt_line(indio_dev, 0);
+ adis16350_remove_trigger(indio_dev);
iio_ring_buffer_unregister(indio_dev->ring);
iio_device_unregister(indio_dev);
diff --git a/drivers/staging/iio/imu/adis16350_trigger.c b/drivers/staging/iio/imu/adis16350_trigger.c
index 739b7ec..593c98f 100644
--- a/drivers/staging/iio/imu/adis16350_trigger.c
+++ b/drivers/staging/iio/imu/adis16350_trigger.c
@@ -13,23 +13,15 @@
#include "adis16350.h"
/**
- * adis16350_data_rdy_trig_poll() the event handler for the data rdy trig
+ * adis16350_data_rdy_trig_poll() the interrupt th for the data rdy trig
**/
-static int adis16350_data_rdy_trig_poll(struct iio_dev *dev_info,
- int index,
- s64 timestamp,
- int no_test)
+static irqreturn_t adis16350_data_rdy_trig_poll(int irq, void *private)
{
- struct adis16350_state *st = iio_dev_get_devdata(dev_info);
- struct iio_trigger *trig = st->trig;
-
- iio_trigger_poll(trig, timestamp);
-
+ disable_irq_nosync(irq);
+ iio_trigger_poll(private, iio_get_time_ns());
return IRQ_HANDLED;
}
-IIO_EVENT_SH(data_rdy_trig, &adis16350_data_rdy_trig_poll);
-
static IIO_TRIGGER_NAME_ATTR;
static struct attribute *adis16350_trigger_attrs[] = {
@@ -53,17 +45,9 @@ static int adis16350_data_rdy_trigger_set_state(struct iio_trigger *trig,
dev_dbg(&indio_dev->dev, "%s (%d)\n", __func__, state);
ret = adis16350_set_irq(&st->indio_dev->dev, state);
- if (state == false) {
- iio_remove_event_from_list(&iio_event_data_rdy_trig,
- &indio_dev->interrupts[0]
- ->ev_list);
- /* possible quirk with handler currently worked around
- by ensuring the work queue is empty */
+ if (state == false)
flush_scheduled_work();
- } else {
- iio_add_event_to_list(&iio_event_data_rdy_trig,
- &indio_dev->interrupts[0]->ev_list);
- }
+
return ret;
}
@@ -82,7 +66,7 @@ static int adis16350_trig_try_reen(struct iio_trigger *trig)
int adis16350_probe_trigger(struct iio_dev *indio_dev)
{
int ret;
- struct adis16350_state *st = indio_dev->dev_data;
+ struct adis16350_state *st = iio_dev_get_devdata(indio_dev);
st->trig = iio_allocate_trigger();
st->trig->name = kasprintf(GFP_KERNEL,
@@ -105,8 +89,15 @@ int adis16350_probe_trigger(struct iio_dev *indio_dev)
if (ret)
goto error_free_trig_name;
+ ret = request_irq(st->us->irq, adis16350_data_rdy_trig_poll,
+ IRQF_TRIGGER_RISING, st->trig->name, st->trig);
+ if (ret)
+ goto error_trigger_unregister;
+
return 0;
+error_trigger_unregister:
+ iio_trigger_unregister(st->trig);
error_free_trig_name:
kfree(st->trig->name);
error_free_trig:
@@ -117,8 +108,9 @@ error_free_trig:
void adis16350_remove_trigger(struct iio_dev *indio_dev)
{
- struct adis16350_state *state = indio_dev->dev_data;
+ struct adis16350_state *state = iio_dev_get_devdata(indio_dev);
+ free_irq(state->us->irq, state->trig);
iio_trigger_unregister(state->trig);
kfree(state->trig->name);
iio_free_trigger(state->trig);
--
1.7.2.2
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH 3/6] staging:iio:adis16350 Add optional event support
2010-09-11 14:58 [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features Jonathan Cameron
2010-09-11 14:58 ` [PATCH 1/6] staging:iio:adis16350 add non burst buffer fill and fix burst logic Jonathan Cameron
2010-09-11 14:58 ` [PATCH 2/6] staging:iio:adis16350 move datardy trigger to straight interrupt Jonathan Cameron
@ 2010-09-11 14:58 ` Jonathan Cameron
2010-09-11 14:58 ` [PATCH 4/6] staging:iio:adis16350 add missing registration of temp_offset attr Jonathan Cameron
` (3 subsequent siblings)
6 siblings, 0 replies; 12+ messages in thread
From: Jonathan Cameron @ 2010-09-11 14:58 UTC (permalink / raw)
To: linux-iio; +Cc: Michael.Hennerich, Robin.Getz, manuel.stahl, Jonathan Cameron
This is fairly complex. The device provides two alarms
which can be configured as rising or falling thresholds
on the magnitude or the rate of change of any channel.
I have made things a little more manageable by restricting
things so you can't set both alarms to the same setting.
This also rolls in some name changes etc to make possible
use of macros for some elements.
Note there is an issue with event codes for ADC channels (there
are now too many of them) that will need fixing before this merges.
Various other minor fixes are also in here.
---
drivers/staging/iio/adc/adc.h | 8 +-
drivers/staging/iio/gyro/gyro.h | 31 ++-
drivers/staging/iio/imu/Kconfig | 7 +
drivers/staging/iio/imu/Makefile | 1 +
drivers/staging/iio/imu/adis16350.h | 65 +++-
drivers/staging/iio/imu/adis16350_core.c | 17 +-
drivers/staging/iio/imu/adis16350_event.c | 499 +++++++++++++++++++++++++++++
drivers/staging/iio/imu/adis16350_ring.c | 10 +-
drivers/staging/iio/sysfs.h | 17 +-
9 files changed, 623 insertions(+), 32 deletions(-)
diff --git a/drivers/staging/iio/adc/adc.h b/drivers/staging/iio/adc/adc.h
index 953b5ce..2cd2ef9 100644
--- a/drivers/staging/iio/adc/adc.h
+++ b/drivers/staging/iio/adc/adc.h
@@ -11,7 +11,7 @@
/* Deprecated */
#define IIO_DEV_ATTR_ADC(_num, _show, _addr) \
- IIO_DEVICE_ATTR(adc_##_num, S_IRUGO, _show, NULL, _addr)
+ IIO_DEVICE_ATTR(adc_##_num, S_IRUGO, _show, NULL, _addr)
#define IIO_DEV_ATTR_IN_RAW(_num, _show, _addr) \
IIO_DEVICE_ATTR(in##_num##_raw, S_IRUGO, _show, NULL, _addr)
@@ -36,3 +36,9 @@
#define IIO_EVENT_CODE_IN_HIGH_THRESH(a) (IIO_EVENT_CODE_ADC_BASE + a)
#define IIO_EVENT_CODE_IN_LOW_THRESH(a) (IIO_EVENT_CODE_ADC_BASE + a + 32)
+#define IIO_EVENT_CODE_IN_HIGH_ROC(a) (IIO_EVENT_CODE_ADC_BASE + a + 64)
+#define IIO_EVENT_CODE_IN_LOW_ROC(a) (IIO_EVENT_CODE_ADC_BASE + a + 96)
+#define IIO_EVENT_CODE_IN_SUPPLY_HIGH (IIO_EVENT_CODE_ADC_BASE + 97)
+#define IIO_EVENT_CODE_IN_SUPPLY_LOW (IIO_EVENT_CODE_ADC_BASE + 98)
+#define IIO_EVENT_CODE_IN_SUPPLY_ROC_HIGH (IIO_EVENT_CODE_ADC_BASE + 99)
+#define IIO_EVENT_CODE_IN_SUPPLY_ROC_LOW (IIO_EVENT_CODE_ADC_BASE + 100)
diff --git a/drivers/staging/iio/gyro/gyro.h b/drivers/staging/iio/gyro/gyro.h
index 98b837b..aa57f24 100644
--- a/drivers/staging/iio/gyro/gyro.h
+++ b/drivers/staging/iio/gyro/gyro.h
@@ -33,31 +33,31 @@
#define IIO_DEV_ATTR_GYRO_Z_SCALE(_mode, _show, _store, _addr) \
IIO_DEVICE_ATTR(gyro_z_scale, _mode, _show, _store, _addr)
-#define IIO_DEV_ATTR_GYRO_CALIBBIAS(_mode, _show, _store, _addr) \
+#define IIO_DEV_ATTR_GYRO_CALIBBIAS(_mode, _show, _store, _addr) \
IIO_DEVICE_ATTR(gyro_calibbias, S_IRUGO, _show, _store, _addr)
-#define IIO_DEV_ATTR_GYRO_X_CALIBBIAS(_mode, _show, _store, _addr) \
+#define IIO_DEV_ATTR_GYRO_X_CALIBBIAS(_mode, _show, _store, _addr) \
IIO_DEVICE_ATTR(gyro_x_calibbias, _mode, _show, _store, _addr)
-#define IIO_DEV_ATTR_GYRO_Y_CALIBBIAS(_mode, _show, _store, _addr) \
+#define IIO_DEV_ATTR_GYRO_Y_CALIBBIAS(_mode, _show, _store, _addr) \
IIO_DEVICE_ATTR(gyro_y_calibbias, _mode, _show, _store, _addr)
-#define IIO_DEV_ATTR_GYRO_Z_CALIBBIAS(_mode, _show, _store, _addr) \
+#define IIO_DEV_ATTR_GYRO_Z_CALIBBIAS(_mode, _show, _store, _addr) \
IIO_DEVICE_ATTR(gyro_z_calibbias, _mode, _show, _store, _addr)
-#define IIO_DEV_ATTR_GYRO_CALIBSCALE(_mode, _show, _store, _addr) \
+#define IIO_DEV_ATTR_GYRO_CALIBSCALE(_mode, _show, _store, _addr) \
IIO_DEVICE_ATTR(gyro_calibscale, S_IRUGO, _show, _store, _addr)
-#define IIO_DEV_ATTR_GYRO_X_CALIBSCALE(_mode, _show, _store, _addr) \
+#define IIO_DEV_ATTR_GYRO_X_CALIBSCALE(_mode, _show, _store, _addr) \
IIO_DEVICE_ATTR(gyro_x_calibscale, _mode, _show, _store, _addr)
-#define IIO_DEV_ATTR_GYRO_Y_CALIBSCALE(_mode, _show, _store, _addr) \
+#define IIO_DEV_ATTR_GYRO_Y_CALIBSCALE(_mode, _show, _store, _addr) \
IIO_DEVICE_ATTR(gyro_y_calibscale, _mode, _show, _store, _addr)
-#define IIO_DEV_ATTR_GYRO_Z_CALIBSCALE(_mode, _show, _store, _addr) \
+#define IIO_DEV_ATTR_GYRO_Z_CALIBSCALE(_mode, _show, _store, _addr) \
IIO_DEVICE_ATTR(gyro_z_calibscale, _mode, _show, _store, _addr)
-#define IIO_DEV_ATTR_GYRO(_show, _addr) \
+#define IIO_DEV_ATTR_GYRO(_show, _addr) \
IIO_DEVICE_ATTR(gyro_raw, S_IRUGO, _show, NULL, _addr)
#define IIO_DEV_ATTR_GYRO_X(_show, _addr) \
@@ -71,3 +71,16 @@
#define IIO_DEV_ATTR_ANGL(_show, _addr) \
IIO_DEVICE_ATTR(angl_raw, S_IRUGO, _show, NULL, _addr)
+
+#define IIO_EVENT_CODE_GYRO_X_HIGH (IIO_EVENT_CODE_GYRO_BASE)
+#define IIO_EVENT_CODE_GYRO_X_LOW (IIO_EVENT_CODE_GYRO_BASE + 1)
+#define IIO_EVENT_CODE_GYRO_X_ROC_HIGH (IIO_EVENT_CODE_GYRO_BASE + 2)
+#define IIO_EVENT_CODE_GYRO_X_ROC_LOW (IIO_EVENT_CODE_GYRO_BASE + 3)
+#define IIO_EVENT_CODE_GYRO_Y_HIGH (IIO_EVENT_CODE_GYRO_BASE + 4)
+#define IIO_EVENT_CODE_GYRO_Y_LOW (IIO_EVENT_CODE_GYRO_BASE + 5)
+#define IIO_EVENT_CODE_GYRO_Y_ROC_HIGH (IIO_EVENT_CODE_GYRO_BASE + 6)
+#define IIO_EVENT_CODE_GYRO_Y_ROC_LOW (IIO_EVENT_CODE_GYRO_BASE + 7)
+#define IIO_EVENT_CODE_GYRO_Z_HIGH (IIO_EVENT_CODE_GYRO_BASE + 8)
+#define IIO_EVENT_CODE_GYRO_Z_LOW (IIO_EVENT_CODE_GYRO_BASE + 9)
+#define IIO_EVENT_CODE_GYRO_Z_ROC_HIGH (IIO_EVENT_CODE_GYRO_BASE + 10)
+#define IIO_EVENT_CODE_GYRO_Z_ROC_LOW (IIO_EVENT_CODE_GYRO_BASE + 11)
diff --git a/drivers/staging/iio/imu/Kconfig b/drivers/staging/iio/imu/Kconfig
index 31a6233..11a4984 100644
--- a/drivers/staging/iio/imu/Kconfig
+++ b/drivers/staging/iio/imu/Kconfig
@@ -21,6 +21,13 @@ config ADIS16350
Say yes here to build support for Analog Devices adis16350/54/55/60/62/64/65
high precision tri-axis inertial sensor.
+if ADIS16350
+config ADIS16350_EVENT
+ bool "Enable events on the ADIS16350"
+ help
+ Threshold and rate of change events for all channels.
+endif #ADIS16350
+
config ADIS16400
tristate "Analog Devices ADIS16400/5 IMU SPI driver"
depends on SPI
diff --git a/drivers/staging/iio/imu/Makefile b/drivers/staging/iio/imu/Makefile
index f3b450b..551a20f 100644
--- a/drivers/staging/iio/imu/Makefile
+++ b/drivers/staging/iio/imu/Makefile
@@ -7,6 +7,7 @@ adis16300-$(CONFIG_IIO_RING_BUFFER) += adis16300_ring.o adis16300_trigger.o
obj-$(CONFIG_ADIS16300) += adis16300.o
adis16350-y := adis16350_core.o
+adis16350-$(CONFIG_ADIS16350_EVENT) += adis16350_event.o
adis16350-$(CONFIG_IIO_RING_BUFFER) += adis16350_ring.o adis16350_trigger.o
obj-$(CONFIG_ADIS16350) += adis16350.o
diff --git a/drivers/staging/iio/imu/adis16350.h b/drivers/staging/iio/imu/adis16350.h
index 07d3eeb..2d8080e 100644
--- a/drivers/staging/iio/imu/adis16350.h
+++ b/drivers/staging/iio/imu/adis16350.h
@@ -108,6 +108,13 @@
* @rx: recieve buffer
* @buf_lock: mutex to protect tx and rx
* @burst_available: does the device support burst reading
+ * @event_lock: protect event state
+ * @event_irq: irq for event line
+ * @event_timestamp: local store for time of last event
+ * @work_event: work struct for event bh
+ * @thresh_cache: cache of thresholds for all the various alarms
+ * @smpl_cache: cache of sample period for ROC alarms
+ * @active_alarms: which alarms are on (in terms of attribute mask)
**/
struct adis16350_state {
struct spi_device *us;
@@ -119,23 +126,57 @@ struct adis16350_state {
u8 *rx;
struct mutex buf_lock;
unsigned int burst_available:1;
+#ifdef CONFIG_ADIS16350_EVENT
+ struct mutex event_lock;
+ int event_irq;
+ s64 event_timestamp;
+ struct work_struct work_event;
+ s16 thresh_cache[44];
+ u8 smpl_cache[22];
+ int active_alarms[2];
+ unsigned int oldest_alarm:1;
+ u8 alarm_on[2];
+#endif
};
int adis16350_set_irq(struct device *dev, bool enable);
-#ifdef CONFIG_IIO_RING_BUFFER
+int adis16350_spi_read_reg_16(struct device *dev,
+ u8 lower_reg_address,
+ u16 *val);
+
+int adis16350_spi_write_reg_16(struct device *dev,
+ u8 lower_reg_address,
+ u16 value);
+
+#ifdef CONFIG_ADIS16350_EVENT
+int adis16350_configure_event_line(struct adis16350_state *st,
+ int interrupt);
+void adis16350_unconfigure_event_line(struct adis16350_state *st);
+#else
+static inline int adis16350_configure_event_line(struct adis16350_state *st,
+ int interrupt)
+{
+ return 0;
+}
+static inline void adis16350_unconfigure_event_line(struct adis16350_state *st)
+{
+}
+#endif
+
+#define ADIS16350_SCAN_IN_SUPPLY 0
+#define ADIS16350_SCAN_GYRO_X 1
+#define ADIS16350_SCAN_GYRO_Y 2
+#define ADIS16350_SCAN_GYRO_Z 3
+#define ADIS16350_SCAN_ACCEL_X 4
+#define ADIS16350_SCAN_ACCEL_Y 5
+#define ADIS16350_SCAN_ACCEL_Z 6
+#define ADIS16350_SCAN_TEMP_X 7
+#define ADIS16350_SCAN_TEMP_Y 8
+#define ADIS16350_SCAN_TEMP_Z 9
+#define ADIS16350_SCAN_IN0 10
-#define ADIS16350_SCAN_SUPPLY 0
-#define ADIS16350_SCAN_GYRO_X 1
-#define ADIS16350_SCAN_GYRO_Y 2
-#define ADIS16350_SCAN_GYRO_Z 3
-#define ADIS16350_SCAN_ACC_X 4
-#define ADIS16350_SCAN_ACC_Y 5
-#define ADIS16350_SCAN_ACC_Z 6
-#define ADIS16350_SCAN_TEMP_X 7
-#define ADIS16350_SCAN_TEMP_Y 8
-#define ADIS16350_SCAN_TEMP_Z 9
-#define ADIS16350_SCAN_ADC_0 10
+#ifdef CONFIG_IIO_RING_BUFFER
void adis16350_remove_trigger(struct iio_dev *indio_dev);
int adis16350_probe_trigger(struct iio_dev *indio_dev);
diff --git a/drivers/staging/iio/imu/adis16350_core.c b/drivers/staging/iio/imu/adis16350_core.c
index e500a5c..b852dfc 100644
--- a/drivers/staging/iio/imu/adis16350_core.c
+++ b/drivers/staging/iio/imu/adis16350_core.c
@@ -62,7 +62,7 @@ static int adis16350_spi_write_reg_8(struct device *dev,
* is assumed to have address one greater.
* @val: value to be written
**/
-static int adis16350_spi_write_reg_16(struct device *dev,
+int adis16350_spi_write_reg_16(struct device *dev,
u8 lower_reg_address,
u16 value)
{
@@ -108,7 +108,7 @@ static int adis16350_spi_write_reg_16(struct device *dev,
* is assumed to have address one greater.
* @val: somewhere to pass back the value read
**/
-static int adis16350_spi_read_reg_16(struct device *dev,
+int adis16350_spi_read_reg_16(struct device *dev,
u8 lower_reg_address,
u16 *val)
{
@@ -641,13 +641,22 @@ static int __devinit adis16350_probe(struct spi_device *spi)
if (ret)
goto error_uninitialize_ring;
}
-
+ /* The event irq */
+ if (spi->dev.platform_data) {
+ ret = adis16350_configure_event_line(st,
+ *(int *)spi->dev.platform_data);
+ if (ret)
+ goto error_remove_trigger;
+ }
/* Get the device into a sane initial state */
ret = adis16350_initial_setup(st);
if (ret)
- goto error_remove_trigger;
+ goto error_unregister_event_line;
+
return 0;
+error_unregister_event_line:
+ adis16350_unconfigure_event_line(st);
error_remove_trigger:
if (spi->irq)
adis16350_remove_trigger(st->indio_dev);
diff --git a/drivers/staging/iio/imu/adis16350_event.c b/drivers/staging/iio/imu/adis16350_event.c
new file mode 100644
index 0000000..116ace8
--- /dev/null
+++ b/drivers/staging/iio/imu/adis16350_event.c
@@ -0,0 +1,499 @@
+/*
+ * ADIS16350/54/55/60/62/64/65 high precision tri-axis inertial sensor
+ * event support.
+ *
+ * Copyright 2010 Jonathan Cameron <jic23@cam.ac.uk>
+ *
+ * Licensed under the GPL-2 or later.
+ */
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/mutex.h>
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/list.h>
+#include "../iio.h"
+#include "../sysfs.h"
+#include "../accel/accel.h"
+#include "../adc/adc.h"
+#include "../gyro/gyro.h"
+
+#include "adis16350.h"
+
+#define ADIS16350_EV_ROC 0x40
+#define ADIS16350_EV_FALLING 0x80
+
+/* Short cut taken: we disable everything and setup from scatch */
+static int adis16350_update_alarms(struct adis16350_state *st,
+ struct device *dev)
+{
+ u16 regval = 0, temp;
+ int ret, i, loc, loc_sp;
+
+ ret = adis16350_spi_read_reg_16(dev,
+ ADIS16350_ALM_CTRL,
+ ®val);
+ regval &= 0x3;
+ if (ret)
+ goto error_ret;
+ ret = adis16350_spi_write_reg_16(dev,
+ ADIS16350_ALM_CTRL,
+ regval);
+ if (ret)
+ goto error_ret;
+ for (i = 0; i < 2; i++)
+ if (st->alarm_on[i]) {
+ regval |= ((st->active_alarms[i] & 0xF) + 1)
+ << (8 + i * 4);
+ regval |= (!!(st->active_alarms[i] & ADIS16350_EV_ROC))
+ << (6 + i);
+ regval |= (1 << 2);
+ loc = 4*(st->active_alarms[i] & 0x3f) +
+ 2*!!(st->active_alarms[i] &
+ ADIS16350_EV_ROC) +
+ !!(st->active_alarms[i] &
+ ADIS16350_EV_FALLING);
+ temp = (st->thresh_cache[loc] & 0xFFF) |
+ (!(st->active_alarms[i] &
+ ADIS16350_EV_FALLING) << 15);
+ ret = adis16350_spi_write_reg_16(dev,
+ i ?
+ ADIS16350_ALM_MAG2 :
+ ADIS16350_ALM_MAG1,
+ temp);
+ if (ret)
+ goto error_ret;
+ if (st->active_alarms[i] & ADIS16350_EV_ROC) {
+ loc_sp = 2*(st->active_alarms[i] & 0x3f) +
+ !!(st->active_alarms[i] &
+ ADIS16350_EV_FALLING);
+ ret = adis16350_spi_write_reg_16(dev,
+ i ?
+ ADIS16350_ALM_SMPL2 :
+ ADIS16350_ALM_SMPL1,
+ st->smpl_cache[loc_sp]);
+ if (ret)
+ goto error_ret;
+ }
+ }
+ if (st->alarm_on[0] || st->alarm_on[1])
+ ret = adis16350_spi_write_reg_16(dev,
+ ADIS16350_ALM_CTRL,
+ regval);
+error_ret:
+ return ret;
+}
+
+static ssize_t adis16350_read_interrupt_config(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct iio_event_attr *this_attr = to_iio_event_attr(attr);
+ struct iio_dev *indio_dev = dev_get_drvdata(dev);
+ struct adis16350_state *st = iio_dev_get_devdata(indio_dev);
+ int enabled = 0;
+
+ mutex_lock(&st->event_lock);
+ if (st->alarm_on[0] && this_attr->mask == st->active_alarms[0])
+ enabled = 1;
+ if (st->alarm_on[1] && this_attr->mask == st->active_alarms[1])
+ enabled = 1;
+ mutex_unlock(&st->event_lock);
+
+ return sprintf(buf, "%d\n", enabled);
+}
+
+static ssize_t adis16350_write_interrupt_config(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf,
+ size_t len)
+{
+ struct iio_event_attr *this_attr = to_iio_event_attr(attr);
+ struct iio_dev *indio_dev = dev_get_drvdata(dev);
+ struct adis16350_state *st = iio_dev_get_devdata(indio_dev);
+ bool enable;
+ int i, ret = 0;
+
+ enable = !(buf[0] == '0');
+ mutex_lock(&st->event_lock);
+ /* First verify this one isn't already in use */
+ for (i = 0; i < 2; i++)
+ if (st->alarm_on[i] &&
+ (this_attr->mask == st->active_alarms[i])) {
+ if (!enable) {
+ st->alarm_on[i] = 0;
+ st->oldest_alarm = i;
+ iio_remove_event_from_list(this_attr->listel,
+ &indio_dev
+ ->interrupts[0]
+ ->ev_list);
+ goto update;
+ }
+ goto done;
+}
+/* Replace the cache of what should be running */
+
+ st->alarm_on[st->oldest_alarm] = 1;
+ st->active_alarms[st->oldest_alarm] = this_attr->mask;
+ st->oldest_alarm = !st->oldest_alarm;
+ iio_add_event_to_list(this_attr->listel,
+ &indio_dev->interrupts[0]->ev_list);
+
+update:
+ ret = adis16350_update_alarms(st, dev);
+done:
+ mutex_unlock(&st->event_lock);
+ return ret ? ret : len;
+}
+
+static int adis16350_thresh_handler_th(struct iio_dev *dev_info,
+ int index,
+ s64 timestamp,
+ int no_test)
+{
+ struct adis16350_state *st = iio_dev_get_devdata(dev_info);
+
+ st->event_timestamp = timestamp;
+ schedule_work(&st->work_event);
+
+ return IRQ_HANDLED;
+}
+
+IIO_EVENT_SH(threshold, &adis16350_thresh_handler_th);
+#define ADIS16350_EV(name, channel) \
+ IIO_EVENT_ATTR_SH(name, \
+ iio_event_threshold, \
+ adis16350_read_interrupt_config, \
+ adis16350_write_interrupt_config, \
+ channel)
+
+static ssize_t adis16350_read_thresh(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct iio_dev *indio_dev = dev_get_drvdata(dev);
+ struct adis16350_state *st = iio_dev_get_devdata(indio_dev);
+ struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
+ int loc = 4*(this_attr->address & 0x3f) +
+ 2*!!(this_attr->address & ADIS16350_EV_ROC) +
+ !!(this_attr->address & ADIS16350_EV_FALLING);
+
+ return sprintf(buf, "%d\n", st->thresh_cache[loc]);
+}
+
+static ssize_t adis16350_write_thresh(struct device *dev,
+ struct device_attribute *attr,
+ s16 valin)
+{
+ struct iio_dev *indio_dev = dev_get_drvdata(dev);
+ struct adis16350_state *st = iio_dev_get_devdata(indio_dev);
+ struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
+ int loc, i, ret;
+
+ loc = 4*(this_attr->address & 0x3f) +
+ 2*!!(this_attr->address & ADIS16350_EV_ROC) +
+ !!(this_attr->address & ADIS16350_EV_FALLING);
+
+
+ st->thresh_cache[loc] = valin;
+
+ /* verify if this alarm is in use and update if it is */
+ for (i = 0; i < 2; i++)
+ if (st->alarm_on[i] &&
+ st->active_alarms[i] == this_attr->address) {
+ ret = adis16350_spi_write_reg_16(dev,
+ i ?
+ ADIS16350_ALM_MAG2 :
+ ADIS16350_ALM_MAG1,
+ st->thresh_cache[loc]);
+ if (ret)
+ return ret;
+ }
+
+ return 0;
+}
+
+static ssize_t adis16350_write_thresh_u12(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf,
+ size_t len)
+{
+ unsigned long valin;
+ int ret;
+ ret = strict_strtoul(buf, 10, &valin);
+ if (ret)
+ return ret;
+ if (valin > 0xfff)
+ return -EINVAL;
+ ret = adis16350_write_thresh(dev, attr, valin);
+
+ return ret ? ret : len;
+}
+
+static ssize_t adis16350_write_thresh_s12(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf,
+ size_t len)
+{
+ long valin;
+ int ret;
+ ret = strict_strtol(buf, 10, &valin);
+ if (ret)
+ return ret;
+ if (valin > 2047 || valin < -2048)
+ return -EINVAL;
+ ret = adis16350_write_thresh(dev, attr, valin);
+
+ return ret ? ret : len;
+}
+
+static ssize_t adis16350_write_thresh_s14(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf,
+ size_t len)
+{
+ long valin;
+ int ret;
+ ret = strict_strtol(buf, 10, &valin);
+ if (ret)
+ return ret;
+ if (valin > 8191 || valin < -8192)
+ return -EINVAL;
+ ret = adis16350_write_thresh(dev, attr, valin);
+
+ return ret ? ret : len;
+}
+
+/* For now this is in samples used - may need to rethink things */
+static ssize_t adis16350_read_sampl(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct iio_dev *indio_dev = dev_get_drvdata(dev);
+ struct adis16350_state *st = iio_dev_get_devdata(indio_dev);
+ struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
+ int loc;
+ loc = 2*(this_attr->address & 0x3f) +
+ !!(this_attr->address & ADIS16350_EV_FALLING);
+
+ return sprintf(buf, "%u\n", st->smpl_cache[loc]);
+}
+
+static ssize_t adis16350_write_sampl(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf,
+ size_t len)
+{
+ struct iio_dev *indio_dev = dev_get_drvdata(dev);
+ struct adis16350_state *st = iio_dev_get_devdata(indio_dev);
+ struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
+ unsigned long val;
+ int loc, ret, i;
+
+ loc = 2*(this_attr->address & 0x3f) +
+ !!(this_attr->address & ADIS16350_EV_FALLING);
+
+ ret = strict_strtoul(buf, 10, &val);
+ if (ret)
+ goto error_ret;
+ if (val > 0xff)
+ return -EINVAL;
+
+ st->smpl_cache[loc] = val;
+
+ /* verify if this alarm is in use and update if it is */
+ for (i = 0; i < 2; i++)
+ if (st->alarm_on[i] &&
+ st->active_alarms[i] == this_attr->address) {
+ ret = adis16350_spi_write_reg_16(dev,
+ i ?
+ ADIS16350_ALM_SMPL2 :
+ ADIS16350_ALM_SMPL1,
+ st->smpl_cache[loc]);
+ if (ret)
+ goto error_ret;
+ }
+error_ret:
+ return ret ? ret : len;
+}
+
+#define ADIS16350_EV_PAIR_THRESH(name, channel, type) \
+ ADIS16350_EV(name ## _thresh_rising_en, channel); \
+ static IIO_DEVICE_ATTR(name ## _thresh_rising_value, \
+ S_IWUSR | S_IRUGO, \
+ adis16350_read_thresh, \
+ adis16350_write_thresh_##type, \
+ channel); \
+ ADIS16350_EV(name ## _thresh_falling_en, \
+ channel | ADIS16350_EV_FALLING); \
+ static IIO_DEVICE_ATTR(name ## _thresh_falling_value, \
+ S_IWUSR | S_IRUGO, \
+ adis16350_read_thresh, \
+ adis16350_write_thresh_##type, \
+ channel | ADIS16350_EV_FALLING);
+
+#define ADIS16350_EV_PAIR_ROC(name, channel, type) \
+ ADIS16350_EV(name ## _roc_rising_en, \
+ channel | ADIS16350_EV_ROC); \
+ static IIO_DEVICE_ATTR(name ## _roc_rising_value, \
+ S_IWUSR | S_IRUGO, \
+ adis16350_read_thresh, \
+ adis16350_write_thresh_##type, \
+ channel | ADIS16350_EV_ROC); \
+ static IIO_DEVICE_ATTR(name ## _roc_rising_period, \
+ S_IWUSR | S_IRUGO, \
+ adis16350_read_sampl, \
+ adis16350_write_sampl, \
+ channel | ADIS16350_EV_ROC); \
+ ADIS16350_EV(name ## _roc_falling_en, \
+ channel | ADIS16350_EV_FALLING | ADIS16350_EV_ROC); \
+ static IIO_DEVICE_ATTR(name ## _roc_falling_value, \
+ S_IWUSR | S_IRUGO, \
+ adis16350_read_thresh, \
+ adis16350_write_thresh_##type, \
+ channel | ADIS16350_EV_FALLING | ADIS16350_EV_ROC); \
+ static IIO_DEVICE_ATTR(name ## _roc_falling_period, \
+ S_IWUSR | S_IRUGO, \
+ adis16350_read_sampl, \
+ adis16350_write_sampl, \
+ channel | ADIS16350_EV_FALLING | ADIS16350_EV_ROC);
+
+#define ADIS16350_EV_QUAD(name, channel, type) \
+ ADIS16350_EV_PAIR_THRESH(name, channel, type); \
+ ADIS16350_EV_PAIR_ROC(name, channel, type);
+
+ADIS16350_EV_QUAD(in_supply, ADIS16350_SCAN_IN_SUPPLY, u12);
+ADIS16350_EV_QUAD(gyro_x, ADIS16350_SCAN_GYRO_X, s14);
+ADIS16350_EV_QUAD(gyro_y, ADIS16350_SCAN_GYRO_Y, s14);
+ADIS16350_EV_QUAD(gyro_z, ADIS16350_SCAN_GYRO_Z, s14);
+ADIS16350_EV_QUAD(accel_x, ADIS16350_SCAN_ACCEL_X, s14);
+ADIS16350_EV_QUAD(accel_y, ADIS16350_SCAN_ACCEL_Y, s14);
+ADIS16350_EV_QUAD(accel_z, ADIS16350_SCAN_ACCEL_Z, s14);
+ADIS16350_EV_QUAD(temp_x, ADIS16350_SCAN_TEMP_X, s12);
+ADIS16350_EV_QUAD(temp_y, ADIS16350_SCAN_TEMP_Y, s12);
+ADIS16350_EV_QUAD(temp_z, ADIS16350_SCAN_TEMP_Z, s12);
+ADIS16350_EV_QUAD(in0, ADIS16350_SCAN_IN0, u12);
+
+#define adis16350_ev_attrs(name) \
+ &iio_event_attr_ ## name ##_thresh_rising_en.dev_attr.attr, \
+ &iio_dev_attr_ ## name ## _thresh_rising_value.dev_attr.attr, \
+ &iio_event_attr_ ## name ## _thresh_falling_en.dev_attr.attr, \
+ &iio_dev_attr_ ## name ## _thresh_falling_value.dev_attr.attr, \
+ &iio_event_attr_ ## name ## _roc_rising_en.dev_attr.attr, \
+ &iio_dev_attr_ ## name ## _roc_rising_value.dev_attr.attr, \
+ &iio_dev_attr_ ## name ## _roc_rising_period.dev_attr.attr, \
+ &iio_event_attr_ ## name ## _roc_falling_en.dev_attr.attr, \
+ &iio_dev_attr_ ## name ## _roc_falling_value.dev_attr.attr, \
+ &iio_dev_attr_ ## name ## _roc_falling_period.dev_attr.attr
+
+static struct attribute *adis16350_event_attributes[] = {
+ adis16350_ev_attrs(in_supply),
+ adis16350_ev_attrs(gyro_x),
+ adis16350_ev_attrs(gyro_y),
+ adis16350_ev_attrs(gyro_z),
+ adis16350_ev_attrs(accel_x),
+ adis16350_ev_attrs(accel_y),
+ adis16350_ev_attrs(accel_z),
+ adis16350_ev_attrs(temp_x),
+ adis16350_ev_attrs(temp_y),
+ adis16350_ev_attrs(temp_z),
+ adis16350_ev_attrs(in0),
+ NULL,
+};
+
+static struct attribute_group adis16350_event_attribute_group = {
+ .attrs = adis16350_event_attributes,
+};
+
+#define ADIS16350_EV_CASES(type) \
+ case ADIS16350_SCAN_##type: \
+ ev_code = IIO_EVENT_CODE_##type##_HIGH; \
+ break; \
+ case ADIS16350_SCAN_##type | ADIS16350_EV_FALLING: \
+ ev_code = IIO_EVENT_CODE_##type##_LOW; \
+ break; \
+ case ADIS16350_SCAN_##type | ADIS16350_EV_ROC: \
+ ev_code = IIO_EVENT_CODE_##type##_ROC_HIGH; \
+ break; \
+ case (ADIS16350_SCAN_##type | ADIS16350_EV_FALLING | \
+ ADIS16350_EV_ROC): \
+ ev_code = IIO_EVENT_CODE_##type##_ROC_LOW; \
+ break;
+
+static void adis16350_event_handler_bh(struct work_struct *work_s)
+{
+ struct adis16350_state *st
+ = container_of(work_s,
+ struct adis16350_state, work_event);
+ int ret, ev_code = 0;
+ u16 status;
+ int i;
+ /* Find out which alarm is triggered */
+ ret = adis16350_spi_read_reg_16(&st->indio_dev->dev,
+ ADIS16350_DIAG_STAT, &status);
+ if (ret)
+ dev_err(&st->indio_dev->dev, "Reading status failed\n");
+ for (i = 0; i < 2; i++)
+ if (status & (1 << (8 + i))) {
+ switch (st->active_alarms[i]) {
+ case ADIS16350_SCAN_IN0:
+ ev_code = IIO_EVENT_CODE_IN_HIGH_THRESH(0);
+ break;
+ case ADIS16350_SCAN_IN0 | ADIS16350_EV_FALLING:
+ ev_code = IIO_EVENT_CODE_IN_LOW_THRESH(0);
+ break;
+ case ADIS16350_SCAN_IN0 | ADIS16350_EV_ROC:
+ ev_code = IIO_EVENT_CODE_IN_HIGH_ROC(0);
+ break;
+ case (ADIS16350_SCAN_IN0 | ADIS16350_EV_FALLING |
+ ADIS16350_EV_ROC):
+ ev_code = IIO_EVENT_CODE_IN_LOW_ROC(0);
+ break;
+ ADIS16350_EV_CASES(IN_SUPPLY);
+ ADIS16350_EV_CASES(ACCEL_X);
+ ADIS16350_EV_CASES(ACCEL_Y);
+ ADIS16350_EV_CASES(ACCEL_Z);
+ ADIS16350_EV_CASES(GYRO_X);
+ ADIS16350_EV_CASES(GYRO_Y);
+ ADIS16350_EV_CASES(GYRO_Z);
+ ADIS16350_EV_CASES(TEMP_X);
+ ADIS16350_EV_CASES(TEMP_Y);
+ ADIS16350_EV_CASES(TEMP_Z);
+ default:
+ BUG_ON("unknown event");
+ }
+ iio_push_event(st->indio_dev,
+ 0,
+ ev_code,
+ st->event_timestamp);
+ }
+
+ enable_irq(st->event_irq);
+}
+
+int adis16350_configure_event_line(struct adis16350_state *st, int interrupt)
+{
+ if (!st->event_irq)
+ return 0;
+
+ INIT_WORK(&st->work_event, adis16350_event_handler_bh);
+ mutex_init(&st->event_lock);
+ st->event_irq = interrupt;
+ st->indio_dev->event_attrs = &adis16350_event_attribute_group;
+ st->indio_dev->num_interrupt_lines = 1;
+
+ return iio_register_interrupt_line(st->event_irq,
+ st->indio_dev,
+ 0,
+ IRQF_TRIGGER_RISING,
+ "adis16350_ev");
+}
+
+void adis16350_unconfigure_event_line(struct adis16350_state *st)
+{
+ if (st->event_irq)
+ iio_unregister_interrupt_line(st->indio_dev, 0);
+}
diff --git a/drivers/staging/iio/imu/adis16350_ring.c b/drivers/staging/iio/imu/adis16350_ring.c
index 1970247..9af0345 100644
--- a/drivers/staging/iio/imu/adis16350_ring.c
+++ b/drivers/staging/iio/imu/adis16350_ring.c
@@ -17,7 +17,7 @@
#include "../trigger.h"
#include "adis16350.h"
-static IIO_SCAN_EL_C(in_supply, ADIS16350_SCAN_SUPPLY, IIO_UNSIGNED(12),
+static IIO_SCAN_EL_C(in_supply, ADIS16350_SCAN_IN_SUPPLY, IIO_UNSIGNED(12),
ADIS16350_SUPPLY_OUT, NULL);
static IIO_SCAN_EL_C(gyro_x, ADIS16350_SCAN_GYRO_X, IIO_SIGNED(14),
@@ -27,11 +27,11 @@ static IIO_SCAN_EL_C(gyro_y, ADIS16350_SCAN_GYRO_Y, IIO_SIGNED(14),
static IIO_SCAN_EL_C(gyro_z, ADIS16350_SCAN_GYRO_Z, IIO_SIGNED(14),
ADIS16350_ZGYRO_OUT, NULL);
-static IIO_SCAN_EL_C(accel_x, ADIS16350_SCAN_ACC_X, IIO_SIGNED(14),
+static IIO_SCAN_EL_C(accel_x, ADIS16350_SCAN_ACCEL_X, IIO_SIGNED(14),
ADIS16350_XACCL_OUT, NULL);
-static IIO_SCAN_EL_C(accel_y, ADIS16350_SCAN_ACC_Y, IIO_SIGNED(14),
+static IIO_SCAN_EL_C(accel_y, ADIS16350_SCAN_ACCEL_Y, IIO_SIGNED(14),
ADIS16350_YACCL_OUT, NULL);
-static IIO_SCAN_EL_C(accel_z, ADIS16350_SCAN_ACC_Z, IIO_SIGNED(14),
+static IIO_SCAN_EL_C(accel_z, ADIS16350_SCAN_ACCEL_Z, IIO_SIGNED(14),
ADIS16350_ZACCL_OUT, NULL);
static IIO_SCAN_EL_C(temp_x, ADIS16350_SCAN_TEMP_X, IIO_SIGNED(12),
@@ -41,7 +41,7 @@ static IIO_SCAN_EL_C(temp_y, ADIS16350_SCAN_TEMP_Y, IIO_SIGNED(12),
static IIO_SCAN_EL_C(temp_z, ADIS16350_SCAN_TEMP_Z, IIO_SIGNED(12),
ADIS16350_ZTEMP_OUT, NULL);
-static IIO_SCAN_EL_C(in0, ADIS16350_SCAN_ADC_0, IIO_UNSIGNED(12),
+static IIO_SCAN_EL_C(in0, ADIS16350_SCAN_IN0, IIO_UNSIGNED(12),
ADIS16350_AUX_ADC, NULL);
static IIO_SCAN_EL_TIMESTAMP(11);
diff --git a/drivers/staging/iio/sysfs.h b/drivers/staging/iio/sysfs.h
index b531dc1..bd3edd4 100644
--- a/drivers/staging/iio/sysfs.h
+++ b/drivers/staging/iio/sysfs.h
@@ -63,7 +63,7 @@ struct iio_const_attr {
container_of(_dev_attr, struct iio_const_attr, dev_attr)
/* Some attributes will be hard coded (device dependent) and not require an
- address, in these cases pass a negative */
+ * address, in these cases pass a negative */
#define IIO_ATTR(_name, _mode, _show, _store, _addr) \
{ .dev_attr = __ATTR(_name, _mode, _show, _store), \
.address = _addr }
@@ -256,8 +256,23 @@ struct iio_const_attr {
#define IIO_EVENT_CODE_ADC_BASE 500
#define IIO_EVENT_CODE_MISC_BASE 600
#define IIO_EVENT_CODE_LIGHT_BASE 700
+#define IIO_EVENT_CODE_TEMP_BASE 800
#define IIO_EVENT_CODE_DEVICE_SPECIFIC 1000
+/* Can we make these a little more predictable rather than
+ * just adding new ones when they turn up? */
+#define IIO_EVENT_CODE_TEMP_X_HIGH (IIO_EVENT_CODE_TEMP_BASE)
+#define IIO_EVENT_CODE_TEMP_X_LOW (IIO_EVENT_CODE_TEMP_BASE + 1)
+#define IIO_EVENT_CODE_TEMP_X_ROC_HIGH (IIO_EVENT_CODE_TEMP_BASE + 2)
+#define IIO_EVENT_CODE_TEMP_X_ROC_LOW (IIO_EVENT_CODE_TEMP_BASE + 3)
+#define IIO_EVENT_CODE_TEMP_Y_HIGH (IIO_EVENT_CODE_TEMP_BASE + 4)
+#define IIO_EVENT_CODE_TEMP_Y_LOW (IIO_EVENT_CODE_TEMP_BASE + 5)
+#define IIO_EVENT_CODE_TEMP_Y_ROC_HIGH (IIO_EVENT_CODE_TEMP_BASE + 6)
+#define IIO_EVENT_CODE_TEMP_Y_ROC_LOW (IIO_EVENT_CODE_TEMP_BASE + 7)
+#define IIO_EVENT_CODE_TEMP_Z_HIGH (IIO_EVENT_CODE_TEMP_BASE + 8)
+#define IIO_EVENT_CODE_TEMP_Z_LOW (IIO_EVENT_CODE_TEMP_BASE + 9)
+#define IIO_EVENT_CODE_TEMP_Z_ROC_HIGH (IIO_EVENT_CODE_TEMP_BASE + 10)
+#define IIO_EVENT_CODE_TEMP_Z_ROC_LOW (IIO_EVENT_CODE_TEMP_BASE + 11)
/**
* IIO_EVENT_ATTR_RING_50_FULL - ring buffer event to indicate 50% full
--
1.7.2.2
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH 4/6] staging:iio:adis16350 add missing registration of temp_offset attr
2010-09-11 14:58 [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features Jonathan Cameron
` (2 preceding siblings ...)
2010-09-11 14:58 ` [PATCH 3/6] staging:iio:adis16350 Add optional event support Jonathan Cameron
@ 2010-09-11 14:58 ` Jonathan Cameron
2010-09-11 14:58 ` [PATCH 5/6] staging:iio:adis16300 merge into adis16350 driver Jonathan Cameron
` (2 subsequent siblings)
6 siblings, 0 replies; 12+ messages in thread
From: Jonathan Cameron @ 2010-09-11 14:58 UTC (permalink / raw)
To: linux-iio; +Cc: Michael.Hennerich, Robin.Getz, manuel.stahl, Jonathan Cameron
Signed-off-by: Jonathan Cameron <jic23@cam.ac.uk>
---
drivers/staging/iio/imu/adis16350_core.c | 1 +
1 files changed, 1 insertions(+), 0 deletions(-)
diff --git a/drivers/staging/iio/imu/adis16350_core.c b/drivers/staging/iio/imu/adis16350_core.c
index b852dfc..dc83489 100644
--- a/drivers/staging/iio/imu/adis16350_core.c
+++ b/drivers/staging/iio/imu/adis16350_core.c
@@ -570,6 +570,7 @@ static struct attribute *adis16350_attributes[] = {
&iio_dev_attr_temp_y_raw.dev_attr.attr,
&iio_dev_attr_temp_z_raw.dev_attr.attr,
&iio_const_attr_temp_scale.dev_attr.attr,
+ &iio_const_attr_temp_offset.dev_attr.attr,
&iio_dev_attr_in0_raw.dev_attr.attr,
&iio_const_attr_in0_scale.dev_attr.attr,
&iio_dev_attr_sampling_frequency.dev_attr.attr,
--
1.7.2.2
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH 5/6] staging:iio:adis16300 merge into adis16350 driver
2010-09-11 14:58 [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features Jonathan Cameron
` (3 preceding siblings ...)
2010-09-11 14:58 ` [PATCH 4/6] staging:iio:adis16350 add missing registration of temp_offset attr Jonathan Cameron
@ 2010-09-11 14:58 ` Jonathan Cameron
2010-09-18 16:06 ` Jonathan Cameron
2010-09-11 14:58 ` [PATCH 6/6] staging:iio:adis16400 " Jonathan Cameron
2010-09-22 8:47 ` [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features Manuel Stahl
6 siblings, 1 reply; 12+ messages in thread
From: Jonathan Cameron @ 2010-09-11 14:58 UTC (permalink / raw)
To: linux-iio; +Cc: Michael.Hennerich, Robin.Getz, manuel.stahl, Jonathan Cameron
Also fix incorrect axis for adis16300 gyro. It is about the
z axis not x.
Signed-off-by: Jonathan Cameron <jic23@cam.ac.uk>
---
drivers/staging/iio/imu/Kconfig | 14 +-
drivers/staging/iio/imu/Makefile | 4 -
drivers/staging/iio/imu/adis16300.h | 184 -------
drivers/staging/iio/imu/adis16300_core.c | 756 ---------------------------
drivers/staging/iio/imu/adis16300_ring.c | 220 --------
drivers/staging/iio/imu/adis16300_trigger.c | 125 -----
drivers/staging/iio/imu/adis16350.h | 40 ++
drivers/staging/iio/imu/adis16350_core.c | 190 ++++++-
drivers/staging/iio/imu/adis16350_ring.c | 67 ++-
9 files changed, 261 insertions(+), 1339 deletions(-)
diff --git a/drivers/staging/iio/imu/Kconfig b/drivers/staging/iio/imu/Kconfig
index 11a4984..ca433d8 100644
--- a/drivers/staging/iio/imu/Kconfig
+++ b/drivers/staging/iio/imu/Kconfig
@@ -3,22 +3,14 @@
#
comment "Inertial measurement units"
-config ADIS16300
- tristate "Analog Devices ADIS16300 IMU SPI driver"
- depends on SPI
- select IIO_SW_RING if IIO_RING_BUFFER
- select IIO_TRIGGER if IIO_RING_BUFFER
- help
- Say yes here to build support for Analog Devices adis16300 four degrees
- of freedom inertial sensor.
-
config ADIS16350
- tristate "Analog Devices ADIS16350/54/55/60/62/64/65 IMU SPI driver"
+ tristate "Analog Devices ADIS16350/00/54/55/60/62/64/65 IMU SPI driver"
depends on SPI
select IIO_TRIGGER if IIO_RING_BUFFER
select IIO_SW_RING if IIO_RING_BUFFER
help
- Say yes here to build support for Analog Devices adis16350/54/55/60/62/64/65
+ Say yes here to build support for Analog Devices adis16300, adis16350,
+ adis16354, adis16355, adis16360, adis16362 and adis16364,
high precision tri-axis inertial sensor.
if ADIS16350
diff --git a/drivers/staging/iio/imu/Makefile b/drivers/staging/iio/imu/Makefile
index 551a20f..f27f896 100644
--- a/drivers/staging/iio/imu/Makefile
+++ b/drivers/staging/iio/imu/Makefile
@@ -2,10 +2,6 @@
# Makefile for Inertial Measurement Units
#
-adis16300-y := adis16300_core.o
-adis16300-$(CONFIG_IIO_RING_BUFFER) += adis16300_ring.o adis16300_trigger.o
-obj-$(CONFIG_ADIS16300) += adis16300.o
-
adis16350-y := adis16350_core.o
adis16350-$(CONFIG_ADIS16350_EVENT) += adis16350_event.o
adis16350-$(CONFIG_IIO_RING_BUFFER) += adis16350_ring.o adis16350_trigger.o
diff --git a/drivers/staging/iio/imu/adis16300.h b/drivers/staging/iio/imu/adis16300.h
deleted file mode 100644
index 1f25d68..0000000
--- a/drivers/staging/iio/imu/adis16300.h
+++ /dev/null
@@ -1,184 +0,0 @@
-#ifndef SPI_ADIS16300_H_
-#define SPI_ADIS16300_H_
-
-#define ADIS16300_STARTUP_DELAY 220 /* ms */
-
-#define ADIS16300_READ_REG(a) a
-#define ADIS16300_WRITE_REG(a) ((a) | 0x80)
-
-#define ADIS16300_FLASH_CNT 0x00 /* Flash memory write count */
-#define ADIS16300_SUPPLY_OUT 0x02 /* Power supply measurement */
-#define ADIS16300_XGYRO_OUT 0x04 /* X-axis gyroscope output */
-#define ADIS16300_XACCL_OUT 0x0A /* X-axis accelerometer output */
-#define ADIS16300_YACCL_OUT 0x0C /* Y-axis accelerometer output */
-#define ADIS16300_ZACCL_OUT 0x0E /* Z-axis accelerometer output */
-#define ADIS16300_TEMP_OUT 0x10 /* Temperature output */
-#define ADIS16300_XINCLI_OUT 0x12 /* X-axis inclinometer output measurement */
-#define ADIS16300_YINCLI_OUT 0x14 /* Y-axis inclinometer output measurement */
-#define ADIS16300_AUX_ADC 0x16 /* Auxiliary ADC measurement */
-
-/* Calibration parameters */
-#define ADIS16300_XGYRO_OFF 0x1A /* X-axis gyroscope bias offset factor */
-#define ADIS16300_XACCL_OFF 0x20 /* X-axis acceleration bias offset factor */
-#define ADIS16300_YACCL_OFF 0x22 /* Y-axis acceleration bias offset factor */
-#define ADIS16300_ZACCL_OFF 0x24 /* Z-axis acceleration bias offset factor */
-
-#define ADIS16300_GPIO_CTRL 0x32 /* Auxiliary digital input/output control */
-#define ADIS16300_MSC_CTRL 0x34 /* Miscellaneous control */
-#define ADIS16300_SMPL_PRD 0x36 /* Internal sample period (rate) control */
-#define ADIS16300_SENS_AVG 0x38 /* Dynamic range and digital filter control */
-#define ADIS16300_SLP_CNT 0x3A /* Sleep mode control */
-#define ADIS16300_DIAG_STAT 0x3C /* System status */
-
-/* Alarm functions */
-#define ADIS16300_GLOB_CMD 0x3E /* System command */
-#define ADIS16300_ALM_MAG1 0x26 /* Alarm 1 amplitude threshold */
-#define ADIS16300_ALM_MAG2 0x28 /* Alarm 2 amplitude threshold */
-#define ADIS16300_ALM_SMPL1 0x2A /* Alarm 1 sample size */
-#define ADIS16300_ALM_SMPL2 0x2C /* Alarm 2 sample size */
-#define ADIS16300_ALM_CTRL 0x2E /* Alarm control */
-#define ADIS16300_AUX_DAC 0x30 /* Auxiliary DAC data */
-
-#define ADIS16300_ERROR_ACTIVE (1<<14)
-#define ADIS16300_NEW_DATA (1<<15)
-
-/* MSC_CTRL */
-#define ADIS16300_MSC_CTRL_MEM_TEST (1<<11)
-#define ADIS16300_MSC_CTRL_INT_SELF_TEST (1<<10)
-#define ADIS16300_MSC_CTRL_NEG_SELF_TEST (1<<9)
-#define ADIS16300_MSC_CTRL_POS_SELF_TEST (1<<8)
-#define ADIS16300_MSC_CTRL_GYRO_BIAS (1<<7)
-#define ADIS16300_MSC_CTRL_ACCL_ALIGN (1<<6)
-#define ADIS16300_MSC_CTRL_DATA_RDY_EN (1<<2)
-#define ADIS16300_MSC_CTRL_DATA_RDY_POL_HIGH (1<<1)
-#define ADIS16300_MSC_CTRL_DATA_RDY_DIO2 (1<<0)
-
-/* SMPL_PRD */
-#define ADIS16300_SMPL_PRD_TIME_BASE (1<<7)
-#define ADIS16300_SMPL_PRD_DIV_MASK 0x7F
-
-/* DIAG_STAT */
-#define ADIS16300_DIAG_STAT_ZACCL_FAIL (1<<15)
-#define ADIS16300_DIAG_STAT_YACCL_FAIL (1<<14)
-#define ADIS16300_DIAG_STAT_XACCL_FAIL (1<<13)
-#define ADIS16300_DIAG_STAT_XGYRO_FAIL (1<<10)
-#define ADIS16300_DIAG_STAT_ALARM2 (1<<9)
-#define ADIS16300_DIAG_STAT_ALARM1 (1<<8)
-#define ADIS16300_DIAG_STAT_FLASH_CHK (1<<6)
-#define ADIS16300_DIAG_STAT_SELF_TEST (1<<5)
-#define ADIS16300_DIAG_STAT_OVERFLOW (1<<4)
-#define ADIS16300_DIAG_STAT_SPI_FAIL (1<<3)
-#define ADIS16300_DIAG_STAT_FLASH_UPT (1<<2)
-#define ADIS16300_DIAG_STAT_POWER_HIGH (1<<1)
-#define ADIS16300_DIAG_STAT_POWER_LOW (1<<0)
-
-/* GLOB_CMD */
-#define ADIS16300_GLOB_CMD_SW_RESET (1<<7)
-#define ADIS16300_GLOB_CMD_P_AUTO_NULL (1<<4)
-#define ADIS16300_GLOB_CMD_FLASH_UPD (1<<3)
-#define ADIS16300_GLOB_CMD_DAC_LATCH (1<<2)
-#define ADIS16300_GLOB_CMD_FAC_CALIB (1<<1)
-#define ADIS16300_GLOB_CMD_AUTO_NULL (1<<0)
-
-/* SLP_CNT */
-#define ADIS16300_SLP_CNT_POWER_OFF (1<<8)
-
-#define ADIS16300_MAX_TX 18
-#define ADIS16300_MAX_RX 18
-
-#define ADIS16300_SPI_SLOW (u32)(300 * 1000)
-#define ADIS16300_SPI_BURST (u32)(1000 * 1000)
-#define ADIS16300_SPI_FAST (u32)(2000 * 1000)
-
-/**
- * struct adis16300_state - device instance specific data
- * @us: actual spi_device
- * @work_trigger_to_ring: bh for triggered event handling
- * @inter: used to check if new interrupt has been triggered
- * @last_timestamp: passing timestamp from th to bh of interrupt handler
- * @indio_dev: industrial I/O device structure
- * @trig: data ready trigger registered with iio
- * @tx: transmit buffer
- * @rx: recieve buffer
- * @buf_lock: mutex to protect tx and rx
- **/
-struct adis16300_state {
- struct spi_device *us;
- struct work_struct work_trigger_to_ring;
- s64 last_timestamp;
- struct iio_dev *indio_dev;
- struct iio_trigger *trig;
- u8 *tx;
- u8 *rx;
- struct mutex buf_lock;
-};
-
-int adis16300_set_irq(struct device *dev, bool enable);
-
-#ifdef CONFIG_IIO_RING_BUFFER
-/* At the moment triggers are only used for ring buffer
- * filling. This may change!
- */
-
-#define ADIS16300_SCAN_SUPPLY 0
-#define ADIS16300_SCAN_GYRO_X 1
-#define ADIS16300_SCAN_ACC_X 2
-#define ADIS16300_SCAN_ACC_Y 3
-#define ADIS16300_SCAN_ACC_Z 4
-#define ADIS16300_SCAN_TEMP 5
-#define ADIS16300_SCAN_ADC_0 6
-#define ADIS16300_SCAN_INCLI_X 7
-#define ADIS16300_SCAN_INCLI_Y 8
-
-void adis16300_remove_trigger(struct iio_dev *indio_dev);
-int adis16300_probe_trigger(struct iio_dev *indio_dev);
-
-ssize_t adis16300_read_data_from_ring(struct device *dev,
- struct device_attribute *attr,
- char *buf);
-
-
-int adis16300_configure_ring(struct iio_dev *indio_dev);
-void adis16300_unconfigure_ring(struct iio_dev *indio_dev);
-
-int adis16300_initialize_ring(struct iio_ring_buffer *ring);
-void adis16300_uninitialize_ring(struct iio_ring_buffer *ring);
-#else /* CONFIG_IIO_RING_BUFFER */
-
-static inline void adis16300_remove_trigger(struct iio_dev *indio_dev)
-{
-}
-
-static inline int adis16300_probe_trigger(struct iio_dev *indio_dev)
-{
- return 0;
-}
-
-static inline ssize_t
-adis16300_read_data_from_ring(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- return 0;
-}
-
-static int adis16300_configure_ring(struct iio_dev *indio_dev)
-{
- return 0;
-}
-
-static inline void adis16300_unconfigure_ring(struct iio_dev *indio_dev)
-{
-}
-
-static inline int adis16300_initialize_ring(struct iio_ring_buffer *ring)
-{
- return 0;
-}
-
-static inline void adis16300_uninitialize_ring(struct iio_ring_buffer *ring)
-{
-}
-
-#endif /* CONFIG_IIO_RING_BUFFER */
-#endif /* SPI_ADIS16300_H_ */
diff --git a/drivers/staging/iio/imu/adis16300_core.c b/drivers/staging/iio/imu/adis16300_core.c
deleted file mode 100644
index 3ed86cc..0000000
--- a/drivers/staging/iio/imu/adis16300_core.c
+++ /dev/null
@@ -1,756 +0,0 @@
-/*
- * ADIS16300 Four Degrees of Freedom Inertial Sensor Driver
- *
- * Copyright 2010 Analog Devices Inc.
- *
- * Licensed under the GPL-2 or later.
- */
-
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/gpio.h>
-#include <linux/delay.h>
-#include <linux/mutex.h>
-#include <linux/device.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/list.h>
-
-#include "../iio.h"
-#include "../sysfs.h"
-#include "../ring_generic.h"
-#include "../accel/accel.h"
-#include "../accel/inclinometer.h"
-#include "../gyro/gyro.h"
-#include "../adc/adc.h"
-
-#include "adis16300.h"
-
-#define DRIVER_NAME "adis16300"
-
-static int adis16300_check_status(struct device *dev);
-
-/**
- * adis16300_spi_write_reg_8() - write single byte to a register
- * @dev: device associated with child of actual device (iio_dev or iio_trig)
- * @reg_address: the address of the register to be written
- * @val: the value to write
- **/
-static int adis16300_spi_write_reg_8(struct device *dev,
- u8 reg_address,
- u8 val)
-{
- int ret;
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- struct adis16300_state *st = iio_dev_get_devdata(indio_dev);
-
- mutex_lock(&st->buf_lock);
- st->tx[0] = ADIS16300_WRITE_REG(reg_address);
- st->tx[1] = val;
-
- ret = spi_write(st->us, st->tx, 2);
- mutex_unlock(&st->buf_lock);
-
- return ret;
-}
-
-/**
- * adis16300_spi_write_reg_16() - write 2 bytes to a pair of registers
- * @dev: device associated with child of actual device (iio_dev or iio_trig)
- * @reg_address: the address of the lower of the two registers. Second register
- * is assumed to have address one greater.
- * @val: value to be written
- **/
-static int adis16300_spi_write_reg_16(struct device *dev,
- u8 lower_reg_address,
- u16 value)
-{
- int ret;
- struct spi_message msg;
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- struct adis16300_state *st = iio_dev_get_devdata(indio_dev);
- struct spi_transfer xfers[] = {
- {
- .tx_buf = st->tx,
- .bits_per_word = 8,
- .len = 2,
- .cs_change = 1,
- .delay_usecs = 75,
- }, {
- .tx_buf = st->tx + 2,
- .bits_per_word = 8,
- .len = 2,
- .cs_change = 1,
- .delay_usecs = 75,
- },
- };
-
- mutex_lock(&st->buf_lock);
- st->tx[0] = ADIS16300_WRITE_REG(lower_reg_address);
- st->tx[1] = value & 0xFF;
- st->tx[2] = ADIS16300_WRITE_REG(lower_reg_address + 1);
- st->tx[3] = (value >> 8) & 0xFF;
-
- spi_message_init(&msg);
- spi_message_add_tail(&xfers[0], &msg);
- spi_message_add_tail(&xfers[1], &msg);
- ret = spi_sync(st->us, &msg);
- mutex_unlock(&st->buf_lock);
-
- return ret;
-}
-
-/**
- * adis16300_spi_read_reg_16() - read 2 bytes from a 16-bit register
- * @dev: device associated with child of actual device (iio_dev or iio_trig)
- * @reg_address: the address of the lower of the two registers. Second register
- * is assumed to have address one greater.
- * @val: somewhere to pass back the value read
- **/
-static int adis16300_spi_read_reg_16(struct device *dev,
- u8 lower_reg_address,
- u16 *val)
-{
- struct spi_message msg;
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- struct adis16300_state *st = iio_dev_get_devdata(indio_dev);
- int ret;
- struct spi_transfer xfers[] = {
- {
- .tx_buf = st->tx,
- .bits_per_word = 8,
- .len = 2,
- .cs_change = 1,
- .delay_usecs = 75,
- }, {
- .rx_buf = st->rx,
- .bits_per_word = 8,
- .len = 2,
- .cs_change = 1,
- .delay_usecs = 75,
- },
- };
-
- mutex_lock(&st->buf_lock);
- st->tx[0] = ADIS16300_READ_REG(lower_reg_address);
- st->tx[1] = 0;
- st->tx[2] = 0;
- st->tx[3] = 0;
-
- spi_message_init(&msg);
- spi_message_add_tail(&xfers[0], &msg);
- spi_message_add_tail(&xfers[1], &msg);
- ret = spi_sync(st->us, &msg);
- if (ret) {
- dev_err(&st->us->dev,
- "problem when reading 16 bit register 0x%02X",
- lower_reg_address);
- goto error_ret;
- }
- *val = (st->rx[0] << 8) | st->rx[1];
-
-error_ret:
- mutex_unlock(&st->buf_lock);
- return ret;
-}
-
-static ssize_t adis16300_spi_read_signed(struct device *dev,
- struct device_attribute *attr,
- char *buf,
- unsigned bits)
-{
- int ret;
- s16 val = 0;
- unsigned shift = 16 - bits;
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- ret = adis16300_spi_read_reg_16(dev, this_attr->address, (u16 *)&val);
- if (ret)
- return ret;
-
- if (val & ADIS16300_ERROR_ACTIVE)
- adis16300_check_status(dev);
- val = ((s16)(val << shift) >> shift);
- return sprintf(buf, "%d\n", val);
-}
-
-static ssize_t adis16300_read_12bit_unsigned(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- int ret;
- u16 val = 0;
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- ret = adis16300_spi_read_reg_16(dev, this_attr->address, &val);
- if (ret)
- return ret;
-
- if (val & ADIS16300_ERROR_ACTIVE)
- adis16300_check_status(dev);
-
- return sprintf(buf, "%u\n", val & 0x0FFF);
-}
-
-static ssize_t adis16300_read_14bit_unsigned(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- int ret;
- u16 val = 0;
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- ret = adis16300_spi_read_reg_16(dev, this_attr->address, &val);
- if (ret)
- return ret;
-
- if (val & ADIS16300_ERROR_ACTIVE)
- adis16300_check_status(dev);
-
- return sprintf(buf, "%u\n", val & 0x3FFF);
-}
-
-static ssize_t adis16300_read_14bit_signed(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- ssize_t ret;
-
- /* Take the iio_dev status lock */
- mutex_lock(&indio_dev->mlock);
- ret = adis16300_spi_read_signed(dev, attr, buf, 14);
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static ssize_t adis16300_read_12bit_signed(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- ssize_t ret;
-
- /* Take the iio_dev status lock */
- mutex_lock(&indio_dev->mlock);
- ret = adis16300_spi_read_signed(dev, attr, buf, 12);
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static ssize_t adis16300_read_13bit_signed(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- ssize_t ret;
-
- /* Take the iio_dev status lock */
- mutex_lock(&indio_dev->mlock);
- ret = adis16300_spi_read_signed(dev, attr, buf, 13);
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static ssize_t adis16300_write_16bit(struct device *dev,
- struct device_attribute *attr,
- const char *buf,
- size_t len)
-{
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
- int ret;
- long val;
-
- ret = strict_strtol(buf, 10, &val);
- if (ret)
- goto error_ret;
- ret = adis16300_spi_write_reg_16(dev, this_attr->address, val);
-
-error_ret:
- return ret ? ret : len;
-}
-
-static ssize_t adis16300_read_frequency(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- int ret, len = 0;
- u16 t;
- int sps;
- ret = adis16300_spi_read_reg_16(dev,
- ADIS16300_SMPL_PRD,
- &t);
- if (ret)
- return ret;
- sps = (t & ADIS16300_SMPL_PRD_TIME_BASE) ? 53 : 1638;
- sps /= (t & ADIS16300_SMPL_PRD_DIV_MASK) + 1;
- len = sprintf(buf, "%d SPS\n", sps);
- return len;
-}
-
-static ssize_t adis16300_write_frequency(struct device *dev,
- struct device_attribute *attr,
- const char *buf,
- size_t len)
-{
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- struct adis16300_state *st = iio_dev_get_devdata(indio_dev);
- long val;
- int ret;
- u8 t;
-
- ret = strict_strtol(buf, 10, &val);
- if (ret)
- return ret;
-
- mutex_lock(&indio_dev->mlock);
-
- t = (1638 / val);
- if (t > 0)
- t--;
- t &= ADIS16300_SMPL_PRD_DIV_MASK;
- if ((t & ADIS16300_SMPL_PRD_DIV_MASK) >= 0x0A)
- st->us->max_speed_hz = ADIS16300_SPI_SLOW;
- else
- st->us->max_speed_hz = ADIS16300_SPI_FAST;
-
- ret = adis16300_spi_write_reg_8(dev,
- ADIS16300_SMPL_PRD,
- t);
-
- mutex_unlock(&indio_dev->mlock);
-
- return ret ? ret : len;
-}
-
-static int adis16300_reset(struct device *dev)
-{
- int ret;
- ret = adis16300_spi_write_reg_8(dev,
- ADIS16300_GLOB_CMD,
- ADIS16300_GLOB_CMD_SW_RESET);
- if (ret)
- dev_err(dev, "problem resetting device");
-
- return ret;
-}
-
-static ssize_t adis16300_write_reset(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- if (len < 1)
- return -1;
- switch (buf[0]) {
- case '1':
- case 'y':
- case 'Y':
- return adis16300_reset(dev);
- }
- return -1;
-}
-
-int adis16300_set_irq(struct device *dev, bool enable)
-{
- int ret;
- u16 msc;
- ret = adis16300_spi_read_reg_16(dev, ADIS16300_MSC_CTRL, &msc);
- if (ret)
- goto error_ret;
-
- msc |= ADIS16300_MSC_CTRL_DATA_RDY_POL_HIGH;
- msc &= ~ADIS16300_MSC_CTRL_DATA_RDY_DIO2;
- if (enable)
- msc |= ADIS16300_MSC_CTRL_DATA_RDY_EN;
- else
- msc &= ~ADIS16300_MSC_CTRL_DATA_RDY_EN;
-
- ret = adis16300_spi_write_reg_16(dev, ADIS16300_MSC_CTRL, msc);
- if (ret)
- goto error_ret;
-
-error_ret:
- return ret;
-}
-
-/* Power down the device */
-static int adis16300_stop_device(struct device *dev)
-{
- int ret;
- u16 val = ADIS16300_SLP_CNT_POWER_OFF;
-
- ret = adis16300_spi_write_reg_16(dev, ADIS16300_SLP_CNT, val);
- if (ret)
- dev_err(dev, "problem with turning device off: SLP_CNT");
-
- return ret;
-}
-
-static int adis16300_self_test(struct device *dev)
-{
- int ret;
- ret = adis16300_spi_write_reg_16(dev,
- ADIS16300_MSC_CTRL,
- ADIS16300_MSC_CTRL_MEM_TEST);
- if (ret) {
- dev_err(dev, "problem starting self test");
- goto err_ret;
- }
-
- adis16300_check_status(dev);
-
-err_ret:
- return ret;
-}
-
-static int adis16300_check_status(struct device *dev)
-{
- u16 status;
- int ret;
-
- ret = adis16300_spi_read_reg_16(dev, ADIS16300_DIAG_STAT, &status);
-
- if (ret < 0) {
- dev_err(dev, "Reading status failed\n");
- goto error_ret;
- }
- ret = status;
- if (status & ADIS16300_DIAG_STAT_ZACCL_FAIL)
- dev_err(dev, "Z-axis accelerometer self-test failure\n");
- if (status & ADIS16300_DIAG_STAT_YACCL_FAIL)
- dev_err(dev, "Y-axis accelerometer self-test failure\n");
- if (status & ADIS16300_DIAG_STAT_XACCL_FAIL)
- dev_err(dev, "X-axis accelerometer self-test failure\n");
- if (status & ADIS16300_DIAG_STAT_XGYRO_FAIL)
- dev_err(dev, "X-axis gyroscope self-test failure\n");
- if (status & ADIS16300_DIAG_STAT_ALARM2)
- dev_err(dev, "Alarm 2 active\n");
- if (status & ADIS16300_DIAG_STAT_ALARM1)
- dev_err(dev, "Alarm 1 active\n");
- if (status & ADIS16300_DIAG_STAT_FLASH_CHK)
- dev_err(dev, "Flash checksum error\n");
- if (status & ADIS16300_DIAG_STAT_SELF_TEST)
- dev_err(dev, "Self test error\n");
- if (status & ADIS16300_DIAG_STAT_OVERFLOW)
- dev_err(dev, "Sensor overrange\n");
- if (status & ADIS16300_DIAG_STAT_SPI_FAIL)
- dev_err(dev, "SPI failure\n");
- if (status & ADIS16300_DIAG_STAT_FLASH_UPT)
- dev_err(dev, "Flash update failed\n");
- if (status & ADIS16300_DIAG_STAT_POWER_HIGH)
- dev_err(dev, "Power supply above 5.25V\n");
- if (status & ADIS16300_DIAG_STAT_POWER_LOW)
- dev_err(dev, "Power supply below 4.75V\n");
-
-error_ret:
- return ret;
-}
-
-static int adis16300_initial_setup(struct adis16300_state *st)
-{
- int ret;
- u16 smp_prd;
- struct device *dev = &st->indio_dev->dev;
-
- /* use low spi speed for init */
- st->us->max_speed_hz = ADIS16300_SPI_SLOW;
- st->us->mode = SPI_MODE_3;
- spi_setup(st->us);
-
- /* Disable IRQ */
- ret = adis16300_set_irq(dev, false);
- if (ret) {
- dev_err(dev, "disable irq failed");
- goto err_ret;
- }
-
- /* Do self test */
- ret = adis16300_self_test(dev);
- if (ret) {
- dev_err(dev, "self test failure");
- goto err_ret;
- }
-
- /* Read status register to check the result */
- ret = adis16300_check_status(dev);
- if (ret) {
- adis16300_reset(dev);
- dev_err(dev, "device not playing ball -> reset");
- msleep(ADIS16300_STARTUP_DELAY);
- ret = adis16300_check_status(dev);
- if (ret) {
- dev_err(dev, "giving up");
- goto err_ret;
- }
- }
-
- printk(KERN_INFO DRIVER_NAME ": at CS%d (irq %d)\n",
- st->us->chip_select, st->us->irq);
-
- /* use high spi speed if possible */
- ret = adis16300_spi_read_reg_16(dev, ADIS16300_SMPL_PRD, &smp_prd);
- if (!ret && (smp_prd & ADIS16300_SMPL_PRD_DIV_MASK) < 0x0A) {
- st->us->max_speed_hz = ADIS16300_SPI_SLOW;
- spi_setup(st->us);
- }
-
-err_ret:
- return ret;
-}
-
-static IIO_DEV_ATTR_GYRO_X_CALIBBIAS(S_IWUSR | S_IRUGO,
- adis16300_read_12bit_signed,
- adis16300_write_16bit,
- ADIS16300_XGYRO_OFF);
-
-static IIO_DEV_ATTR_ACCEL_X_CALIBBIAS(S_IWUSR | S_IRUGO,
- adis16300_read_12bit_signed,
- adis16300_write_16bit,
- ADIS16300_XACCL_OFF);
-
-static IIO_DEV_ATTR_ACCEL_Y_CALIBBIAS(S_IWUSR | S_IRUGO,
- adis16300_read_12bit_signed,
- adis16300_write_16bit,
- ADIS16300_YACCL_OFF);
-
-static IIO_DEV_ATTR_ACCEL_Z_CALIBBIAS(S_IWUSR | S_IRUGO,
- adis16300_read_12bit_signed,
- adis16300_write_16bit,
- ADIS16300_ZACCL_OFF);
-
-static IIO_DEV_ATTR_IN_NAMED_RAW(supply, adis16300_read_14bit_unsigned,
- ADIS16300_SUPPLY_OUT);
-static IIO_CONST_ATTR_IN_NAMED_SCALE(supply, "0.00242");
-
-static IIO_DEV_ATTR_GYRO_X(adis16300_read_14bit_signed,
- ADIS16300_XGYRO_OUT);
-static IIO_CONST_ATTR_GYRO_SCALE("0.000872664");
-
-static IIO_DEV_ATTR_ACCEL_X(adis16300_read_14bit_signed,
- ADIS16300_XACCL_OUT);
-static IIO_DEV_ATTR_ACCEL_Y(adis16300_read_14bit_signed,
- ADIS16300_YACCL_OUT);
-static IIO_DEV_ATTR_ACCEL_Z(adis16300_read_14bit_signed,
- ADIS16300_ZACCL_OUT);
-static IIO_CONST_ATTR_ACCEL_SCALE("0.00588399");
-
-static IIO_DEV_ATTR_INCLI_X(adis16300_read_13bit_signed,
- ADIS16300_XINCLI_OUT);
-static IIO_DEV_ATTR_INCLI_Y(adis16300_read_13bit_signed,
- ADIS16300_YINCLI_OUT);
-static IIO_CONST_ATTR_INCLI_SCALE("0.00076794487");
-
-static IIO_DEV_ATTR_TEMP_RAW(adis16300_read_12bit_unsigned);
-static IIO_CONST_ATTR_TEMP_OFFSET("198.16");
-static IIO_CONST_ATTR_TEMP_SCALE("0.14");
-
-static IIO_DEV_ATTR_IN_RAW(0, adis16300_read_12bit_unsigned,
- ADIS16300_AUX_ADC);
-static IIO_CONST_ATTR(in0_scale, "0.000806");
-
-static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
- adis16300_read_frequency,
- adis16300_write_frequency);
-
-static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16300_write_reset, 0);
-
-static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("409 546 819 1638");
-
-static IIO_CONST_ATTR_NAME("adis16300");
-
-static struct attribute *adis16300_event_attributes[] = {
- NULL
-};
-
-static struct attribute_group adis16300_event_attribute_group = {
- .attrs = adis16300_event_attributes,
-};
-
-static struct attribute *adis16300_attributes[] = {
- &iio_dev_attr_gyro_x_calibbias.dev_attr.attr,
- &iio_dev_attr_accel_x_calibbias.dev_attr.attr,
- &iio_dev_attr_accel_y_calibbias.dev_attr.attr,
- &iio_dev_attr_accel_z_calibbias.dev_attr.attr,
- &iio_dev_attr_in_supply_raw.dev_attr.attr,
- &iio_const_attr_in_supply_scale.dev_attr.attr,
- &iio_dev_attr_gyro_x_raw.dev_attr.attr,
- &iio_const_attr_gyro_scale.dev_attr.attr,
- &iio_dev_attr_accel_x_raw.dev_attr.attr,
- &iio_dev_attr_accel_y_raw.dev_attr.attr,
- &iio_dev_attr_accel_z_raw.dev_attr.attr,
- &iio_const_attr_accel_scale.dev_attr.attr,
- &iio_dev_attr_incli_x_raw.dev_attr.attr,
- &iio_dev_attr_incli_y_raw.dev_attr.attr,
- &iio_const_attr_incli_scale.dev_attr.attr,
- &iio_dev_attr_temp_raw.dev_attr.attr,
- &iio_const_attr_temp_offset.dev_attr.attr,
- &iio_const_attr_temp_scale.dev_attr.attr,
- &iio_dev_attr_in0_raw.dev_attr.attr,
- &iio_const_attr_in0_scale.dev_attr.attr,
- &iio_dev_attr_sampling_frequency.dev_attr.attr,
- &iio_const_attr_sampling_frequency_available.dev_attr.attr,
- &iio_dev_attr_reset.dev_attr.attr,
- &iio_const_attr_name.dev_attr.attr,
- NULL
-};
-
-static const struct attribute_group adis16300_attribute_group = {
- .attrs = adis16300_attributes,
-};
-
-static int __devinit adis16300_probe(struct spi_device *spi)
-{
- int ret, regdone = 0;
- struct adis16300_state *st = kzalloc(sizeof *st, GFP_KERNEL);
- if (!st) {
- ret = -ENOMEM;
- goto error_ret;
- }
- /* this is only used for removal purposes */
- spi_set_drvdata(spi, st);
-
- /* Allocate the comms buffers */
- st->rx = kzalloc(sizeof(*st->rx)*ADIS16300_MAX_RX, GFP_KERNEL);
- if (st->rx == NULL) {
- ret = -ENOMEM;
- goto error_free_st;
- }
- st->tx = kzalloc(sizeof(*st->tx)*ADIS16300_MAX_TX, GFP_KERNEL);
- if (st->tx == NULL) {
- ret = -ENOMEM;
- goto error_free_rx;
- }
- st->us = spi;
- mutex_init(&st->buf_lock);
- /* setup the industrialio driver allocated elements */
- st->indio_dev = iio_allocate_device();
- if (st->indio_dev == NULL) {
- ret = -ENOMEM;
- goto error_free_tx;
- }
-
- st->indio_dev->dev.parent = &spi->dev;
- st->indio_dev->num_interrupt_lines = 1;
- st->indio_dev->event_attrs = &adis16300_event_attribute_group;
- st->indio_dev->attrs = &adis16300_attribute_group;
- st->indio_dev->dev_data = (void *)(st);
- st->indio_dev->driver_module = THIS_MODULE;
- st->indio_dev->modes = INDIO_DIRECT_MODE;
-
- ret = adis16300_configure_ring(st->indio_dev);
- if (ret)
- goto error_free_dev;
-
- ret = iio_device_register(st->indio_dev);
- if (ret)
- goto error_unreg_ring_funcs;
- regdone = 1;
-
- ret = iio_ring_buffer_register(st->indio_dev->ring, 0);
- if (ret) {
- printk(KERN_ERR "failed to initialize the ring\n");
- goto error_unreg_ring_funcs;
- }
-
- if (spi->irq) {
- ret = iio_register_interrupt_line(spi->irq,
- st->indio_dev,
- 0,
- IRQF_TRIGGER_RISING,
- "adis16300");
- if (ret)
- goto error_uninitialize_ring;
-
- ret = adis16300_probe_trigger(st->indio_dev);
- if (ret)
- goto error_unregister_line;
- }
-
- /* Get the device into a sane initial state */
- ret = adis16300_initial_setup(st);
- if (ret)
- goto error_remove_trigger;
- return 0;
-
-error_remove_trigger:
- adis16300_remove_trigger(st->indio_dev);
-error_unregister_line:
- if (spi->irq)
- iio_unregister_interrupt_line(st->indio_dev, 0);
-error_uninitialize_ring:
- iio_ring_buffer_unregister(st->indio_dev->ring);
-error_unreg_ring_funcs:
- adis16300_unconfigure_ring(st->indio_dev);
-error_free_dev:
- if (regdone)
- iio_device_unregister(st->indio_dev);
- else
- iio_free_device(st->indio_dev);
-error_free_tx:
- kfree(st->tx);
-error_free_rx:
- kfree(st->rx);
-error_free_st:
- kfree(st);
-error_ret:
- return ret;
-}
-
-static int adis16300_remove(struct spi_device *spi)
-{
- int ret;
- struct adis16300_state *st = spi_get_drvdata(spi);
- struct iio_dev *indio_dev = st->indio_dev;
-
- ret = adis16300_stop_device(&(indio_dev->dev));
- if (ret)
- goto err_ret;
-
- flush_scheduled_work();
-
- adis16300_remove_trigger(indio_dev);
- if (spi->irq)
- iio_unregister_interrupt_line(indio_dev, 0);
-
- iio_ring_buffer_unregister(indio_dev->ring);
- iio_device_unregister(indio_dev);
- adis16300_unconfigure_ring(indio_dev);
- kfree(st->tx);
- kfree(st->rx);
- kfree(st);
-
- return 0;
-
-err_ret:
- return ret;
-}
-
-static struct spi_driver adis16300_driver = {
- .driver = {
- .name = "adis16300",
- .owner = THIS_MODULE,
- },
- .probe = adis16300_probe,
- .remove = __devexit_p(adis16300_remove),
-};
-
-static __init int adis16300_init(void)
-{
- return spi_register_driver(&adis16300_driver);
-}
-module_init(adis16300_init);
-
-static __exit void adis16300_exit(void)
-{
- spi_unregister_driver(&adis16300_driver);
-}
-module_exit(adis16300_exit);
-
-MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
-MODULE_DESCRIPTION("Analog Devices ADIS16300 IMU SPI driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/staging/iio/imu/adis16300_ring.c b/drivers/staging/iio/imu/adis16300_ring.c
deleted file mode 100644
index 0e09051..0000000
--- a/drivers/staging/iio/imu/adis16300_ring.c
+++ /dev/null
@@ -1,220 +0,0 @@
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/gpio.h>
-#include <linux/workqueue.h>
-#include <linux/mutex.h>
-#include <linux/device.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/list.h>
-
-#include "../iio.h"
-#include "../sysfs.h"
-#include "../ring_sw.h"
-#include "../accel/accel.h"
-#include "../trigger.h"
-#include "adis16300.h"
-
-static IIO_SCAN_EL_C(in_supply, ADIS16300_SCAN_SUPPLY, IIO_UNSIGNED(14),
- ADIS16300_SUPPLY_OUT, NULL);
-
-static IIO_SCAN_EL_C(gyro_x, ADIS16300_SCAN_GYRO_X, IIO_SIGNED(14),
- ADIS16300_XGYRO_OUT, NULL);
-
-static IIO_SCAN_EL_C(accel_x, ADIS16300_SCAN_ACC_X, IIO_SIGNED(14),
- ADIS16300_XACCL_OUT, NULL);
-static IIO_SCAN_EL_C(accel_y, ADIS16300_SCAN_ACC_Y, IIO_SIGNED(14),
- ADIS16300_YACCL_OUT, NULL);
-static IIO_SCAN_EL_C(accel_z, ADIS16300_SCAN_ACC_Z, IIO_SIGNED(14),
- ADIS16300_ZACCL_OUT, NULL);
-
-static IIO_SCAN_EL_C(temp, ADIS16300_SCAN_TEMP, IIO_UNSIGNED(12),
- ADIS16300_TEMP_OUT, NULL);
-static IIO_SCAN_EL_C(in0, ADIS16300_SCAN_ADC_0, IIO_UNSIGNED(12),
- ADIS16300_AUX_ADC, NULL);
-
-static IIO_SCAN_EL_C(incli_x, ADIS16300_SCAN_INCLI_X, IIO_SIGNED(12),
- ADIS16300_XINCLI_OUT, NULL);
-static IIO_SCAN_EL_C(incli_y, ADIS16300_SCAN_INCLI_Y, IIO_SIGNED(12),
- ADIS16300_YINCLI_OUT, NULL);
-
-static IIO_SCAN_EL_TIMESTAMP(9);
-
-static struct attribute *adis16300_scan_el_attrs[] = {
- &iio_scan_el_in_supply.dev_attr.attr,
- &iio_scan_el_gyro_x.dev_attr.attr,
- &iio_scan_el_temp.dev_attr.attr,
- &iio_scan_el_accel_x.dev_attr.attr,
- &iio_scan_el_accel_y.dev_attr.attr,
- &iio_scan_el_accel_z.dev_attr.attr,
- &iio_scan_el_incli_x.dev_attr.attr,
- &iio_scan_el_incli_y.dev_attr.attr,
- &iio_scan_el_in0.dev_attr.attr,
- &iio_scan_el_timestamp.dev_attr.attr,
- NULL,
-};
-
-static struct attribute_group adis16300_scan_el_group = {
- .attrs = adis16300_scan_el_attrs,
- .name = "scan_elements",
-};
-
-/**
- * adis16300_poll_func_th() top half interrupt handler called by trigger
- * @private_data: iio_dev
- **/
-static void adis16300_poll_func_th(struct iio_dev *indio_dev, s64 time)
-{
- struct adis16300_state *st = iio_dev_get_devdata(indio_dev);
- st->last_timestamp = time;
- schedule_work(&st->work_trigger_to_ring);
- /* Indicate that this interrupt is being handled */
-
- /* Technically this is trigger related, but without this
- * handler running there is currently no way for the interrupt
- * to clear.
- */
-}
-
-/**
- * adis16300_spi_read_burst() - read all data registers
- * @dev: device associated with child of actual device (iio_dev or iio_trig)
- * @rx: somewhere to pass back the value read (min size is 24 bytes)
- **/
-static int adis16300_spi_read_burst(struct device *dev, u8 *rx)
-{
- struct spi_message msg;
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- struct adis16300_state *st = iio_dev_get_devdata(indio_dev);
- u32 old_speed_hz = st->us->max_speed_hz;
- int ret;
-
- struct spi_transfer xfers[] = {
- {
- .tx_buf = st->tx,
- .bits_per_word = 8,
- .len = 2,
- .cs_change = 0,
- }, {
- .rx_buf = rx,
- .bits_per_word = 8,
- .len = 18,
- .cs_change = 0,
- },
- };
-
- mutex_lock(&st->buf_lock);
- st->tx[0] = ADIS16300_READ_REG(ADIS16300_GLOB_CMD);
- st->tx[1] = 0;
-
- spi_message_init(&msg);
- spi_message_add_tail(&xfers[0], &msg);
- spi_message_add_tail(&xfers[1], &msg);
-
- st->us->max_speed_hz = ADIS16300_SPI_BURST;
- spi_setup(st->us);
-
- ret = spi_sync(st->us, &msg);
- if (ret)
- dev_err(&st->us->dev, "problem when burst reading");
-
- st->us->max_speed_hz = old_speed_hz;
- spi_setup(st->us);
- mutex_unlock(&st->buf_lock);
- return ret;
-}
-
-/* Whilst this makes a lot of calls to iio_sw_ring functions - it is to device
- * specific to be rolled into the core.
- */
-static void adis16300_trigger_bh_to_ring(struct work_struct *work_s)
-{
- struct adis16300_state *st
- = container_of(work_s, struct adis16300_state,
- work_trigger_to_ring);
- struct iio_ring_buffer *ring = st->indio_dev->ring;
-
- int i = 0;
- s16 *data;
- size_t datasize = ring->access.get_bytes_per_datum(ring);
-
- data = kmalloc(datasize , GFP_KERNEL);
- if (data == NULL) {
- dev_err(&st->us->dev, "memory alloc failed in ring bh");
- return;
- }
-
- if (ring->scan_count)
- if (adis16300_spi_read_burst(&st->indio_dev->dev, st->rx) >= 0)
- for (; i < ring->scan_count; i++)
- data[i] = be16_to_cpup(
- (__be16 *)&(st->rx[i*2]));
-
- /* Guaranteed to be aligned with 8 byte boundary */
- if (ring->scan_timestamp)
- *((s64 *)(data + ((i + 3)/4)*4)) = st->last_timestamp;
-
- ring->access.store_to(ring,
- (u8 *)data,
- st->last_timestamp);
-
- iio_trigger_notify_done(st->indio_dev->trig);
- kfree(data);
-
- return;
-}
-
-void adis16300_unconfigure_ring(struct iio_dev *indio_dev)
-{
- kfree(indio_dev->pollfunc);
- iio_sw_rb_free(indio_dev->ring);
-}
-
-int adis16300_configure_ring(struct iio_dev *indio_dev)
-{
- int ret = 0;
- struct adis16300_state *st = indio_dev->dev_data;
- struct iio_ring_buffer *ring;
- INIT_WORK(&st->work_trigger_to_ring, adis16300_trigger_bh_to_ring);
-
- ring = iio_sw_rb_allocate(indio_dev);
- if (!ring) {
- ret = -ENOMEM;
- return ret;
- }
- indio_dev->ring = ring;
- /* Effectively select the ring buffer implementation */
- iio_ring_sw_register_funcs(&ring->access);
- ring->bpe = 2;
- ring->scan_el_attrs = &adis16300_scan_el_group;
- ring->scan_timestamp = true;
- ring->preenable = &iio_sw_ring_preenable;
- ring->postenable = &iio_triggered_ring_postenable;
- ring->predisable = &iio_triggered_ring_predisable;
- ring->owner = THIS_MODULE;
-
- /* Set default scan mode */
- iio_scan_mask_set(ring, iio_scan_el_in_supply.number);
- iio_scan_mask_set(ring, iio_scan_el_gyro_x.number);
- iio_scan_mask_set(ring, iio_scan_el_accel_x.number);
- iio_scan_mask_set(ring, iio_scan_el_accel_y.number);
- iio_scan_mask_set(ring, iio_scan_el_accel_z.number);
- iio_scan_mask_set(ring, iio_scan_el_temp.number);
- iio_scan_mask_set(ring, iio_scan_el_in0.number);
- iio_scan_mask_set(ring, iio_scan_el_incli_x.number);
- iio_scan_mask_set(ring, iio_scan_el_incli_y.number);
-
- ret = iio_alloc_pollfunc(indio_dev, NULL, &adis16300_poll_func_th);
- if (ret)
- goto error_iio_sw_rb_free;
-
- indio_dev->modes |= INDIO_RING_TRIGGERED;
- return 0;
-
-error_iio_sw_rb_free:
- iio_sw_rb_free(indio_dev->ring);
- return ret;
-}
-
diff --git a/drivers/staging/iio/imu/adis16300_trigger.c b/drivers/staging/iio/imu/adis16300_trigger.c
deleted file mode 100644
index d6677b6..0000000
--- a/drivers/staging/iio/imu/adis16300_trigger.c
+++ /dev/null
@@ -1,125 +0,0 @@
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/mutex.h>
-#include <linux/device.h>
-#include <linux/kernel.h>
-#include <linux/sysfs.h>
-#include <linux/list.h>
-#include <linux/spi/spi.h>
-
-#include "../iio.h"
-#include "../sysfs.h"
-#include "../trigger.h"
-#include "adis16300.h"
-
-/**
- * adis16300_data_rdy_trig_poll() the event handler for the data rdy trig
- **/
-static int adis16300_data_rdy_trig_poll(struct iio_dev *dev_info,
- int index,
- s64 timestamp,
- int no_test)
-{
- struct adis16300_state *st = iio_dev_get_devdata(dev_info);
- struct iio_trigger *trig = st->trig;
-
- iio_trigger_poll(trig, timestamp);
-
- return IRQ_HANDLED;
-}
-
-IIO_EVENT_SH(data_rdy_trig, &adis16300_data_rdy_trig_poll);
-
-static IIO_TRIGGER_NAME_ATTR;
-
-static struct attribute *adis16300_trigger_attrs[] = {
- &dev_attr_name.attr,
- NULL,
-};
-
-static const struct attribute_group adis16300_trigger_attr_group = {
- .attrs = adis16300_trigger_attrs,
-};
-
-/**
- * adis16300_data_rdy_trigger_set_state() set datardy interrupt state
- **/
-static int adis16300_data_rdy_trigger_set_state(struct iio_trigger *trig,
- bool state)
-{
- struct adis16300_state *st = trig->private_data;
- struct iio_dev *indio_dev = st->indio_dev;
- int ret = 0;
-
- dev_dbg(&indio_dev->dev, "%s (%d)\n", __func__, state);
- ret = adis16300_set_irq(&st->indio_dev->dev, state);
- if (state == false) {
- iio_remove_event_from_list(&iio_event_data_rdy_trig,
- &indio_dev->interrupts[0]
- ->ev_list);
- /* possible quirk with handler currently worked around
- by ensuring the work queue is empty */
- flush_scheduled_work();
- } else {
- iio_add_event_to_list(&iio_event_data_rdy_trig,
- &indio_dev->interrupts[0]->ev_list);
- }
- return ret;
-}
-
-/**
- * adis16300_trig_try_reen() try renabling irq for data rdy trigger
- * @trig: the datardy trigger
- **/
-static int adis16300_trig_try_reen(struct iio_trigger *trig)
-{
- struct adis16300_state *st = trig->private_data;
- enable_irq(st->us->irq);
- /* irq reenabled so success! */
- return 0;
-}
-
-int adis16300_probe_trigger(struct iio_dev *indio_dev)
-{
- int ret;
- struct adis16300_state *st = indio_dev->dev_data;
-
- st->trig = iio_allocate_trigger();
- st->trig->name = kasprintf(GFP_KERNEL,
- "adis16300-dev%d",
- indio_dev->id);
- if (!st->trig->name) {
- ret = -ENOMEM;
- goto error_free_trig;
- }
- st->trig->dev.parent = &st->us->dev;
- st->trig->owner = THIS_MODULE;
- st->trig->private_data = st;
- st->trig->set_trigger_state = &adis16300_data_rdy_trigger_set_state;
- st->trig->try_reenable = &adis16300_trig_try_reen;
- st->trig->control_attrs = &adis16300_trigger_attr_group;
- ret = iio_trigger_register(st->trig);
-
- /* select default trigger */
- indio_dev->trig = st->trig;
- if (ret)
- goto error_free_trig_name;
-
- return 0;
-
-error_free_trig_name:
- kfree(st->trig->name);
-error_free_trig:
- iio_free_trigger(st->trig);
-
- return ret;
-}
-
-void adis16300_remove_trigger(struct iio_dev *indio_dev)
-{
- struct adis16300_state *state = indio_dev->dev_data;
-
- iio_trigger_unregister(state->trig);
- kfree(state->trig->name);
- iio_free_trigger(state->trig);
-}
diff --git a/drivers/staging/iio/imu/adis16350.h b/drivers/staging/iio/imu/adis16350.h
index 2d8080e..b7c9052 100644
--- a/drivers/staging/iio/imu/adis16350.h
+++ b/drivers/staging/iio/imu/adis16350.h
@@ -19,6 +19,10 @@
#define ADIS16350_ZTEMP_OUT 0x14 /* Z-axis gyroscope temperature measurement */
#define ADIS16350_AUX_ADC 0x16 /* Auxiliary ADC measurement */
+#define ADIS16300_TEMP_OUT 0x10 /* Temperature output */
+#define ADIS16300_XINCLI_OUT 0x12 /* X-axis inclinometer output measurement */
+#define ADIS16300_YINCLI_OUT 0x14 /* Y-axis inclinometer output measurement */
+
/* Calibration parameters */
#define ADIS16350_XGYRO_OFF 0x1A /* X-axis gyroscope bias offset factor */
#define ADIS16350_YGYRO_OFF 0x1C /* Y-axis gyroscope bias offset factor */
@@ -96,6 +100,34 @@
#define ADIS16350_SPI_BURST (u32)(1000 * 1000)
#define ADIS16350_SPI_FAST (u32)(2000 * 1000)
+enum adis16350_chip_variants {
+ adis16300,
+ adis16350,
+ adis16360,
+};
+
+extern struct attribute_group adis16300_scan_el_group;
+extern struct attribute_group adis16350_scan_el_group;
+
+/**
+ * struct adis16350_chip_info - chip type specific parameters
+ * @attribute_group: sysfs attributes for this variant
+ * @burst_available: does the device support burst reading
+ * @gyro_scale: the scale factor to convert to radians / sec
+ * @accel_scale: the scale factor to convert to m/s^2
+ * @burst_length: the number of bytes needed for a burst read
+ * @all_mask: a bit mask specifying which scan elements exist
+ **/
+struct adis16350_chip_info {
+ const struct attribute_group *attribute_group;
+ struct attribute_group *scan_el_group;
+ unsigned burst_available:1;
+ const char *gyro_scale;
+ const char *accel_scale;
+ u8 burst_length;
+ ulong all_mask;
+};
+
/**
* struct adis16350_state - device instance specific data
* @us: actual spi_device
@@ -103,6 +135,7 @@
* @inter: used to check if new interrupt has been triggered
* @last_timestamp: passing timestamp from th to bh of interrupt handler
* @indio_dev: industrial I/O device structure
+ * @variant: structure providing chip variant specific data
* @trig: data ready trigger registered with iio
* @tx: transmit buffer
* @rx: recieve buffer
@@ -121,6 +154,7 @@ struct adis16350_state {
struct work_struct work_trigger_to_ring;
s64 last_timestamp;
struct iio_dev *indio_dev;
+ struct adis16350_chip_info *variant;
struct iio_trigger *trig;
u8 *tx;
u8 *rx;
@@ -164,6 +198,9 @@ static inline void adis16350_unconfigure_event_line(struct adis16350_state *st)
}
#endif
+/**
+ * All we guarantee with these is that they are monotonic
+ **/
#define ADIS16350_SCAN_IN_SUPPLY 0
#define ADIS16350_SCAN_GYRO_X 1
#define ADIS16350_SCAN_GYRO_Y 2
@@ -171,9 +208,12 @@ static inline void adis16350_unconfigure_event_line(struct adis16350_state *st)
#define ADIS16350_SCAN_ACCEL_X 4
#define ADIS16350_SCAN_ACCEL_Y 5
#define ADIS16350_SCAN_ACCEL_Z 6
+#define ADIS16300_SCAN_TEMP 7
#define ADIS16350_SCAN_TEMP_X 7
#define ADIS16350_SCAN_TEMP_Y 8
+#define ADIS16300_SCAN_INCLI_X 8
#define ADIS16350_SCAN_TEMP_Z 9
+#define ADIS16300_SCAN_INCLI_Y 9
#define ADIS16350_SCAN_IN0 10
#ifdef CONFIG_IIO_RING_BUFFER
diff --git a/drivers/staging/iio/imu/adis16350_core.c b/drivers/staging/iio/imu/adis16350_core.c
index dc83489..f154886 100644
--- a/drivers/staging/iio/imu/adis16350_core.c
+++ b/drivers/staging/iio/imu/adis16350_core.c
@@ -22,6 +22,7 @@
#include "../sysfs.h"
#include "../ring_generic.h"
#include "../accel/accel.h"
+#include "../accel/inclinometer.h"
#include "../adc/adc.h"
#include "../gyro/gyro.h"
@@ -224,6 +225,21 @@ static ssize_t adis16350_read_12bit_signed(struct device *dev,
return ret;
}
+static ssize_t adis16350_read_13bit_signed(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct iio_dev *indio_dev = dev_get_drvdata(dev);
+ ssize_t ret;
+
+ /* Take the iio_dev status lock */
+ mutex_lock(&indio_dev->mlock);
+ ret = adis16350_spi_read_signed(dev, attr, buf, 13);
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
static ssize_t adis16350_write_16bit(struct device *dev,
struct device_attribute *attr,
const char *buf,
@@ -515,7 +531,16 @@ static IIO_DEV_ATTR_GYRO_Y(adis16350_read_14bit_signed,
ADIS16350_YGYRO_OUT);
static IIO_DEV_ATTR_GYRO_Z(adis16350_read_14bit_signed,
ADIS16350_ZGYRO_OUT);
-static IIO_CONST_ATTR_GYRO_SCALE("0.00127862821");
+
+static ssize_t adis16350_show_gyro_scale(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct iio_dev *dev_info = dev_get_drvdata(dev);
+ struct adis16350_state *st = iio_dev_get_devdata(dev_info);
+ return sprintf(buf, "%s\n", st->variant->gyro_scale);
+}
+static IIO_DEV_ATTR_GYRO_SCALE(S_IRUGO, adis16350_show_gyro_scale, NULL, 0);
static IIO_DEV_ATTR_ACCEL_X(adis16350_read_14bit_signed,
ADIS16350_XACCL_OUT);
@@ -523,7 +548,16 @@ static IIO_DEV_ATTR_ACCEL_Y(adis16350_read_14bit_signed,
ADIS16350_YACCL_OUT);
static IIO_DEV_ATTR_ACCEL_Z(adis16350_read_14bit_signed,
ADIS16350_ZACCL_OUT);
-static IIO_CONST_ATTR_ACCEL_SCALE("0.0247323713");
+
+static ssize_t adis16350_show_accel_scale(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct iio_dev *dev_info = dev_get_drvdata(dev);
+ struct adis16350_state *st = iio_dev_get_devdata(dev_info);
+ return sprintf(buf, "%s\n", st->variant->accel_scale);
+}
+static IIO_DEV_ATTR_ACCEL_SCALE(S_IRUGO, adis16350_show_accel_scale, NULL, 0);
static IIO_DEVICE_ATTR(temp_x_raw, S_IRUGO, adis16350_read_12bit_signed,
NULL, ADIS16350_XTEMP_OUT);
@@ -547,7 +581,16 @@ static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL,
static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("409 546 819 1638");
-static IIO_CONST_ATTR_NAME("adis16350");
+
+static ssize_t adis16350_show_name(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct iio_dev *dev_info = dev_get_drvdata(dev);
+ struct adis16350_state *st = iio_dev_get_devdata(dev_info);
+ return sprintf(buf, "%s\n", spi_get_device_id(st->us)->name);
+}
+static IIO_DEVICE_ATTR(name, S_IRUGO, adis16350_show_name, NULL, 0);
static struct attribute *adis16350_attributes[] = {
&iio_dev_attr_gyro_x_calibbias.dev_attr.attr,
@@ -561,11 +604,11 @@ static struct attribute *adis16350_attributes[] = {
&iio_dev_attr_gyro_x_raw.dev_attr.attr,
&iio_dev_attr_gyro_y_raw.dev_attr.attr,
&iio_dev_attr_gyro_z_raw.dev_attr.attr,
- &iio_const_attr_gyro_scale.dev_attr.attr,
+ &iio_dev_attr_gyro_scale.dev_attr.attr,
&iio_dev_attr_accel_x_raw.dev_attr.attr,
&iio_dev_attr_accel_y_raw.dev_attr.attr,
&iio_dev_attr_accel_z_raw.dev_attr.attr,
- &iio_const_attr_accel_scale.dev_attr.attr,
+ &iio_dev_attr_accel_scale.dev_attr.attr,
&iio_dev_attr_temp_x_raw.dev_attr.attr,
&iio_dev_attr_temp_y_raw.dev_attr.attr,
&iio_dev_attr_temp_z_raw.dev_attr.attr,
@@ -576,7 +619,7 @@ static struct attribute *adis16350_attributes[] = {
&iio_dev_attr_sampling_frequency.dev_attr.attr,
&iio_const_attr_sampling_frequency_available.dev_attr.attr,
&iio_dev_attr_reset.dev_attr.attr,
- &iio_const_attr_name.dev_attr.attr,
+ &iio_dev_attr_name.dev_attr.attr,
NULL
};
@@ -584,6 +627,111 @@ static const struct attribute_group adis16350_attribute_group = {
.attrs = adis16350_attributes,
};
+#define ADIS16300_TEMP_OUT 0x10 /* Temperature output */
+#define ADIS16300_XINCLI_OUT 0x12 /* X-axis inclinometer output measurement */
+#define ADIS16300_YINCLI_OUT 0x14 /* Y-axis inclinometer output measurement */
+
+static IIO_DEVICE_ATTR(temp_raw, S_IRUGO, adis16350_read_12bit_unsigned,
+ NULL, ADIS16300_TEMP_OUT);
+
+static IIO_DEV_ATTR_INCLI_X(adis16350_read_13bit_signed,
+ ADIS16300_XINCLI_OUT);
+static IIO_DEV_ATTR_INCLI_Y(adis16350_read_13bit_signed,
+ ADIS16300_YINCLI_OUT);
+static IIO_CONST_ATTR_INCLI_SCALE("0.00076794487");
+
+static struct attribute *adis16300_attributes[] = {
+ &iio_dev_attr_gyro_x_calibbias.dev_attr.attr,
+ &iio_dev_attr_accel_x_calibbias.dev_attr.attr,
+ &iio_dev_attr_accel_y_calibbias.dev_attr.attr,
+ &iio_dev_attr_accel_z_calibbias.dev_attr.attr,
+ &iio_dev_attr_in_supply_raw.dev_attr.attr,
+ &iio_const_attr_in_supply_scale.dev_attr.attr,
+ &iio_dev_attr_gyro_z_raw.dev_attr.attr,
+ &iio_dev_attr_gyro_scale.dev_attr.attr,
+ &iio_dev_attr_accel_x_raw.dev_attr.attr,
+ &iio_dev_attr_accel_y_raw.dev_attr.attr,
+ &iio_dev_attr_accel_z_raw.dev_attr.attr,
+ &iio_dev_attr_accel_scale.dev_attr.attr,
+ &iio_dev_attr_incli_x_raw.dev_attr.attr,
+ &iio_dev_attr_incli_y_raw.dev_attr.attr,
+ &iio_const_attr_incli_scale.dev_attr.attr,
+ &iio_dev_attr_temp_raw.dev_attr.attr,
+ &iio_const_attr_temp_offset.dev_attr.attr,
+ &iio_const_attr_temp_scale.dev_attr.attr,
+ &iio_dev_attr_in0_raw.dev_attr.attr,
+ &iio_const_attr_in0_scale.dev_attr.attr,
+ &iio_dev_attr_sampling_frequency.dev_attr.attr,
+ &iio_const_attr_sampling_frequency_available.dev_attr.attr,
+ &iio_dev_attr_reset.dev_attr.attr,
+ &iio_dev_attr_name.dev_attr.attr,
+ NULL
+};
+
+static const struct attribute_group adis16300_attribute_group = {
+ .attrs = adis16300_attributes,
+};
+
+static struct adis16350_chip_info adis16350_variants[] = {
+ [adis16300] = {
+ .attribute_group = &adis16300_attribute_group,
+ .scan_el_group = &adis16300_scan_el_group,
+ .burst_available = 1,
+ .gyro_scale = "0.000872664",
+ .accel_scale = "0.00588399",
+ .burst_length = 18,
+ .all_mask =
+ BIT(ADIS16350_SCAN_IN_SUPPLY) |
+ BIT(ADIS16350_SCAN_GYRO_Z) |
+ BIT(ADIS16350_SCAN_ACCEL_X) |
+ BIT(ADIS16350_SCAN_ACCEL_Y) |
+ BIT(ADIS16350_SCAN_ACCEL_Z) |
+ BIT(ADIS16300_SCAN_TEMP) |
+ BIT(ADIS16300_SCAN_INCLI_X) |
+ BIT(ADIS16300_SCAN_INCLI_Y) |
+ BIT(ADIS16350_SCAN_IN0),
+ },
+ [adis16350] = {
+ .attribute_group = &adis16350_attribute_group,
+ .scan_el_group = &adis16350_scan_el_group,
+ .burst_available = 0,
+ .gyro_scale = "0.00127862821",
+ .accel_scale = "0.0247323713",
+ .all_mask =
+ BIT(ADIS16350_SCAN_IN_SUPPLY) |
+ BIT(ADIS16350_SCAN_GYRO_X) |
+ BIT(ADIS16350_SCAN_GYRO_Y) |
+ BIT(ADIS16350_SCAN_GYRO_Z) |
+ BIT(ADIS16350_SCAN_ACCEL_X) |
+ BIT(ADIS16350_SCAN_ACCEL_Y) |
+ BIT(ADIS16350_SCAN_ACCEL_Z) |
+ BIT(ADIS16350_SCAN_TEMP_X) |
+ BIT(ADIS16350_SCAN_TEMP_Y) |
+ BIT(ADIS16350_SCAN_TEMP_Z) |
+ BIT(ADIS16350_SCAN_IN0),
+ },
+ [adis16360] = {
+ .attribute_group = &adis16350_attribute_group,
+ .scan_el_group = &adis16350_scan_el_group,
+ .burst_available = 1,
+ .gyro_scale = "0.00127862821",
+ .accel_scale = "0.0247323713",
+ .burst_length = 22,
+ .all_mask =
+ BIT(ADIS16350_SCAN_IN_SUPPLY) |
+ BIT(ADIS16350_SCAN_GYRO_X) |
+ BIT(ADIS16350_SCAN_GYRO_Y) |
+ BIT(ADIS16350_SCAN_GYRO_Z) |
+ BIT(ADIS16350_SCAN_ACCEL_X) |
+ BIT(ADIS16350_SCAN_ACCEL_Y) |
+ BIT(ADIS16350_SCAN_ACCEL_Z) |
+ BIT(ADIS16350_SCAN_TEMP_X) |
+ BIT(ADIS16350_SCAN_TEMP_Y) |
+ BIT(ADIS16350_SCAN_TEMP_Z) |
+ BIT(ADIS16350_SCAN_IN0),
+ },
+};
+
static int __devinit adis16350_probe(struct spi_device *spi)
{
int ret, regdone = 0;
@@ -608,7 +756,8 @@ static int __devinit adis16350_probe(struct spi_device *spi)
}
st->us = spi;
mutex_init(&st->buf_lock);
- st->burst_available = spi_get_device_id(spi)->driver_data;
+ st->variant = &adis16350_variants[spi_get_device_id(spi)->driver_data];
+
/* setup the industrialio driver allocated elements */
st->indio_dev = iio_allocate_device();
if (st->indio_dev == NULL) {
@@ -642,10 +791,16 @@ static int __devinit adis16350_probe(struct spi_device *spi)
if (ret)
goto error_uninitialize_ring;
}
- /* The event irq */
- if (spi->dev.platform_data) {
+ /*
+ * The event irq - currently only supported in the adis16350
+ * and adis16360 famillies.
+ */
+ if (spi->dev.platform_data &&
+ (spi_get_device_id(spi)->driver_data == adis16350 ||
+ spi_get_device_id(spi)->driver_data == adis16360)) {
ret = adis16350_configure_event_line(st,
- *(int *)spi->dev.platform_data);
+ *(int *)spi
+ ->dev.platform_data);
if (ret)
goto error_remove_trigger;
}
@@ -709,13 +864,14 @@ err_ret:
}
static const struct spi_device_id adis16350_id[] = {
- {"adis16350", 0},
- {"adis16354", 0},
- {"adis16355", 0},
- {"adis16360", 1},
- {"adis16362", 1},
- {"adis16364", 1},
- {"adis16365", 1},
+ {"adis16300", adis16300},
+ {"adis16350", adis16350},
+ {"adis16354", adis16350},
+ {"adis16355", adis16350},
+ {"adis16360", adis16360},
+ {"adis16362", adis16360},
+ {"adis16364", adis16360},
+ {"adis16365", adis16360},
{}
};
diff --git a/drivers/staging/iio/imu/adis16350_ring.c b/drivers/staging/iio/imu/adis16350_ring.c
index 9af0345..37ec884 100644
--- a/drivers/staging/iio/imu/adis16350_ring.c
+++ b/drivers/staging/iio/imu/adis16350_ring.c
@@ -62,10 +62,35 @@ static struct attribute *adis16350_scan_el_attrs[] = {
NULL,
};
-static struct attribute_group adis16350_scan_el_group = {
+struct attribute_group adis16350_scan_el_group = {
.attrs = adis16350_scan_el_attrs,
.name = "scan_elements",
};
+static IIO_SCAN_EL_C(incli_x, ADIS16300_SCAN_INCLI_X, IIO_SIGNED(12),
+ ADIS16300_XINCLI_OUT, NULL);
+static IIO_SCAN_EL_C(incli_y, ADIS16300_SCAN_INCLI_Y, IIO_SIGNED(12),
+ ADIS16300_YINCLI_OUT, NULL);
+static IIO_SCAN_EL_C(temp, ADIS16300_SCAN_TEMP, IIO_UNSIGNED(12),
+ ADIS16300_TEMP_OUT, NULL);
+
+static struct attribute *adis16300_scan_el_attrs[] = {
+ &iio_scan_el_in_supply.dev_attr.attr,
+ &iio_scan_el_gyro_x.dev_attr.attr,
+ &iio_scan_el_temp.dev_attr.attr,
+ &iio_scan_el_accel_x.dev_attr.attr,
+ &iio_scan_el_accel_y.dev_attr.attr,
+ &iio_scan_el_accel_z.dev_attr.attr,
+ &iio_scan_el_incli_x.dev_attr.attr,
+ &iio_scan_el_incli_y.dev_attr.attr,
+ &iio_scan_el_in0.dev_attr.attr,
+ &iio_scan_el_timestamp.dev_attr.attr,
+ NULL,
+};
+
+struct attribute_group adis16300_scan_el_group = {
+ .attrs = adis16300_scan_el_attrs,
+ .name = "scan_elements",
+};
/**
* adis16350_poll_func_th() top half interrupt handler called by trigger
@@ -100,7 +125,7 @@ static int adis16350_spi_read_burst(struct device *dev, u8 *rx)
}, {
.rx_buf = rx,
.bits_per_word = 8,
- .len = 22,
+ .len = st->variant->burst_length,
.cs_change = 0,
},
};
@@ -126,7 +151,8 @@ static int adis16350_spi_read_burst(struct device *dev, u8 *rx)
return ret;
}
-static const u16 read_all_tx_array[] = {
+/* So far only the adis16350 familly requires this */
+static const u16 adis16350_read_all_tx_array[] = {
be16_to_cpu(ADIS16350_READ_REG(ADIS16350_SUPPLY_OUT)),
be16_to_cpu(ADIS16350_READ_REG(ADIS16350_XGYRO_OUT)),
be16_to_cpu(ADIS16350_READ_REG(ADIS16350_YGYRO_OUT)),
@@ -155,9 +181,9 @@ static int adis16350_spi_read_all(struct device *dev, u16 *rx_array)
if (xfers == NULL)
return -ENOMEM;
- for (i = 0; i < ARRAY_SIZE(read_all_tx_array); i++)
+ for (i = 0; i < ARRAY_SIZE(adis16350_read_all_tx_array); i++)
if (st->indio_dev->ring->scan_mask & (1 << i)) {
- xfers[j].tx_buf = &read_all_tx_array[i];
+ xfers[j].tx_buf = &adis16350_read_all_tx_array[i];
xfers[j].bits_per_word = 16;
xfers[j].len = 2;
xfers[j + 1].rx_buf = rx_array + j;
@@ -197,15 +223,22 @@ static void adis16350_trigger_bh_to_ring(struct work_struct *work_s)
}
if (ring->scan_count) {
- if (st->burst_available) {
+ if (st->variant->burst_available) {
if (adis16350_spi_read_burst(&st->indio_dev->dev,
- st->rx) < 0)
+ st->rx) < 0)
return;
- for (; i < ring->scan_count; i++)
- if (st->indio_dev->ring->scan_mask & (1 << i))
- data[j++] = le16_to_cpup(
+ /* This compexity is to allow for devices supported by
+ * the same driver to include non contiguous sets of
+ * channels
+ */
+ for_each_set_bit(i, &st->variant->all_mask,
+ sizeof(st->variant->all_mask)*
+ BITS_PER_BYTE)
+ if (st->indio_dev->ring->scan_mask & BIT(i))
+ data[j++] = le16_to_cpup(
(__le16 *)&(st->rx[i*2]));
} else {
+ /* adis16350 only so far */
if (adis16350_spi_read_all(&st->indio_dev->dev,
(u16 *)st->rx) < 0)
return;
@@ -249,7 +282,7 @@ int adis16350_configure_ring(struct iio_dev *indio_dev)
/* Effectively select the ring buffer implementation */
iio_ring_sw_register_funcs(&ring->access);
ring->bpe = 2;
- ring->scan_el_attrs = &adis16350_scan_el_group;
+ ring->scan_el_attrs = st->variant->scan_el_group;
ring->scan_timestamp = true;
ring->preenable = &iio_sw_ring_preenable;
ring->postenable = &iio_triggered_ring_postenable;
@@ -257,17 +290,7 @@ int adis16350_configure_ring(struct iio_dev *indio_dev)
ring->owner = THIS_MODULE;
/* Set default scan mode */
- iio_scan_mask_set(ring, iio_scan_el_in_supply.number);
- iio_scan_mask_set(ring, iio_scan_el_gyro_x.number);
- iio_scan_mask_set(ring, iio_scan_el_gyro_y.number);
- iio_scan_mask_set(ring, iio_scan_el_gyro_z.number);
- iio_scan_mask_set(ring, iio_scan_el_accel_x.number);
- iio_scan_mask_set(ring, iio_scan_el_accel_y.number);
- iio_scan_mask_set(ring, iio_scan_el_accel_z.number);
- iio_scan_mask_set(ring, iio_scan_el_temp_x.number);
- iio_scan_mask_set(ring, iio_scan_el_temp_y.number);
- iio_scan_mask_set(ring, iio_scan_el_temp_z.number);
- iio_scan_mask_set(ring, iio_scan_el_in0.number);
+ ring->scan_mask = st->variant->all_mask;
ret = iio_alloc_pollfunc(indio_dev, NULL, &adis16350_poll_func_th);
if (ret)
--
1.7.2.2
^ permalink raw reply related [flat|nested] 12+ messages in thread* Re: [PATCH 5/6] staging:iio:adis16300 merge into adis16350 driver
2010-09-11 14:58 ` [PATCH 5/6] staging:iio:adis16300 merge into adis16350 driver Jonathan Cameron
@ 2010-09-18 16:06 ` Jonathan Cameron
0 siblings, 0 replies; 12+ messages in thread
From: Jonathan Cameron @ 2010-09-18 16:06 UTC (permalink / raw)
To: Jonathan Cameron; +Cc: linux-iio, Michael.Hennerich, Robin.Getz, manuel.stahl
...
> +static struct attribute *adis16300_attributes[] = {
> + &iio_dev_attr_gyro_x_calibbias.dev_attr.attr,
> + &iio_dev_attr_accel_x_calibbias.dev_attr.attr,
> + &iio_dev_attr_accel_y_calibbias.dev_attr.attr,
> + &iio_dev_attr_accel_z_calibbias.dev_attr.attr,
> + &iio_dev_attr_in_supply_raw.dev_attr.attr,
> + &iio_const_attr_in_supply_scale.dev_attr.attr,
> + &iio_dev_attr_gyro_z_raw.dev_attr.attr,
> + &iio_dev_attr_gyro_scale.dev_attr.attr,
> + &iio_dev_attr_accel_x_raw.dev_attr.attr,
> + &iio_dev_attr_accel_y_raw.dev_attr.attr,
> + &iio_dev_attr_accel_z_raw.dev_attr.attr,
> + &iio_dev_attr_accel_scale.dev_attr.attr,
> + &iio_dev_attr_incli_x_raw.dev_attr.attr,
> + &iio_dev_attr_incli_y_raw.dev_attr.attr,
> + &iio_const_attr_incli_scale.dev_attr.attr,
> + &iio_dev_attr_temp_raw.dev_attr.attr,
> + &iio_const_attr_temp_offset.dev_attr.attr,
> + &iio_const_attr_temp_scale.dev_attr.attr,
> + &iio_dev_attr_in0_raw.dev_attr.attr,
> + &iio_const_attr_in0_scale.dev_attr.attr,
> + &iio_dev_attr_sampling_frequency.dev_attr.attr,
> + &iio_const_attr_sampling_frequency_available.dev_attr.attr,
> + &iio_dev_attr_reset.dev_attr.attr,
> + &iio_dev_attr_name.dev_attr.attr,
> + NULL
> +};
> +
> +static const struct attribute_group adis16300_attribute_group = {
> + .attrs = adis16300_attributes,
> +};
> +
> +static struct adis16350_chip_info adis16350_variants[] = {
> + [adis16300] = {
> + .attribute_group = &adis16300_attribute_group,
The complexity with building is here. If we aren't building with
CONFIG_IIO_RING_BUFFER then the right had side of this statement
does not exist. Updated patch puts an ifdef around here.
It's not pretty but I can't work out any other way of doing it.
Jonathan
> + .scan_el_group = &adis16300_scan_el_group,
> + .burst_available = 1,
> + .gyro_scale = "0.000872664",
> + .accel_scale = "0.00588399",
> + .burst_length = 18,
> + .all_mask =
> + BIT(ADIS16350_SCAN_IN_SUPPLY) |
> + BIT(ADIS16350_SCAN_GYRO_Z) |
> + BIT(ADIS16350_SCAN_ACCEL_X) |
> + BIT(ADIS16350_SCAN_ACCEL_Y) |
> + BIT(ADIS16350_SCAN_ACCEL_Z) |
> + BIT(ADIS16300_SCAN_TEMP) |
> + BIT(ADIS16300_SCAN_INCLI_X) |
> + BIT(ADIS16300_SCAN_INCLI_Y) |
> + BIT(ADIS16350_SCAN_IN0),
> + },
> + [adis16350] = {
> + .attribute_group = &adis16350_attribute_group,
> + .scan_el_group = &adis16350_scan_el_group,
> + .burst_available = 0,
> + .gyro_scale = "0.00127862821",
> + .accel_scale = "0.0247323713",
> + .all_mask =
> + BIT(ADIS16350_SCAN_IN_SUPPLY) |
> + BIT(ADIS16350_SCAN_GYRO_X) |
> + BIT(ADIS16350_SCAN_GYRO_Y) |
> + BIT(ADIS16350_SCAN_GYRO_Z) |
> + BIT(ADIS16350_SCAN_ACCEL_X) |
> + BIT(ADIS16350_SCAN_ACCEL_Y) |
> + BIT(ADIS16350_SCAN_ACCEL_Z) |
> + BIT(ADIS16350_SCAN_TEMP_X) |
> + BIT(ADIS16350_SCAN_TEMP_Y) |
> + BIT(ADIS16350_SCAN_TEMP_Z) |
> + BIT(ADIS16350_SCAN_IN0),
> + },
> + [adis16360] = {
> + .attribute_group = &adis16350_attribute_group,
> + .scan_el_group = &adis16350_scan_el_group,
> + .burst_available = 1,
> + .gyro_scale = "0.00127862821",
> + .accel_scale = "0.0247323713",
> + .burst_length = 22,
> + .all_mask =
> + BIT(ADIS16350_SCAN_IN_SUPPLY) |
> + BIT(ADIS16350_SCAN_GYRO_X) |
> + BIT(ADIS16350_SCAN_GYRO_Y) |
> + BIT(ADIS16350_SCAN_GYRO_Z) |
> + BIT(ADIS16350_SCAN_ACCEL_X) |
> + BIT(ADIS16350_SCAN_ACCEL_Y) |
> + BIT(ADIS16350_SCAN_ACCEL_Z) |
> + BIT(ADIS16350_SCAN_TEMP_X) |
> + BIT(ADIS16350_SCAN_TEMP_Y) |
> + BIT(ADIS16350_SCAN_TEMP_Z) |
> + BIT(ADIS16350_SCAN_IN0),
> + },
> +};
^ permalink raw reply [flat|nested] 12+ messages in thread
* [PATCH 6/6] staging:iio:adis16400 merge into adis16350 driver
2010-09-11 14:58 [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features Jonathan Cameron
` (4 preceding siblings ...)
2010-09-11 14:58 ` [PATCH 5/6] staging:iio:adis16300 merge into adis16350 driver Jonathan Cameron
@ 2010-09-11 14:58 ` Jonathan Cameron
2010-09-11 15:05 ` Jonathan Cameron
2010-09-22 8:47 ` [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features Manuel Stahl
6 siblings, 1 reply; 12+ messages in thread
From: Jonathan Cameron @ 2010-09-11 14:58 UTC (permalink / raw)
To: linux-iio; +Cc: Michael.Hennerich, Robin.Getz, manuel.stahl, Jonathan Cameron
Results in a subtle change to numbering of scan elements on
the adis16350. This does not technically change the abi as
these numbers are only guaranteed to be in the correct order,
not to have particular values.
Signed-off-by: Jonathan Cameron <jic23@cam.ac.uk>
---
drivers/staging/iio/imu/Kconfig | 13 +-
drivers/staging/iio/imu/Makefile | 4 -
drivers/staging/iio/imu/adis16350.h | 18 +-
drivers/staging/iio/imu/adis16350_core.c | 69 +++
drivers/staging/iio/imu/adis16350_ring.c | 33 ++-
drivers/staging/iio/imu/adis16400.h | 208 --------
drivers/staging/iio/imu/adis16400_core.c | 752 ------------------------------
drivers/staging/iio/imu/adis16400_ring.c | 231 ---------
8 files changed, 116 insertions(+), 1212 deletions(-)
diff --git a/drivers/staging/iio/imu/Kconfig b/drivers/staging/iio/imu/Kconfig
index ca433d8..9853fb3 100644
--- a/drivers/staging/iio/imu/Kconfig
+++ b/drivers/staging/iio/imu/Kconfig
@@ -10,8 +10,8 @@ config ADIS16350
select IIO_SW_RING if IIO_RING_BUFFER
help
Say yes here to build support for Analog Devices adis16300, adis16350,
- adis16354, adis16355, adis16360, adis16362 and adis16364,
- high precision tri-axis inertial sensor.
+ adis16354, adis16355, adis16360, adis16362, adis16364, adis16400 and
+ adis16405 high precision tri-axis inertial sensor.
if ADIS16350
config ADIS16350_EVENT
@@ -19,12 +19,3 @@ config ADIS16350_EVENT
help
Threshold and rate of change events for all channels.
endif #ADIS16350
-
-config ADIS16400
- tristate "Analog Devices ADIS16400/5 IMU SPI driver"
- depends on SPI
- select IIO_SW_RING if IIO_RING_BUFFER
- select IIO_TRIGGER if IIO_RING_BUFFER
- help
- Say yes here to build support for Analog Devices adis16400/5 triaxial
- inertial sensor with Magnetometer.
diff --git a/drivers/staging/iio/imu/Makefile b/drivers/staging/iio/imu/Makefile
index f27f896..0c15d6e 100644
--- a/drivers/staging/iio/imu/Makefile
+++ b/drivers/staging/iio/imu/Makefile
@@ -6,7 +6,3 @@ adis16350-y := adis16350_core.o
adis16350-$(CONFIG_ADIS16350_EVENT) += adis16350_event.o
adis16350-$(CONFIG_IIO_RING_BUFFER) += adis16350_ring.o adis16350_trigger.o
obj-$(CONFIG_ADIS16350) += adis16350.o
-
-adis16400-y := adis16400_core.o
-adis16400-$(CONFIG_IIO_RING_BUFFER) += adis16400_ring.o adis16400_trigger.o
-obj-$(CONFIG_ADIS16400) += adis16400.o
diff --git a/drivers/staging/iio/imu/adis16350.h b/drivers/staging/iio/imu/adis16350.h
index b7c9052..ab98d6c 100644
--- a/drivers/staging/iio/imu/adis16350.h
+++ b/drivers/staging/iio/imu/adis16350.h
@@ -19,6 +19,11 @@
#define ADIS16350_ZTEMP_OUT 0x14 /* Z-axis gyroscope temperature measurement */
#define ADIS16350_AUX_ADC 0x16 /* Auxiliary ADC measurement */
+#define ADIS16400_XMAGN_OUT 0x10 /* X-axis magnetometer measurement */
+#define ADIS16400_YMAGN_OUT 0x12 /* Y-axis magnetometer measurement */
+#define ADIS16400_ZMAGN_OUT 0x14 /* Z-axis magnetometer measurement */
+
+
#define ADIS16300_TEMP_OUT 0x10 /* Temperature output */
#define ADIS16300_XINCLI_OUT 0x12 /* X-axis inclinometer output measurement */
#define ADIS16300_YINCLI_OUT 0x14 /* Y-axis inclinometer output measurement */
@@ -104,10 +109,12 @@ enum adis16350_chip_variants {
adis16300,
adis16350,
adis16360,
+ adis16400,
};
extern struct attribute_group adis16300_scan_el_group;
extern struct attribute_group adis16350_scan_el_group;
+extern struct attribute_group adis16400_scan_el_group;
/**
* struct adis16350_chip_info - chip type specific parameters
@@ -165,8 +172,8 @@ struct adis16350_state {
int event_irq;
s64 event_timestamp;
struct work_struct work_event;
- s16 thresh_cache[44];
- u8 smpl_cache[22];
+ s16 thresh_cache[48];
+ u8 smpl_cache[24];
int active_alarms[2];
unsigned int oldest_alarm:1;
u8 alarm_on[2];
@@ -208,13 +215,16 @@ static inline void adis16350_unconfigure_event_line(struct adis16350_state *st)
#define ADIS16350_SCAN_ACCEL_X 4
#define ADIS16350_SCAN_ACCEL_Y 5
#define ADIS16350_SCAN_ACCEL_Z 6
-#define ADIS16300_SCAN_TEMP 7
#define ADIS16350_SCAN_TEMP_X 7
+#define ADIS16400_SCAN_MAGN_X 7
#define ADIS16350_SCAN_TEMP_Y 8
#define ADIS16300_SCAN_INCLI_X 8
+#define ADIS16400_SCAN_MAGN_Y 8
#define ADIS16350_SCAN_TEMP_Z 9
#define ADIS16300_SCAN_INCLI_Y 9
-#define ADIS16350_SCAN_IN0 10
+#define ADIS16400_SCAN_MAGN_Z 9
+#define ADIS16300_SCAN_TEMP 10
+#define ADIS16350_SCAN_IN0 11
#ifdef CONFIG_IIO_RING_BUFFER
diff --git a/drivers/staging/iio/imu/adis16350_core.c b/drivers/staging/iio/imu/adis16350_core.c
index f154886..d8f76c6 100644
--- a/drivers/staging/iio/imu/adis16350_core.c
+++ b/drivers/staging/iio/imu/adis16350_core.c
@@ -25,6 +25,7 @@
#include "../accel/inclinometer.h"
#include "../adc/adc.h"
#include "../gyro/gyro.h"
+#include "../magnetometer/magnet.h"
#include "adis16350.h"
@@ -672,6 +673,51 @@ static const struct attribute_group adis16300_attribute_group = {
.attrs = adis16300_attributes,
};
+static IIO_DEV_ATTR_MAGN_X(adis16350_read_14bit_signed,
+ ADIS16400_XMAGN_OUT);
+static IIO_DEV_ATTR_MAGN_Y(adis16350_read_14bit_signed,
+ ADIS16400_YMAGN_OUT);
+static IIO_DEV_ATTR_MAGN_Z(adis16350_read_14bit_signed,
+ ADIS16400_ZMAGN_OUT);
+static IIO_CONST_ATTR(magn_scale, "0.0005 Gs");
+
+static struct attribute *adis16400_attributes[] = {
+ &iio_dev_attr_gyro_x_calibbias.dev_attr.attr,
+ &iio_dev_attr_gyro_y_calibbias.dev_attr.attr,
+ &iio_dev_attr_gyro_z_calibbias.dev_attr.attr,
+ &iio_dev_attr_accel_x_calibbias.dev_attr.attr,
+ &iio_dev_attr_accel_y_calibbias.dev_attr.attr,
+ &iio_dev_attr_accel_z_calibbias.dev_attr.attr,
+ &iio_dev_attr_in_supply_raw.dev_attr.attr,
+ &iio_const_attr_in_supply_scale.dev_attr.attr,
+ &iio_dev_attr_gyro_x_raw.dev_attr.attr,
+ &iio_dev_attr_gyro_y_raw.dev_attr.attr,
+ &iio_dev_attr_gyro_z_raw.dev_attr.attr,
+ &iio_dev_attr_gyro_scale.dev_attr.attr,
+ &iio_dev_attr_accel_x_raw.dev_attr.attr,
+ &iio_dev_attr_accel_y_raw.dev_attr.attr,
+ &iio_dev_attr_accel_z_raw.dev_attr.attr,
+ &iio_dev_attr_accel_scale.dev_attr.attr,
+ &iio_dev_attr_magn_x_raw.dev_attr.attr,
+ &iio_dev_attr_magn_y_raw.dev_attr.attr,
+ &iio_dev_attr_magn_z_raw.dev_attr.attr,
+ &iio_const_attr_magn_scale.dev_attr.attr,
+ &iio_dev_attr_temp_raw.dev_attr.attr,
+ &iio_const_attr_temp_scale.dev_attr.attr,
+ &iio_const_attr_temp_offset.dev_attr.attr,
+ &iio_dev_attr_in0_raw.dev_attr.attr,
+ &iio_const_attr_in0_scale.dev_attr.attr,
+ &iio_dev_attr_sampling_frequency.dev_attr.attr,
+ &iio_const_attr_sampling_frequency_available.dev_attr.attr,
+ &iio_dev_attr_reset.dev_attr.attr,
+ &iio_dev_attr_name.dev_attr.attr,
+ NULL
+};
+
+static const struct attribute_group adis16400_attribute_group = {
+ .attrs = adis16400_attributes,
+};
+
static struct adis16350_chip_info adis16350_variants[] = {
[adis16300] = {
.attribute_group = &adis16300_attribute_group,
@@ -730,6 +776,27 @@ static struct adis16350_chip_info adis16350_variants[] = {
BIT(ADIS16350_SCAN_TEMP_Z) |
BIT(ADIS16350_SCAN_IN0),
},
+ [adis16400] = {
+ .attribute_group = &adis16400_attribute_group,
+ .scan_el_group = &adis16400_scan_el_group,
+ .burst_available = 1,
+ .gyro_scale = "0.0008726646",
+ .accel_scale = "0.0326561445",
+ .burst_length = 24,
+ .all_mask =
+ BIT(ADIS16350_SCAN_IN_SUPPLY) |
+ BIT(ADIS16350_SCAN_GYRO_X) |
+ BIT(ADIS16350_SCAN_GYRO_Y) |
+ BIT(ADIS16350_SCAN_GYRO_Z) |
+ BIT(ADIS16350_SCAN_ACCEL_X) |
+ BIT(ADIS16350_SCAN_ACCEL_Y) |
+ BIT(ADIS16350_SCAN_ACCEL_Z) |
+ BIT(ADIS16400_SCAN_MAGN_X) |
+ BIT(ADIS16400_SCAN_MAGN_Y) |
+ BIT(ADIS16400_SCAN_MAGN_Z) |
+ BIT(ADIS16300_SCAN_TEMP) |
+ BIT(ADIS16350_SCAN_IN0),
+ }
};
static int __devinit adis16350_probe(struct spi_device *spi)
@@ -872,6 +939,8 @@ static const struct spi_device_id adis16350_id[] = {
{"adis16362", adis16360},
{"adis16364", adis16360},
{"adis16365", adis16360},
+ {"adis16400", adis16400},
+ {"adis16405", adis16400},
{}
};
diff --git a/drivers/staging/iio/imu/adis16350_ring.c b/drivers/staging/iio/imu/adis16350_ring.c
index 37ec884..f8b08e9 100644
--- a/drivers/staging/iio/imu/adis16350_ring.c
+++ b/drivers/staging/iio/imu/adis16350_ring.c
@@ -34,6 +34,13 @@ static IIO_SCAN_EL_C(accel_y, ADIS16350_SCAN_ACCEL_Y, IIO_SIGNED(14),
static IIO_SCAN_EL_C(accel_z, ADIS16350_SCAN_ACCEL_Z, IIO_SIGNED(14),
ADIS16350_ZACCL_OUT, NULL);
+static IIO_SCAN_EL_C(magn_x, ADIS16400_SCAN_MAGN_X, IIO_SIGNED(14),
+ ADIS16400_XMAGN_OUT, NULL);
+static IIO_SCAN_EL_C(magn_y, ADIS16400_SCAN_MAGN_Y, IIO_SIGNED(14),
+ ADIS16400_YMAGN_OUT, NULL);
+static IIO_SCAN_EL_C(magn_z, ADIS16400_SCAN_MAGN_Z, IIO_SIGNED(14),
+ ADIS16400_ZMAGN_OUT, NULL);
+
static IIO_SCAN_EL_C(temp_x, ADIS16350_SCAN_TEMP_X, IIO_SIGNED(12),
ADIS16350_XTEMP_OUT, NULL);
static IIO_SCAN_EL_C(temp_y, ADIS16350_SCAN_TEMP_Y, IIO_SIGNED(12),
@@ -44,7 +51,7 @@ static IIO_SCAN_EL_C(temp_z, ADIS16350_SCAN_TEMP_Z, IIO_SIGNED(12),
static IIO_SCAN_EL_C(in0, ADIS16350_SCAN_IN0, IIO_UNSIGNED(12),
ADIS16350_AUX_ADC, NULL);
-static IIO_SCAN_EL_TIMESTAMP(11);
+static IIO_SCAN_EL_TIMESTAMP(12);
static struct attribute *adis16350_scan_el_attrs[] = {
&iio_scan_el_in_supply.dev_attr.attr,
@@ -75,7 +82,7 @@ static IIO_SCAN_EL_C(temp, ADIS16300_SCAN_TEMP, IIO_UNSIGNED(12),
static struct attribute *adis16300_scan_el_attrs[] = {
&iio_scan_el_in_supply.dev_attr.attr,
- &iio_scan_el_gyro_x.dev_attr.attr,
+ &iio_scan_el_gyro_z.dev_attr.attr,
&iio_scan_el_temp.dev_attr.attr,
&iio_scan_el_accel_x.dev_attr.attr,
&iio_scan_el_accel_y.dev_attr.attr,
@@ -92,6 +99,28 @@ struct attribute_group adis16300_scan_el_group = {
.name = "scan_elements",
};
+static struct attribute *adis16400_scan_el_attrs[] = {
+ &iio_scan_el_in_supply.dev_attr.attr,
+ &iio_scan_el_gyro_x.dev_attr.attr,
+ &iio_scan_el_gyro_y.dev_attr.attr,
+ &iio_scan_el_gyro_z.dev_attr.attr,
+ &iio_scan_el_accel_x.dev_attr.attr,
+ &iio_scan_el_accel_y.dev_attr.attr,
+ &iio_scan_el_accel_z.dev_attr.attr,
+ &iio_scan_el_magn_x.dev_attr.attr,
+ &iio_scan_el_magn_y.dev_attr.attr,
+ &iio_scan_el_magn_z.dev_attr.attr,
+ &iio_scan_el_temp.dev_attr.attr,
+ &iio_scan_el_in0.dev_attr.attr,
+ &iio_scan_el_timestamp.dev_attr.attr,
+ NULL,
+};
+
+struct attribute_group adis16400_scan_el_group = {
+ .attrs = adis16400_scan_el_attrs,
+ .name = "scan_elements",
+};
+
/**
* adis16350_poll_func_th() top half interrupt handler called by trigger
* @private_data: iio_dev
diff --git a/drivers/staging/iio/imu/adis16400.h b/drivers/staging/iio/imu/adis16400.h
deleted file mode 100644
index 6ff33e1..0000000
--- a/drivers/staging/iio/imu/adis16400.h
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
- * adis16400.h support Analog Devices ADIS16400
- * 3d 18g accelerometers,
- * 3d gyroscopes,
- * 3d 2.5gauss magnetometers via SPI
- *
- * Copyright (c) 2009 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>
- * Copyright (c) 2007 Jonathan Cameron <jic23@cam.ac.uk>
- *
- * Loosely based upon lis3l02dq.h
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef SPI_ADIS16400_H_
-#define SPI_ADIS16400_H_
-
-#define ADIS16400_STARTUP_DELAY 220 /* ms */
-
-#define ADIS16400_READ_REG(a) a
-#define ADIS16400_WRITE_REG(a) ((a) | 0x80)
-
-#define ADIS16400_FLASH_CNT 0x00 /* Flash memory write count */
-#define ADIS16400_SUPPLY_OUT 0x02 /* Power supply measurement */
-#define ADIS16400_XGYRO_OUT 0x04 /* X-axis gyroscope output */
-#define ADIS16400_YGYRO_OUT 0x06 /* Y-axis gyroscope output */
-#define ADIS16400_ZGYRO_OUT 0x08 /* Z-axis gyroscope output */
-#define ADIS16400_XACCL_OUT 0x0A /* X-axis accelerometer output */
-#define ADIS16400_YACCL_OUT 0x0C /* Y-axis accelerometer output */
-#define ADIS16400_ZACCL_OUT 0x0E /* Z-axis accelerometer output */
-#define ADIS16400_XMAGN_OUT 0x10 /* X-axis magnetometer measurement */
-#define ADIS16400_YMAGN_OUT 0x12 /* Y-axis magnetometer measurement */
-#define ADIS16400_ZMAGN_OUT 0x14 /* Z-axis magnetometer measurement */
-#define ADIS16400_TEMP_OUT 0x16 /* Temperature output */
-#define ADIS16400_AUX_ADC 0x18 /* Auxiliary ADC measurement */
-
-/* Calibration parameters */
-#define ADIS16400_XGYRO_OFF 0x1A /* X-axis gyroscope bias offset factor */
-#define ADIS16400_YGYRO_OFF 0x1C /* Y-axis gyroscope bias offset factor */
-#define ADIS16400_ZGYRO_OFF 0x1E /* Z-axis gyroscope bias offset factor */
-#define ADIS16400_XACCL_OFF 0x20 /* X-axis acceleration bias offset factor */
-#define ADIS16400_YACCL_OFF 0x22 /* Y-axis acceleration bias offset factor */
-#define ADIS16400_ZACCL_OFF 0x24 /* Z-axis acceleration bias offset factor */
-#define ADIS16400_XMAGN_HIF 0x26 /* X-axis magnetometer, hard-iron factor */
-#define ADIS16400_YMAGN_HIF 0x28 /* Y-axis magnetometer, hard-iron factor */
-#define ADIS16400_ZMAGN_HIF 0x2A /* Z-axis magnetometer, hard-iron factor */
-#define ADIS16400_XMAGN_SIF 0x2C /* X-axis magnetometer, soft-iron factor */
-#define ADIS16400_YMAGN_SIF 0x2E /* Y-axis magnetometer, soft-iron factor */
-#define ADIS16400_ZMAGN_SIF 0x30 /* Z-axis magnetometer, soft-iron factor */
-
-#define ADIS16400_GPIO_CTRL 0x32 /* Auxiliary digital input/output control */
-#define ADIS16400_MSC_CTRL 0x34 /* Miscellaneous control */
-#define ADIS16400_SMPL_PRD 0x36 /* Internal sample period (rate) control */
-#define ADIS16400_SENS_AVG 0x38 /* Dynamic range and digital filter control */
-#define ADIS16400_SLP_CNT 0x3A /* Sleep mode control */
-#define ADIS16400_DIAG_STAT 0x3C /* System status */
-
-/* Alarm functions */
-#define ADIS16400_GLOB_CMD 0x3E /* System command */
-#define ADIS16400_ALM_MAG1 0x40 /* Alarm 1 amplitude threshold */
-#define ADIS16400_ALM_MAG2 0x42 /* Alarm 2 amplitude threshold */
-#define ADIS16400_ALM_SMPL1 0x44 /* Alarm 1 sample size */
-#define ADIS16400_ALM_SMPL2 0x46 /* Alarm 2 sample size */
-#define ADIS16400_ALM_CTRL 0x48 /* Alarm control */
-#define ADIS16400_AUX_DAC 0x4A /* Auxiliary DAC data */
-
-#define ADIS16400_PRODUCT_ID 0x56 /* Product identifier */
-#define ADIS16400_PRODUCT_ID_DEFAULT 0x4015 /* Datasheet says 0x4105, I get 0x4015 */
-
-#define ADIS16400_ERROR_ACTIVE (1<<14)
-#define ADIS16400_NEW_DATA (1<<14)
-
-/* MSC_CTRL */
-#define ADIS16400_MSC_CTRL_MEM_TEST (1<<11)
-#define ADIS16400_MSC_CTRL_INT_SELF_TEST (1<<10)
-#define ADIS16400_MSC_CTRL_NEG_SELF_TEST (1<<9)
-#define ADIS16400_MSC_CTRL_POS_SELF_TEST (1<<8)
-#define ADIS16400_MSC_CTRL_GYRO_BIAS (1<<7)
-#define ADIS16400_MSC_CTRL_ACCL_ALIGN (1<<6)
-#define ADIS16400_MSC_CTRL_DATA_RDY_EN (1<<2)
-#define ADIS16400_MSC_CTRL_DATA_RDY_POL_HIGH (1<<1)
-#define ADIS16400_MSC_CTRL_DATA_RDY_DIO2 (1<<0)
-
-/* SMPL_PRD */
-#define ADIS16400_SMPL_PRD_TIME_BASE (1<<7)
-#define ADIS16400_SMPL_PRD_DIV_MASK 0x7F
-
-/* DIAG_STAT */
-#define ADIS16400_DIAG_STAT_ZACCL_FAIL (1<<15)
-#define ADIS16400_DIAG_STAT_YACCL_FAIL (1<<14)
-#define ADIS16400_DIAG_STAT_XACCL_FAIL (1<<13)
-#define ADIS16400_DIAG_STAT_XGYRO_FAIL (1<<12)
-#define ADIS16400_DIAG_STAT_YGYRO_FAIL (1<<11)
-#define ADIS16400_DIAG_STAT_ZGYRO_FAIL (1<<10)
-#define ADIS16400_DIAG_STAT_ALARM2 (1<<9)
-#define ADIS16400_DIAG_STAT_ALARM1 (1<<8)
-#define ADIS16400_DIAG_STAT_FLASH_CHK (1<<6)
-#define ADIS16400_DIAG_STAT_SELF_TEST (1<<5)
-#define ADIS16400_DIAG_STAT_OVERFLOW (1<<4)
-#define ADIS16400_DIAG_STAT_SPI_FAIL (1<<3)
-#define ADIS16400_DIAG_STAT_FLASH_UPT (1<<2)
-#define ADIS16400_DIAG_STAT_POWER_HIGH (1<<1)
-#define ADIS16400_DIAG_STAT_POWER_LOW (1<<0)
-
-/* GLOB_CMD */
-#define ADIS16400_GLOB_CMD_SW_RESET (1<<7)
-#define ADIS16400_GLOB_CMD_P_AUTO_NULL (1<<4)
-#define ADIS16400_GLOB_CMD_FLASH_UPD (1<<3)
-#define ADIS16400_GLOB_CMD_DAC_LATCH (1<<2)
-#define ADIS16400_GLOB_CMD_FAC_CALIB (1<<1)
-#define ADIS16400_GLOB_CMD_AUTO_NULL (1<<0)
-
-/* SLP_CNT */
-#define ADIS16400_SLP_CNT_POWER_OFF (1<<8)
-
-#define ADIS16400_MAX_TX 24
-#define ADIS16400_MAX_RX 24
-
-#define ADIS16400_SPI_SLOW (u32)(300 * 1000)
-#define ADIS16400_SPI_BURST (u32)(1000 * 1000)
-#define ADIS16400_SPI_FAST (u32)(2000 * 1000)
-
-/**
- * struct adis16400_state - device instance specific data
- * @us: actual spi_device
- * @work_trigger_to_ring: bh for triggered event handling
- * @inter: used to check if new interrupt has been triggered
- * @last_timestamp: passing timestamp from th to bh of interrupt handler
- * @indio_dev: industrial I/O device structure
- * @trig: data ready trigger registered with iio
- * @tx: transmit buffer
- * @rx: recieve buffer
- * @buf_lock: mutex to protect tx and rx
- **/
-struct adis16400_state {
- struct spi_device *us;
- struct work_struct work_trigger_to_ring;
- s64 last_timestamp;
- struct iio_dev *indio_dev;
- struct iio_trigger *trig;
- u8 *tx;
- u8 *rx;
- struct mutex buf_lock;
-};
-
-int adis16400_set_irq(struct device *dev, bool enable);
-
-#ifdef CONFIG_IIO_RING_BUFFER
-/* At the moment triggers are only used for ring buffer
- * filling. This may change!
- */
-
-#define ADIS16400_SCAN_SUPPLY 0
-#define ADIS16400_SCAN_GYRO_X 1
-#define ADIS16400_SCAN_GYRO_Y 2
-#define ADIS16400_SCAN_GYRO_Z 3
-#define ADIS16400_SCAN_ACC_X 4
-#define ADIS16400_SCAN_ACC_Y 5
-#define ADIS16400_SCAN_ACC_Z 6
-#define ADIS16400_SCAN_MAGN_X 7
-#define ADIS16400_SCAN_MAGN_Y 8
-#define ADIS16400_SCAN_MAGN_Z 9
-#define ADIS16400_SCAN_TEMP 10
-#define ADIS16400_SCAN_ADC_0 11
-
-void adis16400_remove_trigger(struct iio_dev *indio_dev);
-int adis16400_probe_trigger(struct iio_dev *indio_dev);
-
-ssize_t adis16400_read_data_from_ring(struct device *dev,
- struct device_attribute *attr,
- char *buf);
-
-
-int adis16400_configure_ring(struct iio_dev *indio_dev);
-void adis16400_unconfigure_ring(struct iio_dev *indio_dev);
-
-#else /* CONFIG_IIO_RING_BUFFER */
-
-static inline void adis16400_remove_trigger(struct iio_dev *indio_dev)
-{
-}
-
-static inline int adis16400_probe_trigger(struct iio_dev *indio_dev)
-{
- return 0;
-}
-
-static inline ssize_t
-adis16400_read_data_from_ring(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- return 0;
-}
-
-static int adis16400_configure_ring(struct iio_dev *indio_dev)
-{
- return 0;
-}
-
-static inline void adis16400_unconfigure_ring(struct iio_dev *indio_dev)
-{
-}
-
-#endif /* CONFIG_IIO_RING_BUFFER */
-#endif /* SPI_ADIS16400_H_ */
diff --git a/drivers/staging/iio/imu/adis16400_core.c b/drivers/staging/iio/imu/adis16400_core.c
deleted file mode 100644
index 5f1643a..0000000
--- a/drivers/staging/iio/imu/adis16400_core.c
+++ /dev/null
@@ -1,752 +0,0 @@
-/*
- * adis16400.c support Analog Devices ADIS16400/5
- * 3d 2g Linear Accelerometers,
- * 3d Gyroscopes,
- * 3d Magnetometers via SPI
- *
- * Copyright (c) 2009 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>
- * Copyright (c) 2007 Jonathan Cameron <jic23@cam.ac.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- */
-
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/gpio.h>
-#include <linux/delay.h>
-#include <linux/mutex.h>
-#include <linux/device.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/list.h>
-
-#include "../iio.h"
-#include "../sysfs.h"
-#include "../ring_generic.h"
-#include "../accel/accel.h"
-#include "../adc/adc.h"
-#include "../gyro/gyro.h"
-#include "../magnetometer/magnet.h"
-
-#include "adis16400.h"
-
-#define DRIVER_NAME "adis16400"
-
-static int adis16400_check_status(struct device *dev);
-
-/* At the moment the spi framework doesn't allow global setting of cs_change.
- * It's in the likely to be added comment at the top of spi.h.
- * This means that use cannot be made of spi_write etc.
- */
-
-/**
- * adis16400_spi_write_reg_8() - write single byte to a register
- * @dev: device associated with child of actual device (iio_dev or iio_trig)
- * @reg_address: the address of the register to be written
- * @val: the value to write
- **/
-static int adis16400_spi_write_reg_8(struct device *dev,
- u8 reg_address,
- u8 val)
-{
- int ret;
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- struct adis16400_state *st = iio_dev_get_devdata(indio_dev);
-
- mutex_lock(&st->buf_lock);
- st->tx[0] = ADIS16400_WRITE_REG(reg_address);
- st->tx[1] = val;
-
- ret = spi_write(st->us, st->tx, 2);
- mutex_unlock(&st->buf_lock);
-
- return ret;
-}
-
-/**
- * adis16400_spi_write_reg_16() - write 2 bytes to a pair of registers
- * @dev: device associated with child of actual device (iio_dev or iio_trig)
- * @reg_address: the address of the lower of the two registers. Second register
- * is assumed to have address one greater.
- * @val: value to be written
- **/
-static int adis16400_spi_write_reg_16(struct device *dev,
- u8 lower_reg_address,
- u16 value)
-{
- int ret;
- struct spi_message msg;
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- struct adis16400_state *st = iio_dev_get_devdata(indio_dev);
- struct spi_transfer xfers[] = {
- {
- .tx_buf = st->tx,
- .bits_per_word = 8,
- .len = 2,
- .cs_change = 1,
- }, {
- .tx_buf = st->tx + 2,
- .bits_per_word = 8,
- .len = 2,
- .cs_change = 1,
- },
- };
-
- mutex_lock(&st->buf_lock);
- st->tx[0] = ADIS16400_WRITE_REG(lower_reg_address);
- st->tx[1] = value & 0xFF;
- st->tx[2] = ADIS16400_WRITE_REG(lower_reg_address + 1);
- st->tx[3] = (value >> 8) & 0xFF;
-
- spi_message_init(&msg);
- spi_message_add_tail(&xfers[0], &msg);
- spi_message_add_tail(&xfers[1], &msg);
- ret = spi_sync(st->us, &msg);
- mutex_unlock(&st->buf_lock);
-
- return ret;
-}
-
-/**
- * adis16400_spi_read_reg_16() - read 2 bytes from a 16-bit register
- * @dev: device associated with child of actual device (iio_dev or iio_trig)
- * @reg_address: the address of the lower of the two registers. Second register
- * is assumed to have address one greater.
- * @val: somewhere to pass back the value read
- **/
-static int adis16400_spi_read_reg_16(struct device *dev,
- u8 lower_reg_address,
- u16 *val)
-{
- struct spi_message msg;
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- struct adis16400_state *st = iio_dev_get_devdata(indio_dev);
- int ret;
- struct spi_transfer xfers[] = {
- {
- .tx_buf = st->tx,
- .bits_per_word = 8,
- .len = 2,
- .cs_change = 1,
- }, {
- .rx_buf = st->rx,
- .bits_per_word = 8,
- .len = 2,
- .cs_change = 1,
- },
- };
-
- mutex_lock(&st->buf_lock);
- st->tx[0] = ADIS16400_READ_REG(lower_reg_address);
- st->tx[1] = 0;
- st->tx[2] = 0;
- st->tx[3] = 0;
-
- spi_message_init(&msg);
- spi_message_add_tail(&xfers[0], &msg);
- spi_message_add_tail(&xfers[1], &msg);
- ret = spi_sync(st->us, &msg);
- if (ret) {
- dev_err(&st->us->dev,
- "problem when reading 16 bit register 0x%02X",
- lower_reg_address);
- goto error_ret;
- }
- *val = (st->rx[0] << 8) | st->rx[1];
-
-error_ret:
- mutex_unlock(&st->buf_lock);
- return ret;
-}
-
-static ssize_t adis16400_spi_read_signed(struct device *dev,
- struct device_attribute *attr,
- char *buf,
- unsigned bits)
-{
- int ret;
- s16 val = 0;
- unsigned shift = 16 - bits;
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- ret = adis16400_spi_read_reg_16(dev, this_attr->address, (u16 *)&val);
- if (ret)
- return ret;
-
- if (val & ADIS16400_ERROR_ACTIVE)
- adis16400_check_status(dev);
- val = ((s16)(val << shift) >> shift);
- return sprintf(buf, "%d\n", val);
-}
-
-static ssize_t adis16400_read_12bit_unsigned(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- int ret;
- u16 val = 0;
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- ret = adis16400_spi_read_reg_16(dev, this_attr->address, &val);
- if (ret)
- return ret;
-
- if (val & ADIS16400_ERROR_ACTIVE)
- adis16400_check_status(dev);
-
- return sprintf(buf, "%u\n", val & 0x0FFF);
-}
-
-static ssize_t adis16400_read_14bit_signed(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- ssize_t ret;
-
- /* Take the iio_dev status lock */
- mutex_lock(&indio_dev->mlock);
- ret = adis16400_spi_read_signed(dev, attr, buf, 14);
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static ssize_t adis16400_read_12bit_signed(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- ssize_t ret;
-
- /* Take the iio_dev status lock */
- mutex_lock(&indio_dev->mlock);
- ret = adis16400_spi_read_signed(dev, attr, buf, 12);
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static ssize_t adis16400_write_16bit(struct device *dev,
- struct device_attribute *attr,
- const char *buf,
- size_t len)
-{
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
- int ret;
- long val;
-
- ret = strict_strtol(buf, 10, &val);
- if (ret)
- goto error_ret;
- ret = adis16400_spi_write_reg_16(dev, this_attr->address, val);
-
-error_ret:
- return ret ? ret : len;
-}
-
-static ssize_t adis16400_read_frequency(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- int ret, len = 0;
- u16 t;
- int sps;
- ret = adis16400_spi_read_reg_16(dev,
- ADIS16400_SMPL_PRD,
- &t);
- if (ret)
- return ret;
- sps = (t & ADIS16400_SMPL_PRD_TIME_BASE) ? 53 : 1638;
- sps /= (t & ADIS16400_SMPL_PRD_DIV_MASK) + 1;
- len = sprintf(buf, "%d SPS\n", sps);
- return len;
-}
-
-static ssize_t adis16400_write_frequency(struct device *dev,
- struct device_attribute *attr,
- const char *buf,
- size_t len)
-{
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- struct adis16400_state *st = iio_dev_get_devdata(indio_dev);
- long val;
- int ret;
- u8 t;
-
- ret = strict_strtol(buf, 10, &val);
- if (ret)
- return ret;
-
- mutex_lock(&indio_dev->mlock);
-
- t = (1638 / val);
- if (t > 0)
- t--;
- t &= ADIS16400_SMPL_PRD_DIV_MASK;
- if ((t & ADIS16400_SMPL_PRD_DIV_MASK) >= 0x0A)
- st->us->max_speed_hz = ADIS16400_SPI_SLOW;
- else
- st->us->max_speed_hz = ADIS16400_SPI_FAST;
-
- ret = adis16400_spi_write_reg_8(dev,
- ADIS16400_SMPL_PRD,
- t);
-
- mutex_unlock(&indio_dev->mlock);
-
- return ret ? ret : len;
-}
-
-static int adis16400_reset(struct device *dev)
-{
- int ret;
- ret = adis16400_spi_write_reg_8(dev,
- ADIS16400_GLOB_CMD,
- ADIS16400_GLOB_CMD_SW_RESET);
- if (ret)
- dev_err(dev, "problem resetting device");
-
- return ret;
-}
-
-static ssize_t adis16400_write_reset(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- if (len < 1)
- return -1;
- switch (buf[0]) {
- case '1':
- case 'y':
- case 'Y':
- return adis16400_reset(dev);
- }
- return -1;
-}
-
-int adis16400_set_irq(struct device *dev, bool enable)
-{
- int ret;
- u16 msc;
- ret = adis16400_spi_read_reg_16(dev, ADIS16400_MSC_CTRL, &msc);
- if (ret)
- goto error_ret;
-
- msc |= ADIS16400_MSC_CTRL_DATA_RDY_POL_HIGH;
- if (enable)
- msc |= ADIS16400_MSC_CTRL_DATA_RDY_EN;
- else
- msc &= ~ADIS16400_MSC_CTRL_DATA_RDY_EN;
-
- ret = adis16400_spi_write_reg_16(dev, ADIS16400_MSC_CTRL, msc);
- if (ret)
- goto error_ret;
-
-error_ret:
- return ret;
-}
-
-/* Power down the device */
-static int adis16400_stop_device(struct device *dev)
-{
- int ret;
- u16 val = ADIS16400_SLP_CNT_POWER_OFF;
-
- ret = adis16400_spi_write_reg_16(dev, ADIS16400_SLP_CNT, val);
- if (ret)
- dev_err(dev, "problem with turning device off: SLP_CNT");
-
- return ret;
-}
-
-static int adis16400_self_test(struct device *dev)
-{
- int ret;
- ret = adis16400_spi_write_reg_16(dev,
- ADIS16400_MSC_CTRL,
- ADIS16400_MSC_CTRL_MEM_TEST);
- if (ret) {
- dev_err(dev, "problem starting self test");
- goto err_ret;
- }
-
- adis16400_check_status(dev);
-
-err_ret:
- return ret;
-}
-
-static int adis16400_check_status(struct device *dev)
-{
- u16 status;
- int ret;
-
- ret = adis16400_spi_read_reg_16(dev, ADIS16400_DIAG_STAT, &status);
-
- if (ret < 0) {
- dev_err(dev, "Reading status failed\n");
- goto error_ret;
- }
- ret = status;
- if (status & ADIS16400_DIAG_STAT_ZACCL_FAIL)
- dev_err(dev, "Z-axis accelerometer self-test failure\n");
- if (status & ADIS16400_DIAG_STAT_YACCL_FAIL)
- dev_err(dev, "Y-axis accelerometer self-test failure\n");
- if (status & ADIS16400_DIAG_STAT_XACCL_FAIL)
- dev_err(dev, "X-axis accelerometer self-test failure\n");
- if (status & ADIS16400_DIAG_STAT_XGYRO_FAIL)
- dev_err(dev, "X-axis gyroscope self-test failure\n");
- if (status & ADIS16400_DIAG_STAT_YGYRO_FAIL)
- dev_err(dev, "Y-axis gyroscope self-test failure\n");
- if (status & ADIS16400_DIAG_STAT_ZGYRO_FAIL)
- dev_err(dev, "Z-axis gyroscope self-test failure\n");
- if (status & ADIS16400_DIAG_STAT_ALARM2)
- dev_err(dev, "Alarm 2 active\n");
- if (status & ADIS16400_DIAG_STAT_ALARM1)
- dev_err(dev, "Alarm 1 active\n");
- if (status & ADIS16400_DIAG_STAT_FLASH_CHK)
- dev_err(dev, "Flash checksum error\n");
- if (status & ADIS16400_DIAG_STAT_SELF_TEST)
- dev_err(dev, "Self test error\n");
- if (status & ADIS16400_DIAG_STAT_OVERFLOW)
- dev_err(dev, "Sensor overrange\n");
- if (status & ADIS16400_DIAG_STAT_SPI_FAIL)
- dev_err(dev, "SPI failure\n");
- if (status & ADIS16400_DIAG_STAT_FLASH_UPT)
- dev_err(dev, "Flash update failed\n");
- if (status & ADIS16400_DIAG_STAT_POWER_HIGH)
- dev_err(dev, "Power supply above 5.25V\n");
- if (status & ADIS16400_DIAG_STAT_POWER_LOW)
- dev_err(dev, "Power supply below 4.75V\n");
-
-error_ret:
- return ret;
-}
-
-static int adis16400_initial_setup(struct adis16400_state *st)
-{
- int ret;
- u16 prod_id, smp_prd;
- struct device *dev = &st->indio_dev->dev;
-
- /* use low spi speed for init */
- st->us->max_speed_hz = ADIS16400_SPI_SLOW;
- st->us->mode = SPI_MODE_3;
- spi_setup(st->us);
-
- /* Disable IRQ */
- ret = adis16400_set_irq(dev, false);
- if (ret) {
- dev_err(dev, "disable irq failed");
- goto err_ret;
- }
-
- /* Do self test */
- ret = adis16400_self_test(dev);
- if (ret) {
- dev_err(dev, "self test failure");
- goto err_ret;
- }
-
- /* Read status register to check the result */
- ret = adis16400_check_status(dev);
- if (ret) {
- adis16400_reset(dev);
- dev_err(dev, "device not playing ball -> reset");
- msleep(ADIS16400_STARTUP_DELAY);
- ret = adis16400_check_status(dev);
- if (ret) {
- dev_err(dev, "giving up");
- goto err_ret;
- }
- }
-
- ret = adis16400_spi_read_reg_16(dev, ADIS16400_PRODUCT_ID, &prod_id);
- if (ret)
- goto err_ret;
-
- if (prod_id != ADIS16400_PRODUCT_ID_DEFAULT)
- dev_warn(dev, "unknown product id");
-
- printk(KERN_INFO DRIVER_NAME ": prod_id 0x%04x at CS%d (irq %d)\n",
- prod_id, st->us->chip_select, st->us->irq);
-
- /* use high spi speed if possible */
- ret = adis16400_spi_read_reg_16(dev, ADIS16400_SMPL_PRD, &smp_prd);
- if (!ret && (smp_prd & ADIS16400_SMPL_PRD_DIV_MASK) < 0x0A) {
- st->us->max_speed_hz = ADIS16400_SPI_SLOW;
- spi_setup(st->us);
- }
-
-
-err_ret:
-
- return ret;
-}
-
-#define ADIS16400_DEV_ATTR_CALIBBIAS(_channel, _reg) \
- IIO_DEV_ATTR_##_channel##_CALIBBIAS(S_IWUSR | S_IRUGO, \
- adis16400_read_12bit_signed, \
- adis16400_write_16bit, \
- _reg)
-
-static ADIS16400_DEV_ATTR_CALIBBIAS(GYRO_X, ADIS16400_XGYRO_OFF);
-static ADIS16400_DEV_ATTR_CALIBBIAS(GYRO_Y, ADIS16400_XGYRO_OFF);
-static ADIS16400_DEV_ATTR_CALIBBIAS(GYRO_Z, ADIS16400_XGYRO_OFF);
-
-static ADIS16400_DEV_ATTR_CALIBBIAS(ACCEL_X, ADIS16400_XACCL_OFF);
-static ADIS16400_DEV_ATTR_CALIBBIAS(ACCEL_Y, ADIS16400_XACCL_OFF);
-static ADIS16400_DEV_ATTR_CALIBBIAS(ACCEL_Z, ADIS16400_XACCL_OFF);
-
-
-static IIO_DEV_ATTR_IN_NAMED_RAW(supply, adis16400_read_14bit_signed,
- ADIS16400_SUPPLY_OUT);
-static IIO_CONST_ATTR_IN_NAMED_SCALE(supply, "0.002418 V");
-
-static IIO_DEV_ATTR_GYRO_X(adis16400_read_14bit_signed,
- ADIS16400_XGYRO_OUT);
-static IIO_DEV_ATTR_GYRO_Y(adis16400_read_14bit_signed,
- ADIS16400_YGYRO_OUT);
-static IIO_DEV_ATTR_GYRO_Z(adis16400_read_14bit_signed,
- ADIS16400_ZGYRO_OUT);
-static IIO_CONST_ATTR(gyro_scale, "0.0008726646");
-
-static IIO_DEV_ATTR_ACCEL_X(adis16400_read_14bit_signed,
- ADIS16400_XACCL_OUT);
-static IIO_DEV_ATTR_ACCEL_Y(adis16400_read_14bit_signed,
- ADIS16400_YACCL_OUT);
-static IIO_DEV_ATTR_ACCEL_Z(adis16400_read_14bit_signed,
- ADIS16400_ZACCL_OUT);
-static IIO_CONST_ATTR(accel_scale, "0.0326561445");
-
-static IIO_DEV_ATTR_MAGN_X(adis16400_read_14bit_signed,
- ADIS16400_XMAGN_OUT);
-static IIO_DEV_ATTR_MAGN_Y(adis16400_read_14bit_signed,
- ADIS16400_YMAGN_OUT);
-static IIO_DEV_ATTR_MAGN_Z(adis16400_read_14bit_signed,
- ADIS16400_ZMAGN_OUT);
-static IIO_CONST_ATTR(magn_scale, "0.0005 Gs");
-
-
-static IIO_DEV_ATTR_TEMP_RAW(adis16400_read_12bit_signed);
-static IIO_CONST_ATTR_TEMP_OFFSET("198.16 K");
-static IIO_CONST_ATTR_TEMP_SCALE("0.14 K");
-
-static IIO_DEV_ATTR_IN_RAW(0, adis16400_read_12bit_unsigned,
- ADIS16400_AUX_ADC);
-static IIO_CONST_ATTR(in0_scale, "0.000806 V");
-
-static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
- adis16400_read_frequency,
- adis16400_write_frequency);
-
-static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16400_write_reset, 0);
-
-static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("409 546 819 1638");
-
-static IIO_CONST_ATTR_NAME("adis16400");
-
-static struct attribute *adis16400_event_attributes[] = {
- NULL
-};
-
-static struct attribute_group adis16400_event_attribute_group = {
- .attrs = adis16400_event_attributes,
-};
-
-static struct attribute *adis16400_attributes[] = {
- &iio_dev_attr_gyro_x_calibbias.dev_attr.attr,
- &iio_dev_attr_gyro_y_calibbias.dev_attr.attr,
- &iio_dev_attr_gyro_z_calibbias.dev_attr.attr,
- &iio_dev_attr_accel_x_calibbias.dev_attr.attr,
- &iio_dev_attr_accel_y_calibbias.dev_attr.attr,
- &iio_dev_attr_accel_z_calibbias.dev_attr.attr,
- &iio_dev_attr_in_supply_raw.dev_attr.attr,
- &iio_const_attr_in_supply_scale.dev_attr.attr,
- &iio_dev_attr_gyro_x_raw.dev_attr.attr,
- &iio_dev_attr_gyro_y_raw.dev_attr.attr,
- &iio_dev_attr_gyro_z_raw.dev_attr.attr,
- &iio_const_attr_gyro_scale.dev_attr.attr,
- &iio_dev_attr_accel_x_raw.dev_attr.attr,
- &iio_dev_attr_accel_y_raw.dev_attr.attr,
- &iio_dev_attr_accel_z_raw.dev_attr.attr,
- &iio_const_attr_accel_scale.dev_attr.attr,
- &iio_dev_attr_magn_x_raw.dev_attr.attr,
- &iio_dev_attr_magn_y_raw.dev_attr.attr,
- &iio_dev_attr_magn_z_raw.dev_attr.attr,
- &iio_const_attr_magn_scale.dev_attr.attr,
- &iio_dev_attr_temp_raw.dev_attr.attr,
- &iio_const_attr_temp_offset.dev_attr.attr,
- &iio_const_attr_temp_scale.dev_attr.attr,
- &iio_dev_attr_in0_raw.dev_attr.attr,
- &iio_const_attr_in0_scale.dev_attr.attr,
- &iio_dev_attr_sampling_frequency.dev_attr.attr,
- &iio_const_attr_sampling_frequency_available.dev_attr.attr,
- &iio_dev_attr_reset.dev_attr.attr,
- &iio_const_attr_name.dev_attr.attr,
- NULL
-};
-
-static const struct attribute_group adis16400_attribute_group = {
- .attrs = adis16400_attributes,
-};
-
-static int __devinit adis16400_probe(struct spi_device *spi)
-{
- int ret, regdone = 0;
- struct adis16400_state *st = kzalloc(sizeof *st, GFP_KERNEL);
- if (!st) {
- ret = -ENOMEM;
- goto error_ret;
- }
- /* this is only used for removal purposes */
- spi_set_drvdata(spi, st);
-
- /* Allocate the comms buffers */
- st->rx = kzalloc(sizeof(*st->rx)*ADIS16400_MAX_RX, GFP_KERNEL);
- if (st->rx == NULL) {
- ret = -ENOMEM;
- goto error_free_st;
- }
- st->tx = kzalloc(sizeof(*st->tx)*ADIS16400_MAX_TX, GFP_KERNEL);
- if (st->tx == NULL) {
- ret = -ENOMEM;
- goto error_free_rx;
- }
- st->us = spi;
- mutex_init(&st->buf_lock);
- /* setup the industrialio driver allocated elements */
- st->indio_dev = iio_allocate_device();
- if (st->indio_dev == NULL) {
- ret = -ENOMEM;
- goto error_free_tx;
- }
-
- st->indio_dev->dev.parent = &spi->dev;
- st->indio_dev->num_interrupt_lines = 1;
- st->indio_dev->event_attrs = &adis16400_event_attribute_group;
- st->indio_dev->attrs = &adis16400_attribute_group;
- st->indio_dev->dev_data = (void *)(st);
- st->indio_dev->driver_module = THIS_MODULE;
- st->indio_dev->modes = INDIO_DIRECT_MODE;
-
- ret = adis16400_configure_ring(st->indio_dev);
- if (ret)
- goto error_free_dev;
-
- ret = iio_device_register(st->indio_dev);
- if (ret)
- goto error_unreg_ring_funcs;
- regdone = 1;
-
- ret = iio_ring_buffer_register(st->indio_dev->ring, 0);
- if (ret) {
- printk(KERN_ERR "failed to initialize the ring\n");
- goto error_unreg_ring_funcs;
- }
-
- if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0) {
- ret = iio_register_interrupt_line(spi->irq,
- st->indio_dev,
- 0,
- IRQF_TRIGGER_RISING,
- "adis16400");
- if (ret)
- goto error_uninitialize_ring;
-
- ret = adis16400_probe_trigger(st->indio_dev);
- if (ret)
- goto error_unregister_line;
- }
-
- /* Get the device into a sane initial state */
- ret = adis16400_initial_setup(st);
- if (ret)
- goto error_remove_trigger;
- return 0;
-
-error_remove_trigger:
- if (st->indio_dev->modes & INDIO_RING_TRIGGERED)
- adis16400_remove_trigger(st->indio_dev);
-error_unregister_line:
- if (st->indio_dev->modes & INDIO_RING_TRIGGERED)
- iio_unregister_interrupt_line(st->indio_dev, 0);
-error_uninitialize_ring:
- iio_ring_buffer_unregister(st->indio_dev->ring);
-error_unreg_ring_funcs:
- adis16400_unconfigure_ring(st->indio_dev);
-error_free_dev:
- if (regdone)
- iio_device_unregister(st->indio_dev);
- else
- iio_free_device(st->indio_dev);
-error_free_tx:
- kfree(st->tx);
-error_free_rx:
- kfree(st->rx);
-error_free_st:
- kfree(st);
-error_ret:
- return ret;
-}
-
-/* fixme, confirm ordering in this function */
-static int adis16400_remove(struct spi_device *spi)
-{
- int ret;
- struct adis16400_state *st = spi_get_drvdata(spi);
- struct iio_dev *indio_dev = st->indio_dev;
-
- ret = adis16400_stop_device(&(indio_dev->dev));
- if (ret)
- goto err_ret;
-
- flush_scheduled_work();
-
- adis16400_remove_trigger(indio_dev);
- if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0)
- iio_unregister_interrupt_line(indio_dev, 0);
-
- iio_ring_buffer_unregister(st->indio_dev->ring);
- adis16400_unconfigure_ring(indio_dev);
- iio_device_unregister(indio_dev);
- kfree(st->tx);
- kfree(st->rx);
- kfree(st);
-
- return 0;
-
-err_ret:
- return ret;
-}
-
-static struct spi_driver adis16400_driver = {
- .driver = {
- .name = "adis16400",
- .owner = THIS_MODULE,
- },
- .probe = adis16400_probe,
- .remove = __devexit_p(adis16400_remove),
-};
-
-static __init int adis16400_init(void)
-{
- return spi_register_driver(&adis16400_driver);
-}
-module_init(adis16400_init);
-
-static __exit void adis16400_exit(void)
-{
- spi_unregister_driver(&adis16400_driver);
-}
-module_exit(adis16400_exit);
-
-MODULE_AUTHOR("Manuel Stahl <manuel.stahl@iis.fraunhofer.de>");
-MODULE_DESCRIPTION("Analog Devices ADIS16400/5 IMU SPI driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/staging/iio/imu/adis16400_ring.c b/drivers/staging/iio/imu/adis16400_ring.c
deleted file mode 100644
index de5ef5c..0000000
--- a/drivers/staging/iio/imu/adis16400_ring.c
+++ /dev/null
@@ -1,231 +0,0 @@
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/gpio.h>
-#include <linux/workqueue.h>
-#include <linux/mutex.h>
-#include <linux/device.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/list.h>
-
-#include "../iio.h"
-#include "../sysfs.h"
-#include "../ring_sw.h"
-#include "../accel/accel.h"
-#include "../trigger.h"
-#include "adis16400.h"
-
-static IIO_SCAN_EL_C(in_supply, ADIS16400_SCAN_SUPPLY, IIO_SIGNED(14),
- ADIS16400_SUPPLY_OUT, NULL);
-
-static IIO_SCAN_EL_C(gyro_x, ADIS16400_SCAN_GYRO_X, IIO_SIGNED(14),
- ADIS16400_XGYRO_OUT, NULL);
-static IIO_SCAN_EL_C(gyro_y, ADIS16400_SCAN_GYRO_Y, IIO_SIGNED(14),
- ADIS16400_YGYRO_OUT, NULL);
-static IIO_SCAN_EL_C(gyro_z, ADIS16400_SCAN_GYRO_Z, IIO_SIGNED(14),
- ADIS16400_ZGYRO_OUT, NULL);
-
-static IIO_SCAN_EL_C(accel_x, ADIS16400_SCAN_ACC_X, IIO_SIGNED(14),
- ADIS16400_XACCL_OUT, NULL);
-static IIO_SCAN_EL_C(accel_y, ADIS16400_SCAN_ACC_Y, IIO_SIGNED(14),
- ADIS16400_YACCL_OUT, NULL);
-static IIO_SCAN_EL_C(accel_z, ADIS16400_SCAN_ACC_Z, IIO_SIGNED(14),
- ADIS16400_ZACCL_OUT, NULL);
-
-static IIO_SCAN_EL_C(magn_x, ADIS16400_SCAN_MAGN_X, IIO_SIGNED(14),
- ADIS16400_XMAGN_OUT, NULL);
-static IIO_SCAN_EL_C(magn_y, ADIS16400_SCAN_MAGN_Y, IIO_SIGNED(14),
- ADIS16400_YMAGN_OUT, NULL);
-static IIO_SCAN_EL_C(magn_z, ADIS16400_SCAN_MAGN_Z, IIO_SIGNED(14),
- ADIS16400_ZMAGN_OUT, NULL);
-
-static IIO_SCAN_EL_C(temp, ADIS16400_SCAN_TEMP, IIO_SIGNED(12),
- ADIS16400_TEMP_OUT, NULL);
-static IIO_SCAN_EL_C(in0, ADIS16400_SCAN_ADC_0, IIO_SIGNED(12),
- ADIS16400_AUX_ADC, NULL);
-
-static IIO_SCAN_EL_TIMESTAMP(12);
-
-static struct attribute *adis16400_scan_el_attrs[] = {
- &iio_scan_el_in_supply.dev_attr.attr,
- &iio_scan_el_gyro_x.dev_attr.attr,
- &iio_scan_el_gyro_y.dev_attr.attr,
- &iio_scan_el_gyro_z.dev_attr.attr,
- &iio_scan_el_accel_x.dev_attr.attr,
- &iio_scan_el_accel_y.dev_attr.attr,
- &iio_scan_el_accel_z.dev_attr.attr,
- &iio_scan_el_magn_x.dev_attr.attr,
- &iio_scan_el_magn_y.dev_attr.attr,
- &iio_scan_el_magn_z.dev_attr.attr,
- &iio_scan_el_temp.dev_attr.attr,
- &iio_scan_el_in0.dev_attr.attr,
- &iio_scan_el_timestamp.dev_attr.attr,
- NULL,
-};
-
-static struct attribute_group adis16400_scan_el_group = {
- .attrs = adis16400_scan_el_attrs,
- .name = "scan_elements",
-};
-
-/**
- * adis16400_poll_func_th() top half interrupt handler called by trigger
- * @private_data: iio_dev
- **/
-static void adis16400_poll_func_th(struct iio_dev *indio_dev, s64 time)
-{
- struct adis16400_state *st = iio_dev_get_devdata(indio_dev);
- st->last_timestamp = time;
- schedule_work(&st->work_trigger_to_ring);
- /* Indicate that this interrupt is being handled */
-
- /* Technically this is trigger related, but without this
- * handler running there is currently no way for the interrupt
- * to clear.
- */
-}
-
-/**
- * adis16400_spi_read_burst() - read all data registers
- * @dev: device associated with child of actual device (iio_dev or iio_trig)
- * @rx: somewhere to pass back the value read (min size is 24 bytes)
- **/
-static int adis16400_spi_read_burst(struct device *dev, u8 *rx)
-{
- struct spi_message msg;
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- struct adis16400_state *st = iio_dev_get_devdata(indio_dev);
- u32 old_speed_hz = st->us->max_speed_hz;
- int ret;
-
- struct spi_transfer xfers[] = {
- {
- .tx_buf = st->tx,
- .bits_per_word = 8,
- .len = 2,
- .cs_change = 0,
- }, {
- .rx_buf = rx,
- .bits_per_word = 8,
- .len = 24,
- .cs_change = 1,
- },
- };
-
- mutex_lock(&st->buf_lock);
- st->tx[0] = ADIS16400_READ_REG(ADIS16400_GLOB_CMD);
- st->tx[1] = 0;
-
- spi_message_init(&msg);
- spi_message_add_tail(&xfers[0], &msg);
- spi_message_add_tail(&xfers[1], &msg);
-
- st->us->max_speed_hz = min(ADIS16400_SPI_BURST, old_speed_hz);
- spi_setup(st->us);
-
- ret = spi_sync(st->us, &msg);
- if (ret)
- dev_err(&st->us->dev, "problem when burst reading");
-
- st->us->max_speed_hz = old_speed_hz;
- spi_setup(st->us);
- mutex_unlock(&st->buf_lock);
- return ret;
-}
-
-/* Whilst this makes a lot of calls to iio_sw_ring functions - it is to device
- * specific to be rolled into the core.
- */
-static void adis16400_trigger_bh_to_ring(struct work_struct *work_s)
-{
- struct adis16400_state *st
- = container_of(work_s, struct adis16400_state,
- work_trigger_to_ring);
- struct iio_ring_buffer *ring = st->indio_dev->ring;
-
- int i = 0;
- s16 *data;
- size_t datasize = ring->access.get_bytes_per_datum(ring);
-
- data = kmalloc(datasize , GFP_KERNEL);
- if (data == NULL) {
- dev_err(&st->us->dev, "memory alloc failed in ring bh");
- return;
- }
-
- if (ring->scan_count)
- if (adis16400_spi_read_burst(&st->indio_dev->dev, st->rx) >= 0)
- for (; i < ring->scan_count; i++)
- data[i] = be16_to_cpup(
- (__be16 *)&(st->rx[i*2]));
-
- /* Guaranteed to be aligned with 8 byte boundary */
- if (ring->scan_timestamp)
- *((s64 *)(data + ((i + 3)/4)*4)) = st->last_timestamp;
-
- ring->access.store_to(ring,
- (u8 *) data,
- st->last_timestamp);
-
- iio_trigger_notify_done(st->indio_dev->trig);
- kfree(data);
-
- return;
-}
-
-void adis16400_unconfigure_ring(struct iio_dev *indio_dev)
-{
- kfree(indio_dev->pollfunc);
- iio_sw_rb_free(indio_dev->ring);
-}
-
-int adis16400_configure_ring(struct iio_dev *indio_dev)
-{
- int ret = 0;
- struct adis16400_state *st = indio_dev->dev_data;
- struct iio_ring_buffer *ring;
- INIT_WORK(&st->work_trigger_to_ring, adis16400_trigger_bh_to_ring);
-
- ring = iio_sw_rb_allocate(indio_dev);
- if (!ring) {
- ret = -ENOMEM;
- return ret;
- }
- indio_dev->ring = ring;
- /* Effectively select the ring buffer implementation */
- iio_ring_sw_register_funcs(&ring->access);
- ring->bpe = 2;
- ring->scan_el_attrs = &adis16400_scan_el_group;
- ring->scan_timestamp = true;
- ring->preenable = &iio_sw_ring_preenable;
- ring->postenable = &iio_triggered_ring_postenable;
- ring->predisable = &iio_triggered_ring_predisable;
- ring->owner = THIS_MODULE;
-
- /* Set default scan mode */
- iio_scan_mask_set(ring, iio_scan_el_in_supply.number);
- iio_scan_mask_set(ring, iio_scan_el_gyro_x.number);
- iio_scan_mask_set(ring, iio_scan_el_gyro_y.number);
- iio_scan_mask_set(ring, iio_scan_el_gyro_z.number);
- iio_scan_mask_set(ring, iio_scan_el_accel_x.number);
- iio_scan_mask_set(ring, iio_scan_el_accel_y.number);
- iio_scan_mask_set(ring, iio_scan_el_accel_z.number);
- iio_scan_mask_set(ring, iio_scan_el_magn_x.number);
- iio_scan_mask_set(ring, iio_scan_el_magn_y.number);
- iio_scan_mask_set(ring, iio_scan_el_magn_z.number);
- iio_scan_mask_set(ring, iio_scan_el_temp.number);
- iio_scan_mask_set(ring, iio_scan_el_in0.number);
-
- ret = iio_alloc_pollfunc(indio_dev, NULL, &adis16400_poll_func_th);
- if (ret)
- goto error_iio_sw_rb_free;
-
- indio_dev->modes |= INDIO_RING_TRIGGERED;
- return 0;
-
-error_iio_sw_rb_free:
- iio_sw_rb_free(indio_dev->ring);
- return ret;
-}
--
1.7.2.2
^ permalink raw reply related [flat|nested] 12+ messages in thread* Re: [PATCH 6/6] staging:iio:adis16400 merge into adis16350 driver
2010-09-11 14:58 ` [PATCH 6/6] staging:iio:adis16400 " Jonathan Cameron
@ 2010-09-11 15:05 ` Jonathan Cameron
0 siblings, 0 replies; 12+ messages in thread
From: Jonathan Cameron @ 2010-09-11 15:05 UTC (permalink / raw)
To: Jonathan Cameron; +Cc: linux-iio, Michael.Hennerich, Robin.Getz, manuel.stahl
On 09/11/10 15:58, Jonathan Cameron wrote:
> Results in a subtle change to numbering of scan elements on
> the adis16350. This does not technically change the abi as
> these numbers are only guaranteed to be in the correct order,
> not to have particular values.
>
> Signed-off-by: Jonathan Cameron <jic23@cam.ac.uk>
> ---
> drivers/staging/iio/imu/Kconfig | 13 +-
> drivers/staging/iio/imu/Makefile | 4 -
> drivers/staging/iio/imu/adis16350.h | 18 +-
> drivers/staging/iio/imu/adis16350_core.c | 69 +++
> drivers/staging/iio/imu/adis16350_ring.c | 33 ++-
> drivers/staging/iio/imu/adis16400.h | 208 --------
> drivers/staging/iio/imu/adis16400_core.c | 752 ------------------------------
> drivers/staging/iio/imu/adis16400_ring.c | 231 ---------
> 8 files changed, 116 insertions(+), 1212 deletions(-)
>
And here I go again. This one should also delete the adis16400_trigger.c file which is
no longer used. Doh. Changes the stats to:
drivers/staging/iio/imu/Kconfig | 13 +-
drivers/staging/iio/imu/Makefile | 4 -
drivers/staging/iio/imu/adis16350.h | 18 +-
drivers/staging/iio/imu/adis16350_core.c | 69 +++
drivers/staging/iio/imu/adis16350_ring.c | 33 ++-
drivers/staging/iio/imu/adis16400.h | 208 --------
drivers/staging/iio/imu/adis16400_core.c | 752 ---------------------------
drivers/staging/iio/imu/adis16400_ring.c | 231 --------
drivers/staging/iio/imu/adis16400_trigger.c | 125 -----
9 files changed, 116 insertions(+), 1337 deletions(-)
Now these are the kind of patch statistics that people like ;)
There is also a subtle difference in here I forgot to mention. Their is no longer a device
id check on probe. I can put this back in if people would like it. It wasn't ever there in
the adis16350 as far as I know...
Jonathan
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features.
2010-09-11 14:58 [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features Jonathan Cameron
` (5 preceding siblings ...)
2010-09-11 14:58 ` [PATCH 6/6] staging:iio:adis16400 " Jonathan Cameron
@ 2010-09-22 8:47 ` Manuel Stahl
2010-09-22 10:12 ` Jonathan Cameron
6 siblings, 1 reply; 12+ messages in thread
From: Manuel Stahl @ 2010-09-22 8:47 UTC (permalink / raw)
To: Jonathan Cameron; +Cc: linux-iio, Michael.Hennerich, Robin.Getz
[-- Attachment #1: Type: text/plain, Size: 4916 bytes --]
Hi Jonathan,
the merge still has severe problems for adis16400. Ring buffer doesn't
read elements (bytes_per_datum is always 8) but the buffer contains
zeros for the elements and a valid timestamp.
The temp attribute has a different address for adis300 and adis400, so
we need a separate entry here.
The attached patch fixes a few problems, but the ring buffer still does
not work.
Am 11.09.2010 16:58, schrieb Jonathan Cameron:
> The first 4 are repeat postings but are now complete (oops).
>
> Cleaning up this driver set has been on my todo list for a while
> and I've finally had a bit of time to see what could be done to
> reduce the huge amount of repeat code found in the 3 IMU drivers.
>
> This is an RFC for two reasons. Firstly I haven't tested this as
> fully yet and will do so before merging. I will do a whole
> lot more testing on the adis16350 that I have. Coverage of the
> adis16300 and adis16400 would be great if anyone can do so.
> I also haven't done full testing on all the build combinations yet.
> (there is at least one known issue to clean up!)
> Secondly the event patch in particularly has some elements not seen
> elsewhere before that I would like people to consider.
>
> Right now, only the adis16350 and adis16360 famillies are supported
> by the event support patch. I'll add support for the other parts
> at a later date unless someone else beats me to it (hint!). Note
> this patch now actually contains the adis16350_event.c file that
> was missing previously.
>
> There is one effective change to all but the adis16400 ABIs.
> When we originally proposed the [m]_<type>_<modifier>_en
> attributes for scan modes I very carefully stated that the index
> [m] for a given device would not necessarily cover all values between
> 0 and the highest present. It was exactly this possible driver
> merge that motivated that arguement. By allowing indexes to be
> missed, we can have single drivers supporting various subsets of
> sensor elements. Here the devices are such that some interleaving
> is possible. This reduces the storage required for the event code,
> so I have done it where possible. Note the addition
> of new devices to this driver in future may change this again!
>
> As ever, all comments welcome. Any tested-bys with a part number
> would be particularly welcome.
>
> Should be trivial to add the adis16367 and adis16385 to this driver.
> Does anyone have one of these parts to test?
>
> Jonathan Cameron (6):
> staging:iio:adis16350 add non burst buffer fill and fix burst logic
> staging:iio:adis16350 move datardy trigger to straight interrupt.
> staging:iio:adis16350 Add optional event support
> staging:iio:adis16350 add missing registration of temp_offset attr
> staging:iio:adis16300 merge into adis16350 driver
> staging:iio:adis16400 merge into adis16350 driver
>
> drivers/staging/iio/adc/adc.h | 8 +-
> drivers/staging/iio/gyro/gyro.h | 31 +-
> drivers/staging/iio/imu/Kconfig | 30 +-
> drivers/staging/iio/imu/Makefile | 9 +-
> drivers/staging/iio/imu/adis16300.h | 184 -------
> drivers/staging/iio/imu/adis16300_core.c | 756 ---------------------------
> drivers/staging/iio/imu/adis16300_ring.c | 220 --------
> drivers/staging/iio/imu/adis16300_trigger.c | 125 -----
> drivers/staging/iio/imu/adis16350.h | 117 ++++-
> drivers/staging/iio/imu/adis16350_core.c | 287 +++++++++--
> drivers/staging/iio/imu/adis16350_event.c | 499 ++++++++++++++++++
> drivers/staging/iio/imu/adis16350_ring.c | 167 +++++-
> drivers/staging/iio/imu/adis16350_trigger.c | 40 +-
> drivers/staging/iio/imu/adis16400.h | 208 --------
> drivers/staging/iio/imu/adis16400_core.c | 752 --------------------------
> drivers/staging/iio/imu/adis16400_ring.c | 231 --------
> drivers/staging/iio/sysfs.h | 17 +-
> 17 files changed, 1067 insertions(+), 2614 deletions(-)
> delete mode 100644 drivers/staging/iio/imu/adis16300.h
> delete mode 100644 drivers/staging/iio/imu/adis16300_core.c
> delete mode 100644 drivers/staging/iio/imu/adis16300_ring.c
> delete mode 100644 drivers/staging/iio/imu/adis16300_trigger.c
> create mode 100644 drivers/staging/iio/imu/adis16350_event.c
> delete mode 100644 drivers/staging/iio/imu/adis16400.h
> delete mode 100644 drivers/staging/iio/imu/adis16400_core.c
> delete mode 100644 drivers/staging/iio/imu/adis16400_ring.c
>
--
Dipl.-Inf. Manuel Stahl
Fraunhofer-Institut für Integrierte Schaltungen IIS
- Leistungsoptimierte Systeme -
Nordostpark 93 Telefon +49 (0)911/58061-6419
90411 Nürnberg Fax +49 (0)911/58061-6398
http://www.iis.fraunhofer.de manuel.stahl@iis.fraunhofer.de
[-- Attachment #2: adis16350_merge_fix.patch --]
[-- Type: text/plain, Size: 4576 bytes --]
diff --git a/drivers/staging/iio/imu/adis16350.h b/drivers/staging/iio/imu/adis16350.h
index ab98d6c..a37f199 100644
--- a/drivers/staging/iio/imu/adis16350.h
+++ b/drivers/staging/iio/imu/adis16350.h
@@ -22,7 +22,8 @@
#define ADIS16400_XMAGN_OUT 0x10 /* X-axis magnetometer measurement */
#define ADIS16400_YMAGN_OUT 0x12 /* Y-axis magnetometer measurement */
#define ADIS16400_ZMAGN_OUT 0x14 /* Z-axis magnetometer measurement */
-
+#define ADIS16400_TEMP_OUT 0x16 /* Temperature output */
+#define ADIS16400_AUX_ADC 0x18 /* Auxiliary ADC measurement */
#define ADIS16300_TEMP_OUT 0x10 /* Temperature output */
#define ADIS16300_XINCLI_OUT 0x12 /* X-axis inclinometer output measurement */
@@ -52,6 +53,14 @@
#define ADIS16350_ALM_CTRL 0x2E /* Alarm control */
#define ADIS16350_AUX_DAC 0x30 /* Auxiliary DAC data */
+#define ADIS16400_ALM_MAG1 0x40 /* Alarm 1 amplitude threshold */
+#define ADIS16400_ALM_MAG2 0x42 /* Alarm 2 amplitude threshold */
+#define ADIS16400_ALM_SMPL1 0x44 /* Alarm 1 sample size */
+#define ADIS16400_ALM_SMPL2 0x46 /* Alarm 2 sample size */
+#define ADIS16400_ALM_CTRL 0x48 /* Alarm control */
+#define ADIS16400_AUX_DAC 0x4A /* Auxiliary DAC data */
+
+
#define ADIS16350_ERROR_ACTIVE (1<<14)
#define ADIS16350_NEW_DATA (1<<15)
diff --git a/drivers/staging/iio/imu/adis16350_core.c b/drivers/staging/iio/imu/adis16350_core.c
index d8f76c6..b921f1d 100644
--- a/drivers/staging/iio/imu/adis16350_core.c
+++ b/drivers/staging/iio/imu/adis16350_core.c
@@ -484,7 +484,7 @@ static int adis16350_initial_setup(struct adis16350_state *st)
/* use high spi speed if possible */
ret = adis16350_spi_read_reg_16(dev, ADIS16350_SMPL_PRD, &smp_prd);
if (!ret && (smp_prd & ADIS16350_SMPL_PRD_DIV_MASK) < 0x0A) {
- st->us->max_speed_hz = ADIS16350_SPI_SLOW;
+ st->us->max_speed_hz = ADIS16350_SPI_FAST;
spi_setup(st->us);
}
@@ -680,29 +680,32 @@ static IIO_DEV_ATTR_MAGN_Y(adis16350_read_14bit_signed,
static IIO_DEV_ATTR_MAGN_Z(adis16350_read_14bit_signed,
ADIS16400_ZMAGN_OUT);
static IIO_CONST_ATTR(magn_scale, "0.0005 Gs");
+static IIO_DEVICE_ATTR(temp0_raw, S_IRUGO, adis16350_read_12bit_unsigned,
+ NULL, ADIS16300_TEMP_OUT);
+
static struct attribute *adis16400_attributes[] = {
- &iio_dev_attr_gyro_x_calibbias.dev_attr.attr,
- &iio_dev_attr_gyro_y_calibbias.dev_attr.attr,
- &iio_dev_attr_gyro_z_calibbias.dev_attr.attr,
- &iio_dev_attr_accel_x_calibbias.dev_attr.attr,
- &iio_dev_attr_accel_y_calibbias.dev_attr.attr,
- &iio_dev_attr_accel_z_calibbias.dev_attr.attr,
&iio_dev_attr_in_supply_raw.dev_attr.attr,
&iio_const_attr_in_supply_scale.dev_attr.attr,
+ &iio_dev_attr_gyro_scale.dev_attr.attr,
&iio_dev_attr_gyro_x_raw.dev_attr.attr,
&iio_dev_attr_gyro_y_raw.dev_attr.attr,
&iio_dev_attr_gyro_z_raw.dev_attr.attr,
- &iio_dev_attr_gyro_scale.dev_attr.attr,
+ &iio_dev_attr_gyro_x_calibbias.dev_attr.attr,
+ &iio_dev_attr_gyro_y_calibbias.dev_attr.attr,
+ &iio_dev_attr_gyro_z_calibbias.dev_attr.attr,
+ &iio_dev_attr_accel_scale.dev_attr.attr,
&iio_dev_attr_accel_x_raw.dev_attr.attr,
&iio_dev_attr_accel_y_raw.dev_attr.attr,
&iio_dev_attr_accel_z_raw.dev_attr.attr,
- &iio_dev_attr_accel_scale.dev_attr.attr,
+ &iio_dev_attr_accel_x_calibbias.dev_attr.attr,
+ &iio_dev_attr_accel_y_calibbias.dev_attr.attr,
+ &iio_dev_attr_accel_z_calibbias.dev_attr.attr,
+ &iio_const_attr_magn_scale.dev_attr.attr,
&iio_dev_attr_magn_x_raw.dev_attr.attr,
&iio_dev_attr_magn_y_raw.dev_attr.attr,
&iio_dev_attr_magn_z_raw.dev_attr.attr,
- &iio_const_attr_magn_scale.dev_attr.attr,
- &iio_dev_attr_temp_raw.dev_attr.attr,
+ &iio_dev_attr_temp0_raw.dev_attr.attr,
&iio_const_attr_temp_scale.dev_attr.attr,
&iio_const_attr_temp_offset.dev_attr.attr,
&iio_dev_attr_in0_raw.dev_attr.attr,
@@ -833,7 +836,7 @@ static int __devinit adis16350_probe(struct spi_device *spi)
}
st->indio_dev->dev.parent = &spi->dev;
- st->indio_dev->attrs = &adis16350_attribute_group;
+ st->indio_dev->attrs = st->variant->attribute_group;
st->indio_dev->dev_data = (void *)(st);
st->indio_dev->driver_module = THIS_MODULE;
st->indio_dev->modes = INDIO_DIRECT_MODE;
@@ -967,5 +970,6 @@ static __exit void adis16350_exit(void)
module_exit(adis16350_exit);
MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
+MODULE_AUTHOR("Manuel Stahl <manuel.stahl@iis.fraunhofer.de>");
MODULE_DESCRIPTION("Analog Devices ADIS16350/54/55/60/62/64/65 IMU SPI driver");
MODULE_LICENSE("GPL v2");
^ permalink raw reply related [flat|nested] 12+ messages in thread* Re: [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features.
2010-09-22 8:47 ` [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features Manuel Stahl
@ 2010-09-22 10:12 ` Jonathan Cameron
2010-09-22 10:17 ` Jonathan Cameron
0 siblings, 1 reply; 12+ messages in thread
From: Jonathan Cameron @ 2010-09-22 10:12 UTC (permalink / raw)
To: Manuel Stahl; +Cc: linux-iio, Michael.Hennerich, Robin.Getz
On 09/22/10 09:47, Manuel Stahl wrote:
> Hi Jonathan,
>
> the merge still has severe problems for adis16400. Ring buffer doesn't read elements (bytes_per_datum is always 8) but the buffer contains zeros for the elements and a valid timestamp.
>
> The temp attribute has a different address for adis300 and adis400, so we need a separate entry here.
gah. I missed that one. It should actually be temp_x_attr as the datasheet clearly labels it as
the X-axis gyroscope temperature measurement. It matches the address for that on the adis16350 so that
should be fine. Otherwise the only fix would have been to add this a chip_info field and change
the attribute look up appropriately.
>
> The attached patch fixes a few problems, but the ring buffer still does not work.
Strange. I must have messed something up. It's likely to be in the area around burst read.
The original code may have worked with all channels on, but I had to rewrite a chunk to make
it support various channel combinations. This is in the earlier patches in the series
(before the merge ones). I don't have any devices that will do burst mode so I couldn't
test that code.
Will look into it.
Thanks for the patch.
Those alarm attributes can wait until someone implements support for the alarms on the
adis16400. Right now they aren't used.
diff --git a/drivers/staging/iio/imu/adis16350_core.c b/drivers/staging/iio/imu/adis16350_core.c
index d8f76c6..b921f1d 100644
--- a/drivers/staging/iio/imu/adis16350_core.c
+++ b/drivers/staging/iio/imu/adis16350_core.c
@@ -484,7 +484,7 @@ static int adis16350_initial_setup(struct adis16350_state *st)
/* use high spi speed if possible */
ret = adis16350_spi_read_reg_16(dev, ADIS16350_SMPL_PRD, &smp_prd);
if (!ret && (smp_prd & ADIS16350_SMPL_PRD_DIV_MASK) < 0x0A) {
- st->us->max_speed_hz = ADIS16350_SPI_SLOW;
+ st->us->max_speed_hz = ADIS16350_SPI_FAST;
spi_setup(st->us);
}
Is quite clearly a bug in the original code. I'll push that out as a separate fix patch
prior to the series. As it's obvious I'll send that directly to Greg (author as you
of course!).
The reorder doesn't matter, but does make the code order more logical.
oops on the last bug chunk. On the author front, shall we just add to the copyright
notices at the top rather than listing multiple authors? I know a lot of the code
in here is your driver, but technically it was Barry who first used it for the central
device. I'll propose some possible wording in an updated patch set.
>
> Am 11.09.2010 16:58, schrieb Jonathan Cameron:
>> The first 4 are repeat postings but are now complete (oops).
>>
>> Cleaning up this driver set has been on my todo list for a while
>> and I've finally had a bit of time to see what could be done to
>> reduce the huge amount of repeat code found in the 3 IMU drivers.
>>
>> This is an RFC for two reasons. Firstly I haven't tested this as
>> fully yet and will do so before merging. I will do a whole
>> lot more testing on the adis16350 that I have. Coverage of the
>> adis16300 and adis16400 would be great if anyone can do so.
>> I also haven't done full testing on all the build combinations yet.
>> (there is at least one known issue to clean up!)
>> Secondly the event patch in particularly has some elements not seen
>> elsewhere before that I would like people to consider.
>>
>> Right now, only the adis16350 and adis16360 famillies are supported
>> by the event support patch. I'll add support for the other parts
>> at a later date unless someone else beats me to it (hint!). Note
>> this patch now actually contains the adis16350_event.c file that
>> was missing previously.
>>
>> There is one effective change to all but the adis16400 ABIs.
>> When we originally proposed the [m]_<type>_<modifier>_en
>> attributes for scan modes I very carefully stated that the index
>> [m] for a given device would not necessarily cover all values between
>> 0 and the highest present. It was exactly this possible driver
>> merge that motivated that arguement. By allowing indexes to be
>> missed, we can have single drivers supporting various subsets of
>> sensor elements. Here the devices are such that some interleaving
>> is possible. This reduces the storage required for the event code,
>> so I have done it where possible. Note the addition
>> of new devices to this driver in future may change this again!
>>
>> As ever, all comments welcome. Any tested-bys with a part number
>> would be particularly welcome.
>>
>> Should be trivial to add the adis16367 and adis16385 to this driver.
>> Does anyone have one of these parts to test?
>>
>> Jonathan Cameron (6):
>> staging:iio:adis16350 add non burst buffer fill and fix burst logic
>> staging:iio:adis16350 move datardy trigger to straight interrupt.
>> staging:iio:adis16350 Add optional event support
>> staging:iio:adis16350 add missing registration of temp_offset attr
>> staging:iio:adis16300 merge into adis16350 driver
>> staging:iio:adis16400 merge into adis16350 driver
>>
>> drivers/staging/iio/adc/adc.h | 8 +-
>> drivers/staging/iio/gyro/gyro.h | 31 +-
>> drivers/staging/iio/imu/Kconfig | 30 +-
>> drivers/staging/iio/imu/Makefile | 9 +-
>> drivers/staging/iio/imu/adis16300.h | 184 -------
>> drivers/staging/iio/imu/adis16300_core.c | 756 ---------------------------
>> drivers/staging/iio/imu/adis16300_ring.c | 220 --------
>> drivers/staging/iio/imu/adis16300_trigger.c | 125 -----
>> drivers/staging/iio/imu/adis16350.h | 117 ++++-
>> drivers/staging/iio/imu/adis16350_core.c | 287 +++++++++--
>> drivers/staging/iio/imu/adis16350_event.c | 499 ++++++++++++++++++
>> drivers/staging/iio/imu/adis16350_ring.c | 167 +++++-
>> drivers/staging/iio/imu/adis16350_trigger.c | 40 +-
>> drivers/staging/iio/imu/adis16400.h | 208 --------
>> drivers/staging/iio/imu/adis16400_core.c | 752 --------------------------
>> drivers/staging/iio/imu/adis16400_ring.c | 231 --------
>> drivers/staging/iio/sysfs.h | 17 +-
>> 17 files changed, 1067 insertions(+), 2614 deletions(-)
>> delete mode 100644 drivers/staging/iio/imu/adis16300.h
>> delete mode 100644 drivers/staging/iio/imu/adis16300_core.c
>> delete mode 100644 drivers/staging/iio/imu/adis16300_ring.c
>> delete mode 100644 drivers/staging/iio/imu/adis16300_trigger.c
>> create mode 100644 drivers/staging/iio/imu/adis16350_event.c
>> delete mode 100644 drivers/staging/iio/imu/adis16400.h
>> delete mode 100644 drivers/staging/iio/imu/adis16400_core.c
>> delete mode 100644 drivers/staging/iio/imu/adis16400_ring.c
>>
>
>
^ permalink raw reply related [flat|nested] 12+ messages in thread* Re: [RFC PATCH 0/6] staging:iio:imu driver merges, fixes and new features.
2010-09-22 10:12 ` Jonathan Cameron
@ 2010-09-22 10:17 ` Jonathan Cameron
0 siblings, 0 replies; 12+ messages in thread
From: Jonathan Cameron @ 2010-09-22 10:17 UTC (permalink / raw)
To: Jonathan Cameron; +Cc: Manuel Stahl, linux-iio, Michael.Hennerich, Robin.Getz
On 09/22/10 11:12, Jonathan Cameron wrote:
> On 09/22/10 09:47, Manuel Stahl wrote:
>> Hi Jonathan,
>>
>> the merge still has severe problems for adis16400. Ring buffer doesn't read elements (bytes_per_datum is always 8) but the buffer contains zeros for the elements and a valid timestamp.
>>
>> The temp attribute has a different address for adis300 and adis400, so we need a separate entry here.
> gah. I missed that one. It should actually be temp_x_attr as the datasheet clearly labels it as
> the X-axis gyroscope temperature measurement. It matches the address for that on the adis16350 so that
> should be fine. Otherwise the only fix would have been to add this a chip_info field and change
> the attribute look up appropriately.
>>
>> The attached patch fixes a few problems, but the ring buffer still does not work.
> Strange. I must have messed something up. It's likely to be in the area around burst read.
> The original code may have worked with all channels on, but I had to rewrite a chunk to make
> it support various channel combinations. This is in the earlier patches in the series
> (before the merge ones). I don't have any devices that will do burst mode so I couldn't
> test that code.
>
> Will look into it.
>
> Thanks for the patch.
>
> Those alarm attributes can wait until someone implements support for the alarms on the
> adis16400. Right now they aren't used.
>
> diff --git a/drivers/staging/iio/imu/adis16350_core.c b/drivers/staging/iio/imu/adis16350_core.c
> index d8f76c6..b921f1d 100644
> --- a/drivers/staging/iio/imu/adis16350_core.c
> +++ b/drivers/staging/iio/imu/adis16350_core.c
> @@ -484,7 +484,7 @@ static int adis16350_initial_setup(struct adis16350_state *st)
> /* use high spi speed if possible */
> ret = adis16350_spi_read_reg_16(dev, ADIS16350_SMPL_PRD, &smp_prd);
> if (!ret && (smp_prd & ADIS16350_SMPL_PRD_DIV_MASK) < 0x0A) {
> - st->us->max_speed_hz = ADIS16350_SPI_SLOW;
> + st->us->max_speed_hz = ADIS16350_SPI_FAST;
> spi_setup(st->us);
> }
>
> Is quite clearly a bug in the original code. I'll push that out as a separate fix patch
> prior to the series. As it's obvious I'll send that directly to Greg (author as you
> of course!).
>
> The reorder doesn't matter, but does make the code order more logical.
It did however make me take a closer look at the other two sets, and I'd missed one of the calibbias
attrs in the adis16300 so definitely a worthwhile exercise!
^ permalink raw reply [flat|nested] 12+ messages in thread