drivers/iio/accel/bma180.c

   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");