GNU Linux-libre 4.14.266-gnu1
[releases.git] / 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
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         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
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 void 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 }
426 EXPORT_SYMBOL_GPL(adxl34x_suspend);
427
428 void 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 }
439 EXPORT_SYMBOL_GPL(adxl34x_resume);
440
441 static 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
449 static 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
480 static DEVICE_ATTR(disable, 0664, adxl34x_disable_show, adxl34x_disable_store);
481
482 static 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
498 static 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
527 static DEVICE_ATTR(calibrate, 0664,
528                    adxl34x_calibrate_show, adxl34x_calibrate_store);
529
530 static 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
538 static 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
562 static DEVICE_ATTR(rate, 0664, adxl34x_rate_show, adxl34x_rate_store);
563
564 static 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
573 static 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
600 static DEVICE_ATTR(autosleep, 0664,
601                    adxl34x_autosleep_show, adxl34x_autosleep_store);
602
603 static 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
617 static DEVICE_ATTR(position, S_IRUGO, adxl34x_position_show, NULL);
618
619 #ifdef ADXL_DEBUG
620 static 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
642 static DEVICE_ATTR(write, 0664, NULL, adxl34x_write_store);
643 #endif
644
645 static 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
657 static const struct attribute_group adxl34x_attr_group = {
658         .attrs = adxl34x_attributes,
659 };
660
661 static 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
677 static 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
691 struct 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         int 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 }
897 EXPORT_SYMBOL_GPL(adxl34x_probe);
898
899 int 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 }
909 EXPORT_SYMBOL_GPL(adxl34x_remove);
910
911 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
912 MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer Driver");
913 MODULE_LICENSE("GPL");