?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / iio / accel / bma180.c
blobfcd91d5f05fd172805535bd31e1a37781c150a91
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * bma180.c - IIO driver for Bosch BMA180 triaxial acceleration sensor
4 *
5 * Copyright 2013 Oleksandr Kravchenko <x0199363@ti.com>
6 *
7 * Support for BMA250 (c) Peter Meerwald <pmeerw@pmeerw.net>
8 *
9 * SPI is not supported by driver
10 * BMA180: 7-bit I2C slave address 0x40 or 0x41
11 * BMA250: 7-bit I2C slave address 0x18 or 0x19
12 * BMA254: 7-bit I2C slave address 0x18 or 0x19
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/of_device.h>
20 #include <linux/of.h>
21 #include <linux/bitops.h>
22 #include <linux/regulator/consumer.h>
23 #include <linux/slab.h>
24 #include <linux/string.h>
25 #include <linux/iio/iio.h>
26 #include <linux/iio/sysfs.h>
27 #include <linux/iio/buffer.h>
28 #include <linux/iio/trigger.h>
29 #include <linux/iio/trigger_consumer.h>
30 #include <linux/iio/triggered_buffer.h>
31
32 #define BMA180_DRV_NAME "bma180"
33 #define BMA180_IRQ_NAME "bma180_event"
34
35 enum chip_ids {
36 BMA180,
37 BMA250,
38 BMA254,
39 };
40
41 struct bma180_data;
42
43 struct bma180_part_info {
44 u8 chip_id;
45 const struct iio_chan_spec *channels;
46 unsigned int num_channels;
47 const int *scale_table;
48 unsigned int num_scales;
49 const int *bw_table;
50 unsigned int num_bw;
51 int center_temp;
52
53 u8 int_reset_reg, int_reset_mask;
54 u8 sleep_reg, sleep_mask;
55 u8 bw_reg, bw_mask;
56 u8 scale_reg, scale_mask;
57 u8 power_reg, power_mask, lowpower_val;
58 u8 int_enable_reg, int_enable_mask;
59 u8 int_map_reg, int_enable_dataready_int1_mask;
60 u8 softreset_reg;
61
62 int (*chip_config)(struct bma180_data *data);
63 void (*chip_disable)(struct bma180_data *data);
64 };
65
66 /* Register set */
67 #define BMA180_CHIP_ID 0x00 /* Need to distinguish BMA180 from other */
68 #define BMA180_ACC_X_LSB 0x02 /* First of 6 registers of accel data */
69 #define BMA180_TEMP 0x08
70 #define BMA180_CTRL_REG0 0x0d
71 #define BMA180_RESET 0x10
72 #define BMA180_BW_TCS 0x20
73 #define BMA180_CTRL_REG3 0x21
74 #define BMA180_TCO_Z 0x30
75 #define BMA180_OFFSET_LSB1 0x35
76
77 /* BMA180_CTRL_REG0 bits */
78 #define BMA180_DIS_WAKE_UP BIT(0) /* Disable wake up mode */
79 #define BMA180_SLEEP BIT(1) /* 1 - chip will sleep */
80 #define BMA180_EE_W BIT(4) /* Unlock writing to addr from 0x20 */
81 #define BMA180_RESET_INT BIT(6) /* Reset pending interrupts */
82
83 /* BMA180_CTRL_REG3 bits */
84 #define BMA180_NEW_DATA_INT BIT(1) /* Intr every new accel data is ready */
85
86 /* BMA180_OFFSET_LSB1 skipping mode bit */
87 #define BMA180_SMP_SKIP BIT(0)
88
89 /* Bit masks for registers bit fields */
90 #define BMA180_RANGE 0x0e /* Range of measured accel values */
91 #define BMA180_BW 0xf0 /* Accel bandwidth */
92 #define BMA180_MODE_CONFIG 0x03 /* Config operation modes */
93
94 /* We have to write this value in reset register to do soft reset */
95 #define BMA180_RESET_VAL 0xb6
96
97 #define BMA180_ID_REG_VAL 0x03
98 #define BMA250_ID_REG_VAL 0x03
99 #define BMA254_ID_REG_VAL 0xfa /* 250 decimal */
100
101 /* Chip power modes */
102 #define BMA180_LOW_POWER 0x03
103
104 #define BMA250_RANGE_REG 0x0f
105 #define BMA250_BW_REG 0x10
106 #define BMA250_POWER_REG 0x11
107 #define BMA250_RESET_REG 0x14
108 #define BMA250_INT_ENABLE_REG 0x17
109 #define BMA250_INT_MAP_REG 0x1a
110 #define BMA250_INT_RESET_REG 0x21
111
112 #define BMA250_RANGE_MASK GENMASK(3, 0) /* Range of accel values */
113 #define BMA250_BW_MASK GENMASK(4, 0) /* Accel bandwidth */
114 #define BMA250_SUSPEND_MASK BIT(7) /* chip will sleep */
115 #define BMA250_LOWPOWER_MASK BIT(6)
116 #define BMA250_DATA_INTEN_MASK BIT(4)
117 #define BMA250_INT1_DATA_MASK BIT(0)
118 #define BMA250_INT_RESET_MASK BIT(7) /* Reset pending interrupts */
119
120 #define BMA254_RANGE_REG 0x0f
121 #define BMA254_BW_REG 0x10
122 #define BMA254_POWER_REG 0x11
123 #define BMA254_RESET_REG 0x14
124 #define BMA254_INT_ENABLE_REG 0x17
125 #define BMA254_INT_MAP_REG 0x1a
126 #define BMA254_INT_RESET_REG 0x21
127
128 #define BMA254_RANGE_MASK GENMASK(3, 0) /* Range of accel values */
129 #define BMA254_BW_MASK GENMASK(4, 0) /* Accel bandwidth */
130 #define BMA254_SUSPEND_MASK BIT(7) /* chip will sleep */
131 #define BMA254_LOWPOWER_MASK BIT(6)
132 #define BMA254_DATA_INTEN_MASK BIT(4)
133 #define BMA254_INT2_DATA_MASK BIT(7)
134 #define BMA254_INT1_DATA_MASK BIT(0)
135 #define BMA254_INT_RESET_MASK BIT(7) /* Reset pending interrupts */
136
137 struct bma180_data {
138 struct regulator *vdd_supply;
139 struct regulator *vddio_supply;
140 struct i2c_client *client;
141 struct iio_trigger *trig;
142 const struct bma180_part_info *part_info;
143 struct iio_mount_matrix orientation;
144 struct mutex mutex;
145 bool sleep_state;
146 int scale;
147 int bw;
148 bool pmode;
149 u8 buff[16]; /* 3x 16-bit + 8-bit + padding + timestamp */
150 };
151
152 enum bma180_chan {
153 AXIS_X,
154 AXIS_Y,
155 AXIS_Z,
156 TEMP
157 };
158
159 static int bma180_bw_table[] = { 10, 20, 40, 75, 150, 300 }; /* Hz */
160 static int bma180_scale_table[] = { 1275, 1863, 2452, 3727, 4903, 9709, 19417 };
161
162 static int bma25x_bw_table[] = { 8, 16, 31, 63, 125, 250 }; /* Hz */
163 static int bma25x_scale_table[] = { 0, 0, 0, 38344, 0, 76590, 0, 0, 153180, 0,
164 0, 0, 306458 };
165
166 static int bma180_get_data_reg(struct bma180_data *data, enum bma180_chan chan)
167 {
168 int ret;
169
170 if (data->sleep_state)
171 return -EBUSY;
172
173 switch (chan) {
174 case TEMP:
175 ret = i2c_smbus_read_byte_data(data->client, BMA180_TEMP);
176 if (ret < 0)
177 dev_err(&data->client->dev, "failed to read temp register\n");
178 break;
179 default:
180 ret = i2c_smbus_read_word_data(data->client,
181 BMA180_ACC_X_LSB + chan * 2);
182 if (ret < 0)
183 dev_err(&data->client->dev,
184 "failed to read accel_%c register\n",
185 'x' + chan);
186 }
187
188 return ret;
189 }
190
191 static int bma180_set_bits(struct bma180_data *data, u8 reg, u8 mask, u8 val)
192 {
193 int ret = i2c_smbus_read_byte_data(data->client, reg);
194 u8 reg_val = (ret & ~mask) | (val << (ffs(mask) - 1));
195
196 if (ret < 0)
197 return ret;
198
199 return i2c_smbus_write_byte_data(data->client, reg, reg_val);
200 }
201
202 static int bma180_reset_intr(struct bma180_data *data)
203 {
204 int ret = bma180_set_bits(data, data->part_info->int_reset_reg,
205 data->part_info->int_reset_mask, 1);
206
207 if (ret)
208 dev_err(&data->client->dev, "failed to reset interrupt\n");
209
210 return ret;
211 }
212
213 static int bma180_set_new_data_intr_state(struct bma180_data *data, bool state)
214 {
215 int ret = bma180_set_bits(data, data->part_info->int_enable_reg,
216 data->part_info->int_enable_mask, state);
217 if (ret)
218 goto err;
219 ret = bma180_reset_intr(data);
220 if (ret)
221 goto err;
222
223 return 0;
224
225 err:
226 dev_err(&data->client->dev,
227 "failed to set new data interrupt state %d\n", state);
228 return ret;
229 }
230
231 static int bma180_set_sleep_state(struct bma180_data *data, bool state)
232 {
233 int ret = bma180_set_bits(data, data->part_info->sleep_reg,
234 data->part_info->sleep_mask, state);
235
236 if (ret) {
237 dev_err(&data->client->dev,
238 "failed to set sleep state %d\n", state);
239 return ret;
240 }
241 data->sleep_state = state;
242
243 return 0;
244 }
245
246 static int bma180_set_ee_writing_state(struct bma180_data *data, bool state)
247 {
248 int ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_EE_W, state);
249
250 if (ret)
251 dev_err(&data->client->dev,
252 "failed to set ee writing state %d\n", state);
253
254 return ret;
255 }
256
257 static int bma180_set_bw(struct bma180_data *data, int val)
258 {
259 int ret, i;
260
261 if (data->sleep_state)
262 return -EBUSY;
263
264 for (i = 0; i < data->part_info->num_bw; ++i) {
265 if (data->part_info->bw_table[i] == val) {
266 ret = bma180_set_bits(data, data->part_info->bw_reg,
267 data->part_info->bw_mask, i);
268 if (ret) {
269 dev_err(&data->client->dev,
270 "failed to set bandwidth\n");
271 return ret;
272 }
273 data->bw = val;
274 return 0;
275 }
276 }
277
278 return -EINVAL;
279 }
280
281 static int bma180_set_scale(struct bma180_data *data, int val)
282 {
283 int ret, i;
284
285 if (data->sleep_state)
286 return -EBUSY;
287
288 for (i = 0; i < data->part_info->num_scales; ++i)
289 if (data->part_info->scale_table[i] == val) {
290 ret = bma180_set_bits(data, data->part_info->scale_reg,
291 data->part_info->scale_mask, i);
292 if (ret) {
293 dev_err(&data->client->dev,
294 "failed to set scale\n");
295 return ret;
296 }
297 data->scale = val;
298 return 0;
299 }
300
301 return -EINVAL;
302 }
303
304 static int bma180_set_pmode(struct bma180_data *data, bool mode)
305 {
306 u8 reg_val = mode ? data->part_info->lowpower_val : 0;
307 int ret = bma180_set_bits(data, data->part_info->power_reg,
308 data->part_info->power_mask, reg_val);
309
310 if (ret) {
311 dev_err(&data->client->dev, "failed to set power mode\n");
312 return ret;
313 }
314 data->pmode = mode;
315
316 return 0;
317 }
318
319 static int bma180_soft_reset(struct bma180_data *data)
320 {
321 int ret = i2c_smbus_write_byte_data(data->client,
322 data->part_info->softreset_reg, BMA180_RESET_VAL);
323
324 if (ret)
325 dev_err(&data->client->dev, "failed to reset the chip\n");
326
327 return ret;
328 }
329
330 static int bma180_chip_init(struct bma180_data *data)
331 {
332 /* Try to read chip_id register. It must return 0x03. */
333 int ret = i2c_smbus_read_byte_data(data->client, BMA180_CHIP_ID);
334
335 if (ret < 0)
336 return ret;
337 if (ret != data->part_info->chip_id) {
338 dev_err(&data->client->dev, "wrong chip ID %d expected %d\n",
339 ret, data->part_info->chip_id);
340 return -ENODEV;
341 }
342
343 ret = bma180_soft_reset(data);
344 if (ret)
345 return ret;
346 /*
347 * No serial transaction should occur within minimum 10 us
348 * after soft_reset command
349 */
350 msleep(20);
351
352 ret = bma180_set_new_data_intr_state(data, false);
353 if (ret)
354 return ret;
355
356 return bma180_set_pmode(data, false);
357 }
358
359 static int bma180_chip_config(struct bma180_data *data)
360 {
361 int ret = bma180_chip_init(data);
362
363 if (ret)
364 goto err;
365 ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_DIS_WAKE_UP, 1);
366 if (ret)
367 goto err;
368 ret = bma180_set_ee_writing_state(data, true);
369 if (ret)
370 goto err;
371 ret = bma180_set_bits(data, BMA180_OFFSET_LSB1, BMA180_SMP_SKIP, 1);
372 if (ret)
373 goto err;
374 ret = bma180_set_bw(data, 20); /* 20 Hz */
375 if (ret)
376 goto err;
377 ret = bma180_set_scale(data, 2452); /* 2 G */
378 if (ret)
379 goto err;
380
381 return 0;
382
383 err:
384 dev_err(&data->client->dev, "failed to config the chip\n");
385 return ret;
386 }
387
388 static int bma25x_chip_config(struct bma180_data *data)
389 {
390 int ret = bma180_chip_init(data);
391
392 if (ret)
393 goto err;
394 ret = bma180_set_bw(data, 16); /* 16 Hz */
395 if (ret)
396 goto err;
397 ret = bma180_set_scale(data, 38344); /* 2 G */
398 if (ret)
399 goto err;
400 /*
401 * This enables dataready interrupt on the INT1 pin
402 * FIXME: support using the INT2 pin
403 */
404 ret = bma180_set_bits(data, data->part_info->int_map_reg,
405 data->part_info->int_enable_dataready_int1_mask, 1);
406 if (ret)
407 goto err;
408
409 return 0;
410
411 err:
412 dev_err(&data->client->dev, "failed to config the chip\n");
413 return ret;
414 }
415
416 static void bma180_chip_disable(struct bma180_data *data)
417 {
418 if (bma180_set_new_data_intr_state(data, false))
419 goto err;
420 if (bma180_set_ee_writing_state(data, false))
421 goto err;
422 if (bma180_set_sleep_state(data, true))
423 goto err;
424
425 return;
426
427 err:
428 dev_err(&data->client->dev, "failed to disable the chip\n");
429 }
430
431 static void bma25x_chip_disable(struct bma180_data *data)
432 {
433 if (bma180_set_new_data_intr_state(data, false))
434 goto err;
435 if (bma180_set_sleep_state(data, true))
436 goto err;
437
438 return;
439
440 err:
441 dev_err(&data->client->dev, "failed to disable the chip\n");
442 }
443
444 static ssize_t bma180_show_avail(char *buf, const int *vals, unsigned int n,
445 bool micros)
446 {
447 size_t len = 0;
448 int i;
449
450 for (i = 0; i < n; i++) {
451 if (!vals[i])
452 continue;
453 len += scnprintf(buf + len, PAGE_SIZE - len,
454 micros ? "0.%06d " : "%d ", vals[i]);
455 }
456 buf[len - 1] = '\n';
457
458 return len;
459 }
460
461 static ssize_t bma180_show_filter_freq_avail(struct device *dev,
462 struct device_attribute *attr, char *buf)
463 {
464 struct bma180_data *data = iio_priv(dev_to_iio_dev(dev));
465
466 return bma180_show_avail(buf, data->part_info->bw_table,
467 data->part_info->num_bw, false);
468 }
469
470 static ssize_t bma180_show_scale_avail(struct device *dev,
471 struct device_attribute *attr, char *buf)
472 {
473 struct bma180_data *data = iio_priv(dev_to_iio_dev(dev));
474
475 return bma180_show_avail(buf, data->part_info->scale_table,
476 data->part_info->num_scales, true);
477 }
478
479 static IIO_DEVICE_ATTR(in_accel_filter_low_pass_3db_frequency_available,
480 S_IRUGO, bma180_show_filter_freq_avail, NULL, 0);
481
482 static IIO_DEVICE_ATTR(in_accel_scale_available,
483 S_IRUGO, bma180_show_scale_avail, NULL, 0);
484
485 static struct attribute *bma180_attributes[] = {
486 &iio_dev_attr_in_accel_filter_low_pass_3db_frequency_available.
487 dev_attr.attr,
488 &iio_dev_attr_in_accel_scale_available.dev_attr.attr,
489 NULL,
490 };
491
492 static const struct attribute_group bma180_attrs_group = {
493 .attrs = bma180_attributes,
494 };
495
496 static int bma180_read_raw(struct iio_dev *indio_dev,
497 struct iio_chan_spec const *chan, int *val, int *val2,
498 long mask)
499 {
500 struct bma180_data *data = iio_priv(indio_dev);
501 int ret;
502
503 switch (mask) {
504 case IIO_CHAN_INFO_RAW:
505 ret = iio_device_claim_direct_mode(indio_dev);
506 if (ret)
507 return ret;
508
509 mutex_lock(&data->mutex);
510 ret = bma180_get_data_reg(data, chan->scan_index);
511 mutex_unlock(&data->mutex);
512 iio_device_release_direct_mode(indio_dev);
513 if (ret < 0)
514 return ret;
515 *val = sign_extend32(ret >> chan->scan_type.shift,
516 chan->scan_type.realbits - 1);
517 return IIO_VAL_INT;
518 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
519 *val = data->bw;
520 return IIO_VAL_INT;
521 case IIO_CHAN_INFO_SCALE:
522 switch (chan->type) {
523 case IIO_ACCEL:
524 *val = 0;
525 *val2 = data->scale;
526 return IIO_VAL_INT_PLUS_MICRO;
527 case IIO_TEMP:
528 *val = 500;
529 return IIO_VAL_INT;
530 default:
531 return -EINVAL;
532 }
533 case IIO_CHAN_INFO_OFFSET:
534 *val = data->part_info->center_temp;
535 return IIO_VAL_INT;
536 default:
537 return -EINVAL;
538 }
539 }
540
541 static int bma180_write_raw(struct iio_dev *indio_dev,
542 struct iio_chan_spec const *chan, int val, int val2, long mask)
543 {
544 struct bma180_data *data = iio_priv(indio_dev);
545 int ret;
546
547 switch (mask) {
548 case IIO_CHAN_INFO_SCALE:
549 if (val)
550 return -EINVAL;
551 mutex_lock(&data->mutex);
552 ret = bma180_set_scale(data, val2);
553 mutex_unlock(&data->mutex);
554 return ret;
555 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
556 if (val2)
557 return -EINVAL;
558 mutex_lock(&data->mutex);
559 ret = bma180_set_bw(data, val);
560 mutex_unlock(&data->mutex);
561 return ret;
562 default:
563 return -EINVAL;
564 }
565 }
566
567 static const struct iio_info bma180_info = {
568 .attrs = &bma180_attrs_group,
569 .read_raw = bma180_read_raw,
570 .write_raw = bma180_write_raw,
571 };
572
573 static const char * const bma180_power_modes[] = { "low_noise", "low_power" };
574
575 static int bma180_get_power_mode(struct iio_dev *indio_dev,
576 const struct iio_chan_spec *chan)
577 {
578 struct bma180_data *data = iio_priv(indio_dev);
579
580 return data->pmode;
581 }
582
583 static int bma180_set_power_mode(struct iio_dev *indio_dev,
584 const struct iio_chan_spec *chan, unsigned int mode)
585 {
586 struct bma180_data *data = iio_priv(indio_dev);
587 int ret;
588
589 mutex_lock(&data->mutex);
590 ret = bma180_set_pmode(data, mode);
591 mutex_unlock(&data->mutex);
592
593 return ret;
594 }
595
596 static const struct iio_mount_matrix *
597 bma180_accel_get_mount_matrix(const struct iio_dev *indio_dev,
598 const struct iio_chan_spec *chan)
599 {
600 struct bma180_data *data = iio_priv(indio_dev);
601
602 return &data->orientation;
603 }
604
605 static const struct iio_enum bma180_power_mode_enum = {
606 .items = bma180_power_modes,
607 .num_items = ARRAY_SIZE(bma180_power_modes),
608 .get = bma180_get_power_mode,
609 .set = bma180_set_power_mode,
610 };
611
612 static const struct iio_chan_spec_ext_info bma180_ext_info[] = {
613 IIO_ENUM("power_mode", true, &bma180_power_mode_enum),
614 IIO_ENUM_AVAILABLE("power_mode", &bma180_power_mode_enum),
615 IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, bma180_accel_get_mount_matrix),
616 { }
617 };
618
619 #define BMA180_ACC_CHANNEL(_axis, _bits) { \
620 .type = IIO_ACCEL, \
621 .modified = 1, \
622 .channel2 = IIO_MOD_##_axis, \
623 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
624 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
625 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
626 .scan_index = AXIS_##_axis, \
627 .scan_type = { \
628 .sign = 's', \
629 .realbits = _bits, \
630 .storagebits = 16, \
631 .shift = 16 - _bits, \
632 }, \
633 .ext_info = bma180_ext_info, \
634 }
635
636 #define BMA180_TEMP_CHANNEL { \
637 .type = IIO_TEMP, \
638 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
639 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_OFFSET), \
640 .scan_index = TEMP, \
641 .scan_type = { \
642 .sign = 's', \
643 .realbits = 8, \
644 .storagebits = 16, \
645 }, \
646 }
647
648 static const struct iio_chan_spec bma180_channels[] = {
649 BMA180_ACC_CHANNEL(X, 14),
650 BMA180_ACC_CHANNEL(Y, 14),
651 BMA180_ACC_CHANNEL(Z, 14),
652 BMA180_TEMP_CHANNEL,
653 IIO_CHAN_SOFT_TIMESTAMP(4),
654 };
655
656 static const struct iio_chan_spec bma250_channels[] = {
657 BMA180_ACC_CHANNEL(X, 10),
658 BMA180_ACC_CHANNEL(Y, 10),
659 BMA180_ACC_CHANNEL(Z, 10),
660 BMA180_TEMP_CHANNEL,
661 IIO_CHAN_SOFT_TIMESTAMP(4),
662 };
663
664 static const struct iio_chan_spec bma254_channels[] = {
665 BMA180_ACC_CHANNEL(X, 12),
666 BMA180_ACC_CHANNEL(Y, 12),
667 BMA180_ACC_CHANNEL(Z, 12),
668 BMA180_TEMP_CHANNEL,
669 IIO_CHAN_SOFT_TIMESTAMP(4),
670 };
671
672 static const struct bma180_part_info bma180_part_info[] = {
673 [BMA180] = {
674 .chip_id = BMA180_ID_REG_VAL,
675 .channels = bma180_channels,
676 .num_channels = ARRAY_SIZE(bma180_channels),
677 .scale_table = bma180_scale_table,
678 .num_scales = ARRAY_SIZE(bma180_scale_table),
679 .bw_table = bma180_bw_table,
680 .num_bw = ARRAY_SIZE(bma180_bw_table),
681 .center_temp = 48, /* 0 LSB @ 24 degree C */
682 .int_reset_reg = BMA180_CTRL_REG0,
683 .int_reset_mask = BMA180_RESET_INT,
684 .sleep_reg = BMA180_CTRL_REG0,
685 .sleep_mask = BMA180_SLEEP,
686 .bw_reg = BMA180_BW_TCS,
687 .bw_mask = BMA180_BW,
688 .scale_reg = BMA180_OFFSET_LSB1,
689 .scale_mask = BMA180_RANGE,
690 .power_reg = BMA180_TCO_Z,
691 .power_mask = BMA180_MODE_CONFIG,
692 .lowpower_val = BMA180_LOW_POWER,
693 .int_enable_reg = BMA180_CTRL_REG3,
694 .int_enable_mask = BMA180_NEW_DATA_INT,
695 .softreset_reg = BMA180_RESET,
696 .chip_config = bma180_chip_config,
697 .chip_disable = bma180_chip_disable,
698 },
699 [BMA250] = {
700 .chip_id = BMA250_ID_REG_VAL,
701 .channels = bma250_channels,
702 .num_channels = ARRAY_SIZE(bma250_channels),
703 .scale_table = bma25x_scale_table,
704 .num_scales = ARRAY_SIZE(bma25x_scale_table),
705 .bw_table = bma25x_bw_table,
706 .num_bw = ARRAY_SIZE(bma25x_bw_table),
707 .center_temp = 48, /* 0 LSB @ 24 degree C */
708 .int_reset_reg = BMA250_INT_RESET_REG,
709 .int_reset_mask = BMA250_INT_RESET_MASK,
710 .sleep_reg = BMA250_POWER_REG,
711 .sleep_mask = BMA250_SUSPEND_MASK,
712 .bw_reg = BMA250_BW_REG,
713 .bw_mask = BMA250_BW_MASK,
714 .scale_reg = BMA250_RANGE_REG,
715 .scale_mask = BMA250_RANGE_MASK,
716 .power_reg = BMA250_POWER_REG,
717 .power_mask = BMA250_LOWPOWER_MASK,
718 .lowpower_val = 1,
719 .int_enable_reg = BMA250_INT_ENABLE_REG,
720 .int_enable_mask = BMA250_DATA_INTEN_MASK,
721 .int_map_reg = BMA250_INT_MAP_REG,
722 .int_enable_dataready_int1_mask = BMA250_INT1_DATA_MASK,
723 .softreset_reg = BMA250_RESET_REG,
724 .chip_config = bma25x_chip_config,
725 .chip_disable = bma25x_chip_disable,
726 },
727 [BMA254] = {
728 .chip_id = BMA254_ID_REG_VAL,
729 .channels = bma254_channels,
730 .num_channels = ARRAY_SIZE(bma254_channels),
731 .scale_table = bma25x_scale_table,
732 .num_scales = ARRAY_SIZE(bma25x_scale_table),
733 .bw_table = bma25x_bw_table,
734 .num_bw = ARRAY_SIZE(bma25x_bw_table),
735 .center_temp = 46, /* 0 LSB @ 23 degree C */
736 .int_reset_reg = BMA254_INT_RESET_REG,
737 .int_reset_mask = BMA254_INT_RESET_MASK,
738 .sleep_reg = BMA254_POWER_REG,
739 .sleep_mask = BMA254_SUSPEND_MASK,
740 .bw_reg = BMA254_BW_REG,
741 .bw_mask = BMA254_BW_MASK,
742 .scale_reg = BMA254_RANGE_REG,
743 .scale_mask = BMA254_RANGE_MASK,
744 .power_reg = BMA254_POWER_REG,
745 .power_mask = BMA254_LOWPOWER_MASK,
746 .lowpower_val = 1,
747 .int_enable_reg = BMA254_INT_ENABLE_REG,
748 .int_enable_mask = BMA254_DATA_INTEN_MASK,
749 .int_map_reg = BMA254_INT_MAP_REG,
750 .int_enable_dataready_int1_mask = BMA254_INT1_DATA_MASK,
751 .softreset_reg = BMA254_RESET_REG,
752 .chip_config = bma25x_chip_config,
753 .chip_disable = bma25x_chip_disable,
754 },
755 };
756
757 static irqreturn_t bma180_trigger_handler(int irq, void *p)
758 {
759 struct iio_poll_func *pf = p;
760 struct iio_dev *indio_dev = pf->indio_dev;
761 struct bma180_data *data = iio_priv(indio_dev);
762 s64 time_ns = iio_get_time_ns(indio_dev);
763 int bit, ret, i = 0;
764
765 mutex_lock(&data->mutex);
766
767 for_each_set_bit(bit, indio_dev->active_scan_mask,
768 indio_dev->masklength) {
769 ret = bma180_get_data_reg(data, bit);
770 if (ret < 0) {
771 mutex_unlock(&data->mutex);
772 goto err;
773 }
774 ((s16 *)data->buff)[i++] = ret;
775 }
776
777 mutex_unlock(&data->mutex);
778
779 iio_push_to_buffers_with_timestamp(indio_dev, data->buff, time_ns);
780 err:
781 iio_trigger_notify_done(indio_dev->trig);
782
783 return IRQ_HANDLED;
784 }
785
786 static int bma180_data_rdy_trigger_set_state(struct iio_trigger *trig,
787 bool state)
788 {
789 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
790 struct bma180_data *data = iio_priv(indio_dev);
791
792 return bma180_set_new_data_intr_state(data, state);
793 }
794
795 static int bma180_trig_try_reen(struct iio_trigger *trig)
796 {
797 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
798 struct bma180_data *data = iio_priv(indio_dev);
799
800 return bma180_reset_intr(data);
801 }
802
803 static const struct iio_trigger_ops bma180_trigger_ops = {
804 .set_trigger_state = bma180_data_rdy_trigger_set_state,
805 .try_reenable = bma180_trig_try_reen,
806 };
807
808 static int bma180_probe(struct i2c_client *client,
809 const struct i2c_device_id *id)
810 {
811 struct device *dev = &client->dev;
812 struct bma180_data *data;
813 struct iio_dev *indio_dev;
814 enum chip_ids chip;
815 int ret;
816
817 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
818 if (!indio_dev)
819 return -ENOMEM;
820
821 data = iio_priv(indio_dev);
822 i2c_set_clientdata(client, indio_dev);
823 data->client = client;
824 if (client->dev.of_node)
825 chip = (enum chip_ids)of_device_get_match_data(dev);
826 else
827 chip = id->driver_data;
828 data->part_info = &bma180_part_info[chip];
829
830 ret = iio_read_mount_matrix(dev, "mount-matrix",
831 &data->orientation);
832 if (ret)
833 return ret;
834
835 data->vdd_supply = devm_regulator_get(dev, "vdd");
836 if (IS_ERR(data->vdd_supply)) {
837 if (PTR_ERR(data->vdd_supply) != -EPROBE_DEFER)
838 dev_err(dev, "Failed to get vdd regulator %d\n",
839 (int)PTR_ERR(data->vdd_supply));
840 return PTR_ERR(data->vdd_supply);
841 }
842 data->vddio_supply = devm_regulator_get(dev, "vddio");
843 if (IS_ERR(data->vddio_supply)) {
844 if (PTR_ERR(data->vddio_supply) != -EPROBE_DEFER)
845 dev_err(dev, "Failed to get vddio regulator %d\n",
846 (int)PTR_ERR(data->vddio_supply));
847 return PTR_ERR(data->vddio_supply);
848 }
849 /* Typical voltage 2.4V these are min and max */
850 ret = regulator_set_voltage(data->vdd_supply, 1620000, 3600000);
851 if (ret)
852 return ret;
853 ret = regulator_set_voltage(data->vddio_supply, 1200000, 3600000);
854 if (ret)
855 return ret;
856 ret = regulator_enable(data->vdd_supply);
857 if (ret) {
858 dev_err(dev, "Failed to enable vdd regulator: %d\n", ret);
859 return ret;
860 }
861 ret = regulator_enable(data->vddio_supply);
862 if (ret) {
863 dev_err(dev, "Failed to enable vddio regulator: %d\n", ret);
864 goto err_disable_vdd;
865 }
866 /* Wait to make sure we started up properly (3 ms at least) */
867 usleep_range(3000, 5000);
868
869 ret = data->part_info->chip_config(data);
870 if (ret < 0)
871 goto err_chip_disable;
872
873 mutex_init(&data->mutex);
874 indio_dev->dev.parent = dev;
875 indio_dev->channels = data->part_info->channels;
876 indio_dev->num_channels = data->part_info->num_channels;
877 indio_dev->name = id->name;
878 indio_dev->modes = INDIO_DIRECT_MODE;
879 indio_dev->info = &bma180_info;
880
881 if (client->irq > 0) {
882 data->trig = iio_trigger_alloc("%s-dev%d", indio_dev->name,
883 indio_dev->id);
884 if (!data->trig) {
885 ret = -ENOMEM;
886 goto err_chip_disable;
887 }
888
889 ret = devm_request_irq(dev, client->irq,
890 iio_trigger_generic_data_rdy_poll, IRQF_TRIGGER_RISING,
891 "bma180_event", data->trig);
892 if (ret) {
893 dev_err(dev, "unable to request IRQ\n");
894 goto err_trigger_free;
895 }
896
897 data->trig->dev.parent = dev;
898 data->trig->ops = &bma180_trigger_ops;
899 iio_trigger_set_drvdata(data->trig, indio_dev);
900 indio_dev->trig = iio_trigger_get(data->trig);
901
902 ret = iio_trigger_register(data->trig);
903 if (ret)
904 goto err_trigger_free;
905 }
906
907 ret = iio_triggered_buffer_setup(indio_dev, NULL,
908 bma180_trigger_handler, NULL);
909 if (ret < 0) {
910 dev_err(dev, "unable to setup iio triggered buffer\n");
911 goto err_trigger_unregister;
912 }
913
914 ret = iio_device_register(indio_dev);
915 if (ret < 0) {
916 dev_err(dev, "unable to register iio device\n");
917 goto err_buffer_cleanup;
918 }
919
920 return 0;
921
922 err_buffer_cleanup:
923 iio_triggered_buffer_cleanup(indio_dev);
924 err_trigger_unregister:
925 if (data->trig)
926 iio_trigger_unregister(data->trig);
927 err_trigger_free:
928 iio_trigger_free(data->trig);
929 err_chip_disable:
930 data->part_info->chip_disable(data);
931 regulator_disable(data->vddio_supply);
932 err_disable_vdd:
933 regulator_disable(data->vdd_supply);
934
935 return ret;
936 }
937
938 static int bma180_remove(struct i2c_client *client)
939 {
940 struct iio_dev *indio_dev = i2c_get_clientdata(client);
941 struct bma180_data *data = iio_priv(indio_dev);
942
943 iio_device_unregister(indio_dev);
944 iio_triggered_buffer_cleanup(indio_dev);
945 if (data->trig) {
946 iio_trigger_unregister(data->trig);
947 iio_trigger_free(data->trig);
948 }
949
950 mutex_lock(&data->mutex);
951 data->part_info->chip_disable(data);
952 mutex_unlock(&data->mutex);
953 regulator_disable(data->vddio_supply);
954 regulator_disable(data->vdd_supply);
955
956 return 0;
957 }
958
959 #ifdef CONFIG_PM_SLEEP
960 static int bma180_suspend(struct device *dev)
961 {
962 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
963 struct bma180_data *data = iio_priv(indio_dev);
964 int ret;
965
966 mutex_lock(&data->mutex);
967 ret = bma180_set_sleep_state(data, true);
968 mutex_unlock(&data->mutex);
969
970 return ret;
971 }
972
973 static int bma180_resume(struct device *dev)
974 {
975 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
976 struct bma180_data *data = iio_priv(indio_dev);
977 int ret;
978
979 mutex_lock(&data->mutex);
980 ret = bma180_set_sleep_state(data, false);
981 mutex_unlock(&data->mutex);
982
983 return ret;
984 }
985
986 static SIMPLE_DEV_PM_OPS(bma180_pm_ops, bma180_suspend, bma180_resume);
987 #define BMA180_PM_OPS (&bma180_pm_ops)
988 #else
989 #define BMA180_PM_OPS NULL
990 #endif
991
992 static const struct i2c_device_id bma180_ids[] = {
993 { "bma180", BMA180 },
994 { "bma250", BMA250 },
995 { "bma254", BMA254 },
996 { }
997 };
998
999 MODULE_DEVICE_TABLE(i2c, bma180_ids);
1000
1001 static const struct of_device_id bma180_of_match[] = {
1002 {
1003 .compatible = "bosch,bma180",
1004 .data = (void *)BMA180
1005 },
1006 {
1007 .compatible = "bosch,bma250",
1008 .data = (void *)BMA250
1009 },
1010 {
1011 .compatible = "bosch,bma254",
1012 .data = (void *)BMA254
1013 },
1014 { }
1015 };
1016 MODULE_DEVICE_TABLE(of, bma180_of_match);
1017
1018 static struct i2c_driver bma180_driver = {
1019 .driver = {
1020 .name = "bma180",
1021 .pm = BMA180_PM_OPS,
1022 .of_match_table = bma180_of_match,
1023 },
1024 .probe = bma180_probe,
1025 .remove = bma180_remove,
1026 .id_table = bma180_ids,
1027 };
1028
1029 module_i2c_driver(bma180_driver);
1030
1031 MODULE_AUTHOR("Kravchenko Oleksandr <x0199363@ti.com>");
1032 MODULE_AUTHOR("Texas Instruments, Inc.");
1033 MODULE_DESCRIPTION("Bosch BMA180/BMA25x triaxial acceleration sensor");
1034 MODULE_LICENSE("GPL");
Linux with added FPC-III support