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