summaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/iio/accel/mma8452.c6
-rw-r--r--drivers/iio/accel/st_accel_core.c12
-rw-r--r--drivers/iio/accel/st_accel_i2c.c51
-rw-r--r--drivers/iio/adc/Kconfig10
-rw-r--r--drivers/iio/adc/Makefile1
-rw-r--r--drivers/iio/adc/ad7291.c (renamed from drivers/staging/iio/adc/ad7291.c)107
-rw-r--r--drivers/iio/adc/xilinx-xadc-events.c6
-rw-r--r--drivers/iio/common/hid-sensors/hid-sensor-attributes.c5
-rw-r--r--drivers/iio/common/st_sensors/st_sensors_core.c64
-rw-r--r--drivers/iio/common/st_sensors/st_sensors_i2c.c30
-rw-r--r--drivers/iio/dac/ad5504.c5
-rw-r--r--drivers/iio/dac/ad5624r_spi.c5
-rw-r--r--drivers/iio/dac/ad5686.c3
-rw-r--r--drivers/iio/gyro/adis16260.c124
-rw-r--r--drivers/iio/gyro/itg3200_core.c101
-rw-r--r--drivers/iio/gyro/st_gyro_core.c12
-rw-r--r--drivers/iio/gyro/st_gyro_i2c.c39
-rw-r--r--drivers/iio/imu/adis16400_buffer.c3
-rw-r--r--drivers/iio/imu/adis16400_core.c78
-rw-r--r--drivers/iio/imu/adis16480.c82
-rw-r--r--drivers/iio/industrialio-event.c1
-rw-r--r--drivers/iio/light/Kconfig24
-rw-r--r--drivers/iio/light/Makefile2
-rw-r--r--drivers/iio/light/isl29125.c347
-rw-r--r--drivers/iio/light/tcs3414.c405
-rw-r--r--drivers/iio/magnetometer/st_magn_core.c12
-rw-r--r--drivers/iio/magnetometer/st_magn_i2c.c23
-rw-r--r--drivers/iio/pressure/st_pressure_core.c27
-rw-r--r--drivers/iio/pressure/st_pressure_i2c.c23
-rw-r--r--drivers/staging/iio/Documentation/iio_event_monitor.c2
-rw-r--r--drivers/staging/iio/accel/adis16201_core.c14
-rw-r--r--drivers/staging/iio/accel/adis16203_core.c11
-rw-r--r--drivers/staging/iio/accel/adis16204_core.c12
-rw-r--r--drivers/staging/iio/accel/adis16209_core.c18
-rw-r--r--drivers/staging/iio/accel/adis16240_core.c12
-rw-r--r--drivers/staging/iio/adc/Kconfig9
-rw-r--r--drivers/staging/iio/adc/Makefile1
-rw-r--r--drivers/staging/iio/adc/ad7291.h12
-rw-r--r--drivers/staging/iio/adc/ad7606_par.c37
-rw-r--r--drivers/staging/iio/frequency/ad9832.c2
-rw-r--r--drivers/staging/iio/trigger/iio-trig-bfin-timer.c31
41 files changed, 1304 insertions, 465 deletions
diff --git a/drivers/iio/accel/mma8452.c b/drivers/iio/accel/mma8452.c
index 17aeea170566..9231f8a65e79 100644
--- a/drivers/iio/accel/mma8452.c
+++ b/drivers/iio/accel/mma8452.c
@@ -423,9 +423,15 @@ static const struct i2c_device_id mma8452_id[] = {
423}; 423};
424MODULE_DEVICE_TABLE(i2c, mma8452_id); 424MODULE_DEVICE_TABLE(i2c, mma8452_id);
425 425
426static const struct of_device_id mma8452_dt_ids[] = {
427 { .compatible = "fsl,mma8452" },
428 { }
429};
430
426static struct i2c_driver mma8452_driver = { 431static struct i2c_driver mma8452_driver = {
427 .driver = { 432 .driver = {
428 .name = "mma8452", 433 .name = "mma8452",
434 .of_match_table = of_match_ptr(mma8452_dt_ids),
429 .pm = MMA8452_PM_OPS, 435 .pm = MMA8452_PM_OPS,
430 }, 436 },
431 .probe = mma8452_probe, 437 .probe = mma8452_probe,
diff --git a/drivers/iio/accel/st_accel_core.c b/drivers/iio/accel/st_accel_core.c
index a2abf7c2ce3b..087864854c61 100644
--- a/drivers/iio/accel/st_accel_core.c
+++ b/drivers/iio/accel/st_accel_core.c
@@ -393,6 +393,9 @@ static int st_accel_read_raw(struct iio_dev *indio_dev,
393 *val = 0; 393 *val = 0;
394 *val2 = adata->current_fullscale->gain; 394 *val2 = adata->current_fullscale->gain;
395 return IIO_VAL_INT_PLUS_MICRO; 395 return IIO_VAL_INT_PLUS_MICRO;
396 case IIO_CHAN_INFO_SAMP_FREQ:
397 *val = adata->odr;
398 return IIO_VAL_INT;
396 default: 399 default:
397 return -EINVAL; 400 return -EINVAL;
398 } 401 }
@@ -410,6 +413,13 @@ static int st_accel_write_raw(struct iio_dev *indio_dev,
410 case IIO_CHAN_INFO_SCALE: 413 case IIO_CHAN_INFO_SCALE:
411 err = st_sensors_set_fullscale_by_gain(indio_dev, val2); 414 err = st_sensors_set_fullscale_by_gain(indio_dev, val2);
412 break; 415 break;
416 case IIO_CHAN_INFO_SAMP_FREQ:
417 if (val2)
418 return -EINVAL;
419 mutex_lock(&indio_dev->mlock);
420 err = st_sensors_set_odr(indio_dev, val);
421 mutex_unlock(&indio_dev->mlock);
422 return err;
413 default: 423 default:
414 return -EINVAL; 424 return -EINVAL;
415 } 425 }
@@ -417,14 +427,12 @@ static int st_accel_write_raw(struct iio_dev *indio_dev,
417 return err; 427 return err;
418} 428}
419 429
420static ST_SENSOR_DEV_ATTR_SAMP_FREQ();
421static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL(); 430static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
422static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available); 431static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available);
423 432
424static struct attribute *st_accel_attributes[] = { 433static struct attribute *st_accel_attributes[] = {
425 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 434 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
426 &iio_dev_attr_in_accel_scale_available.dev_attr.attr, 435 &iio_dev_attr_in_accel_scale_available.dev_attr.attr,
427 &iio_dev_attr_sampling_frequency.dev_attr.attr,
428 NULL, 436 NULL,
429}; 437};
430 438
diff --git a/drivers/iio/accel/st_accel_i2c.c b/drivers/iio/accel/st_accel_i2c.c
index d7bedbdfc81d..7164aeff3ab1 100644
--- a/drivers/iio/accel/st_accel_i2c.c
+++ b/drivers/iio/accel/st_accel_i2c.c
@@ -18,6 +18,55 @@
18#include <linux/iio/common/st_sensors_i2c.h> 18#include <linux/iio/common/st_sensors_i2c.h>
19#include "st_accel.h" 19#include "st_accel.h"
20 20
21#ifdef CONFIG_OF
22static const struct of_device_id st_accel_of_match[] = {
23 {
24 .compatible = "st,lsm303dlh-accel",
25 .data = LSM303DLH_ACCEL_DEV_NAME,
26 },
27 {
28 .compatible = "st,lsm303dlhc-accel",
29 .data = LSM303DLHC_ACCEL_DEV_NAME,
30 },
31 {
32 .compatible = "st,lis3dh-accel",
33 .data = LIS3DH_ACCEL_DEV_NAME,
34 },
35 {
36 .compatible = "st,lsm330d-accel",
37 .data = LSM330D_ACCEL_DEV_NAME,
38 },
39 {
40 .compatible = "st,lsm330dl-accel",
41 .data = LSM330DL_ACCEL_DEV_NAME,
42 },
43 {
44 .compatible = "st,lsm330dlc-accel",
45 .data = LSM330DLC_ACCEL_DEV_NAME,
46 },
47 {
48 .compatible = "st,lis331dlh-accel",
49 .data = LIS331DLH_ACCEL_DEV_NAME,
50 },
51 {
52 .compatible = "st,lsm303dl-accel",
53 .data = LSM303DL_ACCEL_DEV_NAME,
54 },
55 {
56 .compatible = "st,lsm303dlm-accel",
57 .data = LSM303DLM_ACCEL_DEV_NAME,
58 },
59 {
60 .compatible = "st,lsm330-accel",
61 .data = LSM330_ACCEL_DEV_NAME,
62 },
63 {},
64};
65MODULE_DEVICE_TABLE(of, st_accel_of_match);
66#else
67#define st_accel_of_match NULL
68#endif
69
21static int st_accel_i2c_probe(struct i2c_client *client, 70static int st_accel_i2c_probe(struct i2c_client *client,
22 const struct i2c_device_id *id) 71 const struct i2c_device_id *id)
23{ 72{
@@ -31,6 +80,7 @@ static int st_accel_i2c_probe(struct i2c_client *client,
31 80
32 adata = iio_priv(indio_dev); 81 adata = iio_priv(indio_dev);
33 adata->dev = &client->dev; 82 adata->dev = &client->dev;
83 st_sensors_of_i2c_probe(client, st_accel_of_match);
34 84
35 st_sensors_i2c_configure(indio_dev, client, adata); 85 st_sensors_i2c_configure(indio_dev, client, adata);
36 86
@@ -67,6 +117,7 @@ static struct i2c_driver st_accel_driver = {
67 .driver = { 117 .driver = {
68 .owner = THIS_MODULE, 118 .owner = THIS_MODULE,
69 .name = "st-accel-i2c", 119 .name = "st-accel-i2c",
120 .of_match_table = of_match_ptr(st_accel_of_match),
70 }, 121 },
71 .probe = st_accel_i2c_probe, 122 .probe = st_accel_i2c_probe,
72 .remove = st_accel_i2c_remove, 123 .remove = st_accel_i2c_remove,
diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig
index 20a7073f1dd6..11b048a59fde 100644
--- a/drivers/iio/adc/Kconfig
+++ b/drivers/iio/adc/Kconfig
@@ -20,6 +20,16 @@ config AD7266
20 Say yes here to build support for Analog Devices AD7265 and AD7266 20 Say yes here to build support for Analog Devices AD7265 and AD7266
21 ADCs. 21 ADCs.
22 22
23config AD7291
24 tristate "Analog Devices AD7291 ADC driver"
25 depends on I2C
26 help
27 Say yes here to build support for Analog Devices AD7291
28 8 Channel ADC with temperature sensor.
29
30 To compile this driver as a module, choose M here: the
31 module will be called ad7291.
32
23config AD7298 33config AD7298
24 tristate "Analog Devices AD7298 ADC driver" 34 tristate "Analog Devices AD7298 ADC driver"
25 depends on SPI 35 depends on SPI
diff --git a/drivers/iio/adc/Makefile b/drivers/iio/adc/Makefile
index 38cf5c3f5631..ad81b512aa3d 100644
--- a/drivers/iio/adc/Makefile
+++ b/drivers/iio/adc/Makefile
@@ -5,6 +5,7 @@
5# When adding new entries keep the list in alphabetical order 5# When adding new entries keep the list in alphabetical order
6obj-$(CONFIG_AD_SIGMA_DELTA) += ad_sigma_delta.o 6obj-$(CONFIG_AD_SIGMA_DELTA) += ad_sigma_delta.o
7obj-$(CONFIG_AD7266) += ad7266.o 7obj-$(CONFIG_AD7266) += ad7266.o
8obj-$(CONFIG_AD7291) += ad7291.o
8obj-$(CONFIG_AD7298) += ad7298.o 9obj-$(CONFIG_AD7298) += ad7298.o
9obj-$(CONFIG_AD7923) += ad7923.o 10obj-$(CONFIG_AD7923) += ad7923.o
10obj-$(CONFIG_AD7476) += ad7476.o 11obj-$(CONFIG_AD7476) += ad7476.o
diff --git a/drivers/staging/iio/adc/ad7291.c b/drivers/iio/adc/ad7291.c
index 7194bd138762..c0eabf156702 100644
--- a/drivers/staging/iio/adc/ad7291.c
+++ b/drivers/iio/adc/ad7291.c
@@ -6,22 +6,22 @@
6 * Licensed under the GPL-2 or later. 6 * Licensed under the GPL-2 or later.
7 */ 7 */
8 8
9#include <linux/interrupt.h>
10#include <linux/device.h> 9#include <linux/device.h>
11#include <linux/kernel.h> 10#include <linux/err.h>
12#include <linux/slab.h>
13#include <linux/sysfs.h>
14#include <linux/i2c.h> 11#include <linux/i2c.h>
12#include <linux/interrupt.h>
13#include <linux/kernel.h>
15#include <linux/module.h> 14#include <linux/module.h>
16#include <linux/mutex.h> 15#include <linux/mutex.h>
17#include <linux/regulator/consumer.h> 16#include <linux/regulator/consumer.h>
18#include <linux/err.h> 17#include <linux/slab.h>
18#include <linux/sysfs.h>
19 19
20#include <linux/iio/iio.h> 20#include <linux/iio/iio.h>
21#include <linux/iio/sysfs.h> 21#include <linux/iio/sysfs.h>
22#include <linux/iio/events.h> 22#include <linux/iio/events.h>
23 23
24#include "ad7291.h" 24#include <linux/platform_data/ad7291.h>
25 25
26/* 26/*
27 * Simplified handling 27 * Simplified handling
@@ -31,7 +31,6 @@
31 * is in the read mask. 31 * is in the read mask.
32 * 32 *
33 * The noise-delayed bit as per datasheet suggestion is always enabled. 33 * The noise-delayed bit as per datasheet suggestion is always enabled.
34 *
35 */ 34 */
36 35
37/* 36/*
@@ -47,33 +46,38 @@
47#define AD7291_VOLTAGE_ALERT_STATUS 0x1F 46#define AD7291_VOLTAGE_ALERT_STATUS 0x1F
48#define AD7291_T_ALERT_STATUS 0x20 47#define AD7291_T_ALERT_STATUS 0x20
49 48
49#define AD7291_BITS 12
50#define AD7291_VOLTAGE_LIMIT_COUNT 8 50#define AD7291_VOLTAGE_LIMIT_COUNT 8
51 51
52 52
53/* 53/*
54 * AD7291 command 54 * AD7291 command
55 */ 55 */
56#define AD7291_AUTOCYCLE (1 << 0) 56#define AD7291_AUTOCYCLE BIT(0)
57#define AD7291_RESET (1 << 1) 57#define AD7291_RESET BIT(1)
58#define AD7291_ALERT_CLEAR (1 << 2) 58#define AD7291_ALERT_CLEAR BIT(2)
59#define AD7291_ALERT_POLARITY (1 << 3) 59#define AD7291_ALERT_POLARITY BIT(3)
60#define AD7291_EXT_REF (1 << 4) 60#define AD7291_EXT_REF BIT(4)
61#define AD7291_NOISE_DELAY (1 << 5) 61#define AD7291_NOISE_DELAY BIT(5)
62#define AD7291_T_SENSE_MASK (1 << 7) 62#define AD7291_T_SENSE_MASK BIT(7)
63#define AD7291_VOLTAGE_MASK 0xFF00 63#define AD7291_VOLTAGE_MASK GENMASK(15, 8)
64#define AD7291_VOLTAGE_OFFSET 0x8 64#define AD7291_VOLTAGE_OFFSET 8
65 65
66/* 66/*
67 * AD7291 value masks 67 * AD7291 value masks
68 */ 68 */
69#define AD7291_CHANNEL_MASK 0xF000 69#define AD7291_VALUE_MASK GENMASK(11, 0)
70#define AD7291_BITS 12 70
71#define AD7291_VALUE_MASK 0xFFF 71/*
72#define AD7291_T_VALUE_SIGN 0x400 72 * AD7291 alert register bits
73#define AD7291_T_VALUE_FLOAT_OFFSET 2 73 */
74#define AD7291_T_VALUE_FLOAT_MASK 0x2 74#define AD7291_T_LOW BIT(0)
75#define AD7291_T_HIGH BIT(1)
76#define AD7291_T_AVG_LOW BIT(2)
77#define AD7291_T_AVG_HIGH BIT(3)
78#define AD7291_V_LOW(x) BIT((x) * 2)
79#define AD7291_V_HIGH(x) BIT((x) * 2 + 1)
75 80
76#define AD7291_BITS 12
77 81
78struct ad7291_chip_info { 82struct ad7291_chip_info {
79 struct i2c_client *client; 83 struct i2c_client *client;
@@ -129,14 +133,14 @@ static irqreturn_t ad7291_event_handler(int irq, void *private)
129 ad7291_i2c_write(chip, AD7291_COMMAND, command); 133 ad7291_i2c_write(chip, AD7291_COMMAND, command);
130 134
131 /* For now treat t_sense and t_sense_average the same */ 135 /* For now treat t_sense and t_sense_average the same */
132 if ((t_status & (1 << 0)) || (t_status & (1 << 2))) 136 if ((t_status & AD7291_T_LOW) || (t_status & AD7291_T_AVG_LOW))
133 iio_push_event(indio_dev, 137 iio_push_event(indio_dev,
134 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 138 IIO_UNMOD_EVENT_CODE(IIO_TEMP,
135 0, 139 0,
136 IIO_EV_TYPE_THRESH, 140 IIO_EV_TYPE_THRESH,
137 IIO_EV_DIR_FALLING), 141 IIO_EV_DIR_FALLING),
138 timestamp); 142 timestamp);
139 if ((t_status & (1 << 1)) || (t_status & (1 << 3))) 143 if ((t_status & AD7291_T_HIGH) || (t_status & AD7291_T_AVG_HIGH))
140 iio_push_event(indio_dev, 144 iio_push_event(indio_dev,
141 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 145 IIO_UNMOD_EVENT_CODE(IIO_TEMP,
142 0, 146 0,
@@ -144,18 +148,18 @@ static irqreturn_t ad7291_event_handler(int irq, void *private)
144 IIO_EV_DIR_RISING), 148 IIO_EV_DIR_RISING),
145 timestamp); 149 timestamp);
146 150
147 for (i = 0; i < AD7291_VOLTAGE_LIMIT_COUNT*2; i += 2) { 151 for (i = 0; i < AD7291_VOLTAGE_LIMIT_COUNT; i++) {
148 if (v_status & (1 << i)) 152 if (v_status & AD7291_V_LOW(i))
149 iio_push_event(indio_dev, 153 iio_push_event(indio_dev,
150 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 154 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE,
151 i/2, 155 i,
152 IIO_EV_TYPE_THRESH, 156 IIO_EV_TYPE_THRESH,
153 IIO_EV_DIR_FALLING), 157 IIO_EV_DIR_FALLING),
154 timestamp); 158 timestamp);
155 if (v_status & (1 << (i + 1))) 159 if (v_status & AD7291_V_HIGH(i))
156 iio_push_event(indio_dev, 160 iio_push_event(indio_dev,
157 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 161 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE,
158 i/2, 162 i,
159 IIO_EV_TYPE_THRESH, 163 IIO_EV_TYPE_THRESH,
160 IIO_EV_DIR_RISING), 164 IIO_EV_DIR_RISING),
161 timestamp); 165 timestamp);
@@ -165,7 +169,8 @@ static irqreturn_t ad7291_event_handler(int irq, void *private)
165} 169}
166 170
167static unsigned int ad7291_threshold_reg(const struct iio_chan_spec *chan, 171static unsigned int ad7291_threshold_reg(const struct iio_chan_spec *chan,
168 enum iio_event_direction dir, enum iio_event_info info) 172 enum iio_event_direction dir,
173 enum iio_event_info info)
169{ 174{
170 unsigned int offset; 175 unsigned int offset;
171 176
@@ -174,7 +179,7 @@ static unsigned int ad7291_threshold_reg(const struct iio_chan_spec *chan,
174 offset = chan->channel; 179 offset = chan->channel;
175 break; 180 break;
176 case IIO_TEMP: 181 case IIO_TEMP:
177 offset = 8; 182 offset = AD7291_VOLTAGE_OFFSET;
178 break; 183 break;
179 default: 184 default:
180 return 0; 185 return 0;
@@ -182,14 +187,14 @@ static unsigned int ad7291_threshold_reg(const struct iio_chan_spec *chan,
182 187
183 switch (info) { 188 switch (info) {
184 case IIO_EV_INFO_VALUE: 189 case IIO_EV_INFO_VALUE:
185 if (dir == IIO_EV_DIR_FALLING) 190 if (dir == IIO_EV_DIR_FALLING)
186 return AD7291_DATA_HIGH(offset); 191 return AD7291_DATA_HIGH(offset);
187 else 192 else
188 return AD7291_DATA_LOW(offset); 193 return AD7291_DATA_LOW(offset);
189 case IIO_EV_INFO_HYSTERESIS: 194 case IIO_EV_INFO_HYSTERESIS:
190 return AD7291_HYST(offset); 195 return AD7291_HYST(offset);
191 default: 196 default:
192 break; 197 break;
193 } 198 }
194 return 0; 199 return 0;
195} 200}
@@ -206,7 +211,7 @@ static int ad7291_read_event_value(struct iio_dev *indio_dev,
206 u16 uval; 211 u16 uval;
207 212
208 ret = ad7291_i2c_read(chip, ad7291_threshold_reg(chan, dir, info), 213 ret = ad7291_i2c_read(chip, ad7291_threshold_reg(chan, dir, info),
209 &uval); 214 &uval);
210 if (ret < 0) 215 if (ret < 0)
211 return ret; 216 return ret;
212 217
@@ -237,7 +242,7 @@ static int ad7291_write_event_value(struct iio_dev *indio_dev,
237 } 242 }
238 243
239 return ad7291_i2c_write(chip, ad7291_threshold_reg(chan, dir, info), 244 return ad7291_i2c_write(chip, ad7291_threshold_reg(chan, dir, info),
240 val); 245 val);
241} 246}
242 247
243static int ad7291_read_event_config(struct iio_dev *indio_dev, 248static int ad7291_read_event_config(struct iio_dev *indio_dev,
@@ -246,15 +251,14 @@ static int ad7291_read_event_config(struct iio_dev *indio_dev,
246 enum iio_event_direction dir) 251 enum iio_event_direction dir)
247{ 252{
248 struct ad7291_chip_info *chip = iio_priv(indio_dev); 253 struct ad7291_chip_info *chip = iio_priv(indio_dev);
249 /* To be enabled the channel must simply be on. If any are enabled 254 /*
250 we are in continuous sampling mode */ 255 * To be enabled the channel must simply be on. If any are enabled
256 * we are in continuous sampling mode
257 */
251 258
252 switch (chan->type) { 259 switch (chan->type) {
253 case IIO_VOLTAGE: 260 case IIO_VOLTAGE:
254 if (chip->c_mask & (1 << (15 - chan->channel))) 261 return !!(chip->c_mask & BIT(15 - chan->channel));
255 return 1;
256 else
257 return 0;
258 case IIO_TEMP: 262 case IIO_TEMP:
259 /* always on */ 263 /* always on */
260 return 1; 264 return 1;
@@ -336,7 +340,7 @@ static int ad7291_read_raw(struct iio_dev *indio_dev,
336 } 340 }
337 /* Enable this channel alone */ 341 /* Enable this channel alone */
338 regval = chip->command & (~AD7291_VOLTAGE_MASK); 342 regval = chip->command & (~AD7291_VOLTAGE_MASK);
339 regval |= 1 << (15 - chan->channel); 343 regval |= BIT(15 - chan->channel);
340 ret = ad7291_i2c_write(chip, AD7291_COMMAND, regval); 344 ret = ad7291_i2c_write(chip, AD7291_COMMAND, regval);
341 if (ret < 0) { 345 if (ret < 0) {
342 mutex_unlock(&chip->state_lock); 346 mutex_unlock(&chip->state_lock);
@@ -344,7 +348,7 @@ static int ad7291_read_raw(struct iio_dev *indio_dev,
344 } 348 }
345 /* Read voltage */ 349 /* Read voltage */
346 ret = i2c_smbus_read_word_swapped(chip->client, 350 ret = i2c_smbus_read_word_swapped(chip->client,
347 AD7291_VOLTAGE); 351 AD7291_VOLTAGE);
348 if (ret < 0) { 352 if (ret < 0) {
349 mutex_unlock(&chip->state_lock); 353 mutex_unlock(&chip->state_lock);
350 return ret; 354 return ret;
@@ -355,7 +359,7 @@ static int ad7291_read_raw(struct iio_dev *indio_dev,
355 case IIO_TEMP: 359 case IIO_TEMP:
356 /* Assumes tsense bit of command register always set */ 360 /* Assumes tsense bit of command register always set */
357 ret = i2c_smbus_read_word_swapped(chip->client, 361 ret = i2c_smbus_read_word_swapped(chip->client,
358 AD7291_T_SENSE); 362 AD7291_T_SENSE);
359 if (ret < 0) 363 if (ret < 0)
360 return ret; 364 return ret;
361 *val = sign_extend32(ret, 11); 365 *val = sign_extend32(ret, 11);
@@ -365,7 +369,7 @@ static int ad7291_read_raw(struct iio_dev *indio_dev,
365 } 369 }
366 case IIO_CHAN_INFO_AVERAGE_RAW: 370 case IIO_CHAN_INFO_AVERAGE_RAW:
367 ret = i2c_smbus_read_word_swapped(chip->client, 371 ret = i2c_smbus_read_word_swapped(chip->client,
368 AD7291_T_AVERAGE); 372 AD7291_T_AVERAGE);
369 if (ret < 0) 373 if (ret < 0)
370 return ret; 374 return ret;
371 *val = sign_extend32(ret, 11); 375 *val = sign_extend32(ret, 11);
@@ -375,6 +379,7 @@ static int ad7291_read_raw(struct iio_dev *indio_dev,
375 case IIO_VOLTAGE: 379 case IIO_VOLTAGE:
376 if (chip->reg) { 380 if (chip->reg) {
377 int vref; 381 int vref;
382
378 vref = regulator_get_voltage(chip->reg); 383 vref = regulator_get_voltage(chip->reg);
379 if (vref < 0) 384 if (vref < 0)
380 return vref; 385 return vref;
@@ -460,7 +465,7 @@ static const struct iio_info ad7291_info = {
460}; 465};
461 466
462static int ad7291_probe(struct i2c_client *client, 467static int ad7291_probe(struct i2c_client *client,
463 const struct i2c_device_id *id) 468 const struct i2c_device_id *id)
464{ 469{
465 struct ad7291_platform_data *pdata = client->dev.platform_data; 470 struct ad7291_platform_data *pdata = client->dev.platform_data;
466 struct ad7291_chip_info *chip; 471 struct ad7291_chip_info *chip;
diff --git a/drivers/iio/adc/xilinx-xadc-events.c b/drivers/iio/adc/xilinx-xadc-events.c
index 3e7f0d7a80c3..edcf3aabd70d 100644
--- a/drivers/iio/adc/xilinx-xadc-events.c
+++ b/drivers/iio/adc/xilinx-xadc-events.c
@@ -31,17 +31,11 @@ static const struct iio_chan_spec *xadc_event_to_channel(
31static void xadc_handle_event(struct iio_dev *indio_dev, unsigned int event) 31static void xadc_handle_event(struct iio_dev *indio_dev, unsigned int event)
32{ 32{
33 const struct iio_chan_spec *chan; 33 const struct iio_chan_spec *chan;
34 unsigned int offset;
35 34
36 /* Temperature threshold error, we don't handle this yet */ 35 /* Temperature threshold error, we don't handle this yet */
37 if (event == 0) 36 if (event == 0)
38 return; 37 return;
39 38
40 if (event < 4)
41 offset = event;
42 else
43 offset = event + 4;
44
45 chan = xadc_event_to_channel(indio_dev, event); 39 chan = xadc_event_to_channel(indio_dev, event);
46 40
47 if (chan->type == IIO_TEMP) { 41 if (chan->type == IIO_TEMP) {
diff --git a/drivers/iio/common/hid-sensors/hid-sensor-attributes.c b/drivers/iio/common/hid-sensors/hid-sensor-attributes.c
index 403dd3d8986e..25b01e156d82 100644
--- a/drivers/iio/common/hid-sensors/hid-sensor-attributes.c
+++ b/drivers/iio/common/hid-sensors/hid-sensor-attributes.c
@@ -26,12 +26,12 @@
26#include <linux/iio/iio.h> 26#include <linux/iio/iio.h>
27#include <linux/iio/sysfs.h> 27#include <linux/iio/sysfs.h>
28 28
29struct { 29static struct {
30 u32 usage_id; 30 u32 usage_id;
31 int unit; /* 0 for default others from HID sensor spec */ 31 int unit; /* 0 for default others from HID sensor spec */
32 int scale_val0; /* scale, whole number */ 32 int scale_val0; /* scale, whole number */
33 int scale_val1; /* scale, fraction in micros */ 33 int scale_val1; /* scale, fraction in micros */
34} static unit_conversion[] = { 34} unit_conversion[] = {
35 {HID_USAGE_SENSOR_ACCEL_3D, 0, 9, 806650}, 35 {HID_USAGE_SENSOR_ACCEL_3D, 0, 9, 806650},
36 {HID_USAGE_SENSOR_ACCEL_3D, 36 {HID_USAGE_SENSOR_ACCEL_3D,
37 HID_USAGE_SENSOR_UNITS_METERS_PER_SEC_SQRD, 1, 0}, 37 HID_USAGE_SENSOR_UNITS_METERS_PER_SEC_SQRD, 1, 0},
@@ -343,6 +343,7 @@ int hid_sensor_format_scale(u32 usage_id,
343} 343}
344EXPORT_SYMBOL(hid_sensor_format_scale); 344EXPORT_SYMBOL(hid_sensor_format_scale);
345 345
346static
346int hid_sensor_get_reporting_interval(struct hid_sensor_hub_device *hsdev, 347int hid_sensor_get_reporting_interval(struct hid_sensor_hub_device *hsdev,
347 u32 usage_id, 348 u32 usage_id,
348 struct hid_sensor_common *st) 349 struct hid_sensor_common *st)
diff --git a/drivers/iio/common/st_sensors/st_sensors_core.c b/drivers/iio/common/st_sensors/st_sensors_core.c
index e8b932fed70e..8a4ec00a91a0 100644
--- a/drivers/iio/common/st_sensors/st_sensors_core.c
+++ b/drivers/iio/common/st_sensors/st_sensors_core.c
@@ -14,8 +14,8 @@
14#include <linux/delay.h> 14#include <linux/delay.h>
15#include <linux/iio/iio.h> 15#include <linux/iio/iio.h>
16#include <linux/regulator/consumer.h> 16#include <linux/regulator/consumer.h>
17#include <linux/of.h>
17#include <asm/unaligned.h> 18#include <asm/unaligned.h>
18
19#include <linux/iio/common/st_sensors.h> 19#include <linux/iio/common/st_sensors.h>
20 20
21 21
@@ -265,14 +265,47 @@ static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev,
265 return 0; 265 return 0;
266} 266}
267 267
268#ifdef CONFIG_OF
269static struct st_sensors_platform_data *st_sensors_of_probe(struct device *dev,
270 struct st_sensors_platform_data *defdata)
271{
272 struct st_sensors_platform_data *pdata;
273 struct device_node *np = dev->of_node;
274 u32 val;
275
276 if (!np)
277 return NULL;
278
279 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
280 if (!of_property_read_u32(np, "st,drdy-int-pin", &val) && (val <= 2))
281 pdata->drdy_int_pin = (u8) val;
282 else
283 pdata->drdy_int_pin = defdata ? defdata->drdy_int_pin : 1;
284
285 return pdata;
286}
287#else
288static struct st_sensors_platform_data *st_sensors_of_probe(struct device *dev,
289 struct st_sensors_platform_data *defdata)
290{
291 return NULL;
292}
293#endif
294
268int st_sensors_init_sensor(struct iio_dev *indio_dev, 295int st_sensors_init_sensor(struct iio_dev *indio_dev,
269 struct st_sensors_platform_data *pdata) 296 struct st_sensors_platform_data *pdata)
270{ 297{
271 struct st_sensor_data *sdata = iio_priv(indio_dev); 298 struct st_sensor_data *sdata = iio_priv(indio_dev);
299 struct st_sensors_platform_data *of_pdata;
272 int err = 0; 300 int err = 0;
273 301
274 mutex_init(&sdata->tb.buf_lock); 302 mutex_init(&sdata->tb.buf_lock);
275 303
304 /* If OF/DT pdata exists, it will take precedence of anything else */
305 of_pdata = st_sensors_of_probe(indio_dev->dev.parent, pdata);
306 if (of_pdata)
307 pdata = of_pdata;
308
276 if (pdata) 309 if (pdata)
277 err = st_sensors_set_drdy_int_pin(indio_dev, pdata); 310 err = st_sensors_set_drdy_int_pin(indio_dev, pdata);
278 311
@@ -463,35 +496,6 @@ read_wai_error:
463} 496}
464EXPORT_SYMBOL(st_sensors_check_device_support); 497EXPORT_SYMBOL(st_sensors_check_device_support);
465 498
466ssize_t st_sensors_sysfs_get_sampling_frequency(struct device *dev,
467 struct device_attribute *attr, char *buf)
468{
469 struct st_sensor_data *adata = iio_priv(dev_get_drvdata(dev));
470
471 return sprintf(buf, "%d\n", adata->odr);
472}
473EXPORT_SYMBOL(st_sensors_sysfs_get_sampling_frequency);
474
475ssize_t st_sensors_sysfs_set_sampling_frequency(struct device *dev,
476 struct device_attribute *attr, const char *buf, size_t size)
477{
478 int err;
479 unsigned int odr;
480 struct iio_dev *indio_dev = dev_get_drvdata(dev);
481
482 err = kstrtoint(buf, 10, &odr);
483 if (err < 0)
484 goto conversion_error;
485
486 mutex_lock(&indio_dev->mlock);
487 err = st_sensors_set_odr(indio_dev, odr);
488 mutex_unlock(&indio_dev->mlock);
489
490conversion_error:
491 return err < 0 ? err : size;
492}
493EXPORT_SYMBOL(st_sensors_sysfs_set_sampling_frequency);
494
495ssize_t st_sensors_sysfs_sampling_frequency_avail(struct device *dev, 499ssize_t st_sensors_sysfs_sampling_frequency_avail(struct device *dev,
496 struct device_attribute *attr, char *buf) 500 struct device_attribute *attr, char *buf)
497{ 501{
diff --git a/drivers/iio/common/st_sensors/st_sensors_i2c.c b/drivers/iio/common/st_sensors/st_sensors_i2c.c
index 38af9440c103..bb6f3085f57b 100644
--- a/drivers/iio/common/st_sensors/st_sensors_i2c.c
+++ b/drivers/iio/common/st_sensors/st_sensors_i2c.c
@@ -12,6 +12,7 @@
12#include <linux/module.h> 12#include <linux/module.h>
13#include <linux/slab.h> 13#include <linux/slab.h>
14#include <linux/iio/iio.h> 14#include <linux/iio/iio.h>
15#include <linux/of_device.h>
15 16
16#include <linux/iio/common/st_sensors_i2c.h> 17#include <linux/iio/common/st_sensors_i2c.h>
17 18
@@ -76,6 +77,35 @@ void st_sensors_i2c_configure(struct iio_dev *indio_dev,
76} 77}
77EXPORT_SYMBOL(st_sensors_i2c_configure); 78EXPORT_SYMBOL(st_sensors_i2c_configure);
78 79
80#ifdef CONFIG_OF
81/**
82 * st_sensors_of_i2c_probe() - device tree probe for ST I2C sensors
83 * @client: the I2C client device for the sensor
84 * @match: the OF match table for the device, containing compatible strings
85 * but also a .data field with the corresponding internal kernel name
86 * used by this sensor.
87 *
88 * In effect this function matches a compatible string to an internal kernel
89 * name for a certain sensor device, so that the rest of the autodetection can
90 * rely on that name from this point on. I2C client devices will be renamed
91 * to match the internal kernel convention.
92 */
93void st_sensors_of_i2c_probe(struct i2c_client *client,
94 const struct of_device_id *match)
95{
96 const struct of_device_id *of_id;
97
98 of_id = of_match_device(match, &client->dev);
99 if (!of_id)
100 return;
101
102 /* The name from the OF match takes precedence if present */
103 strncpy(client->name, of_id->data, sizeof(client->name));
104 client->name[sizeof(client->name) - 1] = '\0';
105}
106EXPORT_SYMBOL(st_sensors_of_i2c_probe);
107#endif
108
79MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>"); 109MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
80MODULE_DESCRIPTION("STMicroelectronics ST-sensors i2c driver"); 110MODULE_DESCRIPTION("STMicroelectronics ST-sensors i2c driver");
81MODULE_LICENSE("GPL v2"); 111MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/dac/ad5504.c b/drivers/iio/dac/ad5504.c
index c917dd24090a..581ec141de3d 100644
--- a/drivers/iio/dac/ad5504.c
+++ b/drivers/iio/dac/ad5504.c
@@ -125,7 +125,6 @@ static int ad5504_write_raw(struct iio_dev *indio_dev,
125 long mask) 125 long mask)
126{ 126{
127 struct ad5504_state *st = iio_priv(indio_dev); 127 struct ad5504_state *st = iio_priv(indio_dev);
128 int ret;
129 128
130 switch (mask) { 129 switch (mask) {
131 case IIO_CHAN_INFO_RAW: 130 case IIO_CHAN_INFO_RAW:
@@ -134,10 +133,8 @@ static int ad5504_write_raw(struct iio_dev *indio_dev,
134 133
135 return ad5504_spi_write(st, chan->address, val); 134 return ad5504_spi_write(st, chan->address, val);
136 default: 135 default:
137 ret = -EINVAL; 136 return -EINVAL;
138 } 137 }
139
140 return -EINVAL;
141} 138}
142 139
143static const char * const ad5504_powerdown_modes[] = { 140static const char * const ad5504_powerdown_modes[] = {
diff --git a/drivers/iio/dac/ad5624r_spi.c b/drivers/iio/dac/ad5624r_spi.c
index e8199cce2aea..61bb9d4239ea 100644
--- a/drivers/iio/dac/ad5624r_spi.c
+++ b/drivers/iio/dac/ad5624r_spi.c
@@ -67,7 +67,6 @@ static int ad5624r_write_raw(struct iio_dev *indio_dev,
67 long mask) 67 long mask)
68{ 68{
69 struct ad5624r_state *st = iio_priv(indio_dev); 69 struct ad5624r_state *st = iio_priv(indio_dev);
70 int ret;
71 70
72 switch (mask) { 71 switch (mask) {
73 case IIO_CHAN_INFO_RAW: 72 case IIO_CHAN_INFO_RAW:
@@ -79,10 +78,8 @@ static int ad5624r_write_raw(struct iio_dev *indio_dev,
79 chan->address, val, 78 chan->address, val,
80 chan->scan_type.shift); 79 chan->scan_type.shift);
81 default: 80 default:
82 ret = -EINVAL; 81 return -EINVAL;
83 } 82 }
84
85 return -EINVAL;
86} 83}
87 84
88static const char * const ad5624r_powerdown_modes[] = { 85static const char * const ad5624r_powerdown_modes[] = {
diff --git a/drivers/iio/dac/ad5686.c b/drivers/iio/dac/ad5686.c
index 17aca4d9bd06..f57562aa396f 100644
--- a/drivers/iio/dac/ad5686.c
+++ b/drivers/iio/dac/ad5686.c
@@ -313,7 +313,7 @@ static int ad5686_probe(struct spi_device *spi)
313{ 313{
314 struct ad5686_state *st; 314 struct ad5686_state *st;
315 struct iio_dev *indio_dev; 315 struct iio_dev *indio_dev;
316 int ret, regdone = 0, voltage_uv = 0; 316 int ret, voltage_uv = 0;
317 317
318 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); 318 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
319 if (indio_dev == NULL) 319 if (indio_dev == NULL)
@@ -355,7 +355,6 @@ static int ad5686_probe(struct spi_device *spi)
355 indio_dev->channels = st->chip_info->channel; 355 indio_dev->channels = st->chip_info->channel;
356 indio_dev->num_channels = AD5686_DAC_CHANNELS; 356 indio_dev->num_channels = AD5686_DAC_CHANNELS;
357 357
358 regdone = 1;
359 ret = ad5686_spi_write(st, AD5686_CMD_INTERNAL_REFER_SETUP, 0, 358 ret = ad5686_spi_write(st, AD5686_CMD_INTERNAL_REFER_SETUP, 0,
360 !!voltage_uv, 0); 359 !!voltage_uv, 0);
361 if (ret) 360 if (ret)
diff --git a/drivers/iio/gyro/adis16260.c b/drivers/iio/gyro/adis16260.c
index 22b6fb80fa1a..75fe0edd3d0f 100644
--- a/drivers/iio/gyro/adis16260.c
+++ b/drivers/iio/gyro/adis16260.c
@@ -101,65 +101,6 @@
101#define ADIS16260_SCAN_TEMP 3 101#define ADIS16260_SCAN_TEMP 3
102#define ADIS16260_SCAN_ANGL 4 102#define ADIS16260_SCAN_ANGL 4
103 103
104static ssize_t adis16260_read_frequency(struct device *dev,
105 struct device_attribute *attr,
106 char *buf)
107{
108 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
109 struct adis *adis = iio_priv(indio_dev);
110 int ret, len = 0;
111 u16 t;
112 int sps;
113 ret = adis_read_reg_16(adis, ADIS16260_SMPL_PRD, &t);
114 if (ret)
115 return ret;
116
117 if (spi_get_device_id(adis->spi)->driver_data) /* If an adis16251 */
118 sps = (t & ADIS16260_SMPL_PRD_TIME_BASE) ? 8 : 256;
119 else
120 sps = (t & ADIS16260_SMPL_PRD_TIME_BASE) ? 66 : 2048;
121 sps /= (t & ADIS16260_SMPL_PRD_DIV_MASK) + 1;
122 len = sprintf(buf, "%d\n", sps);
123 return len;
124}
125
126static ssize_t adis16260_write_frequency(struct device *dev,
127 struct device_attribute *attr,
128 const char *buf,
129 size_t len)
130{
131 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
132 struct adis *adis = iio_priv(indio_dev);
133 unsigned int val;
134 int ret;
135 u8 t;
136
137 ret = kstrtouint(buf, 10, &val);
138 if (ret)
139 return ret;
140
141 mutex_lock(&indio_dev->mlock);
142 if (spi_get_device_id(adis->spi)->driver_data)
143 t = 256 / val;
144 else
145 t = 2048 / val;
146
147 if (t > ADIS16260_SMPL_PRD_DIV_MASK)
148 t = ADIS16260_SMPL_PRD_DIV_MASK;
149 else if (t > 0)
150 t--;
151
152 if (t >= 0x0A)
153 adis->spi->max_speed_hz = ADIS16260_SPI_SLOW;
154 else
155 adis->spi->max_speed_hz = ADIS16260_SPI_FAST;
156 ret = adis_write_reg_8(adis, ADIS16260_SMPL_PRD, t);
157
158 mutex_unlock(&indio_dev->mlock);
159
160 return ret ? ret : len;
161}
162
163/* Power down the device */ 104/* Power down the device */
164static int adis16260_stop_device(struct iio_dev *indio_dev) 105static int adis16260_stop_device(struct iio_dev *indio_dev)
165{ 106{
@@ -174,18 +115,19 @@ static int adis16260_stop_device(struct iio_dev *indio_dev)
174 return ret; 115 return ret;
175} 116}
176 117
177static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
178 adis16260_read_frequency,
179 adis16260_write_frequency);
180
181static const struct iio_chan_spec adis16260_channels[] = { 118static const struct iio_chan_spec adis16260_channels[] = {
182 ADIS_GYRO_CHAN(X, ADIS16260_GYRO_OUT, ADIS16260_SCAN_GYRO, 119 ADIS_GYRO_CHAN(X, ADIS16260_GYRO_OUT, ADIS16260_SCAN_GYRO,
183 BIT(IIO_CHAN_INFO_CALIBBIAS) | 120 BIT(IIO_CHAN_INFO_CALIBBIAS) |
184 BIT(IIO_CHAN_INFO_CALIBSCALE), 14), 121 BIT(IIO_CHAN_INFO_CALIBSCALE),
185 ADIS_INCLI_CHAN(X, ADIS16260_ANGL_OUT, ADIS16260_SCAN_ANGL, 0, 14), 122 BIT(IIO_CHAN_INFO_SAMP_FREQ), 14),
186 ADIS_TEMP_CHAN(ADIS16260_TEMP_OUT, ADIS16260_SCAN_TEMP, 12), 123 ADIS_INCLI_CHAN(X, ADIS16260_ANGL_OUT, ADIS16260_SCAN_ANGL, 0,
187 ADIS_SUPPLY_CHAN(ADIS16260_SUPPLY_OUT, ADIS16260_SCAN_SUPPLY, 12), 124 BIT(IIO_CHAN_INFO_SAMP_FREQ), 14),
188 ADIS_AUX_ADC_CHAN(ADIS16260_AUX_ADC, ADIS16260_SCAN_AUX_ADC, 12), 125 ADIS_TEMP_CHAN(ADIS16260_TEMP_OUT, ADIS16260_SCAN_TEMP,
126 BIT(IIO_CHAN_INFO_SAMP_FREQ), 12),
127 ADIS_SUPPLY_CHAN(ADIS16260_SUPPLY_OUT, ADIS16260_SCAN_SUPPLY,
128 BIT(IIO_CHAN_INFO_SAMP_FREQ), 12),
129 ADIS_AUX_ADC_CHAN(ADIS16260_AUX_ADC, ADIS16260_SCAN_AUX_ADC,
130 BIT(IIO_CHAN_INFO_SAMP_FREQ), 12),
189 IIO_CHAN_SOFT_TIMESTAMP(5), 131 IIO_CHAN_SOFT_TIMESTAMP(5),
190}; 132};
191 133
@@ -258,6 +200,20 @@ static int adis16260_read_raw(struct iio_dev *indio_dev,
258 200
259 *val = val16; 201 *val = val16;
260 return IIO_VAL_INT; 202 return IIO_VAL_INT;
203 case IIO_CHAN_INFO_SAMP_FREQ:
204 ret = adis_read_reg_16(adis, ADIS16260_SMPL_PRD, &val16);
205 if (ret)
206 return ret;
207
208 if (spi_get_device_id(adis->spi)->driver_data)
209 /* If an adis16251 */
210 *val = (val16 & ADIS16260_SMPL_PRD_TIME_BASE) ?
211 8 : 256;
212 else
213 *val = (val16 & ADIS16260_SMPL_PRD_TIME_BASE) ?
214 66 : 2048;
215 *val /= (val16 & ADIS16260_SMPL_PRD_DIV_MASK) + 1;
216 return IIO_VAL_INT;
261 } 217 }
262 return -EINVAL; 218 return -EINVAL;
263} 219}
@@ -269,7 +225,9 @@ static int adis16260_write_raw(struct iio_dev *indio_dev,
269 long mask) 225 long mask)
270{ 226{
271 struct adis *adis = iio_priv(indio_dev); 227 struct adis *adis = iio_priv(indio_dev);
228 int ret;
272 u8 addr; 229 u8 addr;
230 u8 t;
273 231
274 switch (mask) { 232 switch (mask) {
275 case IIO_CHAN_INFO_CALIBBIAS: 233 case IIO_CHAN_INFO_CALIBBIAS:
@@ -284,21 +242,31 @@ static int adis16260_write_raw(struct iio_dev *indio_dev,
284 242
285 addr = adis16260_addresses[chan->scan_index][1]; 243 addr = adis16260_addresses[chan->scan_index][1];
286 return adis_write_reg_16(adis, addr, val); 244 return adis_write_reg_16(adis, addr, val);
245 case IIO_CHAN_INFO_SAMP_FREQ:
246 mutex_lock(&indio_dev->mlock);
247 if (spi_get_device_id(adis->spi)->driver_data)
248 t = 256 / val;
249 else
250 t = 2048 / val;
251
252 if (t > ADIS16260_SMPL_PRD_DIV_MASK)
253 t = ADIS16260_SMPL_PRD_DIV_MASK;
254 else if (t > 0)
255 t--;
256
257 if (t >= 0x0A)
258 adis->spi->max_speed_hz = ADIS16260_SPI_SLOW;
259 else
260 adis->spi->max_speed_hz = ADIS16260_SPI_FAST;
261 ret = adis_write_reg_8(adis, ADIS16260_SMPL_PRD, t);
262
263 mutex_unlock(&indio_dev->mlock);
264 return ret;
287 } 265 }
288 return -EINVAL; 266 return -EINVAL;
289} 267}
290 268
291static struct attribute *adis16260_attributes[] = {
292 &iio_dev_attr_sampling_frequency.dev_attr.attr,
293 NULL
294};
295
296static const struct attribute_group adis16260_attribute_group = {
297 .attrs = adis16260_attributes,
298};
299
300static const struct iio_info adis16260_info = { 269static const struct iio_info adis16260_info = {
301 .attrs = &adis16260_attribute_group,
302 .read_raw = &adis16260_read_raw, 270 .read_raw = &adis16260_read_raw,
303 .write_raw = &adis16260_write_raw, 271 .write_raw = &adis16260_write_raw,
304 .update_scan_mode = adis_update_scan_mode, 272 .update_scan_mode = adis_update_scan_mode,
diff --git a/drivers/iio/gyro/itg3200_core.c b/drivers/iio/gyro/itg3200_core.c
index 8295e318399f..6a8020d48140 100644
--- a/drivers/iio/gyro/itg3200_core.c
+++ b/drivers/iio/gyro/itg3200_core.c
@@ -90,6 +90,7 @@ static int itg3200_read_raw(struct iio_dev *indio_dev,
90{ 90{
91 int ret = 0; 91 int ret = 0;
92 u8 reg; 92 u8 reg;
93 u8 regval;
93 94
94 switch (info) { 95 switch (info) {
95 case IIO_CHAN_INFO_RAW: 96 case IIO_CHAN_INFO_RAW:
@@ -107,65 +108,60 @@ static int itg3200_read_raw(struct iio_dev *indio_dev,
107 /* Only the temperature channel has an offset */ 108 /* Only the temperature channel has an offset */
108 *val = 23000; 109 *val = 23000;
109 return IIO_VAL_INT; 110 return IIO_VAL_INT;
110 default: 111 case IIO_CHAN_INFO_SAMP_FREQ:
111 return -EINVAL; 112 ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_DLPF, &regval);
112 } 113 if (ret)
113} 114 return ret;
114
115static ssize_t itg3200_read_frequency(struct device *dev,
116 struct device_attribute *attr, char *buf)
117{
118 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
119 int ret, sps;
120 u8 val;
121
122 ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_DLPF, &val);
123 if (ret)
124 return ret;
125 115
126 sps = (val & ITG3200_DLPF_CFG_MASK) ? 1000 : 8000; 116 *val = (regval & ITG3200_DLPF_CFG_MASK) ? 1000 : 8000;
127 117
128 ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_SAMPLE_RATE_DIV, &val); 118 ret = itg3200_read_reg_8(indio_dev,
129 if (ret) 119 ITG3200_REG_SAMPLE_RATE_DIV,
130 return ret; 120 &regval);
121 if (ret)
122 return ret;
131 123
132 sps /= val + 1; 124 *val /= regval + 1;
125 return IIO_VAL_INT;
133 126
134 return sprintf(buf, "%d\n", sps); 127 default:
128 return -EINVAL;
129 }
135} 130}
136 131
137static ssize_t itg3200_write_frequency(struct device *dev, 132static int itg3200_write_raw(struct iio_dev *indio_dev,
138 struct device_attribute *attr, 133 struct iio_chan_spec const *chan,
139 const char *buf, 134 int val,
140 size_t len) 135 int val2,
136 long mask)
141{ 137{
142 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
143 unsigned val;
144 int ret; 138 int ret;
145 u8 t; 139 u8 t;
146 140
147 ret = kstrtouint(buf, 10, &val); 141 switch (mask) {
148 if (ret) 142 case IIO_CHAN_INFO_SAMP_FREQ:
149 return ret; 143 if (val == 0 || val2 != 0)
144 return -EINVAL;
150 145
151 mutex_lock(&indio_dev->mlock); 146 mutex_lock(&indio_dev->mlock);
152 147
153 ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_DLPF, &t); 148 ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_DLPF, &t);
154 if (ret) 149 if (ret) {
155 goto err_ret; 150 mutex_unlock(&indio_dev->mlock);
151 return ret;
152 }
153 t = ((t & ITG3200_DLPF_CFG_MASK) ? 1000u : 8000u) / val - 1;
156 154
157 if (val == 0) { 155 ret = itg3200_write_reg_8(indio_dev,
158 ret = -EINVAL; 156 ITG3200_REG_SAMPLE_RATE_DIV,
159 goto err_ret; 157 t);
160 }
161 t = ((t & ITG3200_DLPF_CFG_MASK) ? 1000u : 8000u) / val - 1;
162 158
163 ret = itg3200_write_reg_8(indio_dev, ITG3200_REG_SAMPLE_RATE_DIV, t); 159 mutex_unlock(&indio_dev->mlock);
164 160 return ret;
165err_ret:
166 mutex_unlock(&indio_dev->mlock);
167 161
168 return ret ? ret : len; 162 default:
163 return -EINVAL;
164 }
169} 165}
170 166
171/* 167/*
@@ -255,6 +251,7 @@ err_ret:
255 .channel2 = IIO_MOD_ ## _mod, \ 251 .channel2 = IIO_MOD_ ## _mod, \
256 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 252 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
257 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 253 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
254 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
258 .address = ITG3200_REG_GYRO_ ## _mod ## OUT_H, \ 255 .address = ITG3200_REG_GYRO_ ## _mod ## OUT_H, \
259 .scan_index = ITG3200_SCAN_GYRO_ ## _mod, \ 256 .scan_index = ITG3200_SCAN_GYRO_ ## _mod, \
260 .scan_type = ITG3200_ST, \ 257 .scan_type = ITG3200_ST, \
@@ -267,6 +264,7 @@ static const struct iio_chan_spec itg3200_channels[] = {
267 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 264 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
268 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) | 265 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
269 BIT(IIO_CHAN_INFO_SCALE), 266 BIT(IIO_CHAN_INFO_SCALE),
267 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
270 .address = ITG3200_REG_TEMP_OUT_H, 268 .address = ITG3200_REG_TEMP_OUT_H,
271 .scan_index = ITG3200_SCAN_TEMP, 269 .scan_index = ITG3200_SCAN_TEMP,
272 .scan_type = ITG3200_ST, 270 .scan_type = ITG3200_ST,
@@ -277,22 +275,9 @@ static const struct iio_chan_spec itg3200_channels[] = {
277 IIO_CHAN_SOFT_TIMESTAMP(ITG3200_SCAN_ELEMENTS), 275 IIO_CHAN_SOFT_TIMESTAMP(ITG3200_SCAN_ELEMENTS),
278}; 276};
279 277
280/* IIO device attributes */
281static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO, itg3200_read_frequency,
282 itg3200_write_frequency);
283
284static struct attribute *itg3200_attributes[] = {
285 &iio_dev_attr_sampling_frequency.dev_attr.attr,
286 NULL
287};
288
289static const struct attribute_group itg3200_attribute_group = {
290 .attrs = itg3200_attributes,
291};
292
293static const struct iio_info itg3200_info = { 278static const struct iio_info itg3200_info = {
294 .attrs = &itg3200_attribute_group,
295 .read_raw = &itg3200_read_raw, 279 .read_raw = &itg3200_read_raw,
280 .write_raw = &itg3200_write_raw,
296 .driver_module = THIS_MODULE, 281 .driver_module = THIS_MODULE,
297}; 282};
298 283
diff --git a/drivers/iio/gyro/st_gyro_core.c b/drivers/iio/gyro/st_gyro_core.c
index ed74a9069989..f156fc6c5c6c 100644
--- a/drivers/iio/gyro/st_gyro_core.c
+++ b/drivers/iio/gyro/st_gyro_core.c
@@ -245,6 +245,9 @@ static int st_gyro_read_raw(struct iio_dev *indio_dev,
245 *val = 0; 245 *val = 0;
246 *val2 = gdata->current_fullscale->gain; 246 *val2 = gdata->current_fullscale->gain;
247 return IIO_VAL_INT_PLUS_MICRO; 247 return IIO_VAL_INT_PLUS_MICRO;
248 case IIO_CHAN_INFO_SAMP_FREQ:
249 *val = gdata->odr;
250 return IIO_VAL_INT;
248 default: 251 default:
249 return -EINVAL; 252 return -EINVAL;
250 } 253 }
@@ -262,6 +265,13 @@ static int st_gyro_write_raw(struct iio_dev *indio_dev,
262 case IIO_CHAN_INFO_SCALE: 265 case IIO_CHAN_INFO_SCALE:
263 err = st_sensors_set_fullscale_by_gain(indio_dev, val2); 266 err = st_sensors_set_fullscale_by_gain(indio_dev, val2);
264 break; 267 break;
268 case IIO_CHAN_INFO_SAMP_FREQ:
269 if (val2)
270 return -EINVAL;
271 mutex_lock(&indio_dev->mlock);
272 err = st_sensors_set_odr(indio_dev, val);
273 mutex_unlock(&indio_dev->mlock);
274 return err;
265 default: 275 default:
266 err = -EINVAL; 276 err = -EINVAL;
267 } 277 }
@@ -269,14 +279,12 @@ static int st_gyro_write_raw(struct iio_dev *indio_dev,
269 return err; 279 return err;
270} 280}
271 281
272static ST_SENSOR_DEV_ATTR_SAMP_FREQ();
273static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL(); 282static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
274static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_anglvel_scale_available); 283static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_anglvel_scale_available);
275 284
276static struct attribute *st_gyro_attributes[] = { 285static struct attribute *st_gyro_attributes[] = {
277 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 286 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
278 &iio_dev_attr_in_anglvel_scale_available.dev_attr.attr, 287 &iio_dev_attr_in_anglvel_scale_available.dev_attr.attr,
279 &iio_dev_attr_sampling_frequency.dev_attr.attr,
280 NULL, 288 NULL,
281}; 289};
282 290
diff --git a/drivers/iio/gyro/st_gyro_i2c.c b/drivers/iio/gyro/st_gyro_i2c.c
index 23c12f361b05..8fa0ad2ef4ef 100644
--- a/drivers/iio/gyro/st_gyro_i2c.c
+++ b/drivers/iio/gyro/st_gyro_i2c.c
@@ -18,6 +18,43 @@
18#include <linux/iio/common/st_sensors_i2c.h> 18#include <linux/iio/common/st_sensors_i2c.h>
19#include "st_gyro.h" 19#include "st_gyro.h"
20 20
21#ifdef CONFIG_OF
22static const struct of_device_id st_gyro_of_match[] = {
23 {
24 .compatible = "st,l3g4200d-gyro",
25 .data = L3G4200D_GYRO_DEV_NAME,
26 },
27 {
28 .compatible = "st,lsm330d-gyro",
29 .data = LSM330D_GYRO_DEV_NAME,
30 },
31 {
32 .compatible = "st,lsm330dl-gyro",
33 .data = LSM330DL_GYRO_DEV_NAME,
34 },
35 {
36 .compatible = "st,lsm330dlc-gyro",
37 .data = LSM330DLC_GYRO_DEV_NAME,
38 },
39 {
40 .compatible = "st,l3gd20-gyro",
41 .data = L3GD20_GYRO_DEV_NAME,
42 },
43 {
44 .compatible = "st,l3g4is-gyro",
45 .data = L3G4IS_GYRO_DEV_NAME,
46 },
47 {
48 .compatible = "st,lsm330-gyro",
49 .data = LSM330_GYRO_DEV_NAME,
50 },
51 {},
52};
53MODULE_DEVICE_TABLE(of, st_gyro_of_match);
54#else
55#define st_gyro_of_match NULL
56#endif
57
21static int st_gyro_i2c_probe(struct i2c_client *client, 58static int st_gyro_i2c_probe(struct i2c_client *client,
22 const struct i2c_device_id *id) 59 const struct i2c_device_id *id)
23{ 60{
@@ -31,6 +68,7 @@ static int st_gyro_i2c_probe(struct i2c_client *client,
31 68
32 gdata = iio_priv(indio_dev); 69 gdata = iio_priv(indio_dev);
33 gdata->dev = &client->dev; 70 gdata->dev = &client->dev;
71 st_sensors_of_i2c_probe(client, st_gyro_of_match);
34 72
35 st_sensors_i2c_configure(indio_dev, client, gdata); 73 st_sensors_i2c_configure(indio_dev, client, gdata);
36 74
@@ -65,6 +103,7 @@ static struct i2c_driver st_gyro_driver = {
65 .driver = { 103 .driver = {
66 .owner = THIS_MODULE, 104 .owner = THIS_MODULE,
67 .name = "st-gyro-i2c", 105 .name = "st-gyro-i2c",
106 .of_match_table = of_match_ptr(st_gyro_of_match),
68 }, 107 },
69 .probe = st_gyro_i2c_probe, 108 .probe = st_gyro_i2c_probe,
70 .remove = st_gyro_i2c_remove, 109 .remove = st_gyro_i2c_remove,
diff --git a/drivers/iio/imu/adis16400_buffer.c b/drivers/iio/imu/adis16400_buffer.c
index f2cf829e5df1..6e727ffe5262 100644
--- a/drivers/iio/imu/adis16400_buffer.c
+++ b/drivers/iio/imu/adis16400_buffer.c
@@ -18,7 +18,7 @@ int adis16400_update_scan_mode(struct iio_dev *indio_dev,
18{ 18{
19 struct adis16400_state *st = iio_priv(indio_dev); 19 struct adis16400_state *st = iio_priv(indio_dev);
20 struct adis *adis = &st->adis; 20 struct adis *adis = &st->adis;
21 uint16_t *tx, *rx; 21 uint16_t *tx;
22 22
23 if (st->variant->flags & ADIS16400_NO_BURST) 23 if (st->variant->flags & ADIS16400_NO_BURST)
24 return adis_update_scan_mode(indio_dev, scan_mask); 24 return adis_update_scan_mode(indio_dev, scan_mask);
@@ -35,7 +35,6 @@ int adis16400_update_scan_mode(struct iio_dev *indio_dev,
35 if (!adis->buffer) 35 if (!adis->buffer)
36 return -ENOMEM; 36 return -ENOMEM;
37 37
38 rx = adis->buffer;
39 tx = adis->buffer + indio_dev->scan_bytes; 38 tx = adis->buffer + indio_dev->scan_bytes;
40 39
41 tx[0] = ADIS_READ_REG(ADIS16400_GLOB_CMD); 40 tx[0] = ADIS_READ_REG(ADIS16400_GLOB_CMD);
diff --git a/drivers/iio/imu/adis16400_core.c b/drivers/iio/imu/adis16400_core.c
index 433583b6f800..b70873de04ea 100644
--- a/drivers/iio/imu/adis16400_core.c
+++ b/drivers/iio/imu/adis16400_core.c
@@ -214,21 +214,6 @@ static int adis16400_set_freq(struct adis16400_state *st, unsigned int freq)
214 return adis_write_reg_8(&st->adis, ADIS16400_SMPL_PRD, val); 214 return adis_write_reg_8(&st->adis, ADIS16400_SMPL_PRD, val);
215} 215}
216 216
217static ssize_t adis16400_read_frequency(struct device *dev,
218 struct device_attribute *attr,
219 char *buf)
220{
221 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
222 struct adis16400_state *st = iio_priv(indio_dev);
223 int ret;
224
225 ret = st->variant->get_freq(st);
226 if (ret < 0)
227 return ret;
228
229 return sprintf(buf, "%d.%.3d\n", ret / 1000, ret % 1000);
230}
231
232static const unsigned adis16400_3db_divisors[] = { 217static const unsigned adis16400_3db_divisors[] = {
233 [0] = 2, /* Special case */ 218 [0] = 2, /* Special case */
234 [1] = 6, 219 [1] = 6,
@@ -260,30 +245,6 @@ static int adis16400_set_filter(struct iio_dev *indio_dev, int sps, int val)
260 return ret; 245 return ret;
261} 246}
262 247
263static ssize_t adis16400_write_frequency(struct device *dev,
264 struct device_attribute *attr, const char *buf, size_t len)
265{
266 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
267 struct adis16400_state *st = iio_priv(indio_dev);
268 int i, f, val;
269 int ret;
270
271 ret = iio_str_to_fixpoint(buf, 100, &i, &f);
272 if (ret)
273 return ret;
274
275 val = i * 1000 + f;
276
277 if (val <= 0)
278 return -EINVAL;
279
280 mutex_lock(&indio_dev->mlock);
281 st->variant->set_freq(st, val);
282 mutex_unlock(&indio_dev->mlock);
283
284 return len;
285}
286
287/* Power down the device */ 248/* Power down the device */
288static int adis16400_stop_device(struct iio_dev *indio_dev) 249static int adis16400_stop_device(struct iio_dev *indio_dev)
289{ 250{
@@ -350,10 +311,6 @@ err_ret:
350 return ret; 311 return ret;
351} 312}
352 313
353static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
354 adis16400_read_frequency,
355 adis16400_write_frequency);
356
357static const uint8_t adis16400_addresses[] = { 314static const uint8_t adis16400_addresses[] = {
358 [ADIS16400_SCAN_GYRO_X] = ADIS16400_XGYRO_OFF, 315 [ADIS16400_SCAN_GYRO_X] = ADIS16400_XGYRO_OFF,
359 [ADIS16400_SCAN_GYRO_Y] = ADIS16400_YGYRO_OFF, 316 [ADIS16400_SCAN_GYRO_Y] = ADIS16400_YGYRO_OFF,
@@ -394,6 +351,16 @@ static int adis16400_write_raw(struct iio_dev *indio_dev,
394 val * 1000 + val2 / 1000); 351 val * 1000 + val2 / 1000);
395 mutex_unlock(&indio_dev->mlock); 352 mutex_unlock(&indio_dev->mlock);
396 return ret; 353 return ret;
354 case IIO_CHAN_INFO_SAMP_FREQ:
355 sps = val * 1000 + val2 / 1000;
356
357 if (sps <= 0)
358 return -EINVAL;
359
360 mutex_lock(&indio_dev->mlock);
361 ret = st->variant->set_freq(st, sps);
362 mutex_unlock(&indio_dev->mlock);
363 return ret;
397 default: 364 default:
398 return -EINVAL; 365 return -EINVAL;
399 } 366 }
@@ -474,6 +441,13 @@ static int adis16400_read_raw(struct iio_dev *indio_dev,
474 if (ret < 0) 441 if (ret < 0)
475 return ret; 442 return ret;
476 return IIO_VAL_INT_PLUS_MICRO; 443 return IIO_VAL_INT_PLUS_MICRO;
444 case IIO_CHAN_INFO_SAMP_FREQ:
445 ret = st->variant->get_freq(st);
446 if (ret < 0)
447 return ret;
448 *val = ret / 1000;
449 *val2 = (ret % 1000) * 1000;
450 return IIO_VAL_INT_PLUS_MICRO;
477 default: 451 default:
478 return -EINVAL; 452 return -EINVAL;
479 } 453 }
@@ -486,6 +460,7 @@ static int adis16400_read_raw(struct iio_dev *indio_dev,
486 .extend_name = name, \ 460 .extend_name = name, \
487 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 461 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
488 BIT(IIO_CHAN_INFO_SCALE), \ 462 BIT(IIO_CHAN_INFO_SCALE), \
463 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
489 .address = (addr), \ 464 .address = (addr), \
490 .scan_index = (si), \ 465 .scan_index = (si), \
491 .scan_type = { \ 466 .scan_type = { \
@@ -511,6 +486,7 @@ static int adis16400_read_raw(struct iio_dev *indio_dev,
511 BIT(IIO_CHAN_INFO_CALIBBIAS), \ 486 BIT(IIO_CHAN_INFO_CALIBBIAS), \
512 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 487 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
513 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \ 488 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
489 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
514 .address = addr, \ 490 .address = addr, \
515 .scan_index = ADIS16400_SCAN_GYRO_ ## mod, \ 491 .scan_index = ADIS16400_SCAN_GYRO_ ## mod, \
516 .scan_type = { \ 492 .scan_type = { \
@@ -530,6 +506,7 @@ static int adis16400_read_raw(struct iio_dev *indio_dev,
530 BIT(IIO_CHAN_INFO_CALIBBIAS), \ 506 BIT(IIO_CHAN_INFO_CALIBBIAS), \
531 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 507 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
532 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \ 508 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
509 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
533 .address = (addr), \ 510 .address = (addr), \
534 .scan_index = ADIS16400_SCAN_ACC_ ## mod, \ 511 .scan_index = ADIS16400_SCAN_ACC_ ## mod, \
535 .scan_type = { \ 512 .scan_type = { \
@@ -548,6 +525,7 @@ static int adis16400_read_raw(struct iio_dev *indio_dev,
548 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 525 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
549 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 526 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
550 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \ 527 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
528 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
551 .address = (addr), \ 529 .address = (addr), \
552 .scan_index = ADIS16400_SCAN_MAGN_ ## mod, \ 530 .scan_index = ADIS16400_SCAN_MAGN_ ## mod, \
553 .scan_type = { \ 531 .scan_type = { \
@@ -573,6 +551,7 @@ static int adis16400_read_raw(struct iio_dev *indio_dev,
573 BIT(IIO_CHAN_INFO_SCALE), \ 551 BIT(IIO_CHAN_INFO_SCALE), \
574 .info_mask_shared_by_type = \ 552 .info_mask_shared_by_type = \
575 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \ 553 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
554 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
576 .address = (addr), \ 555 .address = (addr), \
577 .scan_index = ADIS16350_SCAN_TEMP_ ## mod, \ 556 .scan_index = ADIS16350_SCAN_TEMP_ ## mod, \
578 .scan_type = { \ 557 .scan_type = { \
@@ -591,6 +570,7 @@ static int adis16400_read_raw(struct iio_dev *indio_dev,
591 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 570 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
592 BIT(IIO_CHAN_INFO_OFFSET) | \ 571 BIT(IIO_CHAN_INFO_OFFSET) | \
593 BIT(IIO_CHAN_INFO_SCALE), \ 572 BIT(IIO_CHAN_INFO_SCALE), \
573 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
594 .address = (addr), \ 574 .address = (addr), \
595 .scan_index = ADIS16350_SCAN_TEMP_X, \ 575 .scan_index = ADIS16350_SCAN_TEMP_X, \
596 .scan_type = { \ 576 .scan_type = { \
@@ -608,6 +588,7 @@ static int adis16400_read_raw(struct iio_dev *indio_dev,
608 .channel2 = IIO_MOD_ ## mod, \ 588 .channel2 = IIO_MOD_ ## mod, \
609 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 589 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
610 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 590 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
591 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
611 .address = (addr), \ 592 .address = (addr), \
612 .scan_index = ADIS16300_SCAN_INCLI_ ## mod, \ 593 .scan_index = ADIS16300_SCAN_INCLI_ ## mod, \
613 .scan_type = { \ 594 .scan_type = { \
@@ -649,6 +630,7 @@ static const struct iio_chan_spec adis16448_channels[] = {
649 .type = IIO_PRESSURE, 630 .type = IIO_PRESSURE,
650 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 631 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
651 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), 632 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
633 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
652 .address = ADIS16448_BARO_OUT, 634 .address = ADIS16448_BARO_OUT,
653 .scan_index = ADIS16400_SCAN_BARO, 635 .scan_index = ADIS16400_SCAN_BARO,
654 .scan_type = { 636 .scan_type = {
@@ -704,15 +686,6 @@ static const struct iio_chan_spec adis16334_channels[] = {
704 IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP), 686 IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP),
705}; 687};
706 688
707static struct attribute *adis16400_attributes[] = {
708 &iio_dev_attr_sampling_frequency.dev_attr.attr,
709 NULL
710};
711
712static const struct attribute_group adis16400_attribute_group = {
713 .attrs = adis16400_attributes,
714};
715
716static struct adis16400_chip_info adis16400_chips[] = { 689static struct adis16400_chip_info adis16400_chips[] = {
717 [ADIS16300] = { 690 [ADIS16300] = {
718 .channels = adis16300_channels, 691 .channels = adis16300_channels,
@@ -813,7 +786,6 @@ static const struct iio_info adis16400_info = {
813 .driver_module = THIS_MODULE, 786 .driver_module = THIS_MODULE,
814 .read_raw = &adis16400_read_raw, 787 .read_raw = &adis16400_read_raw,
815 .write_raw = &adis16400_write_raw, 788 .write_raw = &adis16400_write_raw,
816 .attrs = &adis16400_attribute_group,
817 .update_scan_mode = adis16400_update_scan_mode, 789 .update_scan_mode = adis16400_update_scan_mode,
818 .debugfs_reg_access = adis_debugfs_reg_access, 790 .debugfs_reg_access = adis_debugfs_reg_access,
819}; 791};
diff --git a/drivers/iio/imu/adis16480.c b/drivers/iio/imu/adis16480.c
index dd4206cac62d..989605dd6f78 100644
--- a/drivers/iio/imu/adis16480.c
+++ b/drivers/iio/imu/adis16480.c
@@ -257,11 +257,16 @@ static int adis16480_debugfs_init(struct iio_dev *indio_dev)
257 257
258#endif 258#endif
259 259
260static int adis16480_set_freq(struct adis16480 *st, unsigned int freq) 260static int adis16480_set_freq(struct iio_dev *indio_dev, int val, int val2)
261{ 261{
262 struct adis16480 *st = iio_priv(indio_dev);
262 unsigned int t; 263 unsigned int t;
263 264
264 t = 2460000 / freq; 265 t = val * 1000 + val2 / 1000;
266 if (t <= 0)
267 return -EINVAL;
268
269 t = 2460000 / t;
265 if (t > 2048) 270 if (t > 2048)
266 t = 2048; 271 t = 2048;
267 272
@@ -271,65 +276,24 @@ static int adis16480_set_freq(struct adis16480 *st, unsigned int freq)
271 return adis_write_reg_16(&st->adis, ADIS16480_REG_DEC_RATE, t); 276 return adis_write_reg_16(&st->adis, ADIS16480_REG_DEC_RATE, t);
272} 277}
273 278
274static int adis16480_get_freq(struct adis16480 *st, unsigned int *freq) 279static int adis16480_get_freq(struct iio_dev *indio_dev, int *val, int *val2)
275{ 280{
281 struct adis16480 *st = iio_priv(indio_dev);
276 uint16_t t; 282 uint16_t t;
277 int ret; 283 int ret;
284 unsigned freq;
278 285
279 ret = adis_read_reg_16(&st->adis, ADIS16480_REG_DEC_RATE, &t); 286 ret = adis_read_reg_16(&st->adis, ADIS16480_REG_DEC_RATE, &t);
280 if (ret < 0) 287 if (ret < 0)
281 return ret; 288 return ret;
282 289
283 *freq = 2460000 / (t + 1); 290 freq = 2460000 / (t + 1);
291 *val = freq / 1000;
292 *val2 = (freq % 1000) * 1000;
284 293
285 return 0; 294 return IIO_VAL_INT_PLUS_MICRO;
286} 295}
287 296
288static ssize_t adis16480_read_frequency(struct device *dev,
289 struct device_attribute *attr,
290 char *buf)
291{
292 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
293 struct adis16480 *st = iio_priv(indio_dev);
294 unsigned int freq;
295 int ret;
296
297 ret = adis16480_get_freq(st, &freq);
298 if (ret < 0)
299 return ret;
300
301 return sprintf(buf, "%d.%.3d\n", freq / 1000, freq % 1000);
302}
303
304static ssize_t adis16480_write_frequency(struct device *dev,
305 struct device_attribute *attr,
306 const char *buf,
307 size_t len)
308{
309 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
310 struct adis16480 *st = iio_priv(indio_dev);
311 int freq_int, freq_fract;
312 long val;
313 int ret;
314
315 ret = iio_str_to_fixpoint(buf, 100, &freq_int, &freq_fract);
316 if (ret)
317 return ret;
318
319 val = freq_int * 1000 + freq_fract;
320
321 if (val <= 0)
322 return -EINVAL;
323
324 ret = adis16480_set_freq(st, val);
325
326 return ret ? ret : len;
327}
328
329static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
330 adis16480_read_frequency,
331 adis16480_write_frequency);
332
333enum { 297enum {
334 ADIS16480_SCAN_GYRO_X, 298 ADIS16480_SCAN_GYRO_X,
335 ADIS16480_SCAN_GYRO_Y, 299 ADIS16480_SCAN_GYRO_Y,
@@ -571,6 +535,8 @@ static int adis16480_read_raw(struct iio_dev *indio_dev,
571 return adis16480_get_calibscale(indio_dev, chan, val); 535 return adis16480_get_calibscale(indio_dev, chan, val);
572 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: 536 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
573 return adis16480_get_filter_freq(indio_dev, chan, val); 537 return adis16480_get_filter_freq(indio_dev, chan, val);
538 case IIO_CHAN_INFO_SAMP_FREQ:
539 return adis16480_get_freq(indio_dev, val, val2);
574 default: 540 default:
575 return -EINVAL; 541 return -EINVAL;
576 } 542 }
@@ -586,6 +552,9 @@ static int adis16480_write_raw(struct iio_dev *indio_dev,
586 return adis16480_set_calibscale(indio_dev, chan, val); 552 return adis16480_set_calibscale(indio_dev, chan, val);
587 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: 553 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
588 return adis16480_set_filter_freq(indio_dev, chan, val); 554 return adis16480_set_filter_freq(indio_dev, chan, val);
555 case IIO_CHAN_INFO_SAMP_FREQ:
556 return adis16480_set_freq(indio_dev, val, val2);
557
589 default: 558 default:
590 return -EINVAL; 559 return -EINVAL;
591 } 560 }
@@ -600,6 +569,7 @@ static int adis16480_write_raw(struct iio_dev *indio_dev,
600 BIT(IIO_CHAN_INFO_CALIBBIAS) | \ 569 BIT(IIO_CHAN_INFO_CALIBBIAS) | \
601 _info_sep, \ 570 _info_sep, \
602 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 571 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
572 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
603 .address = (_address), \ 573 .address = (_address), \
604 .scan_index = (_si), \ 574 .scan_index = (_si), \
605 .scan_type = { \ 575 .scan_type = { \
@@ -638,6 +608,7 @@ static int adis16480_write_raw(struct iio_dev *indio_dev,
638 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 608 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
639 BIT(IIO_CHAN_INFO_CALIBBIAS) | \ 609 BIT(IIO_CHAN_INFO_CALIBBIAS) | \
640 BIT(IIO_CHAN_INFO_SCALE), \ 610 BIT(IIO_CHAN_INFO_SCALE), \
611 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
641 .address = ADIS16480_REG_BAROM_OUT, \ 612 .address = ADIS16480_REG_BAROM_OUT, \
642 .scan_index = ADIS16480_SCAN_BARO, \ 613 .scan_index = ADIS16480_SCAN_BARO, \
643 .scan_type = { \ 614 .scan_type = { \
@@ -655,6 +626,7 @@ static int adis16480_write_raw(struct iio_dev *indio_dev,
655 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 626 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
656 BIT(IIO_CHAN_INFO_SCALE) | \ 627 BIT(IIO_CHAN_INFO_SCALE) | \
657 BIT(IIO_CHAN_INFO_OFFSET), \ 628 BIT(IIO_CHAN_INFO_OFFSET), \
629 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
658 .address = ADIS16480_REG_TEMP_OUT, \ 630 .address = ADIS16480_REG_TEMP_OUT, \
659 .scan_index = ADIS16480_SCAN_TEMP, \ 631 .scan_index = ADIS16480_SCAN_TEMP, \
660 .scan_type = { \ 632 .scan_type = { \
@@ -717,17 +689,7 @@ static const struct adis16480_chip_info adis16480_chip_info[] = {
717 }, 689 },
718}; 690};
719 691
720static struct attribute *adis16480_attributes[] = {
721 &iio_dev_attr_sampling_frequency.dev_attr.attr,
722 NULL
723};
724
725static const struct attribute_group adis16480_attribute_group = {
726 .attrs = adis16480_attributes,
727};
728
729static const struct iio_info adis16480_info = { 692static const struct iio_info adis16480_info = {
730 .attrs = &adis16480_attribute_group,
731 .read_raw = &adis16480_read_raw, 693 .read_raw = &adis16480_read_raw,
732 .write_raw = &adis16480_write_raw, 694 .write_raw = &adis16480_write_raw,
733 .update_scan_mode = adis_update_scan_mode, 695 .update_scan_mode = adis_update_scan_mode,
diff --git a/drivers/iio/industrialio-event.c b/drivers/iio/industrialio-event.c
index 258a973a1fb8..35a5b0311dae 100644
--- a/drivers/iio/industrialio-event.c
+++ b/drivers/iio/industrialio-event.c
@@ -209,6 +209,7 @@ static const char * const iio_ev_info_text[] = {
209 [IIO_EV_INFO_ENABLE] = "en", 209 [IIO_EV_INFO_ENABLE] = "en",
210 [IIO_EV_INFO_VALUE] = "value", 210 [IIO_EV_INFO_VALUE] = "value",
211 [IIO_EV_INFO_HYSTERESIS] = "hysteresis", 211 [IIO_EV_INFO_HYSTERESIS] = "hysteresis",
212 [IIO_EV_INFO_PERIOD] = "period",
212}; 213};
213 214
214static enum iio_event_direction iio_ev_attr_dir(struct iio_dev_attr *attr) 215static enum iio_event_direction iio_ev_attr_dir(struct iio_dev_attr *attr)
diff --git a/drivers/iio/light/Kconfig b/drivers/iio/light/Kconfig
index c89740d4748f..bf05ca5b0a57 100644
--- a/drivers/iio/light/Kconfig
+++ b/drivers/iio/light/Kconfig
@@ -62,6 +62,18 @@ config GP2AP020A00F
62 To compile this driver as a module, choose M here: the 62 To compile this driver as a module, choose M here: the
63 module will be called gp2ap020a00f. 63 module will be called gp2ap020a00f.
64 64
65config ISL29125
66 tristate "Intersil ISL29125 digital color light sensor"
67 depends on I2C
68 select IIO_BUFFER
69 select IIO_TRIGGERED_BUFFER
70 help
71 Say Y here if you want to build a driver for the Intersil ISL29125
72 RGB light sensor for I2C.
73
74 To compile this driver as a module, choose M here: the module will be
75 called isl29125.
76
65config HID_SENSOR_ALS 77config HID_SENSOR_ALS
66 depends on HID_SENSOR_HUB 78 depends on HID_SENSOR_HUB
67 select IIO_BUFFER 79 select IIO_BUFFER
@@ -116,6 +128,18 @@ config LTR501
116 This driver can also be built as a module. If so, the module 128 This driver can also be built as a module. If so, the module
117 will be called ltr501. 129 will be called ltr501.
118 130
131config TCS3414
132 tristate "TAOS TCS3414 digital color sensor"
133 depends on I2C
134 select IIO_BUFFER
135 select IIO_TRIGGERED_BUFFER
136 help
137 If you say yes here you get support for the TAOS TCS3414
138 family of digital color sensors.
139
140 This driver can also be built as a module. If so, the module
141 will be called tcs3414.
142
119config TCS3472 143config TCS3472
120 tristate "TAOS TCS3472 color light-to-digital converter" 144 tristate "TAOS TCS3472 color light-to-digital converter"
121 depends on I2C 145 depends on I2C
diff --git a/drivers/iio/light/Makefile b/drivers/iio/light/Makefile
index 3eb36e5151fa..8b8c09f9c1f8 100644
--- a/drivers/iio/light/Makefile
+++ b/drivers/iio/light/Makefile
@@ -10,9 +10,11 @@ obj-$(CONFIG_CM36651) += cm36651.o
10obj-$(CONFIG_GP2AP020A00F) += gp2ap020a00f.o 10obj-$(CONFIG_GP2AP020A00F) += gp2ap020a00f.o
11obj-$(CONFIG_HID_SENSOR_ALS) += hid-sensor-als.o 11obj-$(CONFIG_HID_SENSOR_ALS) += hid-sensor-als.o
12obj-$(CONFIG_HID_SENSOR_PROX) += hid-sensor-prox.o 12obj-$(CONFIG_HID_SENSOR_PROX) += hid-sensor-prox.o
13obj-$(CONFIG_ISL29125) += isl29125.o
13obj-$(CONFIG_SENSORS_LM3533) += lm3533-als.o 14obj-$(CONFIG_SENSORS_LM3533) += lm3533-als.o
14obj-$(CONFIG_LTR501) += ltr501.o 15obj-$(CONFIG_LTR501) += ltr501.o
15obj-$(CONFIG_SENSORS_TSL2563) += tsl2563.o 16obj-$(CONFIG_SENSORS_TSL2563) += tsl2563.o
17obj-$(CONFIG_TCS3414) += tcs3414.o
16obj-$(CONFIG_TCS3472) += tcs3472.o 18obj-$(CONFIG_TCS3472) += tcs3472.o
17obj-$(CONFIG_TSL4531) += tsl4531.o 19obj-$(CONFIG_TSL4531) += tsl4531.o
18obj-$(CONFIG_VCNL4000) += vcnl4000.o 20obj-$(CONFIG_VCNL4000) += vcnl4000.o
diff --git a/drivers/iio/light/isl29125.c b/drivers/iio/light/isl29125.c
new file mode 100644
index 000000000000..c82f4a6f8464
--- /dev/null
+++ b/drivers/iio/light/isl29125.c
@@ -0,0 +1,347 @@
1/*
2 * isl29125.c - Support for Intersil ISL29125 RGB light sensor
3 *
4 * Copyright (c) 2014 Peter Meerwald <pmeerw@pmeerw.net>
5 *
6 * This file is subject to the terms and conditions of version 2 of
7 * the GNU General Public License. See the file COPYING in the main
8 * directory of this archive for more details.
9 *
10 * RGB light sensor with 16-bit channels for red, green, blue);
11 * 7-bit I2C slave address 0x44
12 *
13 * TODO: interrupt support, IR compensation, thresholds, 12bit
14 */
15
16#include <linux/module.h>
17#include <linux/i2c.h>
18#include <linux/delay.h>
19#include <linux/pm.h>
20
21#include <linux/iio/iio.h>
22#include <linux/iio/sysfs.h>
23#include <linux/iio/trigger_consumer.h>
24#include <linux/iio/buffer.h>
25#include <linux/iio/triggered_buffer.h>
26
27#define ISL29125_DRV_NAME "isl29125"
28
29#define ISL29125_DEVICE_ID 0x00
30#define ISL29125_CONF1 0x01
31#define ISL29125_CONF2 0x02
32#define ISL29125_CONF3 0x03
33#define ISL29125_STATUS 0x08
34#define ISL29125_GREEN_DATA 0x09
35#define ISL29125_RED_DATA 0x0b
36#define ISL29125_BLUE_DATA 0x0d
37
38#define ISL29125_ID 0x7d
39
40#define ISL29125_MODE_MASK GENMASK(2, 0)
41#define ISL29125_MODE_PD 0x0
42#define ISL29125_MODE_G 0x1
43#define ISL29125_MODE_R 0x2
44#define ISL29125_MODE_B 0x3
45#define ISL29125_MODE_RGB 0x5
46
47#define ISL29125_MODE_RANGE BIT(3)
48
49#define ISL29125_STATUS_CONV BIT(1)
50
51struct isl29125_data {
52 struct i2c_client *client;
53 struct mutex lock;
54 u8 conf1;
55 u16 buffer[8]; /* 3x 16-bit, padding, 8 bytes timestamp */
56};
57
58#define ISL29125_CHANNEL(_color, _si) { \
59 .type = IIO_INTENSITY, \
60 .modified = 1, \
61 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
62 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
63 .channel2 = IIO_MOD_LIGHT_##_color, \
64 .scan_index = _si, \
65 .scan_type = { \
66 .sign = 'u', \
67 .realbits = 16, \
68 .storagebits = 16, \
69 .endianness = IIO_CPU, \
70 }, \
71}
72
73static const struct iio_chan_spec isl29125_channels[] = {
74 ISL29125_CHANNEL(GREEN, 0),
75 ISL29125_CHANNEL(RED, 1),
76 ISL29125_CHANNEL(BLUE, 2),
77 IIO_CHAN_SOFT_TIMESTAMP(3),
78};
79
80static const struct {
81 u8 mode, data;
82} isl29125_regs[] = {
83 {ISL29125_MODE_G, ISL29125_GREEN_DATA},
84 {ISL29125_MODE_R, ISL29125_RED_DATA},
85 {ISL29125_MODE_B, ISL29125_BLUE_DATA},
86};
87
88static int isl29125_read_data(struct isl29125_data *data, int si)
89{
90 int tries = 5;
91 int ret;
92
93 ret = i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
94 data->conf1 | isl29125_regs[si].mode);
95 if (ret < 0)
96 return ret;
97
98 msleep(101);
99
100 while (tries--) {
101 ret = i2c_smbus_read_byte_data(data->client, ISL29125_STATUS);
102 if (ret < 0)
103 goto fail;
104 if (ret & ISL29125_STATUS_CONV)
105 break;
106 msleep(20);
107 }
108
109 if (tries < 0) {
110 dev_err(&data->client->dev, "data not ready\n");
111 ret = -EIO;
112 goto fail;
113 }
114
115 ret = i2c_smbus_read_word_data(data->client, isl29125_regs[si].data);
116
117fail:
118 i2c_smbus_write_byte_data(data->client, ISL29125_CONF1, data->conf1);
119 return ret;
120}
121
122static int isl29125_read_raw(struct iio_dev *indio_dev,
123 struct iio_chan_spec const *chan,
124 int *val, int *val2, long mask)
125{
126 struct isl29125_data *data = iio_priv(indio_dev);
127 int ret;
128
129 switch (mask) {
130 case IIO_CHAN_INFO_RAW:
131 if (iio_buffer_enabled(indio_dev))
132 return -EBUSY;
133 mutex_lock(&data->lock);
134 ret = isl29125_read_data(data, chan->scan_index);
135 mutex_unlock(&data->lock);
136 if (ret < 0)
137 return ret;
138 *val = ret;
139 return IIO_VAL_INT;
140 case IIO_CHAN_INFO_SCALE:
141 *val = 0;
142 if (data->conf1 & ISL29125_MODE_RANGE)
143 *val2 = 152590; /* 10k lux full range */
144 else
145 *val2 = 5722; /* 375 lux full range */
146 return IIO_VAL_INT_PLUS_MICRO;
147 }
148 return -EINVAL;
149}
150
151static int isl29125_write_raw(struct iio_dev *indio_dev,
152 struct iio_chan_spec const *chan,
153 int val, int val2, long mask)
154{
155 struct isl29125_data *data = iio_priv(indio_dev);
156
157 switch (mask) {
158 case IIO_CHAN_INFO_SCALE:
159 if (val != 0)
160 return -EINVAL;
161 if (val2 == 152590)
162 data->conf1 |= ISL29125_MODE_RANGE;
163 else if (val2 == 5722)
164 data->conf1 &= ~ISL29125_MODE_RANGE;
165 else
166 return -EINVAL;
167 return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
168 data->conf1);
169 default:
170 return -EINVAL;
171 }
172}
173
174static irqreturn_t isl29125_trigger_handler(int irq, void *p)
175{
176 struct iio_poll_func *pf = p;
177 struct iio_dev *indio_dev = pf->indio_dev;
178 struct isl29125_data *data = iio_priv(indio_dev);
179 int i, j = 0;
180
181 for_each_set_bit(i, indio_dev->active_scan_mask,
182 indio_dev->masklength) {
183 int ret = i2c_smbus_read_word_data(data->client,
184 isl29125_regs[i].data);
185 if (ret < 0)
186 goto done;
187
188 data->buffer[j++] = ret;
189 }
190
191 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
192 iio_get_time_ns());
193
194done:
195 iio_trigger_notify_done(indio_dev->trig);
196
197 return IRQ_HANDLED;
198}
199
200static const struct iio_info isl29125_info = {
201 .read_raw = isl29125_read_raw,
202 .write_raw = isl29125_write_raw,
203 .driver_module = THIS_MODULE,
204};
205
206static int isl29125_buffer_preenable(struct iio_dev *indio_dev)
207{
208 struct isl29125_data *data = iio_priv(indio_dev);
209
210 data->conf1 |= ISL29125_MODE_RGB;
211 return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
212 data->conf1);
213}
214
215static int isl29125_buffer_predisable(struct iio_dev *indio_dev)
216{
217 struct isl29125_data *data = iio_priv(indio_dev);
218 int ret;
219
220 ret = iio_triggered_buffer_predisable(indio_dev);
221 if (ret < 0)
222 return ret;
223
224 data->conf1 &= ~ISL29125_MODE_MASK;
225 data->conf1 |= ISL29125_MODE_PD;
226 return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
227 data->conf1);
228}
229
230static const struct iio_buffer_setup_ops isl29125_buffer_setup_ops = {
231 .preenable = isl29125_buffer_preenable,
232 .postenable = &iio_triggered_buffer_postenable,
233 .predisable = isl29125_buffer_predisable,
234};
235
236static int isl29125_probe(struct i2c_client *client,
237 const struct i2c_device_id *id)
238{
239 struct isl29125_data *data;
240 struct iio_dev *indio_dev;
241 int ret;
242
243 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
244 if (indio_dev == NULL)
245 return -ENOMEM;
246
247 data = iio_priv(indio_dev);
248 i2c_set_clientdata(client, indio_dev);
249 data->client = client;
250 mutex_init(&data->lock);
251
252 indio_dev->dev.parent = &client->dev;
253 indio_dev->info = &isl29125_info;
254 indio_dev->name = ISL29125_DRV_NAME;
255 indio_dev->channels = isl29125_channels;
256 indio_dev->num_channels = ARRAY_SIZE(isl29125_channels);
257 indio_dev->modes = INDIO_DIRECT_MODE;
258
259 ret = i2c_smbus_read_byte_data(data->client, ISL29125_DEVICE_ID);
260 if (ret < 0)
261 return ret;
262 if (ret != ISL29125_ID)
263 return -ENODEV;
264
265 data->conf1 = ISL29125_MODE_PD | ISL29125_MODE_RANGE;
266 ret = i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
267 data->conf1);
268 if (ret < 0)
269 return ret;
270
271 ret = i2c_smbus_write_byte_data(data->client, ISL29125_STATUS, 0);
272 if (ret < 0)
273 return ret;
274
275 ret = iio_triggered_buffer_setup(indio_dev, NULL,
276 isl29125_trigger_handler, &isl29125_buffer_setup_ops);
277 if (ret < 0)
278 return ret;
279
280 ret = iio_device_register(indio_dev);
281 if (ret < 0)
282 goto buffer_cleanup;
283
284 return 0;
285
286buffer_cleanup:
287 iio_triggered_buffer_cleanup(indio_dev);
288 return ret;
289}
290
291static int isl29125_powerdown(struct isl29125_data *data)
292{
293 return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
294 (data->conf1 & ~ISL29125_MODE_MASK) | ISL29125_MODE_PD);
295}
296
297static int isl29125_remove(struct i2c_client *client)
298{
299 struct iio_dev *indio_dev = i2c_get_clientdata(client);
300
301 iio_device_unregister(indio_dev);
302 iio_triggered_buffer_cleanup(indio_dev);
303 isl29125_powerdown(iio_priv(indio_dev));
304
305 return 0;
306}
307
308#ifdef CONFIG_PM_SLEEP
309static int isl29125_suspend(struct device *dev)
310{
311 struct isl29125_data *data = iio_priv(i2c_get_clientdata(
312 to_i2c_client(dev)));
313 return isl29125_powerdown(data);
314}
315
316static int isl29125_resume(struct device *dev)
317{
318 struct isl29125_data *data = iio_priv(i2c_get_clientdata(
319 to_i2c_client(dev)));
320 return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
321 data->conf1);
322}
323#endif
324
325static SIMPLE_DEV_PM_OPS(isl29125_pm_ops, isl29125_suspend, isl29125_resume);
326
327static const struct i2c_device_id isl29125_id[] = {
328 { "isl29125", 0 },
329 { }
330};
331MODULE_DEVICE_TABLE(i2c, isl29125_id);
332
333static struct i2c_driver isl29125_driver = {
334 .driver = {
335 .name = ISL29125_DRV_NAME,
336 .pm = &isl29125_pm_ops,
337 .owner = THIS_MODULE,
338 },
339 .probe = isl29125_probe,
340 .remove = isl29125_remove,
341 .id_table = isl29125_id,
342};
343module_i2c_driver(isl29125_driver);
344
345MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
346MODULE_DESCRIPTION("ISL29125 RGB light sensor driver");
347MODULE_LICENSE("GPL");
diff --git a/drivers/iio/light/tcs3414.c b/drivers/iio/light/tcs3414.c
new file mode 100644
index 000000000000..a9e449b0be0c
--- /dev/null
+++ b/drivers/iio/light/tcs3414.c
@@ -0,0 +1,405 @@
1/*
2 * tcs3414.c - Support for TAOS TCS3414 digital color sensor
3 *
4 * Copyright (c) 2014 Peter Meerwald <pmeerw@pmeerw.net>
5 *
6 * This file is subject to the terms and conditions of version 2 of
7 * the GNU General Public License. See the file COPYING in the main
8 * directory of this archive for more details.
9 *
10 * Digital color sensor with 16-bit channels for red, green, blue, clear);
11 * 7-bit I2C slave address 0x39 (TCS3414) or 0x29, 0x49, 0x59 (TCS3413,
12 * TCS3415, TCS3416, resp.)
13 *
14 * TODO: sync, interrupt support, thresholds, prescaler
15 */
16
17#include <linux/module.h>
18#include <linux/i2c.h>
19#include <linux/delay.h>
20#include <linux/pm.h>
21
22#include <linux/iio/iio.h>
23#include <linux/iio/sysfs.h>
24#include <linux/iio/trigger_consumer.h>
25#include <linux/iio/buffer.h>
26#include <linux/iio/triggered_buffer.h>
27
28#define TCS3414_DRV_NAME "tcs3414"
29
30#define TCS3414_COMMAND BIT(7)
31#define TCS3414_COMMAND_WORD (TCS3414_COMMAND | BIT(5))
32
33#define TCS3414_CONTROL (TCS3414_COMMAND | 0x00)
34#define TCS3414_TIMING (TCS3414_COMMAND | 0x01)
35#define TCS3414_ID (TCS3414_COMMAND | 0x04)
36#define TCS3414_GAIN (TCS3414_COMMAND | 0x07)
37#define TCS3414_DATA_GREEN (TCS3414_COMMAND_WORD | 0x10)
38#define TCS3414_DATA_RED (TCS3414_COMMAND_WORD | 0x12)
39#define TCS3414_DATA_BLUE (TCS3414_COMMAND_WORD | 0x14)
40#define TCS3414_DATA_CLEAR (TCS3414_COMMAND_WORD | 0x16)
41
42#define TCS3414_CONTROL_ADC_VALID BIT(4)
43#define TCS3414_CONTROL_ADC_EN BIT(1)
44#define TCS3414_CONTROL_POWER BIT(0)
45
46#define TCS3414_INTEG_MASK GENMASK(1, 0)
47#define TCS3414_INTEG_12MS 0x0
48#define TCS3414_INTEG_100MS 0x1
49#define TCS3414_INTEG_400MS 0x2
50
51#define TCS3414_GAIN_MASK GENMASK(5, 4)
52#define TCS3414_GAIN_SHIFT 4
53
54struct tcs3414_data {
55 struct i2c_client *client;
56 struct mutex lock;
57 u8 control;
58 u8 gain;
59 u8 timing;
60 u16 buffer[8]; /* 4x 16-bit + 8 bytes timestamp */
61};
62
63#define TCS3414_CHANNEL(_color, _si, _addr) { \
64 .type = IIO_INTENSITY, \
65 .modified = 1, \
66 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
67 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
68 BIT(IIO_CHAN_INFO_INT_TIME), \
69 .channel2 = IIO_MOD_LIGHT_##_color, \
70 .address = _addr, \
71 .scan_index = _si, \
72 .scan_type = { \
73 .sign = 'u', \
74 .realbits = 16, \
75 .storagebits = 16, \
76 .endianness = IIO_CPU, \
77 }, \
78}
79
80/* scale factors: 1/gain */
81static const int tcs3414_scales[][2] = {
82 {1, 0}, {0, 250000}, {0, 62500}, {0, 15625}
83};
84
85/* integration time in ms */
86static const int tcs3414_times[] = { 12, 100, 400 };
87
88static const struct iio_chan_spec tcs3414_channels[] = {
89 TCS3414_CHANNEL(GREEN, 0, TCS3414_DATA_GREEN),
90 TCS3414_CHANNEL(RED, 1, TCS3414_DATA_RED),
91 TCS3414_CHANNEL(BLUE, 2, TCS3414_DATA_BLUE),
92 TCS3414_CHANNEL(CLEAR, 3, TCS3414_DATA_CLEAR),
93 IIO_CHAN_SOFT_TIMESTAMP(4),
94};
95
96static int tcs3414_req_data(struct tcs3414_data *data)
97{
98 int tries = 25;
99 int ret;
100
101 ret = i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
102 data->control | TCS3414_CONTROL_ADC_EN);
103 if (ret < 0)
104 return ret;
105
106 while (tries--) {
107 ret = i2c_smbus_read_byte_data(data->client, TCS3414_CONTROL);
108 if (ret < 0)
109 return ret;
110 if (ret & TCS3414_CONTROL_ADC_VALID)
111 break;
112 msleep(20);
113 }
114
115 ret = i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
116 data->control);
117 if (ret < 0)
118 return ret;
119
120 if (tries < 0) {
121 dev_err(&data->client->dev, "data not ready\n");
122 return -EIO;
123 }
124
125 return 0;
126}
127
128static int tcs3414_read_raw(struct iio_dev *indio_dev,
129 struct iio_chan_spec const *chan,
130 int *val, int *val2, long mask)
131{
132 struct tcs3414_data *data = iio_priv(indio_dev);
133 int i, ret;
134
135 switch (mask) {
136 case IIO_CHAN_INFO_RAW:
137 if (iio_buffer_enabled(indio_dev))
138 return -EBUSY;
139 mutex_lock(&data->lock);
140 ret = tcs3414_req_data(data);
141 if (ret < 0) {
142 mutex_unlock(&data->lock);
143 return ret;
144 }
145 ret = i2c_smbus_read_word_data(data->client, chan->address);
146 mutex_unlock(&data->lock);
147 if (ret < 0)
148 return ret;
149 *val = ret;
150 return IIO_VAL_INT;
151 case IIO_CHAN_INFO_SCALE:
152 i = (data->gain & TCS3414_GAIN_MASK) >> TCS3414_GAIN_SHIFT;
153 *val = tcs3414_scales[i][0];
154 *val2 = tcs3414_scales[i][1];
155 return IIO_VAL_INT_PLUS_MICRO;
156 case IIO_CHAN_INFO_INT_TIME:
157 *val = 0;
158 *val2 = tcs3414_times[data->timing & TCS3414_INTEG_MASK] * 1000;
159 return IIO_VAL_INT_PLUS_MICRO;
160 }
161 return -EINVAL;
162}
163
164static int tcs3414_write_raw(struct iio_dev *indio_dev,
165 struct iio_chan_spec const *chan,
166 int val, int val2, long mask)
167{
168 struct tcs3414_data *data = iio_priv(indio_dev);
169 int i;
170
171 switch (mask) {
172 case IIO_CHAN_INFO_SCALE:
173 for (i = 0; i < ARRAY_SIZE(tcs3414_scales); i++) {
174 if (val == tcs3414_scales[i][0] &&
175 val2 == tcs3414_scales[i][1]) {
176 data->gain &= ~TCS3414_GAIN_MASK;
177 data->gain |= i << TCS3414_GAIN_SHIFT;
178 return i2c_smbus_write_byte_data(
179 data->client, TCS3414_GAIN,
180 data->gain);
181 }
182 }
183 return -EINVAL;
184 case IIO_CHAN_INFO_INT_TIME:
185 if (val != 0)
186 return -EINVAL;
187 for (i = 0; i < ARRAY_SIZE(tcs3414_times); i++) {
188 if (val == tcs3414_times[i] * 1000) {
189 data->timing &= ~TCS3414_INTEG_MASK;
190 data->timing |= i;
191 return i2c_smbus_write_byte_data(
192 data->client, TCS3414_TIMING,
193 data->timing);
194 }
195 }
196 return -EINVAL;
197 default:
198 return -EINVAL;
199 }
200}
201
202static irqreturn_t tcs3414_trigger_handler(int irq, void *p)
203{
204 struct iio_poll_func *pf = p;
205 struct iio_dev *indio_dev = pf->indio_dev;
206 struct tcs3414_data *data = iio_priv(indio_dev);
207 int i, j = 0;
208
209 for_each_set_bit(i, indio_dev->active_scan_mask,
210 indio_dev->masklength) {
211 int ret = i2c_smbus_read_word_data(data->client,
212 TCS3414_DATA_GREEN + 2*i);
213 if (ret < 0)
214 goto done;
215
216 data->buffer[j++] = ret;
217 }
218
219 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
220 iio_get_time_ns());
221
222done:
223 iio_trigger_notify_done(indio_dev->trig);
224
225 return IRQ_HANDLED;
226}
227
228static IIO_CONST_ATTR(scale_available, "1 0.25 0.0625 0.015625");
229static IIO_CONST_ATTR_INT_TIME_AVAIL("0.012 0.1 0.4");
230
231static struct attribute *tcs3414_attributes[] = {
232 &iio_const_attr_scale_available.dev_attr.attr,
233 &iio_const_attr_integration_time_available.dev_attr.attr,
234 NULL
235};
236
237static const struct attribute_group tcs3414_attribute_group = {
238 .attrs = tcs3414_attributes,
239};
240
241static const struct iio_info tcs3414_info = {
242 .read_raw = tcs3414_read_raw,
243 .write_raw = tcs3414_write_raw,
244 .attrs = &tcs3414_attribute_group,
245 .driver_module = THIS_MODULE,
246};
247
248static int tcs3414_buffer_preenable(struct iio_dev *indio_dev)
249{
250 struct tcs3414_data *data = iio_priv(indio_dev);
251
252 data->control |= TCS3414_CONTROL_ADC_EN;
253 return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
254 data->control);
255}
256
257static int tcs3414_buffer_predisable(struct iio_dev *indio_dev)
258{
259 struct tcs3414_data *data = iio_priv(indio_dev);
260 int ret;
261
262 ret = iio_triggered_buffer_predisable(indio_dev);
263 if (ret < 0)
264 return ret;
265
266 data->control &= ~TCS3414_CONTROL_ADC_EN;
267 return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
268 data->control);
269}
270
271static const struct iio_buffer_setup_ops tcs3414_buffer_setup_ops = {
272 .preenable = tcs3414_buffer_preenable,
273 .postenable = &iio_triggered_buffer_postenable,
274 .predisable = tcs3414_buffer_predisable,
275};
276
277static int tcs3414_probe(struct i2c_client *client,
278 const struct i2c_device_id *id)
279{
280 struct tcs3414_data *data;
281 struct iio_dev *indio_dev;
282 int ret;
283
284 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
285 if (indio_dev == NULL)
286 return -ENOMEM;
287
288 data = iio_priv(indio_dev);
289 i2c_set_clientdata(client, indio_dev);
290 data->client = client;
291 mutex_init(&data->lock);
292
293 indio_dev->dev.parent = &client->dev;
294 indio_dev->info = &tcs3414_info;
295 indio_dev->name = TCS3414_DRV_NAME;
296 indio_dev->channels = tcs3414_channels;
297 indio_dev->num_channels = ARRAY_SIZE(tcs3414_channels);
298 indio_dev->modes = INDIO_DIRECT_MODE;
299
300 ret = i2c_smbus_read_byte_data(data->client, TCS3414_ID);
301 if (ret < 0)
302 return ret;
303
304 switch (ret & 0xf0) {
305 case 0x00:
306 dev_info(&client->dev, "TCS3404 found\n");
307 break;
308 case 0x10:
309 dev_info(&client->dev, "TCS3413/14/15/16 found\n");
310 break;
311 default:
312 return -ENODEV;
313 }
314
315 data->control = TCS3414_CONTROL_POWER;
316 ret = i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
317 data->control);
318 if (ret < 0)
319 return ret;
320
321 data->timing = TCS3414_INTEG_12MS; /* free running */
322 ret = i2c_smbus_write_byte_data(data->client, TCS3414_TIMING,
323 data->timing);
324 if (ret < 0)
325 return ret;
326
327 ret = i2c_smbus_read_byte_data(data->client, TCS3414_GAIN);
328 if (ret < 0)
329 return ret;
330 data->gain = ret;
331
332 ret = iio_triggered_buffer_setup(indio_dev, NULL,
333 tcs3414_trigger_handler, &tcs3414_buffer_setup_ops);
334 if (ret < 0)
335 return ret;
336
337 ret = iio_device_register(indio_dev);
338 if (ret < 0)
339 goto buffer_cleanup;
340
341 return 0;
342
343buffer_cleanup:
344 iio_triggered_buffer_cleanup(indio_dev);
345 return ret;
346}
347
348static int tcs3414_powerdown(struct tcs3414_data *data)
349{
350 return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
351 data->control & ~(TCS3414_CONTROL_POWER |
352 TCS3414_CONTROL_ADC_EN));
353}
354
355static int tcs3414_remove(struct i2c_client *client)
356{
357 struct iio_dev *indio_dev = i2c_get_clientdata(client);
358
359 iio_device_unregister(indio_dev);
360 iio_triggered_buffer_cleanup(indio_dev);
361 tcs3414_powerdown(iio_priv(indio_dev));
362
363 return 0;
364}
365
366#ifdef CONFIG_PM_SLEEP
367static int tcs3414_suspend(struct device *dev)
368{
369 struct tcs3414_data *data = iio_priv(i2c_get_clientdata(
370 to_i2c_client(dev)));
371 return tcs3414_powerdown(data);
372}
373
374static int tcs3414_resume(struct device *dev)
375{
376 struct tcs3414_data *data = iio_priv(i2c_get_clientdata(
377 to_i2c_client(dev)));
378 return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
379 data->control);
380}
381#endif
382
383static SIMPLE_DEV_PM_OPS(tcs3414_pm_ops, tcs3414_suspend, tcs3414_resume);
384
385static const struct i2c_device_id tcs3414_id[] = {
386 { "tcs3414", 0 },
387 { }
388};
389MODULE_DEVICE_TABLE(i2c, tcs3414_id);
390
391static struct i2c_driver tcs3414_driver = {
392 .driver = {
393 .name = TCS3414_DRV_NAME,
394 .pm = &tcs3414_pm_ops,
395 .owner = THIS_MODULE,
396 },
397 .probe = tcs3414_probe,
398 .remove = tcs3414_remove,
399 .id_table = tcs3414_id,
400};
401module_i2c_driver(tcs3414_driver);
402
403MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
404MODULE_DESCRIPTION("TCS3414 digital color sensors driver");
405MODULE_LICENSE("GPL");
diff --git a/drivers/iio/magnetometer/st_magn_core.c b/drivers/iio/magnetometer/st_magn_core.c
index 240a21dd0c61..a4b64130ac2f 100644
--- a/drivers/iio/magnetometer/st_magn_core.c
+++ b/drivers/iio/magnetometer/st_magn_core.c
@@ -299,6 +299,9 @@ static int st_magn_read_raw(struct iio_dev *indio_dev,
299 else 299 else
300 *val2 = mdata->current_fullscale->gain; 300 *val2 = mdata->current_fullscale->gain;
301 return IIO_VAL_INT_PLUS_MICRO; 301 return IIO_VAL_INT_PLUS_MICRO;
302 case IIO_CHAN_INFO_SAMP_FREQ:
303 *val = mdata->odr;
304 return IIO_VAL_INT;
302 default: 305 default:
303 return -EINVAL; 306 return -EINVAL;
304 } 307 }
@@ -316,6 +319,13 @@ static int st_magn_write_raw(struct iio_dev *indio_dev,
316 case IIO_CHAN_INFO_SCALE: 319 case IIO_CHAN_INFO_SCALE:
317 err = st_sensors_set_fullscale_by_gain(indio_dev, val2); 320 err = st_sensors_set_fullscale_by_gain(indio_dev, val2);
318 break; 321 break;
322 case IIO_CHAN_INFO_SAMP_FREQ:
323 if (val2)
324 return -EINVAL;
325 mutex_lock(&indio_dev->mlock);
326 err = st_sensors_set_odr(indio_dev, val);
327 mutex_unlock(&indio_dev->mlock);
328 return err;
319 default: 329 default:
320 err = -EINVAL; 330 err = -EINVAL;
321 } 331 }
@@ -323,14 +333,12 @@ static int st_magn_write_raw(struct iio_dev *indio_dev,
323 return err; 333 return err;
324} 334}
325 335
326static ST_SENSOR_DEV_ATTR_SAMP_FREQ();
327static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL(); 336static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
328static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_magn_scale_available); 337static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_magn_scale_available);
329 338
330static struct attribute *st_magn_attributes[] = { 339static struct attribute *st_magn_attributes[] = {
331 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 340 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
332 &iio_dev_attr_in_magn_scale_available.dev_attr.attr, 341 &iio_dev_attr_in_magn_scale_available.dev_attr.attr,
333 &iio_dev_attr_sampling_frequency.dev_attr.attr,
334 NULL, 342 NULL,
335}; 343};
336 344
diff --git a/drivers/iio/magnetometer/st_magn_i2c.c b/drivers/iio/magnetometer/st_magn_i2c.c
index 892e0feeb5c1..689250058442 100644
--- a/drivers/iio/magnetometer/st_magn_i2c.c
+++ b/drivers/iio/magnetometer/st_magn_i2c.c
@@ -18,6 +18,27 @@
18#include <linux/iio/common/st_sensors_i2c.h> 18#include <linux/iio/common/st_sensors_i2c.h>
19#include "st_magn.h" 19#include "st_magn.h"
20 20
21#ifdef CONFIG_OF
22static const struct of_device_id st_magn_of_match[] = {
23 {
24 .compatible = "st,lsm303dlhc-magn",
25 .data = LSM303DLHC_MAGN_DEV_NAME,
26 },
27 {
28 .compatible = "st,lsm303dlm-magn",
29 .data = LSM303DLM_MAGN_DEV_NAME,
30 },
31 {
32 .compatible = "st,lis3mdl-magn",
33 .data = LIS3MDL_MAGN_DEV_NAME,
34 },
35 {},
36};
37MODULE_DEVICE_TABLE(of, st_magn_of_match);
38#else
39#define st_magn_of_match NULL
40#endif
41
21static int st_magn_i2c_probe(struct i2c_client *client, 42static int st_magn_i2c_probe(struct i2c_client *client,
22 const struct i2c_device_id *id) 43 const struct i2c_device_id *id)
23{ 44{
@@ -31,6 +52,7 @@ static int st_magn_i2c_probe(struct i2c_client *client,
31 52
32 mdata = iio_priv(indio_dev); 53 mdata = iio_priv(indio_dev);
33 mdata->dev = &client->dev; 54 mdata->dev = &client->dev;
55 st_sensors_of_i2c_probe(client, st_magn_of_match);
34 56
35 st_sensors_i2c_configure(indio_dev, client, mdata); 57 st_sensors_i2c_configure(indio_dev, client, mdata);
36 58
@@ -61,6 +83,7 @@ static struct i2c_driver st_magn_driver = {
61 .driver = { 83 .driver = {
62 .owner = THIS_MODULE, 84 .owner = THIS_MODULE,
63 .name = "st-magn-i2c", 85 .name = "st-magn-i2c",
86 .of_match_table = of_match_ptr(st_magn_of_match),
64 }, 87 },
65 .probe = st_magn_i2c_probe, 88 .probe = st_magn_i2c_probe,
66 .remove = st_magn_i2c_remove, 89 .remove = st_magn_i2c_remove,
diff --git a/drivers/iio/pressure/st_pressure_core.c b/drivers/iio/pressure/st_pressure_core.c
index cd7e01f3a93b..473d914ef470 100644
--- a/drivers/iio/pressure/st_pressure_core.c
+++ b/drivers/iio/pressure/st_pressure_core.c
@@ -307,6 +307,27 @@ static const struct st_sensors st_press_sensors[] = {
307 }, 307 },
308}; 308};
309 309
310static int st_press_write_raw(struct iio_dev *indio_dev,
311 struct iio_chan_spec const *ch,
312 int val,
313 int val2,
314 long mask)
315{
316 int err;
317
318 switch (mask) {
319 case IIO_CHAN_INFO_SAMP_FREQ:
320 if (val2)
321 return -EINVAL;
322 mutex_lock(&indio_dev->mlock);
323 err = st_sensors_set_odr(indio_dev, val);
324 mutex_unlock(&indio_dev->mlock);
325 return err;
326 default:
327 return -EINVAL;
328 }
329}
330
310static int st_press_read_raw(struct iio_dev *indio_dev, 331static int st_press_read_raw(struct iio_dev *indio_dev,
311 struct iio_chan_spec const *ch, int *val, 332 struct iio_chan_spec const *ch, int *val,
312 int *val2, long mask) 333 int *val2, long mask)
@@ -349,6 +370,9 @@ static int st_press_read_raw(struct iio_dev *indio_dev,
349 } 370 }
350 371
351 return IIO_VAL_FRACTIONAL; 372 return IIO_VAL_FRACTIONAL;
373 case IIO_CHAN_INFO_SAMP_FREQ:
374 *val = pdata->odr;
375 return IIO_VAL_INT;
352 default: 376 default:
353 return -EINVAL; 377 return -EINVAL;
354 } 378 }
@@ -357,12 +381,10 @@ read_error:
357 return err; 381 return err;
358} 382}
359 383
360static ST_SENSOR_DEV_ATTR_SAMP_FREQ();
361static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL(); 384static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
362 385
363static struct attribute *st_press_attributes[] = { 386static struct attribute *st_press_attributes[] = {
364 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 387 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
365 &iio_dev_attr_sampling_frequency.dev_attr.attr,
366 NULL, 388 NULL,
367}; 389};
368 390
@@ -374,6 +396,7 @@ static const struct iio_info press_info = {
374 .driver_module = THIS_MODULE, 396 .driver_module = THIS_MODULE,
375 .attrs = &st_press_attribute_group, 397 .attrs = &st_press_attribute_group,
376 .read_raw = &st_press_read_raw, 398 .read_raw = &st_press_read_raw,
399 .write_raw = &st_press_write_raw,
377}; 400};
378 401
379#ifdef CONFIG_IIO_TRIGGER 402#ifdef CONFIG_IIO_TRIGGER
diff --git a/drivers/iio/pressure/st_pressure_i2c.c b/drivers/iio/pressure/st_pressure_i2c.c
index 3cd73e39b840..acaf165260bb 100644
--- a/drivers/iio/pressure/st_pressure_i2c.c
+++ b/drivers/iio/pressure/st_pressure_i2c.c
@@ -18,6 +18,27 @@
18#include <linux/iio/common/st_sensors_i2c.h> 18#include <linux/iio/common/st_sensors_i2c.h>
19#include "st_pressure.h" 19#include "st_pressure.h"
20 20
21#ifdef CONFIG_OF
22static const struct of_device_id st_press_of_match[] = {
23 {
24 .compatible = "st,lps001wp-press",
25 .data = LPS001WP_PRESS_DEV_NAME,
26 },
27 {
28 .compatible = "st,lps25h-press",
29 .data = LPS25H_PRESS_DEV_NAME,
30 },
31 {
32 .compatible = "st,lps331ap-press",
33 .data = LPS331AP_PRESS_DEV_NAME,
34 },
35 {},
36};
37MODULE_DEVICE_TABLE(of, st_press_of_match);
38#else
39#define st_press_of_match NULL
40#endif
41
21static int st_press_i2c_probe(struct i2c_client *client, 42static int st_press_i2c_probe(struct i2c_client *client,
22 const struct i2c_device_id *id) 43 const struct i2c_device_id *id)
23{ 44{
@@ -31,6 +52,7 @@ static int st_press_i2c_probe(struct i2c_client *client,
31 52
32 pdata = iio_priv(indio_dev); 53 pdata = iio_priv(indio_dev);
33 pdata->dev = &client->dev; 54 pdata->dev = &client->dev;
55 st_sensors_of_i2c_probe(client, st_press_of_match);
34 56
35 st_sensors_i2c_configure(indio_dev, client, pdata); 57 st_sensors_i2c_configure(indio_dev, client, pdata);
36 58
@@ -60,6 +82,7 @@ static struct i2c_driver st_press_driver = {
60 .driver = { 82 .driver = {
61 .owner = THIS_MODULE, 83 .owner = THIS_MODULE,
62 .name = "st-press-i2c", 84 .name = "st-press-i2c",
85 .of_match_table = of_match_ptr(st_press_of_match),
63 }, 86 },
64 .probe = st_press_i2c_probe, 87 .probe = st_press_i2c_probe,
65 .remove = st_press_i2c_remove, 88 .remove = st_press_i2c_remove,
diff --git a/drivers/staging/iio/Documentation/iio_event_monitor.c b/drivers/staging/iio/Documentation/iio_event_monitor.c
index cb35a97f00c3..569d6f8face5 100644
--- a/drivers/staging/iio/Documentation/iio_event_monitor.c
+++ b/drivers/staging/iio/Documentation/iio_event_monitor.c
@@ -122,8 +122,6 @@ static bool event_is_known(struct iio_event_data *event)
122 case IIO_MOD_LIGHT_IR: 122 case IIO_MOD_LIGHT_IR:
123 case IIO_MOD_ROOT_SUM_SQUARED_X_Y: 123 case IIO_MOD_ROOT_SUM_SQUARED_X_Y:
124 case IIO_MOD_SUM_SQUARED_X_Y_Z: 124 case IIO_MOD_SUM_SQUARED_X_Y_Z:
125 case IIO_MOD_LIGHT_BOTH:
126 case IIO_MOD_LIGHT_IR:
127 case IIO_MOD_LIGHT_CLEAR: 125 case IIO_MOD_LIGHT_CLEAR:
128 case IIO_MOD_LIGHT_RED: 126 case IIO_MOD_LIGHT_RED:
129 case IIO_MOD_LIGHT_GREEN: 127 case IIO_MOD_LIGHT_GREEN:
diff --git a/drivers/staging/iio/accel/adis16201_core.c b/drivers/staging/iio/accel/adis16201_core.c
index 2105576fa77c..50ba1fa7f98a 100644
--- a/drivers/staging/iio/accel/adis16201_core.c
+++ b/drivers/staging/iio/accel/adis16201_core.c
@@ -131,17 +131,17 @@ static int adis16201_write_raw(struct iio_dev *indio_dev,
131} 131}
132 132
133static const struct iio_chan_spec adis16201_channels[] = { 133static const struct iio_chan_spec adis16201_channels[] = {
134 ADIS_SUPPLY_CHAN(ADIS16201_SUPPLY_OUT, ADIS16201_SCAN_SUPPLY, 12), 134 ADIS_SUPPLY_CHAN(ADIS16201_SUPPLY_OUT, ADIS16201_SCAN_SUPPLY, 0, 12),
135 ADIS_TEMP_CHAN(ADIS16201_TEMP_OUT, ADIS16201_SCAN_TEMP, 12), 135 ADIS_TEMP_CHAN(ADIS16201_TEMP_OUT, ADIS16201_SCAN_TEMP, 0, 12),
136 ADIS_ACCEL_CHAN(X, ADIS16201_XACCL_OUT, ADIS16201_SCAN_ACC_X, 136 ADIS_ACCEL_CHAN(X, ADIS16201_XACCL_OUT, ADIS16201_SCAN_ACC_X,
137 BIT(IIO_CHAN_INFO_CALIBBIAS), 14), 137 BIT(IIO_CHAN_INFO_CALIBBIAS), 0, 14),
138 ADIS_ACCEL_CHAN(Y, ADIS16201_YACCL_OUT, ADIS16201_SCAN_ACC_Y, 138 ADIS_ACCEL_CHAN(Y, ADIS16201_YACCL_OUT, ADIS16201_SCAN_ACC_Y,
139 BIT(IIO_CHAN_INFO_CALIBBIAS), 14), 139 BIT(IIO_CHAN_INFO_CALIBBIAS), 0, 14),
140 ADIS_AUX_ADC_CHAN(ADIS16201_AUX_ADC, ADIS16201_SCAN_AUX_ADC, 12), 140 ADIS_AUX_ADC_CHAN(ADIS16201_AUX_ADC, ADIS16201_SCAN_AUX_ADC, 0, 12),
141 ADIS_INCLI_CHAN(X, ADIS16201_XINCL_OUT, ADIS16201_SCAN_INCLI_X, 141 ADIS_INCLI_CHAN(X, ADIS16201_XINCL_OUT, ADIS16201_SCAN_INCLI_X,
142 BIT(IIO_CHAN_INFO_CALIBBIAS), 14), 142 BIT(IIO_CHAN_INFO_CALIBBIAS), 0, 14),
143 ADIS_INCLI_CHAN(X, ADIS16201_YINCL_OUT, ADIS16201_SCAN_INCLI_Y, 143 ADIS_INCLI_CHAN(X, ADIS16201_YINCL_OUT, ADIS16201_SCAN_INCLI_Y,
144 BIT(IIO_CHAN_INFO_CALIBBIAS), 14), 144 BIT(IIO_CHAN_INFO_CALIBBIAS), 0, 14),
145 IIO_CHAN_SOFT_TIMESTAMP(7) 145 IIO_CHAN_SOFT_TIMESTAMP(7)
146}; 146};
147 147
diff --git a/drivers/staging/iio/accel/adis16203_core.c b/drivers/staging/iio/accel/adis16203_core.c
index 409a28ed9043..f472137b0069 100644
--- a/drivers/staging/iio/accel/adis16203_core.c
+++ b/drivers/staging/iio/accel/adis16203_core.c
@@ -99,13 +99,14 @@ static int adis16203_read_raw(struct iio_dev *indio_dev,
99} 99}
100 100
101static const struct iio_chan_spec adis16203_channels[] = { 101static const struct iio_chan_spec adis16203_channels[] = {
102 ADIS_SUPPLY_CHAN(ADIS16203_SUPPLY_OUT, ADIS16203_SCAN_SUPPLY, 12), 102 ADIS_SUPPLY_CHAN(ADIS16203_SUPPLY_OUT, ADIS16203_SCAN_SUPPLY, 0, 12),
103 ADIS_AUX_ADC_CHAN(ADIS16203_AUX_ADC, ADIS16203_SCAN_AUX_ADC, 12), 103 ADIS_AUX_ADC_CHAN(ADIS16203_AUX_ADC, ADIS16203_SCAN_AUX_ADC, 0, 12),
104 ADIS_INCLI_CHAN(X, ADIS16203_XINCL_OUT, ADIS16203_SCAN_INCLI_X, 104 ADIS_INCLI_CHAN(X, ADIS16203_XINCL_OUT, ADIS16203_SCAN_INCLI_X,
105 BIT(IIO_CHAN_INFO_CALIBBIAS), 14), 105 BIT(IIO_CHAN_INFO_CALIBBIAS), 0, 14),
106 /* Fixme: Not what it appears to be - see data sheet */ 106 /* Fixme: Not what it appears to be - see data sheet */
107 ADIS_INCLI_CHAN(Y, ADIS16203_YINCL_OUT, ADIS16203_SCAN_INCLI_Y, 0, 14), 107 ADIS_INCLI_CHAN(Y, ADIS16203_YINCL_OUT, ADIS16203_SCAN_INCLI_Y,
108 ADIS_TEMP_CHAN(ADIS16203_TEMP_OUT, ADIS16203_SCAN_TEMP, 12), 108 0, 0, 14),
109 ADIS_TEMP_CHAN(ADIS16203_TEMP_OUT, ADIS16203_SCAN_TEMP, 0, 12),
109 IIO_CHAN_SOFT_TIMESTAMP(5), 110 IIO_CHAN_SOFT_TIMESTAMP(5),
110}; 111};
111 112
diff --git a/drivers/staging/iio/accel/adis16204_core.c b/drivers/staging/iio/accel/adis16204_core.c
index b8ea76857cd6..19eaebc77d7a 100644
--- a/drivers/staging/iio/accel/adis16204_core.c
+++ b/drivers/staging/iio/accel/adis16204_core.c
@@ -136,15 +136,15 @@ static int adis16204_write_raw(struct iio_dev *indio_dev,
136} 136}
137 137
138static const struct iio_chan_spec adis16204_channels[] = { 138static const struct iio_chan_spec adis16204_channels[] = {
139 ADIS_SUPPLY_CHAN(ADIS16204_SUPPLY_OUT, ADIS16204_SCAN_SUPPLY, 12), 139 ADIS_SUPPLY_CHAN(ADIS16204_SUPPLY_OUT, ADIS16204_SCAN_SUPPLY, 0, 12),
140 ADIS_AUX_ADC_CHAN(ADIS16204_AUX_ADC, ADIS16204_SCAN_AUX_ADC, 12), 140 ADIS_AUX_ADC_CHAN(ADIS16204_AUX_ADC, ADIS16204_SCAN_AUX_ADC, 0, 12),
141 ADIS_TEMP_CHAN(ADIS16204_TEMP_OUT, ADIS16204_SCAN_TEMP, 12), 141 ADIS_TEMP_CHAN(ADIS16204_TEMP_OUT, ADIS16204_SCAN_TEMP, 0, 12),
142 ADIS_ACCEL_CHAN(X, ADIS16204_XACCL_OUT, ADIS16204_SCAN_ACC_X, 142 ADIS_ACCEL_CHAN(X, ADIS16204_XACCL_OUT, ADIS16204_SCAN_ACC_X,
143 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_PEAK), 14), 143 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_PEAK), 0, 14),
144 ADIS_ACCEL_CHAN(Y, ADIS16204_YACCL_OUT, ADIS16204_SCAN_ACC_Y, 144 ADIS_ACCEL_CHAN(Y, ADIS16204_YACCL_OUT, ADIS16204_SCAN_ACC_Y,
145 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_PEAK), 14), 145 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_PEAK), 0, 14),
146 ADIS_ACCEL_CHAN(ROOT_SUM_SQUARED_X_Y, ADIS16204_XY_RSS_OUT, 146 ADIS_ACCEL_CHAN(ROOT_SUM_SQUARED_X_Y, ADIS16204_XY_RSS_OUT,
147 ADIS16204_SCAN_ACC_XY, BIT(IIO_CHAN_INFO_PEAK), 14), 147 ADIS16204_SCAN_ACC_XY, BIT(IIO_CHAN_INFO_PEAK), 0, 14),
148 IIO_CHAN_SOFT_TIMESTAMP(5), 148 IIO_CHAN_SOFT_TIMESTAMP(5),
149}; 149};
150 150
diff --git a/drivers/staging/iio/accel/adis16209_core.c b/drivers/staging/iio/accel/adis16209_core.c
index 4492e51d8886..374dc6edbcf5 100644
--- a/drivers/staging/iio/accel/adis16209_core.c
+++ b/drivers/staging/iio/accel/adis16209_core.c
@@ -130,16 +130,18 @@ static int adis16209_read_raw(struct iio_dev *indio_dev,
130} 130}
131 131
132static const struct iio_chan_spec adis16209_channels[] = { 132static const struct iio_chan_spec adis16209_channels[] = {
133 ADIS_SUPPLY_CHAN(ADIS16209_SUPPLY_OUT, ADIS16209_SCAN_SUPPLY, 14), 133 ADIS_SUPPLY_CHAN(ADIS16209_SUPPLY_OUT, ADIS16209_SCAN_SUPPLY, 0, 14),
134 ADIS_TEMP_CHAN(ADIS16209_TEMP_OUT, ADIS16209_SCAN_TEMP, 12), 134 ADIS_TEMP_CHAN(ADIS16209_TEMP_OUT, ADIS16209_SCAN_TEMP, 0, 12),
135 ADIS_ACCEL_CHAN(X, ADIS16209_XACCL_OUT, ADIS16209_SCAN_ACC_X, 135 ADIS_ACCEL_CHAN(X, ADIS16209_XACCL_OUT, ADIS16209_SCAN_ACC_X,
136 BIT(IIO_CHAN_INFO_CALIBBIAS), 14), 136 BIT(IIO_CHAN_INFO_CALIBBIAS), 0, 14),
137 ADIS_ACCEL_CHAN(Y, ADIS16209_YACCL_OUT, ADIS16209_SCAN_ACC_Y, 137 ADIS_ACCEL_CHAN(Y, ADIS16209_YACCL_OUT, ADIS16209_SCAN_ACC_Y,
138 BIT(IIO_CHAN_INFO_CALIBBIAS), 14), 138 BIT(IIO_CHAN_INFO_CALIBBIAS), 0, 14),
139 ADIS_AUX_ADC_CHAN(ADIS16209_AUX_ADC, ADIS16209_SCAN_AUX_ADC, 12), 139 ADIS_AUX_ADC_CHAN(ADIS16209_AUX_ADC, ADIS16209_SCAN_AUX_ADC, 0, 12),
140 ADIS_INCLI_CHAN(X, ADIS16209_XINCL_OUT, ADIS16209_SCAN_INCLI_X, 0, 14), 140 ADIS_INCLI_CHAN(X, ADIS16209_XINCL_OUT, ADIS16209_SCAN_INCLI_X,
141 ADIS_INCLI_CHAN(Y, ADIS16209_YINCL_OUT, ADIS16209_SCAN_INCLI_Y, 0, 14), 141 0, 0, 14),
142 ADIS_ROT_CHAN(X, ADIS16209_ROT_OUT, ADIS16209_SCAN_ROT, 0, 14), 142 ADIS_INCLI_CHAN(Y, ADIS16209_YINCL_OUT, ADIS16209_SCAN_INCLI_Y,
143 0, 0, 14),
144 ADIS_ROT_CHAN(X, ADIS16209_ROT_OUT, ADIS16209_SCAN_ROT, 0, 0, 14),
143 IIO_CHAN_SOFT_TIMESTAMP(8) 145 IIO_CHAN_SOFT_TIMESTAMP(8)
144}; 146};
145 147
diff --git a/drivers/staging/iio/accel/adis16240_core.c b/drivers/staging/iio/accel/adis16240_core.c
index 3a303a03d028..74ace2a8769d 100644
--- a/drivers/staging/iio/accel/adis16240_core.c
+++ b/drivers/staging/iio/accel/adis16240_core.c
@@ -173,15 +173,15 @@ static int adis16240_write_raw(struct iio_dev *indio_dev,
173} 173}
174 174
175static const struct iio_chan_spec adis16240_channels[] = { 175static const struct iio_chan_spec adis16240_channels[] = {
176 ADIS_SUPPLY_CHAN(ADIS16240_SUPPLY_OUT, ADIS16240_SCAN_SUPPLY, 10), 176 ADIS_SUPPLY_CHAN(ADIS16240_SUPPLY_OUT, ADIS16240_SCAN_SUPPLY, 0, 10),
177 ADIS_AUX_ADC_CHAN(ADIS16240_AUX_ADC, ADIS16240_SCAN_AUX_ADC, 10), 177 ADIS_AUX_ADC_CHAN(ADIS16240_AUX_ADC, ADIS16240_SCAN_AUX_ADC, 0, 10),
178 ADIS_ACCEL_CHAN(X, ADIS16240_XACCL_OUT, ADIS16240_SCAN_ACC_X, 178 ADIS_ACCEL_CHAN(X, ADIS16240_XACCL_OUT, ADIS16240_SCAN_ACC_X,
179 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_PEAK), 10), 179 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_PEAK), 0, 10),
180 ADIS_ACCEL_CHAN(Y, ADIS16240_YACCL_OUT, ADIS16240_SCAN_ACC_Y, 180 ADIS_ACCEL_CHAN(Y, ADIS16240_YACCL_OUT, ADIS16240_SCAN_ACC_Y,
181 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_PEAK), 10), 181 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_PEAK), 0, 10),
182 ADIS_ACCEL_CHAN(Z, ADIS16240_ZACCL_OUT, ADIS16240_SCAN_ACC_Z, 182 ADIS_ACCEL_CHAN(Z, ADIS16240_ZACCL_OUT, ADIS16240_SCAN_ACC_Z,
183 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_PEAK), 10), 183 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_PEAK), 0, 10),
184 ADIS_TEMP_CHAN(ADIS16240_TEMP_OUT, ADIS16240_SCAN_TEMP, 10), 184 ADIS_TEMP_CHAN(ADIS16240_TEMP_OUT, ADIS16240_SCAN_TEMP, 0, 10),
185 IIO_CHAN_SOFT_TIMESTAMP(6) 185 IIO_CHAN_SOFT_TIMESTAMP(6)
186}; 186};
187 187
diff --git a/drivers/staging/iio/adc/Kconfig b/drivers/staging/iio/adc/Kconfig
index b87e382ad768..d01c7076a342 100644
--- a/drivers/staging/iio/adc/Kconfig
+++ b/drivers/staging/iio/adc/Kconfig
@@ -3,13 +3,6 @@
3# 3#
4menu "Analog to digital converters" 4menu "Analog to digital converters"
5 5
6config AD7291
7 tristate "Analog Devices AD7291 ADC driver"
8 depends on I2C
9 help
10 Say yes here to build support for Analog Devices AD7291
11 8 Channel ADC with temperature sensor.
12
13config AD7606 6config AD7606
14 tristate "Analog Devices AD7606 ADC driver" 7 tristate "Analog Devices AD7606 ADC driver"
15 depends on GPIOLIB 8 depends on GPIOLIB
@@ -94,7 +87,7 @@ config LPC32XX_ADC
94 87
95config MXS_LRADC 88config MXS_LRADC
96 tristate "Freescale i.MX23/i.MX28 LRADC" 89 tristate "Freescale i.MX23/i.MX28 LRADC"
97 depends on ARCH_MXS || COMPILE_TEST 90 depends on (ARCH_MXS || COMPILE_TEST) && HAS_IOMEM
98 depends on INPUT 91 depends on INPUT
99 select STMP_DEVICE 92 select STMP_DEVICE
100 select IIO_BUFFER 93 select IIO_BUFFER
diff --git a/drivers/staging/iio/adc/Makefile b/drivers/staging/iio/adc/Makefile
index afdcd1ff08ff..1c4277dbd318 100644
--- a/drivers/staging/iio/adc/Makefile
+++ b/drivers/staging/iio/adc/Makefile
@@ -8,7 +8,6 @@ ad7606-$(CONFIG_AD7606_IFACE_PARALLEL) += ad7606_par.o
8ad7606-$(CONFIG_AD7606_IFACE_SPI) += ad7606_spi.o 8ad7606-$(CONFIG_AD7606_IFACE_SPI) += ad7606_spi.o
9obj-$(CONFIG_AD7606) += ad7606.o 9obj-$(CONFIG_AD7606) += ad7606.o
10 10
11obj-$(CONFIG_AD7291) += ad7291.o
12obj-$(CONFIG_AD7780) += ad7780.o 11obj-$(CONFIG_AD7780) += ad7780.o
13obj-$(CONFIG_AD7816) += ad7816.o 12obj-$(CONFIG_AD7816) += ad7816.o
14obj-$(CONFIG_AD7192) += ad7192.o 13obj-$(CONFIG_AD7192) += ad7192.o
diff --git a/drivers/staging/iio/adc/ad7291.h b/drivers/staging/iio/adc/ad7291.h
deleted file mode 100644
index bbd89fa51188..000000000000
--- a/drivers/staging/iio/adc/ad7291.h
+++ /dev/null
@@ -1,12 +0,0 @@
1#ifndef __IIO_AD7291_H__
2#define __IIO_AD7291_H__
3
4/**
5 * struct ad7291_platform_data - AD7291 platform data
6 * @use_external_ref: Whether to use an external or internal reference voltage
7 */
8struct ad7291_platform_data {
9 bool use_external_ref;
10};
11
12#endif
diff --git a/drivers/staging/iio/adc/ad7606_par.c b/drivers/staging/iio/adc/ad7606_par.c
index 8a48d18de788..7511839ba94e 100644
--- a/drivers/staging/iio/adc/ad7606_par.c
+++ b/drivers/staging/iio/adc/ad7606_par.c
@@ -53,7 +53,7 @@ static int ad7606_par_probe(struct platform_device *pdev)
53 struct iio_dev *indio_dev; 53 struct iio_dev *indio_dev;
54 void __iomem *addr; 54 void __iomem *addr;
55 resource_size_t remap_size; 55 resource_size_t remap_size;
56 int ret, irq; 56 int irq;
57 57
58 irq = platform_get_irq(pdev, 0); 58 irq = platform_get_irq(pdev, 0);
59 if (irq < 0) { 59 if (irq < 0) {
@@ -62,56 +62,31 @@ static int ad7606_par_probe(struct platform_device *pdev)
62 } 62 }
63 63
64 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 64 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
65 if (!res) 65 addr = devm_ioremap_resource(&pdev->dev, res);
66 return -ENODEV; 66 if (IS_ERR(addr))
67 return PTR_ERR(addr);
67 68
68 remap_size = resource_size(res); 69 remap_size = resource_size(res);
69 70
70 /* Request the regions */
71 if (!request_mem_region(res->start, remap_size, "iio-ad7606")) {
72 ret = -EBUSY;
73 goto out1;
74 }
75 addr = ioremap(res->start, remap_size);
76 if (!addr) {
77 ret = -ENOMEM;
78 goto out1;
79 }
80
81 indio_dev = ad7606_probe(&pdev->dev, irq, addr, 71 indio_dev = ad7606_probe(&pdev->dev, irq, addr,
82 platform_get_device_id(pdev)->driver_data, 72 platform_get_device_id(pdev)->driver_data,
83 remap_size > 1 ? &ad7606_par16_bops : 73 remap_size > 1 ? &ad7606_par16_bops :
84 &ad7606_par8_bops); 74 &ad7606_par8_bops);
85 75
86 if (IS_ERR(indio_dev)) { 76 if (IS_ERR(indio_dev))
87 ret = PTR_ERR(indio_dev); 77 return PTR_ERR(indio_dev);
88 goto out2;
89 }
90 78
91 platform_set_drvdata(pdev, indio_dev); 79 platform_set_drvdata(pdev, indio_dev);
92 80
93 return 0; 81 return 0;
94
95out2:
96 iounmap(addr);
97out1:
98 release_mem_region(res->start, remap_size);
99
100 return ret;
101} 82}
102 83
103static int ad7606_par_remove(struct platform_device *pdev) 84static int ad7606_par_remove(struct platform_device *pdev)
104{ 85{
105 struct iio_dev *indio_dev = platform_get_drvdata(pdev); 86 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
106 struct resource *res;
107 struct ad7606_state *st = iio_priv(indio_dev);
108 87
109 ad7606_remove(indio_dev, platform_get_irq(pdev, 0)); 88 ad7606_remove(indio_dev, platform_get_irq(pdev, 0));
110 89
111 iounmap(st->base_address);
112 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
113 release_mem_region(res->start, resource_size(res));
114
115 return 0; 90 return 0;
116} 91}
117 92
diff --git a/drivers/staging/iio/frequency/ad9832.c b/drivers/staging/iio/frequency/ad9832.c
index b7c8351ce2ff..cf68159a5848 100644
--- a/drivers/staging/iio/frequency/ad9832.c
+++ b/drivers/staging/iio/frequency/ad9832.c
@@ -120,7 +120,7 @@ static ssize_t ad9832_write(struct device *dev, struct device_attribute *attr,
120 ret = spi_sync(st->spi, &st->msg); 120 ret = spi_sync(st->spi, &st->msg);
121 break; 121 break;
122 case AD9832_PHASE_SYM: 122 case AD9832_PHASE_SYM:
123 if (val < 0 || val > 3) { 123 if (val > 3) {
124 ret = -EINVAL; 124 ret = -EINVAL;
125 break; 125 break;
126 } 126 }
diff --git a/drivers/staging/iio/trigger/iio-trig-bfin-timer.c b/drivers/staging/iio/trigger/iio-trig-bfin-timer.c
index 16f1a06bcd89..a21b7c514776 100644
--- a/drivers/staging/iio/trigger/iio-trig-bfin-timer.c
+++ b/drivers/staging/iio/trigger/iio-trig-bfin-timer.c
@@ -182,45 +182,40 @@ static int iio_bfin_tmr_trigger_probe(struct platform_device *pdev)
182 unsigned int config; 182 unsigned int config;
183 int ret; 183 int ret;
184 184
185 st = kzalloc(sizeof(*st), GFP_KERNEL); 185 st = devm_kzalloc(&pdev->dev, sizeof(*st), GFP_KERNEL);
186 if (st == NULL) { 186 if (st == NULL)
187 ret = -ENOMEM; 187 return -ENOMEM;
188 goto out;
189 }
190 188
191 st->irq = platform_get_irq(pdev, 0); 189 st->irq = platform_get_irq(pdev, 0);
192 if (!st->irq) { 190 if (!st->irq) {
193 dev_err(&pdev->dev, "No IRQs specified"); 191 dev_err(&pdev->dev, "No IRQs specified");
194 ret = -ENODEV; 192 return -ENODEV;
195 goto out1;
196 } 193 }
197 194
198 ret = iio_bfin_tmr_get_number(st->irq); 195 ret = iio_bfin_tmr_get_number(st->irq);
199 if (ret < 0) 196 if (ret < 0)
200 goto out1; 197 return ret;
201 198
202 st->timer_num = ret; 199 st->timer_num = ret;
203 st->t = &iio_bfin_timer_code[st->timer_num]; 200 st->t = &iio_bfin_timer_code[st->timer_num];
204 201
205 st->trig = iio_trigger_alloc("bfintmr%d", st->timer_num); 202 st->trig = iio_trigger_alloc("bfintmr%d", st->timer_num);
206 if (!st->trig) { 203 if (!st->trig)
207 ret = -ENOMEM; 204 return -ENOMEM;
208 goto out1;
209 }
210 205
211 st->trig->ops = &iio_bfin_tmr_trigger_ops; 206 st->trig->ops = &iio_bfin_tmr_trigger_ops;
212 st->trig->dev.groups = iio_bfin_tmr_trigger_attr_groups; 207 st->trig->dev.groups = iio_bfin_tmr_trigger_attr_groups;
213 iio_trigger_set_drvdata(st->trig, st); 208 iio_trigger_set_drvdata(st->trig, st);
214 ret = iio_trigger_register(st->trig); 209 ret = iio_trigger_register(st->trig);
215 if (ret) 210 if (ret)
216 goto out2; 211 goto out;
217 212
218 ret = request_irq(st->irq, iio_bfin_tmr_trigger_isr, 213 ret = request_irq(st->irq, iio_bfin_tmr_trigger_isr,
219 0, st->trig->name, st); 214 0, st->trig->name, st);
220 if (ret) { 215 if (ret) {
221 dev_err(&pdev->dev, 216 dev_err(&pdev->dev,
222 "request IRQ-%d failed", st->irq); 217 "request IRQ-%d failed", st->irq);
223 goto out4; 218 goto out1;
224 } 219 }
225 220
226 config = PWM_OUT | PERIOD_CNT | IRQ_ENA; 221 config = PWM_OUT | PERIOD_CNT | IRQ_ENA;
@@ -260,13 +255,10 @@ static int iio_bfin_tmr_trigger_probe(struct platform_device *pdev)
260 return 0; 255 return 0;
261out_free_irq: 256out_free_irq:
262 free_irq(st->irq, st); 257 free_irq(st->irq, st);
263out4:
264 iio_trigger_unregister(st->trig);
265out2:
266 iio_trigger_put(st->trig);
267out1: 258out1:
268 kfree(st); 259 iio_trigger_unregister(st->trig);
269out: 260out:
261 iio_trigger_put(st->trig);
270 return ret; 262 return ret;
271} 263}
272 264
@@ -280,7 +272,6 @@ static int iio_bfin_tmr_trigger_remove(struct platform_device *pdev)
280 free_irq(st->irq, st); 272 free_irq(st->irq, st);
281 iio_trigger_unregister(st->trig); 273 iio_trigger_unregister(st->trig);
282 iio_trigger_put(st->trig); 274 iio_trigger_put(st->trig);
283 kfree(st);
284 275
285 return 0; 276 return 0;
286} 277}
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-24 01:56:11 -0500