adxl34x.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * ADXL345/346 Three-Axis Digital Accelerometers
  4 *
  5 * Enter bugs at http://blackfin.uclinux.org/
  6 *
  7 * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
  8 */
  9
 10#include <linux/device.h>
 11#include <linux/delay.h>
 12#include <linux/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
185struct axis_triple {
186	int x;
187	int y;
188	int z;
189};
190
191struct 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
213static 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
239static 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
257static 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
272static 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
279static 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
291static 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
299static 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
402static 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
411static void __adxl34x_enable(struct adxl34x *ac)
412{
413	AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
414}
415
416static 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
430static 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
444static 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
452static 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
481static DEVICE_ATTR(disable, 0664, adxl34x_disable_show, adxl34x_disable_store);
482
483static 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
496static 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
525static DEVICE_ATTR(calibrate, 0664,
526		   adxl34x_calibrate_show, adxl34x_calibrate_store);
527
528static 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
536static 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
558static DEVICE_ATTR(rate, 0664, adxl34x_rate_show, adxl34x_rate_store);
559
560static 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
569static 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
594static DEVICE_ATTR(autosleep, 0664,
595		   adxl34x_autosleep_show, adxl34x_autosleep_store);
596
597static 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
608static DEVICE_ATTR(position, S_IRUGO, adxl34x_position_show, NULL);
609
610#ifdef ADXL_DEBUG
611static 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
632static DEVICE_ATTR(write, 0664, NULL, adxl34x_write_store);
633#endif
634
635static 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
647static const struct attribute_group adxl34x_attr_group = {
648	.attrs = adxl34x_attributes,
649};
650
651const struct attribute_group *adxl34x_groups[] = {
652	&adxl34x_attr_group,
653	NULL
654};
655EXPORT_SYMBOL_GPL(adxl34x_groups);
656
657static 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
671static 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
683struct 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}
866EXPORT_SYMBOL_GPL(adxl34x_probe);
867
868EXPORT_GPL_SIMPLE_DEV_PM_OPS(adxl34x_pm, adxl34x_suspend, adxl34x_resume);
869
870MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
871MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer Driver");
872MODULE_LICENSE("GPL");