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