drivers/iio/accel/bma180.c

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