?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ARM: ep93xx: move timer to its own file
[linux/fpc-iii.git] / drivers / iio / magnetometer / st_magn_core.c
blobb4bcfb790f49fe2060247b259e141d76bf1aff92
1 /*
2 * STMicroelectronics magnetometers driver
3 *
4 * Copyright 2012-2013 STMicroelectronics Inc.
5 *
6 * Denis Ciocca <denis.ciocca@st.com>
7 *
8 * Licensed under the GPL-2.
9 */
10
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/errno.h>
15 #include <linux/types.h>
16 #include <linux/mutex.h>
17 #include <linux/interrupt.h>
18 #include <linux/i2c.h>
19 #include <linux/gpio.h>
20 #include <linux/irq.h>
21 #include <linux/delay.h>
22 #include <linux/iio/iio.h>
23 #include <linux/iio/sysfs.h>
24 #include <linux/iio/buffer.h>
25
26 #include <linux/iio/common/st_sensors.h>
27 #include "st_magn.h"
28
29 #define ST_MAGN_NUMBER_DATA_CHANNELS 3
30
31 /* DEFAULT VALUE FOR SENSORS */
32 #define ST_MAGN_DEFAULT_OUT_X_H_ADDR 0X03
33 #define ST_MAGN_DEFAULT_OUT_Y_H_ADDR 0X07
34 #define ST_MAGN_DEFAULT_OUT_Z_H_ADDR 0X05
35
36 /* FULLSCALE */
37 #define ST_MAGN_FS_AVL_1300MG 1300
38 #define ST_MAGN_FS_AVL_1900MG 1900
39 #define ST_MAGN_FS_AVL_2500MG 2500
40 #define ST_MAGN_FS_AVL_4000MG 4000
41 #define ST_MAGN_FS_AVL_4700MG 4700
42 #define ST_MAGN_FS_AVL_5600MG 5600
43 #define ST_MAGN_FS_AVL_8000MG 8000
44 #define ST_MAGN_FS_AVL_8100MG 8100
45 #define ST_MAGN_FS_AVL_12000MG 12000
46 #define ST_MAGN_FS_AVL_16000MG 16000
47
48 /* CUSTOM VALUES FOR SENSOR 0 */
49 #define ST_MAGN_0_ODR_ADDR 0x00
50 #define ST_MAGN_0_ODR_MASK 0x1c
51 #define ST_MAGN_0_ODR_AVL_1HZ_VAL 0x00
52 #define ST_MAGN_0_ODR_AVL_2HZ_VAL 0x01
53 #define ST_MAGN_0_ODR_AVL_3HZ_VAL 0x02
54 #define ST_MAGN_0_ODR_AVL_8HZ_VAL 0x03
55 #define ST_MAGN_0_ODR_AVL_15HZ_VAL 0x04
56 #define ST_MAGN_0_ODR_AVL_30HZ_VAL 0x05
57 #define ST_MAGN_0_ODR_AVL_75HZ_VAL 0x06
58 #define ST_MAGN_0_ODR_AVL_220HZ_VAL 0x07
59 #define ST_MAGN_0_PW_ADDR 0x02
60 #define ST_MAGN_0_PW_MASK 0x03
61 #define ST_MAGN_0_PW_ON 0x00
62 #define ST_MAGN_0_PW_OFF 0x03
63 #define ST_MAGN_0_FS_ADDR 0x01
64 #define ST_MAGN_0_FS_MASK 0xe0
65 #define ST_MAGN_0_FS_AVL_1300_VAL 0x01
66 #define ST_MAGN_0_FS_AVL_1900_VAL 0x02
67 #define ST_MAGN_0_FS_AVL_2500_VAL 0x03
68 #define ST_MAGN_0_FS_AVL_4000_VAL 0x04
69 #define ST_MAGN_0_FS_AVL_4700_VAL 0x05
70 #define ST_MAGN_0_FS_AVL_5600_VAL 0x06
71 #define ST_MAGN_0_FS_AVL_8100_VAL 0x07
72 #define ST_MAGN_0_FS_AVL_1300_GAIN_XY 1100
73 #define ST_MAGN_0_FS_AVL_1900_GAIN_XY 855
74 #define ST_MAGN_0_FS_AVL_2500_GAIN_XY 670
75 #define ST_MAGN_0_FS_AVL_4000_GAIN_XY 450
76 #define ST_MAGN_0_FS_AVL_4700_GAIN_XY 400
77 #define ST_MAGN_0_FS_AVL_5600_GAIN_XY 330
78 #define ST_MAGN_0_FS_AVL_8100_GAIN_XY 230
79 #define ST_MAGN_0_FS_AVL_1300_GAIN_Z 980
80 #define ST_MAGN_0_FS_AVL_1900_GAIN_Z 760
81 #define ST_MAGN_0_FS_AVL_2500_GAIN_Z 600
82 #define ST_MAGN_0_FS_AVL_4000_GAIN_Z 400
83 #define ST_MAGN_0_FS_AVL_4700_GAIN_Z 355
84 #define ST_MAGN_0_FS_AVL_5600_GAIN_Z 295
85 #define ST_MAGN_0_FS_AVL_8100_GAIN_Z 205
86 #define ST_MAGN_0_MULTIREAD_BIT false
87
88 /* CUSTOM VALUES FOR SENSOR 1 */
89 #define ST_MAGN_1_WAI_EXP 0x3c
90 #define ST_MAGN_1_ODR_ADDR 0x00
91 #define ST_MAGN_1_ODR_MASK 0x1c
92 #define ST_MAGN_1_ODR_AVL_1HZ_VAL 0x00
93 #define ST_MAGN_1_ODR_AVL_2HZ_VAL 0x01
94 #define ST_MAGN_1_ODR_AVL_3HZ_VAL 0x02
95 #define ST_MAGN_1_ODR_AVL_8HZ_VAL 0x03
96 #define ST_MAGN_1_ODR_AVL_15HZ_VAL 0x04
97 #define ST_MAGN_1_ODR_AVL_30HZ_VAL 0x05
98 #define ST_MAGN_1_ODR_AVL_75HZ_VAL 0x06
99 #define ST_MAGN_1_ODR_AVL_220HZ_VAL 0x07
100 #define ST_MAGN_1_PW_ADDR 0x02
101 #define ST_MAGN_1_PW_MASK 0x03
102 #define ST_MAGN_1_PW_ON 0x00
103 #define ST_MAGN_1_PW_OFF 0x03
104 #define ST_MAGN_1_FS_ADDR 0x01
105 #define ST_MAGN_1_FS_MASK 0xe0
106 #define ST_MAGN_1_FS_AVL_1300_VAL 0x01
107 #define ST_MAGN_1_FS_AVL_1900_VAL 0x02
108 #define ST_MAGN_1_FS_AVL_2500_VAL 0x03
109 #define ST_MAGN_1_FS_AVL_4000_VAL 0x04
110 #define ST_MAGN_1_FS_AVL_4700_VAL 0x05
111 #define ST_MAGN_1_FS_AVL_5600_VAL 0x06
112 #define ST_MAGN_1_FS_AVL_8100_VAL 0x07
113 #define ST_MAGN_1_FS_AVL_1300_GAIN_XY 909
114 #define ST_MAGN_1_FS_AVL_1900_GAIN_XY 1169
115 #define ST_MAGN_1_FS_AVL_2500_GAIN_XY 1492
116 #define ST_MAGN_1_FS_AVL_4000_GAIN_XY 2222
117 #define ST_MAGN_1_FS_AVL_4700_GAIN_XY 2500
118 #define ST_MAGN_1_FS_AVL_5600_GAIN_XY 3030
119 #define ST_MAGN_1_FS_AVL_8100_GAIN_XY 4347
120 #define ST_MAGN_1_FS_AVL_1300_GAIN_Z 1020
121 #define ST_MAGN_1_FS_AVL_1900_GAIN_Z 1315
122 #define ST_MAGN_1_FS_AVL_2500_GAIN_Z 1666
123 #define ST_MAGN_1_FS_AVL_4000_GAIN_Z 2500
124 #define ST_MAGN_1_FS_AVL_4700_GAIN_Z 2816
125 #define ST_MAGN_1_FS_AVL_5600_GAIN_Z 3389
126 #define ST_MAGN_1_FS_AVL_8100_GAIN_Z 4878
127 #define ST_MAGN_1_MULTIREAD_BIT false
128
129 /* CUSTOM VALUES FOR SENSOR 2 */
130 #define ST_MAGN_2_WAI_EXP 0x3d
131 #define ST_MAGN_2_ODR_ADDR 0x20
132 #define ST_MAGN_2_ODR_MASK 0x1c
133 #define ST_MAGN_2_ODR_AVL_1HZ_VAL 0x00
134 #define ST_MAGN_2_ODR_AVL_2HZ_VAL 0x01
135 #define ST_MAGN_2_ODR_AVL_3HZ_VAL 0x02
136 #define ST_MAGN_2_ODR_AVL_5HZ_VAL 0x03
137 #define ST_MAGN_2_ODR_AVL_10HZ_VAL 0x04
138 #define ST_MAGN_2_ODR_AVL_20HZ_VAL 0x05
139 #define ST_MAGN_2_ODR_AVL_40HZ_VAL 0x06
140 #define ST_MAGN_2_ODR_AVL_80HZ_VAL 0x07
141 #define ST_MAGN_2_PW_ADDR 0x22
142 #define ST_MAGN_2_PW_MASK 0x03
143 #define ST_MAGN_2_PW_ON 0x00
144 #define ST_MAGN_2_PW_OFF 0x03
145 #define ST_MAGN_2_FS_ADDR 0x21
146 #define ST_MAGN_2_FS_MASK 0x60
147 #define ST_MAGN_2_FS_AVL_4000_VAL 0x00
148 #define ST_MAGN_2_FS_AVL_8000_VAL 0x01
149 #define ST_MAGN_2_FS_AVL_12000_VAL 0x02
150 #define ST_MAGN_2_FS_AVL_16000_VAL 0x03
151 #define ST_MAGN_2_FS_AVL_4000_GAIN 146
152 #define ST_MAGN_2_FS_AVL_8000_GAIN 292
153 #define ST_MAGN_2_FS_AVL_12000_GAIN 438
154 #define ST_MAGN_2_FS_AVL_16000_GAIN 584
155 #define ST_MAGN_2_MULTIREAD_BIT false
156 #define ST_MAGN_2_OUT_X_L_ADDR 0x28
157 #define ST_MAGN_2_OUT_Y_L_ADDR 0x2a
158 #define ST_MAGN_2_OUT_Z_L_ADDR 0x2c
159
160 static const struct iio_chan_spec st_magn_16bit_channels[] = {
161 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
162 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
163 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_BE, 16, 16,
164 ST_MAGN_DEFAULT_OUT_X_H_ADDR),
165 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
166 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
167 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_BE, 16, 16,
168 ST_MAGN_DEFAULT_OUT_Y_H_ADDR),
169 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
170 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
171 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_BE, 16, 16,
172 ST_MAGN_DEFAULT_OUT_Z_H_ADDR),
173 IIO_CHAN_SOFT_TIMESTAMP(3)
174 };
175
176 static const struct iio_chan_spec st_magn_2_16bit_channels[] = {
177 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
178 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
179 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
180 ST_MAGN_2_OUT_X_L_ADDR),
181 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
182 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
183 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
184 ST_MAGN_2_OUT_Y_L_ADDR),
185 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
186 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
187 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
188 ST_MAGN_2_OUT_Z_L_ADDR),
189 IIO_CHAN_SOFT_TIMESTAMP(3)
190 };
191
192 static const struct st_sensor_settings st_magn_sensors_settings[] = {
193 {
194 .wai = 0, /* This sensor has no valid WhoAmI report 0 */
195 .sensors_supported = {
196 [0] = LSM303DLH_MAGN_DEV_NAME,
197 },
198 .ch = (struct iio_chan_spec *)st_magn_16bit_channels,
199 .odr = {
200 .addr = ST_MAGN_0_ODR_ADDR,
201 .mask = ST_MAGN_0_ODR_MASK,
202 .odr_avl = {
203 { 1, ST_MAGN_0_ODR_AVL_1HZ_VAL, },
204 { 2, ST_MAGN_0_ODR_AVL_2HZ_VAL, },
205 { 3, ST_MAGN_0_ODR_AVL_3HZ_VAL, },
206 { 8, ST_MAGN_0_ODR_AVL_8HZ_VAL, },
207 { 15, ST_MAGN_0_ODR_AVL_15HZ_VAL, },
208 { 30, ST_MAGN_0_ODR_AVL_30HZ_VAL, },
209 { 75, ST_MAGN_0_ODR_AVL_75HZ_VAL, },
210 },
211 },
212 .pw = {
213 .addr = ST_MAGN_0_PW_ADDR,
214 .mask = ST_MAGN_0_PW_MASK,
215 .value_on = ST_MAGN_0_PW_ON,
216 .value_off = ST_MAGN_0_PW_OFF,
217 },
218 .fs = {
219 .addr = ST_MAGN_0_FS_ADDR,
220 .mask = ST_MAGN_0_FS_MASK,
221 .fs_avl = {
222 [0] = {
223 .num = ST_MAGN_FS_AVL_1300MG,
224 .value = ST_MAGN_0_FS_AVL_1300_VAL,
225 .gain = ST_MAGN_0_FS_AVL_1300_GAIN_XY,
226 .gain2 = ST_MAGN_0_FS_AVL_1300_GAIN_Z,
227 },
228 [1] = {
229 .num = ST_MAGN_FS_AVL_1900MG,
230 .value = ST_MAGN_0_FS_AVL_1900_VAL,
231 .gain = ST_MAGN_0_FS_AVL_1900_GAIN_XY,
232 .gain2 = ST_MAGN_0_FS_AVL_1900_GAIN_Z,
233 },
234 [2] = {
235 .num = ST_MAGN_FS_AVL_2500MG,
236 .value = ST_MAGN_0_FS_AVL_2500_VAL,
237 .gain = ST_MAGN_0_FS_AVL_2500_GAIN_XY,
238 .gain2 = ST_MAGN_0_FS_AVL_2500_GAIN_Z,
239 },
240 [3] = {
241 .num = ST_MAGN_FS_AVL_4000MG,
242 .value = ST_MAGN_0_FS_AVL_4000_VAL,
243 .gain = ST_MAGN_0_FS_AVL_4000_GAIN_XY,
244 .gain2 = ST_MAGN_0_FS_AVL_4000_GAIN_Z,
245 },
246 [4] = {
247 .num = ST_MAGN_FS_AVL_4700MG,
248 .value = ST_MAGN_0_FS_AVL_4700_VAL,
249 .gain = ST_MAGN_0_FS_AVL_4700_GAIN_XY,
250 .gain2 = ST_MAGN_0_FS_AVL_4700_GAIN_Z,
251 },
252 [5] = {
253 .num = ST_MAGN_FS_AVL_5600MG,
254 .value = ST_MAGN_0_FS_AVL_5600_VAL,
255 .gain = ST_MAGN_0_FS_AVL_5600_GAIN_XY,
256 .gain2 = ST_MAGN_0_FS_AVL_5600_GAIN_Z,
257 },
258 [6] = {
259 .num = ST_MAGN_FS_AVL_8100MG,
260 .value = ST_MAGN_0_FS_AVL_8100_VAL,
261 .gain = ST_MAGN_0_FS_AVL_8100_GAIN_XY,
262 .gain2 = ST_MAGN_0_FS_AVL_8100_GAIN_Z,
263 },
264 },
265 },
266 .multi_read_bit = ST_MAGN_0_MULTIREAD_BIT,
267 .bootime = 2,
268 },
269 {
270 .wai = ST_MAGN_1_WAI_EXP,
271 .sensors_supported = {
272 [0] = LSM303DLHC_MAGN_DEV_NAME,
273 [1] = LSM303DLM_MAGN_DEV_NAME,
274 },
275 .ch = (struct iio_chan_spec *)st_magn_16bit_channels,
276 .odr = {
277 .addr = ST_MAGN_1_ODR_ADDR,
278 .mask = ST_MAGN_1_ODR_MASK,
279 .odr_avl = {
280 { 1, ST_MAGN_1_ODR_AVL_1HZ_VAL, },
281 { 2, ST_MAGN_1_ODR_AVL_2HZ_VAL, },
282 { 3, ST_MAGN_1_ODR_AVL_3HZ_VAL, },
283 { 8, ST_MAGN_1_ODR_AVL_8HZ_VAL, },
284 { 15, ST_MAGN_1_ODR_AVL_15HZ_VAL, },
285 { 30, ST_MAGN_1_ODR_AVL_30HZ_VAL, },
286 { 75, ST_MAGN_1_ODR_AVL_75HZ_VAL, },
287 { 220, ST_MAGN_1_ODR_AVL_220HZ_VAL, },
288 },
289 },
290 .pw = {
291 .addr = ST_MAGN_1_PW_ADDR,
292 .mask = ST_MAGN_1_PW_MASK,
293 .value_on = ST_MAGN_1_PW_ON,
294 .value_off = ST_MAGN_1_PW_OFF,
295 },
296 .fs = {
297 .addr = ST_MAGN_1_FS_ADDR,
298 .mask = ST_MAGN_1_FS_MASK,
299 .fs_avl = {
300 [0] = {
301 .num = ST_MAGN_FS_AVL_1300MG,
302 .value = ST_MAGN_1_FS_AVL_1300_VAL,
303 .gain = ST_MAGN_1_FS_AVL_1300_GAIN_XY,
304 .gain2 = ST_MAGN_1_FS_AVL_1300_GAIN_Z,
305 },
306 [1] = {
307 .num = ST_MAGN_FS_AVL_1900MG,
308 .value = ST_MAGN_1_FS_AVL_1900_VAL,
309 .gain = ST_MAGN_1_FS_AVL_1900_GAIN_XY,
310 .gain2 = ST_MAGN_1_FS_AVL_1900_GAIN_Z,
311 },
312 [2] = {
313 .num = ST_MAGN_FS_AVL_2500MG,
314 .value = ST_MAGN_1_FS_AVL_2500_VAL,
315 .gain = ST_MAGN_1_FS_AVL_2500_GAIN_XY,
316 .gain2 = ST_MAGN_1_FS_AVL_2500_GAIN_Z,
317 },
318 [3] = {
319 .num = ST_MAGN_FS_AVL_4000MG,
320 .value = ST_MAGN_1_FS_AVL_4000_VAL,
321 .gain = ST_MAGN_1_FS_AVL_4000_GAIN_XY,
322 .gain2 = ST_MAGN_1_FS_AVL_4000_GAIN_Z,
323 },
324 [4] = {
325 .num = ST_MAGN_FS_AVL_4700MG,
326 .value = ST_MAGN_1_FS_AVL_4700_VAL,
327 .gain = ST_MAGN_1_FS_AVL_4700_GAIN_XY,
328 .gain2 = ST_MAGN_1_FS_AVL_4700_GAIN_Z,
329 },
330 [5] = {
331 .num = ST_MAGN_FS_AVL_5600MG,
332 .value = ST_MAGN_1_FS_AVL_5600_VAL,
333 .gain = ST_MAGN_1_FS_AVL_5600_GAIN_XY,
334 .gain2 = ST_MAGN_1_FS_AVL_5600_GAIN_Z,
335 },
336 [6] = {
337 .num = ST_MAGN_FS_AVL_8100MG,
338 .value = ST_MAGN_1_FS_AVL_8100_VAL,
339 .gain = ST_MAGN_1_FS_AVL_8100_GAIN_XY,
340 .gain2 = ST_MAGN_1_FS_AVL_8100_GAIN_Z,
341 },
342 },
343 },
344 .multi_read_bit = ST_MAGN_1_MULTIREAD_BIT,
345 .bootime = 2,
346 },
347 {
348 .wai = ST_MAGN_2_WAI_EXP,
349 .sensors_supported = {
350 [0] = LIS3MDL_MAGN_DEV_NAME,
351 },
352 .ch = (struct iio_chan_spec *)st_magn_2_16bit_channels,
353 .odr = {
354 .addr = ST_MAGN_2_ODR_ADDR,
355 .mask = ST_MAGN_2_ODR_MASK,
356 .odr_avl = {
357 { 1, ST_MAGN_2_ODR_AVL_1HZ_VAL, },
358 { 2, ST_MAGN_2_ODR_AVL_2HZ_VAL, },
359 { 3, ST_MAGN_2_ODR_AVL_3HZ_VAL, },
360 { 5, ST_MAGN_2_ODR_AVL_5HZ_VAL, },
361 { 10, ST_MAGN_2_ODR_AVL_10HZ_VAL, },
362 { 20, ST_MAGN_2_ODR_AVL_20HZ_VAL, },
363 { 40, ST_MAGN_2_ODR_AVL_40HZ_VAL, },
364 { 80, ST_MAGN_2_ODR_AVL_80HZ_VAL, },
365 },
366 },
367 .pw = {
368 .addr = ST_MAGN_2_PW_ADDR,
369 .mask = ST_MAGN_2_PW_MASK,
370 .value_on = ST_MAGN_2_PW_ON,
371 .value_off = ST_MAGN_2_PW_OFF,
372 },
373 .fs = {
374 .addr = ST_MAGN_2_FS_ADDR,
375 .mask = ST_MAGN_2_FS_MASK,
376 .fs_avl = {
377 [0] = {
378 .num = ST_MAGN_FS_AVL_4000MG,
379 .value = ST_MAGN_2_FS_AVL_4000_VAL,
380 .gain = ST_MAGN_2_FS_AVL_4000_GAIN,
381 },
382 [1] = {
383 .num = ST_MAGN_FS_AVL_8000MG,
384 .value = ST_MAGN_2_FS_AVL_8000_VAL,
385 .gain = ST_MAGN_2_FS_AVL_8000_GAIN,
386 },
387 [2] = {
388 .num = ST_MAGN_FS_AVL_12000MG,
389 .value = ST_MAGN_2_FS_AVL_12000_VAL,
390 .gain = ST_MAGN_2_FS_AVL_12000_GAIN,
391 },
392 [3] = {
393 .num = ST_MAGN_FS_AVL_16000MG,
394 .value = ST_MAGN_2_FS_AVL_16000_VAL,
395 .gain = ST_MAGN_2_FS_AVL_16000_GAIN,
396 },
397 },
398 },
399 .multi_read_bit = ST_MAGN_2_MULTIREAD_BIT,
400 .bootime = 2,
401 },
402 };
403
404 static int st_magn_read_raw(struct iio_dev *indio_dev,
405 struct iio_chan_spec const *ch, int *val,
406 int *val2, long mask)
407 {
408 int err;
409 struct st_sensor_data *mdata = iio_priv(indio_dev);
410
411 switch (mask) {
412 case IIO_CHAN_INFO_RAW:
413 err = st_sensors_read_info_raw(indio_dev, ch, val);
414 if (err < 0)
415 goto read_error;
416
417 return IIO_VAL_INT;
418 case IIO_CHAN_INFO_SCALE:
419 *val = 0;
420 if ((ch->scan_index == ST_SENSORS_SCAN_Z) &&
421 (mdata->current_fullscale->gain2 != 0))
422 *val2 = mdata->current_fullscale->gain2;
423 else
424 *val2 = mdata->current_fullscale->gain;
425 return IIO_VAL_INT_PLUS_MICRO;
426 case IIO_CHAN_INFO_SAMP_FREQ:
427 *val = mdata->odr;
428 return IIO_VAL_INT;
429 default:
430 return -EINVAL;
431 }
432
433 read_error:
434 return err;
435 }
436
437 static int st_magn_write_raw(struct iio_dev *indio_dev,
438 struct iio_chan_spec const *chan, int val, int val2, long mask)
439 {
440 int err;
441
442 switch (mask) {
443 case IIO_CHAN_INFO_SCALE:
444 err = st_sensors_set_fullscale_by_gain(indio_dev, val2);
445 break;
446 case IIO_CHAN_INFO_SAMP_FREQ:
447 if (val2)
448 return -EINVAL;
449 mutex_lock(&indio_dev->mlock);
450 err = st_sensors_set_odr(indio_dev, val);
451 mutex_unlock(&indio_dev->mlock);
452 return err;
453 default:
454 err = -EINVAL;
455 }
456
457 return err;
458 }
459
460 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
461 static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_magn_scale_available);
462
463 static struct attribute *st_magn_attributes[] = {
464 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
465 &iio_dev_attr_in_magn_scale_available.dev_attr.attr,
466 NULL,
467 };
468
469 static const struct attribute_group st_magn_attribute_group = {
470 .attrs = st_magn_attributes,
471 };
472
473 static const struct iio_info magn_info = {
474 .driver_module = THIS_MODULE,
475 .attrs = &st_magn_attribute_group,
476 .read_raw = &st_magn_read_raw,
477 .write_raw = &st_magn_write_raw,
478 };
479
480 int st_magn_common_probe(struct iio_dev *indio_dev)
481 {
482 struct st_sensor_data *mdata = iio_priv(indio_dev);
483 int irq = mdata->get_irq_data_ready(indio_dev);
484 int err;
485
486 indio_dev->modes = INDIO_DIRECT_MODE;
487 indio_dev->info = &magn_info;
488 mutex_init(&mdata->tb.buf_lock);
489
490 st_sensors_power_enable(indio_dev);
491
492 err = st_sensors_check_device_support(indio_dev,
493 ARRAY_SIZE(st_magn_sensors_settings),
494 st_magn_sensors_settings);
495 if (err < 0)
496 return err;
497
498 mdata->num_data_channels = ST_MAGN_NUMBER_DATA_CHANNELS;
499 mdata->multiread_bit = mdata->sensor_settings->multi_read_bit;
500 indio_dev->channels = mdata->sensor_settings->ch;
501 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
502
503 mdata->current_fullscale = (struct st_sensor_fullscale_avl *)
504 &mdata->sensor_settings->fs.fs_avl[0];
505 mdata->odr = mdata->sensor_settings->odr.odr_avl[0].hz;
506
507 err = st_sensors_init_sensor(indio_dev, NULL);
508 if (err < 0)
509 return err;
510
511 err = st_magn_allocate_ring(indio_dev);
512 if (err < 0)
513 return err;
514
515 if (irq > 0) {
516 err = st_sensors_allocate_trigger(indio_dev, NULL);
517 if (err < 0)
518 goto st_magn_probe_trigger_error;
519 }
520
521 err = iio_device_register(indio_dev);
522 if (err)
523 goto st_magn_device_register_error;
524
525 dev_info(&indio_dev->dev, "registered magnetometer %s\n",
526 indio_dev->name);
527
528 return 0;
529
530 st_magn_device_register_error:
531 if (irq > 0)
532 st_sensors_deallocate_trigger(indio_dev);
533 st_magn_probe_trigger_error:
534 st_magn_deallocate_ring(indio_dev);
535
536 return err;
537 }
538 EXPORT_SYMBOL(st_magn_common_probe);
539
540 void st_magn_common_remove(struct iio_dev *indio_dev)
541 {
542 struct st_sensor_data *mdata = iio_priv(indio_dev);
543
544 st_sensors_power_disable(indio_dev);
545
546 iio_device_unregister(indio_dev);
547 if (mdata->get_irq_data_ready(indio_dev) > 0)
548 st_sensors_deallocate_trigger(indio_dev);
549
550 st_magn_deallocate_ring(indio_dev);
551 }
552 EXPORT_SYMBOL(st_magn_common_remove);
553
554 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
555 MODULE_DESCRIPTION("STMicroelectronics magnetometers driver");
556 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support