tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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_L_ADDR 0X04
33#define ST_MAGN_DEFAULT_OUT_Y_L_ADDR 0X08
34#define ST_MAGN_DEFAULT_OUT_Z_L_ADDR 0X06
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_10000MG 10000
46
47/* CUSTOM VALUES FOR SENSOR 1 */
48#define ST_MAGN_1_WAI_EXP 0x3c
49#define ST_MAGN_1_ODR_ADDR 0x00
50#define ST_MAGN_1_ODR_MASK 0x1c
51#define ST_MAGN_1_ODR_AVL_1HZ_VAL 0x00
52#define ST_MAGN_1_ODR_AVL_2HZ_VAL 0x01
53#define ST_MAGN_1_ODR_AVL_3HZ_VAL 0x02
54#define ST_MAGN_1_ODR_AVL_8HZ_VAL 0x03
55#define ST_MAGN_1_ODR_AVL_15HZ_VAL 0x04
56#define ST_MAGN_1_ODR_AVL_30HZ_VAL 0x05
57#define ST_MAGN_1_ODR_AVL_75HZ_VAL 0x06
58#define ST_MAGN_1_ODR_AVL_220HZ_VAL 0x07
59#define ST_MAGN_1_PW_ADDR 0x02
60#define ST_MAGN_1_PW_MASK 0x03
61#define ST_MAGN_1_PW_ON 0x00
62#define ST_MAGN_1_PW_OFF 0x03
63#define ST_MAGN_1_FS_ADDR 0x01
64#define ST_MAGN_1_FS_MASK 0xe0
65#define ST_MAGN_1_FS_AVL_1300_VAL 0x01
66#define ST_MAGN_1_FS_AVL_1900_VAL 0x02
67#define ST_MAGN_1_FS_AVL_2500_VAL 0x03
68#define ST_MAGN_1_FS_AVL_4000_VAL 0x04
69#define ST_MAGN_1_FS_AVL_4700_VAL 0x05
70#define ST_MAGN_1_FS_AVL_5600_VAL 0x06
71#define ST_MAGN_1_FS_AVL_8100_VAL 0x07
72#define ST_MAGN_1_FS_AVL_1300_GAIN_XY 1100
73#define ST_MAGN_1_FS_AVL_1900_GAIN_XY 855
74#define ST_MAGN_1_FS_AVL_2500_GAIN_XY 670
75#define ST_MAGN_1_FS_AVL_4000_GAIN_XY 450
76#define ST_MAGN_1_FS_AVL_4700_GAIN_XY 400
77#define ST_MAGN_1_FS_AVL_5600_GAIN_XY 330
78#define ST_MAGN_1_FS_AVL_8100_GAIN_XY 230
79#define ST_MAGN_1_FS_AVL_1300_GAIN_Z 980
80#define ST_MAGN_1_FS_AVL_1900_GAIN_Z 760
81#define ST_MAGN_1_FS_AVL_2500_GAIN_Z 600
82#define ST_MAGN_1_FS_AVL_4000_GAIN_Z 400
83#define ST_MAGN_1_FS_AVL_4700_GAIN_Z 355
84#define ST_MAGN_1_FS_AVL_5600_GAIN_Z 295
85#define ST_MAGN_1_FS_AVL_8100_GAIN_Z 205
86#define ST_MAGN_1_MULTIREAD_BIT false
87
88/* CUSTOM VALUES FOR SENSOR 2 */
89#define ST_MAGN_2_WAI_EXP 0x3d
90#define ST_MAGN_2_ODR_ADDR 0x20
91#define ST_MAGN_2_ODR_MASK 0x1c
92#define ST_MAGN_2_ODR_AVL_1HZ_VAL 0x00
93#define ST_MAGN_2_ODR_AVL_2HZ_VAL 0x01
94#define ST_MAGN_2_ODR_AVL_3HZ_VAL 0x02
95#define ST_MAGN_2_ODR_AVL_5HZ_VAL 0x03
96#define ST_MAGN_2_ODR_AVL_10HZ_VAL 0x04
97#define ST_MAGN_2_ODR_AVL_20HZ_VAL 0x05
98#define ST_MAGN_2_ODR_AVL_40HZ_VAL 0x06
99#define ST_MAGN_2_ODR_AVL_80HZ_VAL 0x07
100#define ST_MAGN_2_PW_ADDR 0x22
101#define ST_MAGN_2_PW_MASK 0x03
102#define ST_MAGN_2_PW_ON 0x00
103#define ST_MAGN_2_PW_OFF 0x03
104#define ST_MAGN_2_FS_ADDR 0x21
105#define ST_MAGN_2_FS_MASK 0x60
106#define ST_MAGN_2_FS_AVL_4000_VAL 0x00
107#define ST_MAGN_2_FS_AVL_8000_VAL 0x01
108#define ST_MAGN_2_FS_AVL_10000_VAL 0x02
109#define ST_MAGN_2_FS_AVL_4000_GAIN 430
110#define ST_MAGN_2_FS_AVL_8000_GAIN 230
111#define ST_MAGN_2_FS_AVL_10000_GAIN 230
112#define ST_MAGN_2_MULTIREAD_BIT false
113#define ST_MAGN_2_OUT_X_L_ADDR 0x28
114#define ST_MAGN_2_OUT_Y_L_ADDR 0x2a
115#define ST_MAGN_2_OUT_Z_L_ADDR 0x2c
116
117static const struct iio_chan_spec st_magn_16bit_channels[] = {
118 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
119 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
120 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
121 ST_MAGN_DEFAULT_OUT_X_L_ADDR),
122 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
123 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
124 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
125 ST_MAGN_DEFAULT_OUT_Y_L_ADDR),
126 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
127 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
128 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
129 ST_MAGN_DEFAULT_OUT_Z_L_ADDR),
130 IIO_CHAN_SOFT_TIMESTAMP(3)
131};
132
133static const struct iio_chan_spec st_magn_2_16bit_channels[] = {
134 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
135 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
136 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
137 ST_MAGN_2_OUT_X_L_ADDR),
138 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
139 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
140 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
141 ST_MAGN_2_OUT_Y_L_ADDR),
142 ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
143 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
144 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
145 ST_MAGN_2_OUT_Z_L_ADDR),
146 IIO_CHAN_SOFT_TIMESTAMP(3)
147};
148
149static const struct st_sensors st_magn_sensors[] = {
150 {
151 .wai = ST_MAGN_1_WAI_EXP,
152 .sensors_supported = {
153 [0] = LSM303DLHC_MAGN_DEV_NAME,
154 [1] = LSM303DLM_MAGN_DEV_NAME,
155 },
156 .ch = (struct iio_chan_spec *)st_magn_16bit_channels,
157 .odr = {
158 .addr = ST_MAGN_1_ODR_ADDR,
159 .mask = ST_MAGN_1_ODR_MASK,
160 .odr_avl = {
161 { 1, ST_MAGN_1_ODR_AVL_1HZ_VAL, },
162 { 2, ST_MAGN_1_ODR_AVL_2HZ_VAL, },
163 { 3, ST_MAGN_1_ODR_AVL_3HZ_VAL, },
164 { 8, ST_MAGN_1_ODR_AVL_8HZ_VAL, },
165 { 15, ST_MAGN_1_ODR_AVL_15HZ_VAL, },
166 { 30, ST_MAGN_1_ODR_AVL_30HZ_VAL, },
167 { 75, ST_MAGN_1_ODR_AVL_75HZ_VAL, },
168 { 220, ST_MAGN_1_ODR_AVL_220HZ_VAL, },
169 },
170 },
171 .pw = {
172 .addr = ST_MAGN_1_PW_ADDR,
173 .mask = ST_MAGN_1_PW_MASK,
174 .value_on = ST_MAGN_1_PW_ON,
175 .value_off = ST_MAGN_1_PW_OFF,
176 },
177 .fs = {
178 .addr = ST_MAGN_1_FS_ADDR,
179 .mask = ST_MAGN_1_FS_MASK,
180 .fs_avl = {
181 [0] = {
182 .num = ST_MAGN_FS_AVL_1300MG,
183 .value = ST_MAGN_1_FS_AVL_1300_VAL,
184 .gain = ST_MAGN_1_FS_AVL_1300_GAIN_XY,
185 .gain2 = ST_MAGN_1_FS_AVL_1300_GAIN_Z,
186 },
187 [1] = {
188 .num = ST_MAGN_FS_AVL_1900MG,
189 .value = ST_MAGN_1_FS_AVL_1900_VAL,
190 .gain = ST_MAGN_1_FS_AVL_1900_GAIN_XY,
191 .gain2 = ST_MAGN_1_FS_AVL_1900_GAIN_Z,
192 },
193 [2] = {
194 .num = ST_MAGN_FS_AVL_2500MG,
195 .value = ST_MAGN_1_FS_AVL_2500_VAL,
196 .gain = ST_MAGN_1_FS_AVL_2500_GAIN_XY,
197 .gain2 = ST_MAGN_1_FS_AVL_2500_GAIN_Z,
198 },
199 [3] = {
200 .num = ST_MAGN_FS_AVL_4000MG,
201 .value = ST_MAGN_1_FS_AVL_4000_VAL,
202 .gain = ST_MAGN_1_FS_AVL_4000_GAIN_XY,
203 .gain2 = ST_MAGN_1_FS_AVL_4000_GAIN_Z,
204 },
205 [4] = {
206 .num = ST_MAGN_FS_AVL_4700MG,
207 .value = ST_MAGN_1_FS_AVL_4700_VAL,
208 .gain = ST_MAGN_1_FS_AVL_4700_GAIN_XY,
209 .gain2 = ST_MAGN_1_FS_AVL_4700_GAIN_Z,
210 },
211 [5] = {
212 .num = ST_MAGN_FS_AVL_5600MG,
213 .value = ST_MAGN_1_FS_AVL_5600_VAL,
214 .gain = ST_MAGN_1_FS_AVL_5600_GAIN_XY,
215 .gain2 = ST_MAGN_1_FS_AVL_5600_GAIN_Z,
216 },
217 [6] = {
218 .num = ST_MAGN_FS_AVL_8100MG,
219 .value = ST_MAGN_1_FS_AVL_8100_VAL,
220 .gain = ST_MAGN_1_FS_AVL_8100_GAIN_XY,
221 .gain2 = ST_MAGN_1_FS_AVL_8100_GAIN_Z,
222 },
223 },
224 },
225 .multi_read_bit = ST_MAGN_1_MULTIREAD_BIT,
226 .bootime = 2,
227 },
228 {
229 .wai = ST_MAGN_2_WAI_EXP,
230 .sensors_supported = {
231 [0] = LIS3MDL_MAGN_DEV_NAME,
232 },
233 .ch = (struct iio_chan_spec *)st_magn_2_16bit_channels,
234 .odr = {
235 .addr = ST_MAGN_2_ODR_ADDR,
236 .mask = ST_MAGN_2_ODR_MASK,
237 .odr_avl = {
238 { 1, ST_MAGN_2_ODR_AVL_1HZ_VAL, },
239 { 2, ST_MAGN_2_ODR_AVL_2HZ_VAL, },
240 { 3, ST_MAGN_2_ODR_AVL_3HZ_VAL, },
241 { 5, ST_MAGN_2_ODR_AVL_5HZ_VAL, },
242 { 10, ST_MAGN_2_ODR_AVL_10HZ_VAL, },
243 { 20, ST_MAGN_2_ODR_AVL_20HZ_VAL, },
244 { 40, ST_MAGN_2_ODR_AVL_40HZ_VAL, },
245 { 80, ST_MAGN_2_ODR_AVL_80HZ_VAL, },
246 },
247 },
248 .pw = {
249 .addr = ST_MAGN_2_PW_ADDR,
250 .mask = ST_MAGN_2_PW_MASK,
251 .value_on = ST_MAGN_2_PW_ON,
252 .value_off = ST_MAGN_2_PW_OFF,
253 },
254 .fs = {
255 .addr = ST_MAGN_2_FS_ADDR,
256 .mask = ST_MAGN_2_FS_MASK,
257 .fs_avl = {
258 [0] = {
259 .num = ST_MAGN_FS_AVL_4000MG,
260 .value = ST_MAGN_2_FS_AVL_4000_VAL,
261 .gain = ST_MAGN_2_FS_AVL_4000_GAIN,
262 },
263 [1] = {
264 .num = ST_MAGN_FS_AVL_8000MG,
265 .value = ST_MAGN_2_FS_AVL_8000_VAL,
266 .gain = ST_MAGN_2_FS_AVL_8000_GAIN,
267 },
268 [2] = {
269 .num = ST_MAGN_FS_AVL_10000MG,
270 .value = ST_MAGN_2_FS_AVL_10000_VAL,
271 .gain = ST_MAGN_2_FS_AVL_10000_GAIN,
272 },
273 },
274 },
275 .multi_read_bit = ST_MAGN_2_MULTIREAD_BIT,
276 .bootime = 2,
277 },
278};
279
280static int st_magn_read_raw(struct iio_dev *indio_dev,
281 struct iio_chan_spec const *ch, int *val,
282 int *val2, long mask)
283{
284 int err;
285 struct st_sensor_data *mdata = iio_priv(indio_dev);
286
287 switch (mask) {
288 case IIO_CHAN_INFO_RAW:
289 err = st_sensors_read_info_raw(indio_dev, ch, val);
290 if (err < 0)
291 goto read_error;
292
293 return IIO_VAL_INT;
294 case IIO_CHAN_INFO_SCALE:
295 *val = 0;
296 if ((ch->scan_index == ST_SENSORS_SCAN_Z) &&
297 (mdata->current_fullscale->gain2 != 0))
298 *val2 = mdata->current_fullscale->gain2;
299 else
300 *val2 = mdata->current_fullscale->gain;
301 return IIO_VAL_INT_PLUS_MICRO;
302 default:
303 return -EINVAL;
304 }
305
306read_error:
307 return err;
308}
309
310static int st_magn_write_raw(struct iio_dev *indio_dev,
311 struct iio_chan_spec const *chan, int val, int val2, long mask)
312{
313 int err;
314
315 switch (mask) {
316 case IIO_CHAN_INFO_SCALE:
317 err = st_sensors_set_fullscale_by_gain(indio_dev, val2);
318 break;
319 default:
320 err = -EINVAL;
321 }
322
323 return err;
324}
325
326static ST_SENSOR_DEV_ATTR_SAMP_FREQ();
327static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
328static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_magn_scale_available);
329
330static struct attribute *st_magn_attributes[] = {
331 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
332 &iio_dev_attr_in_magn_scale_available.dev_attr.attr,
333 &iio_dev_attr_sampling_frequency.dev_attr.attr,
334 NULL,
335};
336
337static const struct attribute_group st_magn_attribute_group = {
338 .attrs = st_magn_attributes,
339};
340
341static const struct iio_info magn_info = {
342 .driver_module = THIS_MODULE,
343 .attrs = &st_magn_attribute_group,
344 .read_raw = &st_magn_read_raw,
345 .write_raw = &st_magn_write_raw,
346};
347
348int st_magn_common_probe(struct iio_dev *indio_dev)
349{
350 int err;
351 struct st_sensor_data *mdata = iio_priv(indio_dev);
352
353 indio_dev->modes = INDIO_DIRECT_MODE;
354 indio_dev->info = &magn_info;
355
356 err = st_sensors_check_device_support(indio_dev,
357 ARRAY_SIZE(st_magn_sensors), st_magn_sensors);
358 if (err < 0)
359 goto st_magn_common_probe_error;
360
361 mdata->num_data_channels = ST_MAGN_NUMBER_DATA_CHANNELS;
362 mdata->multiread_bit = mdata->sensor->multi_read_bit;
363 indio_dev->channels = mdata->sensor->ch;
364 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
365
366 mdata->current_fullscale = (struct st_sensor_fullscale_avl *)
367 &mdata->sensor->fs.fs_avl[0];
368 mdata->odr = mdata->sensor->odr.odr_avl[0].hz;
369
370 err = st_sensors_init_sensor(indio_dev);
371 if (err < 0)
372 goto st_magn_common_probe_error;
373
374 if (mdata->get_irq_data_ready(indio_dev) > 0) {
375 err = st_magn_allocate_ring(indio_dev);
376 if (err < 0)
377 goto st_magn_common_probe_error;
378 err = st_sensors_allocate_trigger(indio_dev, NULL);
379 if (err < 0)
380 goto st_magn_probe_trigger_error;
381 }
382
383 err = iio_device_register(indio_dev);
384 if (err)
385 goto st_magn_device_register_error;
386
387 return err;
388
389st_magn_device_register_error:
390 if (mdata->get_irq_data_ready(indio_dev) > 0)
391 st_sensors_deallocate_trigger(indio_dev);
392st_magn_probe_trigger_error:
393 if (mdata->get_irq_data_ready(indio_dev) > 0)
394 st_magn_deallocate_ring(indio_dev);
395st_magn_common_probe_error:
396 return err;
397}
398EXPORT_SYMBOL(st_magn_common_probe);
399
400void st_magn_common_remove(struct iio_dev *indio_dev)
401{
402 struct st_sensor_data *mdata = iio_priv(indio_dev);
403
404 iio_device_unregister(indio_dev);
405 if (mdata->get_irq_data_ready(indio_dev) > 0) {
406 st_sensors_deallocate_trigger(indio_dev);
407 st_magn_deallocate_ring(indio_dev);
408 }
409 iio_device_free(indio_dev);
410}
411EXPORT_SYMBOL(st_magn_common_remove);
412
413MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
414MODULE_DESCRIPTION("STMicroelectronics magnetometers driver");
415MODULE_LICENSE("GPL v2");