drivers/input/misc/lis302dl.c

   1 /* Linux kernel driver for the ST LIS302D 3-axis accelerometer
   2  *
   3  * Copyright (C) 2007-2008 by Openmoko, Inc.
   4  * Author: Harald Welte <laforge@openmoko.org>
   5  *         converted to private bitbang by:
   6  *         Andy Green <andy@openmoko.com>
   7  *         ability to set acceleration threshold added by:
   8  *         Simon Kagstrom <simon.kagstrom@gmail.com>
   9  * All rights reserved.
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License as
  13  * published by the Free Software Foundation; either version 2 of
  14  * the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  24  * MA 02111-1307 USA
  25  *
  26  * TODO
  27  *      * statistics for overflow events
  28  *      * configuration interface (sysfs) for
  29  *              * enable/disable x/y/z axis data ready
  30  *              * enable/disable resume from freee fall / click
  31  *              * free fall / click parameters
  32  *              * high pass filter parameters
  33  */
  34 #include <linux/kernel.h>
  35 #include <linux/types.h>
  36 #include <linux/module.h>
  37 #include <linux/device.h>
  38 #include <linux/platform_device.h>
  39 #include <linux/delay.h>
  40 #include <linux/irq.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/sysfs.h>
  43
  44 #include <linux/lis302dl.h>
  45
  46 /* Utility functions */
  47
  48 static u8 __reg_read(struct lis302dl_info *lis, u8 reg)
  49 {
  50         return (lis->pdata->lis302dl_bitbang_reg_read)(lis, reg);
  51 }
  52
  53 static void __reg_write(struct lis302dl_info *lis, u8 reg, u8 val)
  54 {
  55         (lis->pdata->lis302dl_bitbang_reg_write)(lis, reg, val);
  56 }
  57
  58 static void __reg_set_bit_mask(struct lis302dl_info *lis, u8 reg, u8 mask,
  59                 u8 val)
  60 {
  61         u_int8_t tmp;
  62
  63         val &= mask;
  64
  65         tmp = __reg_read(lis, reg);
  66         tmp &= ~mask;
  67         tmp |= val;
  68         __reg_write(lis, reg, tmp);
  69 }
  70
  71 static int __ms_to_duration(struct lis302dl_info *lis, int ms)
  72 {
  73         /* If we have 400 ms sampling rate, the stepping is 2.5 ms,
  74          * on 100 ms the stepping is 10ms */
  75         if (lis->flags & LIS302DL_F_DR)
  76                 return min((ms * 10) / 25, 637);
  77
  78         return min(ms / 10, 2550);
  79 }
  80
  81 static int __duration_to_ms(struct lis302dl_info *lis, int duration)
  82 {
  83         if (lis->flags & LIS302DL_F_DR)
  84                 return (duration * 25) / 10;
  85
  86         return duration * 10;
  87 }
  88
  89 static u8 __mg_to_threshold(struct lis302dl_info *lis, int mg)
  90 {
  91         /* If FS is set each bit is 71mg, otherwise 18mg. The THS register
  92          * has 7 bits for the threshold value */
  93         if (lis->flags & LIS302DL_F_FS)
  94                 return min(mg / 71, 127);
  95
  96         return min(mg / 18, 127);
  97 }
  98
  99 static int __threshold_to_mg(struct lis302dl_info *lis, u8 threshold)
 100 {
 101         if (lis->flags & LIS302DL_F_FS)
 102                 return threshold * 71;
 103
 104         return threshold * 18;
 105 }
 106
 107 /* interrupt handling related */
 108
 109 enum lis302dl_intmode {
 110         LIS302DL_INTMODE_GND            = 0x00,
 111         LIS302DL_INTMODE_FF_WU_1        = 0x01,
 112         LIS302DL_INTMODE_FF_WU_2        = 0x02,
 113         LIS302DL_INTMODE_FF_WU_12       = 0x03,
 114         LIS302DL_INTMODE_DATA_READY     = 0x04,
 115         LIS302DL_INTMODE_CLICK          = 0x07,
 116 };
 117
 118
 119 static void __lis302dl_int_mode(struct device *dev, int int_pin,
 120                               enum lis302dl_intmode mode)
 121 {
 122         struct lis302dl_info *lis = dev_get_drvdata(dev);
 123
 124         switch (int_pin) {
 125         case 1:
 126                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL3, 0x07, mode);
 127                 break;
 128         case 2:
 129                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL3, 0x38, mode << 3);
 130                 break;
 131         default:
 132                 BUG();
 133         }
 134 }
 135
 136 static void __enable_wakeup(struct lis302dl_info *lis)
 137 {
 138         /* First zero to get to a known state */
 139         __reg_write(lis, LIS302DL_REG_FF_WU_CFG_1,
 140                         lis->wakeup.cfg);
 141         __reg_write(lis, LIS302DL_REG_FF_WU_THS_1,
 142                         lis->wakeup.threshold);
 143         __reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1,
 144                         lis->wakeup.duration);
 145
 146         /* Route the interrupt for wakeup */
 147         __lis302dl_int_mode(lis->dev, 1,
 148                         LIS302DL_INTMODE_FF_WU_1);
 149
 150         __reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD);
 151 }
 152
 153 static void __enable_data_collection(struct lis302dl_info *lis)
 154 {
 155         u_int8_t ctrl1 = LIS302DL_CTRL1_PD | LIS302DL_CTRL1_Xen |
 156                          LIS302DL_CTRL1_Yen | LIS302DL_CTRL1_Zen;
 157
 158         /* make sure we're powered up and generate data ready */
 159         __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, ctrl1, ctrl1);
 160
 161         /* If the threshold is zero, let the device generated an interrupt
 162          * on each datum */
 163         if (lis->threshold == 0) {
 164                 __reg_write(lis, LIS302DL_REG_CTRL2, 0);
 165                 __lis302dl_int_mode(lis->dev, 1, LIS302DL_INTMODE_DATA_READY);
 166                 __lis302dl_int_mode(lis->dev, 2, LIS302DL_INTMODE_DATA_READY);
 167         } else {
 168                 __reg_write(lis, LIS302DL_REG_CTRL2,
 169                                 LIS302DL_CTRL2_HPFF1);
 170                 __reg_write(lis, LIS302DL_REG_FF_WU_THS_1, lis->threshold);
 171                 __reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1, lis->duration);
 172
 173                 /* Clear the HP filter "starting point" */
 174                 __reg_read(lis, LIS302DL_REG_HP_FILTER_RESET);
 175                 __reg_write(lis, LIS302DL_REG_FF_WU_CFG_1,
 176                                 LIS302DL_FFWUCFG_XHIE | LIS302DL_FFWUCFG_YHIE |
 177                                 LIS302DL_FFWUCFG_ZHIE);
 178                 __lis302dl_int_mode(lis->dev, 1, LIS302DL_INTMODE_FF_WU_12);
 179                 __lis302dl_int_mode(lis->dev, 2, LIS302DL_INTMODE_FF_WU_12);
 180         }
 181 }
 182
 183 #if 0
 184 static void _report_btn_single(struct input_dev *inp, int btn)
 185 {
 186         input_report_key(inp, btn, 1);
 187         input_sync(inp);
 188         input_report_key(inp, btn, 0);
 189 }
 190
 191 static void _report_btn_double(struct input_dev *inp, int btn)
 192 {
 193         input_report_key(inp, btn, 1);
 194         input_sync(inp);
 195         input_report_key(inp, btn, 0);
 196         input_sync(inp);
 197         input_report_key(inp, btn, 1);
 198         input_sync(inp);
 199         input_report_key(inp, btn, 0);
 200 }
 201 #endif
 202
 203
 204 static void lis302dl_bitbang_read_sample(struct lis302dl_info *lis)
 205 {
 206         u8 data = 0xc0 | LIS302DL_REG_OUT_X; /* read, autoincrement */
 207         u8 read[5];
 208         unsigned long flags;
 209         int mg_per_sample;
 210
 211         local_irq_save(flags);
 212         mg_per_sample = __threshold_to_mg(lis, 1);
 213
 214         (lis->pdata->lis302dl_bitbang)(lis, &data, 1, &read[0], 5);
 215
 216         local_irq_restore(flags);
 217
 218         input_report_rel(lis->input_dev, REL_X, mg_per_sample * (s8)read[0]);
 219         input_report_rel(lis->input_dev, REL_Y, mg_per_sample * (s8)read[2]);
 220         input_report_rel(lis->input_dev, REL_Z, mg_per_sample * (s8)read[4]);
 221
 222         input_sync(lis->input_dev);
 223
 224         /* Reset the HP filter */
 225         __reg_read(lis, LIS302DL_REG_HP_FILTER_RESET);
 226 }
 227
 228 static irqreturn_t lis302dl_interrupt(int irq, void *_lis)
 229 {
 230         struct lis302dl_info *lis = _lis;
 231
 232         lis302dl_bitbang_read_sample(lis);
 233         return IRQ_HANDLED;
 234 }
 235
 236 /* sysfs */
 237
 238 static ssize_t show_rate(struct device *dev, struct device_attribute *attr,
 239                          char *buf)
 240 {
 241         struct lis302dl_info *lis = dev_get_drvdata(dev);
 242         u8 ctrl1;
 243         unsigned long flags;
 244
 245         local_irq_save(flags);
 246         ctrl1 = __reg_read(lis, LIS302DL_REG_CTRL1);
 247         local_irq_restore(flags);
 248
 249         return sprintf(buf, "%d\n", ctrl1 & LIS302DL_CTRL1_DR ? 400 : 100);
 250 }
 251
 252 static ssize_t set_rate(struct device *dev, struct device_attribute *attr,
 253                         const char *buf, size_t count)
 254 {
 255         struct lis302dl_info *lis = dev_get_drvdata(dev);
 256         unsigned long flags;
 257         int duration_ms = __duration_to_ms(lis, lis->duration);
 258
 259         local_irq_save(flags);
 260
 261         if (!strcmp(buf, "400\n")) {
 262                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_DR,
 263                                  LIS302DL_CTRL1_DR);
 264                 lis->flags |= LIS302DL_F_DR;
 265         } else {
 266                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_DR,
 267                                 0);
 268                 lis->flags &= ~LIS302DL_F_DR;
 269         }
 270         lis->duration = __ms_to_duration(lis, duration_ms);
 271         local_irq_restore(flags);
 272
 273         return count;
 274 }
 275
 276 static DEVICE_ATTR(sample_rate, S_IRUGO | S_IWUSR, show_rate, set_rate);
 277
 278 static ssize_t show_scale(struct device *dev, struct device_attribute *attr,
 279                           char *buf)
 280 {
 281         struct lis302dl_info *lis = dev_get_drvdata(dev);
 282         u_int8_t ctrl1;
 283         unsigned long flags;
 284
 285         local_irq_save(flags);
 286         ctrl1 = __reg_read(lis, LIS302DL_REG_CTRL1);
 287         local_irq_restore(flags);
 288
 289         return sprintf(buf, "%s\n", ctrl1 & LIS302DL_CTRL1_FS ? "9.2" : "2.3");
 290 }
 291
 292 static ssize_t set_scale(struct device *dev, struct device_attribute *attr,
 293                          const char *buf, size_t count)
 294 {
 295         struct lis302dl_info *lis = dev_get_drvdata(dev);
 296         unsigned long flags;
 297         int threshold_mg = __threshold_to_mg(lis, lis->threshold);
 298
 299         local_irq_save(flags);
 300
 301         if (!strcmp(buf, "9.2\n")) {
 302                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_FS,
 303                                  LIS302DL_CTRL1_FS);
 304                 lis->flags |= LIS302DL_F_FS;
 305         } else {
 306                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_FS,
 307                                 0);
 308                 lis->flags &= ~LIS302DL_F_FS;
 309         }
 310
 311         /* Adjust the threshold */
 312         lis->threshold = __mg_to_threshold(lis, threshold_mg);
 313         if (lis->flags & LIS302DL_F_INPUT_OPEN)
 314                 __enable_data_collection(lis);
 315
 316         local_irq_restore(flags);
 317
 318         return count;
 319 }
 320
 321 static DEVICE_ATTR(full_scale, S_IRUGO | S_IWUSR, show_scale, set_scale);
 322
 323 static ssize_t show_threshold(struct device *dev, struct device_attribute *attr,
 324                  char *buf)
 325 {
 326         struct lis302dl_info *lis = dev_get_drvdata(dev);
 327
 328         return sprintf(buf, "%d\n", __threshold_to_mg(lis, lis->threshold));
 329 }
 330
 331 static ssize_t set_threshold(struct device *dev, struct device_attribute *attr,
 332                  const char *buf, size_t count)
 333 {
 334         struct lis302dl_info *lis = dev_get_drvdata(dev);
 335         u32 val;
 336
 337         if (sscanf(buf, "%d\n", &val) != 1)
 338                 return -EINVAL;
 339         /* 8g is the maximum if FS is 1 */
 340         if (val < 0 || val > 8000)
 341                 return -ERANGE;
 342
 343         /* Set the threshold and write it out if the device is used */
 344         lis->threshold = __mg_to_threshold(lis, val);
 345
 346         if (lis->flags & LIS302DL_F_INPUT_OPEN) {
 347                 unsigned long flags;
 348
 349                 local_irq_save(flags);
 350                 __enable_data_collection(lis);
 351                 local_irq_restore(flags);
 352         }
 353
 354         return count;
 355 }
 356
 357 static DEVICE_ATTR(threshold, S_IRUGO | S_IWUSR, show_threshold, set_threshold);
 358
 359 static ssize_t show_duration(struct device *dev, struct device_attribute *attr,
 360                  char *buf)
 361 {
 362         struct lis302dl_info *lis = dev_get_drvdata(dev);
 363
 364         return sprintf(buf, "%d\n", __duration_to_ms(lis, lis->duration));
 365 }
 366
 367 static ssize_t set_duration(struct device *dev, struct device_attribute *attr,
 368                  const char *buf, size_t count)
 369 {
 370         struct lis302dl_info *lis = dev_get_drvdata(dev);
 371         u32 val;
 372
 373         if (sscanf(buf, "%d\n", &val) != 1)
 374                 return -EINVAL;
 375         if (val < 0 || val > 2550)
 376                 return -ERANGE;
 377
 378         lis->duration = __ms_to_duration(lis, val);
 379         if (lis->flags & LIS302DL_F_INPUT_OPEN)
 380                 __reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1, lis->duration);
 381
 382         return count;
 383 }
 384
 385 static DEVICE_ATTR(duration, S_IRUGO | S_IWUSR, show_duration, set_duration);
 386
 387 static ssize_t lis302dl_dump(struct device *dev, struct device_attribute *attr,
 388                                                                       char *buf)
 389 {
 390         struct lis302dl_info *lis = dev_get_drvdata(dev);
 391         int n = 0;
 392         u8 reg[0x40];
 393         char *end = buf;
 394         unsigned long flags;
 395
 396         local_irq_save(flags);
 397
 398         for (n = 0; n < sizeof(reg); n++)
 399                 reg[n] = __reg_read(lis, n);
 400
 401         local_irq_restore(flags);
 402
 403         for (n = 0; n < sizeof(reg); n += 16) {
 404                 hex_dump_to_buffer(reg + n, 16, 16, 1, end, 128, 0);
 405                 end += strlen(end);
 406                 *end++ = '\n';
 407                 *end++ = '\0';
 408         }
 409
 410         return end - buf;
 411 }
 412 static DEVICE_ATTR(dump, S_IRUGO, lis302dl_dump, NULL);
 413
 414 /* Configure freefall/wakeup interrupts */
 415 static ssize_t set_wakeup(struct device *dev, struct device_attribute *attr,
 416                          const char *buf, size_t count)
 417 {
 418         struct lis302dl_info *lis = dev_get_drvdata(dev);
 419         u_int8_t x_lo, y_lo, z_lo;
 420         u_int8_t x_hi, y_hi, z_hi;
 421         int duration, threshold, and_events;
 422         int x, y, z;
 423
 424         /* Zero turns the feature off */
 425         if (strcmp(buf, "0\n") == 0) {
 426                 lis->wakeup.active = 0;
 427
 428                 if (lis->flags & LIS302DL_F_IRQ_WAKE) {
 429                         disable_irq_wake(lis->pdata->interrupt);
 430                         lis->flags &= ~LIS302DL_F_IRQ_WAKE;
 431                 }
 432
 433                 return count;
 434         }
 435
 436         if (sscanf(buf, "%d %d %d %d %d %d", &x, &y, &z, &threshold, &duration,
 437                         &and_events) != 6)
 438                 return -EINVAL;
 439
 440         if (duration < 0 || duration > 2550 ||
 441                         threshold < 0 || threshold > 8000)
 442                 return -ERANGE;
 443
 444         /* Interrupt flags */
 445         x_lo = x < 0 ? LIS302DL_FFWUCFG_XLIE : 0;
 446         y_lo = y < 0 ? LIS302DL_FFWUCFG_YLIE : 0;
 447         z_lo = z < 0 ? LIS302DL_FFWUCFG_ZLIE : 0;
 448         x_hi = x > 0 ? LIS302DL_FFWUCFG_XHIE : 0;
 449         y_hi = y > 0 ? LIS302DL_FFWUCFG_YHIE : 0;
 450         z_hi = z > 0 ? LIS302DL_FFWUCFG_ZHIE : 0;
 451
 452         lis->wakeup.duration = __ms_to_duration(lis, duration);
 453         lis->wakeup.threshold = __mg_to_threshold(lis, threshold);
 454         lis->wakeup.cfg = (and_events ? LIS302DL_FFWUCFG_AOI : 0) |
 455                 x_lo | x_hi | y_lo | y_hi | z_lo | z_hi;
 456
 457         if (!(lis->flags & LIS302DL_F_IRQ_WAKE)) {
 458                 enable_irq_wake(lis->pdata->interrupt);
 459                 lis->flags |= LIS302DL_F_IRQ_WAKE;
 460         }
 461         lis->wakeup.active = 1;
 462
 463         return count;
 464 }
 465
 466 static ssize_t show_wakeup(struct device *dev,
 467                 struct device_attribute *attr, char *buf)
 468 {
 469         struct lis302dl_info *lis = dev_get_drvdata(dev);
 470         u8 config;
 471
 472         /* All events off? */
 473         if (!lis->wakeup.active)
 474                 return sprintf(buf, "off\n");
 475
 476         config = lis->wakeup.cfg;
 477
 478         return sprintf(buf,
 479                         "%s events, duration %d, threshold %d, "
 480                         "enabled: %s %s %s %s %s %s\n",
 481                         (config & LIS302DL_FFWUCFG_AOI) == 0 ? "or" : "and",
 482                         __duration_to_ms(lis, lis->wakeup.duration),
 483                         __threshold_to_mg(lis, lis->wakeup.threshold),
 484                         (config & LIS302DL_FFWUCFG_XLIE) == 0 ? "---" : "xlo",
 485                         (config & LIS302DL_FFWUCFG_XHIE) == 0 ? "---" : "xhi",
 486                         (config & LIS302DL_FFWUCFG_YLIE) == 0 ? "---" : "ylo",
 487                         (config & LIS302DL_FFWUCFG_YHIE) == 0 ? "---" : "yhi",
 488                         (config & LIS302DL_FFWUCFG_ZLIE) == 0 ? "---" : "zlo",
 489                         (config & LIS302DL_FFWUCFG_ZHIE) == 0 ? "---" : "zhi");
 490 }
 491
 492 static DEVICE_ATTR(wakeup, S_IRUGO | S_IWUSR, show_wakeup, set_wakeup);
 493
 494 static struct attribute *lis302dl_sysfs_entries[] = {
 495         &dev_attr_sample_rate.attr,
 496         &dev_attr_full_scale.attr,
 497         &dev_attr_threshold.attr,
 498         &dev_attr_duration.attr,
 499         &dev_attr_dump.attr,
 500         &dev_attr_wakeup.attr,
 501         NULL
 502 };
 503
 504 static struct attribute_group lis302dl_attr_group = {
 505         .name   = NULL,
 506         .attrs  = lis302dl_sysfs_entries,
 507 };
 508
 509 /* input device handling and driver core interaction */
 510 static int lis302dl_input_open(struct input_dev *inp)
 511 {
 512         struct lis302dl_info *lis = inp->private;
 513         unsigned long flags;
 514
 515         local_irq_save(flags);
 516
 517         __enable_data_collection(lis);
 518         lis->flags |= LIS302DL_F_INPUT_OPEN;
 519
 520         /* kick it off -- since we are edge triggered, if we missed the edge
 521          * permanent low interrupt is death for us */
 522         lis302dl_bitbang_read_sample(lis);
 523
 524         local_irq_restore(flags);
 525
 526         return 0;
 527 }
 528
 529 static void lis302dl_input_close(struct input_dev *inp)
 530 {
 531         struct lis302dl_info *lis = inp->private;
 532         u_int8_t ctrl1 = LIS302DL_CTRL1_Xen | LIS302DL_CTRL1_Yen |
 533                          LIS302DL_CTRL1_Zen;
 534         unsigned long flags;
 535
 536         local_irq_save(flags);
 537
 538         /* since the input core already serializes access and makes sure we
 539          * only see close() for the close of the last user, we can safely
 540          * disable the data ready events */
 541         __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, ctrl1, 0x00);
 542         lis->flags &= ~LIS302DL_F_INPUT_OPEN;
 543
 544         /* however, don't power down the whole device if still needed */
 545         if (!(lis->flags & LIS302DL_F_WUP_FF ||
 546               lis->flags & LIS302DL_F_WUP_CLICK)) {
 547                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD,
 548                                  0x00);
 549         }
 550         local_irq_restore(flags);
 551 }
 552
 553 /* get the device to reload its coefficients from EEPROM and wait for it
 554  * to complete
 555  */
 556
 557 static int __lis302dl_reset_device(struct lis302dl_info *lis)
 558 {
 559         int timeout = 10;
 560
 561         __reg_write(lis, LIS302DL_REG_CTRL2,
 562                         LIS302DL_CTRL2_BOOT | LIS302DL_CTRL2_FDS);
 563
 564         while ((__reg_read(lis, LIS302DL_REG_CTRL2)
 565                         & LIS302DL_CTRL2_BOOT) && (timeout--))
 566                 mdelay(1);
 567
 568         return !!(timeout < 0);
 569 }
 570
 571 static int __devinit lis302dl_probe(struct platform_device *pdev)
 572 {
 573         int rc;
 574         struct lis302dl_info *lis;
 575         u_int8_t wai;
 576         unsigned long flags;
 577         struct lis302dl_platform_data *pdata = pdev->dev.platform_data;
 578
 579         lis = kzalloc(sizeof(*lis), GFP_KERNEL);
 580         if (!lis)
 581                 return -ENOMEM;
 582
 583         local_irq_save(flags);
 584
 585         lis->dev = &pdev->dev;
 586
 587         dev_set_drvdata(lis->dev, lis);
 588
 589         lis->pdata = pdata;
 590
 591         /* Configure our IO */
 592         (lis->pdata->lis302dl_suspend_io)(lis, 1);
 593
 594         wai = __reg_read(lis, LIS302DL_REG_WHO_AM_I);
 595         if (wai != LIS302DL_WHO_AM_I_MAGIC) {
 596                 dev_err(lis->dev, "unknown who_am_i signature 0x%02x\n", wai);
 597                 dev_set_drvdata(lis->dev, NULL);
 598                 rc = -ENODEV;
 599                 goto bail_free_lis;
 600         }
 601
 602         rc = sysfs_create_group(&lis->dev->kobj, &lis302dl_attr_group);
 603         if (rc) {
 604                 dev_err(lis->dev, "error creating sysfs group\n");
 605                 goto bail_free_lis;
 606         }
 607
 608         /* initialize input layer details */
 609         lis->input_dev = input_allocate_device();
 610         if (!lis->input_dev) {
 611                 dev_err(lis->dev, "Unable to allocate input device\n");
 612                 goto bail_sysfs;
 613         }
 614
 615         set_bit(EV_REL, lis->input_dev->evbit);
 616         set_bit(REL_X, lis->input_dev->relbit);
 617         set_bit(REL_Y, lis->input_dev->relbit);
 618         set_bit(REL_Z, lis->input_dev->relbit);
 619 /*      set_bit(EV_KEY, lis->input_dev->evbit);
 620         set_bit(BTN_X, lis->input_dev->keybit);
 621         set_bit(BTN_Y, lis->input_dev->keybit);
 622         set_bit(BTN_Z, lis->input_dev->keybit);
 623 */
 624         lis->threshold = 1;
 625         lis->duration = 0;
 626         memset(&lis->wakeup, 0, sizeof(lis->wakeup));
 627
 628         lis->input_dev->private = lis;
 629         lis->input_dev->name = pdata->name;
 630          /* SPI Bus not defined as a valid bus for input subsystem*/
 631         lis->input_dev->id.bustype = BUS_I2C; /* lie about it */
 632         lis->input_dev->open = lis302dl_input_open;
 633         lis->input_dev->close = lis302dl_input_close;
 634
 635         rc = input_register_device(lis->input_dev);
 636         if (rc) {
 637                 dev_err(lis->dev, "error %d registering input device\n", rc);
 638                 goto bail_inp_dev;
 639         }
 640
 641         if (__lis302dl_reset_device(lis))
 642                 dev_err(lis->dev, "device BOOT reload failed\n");
 643
 644         /* force us powered */
 645         __reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD |
 646                         LIS302DL_CTRL1_Xen |
 647                         LIS302DL_CTRL1_Yen |
 648                         LIS302DL_CTRL1_Zen);
 649         mdelay(1);
 650
 651         __reg_write(lis, LIS302DL_REG_CTRL2, 0);
 652         __reg_write(lis, LIS302DL_REG_CTRL3,
 653                         LIS302DL_CTRL3_PP_OD | LIS302DL_CTRL3_IHL);
 654         __reg_write(lis, LIS302DL_REG_FF_WU_THS_1, 0x0);
 655         __reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1, 0x00);
 656         __reg_write(lis, LIS302DL_REG_FF_WU_CFG_1, 0x0);
 657
 658         /* start off in powered down mode; we power up when someone opens us */
 659         __reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_Xen |
 660                         LIS302DL_CTRL1_Yen | LIS302DL_CTRL1_Zen);
 661
 662         if (pdata->open_drain)
 663                 /* switch interrupt to open collector, active-low */
 664                 __reg_write(lis, LIS302DL_REG_CTRL3,
 665                                 LIS302DL_CTRL3_PP_OD | LIS302DL_CTRL3_IHL);
 666         else
 667                 /* push-pull, active-low */
 668                 __reg_write(lis, LIS302DL_REG_CTRL3, LIS302DL_CTRL3_IHL);
 669
 670         __lis302dl_int_mode(lis->dev, 1, LIS302DL_INTMODE_GND);
 671         __lis302dl_int_mode(lis->dev, 2, LIS302DL_INTMODE_GND);
 672
 673         __reg_read(lis, LIS302DL_REG_STATUS);
 674         __reg_read(lis, LIS302DL_REG_FF_WU_SRC_1);
 675         __reg_read(lis, LIS302DL_REG_FF_WU_SRC_2);
 676         __reg_read(lis, LIS302DL_REG_CLICK_SRC);
 677
 678         dev_info(lis->dev, "Found %s\n", pdata->name);
 679
 680         lis->pdata = pdata;
 681
 682         rc = request_irq(pdata->interrupt, lis302dl_interrupt,
 683                          IRQF_TRIGGER_FALLING, "lis302dl", lis);
 684         if (rc < 0) {
 685                 dev_err(lis->dev, "error requesting IRQ %d\n",
 686                         lis->pdata->interrupt);
 687                 goto bail_inp_reg;
 688         }
 689         local_irq_restore(flags);
 690         return 0;
 691
 692 bail_inp_reg:
 693         input_unregister_device(lis->input_dev);
 694 bail_inp_dev:
 695         input_free_device(lis->input_dev);
 696 bail_sysfs:
 697         sysfs_remove_group(&lis->dev->kobj, &lis302dl_attr_group);
 698 bail_free_lis:
 699         kfree(lis);
 700         local_irq_restore(flags);
 701         return rc;
 702 }
 703
 704 static int __devexit lis302dl_remove(struct platform_device *pdev)
 705 {
 706         struct lis302dl_info *lis = dev_get_drvdata(&pdev->dev);
 707         unsigned long flags;
 708
 709         /* Reset and power down the device */
 710         local_irq_save(flags);
 711         __reg_write(lis, LIS302DL_REG_CTRL3, 0x00);
 712         __reg_write(lis, LIS302DL_REG_CTRL2, 0x00);
 713         __reg_write(lis, LIS302DL_REG_CTRL1, 0x00);
 714         local_irq_restore(flags);
 715
 716         /* Cleanup resources */
 717         free_irq(lis->pdata->interrupt, lis);
 718         sysfs_remove_group(&pdev->dev.kobj, &lis302dl_attr_group);
 719         input_unregister_device(lis->input_dev);
 720         if (lis->input_dev)
 721                 input_free_device(lis->input_dev);
 722         dev_set_drvdata(lis->dev, NULL);
 723         kfree(lis);
 724
 725         return 0;
 726 }
 727
 728 #ifdef CONFIG_PM
 729
 730 static u8 regs_to_save[] = {
 731         LIS302DL_REG_CTRL1,
 732         LIS302DL_REG_CTRL2,
 733         LIS302DL_REG_CTRL3,
 734         LIS302DL_REG_FF_WU_CFG_1,
 735         LIS302DL_REG_FF_WU_THS_1,
 736         LIS302DL_REG_FF_WU_DURATION_1,
 737         LIS302DL_REG_FF_WU_CFG_2,
 738         LIS302DL_REG_FF_WU_THS_2,
 739         LIS302DL_REG_FF_WU_DURATION_2,
 740         LIS302DL_REG_CLICK_CFG,
 741         LIS302DL_REG_CLICK_THSY_X,
 742         LIS302DL_REG_CLICK_THSZ,
 743         LIS302DL_REG_CLICK_TIME_LIMIT,
 744         LIS302DL_REG_CLICK_LATENCY,
 745         LIS302DL_REG_CLICK_WINDOW,
 746
 747 };
 748
 749 static int lis302dl_suspend(struct platform_device *pdev, pm_message_t state)
 750 {
 751         struct lis302dl_info *lis = dev_get_drvdata(&pdev->dev);
 752         unsigned long flags;
 753         u_int8_t tmp;
 754         int n;
 755
 756         /* determine if we want to wake up from the accel. */
 757         if (lis->flags & LIS302DL_F_WUP_CLICK)
 758                 return 0;
 759
 760         disable_irq(lis->pdata->interrupt);
 761         local_irq_save(flags);
 762
 763         /*
 764          * When we share SPI over multiple sensors, there is a race here
 765          * that one or more sensors will lose.  In that case, the shared
 766          * SPI bus GPIO will be in sleep mode and partially pulled down.  So
 767          * we explicitly put our IO into "wake" mode here before the final
 768          * traffic to the sensor.
 769          */
 770         (lis->pdata->lis302dl_suspend_io)(lis, 1);
 771
 772         /* save registers */
 773         for (n = 0; n < ARRAY_SIZE(regs_to_save); n++)
 774                 lis->regs[regs_to_save[n]] =
 775                         __reg_read(lis, regs_to_save[n]);
 776
 777         /* power down or enable wakeup */
 778         if (!lis->wakeup.active) {
 779                 tmp = __reg_read(lis, LIS302DL_REG_CTRL1);
 780                 tmp &= ~LIS302DL_CTRL1_PD;
 781                 __reg_write(lis, LIS302DL_REG_CTRL1, tmp);
 782         } else
 783                 __enable_wakeup(lis);
 784
 785         /* place our IO to the device in sleep-compatible states */
 786         (lis->pdata->lis302dl_suspend_io)(lis, 0);
 787
 788         local_irq_restore(flags);
 789
 790         return 0;
 791 }
 792
 793 static int lis302dl_resume(struct platform_device *pdev)
 794 {
 795         struct lis302dl_info *lis = dev_get_drvdata(&pdev->dev);
 796         unsigned long flags;
 797         int n;
 798
 799         if (lis->flags & LIS302DL_F_WUP_CLICK)
 800                 return 0;
 801
 802         local_irq_save(flags);
 803
 804         /* get our IO to the device back in operational states */
 805         (lis->pdata->lis302dl_suspend_io)(lis, 1);
 806
 807         /* resume from powerdown first! */
 808         __reg_write(lis, LIS302DL_REG_CTRL1,
 809                         LIS302DL_CTRL1_PD |
 810                         LIS302DL_CTRL1_Xen |
 811                         LIS302DL_CTRL1_Yen |
 812                         LIS302DL_CTRL1_Zen);
 813         mdelay(1);
 814
 815         if (__lis302dl_reset_device(lis))
 816                 dev_err(&pdev->dev, "device BOOT reload failed\n");
 817
 818         lis->regs[LIS302DL_REG_CTRL1] |=        LIS302DL_CTRL1_PD |
 819                                                 LIS302DL_CTRL1_Xen |
 820                                                 LIS302DL_CTRL1_Yen |
 821                                                 LIS302DL_CTRL1_Zen;
 822
 823         /* restore registers after resume */
 824         for (n = 0; n < ARRAY_SIZE(regs_to_save); n++)
 825                 __reg_write(lis, regs_to_save[n], lis->regs[regs_to_save[n]]);
 826
 827         local_irq_restore(flags);
 828         enable_irq(lis->pdata->interrupt);
 829
 830         return 0;
 831 }
 832 #else
 833 #define lis302dl_suspend        NULL
 834 #define lis302dl_resume         NULL
 835 #endif
 836
 837 static struct platform_driver lis302dl_driver = {
 838         .driver = {
 839                 .name   = "lis302dl",
 840                 .owner  = THIS_MODULE,
 841         },
 842
 843         .probe   = lis302dl_probe,
 844         .remove  = __devexit_p(lis302dl_remove),
 845         .suspend = lis302dl_suspend,
 846         .resume  = lis302dl_resume,
 847 };
 848
 849 static int __devinit lis302dl_init(void)
 850 {
 851         return platform_driver_register(&lis302dl_driver);
 852 }
 853
 854 static void __exit lis302dl_exit(void)
 855 {
 856         platform_driver_unregister(&lis302dl_driver);
 857 }
 858
 859 MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
 860 MODULE_LICENSE("GPL");
 861
 862 module_init(lis302dl_init);
 863 module_exit(lis302dl_exit);