blob: bfec313492b3f0de16c8aa26bfb5b77ba9160473 [file] [log] [blame]
Oleksandr Kravchenkofdadbce2013-08-28 12:01:00 +01001/*
2 * bma180.c - IIO driver for Bosch BMA180 triaxial acceleration sensor
3 *
4 * Copyright 2013 Oleksandr Kravchenko <x0199363@ti.com>
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
11#include <linux/module.h>
12#include <linux/i2c.h>
13#include <linux/interrupt.h>
14#include <linux/delay.h>
15#include <linux/of.h>
16#include <linux/bitops.h>
17#include <linux/slab.h>
18#include <linux/string.h>
19#include <linux/iio/iio.h>
20#include <linux/iio/sysfs.h>
21#include <linux/iio/buffer.h>
22#include <linux/iio/trigger.h>
23#include <linux/iio/trigger_consumer.h>
24#include <linux/iio/triggered_buffer.h>
25
26#define BMA180_DRV_NAME "bma180"
27#define BMA180_IRQ_NAME "bma180_event"
28
29/* Register set */
30#define BMA180_CHIP_ID 0x00 /* Need to distinguish BMA180 from other */
31#define BMA180_ACC_X_LSB 0x02 /* First of 6 registers of accel data */
32#define BMA180_CTRL_REG0 0x0d
33#define BMA180_RESET 0x10
34#define BMA180_BW_TCS 0x20
35#define BMA180_CTRL_REG3 0x21
36#define BMA180_TCO_Z 0x30
37#define BMA180_OFFSET_LSB1 0x35
38
39/* BMA180_CTRL_REG0 bits */
40#define BMA180_DIS_WAKE_UP BIT(0) /* Disable wake up mode */
41#define BMA180_SLEEP BIT(1) /* 1 - chip will sleep */
42#define BMA180_EE_W BIT(4) /* Unlock writing to addr from 0x20 */
43#define BMA180_RESET_INT BIT(6) /* Reset pending interrupts */
44
45/* BMA180_CTRL_REG3 bits */
46#define BMA180_NEW_DATA_INT BIT(1) /* Intr every new accel data is ready */
47
48/* BMA180_OFFSET_LSB1 skipping mode bit */
49#define BMA180_SMP_SKIP BIT(0)
50
51/* Bit masks for registers bit fields */
52#define BMA180_RANGE 0x0e /* Range of measured accel values*/
53#define BMA180_BW 0xf0 /* Accel bandwidth */
54#define BMA180_MODE_CONFIG 0x03 /* Config operation modes */
55
56/* We have to write this value in reset register to do soft reset */
57#define BMA180_RESET_VAL 0xb6
58
59#define BMA_180_ID_REG_VAL 0x03
60
61/* Chip power modes */
62#define BMA180_LOW_NOISE 0x00
63#define BMA180_LOW_POWER 0x03
64
65#define BMA180_LOW_NOISE_STR "low_noise"
66#define BMA180_LOW_POWER_STR "low_power"
67
68/* Defaults values */
69#define BMA180_DEF_PMODE 0
70#define BMA180_DEF_BW 20
71#define BMA180_DEF_SCALE 250
72
73/* Available values for sysfs */
74#define BMA180_FLP_FREQ_AVAILABLE \
75 "10 20 40 75 150 300"
76#define BMA180_SCALE_AVAILABLE \
77 "0.000130 0.000190 0.000250 0.000380 0.000500 0.000990 0.001980"
78
79struct bma180_data {
80 struct i2c_client *client;
81 struct iio_trigger *trig;
82 struct mutex mutex;
83 int sleep_state;
84 int scale;
85 int bw;
86 int pmode;
87 char *buff;
88};
89
90enum bma180_axis {
91 AXIS_X,
92 AXIS_Y,
93 AXIS_Z,
94};
95
96static int bw_table[] = { 10, 20, 40, 75, 150, 300 }; /* Hz */
97static int scale_table[] = { 130, 190, 250, 380, 500, 990, 1980 };
98
99static int bma180_get_acc_reg(struct bma180_data *data, enum bma180_axis axis)
100{
101 u8 reg = BMA180_ACC_X_LSB + axis * 2;
102 int ret;
103
104 if (data->sleep_state)
105 return -EBUSY;
106
107 ret = i2c_smbus_read_word_data(data->client, reg);
108 if (ret < 0)
109 dev_err(&data->client->dev,
110 "failed to read accel_%c registers\n", 'x' + axis);
111
112 return ret;
113}
114
115static int bma180_set_bits(struct bma180_data *data, u8 reg, u8 mask, u8 val)
116{
117 int ret = i2c_smbus_read_byte_data(data->client, reg);
118 u8 reg_val = (ret & ~mask) | (val << (ffs(mask) - 1));
119
120 if (ret < 0)
121 return ret;
122
123 return i2c_smbus_write_byte_data(data->client, reg, reg_val);
124}
125
126static int bma180_reset_intr(struct bma180_data *data)
127{
128 int ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_RESET_INT, 1);
129
130 if (ret)
131 dev_err(&data->client->dev, "failed to reset interrupt\n");
132
133 return ret;
134}
135
136static int bma180_set_new_data_intr_state(struct bma180_data *data, int state)
137{
138 u8 reg_val = state ? BMA180_NEW_DATA_INT : 0x00;
139 int ret = i2c_smbus_write_byte_data(data->client, BMA180_CTRL_REG3,
140 reg_val);
141
142 if (ret)
143 goto err;
144 ret = bma180_reset_intr(data);
145 if (ret)
146 goto err;
147
148 return 0;
149
150err:
151 dev_err(&data->client->dev,
152 "failed to set new data interrupt state %d\n", state);
153 return ret;
154}
155
156static int bma180_set_sleep_state(struct bma180_data *data, int state)
157{
158 int ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_SLEEP, state);
159
160 if (ret) {
161 dev_err(&data->client->dev,
162 "failed to set sleep state %d\n", state);
163 return ret;
164 }
165 data->sleep_state = state;
166
167 return 0;
168}
169
170static int bma180_set_ee_writing_state(struct bma180_data *data, int state)
171{
172 int ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_EE_W, state);
173
174 if (ret)
175 dev_err(&data->client->dev,
176 "failed to set ee writing state %d\n", state);
177
178 return ret;
179}
180
181static int bma180_set_bw(struct bma180_data *data, int val)
182{
183 int ret, i;
184
185 if (data->sleep_state)
186 return -EBUSY;
187
188 for (i = 0; i < ARRAY_SIZE(bw_table); ++i) {
189 if (bw_table[i] == val) {
190 ret = bma180_set_bits(data,
191 BMA180_BW_TCS, BMA180_BW, i);
192 if (ret) {
193 dev_err(&data->client->dev,
194 "failed to set bandwidth\n");
195 return ret;
196 }
197 data->bw = val;
198 return 0;
199 }
200 }
201
202 return -EINVAL;
203}
204
205static int bma180_set_scale(struct bma180_data *data, int val)
206{
207 int ret, i;
208
209 if (data->sleep_state)
210 return -EBUSY;
211
212 for (i = 0; i < ARRAY_SIZE(scale_table); ++i)
213 if (scale_table[i] == val) {
214 ret = bma180_set_bits(data,
215 BMA180_OFFSET_LSB1, BMA180_RANGE, i);
216 if (ret) {
217 dev_err(&data->client->dev,
218 "failed to set scale\n");
219 return ret;
220 }
221 data->scale = val;
222 return 0;
223 }
224
225 return -EINVAL;
226}
227
228static int bma180_set_pmode(struct bma180_data *data, int mode)
229{
230 u8 reg_val = mode ? BMA180_LOW_POWER : BMA180_LOW_NOISE;
231 int ret = bma180_set_bits(data, BMA180_TCO_Z, BMA180_MODE_CONFIG,
232 reg_val);
233
234 if (ret) {
235 dev_err(&data->client->dev, "failed to set power mode\n");
236 return ret;
237 }
238 data->pmode = mode;
239
240 return 0;
241}
242
243static int bma180_soft_reset(struct bma180_data *data)
244{
245 int ret = i2c_smbus_write_byte_data(data->client,
246 BMA180_RESET, BMA180_RESET_VAL);
247
248 if (ret)
249 dev_err(&data->client->dev, "failed to reset the chip\n");
250
251 return ret;
252}
253
254static int bma180_chip_init(struct bma180_data *data)
255{
256 /* Try to read chip_id register. It must return 0x03. */
257 int ret = i2c_smbus_read_byte_data(data->client, BMA180_CHIP_ID);
258
259 if (ret < 0)
260 goto err;
261 if (ret != BMA_180_ID_REG_VAL) {
262 ret = -ENODEV;
263 goto err;
264 }
265
266 ret = bma180_soft_reset(data);
267 if (ret)
268 goto err;
269 /*
270 * No serial transaction should occur within minimum 10 us
271 * after soft_reset command
272 */
273 msleep(20);
274
275 ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_DIS_WAKE_UP, 1);
276 if (ret)
277 goto err;
278 ret = bma180_set_ee_writing_state(data, 1);
279 if (ret)
280 goto err;
281 ret = bma180_set_new_data_intr_state(data, 0);
282 if (ret)
283 goto err;
284 ret = bma180_set_bits(data, BMA180_OFFSET_LSB1, BMA180_SMP_SKIP, 1);
285 if (ret)
286 goto err;
287 ret = bma180_set_pmode(data, BMA180_DEF_PMODE);
288 if (ret)
289 goto err;
290 ret = bma180_set_bw(data, BMA180_DEF_BW);
291 if (ret)
292 goto err;
293 ret = bma180_set_scale(data, BMA180_DEF_SCALE);
294 if (ret)
295 goto err;
296
297 return 0;
298
299err:
300 dev_err(&data->client->dev, "failed to init the chip\n");
301 return ret;
302}
303
304static void bma180_chip_disable(struct bma180_data *data)
305{
306 if (bma180_set_new_data_intr_state(data, 0))
307 goto err;
308 if (bma180_set_ee_writing_state(data, 0))
309 goto err;
310 if (bma180_set_sleep_state(data, 1))
311 goto err;
312
313 return;
314
315err:
316 dev_err(&data->client->dev, "failed to disable the chip\n");
317}
318
319static IIO_CONST_ATTR(in_accel_filter_low_pass_3db_frequency_available,
320 BMA180_FLP_FREQ_AVAILABLE);
321static IIO_CONST_ATTR(in_accel_scale_available, BMA180_SCALE_AVAILABLE);
322
323static struct attribute *bma180_attributes[] = {
324 &iio_const_attr_in_accel_filter_low_pass_3db_frequency_available.dev_attr.attr,
325 &iio_const_attr_in_accel_scale_available.dev_attr.attr,
326 NULL,
327};
328
329static const struct attribute_group bma180_attrs_group = {
330 .attrs = bma180_attributes,
331};
332
333static int bma180_read_raw(struct iio_dev *indio_dev,
334 struct iio_chan_spec const *chan, int *val, int *val2,
335 long mask)
336{
337 struct bma180_data *data = iio_priv(indio_dev);
338 int ret;
339
340 switch (mask) {
341 case IIO_CHAN_INFO_RAW:
342 mutex_lock(&data->mutex);
343 if (iio_buffer_enabled(indio_dev))
344 ret = -EBUSY;
345 else
346 ret = bma180_get_acc_reg(data, chan->scan_index);
347 mutex_unlock(&data->mutex);
348 if (ret < 0)
349 return ret;
350 *val = (s16)ret >> chan->scan_type.shift;
351 return IIO_VAL_INT;
352 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
353 *val = data->bw;
354 return IIO_VAL_INT;
355 case IIO_CHAN_INFO_SCALE:
356 *val = 0;
357 *val2 = data->scale;
358 return IIO_VAL_INT_PLUS_MICRO;
359 default:
360 return -EINVAL;
361 }
362}
363
364static int bma180_write_raw(struct iio_dev *indio_dev,
365 struct iio_chan_spec const *chan, int val, int val2, long mask)
366{
367 struct bma180_data *data = iio_priv(indio_dev);
368 int ret;
369
370 switch (mask) {
371 case IIO_CHAN_INFO_SCALE:
372 if (val)
373 return -EINVAL;
374 mutex_lock(&data->mutex);
375 ret = bma180_set_scale(data, val2);
376 mutex_unlock(&data->mutex);
377 return ret;
378 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
379 mutex_lock(&data->mutex);
380 ret = bma180_set_bw(data, val);
381 mutex_unlock(&data->mutex);
382 return ret;
383 default:
384 return -EINVAL;
385 }
386}
387
388static int bma180_update_scan_mode(struct iio_dev *indio_dev,
389 const unsigned long *scan_mask)
390{
391 struct bma180_data *data = iio_priv(indio_dev);
392
393 if (data->buff)
394 devm_kfree(&indio_dev->dev, data->buff);
395 data->buff = devm_kzalloc(&indio_dev->dev,
396 indio_dev->scan_bytes, GFP_KERNEL);
397 if (!data->buff)
398 return -ENOMEM;
399
400 return 0;
401}
402
403static const struct iio_info bma180_info = {
404 .attrs = &bma180_attrs_group,
405 .read_raw = bma180_read_raw,
406 .write_raw = bma180_write_raw,
407 .update_scan_mode = bma180_update_scan_mode,
408 .driver_module = THIS_MODULE,
409};
410
411static const char * const bma180_power_modes[] = {
412 BMA180_LOW_NOISE_STR,
413 BMA180_LOW_POWER_STR,
414};
415
416static int bma180_get_power_mode(struct iio_dev *indio_dev,
417 const struct iio_chan_spec *chan)
418{
419 struct bma180_data *data = iio_priv(indio_dev);
420
421 return data->pmode;
422}
423
424static int bma180_set_power_mode(struct iio_dev *indio_dev,
425 const struct iio_chan_spec *chan, unsigned int mode)
426{
427 struct bma180_data *data = iio_priv(indio_dev);
428 int ret;
429
430 mutex_lock(&data->mutex);
431 ret = bma180_set_pmode(data, mode);
432 mutex_unlock(&data->mutex);
433
434 return ret;
435}
436
437static const struct iio_enum bma180_power_mode_enum = {
438 .items = bma180_power_modes,
439 .num_items = ARRAY_SIZE(bma180_power_modes),
440 .get = bma180_get_power_mode,
441 .set = bma180_set_power_mode,
442};
443
444static const struct iio_chan_spec_ext_info bma180_ext_info[] = {
445 IIO_ENUM("power_mode", true, &bma180_power_mode_enum),
446 IIO_ENUM_AVAILABLE("power_mode", &bma180_power_mode_enum),
447 { },
448};
449
Peter Meerwald55852152014-10-01 21:37:00 +0100450#define BMA180_CHANNEL(_axis) { \
Oleksandr Kravchenkofdadbce2013-08-28 12:01:00 +0100451 .type = IIO_ACCEL, \
Peter Meerwald55852152014-10-01 21:37:00 +0100452 .modified = 1, \
453 .channel2 = IIO_MOD_##_axis, \
Oleksandr Kravchenkofdadbce2013-08-28 12:01:00 +0100454 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
455 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
456 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
Peter Meerwald55852152014-10-01 21:37:00 +0100457 .scan_index = AXIS_##_axis, \
Jonathan Cameron7d7feae2013-12-11 18:45:00 +0000458 .scan_type = { \
459 .sign = 's', \
460 .realbits = 14, \
461 .storagebits = 16, \
462 .shift = 2, \
463 }, \
Oleksandr Kravchenkofdadbce2013-08-28 12:01:00 +0100464 .ext_info = bma180_ext_info, \
465}
466
467static const struct iio_chan_spec bma180_channels[] = {
Peter Meerwald55852152014-10-01 21:37:00 +0100468 BMA180_CHANNEL(X),
469 BMA180_CHANNEL(Y),
470 BMA180_CHANNEL(Z),
471 IIO_CHAN_SOFT_TIMESTAMP(3),
Oleksandr Kravchenkofdadbce2013-08-28 12:01:00 +0100472};
473
474static irqreturn_t bma180_trigger_handler(int irq, void *p)
475{
476 struct iio_poll_func *pf = p;
477 struct iio_dev *indio_dev = pf->indio_dev;
478 struct bma180_data *data = iio_priv(indio_dev);
Lars-Peter Clausen6bf9d8772013-09-19 13:59:00 +0100479 int64_t time_ns = iio_get_time_ns();
Oleksandr Kravchenkofdadbce2013-08-28 12:01:00 +0100480 int bit, ret, i = 0;
481
482 mutex_lock(&data->mutex);
Oleksandr Kravchenkofdadbce2013-08-28 12:01:00 +0100483
484 for_each_set_bit(bit, indio_dev->buffer->scan_mask,
485 indio_dev->masklength) {
486 ret = bma180_get_acc_reg(data, bit);
487 if (ret < 0) {
488 mutex_unlock(&data->mutex);
489 goto err;
490 }
491 ((s16 *)data->buff)[i++] = ret;
492 }
493 mutex_unlock(&data->mutex);
494
Lars-Peter Clausen6bf9d8772013-09-19 13:59:00 +0100495 iio_push_to_buffers_with_timestamp(indio_dev, data->buff, time_ns);
Oleksandr Kravchenkofdadbce2013-08-28 12:01:00 +0100496err:
497 iio_trigger_notify_done(indio_dev->trig);
498
499 return IRQ_HANDLED;
500}
501
502static int bma180_data_rdy_trigger_set_state(struct iio_trigger *trig,
503 bool state)
504{
505 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
506 struct bma180_data *data = iio_priv(indio_dev);
507
508 return bma180_set_new_data_intr_state(data, state);
509}
510
511static int bma180_trig_try_reen(struct iio_trigger *trig)
512{
513 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
514 struct bma180_data *data = iio_priv(indio_dev);
515
516 return bma180_reset_intr(data);
517}
518
519static const struct iio_trigger_ops bma180_trigger_ops = {
520 .set_trigger_state = bma180_data_rdy_trigger_set_state,
521 .try_reenable = bma180_trig_try_reen,
522 .owner = THIS_MODULE,
523};
524
525static int bma180_probe(struct i2c_client *client,
526 const struct i2c_device_id *id)
527{
528 struct bma180_data *data;
529 struct iio_dev *indio_dev;
530 struct iio_trigger *trig;
531 int ret;
532
533 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
534 if (!indio_dev)
535 return -ENOMEM;
536
537 data = iio_priv(indio_dev);
538 i2c_set_clientdata(client, indio_dev);
539 data->client = client;
540
541 ret = bma180_chip_init(data);
542 if (ret < 0)
543 goto err_chip_disable;
544
545 mutex_init(&data->mutex);
546
547 indio_dev->dev.parent = &client->dev;
548 indio_dev->channels = bma180_channels;
549 indio_dev->num_channels = ARRAY_SIZE(bma180_channels);
550 indio_dev->name = BMA180_DRV_NAME;
551 indio_dev->modes = INDIO_DIRECT_MODE;
552 indio_dev->info = &bma180_info;
553
554 trig = iio_trigger_alloc("%s-dev%d", indio_dev->name, indio_dev->id);
555 if (!trig) {
556 ret = -ENOMEM;
557 goto err_chip_disable;
558 }
559
560 ret = devm_request_irq(&client->dev, client->irq,
561 iio_trigger_generic_data_rdy_poll,
562 IRQF_TRIGGER_RISING, BMA180_IRQ_NAME, trig);
563 if (ret) {
564 dev_err(&client->dev, "unable to request IRQ\n");
565 goto err_trigger_free;
566 }
567
568 trig->dev.parent = &client->dev;
569 trig->ops = &bma180_trigger_ops;
570 iio_trigger_set_drvdata(trig, indio_dev);
571 data->trig = trig;
572 indio_dev->trig = trig;
573
574 ret = iio_trigger_register(trig);
575 if (ret)
576 goto err_trigger_free;
577
578 ret = iio_triggered_buffer_setup(indio_dev, NULL,
579 bma180_trigger_handler, NULL);
580 if (ret < 0) {
581 dev_err(&client->dev, "unable to setup iio triggered buffer\n");
582 goto err_trigger_unregister;
583 }
584
585 ret = iio_device_register(indio_dev);
586 if (ret < 0) {
587 dev_err(&client->dev, "unable to register iio device\n");
588 goto err_buffer_cleanup;
589 }
590
591 return 0;
592
593err_buffer_cleanup:
594 iio_triggered_buffer_cleanup(indio_dev);
595err_trigger_unregister:
596 iio_trigger_unregister(trig);
597err_trigger_free:
598 iio_trigger_free(trig);
599err_chip_disable:
600 bma180_chip_disable(data);
601
602 return ret;
603}
604
605static int bma180_remove(struct i2c_client *client)
606{
607 struct iio_dev *indio_dev = i2c_get_clientdata(client);
608 struct bma180_data *data = iio_priv(indio_dev);
609
610 iio_device_unregister(indio_dev);
611 iio_triggered_buffer_cleanup(indio_dev);
612 iio_trigger_unregister(data->trig);
613 iio_trigger_free(data->trig);
614
615 mutex_lock(&data->mutex);
616 bma180_chip_disable(data);
617 mutex_unlock(&data->mutex);
618
619 return 0;
620}
621
622#ifdef CONFIG_PM_SLEEP
623static int bma180_suspend(struct device *dev)
624{
Peter Meerwald234efa12013-09-18 22:47:00 +0100625 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
Oleksandr Kravchenkofdadbce2013-08-28 12:01:00 +0100626 struct bma180_data *data = iio_priv(indio_dev);
627 int ret;
628
629 mutex_lock(&data->mutex);
630 ret = bma180_set_sleep_state(data, 1);
631 mutex_unlock(&data->mutex);
632
633 return ret;
634}
635
636static int bma180_resume(struct device *dev)
637{
Peter Meerwald234efa12013-09-18 22:47:00 +0100638 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
Oleksandr Kravchenkofdadbce2013-08-28 12:01:00 +0100639 struct bma180_data *data = iio_priv(indio_dev);
640 int ret;
641
642 mutex_lock(&data->mutex);
643 ret = bma180_set_sleep_state(data, 0);
644 mutex_unlock(&data->mutex);
645
646 return ret;
647}
648
649static SIMPLE_DEV_PM_OPS(bma180_pm_ops, bma180_suspend, bma180_resume);
650#define BMA180_PM_OPS (&bma180_pm_ops)
651#else
652#define BMA180_PM_OPS NULL
653#endif
654
655static struct i2c_device_id bma180_id[] = {
656 { BMA180_DRV_NAME, 0 },
657 { }
658};
659
660MODULE_DEVICE_TABLE(i2c, bma180_id);
661
662static struct i2c_driver bma180_driver = {
663 .driver = {
664 .name = BMA180_DRV_NAME,
665 .owner = THIS_MODULE,
666 .pm = BMA180_PM_OPS,
667 },
668 .probe = bma180_probe,
669 .remove = bma180_remove,
670 .id_table = bma180_id,
671};
672
673module_i2c_driver(bma180_driver);
674
675MODULE_AUTHOR("Kravchenko Oleksandr <x0199363@ti.com>");
676MODULE_AUTHOR("Texas Instruments, Inc.");
677MODULE_DESCRIPTION("Bosch BMA180 triaxial acceleration sensor");
678MODULE_LICENSE("GPL");