LXR linux/drivers/input/misc/adxl34x.c

   1/*
   2 * ADXL345/346 Three-Axis Digital Accelerometers
   3 *
   4 * Enter bugs at http://blackfin.uclinux.org/
   5 *
   6 * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
   7 * Licensed under the GPL-2 or later.
   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
 184struct axis_triple {
 185        int x;
 186        int y;
 187        int z;
 188};
 189
 190struct 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
 212static 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
 238static void adxl34x_get_triple(struct adxl34x *ac, struct axis_triple *axis)
 239{
 240        short 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
 256static 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
 271static 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
 278static 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
 290static 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
 298static 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
 401static 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
 410static void __adxl34x_enable(struct adxl34x *ac)
 411{
 412        AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
 413}
 414
 415void adxl34x_suspend(struct adxl34x *ac)
 416{
 417        mutex_lock(&ac->mutex);
 418
 419        if (!ac->suspended && !ac->disabled && ac->opened)
 420                __adxl34x_disable(ac);
 421
 422        ac->suspended = true;
 423
 424        mutex_unlock(&ac->mutex);
 425}
 426EXPORT_SYMBOL_GPL(adxl34x_suspend);
 427
 428void adxl34x_resume(struct adxl34x *ac)
 429{
 430        mutex_lock(&ac->mutex);
 431
 432        if (ac->suspended && !ac->disabled && ac->opened)
 433                __adxl34x_enable(ac);
 434
 435        ac->suspended = false;
 436
 437        mutex_unlock(&ac->mutex);
 438}
 439EXPORT_SYMBOL_GPL(adxl34x_resume);
 440
 441static ssize_t adxl34x_disable_show(struct device *dev,
 442                                    struct device_attribute *attr, char *buf)
 443{
 444        struct adxl34x *ac = dev_get_drvdata(dev);
 445
 446        return sprintf(buf, "%u\n", ac->disabled);
 447}
 448
 449static ssize_t adxl34x_disable_store(struct device *dev,
 450                                     struct device_attribute *attr,
 451                                     const char *buf, size_t count)
 452{
 453        struct adxl34x *ac = dev_get_drvdata(dev);
 454        unsigned int val;
 455        int error;
 456
 457        error = kstrtouint(buf, 10, &val);
 458        if (error)
 459                return error;
 460
 461        mutex_lock(&ac->mutex);
 462
 463        if (!ac->suspended && ac->opened) {
 464                if (val) {
 465                        if (!ac->disabled)
 466                                __adxl34x_disable(ac);
 467                } else {
 468                        if (ac->disabled)
 469                                __adxl34x_enable(ac);
 470                }
 471        }
 472
 473        ac->disabled = !!val;
 474
 475        mutex_unlock(&ac->mutex);
 476
 477        return count;
 478}
 479
 480static DEVICE_ATTR(disable, 0664, adxl34x_disable_show, adxl34x_disable_store);
 481
 482static ssize_t adxl34x_calibrate_show(struct device *dev,
 483                                      struct device_attribute *attr, char *buf)
 484{
 485        struct adxl34x *ac = dev_get_drvdata(dev);
 486        ssize_t count;
 487
 488        mutex_lock(&ac->mutex);
 489        count = sprintf(buf, "%d,%d,%d\n",
 490                        ac->hwcal.x * 4 + ac->swcal.x,
 491                        ac->hwcal.y * 4 + ac->swcal.y,
 492                        ac->hwcal.z * 4 + ac->swcal.z);
 493        mutex_unlock(&ac->mutex);
 494
 495        return count;
 496}
 497
 498static ssize_t adxl34x_calibrate_store(struct device *dev,
 499                                       struct device_attribute *attr,
 500                                       const char *buf, size_t count)
 501{
 502        struct adxl34x *ac = dev_get_drvdata(dev);
 503
 504        /*
 505         * Hardware offset calibration has a resolution of 15.6 mg/LSB.
 506         * We use HW calibration and handle the remaining bits in SW. (4mg/LSB)
 507         */
 508
 509        mutex_lock(&ac->mutex);
 510        ac->hwcal.x -= (ac->saved.x / 4);
 511        ac->swcal.x = ac->saved.x % 4;
 512
 513        ac->hwcal.y -= (ac->saved.y / 4);
 514        ac->swcal.y = ac->saved.y % 4;
 515
 516        ac->hwcal.z -= (ac->saved.z / 4);
 517        ac->swcal.z = ac->saved.z % 4;
 518
 519        AC_WRITE(ac, OFSX, (s8) ac->hwcal.x);
 520        AC_WRITE(ac, OFSY, (s8) ac->hwcal.y);
 521        AC_WRITE(ac, OFSZ, (s8) ac->hwcal.z);
 522        mutex_unlock(&ac->mutex);
 523
 524        return count;
 525}
 526
 527static DEVICE_ATTR(calibrate, 0664,
 528                   adxl34x_calibrate_show, adxl34x_calibrate_store);
 529
 530static ssize_t adxl34x_rate_show(struct device *dev,
 531                                 struct device_attribute *attr, char *buf)
 532{
 533        struct adxl34x *ac = dev_get_drvdata(dev);
 534
 535        return sprintf(buf, "%u\n", RATE(ac->pdata.data_rate));
 536}
 537
 538static ssize_t adxl34x_rate_store(struct device *dev,
 539                                  struct device_attribute *attr,
 540                                  const char *buf, size_t count)
 541{
 542        struct adxl34x *ac = dev_get_drvdata(dev);
 543        unsigned char val;
 544        int error;
 545
 546        error = kstrtou8(buf, 10, &val);
 547        if (error)
 548                return error;
 549
 550        mutex_lock(&ac->mutex);
 551
 552        ac->pdata.data_rate = RATE(val);
 553        AC_WRITE(ac, BW_RATE,
 554                 ac->pdata.data_rate |
 555                        (ac->pdata.low_power_mode ? LOW_POWER : 0));
 556
 557        mutex_unlock(&ac->mutex);
 558
 559        return count;
 560}
 561
 562static DEVICE_ATTR(rate, 0664, adxl34x_rate_show, adxl34x_rate_store);
 563
 564static ssize_t adxl34x_autosleep_show(struct device *dev,
 565                                 struct device_attribute *attr, char *buf)
 566{
 567        struct adxl34x *ac = dev_get_drvdata(dev);
 568
 569        return sprintf(buf, "%u\n",
 570                ac->pdata.power_mode & (PCTL_AUTO_SLEEP | PCTL_LINK) ? 1 : 0);
 571}
 572
 573static ssize_t adxl34x_autosleep_store(struct device *dev,
 574                                  struct device_attribute *attr,
 575                                  const char *buf, size_t count)
 576{
 577        struct adxl34x *ac = dev_get_drvdata(dev);
 578        unsigned int val;
 579        int error;
 580
 581        error = kstrtouint(buf, 10, &val);
 582        if (error)
 583                return error;
 584
 585        mutex_lock(&ac->mutex);
 586
 587        if (val)
 588                ac->pdata.power_mode |= (PCTL_AUTO_SLEEP | PCTL_LINK);
 589        else
 590                ac->pdata.power_mode &= ~(PCTL_AUTO_SLEEP | PCTL_LINK);
 591
 592        if (!ac->disabled && !ac->suspended && ac->opened)
 593                AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
 594
 595        mutex_unlock(&ac->mutex);
 596
 597        return count;
 598}
 599
 600static DEVICE_ATTR(autosleep, 0664,
 601                   adxl34x_autosleep_show, adxl34x_autosleep_store);
 602
 603static ssize_t adxl34x_position_show(struct device *dev,
 604                                 struct device_attribute *attr, char *buf)
 605{
 606        struct adxl34x *ac = dev_get_drvdata(dev);
 607        ssize_t count;
 608
 609        mutex_lock(&ac->mutex);
 610        count = sprintf(buf, "(%d, %d, %d)\n",
 611                        ac->saved.x, ac->saved.y, ac->saved.z);
 612        mutex_unlock(&ac->mutex);
 613
 614        return count;
 615}
 616
 617static DEVICE_ATTR(position, S_IRUGO, adxl34x_position_show, NULL);
 618
 619#ifdef ADXL_DEBUG
 620static ssize_t adxl34x_write_store(struct device *dev,
 621                                   struct device_attribute *attr,
 622                                   const char *buf, size_t count)
 623{
 624        struct adxl34x *ac = dev_get_drvdata(dev);
 625        unsigned int val;
 626        int error;
 627
 628        /*
 629         * This allows basic ADXL register write access for debug purposes.
 630         */
 631        error = kstrtouint(buf, 16, &val);
 632        if (error)
 633                return error;
 634
 635        mutex_lock(&ac->mutex);
 636        AC_WRITE(ac, val >> 8, val & 0xFF);
 637        mutex_unlock(&ac->mutex);
 638
 639        return count;
 640}
 641
 642static DEVICE_ATTR(write, 0664, NULL, adxl34x_write_store);
 643#endif
 644
 645static struct attribute *adxl34x_attributes[] = {
 646        &dev_attr_disable.attr,
 647        &dev_attr_calibrate.attr,
 648        &dev_attr_rate.attr,
 649        &dev_attr_autosleep.attr,
 650        &dev_attr_position.attr,
 651#ifdef ADXL_DEBUG
 652        &dev_attr_write.attr,
 653#endif
 654        NULL
 655};
 656
 657static const struct attribute_group adxl34x_attr_group = {
 658        .attrs = adxl34x_attributes,
 659};
 660
 661static int adxl34x_input_open(struct input_dev *input)
 662{
 663        struct adxl34x *ac = input_get_drvdata(input);
 664
 665        mutex_lock(&ac->mutex);
 666
 667        if (!ac->suspended && !ac->disabled)
 668                __adxl34x_enable(ac);
 669
 670        ac->opened = true;
 671
 672        mutex_unlock(&ac->mutex);
 673
 674        return 0;
 675}
 676
 677static void adxl34x_input_close(struct input_dev *input)
 678{
 679        struct adxl34x *ac = input_get_drvdata(input);
 680
 681        mutex_lock(&ac->mutex);
 682
 683        if (!ac->suspended && !ac->disabled)
 684                __adxl34x_disable(ac);
 685
 686        ac->opened = false;
 687
 688        mutex_unlock(&ac->mutex);
 689}
 690
 691struct adxl34x *adxl34x_probe(struct device *dev, int irq,
 692                              bool fifo_delay_default,
 693                              const struct adxl34x_bus_ops *bops)
 694{
 695        struct adxl34x *ac;
 696        struct input_dev *input_dev;
 697        const struct adxl34x_platform_data *pdata;
 698        int err, range, i;
 699        unsigned char revid;
 700
 701        if (!irq) {
 702                dev_err(dev, "no IRQ?\n");
 703                err = -ENODEV;
 704                goto err_out;
 705        }
 706
 707        ac = kzalloc(sizeof(*ac), GFP_KERNEL);
 708        input_dev = input_allocate_device();
 709        if (!ac || !input_dev) {
 710                err = -ENOMEM;
 711                goto err_free_mem;
 712        }
 713
 714        ac->fifo_delay = fifo_delay_default;
 715
 716        pdata = dev_get_platdata(dev);
 717        if (!pdata) {
 718                dev_dbg(dev,
 719                        "No platform data: Using default initialization\n");
 720                pdata = &adxl34x_default_init;
 721        }
 722
 723        ac->pdata = *pdata;
 724        pdata = &ac->pdata;
 725
 726        ac->input = input_dev;
 727        ac->dev = dev;
 728        ac->irq = irq;
 729        ac->bops = bops;
 730
 731        mutex_init(&ac->mutex);
 732
 733        input_dev->name = "ADXL34x accelerometer";
 734        revid = AC_READ(ac, DEVID);
 735
 736        switch (revid) {
 737        case ID_ADXL345:
 738                ac->model = 345;
 739                break;
 740        case ID_ADXL346:
 741                ac->model = 346;
 742                break;
 743        default:
 744                dev_err(dev, "Failed to probe %s\n", input_dev->name);
 745                err = -ENODEV;
 746                goto err_free_mem;
 747        }
 748
 749        snprintf(ac->phys, sizeof(ac->phys), "%s/input0", dev_name(dev));
 750
 751        input_dev->phys = ac->phys;
 752        input_dev->dev.parent = dev;
 753        input_dev->id.product = ac->model;
 754        input_dev->id.bustype = bops->bustype;
 755        input_dev->open = adxl34x_input_open;
 756        input_dev->close = adxl34x_input_close;
 757
 758        input_set_drvdata(input_dev, ac);
 759
 760        __set_bit(ac->pdata.ev_type, input_dev->evbit);
 761
 762        if (ac->pdata.ev_type == EV_REL) {
 763                __set_bit(REL_X, input_dev->relbit);
 764                __set_bit(REL_Y, input_dev->relbit);
 765                __set_bit(REL_Z, input_dev->relbit);
 766        } else {
 767                /* EV_ABS */
 768                __set_bit(ABS_X, input_dev->absbit);
 769                __set_bit(ABS_Y, input_dev->absbit);
 770                __set_bit(ABS_Z, input_dev->absbit);
 771
 772                if (pdata->data_range & FULL_RES)
 773                        range = ADXL_FULLRES_MAX_VAL;   /* Signed 13-bit */
 774                else
 775                        range = ADXL_FIXEDRES_MAX_VAL;  /* Signed 10-bit */
 776
 777                input_set_abs_params(input_dev, ABS_X, -range, range, 3, 3);
 778                input_set_abs_params(input_dev, ABS_Y, -range, range, 3, 3);
 779                input_set_abs_params(input_dev, ABS_Z, -range, range, 3, 3);
 780        }
 781
 782        __set_bit(EV_KEY, input_dev->evbit);
 783        __set_bit(pdata->ev_code_tap[ADXL_X_AXIS], input_dev->keybit);
 784        __set_bit(pdata->ev_code_tap[ADXL_Y_AXIS], input_dev->keybit);
 785        __set_bit(pdata->ev_code_tap[ADXL_Z_AXIS], input_dev->keybit);
 786
 787        if (pdata->ev_code_ff) {
 788                ac->int_mask = FREE_FALL;
 789                __set_bit(pdata->ev_code_ff, input_dev->keybit);
 790        }
 791
 792        if (pdata->ev_code_act_inactivity)
 793                __set_bit(pdata->ev_code_act_inactivity, input_dev->keybit);
 794
 795        ac->int_mask |= ACTIVITY | INACTIVITY;
 796
 797        if (pdata->watermark) {
 798                ac->int_mask |= WATERMARK;
 799                if (!FIFO_MODE(pdata->fifo_mode))
 800                        ac->pdata.fifo_mode |= FIFO_STREAM;
 801        } else {
 802                ac->int_mask |= DATA_READY;
 803        }
 804
 805        if (pdata->tap_axis_control & (TAP_X_EN | TAP_Y_EN | TAP_Z_EN))
 806                ac->int_mask |= SINGLE_TAP | DOUBLE_TAP;
 807
 808        if (FIFO_MODE(pdata->fifo_mode) == FIFO_BYPASS)
 809                ac->fifo_delay = false;
 810
 811        AC_WRITE(ac, POWER_CTL, 0);
 812
 813        err = request_threaded_irq(ac->irq, NULL, adxl34x_irq,
 814                                   IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
 815                                   dev_name(dev), ac);
 816        if (err) {
 817                dev_err(dev, "irq %d busy?\n", ac->irq);
 818                goto err_free_mem;
 819        }
 820
 821        err = sysfs_create_group(&dev->kobj, &adxl34x_attr_group);
 822        if (err)
 823                goto err_free_irq;
 824
 825        err = input_register_device(input_dev);
 826        if (err)
 827                goto err_remove_attr;
 828
 829        AC_WRITE(ac, OFSX, pdata->x_axis_offset);
 830        ac->hwcal.x = pdata->x_axis_offset;
 831        AC_WRITE(ac, OFSY, pdata->y_axis_offset);
 832        ac->hwcal.y = pdata->y_axis_offset;
 833        AC_WRITE(ac, OFSZ, pdata->z_axis_offset);
 834        ac->hwcal.z = pdata->z_axis_offset;
 835        AC_WRITE(ac, THRESH_TAP, pdata->tap_threshold);
 836        AC_WRITE(ac, DUR, pdata->tap_duration);
 837        AC_WRITE(ac, LATENT, pdata->tap_latency);
 838        AC_WRITE(ac, WINDOW, pdata->tap_window);
 839        AC_WRITE(ac, THRESH_ACT, pdata->activity_threshold);
 840        AC_WRITE(ac, THRESH_INACT, pdata->inactivity_threshold);
 841        AC_WRITE(ac, TIME_INACT, pdata->inactivity_time);
 842        AC_WRITE(ac, THRESH_FF, pdata->free_fall_threshold);
 843        AC_WRITE(ac, TIME_FF, pdata->free_fall_time);
 844        AC_WRITE(ac, TAP_AXES, pdata->tap_axis_control);
 845        AC_WRITE(ac, ACT_INACT_CTL, pdata->act_axis_control);
 846        AC_WRITE(ac, BW_RATE, RATE(ac->pdata.data_rate) |
 847                 (pdata->low_power_mode ? LOW_POWER : 0));
 848        AC_WRITE(ac, DATA_FORMAT, pdata->data_range);
 849        AC_WRITE(ac, FIFO_CTL, FIFO_MODE(pdata->fifo_mode) |
 850                        SAMPLES(pdata->watermark));
 851
 852        if (pdata->use_int2) {
 853                /* Map all INTs to INT2 */
 854                AC_WRITE(ac, INT_MAP, ac->int_mask | OVERRUN);
 855        } else {
 856                /* Map all INTs to INT1 */
 857                AC_WRITE(ac, INT_MAP, 0);
 858        }
 859
 860        if (ac->model == 346 && ac->pdata.orientation_enable) {
 861                AC_WRITE(ac, ORIENT_CONF,
 862                        ORIENT_DEADZONE(ac->pdata.deadzone_angle) |
 863                        ORIENT_DIVISOR(ac->pdata.divisor_length));
 864
 865                ac->orient2d_saved = 1234;
 866                ac->orient3d_saved = 1234;
 867
 868                if (pdata->orientation_enable & ADXL_EN_ORIENTATION_3D)
 869                        for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_3d); i++)
 870                                __set_bit(pdata->ev_codes_orient_3d[i],
 871                                          input_dev->keybit);
 872
 873                if (pdata->orientation_enable & ADXL_EN_ORIENTATION_2D)
 874                        for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_2d); i++)
 875                                __set_bit(pdata->ev_codes_orient_2d[i],
 876                                          input_dev->keybit);
 877        } else {
 878                ac->pdata.orientation_enable = 0;
 879        }
 880
 881        AC_WRITE(ac, INT_ENABLE, ac->int_mask | OVERRUN);
 882
 883        ac->pdata.power_mode &= (PCTL_AUTO_SLEEP | PCTL_LINK);
 884
 885        return ac;
 886
 887 err_remove_attr:
 888        sysfs_remove_group(&dev->kobj, &adxl34x_attr_group);
 889 err_free_irq:
 890        free_irq(ac->irq, ac);
 891 err_free_mem:
 892        input_free_device(input_dev);
 893        kfree(ac);
 894 err_out:
 895        return ERR_PTR(err);
 896}
 897EXPORT_SYMBOL_GPL(adxl34x_probe);
 898
 899int adxl34x_remove(struct adxl34x *ac)
 900{
 901        sysfs_remove_group(&ac->dev->kobj, &adxl34x_attr_group);
 902        free_irq(ac->irq, ac);
 903        input_unregister_device(ac->input);
 904        dev_dbg(ac->dev, "unregistered accelerometer\n");
 905        kfree(ac);
 906
 907        return 0;
 908}
 909EXPORT_SYMBOL_GPL(adxl34x_remove);
 910
 911MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 912MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer Driver");
 913MODULE_LICENSE("GPL");
 914