drivers/input/gsensor/lis3dh_acc_misc.c

   1 /******************** (C) COPYRIGHT 2010 STMicroelectronics ********************
   2  *
   3  * File Name          : lis3dh_acc.c
   4  * Authors            : MSH - Motion Mems BU - Application Team
   5  *                    : Carmine Iascone (carmine.iascone@st.com)
   6  *                    : Matteo Dameno (matteo.dameno@st.com)
   7  * Version            : V.1.0.5
   8  * Date               : 16/08/2010
   9  * Description        : LIS3DH accelerometer sensor API
  10  *
  11  *******************************************************************************
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License version 2 as
  15  * published by the Free Software Foundation.
  16  *
  17  * THE PRESENT SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES
  18  * OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, FOR THE SOLE
  19  * PURPOSE TO SUPPORT YOUR APPLICATION DEVELOPMENT.
  20  * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
  21  * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
  22  * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
  23  * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  24  *
  25  * THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
  26  *
  27  ******************************************************************************
  28  Revision 1.0.0 05/11/09
  29  First Release
  30  Revision 1.0.3 22/01/2010
  31   Linux K&R Compliant Release;
  32  Revision 1.0.5 16/08/2010
  33  modified _get_acceleration_data function
  34  modified _update_odr function
  35  manages 2 interrupts
  36
  37  ******************************************************************************/
  38
  39 #include        <linux/err.h>
  40 #include        <linux/errno.h>
  41 #include        <linux/delay.h>
  42 #include        <linux/fs.h>
  43 #include        <linux/i2c.h>
  44
  45 #include        <linux/input.h>
  46 #include        <linux/input-polldev.h>
  47 #include        <linux/miscdevice.h>
  48 #include        <linux/uaccess.h>
  49
  50 #include        <linux/workqueue.h>
  51 #include        <linux/irq.h>
  52 #include        <linux/gpio.h>
  53 #include        <linux/interrupt.h>
  54
  55 //#include      <linux/i2c/lis3dh.h>
  56 #include "lis3dh_acc_misc.h"
  57
  58
  59 #define DEBUG   1
  60
  61 #define INTERRUPT_MANAGEMENT 1
  62
  63 #define G_MAX           16000   /** Maximum polled-device-reported g value */
  64
  65 /*
  66 #define SHIFT_ADJ_2G            4
  67 #define SHIFT_ADJ_4G            3
  68 #define SHIFT_ADJ_8G            2
  69 #define SHIFT_ADJ_16G           1
  70 */
  71
  72 #define SENSITIVITY_2G          1       /**     mg/LSB  */
  73 #define SENSITIVITY_4G          2       /**     mg/LSB  */
  74 #define SENSITIVITY_8G          4       /**     mg/LSB  */
  75 #define SENSITIVITY_16G         12      /**     mg/LSB  */
  76
  77
  78 #define HIGH_RESOLUTION         0x08
  79
  80 #define AXISDATA_REG            0x28
  81 #define WHOAMI_LIS3DH_ACC       0x33    /*      Expctd content for WAI  */
  82
  83 /*      CONTROL REGISTERS       */
  84 #define WHO_AM_I                0x0F    /*      WhoAmI register         */
  85 #define TEMP_CFG_REG            0x1F    /*      temper sens control reg */
  86 /* ctrl 1: ODR3 ODR2 ODR ODR0 LPen Zenable Yenable Zenable */
  87 #define CTRL_REG1               0x20    /*      control reg 1           */
  88 #define CTRL_REG2               0x21    /*      control reg 2           */
  89 #define CTRL_REG3               0x22    /*      control reg 3           */
  90 #define CTRL_REG4               0x23    /*      control reg 4           */
  91 #define CTRL_REG5               0x24    /*      control reg 5           */
  92 #define CTRL_REG6               0x25    /*      control reg 6           */
  93
  94 #define FIFO_CTRL_REG           0x2E    /*      FiFo control reg        */
  95
  96 #define INT_CFG1                0x30    /*      interrupt 1 config      */
  97 #define INT_SRC1                0x31    /*      interrupt 1 source      */
  98 #define INT_THS1                0x32    /*      interrupt 1 threshold   */
  99 #define INT_DUR1                0x33    /*      interrupt 1 duration    */
 100
 101 #define INT_CFG2                0x34    /*      interrupt 2 config      */
 102 #define INT_SRC2                0x35    /*      interrupt 2 source      */
 103 #define INT_THS2                0x36    /*      interrupt 2 threshold   */
 104 #define INT_DUR2                0x37    /*      interrupt 2 duration    */
 105
 106 #define TT_CFG                  0x38    /*      tap config              */
 107 #define TT_SRC                  0x39    /*      tap source              */
 108 #define TT_THS                  0x3A    /*      tap threshold           */
 109 #define TT_LIM                  0x3B    /*      tap time limit          */
 110 #define TT_TLAT                 0x3C    /*      tap time latency        */
 111 #define TT_TW                   0x3D    /*      tap time window         */
 112 /*      end CONTROL REGISTRES   */
 113
 114
 115 #define ENABLE_HIGH_RESOLUTION  1
 116
 117 #define LIS3DH_ACC_PM_OFF               0x00
 118 #define LIS3DH_ACC_ENABLE_ALL_AXES      0x07
 119
 120 #define PMODE_MASK                      0x08
 121 #define ODR_MASK                        0XF0
 122
 123 #define ODR1            0x10  /* 1Hz output data rate */
 124 #define ODR10           0x20  /* 10Hz output data rate */
 125 #define ODR25           0x30  /* 25Hz output data rate */
 126 #define ODR50           0x40  /* 50Hz output data rate */
 127 #define ODR100          0x50  /* 100Hz output data rate */
 128 #define ODR200          0x60  /* 200Hz output data rate */
 129 #define ODR400          0x70  /* 400Hz output data rate */
 130 #define ODR1250         0x90  /* 1250Hz output data rate */
 131
 132
 133
 134 #define IA                      0x40
 135 #define ZH                      0x20
 136 #define ZL                      0x10
 137 #define YH                      0x08
 138 #define YL                      0x04
 139 #define XH                      0x02
 140 #define XL                      0x01
 141 /* */
 142 /* CTRL REG BITS*/
 143 #define CTRL_REG3_I1_AOI1       0x40
 144 #define CTRL_REG6_I2_TAPEN      0x80
 145 #define CTRL_REG6_HLACTIVE      0x02
 146 /* */
 147
 148 /* TAP_SOURCE_REG BIT */
 149 #define DTAP                    0x20
 150 #define STAP                    0x10
 151 #define SIGNTAP                 0x08
 152 #define ZTAP                    0x04
 153 #define YTAP                    0x02
 154 #define XTAZ                    0x01
 155
 156
 157 #define FUZZ                    32
 158 #define FLAT                    32
 159 #define I2C_RETRY_DELAY         5
 160 #define I2C_RETRIES             5
 161 #define I2C_AUTO_INCREMENT      0x80
 162
 163 /* RESUME STATE INDICES */
 164 #define RES_CTRL_REG1           0
 165 #define RES_CTRL_REG2           1
 166 #define RES_CTRL_REG3           2
 167 #define RES_CTRL_REG4           3
 168 #define RES_CTRL_REG5           4
 169 #define RES_CTRL_REG6           5
 170
 171 #define RES_INT_CFG1            6
 172 #define RES_INT_THS1            7
 173 #define RES_INT_DUR1            8
 174 #define RES_INT_CFG2            9
 175 #define RES_INT_THS2            10
 176 #define RES_INT_DUR2            11
 177
 178 #define RES_TT_CFG              12
 179 #define RES_TT_THS              13
 180 #define RES_TT_LIM              14
 181 #define RES_TT_TLAT             15
 182 #define RES_TT_TW               16
 183
 184 #define RES_TEMP_CFG_REG        17
 185 #define RES_REFERENCE_REG       18
 186 #define RES_FIFO_CTRL_REG       19
 187
 188 #define RESUME_ENTRIES          20
 189 /* end RESUME STATE INDICES */
 190
 191 struct {
 192         unsigned int cutoff_ms;
 193         unsigned int mask;
 194 } lis3dh_acc_odr_table[] = {
 195                         { 1, ODR1250 },
 196                         { 3, ODR400 },
 197                         { 5, ODR200 },
 198                         { 10, ODR100 },
 199                         { 20, ODR50 },
 200                         { 40, ODR25 },
 201                         { 100, ODR10 },
 202                         { 1000, ODR1 },
 203 };
 204
 205 struct lis3dh_acc_data {
 206         struct i2c_client *client;
 207         struct lis3dh_acc_platform_data *pdata;
 208
 209         struct mutex lock;
 210         struct delayed_work input_work;
 211
 212         struct input_dev *input_dev;
 213
 214         int hw_initialized;
 215         /* hw_working=-1 means not tested yet */
 216         int hw_working;
 217         atomic_t enabled;
 218         int on_before_suspend;
 219
 220         u8 sensitivity;
 221
 222         u8 resume_state[RESUME_ENTRIES];
 223
 224         int irq1;
 225         struct work_struct irq1_work;
 226         struct workqueue_struct *irq1_work_queue;
 227         int irq2;
 228         struct work_struct irq2_work;
 229         struct workqueue_struct *irq2_work_queue;
 230 };
 231
 232 /*
 233  * Because misc devices can not carry a pointer from driver register to
 234  * open, we keep this global.  This limits the driver to a single instance.
 235  */
 236 struct lis3dh_acc_data *lis3dh_acc_misc_data;
 237
 238 static int lis3dh_acc_i2c_read(struct lis3dh_acc_data *acc, u8 * buf, int len)
 239 {
 240         int err;
 241         int tries = 0;
 242
 243         struct i2c_msg  msgs[] = {
 244                 {
 245                         .addr = acc->client->addr,
 246                         .flags = acc->client->flags & I2C_M_TEN,
 247                         .len = 1,
 248                         .buf = buf, },
 249                 {
 250                         .addr = acc->client->addr,
 251                         .flags = (acc->client->flags & I2C_M_TEN) | I2C_M_RD,
 252                         .len = len,
 253                         .buf = buf, },
 254         };
 255
 256         do {
 257                 err = i2c_transfer(acc->client->adapter, msgs, 2);
 258                 if (err != 2)
 259                         msleep_interruptible(I2C_RETRY_DELAY);
 260         } while ((err != 2) && (++tries < I2C_RETRIES));
 261
 262         if (err != 2) {
 263                 dev_err(&acc->client->dev, "read transfer error\n");
 264                 err = -EIO;
 265         } else {
 266                 err = 0;
 267         }
 268
 269         return err;
 270 }
 271
 272 static int lis3dh_acc_i2c_write(struct lis3dh_acc_data *acc, u8 * buf, int len)
 273 {
 274         int err;
 275         int tries = 0;
 276
 277         struct i2c_msg msgs[] = { { .addr = acc->client->addr,
 278                         .flags = acc->client->flags & I2C_M_TEN,
 279                         .len = len + 1, .buf = buf, }, };
 280         do {
 281                 err = i2c_transfer(acc->client->adapter, msgs, 1);
 282                 if (err != 1)
 283                         msleep_interruptible(I2C_RETRY_DELAY);
 284         } while ((err != 1) && (++tries < I2C_RETRIES));
 285
 286         if (err != 1) {
 287                 dev_err(&acc->client->dev, "write transfer error\n");
 288                 err = -EIO;
 289         } else {
 290                 err = 0;
 291         }
 292
 293         return err;
 294 }
 295
 296 static int lis3dh_acc_hw_init(struct lis3dh_acc_data *acc)
 297 {
 298         int err = -1;
 299         u8 buf[7];
 300
 301         printk(KERN_INFO "%s: hw init start\n", LIS3DH_ACC_DEV_NAME);
 302
 303         buf[0] = WHO_AM_I;
 304         err = lis3dh_acc_i2c_read(acc, buf, 1);
 305         if (err < 0)
 306                 goto error_firstread;
 307         else
 308                 acc->hw_working = 1;
 309         if (buf[0] != WHOAMI_LIS3DH_ACC) {
 310                 err = -1; /* choose the right coded error */
 311                 goto error_unknown_device;
 312         }
 313
 314         buf[0] = CTRL_REG1;
 315         buf[1] = acc->resume_state[RES_CTRL_REG1];
 316         err = lis3dh_acc_i2c_write(acc, buf, 1);
 317         if (err < 0)
 318                 goto error1;
 319
 320         buf[0] = TEMP_CFG_REG;
 321         buf[1] = acc->resume_state[RES_TEMP_CFG_REG];
 322         err = lis3dh_acc_i2c_write(acc, buf, 1);
 323         if (err < 0)
 324                 goto error1;
 325
 326         buf[0] = FIFO_CTRL_REG;
 327         buf[1] = acc->resume_state[RES_FIFO_CTRL_REG];
 328         err = lis3dh_acc_i2c_write(acc, buf, 1);
 329         if (err < 0)
 330                 goto error1;
 331
 332         buf[0] = (I2C_AUTO_INCREMENT | TT_THS);
 333         buf[1] = acc->resume_state[RES_TT_THS];
 334         buf[2] = acc->resume_state[RES_TT_LIM];
 335         buf[3] = acc->resume_state[RES_TT_TLAT];
 336         buf[4] = acc->resume_state[RES_TT_TW];
 337         err = lis3dh_acc_i2c_write(acc, buf, 4);
 338         if (err < 0)
 339                 goto error1;
 340         buf[0] = TT_CFG;
 341         buf[1] = acc->resume_state[RES_TT_CFG];
 342         err = lis3dh_acc_i2c_write(acc, buf, 1);
 343         if (err < 0)
 344                 goto error1;
 345
 346         buf[0] = (I2C_AUTO_INCREMENT | INT_THS1);
 347         buf[1] = acc->resume_state[RES_INT_THS1];
 348         buf[2] = acc->resume_state[RES_INT_DUR1];
 349         err = lis3dh_acc_i2c_write(acc, buf, 2);
 350         if (err < 0)
 351                 goto error1;
 352         buf[0] = INT_CFG1;
 353         buf[1] = acc->resume_state[RES_INT_CFG1];
 354         err = lis3dh_acc_i2c_write(acc, buf, 1);
 355         if (err < 0)
 356                 goto error1;
 357
 358         buf[0] = (I2C_AUTO_INCREMENT | INT_THS2);
 359         buf[1] = acc->resume_state[RES_INT_THS2];
 360         buf[2] = acc->resume_state[RES_INT_DUR2];
 361         err = lis3dh_acc_i2c_write(acc, buf, 2);
 362         if (err < 0)
 363                 goto error1;
 364         buf[0] = INT_CFG2;
 365         buf[1] = acc->resume_state[RES_INT_CFG2];
 366         err = lis3dh_acc_i2c_write(acc, buf, 1);
 367         if (err < 0)
 368                 goto error1;
 369
 370         buf[0] = (I2C_AUTO_INCREMENT | CTRL_REG2);
 371         buf[1] = acc->resume_state[RES_CTRL_REG2];
 372         buf[2] = acc->resume_state[RES_CTRL_REG3];
 373         buf[3] = acc->resume_state[RES_CTRL_REG4];
 374         buf[4] = acc->resume_state[RES_CTRL_REG5];
 375         buf[5] = acc->resume_state[RES_CTRL_REG6];
 376         err = lis3dh_acc_i2c_write(acc, buf, 5);
 377         if (err < 0)
 378                 goto error1;
 379
 380         acc->hw_initialized = 1;
 381         printk(KERN_INFO "%s: hw init done\n", LIS3DH_ACC_DEV_NAME);
 382         return 0;
 383
 384 error_firstread:
 385         acc->hw_working = 0;
 386         dev_warn(&acc->client->dev, "Error reading WHO_AM_I: is device "
 387                 "available/working?\n");
 388         goto error1;
 389 error_unknown_device:
 390         dev_err(&acc->client->dev,
 391                 "device unknown. Expected: 0x%x,"
 392                 " Replies: 0x%x\n", WHOAMI_LIS3DH_ACC, buf[0]);
 393 error1:
 394         acc->hw_initialized = 0;
 395         dev_err(&acc->client->dev, "hw init error 0x%x,0x%x: %d\n", buf[0],
 396                         buf[1], err);
 397         return err;
 398 }
 399
 400 static void lis3dh_acc_device_power_off(struct lis3dh_acc_data *acc)
 401 {
 402         int err;
 403         u8 buf[2] = { CTRL_REG1, LIS3DH_ACC_PM_OFF };
 404
 405         err = lis3dh_acc_i2c_write(acc, buf, 1);
 406         if (err < 0)
 407                 dev_err(&acc->client->dev, "soft power off failed: %d\n", err);
 408
 409         if (acc->pdata->power_off) {
 410                 disable_irq_nosync(acc->irq1);
 411                 disable_irq_nosync(acc->irq2);
 412                 acc->pdata->power_off();
 413                 acc->hw_initialized = 0;
 414         }
 415         if (acc->hw_initialized) {
 416                 disable_irq_nosync(acc->irq1);
 417                 disable_irq_nosync(acc->irq2);
 418                 acc->hw_initialized = 0;
 419         }
 420
 421 }
 422
 423 static int lis3dh_acc_device_power_on(struct lis3dh_acc_data *acc)
 424 {
 425         int err = -1;
 426
 427         if (acc->pdata->power_on) {
 428                 err = acc->pdata->power_on();
 429                 if (err < 0) {
 430                         dev_err(&acc->client->dev,
 431                                         "power_on failed: %d\n", err);
 432                         return err;
 433                 }
 434                 enable_irq(acc->irq1);
 435                 enable_irq(acc->irq2);
 436         }
 437
 438         if (!acc->hw_initialized) {
 439                 err = lis3dh_acc_hw_init(acc);
 440                 if (acc->hw_working == 1 && err < 0) {
 441                         lis3dh_acc_device_power_off(acc);
 442                         return err;
 443                 }
 444         }
 445
 446         if (acc->hw_initialized) {
 447                 enable_irq(acc->irq1);
 448                 enable_irq(acc->irq2);
 449                 printk(KERN_INFO "%s: power on: irq enabled\n",
 450                                                 LIS3DH_ACC_DEV_NAME);
 451         }
 452         return 0;
 453 }
 454
 455 static irqreturn_t lis3dh_acc_isr1(int irq, void *dev)
 456 {
 457         struct lis3dh_acc_data *acc = dev;
 458
 459         disable_irq_nosync(irq);
 460         queue_work(acc->irq1_work_queue, &acc->irq1_work);
 461         printk(KERN_INFO "%s: isr1 queued\n", LIS3DH_ACC_DEV_NAME);
 462
 463         return IRQ_HANDLED;
 464 }
 465
 466 static irqreturn_t lis3dh_acc_isr2(int irq, void *dev)
 467 {
 468         struct lis3dh_acc_data *acc = dev;
 469
 470         disable_irq_nosync(irq);
 471         queue_work(acc->irq2_work_queue, &acc->irq2_work);
 472         printk(KERN_INFO "%s: isr2 queued\n", LIS3DH_ACC_DEV_NAME);
 473
 474         return IRQ_HANDLED;
 475 }
 476
 477
 478
 479 static void lis3dh_acc_irq1_work_func(struct work_struct *work)
 480 {
 481
 482         struct lis3dh_acc_data *acc =
 483         container_of(work, struct lis3dh_acc_data, irq1_work);
 484         /* TODO  add interrupt service procedure.
 485                  ie:lis3dh_acc_get_int1_source(acc); */
 486         ;
 487         /*  */
 488         printk(KERN_INFO "%s: IRQ1 triggered\n", LIS3DH_ACC_DEV_NAME);
 489 exit:
 490         enable_irq(acc->irq1);
 491 }
 492
 493 static void lis3dh_acc_irq2_work_func(struct work_struct *work)
 494 {
 495
 496         struct lis3dh_acc_data *acc =
 497         container_of(work, struct lis3dh_acc_data, irq2_work);
 498         /* TODO  add interrupt service procedure.
 499                  ie:lis3dh_acc_get_tap_source(acc); */
 500         ;
 501         /*  */
 502
 503         printk(KERN_INFO "%s: IRQ2 triggered\n", LIS3DH_ACC_DEV_NAME);
 504 exit:
 505         enable_irq(acc->irq2);
 506 }
 507
 508 int lis3dh_acc_update_g_range(struct lis3dh_acc_data *acc, u8 new_g_range)
 509 {
 510         int err;
 511
 512         u8 sensitivity;
 513         u8 buf[2];
 514         u8 updated_val;
 515         u8 init_val;
 516         u8 new_val;
 517         u8 mask = LIS3DH_ACC_FS_MASK | HIGH_RESOLUTION;
 518
 519         switch (new_g_range) {
 520         case LIS3DH_ACC_G_2G:
 521
 522                 sensitivity = SENSITIVITY_2G;
 523                 break;
 524         case LIS3DH_ACC_G_4G:
 525
 526                 sensitivity = SENSITIVITY_4G;
 527                 break;
 528         case LIS3DH_ACC_G_8G:
 529
 530                 sensitivity = SENSITIVITY_8G;
 531                 break;
 532         case LIS3DH_ACC_G_16G:
 533
 534                 sensitivity = SENSITIVITY_16G;
 535                 break;
 536         default:
 537                 dev_err(&acc->client->dev, "invalid g range requested: %u\n",
 538                                 new_g_range);
 539                 return -EINVAL;
 540         }
 541
 542         if (atomic_read(&acc->enabled)) {
 543                 /* Set configuration register 4, which contains g range setting
 544                  *  NOTE: this is a straight overwrite because this driver does
 545                  *  not use any of the other configuration bits in this
 546                  *  register.  Should this become untrue, we will have to read
 547                  *  out the value and only change the relevant bits --XX----
 548                  *  (marked by X) */
 549                 buf[0] = CTRL_REG4;
 550                 err = lis3dh_acc_i2c_read(acc, buf, 1);
 551                 if (err < 0)
 552                         goto error;
 553                 init_val = buf[0];
 554                 acc->resume_state[RES_CTRL_REG4] = init_val;
 555                 new_val = new_g_range | HIGH_RESOLUTION;
 556                 updated_val = ((mask & new_val) | ((~mask) & init_val));
 557                 buf[1] = updated_val;
 558                 buf[0] = CTRL_REG4;
 559                 err = lis3dh_acc_i2c_write(acc, buf, 1);
 560                 if (err < 0)
 561                         goto error;
 562                 acc->resume_state[RES_CTRL_REG4] = updated_val;
 563                 acc->sensitivity = sensitivity;
 564         }
 565
 566
 567         return 0;
 568 error:
 569         dev_err(&acc->client->dev, "update g range failed 0x%x,0x%x: %d\n",
 570                         buf[0], buf[1], err);
 571
 572         return err;
 573 }
 574
 575 int lis3dh_acc_update_odr(struct lis3dh_acc_data *acc, int poll_interval_ms)
 576 {
 577         int err = -1;
 578         int i;
 579         u8 config[2];
 580
 581         /* Convert the poll interval into an output data rate configuration
 582          *  that is as low as possible.  The ordering of these checks must be
 583          *  maintained due to the cascading cut off values - poll intervals are
 584          *  checked from shortest to longest.  At each check, if the next lower
 585          *  ODR cannot support the current poll interval, we stop searching */
 586         for (i = ARRAY_SIZE(lis3dh_acc_odr_table) - 1; i >= 0; i--) {
 587                 if (lis3dh_acc_odr_table[i].cutoff_ms <= poll_interval_ms)
 588                         break;
 589         }
 590         config[1] = lis3dh_acc_odr_table[i].mask;
 591
 592         config[1] |= LIS3DH_ACC_ENABLE_ALL_AXES;
 593
 594         /* If device is currently enabled, we need to write new
 595          *  configuration out to it */
 596         if (atomic_read(&acc->enabled)) {
 597                 config[0] = CTRL_REG1;
 598                 err = lis3dh_acc_i2c_write(acc, config, 1);
 599                 if (err < 0)
 600                         goto error;
 601                 acc->resume_state[RES_CTRL_REG1] = config[1];
 602         }
 603
 604         return 0;
 605
 606 error:
 607         dev_err(&acc->client->dev, "update odr failed 0x%x,0x%x: %d\n",
 608                         config[0], config[1], err);
 609
 610         return err;
 611 }
 612
 613 /* */
 614
 615 static int lis3dh_acc_register_write(struct lis3dh_acc_data *acc, u8 *buf,
 616                 u8 reg_address, u8 new_value)
 617 {
 618         int err = -1;
 619
 620         if (atomic_read(&acc->enabled)) {
 621                 /* Sets configuration register at reg_address
 622                  *  NOTE: this is a straight overwrite  */
 623                 buf[0] = reg_address;
 624                 buf[1] = new_value;
 625                 err = lis3dh_acc_i2c_write(acc, buf, 1);
 626                 if (err < 0)
 627                         return err;
 628         }
 629         return err;
 630 }
 631
 632 static int lis3dh_acc_register_read(struct lis3dh_acc_data *acc, u8 *buf,
 633                 u8 reg_address)
 634 {
 635
 636         int err = -1;
 637         buf[0] = (reg_address);
 638         err = lis3dh_acc_i2c_read(acc, buf, 1);
 639         return err;
 640 }
 641
 642 static int lis3dh_acc_register_update(struct lis3dh_acc_data *acc, u8 *buf,
 643                 u8 reg_address, u8 mask, u8 new_bit_values)
 644 {
 645         int err = -1;
 646         u8 init_val;
 647         u8 updated_val;
 648         err = lis3dh_acc_register_read(acc, buf, reg_address);
 649         if (!(err < 0)) {
 650                 init_val = buf[1];
 651                 updated_val = ((mask & new_bit_values) | ((~mask) & init_val));
 652                 err = lis3dh_acc_register_write(acc, buf, reg_address,
 653                                 updated_val);
 654         }
 655         return err;
 656 }
 657
 658 /* */
 659
 660 static int lis3dh_acc_get_acceleration_data(struct lis3dh_acc_data *acc,
 661                 int *xyz)
 662 {
 663         int err = -1;
 664         /* Data bytes from hardware xL, xH, yL, yH, zL, zH */
 665         u8 acc_data[6];
 666         /* x,y,z hardware data */
 667         s16 hw_d[3] = { 0 };
 668
 669         acc_data[0] = (I2C_AUTO_INCREMENT | AXISDATA_REG);
 670         err = lis3dh_acc_i2c_read(acc, acc_data, 6);
 671         if (err < 0)
 672                 return err;
 673
 674         hw_d[0] = (((s16) ((acc_data[1] << 8) | acc_data[0])) >> 4);
 675         hw_d[1] = (((s16) ((acc_data[3] << 8) | acc_data[2])) >> 4);
 676         hw_d[2] = (((s16) ((acc_data[5] << 8) | acc_data[4])) >> 4);
 677
 678         hw_d[0] = hw_d[0] * acc->sensitivity;
 679         hw_d[1] = hw_d[1] * acc->sensitivity;
 680         hw_d[2] = hw_d[2] * acc->sensitivity;
 681
 682
 683         xyz[0] = ((acc->pdata->negate_x) ? (-hw_d[acc->pdata->axis_map_x])
 684                    : (hw_d[acc->pdata->axis_map_x]));
 685         xyz[1] = ((acc->pdata->negate_y) ? (-hw_d[acc->pdata->axis_map_y])
 686                    : (hw_d[acc->pdata->axis_map_y]));
 687         xyz[2] = ((acc->pdata->negate_z) ? (-hw_d[acc->pdata->axis_map_z])
 688                    : (hw_d[acc->pdata->axis_map_z]));
 689
 690         #ifdef DEBUG
 691         /*
 692                 printk(KERN_INFO "%s read x=%d, y=%d, z=%d\n",
 693                         LIS3DH_ACC_DEV_NAME, xyz[0], xyz[1], xyz[2]);
 694         */
 695         #endif
 696         return err;
 697 }
 698
 699 static void lis3dh_acc_report_values(struct lis3dh_acc_data *acc, int *xyz)
 700 {
 701         input_report_abs(acc->input_dev, ABS_X, xyz[0]);
 702         input_report_abs(acc->input_dev, ABS_Y, xyz[1]);
 703         input_report_abs(acc->input_dev, ABS_Z, xyz[2]);
 704         input_sync(acc->input_dev);
 705 }
 706
 707 static int lis3dh_acc_enable(struct lis3dh_acc_data *acc)
 708 {
 709         int err;
 710
 711         if (!atomic_cmpxchg(&acc->enabled, 0, 1)) {
 712                 err = lis3dh_acc_device_power_on(acc);
 713                 if (err < 0) {
 714                         atomic_set(&acc->enabled, 0);
 715                         return err;
 716                 }
 717                 schedule_delayed_work(&acc->input_work, msecs_to_jiffies(
 718                                 acc->pdata->poll_interval));
 719         }
 720
 721         return 0;
 722 }
 723
 724 static int lis3dh_acc_disable(struct lis3dh_acc_data *acc)
 725 {
 726         if (atomic_cmpxchg(&acc->enabled, 1, 0)) {
 727                 cancel_delayed_work_sync(&acc->input_work);
 728                 lis3dh_acc_device_power_off(acc);
 729         }
 730
 731         return 0;
 732 }
 733
 734 static int lis3dh_acc_misc_open(struct inode *inode, struct file *file)
 735 {
 736         int err;
 737         err = nonseekable_open(inode, file);
 738         if (err < 0)
 739                 return err;
 740
 741         file->private_data = lis3dh_acc_misc_data;
 742
 743         return 0;
 744 }
 745
 746 static int lis3dh_acc_misc_ioctl(struct inode *inode, struct file *file,
 747                 unsigned int cmd, unsigned long arg)
 748 {
 749         void __user *argp = (void __user *)arg;
 750         u8 buf[4];
 751         u8 mask;
 752         u8 reg_address;
 753         u8 bit_values;
 754         int err;
 755         int interval;
 756         struct lis3dh_acc_data *acc = file->private_data;
 757
 758         printk(KERN_INFO "%s: %s call with cmd 0x%x and arg 0x%x\n",
 759                         LIS3DH_ACC_DEV_NAME, __func__, cmd, (unsigned int)arg);
 760
 761         switch (cmd) {
 762         case LIS3DH_ACC_IOCTL_GET_DELAY:
 763                 interval = acc->pdata->poll_interval;
 764                 if (copy_to_user(argp, &interval, sizeof(interval)))
 765                         return -EFAULT;
 766                 break;
 767
 768         case LIS3DH_ACC_IOCTL_SET_DELAY:
 769                 if (copy_from_user(&interval, argp, sizeof(interval)))
 770                         return -EFAULT;
 771                 if (interval < 0 || interval > 1000)
 772                         return -EINVAL;
 773
 774                 acc->pdata->poll_interval = max(interval,
 775                                 acc->pdata->min_interval);
 776                 err = lis3dh_acc_update_odr(acc, acc->pdata->poll_interval);
 777                 /* TODO: if update fails poll is still set */
 778                 if (err < 0)
 779                         return err;
 780                 break;
 781
 782         case LIS3DH_ACC_IOCTL_SET_ENABLE:
 783                 if (copy_from_user(&interval, argp, sizeof(interval)))
 784                         return -EFAULT;
 785                 if (interval > 1)
 786                         return -EINVAL;
 787                 if (interval)
 788                         err = lis3dh_acc_enable(acc);
 789                 else
 790                         err = lis3dh_acc_disable(acc);
 791                 return err;
 792                 break;
 793
 794         case LIS3DH_ACC_IOCTL_GET_ENABLE:
 795                 interval = atomic_read(&acc->enabled);
 796                 if (copy_to_user(argp, &interval, sizeof(interval)))
 797                         return -EINVAL;
 798                 break;
 799
 800         case LIS3DH_ACC_IOCTL_SET_G_RANGE:
 801                 if (copy_from_user(buf, argp, 1))
 802                         return -EFAULT;
 803                 bit_values = buf[0];
 804                 err = lis3dh_acc_update_g_range(acc, bit_values);
 805                 if (err < 0)
 806                         return err;
 807                 break;
 808
 809 #ifdef INTERRUPT_MANAGEMENT
 810         case LIS3DH_ACC_IOCTL_SET_CTRL_REG3:
 811                 if (copy_from_user(buf, argp, 2))
 812                         return -EFAULT;
 813                 reg_address = CTRL_REG3;
 814                 mask = buf[1];
 815                 bit_values = buf[0];
 816                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
 817                                 mask, bit_values);
 818                 if (err < 0)
 819                         return err;
 820                 acc->resume_state[RES_CTRL_REG3] = ((mask & bit_values) |
 821                                 ( ~mask & acc->resume_state[RES_CTRL_REG3]));
 822                 break;
 823
 824         case LIS3DH_ACC_IOCTL_SET_CTRL_REG6:
 825                 if (copy_from_user(buf, argp, 2))
 826                         return -EFAULT;
 827                 reg_address = CTRL_REG6;
 828                 mask = buf[1];
 829                 bit_values = buf[0];
 830                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
 831                                 mask, bit_values);
 832                 if (err < 0)
 833                         return err;
 834                 acc->resume_state[RES_CTRL_REG6] = ((mask & bit_values) |
 835                                 ( ~mask & acc->resume_state[RES_CTRL_REG6]));
 836                 break;
 837
 838         case LIS3DH_ACC_IOCTL_SET_DURATION1:
 839                 if (copy_from_user(buf, argp, 1))
 840                         return -EFAULT;
 841                 reg_address = INT_DUR1;
 842                 mask = 0x7F;
 843                 bit_values = buf[0];
 844                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
 845                                 mask, bit_values);
 846                 if (err < 0)
 847                         return err;
 848                 acc->resume_state[RES_INT_DUR1] = ((mask & bit_values) |
 849                                 ( ~mask & acc->resume_state[RES_INT_DUR1]));
 850                 break;
 851
 852         case LIS3DH_ACC_IOCTL_SET_THRESHOLD1:
 853                 if (copy_from_user(buf, argp, 1))
 854                         return -EFAULT;
 855                 reg_address = INT_THS1;
 856                 mask = 0x7F;
 857                 bit_values = buf[0];
 858                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
 859                                 mask, bit_values);
 860                 if (err < 0)
 861                         return err;
 862                 acc->resume_state[RES_INT_THS1] = ((mask & bit_values) |
 863                                 ( ~mask & acc->resume_state[RES_INT_THS1]));
 864                 break;
 865
 866         case LIS3DH_ACC_IOCTL_SET_CONFIG1:
 867                 if (copy_from_user(buf, argp, 2))
 868                         return -EFAULT;
 869                 reg_address = INT_CFG1;
 870                 mask = buf[1];
 871                 bit_values = buf[0];
 872                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
 873                                 mask, bit_values);
 874                 if (err < 0)
 875                         return err;
 876                 acc->resume_state[RES_INT_CFG1] = ((mask & bit_values) |
 877                                 ( ~mask & acc->resume_state[RES_INT_CFG1]));
 878                 break;
 879
 880         case LIS3DH_ACC_IOCTL_GET_SOURCE1:
 881                 err = lis3dh_acc_register_read(acc, buf, INT_SRC1);
 882                 if (err < 0)
 883                         return err;
 884 #if DEBUG
 885                 printk(KERN_ALERT "INT1_SRC content: %d , 0x%x\n",
 886                                 buf[0], buf[0]);
 887 #endif
 888                 if (copy_to_user(argp, buf, 1))
 889                         return -EINVAL;
 890                 break;
 891
 892         case LIS3DH_ACC_IOCTL_SET_DURATION2:
 893                 if (copy_from_user(buf, argp, 1))
 894                         return -EFAULT;
 895                 reg_address = INT_DUR2;
 896                 mask = 0x7F;
 897                 bit_values = buf[0];
 898                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
 899                                 mask, bit_values);
 900                 if (err < 0)
 901                         return err;
 902                 acc->resume_state[RES_INT_DUR2] = ((mask & bit_values) |
 903                                 ( ~mask & acc->resume_state[RES_INT_DUR2]));
 904                 break;
 905
 906         case LIS3DH_ACC_IOCTL_SET_THRESHOLD2:
 907                 if (copy_from_user(buf, argp, 1))
 908                         return -EFAULT;
 909                 reg_address = INT_THS2;
 910                 mask = 0x7F;
 911                 bit_values = buf[0];
 912                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
 913                                 mask, bit_values);
 914                 if (err < 0)
 915                         return err;
 916                 acc->resume_state[RES_INT_THS2] = ((mask & bit_values) |
 917                                 ( ~mask & acc->resume_state[RES_INT_THS2]));
 918                 break;
 919
 920         case LIS3DH_ACC_IOCTL_SET_CONFIG2:
 921                 if (copy_from_user(buf, argp, 2))
 922                         return -EFAULT;
 923                 reg_address = INT_CFG2;
 924                 mask = buf[1];
 925                 bit_values = buf[0];
 926                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
 927                                 mask, bit_values);
 928                 if (err < 0)
 929                         return err;
 930                 acc->resume_state[RES_INT_CFG2] = ((mask & bit_values) |
 931                                 ( ~mask & acc->resume_state[RES_INT_CFG2]));
 932                 break;
 933
 934         case LIS3DH_ACC_IOCTL_GET_SOURCE2:
 935                 err = lis3dh_acc_register_read(acc, buf, INT_SRC2);
 936                 if (err < 0)
 937                         return err;
 938 #if DEBUG
 939                 printk(KERN_ALERT "INT2_SRC content: %d , 0x%x\n",
 940                                 buf[0], buf[0]);
 941 #endif
 942                 if (copy_to_user(argp, buf, 1))
 943                         return -EINVAL;
 944                 break;
 945
 946         case LIS3DH_ACC_IOCTL_GET_TAP_SOURCE:
 947                 err = lis3dh_acc_register_read(acc, buf, TT_SRC);
 948                 if (err < 0)
 949                         return err;
 950 #if DEBUG
 951                 printk(KERN_ALERT "TT_SRC content: %d , 0x%x\n",
 952                                 buf[0], buf[0]);
 953 #endif
 954                 if (copy_to_user(argp, buf, 1)) {
 955                         printk(KERN_ERR "%s: %s error in copy_to_user \n",
 956                                         LIS3DH_ACC_DEV_NAME, __func__);
 957                         return -EINVAL;
 958                 }
 959                 break;
 960
 961         case LIS3DH_ACC_IOCTL_SET_TAP_CFG:
 962                 if (copy_from_user(buf, argp, 2))
 963                         return -EFAULT;
 964                 reg_address = TT_CFG;
 965                 mask = buf[1];
 966                 bit_values = buf[0];
 967                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
 968                                 mask, bit_values);
 969                 if (err < 0)
 970                         return err;
 971                 acc->resume_state[RES_TT_CFG] = ((mask & bit_values) |
 972                                 ( ~mask & acc->resume_state[RES_TT_CFG]));
 973                 break;
 974
 975         case LIS3DH_ACC_IOCTL_SET_TAP_TLIM:
 976                 if (copy_from_user(buf, argp, 2))
 977                         return -EFAULT;
 978                 reg_address = TT_LIM;
 979                 mask = buf[1];
 980                 bit_values = buf[0];
 981                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
 982                                 mask, bit_values);
 983                 if (err < 0)
 984                         return err;
 985                 acc->resume_state[RES_TT_LIM] = ((mask & bit_values) |
 986                                 ( ~mask & acc->resume_state[RES_TT_LIM]));
 987                 break;
 988
 989         case LIS3DH_ACC_IOCTL_SET_TAP_THS:
 990                 if (copy_from_user(buf, argp, 2))
 991                         return -EFAULT;
 992                 reg_address = TT_THS;
 993                 mask = buf[1];
 994                 bit_values = buf[0];
 995                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
 996                                 mask, bit_values);
 997                 if (err < 0)
 998                         return err;
 999                 acc->resume_state[RES_TT_THS] = ((mask & bit_values) |
1000                                 ( ~mask & acc->resume_state[RES_TT_THS]));
1001                 break;
1002
1003         case LIS3DH_ACC_IOCTL_SET_TAP_TLAT:
1004                 if (copy_from_user(buf, argp, 2))
1005                         return -EFAULT;
1006                 reg_address = TT_TLAT;
1007                 mask = buf[1];
1008                 bit_values = buf[0];
1009                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
1010                                 mask, bit_values);
1011                 if (err < 0)
1012                         return err;
1013                 acc->resume_state[RES_TT_TLAT] = ((mask & bit_values) |
1014                                 ( ~mask & acc->resume_state[RES_TT_TLAT]));
1015                 break;
1016
1017         case LIS3DH_ACC_IOCTL_SET_TAP_TW:
1018                 if (copy_from_user(buf, argp, 2))
1019                         return -EFAULT;
1020                 reg_address = TT_TW;
1021                 mask = buf[1];
1022                 bit_values = buf[0];
1023                 err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
1024                                 mask, bit_values);
1025                 if (err < 0)
1026                         return err;
1027                 acc->resume_state[RES_TT_TW] = ((mask & bit_values) |
1028                                 ( ~mask & acc->resume_state[RES_TT_TW]));
1029                 break;
1030
1031 #endif /* INTERRUPT_MANAGEMENT */
1032
1033         default:
1034                 return -EINVAL;
1035         }
1036
1037         return 0;
1038 }
1039
1040 static const struct file_operations lis3dh_acc_misc_fops = {
1041                 .owner = THIS_MODULE,
1042                 .open = lis3dh_acc_misc_open,
1043                 .ioctl = lis3dh_acc_misc_ioctl,
1044 };
1045
1046 static struct miscdevice lis3dh_acc_misc_device = {
1047                 .minor = MISC_DYNAMIC_MINOR,
1048                 .name = LIS3DH_ACC_DEV_NAME,
1049                 .fops = &lis3dh_acc_misc_fops,
1050 };
1051
1052 static void lis3dh_acc_input_work_func(struct work_struct *work)
1053 {
1054         struct lis3dh_acc_data *acc;
1055
1056         int xyz[3] = { 0 };
1057         int err;
1058
1059         acc = container_of((struct delayed_work *)work,
1060                         struct lis3dh_acc_data, input_work);
1061
1062         mutex_lock(&acc->lock);
1063         err = lis3dh_acc_get_acceleration_data(acc, xyz);
1064         if (err < 0)
1065                 dev_err(&acc->client->dev, "get_acceleration_data failed\n");
1066         else
1067                 lis3dh_acc_report_values(acc, xyz);
1068
1069         schedule_delayed_work(&acc->input_work, msecs_to_jiffies(
1070                         acc->pdata->poll_interval));
1071         mutex_unlock(&acc->lock);
1072 }
1073
1074 #ifdef LIS3DH_OPEN_ENABLE
1075 int lis3dh_acc_input_open(struct input_dev *input)
1076 {
1077         struct lis3dh_acc_data *acc = input_get_drvdata(input);
1078
1079         return lis3dh_acc_enable(acc);
1080 }
1081
1082 void lis3dh_acc_input_close(struct input_dev *dev)
1083 {
1084         struct lis3dh_acc_data *acc = input_get_drvdata(dev);
1085
1086         lis3dh_acc_disable(acc);
1087 }
1088 #endif
1089
1090 static int lis3dh_acc_validate_pdata(struct lis3dh_acc_data *acc)
1091 {
1092         acc->pdata->poll_interval = max(acc->pdata->poll_interval,
1093                         acc->pdata->min_interval);
1094
1095         if (acc->pdata->axis_map_x > 2 || acc->pdata->axis_map_y > 2
1096                         || acc->pdata->axis_map_z > 2) {
1097                 dev_err(&acc->client->dev, "invalid axis_map value "
1098                         "x:%u y:%u z%u\n", acc->pdata->axis_map_x,
1099                                 acc->pdata->axis_map_y, acc->pdata->axis_map_z);
1100                 return -EINVAL;
1101         }
1102
1103         /* Only allow 0 and 1 for negation boolean flag */
1104         if (acc->pdata->negate_x > 1 || acc->pdata->negate_y > 1
1105                         || acc->pdata->negate_z > 1) {
1106                 dev_err(&acc->client->dev, "invalid negate value "
1107                         "x:%u y:%u z:%u\n", acc->pdata->negate_x,
1108                                 acc->pdata->negate_y, acc->pdata->negate_z);
1109                 return -EINVAL;
1110         }
1111
1112         /* Enforce minimum polling interval */
1113         if (acc->pdata->poll_interval < acc->pdata->min_interval) {
1114                 dev_err(&acc->client->dev, "minimum poll interval violated\n");
1115                 return -EINVAL;
1116         }
1117
1118         return 0;
1119 }
1120
1121 static int lis3dh_acc_input_init(struct lis3dh_acc_data *acc)
1122 {
1123         int err;
1124
1125         INIT_DELAYED_WORK(&acc->input_work, lis3dh_acc_input_work_func);
1126         acc->input_dev = input_allocate_device();
1127         if (!acc->input_dev) {
1128                 err = -ENOMEM;
1129                 dev_err(&acc->client->dev, "input device allocate failed\n");
1130                 goto err0;
1131         }
1132
1133 #ifdef LIS3DH_ACC_OPEN_ENABLE
1134         acc->input_dev->open = lis3dh_acc_input_open;
1135         acc->input_dev->close = lis3dh_acc_input_close;
1136 #endif
1137
1138         input_set_drvdata(acc->input_dev, acc);
1139
1140         set_bit(EV_ABS, acc->input_dev->evbit);
1141         /*      next is used for interruptA sources data if the case */
1142         set_bit(ABS_MISC, acc->input_dev->absbit);
1143         /*      next is used for interruptB sources data if the case */
1144         set_bit(ABS_WHEEL, acc->input_dev->absbit);
1145
1146         input_set_abs_params(acc->input_dev, ABS_X, -G_MAX, G_MAX, FUZZ, FLAT);
1147         input_set_abs_params(acc->input_dev, ABS_Y, -G_MAX, G_MAX, FUZZ, FLAT);
1148         input_set_abs_params(acc->input_dev, ABS_Z, -G_MAX, G_MAX, FUZZ, FLAT);
1149         /*      next is used for interruptA sources data if the case */
1150         input_set_abs_params(acc->input_dev, ABS_MISC, INT_MIN, INT_MAX, 0, 0);
1151         /*      next is used for interruptB sources data if the case */
1152         input_set_abs_params(acc->input_dev, ABS_WHEEL, INT_MIN, INT_MAX, 0, 0);
1153
1154         acc->input_dev->name = "accelerometer";
1155
1156         err = input_register_device(acc->input_dev);
1157         if (err) {
1158                 dev_err(&acc->client->dev,
1159                                 "unable to register input polled device %s\n",
1160                                 acc->input_dev->name);
1161                 goto err1;
1162         }
1163
1164         return 0;
1165
1166 err1:
1167         input_free_device(acc->input_dev);
1168 err0:
1169         return err;
1170 }
1171
1172 static void lis3dh_acc_input_cleanup(struct lis3dh_acc_data *acc)
1173 {
1174         input_unregister_device(acc->input_dev);
1175         input_free_device(acc->input_dev);
1176 }
1177
1178 static int lis3dh_acc_probe(struct i2c_client *client,
1179                 const struct i2c_device_id *id)
1180 {
1181
1182         struct lis3dh_acc_data *acc;
1183
1184         int err = -1;
1185         int tempvalue;
1186
1187         pr_info("%s: probe start.\n", LIS3DH_ACC_DEV_NAME);
1188
1189         if (client->dev.platform_data == NULL) {
1190                 dev_err(&client->dev, "platform data is NULL. exiting.\n");
1191                 err = -ENODEV;
1192                 goto exit_check_functionality_failed;
1193         }
1194
1195         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1196                 dev_err(&client->dev, "client not i2c capable\n");
1197                 err = -ENODEV;
1198                 goto exit_check_functionality_failed;
1199         }
1200
1201         if (!i2c_check_functionality(client->adapter,
1202                                         I2C_FUNC_SMBUS_BYTE |
1203                                         I2C_FUNC_SMBUS_BYTE_DATA |
1204                                         I2C_FUNC_SMBUS_WORD_DATA)) {
1205                 dev_err(&client->dev, "client not smb-i2c capable:2\n");
1206                 err = -EIO;
1207                 goto exit_check_functionality_failed;
1208         }
1209
1210
1211         if (!i2c_check_functionality(client->adapter,
1212                                                 I2C_FUNC_SMBUS_I2C_BLOCK)){
1213                 dev_err(&client->dev, "client not smb-i2c capable:3\n");
1214                 err = -EIO;
1215                 goto exit_check_functionality_failed;
1216         }
1217         /*
1218          * OK. From now, we presume we have a valid client. We now create the
1219          * client structure, even though we cannot fill it completely yet.
1220          */
1221
1222         acc = kzalloc(sizeof(struct lis3dh_acc_data), GFP_KERNEL);
1223         if (acc == NULL) {
1224                 err = -ENOMEM;
1225                 dev_err(&client->dev,
1226                                 "failed to allocate memory for module data: "
1227                                         "%d\n", err);
1228                 goto exit_alloc_data_failed;
1229         }
1230
1231         mutex_init(&acc->lock);
1232         mutex_lock(&acc->lock);
1233
1234         acc->client = client;
1235         i2c_set_clientdata(client, acc);
1236
1237
1238         INIT_WORK(&acc->irq1_work, lis3dh_acc_irq1_work_func);
1239         acc->irq1_work_queue = create_singlethread_workqueue("lis3dh_acc_wq1");
1240         if (!acc->irq1_work_queue) {
1241                 err = -ENOMEM;
1242                 dev_err(&client->dev, "cannot create work queue1: %d\n", err);
1243                 goto err_mutexunlockfreedata;
1244         }
1245
1246         INIT_WORK(&acc->irq2_work, lis3dh_acc_irq2_work_func);
1247         acc->irq2_work_queue = create_singlethread_workqueue("lis3dh_acc_wq2");
1248         if (!acc->irq2_work_queue) {
1249                 err = -ENOMEM;
1250                 dev_err(&client->dev, "cannot create work queue2: %d\n", err);
1251                 goto err_destoyworkqueue1;
1252         }
1253
1254
1255
1256         if (i2c_smbus_read_byte(client) < 0) {
1257                 printk(KERN_ERR "i2c_smbus_read_byte error!!\n");
1258                 goto err_destoyworkqueue2;
1259         } else {
1260                 printk(KERN_INFO "%s Device detected!\n", LIS3DH_ACC_DEV_NAME);
1261         }
1262
1263         /* read chip id */
1264
1265         tempvalue = i2c_smbus_read_word_data(client, WHO_AM_I);
1266         if ((tempvalue & 0x00FF) == WHOAMI_LIS3DH_ACC) {
1267                 printk(KERN_INFO "%s I2C driver registered!\n",
1268                                                         LIS3DH_ACC_DEV_NAME);
1269         } else {
1270                 acc->client = NULL;
1271                 printk(KERN_INFO "I2C driver not registered!"
1272                                 " Device unknown\n");
1273                 goto err_destoyworkqueue2;
1274         }
1275
1276         acc->pdata = kmalloc(sizeof(*acc->pdata), GFP_KERNEL);
1277         if (acc->pdata == NULL) {
1278                 err = -ENOMEM;
1279                 dev_err(&client->dev,
1280                                 "failed to allocate memory for pdata: %d\n",
1281                                 err);
1282                 goto err_destoyworkqueue2;
1283         }
1284
1285         memcpy(acc->pdata, client->dev.platform_data, sizeof(*acc->pdata));
1286
1287         err = lis3dh_acc_validate_pdata(acc);
1288         if (err < 0) {
1289                 dev_err(&client->dev, "failed to validate platform data\n");
1290                 goto exit_kfree_pdata;
1291         }
1292
1293         i2c_set_clientdata(client, acc);
1294
1295
1296         if (acc->pdata->init) {
1297                 err = acc->pdata->init();
1298                 if (err < 0) {
1299                         dev_err(&client->dev, "init failed: %d\n", err);
1300                         goto err2;
1301                 }
1302         }
1303
1304         memset(acc->resume_state, 0, ARRAY_SIZE(acc->resume_state));
1305
1306         acc->irq1 = gpio_to_irq(acc->pdata->gpio_int1);
1307         printk(KERN_INFO "%s: %s has set irq1 to irq: %d mapped on gpio:%d\n",
1308                 LIS3DH_ACC_DEV_NAME, __func__, acc->irq1,
1309                                                         acc->pdata->gpio_int1);
1310         acc->irq2 = gpio_to_irq(acc->pdata->gpio_int2);
1311         printk(KERN_INFO "%s: %s has set irq2 to irq: %d mapped on gpio:%d\n",
1312                 LIS3DH_ACC_DEV_NAME, __func__, acc->irq2,
1313                                                         acc->pdata->gpio_int2);
1314
1315
1316
1317
1318         acc->resume_state[RES_CTRL_REG1] = LIS3DH_ACC_ENABLE_ALL_AXES;
1319         acc->resume_state[RES_CTRL_REG2] = 0x00;
1320         acc->resume_state[RES_CTRL_REG3] = 0x00;
1321         acc->resume_state[RES_CTRL_REG4] = 0x00;
1322         acc->resume_state[RES_CTRL_REG5] = 0x00;
1323         acc->resume_state[RES_CTRL_REG6] = 0x00;
1324
1325         acc->resume_state[RES_TEMP_CFG_REG] = 0x00;
1326         acc->resume_state[RES_FIFO_CTRL_REG] = 0x00;
1327         acc->resume_state[RES_INT_CFG1] = 0x00;
1328         acc->resume_state[RES_INT_THS1] = 0x00;
1329         acc->resume_state[RES_INT_DUR1] = 0x00;
1330         acc->resume_state[RES_INT_CFG2] = 0x00;
1331         acc->resume_state[RES_INT_THS2] = 0x00;
1332         acc->resume_state[RES_INT_DUR2] = 0x00;
1333
1334         acc->resume_state[RES_TT_CFG] = 0x00;
1335         acc->resume_state[RES_TT_THS] = 0x00;
1336         acc->resume_state[RES_TT_LIM] = 0x00;
1337         acc->resume_state[RES_TT_TLAT] = 0x00;
1338         acc->resume_state[RES_TT_TW] = 0x00;
1339
1340         err = lis3dh_acc_device_power_on(acc);
1341         if (err < 0) {
1342                 dev_err(&client->dev, "power on failed: %d\n", err);
1343                 goto err2;
1344         }
1345
1346         atomic_set(&acc->enabled, 1);
1347
1348         err = lis3dh_acc_update_g_range(acc, acc->pdata->g_range);
1349         if (err < 0) {
1350                 dev_err(&client->dev, "update_g_range failed\n");
1351                 goto  err_power_off;
1352         }
1353
1354         err = lis3dh_acc_update_odr(acc, acc->pdata->poll_interval);
1355         if (err < 0) {
1356                 dev_err(&client->dev, "update_odr failed\n");
1357                 goto  err_power_off;
1358         }
1359
1360         err = lis3dh_acc_input_init(acc);
1361         if (err < 0) {
1362                 dev_err(&client->dev, "input init failed\n");
1363                 goto err_power_off;
1364         }
1365         lis3dh_acc_misc_data = acc;
1366
1367         err = misc_register(&lis3dh_acc_misc_device);
1368         if (err < 0) {
1369                 dev_err(&client->dev,
1370                                 "misc LIS3DH_ACC_DEV_NAME register failed\n");
1371                 goto err_input_cleanup;
1372         }
1373
1374         lis3dh_acc_device_power_off(acc);
1375
1376         /* As default, do not report information */
1377         atomic_set(&acc->enabled, 0);
1378
1379         err = request_irq(acc->irq1, lis3dh_acc_isr1, IRQF_TRIGGER_RISING,
1380                         "lis3dh_acc_irq1", acc);
1381         if (err < 0) {
1382                 dev_err(&client->dev, "request irq1 failed: %d\n", err);
1383                 goto err_misc_dereg;
1384         }
1385         disable_irq_nosync(acc->irq1);
1386
1387         err = request_irq(acc->irq2, lis3dh_acc_isr2, IRQF_TRIGGER_RISING,
1388                         "lis3dh_acc_irq2", acc);
1389         if (err < 0) {
1390                 dev_err(&client->dev, "request irq2 failed: %d\n", err);
1391                 goto err_free_irq1;
1392         }
1393         disable_irq_nosync(acc->irq2);
1394
1395         mutex_unlock(&acc->lock);
1396
1397         dev_info(&client->dev, "%s: probed\n", LIS3DH_ACC_DEV_NAME);
1398
1399         return 0;
1400
1401 err_free_irq1:
1402         free_irq(acc->irq1, acc);
1403 err_misc_dereg:
1404         misc_deregister(&lis3dh_acc_misc_device);
1405 err_input_cleanup:
1406         lis3dh_acc_input_cleanup(acc);
1407 err_power_off:
1408         lis3dh_acc_device_power_off(acc);
1409 err2:
1410         if (acc->pdata->exit)
1411                 acc->pdata->exit();
1412 exit_kfree_pdata:
1413         kfree(acc->pdata);
1414 err_destoyworkqueue2:
1415         destroy_workqueue(acc->irq2_work_queue);
1416 err_destoyworkqueue1:
1417         destroy_workqueue(acc->irq1_work_queue);
1418 err_mutexunlockfreedata:
1419         mutex_unlock(&acc->lock);
1420         kfree(acc);
1421 exit_alloc_data_failed:
1422 exit_check_functionality_failed:
1423         printk(KERN_ERR "%s: Driver Init failed\n", LIS3DH_ACC_DEV_NAME);
1424         return err;
1425 }
1426
1427 static int __devexit lis3dh_acc_remove(struct i2c_client *client)
1428 {
1429         /* TODO: revisit ordering here once _probe order is finalized */
1430         struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
1431
1432         free_irq(acc->irq1, acc);
1433         free_irq(acc->irq2, acc);
1434         gpio_free(acc->pdata->gpio_int1);
1435         gpio_free(acc->pdata->gpio_int2);
1436         destroy_workqueue(acc->irq1_work_queue);
1437         destroy_workqueue(acc->irq2_work_queue);
1438
1439         misc_deregister(&lis3dh_acc_misc_device);
1440         lis3dh_acc_input_cleanup(acc);
1441         lis3dh_acc_device_power_off(acc);
1442         if (acc->pdata->exit)
1443                 acc->pdata->exit();
1444         kfree(acc->pdata);
1445         kfree(acc);
1446
1447         return 0;
1448 }
1449
1450 static int lis3dh_acc_resume(struct i2c_client *client)
1451 {
1452         struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
1453
1454         if (acc->on_before_suspend)
1455                 return lis3dh_acc_enable(acc);
1456         return 0;
1457 }
1458
1459 static int lis3dh_acc_suspend(struct i2c_client *client, pm_message_t mesg)
1460 {
1461         struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
1462
1463         acc->on_before_suspend = atomic_read(&acc->enabled);
1464         return lis3dh_acc_disable(acc);
1465 }
1466
1467 static const struct i2c_device_id lis3dh_acc_id[]
1468                                 = { { LIS3DH_ACC_DEV_NAME, 0 }, { }, };
1469
1470 MODULE_DEVICE_TABLE(i2c, lis3dh_acc_id);
1471
1472 static struct i2c_driver lis3dh_acc_driver = {
1473         .driver = {
1474                         .name = LIS3DH_ACC_DEV_NAME,
1475                   },
1476         .probe = lis3dh_acc_probe,
1477         .remove = __devexit_p(lis3dh_acc_remove),
1478         .resume = lis3dh_acc_resume,
1479         .suspend = lis3dh_acc_suspend,
1480         .id_table = lis3dh_acc_id,
1481 };
1482
1483 static int __init lis3dh_acc_init(void)
1484 {
1485         printk(KERN_INFO "%s accelerometer driver: init\n",
1486                                                 LIS3DH_ACC_DEV_NAME);
1487         return i2c_add_driver(&lis3dh_acc_driver);
1488 }
1489
1490 static void __exit lis3dh_acc_exit(void)
1491 {
1492         #if DEBUG
1493         printk(KERN_INFO "%s accelerometer driver exit\n", LIS3DH_ACC_DEV_NAME);
1494         #endif
1495         i2c_del_driver(&lis3dh_acc_driver);
1496         return;
1497 }
1498
1499 module_init(lis3dh_acc_init);
1500 module_exit(lis3dh_acc_exit);
1501
1502 MODULE_DESCRIPTION("lis3dh accelerometer misc driver");
1503 MODULE_AUTHOR("STMicroelectronics");
1504 MODULE_LICENSE("GPL");
1505