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