aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/iio
diff options
context:
space:
mode:
authorDmitry Torokhov <dmitry.torokhov@gmail.com>2015-02-10 14:35:36 -0500
committerDmitry Torokhov <dmitry.torokhov@gmail.com>2015-02-10 14:35:36 -0500
commit4ba24fef3eb3b142197135223b90ced2f319cd53 (patch)
treea20c125b27740ec7b4c761b11d801108e1b316b2 /drivers/iio
parent47c1ffb2b6b630894e9a16442611c056ab21c057 (diff)
parent98a4a59ee31a12105a2b84f5b8b515ac2cb208ef (diff)
Merge branch 'next' into for-linus
Prepare first round of input updates for 3.20.
Diffstat (limited to 'drivers/iio')
-rw-r--r--drivers/iio/accel/Kconfig24
-rw-r--r--drivers/iio/accel/Makefile1
-rw-r--r--drivers/iio/accel/bma180.c476
-rw-r--r--drivers/iio/accel/bmc150-accel.c1456
-rw-r--r--drivers/iio/accel/hid-sensor-accel-3d.c1
-rw-r--r--drivers/iio/accel/kxcjk-1013.c875
-rw-r--r--drivers/iio/accel/st_accel.h3
-rw-r--r--drivers/iio/accel/st_accel_core.c22
-rw-r--r--drivers/iio/accel/st_accel_i2c.c3
-rw-r--r--drivers/iio/accel/st_accel_spi.c3
-rw-r--r--drivers/iio/adc/Kconfig44
-rw-r--r--drivers/iio/adc/Makefile4
-rw-r--r--drivers/iio/adc/at91_adc.c2
-rw-r--r--drivers/iio/adc/axp288_adc.c261
-rw-r--r--drivers/iio/adc/exynos_adc.c184
-rw-r--r--drivers/iio/adc/lp8788_adc.c1
-rw-r--r--drivers/iio/adc/mcp320x.c222
-rw-r--r--drivers/iio/adc/men_z188_adc.c1
-rw-r--r--drivers/iio/adc/qcom-spmi-iadc.c595
-rw-r--r--drivers/iio/adc/rockchip_saradc.c351
-rw-r--r--drivers/iio/adc/ti-adc128s052.c179
-rw-r--r--drivers/iio/adc/ti_am335x_adc.c6
-rw-r--r--drivers/iio/adc/twl4030-madc.c1
-rw-r--r--drivers/iio/adc/twl6030-gpadc.c1
-rw-r--r--drivers/iio/adc/vf610_adc.c46
-rw-r--r--drivers/iio/adc/viperboard_adc.c1
-rw-r--r--drivers/iio/adc/xilinx-xadc-core.c9
-rw-r--r--drivers/iio/common/st_sensors/st_sensors_buffer.c2
-rw-r--r--drivers/iio/common/st_sensors/st_sensors_core.c131
-rw-r--r--drivers/iio/common/st_sensors/st_sensors_i2c.c1
-rw-r--r--drivers/iio/common/st_sensors/st_sensors_spi.c1
-rw-r--r--drivers/iio/dac/Kconfig8
-rw-r--r--drivers/iio/dac/Makefile1
-rw-r--r--drivers/iio/dac/max5821.c405
-rw-r--r--drivers/iio/gyro/Kconfig11
-rw-r--r--drivers/iio/gyro/Makefile1
-rw-r--r--drivers/iio/gyro/bmg160.c1273
-rw-r--r--drivers/iio/gyro/hid-sensor-gyro-3d.c1
-rw-r--r--drivers/iio/gyro/st_gyro.h3
-rw-r--r--drivers/iio/gyro/st_gyro_core.c19
-rw-r--r--drivers/iio/gyro/st_gyro_i2c.c4
-rw-r--r--drivers/iio/gyro/st_gyro_spi.c4
-rw-r--r--drivers/iio/humidity/Kconfig10
-rw-r--r--drivers/iio/humidity/Makefile1
-rw-r--r--drivers/iio/humidity/dht11.c1
-rw-r--r--drivers/iio/humidity/si7020.c161
-rw-r--r--drivers/iio/imu/inv_mpu6050/inv_mpu_core.c3
-rw-r--r--drivers/iio/industrialio-buffer.c63
-rw-r--r--drivers/iio/inkern.c33
-rw-r--r--drivers/iio/light/Kconfig10
-rw-r--r--drivers/iio/light/Makefile1
-rw-r--r--drivers/iio/light/al3320a.c232
-rw-r--r--drivers/iio/light/hid-sensor-als.c1
-rw-r--r--drivers/iio/light/hid-sensor-prox.c1
-rw-r--r--drivers/iio/light/lm3533-als.c1
-rw-r--r--drivers/iio/light/tsl4531.c7
-rw-r--r--drivers/iio/magnetometer/ak8975.c10
-rw-r--r--drivers/iio/magnetometer/hid-sensor-magn-3d.c8
-rw-r--r--drivers/iio/magnetometer/st_magn.h3
-rw-r--r--drivers/iio/magnetometer/st_magn_core.c18
-rw-r--r--drivers/iio/magnetometer/st_magn_i2c.c3
-rw-r--r--drivers/iio/magnetometer/st_magn_spi.c3
-rw-r--r--drivers/iio/orientation/hid-sensor-incl-3d.c1
-rw-r--r--drivers/iio/orientation/hid-sensor-rotation.c1
-rw-r--r--drivers/iio/pressure/Kconfig11
-rw-r--r--drivers/iio/pressure/Makefile1
-rw-r--r--drivers/iio/pressure/bmp280.c455
-rw-r--r--drivers/iio/pressure/hid-sensor-press.c1
-rw-r--r--drivers/iio/pressure/st_pressure.h3
-rw-r--r--drivers/iio/pressure/st_pressure_buffer.c12
-rw-r--r--drivers/iio/pressure/st_pressure_core.c49
-rw-r--r--drivers/iio/pressure/st_pressure_i2c.c11
-rw-r--r--drivers/iio/pressure/st_pressure_spi.c11
-rw-r--r--drivers/iio/proximity/as3935.c18
-rw-r--r--drivers/iio/trigger/iio-trig-interrupt.c1
75 files changed, 7233 insertions, 549 deletions
diff --git a/drivers/iio/accel/Kconfig b/drivers/iio/accel/Kconfig
index 12addf272a61..9b9be8725e9d 100644
--- a/drivers/iio/accel/Kconfig
+++ b/drivers/iio/accel/Kconfig
@@ -6,17 +6,32 @@
6menu "Accelerometers" 6menu "Accelerometers"
7 7
8config BMA180 8config BMA180
9 tristate "Bosch BMA180 3-Axis Accelerometer Driver" 9 tristate "Bosch BMA180/BMA250 3-Axis Accelerometer Driver"
10 depends on I2C 10 depends on I2C
11 select IIO_BUFFER 11 select IIO_BUFFER
12 select IIO_TRIGGERED_BUFFER 12 select IIO_TRIGGERED_BUFFER
13 help 13 help
14 Say Y here if you want to build a driver for the Bosch BMA180 14 Say Y here if you want to build a driver for the Bosch BMA180 or
15 triaxial acceleration sensor. 15 BMA250 triaxial acceleration sensor.
16 16
17 To compile this driver as a module, choose M here: the 17 To compile this driver as a module, choose M here: the
18 module will be called bma180. 18 module will be called bma180.
19 19
20config BMC150_ACCEL
21 tristate "Bosch BMC150 Accelerometer Driver"
22 depends on I2C
23 select IIO_BUFFER
24 select IIO_TRIGGERED_BUFFER
25 help
26 Say yes here to build support for the following Bosch accelerometers:
27 BMC150, BMI055, BMA250E, BMA222E, BMA255, BMA280.
28
29 Currently this only supports the device via an i2c interface.
30
31 This is a combo module with both accelerometer and magnetometer.
32 This driver is only implementing accelerometer part, which has
33 its own address and register map.
34
20config HID_SENSOR_ACCEL_3D 35config HID_SENSOR_ACCEL_3D
21 depends on HID_SENSOR_HUB 36 depends on HID_SENSOR_HUB
22 select IIO_BUFFER 37 select IIO_BUFFER
@@ -84,7 +99,8 @@ config KXCJK1013
84 select IIO_TRIGGERED_BUFFER 99 select IIO_TRIGGERED_BUFFER
85 help 100 help
86 Say Y here if you want to build a driver for the Kionix KXCJK-1013 101 Say Y here if you want to build a driver for the Kionix KXCJK-1013
87 triaxial acceleration sensor. 102 triaxial acceleration sensor. This driver also supports KXCJ9-1008
103 and KXTJ2-1009.
88 104
89 To compile this driver as a module, choose M here: the module will 105 To compile this driver as a module, choose M here: the module will
90 be called kxcjk-1013. 106 be called kxcjk-1013.
diff --git a/drivers/iio/accel/Makefile b/drivers/iio/accel/Makefile
index 6578ca1a8e09..a593996c6539 100644
--- a/drivers/iio/accel/Makefile
+++ b/drivers/iio/accel/Makefile
@@ -4,6 +4,7 @@
4 4
5# When adding new entries keep the list in alphabetical order 5# When adding new entries keep the list in alphabetical order
6obj-$(CONFIG_BMA180) += bma180.o 6obj-$(CONFIG_BMA180) += bma180.o
7obj-$(CONFIG_BMC150_ACCEL) += bmc150-accel.o
7obj-$(CONFIG_HID_SENSOR_ACCEL_3D) += hid-sensor-accel-3d.o 8obj-$(CONFIG_HID_SENSOR_ACCEL_3D) += hid-sensor-accel-3d.o
8obj-$(CONFIG_KXCJK1013) += kxcjk-1013.o 9obj-$(CONFIG_KXCJK1013) += kxcjk-1013.o
9obj-$(CONFIG_KXSD9) += kxsd9.o 10obj-$(CONFIG_KXSD9) += kxsd9.o
diff --git a/drivers/iio/accel/bma180.c b/drivers/iio/accel/bma180.c
index 19100fddd2ed..1096da327130 100644
--- a/drivers/iio/accel/bma180.c
+++ b/drivers/iio/accel/bma180.c
@@ -3,9 +3,15 @@
3 * 3 *
4 * Copyright 2013 Oleksandr Kravchenko <x0199363@ti.com> 4 * Copyright 2013 Oleksandr Kravchenko <x0199363@ti.com>
5 * 5 *
6 * Support for BMA250 (c) Peter Meerwald <pmeerw@pmeerw.net>
7 *
6 * This file is subject to the terms and conditions of version 2 of 8 * 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 9 * the GNU General Public License. See the file COPYING in the main
8 * directory of this archive for more details. 10 * directory of this archive for more details.
11 *
12 * SPI is not supported by driver
13 * BMA180: 7-bit I2C slave address 0x40 or 0x41
14 * BMA250: 7-bit I2C slave address 0x18 or 0x19
9 */ 15 */
10 16
11#include <linux/module.h> 17#include <linux/module.h>
@@ -26,9 +32,37 @@
26#define BMA180_DRV_NAME "bma180" 32#define BMA180_DRV_NAME "bma180"
27#define BMA180_IRQ_NAME "bma180_event" 33#define BMA180_IRQ_NAME "bma180_event"
28 34
35enum {
36 BMA180,
37 BMA250,
38};
39
40struct bma180_data;
41
42struct bma180_part_info {
43 const struct iio_chan_spec *channels;
44 unsigned num_channels;
45 const int *scale_table;
46 unsigned num_scales;
47 const int *bw_table;
48 unsigned num_bw;
49
50 u8 int_reset_reg, int_reset_mask;
51 u8 sleep_reg, sleep_mask;
52 u8 bw_reg, bw_mask;
53 u8 scale_reg, scale_mask;
54 u8 power_reg, power_mask, lowpower_val;
55 u8 int_enable_reg, int_enable_mask;
56 u8 softreset_reg;
57
58 int (*chip_config)(struct bma180_data *data);
59 void (*chip_disable)(struct bma180_data *data);
60};
61
29/* Register set */ 62/* Register set */
30#define BMA180_CHIP_ID 0x00 /* Need to distinguish BMA180 from other */ 63#define BMA180_CHIP_ID 0x00 /* Need to distinguish BMA180 from other */
31#define BMA180_ACC_X_LSB 0x02 /* First of 6 registers of accel data */ 64#define BMA180_ACC_X_LSB 0x02 /* First of 6 registers of accel data */
65#define BMA180_TEMP 0x08
32#define BMA180_CTRL_REG0 0x0d 66#define BMA180_CTRL_REG0 0x0d
33#define BMA180_RESET 0x10 67#define BMA180_RESET 0x10
34#define BMA180_BW_TCS 0x20 68#define BMA180_BW_TCS 0x20
@@ -49,65 +83,81 @@
49#define BMA180_SMP_SKIP BIT(0) 83#define BMA180_SMP_SKIP BIT(0)
50 84
51/* Bit masks for registers bit fields */ 85/* Bit masks for registers bit fields */
52#define BMA180_RANGE 0x0e /* Range of measured accel values*/ 86#define BMA180_RANGE 0x0e /* Range of measured accel values */
53#define BMA180_BW 0xf0 /* Accel bandwidth */ 87#define BMA180_BW 0xf0 /* Accel bandwidth */
54#define BMA180_MODE_CONFIG 0x03 /* Config operation modes */ 88#define BMA180_MODE_CONFIG 0x03 /* Config operation modes */
55 89
56/* We have to write this value in reset register to do soft reset */ 90/* We have to write this value in reset register to do soft reset */
57#define BMA180_RESET_VAL 0xb6 91#define BMA180_RESET_VAL 0xb6
58 92
59#define BMA_180_ID_REG_VAL 0x03 93#define BMA180_ID_REG_VAL 0x03
60 94
61/* Chip power modes */ 95/* Chip power modes */
62#define BMA180_LOW_NOISE 0x00
63#define BMA180_LOW_POWER 0x03 96#define BMA180_LOW_POWER 0x03
64 97
65#define BMA180_LOW_NOISE_STR "low_noise" 98#define BMA250_RANGE_REG 0x0f
66#define BMA180_LOW_POWER_STR "low_power" 99#define BMA250_BW_REG 0x10
67 100#define BMA250_POWER_REG 0x11
68/* Defaults values */ 101#define BMA250_RESET_REG 0x14
69#define BMA180_DEF_PMODE 0 102#define BMA250_INT_ENABLE_REG 0x17
70#define BMA180_DEF_BW 20 103#define BMA250_INT_MAP_REG 0x1a
71#define BMA180_DEF_SCALE 2452 104#define BMA250_INT_RESET_REG 0x21
72 105
73/* Available values for sysfs */ 106#define BMA250_RANGE_MASK GENMASK(3, 0) /* Range of accel values */
74#define BMA180_FLP_FREQ_AVAILABLE \ 107#define BMA250_BW_MASK GENMASK(4, 0) /* Accel bandwidth */
75 "10 20 40 75 150 300" 108#define BMA250_SUSPEND_MASK BIT(7) /* chip will sleep */
76#define BMA180_SCALE_AVAILABLE \ 109#define BMA250_LOWPOWER_MASK BIT(6)
77 "0.001275 0.001863 0.002452 0.003727 0.004903 0.009709 0.019417" 110#define BMA250_DATA_INTEN_MASK BIT(4)
111#define BMA250_INT1_DATA_MASK BIT(0)
112#define BMA250_INT_RESET_MASK BIT(7) /* Reset pending interrupts */
78 113
79struct bma180_data { 114struct bma180_data {
80 struct i2c_client *client; 115 struct i2c_client *client;
81 struct iio_trigger *trig; 116 struct iio_trigger *trig;
117 const struct bma180_part_info *part_info;
82 struct mutex mutex; 118 struct mutex mutex;
83 int sleep_state; 119 bool sleep_state;
84 int scale; 120 int scale;
85 int bw; 121 int bw;
86 int pmode; 122 bool pmode;
87 char *buff; 123 u8 buff[16]; /* 3x 16-bit + 8-bit + padding + timestamp */
88}; 124};
89 125
90enum bma180_axis { 126enum bma180_chan {
91 AXIS_X, 127 AXIS_X,
92 AXIS_Y, 128 AXIS_Y,
93 AXIS_Z, 129 AXIS_Z,
130 TEMP
94}; 131};
95 132
96static int bw_table[] = { 10, 20, 40, 75, 150, 300 }; /* Hz */ 133static int bma180_bw_table[] = { 10, 20, 40, 75, 150, 300 }; /* Hz */
97static int scale_table[] = { 1275, 1863, 2452, 3727, 4903, 9709, 19417 }; 134static int bma180_scale_table[] = { 1275, 1863, 2452, 3727, 4903, 9709, 19417 };
135
136static int bma250_bw_table[] = { 8, 16, 31, 63, 125, 250 }; /* Hz */
137static int bma250_scale_table[] = { 0, 0, 0, 38344, 0, 76590, 0, 0, 153180, 0,
138 0, 0, 306458 };
98 139
99static int bma180_get_acc_reg(struct bma180_data *data, enum bma180_axis axis) 140static int bma180_get_data_reg(struct bma180_data *data, enum bma180_chan chan)
100{ 141{
101 u8 reg = BMA180_ACC_X_LSB + axis * 2;
102 int ret; 142 int ret;
103 143
104 if (data->sleep_state) 144 if (data->sleep_state)
105 return -EBUSY; 145 return -EBUSY;
106 146
107 ret = i2c_smbus_read_word_data(data->client, reg); 147 switch (chan) {
108 if (ret < 0) 148 case TEMP:
109 dev_err(&data->client->dev, 149 ret = i2c_smbus_read_byte_data(data->client, BMA180_TEMP);
110 "failed to read accel_%c registers\n", 'x' + axis); 150 if (ret < 0)
151 dev_err(&data->client->dev, "failed to read temp register\n");
152 break;
153 default:
154 ret = i2c_smbus_read_word_data(data->client,
155 BMA180_ACC_X_LSB + chan * 2);
156 if (ret < 0)
157 dev_err(&data->client->dev,
158 "failed to read accel_%c register\n",
159 'x' + chan);
160 }
111 161
112 return ret; 162 return ret;
113} 163}
@@ -125,7 +175,8 @@ static int bma180_set_bits(struct bma180_data *data, u8 reg, u8 mask, u8 val)
125 175
126static int bma180_reset_intr(struct bma180_data *data) 176static int bma180_reset_intr(struct bma180_data *data)
127{ 177{
128 int ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_RESET_INT, 1); 178 int ret = bma180_set_bits(data, data->part_info->int_reset_reg,
179 data->part_info->int_reset_mask, 1);
129 180
130 if (ret) 181 if (ret)
131 dev_err(&data->client->dev, "failed to reset interrupt\n"); 182 dev_err(&data->client->dev, "failed to reset interrupt\n");
@@ -133,12 +184,10 @@ static int bma180_reset_intr(struct bma180_data *data)
133 return ret; 184 return ret;
134} 185}
135 186
136static int bma180_set_new_data_intr_state(struct bma180_data *data, int state) 187static int bma180_set_new_data_intr_state(struct bma180_data *data, bool state)
137{ 188{
138 u8 reg_val = state ? BMA180_NEW_DATA_INT : 0x00; 189 int ret = bma180_set_bits(data, data->part_info->int_enable_reg,
139 int ret = i2c_smbus_write_byte_data(data->client, BMA180_CTRL_REG3, 190 data->part_info->int_enable_mask, state);
140 reg_val);
141
142 if (ret) 191 if (ret)
143 goto err; 192 goto err;
144 ret = bma180_reset_intr(data); 193 ret = bma180_reset_intr(data);
@@ -153,9 +202,10 @@ err:
153 return ret; 202 return ret;
154} 203}
155 204
156static int bma180_set_sleep_state(struct bma180_data *data, int state) 205static int bma180_set_sleep_state(struct bma180_data *data, bool state)
157{ 206{
158 int ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_SLEEP, state); 207 int ret = bma180_set_bits(data, data->part_info->sleep_reg,
208 data->part_info->sleep_mask, state);
159 209
160 if (ret) { 210 if (ret) {
161 dev_err(&data->client->dev, 211 dev_err(&data->client->dev,
@@ -167,7 +217,7 @@ static int bma180_set_sleep_state(struct bma180_data *data, int state)
167 return 0; 217 return 0;
168} 218}
169 219
170static int bma180_set_ee_writing_state(struct bma180_data *data, int state) 220static int bma180_set_ee_writing_state(struct bma180_data *data, bool state)
171{ 221{
172 int ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_EE_W, state); 222 int ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_EE_W, state);
173 223
@@ -185,10 +235,10 @@ static int bma180_set_bw(struct bma180_data *data, int val)
185 if (data->sleep_state) 235 if (data->sleep_state)
186 return -EBUSY; 236 return -EBUSY;
187 237
188 for (i = 0; i < ARRAY_SIZE(bw_table); ++i) { 238 for (i = 0; i < data->part_info->num_bw; ++i) {
189 if (bw_table[i] == val) { 239 if (data->part_info->bw_table[i] == val) {
190 ret = bma180_set_bits(data, 240 ret = bma180_set_bits(data, data->part_info->bw_reg,
191 BMA180_BW_TCS, BMA180_BW, i); 241 data->part_info->bw_mask, i);
192 if (ret) { 242 if (ret) {
193 dev_err(&data->client->dev, 243 dev_err(&data->client->dev,
194 "failed to set bandwidth\n"); 244 "failed to set bandwidth\n");
@@ -209,10 +259,10 @@ static int bma180_set_scale(struct bma180_data *data, int val)
209 if (data->sleep_state) 259 if (data->sleep_state)
210 return -EBUSY; 260 return -EBUSY;
211 261
212 for (i = 0; i < ARRAY_SIZE(scale_table); ++i) 262 for (i = 0; i < data->part_info->num_scales; ++i)
213 if (scale_table[i] == val) { 263 if (data->part_info->scale_table[i] == val) {
214 ret = bma180_set_bits(data, 264 ret = bma180_set_bits(data, data->part_info->scale_reg,
215 BMA180_OFFSET_LSB1, BMA180_RANGE, i); 265 data->part_info->scale_mask, i);
216 if (ret) { 266 if (ret) {
217 dev_err(&data->client->dev, 267 dev_err(&data->client->dev,
218 "failed to set scale\n"); 268 "failed to set scale\n");
@@ -225,11 +275,11 @@ static int bma180_set_scale(struct bma180_data *data, int val)
225 return -EINVAL; 275 return -EINVAL;
226} 276}
227 277
228static int bma180_set_pmode(struct bma180_data *data, int mode) 278static int bma180_set_pmode(struct bma180_data *data, bool mode)
229{ 279{
230 u8 reg_val = mode ? BMA180_LOW_POWER : BMA180_LOW_NOISE; 280 u8 reg_val = mode ? data->part_info->lowpower_val : 0;
231 int ret = bma180_set_bits(data, BMA180_TCO_Z, BMA180_MODE_CONFIG, 281 int ret = bma180_set_bits(data, data->part_info->power_reg,
232 reg_val); 282 data->part_info->power_mask, reg_val);
233 283
234 if (ret) { 284 if (ret) {
235 dev_err(&data->client->dev, "failed to set power mode\n"); 285 dev_err(&data->client->dev, "failed to set power mode\n");
@@ -243,7 +293,7 @@ static int bma180_set_pmode(struct bma180_data *data, int mode)
243static int bma180_soft_reset(struct bma180_data *data) 293static int bma180_soft_reset(struct bma180_data *data)
244{ 294{
245 int ret = i2c_smbus_write_byte_data(data->client, 295 int ret = i2c_smbus_write_byte_data(data->client,
246 BMA180_RESET, BMA180_RESET_VAL); 296 data->part_info->softreset_reg, BMA180_RESET_VAL);
247 297
248 if (ret) 298 if (ret)
249 dev_err(&data->client->dev, "failed to reset the chip\n"); 299 dev_err(&data->client->dev, "failed to reset the chip\n");
@@ -257,57 +307,99 @@ static int bma180_chip_init(struct bma180_data *data)
257 int ret = i2c_smbus_read_byte_data(data->client, BMA180_CHIP_ID); 307 int ret = i2c_smbus_read_byte_data(data->client, BMA180_CHIP_ID);
258 308
259 if (ret < 0) 309 if (ret < 0)
260 goto err; 310 return ret;
261 if (ret != BMA_180_ID_REG_VAL) { 311 if (ret != BMA180_ID_REG_VAL)
262 ret = -ENODEV; 312 return -ENODEV;
263 goto err;
264 }
265 313
266 ret = bma180_soft_reset(data); 314 ret = bma180_soft_reset(data);
267 if (ret) 315 if (ret)
268 goto err; 316 return ret;
269 /* 317 /*
270 * No serial transaction should occur within minimum 10 us 318 * No serial transaction should occur within minimum 10 us
271 * after soft_reset command 319 * after soft_reset command
272 */ 320 */
273 msleep(20); 321 msleep(20);
274 322
275 ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_DIS_WAKE_UP, 1); 323 ret = bma180_set_new_data_intr_state(data, false);
324 if (ret)
325 return ret;
326
327 return bma180_set_pmode(data, false);
328}
329
330static int bma180_chip_config(struct bma180_data *data)
331{
332 int ret = bma180_chip_init(data);
333
276 if (ret) 334 if (ret)
277 goto err; 335 goto err;
278 ret = bma180_set_ee_writing_state(data, 1); 336 ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_DIS_WAKE_UP, 1);
279 if (ret) 337 if (ret)
280 goto err; 338 goto err;
281 ret = bma180_set_new_data_intr_state(data, 0); 339 ret = bma180_set_ee_writing_state(data, true);
282 if (ret) 340 if (ret)
283 goto err; 341 goto err;
284 ret = bma180_set_bits(data, BMA180_OFFSET_LSB1, BMA180_SMP_SKIP, 1); 342 ret = bma180_set_bits(data, BMA180_OFFSET_LSB1, BMA180_SMP_SKIP, 1);
285 if (ret) 343 if (ret)
286 goto err; 344 goto err;
287 ret = bma180_set_pmode(data, BMA180_DEF_PMODE); 345 ret = bma180_set_bw(data, 20); /* 20 Hz */
288 if (ret) 346 if (ret)
289 goto err; 347 goto err;
290 ret = bma180_set_bw(data, BMA180_DEF_BW); 348 ret = bma180_set_scale(data, 2452); /* 2 G */
349 if (ret)
350 goto err;
351
352 return 0;
353
354err:
355 dev_err(&data->client->dev, "failed to config the chip\n");
356 return ret;
357}
358
359static int bma250_chip_config(struct bma180_data *data)
360{
361 int ret = bma180_chip_init(data);
362
291 if (ret) 363 if (ret)
292 goto err; 364 goto err;
293 ret = bma180_set_scale(data, BMA180_DEF_SCALE); 365 ret = bma180_set_bw(data, 16); /* 16 Hz */
366 if (ret)
367 goto err;
368 ret = bma180_set_scale(data, 38344); /* 2 G */
369 if (ret)
370 goto err;
371 ret = bma180_set_bits(data, BMA250_INT_MAP_REG,
372 BMA250_INT1_DATA_MASK, 1);
294 if (ret) 373 if (ret)
295 goto err; 374 goto err;
296 375
297 return 0; 376 return 0;
298 377
299err: 378err:
300 dev_err(&data->client->dev, "failed to init the chip\n"); 379 dev_err(&data->client->dev, "failed to config the chip\n");
301 return ret; 380 return ret;
302} 381}
303 382
304static void bma180_chip_disable(struct bma180_data *data) 383static void bma180_chip_disable(struct bma180_data *data)
305{ 384{
306 if (bma180_set_new_data_intr_state(data, 0)) 385 if (bma180_set_new_data_intr_state(data, false))
307 goto err; 386 goto err;
308 if (bma180_set_ee_writing_state(data, 0)) 387 if (bma180_set_ee_writing_state(data, false))
388 goto err;
389 if (bma180_set_sleep_state(data, true))
390 goto err;
391
392 return;
393
394err:
395 dev_err(&data->client->dev, "failed to disable the chip\n");
396}
397
398static void bma250_chip_disable(struct bma180_data *data)
399{
400 if (bma180_set_new_data_intr_state(data, false))
309 goto err; 401 goto err;
310 if (bma180_set_sleep_state(data, 1)) 402 if (bma180_set_sleep_state(data, true))
311 goto err; 403 goto err;
312 404
313 return; 405 return;
@@ -316,13 +408,51 @@ err:
316 dev_err(&data->client->dev, "failed to disable the chip\n"); 408 dev_err(&data->client->dev, "failed to disable the chip\n");
317} 409}
318 410
319static IIO_CONST_ATTR(in_accel_filter_low_pass_3db_frequency_available, 411static ssize_t bma180_show_avail(char *buf, const int *vals, unsigned n,
320 BMA180_FLP_FREQ_AVAILABLE); 412 bool micros)
321static IIO_CONST_ATTR(in_accel_scale_available, BMA180_SCALE_AVAILABLE); 413{
414 size_t len = 0;
415 int i;
416
417 for (i = 0; i < n; i++) {
418 if (!vals[i])
419 continue;
420 len += scnprintf(buf + len, PAGE_SIZE - len,
421 micros ? "0.%06d " : "%d ", vals[i]);
422 }
423 buf[len - 1] = '\n';
424
425 return len;
426}
427
428static ssize_t bma180_show_filter_freq_avail(struct device *dev,
429 struct device_attribute *attr, char *buf)
430{
431 struct bma180_data *data = iio_priv(dev_to_iio_dev(dev));
432
433 return bma180_show_avail(buf, data->part_info->bw_table,
434 data->part_info->num_bw, false);
435}
436
437static ssize_t bma180_show_scale_avail(struct device *dev,
438 struct device_attribute *attr, char *buf)
439{
440 struct bma180_data *data = iio_priv(dev_to_iio_dev(dev));
441
442 return bma180_show_avail(buf, data->part_info->scale_table,
443 data->part_info->num_scales, true);
444}
445
446static IIO_DEVICE_ATTR(in_accel_filter_low_pass_3db_frequency_available,
447 S_IRUGO, bma180_show_filter_freq_avail, NULL, 0);
448
449static IIO_DEVICE_ATTR(in_accel_scale_available,
450 S_IRUGO, bma180_show_scale_avail, NULL, 0);
322 451
323static struct attribute *bma180_attributes[] = { 452static struct attribute *bma180_attributes[] = {
324 &iio_const_attr_in_accel_filter_low_pass_3db_frequency_available.dev_attr.attr, 453 &iio_dev_attr_in_accel_filter_low_pass_3db_frequency_available.
325 &iio_const_attr_in_accel_scale_available.dev_attr.attr, 454 dev_attr.attr,
455 &iio_dev_attr_in_accel_scale_available.dev_attr.attr,
326 NULL, 456 NULL,
327}; 457};
328 458
@@ -340,22 +470,35 @@ static int bma180_read_raw(struct iio_dev *indio_dev,
340 switch (mask) { 470 switch (mask) {
341 case IIO_CHAN_INFO_RAW: 471 case IIO_CHAN_INFO_RAW:
342 mutex_lock(&data->mutex); 472 mutex_lock(&data->mutex);
343 if (iio_buffer_enabled(indio_dev)) 473 if (iio_buffer_enabled(indio_dev)) {
344 ret = -EBUSY; 474 mutex_unlock(&data->mutex);
345 else 475 return -EBUSY;
346 ret = bma180_get_acc_reg(data, chan->scan_index); 476 }
477 ret = bma180_get_data_reg(data, chan->scan_index);
347 mutex_unlock(&data->mutex); 478 mutex_unlock(&data->mutex);
348 if (ret < 0) 479 if (ret < 0)
349 return ret; 480 return ret;
350 *val = (s16)ret >> chan->scan_type.shift; 481 *val = sign_extend32(ret >> chan->scan_type.shift,
482 chan->scan_type.realbits - 1);
351 return IIO_VAL_INT; 483 return IIO_VAL_INT;
352 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: 484 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
353 *val = data->bw; 485 *val = data->bw;
354 return IIO_VAL_INT; 486 return IIO_VAL_INT;
355 case IIO_CHAN_INFO_SCALE: 487 case IIO_CHAN_INFO_SCALE:
356 *val = 0; 488 switch (chan->type) {
357 *val2 = data->scale; 489 case IIO_ACCEL:
358 return IIO_VAL_INT_PLUS_MICRO; 490 *val = 0;
491 *val2 = data->scale;
492 return IIO_VAL_INT_PLUS_MICRO;
493 case IIO_TEMP:
494 *val = 500;
495 return IIO_VAL_INT;
496 default:
497 return -EINVAL;
498 }
499 case IIO_CHAN_INFO_OFFSET:
500 *val = 48; /* 0 LSB @ 24 degree C */
501 return IIO_VAL_INT;
359 default: 502 default:
360 return -EINVAL; 503 return -EINVAL;
361 } 504 }
@@ -387,33 +530,14 @@ static int bma180_write_raw(struct iio_dev *indio_dev,
387 } 530 }
388} 531}
389 532
390static int bma180_update_scan_mode(struct iio_dev *indio_dev,
391 const unsigned long *scan_mask)
392{
393 struct bma180_data *data = iio_priv(indio_dev);
394
395 if (data->buff)
396 devm_kfree(&indio_dev->dev, data->buff);
397 data->buff = devm_kzalloc(&indio_dev->dev,
398 indio_dev->scan_bytes, GFP_KERNEL);
399 if (!data->buff)
400 return -ENOMEM;
401
402 return 0;
403}
404
405static const struct iio_info bma180_info = { 533static const struct iio_info bma180_info = {
406 .attrs = &bma180_attrs_group, 534 .attrs = &bma180_attrs_group,
407 .read_raw = bma180_read_raw, 535 .read_raw = bma180_read_raw,
408 .write_raw = bma180_write_raw, 536 .write_raw = bma180_write_raw,
409 .update_scan_mode = bma180_update_scan_mode,
410 .driver_module = THIS_MODULE, 537 .driver_module = THIS_MODULE,
411}; 538};
412 539
413static const char * const bma180_power_modes[] = { 540static const char * const bma180_power_modes[] = { "low_noise", "low_power" };
414 BMA180_LOW_NOISE_STR,
415 BMA180_LOW_POWER_STR,
416};
417 541
418static int bma180_get_power_mode(struct iio_dev *indio_dev, 542static int bma180_get_power_mode(struct iio_dev *indio_dev,
419 const struct iio_chan_spec *chan) 543 const struct iio_chan_spec *chan)
@@ -449,7 +573,7 @@ static const struct iio_chan_spec_ext_info bma180_ext_info[] = {
449 { }, 573 { },
450}; 574};
451 575
452#define BMA180_CHANNEL(_axis) { \ 576#define BMA180_ACC_CHANNEL(_axis, _bits) { \
453 .type = IIO_ACCEL, \ 577 .type = IIO_ACCEL, \
454 .modified = 1, \ 578 .modified = 1, \
455 .channel2 = IIO_MOD_##_axis, \ 579 .channel2 = IIO_MOD_##_axis, \
@@ -459,18 +583,70 @@ static const struct iio_chan_spec_ext_info bma180_ext_info[] = {
459 .scan_index = AXIS_##_axis, \ 583 .scan_index = AXIS_##_axis, \
460 .scan_type = { \ 584 .scan_type = { \
461 .sign = 's', \ 585 .sign = 's', \
462 .realbits = 14, \ 586 .realbits = _bits, \
463 .storagebits = 16, \ 587 .storagebits = 16, \
464 .shift = 2, \ 588 .shift = 16 - _bits, \
465 }, \ 589 }, \
466 .ext_info = bma180_ext_info, \ 590 .ext_info = bma180_ext_info, \
467} 591}
468 592
593#define BMA180_TEMP_CHANNEL { \
594 .type = IIO_TEMP, \
595 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
596 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_OFFSET), \
597 .scan_index = TEMP, \
598 .scan_type = { \
599 .sign = 's', \
600 .realbits = 8, \
601 .storagebits = 16, \
602 }, \
603}
604
469static const struct iio_chan_spec bma180_channels[] = { 605static const struct iio_chan_spec bma180_channels[] = {
470 BMA180_CHANNEL(X), 606 BMA180_ACC_CHANNEL(X, 14),
471 BMA180_CHANNEL(Y), 607 BMA180_ACC_CHANNEL(Y, 14),
472 BMA180_CHANNEL(Z), 608 BMA180_ACC_CHANNEL(Z, 14),
473 IIO_CHAN_SOFT_TIMESTAMP(3), 609 BMA180_TEMP_CHANNEL,
610 IIO_CHAN_SOFT_TIMESTAMP(4),
611};
612
613static const struct iio_chan_spec bma250_channels[] = {
614 BMA180_ACC_CHANNEL(X, 10),
615 BMA180_ACC_CHANNEL(Y, 10),
616 BMA180_ACC_CHANNEL(Z, 10),
617 BMA180_TEMP_CHANNEL,
618 IIO_CHAN_SOFT_TIMESTAMP(4),
619};
620
621static const struct bma180_part_info bma180_part_info[] = {
622 [BMA180] = {
623 bma180_channels, ARRAY_SIZE(bma180_channels),
624 bma180_scale_table, ARRAY_SIZE(bma180_scale_table),
625 bma180_bw_table, ARRAY_SIZE(bma180_bw_table),
626 BMA180_CTRL_REG0, BMA180_RESET_INT,
627 BMA180_CTRL_REG0, BMA180_SLEEP,
628 BMA180_BW_TCS, BMA180_BW,
629 BMA180_OFFSET_LSB1, BMA180_RANGE,
630 BMA180_TCO_Z, BMA180_MODE_CONFIG, BMA180_LOW_POWER,
631 BMA180_CTRL_REG3, BMA180_NEW_DATA_INT,
632 BMA180_RESET,
633 bma180_chip_config,
634 bma180_chip_disable,
635 },
636 [BMA250] = {
637 bma250_channels, ARRAY_SIZE(bma250_channels),
638 bma250_scale_table, ARRAY_SIZE(bma250_scale_table),
639 bma250_bw_table, ARRAY_SIZE(bma250_bw_table),
640 BMA250_INT_RESET_REG, BMA250_INT_RESET_MASK,
641 BMA250_POWER_REG, BMA250_SUSPEND_MASK,
642 BMA250_BW_REG, BMA250_BW_MASK,
643 BMA250_RANGE_REG, BMA250_RANGE_MASK,
644 BMA250_POWER_REG, BMA250_LOWPOWER_MASK, 1,
645 BMA250_INT_ENABLE_REG, BMA250_DATA_INTEN_MASK,
646 BMA250_RESET_REG,
647 bma250_chip_config,
648 bma250_chip_disable,
649 },
474}; 650};
475 651
476static irqreturn_t bma180_trigger_handler(int irq, void *p) 652static irqreturn_t bma180_trigger_handler(int irq, void *p)
@@ -485,13 +661,14 @@ static irqreturn_t bma180_trigger_handler(int irq, void *p)
485 661
486 for_each_set_bit(bit, indio_dev->buffer->scan_mask, 662 for_each_set_bit(bit, indio_dev->buffer->scan_mask,
487 indio_dev->masklength) { 663 indio_dev->masklength) {
488 ret = bma180_get_acc_reg(data, bit); 664 ret = bma180_get_data_reg(data, bit);
489 if (ret < 0) { 665 if (ret < 0) {
490 mutex_unlock(&data->mutex); 666 mutex_unlock(&data->mutex);
491 goto err; 667 goto err;
492 } 668 }
493 ((s16 *)data->buff)[i++] = ret; 669 ((s16 *)data->buff)[i++] = ret;
494 } 670 }
671
495 mutex_unlock(&data->mutex); 672 mutex_unlock(&data->mutex);
496 673
497 iio_push_to_buffers_with_timestamp(indio_dev, data->buff, time_ns); 674 iio_push_to_buffers_with_timestamp(indio_dev, data->buff, time_ns);
@@ -529,7 +706,6 @@ static int bma180_probe(struct i2c_client *client,
529{ 706{
530 struct bma180_data *data; 707 struct bma180_data *data;
531 struct iio_dev *indio_dev; 708 struct iio_dev *indio_dev;
532 struct iio_trigger *trig;
533 int ret; 709 int ret;
534 710
535 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 711 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
@@ -539,43 +715,45 @@ static int bma180_probe(struct i2c_client *client,
539 data = iio_priv(indio_dev); 715 data = iio_priv(indio_dev);
540 i2c_set_clientdata(client, indio_dev); 716 i2c_set_clientdata(client, indio_dev);
541 data->client = client; 717 data->client = client;
718 data->part_info = &bma180_part_info[id->driver_data];
542 719
543 ret = bma180_chip_init(data); 720 ret = data->part_info->chip_config(data);
544 if (ret < 0) 721 if (ret < 0)
545 goto err_chip_disable; 722 goto err_chip_disable;
546 723
547 mutex_init(&data->mutex); 724 mutex_init(&data->mutex);
548
549 indio_dev->dev.parent = &client->dev; 725 indio_dev->dev.parent = &client->dev;
550 indio_dev->channels = bma180_channels; 726 indio_dev->channels = data->part_info->channels;
551 indio_dev->num_channels = ARRAY_SIZE(bma180_channels); 727 indio_dev->num_channels = data->part_info->num_channels;
552 indio_dev->name = BMA180_DRV_NAME; 728 indio_dev->name = id->name;
553 indio_dev->modes = INDIO_DIRECT_MODE; 729 indio_dev->modes = INDIO_DIRECT_MODE;
554 indio_dev->info = &bma180_info; 730 indio_dev->info = &bma180_info;
555 731
556 trig = iio_trigger_alloc("%s-dev%d", indio_dev->name, indio_dev->id); 732 if (client->irq > 0) {
557 if (!trig) { 733 data->trig = iio_trigger_alloc("%s-dev%d", indio_dev->name,
558 ret = -ENOMEM; 734 indio_dev->id);
559 goto err_chip_disable; 735 if (!data->trig) {
560 } 736 ret = -ENOMEM;
737 goto err_chip_disable;
738 }
561 739
562 ret = devm_request_irq(&client->dev, client->irq, 740 ret = devm_request_irq(&client->dev, client->irq,
563 iio_trigger_generic_data_rdy_poll, 741 iio_trigger_generic_data_rdy_poll, IRQF_TRIGGER_RISING,
564 IRQF_TRIGGER_RISING, BMA180_IRQ_NAME, trig); 742 "bma180_event", data->trig);
565 if (ret) { 743 if (ret) {
566 dev_err(&client->dev, "unable to request IRQ\n"); 744 dev_err(&client->dev, "unable to request IRQ\n");
567 goto err_trigger_free; 745 goto err_trigger_free;
568 } 746 }
569 747
570 trig->dev.parent = &client->dev; 748 data->trig->dev.parent = &client->dev;
571 trig->ops = &bma180_trigger_ops; 749 data->trig->ops = &bma180_trigger_ops;
572 iio_trigger_set_drvdata(trig, indio_dev); 750 iio_trigger_set_drvdata(data->trig, indio_dev);
573 data->trig = trig; 751 indio_dev->trig = iio_trigger_get(data->trig);
574 indio_dev->trig = iio_trigger_get(trig);
575 752
576 ret = iio_trigger_register(trig); 753 ret = iio_trigger_register(data->trig);
577 if (ret) 754 if (ret)
578 goto err_trigger_free; 755 goto err_trigger_free;
756 }
579 757
580 ret = iio_triggered_buffer_setup(indio_dev, NULL, 758 ret = iio_triggered_buffer_setup(indio_dev, NULL,
581 bma180_trigger_handler, NULL); 759 bma180_trigger_handler, NULL);
@@ -595,11 +773,12 @@ static int bma180_probe(struct i2c_client *client,
595err_buffer_cleanup: 773err_buffer_cleanup:
596 iio_triggered_buffer_cleanup(indio_dev); 774 iio_triggered_buffer_cleanup(indio_dev);
597err_trigger_unregister: 775err_trigger_unregister:
598 iio_trigger_unregister(trig); 776 if (data->trig)
777 iio_trigger_unregister(data->trig);
599err_trigger_free: 778err_trigger_free:
600 iio_trigger_free(trig); 779 iio_trigger_free(data->trig);
601err_chip_disable: 780err_chip_disable:
602 bma180_chip_disable(data); 781 data->part_info->chip_disable(data);
603 782
604 return ret; 783 return ret;
605} 784}
@@ -611,11 +790,13 @@ static int bma180_remove(struct i2c_client *client)
611 790
612 iio_device_unregister(indio_dev); 791 iio_device_unregister(indio_dev);
613 iio_triggered_buffer_cleanup(indio_dev); 792 iio_triggered_buffer_cleanup(indio_dev);
614 iio_trigger_unregister(data->trig); 793 if (data->trig) {
615 iio_trigger_free(data->trig); 794 iio_trigger_unregister(data->trig);
795 iio_trigger_free(data->trig);
796 }
616 797
617 mutex_lock(&data->mutex); 798 mutex_lock(&data->mutex);
618 bma180_chip_disable(data); 799 data->part_info->chip_disable(data);
619 mutex_unlock(&data->mutex); 800 mutex_unlock(&data->mutex);
620 801
621 return 0; 802 return 0;
@@ -629,7 +810,7 @@ static int bma180_suspend(struct device *dev)
629 int ret; 810 int ret;
630 811
631 mutex_lock(&data->mutex); 812 mutex_lock(&data->mutex);
632 ret = bma180_set_sleep_state(data, 1); 813 ret = bma180_set_sleep_state(data, true);
633 mutex_unlock(&data->mutex); 814 mutex_unlock(&data->mutex);
634 815
635 return ret; 816 return ret;
@@ -642,7 +823,7 @@ static int bma180_resume(struct device *dev)
642 int ret; 823 int ret;
643 824
644 mutex_lock(&data->mutex); 825 mutex_lock(&data->mutex);
645 ret = bma180_set_sleep_state(data, 0); 826 ret = bma180_set_sleep_state(data, false);
646 mutex_unlock(&data->mutex); 827 mutex_unlock(&data->mutex);
647 828
648 return ret; 829 return ret;
@@ -654,27 +835,28 @@ static SIMPLE_DEV_PM_OPS(bma180_pm_ops, bma180_suspend, bma180_resume);
654#define BMA180_PM_OPS NULL 835#define BMA180_PM_OPS NULL
655#endif 836#endif
656 837
657static struct i2c_device_id bma180_id[] = { 838static struct i2c_device_id bma180_ids[] = {
658 { BMA180_DRV_NAME, 0 }, 839 { "bma180", BMA180 },
840 { "bma250", BMA250 },
659 { } 841 { }
660}; 842};
661 843
662MODULE_DEVICE_TABLE(i2c, bma180_id); 844MODULE_DEVICE_TABLE(i2c, bma180_ids);
663 845
664static struct i2c_driver bma180_driver = { 846static struct i2c_driver bma180_driver = {
665 .driver = { 847 .driver = {
666 .name = BMA180_DRV_NAME, 848 .name = "bma180",
667 .owner = THIS_MODULE, 849 .owner = THIS_MODULE,
668 .pm = BMA180_PM_OPS, 850 .pm = BMA180_PM_OPS,
669 }, 851 },
670 .probe = bma180_probe, 852 .probe = bma180_probe,
671 .remove = bma180_remove, 853 .remove = bma180_remove,
672 .id_table = bma180_id, 854 .id_table = bma180_ids,
673}; 855};
674 856
675module_i2c_driver(bma180_driver); 857module_i2c_driver(bma180_driver);
676 858
677MODULE_AUTHOR("Kravchenko Oleksandr <x0199363@ti.com>"); 859MODULE_AUTHOR("Kravchenko Oleksandr <x0199363@ti.com>");
678MODULE_AUTHOR("Texas Instruments, Inc."); 860MODULE_AUTHOR("Texas Instruments, Inc.");
679MODULE_DESCRIPTION("Bosch BMA180 triaxial acceleration sensor"); 861MODULE_DESCRIPTION("Bosch BMA180/BMA250 triaxial acceleration sensor");
680MODULE_LICENSE("GPL"); 862MODULE_LICENSE("GPL");
diff --git a/drivers/iio/accel/bmc150-accel.c b/drivers/iio/accel/bmc150-accel.c
new file mode 100644
index 000000000000..066d0c04072c
--- /dev/null
+++ b/drivers/iio/accel/bmc150-accel.c
@@ -0,0 +1,1456 @@
1/*
2 * 3-axis accelerometer driver supporting following Bosch-Sensortec chips:
3 * - BMC150
4 * - BMI055
5 * - BMA255
6 * - BMA250E
7 * - BMA222E
8 * - BMA280
9 *
10 * Copyright (c) 2014, Intel Corporation.
11 *
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms and conditions of the GNU General Public License,
14 * version 2, as published by the Free Software Foundation.
15 *
16 * This program is distributed in the hope it will be useful, but WITHOUT
17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
19 * more details.
20 */
21
22#include <linux/module.h>
23#include <linux/i2c.h>
24#include <linux/interrupt.h>
25#include <linux/delay.h>
26#include <linux/slab.h>
27#include <linux/acpi.h>
28#include <linux/gpio/consumer.h>
29#include <linux/pm.h>
30#include <linux/pm_runtime.h>
31#include <linux/iio/iio.h>
32#include <linux/iio/sysfs.h>
33#include <linux/iio/buffer.h>
34#include <linux/iio/events.h>
35#include <linux/iio/trigger.h>
36#include <linux/iio/trigger_consumer.h>
37#include <linux/iio/triggered_buffer.h>
38
39#define BMC150_ACCEL_DRV_NAME "bmc150_accel"
40#define BMC150_ACCEL_IRQ_NAME "bmc150_accel_event"
41#define BMC150_ACCEL_GPIO_NAME "bmc150_accel_int"
42
43#define BMC150_ACCEL_REG_CHIP_ID 0x00
44
45#define BMC150_ACCEL_REG_INT_STATUS_2 0x0B
46#define BMC150_ACCEL_ANY_MOTION_MASK 0x07
47#define BMC150_ACCEL_ANY_MOTION_BIT_X BIT(0)
48#define BMC150_ACCEL_ANY_MOTION_BIT_Y BIT(1)
49#define BMC150_ACCEL_ANY_MOTION_BIT_Z BIT(2)
50#define BMC150_ACCEL_ANY_MOTION_BIT_SIGN BIT(3)
51
52#define BMC150_ACCEL_REG_PMU_LPW 0x11
53#define BMC150_ACCEL_PMU_MODE_MASK 0xE0
54#define BMC150_ACCEL_PMU_MODE_SHIFT 5
55#define BMC150_ACCEL_PMU_BIT_SLEEP_DUR_MASK 0x17
56#define BMC150_ACCEL_PMU_BIT_SLEEP_DUR_SHIFT 1
57
58#define BMC150_ACCEL_REG_PMU_RANGE 0x0F
59
60#define BMC150_ACCEL_DEF_RANGE_2G 0x03
61#define BMC150_ACCEL_DEF_RANGE_4G 0x05
62#define BMC150_ACCEL_DEF_RANGE_8G 0x08
63#define BMC150_ACCEL_DEF_RANGE_16G 0x0C
64
65/* Default BW: 125Hz */
66#define BMC150_ACCEL_REG_PMU_BW 0x10
67#define BMC150_ACCEL_DEF_BW 125
68
69#define BMC150_ACCEL_REG_INT_MAP_0 0x19
70#define BMC150_ACCEL_INT_MAP_0_BIT_SLOPE BIT(2)
71
72#define BMC150_ACCEL_REG_INT_MAP_1 0x1A
73#define BMC150_ACCEL_INT_MAP_1_BIT_DATA BIT(0)
74
75#define BMC150_ACCEL_REG_INT_RST_LATCH 0x21
76#define BMC150_ACCEL_INT_MODE_LATCH_RESET 0x80
77#define BMC150_ACCEL_INT_MODE_LATCH_INT 0x0F
78#define BMC150_ACCEL_INT_MODE_NON_LATCH_INT 0x00
79
80#define BMC150_ACCEL_REG_INT_EN_0 0x16
81#define BMC150_ACCEL_INT_EN_BIT_SLP_X BIT(0)
82#define BMC150_ACCEL_INT_EN_BIT_SLP_Y BIT(1)
83#define BMC150_ACCEL_INT_EN_BIT_SLP_Z BIT(2)
84
85#define BMC150_ACCEL_REG_INT_EN_1 0x17
86#define BMC150_ACCEL_INT_EN_BIT_DATA_EN BIT(4)
87
88#define BMC150_ACCEL_REG_INT_OUT_CTRL 0x20
89#define BMC150_ACCEL_INT_OUT_CTRL_INT1_LVL BIT(0)
90
91#define BMC150_ACCEL_REG_INT_5 0x27
92#define BMC150_ACCEL_SLOPE_DUR_MASK 0x03
93
94#define BMC150_ACCEL_REG_INT_6 0x28
95#define BMC150_ACCEL_SLOPE_THRES_MASK 0xFF
96
97/* Slope duration in terms of number of samples */
98#define BMC150_ACCEL_DEF_SLOPE_DURATION 1
99/* in terms of multiples of g's/LSB, based on range */
100#define BMC150_ACCEL_DEF_SLOPE_THRESHOLD 1
101
102#define BMC150_ACCEL_REG_XOUT_L 0x02
103
104#define BMC150_ACCEL_MAX_STARTUP_TIME_MS 100
105
106/* Sleep Duration values */
107#define BMC150_ACCEL_SLEEP_500_MICRO 0x05
108#define BMC150_ACCEL_SLEEP_1_MS 0x06
109#define BMC150_ACCEL_SLEEP_2_MS 0x07
110#define BMC150_ACCEL_SLEEP_4_MS 0x08
111#define BMC150_ACCEL_SLEEP_6_MS 0x09
112#define BMC150_ACCEL_SLEEP_10_MS 0x0A
113#define BMC150_ACCEL_SLEEP_25_MS 0x0B
114#define BMC150_ACCEL_SLEEP_50_MS 0x0C
115#define BMC150_ACCEL_SLEEP_100_MS 0x0D
116#define BMC150_ACCEL_SLEEP_500_MS 0x0E
117#define BMC150_ACCEL_SLEEP_1_SEC 0x0F
118
119#define BMC150_ACCEL_REG_TEMP 0x08
120#define BMC150_ACCEL_TEMP_CENTER_VAL 24
121
122#define BMC150_ACCEL_AXIS_TO_REG(axis) (BMC150_ACCEL_REG_XOUT_L + (axis * 2))
123#define BMC150_AUTO_SUSPEND_DELAY_MS 2000
124
125enum bmc150_accel_axis {
126 AXIS_X,
127 AXIS_Y,
128 AXIS_Z,
129};
130
131enum bmc150_power_modes {
132 BMC150_ACCEL_SLEEP_MODE_NORMAL,
133 BMC150_ACCEL_SLEEP_MODE_DEEP_SUSPEND,
134 BMC150_ACCEL_SLEEP_MODE_LPM,
135 BMC150_ACCEL_SLEEP_MODE_SUSPEND = 0x04,
136};
137
138struct bmc150_scale_info {
139 int scale;
140 u8 reg_range;
141};
142
143struct bmc150_accel_chip_info {
144 u8 chip_id;
145 const struct iio_chan_spec *channels;
146 int num_channels;
147 const struct bmc150_scale_info scale_table[4];
148};
149
150struct bmc150_accel_data {
151 struct i2c_client *client;
152 struct iio_trigger *dready_trig;
153 struct iio_trigger *motion_trig;
154 struct mutex mutex;
155 s16 buffer[8];
156 u8 bw_bits;
157 u32 slope_dur;
158 u32 slope_thres;
159 u32 range;
160 int ev_enable_state;
161 bool dready_trigger_on;
162 bool motion_trigger_on;
163 int64_t timestamp;
164 const struct bmc150_accel_chip_info *chip_info;
165};
166
167static const struct {
168 int val;
169 int val2;
170 u8 bw_bits;
171} bmc150_accel_samp_freq_table[] = { {7, 810000, 0x08},
172 {15, 630000, 0x09},
173 {31, 250000, 0x0A},
174 {62, 500000, 0x0B},
175 {125, 0, 0x0C},
176 {250, 0, 0x0D},
177 {500, 0, 0x0E},
178 {1000, 0, 0x0F} };
179
180static const struct {
181 int bw_bits;
182 int msec;
183} bmc150_accel_sample_upd_time[] = { {0x08, 64},
184 {0x09, 32},
185 {0x0A, 16},
186 {0x0B, 8},
187 {0x0C, 4},
188 {0x0D, 2},
189 {0x0E, 1},
190 {0x0F, 1} };
191
192static const struct {
193 int sleep_dur;
194 u8 reg_value;
195} bmc150_accel_sleep_value_table[] = { {0, 0},
196 {500, BMC150_ACCEL_SLEEP_500_MICRO},
197 {1000, BMC150_ACCEL_SLEEP_1_MS},
198 {2000, BMC150_ACCEL_SLEEP_2_MS},
199 {4000, BMC150_ACCEL_SLEEP_4_MS},
200 {6000, BMC150_ACCEL_SLEEP_6_MS},
201 {10000, BMC150_ACCEL_SLEEP_10_MS},
202 {25000, BMC150_ACCEL_SLEEP_25_MS},
203 {50000, BMC150_ACCEL_SLEEP_50_MS},
204 {100000, BMC150_ACCEL_SLEEP_100_MS},
205 {500000, BMC150_ACCEL_SLEEP_500_MS},
206 {1000000, BMC150_ACCEL_SLEEP_1_SEC} };
207
208
209static int bmc150_accel_set_mode(struct bmc150_accel_data *data,
210 enum bmc150_power_modes mode,
211 int dur_us)
212{
213 int i;
214 int ret;
215 u8 lpw_bits;
216 int dur_val = -1;
217
218 if (dur_us > 0) {
219 for (i = 0; i < ARRAY_SIZE(bmc150_accel_sleep_value_table);
220 ++i) {
221 if (bmc150_accel_sleep_value_table[i].sleep_dur ==
222 dur_us)
223 dur_val =
224 bmc150_accel_sleep_value_table[i].reg_value;
225 }
226 } else
227 dur_val = 0;
228
229 if (dur_val < 0)
230 return -EINVAL;
231
232 lpw_bits = mode << BMC150_ACCEL_PMU_MODE_SHIFT;
233 lpw_bits |= (dur_val << BMC150_ACCEL_PMU_BIT_SLEEP_DUR_SHIFT);
234
235 dev_dbg(&data->client->dev, "Set Mode bits %x\n", lpw_bits);
236
237 ret = i2c_smbus_write_byte_data(data->client,
238 BMC150_ACCEL_REG_PMU_LPW, lpw_bits);
239 if (ret < 0) {
240 dev_err(&data->client->dev, "Error writing reg_pmu_lpw\n");
241 return ret;
242 }
243
244 return 0;
245}
246
247static int bmc150_accel_set_bw(struct bmc150_accel_data *data, int val,
248 int val2)
249{
250 int i;
251 int ret;
252
253 for (i = 0; i < ARRAY_SIZE(bmc150_accel_samp_freq_table); ++i) {
254 if (bmc150_accel_samp_freq_table[i].val == val &&
255 bmc150_accel_samp_freq_table[i].val2 == val2) {
256 ret = i2c_smbus_write_byte_data(
257 data->client,
258 BMC150_ACCEL_REG_PMU_BW,
259 bmc150_accel_samp_freq_table[i].bw_bits);
260 if (ret < 0)
261 return ret;
262
263 data->bw_bits =
264 bmc150_accel_samp_freq_table[i].bw_bits;
265 return 0;
266 }
267 }
268
269 return -EINVAL;
270}
271
272static int bmc150_accel_chip_init(struct bmc150_accel_data *data)
273{
274 int ret;
275
276 ret = i2c_smbus_read_byte_data(data->client, BMC150_ACCEL_REG_CHIP_ID);
277 if (ret < 0) {
278 dev_err(&data->client->dev,
279 "Error: Reading chip id\n");
280 return ret;
281 }
282
283 dev_dbg(&data->client->dev, "Chip Id %x\n", ret);
284 if (ret != data->chip_info->chip_id) {
285 dev_err(&data->client->dev, "Invalid chip %x\n", ret);
286 return -ENODEV;
287 }
288
289 ret = bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_NORMAL, 0);
290 if (ret < 0)
291 return ret;
292
293 /* Set Bandwidth */
294 ret = bmc150_accel_set_bw(data, BMC150_ACCEL_DEF_BW, 0);
295 if (ret < 0)
296 return ret;
297
298 /* Set Default Range */
299 ret = i2c_smbus_write_byte_data(data->client,
300 BMC150_ACCEL_REG_PMU_RANGE,
301 BMC150_ACCEL_DEF_RANGE_4G);
302 if (ret < 0) {
303 dev_err(&data->client->dev,
304 "Error writing reg_pmu_range\n");
305 return ret;
306 }
307
308 data->range = BMC150_ACCEL_DEF_RANGE_4G;
309
310 /* Set default slope duration */
311 ret = i2c_smbus_read_byte_data(data->client, BMC150_ACCEL_REG_INT_5);
312 if (ret < 0) {
313 dev_err(&data->client->dev, "Error reading reg_int_5\n");
314 return ret;
315 }
316 data->slope_dur |= BMC150_ACCEL_DEF_SLOPE_DURATION;
317 ret = i2c_smbus_write_byte_data(data->client,
318 BMC150_ACCEL_REG_INT_5,
319 data->slope_dur);
320 if (ret < 0) {
321 dev_err(&data->client->dev, "Error writing reg_int_5\n");
322 return ret;
323 }
324 dev_dbg(&data->client->dev, "slope_dur %x\n", data->slope_dur);
325
326 /* Set default slope thresholds */
327 ret = i2c_smbus_write_byte_data(data->client,
328 BMC150_ACCEL_REG_INT_6,
329 BMC150_ACCEL_DEF_SLOPE_THRESHOLD);
330 if (ret < 0) {
331 dev_err(&data->client->dev, "Error writing reg_int_6\n");
332 return ret;
333 }
334 data->slope_thres = BMC150_ACCEL_DEF_SLOPE_THRESHOLD;
335 dev_dbg(&data->client->dev, "slope_thres %x\n", data->slope_thres);
336
337 /* Set default as latched interrupts */
338 ret = i2c_smbus_write_byte_data(data->client,
339 BMC150_ACCEL_REG_INT_RST_LATCH,
340 BMC150_ACCEL_INT_MODE_LATCH_INT |
341 BMC150_ACCEL_INT_MODE_LATCH_RESET);
342 if (ret < 0) {
343 dev_err(&data->client->dev,
344 "Error writing reg_int_rst_latch\n");
345 return ret;
346 }
347
348 return 0;
349}
350
351static int bmc150_accel_setup_any_motion_interrupt(
352 struct bmc150_accel_data *data,
353 bool status)
354{
355 int ret;
356
357 /* Enable/Disable INT1 mapping */
358 ret = i2c_smbus_read_byte_data(data->client,
359 BMC150_ACCEL_REG_INT_MAP_0);
360 if (ret < 0) {
361 dev_err(&data->client->dev, "Error reading reg_int_map_0\n");
362 return ret;
363 }
364 if (status)
365 ret |= BMC150_ACCEL_INT_MAP_0_BIT_SLOPE;
366 else
367 ret &= ~BMC150_ACCEL_INT_MAP_0_BIT_SLOPE;
368
369 ret = i2c_smbus_write_byte_data(data->client,
370 BMC150_ACCEL_REG_INT_MAP_0,
371 ret);
372 if (ret < 0) {
373 dev_err(&data->client->dev, "Error writing reg_int_map_0\n");
374 return ret;
375 }
376
377 if (status) {
378 /* Set slope duration (no of samples) */
379 ret = i2c_smbus_write_byte_data(data->client,
380 BMC150_ACCEL_REG_INT_5,
381 data->slope_dur);
382 if (ret < 0) {
383 dev_err(&data->client->dev, "Error write reg_int_5\n");
384 return ret;
385 }
386
387 /* Set slope thresholds */
388 ret = i2c_smbus_write_byte_data(data->client,
389 BMC150_ACCEL_REG_INT_6,
390 data->slope_thres);
391 if (ret < 0) {
392 dev_err(&data->client->dev, "Error write reg_int_6\n");
393 return ret;
394 }
395
396 /*
397 * New data interrupt is always non-latched,
398 * which will have higher priority, so no need
399 * to set latched mode, we will be flooded anyway with INTR
400 */
401 if (!data->dready_trigger_on) {
402 ret = i2c_smbus_write_byte_data(data->client,
403 BMC150_ACCEL_REG_INT_RST_LATCH,
404 BMC150_ACCEL_INT_MODE_LATCH_INT |
405 BMC150_ACCEL_INT_MODE_LATCH_RESET);
406 if (ret < 0) {
407 dev_err(&data->client->dev,
408 "Error writing reg_int_rst_latch\n");
409 return ret;
410 }
411 }
412
413 ret = i2c_smbus_write_byte_data(data->client,
414 BMC150_ACCEL_REG_INT_EN_0,
415 BMC150_ACCEL_INT_EN_BIT_SLP_X |
416 BMC150_ACCEL_INT_EN_BIT_SLP_Y |
417 BMC150_ACCEL_INT_EN_BIT_SLP_Z);
418 } else
419 ret = i2c_smbus_write_byte_data(data->client,
420 BMC150_ACCEL_REG_INT_EN_0,
421 0);
422
423 if (ret < 0) {
424 dev_err(&data->client->dev, "Error writing reg_int_en_0\n");
425 return ret;
426 }
427
428 return 0;
429}
430
431static int bmc150_accel_setup_new_data_interrupt(struct bmc150_accel_data *data,
432 bool status)
433{
434 int ret;
435
436 /* Enable/Disable INT1 mapping */
437 ret = i2c_smbus_read_byte_data(data->client,
438 BMC150_ACCEL_REG_INT_MAP_1);
439 if (ret < 0) {
440 dev_err(&data->client->dev, "Error reading reg_int_map_1\n");
441 return ret;
442 }
443 if (status)
444 ret |= BMC150_ACCEL_INT_MAP_1_BIT_DATA;
445 else
446 ret &= ~BMC150_ACCEL_INT_MAP_1_BIT_DATA;
447
448 ret = i2c_smbus_write_byte_data(data->client,
449 BMC150_ACCEL_REG_INT_MAP_1,
450 ret);
451 if (ret < 0) {
452 dev_err(&data->client->dev, "Error writing reg_int_map_1\n");
453 return ret;
454 }
455
456 if (status) {
457 /*
458 * Set non latched mode interrupt and clear any latched
459 * interrupt
460 */
461 ret = i2c_smbus_write_byte_data(data->client,
462 BMC150_ACCEL_REG_INT_RST_LATCH,
463 BMC150_ACCEL_INT_MODE_NON_LATCH_INT |
464 BMC150_ACCEL_INT_MODE_LATCH_RESET);
465 if (ret < 0) {
466 dev_err(&data->client->dev,
467 "Error writing reg_int_rst_latch\n");
468 return ret;
469 }
470
471 ret = i2c_smbus_write_byte_data(data->client,
472 BMC150_ACCEL_REG_INT_EN_1,
473 BMC150_ACCEL_INT_EN_BIT_DATA_EN);
474
475 } else {
476 /* Restore default interrupt mode */
477 ret = i2c_smbus_write_byte_data(data->client,
478 BMC150_ACCEL_REG_INT_RST_LATCH,
479 BMC150_ACCEL_INT_MODE_LATCH_INT |
480 BMC150_ACCEL_INT_MODE_LATCH_RESET);
481 if (ret < 0) {
482 dev_err(&data->client->dev,
483 "Error writing reg_int_rst_latch\n");
484 return ret;
485 }
486
487 ret = i2c_smbus_write_byte_data(data->client,
488 BMC150_ACCEL_REG_INT_EN_1,
489 0);
490 }
491
492 if (ret < 0) {
493 dev_err(&data->client->dev, "Error writing reg_int_en_1\n");
494 return ret;
495 }
496
497 return 0;
498}
499
500static int bmc150_accel_get_bw(struct bmc150_accel_data *data, int *val,
501 int *val2)
502{
503 int i;
504
505 for (i = 0; i < ARRAY_SIZE(bmc150_accel_samp_freq_table); ++i) {
506 if (bmc150_accel_samp_freq_table[i].bw_bits == data->bw_bits) {
507 *val = bmc150_accel_samp_freq_table[i].val;
508 *val2 = bmc150_accel_samp_freq_table[i].val2;
509 return IIO_VAL_INT_PLUS_MICRO;
510 }
511 }
512
513 return -EINVAL;
514}
515
516#ifdef CONFIG_PM
517static int bmc150_accel_get_startup_times(struct bmc150_accel_data *data)
518{
519 int i;
520
521 for (i = 0; i < ARRAY_SIZE(bmc150_accel_sample_upd_time); ++i) {
522 if (bmc150_accel_sample_upd_time[i].bw_bits == data->bw_bits)
523 return bmc150_accel_sample_upd_time[i].msec;
524 }
525
526 return BMC150_ACCEL_MAX_STARTUP_TIME_MS;
527}
528
529static int bmc150_accel_set_power_state(struct bmc150_accel_data *data, bool on)
530{
531 int ret;
532
533 if (on)
534 ret = pm_runtime_get_sync(&data->client->dev);
535 else {
536 pm_runtime_mark_last_busy(&data->client->dev);
537 ret = pm_runtime_put_autosuspend(&data->client->dev);
538 }
539 if (ret < 0) {
540 dev_err(&data->client->dev,
541 "Failed: bmc150_accel_set_power_state for %d\n", on);
542 if (on)
543 pm_runtime_put_noidle(&data->client->dev);
544
545 return ret;
546 }
547
548 return 0;
549}
550#else
551static int bmc150_accel_set_power_state(struct bmc150_accel_data *data, bool on)
552{
553 return 0;
554}
555#endif
556
557static int bmc150_accel_set_scale(struct bmc150_accel_data *data, int val)
558{
559 int ret, i;
560
561 for (i = 0; i < ARRAY_SIZE(data->chip_info->scale_table); ++i) {
562 if (data->chip_info->scale_table[i].scale == val) {
563 ret = i2c_smbus_write_byte_data(
564 data->client,
565 BMC150_ACCEL_REG_PMU_RANGE,
566 data->chip_info->scale_table[i].reg_range);
567 if (ret < 0) {
568 dev_err(&data->client->dev,
569 "Error writing pmu_range\n");
570 return ret;
571 }
572
573 data->range = data->chip_info->scale_table[i].reg_range;
574 return 0;
575 }
576 }
577
578 return -EINVAL;
579}
580
581static int bmc150_accel_get_temp(struct bmc150_accel_data *data, int *val)
582{
583 int ret;
584
585 mutex_lock(&data->mutex);
586
587 ret = i2c_smbus_read_byte_data(data->client, BMC150_ACCEL_REG_TEMP);
588 if (ret < 0) {
589 dev_err(&data->client->dev, "Error reading reg_temp\n");
590 mutex_unlock(&data->mutex);
591 return ret;
592 }
593 *val = sign_extend32(ret, 7);
594
595 mutex_unlock(&data->mutex);
596
597 return IIO_VAL_INT;
598}
599
600static int bmc150_accel_get_axis(struct bmc150_accel_data *data,
601 struct iio_chan_spec const *chan,
602 int *val)
603{
604 int ret;
605 int axis = chan->scan_index;
606
607 mutex_lock(&data->mutex);
608 ret = bmc150_accel_set_power_state(data, true);
609 if (ret < 0) {
610 mutex_unlock(&data->mutex);
611 return ret;
612 }
613
614 ret = i2c_smbus_read_word_data(data->client,
615 BMC150_ACCEL_AXIS_TO_REG(axis));
616 if (ret < 0) {
617 dev_err(&data->client->dev, "Error reading axis %d\n", axis);
618 bmc150_accel_set_power_state(data, false);
619 mutex_unlock(&data->mutex);
620 return ret;
621 }
622 *val = sign_extend32(ret >> chan->scan_type.shift,
623 chan->scan_type.realbits - 1);
624 ret = bmc150_accel_set_power_state(data, false);
625 mutex_unlock(&data->mutex);
626 if (ret < 0)
627 return ret;
628
629 return IIO_VAL_INT;
630}
631
632static int bmc150_accel_read_raw(struct iio_dev *indio_dev,
633 struct iio_chan_spec const *chan,
634 int *val, int *val2, long mask)
635{
636 struct bmc150_accel_data *data = iio_priv(indio_dev);
637 int ret;
638
639 switch (mask) {
640 case IIO_CHAN_INFO_RAW:
641 switch (chan->type) {
642 case IIO_TEMP:
643 return bmc150_accel_get_temp(data, val);
644 case IIO_ACCEL:
645 if (iio_buffer_enabled(indio_dev))
646 return -EBUSY;
647 else
648 return bmc150_accel_get_axis(data, chan, val);
649 default:
650 return -EINVAL;
651 }
652 case IIO_CHAN_INFO_OFFSET:
653 if (chan->type == IIO_TEMP) {
654 *val = BMC150_ACCEL_TEMP_CENTER_VAL;
655 return IIO_VAL_INT;
656 } else
657 return -EINVAL;
658 case IIO_CHAN_INFO_SCALE:
659 *val = 0;
660 switch (chan->type) {
661 case IIO_TEMP:
662 *val2 = 500000;
663 return IIO_VAL_INT_PLUS_MICRO;
664 case IIO_ACCEL:
665 {
666 int i;
667 const struct bmc150_scale_info *si;
668 int st_size = ARRAY_SIZE(data->chip_info->scale_table);
669
670 for (i = 0; i < st_size; ++i) {
671 si = &data->chip_info->scale_table[i];
672 if (si->reg_range == data->range) {
673 *val2 = si->scale;
674 return IIO_VAL_INT_PLUS_MICRO;
675 }
676 }
677 return -EINVAL;
678 }
679 default:
680 return -EINVAL;
681 }
682 case IIO_CHAN_INFO_SAMP_FREQ:
683 mutex_lock(&data->mutex);
684 ret = bmc150_accel_get_bw(data, val, val2);
685 mutex_unlock(&data->mutex);
686 return ret;
687 default:
688 return -EINVAL;
689 }
690}
691
692static int bmc150_accel_write_raw(struct iio_dev *indio_dev,
693 struct iio_chan_spec const *chan,
694 int val, int val2, long mask)
695{
696 struct bmc150_accel_data *data = iio_priv(indio_dev);
697 int ret;
698
699 switch (mask) {
700 case IIO_CHAN_INFO_SAMP_FREQ:
701 mutex_lock(&data->mutex);
702 ret = bmc150_accel_set_bw(data, val, val2);
703 mutex_unlock(&data->mutex);
704 break;
705 case IIO_CHAN_INFO_SCALE:
706 if (val)
707 return -EINVAL;
708
709 mutex_lock(&data->mutex);
710 ret = bmc150_accel_set_scale(data, val2);
711 mutex_unlock(&data->mutex);
712 return ret;
713 default:
714 ret = -EINVAL;
715 }
716
717 return ret;
718}
719
720static int bmc150_accel_read_event(struct iio_dev *indio_dev,
721 const struct iio_chan_spec *chan,
722 enum iio_event_type type,
723 enum iio_event_direction dir,
724 enum iio_event_info info,
725 int *val, int *val2)
726{
727 struct bmc150_accel_data *data = iio_priv(indio_dev);
728
729 *val2 = 0;
730 switch (info) {
731 case IIO_EV_INFO_VALUE:
732 *val = data->slope_thres;
733 break;
734 case IIO_EV_INFO_PERIOD:
735 *val = data->slope_dur & BMC150_ACCEL_SLOPE_DUR_MASK;
736 break;
737 default:
738 return -EINVAL;
739 }
740
741 return IIO_VAL_INT;
742}
743
744static int bmc150_accel_write_event(struct iio_dev *indio_dev,
745 const struct iio_chan_spec *chan,
746 enum iio_event_type type,
747 enum iio_event_direction dir,
748 enum iio_event_info info,
749 int val, int val2)
750{
751 struct bmc150_accel_data *data = iio_priv(indio_dev);
752
753 if (data->ev_enable_state)
754 return -EBUSY;
755
756 switch (info) {
757 case IIO_EV_INFO_VALUE:
758 data->slope_thres = val;
759 break;
760 case IIO_EV_INFO_PERIOD:
761 data->slope_dur &= ~BMC150_ACCEL_SLOPE_DUR_MASK;
762 data->slope_dur |= val & BMC150_ACCEL_SLOPE_DUR_MASK;
763 break;
764 default:
765 return -EINVAL;
766 }
767
768 return 0;
769}
770
771static int bmc150_accel_read_event_config(struct iio_dev *indio_dev,
772 const struct iio_chan_spec *chan,
773 enum iio_event_type type,
774 enum iio_event_direction dir)
775{
776
777 struct bmc150_accel_data *data = iio_priv(indio_dev);
778
779 return data->ev_enable_state;
780}
781
782static int bmc150_accel_write_event_config(struct iio_dev *indio_dev,
783 const struct iio_chan_spec *chan,
784 enum iio_event_type type,
785 enum iio_event_direction dir,
786 int state)
787{
788 struct bmc150_accel_data *data = iio_priv(indio_dev);
789 int ret;
790
791 if (state && data->ev_enable_state)
792 return 0;
793
794 mutex_lock(&data->mutex);
795
796 if (!state && data->motion_trigger_on) {
797 data->ev_enable_state = 0;
798 mutex_unlock(&data->mutex);
799 return 0;
800 }
801
802 /*
803 * We will expect the enable and disable to do operation in
804 * in reverse order. This will happen here anyway as our
805 * resume operation uses sync mode runtime pm calls, the
806 * suspend operation will be delayed by autosuspend delay
807 * So the disable operation will still happen in reverse of
808 * enable operation. When runtime pm is disabled the mode
809 * is always on so sequence doesn't matter
810 */
811
812 ret = bmc150_accel_set_power_state(data, state);
813 if (ret < 0) {
814 mutex_unlock(&data->mutex);
815 return ret;
816 }
817
818 ret = bmc150_accel_setup_any_motion_interrupt(data, state);
819 if (ret < 0) {
820 bmc150_accel_set_power_state(data, false);
821 mutex_unlock(&data->mutex);
822 return ret;
823 }
824
825 data->ev_enable_state = state;
826 mutex_unlock(&data->mutex);
827
828 return 0;
829}
830
831static int bmc150_accel_validate_trigger(struct iio_dev *indio_dev,
832 struct iio_trigger *trig)
833{
834 struct bmc150_accel_data *data = iio_priv(indio_dev);
835
836 if (data->dready_trig != trig && data->motion_trig != trig)
837 return -EINVAL;
838
839 return 0;
840}
841
842static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
843 "7.810000 15.630000 31.250000 62.500000 125 250 500 1000");
844
845static struct attribute *bmc150_accel_attributes[] = {
846 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
847 NULL,
848};
849
850static const struct attribute_group bmc150_accel_attrs_group = {
851 .attrs = bmc150_accel_attributes,
852};
853
854static const struct iio_event_spec bmc150_accel_event = {
855 .type = IIO_EV_TYPE_ROC,
856 .dir = IIO_EV_DIR_EITHER,
857 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
858 BIT(IIO_EV_INFO_ENABLE) |
859 BIT(IIO_EV_INFO_PERIOD)
860};
861
862#define BMC150_ACCEL_CHANNEL(_axis, bits) { \
863 .type = IIO_ACCEL, \
864 .modified = 1, \
865 .channel2 = IIO_MOD_##_axis, \
866 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
867 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
868 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
869 .scan_index = AXIS_##_axis, \
870 .scan_type = { \
871 .sign = 's', \
872 .realbits = (bits), \
873 .storagebits = 16, \
874 .shift = 16 - (bits), \
875 }, \
876 .event_spec = &bmc150_accel_event, \
877 .num_event_specs = 1 \
878}
879
880#define BMC150_ACCEL_CHANNELS(bits) { \
881 { \
882 .type = IIO_TEMP, \
883 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
884 BIT(IIO_CHAN_INFO_SCALE) | \
885 BIT(IIO_CHAN_INFO_OFFSET), \
886 .scan_index = -1, \
887 }, \
888 BMC150_ACCEL_CHANNEL(X, bits), \
889 BMC150_ACCEL_CHANNEL(Y, bits), \
890 BMC150_ACCEL_CHANNEL(Z, bits), \
891 IIO_CHAN_SOFT_TIMESTAMP(3), \
892}
893
894static const struct iio_chan_spec bma222e_accel_channels[] =
895 BMC150_ACCEL_CHANNELS(8);
896static const struct iio_chan_spec bma250e_accel_channels[] =
897 BMC150_ACCEL_CHANNELS(10);
898static const struct iio_chan_spec bmc150_accel_channels[] =
899 BMC150_ACCEL_CHANNELS(12);
900static const struct iio_chan_spec bma280_accel_channels[] =
901 BMC150_ACCEL_CHANNELS(14);
902
903enum {
904 bmc150,
905 bmi055,
906 bma255,
907 bma250e,
908 bma222e,
909 bma280,
910};
911
912static const struct bmc150_accel_chip_info bmc150_accel_chip_info_tbl[] = {
913 [bmc150] = {
914 .chip_id = 0xFA,
915 .channels = bmc150_accel_channels,
916 .num_channels = ARRAY_SIZE(bmc150_accel_channels),
917 .scale_table = { {9610, BMC150_ACCEL_DEF_RANGE_2G},
918 {19122, BMC150_ACCEL_DEF_RANGE_4G},
919 {38344, BMC150_ACCEL_DEF_RANGE_8G},
920 {76590, BMC150_ACCEL_DEF_RANGE_16G} },
921 },
922 [bmi055] = {
923 .chip_id = 0xFA,
924 .channels = bmc150_accel_channels,
925 .num_channels = ARRAY_SIZE(bmc150_accel_channels),
926 .scale_table = { {9610, BMC150_ACCEL_DEF_RANGE_2G},
927 {19122, BMC150_ACCEL_DEF_RANGE_4G},
928 {38344, BMC150_ACCEL_DEF_RANGE_8G},
929 {76590, BMC150_ACCEL_DEF_RANGE_16G} },
930 },
931 [bma255] = {
932 .chip_id = 0xFA,
933 .channels = bmc150_accel_channels,
934 .num_channels = ARRAY_SIZE(bmc150_accel_channels),
935 .scale_table = { {9610, BMC150_ACCEL_DEF_RANGE_2G},
936 {19122, BMC150_ACCEL_DEF_RANGE_4G},
937 {38344, BMC150_ACCEL_DEF_RANGE_8G},
938 {76590, BMC150_ACCEL_DEF_RANGE_16G} },
939 },
940 [bma250e] = {
941 .chip_id = 0xF9,
942 .channels = bma250e_accel_channels,
943 .num_channels = ARRAY_SIZE(bma250e_accel_channels),
944 .scale_table = { {38344, BMC150_ACCEL_DEF_RANGE_2G},
945 {76590, BMC150_ACCEL_DEF_RANGE_4G},
946 {153277, BMC150_ACCEL_DEF_RANGE_8G},
947 {306457, BMC150_ACCEL_DEF_RANGE_16G} },
948 },
949 [bma222e] = {
950 .chip_id = 0xF8,
951 .channels = bma222e_accel_channels,
952 .num_channels = ARRAY_SIZE(bma222e_accel_channels),
953 .scale_table = { {153277, BMC150_ACCEL_DEF_RANGE_2G},
954 {306457, BMC150_ACCEL_DEF_RANGE_4G},
955 {612915, BMC150_ACCEL_DEF_RANGE_8G},
956 {1225831, BMC150_ACCEL_DEF_RANGE_16G} },
957 },
958 [bma280] = {
959 .chip_id = 0xFB,
960 .channels = bma280_accel_channels,
961 .num_channels = ARRAY_SIZE(bma280_accel_channels),
962 .scale_table = { {2392, BMC150_ACCEL_DEF_RANGE_2G},
963 {4785, BMC150_ACCEL_DEF_RANGE_4G},
964 {9581, BMC150_ACCEL_DEF_RANGE_8G},
965 {19152, BMC150_ACCEL_DEF_RANGE_16G} },
966 },
967};
968
969static const struct iio_info bmc150_accel_info = {
970 .attrs = &bmc150_accel_attrs_group,
971 .read_raw = bmc150_accel_read_raw,
972 .write_raw = bmc150_accel_write_raw,
973 .read_event_value = bmc150_accel_read_event,
974 .write_event_value = bmc150_accel_write_event,
975 .write_event_config = bmc150_accel_write_event_config,
976 .read_event_config = bmc150_accel_read_event_config,
977 .validate_trigger = bmc150_accel_validate_trigger,
978 .driver_module = THIS_MODULE,
979};
980
981static irqreturn_t bmc150_accel_trigger_handler(int irq, void *p)
982{
983 struct iio_poll_func *pf = p;
984 struct iio_dev *indio_dev = pf->indio_dev;
985 struct bmc150_accel_data *data = iio_priv(indio_dev);
986 int bit, ret, i = 0;
987
988 mutex_lock(&data->mutex);
989 for_each_set_bit(bit, indio_dev->buffer->scan_mask,
990 indio_dev->masklength) {
991 ret = i2c_smbus_read_word_data(data->client,
992 BMC150_ACCEL_AXIS_TO_REG(bit));
993 if (ret < 0) {
994 mutex_unlock(&data->mutex);
995 goto err_read;
996 }
997 data->buffer[i++] = ret;
998 }
999 mutex_unlock(&data->mutex);
1000
1001 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
1002 data->timestamp);
1003err_read:
1004 iio_trigger_notify_done(indio_dev->trig);
1005
1006 return IRQ_HANDLED;
1007}
1008
1009static int bmc150_accel_trig_try_reen(struct iio_trigger *trig)
1010{
1011 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1012 struct bmc150_accel_data *data = iio_priv(indio_dev);
1013 int ret;
1014
1015 /* new data interrupts don't need ack */
1016 if (data->dready_trigger_on)
1017 return 0;
1018
1019 mutex_lock(&data->mutex);
1020 /* clear any latched interrupt */
1021 ret = i2c_smbus_write_byte_data(data->client,
1022 BMC150_ACCEL_REG_INT_RST_LATCH,
1023 BMC150_ACCEL_INT_MODE_LATCH_INT |
1024 BMC150_ACCEL_INT_MODE_LATCH_RESET);
1025 mutex_unlock(&data->mutex);
1026 if (ret < 0) {
1027 dev_err(&data->client->dev,
1028 "Error writing reg_int_rst_latch\n");
1029 return ret;
1030 }
1031
1032 return 0;
1033}
1034
1035static int bmc150_accel_data_rdy_trigger_set_state(struct iio_trigger *trig,
1036 bool state)
1037{
1038 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1039 struct bmc150_accel_data *data = iio_priv(indio_dev);
1040 int ret;
1041
1042 mutex_lock(&data->mutex);
1043
1044 if (!state && data->ev_enable_state && data->motion_trigger_on) {
1045 data->motion_trigger_on = false;
1046 mutex_unlock(&data->mutex);
1047 return 0;
1048 }
1049
1050 /*
1051 * Refer to comment in bmc150_accel_write_event_config for
1052 * enable/disable operation order
1053 */
1054 ret = bmc150_accel_set_power_state(data, state);
1055 if (ret < 0) {
1056 mutex_unlock(&data->mutex);
1057 return ret;
1058 }
1059 if (data->motion_trig == trig)
1060 ret = bmc150_accel_setup_any_motion_interrupt(data, state);
1061 else
1062 ret = bmc150_accel_setup_new_data_interrupt(data, state);
1063 if (ret < 0) {
1064 bmc150_accel_set_power_state(data, false);
1065 mutex_unlock(&data->mutex);
1066 return ret;
1067 }
1068 if (data->motion_trig == trig)
1069 data->motion_trigger_on = state;
1070 else
1071 data->dready_trigger_on = state;
1072
1073 mutex_unlock(&data->mutex);
1074
1075 return ret;
1076}
1077
1078static const struct iio_trigger_ops bmc150_accel_trigger_ops = {
1079 .set_trigger_state = bmc150_accel_data_rdy_trigger_set_state,
1080 .try_reenable = bmc150_accel_trig_try_reen,
1081 .owner = THIS_MODULE,
1082};
1083
1084static irqreturn_t bmc150_accel_event_handler(int irq, void *private)
1085{
1086 struct iio_dev *indio_dev = private;
1087 struct bmc150_accel_data *data = iio_priv(indio_dev);
1088 int ret;
1089 int dir;
1090
1091 ret = i2c_smbus_read_byte_data(data->client,
1092 BMC150_ACCEL_REG_INT_STATUS_2);
1093 if (ret < 0) {
1094 dev_err(&data->client->dev, "Error reading reg_int_status_2\n");
1095 goto ack_intr_status;
1096 }
1097
1098 if (ret & BMC150_ACCEL_ANY_MOTION_BIT_SIGN)
1099 dir = IIO_EV_DIR_FALLING;
1100 else
1101 dir = IIO_EV_DIR_RISING;
1102
1103 if (ret & BMC150_ACCEL_ANY_MOTION_BIT_X)
1104 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ACCEL,
1105 0,
1106 IIO_MOD_X,
1107 IIO_EV_TYPE_ROC,
1108 dir),
1109 data->timestamp);
1110 if (ret & BMC150_ACCEL_ANY_MOTION_BIT_Y)
1111 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ACCEL,
1112 0,
1113 IIO_MOD_Y,
1114 IIO_EV_TYPE_ROC,
1115 dir),
1116 data->timestamp);
1117 if (ret & BMC150_ACCEL_ANY_MOTION_BIT_Z)
1118 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ACCEL,
1119 0,
1120 IIO_MOD_Z,
1121 IIO_EV_TYPE_ROC,
1122 dir),
1123 data->timestamp);
1124ack_intr_status:
1125 if (!data->dready_trigger_on)
1126 ret = i2c_smbus_write_byte_data(data->client,
1127 BMC150_ACCEL_REG_INT_RST_LATCH,
1128 BMC150_ACCEL_INT_MODE_LATCH_INT |
1129 BMC150_ACCEL_INT_MODE_LATCH_RESET);
1130
1131 return IRQ_HANDLED;
1132}
1133
1134static irqreturn_t bmc150_accel_data_rdy_trig_poll(int irq, void *private)
1135{
1136 struct iio_dev *indio_dev = private;
1137 struct bmc150_accel_data *data = iio_priv(indio_dev);
1138
1139 data->timestamp = iio_get_time_ns();
1140
1141 if (data->dready_trigger_on)
1142 iio_trigger_poll(data->dready_trig);
1143 else if (data->motion_trigger_on)
1144 iio_trigger_poll(data->motion_trig);
1145
1146 if (data->ev_enable_state)
1147 return IRQ_WAKE_THREAD;
1148 else
1149 return IRQ_HANDLED;
1150}
1151
1152static const char *bmc150_accel_match_acpi_device(struct device *dev, int *data)
1153{
1154 const struct acpi_device_id *id;
1155
1156 id = acpi_match_device(dev->driver->acpi_match_table, dev);
1157
1158 if (!id)
1159 return NULL;
1160
1161 *data = (int) id->driver_data;
1162
1163 return dev_name(dev);
1164}
1165
1166static int bmc150_accel_gpio_probe(struct i2c_client *client,
1167 struct bmc150_accel_data *data)
1168{
1169 struct device *dev;
1170 struct gpio_desc *gpio;
1171 int ret;
1172
1173 if (!client)
1174 return -EINVAL;
1175
1176 dev = &client->dev;
1177
1178 /* data ready gpio interrupt pin */
1179 gpio = devm_gpiod_get_index(dev, BMC150_ACCEL_GPIO_NAME, 0);
1180 if (IS_ERR(gpio)) {
1181 dev_err(dev, "Failed: gpio get index\n");
1182 return PTR_ERR(gpio);
1183 }
1184
1185 ret = gpiod_direction_input(gpio);
1186 if (ret)
1187 return ret;
1188
1189 ret = gpiod_to_irq(gpio);
1190
1191 dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
1192
1193 return ret;
1194}
1195
1196static int bmc150_accel_probe(struct i2c_client *client,
1197 const struct i2c_device_id *id)
1198{
1199 struct bmc150_accel_data *data;
1200 struct iio_dev *indio_dev;
1201 int ret;
1202 const char *name = NULL;
1203 int chip_id = 0;
1204
1205 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1206 if (!indio_dev)
1207 return -ENOMEM;
1208
1209 data = iio_priv(indio_dev);
1210 i2c_set_clientdata(client, indio_dev);
1211 data->client = client;
1212
1213 if (id) {
1214 name = id->name;
1215 chip_id = id->driver_data;
1216 }
1217
1218 if (ACPI_HANDLE(&client->dev))
1219 name = bmc150_accel_match_acpi_device(&client->dev, &chip_id);
1220
1221 data->chip_info = &bmc150_accel_chip_info_tbl[chip_id];
1222
1223 ret = bmc150_accel_chip_init(data);
1224 if (ret < 0)
1225 return ret;
1226
1227 mutex_init(&data->mutex);
1228
1229 indio_dev->dev.parent = &client->dev;
1230 indio_dev->channels = data->chip_info->channels;
1231 indio_dev->num_channels = data->chip_info->num_channels;
1232 indio_dev->name = name;
1233 indio_dev->modes = INDIO_DIRECT_MODE;
1234 indio_dev->info = &bmc150_accel_info;
1235
1236 if (client->irq < 0)
1237 client->irq = bmc150_accel_gpio_probe(client, data);
1238
1239 if (client->irq >= 0) {
1240 ret = devm_request_threaded_irq(
1241 &client->dev, client->irq,
1242 bmc150_accel_data_rdy_trig_poll,
1243 bmc150_accel_event_handler,
1244 IRQF_TRIGGER_RISING,
1245 BMC150_ACCEL_IRQ_NAME,
1246 indio_dev);
1247 if (ret)
1248 return ret;
1249
1250 data->dready_trig = devm_iio_trigger_alloc(&client->dev,
1251 "%s-dev%d",
1252 indio_dev->name,
1253 indio_dev->id);
1254 if (!data->dready_trig)
1255 return -ENOMEM;
1256
1257 data->motion_trig = devm_iio_trigger_alloc(&client->dev,
1258 "%s-any-motion-dev%d",
1259 indio_dev->name,
1260 indio_dev->id);
1261 if (!data->motion_trig)
1262 return -ENOMEM;
1263
1264 data->dready_trig->dev.parent = &client->dev;
1265 data->dready_trig->ops = &bmc150_accel_trigger_ops;
1266 iio_trigger_set_drvdata(data->dready_trig, indio_dev);
1267 ret = iio_trigger_register(data->dready_trig);
1268 if (ret)
1269 return ret;
1270
1271 data->motion_trig->dev.parent = &client->dev;
1272 data->motion_trig->ops = &bmc150_accel_trigger_ops;
1273 iio_trigger_set_drvdata(data->motion_trig, indio_dev);
1274 ret = iio_trigger_register(data->motion_trig);
1275 if (ret) {
1276 data->motion_trig = NULL;
1277 goto err_trigger_unregister;
1278 }
1279
1280 ret = iio_triggered_buffer_setup(indio_dev,
1281 &iio_pollfunc_store_time,
1282 bmc150_accel_trigger_handler,
1283 NULL);
1284 if (ret < 0) {
1285 dev_err(&client->dev,
1286 "Failed: iio triggered buffer setup\n");
1287 goto err_trigger_unregister;
1288 }
1289 }
1290
1291 ret = iio_device_register(indio_dev);
1292 if (ret < 0) {
1293 dev_err(&client->dev, "Unable to register iio device\n");
1294 goto err_buffer_cleanup;
1295 }
1296
1297 ret = pm_runtime_set_active(&client->dev);
1298 if (ret)
1299 goto err_iio_unregister;
1300
1301 pm_runtime_enable(&client->dev);
1302 pm_runtime_set_autosuspend_delay(&client->dev,
1303 BMC150_AUTO_SUSPEND_DELAY_MS);
1304 pm_runtime_use_autosuspend(&client->dev);
1305
1306 return 0;
1307
1308err_iio_unregister:
1309 iio_device_unregister(indio_dev);
1310err_buffer_cleanup:
1311 if (data->dready_trig)
1312 iio_triggered_buffer_cleanup(indio_dev);
1313err_trigger_unregister:
1314 if (data->dready_trig)
1315 iio_trigger_unregister(data->dready_trig);
1316 if (data->motion_trig)
1317 iio_trigger_unregister(data->motion_trig);
1318
1319 return ret;
1320}
1321
1322static int bmc150_accel_remove(struct i2c_client *client)
1323{
1324 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1325 struct bmc150_accel_data *data = iio_priv(indio_dev);
1326
1327 pm_runtime_disable(&client->dev);
1328 pm_runtime_set_suspended(&client->dev);
1329 pm_runtime_put_noidle(&client->dev);
1330
1331 iio_device_unregister(indio_dev);
1332
1333 if (data->dready_trig) {
1334 iio_triggered_buffer_cleanup(indio_dev);
1335 iio_trigger_unregister(data->dready_trig);
1336 iio_trigger_unregister(data->motion_trig);
1337 }
1338
1339 mutex_lock(&data->mutex);
1340 bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_DEEP_SUSPEND, 0);
1341 mutex_unlock(&data->mutex);
1342
1343 return 0;
1344}
1345
1346#ifdef CONFIG_PM_SLEEP
1347static int bmc150_accel_suspend(struct device *dev)
1348{
1349 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1350 struct bmc150_accel_data *data = iio_priv(indio_dev);
1351
1352 mutex_lock(&data->mutex);
1353 bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_SUSPEND, 0);
1354 mutex_unlock(&data->mutex);
1355
1356 return 0;
1357}
1358
1359static int bmc150_accel_resume(struct device *dev)
1360{
1361 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1362 struct bmc150_accel_data *data = iio_priv(indio_dev);
1363
1364 mutex_lock(&data->mutex);
1365 if (data->dready_trigger_on || data->motion_trigger_on ||
1366 data->ev_enable_state)
1367 bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_NORMAL, 0);
1368 mutex_unlock(&data->mutex);
1369
1370 return 0;
1371}
1372#endif
1373
1374#ifdef CONFIG_PM
1375static int bmc150_accel_runtime_suspend(struct device *dev)
1376{
1377 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1378 struct bmc150_accel_data *data = iio_priv(indio_dev);
1379 int ret;
1380
1381 dev_dbg(&data->client->dev, __func__);
1382 ret = bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_SUSPEND, 0);
1383 if (ret < 0)
1384 return -EAGAIN;
1385
1386 return 0;
1387}
1388
1389static int bmc150_accel_runtime_resume(struct device *dev)
1390{
1391 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1392 struct bmc150_accel_data *data = iio_priv(indio_dev);
1393 int ret;
1394 int sleep_val;
1395
1396 dev_dbg(&data->client->dev, __func__);
1397
1398 ret = bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_NORMAL, 0);
1399 if (ret < 0)
1400 return ret;
1401
1402 sleep_val = bmc150_accel_get_startup_times(data);
1403 if (sleep_val < 20)
1404 usleep_range(sleep_val * 1000, 20000);
1405 else
1406 msleep_interruptible(sleep_val);
1407
1408 return 0;
1409}
1410#endif
1411
1412static const struct dev_pm_ops bmc150_accel_pm_ops = {
1413 SET_SYSTEM_SLEEP_PM_OPS(bmc150_accel_suspend, bmc150_accel_resume)
1414 SET_RUNTIME_PM_OPS(bmc150_accel_runtime_suspend,
1415 bmc150_accel_runtime_resume, NULL)
1416};
1417
1418static const struct acpi_device_id bmc150_accel_acpi_match[] = {
1419 {"BSBA0150", bmc150},
1420 {"BMC150A", bmc150},
1421 {"BMI055A", bmi055},
1422 {"BMA0255", bma255},
1423 {"BMA250E", bma250e},
1424 {"BMA222E", bma222e},
1425 {"BMA0280", bma280},
1426 { },
1427};
1428MODULE_DEVICE_TABLE(acpi, bmc150_accel_acpi_match);
1429
1430static const struct i2c_device_id bmc150_accel_id[] = {
1431 {"bmc150_accel", bmc150},
1432 {"bmi055_accel", bmi055},
1433 {"bma255", bma255},
1434 {"bma250e", bma250e},
1435 {"bma222e", bma222e},
1436 {"bma280", bma280},
1437 {}
1438};
1439
1440MODULE_DEVICE_TABLE(i2c, bmc150_accel_id);
1441
1442static struct i2c_driver bmc150_accel_driver = {
1443 .driver = {
1444 .name = BMC150_ACCEL_DRV_NAME,
1445 .acpi_match_table = ACPI_PTR(bmc150_accel_acpi_match),
1446 .pm = &bmc150_accel_pm_ops,
1447 },
1448 .probe = bmc150_accel_probe,
1449 .remove = bmc150_accel_remove,
1450 .id_table = bmc150_accel_id,
1451};
1452module_i2c_driver(bmc150_accel_driver);
1453
1454MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
1455MODULE_LICENSE("GPL v2");
1456MODULE_DESCRIPTION("BMC150 accelerometer driver");
diff --git a/drivers/iio/accel/hid-sensor-accel-3d.c b/drivers/iio/accel/hid-sensor-accel-3d.c
index 54e464e4bb72..d5d95317003a 100644
--- a/drivers/iio/accel/hid-sensor-accel-3d.c
+++ b/drivers/iio/accel/hid-sensor-accel-3d.c
@@ -419,7 +419,6 @@ static struct platform_driver hid_accel_3d_platform_driver = {
419 .id_table = hid_accel_3d_ids, 419 .id_table = hid_accel_3d_ids,
420 .driver = { 420 .driver = {
421 .name = KBUILD_MODNAME, 421 .name = KBUILD_MODNAME,
422 .owner = THIS_MODULE,
423 }, 422 },
424 .probe = hid_accel_3d_probe, 423 .probe = hid_accel_3d_probe,
425 .remove = hid_accel_3d_remove, 424 .remove = hid_accel_3d_remove,
diff --git a/drivers/iio/accel/kxcjk-1013.c b/drivers/iio/accel/kxcjk-1013.c
index 7941cf2d31ee..da2fe93739a2 100644
--- a/drivers/iio/accel/kxcjk-1013.c
+++ b/drivers/iio/accel/kxcjk-1013.c
@@ -21,10 +21,13 @@
21#include <linux/string.h> 21#include <linux/string.h>
22#include <linux/acpi.h> 22#include <linux/acpi.h>
23#include <linux/gpio/consumer.h> 23#include <linux/gpio/consumer.h>
24#include <linux/pm.h>
25#include <linux/pm_runtime.h>
24#include <linux/iio/iio.h> 26#include <linux/iio/iio.h>
25#include <linux/iio/sysfs.h> 27#include <linux/iio/sysfs.h>
26#include <linux/iio/buffer.h> 28#include <linux/iio/buffer.h>
27#include <linux/iio/trigger.h> 29#include <linux/iio/trigger.h>
30#include <linux/iio/events.h>
28#include <linux/iio/trigger_consumer.h> 31#include <linux/iio/trigger_consumer.h>
29#include <linux/iio/triggered_buffer.h> 32#include <linux/iio/triggered_buffer.h>
30#include <linux/iio/accel/kxcjk_1013.h> 33#include <linux/iio/accel/kxcjk_1013.h>
@@ -71,15 +74,40 @@
71#define KXCJK1013_DATA_MASK_12_BIT 0x0FFF 74#define KXCJK1013_DATA_MASK_12_BIT 0x0FFF
72#define KXCJK1013_MAX_STARTUP_TIME_US 100000 75#define KXCJK1013_MAX_STARTUP_TIME_US 100000
73 76
77#define KXCJK1013_SLEEP_DELAY_MS 2000
78
79#define KXCJK1013_REG_INT_SRC2_BIT_ZP BIT(0)
80#define KXCJK1013_REG_INT_SRC2_BIT_ZN BIT(1)
81#define KXCJK1013_REG_INT_SRC2_BIT_YP BIT(2)
82#define KXCJK1013_REG_INT_SRC2_BIT_YN BIT(3)
83#define KXCJK1013_REG_INT_SRC2_BIT_XP BIT(4)
84#define KXCJK1013_REG_INT_SRC2_BIT_XN BIT(5)
85
86#define KXCJK1013_DEFAULT_WAKE_THRES 1
87
88enum kx_chipset {
89 KXCJK1013,
90 KXCJ91008,
91 KXTJ21009,
92 KX_MAX_CHIPS /* this must be last */
93};
94
74struct kxcjk1013_data { 95struct kxcjk1013_data {
75 struct i2c_client *client; 96 struct i2c_client *client;
76 struct iio_trigger *trig; 97 struct iio_trigger *dready_trig;
77 bool trig_mode; 98 struct iio_trigger *motion_trig;
78 struct mutex mutex; 99 struct mutex mutex;
79 s16 buffer[8]; 100 s16 buffer[8];
80 int power_state;
81 u8 odr_bits; 101 u8 odr_bits;
102 u8 range;
103 int wake_thres;
104 int wake_dur;
82 bool active_high_intr; 105 bool active_high_intr;
106 bool dready_trigger_on;
107 int ev_enable_state;
108 bool motion_trigger_on;
109 int64_t timestamp;
110 enum kx_chipset chipset;
83}; 111};
84 112
85enum kxcjk1013_axis { 113enum kxcjk1013_axis {
@@ -93,6 +121,12 @@ enum kxcjk1013_mode {
93 OPERATION, 121 OPERATION,
94}; 122};
95 123
124enum kxcjk1013_range {
125 KXCJK1013_RANGE_2G,
126 KXCJK1013_RANGE_4G,
127 KXCJK1013_RANGE_8G,
128};
129
96static const struct { 130static const struct {
97 int val; 131 int val;
98 int val2; 132 int val2;
@@ -107,10 +141,78 @@ static const struct {
107static const struct { 141static const struct {
108 int odr_bits; 142 int odr_bits;
109 int usec; 143 int usec;
110} odr_start_up_times[] = { {0x08, 100000}, {0x09, 100000}, {0x0A, 100000}, 144} odr_start_up_times[KX_MAX_CHIPS][12] = {
111 {0x0B, 100000}, { 0, 80000}, {0x01, 41000}, 145 /* KXCJK-1013 */
112 {0x02, 21000}, {0x03, 11000}, {0x04, 6400}, 146 {
113 {0x05, 3900}, {0x06, 2700}, {0x07, 2100} }; 147 {0x08, 100000},
148 {0x09, 100000},
149 {0x0A, 100000},
150 {0x0B, 100000},
151 {0, 80000},
152 {0x01, 41000},
153 {0x02, 21000},
154 {0x03, 11000},
155 {0x04, 6400},
156 {0x05, 3900},
157 {0x06, 2700},
158 {0x07, 2100},
159 },
160 /* KXCJ9-1008 */
161 {
162 {0x08, 100000},
163 {0x09, 100000},
164 {0x0A, 100000},
165 {0x0B, 100000},
166 {0, 80000},
167 {0x01, 41000},
168 {0x02, 21000},
169 {0x03, 11000},
170 {0x04, 6400},
171 {0x05, 3900},
172 {0x06, 2700},
173 {0x07, 2100},
174 },
175 /* KXCTJ2-1009 */
176 {
177 {0x08, 1240000},
178 {0x09, 621000},
179 {0x0A, 309000},
180 {0x0B, 151000},
181 {0, 80000},
182 {0x01, 41000},
183 {0x02, 21000},
184 {0x03, 11000},
185 {0x04, 6000},
186 {0x05, 4000},
187 {0x06, 3000},
188 {0x07, 2000},
189 },
190};
191
192static const struct {
193 u16 scale;
194 u8 gsel_0;
195 u8 gsel_1;
196} KXCJK1013_scale_table[] = { {9582, 0, 0},
197 {19163, 1, 0},
198 {38326, 0, 1} };
199
200static const struct {
201 int val;
202 int val2;
203 int odr_bits;
204} wake_odr_data_rate_table[] = { {0, 781000, 0x00},
205 {1, 563000, 0x01},
206 {3, 125000, 0x02},
207 {6, 250000, 0x03},
208 {12, 500000, 0x04},
209 {25, 0, 0x05},
210 {50, 0, 0x06},
211 {100, 0, 0x06},
212 {200, 0, 0x06},
213 {400, 0, 0x06},
214 {800, 0, 0x06},
215 {1600, 0, 0x06} };
114 216
115static int kxcjk1013_set_mode(struct kxcjk1013_data *data, 217static int kxcjk1013_set_mode(struct kxcjk1013_data *data,
116 enum kxcjk1013_mode mode) 218 enum kxcjk1013_mode mode)
@@ -138,6 +240,53 @@ static int kxcjk1013_set_mode(struct kxcjk1013_data *data,
138 return 0; 240 return 0;
139} 241}
140 242
243static int kxcjk1013_get_mode(struct kxcjk1013_data *data,
244 enum kxcjk1013_mode *mode)
245{
246 int ret;
247
248 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
249 if (ret < 0) {
250 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
251 return ret;
252 }
253
254 if (ret & KXCJK1013_REG_CTRL1_BIT_PC1)
255 *mode = OPERATION;
256 else
257 *mode = STANDBY;
258
259 return 0;
260}
261
262static int kxcjk1013_set_range(struct kxcjk1013_data *data, int range_index)
263{
264 int ret;
265
266 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
267 if (ret < 0) {
268 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
269 return ret;
270 }
271
272 ret &= ~(KXCJK1013_REG_CTRL1_BIT_GSEL0 |
273 KXCJK1013_REG_CTRL1_BIT_GSEL1);
274 ret |= (KXCJK1013_scale_table[range_index].gsel_0 << 3);
275 ret |= (KXCJK1013_scale_table[range_index].gsel_1 << 4);
276
277 ret = i2c_smbus_write_byte_data(data->client,
278 KXCJK1013_REG_CTRL1,
279 ret);
280 if (ret < 0) {
281 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
282 return ret;
283 }
284
285 data->range = range_index;
286
287 return 0;
288}
289
141static int kxcjk1013_chip_init(struct kxcjk1013_data *data) 290static int kxcjk1013_chip_init(struct kxcjk1013_data *data)
142{ 291{
143 int ret; 292 int ret;
@@ -160,10 +309,6 @@ static int kxcjk1013_chip_init(struct kxcjk1013_data *data)
160 return ret; 309 return ret;
161 } 310 }
162 311
163 /* Setting range to 4G */
164 ret |= KXCJK1013_REG_CTRL1_BIT_GSEL0;
165 ret &= ~KXCJK1013_REG_CTRL1_BIT_GSEL1;
166
167 /* Set 12 bit mode */ 312 /* Set 12 bit mode */
168 ret |= KXCJK1013_REG_CTRL1_BIT_RES; 313 ret |= KXCJK1013_REG_CTRL1_BIT_RES;
169 314
@@ -174,6 +319,11 @@ static int kxcjk1013_chip_init(struct kxcjk1013_data *data)
174 return ret; 319 return ret;
175 } 320 }
176 321
322 /* Setting range to 4G */
323 ret = kxcjk1013_set_range(data, KXCJK1013_RANGE_4G);
324 if (ret < 0)
325 return ret;
326
177 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_DATA_CTRL); 327 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_DATA_CTRL);
178 if (ret < 0) { 328 if (ret < 0) {
179 dev_err(&data->client->dev, "Error reading reg_data_ctrl\n"); 329 dev_err(&data->client->dev, "Error reading reg_data_ctrl\n");
@@ -201,14 +351,147 @@ static int kxcjk1013_chip_init(struct kxcjk1013_data *data)
201 return ret; 351 return ret;
202 } 352 }
203 353
354 ret = kxcjk1013_set_mode(data, OPERATION);
355 if (ret < 0)
356 return ret;
357
358 data->wake_thres = KXCJK1013_DEFAULT_WAKE_THRES;
359
204 return 0; 360 return 0;
205} 361}
206 362
207static int kxcjk1013_chip_setup_interrupt(struct kxcjk1013_data *data, 363#ifdef CONFIG_PM
208 bool status) 364static int kxcjk1013_get_startup_times(struct kxcjk1013_data *data)
365{
366 int i;
367 int idx = data->chipset;
368
369 for (i = 0; i < ARRAY_SIZE(odr_start_up_times[idx]); ++i) {
370 if (odr_start_up_times[idx][i].odr_bits == data->odr_bits)
371 return odr_start_up_times[idx][i].usec;
372 }
373
374 return KXCJK1013_MAX_STARTUP_TIME_US;
375}
376#endif
377
378static int kxcjk1013_set_power_state(struct kxcjk1013_data *data, bool on)
209{ 379{
210 int ret; 380 int ret;
211 381
382 if (on)
383 ret = pm_runtime_get_sync(&data->client->dev);
384 else {
385 pm_runtime_mark_last_busy(&data->client->dev);
386 ret = pm_runtime_put_autosuspend(&data->client->dev);
387 }
388 if (ret < 0) {
389 dev_err(&data->client->dev,
390 "Failed: kxcjk1013_set_power_state for %d\n", on);
391 return ret;
392 }
393
394 return 0;
395}
396
397static int kxcjk1013_chip_update_thresholds(struct kxcjk1013_data *data)
398{
399 int ret;
400
401 ret = i2c_smbus_write_byte_data(data->client,
402 KXCJK1013_REG_WAKE_TIMER,
403 data->wake_dur);
404 if (ret < 0) {
405 dev_err(&data->client->dev,
406 "Error writing reg_wake_timer\n");
407 return ret;
408 }
409
410 ret = i2c_smbus_write_byte_data(data->client,
411 KXCJK1013_REG_WAKE_THRES,
412 data->wake_thres);
413 if (ret < 0) {
414 dev_err(&data->client->dev, "Error writing reg_wake_thres\n");
415 return ret;
416 }
417
418 return 0;
419}
420
421static int kxcjk1013_setup_any_motion_interrupt(struct kxcjk1013_data *data,
422 bool status)
423{
424 int ret;
425 enum kxcjk1013_mode store_mode;
426
427 ret = kxcjk1013_get_mode(data, &store_mode);
428 if (ret < 0)
429 return ret;
430
431 /* This is requirement by spec to change state to STANDBY */
432 ret = kxcjk1013_set_mode(data, STANDBY);
433 if (ret < 0)
434 return ret;
435
436 ret = kxcjk1013_chip_update_thresholds(data);
437 if (ret < 0)
438 return ret;
439
440 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
441 if (ret < 0) {
442 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
443 return ret;
444 }
445
446 if (status)
447 ret |= KXCJK1013_REG_INT_REG1_BIT_IEN;
448 else
449 ret &= ~KXCJK1013_REG_INT_REG1_BIT_IEN;
450
451 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
452 ret);
453 if (ret < 0) {
454 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
455 return ret;
456 }
457
458 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
459 if (ret < 0) {
460 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
461 return ret;
462 }
463
464 if (status)
465 ret |= KXCJK1013_REG_CTRL1_BIT_WUFE;
466 else
467 ret &= ~KXCJK1013_REG_CTRL1_BIT_WUFE;
468
469 ret = i2c_smbus_write_byte_data(data->client,
470 KXCJK1013_REG_CTRL1, ret);
471 if (ret < 0) {
472 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
473 return ret;
474 }
475
476 if (store_mode == OPERATION) {
477 ret = kxcjk1013_set_mode(data, OPERATION);
478 if (ret < 0)
479 return ret;
480 }
481
482 return 0;
483}
484
485static int kxcjk1013_setup_new_data_interrupt(struct kxcjk1013_data *data,
486 bool status)
487{
488 int ret;
489 enum kxcjk1013_mode store_mode;
490
491 ret = kxcjk1013_get_mode(data, &store_mode);
492 if (ret < 0)
493 return ret;
494
212 /* This is requirement by spec to change state to STANDBY */ 495 /* This is requirement by spec to change state to STANDBY */
213 ret = kxcjk1013_set_mode(data, STANDBY); 496 ret = kxcjk1013_set_mode(data, STANDBY);
214 if (ret < 0) 497 if (ret < 0)
@@ -250,7 +533,13 @@ static int kxcjk1013_chip_setup_interrupt(struct kxcjk1013_data *data,
250 return ret; 533 return ret;
251 } 534 }
252 535
253 return ret; 536 if (store_mode == OPERATION) {
537 ret = kxcjk1013_set_mode(data, OPERATION);
538 if (ret < 0)
539 return ret;
540 }
541
542 return 0;
254} 543}
255 544
256static int kxcjk1013_convert_freq_to_bit(int val, int val2) 545static int kxcjk1013_convert_freq_to_bit(int val, int val2)
@@ -267,10 +556,29 @@ static int kxcjk1013_convert_freq_to_bit(int val, int val2)
267 return -EINVAL; 556 return -EINVAL;
268} 557}
269 558
559static int kxcjk1013_convert_wake_odr_to_bit(int val, int val2)
560{
561 int i;
562
563 for (i = 0; i < ARRAY_SIZE(wake_odr_data_rate_table); ++i) {
564 if (wake_odr_data_rate_table[i].val == val &&
565 wake_odr_data_rate_table[i].val2 == val2) {
566 return wake_odr_data_rate_table[i].odr_bits;
567 }
568 }
569
570 return -EINVAL;
571}
572
270static int kxcjk1013_set_odr(struct kxcjk1013_data *data, int val, int val2) 573static int kxcjk1013_set_odr(struct kxcjk1013_data *data, int val, int val2)
271{ 574{
272 int ret; 575 int ret;
273 int odr_bits; 576 int odr_bits;
577 enum kxcjk1013_mode store_mode;
578
579 ret = kxcjk1013_get_mode(data, &store_mode);
580 if (ret < 0)
581 return ret;
274 582
275 odr_bits = kxcjk1013_convert_freq_to_bit(val, val2); 583 odr_bits = kxcjk1013_convert_freq_to_bit(val, val2);
276 if (odr_bits < 0) 584 if (odr_bits < 0)
@@ -290,9 +598,18 @@ static int kxcjk1013_set_odr(struct kxcjk1013_data *data, int val, int val2)
290 598
291 data->odr_bits = odr_bits; 599 data->odr_bits = odr_bits;
292 600
293 /* Check, if the ODR is changed after data enable */ 601 odr_bits = kxcjk1013_convert_wake_odr_to_bit(val, val2);
294 if (data->power_state) { 602 if (odr_bits < 0)
295 /* Set the state back to operation */ 603 return odr_bits;
604
605 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_CTRL2,
606 odr_bits);
607 if (ret < 0) {
608 dev_err(&data->client->dev, "Error writing reg_ctrl2\n");
609 return ret;
610 }
611
612 if (store_mode == OPERATION) {
296 ret = kxcjk1013_set_mode(data, OPERATION); 613 ret = kxcjk1013_set_mode(data, OPERATION);
297 if (ret < 0) 614 if (ret < 0)
298 return ret; 615 return ret;
@@ -331,16 +648,38 @@ static int kxcjk1013_get_acc_reg(struct kxcjk1013_data *data, int axis)
331 return ret; 648 return ret;
332} 649}
333 650
334static int kxcjk1013_get_startup_times(struct kxcjk1013_data *data) 651static int kxcjk1013_set_scale(struct kxcjk1013_data *data, int val)
335{ 652{
336 int i; 653 int ret, i;
654 enum kxcjk1013_mode store_mode;
655
656
657 for (i = 0; i < ARRAY_SIZE(KXCJK1013_scale_table); ++i) {
658 if (KXCJK1013_scale_table[i].scale == val) {
659
660 ret = kxcjk1013_get_mode(data, &store_mode);
661 if (ret < 0)
662 return ret;
663
664 ret = kxcjk1013_set_mode(data, STANDBY);
665 if (ret < 0)
666 return ret;
667
668 ret = kxcjk1013_set_range(data, i);
669 if (ret < 0)
670 return ret;
337 671
338 for (i = 0; i < ARRAY_SIZE(odr_start_up_times); ++i) { 672 if (store_mode == OPERATION) {
339 if (odr_start_up_times[i].odr_bits == data->odr_bits) 673 ret = kxcjk1013_set_mode(data, OPERATION);
340 return odr_start_up_times[i].usec; 674 if (ret)
675 return ret;
676 }
677
678 return 0;
679 }
341 } 680 }
342 681
343 return KXCJK1013_MAX_STARTUP_TIME_US; 682 return -EINVAL;
344} 683}
345 684
346static int kxcjk1013_read_raw(struct iio_dev *indio_dev, 685static int kxcjk1013_read_raw(struct iio_dev *indio_dev,
@@ -356,34 +695,30 @@ static int kxcjk1013_read_raw(struct iio_dev *indio_dev,
356 if (iio_buffer_enabled(indio_dev)) 695 if (iio_buffer_enabled(indio_dev))
357 ret = -EBUSY; 696 ret = -EBUSY;
358 else { 697 else {
359 int sleep_val; 698 ret = kxcjk1013_set_power_state(data, true);
360
361 ret = kxcjk1013_set_mode(data, OPERATION);
362 if (ret < 0) { 699 if (ret < 0) {
363 mutex_unlock(&data->mutex); 700 mutex_unlock(&data->mutex);
364 return ret; 701 return ret;
365 } 702 }
366 ++data->power_state;
367 sleep_val = kxcjk1013_get_startup_times(data);
368 if (sleep_val < 20000)
369 usleep_range(sleep_val, 20000);
370 else
371 msleep_interruptible(sleep_val/1000);
372 ret = kxcjk1013_get_acc_reg(data, chan->scan_index); 703 ret = kxcjk1013_get_acc_reg(data, chan->scan_index);
373 if (--data->power_state == 0) 704 if (ret < 0) {
374 kxcjk1013_set_mode(data, STANDBY); 705 kxcjk1013_set_power_state(data, false);
706 mutex_unlock(&data->mutex);
707 return ret;
708 }
709 *val = sign_extend32(ret >> 4, 11);
710 ret = kxcjk1013_set_power_state(data, false);
375 } 711 }
376 mutex_unlock(&data->mutex); 712 mutex_unlock(&data->mutex);
377 713
378 if (ret < 0) 714 if (ret < 0)
379 return ret; 715 return ret;
380 716
381 *val = sign_extend32(ret >> 4, 11);
382 return IIO_VAL_INT; 717 return IIO_VAL_INT;
383 718
384 case IIO_CHAN_INFO_SCALE: 719 case IIO_CHAN_INFO_SCALE:
385 *val = 0; 720 *val = 0;
386 *val2 = 19163; /* range +-4g (4/2047*9.806650) */ 721 *val2 = KXCJK1013_scale_table[data->range].scale;
387 return IIO_VAL_INT_PLUS_MICRO; 722 return IIO_VAL_INT_PLUS_MICRO;
388 723
389 case IIO_CHAN_INFO_SAMP_FREQ: 724 case IIO_CHAN_INFO_SAMP_FREQ:
@@ -410,6 +745,14 @@ static int kxcjk1013_write_raw(struct iio_dev *indio_dev,
410 ret = kxcjk1013_set_odr(data, val, val2); 745 ret = kxcjk1013_set_odr(data, val, val2);
411 mutex_unlock(&data->mutex); 746 mutex_unlock(&data->mutex);
412 break; 747 break;
748 case IIO_CHAN_INFO_SCALE:
749 if (val)
750 return -EINVAL;
751
752 mutex_lock(&data->mutex);
753 ret = kxcjk1013_set_scale(data, val2);
754 mutex_unlock(&data->mutex);
755 break;
413 default: 756 default:
414 ret = -EINVAL; 757 ret = -EINVAL;
415 } 758 }
@@ -417,12 +760,120 @@ static int kxcjk1013_write_raw(struct iio_dev *indio_dev,
417 return ret; 760 return ret;
418} 761}
419 762
763static int kxcjk1013_read_event(struct iio_dev *indio_dev,
764 const struct iio_chan_spec *chan,
765 enum iio_event_type type,
766 enum iio_event_direction dir,
767 enum iio_event_info info,
768 int *val, int *val2)
769{
770 struct kxcjk1013_data *data = iio_priv(indio_dev);
771
772 *val2 = 0;
773 switch (info) {
774 case IIO_EV_INFO_VALUE:
775 *val = data->wake_thres;
776 break;
777 case IIO_EV_INFO_PERIOD:
778 *val = data->wake_dur;
779 break;
780 default:
781 return -EINVAL;
782 }
783
784 return IIO_VAL_INT;
785}
786
787static int kxcjk1013_write_event(struct iio_dev *indio_dev,
788 const struct iio_chan_spec *chan,
789 enum iio_event_type type,
790 enum iio_event_direction dir,
791 enum iio_event_info info,
792 int val, int val2)
793{
794 struct kxcjk1013_data *data = iio_priv(indio_dev);
795
796 if (data->ev_enable_state)
797 return -EBUSY;
798
799 switch (info) {
800 case IIO_EV_INFO_VALUE:
801 data->wake_thres = val;
802 break;
803 case IIO_EV_INFO_PERIOD:
804 data->wake_dur = val;
805 break;
806 default:
807 return -EINVAL;
808 }
809
810 return 0;
811}
812
813static int kxcjk1013_read_event_config(struct iio_dev *indio_dev,
814 const struct iio_chan_spec *chan,
815 enum iio_event_type type,
816 enum iio_event_direction dir)
817{
818
819 struct kxcjk1013_data *data = iio_priv(indio_dev);
820
821 return data->ev_enable_state;
822}
823
824static int kxcjk1013_write_event_config(struct iio_dev *indio_dev,
825 const struct iio_chan_spec *chan,
826 enum iio_event_type type,
827 enum iio_event_direction dir,
828 int state)
829{
830 struct kxcjk1013_data *data = iio_priv(indio_dev);
831 int ret;
832
833 if (state && data->ev_enable_state)
834 return 0;
835
836 mutex_lock(&data->mutex);
837
838 if (!state && data->motion_trigger_on) {
839 data->ev_enable_state = 0;
840 mutex_unlock(&data->mutex);
841 return 0;
842 }
843
844 /*
845 * We will expect the enable and disable to do operation in
846 * in reverse order. This will happen here anyway as our
847 * resume operation uses sync mode runtime pm calls, the
848 * suspend operation will be delayed by autosuspend delay
849 * So the disable operation will still happen in reverse of
850 * enable operation. When runtime pm is disabled the mode
851 * is always on so sequence doesn't matter
852 */
853 ret = kxcjk1013_set_power_state(data, state);
854 if (ret < 0) {
855 mutex_unlock(&data->mutex);
856 return ret;
857 }
858
859 ret = kxcjk1013_setup_any_motion_interrupt(data, state);
860 if (ret < 0) {
861 mutex_unlock(&data->mutex);
862 return ret;
863 }
864
865 data->ev_enable_state = state;
866 mutex_unlock(&data->mutex);
867
868 return 0;
869}
870
420static int kxcjk1013_validate_trigger(struct iio_dev *indio_dev, 871static int kxcjk1013_validate_trigger(struct iio_dev *indio_dev,
421 struct iio_trigger *trig) 872 struct iio_trigger *trig)
422{ 873{
423 struct kxcjk1013_data *data = iio_priv(indio_dev); 874 struct kxcjk1013_data *data = iio_priv(indio_dev);
424 875
425 if (data->trig != trig) 876 if (data->dready_trig != trig && data->motion_trig != trig)
426 return -EINVAL; 877 return -EINVAL;
427 878
428 return 0; 879 return 0;
@@ -431,8 +882,11 @@ static int kxcjk1013_validate_trigger(struct iio_dev *indio_dev,
431static IIO_CONST_ATTR_SAMP_FREQ_AVAIL( 882static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
432 "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800 1600"); 883 "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800 1600");
433 884
885static IIO_CONST_ATTR(in_accel_scale_available, "0.009582 0.019163 0.038326");
886
434static struct attribute *kxcjk1013_attributes[] = { 887static struct attribute *kxcjk1013_attributes[] = {
435 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 888 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
889 &iio_const_attr_in_accel_scale_available.dev_attr.attr,
436 NULL, 890 NULL,
437}; 891};
438 892
@@ -440,6 +894,14 @@ static const struct attribute_group kxcjk1013_attrs_group = {
440 .attrs = kxcjk1013_attributes, 894 .attrs = kxcjk1013_attributes,
441}; 895};
442 896
897static const struct iio_event_spec kxcjk1013_event = {
898 .type = IIO_EV_TYPE_THRESH,
899 .dir = IIO_EV_DIR_EITHER,
900 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
901 BIT(IIO_EV_INFO_ENABLE) |
902 BIT(IIO_EV_INFO_PERIOD)
903};
904
443#define KXCJK1013_CHANNEL(_axis) { \ 905#define KXCJK1013_CHANNEL(_axis) { \
444 .type = IIO_ACCEL, \ 906 .type = IIO_ACCEL, \
445 .modified = 1, \ 907 .modified = 1, \
@@ -455,6 +917,8 @@ static const struct attribute_group kxcjk1013_attrs_group = {
455 .shift = 4, \ 917 .shift = 4, \
456 .endianness = IIO_CPU, \ 918 .endianness = IIO_CPU, \
457 }, \ 919 }, \
920 .event_spec = &kxcjk1013_event, \
921 .num_event_specs = 1 \
458} 922}
459 923
460static const struct iio_chan_spec kxcjk1013_channels[] = { 924static const struct iio_chan_spec kxcjk1013_channels[] = {
@@ -468,6 +932,10 @@ static const struct iio_info kxcjk1013_info = {
468 .attrs = &kxcjk1013_attrs_group, 932 .attrs = &kxcjk1013_attrs_group,
469 .read_raw = kxcjk1013_read_raw, 933 .read_raw = kxcjk1013_read_raw,
470 .write_raw = kxcjk1013_write_raw, 934 .write_raw = kxcjk1013_write_raw,
935 .read_event_value = kxcjk1013_read_event,
936 .write_event_value = kxcjk1013_write_event,
937 .write_event_config = kxcjk1013_write_event_config,
938 .read_event_config = kxcjk1013_read_event_config,
471 .validate_trigger = kxcjk1013_validate_trigger, 939 .validate_trigger = kxcjk1013_validate_trigger,
472 .driver_module = THIS_MODULE, 940 .driver_module = THIS_MODULE,
473}; 941};
@@ -493,7 +961,7 @@ static irqreturn_t kxcjk1013_trigger_handler(int irq, void *p)
493 mutex_unlock(&data->mutex); 961 mutex_unlock(&data->mutex);
494 962
495 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer, 963 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
496 pf->timestamp); 964 data->timestamp);
497err: 965err:
498 iio_trigger_notify_done(indio_dev->trig); 966 iio_trigger_notify_done(indio_dev->trig);
499 967
@@ -520,20 +988,34 @@ static int kxcjk1013_data_rdy_trigger_set_state(struct iio_trigger *trig,
520{ 988{
521 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 989 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
522 struct kxcjk1013_data *data = iio_priv(indio_dev); 990 struct kxcjk1013_data *data = iio_priv(indio_dev);
991 int ret;
523 992
524 mutex_lock(&data->mutex); 993 mutex_lock(&data->mutex);
525 if (state) { 994
526 kxcjk1013_chip_setup_interrupt(data, true); 995 if (!state && data->ev_enable_state && data->motion_trigger_on) {
527 kxcjk1013_set_mode(data, OPERATION); 996 data->motion_trigger_on = false;
528 ++data->power_state; 997 mutex_unlock(&data->mutex);
529 } else { 998 return 0;
530 if (--data->power_state) {
531 mutex_unlock(&data->mutex);
532 return 0;
533 }
534 kxcjk1013_chip_setup_interrupt(data, false);
535 kxcjk1013_set_mode(data, STANDBY);
536 } 999 }
1000
1001 ret = kxcjk1013_set_power_state(data, state);
1002 if (ret < 0) {
1003 mutex_unlock(&data->mutex);
1004 return ret;
1005 }
1006 if (data->motion_trig == trig)
1007 ret = kxcjk1013_setup_any_motion_interrupt(data, state);
1008 else
1009 ret = kxcjk1013_setup_new_data_interrupt(data, state);
1010 if (ret < 0) {
1011 mutex_unlock(&data->mutex);
1012 return ret;
1013 }
1014 if (data->motion_trig == trig)
1015 data->motion_trigger_on = state;
1016 else
1017 data->dready_trigger_on = state;
1018
537 mutex_unlock(&data->mutex); 1019 mutex_unlock(&data->mutex);
538 1020
539 return 0; 1021 return 0;
@@ -545,10 +1027,124 @@ static const struct iio_trigger_ops kxcjk1013_trigger_ops = {
545 .owner = THIS_MODULE, 1027 .owner = THIS_MODULE,
546}; 1028};
547 1029
548static int kxcjk1013_acpi_gpio_probe(struct i2c_client *client, 1030static irqreturn_t kxcjk1013_event_handler(int irq, void *private)
549 struct kxcjk1013_data *data) 1031{
1032 struct iio_dev *indio_dev = private;
1033 struct kxcjk1013_data *data = iio_priv(indio_dev);
1034 int ret;
1035
1036 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_SRC1);
1037 if (ret < 0) {
1038 dev_err(&data->client->dev, "Error reading reg_int_src1\n");
1039 goto ack_intr;
1040 }
1041
1042 if (ret & 0x02) {
1043 ret = i2c_smbus_read_byte_data(data->client,
1044 KXCJK1013_REG_INT_SRC2);
1045 if (ret < 0) {
1046 dev_err(&data->client->dev,
1047 "Error reading reg_int_src2\n");
1048 goto ack_intr;
1049 }
1050
1051 if (ret & KXCJK1013_REG_INT_SRC2_BIT_XN)
1052 iio_push_event(indio_dev,
1053 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1054 0,
1055 IIO_MOD_X,
1056 IIO_EV_TYPE_THRESH,
1057 IIO_EV_DIR_FALLING),
1058 data->timestamp);
1059 if (ret & KXCJK1013_REG_INT_SRC2_BIT_XP)
1060 iio_push_event(indio_dev,
1061 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1062 0,
1063 IIO_MOD_X,
1064 IIO_EV_TYPE_THRESH,
1065 IIO_EV_DIR_RISING),
1066 data->timestamp);
1067
1068
1069 if (ret & KXCJK1013_REG_INT_SRC2_BIT_YN)
1070 iio_push_event(indio_dev,
1071 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1072 0,
1073 IIO_MOD_Y,
1074 IIO_EV_TYPE_THRESH,
1075 IIO_EV_DIR_FALLING),
1076 data->timestamp);
1077 if (ret & KXCJK1013_REG_INT_SRC2_BIT_YP)
1078 iio_push_event(indio_dev,
1079 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1080 0,
1081 IIO_MOD_Y,
1082 IIO_EV_TYPE_THRESH,
1083 IIO_EV_DIR_RISING),
1084 data->timestamp);
1085
1086 if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZN)
1087 iio_push_event(indio_dev,
1088 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1089 0,
1090 IIO_MOD_Z,
1091 IIO_EV_TYPE_THRESH,
1092 IIO_EV_DIR_FALLING),
1093 data->timestamp);
1094 if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZP)
1095 iio_push_event(indio_dev,
1096 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1097 0,
1098 IIO_MOD_Z,
1099 IIO_EV_TYPE_THRESH,
1100 IIO_EV_DIR_RISING),
1101 data->timestamp);
1102 }
1103
1104ack_intr:
1105 if (data->dready_trigger_on)
1106 return IRQ_HANDLED;
1107
1108 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_REL);
1109 if (ret < 0)
1110 dev_err(&data->client->dev, "Error reading reg_int_rel\n");
1111
1112 return IRQ_HANDLED;
1113}
1114
1115static irqreturn_t kxcjk1013_data_rdy_trig_poll(int irq, void *private)
1116{
1117 struct iio_dev *indio_dev = private;
1118 struct kxcjk1013_data *data = iio_priv(indio_dev);
1119
1120 data->timestamp = iio_get_time_ns();
1121
1122 if (data->dready_trigger_on)
1123 iio_trigger_poll(data->dready_trig);
1124 else if (data->motion_trigger_on)
1125 iio_trigger_poll(data->motion_trig);
1126
1127 if (data->ev_enable_state)
1128 return IRQ_WAKE_THREAD;
1129 else
1130 return IRQ_HANDLED;
1131}
1132
1133static const char *kxcjk1013_match_acpi_device(struct device *dev,
1134 enum kx_chipset *chipset)
550{ 1135{
551 const struct acpi_device_id *id; 1136 const struct acpi_device_id *id;
1137 id = acpi_match_device(dev->driver->acpi_match_table, dev);
1138 if (!id)
1139 return NULL;
1140 *chipset = (enum kx_chipset)id->driver_data;
1141
1142 return dev_name(dev);
1143}
1144
1145static int kxcjk1013_gpio_probe(struct i2c_client *client,
1146 struct kxcjk1013_data *data)
1147{
552 struct device *dev; 1148 struct device *dev;
553 struct gpio_desc *gpio; 1149 struct gpio_desc *gpio;
554 int ret; 1150 int ret;
@@ -557,12 +1153,6 @@ static int kxcjk1013_acpi_gpio_probe(struct i2c_client *client,
557 return -EINVAL; 1153 return -EINVAL;
558 1154
559 dev = &client->dev; 1155 dev = &client->dev;
560 if (!ACPI_HANDLE(dev))
561 return -ENODEV;
562
563 id = acpi_match_device(dev->driver->acpi_match_table, dev);
564 if (!id)
565 return -ENODEV;
566 1156
567 /* data ready gpio interrupt pin */ 1157 /* data ready gpio interrupt pin */
568 gpio = devm_gpiod_get_index(dev, "kxcjk1013_int", 0); 1158 gpio = devm_gpiod_get_index(dev, "kxcjk1013_int", 0);
@@ -587,8 +1177,8 @@ static int kxcjk1013_probe(struct i2c_client *client,
587{ 1177{
588 struct kxcjk1013_data *data; 1178 struct kxcjk1013_data *data;
589 struct iio_dev *indio_dev; 1179 struct iio_dev *indio_dev;
590 struct iio_trigger *trig = NULL;
591 struct kxcjk_1013_platform_data *pdata; 1180 struct kxcjk_1013_platform_data *pdata;
1181 const char *name;
592 int ret; 1182 int ret;
593 1183
594 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 1184 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
@@ -605,6 +1195,15 @@ static int kxcjk1013_probe(struct i2c_client *client,
605 else 1195 else
606 data->active_high_intr = true; /* default polarity */ 1196 data->active_high_intr = true; /* default polarity */
607 1197
1198 if (id) {
1199 data->chipset = (enum kx_chipset)(id->driver_data);
1200 name = id->name;
1201 } else if (ACPI_HANDLE(&client->dev)) {
1202 name = kxcjk1013_match_acpi_device(&client->dev,
1203 &data->chipset);
1204 } else
1205 return -ENODEV;
1206
608 ret = kxcjk1013_chip_init(data); 1207 ret = kxcjk1013_chip_init(data);
609 if (ret < 0) 1208 if (ret < 0)
610 return ret; 1209 return ret;
@@ -614,41 +1213,54 @@ static int kxcjk1013_probe(struct i2c_client *client,
614 indio_dev->dev.parent = &client->dev; 1213 indio_dev->dev.parent = &client->dev;
615 indio_dev->channels = kxcjk1013_channels; 1214 indio_dev->channels = kxcjk1013_channels;
616 indio_dev->num_channels = ARRAY_SIZE(kxcjk1013_channels); 1215 indio_dev->num_channels = ARRAY_SIZE(kxcjk1013_channels);
617 indio_dev->name = KXCJK1013_DRV_NAME; 1216 indio_dev->name = name;
618 indio_dev->modes = INDIO_DIRECT_MODE; 1217 indio_dev->modes = INDIO_DIRECT_MODE;
619 indio_dev->info = &kxcjk1013_info; 1218 indio_dev->info = &kxcjk1013_info;
620 1219
621 if (client->irq < 0) 1220 if (client->irq < 0)
622 client->irq = kxcjk1013_acpi_gpio_probe(client, data); 1221 client->irq = kxcjk1013_gpio_probe(client, data);
623 1222
624 if (client->irq >= 0) { 1223 if (client->irq >= 0) {
625 trig = iio_trigger_alloc("%s-dev%d", indio_dev->name, 1224 ret = devm_request_threaded_irq(&client->dev, client->irq,
626 indio_dev->id); 1225 kxcjk1013_data_rdy_trig_poll,
627 if (!trig) 1226 kxcjk1013_event_handler,
628 return -ENOMEM; 1227 IRQF_TRIGGER_RISING,
1228 KXCJK1013_IRQ_NAME,
1229 indio_dev);
1230 if (ret)
1231 return ret;
629 1232
630 data->trig_mode = true; 1233 data->dready_trig = devm_iio_trigger_alloc(&client->dev,
1234 "%s-dev%d",
1235 indio_dev->name,
1236 indio_dev->id);
1237 if (!data->dready_trig)
1238 return -ENOMEM;
631 1239
632 ret = devm_request_irq(&client->dev, client->irq, 1240 data->motion_trig = devm_iio_trigger_alloc(&client->dev,
633 iio_trigger_generic_data_rdy_poll, 1241 "%s-any-motion-dev%d",
634 IRQF_TRIGGER_RISING, 1242 indio_dev->name,
635 KXCJK1013_IRQ_NAME, 1243 indio_dev->id);
636 trig); 1244 if (!data->motion_trig)
637 if (ret) { 1245 return -ENOMEM;
638 dev_err(&client->dev, "unable to request IRQ\n");
639 goto err_trigger_free;
640 }
641 1246
642 trig->dev.parent = &client->dev; 1247 data->dready_trig->dev.parent = &client->dev;
643 trig->ops = &kxcjk1013_trigger_ops; 1248 data->dready_trig->ops = &kxcjk1013_trigger_ops;
644 iio_trigger_set_drvdata(trig, indio_dev); 1249 iio_trigger_set_drvdata(data->dready_trig, indio_dev);
645 data->trig = trig; 1250 indio_dev->trig = data->dready_trig;
646 indio_dev->trig = trig;
647 iio_trigger_get(indio_dev->trig); 1251 iio_trigger_get(indio_dev->trig);
648 1252 ret = iio_trigger_register(data->dready_trig);
649 ret = iio_trigger_register(trig);
650 if (ret) 1253 if (ret)
651 goto err_trigger_free; 1254 return ret;
1255
1256 data->motion_trig->dev.parent = &client->dev;
1257 data->motion_trig->ops = &kxcjk1013_trigger_ops;
1258 iio_trigger_set_drvdata(data->motion_trig, indio_dev);
1259 ret = iio_trigger_register(data->motion_trig);
1260 if (ret) {
1261 data->motion_trig = NULL;
1262 goto err_trigger_unregister;
1263 }
652 1264
653 ret = iio_triggered_buffer_setup(indio_dev, 1265 ret = iio_triggered_buffer_setup(indio_dev,
654 &iio_pollfunc_store_time, 1266 &iio_pollfunc_store_time,
@@ -661,23 +1273,33 @@ static int kxcjk1013_probe(struct i2c_client *client,
661 } 1273 }
662 } 1274 }
663 1275
664 ret = devm_iio_device_register(&client->dev, indio_dev); 1276 ret = iio_device_register(indio_dev);
665 if (ret < 0) { 1277 if (ret < 0) {
666 dev_err(&client->dev, "unable to register iio device\n"); 1278 dev_err(&client->dev, "unable to register iio device\n");
667 goto err_buffer_cleanup; 1279 goto err_buffer_cleanup;
668 } 1280 }
669 1281
1282 ret = pm_runtime_set_active(&client->dev);
1283 if (ret)
1284 goto err_iio_unregister;
1285
1286 pm_runtime_enable(&client->dev);
1287 pm_runtime_set_autosuspend_delay(&client->dev,
1288 KXCJK1013_SLEEP_DELAY_MS);
1289 pm_runtime_use_autosuspend(&client->dev);
1290
670 return 0; 1291 return 0;
671 1292
1293err_iio_unregister:
1294 iio_device_unregister(indio_dev);
672err_buffer_cleanup: 1295err_buffer_cleanup:
673 if (data->trig_mode) 1296 if (data->dready_trig)
674 iio_triggered_buffer_cleanup(indio_dev); 1297 iio_triggered_buffer_cleanup(indio_dev);
675err_trigger_unregister: 1298err_trigger_unregister:
676 if (data->trig_mode) 1299 if (data->dready_trig)
677 iio_trigger_unregister(trig); 1300 iio_trigger_unregister(data->dready_trig);
678err_trigger_free: 1301 if (data->motion_trig)
679 if (data->trig_mode) 1302 iio_trigger_unregister(data->motion_trig);
680 iio_trigger_free(trig);
681 1303
682 return ret; 1304 return ret;
683} 1305}
@@ -687,10 +1309,16 @@ static int kxcjk1013_remove(struct i2c_client *client)
687 struct iio_dev *indio_dev = i2c_get_clientdata(client); 1309 struct iio_dev *indio_dev = i2c_get_clientdata(client);
688 struct kxcjk1013_data *data = iio_priv(indio_dev); 1310 struct kxcjk1013_data *data = iio_priv(indio_dev);
689 1311
690 if (data->trig_mode) { 1312 pm_runtime_disable(&client->dev);
1313 pm_runtime_set_suspended(&client->dev);
1314 pm_runtime_put_noidle(&client->dev);
1315
1316 iio_device_unregister(indio_dev);
1317
1318 if (data->dready_trig) {
691 iio_triggered_buffer_cleanup(indio_dev); 1319 iio_triggered_buffer_cleanup(indio_dev);
692 iio_trigger_unregister(data->trig); 1320 iio_trigger_unregister(data->dready_trig);
693 iio_trigger_free(data->trig); 1321 iio_trigger_unregister(data->motion_trig);
694 } 1322 }
695 1323
696 mutex_lock(&data->mutex); 1324 mutex_lock(&data->mutex);
@@ -705,43 +1333,80 @@ static int kxcjk1013_suspend(struct device *dev)
705{ 1333{
706 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1334 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
707 struct kxcjk1013_data *data = iio_priv(indio_dev); 1335 struct kxcjk1013_data *data = iio_priv(indio_dev);
1336 int ret;
708 1337
709 mutex_lock(&data->mutex); 1338 mutex_lock(&data->mutex);
710 kxcjk1013_set_mode(data, STANDBY); 1339 ret = kxcjk1013_set_mode(data, STANDBY);
711 mutex_unlock(&data->mutex); 1340 mutex_unlock(&data->mutex);
712 1341
713 return 0; 1342 return ret;
714} 1343}
715 1344
716static int kxcjk1013_resume(struct device *dev) 1345static int kxcjk1013_resume(struct device *dev)
717{ 1346{
718 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1347 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
719 struct kxcjk1013_data *data = iio_priv(indio_dev); 1348 struct kxcjk1013_data *data = iio_priv(indio_dev);
1349 int ret = 0;
720 1350
721 mutex_lock(&data->mutex); 1351 mutex_lock(&data->mutex);
1352 /* Check, if the suspend occured while active */
1353 if (data->dready_trigger_on || data->motion_trigger_on ||
1354 data->ev_enable_state)
1355 ret = kxcjk1013_set_mode(data, OPERATION);
1356 mutex_unlock(&data->mutex);
722 1357
723 if (data->power_state) 1358 return ret;
724 kxcjk1013_set_mode(data, OPERATION); 1359}
1360#endif
725 1361
726 mutex_unlock(&data->mutex); 1362#ifdef CONFIG_PM
1363static int kxcjk1013_runtime_suspend(struct device *dev)
1364{
1365 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1366 struct kxcjk1013_data *data = iio_priv(indio_dev);
727 1367
728 return 0; 1368 return kxcjk1013_set_mode(data, STANDBY);
729} 1369}
730 1370
731static SIMPLE_DEV_PM_OPS(kxcjk1013_pm_ops, kxcjk1013_suspend, kxcjk1013_resume); 1371static int kxcjk1013_runtime_resume(struct device *dev)
732#define KXCJK1013_PM_OPS (&kxcjk1013_pm_ops) 1372{
733#else 1373 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
734#define KXCJK1013_PM_OPS NULL 1374 struct kxcjk1013_data *data = iio_priv(indio_dev);
1375 int ret;
1376 int sleep_val;
1377
1378 ret = kxcjk1013_set_mode(data, OPERATION);
1379 if (ret < 0)
1380 return ret;
1381
1382 sleep_val = kxcjk1013_get_startup_times(data);
1383 if (sleep_val < 20000)
1384 usleep_range(sleep_val, 20000);
1385 else
1386 msleep_interruptible(sleep_val/1000);
1387
1388 return 0;
1389}
735#endif 1390#endif
736 1391
1392static const struct dev_pm_ops kxcjk1013_pm_ops = {
1393 SET_SYSTEM_SLEEP_PM_OPS(kxcjk1013_suspend, kxcjk1013_resume)
1394 SET_RUNTIME_PM_OPS(kxcjk1013_runtime_suspend,
1395 kxcjk1013_runtime_resume, NULL)
1396};
1397
737static const struct acpi_device_id kx_acpi_match[] = { 1398static const struct acpi_device_id kx_acpi_match[] = {
738 {"KXCJ1013", 0}, 1399 {"KXCJ1013", KXCJK1013},
1400 {"KXCJ1008", KXCJ91008},
1401 {"KXTJ1009", KXTJ21009},
739 { }, 1402 { },
740}; 1403};
741MODULE_DEVICE_TABLE(acpi, kx_acpi_match); 1404MODULE_DEVICE_TABLE(acpi, kx_acpi_match);
742 1405
743static const struct i2c_device_id kxcjk1013_id[] = { 1406static const struct i2c_device_id kxcjk1013_id[] = {
744 {"kxcjk1013", 0}, 1407 {"kxcjk1013", KXCJK1013},
1408 {"kxcj91008", KXCJ91008},
1409 {"kxtj21009", KXTJ21009},
745 {} 1410 {}
746}; 1411};
747 1412
@@ -751,7 +1416,7 @@ static struct i2c_driver kxcjk1013_driver = {
751 .driver = { 1416 .driver = {
752 .name = KXCJK1013_DRV_NAME, 1417 .name = KXCJK1013_DRV_NAME,
753 .acpi_match_table = ACPI_PTR(kx_acpi_match), 1418 .acpi_match_table = ACPI_PTR(kx_acpi_match),
754 .pm = KXCJK1013_PM_OPS, 1419 .pm = &kxcjk1013_pm_ops,
755 }, 1420 },
756 .probe = kxcjk1013_probe, 1421 .probe = kxcjk1013_probe,
757 .remove = kxcjk1013_remove, 1422 .remove = kxcjk1013_remove,
diff --git a/drivers/iio/accel/st_accel.h b/drivers/iio/accel/st_accel.h
index c3877630b2e4..fa9646034305 100644
--- a/drivers/iio/accel/st_accel.h
+++ b/drivers/iio/accel/st_accel.h
@@ -33,8 +33,7 @@ static const struct st_sensors_platform_data default_accel_pdata = {
33 .drdy_int_pin = 1, 33 .drdy_int_pin = 1,
34}; 34};
35 35
36int st_accel_common_probe(struct iio_dev *indio_dev, 36int st_accel_common_probe(struct iio_dev *indio_dev);
37 struct st_sensors_platform_data *pdata);
38void st_accel_common_remove(struct iio_dev *indio_dev); 37void st_accel_common_remove(struct iio_dev *indio_dev);
39 38
40#ifdef CONFIG_IIO_BUFFER 39#ifdef CONFIG_IIO_BUFFER
diff --git a/drivers/iio/accel/st_accel_core.c b/drivers/iio/accel/st_accel_core.c
index 087864854c61..53f32629283a 100644
--- a/drivers/iio/accel/st_accel_core.c
+++ b/drivers/iio/accel/st_accel_core.c
@@ -161,7 +161,7 @@ static const struct iio_chan_spec st_accel_16bit_channels[] = {
161 IIO_CHAN_SOFT_TIMESTAMP(3) 161 IIO_CHAN_SOFT_TIMESTAMP(3)
162}; 162};
163 163
164static const struct st_sensors st_accel_sensors[] = { 164static const struct st_sensor_settings st_accel_sensors_settings[] = {
165 { 165 {
166 .wai = ST_ACCEL_1_WAI_EXP, 166 .wai = ST_ACCEL_1_WAI_EXP,
167 .sensors_supported = { 167 .sensors_supported = {
@@ -457,8 +457,7 @@ static const struct iio_trigger_ops st_accel_trigger_ops = {
457#define ST_ACCEL_TRIGGER_OPS NULL 457#define ST_ACCEL_TRIGGER_OPS NULL
458#endif 458#endif
459 459
460int st_accel_common_probe(struct iio_dev *indio_dev, 460int st_accel_common_probe(struct iio_dev *indio_dev)
461 struct st_sensors_platform_data *plat_data)
462{ 461{
463 struct st_sensor_data *adata = iio_priv(indio_dev); 462 struct st_sensor_data *adata = iio_priv(indio_dev);
464 int irq = adata->get_irq_data_ready(indio_dev); 463 int irq = adata->get_irq_data_ready(indio_dev);
@@ -470,24 +469,25 @@ int st_accel_common_probe(struct iio_dev *indio_dev,
470 st_sensors_power_enable(indio_dev); 469 st_sensors_power_enable(indio_dev);
471 470
472 err = st_sensors_check_device_support(indio_dev, 471 err = st_sensors_check_device_support(indio_dev,
473 ARRAY_SIZE(st_accel_sensors), st_accel_sensors); 472 ARRAY_SIZE(st_accel_sensors_settings),
473 st_accel_sensors_settings);
474 if (err < 0) 474 if (err < 0)
475 return err; 475 return err;
476 476
477 adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS; 477 adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS;
478 adata->multiread_bit = adata->sensor->multi_read_bit; 478 adata->multiread_bit = adata->sensor_settings->multi_read_bit;
479 indio_dev->channels = adata->sensor->ch; 479 indio_dev->channels = adata->sensor_settings->ch;
480 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS; 480 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
481 481
482 adata->current_fullscale = (struct st_sensor_fullscale_avl *) 482 adata->current_fullscale = (struct st_sensor_fullscale_avl *)
483 &adata->sensor->fs.fs_avl[0]; 483 &adata->sensor_settings->fs.fs_avl[0];
484 adata->odr = adata->sensor->odr.odr_avl[0].hz; 484 adata->odr = adata->sensor_settings->odr.odr_avl[0].hz;
485 485
486 if (!plat_data) 486 if (!adata->dev->platform_data)
487 plat_data = 487 adata->dev->platform_data =
488 (struct st_sensors_platform_data *)&default_accel_pdata; 488 (struct st_sensors_platform_data *)&default_accel_pdata;
489 489
490 err = st_sensors_init_sensor(indio_dev, plat_data); 490 err = st_sensors_init_sensor(indio_dev, adata->dev->platform_data);
491 if (err < 0) 491 if (err < 0)
492 return err; 492 return err;
493 493
diff --git a/drivers/iio/accel/st_accel_i2c.c b/drivers/iio/accel/st_accel_i2c.c
index 7164aeff3ab1..c7246bdd30b9 100644
--- a/drivers/iio/accel/st_accel_i2c.c
+++ b/drivers/iio/accel/st_accel_i2c.c
@@ -79,12 +79,11 @@ static int st_accel_i2c_probe(struct i2c_client *client,
79 return -ENOMEM; 79 return -ENOMEM;
80 80
81 adata = iio_priv(indio_dev); 81 adata = iio_priv(indio_dev);
82 adata->dev = &client->dev;
83 st_sensors_of_i2c_probe(client, st_accel_of_match); 82 st_sensors_of_i2c_probe(client, st_accel_of_match);
84 83
85 st_sensors_i2c_configure(indio_dev, client, adata); 84 st_sensors_i2c_configure(indio_dev, client, adata);
86 85
87 err = st_accel_common_probe(indio_dev, client->dev.platform_data); 86 err = st_accel_common_probe(indio_dev);
88 if (err < 0) 87 if (err < 0)
89 return err; 88 return err;
90 89
diff --git a/drivers/iio/accel/st_accel_spi.c b/drivers/iio/accel/st_accel_spi.c
index 195639646e34..12ec29389e4b 100644
--- a/drivers/iio/accel/st_accel_spi.c
+++ b/drivers/iio/accel/st_accel_spi.c
@@ -29,11 +29,10 @@ static int st_accel_spi_probe(struct spi_device *spi)
29 return -ENOMEM; 29 return -ENOMEM;
30 30
31 adata = iio_priv(indio_dev); 31 adata = iio_priv(indio_dev);
32 adata->dev = &spi->dev;
33 32
34 st_sensors_spi_configure(indio_dev, spi, adata); 33 st_sensors_spi_configure(indio_dev, spi, adata);
35 34
36 err = st_accel_common_probe(indio_dev, spi->dev.platform_data); 35 err = st_accel_common_probe(indio_dev);
37 if (err < 0) 36 if (err < 0)
38 return err; 37 return err;
39 38
diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig
index 11b048a59fde..0f79e4725763 100644
--- a/drivers/iio/adc/Kconfig
+++ b/drivers/iio/adc/Kconfig
@@ -127,9 +127,17 @@ config AT91_ADC
127 help 127 help
128 Say yes here to build support for Atmel AT91 ADC. 128 Say yes here to build support for Atmel AT91 ADC.
129 129
130config AXP288_ADC
131 tristate "X-Powers AXP288 ADC driver"
132 depends on MFD_AXP20X
133 help
134 Say yes here to have support for X-Powers power management IC (PMIC) ADC
135 device. Depending on platform configuration, this general purpose ADC can
136 be used for sampling sensors such as thermal resistors.
137
130config EXYNOS_ADC 138config EXYNOS_ADC
131 tristate "Exynos ADC driver support" 139 tristate "Exynos ADC driver support"
132 depends on ARCH_EXYNOS || (OF && COMPILE_TEST) 140 depends on ARCH_EXYNOS || ARCH_S3C24XX || ARCH_S3C64XX || (OF && COMPILE_TEST)
133 help 141 help
134 Core support for the ADC block found in the Samsung EXYNOS series 142 Core support for the ADC block found in the Samsung EXYNOS series
135 of SoCs for drivers such as the touchscreen and hwmon to use to share 143 of SoCs for drivers such as the touchscreen and hwmon to use to share
@@ -206,6 +214,30 @@ config NAU7802
206 To compile this driver as a module, choose M here: the 214 To compile this driver as a module, choose M here: the
207 module will be called nau7802. 215 module will be called nau7802.
208 216
217config QCOM_SPMI_IADC
218 tristate "Qualcomm SPMI PMIC current ADC"
219 depends on SPMI
220 select REGMAP_SPMI
221 help
222 This is the IIO Current ADC driver for Qualcomm QPNP IADC Chip.
223
224 The driver supports single mode operation to read from one of two
225 channels (external or internal). Hardware have additional
226 channels internally used for gain and offset calibration.
227
228 To compile this driver as a module, choose M here: the module will
229 be called qcom-spmi-iadc.
230
231config ROCKCHIP_SARADC
232 tristate "Rockchip SARADC driver"
233 depends on ARCH_ROCKCHIP || (ARM && COMPILE_TEST)
234 help
235 Say yes here to build support for the SARADC found in SoCs from
236 Rockchip.
237
238 To compile this driver as a module, choose M here: the
239 module will be called rockchip_saradc.
240
209config TI_ADC081C 241config TI_ADC081C
210 tristate "Texas Instruments ADC081C021/027" 242 tristate "Texas Instruments ADC081C021/027"
211 depends on I2C 243 depends on I2C
@@ -216,6 +248,16 @@ config TI_ADC081C
216 This driver can also be built as a module. If so, the module will be 248 This driver can also be built as a module. If so, the module will be
217 called ti-adc081c. 249 called ti-adc081c.
218 250
251config TI_ADC128S052
252 tristate "Texas Instruments ADC128S052"
253 depends on SPI
254 help
255 If you say yes here you get support for Texas Instruments ADC128S052
256 chip.
257
258 This driver can also be built as a module. If so, the module will be
259 called ti-adc128s052.
260
219config TI_AM335X_ADC 261config TI_AM335X_ADC
220 tristate "TI's AM335X ADC driver" 262 tristate "TI's AM335X ADC driver"
221 depends on MFD_TI_AM335X_TSCADC 263 depends on MFD_TI_AM335X_TSCADC
diff --git a/drivers/iio/adc/Makefile b/drivers/iio/adc/Makefile
index ad81b512aa3d..701fdb7c96aa 100644
--- a/drivers/iio/adc/Makefile
+++ b/drivers/iio/adc/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_AD7793) += ad7793.o
14obj-$(CONFIG_AD7887) += ad7887.o 14obj-$(CONFIG_AD7887) += ad7887.o
15obj-$(CONFIG_AD799X) += ad799x.o 15obj-$(CONFIG_AD799X) += ad799x.o
16obj-$(CONFIG_AT91_ADC) += at91_adc.o 16obj-$(CONFIG_AT91_ADC) += at91_adc.o
17obj-$(CONFIG_AXP288_ADC) += axp288_adc.o
17obj-$(CONFIG_EXYNOS_ADC) += exynos_adc.o 18obj-$(CONFIG_EXYNOS_ADC) += exynos_adc.o
18obj-$(CONFIG_LP8788_ADC) += lp8788_adc.o 19obj-$(CONFIG_LP8788_ADC) += lp8788_adc.o
19obj-$(CONFIG_MAX1027) += max1027.o 20obj-$(CONFIG_MAX1027) += max1027.o
@@ -22,7 +23,10 @@ obj-$(CONFIG_MCP320X) += mcp320x.o
22obj-$(CONFIG_MCP3422) += mcp3422.o 23obj-$(CONFIG_MCP3422) += mcp3422.o
23obj-$(CONFIG_MEN_Z188_ADC) += men_z188_adc.o 24obj-$(CONFIG_MEN_Z188_ADC) += men_z188_adc.o
24obj-$(CONFIG_NAU7802) += nau7802.o 25obj-$(CONFIG_NAU7802) += nau7802.o
26obj-$(CONFIG_QCOM_SPMI_IADC) += qcom-spmi-iadc.o
27obj-$(CONFIG_ROCKCHIP_SARADC) += rockchip_saradc.o
25obj-$(CONFIG_TI_ADC081C) += ti-adc081c.o 28obj-$(CONFIG_TI_ADC081C) += ti-adc081c.o
29obj-$(CONFIG_TI_ADC128S052) += ti-adc128s052.o
26obj-$(CONFIG_TI_AM335X_ADC) += ti_am335x_adc.o 30obj-$(CONFIG_TI_AM335X_ADC) += ti_am335x_adc.o
27obj-$(CONFIG_TWL4030_MADC) += twl4030-madc.o 31obj-$(CONFIG_TWL4030_MADC) += twl4030-madc.o
28obj-$(CONFIG_TWL6030_GPADC) += twl6030-gpadc.o 32obj-$(CONFIG_TWL6030_GPADC) += twl6030-gpadc.o
diff --git a/drivers/iio/adc/at91_adc.c b/drivers/iio/adc/at91_adc.c
index 7eadaf16adc1..ff61ae55dd3f 100644
--- a/drivers/iio/adc/at91_adc.c
+++ b/drivers/iio/adc/at91_adc.c
@@ -267,7 +267,7 @@ static irqreturn_t at91_adc_trigger_handler(int irq, void *p)
267} 267}
268 268
269/* Handler for classic adc channel eoc trigger */ 269/* Handler for classic adc channel eoc trigger */
270void handle_adc_eoc_trigger(int irq, struct iio_dev *idev) 270static void handle_adc_eoc_trigger(int irq, struct iio_dev *idev)
271{ 271{
272 struct at91_adc_state *st = iio_priv(idev); 272 struct at91_adc_state *st = iio_priv(idev);
273 273
diff --git a/drivers/iio/adc/axp288_adc.c b/drivers/iio/adc/axp288_adc.c
new file mode 100644
index 000000000000..08bcfb061ca5
--- /dev/null
+++ b/drivers/iio/adc/axp288_adc.c
@@ -0,0 +1,261 @@
1/*
2 * axp288_adc.c - X-Powers AXP288 PMIC ADC Driver
3 *
4 * Copyright (C) 2014 Intel Corporation
5 *
6 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; version 2 of the License.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 */
18
19#include <linux/module.h>
20#include <linux/kernel.h>
21#include <linux/device.h>
22#include <linux/regmap.h>
23#include <linux/mfd/axp20x.h>
24#include <linux/platform_device.h>
25
26#include <linux/iio/iio.h>
27#include <linux/iio/machine.h>
28#include <linux/iio/driver.h>
29
30#define AXP288_ADC_EN_MASK 0xF1
31#define AXP288_ADC_TS_PIN_GPADC 0xF2
32#define AXP288_ADC_TS_PIN_ON 0xF3
33
34enum axp288_adc_id {
35 AXP288_ADC_TS,
36 AXP288_ADC_PMIC,
37 AXP288_ADC_GP,
38 AXP288_ADC_BATT_CHRG_I,
39 AXP288_ADC_BATT_DISCHRG_I,
40 AXP288_ADC_BATT_V,
41 AXP288_ADC_NR_CHAN,
42};
43
44struct axp288_adc_info {
45 int irq;
46 struct regmap *regmap;
47};
48
49static const struct iio_chan_spec const axp288_adc_channels[] = {
50 {
51 .indexed = 1,
52 .type = IIO_TEMP,
53 .channel = 0,
54 .address = AXP288_TS_ADC_H,
55 .datasheet_name = "TS_PIN",
56 }, {
57 .indexed = 1,
58 .type = IIO_TEMP,
59 .channel = 1,
60 .address = AXP288_PMIC_ADC_H,
61 .datasheet_name = "PMIC_TEMP",
62 }, {
63 .indexed = 1,
64 .type = IIO_TEMP,
65 .channel = 2,
66 .address = AXP288_GP_ADC_H,
67 .datasheet_name = "GPADC",
68 }, {
69 .indexed = 1,
70 .type = IIO_CURRENT,
71 .channel = 3,
72 .address = AXP20X_BATT_CHRG_I_H,
73 .datasheet_name = "BATT_CHG_I",
74 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
75 }, {
76 .indexed = 1,
77 .type = IIO_CURRENT,
78 .channel = 4,
79 .address = AXP20X_BATT_DISCHRG_I_H,
80 .datasheet_name = "BATT_DISCHRG_I",
81 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
82 }, {
83 .indexed = 1,
84 .type = IIO_VOLTAGE,
85 .channel = 5,
86 .address = AXP20X_BATT_V_H,
87 .datasheet_name = "BATT_V",
88 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
89 },
90};
91
92#define AXP288_ADC_MAP(_adc_channel_label, _consumer_dev_name, \
93 _consumer_channel) \
94 { \
95 .adc_channel_label = _adc_channel_label, \
96 .consumer_dev_name = _consumer_dev_name, \
97 .consumer_channel = _consumer_channel, \
98 }
99
100/* for consumer drivers */
101static struct iio_map axp288_adc_default_maps[] = {
102 AXP288_ADC_MAP("TS_PIN", "axp288-batt", "axp288-batt-temp"),
103 AXP288_ADC_MAP("PMIC_TEMP", "axp288-pmic", "axp288-pmic-temp"),
104 AXP288_ADC_MAP("GPADC", "axp288-gpadc", "axp288-system-temp"),
105 AXP288_ADC_MAP("BATT_CHG_I", "axp288-chrg", "axp288-chrg-curr"),
106 AXP288_ADC_MAP("BATT_DISCHRG_I", "axp288-chrg", "axp288-chrg-d-curr"),
107 AXP288_ADC_MAP("BATT_V", "axp288-batt", "axp288-batt-volt"),
108 {},
109};
110
111static int axp288_adc_read_channel(int *val, unsigned long address,
112 struct regmap *regmap)
113{
114 u8 buf[2];
115
116 if (regmap_bulk_read(regmap, address, buf, 2))
117 return -EIO;
118 *val = (buf[0] << 4) + ((buf[1] >> 4) & 0x0F);
119
120 return IIO_VAL_INT;
121}
122
123static int axp288_adc_set_ts(struct regmap *regmap, unsigned int mode,
124 unsigned long address)
125{
126 /* channels other than GPADC do not need to switch TS pin */
127 if (address != AXP288_GP_ADC_H)
128 return 0;
129
130 return regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL, mode);
131}
132
133static int axp288_adc_read_raw(struct iio_dev *indio_dev,
134 struct iio_chan_spec const *chan,
135 int *val, int *val2, long mask)
136{
137 int ret;
138 struct axp288_adc_info *info = iio_priv(indio_dev);
139
140 mutex_lock(&indio_dev->mlock);
141 switch (mask) {
142 case IIO_CHAN_INFO_RAW:
143 if (axp288_adc_set_ts(info->regmap, AXP288_ADC_TS_PIN_GPADC,
144 chan->address)) {
145 dev_err(&indio_dev->dev, "GPADC mode\n");
146 ret = -EINVAL;
147 break;
148 }
149 ret = axp288_adc_read_channel(val, chan->address, info->regmap);
150 if (axp288_adc_set_ts(info->regmap, AXP288_ADC_TS_PIN_ON,
151 chan->address))
152 dev_err(&indio_dev->dev, "TS pin restore\n");
153 break;
154 case IIO_CHAN_INFO_PROCESSED:
155 ret = axp288_adc_read_channel(val, chan->address, info->regmap);
156 break;
157 default:
158 ret = -EINVAL;
159 }
160 mutex_unlock(&indio_dev->mlock);
161
162 return ret;
163}
164
165static int axp288_adc_set_state(struct regmap *regmap)
166{
167 /* ADC should be always enabled for internal FG to function */
168 if (regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL, AXP288_ADC_TS_PIN_ON))
169 return -EIO;
170
171 return regmap_write(regmap, AXP20X_ADC_EN1, AXP288_ADC_EN_MASK);
172}
173
174static const struct iio_info axp288_adc_iio_info = {
175 .read_raw = &axp288_adc_read_raw,
176 .driver_module = THIS_MODULE,
177};
178
179static int axp288_adc_probe(struct platform_device *pdev)
180{
181 int ret;
182 struct axp288_adc_info *info;
183 struct iio_dev *indio_dev;
184 struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
185
186 indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*info));
187 if (!indio_dev)
188 return -ENOMEM;
189
190 info = iio_priv(indio_dev);
191 info->irq = platform_get_irq(pdev, 0);
192 if (info->irq < 0) {
193 dev_err(&pdev->dev, "no irq resource?\n");
194 return info->irq;
195 }
196 platform_set_drvdata(pdev, indio_dev);
197 info->regmap = axp20x->regmap;
198 /*
199 * Set ADC to enabled state at all time, including system suspend.
200 * otherwise internal fuel gauge functionality may be affected.
201 */
202 ret = axp288_adc_set_state(axp20x->regmap);
203 if (ret) {
204 dev_err(&pdev->dev, "unable to enable ADC device\n");
205 return ret;
206 }
207
208 indio_dev->dev.parent = &pdev->dev;
209 indio_dev->name = pdev->name;
210 indio_dev->channels = axp288_adc_channels;
211 indio_dev->num_channels = ARRAY_SIZE(axp288_adc_channels);
212 indio_dev->info = &axp288_adc_iio_info;
213 indio_dev->modes = INDIO_DIRECT_MODE;
214 ret = iio_map_array_register(indio_dev, axp288_adc_default_maps);
215 if (ret < 0)
216 return ret;
217
218 ret = iio_device_register(indio_dev);
219 if (ret < 0) {
220 dev_err(&pdev->dev, "unable to register iio device\n");
221 goto err_array_unregister;
222 }
223 return 0;
224
225err_array_unregister:
226 iio_map_array_unregister(indio_dev);
227
228 return ret;
229}
230
231static int axp288_adc_remove(struct platform_device *pdev)
232{
233 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
234
235 iio_device_unregister(indio_dev);
236 iio_map_array_unregister(indio_dev);
237
238 return 0;
239}
240
241static struct platform_device_id axp288_adc_id_table[] = {
242 { .name = "axp288_adc" },
243 {},
244};
245
246static struct platform_driver axp288_adc_driver = {
247 .probe = axp288_adc_probe,
248 .remove = axp288_adc_remove,
249 .id_table = axp288_adc_id_table,
250 .driver = {
251 .name = "axp288_adc",
252 },
253};
254
255MODULE_DEVICE_TABLE(platform, axp288_adc_id_table);
256
257module_platform_driver(axp288_adc_driver);
258
259MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@linux.intel.com>");
260MODULE_DESCRIPTION("X-Powers AXP288 ADC Driver");
261MODULE_LICENSE("GPL");
diff --git a/drivers/iio/adc/exynos_adc.c b/drivers/iio/adc/exynos_adc.c
index fc9dfc23ecb7..3a2dbb3b4926 100644
--- a/drivers/iio/adc/exynos_adc.c
+++ b/drivers/iio/adc/exynos_adc.c
@@ -39,14 +39,19 @@
39#include <linux/iio/iio.h> 39#include <linux/iio/iio.h>
40#include <linux/iio/machine.h> 40#include <linux/iio/machine.h>
41#include <linux/iio/driver.h> 41#include <linux/iio/driver.h>
42#include <linux/mfd/syscon.h>
43#include <linux/regmap.h>
42 44
43/* EXYNOS4412/5250 ADC_V1 registers definitions */ 45/* S3C/EXYNOS4412/5250 ADC_V1 registers definitions */
44#define ADC_V1_CON(x) ((x) + 0x00) 46#define ADC_V1_CON(x) ((x) + 0x00)
45#define ADC_V1_DLY(x) ((x) + 0x08) 47#define ADC_V1_DLY(x) ((x) + 0x08)
46#define ADC_V1_DATX(x) ((x) + 0x0C) 48#define ADC_V1_DATX(x) ((x) + 0x0C)
47#define ADC_V1_INTCLR(x) ((x) + 0x18) 49#define ADC_V1_INTCLR(x) ((x) + 0x18)
48#define ADC_V1_MUX(x) ((x) + 0x1c) 50#define ADC_V1_MUX(x) ((x) + 0x1c)
49 51
52/* S3C2410 ADC registers definitions */
53#define ADC_S3C2410_MUX(x) ((x) + 0x18)
54
50/* Future ADC_V2 registers definitions */ 55/* Future ADC_V2 registers definitions */
51#define ADC_V2_CON1(x) ((x) + 0x00) 56#define ADC_V2_CON1(x) ((x) + 0x00)
52#define ADC_V2_CON2(x) ((x) + 0x04) 57#define ADC_V2_CON2(x) ((x) + 0x04)
@@ -61,6 +66,11 @@
61#define ADC_V1_CON_PRSCLV(x) (((x) & 0xFF) << 6) 66#define ADC_V1_CON_PRSCLV(x) (((x) & 0xFF) << 6)
62#define ADC_V1_CON_STANDBY (1u << 2) 67#define ADC_V1_CON_STANDBY (1u << 2)
63 68
69/* Bit definitions for S3C2410 ADC */
70#define ADC_S3C2410_CON_SELMUX(x) (((x) & 7) << 3)
71#define ADC_S3C2410_DATX_MASK 0x3FF
72#define ADC_S3C2416_CON_RES_SEL (1u << 3)
73
64/* Bit definitions for ADC_V2 */ 74/* Bit definitions for ADC_V2 */
65#define ADC_V2_CON1_SOFT_RESET (1u << 2) 75#define ADC_V2_CON1_SOFT_RESET (1u << 2)
66 76
@@ -77,15 +87,19 @@
77 87
78/* Bit definitions common for ADC_V1 and ADC_V2 */ 88/* Bit definitions common for ADC_V1 and ADC_V2 */
79#define ADC_CON_EN_START (1u << 0) 89#define ADC_CON_EN_START (1u << 0)
90#define ADC_CON_EN_START_MASK (0x3 << 0)
80#define ADC_DATX_MASK 0xFFF 91#define ADC_DATX_MASK 0xFFF
81 92
82#define EXYNOS_ADC_TIMEOUT (msecs_to_jiffies(100)) 93#define EXYNOS_ADC_TIMEOUT (msecs_to_jiffies(100))
83 94
95#define EXYNOS_ADCV1_PHY_OFFSET 0x0718
96#define EXYNOS_ADCV2_PHY_OFFSET 0x0720
97
84struct exynos_adc { 98struct exynos_adc {
85 struct exynos_adc_data *data; 99 struct exynos_adc_data *data;
86 struct device *dev; 100 struct device *dev;
87 void __iomem *regs; 101 void __iomem *regs;
88 void __iomem *enable_reg; 102 struct regmap *pmu_map;
89 struct clk *clk; 103 struct clk *clk;
90 struct clk *sclk; 104 struct clk *sclk;
91 unsigned int irq; 105 unsigned int irq;
@@ -100,6 +114,9 @@ struct exynos_adc {
100struct exynos_adc_data { 114struct exynos_adc_data {
101 int num_channels; 115 int num_channels;
102 bool needs_sclk; 116 bool needs_sclk;
117 bool needs_adc_phy;
118 int phy_offset;
119 u32 mask;
103 120
104 void (*init_hw)(struct exynos_adc *info); 121 void (*init_hw)(struct exynos_adc *info);
105 void (*exit_hw)(struct exynos_adc *info); 122 void (*exit_hw)(struct exynos_adc *info);
@@ -171,7 +188,8 @@ static void exynos_adc_v1_init_hw(struct exynos_adc *info)
171{ 188{
172 u32 con1; 189 u32 con1;
173 190
174 writel(1, info->enable_reg); 191 if (info->data->needs_adc_phy)
192 regmap_write(info->pmu_map, info->data->phy_offset, 1);
175 193
176 /* set default prescaler values and Enable prescaler */ 194 /* set default prescaler values and Enable prescaler */
177 con1 = ADC_V1_CON_PRSCLV(49) | ADC_V1_CON_PRSCEN; 195 con1 = ADC_V1_CON_PRSCLV(49) | ADC_V1_CON_PRSCEN;
@@ -185,7 +203,8 @@ static void exynos_adc_v1_exit_hw(struct exynos_adc *info)
185{ 203{
186 u32 con; 204 u32 con;
187 205
188 writel(0, info->enable_reg); 206 if (info->data->needs_adc_phy)
207 regmap_write(info->pmu_map, info->data->phy_offset, 0);
189 208
190 con = readl(ADC_V1_CON(info->regs)); 209 con = readl(ADC_V1_CON(info->regs));
191 con |= ADC_V1_CON_STANDBY; 210 con |= ADC_V1_CON_STANDBY;
@@ -210,6 +229,9 @@ static void exynos_adc_v1_start_conv(struct exynos_adc *info,
210 229
211static const struct exynos_adc_data exynos_adc_v1_data = { 230static const struct exynos_adc_data exynos_adc_v1_data = {
212 .num_channels = MAX_ADC_V1_CHANNELS, 231 .num_channels = MAX_ADC_V1_CHANNELS,
232 .mask = ADC_DATX_MASK, /* 12 bit ADC resolution */
233 .needs_adc_phy = true,
234 .phy_offset = EXYNOS_ADCV1_PHY_OFFSET,
213 235
214 .init_hw = exynos_adc_v1_init_hw, 236 .init_hw = exynos_adc_v1_init_hw,
215 .exit_hw = exynos_adc_v1_exit_hw, 237 .exit_hw = exynos_adc_v1_exit_hw,
@@ -217,11 +239,89 @@ static const struct exynos_adc_data exynos_adc_v1_data = {
217 .start_conv = exynos_adc_v1_start_conv, 239 .start_conv = exynos_adc_v1_start_conv,
218}; 240};
219 241
242static void exynos_adc_s3c2416_start_conv(struct exynos_adc *info,
243 unsigned long addr)
244{
245 u32 con1;
246
247 /* Enable 12 bit ADC resolution */
248 con1 = readl(ADC_V1_CON(info->regs));
249 con1 |= ADC_S3C2416_CON_RES_SEL;
250 writel(con1, ADC_V1_CON(info->regs));
251
252 /* Select channel for S3C2416 */
253 writel(addr, ADC_S3C2410_MUX(info->regs));
254
255 con1 = readl(ADC_V1_CON(info->regs));
256 writel(con1 | ADC_CON_EN_START, ADC_V1_CON(info->regs));
257}
258
259static struct exynos_adc_data const exynos_adc_s3c2416_data = {
260 .num_channels = MAX_ADC_V1_CHANNELS,
261 .mask = ADC_DATX_MASK, /* 12 bit ADC resolution */
262
263 .init_hw = exynos_adc_v1_init_hw,
264 .exit_hw = exynos_adc_v1_exit_hw,
265 .start_conv = exynos_adc_s3c2416_start_conv,
266};
267
268static void exynos_adc_s3c2443_start_conv(struct exynos_adc *info,
269 unsigned long addr)
270{
271 u32 con1;
272
273 /* Select channel for S3C2433 */
274 writel(addr, ADC_S3C2410_MUX(info->regs));
275
276 con1 = readl(ADC_V1_CON(info->regs));
277 writel(con1 | ADC_CON_EN_START, ADC_V1_CON(info->regs));
278}
279
280static struct exynos_adc_data const exynos_adc_s3c2443_data = {
281 .num_channels = MAX_ADC_V1_CHANNELS,
282 .mask = ADC_S3C2410_DATX_MASK, /* 10 bit ADC resolution */
283
284 .init_hw = exynos_adc_v1_init_hw,
285 .exit_hw = exynos_adc_v1_exit_hw,
286 .start_conv = exynos_adc_s3c2443_start_conv,
287};
288
289static void exynos_adc_s3c64xx_start_conv(struct exynos_adc *info,
290 unsigned long addr)
291{
292 u32 con1;
293
294 con1 = readl(ADC_V1_CON(info->regs));
295 con1 &= ~ADC_S3C2410_CON_SELMUX(0x7);
296 con1 |= ADC_S3C2410_CON_SELMUX(addr);
297 writel(con1 | ADC_CON_EN_START, ADC_V1_CON(info->regs));
298}
299
300static struct exynos_adc_data const exynos_adc_s3c24xx_data = {
301 .num_channels = MAX_ADC_V1_CHANNELS,
302 .mask = ADC_S3C2410_DATX_MASK, /* 10 bit ADC resolution */
303
304 .init_hw = exynos_adc_v1_init_hw,
305 .exit_hw = exynos_adc_v1_exit_hw,
306 .start_conv = exynos_adc_s3c64xx_start_conv,
307};
308
309static struct exynos_adc_data const exynos_adc_s3c64xx_data = {
310 .num_channels = MAX_ADC_V1_CHANNELS,
311 .mask = ADC_DATX_MASK, /* 12 bit ADC resolution */
312
313 .init_hw = exynos_adc_v1_init_hw,
314 .exit_hw = exynos_adc_v1_exit_hw,
315 .clear_irq = exynos_adc_v1_clear_irq,
316 .start_conv = exynos_adc_s3c64xx_start_conv,
317};
318
220static void exynos_adc_v2_init_hw(struct exynos_adc *info) 319static void exynos_adc_v2_init_hw(struct exynos_adc *info)
221{ 320{
222 u32 con1, con2; 321 u32 con1, con2;
223 322
224 writel(1, info->enable_reg); 323 if (info->data->needs_adc_phy)
324 regmap_write(info->pmu_map, info->data->phy_offset, 1);
225 325
226 con1 = ADC_V2_CON1_SOFT_RESET; 326 con1 = ADC_V2_CON1_SOFT_RESET;
227 writel(con1, ADC_V2_CON1(info->regs)); 327 writel(con1, ADC_V2_CON1(info->regs));
@@ -238,7 +338,8 @@ static void exynos_adc_v2_exit_hw(struct exynos_adc *info)
238{ 338{
239 u32 con; 339 u32 con;
240 340
241 writel(0, info->enable_reg); 341 if (info->data->needs_adc_phy)
342 regmap_write(info->pmu_map, info->data->phy_offset, 0);
242 343
243 con = readl(ADC_V2_CON1(info->regs)); 344 con = readl(ADC_V2_CON1(info->regs));
244 con &= ~ADC_CON_EN_START; 345 con &= ~ADC_CON_EN_START;
@@ -266,6 +367,9 @@ static void exynos_adc_v2_start_conv(struct exynos_adc *info,
266 367
267static const struct exynos_adc_data exynos_adc_v2_data = { 368static const struct exynos_adc_data exynos_adc_v2_data = {
268 .num_channels = MAX_ADC_V2_CHANNELS, 369 .num_channels = MAX_ADC_V2_CHANNELS,
370 .mask = ADC_DATX_MASK, /* 12 bit ADC resolution */
371 .needs_adc_phy = true,
372 .phy_offset = EXYNOS_ADCV2_PHY_OFFSET,
269 373
270 .init_hw = exynos_adc_v2_init_hw, 374 .init_hw = exynos_adc_v2_init_hw,
271 .exit_hw = exynos_adc_v2_exit_hw, 375 .exit_hw = exynos_adc_v2_exit_hw,
@@ -275,7 +379,10 @@ static const struct exynos_adc_data exynos_adc_v2_data = {
275 379
276static const struct exynos_adc_data exynos3250_adc_data = { 380static const struct exynos_adc_data exynos3250_adc_data = {
277 .num_channels = MAX_EXYNOS3250_ADC_CHANNELS, 381 .num_channels = MAX_EXYNOS3250_ADC_CHANNELS,
382 .mask = ADC_DATX_MASK, /* 12 bit ADC resolution */
278 .needs_sclk = true, 383 .needs_sclk = true,
384 .needs_adc_phy = true,
385 .phy_offset = EXYNOS_ADCV1_PHY_OFFSET,
279 386
280 .init_hw = exynos_adc_v2_init_hw, 387 .init_hw = exynos_adc_v2_init_hw,
281 .exit_hw = exynos_adc_v2_exit_hw, 388 .exit_hw = exynos_adc_v2_exit_hw,
@@ -283,8 +390,52 @@ static const struct exynos_adc_data exynos3250_adc_data = {
283 .start_conv = exynos_adc_v2_start_conv, 390 .start_conv = exynos_adc_v2_start_conv,
284}; 391};
285 392
393static void exynos_adc_exynos7_init_hw(struct exynos_adc *info)
394{
395 u32 con1, con2;
396
397 if (info->data->needs_adc_phy)
398 regmap_write(info->pmu_map, info->data->phy_offset, 1);
399
400 con1 = ADC_V2_CON1_SOFT_RESET;
401 writel(con1, ADC_V2_CON1(info->regs));
402
403 con2 = readl(ADC_V2_CON2(info->regs));
404 con2 &= ~ADC_V2_CON2_C_TIME(7);
405 con2 |= ADC_V2_CON2_C_TIME(0);
406 writel(con2, ADC_V2_CON2(info->regs));
407
408 /* Enable interrupts */
409 writel(1, ADC_V2_INT_EN(info->regs));
410}
411
412static const struct exynos_adc_data exynos7_adc_data = {
413 .num_channels = MAX_ADC_V1_CHANNELS,
414 .mask = ADC_DATX_MASK, /* 12 bit ADC resolution */
415
416 .init_hw = exynos_adc_exynos7_init_hw,
417 .exit_hw = exynos_adc_v2_exit_hw,
418 .clear_irq = exynos_adc_v2_clear_irq,
419 .start_conv = exynos_adc_v2_start_conv,
420};
421
286static const struct of_device_id exynos_adc_match[] = { 422static const struct of_device_id exynos_adc_match[] = {
287 { 423 {
424 .compatible = "samsung,s3c2410-adc",
425 .data = &exynos_adc_s3c24xx_data,
426 }, {
427 .compatible = "samsung,s3c2416-adc",
428 .data = &exynos_adc_s3c2416_data,
429 }, {
430 .compatible = "samsung,s3c2440-adc",
431 .data = &exynos_adc_s3c24xx_data,
432 }, {
433 .compatible = "samsung,s3c2443-adc",
434 .data = &exynos_adc_s3c2443_data,
435 }, {
436 .compatible = "samsung,s3c6410-adc",
437 .data = &exynos_adc_s3c64xx_data,
438 }, {
288 .compatible = "samsung,exynos-adc-v1", 439 .compatible = "samsung,exynos-adc-v1",
289 .data = &exynos_adc_v1_data, 440 .data = &exynos_adc_v1_data,
290 }, { 441 }, {
@@ -293,6 +444,9 @@ static const struct of_device_id exynos_adc_match[] = {
293 }, { 444 }, {
294 .compatible = "samsung,exynos3250-adc", 445 .compatible = "samsung,exynos3250-adc",
295 .data = &exynos3250_adc_data, 446 .data = &exynos3250_adc_data,
447 }, {
448 .compatible = "samsung,exynos7-adc",
449 .data = &exynos7_adc_data,
296 }, 450 },
297 {}, 451 {},
298}; 452};
@@ -347,9 +501,10 @@ static int exynos_read_raw(struct iio_dev *indio_dev,
347static irqreturn_t exynos_adc_isr(int irq, void *dev_id) 501static irqreturn_t exynos_adc_isr(int irq, void *dev_id)
348{ 502{
349 struct exynos_adc *info = (struct exynos_adc *)dev_id; 503 struct exynos_adc *info = (struct exynos_adc *)dev_id;
504 u32 mask = info->data->mask;
350 505
351 /* Read value */ 506 /* Read value */
352 info->value = readl(ADC_V1_DATX(info->regs)) & ADC_DATX_MASK; 507 info->value = readl(ADC_V1_DATX(info->regs)) & mask;
353 508
354 /* clear irq */ 509 /* clear irq */
355 if (info->data->clear_irq) 510 if (info->data->clear_irq)
@@ -442,10 +597,16 @@ static int exynos_adc_probe(struct platform_device *pdev)
442 if (IS_ERR(info->regs)) 597 if (IS_ERR(info->regs))
443 return PTR_ERR(info->regs); 598 return PTR_ERR(info->regs);
444 599
445 mem = platform_get_resource(pdev, IORESOURCE_MEM, 1); 600
446 info->enable_reg = devm_ioremap_resource(&pdev->dev, mem); 601 if (info->data->needs_adc_phy) {
447 if (IS_ERR(info->enable_reg)) 602 info->pmu_map = syscon_regmap_lookup_by_phandle(
448 return PTR_ERR(info->enable_reg); 603 pdev->dev.of_node,
604 "samsung,syscon-phandle");
605 if (IS_ERR(info->pmu_map)) {
606 dev_err(&pdev->dev, "syscon regmap lookup failed.\n");
607 return PTR_ERR(info->pmu_map);
608 }
609 }
449 610
450 irq = platform_get_irq(pdev, 0); 611 irq = platform_get_irq(pdev, 0);
451 if (irq < 0) { 612 if (irq < 0) {
@@ -606,7 +767,6 @@ static struct platform_driver exynos_adc_driver = {
606 .remove = exynos_adc_remove, 767 .remove = exynos_adc_remove,
607 .driver = { 768 .driver = {
608 .name = "exynos-adc", 769 .name = "exynos-adc",
609 .owner = THIS_MODULE,
610 .of_match_table = exynos_adc_match, 770 .of_match_table = exynos_adc_match,
611 .pm = &exynos_adc_pm_ops, 771 .pm = &exynos_adc_pm_ops,
612 }, 772 },
diff --git a/drivers/iio/adc/lp8788_adc.c b/drivers/iio/adc/lp8788_adc.c
index 5c8c91595f47..152cfc8e1c7b 100644
--- a/drivers/iio/adc/lp8788_adc.c
+++ b/drivers/iio/adc/lp8788_adc.c
@@ -244,7 +244,6 @@ static struct platform_driver lp8788_adc_driver = {
244 .remove = lp8788_adc_remove, 244 .remove = lp8788_adc_remove,
245 .driver = { 245 .driver = {
246 .name = LP8788_DEV_ADC, 246 .name = LP8788_DEV_ADC,
247 .owner = THIS_MODULE,
248 }, 247 },
249}; 248};
250module_platform_driver(lp8788_adc_driver); 249module_platform_driver(lp8788_adc_driver);
diff --git a/drivers/iio/adc/mcp320x.c b/drivers/iio/adc/mcp320x.c
index 28a086e48776..efbfd12a4bfd 100644
--- a/drivers/iio/adc/mcp320x.c
+++ b/drivers/iio/adc/mcp320x.c
@@ -1,9 +1,30 @@
1/* 1/*
2 * Copyright (C) 2013 Oskar Andero <oskar.andero@gmail.com> 2 * Copyright (C) 2013 Oskar Andero <oskar.andero@gmail.com>
3 * Copyright (C) 2014 Rose Technology
4 * Allan Bendorff Jensen <abj@rosetechnology.dk>
5 * Soren Andersen <san@rosetechnology.dk>
6 *
7 * Driver for following ADC chips from Microchip Technology's:
8 * 10 Bit converter
9 * MCP3001
10 * MCP3002
11 * MCP3004
12 * MCP3008
13 * ------------
14 * 12 bit converter
15 * MCP3201
16 * MCP3202
17 * MCP3204
18 * MCP3208
19 * ------------
3 * 20 *
4 * Driver for Microchip Technology's MCP3204 and MCP3208 ADC chips.
5 * Datasheet can be found here: 21 * Datasheet can be found here:
6 * http://ww1.microchip.com/downloads/en/devicedoc/21298c.pdf 22 * http://ww1.microchip.com/downloads/en/DeviceDoc/21293C.pdf mcp3001
23 * http://ww1.microchip.com/downloads/en/DeviceDoc/21294E.pdf mcp3002
24 * http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf mcp3004/08
25 * http://ww1.microchip.com/downloads/en/DeviceDoc/21290D.pdf mcp3201
26 * http://ww1.microchip.com/downloads/en/DeviceDoc/21034D.pdf mcp3202
27 * http://ww1.microchip.com/downloads/en/DeviceDoc/21298c.pdf mcp3204/08
7 * 28 *
8 * This program is free software; you can redistribute it and/or modify 29 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as 30 * it under the terms of the GNU General Public License version 2 as
@@ -11,19 +32,29 @@
11 */ 32 */
12 33
13#include <linux/err.h> 34#include <linux/err.h>
35#include <linux/delay.h>
14#include <linux/spi/spi.h> 36#include <linux/spi/spi.h>
15#include <linux/module.h> 37#include <linux/module.h>
16#include <linux/iio/iio.h> 38#include <linux/iio/iio.h>
17#include <linux/regulator/consumer.h> 39#include <linux/regulator/consumer.h>
18 40
19#define MCP_SINGLE_ENDED (1 << 3)
20#define MCP_START_BIT (1 << 4)
21
22enum { 41enum {
42 mcp3001,
43 mcp3002,
44 mcp3004,
45 mcp3008,
46 mcp3201,
47 mcp3202,
23 mcp3204, 48 mcp3204,
24 mcp3208, 49 mcp3208,
25}; 50};
26 51
52struct mcp320x_chip_info {
53 const struct iio_chan_spec *channels;
54 unsigned int num_channels;
55 unsigned int resolution;
56};
57
27struct mcp320x { 58struct mcp320x {
28 struct spi_device *spi; 59 struct spi_device *spi;
29 struct spi_message msg; 60 struct spi_message msg;
@@ -34,19 +65,69 @@ struct mcp320x {
34 65
35 struct regulator *reg; 66 struct regulator *reg;
36 struct mutex lock; 67 struct mutex lock;
68 const struct mcp320x_chip_info *chip_info;
37}; 69};
38 70
39static int mcp320x_adc_conversion(struct mcp320x *adc, u8 msg) 71static int mcp320x_channel_to_tx_data(int device_index,
72 const unsigned int channel, bool differential)
73{
74 int start_bit = 1;
75
76 switch (device_index) {
77 case mcp3001:
78 case mcp3201:
79 return 0;
80 case mcp3002:
81 case mcp3202:
82 return ((start_bit << 4) | (!differential << 3) |
83 (channel << 2));
84 case mcp3004:
85 case mcp3204:
86 case mcp3008:
87 case mcp3208:
88 return ((start_bit << 6) | (!differential << 5) |
89 (channel << 2));
90 default:
91 return -EINVAL;
92 }
93}
94
95static int mcp320x_adc_conversion(struct mcp320x *adc, u8 channel,
96 bool differential, int device_index)
40{ 97{
41 int ret; 98 int ret;
42 99
43 adc->tx_buf = msg; 100 adc->rx_buf[0] = 0;
44 ret = spi_sync(adc->spi, &adc->msg); 101 adc->rx_buf[1] = 0;
45 if (ret < 0) 102 adc->tx_buf = mcp320x_channel_to_tx_data(device_index,
46 return ret; 103 channel, differential);
104
105 if (device_index != mcp3001 && device_index != mcp3201) {
106 ret = spi_sync(adc->spi, &adc->msg);
107 if (ret < 0)
108 return ret;
109 } else {
110 ret = spi_read(adc->spi, &adc->rx_buf, sizeof(adc->rx_buf));
111 if (ret < 0)
112 return ret;
113 }
47 114
48 return ((adc->rx_buf[0] & 0x3f) << 6) | 115 switch (device_index) {
49 (adc->rx_buf[1] >> 2); 116 case mcp3001:
117 return (adc->rx_buf[0] << 5 | adc->rx_buf[1] >> 3);
118 case mcp3002:
119 case mcp3004:
120 case mcp3008:
121 return (adc->rx_buf[0] << 2 | adc->rx_buf[1] >> 6);
122 case mcp3201:
123 return (adc->rx_buf[0] << 7 | adc->rx_buf[1] >> 1);
124 case mcp3202:
125 case mcp3204:
126 case mcp3208:
127 return (adc->rx_buf[0] << 4 | adc->rx_buf[1] >> 4);
128 default:
129 return -EINVAL;
130 }
50} 131}
51 132
52static int mcp320x_read_raw(struct iio_dev *indio_dev, 133static int mcp320x_read_raw(struct iio_dev *indio_dev,
@@ -55,18 +136,17 @@ static int mcp320x_read_raw(struct iio_dev *indio_dev,
55{ 136{
56 struct mcp320x *adc = iio_priv(indio_dev); 137 struct mcp320x *adc = iio_priv(indio_dev);
57 int ret = -EINVAL; 138 int ret = -EINVAL;
139 int device_index = 0;
58 140
59 mutex_lock(&adc->lock); 141 mutex_lock(&adc->lock);
60 142
143 device_index = spi_get_device_id(adc->spi)->driver_data;
144
61 switch (mask) { 145 switch (mask) {
62 case IIO_CHAN_INFO_RAW: 146 case IIO_CHAN_INFO_RAW:
63 if (channel->differential) 147 ret = mcp320x_adc_conversion(adc, channel->address,
64 ret = mcp320x_adc_conversion(adc, 148 channel->differential, device_index);
65 MCP_START_BIT | channel->address); 149
66 else
67 ret = mcp320x_adc_conversion(adc,
68 MCP_START_BIT | MCP_SINGLE_ENDED |
69 channel->address);
70 if (ret < 0) 150 if (ret < 0)
71 goto out; 151 goto out;
72 152
@@ -75,18 +155,15 @@ static int mcp320x_read_raw(struct iio_dev *indio_dev,
75 break; 155 break;
76 156
77 case IIO_CHAN_INFO_SCALE: 157 case IIO_CHAN_INFO_SCALE:
78 /* Digital output code = (4096 * Vin) / Vref */
79 ret = regulator_get_voltage(adc->reg); 158 ret = regulator_get_voltage(adc->reg);
80 if (ret < 0) 159 if (ret < 0)
81 goto out; 160 goto out;
82 161
162 /* convert regulator output voltage to mV */
83 *val = ret / 1000; 163 *val = ret / 1000;
84 *val2 = 12; 164 *val2 = adc->chip_info->resolution;
85 ret = IIO_VAL_FRACTIONAL_LOG2; 165 ret = IIO_VAL_FRACTIONAL_LOG2;
86 break; 166 break;
87
88 default:
89 break;
90 } 167 }
91 168
92out: 169out:
@@ -117,6 +194,16 @@ out:
117 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) \ 194 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) \
118 } 195 }
119 196
197static const struct iio_chan_spec mcp3201_channels[] = {
198 MCP320X_VOLTAGE_CHANNEL_DIFF(0),
199};
200
201static const struct iio_chan_spec mcp3202_channels[] = {
202 MCP320X_VOLTAGE_CHANNEL(0),
203 MCP320X_VOLTAGE_CHANNEL(1),
204 MCP320X_VOLTAGE_CHANNEL_DIFF(0),
205};
206
120static const struct iio_chan_spec mcp3204_channels[] = { 207static const struct iio_chan_spec mcp3204_channels[] = {
121 MCP320X_VOLTAGE_CHANNEL(0), 208 MCP320X_VOLTAGE_CHANNEL(0),
122 MCP320X_VOLTAGE_CHANNEL(1), 209 MCP320X_VOLTAGE_CHANNEL(1),
@@ -146,19 +233,46 @@ static const struct iio_info mcp320x_info = {
146 .driver_module = THIS_MODULE, 233 .driver_module = THIS_MODULE,
147}; 234};
148 235
149struct mcp3208_chip_info { 236static const struct mcp320x_chip_info mcp320x_chip_infos[] = {
150 const struct iio_chan_spec *channels; 237 [mcp3001] = {
151 unsigned int num_channels; 238 .channels = mcp3201_channels,
152}; 239 .num_channels = ARRAY_SIZE(mcp3201_channels),
153 240 .resolution = 10
154static const struct mcp3208_chip_info mcp3208_chip_infos[] = { 241 },
242 [mcp3002] = {
243 .channels = mcp3202_channels,
244 .num_channels = ARRAY_SIZE(mcp3202_channels),
245 .resolution = 10
246 },
247 [mcp3004] = {
248 .channels = mcp3204_channels,
249 .num_channels = ARRAY_SIZE(mcp3204_channels),
250 .resolution = 10
251 },
252 [mcp3008] = {
253 .channels = mcp3208_channels,
254 .num_channels = ARRAY_SIZE(mcp3208_channels),
255 .resolution = 10
256 },
257 [mcp3201] = {
258 .channels = mcp3201_channels,
259 .num_channels = ARRAY_SIZE(mcp3201_channels),
260 .resolution = 12
261 },
262 [mcp3202] = {
263 .channels = mcp3202_channels,
264 .num_channels = ARRAY_SIZE(mcp3202_channels),
265 .resolution = 12
266 },
155 [mcp3204] = { 267 [mcp3204] = {
156 .channels = mcp3204_channels, 268 .channels = mcp3204_channels,
157 .num_channels = ARRAY_SIZE(mcp3204_channels) 269 .num_channels = ARRAY_SIZE(mcp3204_channels),
270 .resolution = 12
158 }, 271 },
159 [mcp3208] = { 272 [mcp3208] = {
160 .channels = mcp3208_channels, 273 .channels = mcp3208_channels,
161 .num_channels = ARRAY_SIZE(mcp3208_channels) 274 .num_channels = ARRAY_SIZE(mcp3208_channels),
275 .resolution = 12
162 }, 276 },
163}; 277};
164 278
@@ -166,7 +280,7 @@ static int mcp320x_probe(struct spi_device *spi)
166{ 280{
167 struct iio_dev *indio_dev; 281 struct iio_dev *indio_dev;
168 struct mcp320x *adc; 282 struct mcp320x *adc;
169 const struct mcp3208_chip_info *chip_info; 283 const struct mcp320x_chip_info *chip_info;
170 int ret; 284 int ret;
171 285
172 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adc)); 286 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adc));
@@ -181,7 +295,7 @@ static int mcp320x_probe(struct spi_device *spi)
181 indio_dev->modes = INDIO_DIRECT_MODE; 295 indio_dev->modes = INDIO_DIRECT_MODE;
182 indio_dev->info = &mcp320x_info; 296 indio_dev->info = &mcp320x_info;
183 297
184 chip_info = &mcp3208_chip_infos[spi_get_device_id(spi)->driver_data]; 298 chip_info = &mcp320x_chip_infos[spi_get_device_id(spi)->driver_data];
185 indio_dev->channels = chip_info->channels; 299 indio_dev->channels = chip_info->channels;
186 indio_dev->num_channels = chip_info->num_channels; 300 indio_dev->num_channels = chip_info->num_channels;
187 301
@@ -226,7 +340,45 @@ static int mcp320x_remove(struct spi_device *spi)
226 return 0; 340 return 0;
227} 341}
228 342
343#if defined(CONFIG_OF)
344static const struct of_device_id mcp320x_dt_ids[] = {
345 {
346 .compatible = "mcp3001",
347 .data = &mcp320x_chip_infos[mcp3001],
348 }, {
349 .compatible = "mcp3002",
350 .data = &mcp320x_chip_infos[mcp3002],
351 }, {
352 .compatible = "mcp3004",
353 .data = &mcp320x_chip_infos[mcp3004],
354 }, {
355 .compatible = "mcp3008",
356 .data = &mcp320x_chip_infos[mcp3008],
357 }, {
358 .compatible = "mcp3201",
359 .data = &mcp320x_chip_infos[mcp3201],
360 }, {
361 .compatible = "mcp3202",
362 .data = &mcp320x_chip_infos[mcp3202],
363 }, {
364 .compatible = "mcp3204",
365 .data = &mcp320x_chip_infos[mcp3204],
366 }, {
367 .compatible = "mcp3208",
368 .data = &mcp320x_chip_infos[mcp3208],
369 }, {
370 }
371};
372MODULE_DEVICE_TABLE(of, mcp320x_dt_ids);
373#endif
374
229static const struct spi_device_id mcp320x_id[] = { 375static const struct spi_device_id mcp320x_id[] = {
376 { "mcp3001", mcp3001 },
377 { "mcp3002", mcp3002 },
378 { "mcp3004", mcp3004 },
379 { "mcp3008", mcp3008 },
380 { "mcp3201", mcp3201 },
381 { "mcp3202", mcp3202 },
230 { "mcp3204", mcp3204 }, 382 { "mcp3204", mcp3204 },
231 { "mcp3208", mcp3208 }, 383 { "mcp3208", mcp3208 },
232 { } 384 { }
@@ -245,5 +397,5 @@ static struct spi_driver mcp320x_driver = {
245module_spi_driver(mcp320x_driver); 397module_spi_driver(mcp320x_driver);
246 398
247MODULE_AUTHOR("Oskar Andero <oskar.andero@gmail.com>"); 399MODULE_AUTHOR("Oskar Andero <oskar.andero@gmail.com>");
248MODULE_DESCRIPTION("Microchip Technology MCP3204/08"); 400MODULE_DESCRIPTION("Microchip Technology MCP3x01/02/04/08");
249MODULE_LICENSE("GPL v2"); 401MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/adc/men_z188_adc.c b/drivers/iio/adc/men_z188_adc.c
index b58d6302521f..d095efe1ba14 100644
--- a/drivers/iio/adc/men_z188_adc.c
+++ b/drivers/iio/adc/men_z188_adc.c
@@ -152,6 +152,7 @@ static void men_z188_remove(struct mcb_device *dev)
152 152
153static const struct mcb_device_id men_z188_ids[] = { 153static const struct mcb_device_id men_z188_ids[] = {
154 { .device = 0xbc }, 154 { .device = 0xbc },
155 { }
155}; 156};
156MODULE_DEVICE_TABLE(mcb, men_z188_ids); 157MODULE_DEVICE_TABLE(mcb, men_z188_ids);
157 158
diff --git a/drivers/iio/adc/qcom-spmi-iadc.c b/drivers/iio/adc/qcom-spmi-iadc.c
new file mode 100644
index 000000000000..b9666f2f5e51
--- /dev/null
+++ b/drivers/iio/adc/qcom-spmi-iadc.c
@@ -0,0 +1,595 @@
1/*
2 * Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 and
6 * only version 2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 */
13
14#include <linux/bitops.h>
15#include <linux/completion.h>
16#include <linux/delay.h>
17#include <linux/err.h>
18#include <linux/iio/iio.h>
19#include <linux/interrupt.h>
20#include <linux/kernel.h>
21#include <linux/mutex.h>
22#include <linux/module.h>
23#include <linux/of.h>
24#include <linux/of_device.h>
25#include <linux/platform_device.h>
26#include <linux/regmap.h>
27#include <linux/slab.h>
28
29/* IADC register and bit definition */
30#define IADC_REVISION2 0x1
31#define IADC_REVISION2_SUPPORTED_IADC 1
32
33#define IADC_PERPH_TYPE 0x4
34#define IADC_PERPH_TYPE_ADC 8
35
36#define IADC_PERPH_SUBTYPE 0x5
37#define IADC_PERPH_SUBTYPE_IADC 3
38
39#define IADC_STATUS1 0x8
40#define IADC_STATUS1_OP_MODE 4
41#define IADC_STATUS1_REQ_STS BIT(1)
42#define IADC_STATUS1_EOC BIT(0)
43#define IADC_STATUS1_REQ_STS_EOC_MASK 0x3
44
45#define IADC_MODE_CTL 0x40
46#define IADC_OP_MODE_SHIFT 3
47#define IADC_OP_MODE_NORMAL 0
48#define IADC_TRIM_EN BIT(0)
49
50#define IADC_EN_CTL1 0x46
51#define IADC_EN_CTL1_SET BIT(7)
52
53#define IADC_CH_SEL_CTL 0x48
54
55#define IADC_DIG_PARAM 0x50
56#define IADC_DIG_DEC_RATIO_SEL_SHIFT 2
57
58#define IADC_HW_SETTLE_DELAY 0x51
59
60#define IADC_CONV_REQ 0x52
61#define IADC_CONV_REQ_SET BIT(7)
62
63#define IADC_FAST_AVG_CTL 0x5a
64#define IADC_FAST_AVG_EN 0x5b
65#define IADC_FAST_AVG_EN_SET BIT(7)
66
67#define IADC_PERH_RESET_CTL3 0xda
68#define IADC_FOLLOW_WARM_RB BIT(2)
69
70#define IADC_DATA 0x60 /* 16 bits */
71
72#define IADC_SEC_ACCESS 0xd0
73#define IADC_SEC_ACCESS_DATA 0xa5
74
75#define IADC_NOMINAL_RSENSE 0xf4
76#define IADC_NOMINAL_RSENSE_SIGN_MASK BIT(7)
77
78#define IADC_REF_GAIN_MICRO_VOLTS 17857
79
80#define IADC_INT_RSENSE_DEVIATION 15625 /* nano Ohms per bit */
81
82#define IADC_INT_RSENSE_IDEAL_VALUE 10000 /* micro Ohms */
83#define IADC_INT_RSENSE_DEFAULT_VALUE 7800 /* micro Ohms */
84#define IADC_INT_RSENSE_DEFAULT_GF 9000 /* micro Ohms */
85#define IADC_INT_RSENSE_DEFAULT_SMIC 9700 /* micro Ohms */
86
87#define IADC_CONV_TIME_MIN_US 2000
88#define IADC_CONV_TIME_MAX_US 2100
89
90#define IADC_DEF_PRESCALING 0 /* 1:1 */
91#define IADC_DEF_DECIMATION 0 /* 512 */
92#define IADC_DEF_HW_SETTLE_TIME 0 /* 0 us */
93#define IADC_DEF_AVG_SAMPLES 0 /* 1 sample */
94
95/* IADC channel list */
96#define IADC_INT_RSENSE 0
97#define IADC_EXT_RSENSE 1
98#define IADC_GAIN_17P857MV 3
99#define IADC_EXT_OFFSET_CSP_CSN 5
100#define IADC_INT_OFFSET_CSP2_CSN2 6
101
102/**
103 * struct iadc_chip - IADC Current ADC device structure.
104 * @regmap: regmap for register read/write.
105 * @dev: This device pointer.
106 * @base: base offset for the ADC peripheral.
107 * @rsense: Values of the internal and external sense resister in micro Ohms.
108 * @poll_eoc: Poll for end of conversion instead of waiting for IRQ.
109 * @offset: Raw offset values for the internal and external channels.
110 * @gain: Raw gain of the channels.
111 * @lock: ADC lock for access to the peripheral.
112 * @complete: ADC notification after end of conversion interrupt is received.
113 */
114struct iadc_chip {
115 struct regmap *regmap;
116 struct device *dev;
117 u16 base;
118 bool poll_eoc;
119 u32 rsense[2];
120 u16 offset[2];
121 u16 gain;
122 struct mutex lock;
123 struct completion complete;
124};
125
126static int iadc_read(struct iadc_chip *iadc, u16 offset, u8 *data)
127{
128 unsigned int val;
129 int ret;
130
131 ret = regmap_read(iadc->regmap, iadc->base + offset, &val);
132 if (ret < 0)
133 return ret;
134
135 *data = val;
136 return 0;
137}
138
139static int iadc_write(struct iadc_chip *iadc, u16 offset, u8 data)
140{
141 return regmap_write(iadc->regmap, iadc->base + offset, data);
142}
143
144static int iadc_reset(struct iadc_chip *iadc)
145{
146 u8 data;
147 int ret;
148
149 ret = iadc_write(iadc, IADC_SEC_ACCESS, IADC_SEC_ACCESS_DATA);
150 if (ret < 0)
151 return ret;
152
153 ret = iadc_read(iadc, IADC_PERH_RESET_CTL3, &data);
154 if (ret < 0)
155 return ret;
156
157 ret = iadc_write(iadc, IADC_SEC_ACCESS, IADC_SEC_ACCESS_DATA);
158 if (ret < 0)
159 return ret;
160
161 data |= IADC_FOLLOW_WARM_RB;
162
163 return iadc_write(iadc, IADC_PERH_RESET_CTL3, data);
164}
165
166static int iadc_set_state(struct iadc_chip *iadc, bool state)
167{
168 return iadc_write(iadc, IADC_EN_CTL1, state ? IADC_EN_CTL1_SET : 0);
169}
170
171static void iadc_status_show(struct iadc_chip *iadc)
172{
173 u8 mode, sta1, chan, dig, en, req;
174 int ret;
175
176 ret = iadc_read(iadc, IADC_MODE_CTL, &mode);
177 if (ret < 0)
178 return;
179
180 ret = iadc_read(iadc, IADC_DIG_PARAM, &dig);
181 if (ret < 0)
182 return;
183
184 ret = iadc_read(iadc, IADC_CH_SEL_CTL, &chan);
185 if (ret < 0)
186 return;
187
188 ret = iadc_read(iadc, IADC_CONV_REQ, &req);
189 if (ret < 0)
190 return;
191
192 ret = iadc_read(iadc, IADC_STATUS1, &sta1);
193 if (ret < 0)
194 return;
195
196 ret = iadc_read(iadc, IADC_EN_CTL1, &en);
197 if (ret < 0)
198 return;
199
200 dev_err(iadc->dev,
201 "mode:%02x en:%02x chan:%02x dig:%02x req:%02x sta1:%02x\n",
202 mode, en, chan, dig, req, sta1);
203}
204
205static int iadc_configure(struct iadc_chip *iadc, int channel)
206{
207 u8 decim, mode;
208 int ret;
209
210 /* Mode selection */
211 mode = (IADC_OP_MODE_NORMAL << IADC_OP_MODE_SHIFT) | IADC_TRIM_EN;
212 ret = iadc_write(iadc, IADC_MODE_CTL, mode);
213 if (ret < 0)
214 return ret;
215
216 /* Channel selection */
217 ret = iadc_write(iadc, IADC_CH_SEL_CTL, channel);
218 if (ret < 0)
219 return ret;
220
221 /* Digital parameter setup */
222 decim = IADC_DEF_DECIMATION << IADC_DIG_DEC_RATIO_SEL_SHIFT;
223 ret = iadc_write(iadc, IADC_DIG_PARAM, decim);
224 if (ret < 0)
225 return ret;
226
227 /* HW settle time delay */
228 ret = iadc_write(iadc, IADC_HW_SETTLE_DELAY, IADC_DEF_HW_SETTLE_TIME);
229 if (ret < 0)
230 return ret;
231
232 ret = iadc_write(iadc, IADC_FAST_AVG_CTL, IADC_DEF_AVG_SAMPLES);
233 if (ret < 0)
234 return ret;
235
236 if (IADC_DEF_AVG_SAMPLES)
237 ret = iadc_write(iadc, IADC_FAST_AVG_EN, IADC_FAST_AVG_EN_SET);
238 else
239 ret = iadc_write(iadc, IADC_FAST_AVG_EN, 0);
240
241 if (ret < 0)
242 return ret;
243
244 if (!iadc->poll_eoc)
245 reinit_completion(&iadc->complete);
246
247 ret = iadc_set_state(iadc, true);
248 if (ret < 0)
249 return ret;
250
251 /* Request conversion */
252 return iadc_write(iadc, IADC_CONV_REQ, IADC_CONV_REQ_SET);
253}
254
255static int iadc_poll_wait_eoc(struct iadc_chip *iadc, unsigned int interval_us)
256{
257 unsigned int count, retry;
258 int ret;
259 u8 sta1;
260
261 retry = interval_us / IADC_CONV_TIME_MIN_US;
262
263 for (count = 0; count < retry; count++) {
264 ret = iadc_read(iadc, IADC_STATUS1, &sta1);
265 if (ret < 0)
266 return ret;
267
268 sta1 &= IADC_STATUS1_REQ_STS_EOC_MASK;
269 if (sta1 == IADC_STATUS1_EOC)
270 return 0;
271
272 usleep_range(IADC_CONV_TIME_MIN_US, IADC_CONV_TIME_MAX_US);
273 }
274
275 iadc_status_show(iadc);
276
277 return -ETIMEDOUT;
278}
279
280static int iadc_read_result(struct iadc_chip *iadc, u16 *data)
281{
282 return regmap_bulk_read(iadc->regmap, iadc->base + IADC_DATA, data, 2);
283}
284
285static int iadc_do_conversion(struct iadc_chip *iadc, int chan, u16 *data)
286{
287 unsigned int wait;
288 int ret;
289
290 ret = iadc_configure(iadc, chan);
291 if (ret < 0)
292 goto exit;
293
294 wait = BIT(IADC_DEF_AVG_SAMPLES) * IADC_CONV_TIME_MIN_US * 2;
295
296 if (iadc->poll_eoc) {
297 ret = iadc_poll_wait_eoc(iadc, wait);
298 } else {
299 ret = wait_for_completion_timeout(&iadc->complete, wait);
300 if (!ret)
301 ret = -ETIMEDOUT;
302 else
303 /* double check conversion status */
304 ret = iadc_poll_wait_eoc(iadc, IADC_CONV_TIME_MIN_US);
305 }
306
307 if (!ret)
308 ret = iadc_read_result(iadc, data);
309exit:
310 iadc_set_state(iadc, false);
311 if (ret < 0)
312 dev_err(iadc->dev, "conversion failed\n");
313
314 return ret;
315}
316
317static int iadc_read_raw(struct iio_dev *indio_dev,
318 struct iio_chan_spec const *chan,
319 int *val, int *val2, long mask)
320{
321 struct iadc_chip *iadc = iio_priv(indio_dev);
322 s32 isense_ua, vsense_uv;
323 u16 adc_raw, vsense_raw;
324 int ret;
325
326 switch (mask) {
327 case IIO_CHAN_INFO_RAW:
328 mutex_lock(&iadc->lock);
329 ret = iadc_do_conversion(iadc, chan->channel, &adc_raw);
330 mutex_unlock(&iadc->lock);
331 if (ret < 0)
332 return ret;
333
334 vsense_raw = adc_raw - iadc->offset[chan->channel];
335
336 vsense_uv = vsense_raw * IADC_REF_GAIN_MICRO_VOLTS;
337 vsense_uv /= (s32)iadc->gain - iadc->offset[chan->channel];
338
339 isense_ua = vsense_uv / iadc->rsense[chan->channel];
340
341 dev_dbg(iadc->dev, "off %d gain %d adc %d %duV I %duA\n",
342 iadc->offset[chan->channel], iadc->gain,
343 adc_raw, vsense_uv, isense_ua);
344
345 *val = isense_ua;
346 return IIO_VAL_INT;
347 case IIO_CHAN_INFO_SCALE:
348 *val = 0;
349 *val2 = 1000;
350 return IIO_VAL_INT_PLUS_MICRO;
351 }
352
353 return -EINVAL;
354}
355
356static const struct iio_info iadc_info = {
357 .read_raw = iadc_read_raw,
358 .driver_module = THIS_MODULE,
359};
360
361static irqreturn_t iadc_isr(int irq, void *dev_id)
362{
363 struct iadc_chip *iadc = dev_id;
364
365 complete(&iadc->complete);
366
367 return IRQ_HANDLED;
368}
369
370static int iadc_update_offset(struct iadc_chip *iadc)
371{
372 int ret;
373
374 ret = iadc_do_conversion(iadc, IADC_GAIN_17P857MV, &iadc->gain);
375 if (ret < 0)
376 return ret;
377
378 ret = iadc_do_conversion(iadc, IADC_INT_OFFSET_CSP2_CSN2,
379 &iadc->offset[IADC_INT_RSENSE]);
380 if (ret < 0)
381 return ret;
382
383 if (iadc->gain == iadc->offset[IADC_INT_RSENSE]) {
384 dev_err(iadc->dev, "error: internal offset == gain %d\n",
385 iadc->gain);
386 return -EINVAL;
387 }
388
389 ret = iadc_do_conversion(iadc, IADC_EXT_OFFSET_CSP_CSN,
390 &iadc->offset[IADC_EXT_RSENSE]);
391 if (ret < 0)
392 return ret;
393
394 if (iadc->gain == iadc->offset[IADC_EXT_RSENSE]) {
395 dev_err(iadc->dev, "error: external offset == gain %d\n",
396 iadc->gain);
397 return -EINVAL;
398 }
399
400 return 0;
401}
402
403static int iadc_version_check(struct iadc_chip *iadc)
404{
405 u8 val;
406 int ret;
407
408 ret = iadc_read(iadc, IADC_PERPH_TYPE, &val);
409 if (ret < 0)
410 return ret;
411
412 if (val < IADC_PERPH_TYPE_ADC) {
413 dev_err(iadc->dev, "%d is not ADC\n", val);
414 return -EINVAL;
415 }
416
417 ret = iadc_read(iadc, IADC_PERPH_SUBTYPE, &val);
418 if (ret < 0)
419 return ret;
420
421 if (val < IADC_PERPH_SUBTYPE_IADC) {
422 dev_err(iadc->dev, "%d is not IADC\n", val);
423 return -EINVAL;
424 }
425
426 ret = iadc_read(iadc, IADC_REVISION2, &val);
427 if (ret < 0)
428 return ret;
429
430 if (val < IADC_REVISION2_SUPPORTED_IADC) {
431 dev_err(iadc->dev, "revision %d not supported\n", val);
432 return -EINVAL;
433 }
434
435 return 0;
436}
437
438static int iadc_rsense_read(struct iadc_chip *iadc, struct device_node *node)
439{
440 int ret, sign, int_sense;
441 u8 deviation;
442
443 ret = of_property_read_u32(node, "qcom,external-resistor-micro-ohms",
444 &iadc->rsense[IADC_EXT_RSENSE]);
445 if (ret < 0)
446 iadc->rsense[IADC_EXT_RSENSE] = IADC_INT_RSENSE_IDEAL_VALUE;
447
448 if (!iadc->rsense[IADC_EXT_RSENSE]) {
449 dev_err(iadc->dev, "external resistor can't be zero Ohms");
450 return -EINVAL;
451 }
452
453 ret = iadc_read(iadc, IADC_NOMINAL_RSENSE, &deviation);
454 if (ret < 0)
455 return ret;
456
457 /*
458 * Deviation value stored is an offset from 10 mili Ohms, bit 7 is
459 * the sign, the remaining bits have an LSB of 15625 nano Ohms.
460 */
461 sign = (deviation & IADC_NOMINAL_RSENSE_SIGN_MASK) ? -1 : 1;
462
463 deviation &= ~IADC_NOMINAL_RSENSE_SIGN_MASK;
464
465 /* Scale it to nono Ohms */
466 int_sense = IADC_INT_RSENSE_IDEAL_VALUE * 1000;
467 int_sense += sign * deviation * IADC_INT_RSENSE_DEVIATION;
468 int_sense /= 1000; /* micro Ohms */
469
470 iadc->rsense[IADC_INT_RSENSE] = int_sense;
471 return 0;
472}
473
474static const struct iio_chan_spec iadc_channels[] = {
475 {
476 .type = IIO_CURRENT,
477 .datasheet_name = "INTERNAL_RSENSE",
478 .channel = 0,
479 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
480 BIT(IIO_CHAN_INFO_SCALE),
481 .indexed = 1,
482 },
483 {
484 .type = IIO_CURRENT,
485 .datasheet_name = "EXTERNAL_RSENSE",
486 .channel = 1,
487 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
488 BIT(IIO_CHAN_INFO_SCALE),
489 .indexed = 1,
490 },
491};
492
493static int iadc_probe(struct platform_device *pdev)
494{
495 struct device_node *node = pdev->dev.of_node;
496 struct device *dev = &pdev->dev;
497 struct iio_dev *indio_dev;
498 struct iadc_chip *iadc;
499 int ret, irq_eoc;
500 u32 res;
501
502 indio_dev = devm_iio_device_alloc(dev, sizeof(*iadc));
503 if (!indio_dev)
504 return -ENOMEM;
505
506 iadc = iio_priv(indio_dev);
507 iadc->dev = dev;
508
509 iadc->regmap = dev_get_regmap(dev->parent, NULL);
510 if (!iadc->regmap)
511 return -ENODEV;
512
513 init_completion(&iadc->complete);
514 mutex_init(&iadc->lock);
515
516 ret = of_property_read_u32(node, "reg", &res);
517 if (ret < 0)
518 return -ENODEV;
519
520 iadc->base = res;
521
522 ret = iadc_version_check(iadc);
523 if (ret < 0)
524 return -ENODEV;
525
526 ret = iadc_rsense_read(iadc, node);
527 if (ret < 0)
528 return -ENODEV;
529
530 dev_dbg(iadc->dev, "sense resistors %d and %d micro Ohm\n",
531 iadc->rsense[IADC_INT_RSENSE],
532 iadc->rsense[IADC_EXT_RSENSE]);
533
534 irq_eoc = platform_get_irq(pdev, 0);
535 if (irq_eoc == -EPROBE_DEFER)
536 return irq_eoc;
537
538 if (irq_eoc < 0)
539 iadc->poll_eoc = true;
540
541 ret = iadc_reset(iadc);
542 if (ret < 0) {
543 dev_err(dev, "reset failed\n");
544 return ret;
545 }
546
547 if (!iadc->poll_eoc) {
548 ret = devm_request_irq(dev, irq_eoc, iadc_isr, 0,
549 "spmi-iadc", iadc);
550 if (!ret)
551 enable_irq_wake(irq_eoc);
552 else
553 return ret;
554 } else {
555 device_init_wakeup(iadc->dev, 1);
556 }
557
558 ret = iadc_update_offset(iadc);
559 if (ret < 0) {
560 dev_err(dev, "failed offset calibration\n");
561 return ret;
562 }
563
564 indio_dev->dev.parent = dev;
565 indio_dev->dev.of_node = node;
566 indio_dev->name = pdev->name;
567 indio_dev->modes = INDIO_DIRECT_MODE;
568 indio_dev->info = &iadc_info;
569 indio_dev->channels = iadc_channels;
570 indio_dev->num_channels = ARRAY_SIZE(iadc_channels);
571
572 return devm_iio_device_register(dev, indio_dev);
573}
574
575static const struct of_device_id iadc_match_table[] = {
576 { .compatible = "qcom,spmi-iadc" },
577 { }
578};
579
580MODULE_DEVICE_TABLE(of, iadc_match_table);
581
582static struct platform_driver iadc_driver = {
583 .driver = {
584 .name = "qcom-spmi-iadc",
585 .of_match_table = iadc_match_table,
586 },
587 .probe = iadc_probe,
588};
589
590module_platform_driver(iadc_driver);
591
592MODULE_ALIAS("platform:qcom-spmi-iadc");
593MODULE_DESCRIPTION("Qualcomm SPMI PMIC current ADC driver");
594MODULE_LICENSE("GPL v2");
595MODULE_AUTHOR("Ivan T. Ivanov <iivanov@mm-sol.com>");
diff --git a/drivers/iio/adc/rockchip_saradc.c b/drivers/iio/adc/rockchip_saradc.c
new file mode 100644
index 000000000000..8d4e019ea4ca
--- /dev/null
+++ b/drivers/iio/adc/rockchip_saradc.c
@@ -0,0 +1,351 @@
1/*
2 * Rockchip Successive Approximation Register (SAR) A/D Converter
3 * Copyright (C) 2014 ROCKCHIP, Inc.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 */
15
16#include <linux/module.h>
17#include <linux/platform_device.h>
18#include <linux/interrupt.h>
19#include <linux/io.h>
20#include <linux/of.h>
21#include <linux/of_device.h>
22#include <linux/clk.h>
23#include <linux/completion.h>
24#include <linux/regulator/consumer.h>
25#include <linux/iio/iio.h>
26
27#define SARADC_DATA 0x00
28
29#define SARADC_STAS 0x04
30#define SARADC_STAS_BUSY BIT(0)
31
32#define SARADC_CTRL 0x08
33#define SARADC_CTRL_IRQ_STATUS BIT(6)
34#define SARADC_CTRL_IRQ_ENABLE BIT(5)
35#define SARADC_CTRL_POWER_CTRL BIT(3)
36#define SARADC_CTRL_CHN_MASK 0x7
37
38#define SARADC_DLY_PU_SOC 0x0c
39#define SARADC_DLY_PU_SOC_MASK 0x3f
40
41#define SARADC_TIMEOUT msecs_to_jiffies(100)
42
43struct rockchip_saradc_data {
44 int num_bits;
45 const struct iio_chan_spec *channels;
46 int num_channels;
47 unsigned long clk_rate;
48};
49
50struct rockchip_saradc {
51 void __iomem *regs;
52 struct clk *pclk;
53 struct clk *clk;
54 struct completion completion;
55 struct regulator *vref;
56 const struct rockchip_saradc_data *data;
57 u16 last_val;
58};
59
60static int rockchip_saradc_read_raw(struct iio_dev *indio_dev,
61 struct iio_chan_spec const *chan,
62 int *val, int *val2, long mask)
63{
64 struct rockchip_saradc *info = iio_priv(indio_dev);
65 int ret;
66
67 switch (mask) {
68 case IIO_CHAN_INFO_RAW:
69 mutex_lock(&indio_dev->mlock);
70
71 reinit_completion(&info->completion);
72
73 /* 8 clock periods as delay between power up and start cmd */
74 writel_relaxed(8, info->regs + SARADC_DLY_PU_SOC);
75
76 /* Select the channel to be used and trigger conversion */
77 writel(SARADC_CTRL_POWER_CTRL
78 | (chan->channel & SARADC_CTRL_CHN_MASK)
79 | SARADC_CTRL_IRQ_ENABLE,
80 info->regs + SARADC_CTRL);
81
82 if (!wait_for_completion_timeout(&info->completion,
83 SARADC_TIMEOUT)) {
84 writel_relaxed(0, info->regs + SARADC_CTRL);
85 mutex_unlock(&indio_dev->mlock);
86 return -ETIMEDOUT;
87 }
88
89 *val = info->last_val;
90 mutex_unlock(&indio_dev->mlock);
91 return IIO_VAL_INT;
92 case IIO_CHAN_INFO_SCALE:
93 ret = regulator_get_voltage(info->vref);
94 if (ret < 0) {
95 dev_err(&indio_dev->dev, "failed to get voltage\n");
96 return ret;
97 }
98
99 *val = ret / 1000;
100 *val2 = info->data->num_bits;
101 return IIO_VAL_FRACTIONAL_LOG2;
102 default:
103 return -EINVAL;
104 }
105}
106
107static irqreturn_t rockchip_saradc_isr(int irq, void *dev_id)
108{
109 struct rockchip_saradc *info = (struct rockchip_saradc *)dev_id;
110
111 /* Read value */
112 info->last_val = readl_relaxed(info->regs + SARADC_DATA);
113 info->last_val &= GENMASK(info->data->num_bits - 1, 0);
114
115 /* Clear irq & power down adc */
116 writel_relaxed(0, info->regs + SARADC_CTRL);
117
118 complete(&info->completion);
119
120 return IRQ_HANDLED;
121}
122
123static const struct iio_info rockchip_saradc_iio_info = {
124 .read_raw = rockchip_saradc_read_raw,
125 .driver_module = THIS_MODULE,
126};
127
128#define ADC_CHANNEL(_index, _id) { \
129 .type = IIO_VOLTAGE, \
130 .indexed = 1, \
131 .channel = _index, \
132 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
133 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
134 .datasheet_name = _id, \
135}
136
137static const struct iio_chan_spec rockchip_saradc_iio_channels[] = {
138 ADC_CHANNEL(0, "adc0"),
139 ADC_CHANNEL(1, "adc1"),
140 ADC_CHANNEL(2, "adc2"),
141};
142
143static const struct rockchip_saradc_data saradc_data = {
144 .num_bits = 10,
145 .channels = rockchip_saradc_iio_channels,
146 .num_channels = ARRAY_SIZE(rockchip_saradc_iio_channels),
147 .clk_rate = 1000000,
148};
149
150static const struct iio_chan_spec rockchip_rk3066_tsadc_iio_channels[] = {
151 ADC_CHANNEL(0, "adc0"),
152 ADC_CHANNEL(1, "adc1"),
153};
154
155static const struct rockchip_saradc_data rk3066_tsadc_data = {
156 .num_bits = 12,
157 .channels = rockchip_rk3066_tsadc_iio_channels,
158 .num_channels = ARRAY_SIZE(rockchip_rk3066_tsadc_iio_channels),
159 .clk_rate = 50000,
160};
161
162static const struct of_device_id rockchip_saradc_match[] = {
163 {
164 .compatible = "rockchip,saradc",
165 .data = &saradc_data,
166 }, {
167 .compatible = "rockchip,rk3066-tsadc",
168 .data = &rk3066_tsadc_data,
169 },
170 {},
171};
172MODULE_DEVICE_TABLE(of, rockchip_saradc_match);
173
174static int rockchip_saradc_probe(struct platform_device *pdev)
175{
176 struct rockchip_saradc *info = NULL;
177 struct device_node *np = pdev->dev.of_node;
178 struct iio_dev *indio_dev = NULL;
179 struct resource *mem;
180 const struct of_device_id *match;
181 int ret;
182 int irq;
183
184 if (!np)
185 return -ENODEV;
186
187 indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*info));
188 if (!indio_dev) {
189 dev_err(&pdev->dev, "failed allocating iio device\n");
190 return -ENOMEM;
191 }
192 info = iio_priv(indio_dev);
193
194 match = of_match_device(rockchip_saradc_match, &pdev->dev);
195 info->data = match->data;
196
197 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
198 info->regs = devm_ioremap_resource(&pdev->dev, mem);
199 if (IS_ERR(info->regs))
200 return PTR_ERR(info->regs);
201
202 init_completion(&info->completion);
203
204 irq = platform_get_irq(pdev, 0);
205 if (irq < 0) {
206 dev_err(&pdev->dev, "no irq resource?\n");
207 return irq;
208 }
209
210 ret = devm_request_irq(&pdev->dev, irq, rockchip_saradc_isr,
211 0, dev_name(&pdev->dev), info);
212 if (ret < 0) {
213 dev_err(&pdev->dev, "failed requesting irq %d\n", irq);
214 return ret;
215 }
216
217 info->pclk = devm_clk_get(&pdev->dev, "apb_pclk");
218 if (IS_ERR(info->pclk)) {
219 dev_err(&pdev->dev, "failed to get pclk\n");
220 return PTR_ERR(info->pclk);
221 }
222
223 info->clk = devm_clk_get(&pdev->dev, "saradc");
224 if (IS_ERR(info->clk)) {
225 dev_err(&pdev->dev, "failed to get adc clock\n");
226 return PTR_ERR(info->clk);
227 }
228
229 info->vref = devm_regulator_get(&pdev->dev, "vref");
230 if (IS_ERR(info->vref)) {
231 dev_err(&pdev->dev, "failed to get regulator, %ld\n",
232 PTR_ERR(info->vref));
233 return PTR_ERR(info->vref);
234 }
235
236 /*
237 * Use a default value for the converter clock.
238 * This may become user-configurable in the future.
239 */
240 ret = clk_set_rate(info->clk, info->data->clk_rate);
241 if (ret < 0) {
242 dev_err(&pdev->dev, "failed to set adc clk rate, %d\n", ret);
243 return ret;
244 }
245
246 ret = regulator_enable(info->vref);
247 if (ret < 0) {
248 dev_err(&pdev->dev, "failed to enable vref regulator\n");
249 return ret;
250 }
251
252 ret = clk_prepare_enable(info->pclk);
253 if (ret < 0) {
254 dev_err(&pdev->dev, "failed to enable pclk\n");
255 goto err_reg_voltage;
256 }
257
258 ret = clk_prepare_enable(info->clk);
259 if (ret < 0) {
260 dev_err(&pdev->dev, "failed to enable converter clock\n");
261 goto err_pclk;
262 }
263
264 platform_set_drvdata(pdev, indio_dev);
265
266 indio_dev->name = dev_name(&pdev->dev);
267 indio_dev->dev.parent = &pdev->dev;
268 indio_dev->dev.of_node = pdev->dev.of_node;
269 indio_dev->info = &rockchip_saradc_iio_info;
270 indio_dev->modes = INDIO_DIRECT_MODE;
271
272 indio_dev->channels = info->data->channels;
273 indio_dev->num_channels = info->data->num_channels;
274
275 ret = iio_device_register(indio_dev);
276 if (ret)
277 goto err_clk;
278
279 return 0;
280
281err_clk:
282 clk_disable_unprepare(info->clk);
283err_pclk:
284 clk_disable_unprepare(info->pclk);
285err_reg_voltage:
286 regulator_disable(info->vref);
287 return ret;
288}
289
290static int rockchip_saradc_remove(struct platform_device *pdev)
291{
292 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
293 struct rockchip_saradc *info = iio_priv(indio_dev);
294
295 iio_device_unregister(indio_dev);
296 clk_disable_unprepare(info->clk);
297 clk_disable_unprepare(info->pclk);
298 regulator_disable(info->vref);
299
300 return 0;
301}
302
303#ifdef CONFIG_PM_SLEEP
304static int rockchip_saradc_suspend(struct device *dev)
305{
306 struct iio_dev *indio_dev = dev_get_drvdata(dev);
307 struct rockchip_saradc *info = iio_priv(indio_dev);
308
309 clk_disable_unprepare(info->clk);
310 clk_disable_unprepare(info->pclk);
311 regulator_disable(info->vref);
312
313 return 0;
314}
315
316static int rockchip_saradc_resume(struct device *dev)
317{
318 struct iio_dev *indio_dev = dev_get_drvdata(dev);
319 struct rockchip_saradc *info = iio_priv(indio_dev);
320 int ret;
321
322 ret = regulator_enable(info->vref);
323 if (ret)
324 return ret;
325
326 ret = clk_prepare_enable(info->pclk);
327 if (ret)
328 return ret;
329
330 ret = clk_prepare_enable(info->clk);
331 if (ret)
332 return ret;
333
334 return ret;
335}
336#endif
337
338static SIMPLE_DEV_PM_OPS(rockchip_saradc_pm_ops,
339 rockchip_saradc_suspend, rockchip_saradc_resume);
340
341static struct platform_driver rockchip_saradc_driver = {
342 .probe = rockchip_saradc_probe,
343 .remove = rockchip_saradc_remove,
344 .driver = {
345 .name = "rockchip-saradc",
346 .of_match_table = rockchip_saradc_match,
347 .pm = &rockchip_saradc_pm_ops,
348 },
349};
350
351module_platform_driver(rockchip_saradc_driver);
diff --git a/drivers/iio/adc/ti-adc128s052.c b/drivers/iio/adc/ti-adc128s052.c
new file mode 100644
index 000000000000..655cb564ec54
--- /dev/null
+++ b/drivers/iio/adc/ti-adc128s052.c
@@ -0,0 +1,179 @@
1/*
2 * Copyright (C) 2014 Angelo Compagnucci <angelo.compagnucci@gmail.com>
3 *
4 * Driver for Texas Instruments' ADC128S052 ADC chip.
5 * Datasheet can be found here:
6 * http://www.ti.com/lit/ds/symlink/adc128s052.pdf
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13#include <linux/err.h>
14#include <linux/spi/spi.h>
15#include <linux/module.h>
16#include <linux/iio/iio.h>
17#include <linux/regulator/consumer.h>
18
19struct adc128 {
20 struct spi_device *spi;
21
22 struct regulator *reg;
23 struct mutex lock;
24
25 u8 buffer[2] ____cacheline_aligned;
26};
27
28static int adc128_adc_conversion(struct adc128 *adc, u8 channel)
29{
30 int ret;
31
32 mutex_lock(&adc->lock);
33
34 adc->buffer[0] = channel << 3;
35 adc->buffer[1] = 0;
36
37 ret = spi_write(adc->spi, &adc->buffer, 2);
38 if (ret < 0) {
39 mutex_unlock(&adc->lock);
40 return ret;
41 }
42
43 ret = spi_read(adc->spi, &adc->buffer, 2);
44
45 mutex_unlock(&adc->lock);
46
47 if (ret < 0)
48 return ret;
49
50 return ((adc->buffer[0] << 8 | adc->buffer[1]) & 0xFFF);
51}
52
53static int adc128_read_raw(struct iio_dev *indio_dev,
54 struct iio_chan_spec const *channel, int *val,
55 int *val2, long mask)
56{
57 struct adc128 *adc = iio_priv(indio_dev);
58 int ret;
59
60 switch (mask) {
61 case IIO_CHAN_INFO_RAW:
62
63 ret = adc128_adc_conversion(adc, channel->channel);
64 if (ret < 0)
65 return ret;
66
67 *val = ret;
68 return IIO_VAL_INT;
69
70 case IIO_CHAN_INFO_SCALE:
71
72 ret = regulator_get_voltage(adc->reg);
73 if (ret < 0)
74 return ret;
75
76 *val = ret / 1000;
77 *val2 = 12;
78 return IIO_VAL_FRACTIONAL_LOG2;
79
80 default:
81 return -EINVAL;
82 }
83
84}
85
86#define ADC128_VOLTAGE_CHANNEL(num) \
87 { \
88 .type = IIO_VOLTAGE, \
89 .indexed = 1, \
90 .channel = (num), \
91 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
92 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) \
93 }
94
95static const struct iio_chan_spec adc128_channels[] = {
96 ADC128_VOLTAGE_CHANNEL(0),
97 ADC128_VOLTAGE_CHANNEL(1),
98 ADC128_VOLTAGE_CHANNEL(2),
99 ADC128_VOLTAGE_CHANNEL(3),
100 ADC128_VOLTAGE_CHANNEL(4),
101 ADC128_VOLTAGE_CHANNEL(5),
102 ADC128_VOLTAGE_CHANNEL(6),
103 ADC128_VOLTAGE_CHANNEL(7),
104};
105
106static const struct iio_info adc128_info = {
107 .read_raw = adc128_read_raw,
108 .driver_module = THIS_MODULE,
109};
110
111static int adc128_probe(struct spi_device *spi)
112{
113 struct iio_dev *indio_dev;
114 struct adc128 *adc;
115 int ret;
116
117 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adc));
118 if (!indio_dev)
119 return -ENOMEM;
120
121 adc = iio_priv(indio_dev);
122 adc->spi = spi;
123
124 spi_set_drvdata(spi, indio_dev);
125
126 indio_dev->dev.parent = &spi->dev;
127 indio_dev->name = spi_get_device_id(spi)->name;
128 indio_dev->modes = INDIO_DIRECT_MODE;
129 indio_dev->info = &adc128_info;
130
131 indio_dev->channels = adc128_channels;
132 indio_dev->num_channels = ARRAY_SIZE(adc128_channels);
133
134 adc->reg = devm_regulator_get(&spi->dev, "vref");
135 if (IS_ERR(adc->reg))
136 return PTR_ERR(adc->reg);
137
138 ret = regulator_enable(adc->reg);
139 if (ret < 0)
140 return ret;
141
142 mutex_init(&adc->lock);
143
144 ret = iio_device_register(indio_dev);
145
146 return ret;
147}
148
149static int adc128_remove(struct spi_device *spi)
150{
151 struct iio_dev *indio_dev = spi_get_drvdata(spi);
152 struct adc128 *adc = iio_priv(indio_dev);
153
154 iio_device_unregister(indio_dev);
155 regulator_disable(adc->reg);
156
157 return 0;
158}
159
160static const struct spi_device_id adc128_id[] = {
161 { "adc128s052", 0},
162 { }
163};
164MODULE_DEVICE_TABLE(spi, adc128_id);
165
166static struct spi_driver adc128_driver = {
167 .driver = {
168 .name = "adc128s052",
169 .owner = THIS_MODULE,
170 },
171 .probe = adc128_probe,
172 .remove = adc128_remove,
173 .id_table = adc128_id,
174};
175module_spi_driver(adc128_driver);
176
177MODULE_AUTHOR("Angelo Compagnucci <angelo.compagnucci@gmail.com>");
178MODULE_DESCRIPTION("Texas Instruments ADC128S052");
179MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/adc/ti_am335x_adc.c b/drivers/iio/adc/ti_am335x_adc.c
index d5dc4c6ce86c..adba23246474 100644
--- a/drivers/iio/adc/ti_am335x_adc.c
+++ b/drivers/iio/adc/ti_am335x_adc.c
@@ -86,19 +86,18 @@ static void tiadc_step_config(struct iio_dev *indio_dev)
86{ 86{
87 struct tiadc_device *adc_dev = iio_priv(indio_dev); 87 struct tiadc_device *adc_dev = iio_priv(indio_dev);
88 unsigned int stepconfig; 88 unsigned int stepconfig;
89 int i, steps; 89 int i, steps = 0;
90 90
91 /* 91 /*
92 * There are 16 configurable steps and 8 analog input 92 * There are 16 configurable steps and 8 analog input
93 * lines available which are shared between Touchscreen and ADC. 93 * lines available which are shared between Touchscreen and ADC.
94 * 94 *
95 * Steps backwards i.e. from 16 towards 0 are used by ADC 95 * Steps forwards i.e. from 0 towards 16 are used by ADC
96 * depending on number of input lines needed. 96 * depending on number of input lines needed.
97 * Channel would represent which analog input 97 * Channel would represent which analog input
98 * needs to be given to ADC to digitalize data. 98 * needs to be given to ADC to digitalize data.
99 */ 99 */
100 100
101 steps = TOTAL_STEPS - adc_dev->channels;
102 if (iio_buffer_enabled(indio_dev)) 101 if (iio_buffer_enabled(indio_dev))
103 stepconfig = STEPCONFIG_AVG_16 | STEPCONFIG_FIFO1 102 stepconfig = STEPCONFIG_AVG_16 | STEPCONFIG_FIFO1
104 | STEPCONFIG_MODE_SWCNT; 103 | STEPCONFIG_MODE_SWCNT;
@@ -545,7 +544,6 @@ MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);
545static struct platform_driver tiadc_driver = { 544static struct platform_driver tiadc_driver = {
546 .driver = { 545 .driver = {
547 .name = "TI-am335x-adc", 546 .name = "TI-am335x-adc",
548 .owner = THIS_MODULE,
549 .pm = TIADC_PM_OPS, 547 .pm = TIADC_PM_OPS,
550 .of_match_table = ti_adc_dt_ids, 548 .of_match_table = ti_adc_dt_ids,
551 }, 549 },
diff --git a/drivers/iio/adc/twl4030-madc.c b/drivers/iio/adc/twl4030-madc.c
index eb86786e698e..94c5f05b4bc1 100644
--- a/drivers/iio/adc/twl4030-madc.c
+++ b/drivers/iio/adc/twl4030-madc.c
@@ -883,7 +883,6 @@ static struct platform_driver twl4030_madc_driver = {
883 .remove = twl4030_madc_remove, 883 .remove = twl4030_madc_remove,
884 .driver = { 884 .driver = {
885 .name = "twl4030_madc", 885 .name = "twl4030_madc",
886 .owner = THIS_MODULE,
887 .of_match_table = of_match_ptr(twl_madc_of_match), 886 .of_match_table = of_match_ptr(twl_madc_of_match),
888 }, 887 },
889}; 888};
diff --git a/drivers/iio/adc/twl6030-gpadc.c b/drivers/iio/adc/twl6030-gpadc.c
index 15282f148b3b..89d8aa1d2818 100644
--- a/drivers/iio/adc/twl6030-gpadc.c
+++ b/drivers/iio/adc/twl6030-gpadc.c
@@ -994,7 +994,6 @@ static struct platform_driver twl6030_gpadc_driver = {
994 .remove = twl6030_gpadc_remove, 994 .remove = twl6030_gpadc_remove,
995 .driver = { 995 .driver = {
996 .name = DRIVER_NAME, 996 .name = DRIVER_NAME,
997 .owner = THIS_MODULE,
998 .pm = &twl6030_gpadc_pm_ops, 997 .pm = &twl6030_gpadc_pm_ops,
999 .of_match_table = of_twl6030_match_tbl, 998 .of_match_table = of_twl6030_match_tbl,
1000 }, 999 },
diff --git a/drivers/iio/adc/vf610_adc.c b/drivers/iio/adc/vf610_adc.c
index 44799eb5930e..8ec353c01d98 100644
--- a/drivers/iio/adc/vf610_adc.c
+++ b/drivers/iio/adc/vf610_adc.c
@@ -91,7 +91,7 @@
91#define VF610_ADC_CAL 0x80 91#define VF610_ADC_CAL 0x80
92 92
93/* Other field define */ 93/* Other field define */
94#define VF610_ADC_ADCHC(x) ((x) & 0xF) 94#define VF610_ADC_ADCHC(x) ((x) & 0x1F)
95#define VF610_ADC_AIEN (0x1 << 7) 95#define VF610_ADC_AIEN (0x1 << 7)
96#define VF610_ADC_CONV_DISABLE 0x1F 96#define VF610_ADC_CONV_DISABLE 0x1F
97#define VF610_ADC_HS_COCO0 0x1 97#define VF610_ADC_HS_COCO0 0x1
@@ -153,6 +153,12 @@ struct vf610_adc {
153 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 153 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
154} 154}
155 155
156#define VF610_ADC_TEMPERATURE_CHAN(_idx, _chan_type) { \
157 .type = (_chan_type), \
158 .channel = (_idx), \
159 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \
160}
161
156static const struct iio_chan_spec vf610_adc_iio_channels[] = { 162static const struct iio_chan_spec vf610_adc_iio_channels[] = {
157 VF610_ADC_CHAN(0, IIO_VOLTAGE), 163 VF610_ADC_CHAN(0, IIO_VOLTAGE),
158 VF610_ADC_CHAN(1, IIO_VOLTAGE), 164 VF610_ADC_CHAN(1, IIO_VOLTAGE),
@@ -170,6 +176,7 @@ static const struct iio_chan_spec vf610_adc_iio_channels[] = {
170 VF610_ADC_CHAN(13, IIO_VOLTAGE), 176 VF610_ADC_CHAN(13, IIO_VOLTAGE),
171 VF610_ADC_CHAN(14, IIO_VOLTAGE), 177 VF610_ADC_CHAN(14, IIO_VOLTAGE),
172 VF610_ADC_CHAN(15, IIO_VOLTAGE), 178 VF610_ADC_CHAN(15, IIO_VOLTAGE),
179 VF610_ADC_TEMPERATURE_CHAN(26, IIO_TEMP),
173 /* sentinel */ 180 /* sentinel */
174}; 181};
175 182
@@ -451,6 +458,7 @@ static int vf610_read_raw(struct iio_dev *indio_dev,
451 458
452 switch (mask) { 459 switch (mask) {
453 case IIO_CHAN_INFO_RAW: 460 case IIO_CHAN_INFO_RAW:
461 case IIO_CHAN_INFO_PROCESSED:
454 mutex_lock(&indio_dev->mlock); 462 mutex_lock(&indio_dev->mlock);
455 reinit_completion(&info->completion); 463 reinit_completion(&info->completion);
456 464
@@ -468,7 +476,23 @@ static int vf610_read_raw(struct iio_dev *indio_dev,
468 return ret; 476 return ret;
469 } 477 }
470 478
471 *val = info->value; 479 switch (chan->type) {
480 case IIO_VOLTAGE:
481 *val = info->value;
482 break;
483 case IIO_TEMP:
484 /*
485 * Calculate in degree Celsius times 1000
486 * Using sensor slope of 1.84 mV/°C and
487 * V at 25°C of 696 mV
488 */
489 *val = 25000 - ((int)info->value - 864) * 1000000 / 1840;
490 break;
491 default:
492 mutex_unlock(&indio_dev->mlock);
493 return -EINVAL;
494 }
495
472 mutex_unlock(&indio_dev->mlock); 496 mutex_unlock(&indio_dev->mlock);
473 return IIO_VAL_INT; 497 return IIO_VAL_INT;
474 498
@@ -569,9 +593,9 @@ static int vf610_adc_probe(struct platform_device *pdev)
569 return PTR_ERR(info->regs); 593 return PTR_ERR(info->regs);
570 594
571 irq = platform_get_irq(pdev, 0); 595 irq = platform_get_irq(pdev, 0);
572 if (irq <= 0) { 596 if (irq < 0) {
573 dev_err(&pdev->dev, "no irq resource?\n"); 597 dev_err(&pdev->dev, "no irq resource?\n");
574 return -EINVAL; 598 return irq;
575 } 599 }
576 600
577 ret = devm_request_irq(info->dev, irq, 601 ret = devm_request_irq(info->dev, irq,
@@ -586,8 +610,7 @@ static int vf610_adc_probe(struct platform_device *pdev)
586 if (IS_ERR(info->clk)) { 610 if (IS_ERR(info->clk)) {
587 dev_err(&pdev->dev, "failed getting clock, err = %ld\n", 611 dev_err(&pdev->dev, "failed getting clock, err = %ld\n",
588 PTR_ERR(info->clk)); 612 PTR_ERR(info->clk));
589 ret = PTR_ERR(info->clk); 613 return PTR_ERR(info->clk);
590 return ret;
591 } 614 }
592 615
593 info->vref = devm_regulator_get(&pdev->dev, "vref"); 616 info->vref = devm_regulator_get(&pdev->dev, "vref");
@@ -681,24 +704,25 @@ static int vf610_adc_resume(struct device *dev)
681 704
682 ret = clk_prepare_enable(info->clk); 705 ret = clk_prepare_enable(info->clk);
683 if (ret) 706 if (ret)
684 return ret; 707 goto disable_reg;
685 708
686 vf610_adc_hw_init(info); 709 vf610_adc_hw_init(info);
687 710
688 return 0; 711 return 0;
712
713disable_reg:
714 regulator_disable(info->vref);
715 return ret;
689} 716}
690#endif 717#endif
691 718
692static SIMPLE_DEV_PM_OPS(vf610_adc_pm_ops, 719static SIMPLE_DEV_PM_OPS(vf610_adc_pm_ops, vf610_adc_suspend, vf610_adc_resume);
693 vf610_adc_suspend,
694 vf610_adc_resume);
695 720
696static struct platform_driver vf610_adc_driver = { 721static struct platform_driver vf610_adc_driver = {
697 .probe = vf610_adc_probe, 722 .probe = vf610_adc_probe,
698 .remove = vf610_adc_remove, 723 .remove = vf610_adc_remove,
699 .driver = { 724 .driver = {
700 .name = DRIVER_NAME, 725 .name = DRIVER_NAME,
701 .owner = THIS_MODULE,
702 .of_match_table = vf610_adc_match, 726 .of_match_table = vf610_adc_match,
703 .pm = &vf610_adc_pm_ops, 727 .pm = &vf610_adc_pm_ops,
704 }, 728 },
diff --git a/drivers/iio/adc/viperboard_adc.c b/drivers/iio/adc/viperboard_adc.c
index 9acf6b6d705b..3be2e35721cc 100644
--- a/drivers/iio/adc/viperboard_adc.c
+++ b/drivers/iio/adc/viperboard_adc.c
@@ -145,7 +145,6 @@ static int vprbrd_adc_probe(struct platform_device *pdev)
145static struct platform_driver vprbrd_adc_driver = { 145static struct platform_driver vprbrd_adc_driver = {
146 .driver = { 146 .driver = {
147 .name = "viperboard-adc", 147 .name = "viperboard-adc",
148 .owner = THIS_MODULE,
149 }, 148 },
150 .probe = vprbrd_adc_probe, 149 .probe = vprbrd_adc_probe,
151}; 150};
diff --git a/drivers/iio/adc/xilinx-xadc-core.c b/drivers/iio/adc/xilinx-xadc-core.c
index 626b39749767..a221f7329b79 100644
--- a/drivers/iio/adc/xilinx-xadc-core.c
+++ b/drivers/iio/adc/xilinx-xadc-core.c
@@ -1201,12 +1201,16 @@ static int xadc_probe(struct platform_device *pdev)
1201 goto err_device_free; 1201 goto err_device_free;
1202 1202
1203 xadc->convst_trigger = xadc_alloc_trigger(indio_dev, "convst"); 1203 xadc->convst_trigger = xadc_alloc_trigger(indio_dev, "convst");
1204 if (IS_ERR(xadc->convst_trigger)) 1204 if (IS_ERR(xadc->convst_trigger)) {
1205 ret = PTR_ERR(xadc->convst_trigger);
1205 goto err_triggered_buffer_cleanup; 1206 goto err_triggered_buffer_cleanup;
1207 }
1206 xadc->samplerate_trigger = xadc_alloc_trigger(indio_dev, 1208 xadc->samplerate_trigger = xadc_alloc_trigger(indio_dev,
1207 "samplerate"); 1209 "samplerate");
1208 if (IS_ERR(xadc->samplerate_trigger)) 1210 if (IS_ERR(xadc->samplerate_trigger)) {
1211 ret = PTR_ERR(xadc->samplerate_trigger);
1209 goto err_free_convst_trigger; 1212 goto err_free_convst_trigger;
1213 }
1210 } 1214 }
1211 1215
1212 xadc->clk = devm_clk_get(&pdev->dev, NULL); 1216 xadc->clk = devm_clk_get(&pdev->dev, NULL);
@@ -1322,7 +1326,6 @@ static struct platform_driver xadc_driver = {
1322 .remove = xadc_remove, 1326 .remove = xadc_remove,
1323 .driver = { 1327 .driver = {
1324 .name = "xadc", 1328 .name = "xadc",
1325 .owner = THIS_MODULE,
1326 .of_match_table = xadc_of_match_table, 1329 .of_match_table = xadc_of_match_table,
1327 }, 1330 },
1328}; 1331};
diff --git a/drivers/iio/common/st_sensors/st_sensors_buffer.c b/drivers/iio/common/st_sensors/st_sensors_buffer.c
index 1665c8e4b62b..e18bc6782256 100644
--- a/drivers/iio/common/st_sensors/st_sensors_buffer.c
+++ b/drivers/iio/common/st_sensors/st_sensors_buffer.c
@@ -71,7 +71,7 @@ int st_sensors_get_buffer_element(struct iio_dev *indio_dev, u8 *buf)
71 goto st_sensors_free_memory; 71 goto st_sensors_free_memory;
72 } 72 }
73 73
74 for (i = 0; i < n * num_data_channels; i++) { 74 for (i = 0; i < n * byte_for_channel; i++) {
75 if (i < n) 75 if (i < n)
76 buf[i] = rx_array[i]; 76 buf[i] = rx_array[i];
77 else 77 else
diff --git a/drivers/iio/common/st_sensors/st_sensors_core.c b/drivers/iio/common/st_sensors/st_sensors_core.c
index 8a4ec00a91a0..edd13d2b4121 100644
--- a/drivers/iio/common/st_sensors/st_sensors_core.c
+++ b/drivers/iio/common/st_sensors/st_sensors_core.c
@@ -44,18 +44,18 @@ st_sensors_write_data_with_mask_error:
44 return err; 44 return err;
45} 45}
46 46
47static int st_sensors_match_odr(struct st_sensors *sensor, 47static int st_sensors_match_odr(struct st_sensor_settings *sensor_settings,
48 unsigned int odr, struct st_sensor_odr_avl *odr_out) 48 unsigned int odr, struct st_sensor_odr_avl *odr_out)
49{ 49{
50 int i, ret = -EINVAL; 50 int i, ret = -EINVAL;
51 51
52 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) { 52 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
53 if (sensor->odr.odr_avl[i].hz == 0) 53 if (sensor_settings->odr.odr_avl[i].hz == 0)
54 goto st_sensors_match_odr_error; 54 goto st_sensors_match_odr_error;
55 55
56 if (sensor->odr.odr_avl[i].hz == odr) { 56 if (sensor_settings->odr.odr_avl[i].hz == odr) {
57 odr_out->hz = sensor->odr.odr_avl[i].hz; 57 odr_out->hz = sensor_settings->odr.odr_avl[i].hz;
58 odr_out->value = sensor->odr.odr_avl[i].value; 58 odr_out->value = sensor_settings->odr.odr_avl[i].value;
59 ret = 0; 59 ret = 0;
60 break; 60 break;
61 } 61 }
@@ -71,23 +71,26 @@ int st_sensors_set_odr(struct iio_dev *indio_dev, unsigned int odr)
71 struct st_sensor_odr_avl odr_out = {0, 0}; 71 struct st_sensor_odr_avl odr_out = {0, 0};
72 struct st_sensor_data *sdata = iio_priv(indio_dev); 72 struct st_sensor_data *sdata = iio_priv(indio_dev);
73 73
74 err = st_sensors_match_odr(sdata->sensor, odr, &odr_out); 74 err = st_sensors_match_odr(sdata->sensor_settings, odr, &odr_out);
75 if (err < 0) 75 if (err < 0)
76 goto st_sensors_match_odr_error; 76 goto st_sensors_match_odr_error;
77 77
78 if ((sdata->sensor->odr.addr == sdata->sensor->pw.addr) && 78 if ((sdata->sensor_settings->odr.addr ==
79 (sdata->sensor->odr.mask == sdata->sensor->pw.mask)) { 79 sdata->sensor_settings->pw.addr) &&
80 (sdata->sensor_settings->odr.mask ==
81 sdata->sensor_settings->pw.mask)) {
80 if (sdata->enabled == true) { 82 if (sdata->enabled == true) {
81 err = st_sensors_write_data_with_mask(indio_dev, 83 err = st_sensors_write_data_with_mask(indio_dev,
82 sdata->sensor->odr.addr, 84 sdata->sensor_settings->odr.addr,
83 sdata->sensor->odr.mask, 85 sdata->sensor_settings->odr.mask,
84 odr_out.value); 86 odr_out.value);
85 } else { 87 } else {
86 err = 0; 88 err = 0;
87 } 89 }
88 } else { 90 } else {
89 err = st_sensors_write_data_with_mask(indio_dev, 91 err = st_sensors_write_data_with_mask(indio_dev,
90 sdata->sensor->odr.addr, sdata->sensor->odr.mask, 92 sdata->sensor_settings->odr.addr,
93 sdata->sensor_settings->odr.mask,
91 odr_out.value); 94 odr_out.value);
92 } 95 }
93 if (err >= 0) 96 if (err >= 0)
@@ -98,16 +101,16 @@ st_sensors_match_odr_error:
98} 101}
99EXPORT_SYMBOL(st_sensors_set_odr); 102EXPORT_SYMBOL(st_sensors_set_odr);
100 103
101static int st_sensors_match_fs(struct st_sensors *sensor, 104static int st_sensors_match_fs(struct st_sensor_settings *sensor_settings,
102 unsigned int fs, int *index_fs_avl) 105 unsigned int fs, int *index_fs_avl)
103{ 106{
104 int i, ret = -EINVAL; 107 int i, ret = -EINVAL;
105 108
106 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) { 109 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
107 if (sensor->fs.fs_avl[i].num == 0) 110 if (sensor_settings->fs.fs_avl[i].num == 0)
108 goto st_sensors_match_odr_error; 111 goto st_sensors_match_odr_error;
109 112
110 if (sensor->fs.fs_avl[i].num == fs) { 113 if (sensor_settings->fs.fs_avl[i].num == fs) {
111 *index_fs_avl = i; 114 *index_fs_avl = i;
112 ret = 0; 115 ret = 0;
113 break; 116 break;
@@ -118,25 +121,24 @@ st_sensors_match_odr_error:
118 return ret; 121 return ret;
119} 122}
120 123
121static int st_sensors_set_fullscale(struct iio_dev *indio_dev, 124static int st_sensors_set_fullscale(struct iio_dev *indio_dev, unsigned int fs)
122 unsigned int fs)
123{ 125{
124 int err, i = 0; 126 int err, i = 0;
125 struct st_sensor_data *sdata = iio_priv(indio_dev); 127 struct st_sensor_data *sdata = iio_priv(indio_dev);
126 128
127 err = st_sensors_match_fs(sdata->sensor, fs, &i); 129 err = st_sensors_match_fs(sdata->sensor_settings, fs, &i);
128 if (err < 0) 130 if (err < 0)
129 goto st_accel_set_fullscale_error; 131 goto st_accel_set_fullscale_error;
130 132
131 err = st_sensors_write_data_with_mask(indio_dev, 133 err = st_sensors_write_data_with_mask(indio_dev,
132 sdata->sensor->fs.addr, 134 sdata->sensor_settings->fs.addr,
133 sdata->sensor->fs.mask, 135 sdata->sensor_settings->fs.mask,
134 sdata->sensor->fs.fs_avl[i].value); 136 sdata->sensor_settings->fs.fs_avl[i].value);
135 if (err < 0) 137 if (err < 0)
136 goto st_accel_set_fullscale_error; 138 goto st_accel_set_fullscale_error;
137 139
138 sdata->current_fullscale = (struct st_sensor_fullscale_avl *) 140 sdata->current_fullscale = (struct st_sensor_fullscale_avl *)
139 &sdata->sensor->fs.fs_avl[i]; 141 &sdata->sensor_settings->fs.fs_avl[i];
140 return err; 142 return err;
141 143
142st_accel_set_fullscale_error: 144st_accel_set_fullscale_error:
@@ -153,10 +155,12 @@ int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable)
153 struct st_sensor_data *sdata = iio_priv(indio_dev); 155 struct st_sensor_data *sdata = iio_priv(indio_dev);
154 156
155 if (enable) { 157 if (enable) {
156 tmp_value = sdata->sensor->pw.value_on; 158 tmp_value = sdata->sensor_settings->pw.value_on;
157 if ((sdata->sensor->odr.addr == sdata->sensor->pw.addr) && 159 if ((sdata->sensor_settings->odr.addr ==
158 (sdata->sensor->odr.mask == sdata->sensor->pw.mask)) { 160 sdata->sensor_settings->pw.addr) &&
159 err = st_sensors_match_odr(sdata->sensor, 161 (sdata->sensor_settings->odr.mask ==
162 sdata->sensor_settings->pw.mask)) {
163 err = st_sensors_match_odr(sdata->sensor_settings,
160 sdata->odr, &odr_out); 164 sdata->odr, &odr_out);
161 if (err < 0) 165 if (err < 0)
162 goto set_enable_error; 166 goto set_enable_error;
@@ -164,8 +168,8 @@ int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable)
164 found = true; 168 found = true;
165 } 169 }
166 err = st_sensors_write_data_with_mask(indio_dev, 170 err = st_sensors_write_data_with_mask(indio_dev,
167 sdata->sensor->pw.addr, 171 sdata->sensor_settings->pw.addr,
168 sdata->sensor->pw.mask, tmp_value); 172 sdata->sensor_settings->pw.mask, tmp_value);
169 if (err < 0) 173 if (err < 0)
170 goto set_enable_error; 174 goto set_enable_error;
171 175
@@ -175,9 +179,9 @@ int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable)
175 sdata->odr = odr_out.hz; 179 sdata->odr = odr_out.hz;
176 } else { 180 } else {
177 err = st_sensors_write_data_with_mask(indio_dev, 181 err = st_sensors_write_data_with_mask(indio_dev,
178 sdata->sensor->pw.addr, 182 sdata->sensor_settings->pw.addr,
179 sdata->sensor->pw.mask, 183 sdata->sensor_settings->pw.mask,
180 sdata->sensor->pw.value_off); 184 sdata->sensor_settings->pw.value_off);
181 if (err < 0) 185 if (err < 0)
182 goto set_enable_error; 186 goto set_enable_error;
183 187
@@ -194,8 +198,9 @@ int st_sensors_set_axis_enable(struct iio_dev *indio_dev, u8 axis_enable)
194 struct st_sensor_data *sdata = iio_priv(indio_dev); 198 struct st_sensor_data *sdata = iio_priv(indio_dev);
195 199
196 return st_sensors_write_data_with_mask(indio_dev, 200 return st_sensors_write_data_with_mask(indio_dev,
197 sdata->sensor->enable_axis.addr, 201 sdata->sensor_settings->enable_axis.addr,
198 sdata->sensor->enable_axis.mask, axis_enable); 202 sdata->sensor_settings->enable_axis.mask,
203 axis_enable);
199} 204}
200EXPORT_SYMBOL(st_sensors_set_axis_enable); 205EXPORT_SYMBOL(st_sensors_set_axis_enable);
201 206
@@ -236,13 +241,13 @@ void st_sensors_power_disable(struct iio_dev *indio_dev)
236EXPORT_SYMBOL(st_sensors_power_disable); 241EXPORT_SYMBOL(st_sensors_power_disable);
237 242
238static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev, 243static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev,
239 struct st_sensors_platform_data *pdata) 244 struct st_sensors_platform_data *pdata)
240{ 245{
241 struct st_sensor_data *sdata = iio_priv(indio_dev); 246 struct st_sensor_data *sdata = iio_priv(indio_dev);
242 247
243 switch (pdata->drdy_int_pin) { 248 switch (pdata->drdy_int_pin) {
244 case 1: 249 case 1:
245 if (sdata->sensor->drdy_irq.mask_int1 == 0) { 250 if (sdata->sensor_settings->drdy_irq.mask_int1 == 0) {
246 dev_err(&indio_dev->dev, 251 dev_err(&indio_dev->dev,
247 "DRDY on INT1 not available.\n"); 252 "DRDY on INT1 not available.\n");
248 return -EINVAL; 253 return -EINVAL;
@@ -250,7 +255,7 @@ static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev,
250 sdata->drdy_int_pin = 1; 255 sdata->drdy_int_pin = 1;
251 break; 256 break;
252 case 2: 257 case 2:
253 if (sdata->sensor->drdy_irq.mask_int2 == 0) { 258 if (sdata->sensor_settings->drdy_irq.mask_int2 == 0) {
254 dev_err(&indio_dev->dev, 259 dev_err(&indio_dev->dev,
255 "DRDY on INT2 not available.\n"); 260 "DRDY on INT2 not available.\n");
256 return -EINVAL; 261 return -EINVAL;
@@ -306,8 +311,11 @@ int st_sensors_init_sensor(struct iio_dev *indio_dev,
306 if (of_pdata) 311 if (of_pdata)
307 pdata = of_pdata; 312 pdata = of_pdata;
308 313
309 if (pdata) 314 if (pdata) {
310 err = st_sensors_set_drdy_int_pin(indio_dev, pdata); 315 err = st_sensors_set_drdy_int_pin(indio_dev, pdata);
316 if (err < 0)
317 return err;
318 }
311 319
312 err = st_sensors_set_enable(indio_dev, false); 320 err = st_sensors_set_enable(indio_dev, false);
313 if (err < 0) 321 if (err < 0)
@@ -315,7 +323,7 @@ int st_sensors_init_sensor(struct iio_dev *indio_dev,
315 323
316 if (sdata->current_fullscale) { 324 if (sdata->current_fullscale) {
317 err = st_sensors_set_fullscale(indio_dev, 325 err = st_sensors_set_fullscale(indio_dev,
318 sdata->current_fullscale->num); 326 sdata->current_fullscale->num);
319 if (err < 0) 327 if (err < 0)
320 return err; 328 return err;
321 } else 329 } else
@@ -327,7 +335,8 @@ int st_sensors_init_sensor(struct iio_dev *indio_dev,
327 335
328 /* set BDU */ 336 /* set BDU */
329 err = st_sensors_write_data_with_mask(indio_dev, 337 err = st_sensors_write_data_with_mask(indio_dev,
330 sdata->sensor->bdu.addr, sdata->sensor->bdu.mask, true); 338 sdata->sensor_settings->bdu.addr,
339 sdata->sensor_settings->bdu.mask, true);
331 if (err < 0) 340 if (err < 0)
332 return err; 341 return err;
333 342
@@ -343,26 +352,28 @@ int st_sensors_set_dataready_irq(struct iio_dev *indio_dev, bool enable)
343 u8 drdy_mask; 352 u8 drdy_mask;
344 struct st_sensor_data *sdata = iio_priv(indio_dev); 353 struct st_sensor_data *sdata = iio_priv(indio_dev);
345 354
346 if (!sdata->sensor->drdy_irq.addr) 355 if (!sdata->sensor_settings->drdy_irq.addr)
347 return 0; 356 return 0;
348 357
349 /* Enable/Disable the interrupt generator 1. */ 358 /* Enable/Disable the interrupt generator 1. */
350 if (sdata->sensor->drdy_irq.ig1.en_addr > 0) { 359 if (sdata->sensor_settings->drdy_irq.ig1.en_addr > 0) {
351 err = st_sensors_write_data_with_mask(indio_dev, 360 err = st_sensors_write_data_with_mask(indio_dev,
352 sdata->sensor->drdy_irq.ig1.en_addr, 361 sdata->sensor_settings->drdy_irq.ig1.en_addr,
353 sdata->sensor->drdy_irq.ig1.en_mask, (int)enable); 362 sdata->sensor_settings->drdy_irq.ig1.en_mask,
363 (int)enable);
354 if (err < 0) 364 if (err < 0)
355 goto st_accel_set_dataready_irq_error; 365 goto st_accel_set_dataready_irq_error;
356 } 366 }
357 367
358 if (sdata->drdy_int_pin == 1) 368 if (sdata->drdy_int_pin == 1)
359 drdy_mask = sdata->sensor->drdy_irq.mask_int1; 369 drdy_mask = sdata->sensor_settings->drdy_irq.mask_int1;
360 else 370 else
361 drdy_mask = sdata->sensor->drdy_irq.mask_int2; 371 drdy_mask = sdata->sensor_settings->drdy_irq.mask_int2;
362 372
363 /* Enable/Disable the interrupt generator for data ready. */ 373 /* Enable/Disable the interrupt generator for data ready. */
364 err = st_sensors_write_data_with_mask(indio_dev, 374 err = st_sensors_write_data_with_mask(indio_dev,
365 sdata->sensor->drdy_irq.addr, drdy_mask, (int)enable); 375 sdata->sensor_settings->drdy_irq.addr,
376 drdy_mask, (int)enable);
366 377
367st_accel_set_dataready_irq_error: 378st_accel_set_dataready_irq_error:
368 return err; 379 return err;
@@ -375,8 +386,8 @@ int st_sensors_set_fullscale_by_gain(struct iio_dev *indio_dev, int scale)
375 struct st_sensor_data *sdata = iio_priv(indio_dev); 386 struct st_sensor_data *sdata = iio_priv(indio_dev);
376 387
377 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) { 388 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
378 if ((sdata->sensor->fs.fs_avl[i].gain == scale) && 389 if ((sdata->sensor_settings->fs.fs_avl[i].gain == scale) &&
379 (sdata->sensor->fs.fs_avl[i].gain != 0)) { 390 (sdata->sensor_settings->fs.fs_avl[i].gain != 0)) {
380 err = 0; 391 err = 0;
381 break; 392 break;
382 } 393 }
@@ -385,7 +396,7 @@ int st_sensors_set_fullscale_by_gain(struct iio_dev *indio_dev, int scale)
385 goto st_sensors_match_scale_error; 396 goto st_sensors_match_scale_error;
386 397
387 err = st_sensors_set_fullscale(indio_dev, 398 err = st_sensors_set_fullscale(indio_dev,
388 sdata->sensor->fs.fs_avl[i].num); 399 sdata->sensor_settings->fs.fs_avl[i].num);
389 400
390st_sensors_match_scale_error: 401st_sensors_match_scale_error:
391 return err; 402 return err;
@@ -436,7 +447,7 @@ int st_sensors_read_info_raw(struct iio_dev *indio_dev,
436 if (err < 0) 447 if (err < 0)
437 goto out; 448 goto out;
438 449
439 msleep((sdata->sensor->bootime * 1000) / sdata->odr); 450 msleep((sdata->sensor_settings->bootime * 1000) / sdata->odr);
440 err = st_sensors_read_axis_data(indio_dev, ch, val); 451 err = st_sensors_read_axis_data(indio_dev, ch, val);
441 if (err < 0) 452 if (err < 0)
442 goto out; 453 goto out;
@@ -453,7 +464,8 @@ out:
453EXPORT_SYMBOL(st_sensors_read_info_raw); 464EXPORT_SYMBOL(st_sensors_read_info_raw);
454 465
455int st_sensors_check_device_support(struct iio_dev *indio_dev, 466int st_sensors_check_device_support(struct iio_dev *indio_dev,
456 int num_sensors_list, const struct st_sensors *sensors) 467 int num_sensors_list,
468 const struct st_sensor_settings *sensor_settings)
457{ 469{
458 u8 wai; 470 u8 wai;
459 int i, n, err; 471 int i, n, err;
@@ -467,23 +479,24 @@ int st_sensors_check_device_support(struct iio_dev *indio_dev,
467 } 479 }
468 480
469 for (i = 0; i < num_sensors_list; i++) { 481 for (i = 0; i < num_sensors_list; i++) {
470 if (sensors[i].wai == wai) 482 if (sensor_settings[i].wai == wai)
471 break; 483 break;
472 } 484 }
473 if (i == num_sensors_list) 485 if (i == num_sensors_list)
474 goto device_not_supported; 486 goto device_not_supported;
475 487
476 for (n = 0; n < ARRAY_SIZE(sensors[i].sensors_supported); n++) { 488 for (n = 0; n < ARRAY_SIZE(sensor_settings[i].sensors_supported); n++) {
477 if (strcmp(indio_dev->name, 489 if (strcmp(indio_dev->name,
478 &sensors[i].sensors_supported[n][0]) == 0) 490 &sensor_settings[i].sensors_supported[n][0]) == 0)
479 break; 491 break;
480 } 492 }
481 if (n == ARRAY_SIZE(sensors[i].sensors_supported)) { 493 if (n == ARRAY_SIZE(sensor_settings[i].sensors_supported)) {
482 dev_err(&indio_dev->dev, "device name and WhoAmI mismatch.\n"); 494 dev_err(&indio_dev->dev, "device name and WhoAmI mismatch.\n");
483 goto sensor_name_mismatch; 495 goto sensor_name_mismatch;
484 } 496 }
485 497
486 sdata->sensor = (struct st_sensors *)&sensors[i]; 498 sdata->sensor_settings =
499 (struct st_sensor_settings *)&sensor_settings[i];
487 500
488 return i; 501 return i;
489 502
@@ -505,11 +518,11 @@ ssize_t st_sensors_sysfs_sampling_frequency_avail(struct device *dev,
505 518
506 mutex_lock(&indio_dev->mlock); 519 mutex_lock(&indio_dev->mlock);
507 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) { 520 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
508 if (sdata->sensor->odr.odr_avl[i].hz == 0) 521 if (sdata->sensor_settings->odr.odr_avl[i].hz == 0)
509 break; 522 break;
510 523
511 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ", 524 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
512 sdata->sensor->odr.odr_avl[i].hz); 525 sdata->sensor_settings->odr.odr_avl[i].hz);
513 } 526 }
514 mutex_unlock(&indio_dev->mlock); 527 mutex_unlock(&indio_dev->mlock);
515 buf[len - 1] = '\n'; 528 buf[len - 1] = '\n';
@@ -527,11 +540,11 @@ ssize_t st_sensors_sysfs_scale_avail(struct device *dev,
527 540
528 mutex_lock(&indio_dev->mlock); 541 mutex_lock(&indio_dev->mlock);
529 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) { 542 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
530 if (sdata->sensor->fs.fs_avl[i].num == 0) 543 if (sdata->sensor_settings->fs.fs_avl[i].num == 0)
531 break; 544 break;
532 545
533 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ", 546 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ",
534 sdata->sensor->fs.fs_avl[i].gain); 547 sdata->sensor_settings->fs.fs_avl[i].gain);
535 } 548 }
536 mutex_unlock(&indio_dev->mlock); 549 mutex_unlock(&indio_dev->mlock);
537 buf[len - 1] = '\n'; 550 buf[len - 1] = '\n';
diff --git a/drivers/iio/common/st_sensors/st_sensors_i2c.c b/drivers/iio/common/st_sensors/st_sensors_i2c.c
index bb6f3085f57b..98cfee296d46 100644
--- a/drivers/iio/common/st_sensors/st_sensors_i2c.c
+++ b/drivers/iio/common/st_sensors/st_sensors_i2c.c
@@ -72,6 +72,7 @@ void st_sensors_i2c_configure(struct iio_dev *indio_dev,
72 indio_dev->dev.parent = &client->dev; 72 indio_dev->dev.parent = &client->dev;
73 indio_dev->name = client->name; 73 indio_dev->name = client->name;
74 74
75 sdata->dev = &client->dev;
75 sdata->tf = &st_sensors_tf_i2c; 76 sdata->tf = &st_sensors_tf_i2c;
76 sdata->get_irq_data_ready = st_sensors_i2c_get_irq; 77 sdata->get_irq_data_ready = st_sensors_i2c_get_irq;
77} 78}
diff --git a/drivers/iio/common/st_sensors/st_sensors_spi.c b/drivers/iio/common/st_sensors/st_sensors_spi.c
index 251baf6abc25..78a6a1ab3ece 100644
--- a/drivers/iio/common/st_sensors/st_sensors_spi.c
+++ b/drivers/iio/common/st_sensors/st_sensors_spi.c
@@ -111,6 +111,7 @@ void st_sensors_spi_configure(struct iio_dev *indio_dev,
111 indio_dev->dev.parent = &spi->dev; 111 indio_dev->dev.parent = &spi->dev;
112 indio_dev->name = spi->modalias; 112 indio_dev->name = spi->modalias;
113 113
114 sdata->dev = &spi->dev;
114 sdata->tf = &st_sensors_tf_spi; 115 sdata->tf = &st_sensors_tf_spi;
115 sdata->get_irq_data_ready = st_sensors_spi_get_irq; 116 sdata->get_irq_data_ready = st_sensors_spi_get_irq;
116} 117}
diff --git a/drivers/iio/dac/Kconfig b/drivers/iio/dac/Kconfig
index f278eff42a4c..2236ea22f98a 100644
--- a/drivers/iio/dac/Kconfig
+++ b/drivers/iio/dac/Kconfig
@@ -152,6 +152,14 @@ config MAX517
152 This driver can also be built as a module. If so, the module 152 This driver can also be built as a module. If so, the module
153 will be called max517. 153 will be called max517.
154 154
155config MAX5821
156 tristate "Maxim MAX5821 DAC driver"
157 depends on I2C
158 depends on OF
159 help
160 Say yes here to build support for Maxim MAX5821
161 10 bits DAC.
162
155config MCP4725 163config MCP4725
156 tristate "MCP4725 DAC driver" 164 tristate "MCP4725 DAC driver"
157 depends on I2C 165 depends on I2C
diff --git a/drivers/iio/dac/Makefile b/drivers/iio/dac/Makefile
index 10107640bb46..52be7e1acf16 100644
--- a/drivers/iio/dac/Makefile
+++ b/drivers/iio/dac/Makefile
@@ -17,5 +17,6 @@ obj-$(CONFIG_AD5791) += ad5791.o
17obj-$(CONFIG_AD5686) += ad5686.o 17obj-$(CONFIG_AD5686) += ad5686.o
18obj-$(CONFIG_AD7303) += ad7303.o 18obj-$(CONFIG_AD7303) += ad7303.o
19obj-$(CONFIG_MAX517) += max517.o 19obj-$(CONFIG_MAX517) += max517.o
20obj-$(CONFIG_MAX5821) += max5821.o
20obj-$(CONFIG_MCP4725) += mcp4725.o 21obj-$(CONFIG_MCP4725) += mcp4725.o
21obj-$(CONFIG_MCP4922) += mcp4922.o 22obj-$(CONFIG_MCP4922) += mcp4922.o
diff --git a/drivers/iio/dac/max5821.c b/drivers/iio/dac/max5821.c
new file mode 100644
index 000000000000..6e914495b346
--- /dev/null
+++ b/drivers/iio/dac/max5821.c
@@ -0,0 +1,405 @@
1 /*
2 * iio/dac/max5821.c
3 * Copyright (C) 2014 Philippe Reynes
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 */
9
10#include <linux/kernel.h>
11#include <linux/module.h>
12#include <linux/i2c.h>
13#include <linux/iio/iio.h>
14#include <linux/regulator/consumer.h>
15
16#define MAX5821_MAX_DAC_CHANNELS 2
17
18/* command bytes */
19#define MAX5821_LOAD_DAC_A_IN_REG_B 0x00
20#define MAX5821_LOAD_DAC_B_IN_REG_A 0x10
21#define MAX5821_EXTENDED_COMMAND_MODE 0xf0
22#define MAX5821_READ_DAC_A_COMMAND 0xf1
23#define MAX5821_READ_DAC_B_COMMAND 0xf2
24
25#define MAX5821_EXTENDED_POWER_UP 0x00
26#define MAX5821_EXTENDED_POWER_DOWN_MODE0 0x01
27#define MAX5821_EXTENDED_POWER_DOWN_MODE1 0x02
28#define MAX5821_EXTENDED_POWER_DOWN_MODE2 0x03
29#define MAX5821_EXTENDED_DAC_A 0x04
30#define MAX5821_EXTENDED_DAC_B 0x08
31
32enum max5821_device_ids {
33 ID_MAX5821,
34};
35
36struct max5821_data {
37 struct i2c_client *client;
38 struct regulator *vref_reg;
39 unsigned short vref_mv;
40 bool powerdown[MAX5821_MAX_DAC_CHANNELS];
41 u8 powerdown_mode[MAX5821_MAX_DAC_CHANNELS];
42 struct mutex lock;
43};
44
45static const char * const max5821_powerdown_modes[] = {
46 "three_state",
47 "1kohm_to_gnd",
48 "100kohm_to_gnd",
49};
50
51enum {
52 MAX5821_THREE_STATE,
53 MAX5821_1KOHM_TO_GND,
54 MAX5821_100KOHM_TO_GND
55};
56
57static int max5821_get_powerdown_mode(struct iio_dev *indio_dev,
58 const struct iio_chan_spec *chan)
59{
60 struct max5821_data *st = iio_priv(indio_dev);
61
62 return st->powerdown_mode[chan->channel];
63}
64
65static int max5821_set_powerdown_mode(struct iio_dev *indio_dev,
66 const struct iio_chan_spec *chan,
67 unsigned int mode)
68{
69 struct max5821_data *st = iio_priv(indio_dev);
70
71 st->powerdown_mode[chan->channel] = mode;
72
73 return 0;
74}
75
76static const struct iio_enum max5821_powerdown_mode_enum = {
77 .items = max5821_powerdown_modes,
78 .num_items = ARRAY_SIZE(max5821_powerdown_modes),
79 .get = max5821_get_powerdown_mode,
80 .set = max5821_set_powerdown_mode,
81};
82
83static ssize_t max5821_read_dac_powerdown(struct iio_dev *indio_dev,
84 uintptr_t private,
85 const struct iio_chan_spec *chan,
86 char *buf)
87{
88 struct max5821_data *st = iio_priv(indio_dev);
89
90 return sprintf(buf, "%d\n", st->powerdown[chan->channel]);
91}
92
93static int max5821_sync_powerdown_mode(struct max5821_data *data,
94 const struct iio_chan_spec *chan)
95{
96 u8 outbuf[2];
97
98 outbuf[0] = MAX5821_EXTENDED_COMMAND_MODE;
99
100 if (chan->channel == 0)
101 outbuf[1] = MAX5821_EXTENDED_DAC_A;
102 else
103 outbuf[1] = MAX5821_EXTENDED_DAC_B;
104
105 if (data->powerdown[chan->channel])
106 outbuf[1] |= data->powerdown_mode[chan->channel] + 1;
107 else
108 outbuf[1] |= MAX5821_EXTENDED_POWER_UP;
109
110 return i2c_master_send(data->client, outbuf, 2);
111}
112
113static ssize_t max5821_write_dac_powerdown(struct iio_dev *indio_dev,
114 uintptr_t private,
115 const struct iio_chan_spec *chan,
116 const char *buf, size_t len)
117{
118 struct max5821_data *data = iio_priv(indio_dev);
119 bool powerdown;
120 int ret;
121
122 ret = strtobool(buf, &powerdown);
123 if (ret)
124 return ret;
125
126 data->powerdown[chan->channel] = powerdown;
127
128 ret = max5821_sync_powerdown_mode(data, chan);
129 if (ret < 0)
130 return ret;
131
132 return len;
133}
134
135static const struct iio_chan_spec_ext_info max5821_ext_info[] = {
136 {
137 .name = "powerdown",
138 .read = max5821_read_dac_powerdown,
139 .write = max5821_write_dac_powerdown,
140 .shared = IIO_SEPARATE,
141 },
142 IIO_ENUM("powerdown_mode", IIO_SEPARATE, &max5821_powerdown_mode_enum),
143 IIO_ENUM_AVAILABLE("powerdown_mode", &max5821_powerdown_mode_enum),
144 { },
145};
146
147#define MAX5821_CHANNEL(chan) { \
148 .type = IIO_VOLTAGE, \
149 .indexed = 1, \
150 .output = 1, \
151 .channel = (chan), \
152 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
153 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SCALE), \
154 .ext_info = max5821_ext_info, \
155}
156
157static const struct iio_chan_spec max5821_channels[] = {
158 MAX5821_CHANNEL(0),
159 MAX5821_CHANNEL(1)
160};
161
162static const u8 max5821_read_dac_command[] = {
163 MAX5821_READ_DAC_A_COMMAND,
164 MAX5821_READ_DAC_B_COMMAND
165};
166
167static const u8 max5821_load_dac_command[] = {
168 MAX5821_LOAD_DAC_A_IN_REG_B,
169 MAX5821_LOAD_DAC_B_IN_REG_A
170};
171
172static int max5821_get_value(struct iio_dev *indio_dev,
173 int *val, int channel)
174{
175 struct max5821_data *data = iio_priv(indio_dev);
176 struct i2c_client *client = data->client;
177 u8 outbuf[1];
178 u8 inbuf[2];
179 int ret;
180
181 if ((channel != 0) && (channel != 1))
182 return -EINVAL;
183
184 outbuf[0] = max5821_read_dac_command[channel];
185
186 mutex_lock(&data->lock);
187
188 ret = i2c_master_send(client, outbuf, 1);
189 if (ret < 0) {
190 mutex_unlock(&data->lock);
191 return ret;
192 } else if (ret != 1) {
193 mutex_unlock(&data->lock);
194 return -EIO;
195 }
196
197 ret = i2c_master_recv(client, inbuf, 2);
198 if (ret < 0) {
199 mutex_unlock(&data->lock);
200 return ret;
201 } else if (ret != 2) {
202 mutex_unlock(&data->lock);
203 return -EIO;
204 }
205
206 mutex_unlock(&data->lock);
207
208 *val = ((inbuf[0] & 0x0f) << 6) | (inbuf[1] >> 2);
209
210 return IIO_VAL_INT;
211}
212
213static int max5821_set_value(struct iio_dev *indio_dev,
214 int val, int channel)
215{
216 struct max5821_data *data = iio_priv(indio_dev);
217 struct i2c_client *client = data->client;
218 u8 outbuf[2];
219 int ret;
220
221 if ((val < 0) || (val > 1023))
222 return -EINVAL;
223
224 if ((channel != 0) && (channel != 1))
225 return -EINVAL;
226
227 outbuf[0] = max5821_load_dac_command[channel];
228 outbuf[0] |= val >> 6;
229 outbuf[1] = (val & 0x3f) << 2;
230
231 ret = i2c_master_send(client, outbuf, 2);
232 if (ret < 0)
233 return ret;
234 else if (ret != 2)
235 return -EIO;
236 else
237 return 0;
238}
239
240static int max5821_read_raw(struct iio_dev *indio_dev,
241 struct iio_chan_spec const *chan,
242 int *val, int *val2, long mask)
243{
244 struct max5821_data *data = iio_priv(indio_dev);
245
246 switch (mask) {
247 case IIO_CHAN_INFO_RAW:
248 return max5821_get_value(indio_dev, val, chan->channel);
249 case IIO_CHAN_INFO_SCALE:
250 *val = data->vref_mv;
251 *val2 = 10;
252 return IIO_VAL_FRACTIONAL_LOG2;
253 default:
254 return -EINVAL;
255 }
256}
257
258static int max5821_write_raw(struct iio_dev *indio_dev,
259 struct iio_chan_spec const *chan,
260 int val, int val2, long mask)
261{
262 if (val2 != 0)
263 return -EINVAL;
264
265 switch (mask) {
266 case IIO_CHAN_INFO_RAW:
267 return max5821_set_value(indio_dev, val, chan->channel);
268 default:
269 return -EINVAL;
270 }
271}
272
273#ifdef CONFIG_PM_SLEEP
274static int max5821_suspend(struct device *dev)
275{
276 u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE,
277 MAX5821_EXTENDED_DAC_A |
278 MAX5821_EXTENDED_DAC_B |
279 MAX5821_EXTENDED_POWER_DOWN_MODE2 };
280
281 return i2c_master_send(to_i2c_client(dev), outbuf, 2);
282}
283
284static int max5821_resume(struct device *dev)
285{
286 u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE,
287 MAX5821_EXTENDED_DAC_A |
288 MAX5821_EXTENDED_DAC_B |
289 MAX5821_EXTENDED_POWER_UP };
290
291 return i2c_master_send(to_i2c_client(dev), outbuf, 2);
292}
293
294static SIMPLE_DEV_PM_OPS(max5821_pm_ops, max5821_suspend, max5821_resume);
295#define MAX5821_PM_OPS (&max5821_pm_ops)
296#else
297#define MAX5821_PM_OPS NULL
298#endif /* CONFIG_PM_SLEEP */
299
300static const struct iio_info max5821_info = {
301 .read_raw = max5821_read_raw,
302 .write_raw = max5821_write_raw,
303 .driver_module = THIS_MODULE,
304};
305
306static int max5821_probe(struct i2c_client *client,
307 const struct i2c_device_id *id)
308{
309 struct max5821_data *data;
310 struct iio_dev *indio_dev;
311 u32 tmp;
312 int ret;
313
314 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
315 if (!indio_dev)
316 return -ENOMEM;
317 data = iio_priv(indio_dev);
318 i2c_set_clientdata(client, indio_dev);
319 data->client = client;
320 mutex_init(&data->lock);
321
322 /* max5821 start in powerdown mode 100Kohm to ground */
323 for (tmp = 0; tmp < MAX5821_MAX_DAC_CHANNELS; tmp++) {
324 data->powerdown[tmp] = true;
325 data->powerdown_mode[tmp] = MAX5821_100KOHM_TO_GND;
326 }
327
328 data->vref_reg = devm_regulator_get(&client->dev, "vref");
329 if (IS_ERR(data->vref_reg)) {
330 ret = PTR_ERR(data->vref_reg);
331 dev_err(&client->dev,
332 "Failed to get vref regulator: %d\n", ret);
333 goto error_free_reg;
334 }
335
336 ret = regulator_enable(data->vref_reg);
337 if (ret) {
338 dev_err(&client->dev,
339 "Failed to enable vref regulator: %d\n", ret);
340 goto error_free_reg;
341 }
342
343 ret = regulator_get_voltage(data->vref_reg);
344 if (ret < 0) {
345 dev_err(&client->dev,
346 "Failed to get voltage on regulator: %d\n", ret);
347 goto error_disable_reg;
348 }
349
350 data->vref_mv = ret / 1000;
351
352 indio_dev->name = id->name;
353 indio_dev->dev.parent = &client->dev;
354 indio_dev->num_channels = ARRAY_SIZE(max5821_channels);
355 indio_dev->channels = max5821_channels;
356 indio_dev->modes = INDIO_DIRECT_MODE;
357 indio_dev->info = &max5821_info;
358
359 return iio_device_register(indio_dev);
360
361error_disable_reg:
362 regulator_disable(data->vref_reg);
363
364error_free_reg:
365
366 return ret;
367}
368
369static int max5821_remove(struct i2c_client *client)
370{
371 struct iio_dev *indio_dev = i2c_get_clientdata(client);
372 struct max5821_data *data = iio_priv(indio_dev);
373
374 iio_device_unregister(indio_dev);
375 regulator_disable(data->vref_reg);
376
377 return 0;
378}
379
380static const struct i2c_device_id max5821_id[] = {
381 { "max5821", ID_MAX5821 },
382 { }
383};
384MODULE_DEVICE_TABLE(i2c, max5821_id);
385
386static const struct of_device_id max5821_of_match[] = {
387 { .compatible = "maxim,max5821" },
388 { }
389};
390
391static struct i2c_driver max5821_driver = {
392 .driver = {
393 .name = "max5821",
394 .pm = MAX5821_PM_OPS,
395 .owner = THIS_MODULE,
396 },
397 .probe = max5821_probe,
398 .remove = max5821_remove,
399 .id_table = max5821_id,
400};
401module_i2c_driver(max5821_driver);
402
403MODULE_AUTHOR("Philippe Reynes <tremyfr@yahoo.fr>");
404MODULE_DESCRIPTION("MAX5821 DAC");
405MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/gyro/Kconfig b/drivers/iio/gyro/Kconfig
index ac2d69e34c8c..b3d0e94f72eb 100644
--- a/drivers/iio/gyro/Kconfig
+++ b/drivers/iio/gyro/Kconfig
@@ -50,6 +50,17 @@ config ADXRS450
50 This driver can also be built as a module. If so, the module 50 This driver can also be built as a module. If so, the module
51 will be called adxrs450. 51 will be called adxrs450.
52 52
53config BMG160
54 tristate "BOSCH BMG160 Gyro Sensor"
55 depends on I2C
56 select IIO_TRIGGERED_BUFFER if IIO_BUFFER
57 help
58 Say yes here to build support for Bosch BMG160 Tri-axis Gyro Sensor
59 driver. This driver also supports BMI055 gyroscope.
60
61 This driver can also be built as a module. If so, the module
62 will be called bmg160.
63
53config HID_SENSOR_GYRO_3D 64config HID_SENSOR_GYRO_3D
54 depends on HID_SENSOR_HUB 65 depends on HID_SENSOR_HUB
55 select IIO_BUFFER 66 select IIO_BUFFER
diff --git a/drivers/iio/gyro/Makefile b/drivers/iio/gyro/Makefile
index 2f2752a4ea83..36a38776f739 100644
--- a/drivers/iio/gyro/Makefile
+++ b/drivers/iio/gyro/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_ADIS16130) += adis16130.o
8obj-$(CONFIG_ADIS16136) += adis16136.o 8obj-$(CONFIG_ADIS16136) += adis16136.o
9obj-$(CONFIG_ADIS16260) += adis16260.o 9obj-$(CONFIG_ADIS16260) += adis16260.o
10obj-$(CONFIG_ADXRS450) += adxrs450.o 10obj-$(CONFIG_ADXRS450) += adxrs450.o
11obj-$(CONFIG_BMG160) += bmg160.o
11 12
12obj-$(CONFIG_HID_SENSOR_GYRO_3D) += hid-sensor-gyro-3d.o 13obj-$(CONFIG_HID_SENSOR_GYRO_3D) += hid-sensor-gyro-3d.o
13 14
diff --git a/drivers/iio/gyro/bmg160.c b/drivers/iio/gyro/bmg160.c
new file mode 100644
index 000000000000..60451b328242
--- /dev/null
+++ b/drivers/iio/gyro/bmg160.c
@@ -0,0 +1,1273 @@
1/*
2 * BMG160 Gyro Sensor driver
3 * Copyright (c) 2014, Intel Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 */
14
15#include <linux/module.h>
16#include <linux/i2c.h>
17#include <linux/interrupt.h>
18#include <linux/delay.h>
19#include <linux/slab.h>
20#include <linux/acpi.h>
21#include <linux/gpio/consumer.h>
22#include <linux/pm.h>
23#include <linux/pm_runtime.h>
24#include <linux/iio/iio.h>
25#include <linux/iio/sysfs.h>
26#include <linux/iio/buffer.h>
27#include <linux/iio/trigger.h>
28#include <linux/iio/events.h>
29#include <linux/iio/trigger_consumer.h>
30#include <linux/iio/triggered_buffer.h>
31
32#define BMG160_DRV_NAME "bmg160"
33#define BMG160_IRQ_NAME "bmg160_event"
34#define BMG160_GPIO_NAME "gpio_int"
35
36#define BMG160_REG_CHIP_ID 0x00
37#define BMG160_CHIP_ID_VAL 0x0F
38
39#define BMG160_REG_PMU_LPW 0x11
40#define BMG160_MODE_NORMAL 0x00
41#define BMG160_MODE_DEEP_SUSPEND 0x20
42#define BMG160_MODE_SUSPEND 0x80
43
44#define BMG160_REG_RANGE 0x0F
45
46#define BMG160_RANGE_2000DPS 0
47#define BMG160_RANGE_1000DPS 1
48#define BMG160_RANGE_500DPS 2
49#define BMG160_RANGE_250DPS 3
50#define BMG160_RANGE_125DPS 4
51
52#define BMG160_REG_PMU_BW 0x10
53#define BMG160_NO_FILTER 0
54#define BMG160_DEF_BW 100
55
56#define BMG160_REG_INT_MAP_0 0x17
57#define BMG160_INT_MAP_0_BIT_ANY BIT(1)
58
59#define BMG160_REG_INT_MAP_1 0x18
60#define BMG160_INT_MAP_1_BIT_NEW_DATA BIT(0)
61
62#define BMG160_REG_INT_RST_LATCH 0x21
63#define BMG160_INT_MODE_LATCH_RESET 0x80
64#define BMG160_INT_MODE_LATCH_INT 0x0F
65#define BMG160_INT_MODE_NON_LATCH_INT 0x00
66
67#define BMG160_REG_INT_EN_0 0x15
68#define BMG160_DATA_ENABLE_INT BIT(7)
69
70#define BMG160_REG_INT_EN_1 0x16
71#define BMG160_INT1_BIT_OD BIT(1)
72
73#define BMG160_REG_XOUT_L 0x02
74#define BMG160_AXIS_TO_REG(axis) (BMG160_REG_XOUT_L + (axis * 2))
75
76#define BMG160_REG_SLOPE_THRES 0x1B
77#define BMG160_SLOPE_THRES_MASK 0x0F
78
79#define BMG160_REG_MOTION_INTR 0x1C
80#define BMG160_INT_MOTION_X BIT(0)
81#define BMG160_INT_MOTION_Y BIT(1)
82#define BMG160_INT_MOTION_Z BIT(2)
83#define BMG160_ANY_DUR_MASK 0x30
84#define BMG160_ANY_DUR_SHIFT 4
85
86#define BMG160_REG_INT_STATUS_2 0x0B
87#define BMG160_ANY_MOTION_MASK 0x07
88#define BMG160_ANY_MOTION_BIT_X BIT(0)
89#define BMG160_ANY_MOTION_BIT_Y BIT(1)
90#define BMG160_ANY_MOTION_BIT_Z BIT(2)
91
92#define BMG160_REG_TEMP 0x08
93#define BMG160_TEMP_CENTER_VAL 23
94
95#define BMG160_MAX_STARTUP_TIME_MS 80
96
97#define BMG160_AUTO_SUSPEND_DELAY_MS 2000
98
99struct bmg160_data {
100 struct i2c_client *client;
101 struct iio_trigger *dready_trig;
102 struct iio_trigger *motion_trig;
103 struct mutex mutex;
104 s16 buffer[8];
105 u8 bw_bits;
106 u32 dps_range;
107 int ev_enable_state;
108 int slope_thres;
109 bool dready_trigger_on;
110 bool motion_trigger_on;
111 int64_t timestamp;
112};
113
114enum bmg160_axis {
115 AXIS_X,
116 AXIS_Y,
117 AXIS_Z,
118};
119
120static const struct {
121 int val;
122 int bw_bits;
123} bmg160_samp_freq_table[] = { {100, 0x07},
124 {200, 0x06},
125 {400, 0x03},
126 {1000, 0x02},
127 {2000, 0x01} };
128
129static const struct {
130 int scale;
131 int dps_range;
132} bmg160_scale_table[] = { { 1065, BMG160_RANGE_2000DPS},
133 { 532, BMG160_RANGE_1000DPS},
134 { 266, BMG160_RANGE_500DPS},
135 { 133, BMG160_RANGE_250DPS},
136 { 66, BMG160_RANGE_125DPS} };
137
138static int bmg160_set_mode(struct bmg160_data *data, u8 mode)
139{
140 int ret;
141
142 ret = i2c_smbus_write_byte_data(data->client,
143 BMG160_REG_PMU_LPW, mode);
144 if (ret < 0) {
145 dev_err(&data->client->dev, "Error writing reg_pmu_lpw\n");
146 return ret;
147 }
148
149 return 0;
150}
151
152static int bmg160_convert_freq_to_bit(int val)
153{
154 int i;
155
156 for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
157 if (bmg160_samp_freq_table[i].val == val)
158 return bmg160_samp_freq_table[i].bw_bits;
159 }
160
161 return -EINVAL;
162}
163
164static int bmg160_set_bw(struct bmg160_data *data, int val)
165{
166 int ret;
167 int bw_bits;
168
169 bw_bits = bmg160_convert_freq_to_bit(val);
170 if (bw_bits < 0)
171 return bw_bits;
172
173 ret = i2c_smbus_write_byte_data(data->client, BMG160_REG_PMU_BW,
174 bw_bits);
175 if (ret < 0) {
176 dev_err(&data->client->dev, "Error writing reg_pmu_bw\n");
177 return ret;
178 }
179
180 data->bw_bits = bw_bits;
181
182 return 0;
183}
184
185static int bmg160_chip_init(struct bmg160_data *data)
186{
187 int ret;
188
189 ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_CHIP_ID);
190 if (ret < 0) {
191 dev_err(&data->client->dev, "Error reading reg_chip_id\n");
192 return ret;
193 }
194
195 dev_dbg(&data->client->dev, "Chip Id %x\n", ret);
196 if (ret != BMG160_CHIP_ID_VAL) {
197 dev_err(&data->client->dev, "invalid chip %x\n", ret);
198 return -ENODEV;
199 }
200
201 ret = bmg160_set_mode(data, BMG160_MODE_NORMAL);
202 if (ret < 0)
203 return ret;
204
205 /* Wait upto 500 ms to be ready after changing mode */
206 usleep_range(500, 1000);
207
208 /* Set Bandwidth */
209 ret = bmg160_set_bw(data, BMG160_DEF_BW);
210 if (ret < 0)
211 return ret;
212
213 /* Set Default Range */
214 ret = i2c_smbus_write_byte_data(data->client,
215 BMG160_REG_RANGE,
216 BMG160_RANGE_500DPS);
217 if (ret < 0) {
218 dev_err(&data->client->dev, "Error writing reg_range\n");
219 return ret;
220 }
221 data->dps_range = BMG160_RANGE_500DPS;
222
223 ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_SLOPE_THRES);
224 if (ret < 0) {
225 dev_err(&data->client->dev, "Error reading reg_slope_thres\n");
226 return ret;
227 }
228 data->slope_thres = ret;
229
230 /* Set default interrupt mode */
231 ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_INT_EN_1);
232 if (ret < 0) {
233 dev_err(&data->client->dev, "Error reading reg_int_en_1\n");
234 return ret;
235 }
236 ret &= ~BMG160_INT1_BIT_OD;
237 ret = i2c_smbus_write_byte_data(data->client,
238 BMG160_REG_INT_EN_1, ret);
239 if (ret < 0) {
240 dev_err(&data->client->dev, "Error writing reg_int_en_1\n");
241 return ret;
242 }
243
244 ret = i2c_smbus_write_byte_data(data->client,
245 BMG160_REG_INT_RST_LATCH,
246 BMG160_INT_MODE_LATCH_INT |
247 BMG160_INT_MODE_LATCH_RESET);
248 if (ret < 0) {
249 dev_err(&data->client->dev,
250 "Error writing reg_motion_intr\n");
251 return ret;
252 }
253
254 return 0;
255}
256
257static int bmg160_set_power_state(struct bmg160_data *data, bool on)
258{
259#ifdef CONFIG_PM
260 int ret;
261
262 if (on)
263 ret = pm_runtime_get_sync(&data->client->dev);
264 else {
265 pm_runtime_mark_last_busy(&data->client->dev);
266 ret = pm_runtime_put_autosuspend(&data->client->dev);
267 }
268
269 if (ret < 0) {
270 dev_err(&data->client->dev,
271 "Failed: bmg160_set_power_state for %d\n", on);
272 if (on)
273 pm_runtime_put_noidle(&data->client->dev);
274
275 return ret;
276 }
277#endif
278
279 return 0;
280}
281
282static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
283 bool status)
284{
285 int ret;
286
287 /* Enable/Disable INT_MAP0 mapping */
288 ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_INT_MAP_0);
289 if (ret < 0) {
290 dev_err(&data->client->dev, "Error reading reg_int_map0\n");
291 return ret;
292 }
293 if (status)
294 ret |= BMG160_INT_MAP_0_BIT_ANY;
295 else
296 ret &= ~BMG160_INT_MAP_0_BIT_ANY;
297
298 ret = i2c_smbus_write_byte_data(data->client,
299 BMG160_REG_INT_MAP_0,
300 ret);
301 if (ret < 0) {
302 dev_err(&data->client->dev, "Error writing reg_int_map0\n");
303 return ret;
304 }
305
306 /* Enable/Disable slope interrupts */
307 if (status) {
308 /* Update slope thres */
309 ret = i2c_smbus_write_byte_data(data->client,
310 BMG160_REG_SLOPE_THRES,
311 data->slope_thres);
312 if (ret < 0) {
313 dev_err(&data->client->dev,
314 "Error writing reg_slope_thres\n");
315 return ret;
316 }
317
318 ret = i2c_smbus_write_byte_data(data->client,
319 BMG160_REG_MOTION_INTR,
320 BMG160_INT_MOTION_X |
321 BMG160_INT_MOTION_Y |
322 BMG160_INT_MOTION_Z);
323 if (ret < 0) {
324 dev_err(&data->client->dev,
325 "Error writing reg_motion_intr\n");
326 return ret;
327 }
328
329 /*
330 * New data interrupt is always non-latched,
331 * which will have higher priority, so no need
332 * to set latched mode, we will be flooded anyway with INTR
333 */
334 if (!data->dready_trigger_on) {
335 ret = i2c_smbus_write_byte_data(data->client,
336 BMG160_REG_INT_RST_LATCH,
337 BMG160_INT_MODE_LATCH_INT |
338 BMG160_INT_MODE_LATCH_RESET);
339 if (ret < 0) {
340 dev_err(&data->client->dev,
341 "Error writing reg_rst_latch\n");
342 return ret;
343 }
344 }
345
346 ret = i2c_smbus_write_byte_data(data->client,
347 BMG160_REG_INT_EN_0,
348 BMG160_DATA_ENABLE_INT);
349
350 } else
351 ret = i2c_smbus_write_byte_data(data->client,
352 BMG160_REG_INT_EN_0,
353 0);
354
355 if (ret < 0) {
356 dev_err(&data->client->dev, "Error writing reg_int_en0\n");
357 return ret;
358 }
359
360 return 0;
361}
362
363static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
364 bool status)
365{
366 int ret;
367
368 /* Enable/Disable INT_MAP1 mapping */
369 ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_INT_MAP_1);
370 if (ret < 0) {
371 dev_err(&data->client->dev, "Error reading reg_int_map1\n");
372 return ret;
373 }
374
375 if (status)
376 ret |= BMG160_INT_MAP_1_BIT_NEW_DATA;
377 else
378 ret &= ~BMG160_INT_MAP_1_BIT_NEW_DATA;
379
380 ret = i2c_smbus_write_byte_data(data->client,
381 BMG160_REG_INT_MAP_1,
382 ret);
383 if (ret < 0) {
384 dev_err(&data->client->dev, "Error writing reg_int_map1\n");
385 return ret;
386 }
387
388 if (status) {
389 ret = i2c_smbus_write_byte_data(data->client,
390 BMG160_REG_INT_RST_LATCH,
391 BMG160_INT_MODE_NON_LATCH_INT |
392 BMG160_INT_MODE_LATCH_RESET);
393 if (ret < 0) {
394 dev_err(&data->client->dev,
395 "Error writing reg_rst_latch\n");
396 return ret;
397 }
398
399 ret = i2c_smbus_write_byte_data(data->client,
400 BMG160_REG_INT_EN_0,
401 BMG160_DATA_ENABLE_INT);
402
403 } else {
404 /* Restore interrupt mode */
405 ret = i2c_smbus_write_byte_data(data->client,
406 BMG160_REG_INT_RST_LATCH,
407 BMG160_INT_MODE_LATCH_INT |
408 BMG160_INT_MODE_LATCH_RESET);
409 if (ret < 0) {
410 dev_err(&data->client->dev,
411 "Error writing reg_rst_latch\n");
412 return ret;
413 }
414
415 ret = i2c_smbus_write_byte_data(data->client,
416 BMG160_REG_INT_EN_0,
417 0);
418 }
419
420 if (ret < 0) {
421 dev_err(&data->client->dev, "Error writing reg_int_en0\n");
422 return ret;
423 }
424
425 return 0;
426}
427
428static int bmg160_get_bw(struct bmg160_data *data, int *val)
429{
430 int i;
431
432 for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
433 if (bmg160_samp_freq_table[i].bw_bits == data->bw_bits) {
434 *val = bmg160_samp_freq_table[i].val;
435 return IIO_VAL_INT;
436 }
437 }
438
439 return -EINVAL;
440}
441
442static int bmg160_set_scale(struct bmg160_data *data, int val)
443{
444 int ret, i;
445
446 for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
447 if (bmg160_scale_table[i].scale == val) {
448 ret = i2c_smbus_write_byte_data(
449 data->client,
450 BMG160_REG_RANGE,
451 bmg160_scale_table[i].dps_range);
452 if (ret < 0) {
453 dev_err(&data->client->dev,
454 "Error writing reg_range\n");
455 return ret;
456 }
457 data->dps_range = bmg160_scale_table[i].dps_range;
458 return 0;
459 }
460 }
461
462 return -EINVAL;
463}
464
465static int bmg160_get_temp(struct bmg160_data *data, int *val)
466{
467 int ret;
468
469 mutex_lock(&data->mutex);
470 ret = bmg160_set_power_state(data, true);
471 if (ret < 0) {
472 mutex_unlock(&data->mutex);
473 return ret;
474 }
475
476 ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_TEMP);
477 if (ret < 0) {
478 dev_err(&data->client->dev, "Error reading reg_temp\n");
479 bmg160_set_power_state(data, false);
480 mutex_unlock(&data->mutex);
481 return ret;
482 }
483
484 *val = sign_extend32(ret, 7);
485 ret = bmg160_set_power_state(data, false);
486 mutex_unlock(&data->mutex);
487 if (ret < 0)
488 return ret;
489
490 return IIO_VAL_INT;
491}
492
493static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
494{
495 int ret;
496
497 mutex_lock(&data->mutex);
498 ret = bmg160_set_power_state(data, true);
499 if (ret < 0) {
500 mutex_unlock(&data->mutex);
501 return ret;
502 }
503
504 ret = i2c_smbus_read_word_data(data->client, BMG160_AXIS_TO_REG(axis));
505 if (ret < 0) {
506 dev_err(&data->client->dev, "Error reading axis %d\n", axis);
507 bmg160_set_power_state(data, false);
508 mutex_unlock(&data->mutex);
509 return ret;
510 }
511
512 *val = sign_extend32(ret, 15);
513 ret = bmg160_set_power_state(data, false);
514 mutex_unlock(&data->mutex);
515 if (ret < 0)
516 return ret;
517
518 return IIO_VAL_INT;
519}
520
521static int bmg160_read_raw(struct iio_dev *indio_dev,
522 struct iio_chan_spec const *chan,
523 int *val, int *val2, long mask)
524{
525 struct bmg160_data *data = iio_priv(indio_dev);
526 int ret;
527
528 switch (mask) {
529 case IIO_CHAN_INFO_RAW:
530 switch (chan->type) {
531 case IIO_TEMP:
532 return bmg160_get_temp(data, val);
533 case IIO_ANGL_VEL:
534 if (iio_buffer_enabled(indio_dev))
535 return -EBUSY;
536 else
537 return bmg160_get_axis(data, chan->scan_index,
538 val);
539 default:
540 return -EINVAL;
541 }
542 case IIO_CHAN_INFO_OFFSET:
543 if (chan->type == IIO_TEMP) {
544 *val = BMG160_TEMP_CENTER_VAL;
545 return IIO_VAL_INT;
546 } else
547 return -EINVAL;
548 case IIO_CHAN_INFO_SCALE:
549 *val = 0;
550 switch (chan->type) {
551 case IIO_TEMP:
552 *val2 = 500000;
553 return IIO_VAL_INT_PLUS_MICRO;
554 case IIO_ANGL_VEL:
555 {
556 int i;
557
558 for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
559 if (bmg160_scale_table[i].dps_range ==
560 data->dps_range) {
561 *val2 = bmg160_scale_table[i].scale;
562 return IIO_VAL_INT_PLUS_MICRO;
563 }
564 }
565 return -EINVAL;
566 }
567 default:
568 return -EINVAL;
569 }
570 case IIO_CHAN_INFO_SAMP_FREQ:
571 *val2 = 0;
572 mutex_lock(&data->mutex);
573 ret = bmg160_get_bw(data, val);
574 mutex_unlock(&data->mutex);
575 return ret;
576 default:
577 return -EINVAL;
578 }
579}
580
581static int bmg160_write_raw(struct iio_dev *indio_dev,
582 struct iio_chan_spec const *chan,
583 int val, int val2, long mask)
584{
585 struct bmg160_data *data = iio_priv(indio_dev);
586 int ret;
587
588 switch (mask) {
589 case IIO_CHAN_INFO_SAMP_FREQ:
590 mutex_lock(&data->mutex);
591 /*
592 * Section 4.2 of spec
593 * In suspend mode, the only supported operations are reading
594 * registers as well as writing to the (0x14) softreset
595 * register. Since we will be in suspend mode by default, change
596 * mode to power on for other writes.
597 */
598 ret = bmg160_set_power_state(data, true);
599 if (ret < 0) {
600 mutex_unlock(&data->mutex);
601 return ret;
602 }
603 ret = bmg160_set_bw(data, val);
604 if (ret < 0) {
605 bmg160_set_power_state(data, false);
606 mutex_unlock(&data->mutex);
607 return ret;
608 }
609 ret = bmg160_set_power_state(data, false);
610 mutex_unlock(&data->mutex);
611 return ret;
612 case IIO_CHAN_INFO_SCALE:
613 if (val)
614 return -EINVAL;
615
616 mutex_lock(&data->mutex);
617 /* Refer to comments above for the suspend mode ops */
618 ret = bmg160_set_power_state(data, true);
619 if (ret < 0) {
620 mutex_unlock(&data->mutex);
621 return ret;
622 }
623 ret = bmg160_set_scale(data, val2);
624 if (ret < 0) {
625 bmg160_set_power_state(data, false);
626 mutex_unlock(&data->mutex);
627 return ret;
628 }
629 ret = bmg160_set_power_state(data, false);
630 mutex_unlock(&data->mutex);
631 return ret;
632 default:
633 return -EINVAL;
634 }
635
636 return -EINVAL;
637}
638
639static int bmg160_read_event(struct iio_dev *indio_dev,
640 const struct iio_chan_spec *chan,
641 enum iio_event_type type,
642 enum iio_event_direction dir,
643 enum iio_event_info info,
644 int *val, int *val2)
645{
646 struct bmg160_data *data = iio_priv(indio_dev);
647
648 *val2 = 0;
649 switch (info) {
650 case IIO_EV_INFO_VALUE:
651 *val = data->slope_thres & BMG160_SLOPE_THRES_MASK;
652 break;
653 default:
654 return -EINVAL;
655 }
656
657 return IIO_VAL_INT;
658}
659
660static int bmg160_write_event(struct iio_dev *indio_dev,
661 const struct iio_chan_spec *chan,
662 enum iio_event_type type,
663 enum iio_event_direction dir,
664 enum iio_event_info info,
665 int val, int val2)
666{
667 struct bmg160_data *data = iio_priv(indio_dev);
668
669 switch (info) {
670 case IIO_EV_INFO_VALUE:
671 if (data->ev_enable_state)
672 return -EBUSY;
673 data->slope_thres &= ~BMG160_SLOPE_THRES_MASK;
674 data->slope_thres |= (val & BMG160_SLOPE_THRES_MASK);
675 break;
676 default:
677 return -EINVAL;
678 }
679
680 return 0;
681}
682
683static int bmg160_read_event_config(struct iio_dev *indio_dev,
684 const struct iio_chan_spec *chan,
685 enum iio_event_type type,
686 enum iio_event_direction dir)
687{
688
689 struct bmg160_data *data = iio_priv(indio_dev);
690
691 return data->ev_enable_state;
692}
693
694static int bmg160_write_event_config(struct iio_dev *indio_dev,
695 const struct iio_chan_spec *chan,
696 enum iio_event_type type,
697 enum iio_event_direction dir,
698 int state)
699{
700 struct bmg160_data *data = iio_priv(indio_dev);
701 int ret;
702
703 if (state && data->ev_enable_state)
704 return 0;
705
706 mutex_lock(&data->mutex);
707
708 if (!state && data->motion_trigger_on) {
709 data->ev_enable_state = 0;
710 mutex_unlock(&data->mutex);
711 return 0;
712 }
713 /*
714 * We will expect the enable and disable to do operation in
715 * in reverse order. This will happen here anyway as our
716 * resume operation uses sync mode runtime pm calls, the
717 * suspend operation will be delayed by autosuspend delay
718 * So the disable operation will still happen in reverse of
719 * enable operation. When runtime pm is disabled the mode
720 * is always on so sequence doesn't matter
721 */
722 ret = bmg160_set_power_state(data, state);
723 if (ret < 0) {
724 mutex_unlock(&data->mutex);
725 return ret;
726 }
727
728 ret = bmg160_setup_any_motion_interrupt(data, state);
729 if (ret < 0) {
730 bmg160_set_power_state(data, false);
731 mutex_unlock(&data->mutex);
732 return ret;
733 }
734
735 data->ev_enable_state = state;
736 mutex_unlock(&data->mutex);
737
738 return 0;
739}
740
741static int bmg160_validate_trigger(struct iio_dev *indio_dev,
742 struct iio_trigger *trig)
743{
744 struct bmg160_data *data = iio_priv(indio_dev);
745
746 if (data->dready_trig != trig && data->motion_trig != trig)
747 return -EINVAL;
748
749 return 0;
750}
751
752static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("100 200 400 1000 2000");
753
754static IIO_CONST_ATTR(in_anglvel_scale_available,
755 "0.001065 0.000532 0.000266 0.000133 0.000066");
756
757static struct attribute *bmg160_attributes[] = {
758 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
759 &iio_const_attr_in_anglvel_scale_available.dev_attr.attr,
760 NULL,
761};
762
763static const struct attribute_group bmg160_attrs_group = {
764 .attrs = bmg160_attributes,
765};
766
767static const struct iio_event_spec bmg160_event = {
768 .type = IIO_EV_TYPE_ROC,
769 .dir = IIO_EV_DIR_EITHER,
770 .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) |
771 BIT(IIO_EV_INFO_ENABLE)
772};
773
774#define BMG160_CHANNEL(_axis) { \
775 .type = IIO_ANGL_VEL, \
776 .modified = 1, \
777 .channel2 = IIO_MOD_##_axis, \
778 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
779 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
780 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
781 .scan_index = AXIS_##_axis, \
782 .scan_type = { \
783 .sign = 's', \
784 .realbits = 16, \
785 .storagebits = 16, \
786 }, \
787 .event_spec = &bmg160_event, \
788 .num_event_specs = 1 \
789}
790
791static const struct iio_chan_spec bmg160_channels[] = {
792 {
793 .type = IIO_TEMP,
794 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
795 BIT(IIO_CHAN_INFO_SCALE) |
796 BIT(IIO_CHAN_INFO_OFFSET),
797 .scan_index = -1,
798 },
799 BMG160_CHANNEL(X),
800 BMG160_CHANNEL(Y),
801 BMG160_CHANNEL(Z),
802 IIO_CHAN_SOFT_TIMESTAMP(3),
803};
804
805static const struct iio_info bmg160_info = {
806 .attrs = &bmg160_attrs_group,
807 .read_raw = bmg160_read_raw,
808 .write_raw = bmg160_write_raw,
809 .read_event_value = bmg160_read_event,
810 .write_event_value = bmg160_write_event,
811 .write_event_config = bmg160_write_event_config,
812 .read_event_config = bmg160_read_event_config,
813 .validate_trigger = bmg160_validate_trigger,
814 .driver_module = THIS_MODULE,
815};
816
817static irqreturn_t bmg160_trigger_handler(int irq, void *p)
818{
819 struct iio_poll_func *pf = p;
820 struct iio_dev *indio_dev = pf->indio_dev;
821 struct bmg160_data *data = iio_priv(indio_dev);
822 int bit, ret, i = 0;
823
824 mutex_lock(&data->mutex);
825 for_each_set_bit(bit, indio_dev->buffer->scan_mask,
826 indio_dev->masklength) {
827 ret = i2c_smbus_read_word_data(data->client,
828 BMG160_AXIS_TO_REG(bit));
829 if (ret < 0) {
830 mutex_unlock(&data->mutex);
831 goto err;
832 }
833 data->buffer[i++] = ret;
834 }
835 mutex_unlock(&data->mutex);
836
837 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
838 data->timestamp);
839err:
840 iio_trigger_notify_done(indio_dev->trig);
841
842 return IRQ_HANDLED;
843}
844
845static int bmg160_trig_try_reen(struct iio_trigger *trig)
846{
847 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
848 struct bmg160_data *data = iio_priv(indio_dev);
849 int ret;
850
851 /* new data interrupts don't need ack */
852 if (data->dready_trigger_on)
853 return 0;
854
855 /* Set latched mode interrupt and clear any latched interrupt */
856 ret = i2c_smbus_write_byte_data(data->client,
857 BMG160_REG_INT_RST_LATCH,
858 BMG160_INT_MODE_LATCH_INT |
859 BMG160_INT_MODE_LATCH_RESET);
860 if (ret < 0) {
861 dev_err(&data->client->dev, "Error writing reg_rst_latch\n");
862 return ret;
863 }
864
865 return 0;
866}
867
868static int bmg160_data_rdy_trigger_set_state(struct iio_trigger *trig,
869 bool state)
870{
871 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
872 struct bmg160_data *data = iio_priv(indio_dev);
873 int ret;
874
875 mutex_lock(&data->mutex);
876
877 if (!state && data->ev_enable_state && data->motion_trigger_on) {
878 data->motion_trigger_on = false;
879 mutex_unlock(&data->mutex);
880 return 0;
881 }
882
883 /*
884 * Refer to comment in bmg160_write_event_config for
885 * enable/disable operation order
886 */
887 ret = bmg160_set_power_state(data, state);
888 if (ret < 0) {
889 mutex_unlock(&data->mutex);
890 return ret;
891 }
892 if (data->motion_trig == trig)
893 ret = bmg160_setup_any_motion_interrupt(data, state);
894 else
895 ret = bmg160_setup_new_data_interrupt(data, state);
896 if (ret < 0) {
897 bmg160_set_power_state(data, false);
898 mutex_unlock(&data->mutex);
899 return ret;
900 }
901 if (data->motion_trig == trig)
902 data->motion_trigger_on = state;
903 else
904 data->dready_trigger_on = state;
905
906 mutex_unlock(&data->mutex);
907
908 return 0;
909}
910
911static const struct iio_trigger_ops bmg160_trigger_ops = {
912 .set_trigger_state = bmg160_data_rdy_trigger_set_state,
913 .try_reenable = bmg160_trig_try_reen,
914 .owner = THIS_MODULE,
915};
916
917static irqreturn_t bmg160_event_handler(int irq, void *private)
918{
919 struct iio_dev *indio_dev = private;
920 struct bmg160_data *data = iio_priv(indio_dev);
921 int ret;
922 int dir;
923
924 ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_INT_STATUS_2);
925 if (ret < 0) {
926 dev_err(&data->client->dev, "Error reading reg_int_status2\n");
927 goto ack_intr_status;
928 }
929
930 if (ret & 0x08)
931 dir = IIO_EV_DIR_RISING;
932 else
933 dir = IIO_EV_DIR_FALLING;
934
935 if (ret & BMG160_ANY_MOTION_BIT_X)
936 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
937 0,
938 IIO_MOD_X,
939 IIO_EV_TYPE_ROC,
940 dir),
941 data->timestamp);
942 if (ret & BMG160_ANY_MOTION_BIT_Y)
943 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
944 0,
945 IIO_MOD_Y,
946 IIO_EV_TYPE_ROC,
947 dir),
948 data->timestamp);
949 if (ret & BMG160_ANY_MOTION_BIT_Z)
950 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
951 0,
952 IIO_MOD_Z,
953 IIO_EV_TYPE_ROC,
954 dir),
955 data->timestamp);
956
957ack_intr_status:
958 if (!data->dready_trigger_on) {
959 ret = i2c_smbus_write_byte_data(data->client,
960 BMG160_REG_INT_RST_LATCH,
961 BMG160_INT_MODE_LATCH_INT |
962 BMG160_INT_MODE_LATCH_RESET);
963 if (ret < 0)
964 dev_err(&data->client->dev,
965 "Error writing reg_rst_latch\n");
966 }
967
968 return IRQ_HANDLED;
969}
970
971static irqreturn_t bmg160_data_rdy_trig_poll(int irq, void *private)
972{
973 struct iio_dev *indio_dev = private;
974 struct bmg160_data *data = iio_priv(indio_dev);
975
976 data->timestamp = iio_get_time_ns();
977
978 if (data->dready_trigger_on)
979 iio_trigger_poll(data->dready_trig);
980 else if (data->motion_trigger_on)
981 iio_trigger_poll(data->motion_trig);
982
983 if (data->ev_enable_state)
984 return IRQ_WAKE_THREAD;
985 else
986 return IRQ_HANDLED;
987
988}
989
990static int bmg160_gpio_probe(struct i2c_client *client,
991 struct bmg160_data *data)
992
993{
994 struct device *dev;
995 struct gpio_desc *gpio;
996 int ret;
997
998 if (!client)
999 return -EINVAL;
1000
1001 dev = &client->dev;
1002
1003 /* data ready gpio interrupt pin */
1004 gpio = devm_gpiod_get_index(dev, BMG160_GPIO_NAME, 0);
1005 if (IS_ERR(gpio)) {
1006 dev_err(dev, "acpi gpio get index failed\n");
1007 return PTR_ERR(gpio);
1008 }
1009
1010 ret = gpiod_direction_input(gpio);
1011 if (ret)
1012 return ret;
1013
1014 ret = gpiod_to_irq(gpio);
1015
1016 dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
1017
1018 return ret;
1019}
1020
1021static const char *bmg160_match_acpi_device(struct device *dev)
1022{
1023 const struct acpi_device_id *id;
1024
1025 id = acpi_match_device(dev->driver->acpi_match_table, dev);
1026 if (!id)
1027 return NULL;
1028
1029 return dev_name(dev);
1030}
1031
1032static int bmg160_probe(struct i2c_client *client,
1033 const struct i2c_device_id *id)
1034{
1035 struct bmg160_data *data;
1036 struct iio_dev *indio_dev;
1037 int ret;
1038 const char *name = NULL;
1039
1040 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1041 if (!indio_dev)
1042 return -ENOMEM;
1043
1044 data = iio_priv(indio_dev);
1045 i2c_set_clientdata(client, indio_dev);
1046 data->client = client;
1047
1048 ret = bmg160_chip_init(data);
1049 if (ret < 0)
1050 return ret;
1051
1052 mutex_init(&data->mutex);
1053
1054 if (id)
1055 name = id->name;
1056
1057 if (ACPI_HANDLE(&client->dev))
1058 name = bmg160_match_acpi_device(&client->dev);
1059
1060 indio_dev->dev.parent = &client->dev;
1061 indio_dev->channels = bmg160_channels;
1062 indio_dev->num_channels = ARRAY_SIZE(bmg160_channels);
1063 indio_dev->name = name;
1064 indio_dev->modes = INDIO_DIRECT_MODE;
1065 indio_dev->info = &bmg160_info;
1066
1067 if (client->irq <= 0)
1068 client->irq = bmg160_gpio_probe(client, data);
1069
1070 if (client->irq > 0) {
1071 ret = devm_request_threaded_irq(&client->dev,
1072 client->irq,
1073 bmg160_data_rdy_trig_poll,
1074 bmg160_event_handler,
1075 IRQF_TRIGGER_RISING,
1076 BMG160_IRQ_NAME,
1077 indio_dev);
1078 if (ret)
1079 return ret;
1080
1081 data->dready_trig = devm_iio_trigger_alloc(&client->dev,
1082 "%s-dev%d",
1083 indio_dev->name,
1084 indio_dev->id);
1085 if (!data->dready_trig)
1086 return -ENOMEM;
1087
1088 data->motion_trig = devm_iio_trigger_alloc(&client->dev,
1089 "%s-any-motion-dev%d",
1090 indio_dev->name,
1091 indio_dev->id);
1092 if (!data->motion_trig)
1093 return -ENOMEM;
1094
1095 data->dready_trig->dev.parent = &client->dev;
1096 data->dready_trig->ops = &bmg160_trigger_ops;
1097 iio_trigger_set_drvdata(data->dready_trig, indio_dev);
1098 ret = iio_trigger_register(data->dready_trig);
1099 if (ret)
1100 return ret;
1101
1102 data->motion_trig->dev.parent = &client->dev;
1103 data->motion_trig->ops = &bmg160_trigger_ops;
1104 iio_trigger_set_drvdata(data->motion_trig, indio_dev);
1105 ret = iio_trigger_register(data->motion_trig);
1106 if (ret) {
1107 data->motion_trig = NULL;
1108 goto err_trigger_unregister;
1109 }
1110
1111 ret = iio_triggered_buffer_setup(indio_dev,
1112 NULL,
1113 bmg160_trigger_handler,
1114 NULL);
1115 if (ret < 0) {
1116 dev_err(&client->dev,
1117 "iio triggered buffer setup failed\n");
1118 goto err_trigger_unregister;
1119 }
1120 }
1121
1122 ret = iio_device_register(indio_dev);
1123 if (ret < 0) {
1124 dev_err(&client->dev, "unable to register iio device\n");
1125 goto err_buffer_cleanup;
1126 }
1127
1128 ret = pm_runtime_set_active(&client->dev);
1129 if (ret)
1130 goto err_iio_unregister;
1131
1132 pm_runtime_enable(&client->dev);
1133 pm_runtime_set_autosuspend_delay(&client->dev,
1134 BMG160_AUTO_SUSPEND_DELAY_MS);
1135 pm_runtime_use_autosuspend(&client->dev);
1136
1137 return 0;
1138
1139err_iio_unregister:
1140 iio_device_unregister(indio_dev);
1141err_buffer_cleanup:
1142 if (data->dready_trig)
1143 iio_triggered_buffer_cleanup(indio_dev);
1144err_trigger_unregister:
1145 if (data->dready_trig)
1146 iio_trigger_unregister(data->dready_trig);
1147 if (data->motion_trig)
1148 iio_trigger_unregister(data->motion_trig);
1149
1150 return ret;
1151}
1152
1153static int bmg160_remove(struct i2c_client *client)
1154{
1155 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1156 struct bmg160_data *data = iio_priv(indio_dev);
1157
1158 pm_runtime_disable(&client->dev);
1159 pm_runtime_set_suspended(&client->dev);
1160 pm_runtime_put_noidle(&client->dev);
1161
1162 iio_device_unregister(indio_dev);
1163
1164 if (data->dready_trig) {
1165 iio_triggered_buffer_cleanup(indio_dev);
1166 iio_trigger_unregister(data->dready_trig);
1167 iio_trigger_unregister(data->motion_trig);
1168 }
1169
1170 mutex_lock(&data->mutex);
1171 bmg160_set_mode(data, BMG160_MODE_DEEP_SUSPEND);
1172 mutex_unlock(&data->mutex);
1173
1174 return 0;
1175}
1176
1177#ifdef CONFIG_PM_SLEEP
1178static int bmg160_suspend(struct device *dev)
1179{
1180 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1181 struct bmg160_data *data = iio_priv(indio_dev);
1182
1183 mutex_lock(&data->mutex);
1184 bmg160_set_mode(data, BMG160_MODE_SUSPEND);
1185 mutex_unlock(&data->mutex);
1186
1187 return 0;
1188}
1189
1190static int bmg160_resume(struct device *dev)
1191{
1192 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1193 struct bmg160_data *data = iio_priv(indio_dev);
1194
1195 mutex_lock(&data->mutex);
1196 if (data->dready_trigger_on || data->motion_trigger_on ||
1197 data->ev_enable_state)
1198 bmg160_set_mode(data, BMG160_MODE_NORMAL);
1199 mutex_unlock(&data->mutex);
1200
1201 return 0;
1202}
1203#endif
1204
1205#ifdef CONFIG_PM
1206static int bmg160_runtime_suspend(struct device *dev)
1207{
1208 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1209 struct bmg160_data *data = iio_priv(indio_dev);
1210 int ret;
1211
1212 ret = bmg160_set_mode(data, BMG160_MODE_SUSPEND);
1213 if (ret < 0) {
1214 dev_err(&data->client->dev, "set mode failed\n");
1215 return -EAGAIN;
1216 }
1217
1218 return 0;
1219}
1220
1221static int bmg160_runtime_resume(struct device *dev)
1222{
1223 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1224 struct bmg160_data *data = iio_priv(indio_dev);
1225 int ret;
1226
1227 ret = bmg160_set_mode(data, BMG160_MODE_NORMAL);
1228 if (ret < 0)
1229 return ret;
1230
1231 msleep_interruptible(BMG160_MAX_STARTUP_TIME_MS);
1232
1233 return 0;
1234}
1235#endif
1236
1237static const struct dev_pm_ops bmg160_pm_ops = {
1238 SET_SYSTEM_SLEEP_PM_OPS(bmg160_suspend, bmg160_resume)
1239 SET_RUNTIME_PM_OPS(bmg160_runtime_suspend,
1240 bmg160_runtime_resume, NULL)
1241};
1242
1243static const struct acpi_device_id bmg160_acpi_match[] = {
1244 {"BMG0160", 0},
1245 {"BMI055B", 0},
1246 {},
1247};
1248
1249MODULE_DEVICE_TABLE(acpi, bmg160_acpi_match);
1250
1251static const struct i2c_device_id bmg160_id[] = {
1252 {"bmg160", 0},
1253 {"bmi055_gyro", 0},
1254 {}
1255};
1256
1257MODULE_DEVICE_TABLE(i2c, bmg160_id);
1258
1259static struct i2c_driver bmg160_driver = {
1260 .driver = {
1261 .name = BMG160_DRV_NAME,
1262 .acpi_match_table = ACPI_PTR(bmg160_acpi_match),
1263 .pm = &bmg160_pm_ops,
1264 },
1265 .probe = bmg160_probe,
1266 .remove = bmg160_remove,
1267 .id_table = bmg160_id,
1268};
1269module_i2c_driver(bmg160_driver);
1270
1271MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
1272MODULE_LICENSE("GPL v2");
1273MODULE_DESCRIPTION("BMG160 Gyro driver");
diff --git a/drivers/iio/gyro/hid-sensor-gyro-3d.c b/drivers/iio/gyro/hid-sensor-gyro-3d.c
index fa034a3dad78..a3ea1e8785d7 100644
--- a/drivers/iio/gyro/hid-sensor-gyro-3d.c
+++ b/drivers/iio/gyro/hid-sensor-gyro-3d.c
@@ -416,7 +416,6 @@ static struct platform_driver hid_gyro_3d_platform_driver = {
416 .id_table = hid_gyro_3d_ids, 416 .id_table = hid_gyro_3d_ids,
417 .driver = { 417 .driver = {
418 .name = KBUILD_MODNAME, 418 .name = KBUILD_MODNAME,
419 .owner = THIS_MODULE,
420 }, 419 },
421 .probe = hid_gyro_3d_probe, 420 .probe = hid_gyro_3d_probe,
422 .remove = hid_gyro_3d_remove, 421 .remove = hid_gyro_3d_remove,
diff --git a/drivers/iio/gyro/st_gyro.h b/drivers/iio/gyro/st_gyro.h
index c197360c450b..5353d6328c54 100644
--- a/drivers/iio/gyro/st_gyro.h
+++ b/drivers/iio/gyro/st_gyro.h
@@ -30,8 +30,7 @@ static const struct st_sensors_platform_data gyro_pdata = {
30 .drdy_int_pin = 2, 30 .drdy_int_pin = 2,
31}; 31};
32 32
33int st_gyro_common_probe(struct iio_dev *indio_dev, 33int st_gyro_common_probe(struct iio_dev *indio_dev);
34 struct st_sensors_platform_data *pdata);
35void st_gyro_common_remove(struct iio_dev *indio_dev); 34void st_gyro_common_remove(struct iio_dev *indio_dev);
36 35
37#ifdef CONFIG_IIO_BUFFER 36#ifdef CONFIG_IIO_BUFFER
diff --git a/drivers/iio/gyro/st_gyro_core.c b/drivers/iio/gyro/st_gyro_core.c
index f156fc6c5c6c..f07a2336f7dc 100644
--- a/drivers/iio/gyro/st_gyro_core.c
+++ b/drivers/iio/gyro/st_gyro_core.c
@@ -103,7 +103,7 @@ static const struct iio_chan_spec st_gyro_16bit_channels[] = {
103 IIO_CHAN_SOFT_TIMESTAMP(3) 103 IIO_CHAN_SOFT_TIMESTAMP(3)
104}; 104};
105 105
106static const struct st_sensors st_gyro_sensors[] = { 106static const struct st_sensor_settings st_gyro_sensors_settings[] = {
107 { 107 {
108 .wai = ST_GYRO_1_WAI_EXP, 108 .wai = ST_GYRO_1_WAI_EXP,
109 .sensors_supported = { 109 .sensors_supported = {
@@ -309,8 +309,7 @@ static const struct iio_trigger_ops st_gyro_trigger_ops = {
309#define ST_GYRO_TRIGGER_OPS NULL 309#define ST_GYRO_TRIGGER_OPS NULL
310#endif 310#endif
311 311
312int st_gyro_common_probe(struct iio_dev *indio_dev, 312int st_gyro_common_probe(struct iio_dev *indio_dev)
313 struct st_sensors_platform_data *pdata)
314{ 313{
315 struct st_sensor_data *gdata = iio_priv(indio_dev); 314 struct st_sensor_data *gdata = iio_priv(indio_dev);
316 int irq = gdata->get_irq_data_ready(indio_dev); 315 int irq = gdata->get_irq_data_ready(indio_dev);
@@ -322,20 +321,22 @@ int st_gyro_common_probe(struct iio_dev *indio_dev,
322 st_sensors_power_enable(indio_dev); 321 st_sensors_power_enable(indio_dev);
323 322
324 err = st_sensors_check_device_support(indio_dev, 323 err = st_sensors_check_device_support(indio_dev,
325 ARRAY_SIZE(st_gyro_sensors), st_gyro_sensors); 324 ARRAY_SIZE(st_gyro_sensors_settings),
325 st_gyro_sensors_settings);
326 if (err < 0) 326 if (err < 0)
327 return err; 327 return err;
328 328
329 gdata->num_data_channels = ST_GYRO_NUMBER_DATA_CHANNELS; 329 gdata->num_data_channels = ST_GYRO_NUMBER_DATA_CHANNELS;
330 gdata->multiread_bit = gdata->sensor->multi_read_bit; 330 gdata->multiread_bit = gdata->sensor_settings->multi_read_bit;
331 indio_dev->channels = gdata->sensor->ch; 331 indio_dev->channels = gdata->sensor_settings->ch;
332 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS; 332 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
333 333
334 gdata->current_fullscale = (struct st_sensor_fullscale_avl *) 334 gdata->current_fullscale = (struct st_sensor_fullscale_avl *)
335 &gdata->sensor->fs.fs_avl[0]; 335 &gdata->sensor_settings->fs.fs_avl[0];
336 gdata->odr = gdata->sensor->odr.odr_avl[0].hz; 336 gdata->odr = gdata->sensor_settings->odr.odr_avl[0].hz;
337 337
338 err = st_sensors_init_sensor(indio_dev, pdata); 338 err = st_sensors_init_sensor(indio_dev,
339 (struct st_sensors_platform_data *)&gyro_pdata);
339 if (err < 0) 340 if (err < 0)
340 return err; 341 return err;
341 342
diff --git a/drivers/iio/gyro/st_gyro_i2c.c b/drivers/iio/gyro/st_gyro_i2c.c
index 8fa0ad2ef4ef..64480b16c689 100644
--- a/drivers/iio/gyro/st_gyro_i2c.c
+++ b/drivers/iio/gyro/st_gyro_i2c.c
@@ -67,13 +67,11 @@ static int st_gyro_i2c_probe(struct i2c_client *client,
67 return -ENOMEM; 67 return -ENOMEM;
68 68
69 gdata = iio_priv(indio_dev); 69 gdata = iio_priv(indio_dev);
70 gdata->dev = &client->dev;
71 st_sensors_of_i2c_probe(client, st_gyro_of_match); 70 st_sensors_of_i2c_probe(client, st_gyro_of_match);
72 71
73 st_sensors_i2c_configure(indio_dev, client, gdata); 72 st_sensors_i2c_configure(indio_dev, client, gdata);
74 73
75 err = st_gyro_common_probe(indio_dev, 74 err = st_gyro_common_probe(indio_dev);
76 (struct st_sensors_platform_data *)&gyro_pdata);
77 if (err < 0) 75 if (err < 0)
78 return err; 76 return err;
79 77
diff --git a/drivers/iio/gyro/st_gyro_spi.c b/drivers/iio/gyro/st_gyro_spi.c
index b4ad3be26687..e59bead6bc3c 100644
--- a/drivers/iio/gyro/st_gyro_spi.c
+++ b/drivers/iio/gyro/st_gyro_spi.c
@@ -29,12 +29,10 @@ static int st_gyro_spi_probe(struct spi_device *spi)
29 return -ENOMEM; 29 return -ENOMEM;
30 30
31 gdata = iio_priv(indio_dev); 31 gdata = iio_priv(indio_dev);
32 gdata->dev = &spi->dev;
33 32
34 st_sensors_spi_configure(indio_dev, spi, gdata); 33 st_sensors_spi_configure(indio_dev, spi, gdata);
35 34
36 err = st_gyro_common_probe(indio_dev, 35 err = st_gyro_common_probe(indio_dev);
37 (struct st_sensors_platform_data *)&gyro_pdata);
38 if (err < 0) 36 if (err < 0)
39 return err; 37 return err;
40 38
diff --git a/drivers/iio/humidity/Kconfig b/drivers/iio/humidity/Kconfig
index e116bd8dd0e4..4813b793b9f7 100644
--- a/drivers/iio/humidity/Kconfig
+++ b/drivers/iio/humidity/Kconfig
@@ -22,4 +22,14 @@ config SI7005
22 To compile this driver as a module, choose M here: the module 22 To compile this driver as a module, choose M here: the module
23 will be called si7005. 23 will be called si7005.
24 24
25config SI7020
26 tristate "Si7013/20/21 Relative Humidity and Temperature Sensors"
27 depends on I2C
28 help
29 Say yes here to build support for the Silicon Labs Si7013/20/21
30 Relative Humidity and Temperature Sensors.
31
32 To compile this driver as a module, choose M here: the module
33 will be called si7020.
34
25endmenu 35endmenu
diff --git a/drivers/iio/humidity/Makefile b/drivers/iio/humidity/Makefile
index e3f3d942e646..86e2d26e9f4d 100644
--- a/drivers/iio/humidity/Makefile
+++ b/drivers/iio/humidity/Makefile
@@ -4,3 +4,4 @@
4 4
5obj-$(CONFIG_DHT11) += dht11.o 5obj-$(CONFIG_DHT11) += dht11.o
6obj-$(CONFIG_SI7005) += si7005.o 6obj-$(CONFIG_SI7005) += si7005.o
7obj-$(CONFIG_SI7020) += si7020.o
diff --git a/drivers/iio/humidity/dht11.c b/drivers/iio/humidity/dht11.c
index d8771f546bf2..623c145d8a97 100644
--- a/drivers/iio/humidity/dht11.c
+++ b/drivers/iio/humidity/dht11.c
@@ -281,7 +281,6 @@ static int dht11_probe(struct platform_device *pdev)
281static struct platform_driver dht11_driver = { 281static struct platform_driver dht11_driver = {
282 .driver = { 282 .driver = {
283 .name = DRIVER_NAME, 283 .name = DRIVER_NAME,
284 .owner = THIS_MODULE,
285 .of_match_table = dht11_dt_ids, 284 .of_match_table = dht11_dt_ids,
286 }, 285 },
287 .probe = dht11_probe, 286 .probe = dht11_probe,
diff --git a/drivers/iio/humidity/si7020.c b/drivers/iio/humidity/si7020.c
new file mode 100644
index 000000000000..b54164677b89
--- /dev/null
+++ b/drivers/iio/humidity/si7020.c
@@ -0,0 +1,161 @@
1/*
2 * si7020.c - Silicon Labs Si7013/20/21 Relative Humidity and Temp Sensors
3 * Copyright (c) 2013,2014 Uplogix, Inc.
4 * David Barksdale <dbarksdale@uplogix.com>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 */
15
16/*
17 * The Silicon Labs Si7013/20/21 Relative Humidity and Temperature Sensors
18 * are i2c devices which have an identical programming interface for
19 * measuring relative humidity and temperature. The Si7013 has an additional
20 * temperature input which this driver does not support.
21 *
22 * Data Sheets:
23 * Si7013: http://www.silabs.com/Support%20Documents/TechnicalDocs/Si7013.pdf
24 * Si7020: http://www.silabs.com/Support%20Documents/TechnicalDocs/Si7020.pdf
25 * Si7021: http://www.silabs.com/Support%20Documents/TechnicalDocs/Si7021.pdf
26 */
27
28#include <linux/delay.h>
29#include <linux/i2c.h>
30#include <linux/module.h>
31#include <linux/slab.h>
32#include <linux/sysfs.h>
33
34#include <linux/iio/iio.h>
35#include <linux/iio/sysfs.h>
36
37/* Measure Relative Humidity, Hold Master Mode */
38#define SI7020CMD_RH_HOLD 0xE5
39/* Measure Temperature, Hold Master Mode */
40#define SI7020CMD_TEMP_HOLD 0xE3
41/* Software Reset */
42#define SI7020CMD_RESET 0xFE
43
44static int si7020_read_raw(struct iio_dev *indio_dev,
45 struct iio_chan_spec const *chan, int *val,
46 int *val2, long mask)
47{
48 struct i2c_client *client = iio_priv(indio_dev);
49 int ret;
50
51 switch (mask) {
52 case IIO_CHAN_INFO_RAW:
53 ret = i2c_smbus_read_word_data(client,
54 chan->type == IIO_TEMP ?
55 SI7020CMD_TEMP_HOLD :
56 SI7020CMD_RH_HOLD);
57 if (ret < 0)
58 return ret;
59 *val = ret >> 2;
60 if (chan->type == IIO_HUMIDITYRELATIVE)
61 *val &= GENMASK(11, 0);
62 return IIO_VAL_INT;
63 case IIO_CHAN_INFO_SCALE:
64 if (chan->type == IIO_TEMP)
65 *val = 175720; /* = 175.72 * 1000 */
66 else
67 *val = 125 * 1000;
68 *val2 = 65536 >> 2;
69 return IIO_VAL_FRACTIONAL;
70 case IIO_CHAN_INFO_OFFSET:
71 /*
72 * Since iio_convert_raw_to_processed_unlocked assumes offset
73 * is an integer we have to round these values and lose
74 * accuracy.
75 * Relative humidity will be 0.0032959% too high and
76 * temperature will be 0.00277344 degrees too high.
77 * This is no big deal because it's within the accuracy of the
78 * sensor.
79 */
80 if (chan->type == IIO_TEMP)
81 *val = -4368; /* = -46.85 * (65536 >> 2) / 175.72 */
82 else
83 *val = -786; /* = -6 * (65536 >> 2) / 125 */
84 return IIO_VAL_INT;
85 default:
86 break;
87 }
88
89 return -EINVAL;
90}
91
92static const struct iio_chan_spec si7020_channels[] = {
93 {
94 .type = IIO_HUMIDITYRELATIVE,
95 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
96 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_OFFSET),
97 },
98 {
99 .type = IIO_TEMP,
100 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
101 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_OFFSET),
102 }
103};
104
105static const struct iio_info si7020_info = {
106 .read_raw = si7020_read_raw,
107 .driver_module = THIS_MODULE,
108};
109
110static int si7020_probe(struct i2c_client *client,
111 const struct i2c_device_id *id)
112{
113 struct iio_dev *indio_dev;
114 struct i2c_client **data;
115 int ret;
116
117 if (!i2c_check_functionality(client->adapter,
118 I2C_FUNC_SMBUS_WRITE_BYTE |
119 I2C_FUNC_SMBUS_READ_WORD_DATA))
120 return -ENODEV;
121
122 /* Reset device, loads default settings. */
123 ret = i2c_smbus_write_byte(client, SI7020CMD_RESET);
124 if (ret < 0)
125 return ret;
126 /* Wait the maximum power-up time after software reset. */
127 msleep(15);
128
129 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*client));
130 if (!indio_dev)
131 return -ENOMEM;
132
133 data = iio_priv(indio_dev);
134 *data = client;
135
136 indio_dev->dev.parent = &client->dev;
137 indio_dev->name = dev_name(&client->dev);
138 indio_dev->modes = INDIO_DIRECT_MODE;
139 indio_dev->info = &si7020_info;
140 indio_dev->channels = si7020_channels;
141 indio_dev->num_channels = ARRAY_SIZE(si7020_channels);
142
143 return devm_iio_device_register(&client->dev, indio_dev);
144}
145
146static const struct i2c_device_id si7020_id[] = {
147 { "si7020", 0 },
148 { }
149};
150MODULE_DEVICE_TABLE(i2c, si7020_id);
151
152static struct i2c_driver si7020_driver = {
153 .driver.name = "si7020",
154 .probe = si7020_probe,
155 .id_table = si7020_id,
156};
157
158module_i2c_driver(si7020_driver);
159MODULE_DESCRIPTION("Silicon Labs Si7013/20/21 Relative Humidity and Temperature Sensors");
160MODULE_AUTHOR("David Barksdale <dbarksdale@uplogix.com>");
161MODULE_LICENSE("GPL");
diff --git a/drivers/iio/imu/inv_mpu6050/inv_mpu_core.c b/drivers/iio/imu/inv_mpu6050/inv_mpu_core.c
index 0c6517c94a9d..b75519deac1a 100644
--- a/drivers/iio/imu/inv_mpu6050/inv_mpu_core.c
+++ b/drivers/iio/imu/inv_mpu6050/inv_mpu_core.c
@@ -673,8 +673,7 @@ static int inv_mpu_probe(struct i2c_client *client,
673 673
674 st = iio_priv(indio_dev); 674 st = iio_priv(indio_dev);
675 st->client = client; 675 st->client = client;
676 pdata = (struct inv_mpu6050_platform_data 676 pdata = dev_get_platdata(&client->dev);
677 *)dev_get_platdata(&client->dev);
678 if (pdata) 677 if (pdata)
679 st->plat_data = *pdata; 678 st->plat_data = *pdata;
680 /* power is turned on inside check chip type*/ 679 /* power is turned on inside check chip type*/
diff --git a/drivers/iio/industrialio-buffer.c b/drivers/iio/industrialio-buffer.c
index 0472ee268271..f971f79103ec 100644
--- a/drivers/iio/industrialio-buffer.c
+++ b/drivers/iio/industrialio-buffer.c
@@ -942,13 +942,34 @@ int iio_push_to_buffers(struct iio_dev *indio_dev, const void *data)
942} 942}
943EXPORT_SYMBOL_GPL(iio_push_to_buffers); 943EXPORT_SYMBOL_GPL(iio_push_to_buffers);
944 944
945static int iio_buffer_add_demux(struct iio_buffer *buffer,
946 struct iio_demux_table **p, unsigned int in_loc, unsigned int out_loc,
947 unsigned int length)
948{
949
950 if (*p && (*p)->from + (*p)->length == in_loc &&
951 (*p)->to + (*p)->length == out_loc) {
952 (*p)->length += length;
953 } else {
954 *p = kmalloc(sizeof(**p), GFP_KERNEL);
955 if (*p == NULL)
956 return -ENOMEM;
957 (*p)->from = in_loc;
958 (*p)->to = out_loc;
959 (*p)->length = length;
960 list_add_tail(&(*p)->l, &buffer->demux_list);
961 }
962
963 return 0;
964}
965
945static int iio_buffer_update_demux(struct iio_dev *indio_dev, 966static int iio_buffer_update_demux(struct iio_dev *indio_dev,
946 struct iio_buffer *buffer) 967 struct iio_buffer *buffer)
947{ 968{
948 const struct iio_chan_spec *ch; 969 const struct iio_chan_spec *ch;
949 int ret, in_ind = -1, out_ind, length; 970 int ret, in_ind = -1, out_ind, length;
950 unsigned in_loc = 0, out_loc = 0; 971 unsigned in_loc = 0, out_loc = 0;
951 struct iio_demux_table *p; 972 struct iio_demux_table *p = NULL;
952 973
953 /* Clear out any old demux */ 974 /* Clear out any old demux */
954 iio_buffer_demux_free(buffer); 975 iio_buffer_demux_free(buffer);
@@ -979,14 +1000,7 @@ static int iio_buffer_update_demux(struct iio_dev *indio_dev,
979 else 1000 else
980 length = ch->scan_type.storagebits / 8; 1001 length = ch->scan_type.storagebits / 8;
981 /* Make sure we are aligned */ 1002 /* Make sure we are aligned */
982 in_loc += length; 1003 in_loc = roundup(in_loc, length) + length;
983 if (in_loc % length)
984 in_loc += length - in_loc % length;
985 }
986 p = kmalloc(sizeof(*p), GFP_KERNEL);
987 if (p == NULL) {
988 ret = -ENOMEM;
989 goto error_clear_mux_table;
990 } 1004 }
991 ch = iio_find_channel_from_si(indio_dev, in_ind); 1005 ch = iio_find_channel_from_si(indio_dev, in_ind);
992 if (ch->scan_type.repeat > 1) 1006 if (ch->scan_type.repeat > 1)
@@ -994,24 +1008,16 @@ static int iio_buffer_update_demux(struct iio_dev *indio_dev,
994 ch->scan_type.repeat; 1008 ch->scan_type.repeat;
995 else 1009 else
996 length = ch->scan_type.storagebits / 8; 1010 length = ch->scan_type.storagebits / 8;
997 if (out_loc % length) 1011 out_loc = roundup(out_loc, length);
998 out_loc += length - out_loc % length; 1012 in_loc = roundup(in_loc, length);
999 if (in_loc % length) 1013 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
1000 in_loc += length - in_loc % length; 1014 if (ret)
1001 p->from = in_loc; 1015 goto error_clear_mux_table;
1002 p->to = out_loc;
1003 p->length = length;
1004 list_add_tail(&p->l, &buffer->demux_list);
1005 out_loc += length; 1016 out_loc += length;
1006 in_loc += length; 1017 in_loc += length;
1007 } 1018 }
1008 /* Relies on scan_timestamp being last */ 1019 /* Relies on scan_timestamp being last */
1009 if (buffer->scan_timestamp) { 1020 if (buffer->scan_timestamp) {
1010 p = kmalloc(sizeof(*p), GFP_KERNEL);
1011 if (p == NULL) {
1012 ret = -ENOMEM;
1013 goto error_clear_mux_table;
1014 }
1015 ch = iio_find_channel_from_si(indio_dev, 1021 ch = iio_find_channel_from_si(indio_dev,
1016 indio_dev->scan_index_timestamp); 1022 indio_dev->scan_index_timestamp);
1017 if (ch->scan_type.repeat > 1) 1023 if (ch->scan_type.repeat > 1)
@@ -1019,14 +1025,11 @@ static int iio_buffer_update_demux(struct iio_dev *indio_dev,
1019 ch->scan_type.repeat; 1025 ch->scan_type.repeat;
1020 else 1026 else
1021 length = ch->scan_type.storagebits / 8; 1027 length = ch->scan_type.storagebits / 8;
1022 if (out_loc % length) 1028 out_loc = roundup(out_loc, length);
1023 out_loc += length - out_loc % length; 1029 in_loc = roundup(in_loc, length);
1024 if (in_loc % length) 1030 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
1025 in_loc += length - in_loc % length; 1031 if (ret)
1026 p->from = in_loc; 1032 goto error_clear_mux_table;
1027 p->to = out_loc;
1028 p->length = length;
1029 list_add_tail(&p->l, &buffer->demux_list);
1030 out_loc += length; 1033 out_loc += length;
1031 in_loc += length; 1034 in_loc += length;
1032 } 1035 }
diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c
index f0846108d006..866fe904cba2 100644
--- a/drivers/iio/inkern.c
+++ b/drivers/iio/inkern.c
@@ -100,6 +100,28 @@ static int iio_dev_node_match(struct device *dev, void *data)
100 return dev->of_node == data && dev->type == &iio_device_type; 100 return dev->of_node == data && dev->type == &iio_device_type;
101} 101}
102 102
103/**
104 * __of_iio_simple_xlate - translate iiospec to the IIO channel index
105 * @indio_dev: pointer to the iio_dev structure
106 * @iiospec: IIO specifier as found in the device tree
107 *
108 * This is simple translation function, suitable for the most 1:1 mapped
109 * channels in IIO chips. This function performs only one sanity check:
110 * whether IIO index is less than num_channels (that is specified in the
111 * iio_dev).
112 */
113static int __of_iio_simple_xlate(struct iio_dev *indio_dev,
114 const struct of_phandle_args *iiospec)
115{
116 if (!iiospec->args_count)
117 return 0;
118
119 if (iiospec->args[0] >= indio_dev->num_channels)
120 return -EINVAL;
121
122 return iiospec->args[0];
123}
124
103static int __of_iio_channel_get(struct iio_channel *channel, 125static int __of_iio_channel_get(struct iio_channel *channel,
104 struct device_node *np, int index) 126 struct device_node *np, int index)
105{ 127{
@@ -122,18 +144,19 @@ static int __of_iio_channel_get(struct iio_channel *channel,
122 144
123 indio_dev = dev_to_iio_dev(idev); 145 indio_dev = dev_to_iio_dev(idev);
124 channel->indio_dev = indio_dev; 146 channel->indio_dev = indio_dev;
125 index = iiospec.args_count ? iiospec.args[0] : 0; 147 if (indio_dev->info->of_xlate)
126 if (index >= indio_dev->num_channels) { 148 index = indio_dev->info->of_xlate(indio_dev, &iiospec);
127 err = -EINVAL; 149 else
150 index = __of_iio_simple_xlate(indio_dev, &iiospec);
151 if (index < 0)
128 goto err_put; 152 goto err_put;
129 }
130 channel->channel = &indio_dev->channels[index]; 153 channel->channel = &indio_dev->channels[index];
131 154
132 return 0; 155 return 0;
133 156
134err_put: 157err_put:
135 iio_device_put(indio_dev); 158 iio_device_put(indio_dev);
136 return err; 159 return index;
137} 160}
138 161
139static struct iio_channel *of_iio_channel_get(struct device_node *np, int index) 162static struct iio_channel *of_iio_channel_get(struct device_node *np, int index)
diff --git a/drivers/iio/light/Kconfig b/drivers/iio/light/Kconfig
index bf05ca5b0a57..5bea821adcae 100644
--- a/drivers/iio/light/Kconfig
+++ b/drivers/iio/light/Kconfig
@@ -17,6 +17,16 @@ config ADJD_S311
17 This driver can also be built as a module. If so, the module 17 This driver can also be built as a module. If so, the module
18 will be called adjd_s311. 18 will be called adjd_s311.
19 19
20config AL3320A
21 tristate "AL3320A ambient light sensor"
22 depends on I2C
23 help
24 Say Y here if you want to build a driver for the Dyna Image AL3320A
25 ambient light sensor.
26
27 To compile this driver as a module, choose M here: the
28 module will be called al3320a.
29
20config APDS9300 30config APDS9300
21 tristate "APDS9300 ambient light sensor" 31 tristate "APDS9300 ambient light sensor"
22 depends on I2C 32 depends on I2C
diff --git a/drivers/iio/light/Makefile b/drivers/iio/light/Makefile
index 8b8c09f9c1f8..47877a36cc12 100644
--- a/drivers/iio/light/Makefile
+++ b/drivers/iio/light/Makefile
@@ -4,6 +4,7 @@
4 4
5# When adding new entries keep the list in alphabetical order 5# When adding new entries keep the list in alphabetical order
6obj-$(CONFIG_ADJD_S311) += adjd_s311.o 6obj-$(CONFIG_ADJD_S311) += adjd_s311.o
7obj-$(CONFIG_AL3320A) += al3320a.o
7obj-$(CONFIG_APDS9300) += apds9300.o 8obj-$(CONFIG_APDS9300) += apds9300.o
8obj-$(CONFIG_CM32181) += cm32181.o 9obj-$(CONFIG_CM32181) += cm32181.o
9obj-$(CONFIG_CM36651) += cm36651.o 10obj-$(CONFIG_CM36651) += cm36651.o
diff --git a/drivers/iio/light/al3320a.c b/drivers/iio/light/al3320a.c
new file mode 100644
index 000000000000..6aac6513fd41
--- /dev/null
+++ b/drivers/iio/light/al3320a.c
@@ -0,0 +1,232 @@
1/*
2 * AL3320A - Dyna Image Ambient Light Sensor
3 *
4 * Copyright (c) 2014, Intel Corporation.
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 * IIO driver for AL3320A (7-bit I2C slave address 0x1C).
11 *
12 * TODO: interrupt support, thresholds
13 *
14 */
15
16#include <linux/module.h>
17#include <linux/init.h>
18#include <linux/i2c.h>
19
20#include <linux/iio/iio.h>
21#include <linux/iio/sysfs.h>
22
23#define AL3320A_DRV_NAME "al3320a"
24
25#define AL3320A_REG_CONFIG 0x00
26#define AL3320A_REG_STATUS 0x01
27#define AL3320A_REG_INT 0x02
28#define AL3320A_REG_WAIT 0x06
29#define AL3320A_REG_CONFIG_RANGE 0x07
30#define AL3320A_REG_PERSIST 0x08
31#define AL3320A_REG_MEAN_TIME 0x09
32#define AL3320A_REG_ADUMMY 0x0A
33#define AL3320A_REG_DATA_LOW 0x22
34
35#define AL3320A_REG_LOW_THRESH_LOW 0x30
36#define AL3320A_REG_LOW_THRESH_HIGH 0x31
37#define AL3320A_REG_HIGH_THRESH_LOW 0x32
38#define AL3320A_REG_HIGH_THRESH_HIGH 0x33
39
40#define AL3320A_CONFIG_DISABLE 0x00
41#define AL3320A_CONFIG_ENABLE 0x01
42
43#define AL3320A_GAIN_SHIFT 1
44#define AL3320A_GAIN_MASK (BIT(2) | BIT(1))
45
46/* chip params default values */
47#define AL3320A_DEFAULT_MEAN_TIME 4
48#define AL3320A_DEFAULT_WAIT_TIME 0 /* no waiting */
49
50#define AL3320A_SCALE_AVAILABLE "0.512 0.128 0.032 0.01"
51
52enum al3320a_range {
53 AL3320A_RANGE_1, /* 33.28 Klx */
54 AL3320A_RANGE_2, /* 8.32 Klx */
55 AL3320A_RANGE_3, /* 2.08 Klx */
56 AL3320A_RANGE_4 /* 0.65 Klx */
57};
58
59static const int al3320a_scales[][2] = {
60 {0, 512000}, {0, 128000}, {0, 32000}, {0, 10000}
61};
62
63struct al3320a_data {
64 struct i2c_client *client;
65};
66
67static const struct iio_chan_spec al3320a_channels[] = {
68 {
69 .type = IIO_LIGHT,
70 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
71 BIT(IIO_CHAN_INFO_SCALE),
72 }
73};
74
75static IIO_CONST_ATTR(in_illuminance_scale_available, AL3320A_SCALE_AVAILABLE);
76
77static struct attribute *al3320a_attributes[] = {
78 &iio_const_attr_in_illuminance_scale_available.dev_attr.attr,
79 NULL,
80};
81
82static const struct attribute_group al3320a_attribute_group = {
83 .attrs = al3320a_attributes,
84};
85
86static int al3320a_init(struct al3320a_data *data)
87{
88 int ret;
89
90 /* power on */
91 ret = i2c_smbus_write_byte_data(data->client, AL3320A_REG_CONFIG,
92 AL3320A_CONFIG_ENABLE);
93 if (ret < 0)
94 return ret;
95
96 ret = i2c_smbus_write_byte_data(data->client, AL3320A_REG_CONFIG_RANGE,
97 AL3320A_RANGE_3 << AL3320A_GAIN_SHIFT);
98 if (ret < 0)
99 return ret;
100
101 ret = i2c_smbus_write_byte_data(data->client, AL3320A_REG_MEAN_TIME,
102 AL3320A_DEFAULT_MEAN_TIME);
103 if (ret < 0)
104 return ret;
105
106 ret = i2c_smbus_write_byte_data(data->client, AL3320A_REG_WAIT,
107 AL3320A_DEFAULT_WAIT_TIME);
108 if (ret < 0)
109 return ret;
110
111 return 0;
112}
113
114static int al3320a_read_raw(struct iio_dev *indio_dev,
115 struct iio_chan_spec const *chan, int *val,
116 int *val2, long mask)
117{
118 struct al3320a_data *data = iio_priv(indio_dev);
119 int ret;
120
121 switch (mask) {
122 case IIO_CHAN_INFO_RAW:
123 /*
124 * ALS ADC value is stored in two adjacent registers:
125 * - low byte of output is stored at AL3320A_REG_DATA_LOW
126 * - high byte of output is stored at AL3320A_REG_DATA_LOW + 1
127 */
128 ret = i2c_smbus_read_word_data(data->client,
129 AL3320A_REG_DATA_LOW);
130 if (ret < 0)
131 return ret;
132 *val = ret;
133 return IIO_VAL_INT;
134 case IIO_CHAN_INFO_SCALE:
135 ret = i2c_smbus_read_byte_data(data->client,
136 AL3320A_REG_CONFIG_RANGE);
137 if (ret < 0)
138 return ret;
139
140 ret = (ret & AL3320A_GAIN_MASK) >> AL3320A_GAIN_SHIFT;
141 *val = al3320a_scales[ret][0];
142 *val2 = al3320a_scales[ret][1];
143
144 return IIO_VAL_INT_PLUS_MICRO;
145 }
146 return -EINVAL;
147}
148
149static int al3320a_write_raw(struct iio_dev *indio_dev,
150 struct iio_chan_spec const *chan, int val,
151 int val2, long mask)
152{
153 struct al3320a_data *data = iio_priv(indio_dev);
154 int i;
155
156 switch (mask) {
157 case IIO_CHAN_INFO_SCALE:
158 for (i = 0; i < ARRAY_SIZE(al3320a_scales); i++) {
159 if (val == al3320a_scales[i][0] &&
160 val2 == al3320a_scales[i][1])
161 return i2c_smbus_write_byte_data(data->client,
162 AL3320A_REG_CONFIG_RANGE,
163 i << AL3320A_GAIN_SHIFT);
164 }
165 break;
166 }
167 return -EINVAL;
168}
169
170static const struct iio_info al3320a_info = {
171 .driver_module = THIS_MODULE,
172 .read_raw = al3320a_read_raw,
173 .write_raw = al3320a_write_raw,
174 .attrs = &al3320a_attribute_group,
175};
176
177static int al3320a_probe(struct i2c_client *client,
178 const struct i2c_device_id *id)
179{
180 struct al3320a_data *data;
181 struct iio_dev *indio_dev;
182 int ret;
183
184 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
185 if (!indio_dev)
186 return -ENOMEM;
187
188 data = iio_priv(indio_dev);
189 i2c_set_clientdata(client, indio_dev);
190 data->client = client;
191
192 indio_dev->dev.parent = &client->dev;
193 indio_dev->info = &al3320a_info;
194 indio_dev->name = AL3320A_DRV_NAME;
195 indio_dev->channels = al3320a_channels;
196 indio_dev->num_channels = ARRAY_SIZE(al3320a_channels);
197 indio_dev->modes = INDIO_DIRECT_MODE;
198
199 ret = al3320a_init(data);
200 if (ret < 0) {
201 dev_err(&client->dev, "al3320a chip init failed\n");
202 return ret;
203 }
204 return devm_iio_device_register(&client->dev, indio_dev);
205}
206
207static int al3320a_remove(struct i2c_client *client)
208{
209 return i2c_smbus_write_byte_data(client, AL3320A_REG_CONFIG,
210 AL3320A_CONFIG_DISABLE);
211}
212
213static const struct i2c_device_id al3320a_id[] = {
214 {"al3320a", 0},
215 {}
216};
217MODULE_DEVICE_TABLE(i2c, al3320a_id);
218
219static struct i2c_driver al3320a_driver = {
220 .driver = {
221 .name = AL3320A_DRV_NAME,
222 },
223 .probe = al3320a_probe,
224 .remove = al3320a_remove,
225 .id_table = al3320a_id,
226};
227
228module_i2c_driver(al3320a_driver);
229
230MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
231MODULE_DESCRIPTION("AL3320A Ambient Light Sensor driver");
232MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/light/hid-sensor-als.c b/drivers/iio/light/hid-sensor-als.c
index 96e71e103ea7..a5283d75c096 100644
--- a/drivers/iio/light/hid-sensor-als.c
+++ b/drivers/iio/light/hid-sensor-als.c
@@ -381,7 +381,6 @@ static struct platform_driver hid_als_platform_driver = {
381 .id_table = hid_als_ids, 381 .id_table = hid_als_ids,
382 .driver = { 382 .driver = {
383 .name = KBUILD_MODNAME, 383 .name = KBUILD_MODNAME,
384 .owner = THIS_MODULE,
385 }, 384 },
386 .probe = hid_als_probe, 385 .probe = hid_als_probe,
387 .remove = hid_als_remove, 386 .remove = hid_als_remove,
diff --git a/drivers/iio/light/hid-sensor-prox.c b/drivers/iio/light/hid-sensor-prox.c
index 412bae86d6ae..f5a514698fd8 100644
--- a/drivers/iio/light/hid-sensor-prox.c
+++ b/drivers/iio/light/hid-sensor-prox.c
@@ -373,7 +373,6 @@ static struct platform_driver hid_prox_platform_driver = {
373 .id_table = hid_prox_ids, 373 .id_table = hid_prox_ids,
374 .driver = { 374 .driver = {
375 .name = KBUILD_MODNAME, 375 .name = KBUILD_MODNAME,
376 .owner = THIS_MODULE,
377 }, 376 },
378 .probe = hid_prox_probe, 377 .probe = hid_prox_probe,
379 .remove = hid_prox_remove, 378 .remove = hid_prox_remove,
diff --git a/drivers/iio/light/lm3533-als.c b/drivers/iio/light/lm3533-als.c
index c1aadc6b865a..ae3c71bdd6c6 100644
--- a/drivers/iio/light/lm3533-als.c
+++ b/drivers/iio/light/lm3533-als.c
@@ -915,7 +915,6 @@ static int lm3533_als_remove(struct platform_device *pdev)
915static struct platform_driver lm3533_als_driver = { 915static struct platform_driver lm3533_als_driver = {
916 .driver = { 916 .driver = {
917 .name = "lm3533-als", 917 .name = "lm3533-als",
918 .owner = THIS_MODULE,
919 }, 918 },
920 .probe = lm3533_als_probe, 919 .probe = lm3533_als_probe,
921 .remove = lm3533_als_remove, 920 .remove = lm3533_als_remove,
diff --git a/drivers/iio/light/tsl4531.c b/drivers/iio/light/tsl4531.c
index a15006efa137..0763b8632573 100644
--- a/drivers/iio/light/tsl4531.c
+++ b/drivers/iio/light/tsl4531.c
@@ -230,9 +230,12 @@ static int tsl4531_resume(struct device *dev)
230 return i2c_smbus_write_byte_data(to_i2c_client(dev), TSL4531_CONTROL, 230 return i2c_smbus_write_byte_data(to_i2c_client(dev), TSL4531_CONTROL,
231 TSL4531_MODE_NORMAL); 231 TSL4531_MODE_NORMAL);
232} 232}
233#endif
234 233
235static SIMPLE_DEV_PM_OPS(tsl4531_pm_ops, tsl4531_suspend, tsl4531_resume); 234static SIMPLE_DEV_PM_OPS(tsl4531_pm_ops, tsl4531_suspend, tsl4531_resume);
235#define TSL4531_PM_OPS (&tsl4531_pm_ops)
236#else
237#define TSL4531_PM_OPS NULL
238#endif
236 239
237static const struct i2c_device_id tsl4531_id[] = { 240static const struct i2c_device_id tsl4531_id[] = {
238 { "tsl4531", 0 }, 241 { "tsl4531", 0 },
@@ -243,7 +246,7 @@ MODULE_DEVICE_TABLE(i2c, tsl4531_id);
243static struct i2c_driver tsl4531_driver = { 246static struct i2c_driver tsl4531_driver = {
244 .driver = { 247 .driver = {
245 .name = TSL4531_DRV_NAME, 248 .name = TSL4531_DRV_NAME,
246 .pm = &tsl4531_pm_ops, 249 .pm = TSL4531_PM_OPS,
247 .owner = THIS_MODULE, 250 .owner = THIS_MODULE,
248 }, 251 },
249 .probe = tsl4531_probe, 252 .probe = tsl4531_probe,
diff --git a/drivers/iio/magnetometer/ak8975.c b/drivers/iio/magnetometer/ak8975.c
index a2357921d761..bf5ef077e791 100644
--- a/drivers/iio/magnetometer/ak8975.c
+++ b/drivers/iio/magnetometer/ak8975.c
@@ -477,8 +477,8 @@ static const struct acpi_device_id ak_acpi_match[] = {
477}; 477};
478MODULE_DEVICE_TABLE(acpi, ak_acpi_match); 478MODULE_DEVICE_TABLE(acpi, ak_acpi_match);
479 479
480static char *ak8975_match_acpi_device(struct device *dev, 480static const char *ak8975_match_acpi_device(struct device *dev,
481 enum asahi_compass_chipset *chipset) 481 enum asahi_compass_chipset *chipset)
482{ 482{
483 const struct acpi_device_id *id; 483 const struct acpi_device_id *id;
484 484
@@ -487,7 +487,7 @@ static char *ak8975_match_acpi_device(struct device *dev,
487 return NULL; 487 return NULL;
488 *chipset = (int)id->driver_data; 488 *chipset = (int)id->driver_data;
489 489
490 return (char *)dev_name(dev); 490 return dev_name(dev);
491} 491}
492 492
493static int ak8975_probe(struct i2c_client *client, 493static int ak8975_probe(struct i2c_client *client,
@@ -497,7 +497,7 @@ static int ak8975_probe(struct i2c_client *client,
497 struct iio_dev *indio_dev; 497 struct iio_dev *indio_dev;
498 int eoc_gpio; 498 int eoc_gpio;
499 int err; 499 int err;
500 char *name = NULL; 500 const char *name = NULL;
501 501
502 /* Grab and set up the supplied GPIO. */ 502 /* Grab and set up the supplied GPIO. */
503 if (client->dev.platform_data) 503 if (client->dev.platform_data)
@@ -539,7 +539,7 @@ static int ak8975_probe(struct i2c_client *client,
539 if (id) { 539 if (id) {
540 data->chipset = 540 data->chipset =
541 (enum asahi_compass_chipset)(id->driver_data); 541 (enum asahi_compass_chipset)(id->driver_data);
542 name = (char *) id->name; 542 name = id->name;
543 } else if (ACPI_HANDLE(&client->dev)) 543 } else if (ACPI_HANDLE(&client->dev))
544 name = ak8975_match_acpi_device(&client->dev, &data->chipset); 544 name = ak8975_match_acpi_device(&client->dev, &data->chipset);
545 else 545 else
diff --git a/drivers/iio/magnetometer/hid-sensor-magn-3d.c b/drivers/iio/magnetometer/hid-sensor-magn-3d.c
index 3ec777a8f64e..6294575d2777 100644
--- a/drivers/iio/magnetometer/hid-sensor-magn-3d.c
+++ b/drivers/iio/magnetometer/hid-sensor-magn-3d.c
@@ -246,8 +246,7 @@ static const struct iio_info magn_3d_info = {
246}; 246};
247 247
248/* Function to push data to buffer */ 248/* Function to push data to buffer */
249static void hid_sensor_push_data(struct iio_dev *indio_dev, const void *data, 249static void hid_sensor_push_data(struct iio_dev *indio_dev, const void *data)
250 int len)
251{ 250{
252 dev_dbg(&indio_dev->dev, "hid_sensor_push_data\n"); 251 dev_dbg(&indio_dev->dev, "hid_sensor_push_data\n");
253 iio_push_to_buffers(indio_dev, data); 252 iio_push_to_buffers(indio_dev, data);
@@ -263,9 +262,7 @@ static int magn_3d_proc_event(struct hid_sensor_hub_device *hsdev,
263 262
264 dev_dbg(&indio_dev->dev, "magn_3d_proc_event\n"); 263 dev_dbg(&indio_dev->dev, "magn_3d_proc_event\n");
265 if (atomic_read(&magn_state->common_attributes.data_ready)) 264 if (atomic_read(&magn_state->common_attributes.data_ready))
266 hid_sensor_push_data(indio_dev, 265 hid_sensor_push_data(indio_dev, magn_state->iio_vals);
267 magn_state->iio_vals,
268 sizeof(magn_state->iio_vals));
269 266
270 return 0; 267 return 0;
271} 268}
@@ -533,7 +530,6 @@ static struct platform_driver hid_magn_3d_platform_driver = {
533 .id_table = hid_magn_3d_ids, 530 .id_table = hid_magn_3d_ids,
534 .driver = { 531 .driver = {
535 .name = KBUILD_MODNAME, 532 .name = KBUILD_MODNAME,
536 .owner = THIS_MODULE,
537 }, 533 },
538 .probe = hid_magn_3d_probe, 534 .probe = hid_magn_3d_probe,
539 .remove = hid_magn_3d_remove, 535 .remove = hid_magn_3d_remove,
diff --git a/drivers/iio/magnetometer/st_magn.h b/drivers/iio/magnetometer/st_magn.h
index 694e33e0fb72..7e81d00ef0c3 100644
--- a/drivers/iio/magnetometer/st_magn.h
+++ b/drivers/iio/magnetometer/st_magn.h
@@ -18,8 +18,7 @@
18#define LSM303DLM_MAGN_DEV_NAME "lsm303dlm_magn" 18#define LSM303DLM_MAGN_DEV_NAME "lsm303dlm_magn"
19#define LIS3MDL_MAGN_DEV_NAME "lis3mdl" 19#define LIS3MDL_MAGN_DEV_NAME "lis3mdl"
20 20
21int st_magn_common_probe(struct iio_dev *indio_dev, 21int st_magn_common_probe(struct iio_dev *indio_dev);
22 struct st_sensors_platform_data *pdata);
23void st_magn_common_remove(struct iio_dev *indio_dev); 22void st_magn_common_remove(struct iio_dev *indio_dev);
24 23
25#ifdef CONFIG_IIO_BUFFER 24#ifdef CONFIG_IIO_BUFFER
diff --git a/drivers/iio/magnetometer/st_magn_core.c b/drivers/iio/magnetometer/st_magn_core.c
index 68cae86dbd29..8ade473f99fe 100644
--- a/drivers/iio/magnetometer/st_magn_core.c
+++ b/drivers/iio/magnetometer/st_magn_core.c
@@ -149,7 +149,7 @@ static const struct iio_chan_spec st_magn_2_16bit_channels[] = {
149 IIO_CHAN_SOFT_TIMESTAMP(3) 149 IIO_CHAN_SOFT_TIMESTAMP(3)
150}; 150};
151 151
152static const struct st_sensors st_magn_sensors[] = { 152static const struct st_sensor_settings st_magn_sensors_settings[] = {
153 { 153 {
154 .wai = ST_MAGN_1_WAI_EXP, 154 .wai = ST_MAGN_1_WAI_EXP,
155 .sensors_supported = { 155 .sensors_supported = {
@@ -361,8 +361,7 @@ static const struct iio_info magn_info = {
361 .write_raw = &st_magn_write_raw, 361 .write_raw = &st_magn_write_raw,
362}; 362};
363 363
364int st_magn_common_probe(struct iio_dev *indio_dev, 364int st_magn_common_probe(struct iio_dev *indio_dev)
365 struct st_sensors_platform_data *pdata)
366{ 365{
367 struct st_sensor_data *mdata = iio_priv(indio_dev); 366 struct st_sensor_data *mdata = iio_priv(indio_dev);
368 int irq = mdata->get_irq_data_ready(indio_dev); 367 int irq = mdata->get_irq_data_ready(indio_dev);
@@ -374,20 +373,21 @@ int st_magn_common_probe(struct iio_dev *indio_dev,
374 st_sensors_power_enable(indio_dev); 373 st_sensors_power_enable(indio_dev);
375 374
376 err = st_sensors_check_device_support(indio_dev, 375 err = st_sensors_check_device_support(indio_dev,
377 ARRAY_SIZE(st_magn_sensors), st_magn_sensors); 376 ARRAY_SIZE(st_magn_sensors_settings),
377 st_magn_sensors_settings);
378 if (err < 0) 378 if (err < 0)
379 return err; 379 return err;
380 380
381 mdata->num_data_channels = ST_MAGN_NUMBER_DATA_CHANNELS; 381 mdata->num_data_channels = ST_MAGN_NUMBER_DATA_CHANNELS;
382 mdata->multiread_bit = mdata->sensor->multi_read_bit; 382 mdata->multiread_bit = mdata->sensor_settings->multi_read_bit;
383 indio_dev->channels = mdata->sensor->ch; 383 indio_dev->channels = mdata->sensor_settings->ch;
384 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS; 384 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
385 385
386 mdata->current_fullscale = (struct st_sensor_fullscale_avl *) 386 mdata->current_fullscale = (struct st_sensor_fullscale_avl *)
387 &mdata->sensor->fs.fs_avl[0]; 387 &mdata->sensor_settings->fs.fs_avl[0];
388 mdata->odr = mdata->sensor->odr.odr_avl[0].hz; 388 mdata->odr = mdata->sensor_settings->odr.odr_avl[0].hz;
389 389
390 err = st_sensors_init_sensor(indio_dev, pdata); 390 err = st_sensors_init_sensor(indio_dev, NULL);
391 if (err < 0) 391 if (err < 0)
392 return err; 392 return err;
393 393
diff --git a/drivers/iio/magnetometer/st_magn_i2c.c b/drivers/iio/magnetometer/st_magn_i2c.c
index 689250058442..92e5c15452a3 100644
--- a/drivers/iio/magnetometer/st_magn_i2c.c
+++ b/drivers/iio/magnetometer/st_magn_i2c.c
@@ -51,12 +51,11 @@ static int st_magn_i2c_probe(struct i2c_client *client,
51 return -ENOMEM; 51 return -ENOMEM;
52 52
53 mdata = iio_priv(indio_dev); 53 mdata = iio_priv(indio_dev);
54 mdata->dev = &client->dev;
55 st_sensors_of_i2c_probe(client, st_magn_of_match); 54 st_sensors_of_i2c_probe(client, st_magn_of_match);
56 55
57 st_sensors_i2c_configure(indio_dev, client, mdata); 56 st_sensors_i2c_configure(indio_dev, client, mdata);
58 57
59 err = st_magn_common_probe(indio_dev, NULL); 58 err = st_magn_common_probe(indio_dev);
60 if (err < 0) 59 if (err < 0)
61 return err; 60 return err;
62 61
diff --git a/drivers/iio/magnetometer/st_magn_spi.c b/drivers/iio/magnetometer/st_magn_spi.c
index a6143ea51dfc..7adacf160146 100644
--- a/drivers/iio/magnetometer/st_magn_spi.c
+++ b/drivers/iio/magnetometer/st_magn_spi.c
@@ -29,11 +29,10 @@ static int st_magn_spi_probe(struct spi_device *spi)
29 return -ENOMEM; 29 return -ENOMEM;
30 30
31 mdata = iio_priv(indio_dev); 31 mdata = iio_priv(indio_dev);
32 mdata->dev = &spi->dev;
33 32
34 st_sensors_spi_configure(indio_dev, spi, mdata); 33 st_sensors_spi_configure(indio_dev, spi, mdata);
35 34
36 err = st_magn_common_probe(indio_dev, NULL); 35 err = st_magn_common_probe(indio_dev);
37 if (err < 0) 36 if (err < 0)
38 return err; 37 return err;
39 38
diff --git a/drivers/iio/orientation/hid-sensor-incl-3d.c b/drivers/iio/orientation/hid-sensor-incl-3d.c
index 2478f6c2ef25..1ff181bbbcef 100644
--- a/drivers/iio/orientation/hid-sensor-incl-3d.c
+++ b/drivers/iio/orientation/hid-sensor-incl-3d.c
@@ -437,7 +437,6 @@ static struct platform_driver hid_incl_3d_platform_driver = {
437 .id_table = hid_incl_3d_ids, 437 .id_table = hid_incl_3d_ids,
438 .driver = { 438 .driver = {
439 .name = KBUILD_MODNAME, 439 .name = KBUILD_MODNAME,
440 .owner = THIS_MODULE,
441 }, 440 },
442 .probe = hid_incl_3d_probe, 441 .probe = hid_incl_3d_probe,
443 .remove = hid_incl_3d_remove, 442 .remove = hid_incl_3d_remove,
diff --git a/drivers/iio/orientation/hid-sensor-rotation.c b/drivers/iio/orientation/hid-sensor-rotation.c
index dccf848e8b0f..4afb6c79ccbc 100644
--- a/drivers/iio/orientation/hid-sensor-rotation.c
+++ b/drivers/iio/orientation/hid-sensor-rotation.c
@@ -334,7 +334,6 @@ static struct platform_driver hid_dev_rot_platform_driver = {
334 .id_table = hid_dev_rot_ids, 334 .id_table = hid_dev_rot_ids,
335 .driver = { 335 .driver = {
336 .name = KBUILD_MODNAME, 336 .name = KBUILD_MODNAME,
337 .owner = THIS_MODULE,
338 }, 337 },
339 .probe = hid_dev_rot_probe, 338 .probe = hid_dev_rot_probe,
340 .remove = hid_dev_rot_remove, 339 .remove = hid_dev_rot_remove,
diff --git a/drivers/iio/pressure/Kconfig b/drivers/iio/pressure/Kconfig
index 15afbc919521..a3be53792072 100644
--- a/drivers/iio/pressure/Kconfig
+++ b/drivers/iio/pressure/Kconfig
@@ -5,6 +5,17 @@
5 5
6menu "Pressure sensors" 6menu "Pressure sensors"
7 7
8config BMP280
9 tristate "Bosch Sensortec BMP280 pressure sensor driver"
10 depends on I2C
11 select REGMAP_I2C
12 help
13 Say yes here to build support for Bosch Sensortec BMP280
14 pressure and temperature sensor.
15
16 To compile this driver as a module, choose M here: the module
17 will be called bmp280.
18
8config HID_SENSOR_PRESS 19config HID_SENSOR_PRESS
9 depends on HID_SENSOR_HUB 20 depends on HID_SENSOR_HUB
10 select IIO_BUFFER 21 select IIO_BUFFER
diff --git a/drivers/iio/pressure/Makefile b/drivers/iio/pressure/Makefile
index 90a37e85cf21..88011f2ae00e 100644
--- a/drivers/iio/pressure/Makefile
+++ b/drivers/iio/pressure/Makefile
@@ -3,6 +3,7 @@
3# 3#
4 4
5# When adding new entries keep the list in alphabetical order 5# When adding new entries keep the list in alphabetical order
6obj-$(CONFIG_BMP280) += bmp280.o
6obj-$(CONFIG_HID_SENSOR_PRESS) += hid-sensor-press.o 7obj-$(CONFIG_HID_SENSOR_PRESS) += hid-sensor-press.o
7obj-$(CONFIG_MPL115) += mpl115.o 8obj-$(CONFIG_MPL115) += mpl115.o
8obj-$(CONFIG_MPL3115) += mpl3115.o 9obj-$(CONFIG_MPL3115) += mpl3115.o
diff --git a/drivers/iio/pressure/bmp280.c b/drivers/iio/pressure/bmp280.c
new file mode 100644
index 000000000000..75038dacfff1
--- /dev/null
+++ b/drivers/iio/pressure/bmp280.c
@@ -0,0 +1,455 @@
1/*
2 * Copyright (c) 2014 Intel Corporation
3 *
4 * Driver for Bosch Sensortec BMP280 digital pressure sensor.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 */
11
12#define pr_fmt(fmt) "bmp280: " fmt
13
14#include <linux/module.h>
15#include <linux/i2c.h>
16#include <linux/acpi.h>
17#include <linux/regmap.h>
18#include <linux/iio/iio.h>
19#include <linux/iio/sysfs.h>
20
21#define BMP280_REG_TEMP_XLSB 0xFC
22#define BMP280_REG_TEMP_LSB 0xFB
23#define BMP280_REG_TEMP_MSB 0xFA
24#define BMP280_REG_PRESS_XLSB 0xF9
25#define BMP280_REG_PRESS_LSB 0xF8
26#define BMP280_REG_PRESS_MSB 0xF7
27
28#define BMP280_REG_CONFIG 0xF5
29#define BMP280_REG_CTRL_MEAS 0xF4
30#define BMP280_REG_STATUS 0xF3
31#define BMP280_REG_RESET 0xE0
32#define BMP280_REG_ID 0xD0
33
34#define BMP280_REG_COMP_TEMP_START 0x88
35#define BMP280_COMP_TEMP_REG_COUNT 6
36
37#define BMP280_REG_COMP_PRESS_START 0x8E
38#define BMP280_COMP_PRESS_REG_COUNT 18
39
40#define BMP280_FILTER_MASK (BIT(4) | BIT(3) | BIT(2))
41#define BMP280_FILTER_OFF 0
42#define BMP280_FILTER_2X BIT(2)
43#define BMP280_FILTER_4X BIT(3)
44#define BMP280_FILTER_8X (BIT(3) | BIT(2))
45#define BMP280_FILTER_16X BIT(4)
46
47#define BMP280_OSRS_TEMP_MASK (BIT(7) | BIT(6) | BIT(5))
48#define BMP280_OSRS_TEMP_SKIP 0
49#define BMP280_OSRS_TEMP_1X BIT(5)
50#define BMP280_OSRS_TEMP_2X BIT(6)
51#define BMP280_OSRS_TEMP_4X (BIT(6) | BIT(5))
52#define BMP280_OSRS_TEMP_8X BIT(7)
53#define BMP280_OSRS_TEMP_16X (BIT(7) | BIT(5))
54
55#define BMP280_OSRS_PRESS_MASK (BIT(4) | BIT(3) | BIT(2))
56#define BMP280_OSRS_PRESS_SKIP 0
57#define BMP280_OSRS_PRESS_1X BIT(2)
58#define BMP280_OSRS_PRESS_2X BIT(3)
59#define BMP280_OSRS_PRESS_4X (BIT(3) | BIT(2))
60#define BMP280_OSRS_PRESS_8X BIT(4)
61#define BMP280_OSRS_PRESS_16X (BIT(4) | BIT(2))
62
63#define BMP280_MODE_MASK (BIT(1) | BIT(0))
64#define BMP280_MODE_SLEEP 0
65#define BMP280_MODE_FORCED BIT(0)
66#define BMP280_MODE_NORMAL (BIT(1) | BIT(0))
67
68#define BMP280_CHIP_ID 0x58
69#define BMP280_SOFT_RESET_VAL 0xB6
70
71struct bmp280_data {
72 struct i2c_client *client;
73 struct mutex lock;
74 struct regmap *regmap;
75
76 /*
77 * Carryover value from temperature conversion, used in pressure
78 * calculation.
79 */
80 s32 t_fine;
81};
82
83/* Compensation parameters. */
84struct bmp280_comp_temp {
85 u16 dig_t1;
86 s16 dig_t2, dig_t3;
87};
88
89struct bmp280_comp_press {
90 u16 dig_p1;
91 s16 dig_p2, dig_p3, dig_p4, dig_p5, dig_p6, dig_p7, dig_p8, dig_p9;
92};
93
94static const struct iio_chan_spec bmp280_channels[] = {
95 {
96 .type = IIO_PRESSURE,
97 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
98 },
99 {
100 .type = IIO_TEMP,
101 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
102 },
103};
104
105static bool bmp280_is_writeable_reg(struct device *dev, unsigned int reg)
106{
107 switch (reg) {
108 case BMP280_REG_CONFIG:
109 case BMP280_REG_CTRL_MEAS:
110 case BMP280_REG_RESET:
111 return true;
112 default:
113 return false;
114 };
115}
116
117static bool bmp280_is_volatile_reg(struct device *dev, unsigned int reg)
118{
119 switch (reg) {
120 case BMP280_REG_TEMP_XLSB:
121 case BMP280_REG_TEMP_LSB:
122 case BMP280_REG_TEMP_MSB:
123 case BMP280_REG_PRESS_XLSB:
124 case BMP280_REG_PRESS_LSB:
125 case BMP280_REG_PRESS_MSB:
126 case BMP280_REG_STATUS:
127 return true;
128 default:
129 return false;
130 }
131}
132
133static const struct regmap_config bmp280_regmap_config = {
134 .reg_bits = 8,
135 .val_bits = 8,
136
137 .max_register = BMP280_REG_TEMP_XLSB,
138 .cache_type = REGCACHE_RBTREE,
139
140 .writeable_reg = bmp280_is_writeable_reg,
141 .volatile_reg = bmp280_is_volatile_reg,
142};
143
144static int bmp280_read_compensation_temp(struct bmp280_data *data,
145 struct bmp280_comp_temp *comp)
146{
147 int ret;
148 __le16 buf[BMP280_COMP_TEMP_REG_COUNT / 2];
149
150 ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_TEMP_START,
151 buf, BMP280_COMP_TEMP_REG_COUNT);
152 if (ret < 0) {
153 dev_err(&data->client->dev,
154 "failed to read temperature calibration parameters\n");
155 return ret;
156 }
157
158 comp->dig_t1 = (u16) le16_to_cpu(buf[0]);
159 comp->dig_t2 = (s16) le16_to_cpu(buf[1]);
160 comp->dig_t3 = (s16) le16_to_cpu(buf[2]);
161
162 return 0;
163}
164
165static int bmp280_read_compensation_press(struct bmp280_data *data,
166 struct bmp280_comp_press *comp)
167{
168 int ret;
169 __le16 buf[BMP280_COMP_PRESS_REG_COUNT / 2];
170
171 ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_PRESS_START,
172 buf, BMP280_COMP_PRESS_REG_COUNT);
173 if (ret < 0) {
174 dev_err(&data->client->dev,
175 "failed to read pressure calibration parameters\n");
176 return ret;
177 }
178
179 comp->dig_p1 = (u16) le16_to_cpu(buf[0]);
180 comp->dig_p2 = (s16) le16_to_cpu(buf[1]);
181 comp->dig_p3 = (s16) le16_to_cpu(buf[2]);
182 comp->dig_p4 = (s16) le16_to_cpu(buf[3]);
183 comp->dig_p5 = (s16) le16_to_cpu(buf[4]);
184 comp->dig_p6 = (s16) le16_to_cpu(buf[5]);
185 comp->dig_p7 = (s16) le16_to_cpu(buf[6]);
186 comp->dig_p8 = (s16) le16_to_cpu(buf[7]);
187 comp->dig_p9 = (s16) le16_to_cpu(buf[8]);
188
189 return 0;
190}
191
192/*
193 * Returns temperature in DegC, resolution is 0.01 DegC. Output value of
194 * "5123" equals 51.23 DegC. t_fine carries fine temperature as global
195 * value.
196 *
197 * Taken from datasheet, Section 3.11.3, "Compensation formula".
198 */
199static s32 bmp280_compensate_temp(struct bmp280_data *data,
200 struct bmp280_comp_temp *comp,
201 s32 adc_temp)
202{
203 s32 var1, var2, t;
204
205 var1 = (((adc_temp >> 3) - ((s32) comp->dig_t1 << 1)) *
206 ((s32) comp->dig_t2)) >> 11;
207 var2 = (((((adc_temp >> 4) - ((s32) comp->dig_t1)) *
208 ((adc_temp >> 4) - ((s32) comp->dig_t1))) >> 12) *
209 ((s32) comp->dig_t3)) >> 14;
210
211 data->t_fine = var1 + var2;
212 t = (data->t_fine * 5 + 128) >> 8;
213
214 return t;
215}
216
217/*
218 * Returns pressure in Pa as unsigned 32 bit integer in Q24.8 format (24
219 * integer bits and 8 fractional bits). Output value of "24674867"
220 * represents 24674867/256 = 96386.2 Pa = 963.862 hPa
221 *
222 * Taken from datasheet, Section 3.11.3, "Compensation formula".
223 */
224static u32 bmp280_compensate_press(struct bmp280_data *data,
225 struct bmp280_comp_press *comp,
226 s32 adc_press)
227{
228 s64 var1, var2, p;
229
230 var1 = ((s64) data->t_fine) - 128000;
231 var2 = var1 * var1 * (s64) comp->dig_p6;
232 var2 = var2 + ((var1 * (s64) comp->dig_p5) << 17);
233 var2 = var2 + (((s64) comp->dig_p4) << 35);
234 var1 = ((var1 * var1 * (s64) comp->dig_p3) >> 8) +
235 ((var1 * (s64) comp->dig_p2) << 12);
236 var1 = (((((s64) 1) << 47) + var1)) * ((s64) comp->dig_p1) >> 33;
237
238 if (var1 == 0)
239 return 0;
240
241 p = ((((s64) 1048576 - adc_press) << 31) - var2) * 3125;
242 p = div64_s64(p, var1);
243 var1 = (((s64) comp->dig_p9) * (p >> 13) * (p >> 13)) >> 25;
244 var2 = (((s64) comp->dig_p8) * p) >> 19;
245 p = ((p + var1 + var2) >> 8) + (((s64) comp->dig_p7) << 4);
246
247 return (u32) p;
248}
249
250static int bmp280_read_temp(struct bmp280_data *data,
251 int *val)
252{
253 int ret;
254 __be32 tmp = 0;
255 s32 adc_temp, comp_temp;
256 struct bmp280_comp_temp comp;
257
258 ret = bmp280_read_compensation_temp(data, &comp);
259 if (ret < 0)
260 return ret;
261
262 ret = regmap_bulk_read(data->regmap, BMP280_REG_TEMP_MSB,
263 (u8 *) &tmp, 3);
264 if (ret < 0) {
265 dev_err(&data->client->dev, "failed to read temperature\n");
266 return ret;
267 }
268
269 adc_temp = be32_to_cpu(tmp) >> 12;
270 comp_temp = bmp280_compensate_temp(data, &comp, adc_temp);
271
272 /*
273 * val might be NULL if we're called by the read_press routine,
274 * who only cares about the carry over t_fine value.
275 */
276 if (val) {
277 *val = comp_temp * 10;
278 return IIO_VAL_INT;
279 }
280
281 return 0;
282}
283
284static int bmp280_read_press(struct bmp280_data *data,
285 int *val, int *val2)
286{
287 int ret;
288 __be32 tmp = 0;
289 s32 adc_press;
290 u32 comp_press;
291 struct bmp280_comp_press comp;
292
293 ret = bmp280_read_compensation_press(data, &comp);
294 if (ret < 0)
295 return ret;
296
297 /* Read and compensate temperature so we get a reading of t_fine. */
298 ret = bmp280_read_temp(data, NULL);
299 if (ret < 0)
300 return ret;
301
302 ret = regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB,
303 (u8 *) &tmp, 3);
304 if (ret < 0) {
305 dev_err(&data->client->dev, "failed to read pressure\n");
306 return ret;
307 }
308
309 adc_press = be32_to_cpu(tmp) >> 12;
310 comp_press = bmp280_compensate_press(data, &comp, adc_press);
311
312 *val = comp_press;
313 *val2 = 256000;
314
315 return IIO_VAL_FRACTIONAL;
316}
317
318static int bmp280_read_raw(struct iio_dev *indio_dev,
319 struct iio_chan_spec const *chan,
320 int *val, int *val2, long mask)
321{
322 int ret;
323 struct bmp280_data *data = iio_priv(indio_dev);
324
325 mutex_lock(&data->lock);
326
327 switch (mask) {
328 case IIO_CHAN_INFO_PROCESSED:
329 switch (chan->type) {
330 case IIO_PRESSURE:
331 ret = bmp280_read_press(data, val, val2);
332 break;
333 case IIO_TEMP:
334 ret = bmp280_read_temp(data, val);
335 break;
336 default:
337 ret = -EINVAL;
338 break;
339 }
340 break;
341 default:
342 ret = -EINVAL;
343 break;
344 }
345
346 mutex_unlock(&data->lock);
347
348 return ret;
349}
350
351static const struct iio_info bmp280_info = {
352 .driver_module = THIS_MODULE,
353 .read_raw = &bmp280_read_raw,
354};
355
356static int bmp280_chip_init(struct bmp280_data *data)
357{
358 int ret;
359
360 ret = regmap_update_bits(data->regmap, BMP280_REG_CTRL_MEAS,
361 BMP280_OSRS_TEMP_MASK |
362 BMP280_OSRS_PRESS_MASK |
363 BMP280_MODE_MASK,
364 BMP280_OSRS_TEMP_2X |
365 BMP280_OSRS_PRESS_16X |
366 BMP280_MODE_NORMAL);
367 if (ret < 0) {
368 dev_err(&data->client->dev,
369 "failed to write config register\n");
370 return ret;
371 }
372
373 ret = regmap_update_bits(data->regmap, BMP280_REG_CONFIG,
374 BMP280_FILTER_MASK,
375 BMP280_FILTER_4X);
376 if (ret < 0) {
377 dev_err(&data->client->dev,
378 "failed to write config register\n");
379 return ret;
380 }
381
382 return ret;
383}
384
385static int bmp280_probe(struct i2c_client *client,
386 const struct i2c_device_id *id)
387{
388 int ret;
389 struct iio_dev *indio_dev;
390 struct bmp280_data *data;
391 unsigned int chip_id;
392
393 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
394 if (!indio_dev)
395 return -ENOMEM;
396
397 i2c_set_clientdata(client, indio_dev);
398 data = iio_priv(indio_dev);
399 mutex_init(&data->lock);
400 data->client = client;
401
402 indio_dev->dev.parent = &client->dev;
403 indio_dev->name = id->name;
404 indio_dev->channels = bmp280_channels;
405 indio_dev->num_channels = ARRAY_SIZE(bmp280_channels);
406 indio_dev->info = &bmp280_info;
407 indio_dev->modes = INDIO_DIRECT_MODE;
408
409 data->regmap = devm_regmap_init_i2c(client, &bmp280_regmap_config);
410 if (IS_ERR(data->regmap)) {
411 dev_err(&client->dev, "failed to allocate register map\n");
412 return PTR_ERR(data->regmap);
413 }
414
415 ret = regmap_read(data->regmap, BMP280_REG_ID, &chip_id);
416 if (ret < 0)
417 return ret;
418 if (chip_id != BMP280_CHIP_ID) {
419 dev_err(&client->dev, "bad chip id. expected %x got %x\n",
420 BMP280_CHIP_ID, chip_id);
421 return -EINVAL;
422 }
423
424 ret = bmp280_chip_init(data);
425 if (ret < 0)
426 return ret;
427
428 return devm_iio_device_register(&client->dev, indio_dev);
429}
430
431static const struct acpi_device_id bmp280_acpi_match[] = {
432 {"BMP0280", 0},
433 { },
434};
435MODULE_DEVICE_TABLE(acpi, bmp280_acpi_match);
436
437static const struct i2c_device_id bmp280_id[] = {
438 {"bmp280", 0},
439 { },
440};
441MODULE_DEVICE_TABLE(i2c, bmp280_id);
442
443static struct i2c_driver bmp280_driver = {
444 .driver = {
445 .name = "bmp280",
446 .acpi_match_table = ACPI_PTR(bmp280_acpi_match),
447 },
448 .probe = bmp280_probe,
449 .id_table = bmp280_id,
450};
451module_i2c_driver(bmp280_driver);
452
453MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
454MODULE_DESCRIPTION("Driver for Bosch Sensortec BMP280 pressure and temperature sensor");
455MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/pressure/hid-sensor-press.c b/drivers/iio/pressure/hid-sensor-press.c
index 2c0d2a4fed8c..764928682df2 100644
--- a/drivers/iio/pressure/hid-sensor-press.c
+++ b/drivers/iio/pressure/hid-sensor-press.c
@@ -382,7 +382,6 @@ static struct platform_driver hid_press_platform_driver = {
382 .id_table = hid_press_ids, 382 .id_table = hid_press_ids,
383 .driver = { 383 .driver = {
384 .name = KBUILD_MODNAME, 384 .name = KBUILD_MODNAME,
385 .owner = THIS_MODULE,
386 }, 385 },
387 .probe = hid_press_probe, 386 .probe = hid_press_probe,
388 .remove = hid_press_remove, 387 .remove = hid_press_remove,
diff --git a/drivers/iio/pressure/st_pressure.h b/drivers/iio/pressure/st_pressure.h
index 242943c0c4e4..f5f41490060b 100644
--- a/drivers/iio/pressure/st_pressure.h
+++ b/drivers/iio/pressure/st_pressure.h
@@ -26,8 +26,7 @@ static const struct st_sensors_platform_data default_press_pdata = {
26 .drdy_int_pin = 1, 26 .drdy_int_pin = 1,
27}; 27};
28 28
29int st_press_common_probe(struct iio_dev *indio_dev, 29int st_press_common_probe(struct iio_dev *indio_dev);
30 struct st_sensors_platform_data *pdata);
31void st_press_common_remove(struct iio_dev *indio_dev); 30void st_press_common_remove(struct iio_dev *indio_dev);
32 31
33#ifdef CONFIG_IIO_BUFFER 32#ifdef CONFIG_IIO_BUFFER
diff --git a/drivers/iio/pressure/st_pressure_buffer.c b/drivers/iio/pressure/st_pressure_buffer.c
index b37b1c9ac932..2ff53f222352 100644
--- a/drivers/iio/pressure/st_pressure_buffer.c
+++ b/drivers/iio/pressure/st_pressure_buffer.c
@@ -38,10 +38,10 @@ static int st_press_buffer_preenable(struct iio_dev *indio_dev)
38static int st_press_buffer_postenable(struct iio_dev *indio_dev) 38static int st_press_buffer_postenable(struct iio_dev *indio_dev)
39{ 39{
40 int err; 40 int err;
41 struct st_sensor_data *pdata = iio_priv(indio_dev); 41 struct st_sensor_data *press_data = iio_priv(indio_dev);
42 42
43 pdata->buffer_data = kmalloc(indio_dev->scan_bytes, GFP_KERNEL); 43 press_data->buffer_data = kmalloc(indio_dev->scan_bytes, GFP_KERNEL);
44 if (pdata->buffer_data == NULL) { 44 if (press_data->buffer_data == NULL) {
45 err = -ENOMEM; 45 err = -ENOMEM;
46 goto allocate_memory_error; 46 goto allocate_memory_error;
47 } 47 }
@@ -53,7 +53,7 @@ static int st_press_buffer_postenable(struct iio_dev *indio_dev)
53 return err; 53 return err;
54 54
55st_press_buffer_postenable_error: 55st_press_buffer_postenable_error:
56 kfree(pdata->buffer_data); 56 kfree(press_data->buffer_data);
57allocate_memory_error: 57allocate_memory_error:
58 return err; 58 return err;
59} 59}
@@ -61,7 +61,7 @@ allocate_memory_error:
61static int st_press_buffer_predisable(struct iio_dev *indio_dev) 61static int st_press_buffer_predisable(struct iio_dev *indio_dev)
62{ 62{
63 int err; 63 int err;
64 struct st_sensor_data *pdata = iio_priv(indio_dev); 64 struct st_sensor_data *press_data = iio_priv(indio_dev);
65 65
66 err = iio_triggered_buffer_predisable(indio_dev); 66 err = iio_triggered_buffer_predisable(indio_dev);
67 if (err < 0) 67 if (err < 0)
@@ -70,7 +70,7 @@ static int st_press_buffer_predisable(struct iio_dev *indio_dev)
70 err = st_sensors_set_enable(indio_dev, false); 70 err = st_sensors_set_enable(indio_dev, false);
71 71
72st_press_buffer_predisable_error: 72st_press_buffer_predisable_error:
73 kfree(pdata->buffer_data); 73 kfree(press_data->buffer_data);
74 return err; 74 return err;
75} 75}
76 76
diff --git a/drivers/iio/pressure/st_pressure_core.c b/drivers/iio/pressure/st_pressure_core.c
index 473d914ef470..97baf40d424b 100644
--- a/drivers/iio/pressure/st_pressure_core.c
+++ b/drivers/iio/pressure/st_pressure_core.c
@@ -175,7 +175,7 @@ static const struct iio_chan_spec st_press_lps001wp_channels[] = {
175 IIO_CHAN_SOFT_TIMESTAMP(1) 175 IIO_CHAN_SOFT_TIMESTAMP(1)
176}; 176};
177 177
178static const struct st_sensors st_press_sensors[] = { 178static const struct st_sensor_settings st_press_sensors_settings[] = {
179 { 179 {
180 .wai = ST_PRESS_LPS331AP_WAI_EXP, 180 .wai = ST_PRESS_LPS331AP_WAI_EXP,
181 .sensors_supported = { 181 .sensors_supported = {
@@ -333,7 +333,7 @@ static int st_press_read_raw(struct iio_dev *indio_dev,
333 int *val2, long mask) 333 int *val2, long mask)
334{ 334{
335 int err; 335 int err;
336 struct st_sensor_data *pdata = iio_priv(indio_dev); 336 struct st_sensor_data *press_data = iio_priv(indio_dev);
337 337
338 switch (mask) { 338 switch (mask) {
339 case IIO_CHAN_INFO_RAW: 339 case IIO_CHAN_INFO_RAW:
@@ -347,10 +347,10 @@ static int st_press_read_raw(struct iio_dev *indio_dev,
347 347
348 switch (ch->type) { 348 switch (ch->type) {
349 case IIO_PRESSURE: 349 case IIO_PRESSURE:
350 *val2 = pdata->current_fullscale->gain; 350 *val2 = press_data->current_fullscale->gain;
351 break; 351 break;
352 case IIO_TEMP: 352 case IIO_TEMP:
353 *val2 = pdata->current_fullscale->gain2; 353 *val2 = press_data->current_fullscale->gain2;
354 break; 354 break;
355 default: 355 default:
356 err = -EINVAL; 356 err = -EINVAL;
@@ -371,7 +371,7 @@ static int st_press_read_raw(struct iio_dev *indio_dev,
371 371
372 return IIO_VAL_FRACTIONAL; 372 return IIO_VAL_FRACTIONAL;
373 case IIO_CHAN_INFO_SAMP_FREQ: 373 case IIO_CHAN_INFO_SAMP_FREQ:
374 *val = pdata->odr; 374 *val = press_data->odr;
375 return IIO_VAL_INT; 375 return IIO_VAL_INT;
376 default: 376 default:
377 return -EINVAL; 377 return -EINVAL;
@@ -409,11 +409,10 @@ static const struct iio_trigger_ops st_press_trigger_ops = {
409#define ST_PRESS_TRIGGER_OPS NULL 409#define ST_PRESS_TRIGGER_OPS NULL
410#endif 410#endif
411 411
412int st_press_common_probe(struct iio_dev *indio_dev, 412int st_press_common_probe(struct iio_dev *indio_dev)
413 struct st_sensors_platform_data *plat_data)
414{ 413{
415 struct st_sensor_data *pdata = iio_priv(indio_dev); 414 struct st_sensor_data *press_data = iio_priv(indio_dev);
416 int irq = pdata->get_irq_data_ready(indio_dev); 415 int irq = press_data->get_irq_data_ready(indio_dev);
417 int err; 416 int err;
418 417
419 indio_dev->modes = INDIO_DIRECT_MODE; 418 indio_dev->modes = INDIO_DIRECT_MODE;
@@ -422,28 +421,30 @@ int st_press_common_probe(struct iio_dev *indio_dev,
422 st_sensors_power_enable(indio_dev); 421 st_sensors_power_enable(indio_dev);
423 422
424 err = st_sensors_check_device_support(indio_dev, 423 err = st_sensors_check_device_support(indio_dev,
425 ARRAY_SIZE(st_press_sensors), 424 ARRAY_SIZE(st_press_sensors_settings),
426 st_press_sensors); 425 st_press_sensors_settings);
427 if (err < 0) 426 if (err < 0)
428 return err; 427 return err;
429 428
430 pdata->num_data_channels = ST_PRESS_NUMBER_DATA_CHANNELS; 429 press_data->num_data_channels = ST_PRESS_NUMBER_DATA_CHANNELS;
431 pdata->multiread_bit = pdata->sensor->multi_read_bit; 430 press_data->multiread_bit = press_data->sensor_settings->multi_read_bit;
432 indio_dev->channels = pdata->sensor->ch; 431 indio_dev->channels = press_data->sensor_settings->ch;
433 indio_dev->num_channels = pdata->sensor->num_ch; 432 indio_dev->num_channels = press_data->sensor_settings->num_ch;
434 433
435 if (pdata->sensor->fs.addr != 0) 434 if (press_data->sensor_settings->fs.addr != 0)
436 pdata->current_fullscale = (struct st_sensor_fullscale_avl *) 435 press_data->current_fullscale =
437 &pdata->sensor->fs.fs_avl[0]; 436 (struct st_sensor_fullscale_avl *)
437 &press_data->sensor_settings->fs.fs_avl[0];
438 438
439 pdata->odr = pdata->sensor->odr.odr_avl[0].hz; 439 press_data->odr = press_data->sensor_settings->odr.odr_avl[0].hz;
440 440
441 /* Some devices don't support a data ready pin. */ 441 /* Some devices don't support a data ready pin. */
442 if (!plat_data && pdata->sensor->drdy_irq.addr) 442 if (!press_data->dev->platform_data &&
443 plat_data = 443 press_data->sensor_settings->drdy_irq.addr)
444 press_data->dev->platform_data =
444 (struct st_sensors_platform_data *)&default_press_pdata; 445 (struct st_sensors_platform_data *)&default_press_pdata;
445 446
446 err = st_sensors_init_sensor(indio_dev, plat_data); 447 err = st_sensors_init_sensor(indio_dev, press_data->dev->platform_data);
447 if (err < 0) 448 if (err < 0)
448 return err; 449 return err;
449 450
@@ -479,12 +480,12 @@ EXPORT_SYMBOL(st_press_common_probe);
479 480
480void st_press_common_remove(struct iio_dev *indio_dev) 481void st_press_common_remove(struct iio_dev *indio_dev)
481{ 482{
482 struct st_sensor_data *pdata = iio_priv(indio_dev); 483 struct st_sensor_data *press_data = iio_priv(indio_dev);
483 484
484 st_sensors_power_disable(indio_dev); 485 st_sensors_power_disable(indio_dev);
485 486
486 iio_device_unregister(indio_dev); 487 iio_device_unregister(indio_dev);
487 if (pdata->get_irq_data_ready(indio_dev) > 0) 488 if (press_data->get_irq_data_ready(indio_dev) > 0)
488 st_sensors_deallocate_trigger(indio_dev); 489 st_sensors_deallocate_trigger(indio_dev);
489 490
490 st_press_deallocate_ring(indio_dev); 491 st_press_deallocate_ring(indio_dev);
diff --git a/drivers/iio/pressure/st_pressure_i2c.c b/drivers/iio/pressure/st_pressure_i2c.c
index acaf165260bb..137788bba4a3 100644
--- a/drivers/iio/pressure/st_pressure_i2c.c
+++ b/drivers/iio/pressure/st_pressure_i2c.c
@@ -43,20 +43,19 @@ static int st_press_i2c_probe(struct i2c_client *client,
43 const struct i2c_device_id *id) 43 const struct i2c_device_id *id)
44{ 44{
45 struct iio_dev *indio_dev; 45 struct iio_dev *indio_dev;
46 struct st_sensor_data *pdata; 46 struct st_sensor_data *press_data;
47 int err; 47 int err;
48 48
49 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*pdata)); 49 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*press_data));
50 if (!indio_dev) 50 if (!indio_dev)
51 return -ENOMEM; 51 return -ENOMEM;
52 52
53 pdata = iio_priv(indio_dev); 53 press_data = iio_priv(indio_dev);
54 pdata->dev = &client->dev;
55 st_sensors_of_i2c_probe(client, st_press_of_match); 54 st_sensors_of_i2c_probe(client, st_press_of_match);
56 55
57 st_sensors_i2c_configure(indio_dev, client, pdata); 56 st_sensors_i2c_configure(indio_dev, client, press_data);
58 57
59 err = st_press_common_probe(indio_dev, client->dev.platform_data); 58 err = st_press_common_probe(indio_dev);
60 if (err < 0) 59 if (err < 0)
61 return err; 60 return err;
62 61
diff --git a/drivers/iio/pressure/st_pressure_spi.c b/drivers/iio/pressure/st_pressure_spi.c
index f45d430ec529..1ffa6d4d349c 100644
--- a/drivers/iio/pressure/st_pressure_spi.c
+++ b/drivers/iio/pressure/st_pressure_spi.c
@@ -21,19 +21,18 @@
21static int st_press_spi_probe(struct spi_device *spi) 21static int st_press_spi_probe(struct spi_device *spi)
22{ 22{
23 struct iio_dev *indio_dev; 23 struct iio_dev *indio_dev;
24 struct st_sensor_data *pdata; 24 struct st_sensor_data *press_data;
25 int err; 25 int err;
26 26
27 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*pdata)); 27 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*press_data));
28 if (indio_dev == NULL) 28 if (indio_dev == NULL)
29 return -ENOMEM; 29 return -ENOMEM;
30 30
31 pdata = iio_priv(indio_dev); 31 press_data = iio_priv(indio_dev);
32 pdata->dev = &spi->dev;
33 32
34 st_sensors_spi_configure(indio_dev, spi, pdata); 33 st_sensors_spi_configure(indio_dev, spi, press_data);
35 34
36 err = st_press_common_probe(indio_dev, spi->dev.platform_data); 35 err = st_press_common_probe(indio_dev);
37 if (err < 0) 36 if (err < 0)
38 return err; 37 return err;
39 38
diff --git a/drivers/iio/proximity/as3935.c b/drivers/iio/proximity/as3935.c
index 5e780ef206f3..466aa4314667 100644
--- a/drivers/iio/proximity/as3935.c
+++ b/drivers/iio/proximity/as3935.c
@@ -95,7 +95,7 @@ static int as3935_read(struct as3935_state *st, unsigned int reg, int *val)
95 *val = ret; 95 *val = ret;
96 96
97 return 0; 97 return 0;
98}; 98}
99 99
100static int as3935_write(struct as3935_state *st, 100static int as3935_write(struct as3935_state *st,
101 unsigned int reg, 101 unsigned int reg,
@@ -107,7 +107,7 @@ static int as3935_write(struct as3935_state *st,
107 buf[1] = val; 107 buf[1] = val;
108 108
109 return spi_write(st->spi, buf, 2); 109 return spi_write(st->spi, buf, 2);
110}; 110}
111 111
112static ssize_t as3935_sensor_sensitivity_show(struct device *dev, 112static ssize_t as3935_sensor_sensitivity_show(struct device *dev,
113 struct device_attribute *attr, 113 struct device_attribute *attr,
@@ -122,7 +122,7 @@ static ssize_t as3935_sensor_sensitivity_show(struct device *dev,
122 val = (val & AS3935_AFE_MASK) >> 1; 122 val = (val & AS3935_AFE_MASK) >> 1;
123 123
124 return sprintf(buf, "%d\n", val); 124 return sprintf(buf, "%d\n", val);
125}; 125}
126 126
127static ssize_t as3935_sensor_sensitivity_store(struct device *dev, 127static ssize_t as3935_sensor_sensitivity_store(struct device *dev,
128 struct device_attribute *attr, 128 struct device_attribute *attr,
@@ -142,7 +142,7 @@ static ssize_t as3935_sensor_sensitivity_store(struct device *dev,
142 as3935_write(st, AS3935_AFE_GAIN, val << 1); 142 as3935_write(st, AS3935_AFE_GAIN, val << 1);
143 143
144 return len; 144 return len;
145}; 145}
146 146
147static IIO_DEVICE_ATTR(sensor_sensitivity, S_IRUGO | S_IWUSR, 147static IIO_DEVICE_ATTR(sensor_sensitivity, S_IRUGO | S_IWUSR,
148 as3935_sensor_sensitivity_show, as3935_sensor_sensitivity_store, 0); 148 as3935_sensor_sensitivity_show, as3935_sensor_sensitivity_store, 0);
@@ -214,7 +214,7 @@ err_read:
214 iio_trigger_notify_done(indio_dev->trig); 214 iio_trigger_notify_done(indio_dev->trig);
215 215
216 return IRQ_HANDLED; 216 return IRQ_HANDLED;
217}; 217}
218 218
219static const struct iio_trigger_ops iio_interrupt_trigger_ops = { 219static const struct iio_trigger_ops iio_interrupt_trigger_ops = {
220 .owner = THIS_MODULE, 220 .owner = THIS_MODULE,
@@ -238,7 +238,7 @@ static void as3935_event_work(struct work_struct *work)
238 dev_warn(&st->spi->dev, "noise level is too high"); 238 dev_warn(&st->spi->dev, "noise level is too high");
239 break; 239 break;
240 } 240 }
241}; 241}
242 242
243static irqreturn_t as3935_interrupt_handler(int irq, void *private) 243static irqreturn_t as3935_interrupt_handler(int irq, void *private)
244{ 244{
@@ -330,7 +330,7 @@ static int as3935_probe(struct spi_device *spi)
330 return -EINVAL; 330 return -EINVAL;
331 } 331 }
332 332
333 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(st)); 333 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
334 if (!indio_dev) 334 if (!indio_dev)
335 return -ENOMEM; 335 return -ENOMEM;
336 336
@@ -417,7 +417,7 @@ unregister_trigger:
417 iio_trigger_unregister(st->trig); 417 iio_trigger_unregister(st->trig);
418 418
419 return ret; 419 return ret;
420}; 420}
421 421
422static int as3935_remove(struct spi_device *spi) 422static int as3935_remove(struct spi_device *spi)
423{ 423{
@@ -429,7 +429,7 @@ static int as3935_remove(struct spi_device *spi)
429 iio_trigger_unregister(st->trig); 429 iio_trigger_unregister(st->trig);
430 430
431 return 0; 431 return 0;
432}; 432}
433 433
434static const struct spi_device_id as3935_id[] = { 434static const struct spi_device_id as3935_id[] = {
435 {"as3935", 0}, 435 {"as3935", 0},
diff --git a/drivers/iio/trigger/iio-trig-interrupt.c b/drivers/iio/trigger/iio-trig-interrupt.c
index 7a149a7822bc..572bc6f02ca8 100644
--- a/drivers/iio/trigger/iio-trig-interrupt.c
+++ b/drivers/iio/trigger/iio-trig-interrupt.c
@@ -109,7 +109,6 @@ static struct platform_driver iio_interrupt_trigger_driver = {
109 .remove = iio_interrupt_trigger_remove, 109 .remove = iio_interrupt_trigger_remove,
110 .driver = { 110 .driver = {
111 .name = "iio_interrupt_trigger", 111 .name = "iio_interrupt_trigger",
112 .owner = THIS_MODULE,
113 }, 112 },
114}; 113};
115 114
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-14 03:29:29 -0400