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