drivers/input/misc/bma150.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (c) 2011 Bosch Sensortec GmbH
   4  * Copyright (c) 2011 Unixphere
   5  *
   6  * This driver adds support for Bosch Sensortec's digital acceleration
   7  * sensors BMA150 and SMB380.
   8  * The SMB380 is fully compatible with BMA150 and only differs in packaging.
   9  *
  10  * The datasheet for the BMA150 chip can be found here:
  11  * http://www.bosch-sensortec.com/content/language1/downloads/BST-BMA150-DS000-07.pdf
  12  */
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/i2c.h>
  16 #include <linux/input.h>
  17 #include <linux/input-polldev.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/delay.h>
  20 #include <linux/slab.h>
  21 #include <linux/pm.h>
  22 #include <linux/pm_runtime.h>
  23 #include <linux/bma150.h>
  24
  25 #define ABSMAX_ACC_VAL          0x01FF
  26 #define ABSMIN_ACC_VAL          -(ABSMAX_ACC_VAL)
  27
  28 /* Each axis is represented by a 2-byte data word */
  29 #define BMA150_XYZ_DATA_SIZE    6
  30
  31 /* Input poll interval in milliseconds */
  32 #define BMA150_POLL_INTERVAL    10
  33 #define BMA150_POLL_MAX         200
  34 #define BMA150_POLL_MIN         0
  35
  36 #define BMA150_MODE_NORMAL      0
  37 #define BMA150_MODE_SLEEP       2
  38 #define BMA150_MODE_WAKE_UP     3
  39
  40 /* Data register addresses */
  41 #define BMA150_DATA_0_REG       0x00
  42 #define BMA150_DATA_1_REG       0x01
  43 #define BMA150_DATA_2_REG       0x02
  44
  45 /* Control register addresses */
  46 #define BMA150_CTRL_0_REG       0x0A
  47 #define BMA150_CTRL_1_REG       0x0B
  48 #define BMA150_CTRL_2_REG       0x14
  49 #define BMA150_CTRL_3_REG       0x15
  50
  51 /* Configuration/Setting register addresses */
  52 #define BMA150_CFG_0_REG        0x0C
  53 #define BMA150_CFG_1_REG        0x0D
  54 #define BMA150_CFG_2_REG        0x0E
  55 #define BMA150_CFG_3_REG        0x0F
  56 #define BMA150_CFG_4_REG        0x10
  57 #define BMA150_CFG_5_REG        0x11
  58
  59 #define BMA150_CHIP_ID          2
  60 #define BMA150_CHIP_ID_REG      BMA150_DATA_0_REG
  61
  62 #define BMA150_ACC_X_LSB_REG    BMA150_DATA_2_REG
  63
  64 #define BMA150_SLEEP_POS        0
  65 #define BMA150_SLEEP_MSK        0x01
  66 #define BMA150_SLEEP_REG        BMA150_CTRL_0_REG
  67
  68 #define BMA150_BANDWIDTH_POS    0
  69 #define BMA150_BANDWIDTH_MSK    0x07
  70 #define BMA150_BANDWIDTH_REG    BMA150_CTRL_2_REG
  71
  72 #define BMA150_RANGE_POS        3
  73 #define BMA150_RANGE_MSK        0x18
  74 #define BMA150_RANGE_REG        BMA150_CTRL_2_REG
  75
  76 #define BMA150_WAKE_UP_POS      0
  77 #define BMA150_WAKE_UP_MSK      0x01
  78 #define BMA150_WAKE_UP_REG      BMA150_CTRL_3_REG
  79
  80 #define BMA150_SW_RES_POS       1
  81 #define BMA150_SW_RES_MSK       0x02
  82 #define BMA150_SW_RES_REG       BMA150_CTRL_0_REG
  83
  84 /* Any-motion interrupt register fields */
  85 #define BMA150_ANY_MOTION_EN_POS        6
  86 #define BMA150_ANY_MOTION_EN_MSK        0x40
  87 #define BMA150_ANY_MOTION_EN_REG        BMA150_CTRL_1_REG
  88
  89 #define BMA150_ANY_MOTION_DUR_POS       6
  90 #define BMA150_ANY_MOTION_DUR_MSK       0xC0
  91 #define BMA150_ANY_MOTION_DUR_REG       BMA150_CFG_5_REG
  92
  93 #define BMA150_ANY_MOTION_THRES_REG     BMA150_CFG_4_REG
  94
  95 /* Advanced interrupt register fields */
  96 #define BMA150_ADV_INT_EN_POS           6
  97 #define BMA150_ADV_INT_EN_MSK           0x40
  98 #define BMA150_ADV_INT_EN_REG           BMA150_CTRL_3_REG
  99
 100 /* High-G interrupt register fields */
 101 #define BMA150_HIGH_G_EN_POS            1
 102 #define BMA150_HIGH_G_EN_MSK            0x02
 103 #define BMA150_HIGH_G_EN_REG            BMA150_CTRL_1_REG
 104
 105 #define BMA150_HIGH_G_HYST_POS          3
 106 #define BMA150_HIGH_G_HYST_MSK          0x38
 107 #define BMA150_HIGH_G_HYST_REG          BMA150_CFG_5_REG
 108
 109 #define BMA150_HIGH_G_DUR_REG           BMA150_CFG_3_REG
 110 #define BMA150_HIGH_G_THRES_REG         BMA150_CFG_2_REG
 111
 112 /* Low-G interrupt register fields */
 113 #define BMA150_LOW_G_EN_POS             0
 114 #define BMA150_LOW_G_EN_MSK             0x01
 115 #define BMA150_LOW_G_EN_REG             BMA150_CTRL_1_REG
 116
 117 #define BMA150_LOW_G_HYST_POS           0
 118 #define BMA150_LOW_G_HYST_MSK           0x07
 119 #define BMA150_LOW_G_HYST_REG           BMA150_CFG_5_REG
 120
 121 #define BMA150_LOW_G_DUR_REG            BMA150_CFG_1_REG
 122 #define BMA150_LOW_G_THRES_REG          BMA150_CFG_0_REG
 123
 124 struct bma150_data {
 125         struct i2c_client *client;
 126         struct input_polled_dev *input_polled;
 127         struct input_dev *input;
 128         u8 mode;
 129 };
 130
 131 /*
 132  * The settings for the given range, bandwidth and interrupt features
 133  * are stated and verified by Bosch Sensortec where they are configured
 134  * to provide a generic sensitivity performance.
 135  */
 136 static const struct bma150_cfg default_cfg = {
 137         .any_motion_int = 1,
 138         .hg_int = 1,
 139         .lg_int = 1,
 140         .any_motion_dur = 0,
 141         .any_motion_thres = 0,
 142         .hg_hyst = 0,
 143         .hg_dur = 150,
 144         .hg_thres = 160,
 145         .lg_hyst = 0,
 146         .lg_dur = 150,
 147         .lg_thres = 20,
 148         .range = BMA150_RANGE_2G,
 149         .bandwidth = BMA150_BW_50HZ
 150 };
 151
 152 static int bma150_write_byte(struct i2c_client *client, u8 reg, u8 val)
 153 {
 154         s32 ret;
 155
 156         /* As per specification, disable irq in between register writes */
 157         if (client->irq)
 158                 disable_irq_nosync(client->irq);
 159
 160         ret = i2c_smbus_write_byte_data(client, reg, val);
 161
 162         if (client->irq)
 163                 enable_irq(client->irq);
 164
 165         return ret;
 166 }
 167
 168 static int bma150_set_reg_bits(struct i2c_client *client,
 169                                         int val, int shift, u8 mask, u8 reg)
 170 {
 171         int data;
 172
 173         data = i2c_smbus_read_byte_data(client, reg);
 174         if (data < 0)
 175                 return data;
 176
 177         data = (data & ~mask) | ((val << shift) & mask);
 178         return bma150_write_byte(client, reg, data);
 179 }
 180
 181 static int bma150_set_mode(struct bma150_data *bma150, u8 mode)
 182 {
 183         int error;
 184
 185         error = bma150_set_reg_bits(bma150->client, mode, BMA150_WAKE_UP_POS,
 186                                 BMA150_WAKE_UP_MSK, BMA150_WAKE_UP_REG);
 187         if (error)
 188                 return error;
 189
 190         error = bma150_set_reg_bits(bma150->client, mode, BMA150_SLEEP_POS,
 191                                 BMA150_SLEEP_MSK, BMA150_SLEEP_REG);
 192         if (error)
 193                 return error;
 194
 195         if (mode == BMA150_MODE_NORMAL)
 196                 usleep_range(2000, 2100);
 197
 198         bma150->mode = mode;
 199         return 0;
 200 }
 201
 202 static int bma150_soft_reset(struct bma150_data *bma150)
 203 {
 204         int error;
 205
 206         error = bma150_set_reg_bits(bma150->client, 1, BMA150_SW_RES_POS,
 207                                 BMA150_SW_RES_MSK, BMA150_SW_RES_REG);
 208         if (error)
 209                 return error;
 210
 211         usleep_range(2000, 2100);
 212         return 0;
 213 }
 214
 215 static int bma150_set_range(struct bma150_data *bma150, u8 range)
 216 {
 217         return bma150_set_reg_bits(bma150->client, range, BMA150_RANGE_POS,
 218                                 BMA150_RANGE_MSK, BMA150_RANGE_REG);
 219 }
 220
 221 static int bma150_set_bandwidth(struct bma150_data *bma150, u8 bw)
 222 {
 223         return bma150_set_reg_bits(bma150->client, bw, BMA150_BANDWIDTH_POS,
 224                                 BMA150_BANDWIDTH_MSK, BMA150_BANDWIDTH_REG);
 225 }
 226
 227 static int bma150_set_low_g_interrupt(struct bma150_data *bma150,
 228                                         u8 enable, u8 hyst, u8 dur, u8 thres)
 229 {
 230         int error;
 231
 232         error = bma150_set_reg_bits(bma150->client, hyst,
 233                                 BMA150_LOW_G_HYST_POS, BMA150_LOW_G_HYST_MSK,
 234                                 BMA150_LOW_G_HYST_REG);
 235         if (error)
 236                 return error;
 237
 238         error = bma150_write_byte(bma150->client, BMA150_LOW_G_DUR_REG, dur);
 239         if (error)
 240                 return error;
 241
 242         error = bma150_write_byte(bma150->client, BMA150_LOW_G_THRES_REG, thres);
 243         if (error)
 244                 return error;
 245
 246         return bma150_set_reg_bits(bma150->client, !!enable,
 247                                 BMA150_LOW_G_EN_POS, BMA150_LOW_G_EN_MSK,
 248                                 BMA150_LOW_G_EN_REG);
 249 }
 250
 251 static int bma150_set_high_g_interrupt(struct bma150_data *bma150,
 252                                         u8 enable, u8 hyst, u8 dur, u8 thres)
 253 {
 254         int error;
 255
 256         error = bma150_set_reg_bits(bma150->client, hyst,
 257                                 BMA150_HIGH_G_HYST_POS, BMA150_HIGH_G_HYST_MSK,
 258                                 BMA150_HIGH_G_HYST_REG);
 259         if (error)
 260                 return error;
 261
 262         error = bma150_write_byte(bma150->client,
 263                                 BMA150_HIGH_G_DUR_REG, dur);
 264         if (error)
 265                 return error;
 266
 267         error = bma150_write_byte(bma150->client,
 268                                 BMA150_HIGH_G_THRES_REG, thres);
 269         if (error)
 270                 return error;
 271
 272         return bma150_set_reg_bits(bma150->client, !!enable,
 273                                 BMA150_HIGH_G_EN_POS, BMA150_HIGH_G_EN_MSK,
 274                                 BMA150_HIGH_G_EN_REG);
 275 }
 276
 277
 278 static int bma150_set_any_motion_interrupt(struct bma150_data *bma150,
 279                                                 u8 enable, u8 dur, u8 thres)
 280 {
 281         int error;
 282
 283         error = bma150_set_reg_bits(bma150->client, dur,
 284                                 BMA150_ANY_MOTION_DUR_POS,
 285                                 BMA150_ANY_MOTION_DUR_MSK,
 286                                 BMA150_ANY_MOTION_DUR_REG);
 287         if (error)
 288                 return error;
 289
 290         error = bma150_write_byte(bma150->client,
 291                                 BMA150_ANY_MOTION_THRES_REG, thres);
 292         if (error)
 293                 return error;
 294
 295         error = bma150_set_reg_bits(bma150->client, !!enable,
 296                                 BMA150_ADV_INT_EN_POS, BMA150_ADV_INT_EN_MSK,
 297                                 BMA150_ADV_INT_EN_REG);
 298         if (error)
 299                 return error;
 300
 301         return bma150_set_reg_bits(bma150->client, !!enable,
 302                                 BMA150_ANY_MOTION_EN_POS,
 303                                 BMA150_ANY_MOTION_EN_MSK,
 304                                 BMA150_ANY_MOTION_EN_REG);
 305 }
 306
 307 static void bma150_report_xyz(struct bma150_data *bma150)
 308 {
 309         u8 data[BMA150_XYZ_DATA_SIZE];
 310         s16 x, y, z;
 311         s32 ret;
 312
 313         ret = i2c_smbus_read_i2c_block_data(bma150->client,
 314                         BMA150_ACC_X_LSB_REG, BMA150_XYZ_DATA_SIZE, data);
 315         if (ret != BMA150_XYZ_DATA_SIZE)
 316                 return;
 317
 318         x = ((0xc0 & data[0]) >> 6) | (data[1] << 2);
 319         y = ((0xc0 & data[2]) >> 6) | (data[3] << 2);
 320         z = ((0xc0 & data[4]) >> 6) | (data[5] << 2);
 321
 322         x = sign_extend32(x, 9);
 323         y = sign_extend32(y, 9);
 324         z = sign_extend32(z, 9);
 325
 326         input_report_abs(bma150->input, ABS_X, x);
 327         input_report_abs(bma150->input, ABS_Y, y);
 328         input_report_abs(bma150->input, ABS_Z, z);
 329         input_sync(bma150->input);
 330 }
 331
 332 static irqreturn_t bma150_irq_thread(int irq, void *dev)
 333 {
 334         bma150_report_xyz(dev);
 335
 336         return IRQ_HANDLED;
 337 }
 338
 339 static void bma150_poll(struct input_polled_dev *dev)
 340 {
 341         bma150_report_xyz(dev->private);
 342 }
 343
 344 static int bma150_open(struct bma150_data *bma150)
 345 {
 346         int error;
 347
 348         error = pm_runtime_get_sync(&bma150->client->dev);
 349         if (error < 0 && error != -ENOSYS)
 350                 return error;
 351
 352         /*
 353          * See if runtime PM woke up the device. If runtime PM
 354          * is disabled we need to do it ourselves.
 355          */
 356         if (bma150->mode != BMA150_MODE_NORMAL) {
 357                 error = bma150_set_mode(bma150, BMA150_MODE_NORMAL);
 358                 if (error)
 359                         return error;
 360         }
 361
 362         return 0;
 363 }
 364
 365 static void bma150_close(struct bma150_data *bma150)
 366 {
 367         pm_runtime_put_sync(&bma150->client->dev);
 368
 369         if (bma150->mode != BMA150_MODE_SLEEP)
 370                 bma150_set_mode(bma150, BMA150_MODE_SLEEP);
 371 }
 372
 373 static int bma150_irq_open(struct input_dev *input)
 374 {
 375         struct bma150_data *bma150 = input_get_drvdata(input);
 376
 377         return bma150_open(bma150);
 378 }
 379
 380 static void bma150_irq_close(struct input_dev *input)
 381 {
 382         struct bma150_data *bma150 = input_get_drvdata(input);
 383
 384         bma150_close(bma150);
 385 }
 386
 387 static void bma150_poll_open(struct input_polled_dev *ipoll_dev)
 388 {
 389         struct bma150_data *bma150 = ipoll_dev->private;
 390
 391         bma150_open(bma150);
 392 }
 393
 394 static void bma150_poll_close(struct input_polled_dev *ipoll_dev)
 395 {
 396         struct bma150_data *bma150 = ipoll_dev->private;
 397
 398         bma150_close(bma150);
 399 }
 400
 401 static int bma150_initialize(struct bma150_data *bma150,
 402                                        const struct bma150_cfg *cfg)
 403 {
 404         int error;
 405
 406         error = bma150_soft_reset(bma150);
 407         if (error)
 408                 return error;
 409
 410         error = bma150_set_bandwidth(bma150, cfg->bandwidth);
 411         if (error)
 412                 return error;
 413
 414         error = bma150_set_range(bma150, cfg->range);
 415         if (error)
 416                 return error;
 417
 418         if (bma150->client->irq) {
 419                 error = bma150_set_any_motion_interrupt(bma150,
 420                                         cfg->any_motion_int,
 421                                         cfg->any_motion_dur,
 422                                         cfg->any_motion_thres);
 423                 if (error)
 424                         return error;
 425
 426                 error = bma150_set_high_g_interrupt(bma150,
 427                                         cfg->hg_int, cfg->hg_hyst,
 428                                         cfg->hg_dur, cfg->hg_thres);
 429                 if (error)
 430                         return error;
 431
 432                 error = bma150_set_low_g_interrupt(bma150,
 433                                         cfg->lg_int, cfg->lg_hyst,
 434                                         cfg->lg_dur, cfg->lg_thres);
 435                 if (error)
 436                         return error;
 437         }
 438
 439         return bma150_set_mode(bma150, BMA150_MODE_SLEEP);
 440 }
 441
 442 static void bma150_init_input_device(struct bma150_data *bma150,
 443                                                 struct input_dev *idev)
 444 {
 445         idev->name = BMA150_DRIVER;
 446         idev->phys = BMA150_DRIVER "/input0";
 447         idev->id.bustype = BUS_I2C;
 448         idev->dev.parent = &bma150->client->dev;
 449
 450         idev->evbit[0] = BIT_MASK(EV_ABS);
 451         input_set_abs_params(idev, ABS_X, ABSMIN_ACC_VAL, ABSMAX_ACC_VAL, 0, 0);
 452         input_set_abs_params(idev, ABS_Y, ABSMIN_ACC_VAL, ABSMAX_ACC_VAL, 0, 0);
 453         input_set_abs_params(idev, ABS_Z, ABSMIN_ACC_VAL, ABSMAX_ACC_VAL, 0, 0);
 454 }
 455
 456 static int bma150_register_input_device(struct bma150_data *bma150)
 457 {
 458         struct input_dev *idev;
 459         int error;
 460
 461         idev = input_allocate_device();
 462         if (!idev)
 463                 return -ENOMEM;
 464
 465         bma150_init_input_device(bma150, idev);
 466
 467         idev->open = bma150_irq_open;
 468         idev->close = bma150_irq_close;
 469         input_set_drvdata(idev, bma150);
 470
 471         bma150->input = idev;
 472
 473         error = input_register_device(idev);
 474         if (error) {
 475                 input_free_device(idev);
 476                 return error;
 477         }
 478
 479         return 0;
 480 }
 481
 482 static int bma150_register_polled_device(struct bma150_data *bma150)
 483 {
 484         struct input_polled_dev *ipoll_dev;
 485         int error;
 486
 487         ipoll_dev = input_allocate_polled_device();
 488         if (!ipoll_dev)
 489                 return -ENOMEM;
 490
 491         ipoll_dev->private = bma150;
 492         ipoll_dev->open = bma150_poll_open;
 493         ipoll_dev->close = bma150_poll_close;
 494         ipoll_dev->poll = bma150_poll;
 495         ipoll_dev->poll_interval = BMA150_POLL_INTERVAL;
 496         ipoll_dev->poll_interval_min = BMA150_POLL_MIN;
 497         ipoll_dev->poll_interval_max = BMA150_POLL_MAX;
 498
 499         bma150_init_input_device(bma150, ipoll_dev->input);
 500
 501         bma150->input_polled = ipoll_dev;
 502         bma150->input = ipoll_dev->input;
 503
 504         error = input_register_polled_device(ipoll_dev);
 505         if (error) {
 506                 input_free_polled_device(ipoll_dev);
 507                 return error;
 508         }
 509
 510         return 0;
 511 }
 512
 513 static int bma150_probe(struct i2c_client *client,
 514                                   const struct i2c_device_id *id)
 515 {
 516         const struct bma150_platform_data *pdata =
 517                         dev_get_platdata(&client->dev);
 518         const struct bma150_cfg *cfg;
 519         struct bma150_data *bma150;
 520         int chip_id;
 521         int error;
 522
 523         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 524                 dev_err(&client->dev, "i2c_check_functionality error\n");
 525                 return -EIO;
 526         }
 527
 528         chip_id = i2c_smbus_read_byte_data(client, BMA150_CHIP_ID_REG);
 529         if (chip_id != BMA150_CHIP_ID) {
 530                 dev_err(&client->dev, "BMA150 chip id error: %d\n", chip_id);
 531                 return -EINVAL;
 532         }
 533
 534         bma150 = kzalloc(sizeof(struct bma150_data), GFP_KERNEL);
 535         if (!bma150)
 536                 return -ENOMEM;
 537
 538         bma150->client = client;
 539
 540         if (pdata) {
 541                 if (pdata->irq_gpio_cfg) {
 542                         error = pdata->irq_gpio_cfg();
 543                         if (error) {
 544                                 dev_err(&client->dev,
 545                                         "IRQ GPIO conf. error %d, error %d\n",
 546                                         client->irq, error);
 547                                 goto err_free_mem;
 548                         }
 549                 }
 550                 cfg = &pdata->cfg;
 551         } else {
 552                 cfg = &default_cfg;
 553         }
 554
 555         error = bma150_initialize(bma150, cfg);
 556         if (error)
 557                 goto err_free_mem;
 558
 559         if (client->irq > 0) {
 560                 error = bma150_register_input_device(bma150);
 561                 if (error)
 562                         goto err_free_mem;
 563
 564                 error = request_threaded_irq(client->irq,
 565                                         NULL, bma150_irq_thread,
 566                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 567                                         BMA150_DRIVER, bma150);
 568                 if (error) {
 569                         dev_err(&client->dev,
 570                                 "irq request failed %d, error %d\n",
 571                                 client->irq, error);
 572                         input_unregister_device(bma150->input);
 573                         goto err_free_mem;
 574                 }
 575         } else {
 576                 error = bma150_register_polled_device(bma150);
 577                 if (error)
 578                         goto err_free_mem;
 579         }
 580
 581         i2c_set_clientdata(client, bma150);
 582
 583         pm_runtime_enable(&client->dev);
 584
 585         return 0;
 586
 587 err_free_mem:
 588         kfree(bma150);
 589         return error;
 590 }
 591
 592 static int bma150_remove(struct i2c_client *client)
 593 {
 594         struct bma150_data *bma150 = i2c_get_clientdata(client);
 595
 596         pm_runtime_disable(&client->dev);
 597
 598         if (client->irq > 0) {
 599                 free_irq(client->irq, bma150);
 600                 input_unregister_device(bma150->input);
 601         } else {
 602                 input_unregister_polled_device(bma150->input_polled);
 603                 input_free_polled_device(bma150->input_polled);
 604         }
 605
 606         kfree(bma150);
 607
 608         return 0;
 609 }
 610
 611 #ifdef CONFIG_PM
 612 static int bma150_suspend(struct device *dev)
 613 {
 614         struct i2c_client *client = to_i2c_client(dev);
 615         struct bma150_data *bma150 = i2c_get_clientdata(client);
 616
 617         return bma150_set_mode(bma150, BMA150_MODE_SLEEP);
 618 }
 619
 620 static int bma150_resume(struct device *dev)
 621 {
 622         struct i2c_client *client = to_i2c_client(dev);
 623         struct bma150_data *bma150 = i2c_get_clientdata(client);
 624
 625         return bma150_set_mode(bma150, BMA150_MODE_NORMAL);
 626 }
 627 #endif
 628
 629 static UNIVERSAL_DEV_PM_OPS(bma150_pm, bma150_suspend, bma150_resume, NULL);
 630
 631 static const struct i2c_device_id bma150_id[] = {
 632         { "bma150", 0 },
 633         { "smb380", 0 },
 634         { "bma023", 0 },
 635         { }
 636 };
 637
 638 MODULE_DEVICE_TABLE(i2c, bma150_id);
 639
 640 static struct i2c_driver bma150_driver = {
 641         .driver = {
 642                 .name   = BMA150_DRIVER,
 643                 .pm     = &bma150_pm,
 644         },
 645         .class          = I2C_CLASS_HWMON,
 646         .id_table       = bma150_id,
 647         .probe          = bma150_probe,
 648         .remove         = bma150_remove,
 649 };
 650
 651 module_i2c_driver(bma150_driver);
 652
 653 MODULE_AUTHOR("Albert Zhang <xu.zhang@bosch-sensortec.com>");
 654 MODULE_DESCRIPTION("BMA150 driver");
 655 MODULE_LICENSE("GPL");