drivers/input/misc/adxl34x.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * ADXL345/346 Three-Axis Digital Accelerometers
   4  *
   5  * Enter bugs at http://blackfin.uclinux.org/
   6  *
   7  * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
   8  */
   9
  10 #include <linux/device.h>
  11 #include <linux/delay.h>
  12 #include <linux/input.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/irq.h>
  15 #include <linux/slab.h>
  16 #include <linux/workqueue.h>
  17 #include <linux/input/adxl34x.h>
  18 #include <linux/module.h>
  19
  20 #include "adxl34x.h"
  21
  22 /* ADXL345/6 Register Map */
  23 #define DEVID           0x00    /* R   Device ID */
  24 #define THRESH_TAP      0x1D    /* R/W Tap threshold */
  25 #define OFSX            0x1E    /* R/W X-axis offset */
  26 #define OFSY            0x1F    /* R/W Y-axis offset */
  27 #define OFSZ            0x20    /* R/W Z-axis offset */
  28 #define DUR             0x21    /* R/W Tap duration */
  29 #define LATENT          0x22    /* R/W Tap latency */
  30 #define WINDOW          0x23    /* R/W Tap window */
  31 #define THRESH_ACT      0x24    /* R/W Activity threshold */
  32 #define THRESH_INACT    0x25    /* R/W Inactivity threshold */
  33 #define TIME_INACT      0x26    /* R/W Inactivity time */
  34 #define ACT_INACT_CTL   0x27    /* R/W Axis enable control for activity and */
  35                                 /* inactivity detection */
  36 #define THRESH_FF       0x28    /* R/W Free-fall threshold */
  37 #define TIME_FF         0x29    /* R/W Free-fall time */
  38 #define TAP_AXES        0x2A    /* R/W Axis control for tap/double tap */
  39 #define ACT_TAP_STATUS  0x2B    /* R   Source of tap/double tap */
  40 #define BW_RATE         0x2C    /* R/W Data rate and power mode control */
  41 #define POWER_CTL       0x2D    /* R/W Power saving features control */
  42 #define INT_ENABLE      0x2E    /* R/W Interrupt enable control */
  43 #define INT_MAP         0x2F    /* R/W Interrupt mapping control */
  44 #define INT_SOURCE      0x30    /* R   Source of interrupts */
  45 #define DATA_FORMAT     0x31    /* R/W Data format control */
  46 #define DATAX0          0x32    /* R   X-Axis Data 0 */
  47 #define DATAX1          0x33    /* R   X-Axis Data 1 */
  48 #define DATAY0          0x34    /* R   Y-Axis Data 0 */
  49 #define DATAY1          0x35    /* R   Y-Axis Data 1 */
  50 #define DATAZ0          0x36    /* R   Z-Axis Data 0 */
  51 #define DATAZ1          0x37    /* R   Z-Axis Data 1 */
  52 #define FIFO_CTL        0x38    /* R/W FIFO control */
  53 #define FIFO_STATUS     0x39    /* R   FIFO status */
  54 #define TAP_SIGN        0x3A    /* R   Sign and source for tap/double tap */
  55 /* Orientation ADXL346 only */
  56 #define ORIENT_CONF     0x3B    /* R/W Orientation configuration */
  57 #define ORIENT          0x3C    /* R   Orientation status */
  58
  59 /* DEVIDs */
  60 #define ID_ADXL345      0xE5
  61 #define ID_ADXL346      0xE6
  62
  63 /* INT_ENABLE/INT_MAP/INT_SOURCE Bits */
  64 #define DATA_READY      (1 << 7)
  65 #define SINGLE_TAP      (1 << 6)
  66 #define DOUBLE_TAP      (1 << 5)
  67 #define ACTIVITY        (1 << 4)
  68 #define INACTIVITY      (1 << 3)
  69 #define FREE_FALL       (1 << 2)
  70 #define WATERMARK       (1 << 1)
  71 #define OVERRUN         (1 << 0)
  72
  73 /* ACT_INACT_CONTROL Bits */
  74 #define ACT_ACDC        (1 << 7)
  75 #define ACT_X_EN        (1 << 6)
  76 #define ACT_Y_EN        (1 << 5)
  77 #define ACT_Z_EN        (1 << 4)
  78 #define INACT_ACDC      (1 << 3)
  79 #define INACT_X_EN      (1 << 2)
  80 #define INACT_Y_EN      (1 << 1)
  81 #define INACT_Z_EN      (1 << 0)
  82
  83 /* TAP_AXES Bits */
  84 #define SUPPRESS        (1 << 3)
  85 #define TAP_X_EN        (1 << 2)
  86 #define TAP_Y_EN        (1 << 1)
  87 #define TAP_Z_EN        (1 << 0)
  88
  89 /* ACT_TAP_STATUS Bits */
  90 #define ACT_X_SRC       (1 << 6)
  91 #define ACT_Y_SRC       (1 << 5)
  92 #define ACT_Z_SRC       (1 << 4)
  93 #define ASLEEP          (1 << 3)
  94 #define TAP_X_SRC       (1 << 2)
  95 #define TAP_Y_SRC       (1 << 1)
  96 #define TAP_Z_SRC       (1 << 0)
  97
  98 /* BW_RATE Bits */
  99 #define LOW_POWER       (1 << 4)
 100 #define RATE(x)         ((x) & 0xF)
 101
 102 /* POWER_CTL Bits */
 103 #define PCTL_LINK       (1 << 5)
 104 #define PCTL_AUTO_SLEEP (1 << 4)
 105 #define PCTL_MEASURE    (1 << 3)
 106 #define PCTL_SLEEP      (1 << 2)
 107 #define PCTL_WAKEUP(x)  ((x) & 0x3)
 108
 109 /* DATA_FORMAT Bits */
 110 #define SELF_TEST       (1 << 7)
 111 #define SPI             (1 << 6)
 112 #define INT_INVERT      (1 << 5)
 113 #define FULL_RES        (1 << 3)
 114 #define JUSTIFY         (1 << 2)
 115 #define RANGE(x)        ((x) & 0x3)
 116 #define RANGE_PM_2g     0
 117 #define RANGE_PM_4g     1
 118 #define RANGE_PM_8g     2
 119 #define RANGE_PM_16g    3
 120
 121 /*
 122  * Maximum value our axis may get in full res mode for the input device
 123  * (signed 13 bits)
 124  */
 125 #define ADXL_FULLRES_MAX_VAL 4096
 126
 127 /*
 128  * Maximum value our axis may get in fixed res mode for the input device
 129  * (signed 10 bits)
 130  */
 131 #define ADXL_FIXEDRES_MAX_VAL 512
 132
 133 /* FIFO_CTL Bits */
 134 #define FIFO_MODE(x)    (((x) & 0x3) << 6)
 135 #define FIFO_BYPASS     0
 136 #define FIFO_FIFO       1
 137 #define FIFO_STREAM     2
 138 #define FIFO_TRIGGER    3
 139 #define TRIGGER         (1 << 5)
 140 #define SAMPLES(x)      ((x) & 0x1F)
 141
 142 /* FIFO_STATUS Bits */
 143 #define FIFO_TRIG       (1 << 7)
 144 #define ENTRIES(x)      ((x) & 0x3F)
 145
 146 /* TAP_SIGN Bits ADXL346 only */
 147 #define XSIGN           (1 << 6)
 148 #define YSIGN           (1 << 5)
 149 #define ZSIGN           (1 << 4)
 150 #define XTAP            (1 << 3)
 151 #define YTAP            (1 << 2)
 152 #define ZTAP            (1 << 1)
 153
 154 /* ORIENT_CONF ADXL346 only */
 155 #define ORIENT_DEADZONE(x)      (((x) & 0x7) << 4)
 156 #define ORIENT_DIVISOR(x)       ((x) & 0x7)
 157
 158 /* ORIENT ADXL346 only */
 159 #define ADXL346_2D_VALID                (1 << 6)
 160 #define ADXL346_2D_ORIENT(x)            (((x) & 0x30) >> 4)
 161 #define ADXL346_3D_VALID                (1 << 3)
 162 #define ADXL346_3D_ORIENT(x)            ((x) & 0x7)
 163 #define ADXL346_2D_PORTRAIT_POS         0       /* +X */
 164 #define ADXL346_2D_PORTRAIT_NEG         1       /* -X */
 165 #define ADXL346_2D_LANDSCAPE_POS        2       /* +Y */
 166 #define ADXL346_2D_LANDSCAPE_NEG        3       /* -Y */
 167
 168 #define ADXL346_3D_FRONT                3       /* +X */
 169 #define ADXL346_3D_BACK                 4       /* -X */
 170 #define ADXL346_3D_RIGHT                2       /* +Y */
 171 #define ADXL346_3D_LEFT                 5       /* -Y */
 172 #define ADXL346_3D_TOP                  1       /* +Z */
 173 #define ADXL346_3D_BOTTOM               6       /* -Z */
 174
 175 #undef ADXL_DEBUG
 176
 177 #define ADXL_X_AXIS                     0
 178 #define ADXL_Y_AXIS                     1
 179 #define ADXL_Z_AXIS                     2
 180
 181 #define AC_READ(ac, reg)        ((ac)->bops->read((ac)->dev, reg))
 182 #define AC_WRITE(ac, reg, val)  ((ac)->bops->write((ac)->dev, reg, val))
 183
 184 struct axis_triple {
 185         int x;
 186         int y;
 187         int z;
 188 };
 189
 190 struct adxl34x {
 191         struct device *dev;
 192         struct input_dev *input;
 193         struct mutex mutex;     /* reentrant protection for struct */
 194         struct adxl34x_platform_data pdata;
 195         struct axis_triple swcal;
 196         struct axis_triple hwcal;
 197         struct axis_triple saved;
 198         char phys[32];
 199         unsigned orient2d_saved;
 200         unsigned orient3d_saved;
 201         bool disabled;  /* P: mutex */
 202         bool opened;    /* P: mutex */
 203         bool suspended; /* P: mutex */
 204         bool fifo_delay;
 205         int irq;
 206         unsigned model;
 207         unsigned int_mask;
 208
 209         const struct adxl34x_bus_ops *bops;
 210 };
 211
 212 static const struct adxl34x_platform_data adxl34x_default_init = {
 213         .tap_threshold = 35,
 214         .tap_duration = 3,
 215         .tap_latency = 20,
 216         .tap_window = 20,
 217         .tap_axis_control = ADXL_TAP_X_EN | ADXL_TAP_Y_EN | ADXL_TAP_Z_EN,
 218         .act_axis_control = 0xFF,
 219         .activity_threshold = 6,
 220         .inactivity_threshold = 4,
 221         .inactivity_time = 3,
 222         .free_fall_threshold = 8,
 223         .free_fall_time = 0x20,
 224         .data_rate = 8,
 225         .data_range = ADXL_FULL_RES,
 226
 227         .ev_type = EV_ABS,
 228         .ev_code_x = ABS_X,     /* EV_REL */
 229         .ev_code_y = ABS_Y,     /* EV_REL */
 230         .ev_code_z = ABS_Z,     /* EV_REL */
 231
 232         .ev_code_tap = {BTN_TOUCH, BTN_TOUCH, BTN_TOUCH}, /* EV_KEY {x,y,z} */
 233         .power_mode = ADXL_AUTO_SLEEP | ADXL_LINK,
 234         .fifo_mode = ADXL_FIFO_STREAM,
 235         .watermark = 0,
 236 };
 237
 238 static void adxl34x_get_triple(struct adxl34x *ac, struct axis_triple *axis)
 239 {
 240         __le16 buf[3];
 241
 242         ac->bops->read_block(ac->dev, DATAX0, DATAZ1 - DATAX0 + 1, buf);
 243
 244         mutex_lock(&ac->mutex);
 245         ac->saved.x = (s16) le16_to_cpu(buf[0]);
 246         axis->x = ac->saved.x;
 247
 248         ac->saved.y = (s16) le16_to_cpu(buf[1]);
 249         axis->y = ac->saved.y;
 250
 251         ac->saved.z = (s16) le16_to_cpu(buf[2]);
 252         axis->z = ac->saved.z;
 253         mutex_unlock(&ac->mutex);
 254 }
 255
 256 static void adxl34x_service_ev_fifo(struct adxl34x *ac)
 257 {
 258         struct adxl34x_platform_data *pdata = &ac->pdata;
 259         struct axis_triple axis;
 260
 261         adxl34x_get_triple(ac, &axis);
 262
 263         input_event(ac->input, pdata->ev_type, pdata->ev_code_x,
 264                     axis.x - ac->swcal.x);
 265         input_event(ac->input, pdata->ev_type, pdata->ev_code_y,
 266                     axis.y - ac->swcal.y);
 267         input_event(ac->input, pdata->ev_type, pdata->ev_code_z,
 268                     axis.z - ac->swcal.z);
 269 }
 270
 271 static void adxl34x_report_key_single(struct input_dev *input, int key)
 272 {
 273         input_report_key(input, key, true);
 274         input_sync(input);
 275         input_report_key(input, key, false);
 276 }
 277
 278 static void adxl34x_send_key_events(struct adxl34x *ac,
 279                 struct adxl34x_platform_data *pdata, int status, int press)
 280 {
 281         int i;
 282
 283         for (i = ADXL_X_AXIS; i <= ADXL_Z_AXIS; i++) {
 284                 if (status & (1 << (ADXL_Z_AXIS - i)))
 285                         input_report_key(ac->input,
 286                                          pdata->ev_code_tap[i], press);
 287         }
 288 }
 289
 290 static void adxl34x_do_tap(struct adxl34x *ac,
 291                 struct adxl34x_platform_data *pdata, int status)
 292 {
 293         adxl34x_send_key_events(ac, pdata, status, true);
 294         input_sync(ac->input);
 295         adxl34x_send_key_events(ac, pdata, status, false);
 296 }
 297
 298 static irqreturn_t adxl34x_irq(int irq, void *handle)
 299 {
 300         struct adxl34x *ac = handle;
 301         struct adxl34x_platform_data *pdata = &ac->pdata;
 302         int int_stat, tap_stat, samples, orient, orient_code;
 303
 304         /*
 305          * ACT_TAP_STATUS should be read before clearing the interrupt
 306          * Avoid reading ACT_TAP_STATUS in case TAP detection is disabled
 307          */
 308
 309         if (pdata->tap_axis_control & (TAP_X_EN | TAP_Y_EN | TAP_Z_EN))
 310                 tap_stat = AC_READ(ac, ACT_TAP_STATUS);
 311         else
 312                 tap_stat = 0;
 313
 314         int_stat = AC_READ(ac, INT_SOURCE);
 315
 316         if (int_stat & FREE_FALL)
 317                 adxl34x_report_key_single(ac->input, pdata->ev_code_ff);
 318
 319         if (int_stat & OVERRUN)
 320                 dev_dbg(ac->dev, "OVERRUN\n");
 321
 322         if (int_stat & (SINGLE_TAP | DOUBLE_TAP)) {
 323                 adxl34x_do_tap(ac, pdata, tap_stat);
 324
 325                 if (int_stat & DOUBLE_TAP)
 326                         adxl34x_do_tap(ac, pdata, tap_stat);
 327         }
 328
 329         if (pdata->ev_code_act_inactivity) {
 330                 if (int_stat & ACTIVITY)
 331                         input_report_key(ac->input,
 332                                          pdata->ev_code_act_inactivity, 1);
 333                 if (int_stat & INACTIVITY)
 334                         input_report_key(ac->input,
 335                                          pdata->ev_code_act_inactivity, 0);
 336         }
 337
 338         /*
 339          * ORIENTATION SENSING ADXL346 only
 340          */
 341         if (pdata->orientation_enable) {
 342                 orient = AC_READ(ac, ORIENT);
 343                 if ((pdata->orientation_enable & ADXL_EN_ORIENTATION_2D) &&
 344                     (orient & ADXL346_2D_VALID)) {
 345
 346                         orient_code = ADXL346_2D_ORIENT(orient);
 347                         /* Report orientation only when it changes */
 348                         if (ac->orient2d_saved != orient_code) {
 349                                 ac->orient2d_saved = orient_code;
 350                                 adxl34x_report_key_single(ac->input,
 351                                         pdata->ev_codes_orient_2d[orient_code]);
 352                         }
 353                 }
 354
 355                 if ((pdata->orientation_enable & ADXL_EN_ORIENTATION_3D) &&
 356                     (orient & ADXL346_3D_VALID)) {
 357
 358                         orient_code = ADXL346_3D_ORIENT(orient) - 1;
 359                         /* Report orientation only when it changes */
 360                         if (ac->orient3d_saved != orient_code) {
 361                                 ac->orient3d_saved = orient_code;
 362                                 adxl34x_report_key_single(ac->input,
 363                                         pdata->ev_codes_orient_3d[orient_code]);
 364                         }
 365                 }
 366         }
 367
 368         if (int_stat & (DATA_READY | WATERMARK)) {
 369
 370                 if (pdata->fifo_mode)
 371                         samples = ENTRIES(AC_READ(ac, FIFO_STATUS)) + 1;
 372                 else
 373                         samples = 1;
 374
 375                 for (; samples > 0; samples--) {
 376                         adxl34x_service_ev_fifo(ac);
 377                         /*
 378                          * To ensure that the FIFO has
 379                          * completely popped, there must be at least 5 us between
 380                          * the end of reading the data registers, signified by the
 381                          * transition to register 0x38 from 0x37 or the CS pin
 382                          * going high, and the start of new reads of the FIFO or
 383                          * reading the FIFO_STATUS register. For SPI operation at
 384                          * 1.5 MHz or lower, the register addressing portion of the
 385                          * transmission is sufficient delay to ensure the FIFO has
 386                          * completely popped. It is necessary for SPI operation
 387                          * greater than 1.5 MHz to de-assert the CS pin to ensure a
 388                          * total of 5 us, which is at most 3.4 us at 5 MHz
 389                          * operation.
 390                          */
 391                         if (ac->fifo_delay && (samples > 1))
 392                                 udelay(3);
 393                 }
 394         }
 395
 396         input_sync(ac->input);
 397
 398         return IRQ_HANDLED;
 399 }
 400
 401 static void __adxl34x_disable(struct adxl34x *ac)
 402 {
 403         /*
 404          * A '0' places the ADXL34x into standby mode
 405          * with minimum power consumption.
 406          */
 407         AC_WRITE(ac, POWER_CTL, 0);
 408 }
 409
 410 static void __adxl34x_enable(struct adxl34x *ac)
 411 {
 412         AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
 413 }
 414
 415 static int adxl34x_suspend(struct device *dev)
 416 {
 417         struct adxl34x *ac = dev_get_drvdata(dev);
 418
 419         mutex_lock(&ac->mutex);
 420
 421         if (!ac->suspended && !ac->disabled && ac->opened)
 422                 __adxl34x_disable(ac);
 423
 424         ac->suspended = true;
 425
 426         mutex_unlock(&ac->mutex);
 427
 428         return 0;
 429 }
 430
 431 static int adxl34x_resume(struct device *dev)
 432 {
 433         struct adxl34x *ac = dev_get_drvdata(dev);
 434
 435         mutex_lock(&ac->mutex);
 436
 437         if (ac->suspended && !ac->disabled && ac->opened)
 438                 __adxl34x_enable(ac);
 439
 440         ac->suspended = false;
 441
 442         mutex_unlock(&ac->mutex);
 443
 444         return 0;
 445 }
 446
 447 static ssize_t adxl34x_disable_show(struct device *dev,
 448                                     struct device_attribute *attr, char *buf)
 449 {
 450         struct adxl34x *ac = dev_get_drvdata(dev);
 451
 452         return sprintf(buf, "%u\n", ac->disabled);
 453 }
 454
 455 static ssize_t adxl34x_disable_store(struct device *dev,
 456                                      struct device_attribute *attr,
 457                                      const char *buf, size_t count)
 458 {
 459         struct adxl34x *ac = dev_get_drvdata(dev);
 460         unsigned int val;
 461         int error;
 462
 463         error = kstrtouint(buf, 10, &val);
 464         if (error)
 465                 return error;
 466
 467         mutex_lock(&ac->mutex);
 468
 469         if (!ac->suspended && ac->opened) {
 470                 if (val) {
 471                         if (!ac->disabled)
 472                                 __adxl34x_disable(ac);
 473                 } else {
 474                         if (ac->disabled)
 475                                 __adxl34x_enable(ac);
 476                 }
 477         }
 478
 479         ac->disabled = !!val;
 480
 481         mutex_unlock(&ac->mutex);
 482
 483         return count;
 484 }
 485
 486 static DEVICE_ATTR(disable, 0664, adxl34x_disable_show, adxl34x_disable_store);
 487
 488 static ssize_t adxl34x_calibrate_show(struct device *dev,
 489                                       struct device_attribute *attr, char *buf)
 490 {
 491         struct adxl34x *ac = dev_get_drvdata(dev);
 492         ssize_t count;
 493
 494         mutex_lock(&ac->mutex);
 495         count = sprintf(buf, "%d,%d,%d\n",
 496                         ac->hwcal.x * 4 + ac->swcal.x,
 497                         ac->hwcal.y * 4 + ac->swcal.y,
 498                         ac->hwcal.z * 4 + ac->swcal.z);
 499         mutex_unlock(&ac->mutex);
 500
 501         return count;
 502 }
 503
 504 static ssize_t adxl34x_calibrate_store(struct device *dev,
 505                                        struct device_attribute *attr,
 506                                        const char *buf, size_t count)
 507 {
 508         struct adxl34x *ac = dev_get_drvdata(dev);
 509
 510         /*
 511          * Hardware offset calibration has a resolution of 15.6 mg/LSB.
 512          * We use HW calibration and handle the remaining bits in SW. (4mg/LSB)
 513          */
 514
 515         mutex_lock(&ac->mutex);
 516         ac->hwcal.x -= (ac->saved.x / 4);
 517         ac->swcal.x = ac->saved.x % 4;
 518
 519         ac->hwcal.y -= (ac->saved.y / 4);
 520         ac->swcal.y = ac->saved.y % 4;
 521
 522         ac->hwcal.z -= (ac->saved.z / 4);
 523         ac->swcal.z = ac->saved.z % 4;
 524
 525         AC_WRITE(ac, OFSX, (s8) ac->hwcal.x);
 526         AC_WRITE(ac, OFSY, (s8) ac->hwcal.y);
 527         AC_WRITE(ac, OFSZ, (s8) ac->hwcal.z);
 528         mutex_unlock(&ac->mutex);
 529
 530         return count;
 531 }
 532
 533 static DEVICE_ATTR(calibrate, 0664,
 534                    adxl34x_calibrate_show, adxl34x_calibrate_store);
 535
 536 static ssize_t adxl34x_rate_show(struct device *dev,
 537                                  struct device_attribute *attr, char *buf)
 538 {
 539         struct adxl34x *ac = dev_get_drvdata(dev);
 540
 541         return sprintf(buf, "%u\n", RATE(ac->pdata.data_rate));
 542 }
 543
 544 static ssize_t adxl34x_rate_store(struct device *dev,
 545                                   struct device_attribute *attr,
 546                                   const char *buf, size_t count)
 547 {
 548         struct adxl34x *ac = dev_get_drvdata(dev);
 549         unsigned char val;
 550         int error;
 551
 552         error = kstrtou8(buf, 10, &val);
 553         if (error)
 554                 return error;
 555
 556         mutex_lock(&ac->mutex);
 557
 558         ac->pdata.data_rate = RATE(val);
 559         AC_WRITE(ac, BW_RATE,
 560                  ac->pdata.data_rate |
 561                         (ac->pdata.low_power_mode ? LOW_POWER : 0));
 562
 563         mutex_unlock(&ac->mutex);
 564
 565         return count;
 566 }
 567
 568 static DEVICE_ATTR(rate, 0664, adxl34x_rate_show, adxl34x_rate_store);
 569
 570 static ssize_t adxl34x_autosleep_show(struct device *dev,
 571                                  struct device_attribute *attr, char *buf)
 572 {
 573         struct adxl34x *ac = dev_get_drvdata(dev);
 574
 575         return sprintf(buf, "%u\n",
 576                 ac->pdata.power_mode & (PCTL_AUTO_SLEEP | PCTL_LINK) ? 1 : 0);
 577 }
 578
 579 static ssize_t adxl34x_autosleep_store(struct device *dev,
 580                                   struct device_attribute *attr,
 581                                   const char *buf, size_t count)
 582 {
 583         struct adxl34x *ac = dev_get_drvdata(dev);
 584         unsigned int val;
 585         int error;
 586
 587         error = kstrtouint(buf, 10, &val);
 588         if (error)
 589                 return error;
 590
 591         mutex_lock(&ac->mutex);
 592
 593         if (val)
 594                 ac->pdata.power_mode |= (PCTL_AUTO_SLEEP | PCTL_LINK);
 595         else
 596                 ac->pdata.power_mode &= ~(PCTL_AUTO_SLEEP | PCTL_LINK);
 597
 598         if (!ac->disabled && !ac->suspended && ac->opened)
 599                 AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
 600
 601         mutex_unlock(&ac->mutex);
 602
 603         return count;
 604 }
 605
 606 static DEVICE_ATTR(autosleep, 0664,
 607                    adxl34x_autosleep_show, adxl34x_autosleep_store);
 608
 609 static ssize_t adxl34x_position_show(struct device *dev,
 610                                  struct device_attribute *attr, char *buf)
 611 {
 612         struct adxl34x *ac = dev_get_drvdata(dev);
 613         ssize_t count;
 614
 615         mutex_lock(&ac->mutex);
 616         count = sprintf(buf, "(%d, %d, %d)\n",
 617                         ac->saved.x, ac->saved.y, ac->saved.z);
 618         mutex_unlock(&ac->mutex);
 619
 620         return count;
 621 }
 622
 623 static DEVICE_ATTR(position, S_IRUGO, adxl34x_position_show, NULL);
 624
 625 #ifdef ADXL_DEBUG
 626 static ssize_t adxl34x_write_store(struct device *dev,
 627                                    struct device_attribute *attr,
 628                                    const char *buf, size_t count)
 629 {
 630         struct adxl34x *ac = dev_get_drvdata(dev);
 631         unsigned int val;
 632         int error;
 633
 634         /*
 635          * This allows basic ADXL register write access for debug purposes.
 636          */
 637         error = kstrtouint(buf, 16, &val);
 638         if (error)
 639                 return error;
 640
 641         mutex_lock(&ac->mutex);
 642         AC_WRITE(ac, val >> 8, val & 0xFF);
 643         mutex_unlock(&ac->mutex);
 644
 645         return count;
 646 }
 647
 648 static DEVICE_ATTR(write, 0664, NULL, adxl34x_write_store);
 649 #endif
 650
 651 static struct attribute *adxl34x_attributes[] = {
 652         &dev_attr_disable.attr,
 653         &dev_attr_calibrate.attr,
 654         &dev_attr_rate.attr,
 655         &dev_attr_autosleep.attr,
 656         &dev_attr_position.attr,
 657 #ifdef ADXL_DEBUG
 658         &dev_attr_write.attr,
 659 #endif
 660         NULL
 661 };
 662
 663 static const struct attribute_group adxl34x_attr_group = {
 664         .attrs = adxl34x_attributes,
 665 };
 666
 667 static int adxl34x_input_open(struct input_dev *input)
 668 {
 669         struct adxl34x *ac = input_get_drvdata(input);
 670
 671         mutex_lock(&ac->mutex);
 672
 673         if (!ac->suspended && !ac->disabled)
 674                 __adxl34x_enable(ac);
 675
 676         ac->opened = true;
 677
 678         mutex_unlock(&ac->mutex);
 679
 680         return 0;
 681 }
 682
 683 static void adxl34x_input_close(struct input_dev *input)
 684 {
 685         struct adxl34x *ac = input_get_drvdata(input);
 686
 687         mutex_lock(&ac->mutex);
 688
 689         if (!ac->suspended && !ac->disabled)
 690                 __adxl34x_disable(ac);
 691
 692         ac->opened = false;
 693
 694         mutex_unlock(&ac->mutex);
 695 }
 696
 697 struct adxl34x *adxl34x_probe(struct device *dev, int irq,
 698                               bool fifo_delay_default,
 699                               const struct adxl34x_bus_ops *bops)
 700 {
 701         struct adxl34x *ac;
 702         struct input_dev *input_dev;
 703         const struct adxl34x_platform_data *pdata;
 704         int err, range, i;
 705         int revid;
 706
 707         if (!irq) {
 708                 dev_err(dev, "no IRQ?\n");
 709                 err = -ENODEV;
 710                 goto err_out;
 711         }
 712
 713         ac = kzalloc(sizeof(*ac), GFP_KERNEL);
 714         input_dev = input_allocate_device();
 715         if (!ac || !input_dev) {
 716                 err = -ENOMEM;
 717                 goto err_free_mem;
 718         }
 719
 720         ac->fifo_delay = fifo_delay_default;
 721
 722         pdata = dev_get_platdata(dev);
 723         if (!pdata) {
 724                 dev_dbg(dev,
 725                         "No platform data: Using default initialization\n");
 726                 pdata = &adxl34x_default_init;
 727         }
 728
 729         ac->pdata = *pdata;
 730         pdata = &ac->pdata;
 731
 732         ac->input = input_dev;
 733         ac->dev = dev;
 734         ac->irq = irq;
 735         ac->bops = bops;
 736
 737         mutex_init(&ac->mutex);
 738
 739         input_dev->name = "ADXL34x accelerometer";
 740         revid = AC_READ(ac, DEVID);
 741
 742         switch (revid) {
 743         case ID_ADXL345:
 744                 ac->model = 345;
 745                 break;
 746         case ID_ADXL346:
 747                 ac->model = 346;
 748                 break;
 749         default:
 750                 dev_err(dev, "Failed to probe %s\n", input_dev->name);
 751                 err = -ENODEV;
 752                 goto err_free_mem;
 753         }
 754
 755         snprintf(ac->phys, sizeof(ac->phys), "%s/input0", dev_name(dev));
 756
 757         input_dev->phys = ac->phys;
 758         input_dev->dev.parent = dev;
 759         input_dev->id.product = ac->model;
 760         input_dev->id.bustype = bops->bustype;
 761         input_dev->open = adxl34x_input_open;
 762         input_dev->close = adxl34x_input_close;
 763
 764         input_set_drvdata(input_dev, ac);
 765
 766         __set_bit(ac->pdata.ev_type, input_dev->evbit);
 767
 768         if (ac->pdata.ev_type == EV_REL) {
 769                 __set_bit(REL_X, input_dev->relbit);
 770                 __set_bit(REL_Y, input_dev->relbit);
 771                 __set_bit(REL_Z, input_dev->relbit);
 772         } else {
 773                 /* EV_ABS */
 774                 __set_bit(ABS_X, input_dev->absbit);
 775                 __set_bit(ABS_Y, input_dev->absbit);
 776                 __set_bit(ABS_Z, input_dev->absbit);
 777
 778                 if (pdata->data_range & FULL_RES)
 779                         range = ADXL_FULLRES_MAX_VAL;   /* Signed 13-bit */
 780                 else
 781                         range = ADXL_FIXEDRES_MAX_VAL;  /* Signed 10-bit */
 782
 783                 input_set_abs_params(input_dev, ABS_X, -range, range, 3, 3);
 784                 input_set_abs_params(input_dev, ABS_Y, -range, range, 3, 3);
 785                 input_set_abs_params(input_dev, ABS_Z, -range, range, 3, 3);
 786         }
 787
 788         __set_bit(EV_KEY, input_dev->evbit);
 789         __set_bit(pdata->ev_code_tap[ADXL_X_AXIS], input_dev->keybit);
 790         __set_bit(pdata->ev_code_tap[ADXL_Y_AXIS], input_dev->keybit);
 791         __set_bit(pdata->ev_code_tap[ADXL_Z_AXIS], input_dev->keybit);
 792
 793         if (pdata->ev_code_ff) {
 794                 ac->int_mask = FREE_FALL;
 795                 __set_bit(pdata->ev_code_ff, input_dev->keybit);
 796         }
 797
 798         if (pdata->ev_code_act_inactivity)
 799                 __set_bit(pdata->ev_code_act_inactivity, input_dev->keybit);
 800
 801         ac->int_mask |= ACTIVITY | INACTIVITY;
 802
 803         if (pdata->watermark) {
 804                 ac->int_mask |= WATERMARK;
 805                 if (FIFO_MODE(pdata->fifo_mode) == FIFO_BYPASS)
 806                         ac->pdata.fifo_mode |= FIFO_STREAM;
 807         } else {
 808                 ac->int_mask |= DATA_READY;
 809         }
 810
 811         if (pdata->tap_axis_control & (TAP_X_EN | TAP_Y_EN | TAP_Z_EN))
 812                 ac->int_mask |= SINGLE_TAP | DOUBLE_TAP;
 813
 814         if (FIFO_MODE(pdata->fifo_mode) == FIFO_BYPASS)
 815                 ac->fifo_delay = false;
 816
 817         AC_WRITE(ac, POWER_CTL, 0);
 818
 819         err = request_threaded_irq(ac->irq, NULL, adxl34x_irq,
 820                                    IRQF_ONESHOT, dev_name(dev), ac);
 821         if (err) {
 822                 dev_err(dev, "irq %d busy?\n", ac->irq);
 823                 goto err_free_mem;
 824         }
 825
 826         err = sysfs_create_group(&dev->kobj, &adxl34x_attr_group);
 827         if (err)
 828                 goto err_free_irq;
 829
 830         err = input_register_device(input_dev);
 831         if (err)
 832                 goto err_remove_attr;
 833
 834         AC_WRITE(ac, OFSX, pdata->x_axis_offset);
 835         ac->hwcal.x = pdata->x_axis_offset;
 836         AC_WRITE(ac, OFSY, pdata->y_axis_offset);
 837         ac->hwcal.y = pdata->y_axis_offset;
 838         AC_WRITE(ac, OFSZ, pdata->z_axis_offset);
 839         ac->hwcal.z = pdata->z_axis_offset;
 840         AC_WRITE(ac, THRESH_TAP, pdata->tap_threshold);
 841         AC_WRITE(ac, DUR, pdata->tap_duration);
 842         AC_WRITE(ac, LATENT, pdata->tap_latency);
 843         AC_WRITE(ac, WINDOW, pdata->tap_window);
 844         AC_WRITE(ac, THRESH_ACT, pdata->activity_threshold);
 845         AC_WRITE(ac, THRESH_INACT, pdata->inactivity_threshold);
 846         AC_WRITE(ac, TIME_INACT, pdata->inactivity_time);
 847         AC_WRITE(ac, THRESH_FF, pdata->free_fall_threshold);
 848         AC_WRITE(ac, TIME_FF, pdata->free_fall_time);
 849         AC_WRITE(ac, TAP_AXES, pdata->tap_axis_control);
 850         AC_WRITE(ac, ACT_INACT_CTL, pdata->act_axis_control);
 851         AC_WRITE(ac, BW_RATE, RATE(ac->pdata.data_rate) |
 852                  (pdata->low_power_mode ? LOW_POWER : 0));
 853         AC_WRITE(ac, DATA_FORMAT, pdata->data_range);
 854         AC_WRITE(ac, FIFO_CTL, FIFO_MODE(pdata->fifo_mode) |
 855                         SAMPLES(pdata->watermark));
 856
 857         if (pdata->use_int2) {
 858                 /* Map all INTs to INT2 */
 859                 AC_WRITE(ac, INT_MAP, ac->int_mask | OVERRUN);
 860         } else {
 861                 /* Map all INTs to INT1 */
 862                 AC_WRITE(ac, INT_MAP, 0);
 863         }
 864
 865         if (ac->model == 346 && ac->pdata.orientation_enable) {
 866                 AC_WRITE(ac, ORIENT_CONF,
 867                         ORIENT_DEADZONE(ac->pdata.deadzone_angle) |
 868                         ORIENT_DIVISOR(ac->pdata.divisor_length));
 869
 870                 ac->orient2d_saved = 1234;
 871                 ac->orient3d_saved = 1234;
 872
 873                 if (pdata->orientation_enable & ADXL_EN_ORIENTATION_3D)
 874                         for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_3d); i++)
 875                                 __set_bit(pdata->ev_codes_orient_3d[i],
 876                                           input_dev->keybit);
 877
 878                 if (pdata->orientation_enable & ADXL_EN_ORIENTATION_2D)
 879                         for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_2d); i++)
 880                                 __set_bit(pdata->ev_codes_orient_2d[i],
 881                                           input_dev->keybit);
 882         } else {
 883                 ac->pdata.orientation_enable = 0;
 884         }
 885
 886         AC_WRITE(ac, INT_ENABLE, ac->int_mask | OVERRUN);
 887
 888         ac->pdata.power_mode &= (PCTL_AUTO_SLEEP | PCTL_LINK);
 889
 890         return ac;
 891
 892  err_remove_attr:
 893         sysfs_remove_group(&dev->kobj, &adxl34x_attr_group);
 894  err_free_irq:
 895         free_irq(ac->irq, ac);
 896  err_free_mem:
 897         input_free_device(input_dev);
 898         kfree(ac);
 899  err_out:
 900         return ERR_PTR(err);
 901 }
 902 EXPORT_SYMBOL_GPL(adxl34x_probe);
 903
 904 void adxl34x_remove(struct adxl34x *ac)
 905 {
 906         sysfs_remove_group(&ac->dev->kobj, &adxl34x_attr_group);
 907         free_irq(ac->irq, ac);
 908         input_unregister_device(ac->input);
 909         dev_dbg(ac->dev, "unregistered accelerometer\n");
 910         kfree(ac);
 911 }
 912 EXPORT_SYMBOL_GPL(adxl34x_remove);
 913
 914 EXPORT_GPL_SIMPLE_DEV_PM_OPS(adxl34x_pm, adxl34x_suspend, adxl34x_resume);
 915
 916 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 917 MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer Driver");
 918 MODULE_LICENSE("GPL");