?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sh_eth: fix EESIPR values for SH77{34|63}
[linux/fpc-iii.git] / drivers / iio / imu / bmi160 / bmi160_core.c
blob5355507f8fa1493c8fc5346e4f51da37f8f4790c
1 /*
2 * BMI160 - Bosch IMU (accel, gyro plus external magnetometer)
3 *
4 * Copyright (c) 2016, 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 core driver for BMI160, with support for I2C/SPI busses
11 *
12 * TODO: magnetometer, interrupts, hardware FIFO
13 */
14 #include <linux/module.h>
15 #include <linux/regmap.h>
16 #include <linux/acpi.h>
17 #include <linux/delay.h>
18
19 #include <linux/iio/iio.h>
20 #include <linux/iio/triggered_buffer.h>
21 #include <linux/iio/trigger_consumer.h>
22 #include <linux/iio/buffer.h>
23 #include <linux/iio/sysfs.h>
24
25 #include "bmi160.h"
26
27 #define BMI160_REG_CHIP_ID 0x00
28 #define BMI160_CHIP_ID_VAL 0xD1
29
30 #define BMI160_REG_PMU_STATUS 0x03
31
32 /* X axis data low byte address, the rest can be obtained using axis offset */
33 #define BMI160_REG_DATA_MAGN_XOUT_L 0x04
34 #define BMI160_REG_DATA_GYRO_XOUT_L 0x0C
35 #define BMI160_REG_DATA_ACCEL_XOUT_L 0x12
36
37 #define BMI160_REG_ACCEL_CONFIG 0x40
38 #define BMI160_ACCEL_CONFIG_ODR_MASK GENMASK(3, 0)
39 #define BMI160_ACCEL_CONFIG_BWP_MASK GENMASK(6, 4)
40
41 #define BMI160_REG_ACCEL_RANGE 0x41
42 #define BMI160_ACCEL_RANGE_2G 0x03
43 #define BMI160_ACCEL_RANGE_4G 0x05
44 #define BMI160_ACCEL_RANGE_8G 0x08
45 #define BMI160_ACCEL_RANGE_16G 0x0C
46
47 #define BMI160_REG_GYRO_CONFIG 0x42
48 #define BMI160_GYRO_CONFIG_ODR_MASK GENMASK(3, 0)
49 #define BMI160_GYRO_CONFIG_BWP_MASK GENMASK(5, 4)
50
51 #define BMI160_REG_GYRO_RANGE 0x43
52 #define BMI160_GYRO_RANGE_2000DPS 0x00
53 #define BMI160_GYRO_RANGE_1000DPS 0x01
54 #define BMI160_GYRO_RANGE_500DPS 0x02
55 #define BMI160_GYRO_RANGE_250DPS 0x03
56 #define BMI160_GYRO_RANGE_125DPS 0x04
57
58 #define BMI160_REG_CMD 0x7E
59 #define BMI160_CMD_ACCEL_PM_SUSPEND 0x10
60 #define BMI160_CMD_ACCEL_PM_NORMAL 0x11
61 #define BMI160_CMD_ACCEL_PM_LOW_POWER 0x12
62 #define BMI160_CMD_GYRO_PM_SUSPEND 0x14
63 #define BMI160_CMD_GYRO_PM_NORMAL 0x15
64 #define BMI160_CMD_GYRO_PM_FAST_STARTUP 0x17
65 #define BMI160_CMD_SOFTRESET 0xB6
66
67 #define BMI160_REG_DUMMY 0x7F
68
69 #define BMI160_ACCEL_PMU_MIN_USLEEP 3200
70 #define BMI160_ACCEL_PMU_MAX_USLEEP 3800
71 #define BMI160_GYRO_PMU_MIN_USLEEP 55000
72 #define BMI160_GYRO_PMU_MAX_USLEEP 80000
73 #define BMI160_SOFTRESET_USLEEP 1000
74
75 #define BMI160_CHANNEL(_type, _axis, _index) { \
76 .type = _type, \
77 .modified = 1, \
78 .channel2 = IIO_MOD_##_axis, \
79 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
80 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
81 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
82 .scan_index = _index, \
83 .scan_type = { \
84 .sign = 's', \
85 .realbits = 16, \
86 .storagebits = 16, \
87 .endianness = IIO_LE, \
88 }, \
89 }
90
91 /* scan indexes follow DATA register order */
92 enum bmi160_scan_axis {
93 BMI160_SCAN_EXT_MAGN_X = 0,
94 BMI160_SCAN_EXT_MAGN_Y,
95 BMI160_SCAN_EXT_MAGN_Z,
96 BMI160_SCAN_RHALL,
97 BMI160_SCAN_GYRO_X,
98 BMI160_SCAN_GYRO_Y,
99 BMI160_SCAN_GYRO_Z,
100 BMI160_SCAN_ACCEL_X,
101 BMI160_SCAN_ACCEL_Y,
102 BMI160_SCAN_ACCEL_Z,
103 BMI160_SCAN_TIMESTAMP,
104 };
105
106 enum bmi160_sensor_type {
107 BMI160_ACCEL = 0,
108 BMI160_GYRO,
109 BMI160_EXT_MAGN,
110 BMI160_NUM_SENSORS /* must be last */
111 };
112
113 struct bmi160_data {
114 struct regmap *regmap;
115 };
116
117 const struct regmap_config bmi160_regmap_config = {
118 .reg_bits = 8,
119 .val_bits = 8,
120 };
121 EXPORT_SYMBOL(bmi160_regmap_config);
122
123 struct bmi160_regs {
124 u8 data; /* LSB byte register for X-axis */
125 u8 config;
126 u8 config_odr_mask;
127 u8 config_bwp_mask;
128 u8 range;
129 u8 pmu_cmd_normal;
130 u8 pmu_cmd_suspend;
131 };
132
133 static struct bmi160_regs bmi160_regs[] = {
134 [BMI160_ACCEL] = {
135 .data = BMI160_REG_DATA_ACCEL_XOUT_L,
136 .config = BMI160_REG_ACCEL_CONFIG,
137 .config_odr_mask = BMI160_ACCEL_CONFIG_ODR_MASK,
138 .config_bwp_mask = BMI160_ACCEL_CONFIG_BWP_MASK,
139 .range = BMI160_REG_ACCEL_RANGE,
140 .pmu_cmd_normal = BMI160_CMD_ACCEL_PM_NORMAL,
141 .pmu_cmd_suspend = BMI160_CMD_ACCEL_PM_SUSPEND,
142 },
143 [BMI160_GYRO] = {
144 .data = BMI160_REG_DATA_GYRO_XOUT_L,
145 .config = BMI160_REG_GYRO_CONFIG,
146 .config_odr_mask = BMI160_GYRO_CONFIG_ODR_MASK,
147 .config_bwp_mask = BMI160_GYRO_CONFIG_BWP_MASK,
148 .range = BMI160_REG_GYRO_RANGE,
149 .pmu_cmd_normal = BMI160_CMD_GYRO_PM_NORMAL,
150 .pmu_cmd_suspend = BMI160_CMD_GYRO_PM_SUSPEND,
151 },
152 };
153
154 struct bmi160_pmu_time {
155 unsigned long min;
156 unsigned long max;
157 };
158
159 static struct bmi160_pmu_time bmi160_pmu_time[] = {
160 [BMI160_ACCEL] = {
161 .min = BMI160_ACCEL_PMU_MIN_USLEEP,
162 .max = BMI160_ACCEL_PMU_MAX_USLEEP
163 },
164 [BMI160_GYRO] = {
165 .min = BMI160_GYRO_PMU_MIN_USLEEP,
166 .max = BMI160_GYRO_PMU_MIN_USLEEP,
167 },
168 };
169
170 struct bmi160_scale {
171 u8 bits;
172 int uscale;
173 };
174
175 struct bmi160_odr {
176 u8 bits;
177 int odr;
178 int uodr;
179 };
180
181 static const struct bmi160_scale bmi160_accel_scale[] = {
182 { BMI160_ACCEL_RANGE_2G, 598},
183 { BMI160_ACCEL_RANGE_4G, 1197},
184 { BMI160_ACCEL_RANGE_8G, 2394},
185 { BMI160_ACCEL_RANGE_16G, 4788},
186 };
187
188 static const struct bmi160_scale bmi160_gyro_scale[] = {
189 { BMI160_GYRO_RANGE_2000DPS, 1065},
190 { BMI160_GYRO_RANGE_1000DPS, 532},
191 { BMI160_GYRO_RANGE_500DPS, 266},
192 { BMI160_GYRO_RANGE_250DPS, 133},
193 { BMI160_GYRO_RANGE_125DPS, 66},
194 };
195
196 struct bmi160_scale_item {
197 const struct bmi160_scale *tbl;
198 int num;
199 };
200
201 static const struct bmi160_scale_item bmi160_scale_table[] = {
202 [BMI160_ACCEL] = {
203 .tbl = bmi160_accel_scale,
204 .num = ARRAY_SIZE(bmi160_accel_scale),
205 },
206 [BMI160_GYRO] = {
207 .tbl = bmi160_gyro_scale,
208 .num = ARRAY_SIZE(bmi160_gyro_scale),
209 },
210 };
211
212 static const struct bmi160_odr bmi160_accel_odr[] = {
213 {0x01, 0, 781250},
214 {0x02, 1, 562500},
215 {0x03, 3, 125000},
216 {0x04, 6, 250000},
217 {0x05, 12, 500000},
218 {0x06, 25, 0},
219 {0x07, 50, 0},
220 {0x08, 100, 0},
221 {0x09, 200, 0},
222 {0x0A, 400, 0},
223 {0x0B, 800, 0},
224 {0x0C, 1600, 0},
225 };
226
227 static const struct bmi160_odr bmi160_gyro_odr[] = {
228 {0x06, 25, 0},
229 {0x07, 50, 0},
230 {0x08, 100, 0},
231 {0x09, 200, 0},
232 {0x0A, 400, 0},
233 {0x0B, 800, 0},
234 {0x0C, 1600, 0},
235 {0x0D, 3200, 0},
236 };
237
238 struct bmi160_odr_item {
239 const struct bmi160_odr *tbl;
240 int num;
241 };
242
243 static const struct bmi160_odr_item bmi160_odr_table[] = {
244 [BMI160_ACCEL] = {
245 .tbl = bmi160_accel_odr,
246 .num = ARRAY_SIZE(bmi160_accel_odr),
247 },
248 [BMI160_GYRO] = {
249 .tbl = bmi160_gyro_odr,
250 .num = ARRAY_SIZE(bmi160_gyro_odr),
251 },
252 };
253
254 static const struct iio_chan_spec bmi160_channels[] = {
255 BMI160_CHANNEL(IIO_ACCEL, X, BMI160_SCAN_ACCEL_X),
256 BMI160_CHANNEL(IIO_ACCEL, Y, BMI160_SCAN_ACCEL_Y),
257 BMI160_CHANNEL(IIO_ACCEL, Z, BMI160_SCAN_ACCEL_Z),
258 BMI160_CHANNEL(IIO_ANGL_VEL, X, BMI160_SCAN_GYRO_X),
259 BMI160_CHANNEL(IIO_ANGL_VEL, Y, BMI160_SCAN_GYRO_Y),
260 BMI160_CHANNEL(IIO_ANGL_VEL, Z, BMI160_SCAN_GYRO_Z),
261 IIO_CHAN_SOFT_TIMESTAMP(BMI160_SCAN_TIMESTAMP),
262 };
263
264 static enum bmi160_sensor_type bmi160_to_sensor(enum iio_chan_type iio_type)
265 {
266 switch (iio_type) {
267 case IIO_ACCEL:
268 return BMI160_ACCEL;
269 case IIO_ANGL_VEL:
270 return BMI160_GYRO;
271 default:
272 return -EINVAL;
273 }
274 }
275
276 static
277 int bmi160_set_mode(struct bmi160_data *data, enum bmi160_sensor_type t,
278 bool mode)
279 {
280 int ret;
281 u8 cmd;
282
283 if (mode)
284 cmd = bmi160_regs[t].pmu_cmd_normal;
285 else
286 cmd = bmi160_regs[t].pmu_cmd_suspend;
287
288 ret = regmap_write(data->regmap, BMI160_REG_CMD, cmd);
289 if (ret < 0)
290 return ret;
291
292 usleep_range(bmi160_pmu_time[t].min, bmi160_pmu_time[t].max);
293
294 return 0;
295 }
296
297 static
298 int bmi160_set_scale(struct bmi160_data *data, enum bmi160_sensor_type t,
299 int uscale)
300 {
301 int i;
302
303 for (i = 0; i < bmi160_scale_table[t].num; i++)
304 if (bmi160_scale_table[t].tbl[i].uscale == uscale)
305 break;
306
307 if (i == bmi160_scale_table[t].num)
308 return -EINVAL;
309
310 return regmap_write(data->regmap, bmi160_regs[t].range,
311 bmi160_scale_table[t].tbl[i].bits);
312 }
313
314 static
315 int bmi160_get_scale(struct bmi160_data *data, enum bmi160_sensor_type t,
316 int *uscale)
317 {
318 int i, ret, val;
319
320 ret = regmap_read(data->regmap, bmi160_regs[t].range, &val);
321 if (ret < 0)
322 return ret;
323
324 for (i = 0; i < bmi160_scale_table[t].num; i++)
325 if (bmi160_scale_table[t].tbl[i].bits == val) {
326 *uscale = bmi160_scale_table[t].tbl[i].uscale;
327 return 0;
328 }
329
330 return -EINVAL;
331 }
332
333 static int bmi160_get_data(struct bmi160_data *data, int chan_type,
334 int axis, int *val)
335 {
336 u8 reg;
337 int ret;
338 __le16 sample;
339 enum bmi160_sensor_type t = bmi160_to_sensor(chan_type);
340
341 reg = bmi160_regs[t].data + (axis - IIO_MOD_X) * sizeof(__le16);
342
343 ret = regmap_bulk_read(data->regmap, reg, &sample, sizeof(__le16));
344 if (ret < 0)
345 return ret;
346
347 *val = sign_extend32(le16_to_cpu(sample), 15);
348
349 return 0;
350 }
351
352 static
353 int bmi160_set_odr(struct bmi160_data *data, enum bmi160_sensor_type t,
354 int odr, int uodr)
355 {
356 int i;
357
358 for (i = 0; i < bmi160_odr_table[t].num; i++)
359 if (bmi160_odr_table[t].tbl[i].odr == odr &&
360 bmi160_odr_table[t].tbl[i].uodr == uodr)
361 break;
362
363 if (i >= bmi160_odr_table[t].num)
364 return -EINVAL;
365
366 return regmap_update_bits(data->regmap,
367 bmi160_regs[t].config,
368 bmi160_regs[t].config_odr_mask,
369 bmi160_odr_table[t].tbl[i].bits);
370 }
371
372 static int bmi160_get_odr(struct bmi160_data *data, enum bmi160_sensor_type t,
373 int *odr, int *uodr)
374 {
375 int i, val, ret;
376
377 ret = regmap_read(data->regmap, bmi160_regs[t].config, &val);
378 if (ret < 0)
379 return ret;
380
381 val &= bmi160_regs[t].config_odr_mask;
382
383 for (i = 0; i < bmi160_odr_table[t].num; i++)
384 if (val == bmi160_odr_table[t].tbl[i].bits)
385 break;
386
387 if (i >= bmi160_odr_table[t].num)
388 return -EINVAL;
389
390 *odr = bmi160_odr_table[t].tbl[i].odr;
391 *uodr = bmi160_odr_table[t].tbl[i].uodr;
392
393 return 0;
394 }
395
396 static irqreturn_t bmi160_trigger_handler(int irq, void *p)
397 {
398 struct iio_poll_func *pf = p;
399 struct iio_dev *indio_dev = pf->indio_dev;
400 struct bmi160_data *data = iio_priv(indio_dev);
401 __le16 buf[16];
402 /* 3 sens x 3 axis x __le16 + 3 x __le16 pad + 4 x __le16 tstamp */
403 int i, ret, j = 0, base = BMI160_REG_DATA_MAGN_XOUT_L;
404 __le16 sample;
405
406 for_each_set_bit(i, indio_dev->active_scan_mask,
407 indio_dev->masklength) {
408 ret = regmap_bulk_read(data->regmap, base + i * sizeof(__le16),
409 &sample, sizeof(__le16));
410 if (ret < 0)
411 goto done;
412 buf[j++] = sample;
413 }
414
415 iio_push_to_buffers_with_timestamp(indio_dev, buf,
416 iio_get_time_ns(indio_dev));
417 done:
418 iio_trigger_notify_done(indio_dev->trig);
419 return IRQ_HANDLED;
420 }
421
422 static int bmi160_read_raw(struct iio_dev *indio_dev,
423 struct iio_chan_spec const *chan,
424 int *val, int *val2, long mask)
425 {
426 int ret;
427 struct bmi160_data *data = iio_priv(indio_dev);
428
429 switch (mask) {
430 case IIO_CHAN_INFO_RAW:
431 ret = bmi160_get_data(data, chan->type, chan->channel2, val);
432 if (ret < 0)
433 return ret;
434 return IIO_VAL_INT;
435 case IIO_CHAN_INFO_SCALE:
436 *val = 0;
437 ret = bmi160_get_scale(data,
438 bmi160_to_sensor(chan->type), val2);
439 return ret < 0 ? ret : IIO_VAL_INT_PLUS_MICRO;
440 case IIO_CHAN_INFO_SAMP_FREQ:
441 ret = bmi160_get_odr(data, bmi160_to_sensor(chan->type),
442 val, val2);
443 return ret < 0 ? ret : IIO_VAL_INT_PLUS_MICRO;
444 default:
445 return -EINVAL;
446 }
447
448 return 0;
449 }
450
451 static int bmi160_write_raw(struct iio_dev *indio_dev,
452 struct iio_chan_spec const *chan,
453 int val, int val2, long mask)
454 {
455 struct bmi160_data *data = iio_priv(indio_dev);
456
457 switch (mask) {
458 case IIO_CHAN_INFO_SCALE:
459 return bmi160_set_scale(data,
460 bmi160_to_sensor(chan->type), val2);
461 break;
462 case IIO_CHAN_INFO_SAMP_FREQ:
463 return bmi160_set_odr(data, bmi160_to_sensor(chan->type),
464 val, val2);
465 default:
466 return -EINVAL;
467 }
468
469 return 0;
470 }
471
472 static
473 IIO_CONST_ATTR(in_accel_sampling_frequency_available,
474 "0.78125 1.5625 3.125 6.25 12.5 25 50 100 200 400 800 1600");
475 static
476 IIO_CONST_ATTR(in_anglvel_sampling_frequency_available,
477 "25 50 100 200 400 800 1600 3200");
478 static
479 IIO_CONST_ATTR(in_accel_scale_available,
480 "0.000598 0.001197 0.002394 0.004788");
481 static
482 IIO_CONST_ATTR(in_anglvel_scale_available,
483 "0.001065 0.000532 0.000266 0.000133 0.000066");
484
485 static struct attribute *bmi160_attrs[] = {
486 &iio_const_attr_in_accel_sampling_frequency_available.dev_attr.attr,
487 &iio_const_attr_in_anglvel_sampling_frequency_available.dev_attr.attr,
488 &iio_const_attr_in_accel_scale_available.dev_attr.attr,
489 &iio_const_attr_in_anglvel_scale_available.dev_attr.attr,
490 NULL,
491 };
492
493 static const struct attribute_group bmi160_attrs_group = {
494 .attrs = bmi160_attrs,
495 };
496
497 static const struct iio_info bmi160_info = {
498 .driver_module = THIS_MODULE,
499 .read_raw = bmi160_read_raw,
500 .write_raw = bmi160_write_raw,
501 .attrs = &bmi160_attrs_group,
502 };
503
504 static const char *bmi160_match_acpi_device(struct device *dev)
505 {
506 const struct acpi_device_id *id;
507
508 id = acpi_match_device(dev->driver->acpi_match_table, dev);
509 if (!id)
510 return NULL;
511
512 return dev_name(dev);
513 }
514
515 static int bmi160_chip_init(struct bmi160_data *data, bool use_spi)
516 {
517 int ret;
518 unsigned int val;
519 struct device *dev = regmap_get_device(data->regmap);
520
521 ret = regmap_write(data->regmap, BMI160_REG_CMD, BMI160_CMD_SOFTRESET);
522 if (ret < 0)
523 return ret;
524
525 usleep_range(BMI160_SOFTRESET_USLEEP, BMI160_SOFTRESET_USLEEP + 1);
526
527 /*
528 * CS rising edge is needed before starting SPI, so do a dummy read
529 * See Section 3.2.1, page 86 of the datasheet
530 */
531 if (use_spi) {
532 ret = regmap_read(data->regmap, BMI160_REG_DUMMY, &val);
533 if (ret < 0)
534 return ret;
535 }
536
537 ret = regmap_read(data->regmap, BMI160_REG_CHIP_ID, &val);
538 if (ret < 0) {
539 dev_err(dev, "Error reading chip id\n");
540 return ret;
541 }
542 if (val != BMI160_CHIP_ID_VAL) {
543 dev_err(dev, "Wrong chip id, got %x expected %x\n",
544 val, BMI160_CHIP_ID_VAL);
545 return -ENODEV;
546 }
547
548 ret = bmi160_set_mode(data, BMI160_ACCEL, true);
549 if (ret < 0)
550 return ret;
551
552 ret = bmi160_set_mode(data, BMI160_GYRO, true);
553 if (ret < 0)
554 return ret;
555
556 return 0;
557 }
558
559 static void bmi160_chip_uninit(struct bmi160_data *data)
560 {
561 bmi160_set_mode(data, BMI160_GYRO, false);
562 bmi160_set_mode(data, BMI160_ACCEL, false);
563 }
564
565 int bmi160_core_probe(struct device *dev, struct regmap *regmap,
566 const char *name, bool use_spi)
567 {
568 struct iio_dev *indio_dev;
569 struct bmi160_data *data;
570 int ret;
571
572 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
573 if (!indio_dev)
574 return -ENOMEM;
575
576 data = iio_priv(indio_dev);
577 dev_set_drvdata(dev, indio_dev);
578 data->regmap = regmap;
579
580 ret = bmi160_chip_init(data, use_spi);
581 if (ret < 0)
582 return ret;
583
584 if (!name && ACPI_HANDLE(dev))
585 name = bmi160_match_acpi_device(dev);
586
587 indio_dev->dev.parent = dev;
588 indio_dev->channels = bmi160_channels;
589 indio_dev->num_channels = ARRAY_SIZE(bmi160_channels);
590 indio_dev->name = name;
591 indio_dev->modes = INDIO_DIRECT_MODE;
592 indio_dev->info = &bmi160_info;
593
594 ret = iio_triggered_buffer_setup(indio_dev, NULL,
595 bmi160_trigger_handler, NULL);
596 if (ret < 0)
597 goto uninit;
598
599 ret = iio_device_register(indio_dev);
600 if (ret < 0)
601 goto buffer_cleanup;
602
603 return 0;
604 buffer_cleanup:
605 iio_triggered_buffer_cleanup(indio_dev);
606 uninit:
607 bmi160_chip_uninit(data);
608 return ret;
609 }
610 EXPORT_SYMBOL_GPL(bmi160_core_probe);
611
612 void bmi160_core_remove(struct device *dev)
613 {
614 struct iio_dev *indio_dev = dev_get_drvdata(dev);
615 struct bmi160_data *data = iio_priv(indio_dev);
616
617 iio_device_unregister(indio_dev);
618 iio_triggered_buffer_cleanup(indio_dev);
619 bmi160_chip_uninit(data);
620 }
621 EXPORT_SYMBOL_GPL(bmi160_core_remove);
622
623 MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com");
624 MODULE_DESCRIPTION("Bosch BMI160 driver");
625 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support