1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  lis3lv02d.c - ST LIS3LV02DL accelerometer driver
4  *
5  *  Copyright (C) 2007-2008 Yan Burman
6  *  Copyright (C) 2008 Eric Piel
7  *  Copyright (C) 2008-2009 Pavel Machek
8  */
9 
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 
12 #include <linux/kernel.h>
13 #include <linux/sched/signal.h>
14 #include <linux/dmi.h>
15 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <linux/platform_device.h>
18 #include <linux/interrupt.h>
19 #include <linux/input.h>
20 #include <linux/delay.h>
21 #include <linux/wait.h>
22 #include <linux/poll.h>
23 #include <linux/slab.h>
24 #include <linux/freezer.h>
25 #include <linux/uaccess.h>
26 #include <linux/miscdevice.h>
27 #include <linux/pm_runtime.h>
28 #include <linux/atomic.h>
29 #include <linux/of.h>
30 #include "lis3lv02d.h"
31 
32 #define DRIVER_NAME     "lis3lv02d"
33 
34 /* joystick device poll interval in milliseconds */
35 #define MDPS_POLL_INTERVAL 50
36 #define MDPS_POLL_MIN	   0
37 #define MDPS_POLL_MAX	   2000
38 
39 #define LIS3_SYSFS_POWERDOWN_DELAY 5000 /* In milliseconds */
40 
41 #define SELFTEST_OK	       0
42 #define SELFTEST_FAIL	       -1
43 #define SELFTEST_IRQ	       -2
44 
45 #define IRQ_LINE0	       0
46 #define IRQ_LINE1	       1
47 
48 /*
49  * The sensor can also generate interrupts (DRDY) but it's pretty pointless
50  * because they are generated even if the data do not change. So it's better
51  * to keep the interrupt for the free-fall event. The values are updated at
52  * 40Hz (at the lowest frequency), but as it can be pretty time consuming on
53  * some low processor, we poll the sensor only at 20Hz... enough for the
54  * joystick.
55  */
56 
57 #define LIS3_PWRON_DELAY_WAI_12B	(5000)
58 #define LIS3_PWRON_DELAY_WAI_8B		(3000)
59 
60 /*
61  * LIS3LV02D spec says 1024 LSBs corresponds 1 G -> 1LSB is 1000/1024 mG
62  * LIS302D spec says: 18 mG / digit
63  * LIS3_ACCURACY is used to increase accuracy of the intermediate
64  * calculation results.
65  */
66 #define LIS3_ACCURACY			1024
67 /* Sensitivity values for -2G +2G scale */
68 #define LIS3_SENSITIVITY_12B		((LIS3_ACCURACY * 1000) / 1024)
69 #define LIS3_SENSITIVITY_8B		(18 * LIS3_ACCURACY)
70 
71 /*
72  * LIS331DLH spec says 1LSBs corresponds 4G/4096 -> 1LSB is 1000/1024 mG.
73  * Below macros defines sensitivity values for +/-2G. Dataout bits for
74  * +/-2G range is 12 bits so 4 bits adjustment must be done to get 12bit
75  * data from 16bit value. Currently this driver supports only 2G range.
76  */
77 #define LIS3DLH_SENSITIVITY_2G		((LIS3_ACCURACY * 1000) / 1024)
78 #define SHIFT_ADJ_2G			4
79 
80 #define LIS3_DEFAULT_FUZZ_12B		3
81 #define LIS3_DEFAULT_FLAT_12B		3
82 #define LIS3_DEFAULT_FUZZ_8B		1
83 #define LIS3_DEFAULT_FLAT_8B		1
84 
85 struct lis3lv02d lis3_dev = {
86 	.misc_wait   = __WAIT_QUEUE_HEAD_INITIALIZER(lis3_dev.misc_wait),
87 };
88 EXPORT_SYMBOL_GPL(lis3_dev);
89 
90 /* just like param_set_int() but does sanity-check so that it won't point
91  * over the axis array size
92  */
93 static int param_set_axis(const char *val, const struct kernel_param *kp)
94 {
95 	int ret = param_set_int(val, kp);
96 	if (!ret) {
97 		int val = *(int *)kp->arg;
98 		if (val < 0)
99 			val = -val;
100 		if (!val || val > 3)
101 			return -EINVAL;
102 	}
103 	return ret;
104 }
105 
106 static const struct kernel_param_ops param_ops_axis = {
107 	.set = param_set_axis,
108 	.get = param_get_int,
109 };
110 
111 #define param_check_axis(name, p) param_check_int(name, p)
112 
113 module_param_array_named(axes, lis3_dev.ac.as_array, axis, NULL, 0644);
114 MODULE_PARM_DESC(axes, "Axis-mapping for x,y,z directions");
115 
116 static s16 lis3lv02d_read_8(struct lis3lv02d *lis3, int reg)
117 {
118 	s8 lo;
119 	if (lis3->read(lis3, reg, &lo) < 0)
120 		return 0;
121 
122 	return lo;
123 }
124 
125 static s16 lis3lv02d_read_12(struct lis3lv02d *lis3, int reg)
126 {
127 	u8 lo, hi;
128 
129 	lis3->read(lis3, reg - 1, &lo);
130 	lis3->read(lis3, reg, &hi);
131 	/* In "12 bit right justified" mode, bit 6, bit 7, bit 8 = bit 5 */
132 	return (s16)((hi << 8) | lo);
133 }
134 
135 /* 12bits for 2G range, 13 bits for 4G range and 14 bits for 8G range */
136 static s16 lis331dlh_read_data(struct lis3lv02d *lis3, int reg)
137 {
138 	u8 lo, hi;
139 	int v;
140 
141 	lis3->read(lis3, reg - 1, &lo);
142 	lis3->read(lis3, reg, &hi);
143 	v = (int) ((hi << 8) | lo);
144 
145 	return (s16) v >> lis3->shift_adj;
146 }
147 
148 /**
149  * lis3lv02d_get_axis - For the given axis, give the value converted
150  * @axis:      1,2,3 - can also be negative
151  * @hw_values: raw values returned by the hardware
152  *
153  * Returns the converted value.
154  */
155 static inline int lis3lv02d_get_axis(s8 axis, int hw_values[3])
156 {
157 	if (axis > 0)
158 		return hw_values[axis - 1];
159 	else
160 		return -hw_values[-axis - 1];
161 }
162 
163 /**
164  * lis3lv02d_get_xyz - Get X, Y and Z axis values from the accelerometer
165  * @lis3: pointer to the device struct
166  * @x:    where to store the X axis value
167  * @y:    where to store the Y axis value
168  * @z:    where to store the Z axis value
169  *
170  * Note that 40Hz input device can eat up about 10% CPU at 800MHZ
171  */
172 static void lis3lv02d_get_xyz(struct lis3lv02d *lis3, int *x, int *y, int *z)
173 {
174 	int position[3];
175 	int i;
176 
177 	if (lis3->blkread) {
178 		if (lis3->whoami == WAI_12B) {
179 			u16 data[3];
180 			lis3->blkread(lis3, OUTX_L, 6, (u8 *)data);
181 			for (i = 0; i < 3; i++)
182 				position[i] = (s16)le16_to_cpu(data[i]);
183 		} else {
184 			u8 data[5];
185 			/* Data: x, dummy, y, dummy, z */
186 			lis3->blkread(lis3, OUTX, 5, data);
187 			for (i = 0; i < 3; i++)
188 				position[i] = (s8)data[i * 2];
189 		}
190 	} else {
191 		position[0] = lis3->read_data(lis3, OUTX);
192 		position[1] = lis3->read_data(lis3, OUTY);
193 		position[2] = lis3->read_data(lis3, OUTZ);
194 	}
195 
196 	for (i = 0; i < 3; i++)
197 		position[i] = (position[i] * lis3->scale) / LIS3_ACCURACY;
198 
199 	*x = lis3lv02d_get_axis(lis3->ac.x, position);
200 	*y = lis3lv02d_get_axis(lis3->ac.y, position);
201 	*z = lis3lv02d_get_axis(lis3->ac.z, position);
202 }
203 
204 /* conversion btw sampling rate and the register values */
205 static int lis3_12_rates[4] = {40, 160, 640, 2560};
206 static int lis3_8_rates[2] = {100, 400};
207 static int lis3_3dc_rates[16] = {0, 1, 10, 25, 50, 100, 200, 400, 1600, 5000};
208 static int lis3_3dlh_rates[4] = {50, 100, 400, 1000};
209 
210 /* ODR is Output Data Rate */
211 static int lis3lv02d_get_odr_index(struct lis3lv02d *lis3)
212 {
213 	u8 ctrl;
214 	int shift;
215 
216 	lis3->read(lis3, CTRL_REG1, &ctrl);
217 	ctrl &= lis3->odr_mask;
218 	shift = ffs(lis3->odr_mask) - 1;
219 	return (ctrl >> shift);
220 }
221 
222 static int lis3lv02d_get_pwron_wait(struct lis3lv02d *lis3)
223 {
224 	int odr_idx = lis3lv02d_get_odr_index(lis3);
225 	int div = lis3->odrs[odr_idx];
226 
227 	if (div == 0) {
228 		if (odr_idx == 0) {
229 			/* Power-down mode, not sampling no need to sleep */
230 			return 0;
231 		}
232 
233 		dev_err(&lis3->pdev->dev, "Error unknown odrs-index: %d\n", odr_idx);
234 		return -ENXIO;
235 	}
236 
237 	/* LIS3 power on delay is quite long */
238 	msleep(lis3->pwron_delay / div);
239 	return 0;
240 }
241 
242 static int lis3lv02d_set_odr(struct lis3lv02d *lis3, int rate)
243 {
244 	u8 ctrl;
245 	int i, len, shift;
246 
247 	if (!rate)
248 		return -EINVAL;
249 
250 	lis3->read(lis3, CTRL_REG1, &ctrl);
251 	ctrl &= ~lis3->odr_mask;
252 	len = 1 << hweight_long(lis3->odr_mask); /* # of possible values */
253 	shift = ffs(lis3->odr_mask) - 1;
254 
255 	for (i = 0; i < len; i++)
256 		if (lis3->odrs[i] == rate) {
257 			lis3->write(lis3, CTRL_REG1,
258 					ctrl | (i << shift));
259 			return 0;
260 		}
261 	return -EINVAL;
262 }
263 
264 static int lis3lv02d_selftest(struct lis3lv02d *lis3, s16 results[3])
265 {
266 	u8 ctlreg, reg;
267 	s16 x, y, z;
268 	u8 selftest;
269 	int ret;
270 	u8 ctrl_reg_data;
271 	unsigned char irq_cfg;
272 
273 	mutex_lock(&lis3->mutex);
274 
275 	irq_cfg = lis3->irq_cfg;
276 	if (lis3->whoami == WAI_8B) {
277 		lis3->data_ready_count[IRQ_LINE0] = 0;
278 		lis3->data_ready_count[IRQ_LINE1] = 0;
279 
280 		/* Change interrupt cfg to data ready for selftest */
281 		atomic_inc(&lis3->wake_thread);
282 		lis3->irq_cfg = LIS3_IRQ1_DATA_READY | LIS3_IRQ2_DATA_READY;
283 		lis3->read(lis3, CTRL_REG3, &ctrl_reg_data);
284 		lis3->write(lis3, CTRL_REG3, (ctrl_reg_data &
285 				~(LIS3_IRQ1_MASK | LIS3_IRQ2_MASK)) |
286 				(LIS3_IRQ1_DATA_READY | LIS3_IRQ2_DATA_READY));
287 	}
288 
289 	if ((lis3->whoami == WAI_3DC) || (lis3->whoami == WAI_3DLH)) {
290 		ctlreg = CTRL_REG4;
291 		selftest = CTRL4_ST0;
292 	} else {
293 		ctlreg = CTRL_REG1;
294 		if (lis3->whoami == WAI_12B)
295 			selftest = CTRL1_ST;
296 		else
297 			selftest = CTRL1_STP;
298 	}
299 
300 	lis3->read(lis3, ctlreg, &reg);
301 	lis3->write(lis3, ctlreg, (reg | selftest));
302 	ret = lis3lv02d_get_pwron_wait(lis3);
303 	if (ret)
304 		goto fail;
305 
306 	/* Read directly to avoid axis remap */
307 	x = lis3->read_data(lis3, OUTX);
308 	y = lis3->read_data(lis3, OUTY);
309 	z = lis3->read_data(lis3, OUTZ);
310 
311 	/* back to normal settings */
312 	lis3->write(lis3, ctlreg, reg);
313 	ret = lis3lv02d_get_pwron_wait(lis3);
314 	if (ret)
315 		goto fail;
316 
317 	results[0] = x - lis3->read_data(lis3, OUTX);
318 	results[1] = y - lis3->read_data(lis3, OUTY);
319 	results[2] = z - lis3->read_data(lis3, OUTZ);
320 
321 	ret = 0;
322 
323 	if (lis3->whoami == WAI_8B) {
324 		/* Restore original interrupt configuration */
325 		atomic_dec(&lis3->wake_thread);
326 		lis3->write(lis3, CTRL_REG3, ctrl_reg_data);
327 		lis3->irq_cfg = irq_cfg;
328 
329 		if ((irq_cfg & LIS3_IRQ1_MASK) &&
330 			lis3->data_ready_count[IRQ_LINE0] < 2) {
331 			ret = SELFTEST_IRQ;
332 			goto fail;
333 		}
334 
335 		if ((irq_cfg & LIS3_IRQ2_MASK) &&
336 			lis3->data_ready_count[IRQ_LINE1] < 2) {
337 			ret = SELFTEST_IRQ;
338 			goto fail;
339 		}
340 	}
341 
342 	if (lis3->pdata) {
343 		int i;
344 		for (i = 0; i < 3; i++) {
345 			/* Check against selftest acceptance limits */
346 			if ((results[i] < lis3->pdata->st_min_limits[i]) ||
347 			    (results[i] > lis3->pdata->st_max_limits[i])) {
348 				ret = SELFTEST_FAIL;
349 				goto fail;
350 			}
351 		}
352 	}
353 
354 	/* test passed */
355 fail:
356 	mutex_unlock(&lis3->mutex);
357 	return ret;
358 }
359 
360 /*
361  * Order of registers in the list affects to order of the restore process.
362  * Perhaps it is a good idea to set interrupt enable register as a last one
363  * after all other configurations
364  */
365 static u8 lis3_wai8_regs[] = { FF_WU_CFG_1, FF_WU_THS_1, FF_WU_DURATION_1,
366 			       FF_WU_CFG_2, FF_WU_THS_2, FF_WU_DURATION_2,
367 			       CLICK_CFG, CLICK_SRC, CLICK_THSY_X, CLICK_THSZ,
368 			       CLICK_TIMELIMIT, CLICK_LATENCY, CLICK_WINDOW,
369 			       CTRL_REG1, CTRL_REG2, CTRL_REG3};
370 
371 static u8 lis3_wai12_regs[] = {FF_WU_CFG, FF_WU_THS_L, FF_WU_THS_H,
372 			       FF_WU_DURATION, DD_CFG, DD_THSI_L, DD_THSI_H,
373 			       DD_THSE_L, DD_THSE_H,
374 			       CTRL_REG1, CTRL_REG3, CTRL_REG2};
375 
376 static inline void lis3_context_save(struct lis3lv02d *lis3)
377 {
378 	int i;
379 	for (i = 0; i < lis3->regs_size; i++)
380 		lis3->read(lis3, lis3->regs[i], &lis3->reg_cache[i]);
381 	lis3->regs_stored = true;
382 }
383 
384 static inline void lis3_context_restore(struct lis3lv02d *lis3)
385 {
386 	int i;
387 	if (lis3->regs_stored)
388 		for (i = 0; i < lis3->regs_size; i++)
389 			lis3->write(lis3, lis3->regs[i], lis3->reg_cache[i]);
390 }
391 
392 void lis3lv02d_poweroff(struct lis3lv02d *lis3)
393 {
394 	if (lis3->reg_ctrl)
395 		lis3_context_save(lis3);
396 	/* disable X,Y,Z axis and power down */
397 	lis3->write(lis3, CTRL_REG1, 0x00);
398 	if (lis3->reg_ctrl)
399 		lis3->reg_ctrl(lis3, LIS3_REG_OFF);
400 }
401 EXPORT_SYMBOL_GPL(lis3lv02d_poweroff);
402 
403 int lis3lv02d_poweron(struct lis3lv02d *lis3)
404 {
405 	int err;
406 	u8 reg;
407 
408 	lis3->init(lis3);
409 
410 	/*
411 	 * Common configuration
412 	 * BDU: (12 bits sensors only) LSB and MSB values are not updated until
413 	 *      both have been read. So the value read will always be correct.
414 	 * Set BOOT bit to refresh factory tuning values.
415 	 */
416 	if (lis3->pdata) {
417 		lis3->read(lis3, CTRL_REG2, &reg);
418 		if (lis3->whoami ==  WAI_12B)
419 			reg |= CTRL2_BDU | CTRL2_BOOT;
420 		else if (lis3->whoami ==  WAI_3DLH)
421 			reg |= CTRL2_BOOT_3DLH;
422 		else
423 			reg |= CTRL2_BOOT_8B;
424 		lis3->write(lis3, CTRL_REG2, reg);
425 
426 		if (lis3->whoami ==  WAI_3DLH) {
427 			lis3->read(lis3, CTRL_REG4, &reg);
428 			reg |= CTRL4_BDU;
429 			lis3->write(lis3, CTRL_REG4, reg);
430 		}
431 	}
432 
433 	err = lis3lv02d_get_pwron_wait(lis3);
434 	if (err)
435 		return err;
436 
437 	if (lis3->reg_ctrl)
438 		lis3_context_restore(lis3);
439 
440 	return 0;
441 }
442 EXPORT_SYMBOL_GPL(lis3lv02d_poweron);
443 
444 
445 static void lis3lv02d_joystick_poll(struct input_dev *input)
446 {
447 	struct lis3lv02d *lis3 = input_get_drvdata(input);
448 	int x, y, z;
449 
450 	mutex_lock(&lis3->mutex);
451 	lis3lv02d_get_xyz(lis3, &x, &y, &z);
452 	input_report_abs(input, ABS_X, x);
453 	input_report_abs(input, ABS_Y, y);
454 	input_report_abs(input, ABS_Z, z);
455 	input_sync(input);
456 	mutex_unlock(&lis3->mutex);
457 }
458 
459 static int lis3lv02d_joystick_open(struct input_dev *input)
460 {
461 	struct lis3lv02d *lis3 = input_get_drvdata(input);
462 
463 	if (lis3->pm_dev)
464 		pm_runtime_get_sync(lis3->pm_dev);
465 
466 	if (lis3->pdata && lis3->whoami == WAI_8B && lis3->idev)
467 		atomic_set(&lis3->wake_thread, 1);
468 	/*
469 	 * Update coordinates for the case where poll interval is 0 and
470 	 * the chip in running purely under interrupt control
471 	 */
472 	lis3lv02d_joystick_poll(input);
473 
474 	return 0;
475 }
476 
477 static void lis3lv02d_joystick_close(struct input_dev *input)
478 {
479 	struct lis3lv02d *lis3 = input_get_drvdata(input);
480 
481 	atomic_set(&lis3->wake_thread, 0);
482 	if (lis3->pm_dev)
483 		pm_runtime_put(lis3->pm_dev);
484 }
485 
486 static irqreturn_t lis302dl_interrupt(int irq, void *data)
487 {
488 	struct lis3lv02d *lis3 = data;
489 
490 	if (!test_bit(0, &lis3->misc_opened))
491 		goto out;
492 
493 	/*
494 	 * Be careful: on some HP laptops the bios force DD when on battery and
495 	 * the lid is closed. This leads to interrupts as soon as a little move
496 	 * is done.
497 	 */
498 	atomic_inc(&lis3->count);
499 
500 	wake_up_interruptible(&lis3->misc_wait);
501 	kill_fasync(&lis3->async_queue, SIGIO, POLL_IN);
502 out:
503 	if (atomic_read(&lis3->wake_thread))
504 		return IRQ_WAKE_THREAD;
505 	return IRQ_HANDLED;
506 }
507 
508 static void lis302dl_interrupt_handle_click(struct lis3lv02d *lis3)
509 {
510 	struct input_dev *dev = lis3->idev;
511 	u8 click_src;
512 
513 	mutex_lock(&lis3->mutex);
514 	lis3->read(lis3, CLICK_SRC, &click_src);
515 
516 	if (click_src & CLICK_SINGLE_X) {
517 		input_report_key(dev, lis3->mapped_btns[0], 1);
518 		input_report_key(dev, lis3->mapped_btns[0], 0);
519 	}
520 
521 	if (click_src & CLICK_SINGLE_Y) {
522 		input_report_key(dev, lis3->mapped_btns[1], 1);
523 		input_report_key(dev, lis3->mapped_btns[1], 0);
524 	}
525 
526 	if (click_src & CLICK_SINGLE_Z) {
527 		input_report_key(dev, lis3->mapped_btns[2], 1);
528 		input_report_key(dev, lis3->mapped_btns[2], 0);
529 	}
530 	input_sync(dev);
531 	mutex_unlock(&lis3->mutex);
532 }
533 
534 static inline void lis302dl_data_ready(struct lis3lv02d *lis3, int index)
535 {
536 	int dummy;
537 
538 	/* Dummy read to ack interrupt */
539 	lis3lv02d_get_xyz(lis3, &dummy, &dummy, &dummy);
540 	lis3->data_ready_count[index]++;
541 }
542 
543 static irqreturn_t lis302dl_interrupt_thread1_8b(int irq, void *data)
544 {
545 	struct lis3lv02d *lis3 = data;
546 	u8 irq_cfg = lis3->irq_cfg & LIS3_IRQ1_MASK;
547 
548 	if (irq_cfg == LIS3_IRQ1_CLICK)
549 		lis302dl_interrupt_handle_click(lis3);
550 	else if (unlikely(irq_cfg == LIS3_IRQ1_DATA_READY))
551 		lis302dl_data_ready(lis3, IRQ_LINE0);
552 	else
553 		lis3lv02d_joystick_poll(lis3->idev);
554 
555 	return IRQ_HANDLED;
556 }
557 
558 static irqreturn_t lis302dl_interrupt_thread2_8b(int irq, void *data)
559 {
560 	struct lis3lv02d *lis3 = data;
561 	u8 irq_cfg = lis3->irq_cfg & LIS3_IRQ2_MASK;
562 
563 	if (irq_cfg == LIS3_IRQ2_CLICK)
564 		lis302dl_interrupt_handle_click(lis3);
565 	else if (unlikely(irq_cfg == LIS3_IRQ2_DATA_READY))
566 		lis302dl_data_ready(lis3, IRQ_LINE1);
567 	else
568 		lis3lv02d_joystick_poll(lis3->idev);
569 
570 	return IRQ_HANDLED;
571 }
572 
573 static int lis3lv02d_misc_open(struct inode *inode, struct file *file)
574 {
575 	struct lis3lv02d *lis3 = container_of(file->private_data,
576 					      struct lis3lv02d, miscdev);
577 
578 	if (test_and_set_bit(0, &lis3->misc_opened))
579 		return -EBUSY; /* already open */
580 
581 	if (lis3->pm_dev)
582 		pm_runtime_get_sync(lis3->pm_dev);
583 
584 	atomic_set(&lis3->count, 0);
585 	return 0;
586 }
587 
588 static int lis3lv02d_misc_release(struct inode *inode, struct file *file)
589 {
590 	struct lis3lv02d *lis3 = container_of(file->private_data,
591 					      struct lis3lv02d, miscdev);
592 
593 	clear_bit(0, &lis3->misc_opened); /* release the device */
594 	if (lis3->pm_dev)
595 		pm_runtime_put(lis3->pm_dev);
596 	return 0;
597 }
598 
599 static ssize_t lis3lv02d_misc_read(struct file *file, char __user *buf,
600 				size_t count, loff_t *pos)
601 {
602 	struct lis3lv02d *lis3 = container_of(file->private_data,
603 					      struct lis3lv02d, miscdev);
604 
605 	DECLARE_WAITQUEUE(wait, current);
606 	u32 data;
607 	unsigned char byte_data;
608 	ssize_t retval = 1;
609 
610 	if (count < 1)
611 		return -EINVAL;
612 
613 	add_wait_queue(&lis3->misc_wait, &wait);
614 	while (true) {
615 		set_current_state(TASK_INTERRUPTIBLE);
616 		data = atomic_xchg(&lis3->count, 0);
617 		if (data)
618 			break;
619 
620 		if (file->f_flags & O_NONBLOCK) {
621 			retval = -EAGAIN;
622 			goto out;
623 		}
624 
625 		if (signal_pending(current)) {
626 			retval = -ERESTARTSYS;
627 			goto out;
628 		}
629 
630 		schedule();
631 	}
632 
633 	if (data < 255)
634 		byte_data = data;
635 	else
636 		byte_data = 255;
637 
638 	/* make sure we are not going into copy_to_user() with
639 	 * TASK_INTERRUPTIBLE state */
640 	set_current_state(TASK_RUNNING);
641 	if (copy_to_user(buf, &byte_data, sizeof(byte_data)))
642 		retval = -EFAULT;
643 
644 out:
645 	__set_current_state(TASK_RUNNING);
646 	remove_wait_queue(&lis3->misc_wait, &wait);
647 
648 	return retval;
649 }
650 
651 static __poll_t lis3lv02d_misc_poll(struct file *file, poll_table *wait)
652 {
653 	struct lis3lv02d *lis3 = container_of(file->private_data,
654 					      struct lis3lv02d, miscdev);
655 
656 	poll_wait(file, &lis3->misc_wait, wait);
657 	if (atomic_read(&lis3->count))
658 		return EPOLLIN | EPOLLRDNORM;
659 	return 0;
660 }
661 
662 static int lis3lv02d_misc_fasync(int fd, struct file *file, int on)
663 {
664 	struct lis3lv02d *lis3 = container_of(file->private_data,
665 					      struct lis3lv02d, miscdev);
666 
667 	return fasync_helper(fd, file, on, &lis3->async_queue);
668 }
669 
670 static const struct file_operations lis3lv02d_misc_fops = {
671 	.owner   = THIS_MODULE,
672 	.llseek  = no_llseek,
673 	.read    = lis3lv02d_misc_read,
674 	.open    = lis3lv02d_misc_open,
675 	.release = lis3lv02d_misc_release,
676 	.poll    = lis3lv02d_misc_poll,
677 	.fasync  = lis3lv02d_misc_fasync,
678 };
679 
680 int lis3lv02d_joystick_enable(struct lis3lv02d *lis3)
681 {
682 	struct input_dev *input_dev;
683 	int err;
684 	int max_val, fuzz, flat;
685 	int btns[] = {BTN_X, BTN_Y, BTN_Z};
686 
687 	if (lis3->idev)
688 		return -EINVAL;
689 
690 	input_dev = input_allocate_device();
691 	if (!input_dev)
692 		return -ENOMEM;
693 
694 	input_dev->name       = "ST LIS3LV02DL Accelerometer";
695 	input_dev->phys       = DRIVER_NAME "/input0";
696 	input_dev->id.bustype = BUS_HOST;
697 	input_dev->id.vendor  = 0;
698 	input_dev->dev.parent = &lis3->pdev->dev;
699 
700 	input_dev->open = lis3lv02d_joystick_open;
701 	input_dev->close = lis3lv02d_joystick_close;
702 
703 	max_val = (lis3->mdps_max_val * lis3->scale) / LIS3_ACCURACY;
704 	if (lis3->whoami == WAI_12B) {
705 		fuzz = LIS3_DEFAULT_FUZZ_12B;
706 		flat = LIS3_DEFAULT_FLAT_12B;
707 	} else {
708 		fuzz = LIS3_DEFAULT_FUZZ_8B;
709 		flat = LIS3_DEFAULT_FLAT_8B;
710 	}
711 	fuzz = (fuzz * lis3->scale) / LIS3_ACCURACY;
712 	flat = (flat * lis3->scale) / LIS3_ACCURACY;
713 
714 	input_set_abs_params(input_dev, ABS_X, -max_val, max_val, fuzz, flat);
715 	input_set_abs_params(input_dev, ABS_Y, -max_val, max_val, fuzz, flat);
716 	input_set_abs_params(input_dev, ABS_Z, -max_val, max_val, fuzz, flat);
717 
718 	input_set_drvdata(input_dev, lis3);
719 	lis3->idev = input_dev;
720 
721 	err = input_setup_polling(input_dev, lis3lv02d_joystick_poll);
722 	if (err)
723 		goto err_free_input;
724 
725 	input_set_poll_interval(input_dev, MDPS_POLL_INTERVAL);
726 	input_set_min_poll_interval(input_dev, MDPS_POLL_MIN);
727 	input_set_max_poll_interval(input_dev, MDPS_POLL_MAX);
728 
729 	lis3->mapped_btns[0] = lis3lv02d_get_axis(abs(lis3->ac.x), btns);
730 	lis3->mapped_btns[1] = lis3lv02d_get_axis(abs(lis3->ac.y), btns);
731 	lis3->mapped_btns[2] = lis3lv02d_get_axis(abs(lis3->ac.z), btns);
732 
733 	err = input_register_device(lis3->idev);
734 	if (err)
735 		goto err_free_input;
736 
737 	return 0;
738 
739 err_free_input:
740 	input_free_device(input_dev);
741 	lis3->idev = NULL;
742 	return err;
743 
744 }
745 EXPORT_SYMBOL_GPL(lis3lv02d_joystick_enable);
746 
747 void lis3lv02d_joystick_disable(struct lis3lv02d *lis3)
748 {
749 	if (lis3->irq)
750 		free_irq(lis3->irq, lis3);
751 	if (lis3->pdata && lis3->pdata->irq2)
752 		free_irq(lis3->pdata->irq2, lis3);
753 
754 	if (!lis3->idev)
755 		return;
756 
757 	if (lis3->irq)
758 		misc_deregister(&lis3->miscdev);
759 	input_unregister_device(lis3->idev);
760 	lis3->idev = NULL;
761 }
762 EXPORT_SYMBOL_GPL(lis3lv02d_joystick_disable);
763 
764 /* Sysfs stuff */
765 static void lis3lv02d_sysfs_poweron(struct lis3lv02d *lis3)
766 {
767 	/*
768 	 * SYSFS functions are fast visitors so put-call
769 	 * immediately after the get-call. However, keep
770 	 * chip running for a while and schedule delayed
771 	 * suspend. This way periodic sysfs calls doesn't
772 	 * suffer from relatively long power up time.
773 	 */
774 
775 	if (lis3->pm_dev) {
776 		pm_runtime_get_sync(lis3->pm_dev);
777 		pm_runtime_put_noidle(lis3->pm_dev);
778 		pm_schedule_suspend(lis3->pm_dev, LIS3_SYSFS_POWERDOWN_DELAY);
779 	}
780 }
781 
782 static ssize_t lis3lv02d_selftest_show(struct device *dev,
783 				struct device_attribute *attr, char *buf)
784 {
785 	struct lis3lv02d *lis3 = dev_get_drvdata(dev);
786 	s16 values[3];
787 
788 	static const char ok[] = "OK";
789 	static const char fail[] = "FAIL";
790 	static const char irq[] = "FAIL_IRQ";
791 	const char *res;
792 
793 	lis3lv02d_sysfs_poweron(lis3);
794 	switch (lis3lv02d_selftest(lis3, values)) {
795 	case SELFTEST_FAIL:
796 		res = fail;
797 		break;
798 	case SELFTEST_IRQ:
799 		res = irq;
800 		break;
801 	case SELFTEST_OK:
802 	default:
803 		res = ok;
804 		break;
805 	}
806 	return sprintf(buf, "%s %d %d %d\n", res,
807 		values[0], values[1], values[2]);
808 }
809 
810 static ssize_t lis3lv02d_position_show(struct device *dev,
811 				struct device_attribute *attr, char *buf)
812 {
813 	struct lis3lv02d *lis3 = dev_get_drvdata(dev);
814 	int x, y, z;
815 
816 	lis3lv02d_sysfs_poweron(lis3);
817 	mutex_lock(&lis3->mutex);
818 	lis3lv02d_get_xyz(lis3, &x, &y, &z);
819 	mutex_unlock(&lis3->mutex);
820 	return sprintf(buf, "(%d,%d,%d)\n", x, y, z);
821 }
822 
823 static ssize_t lis3lv02d_rate_show(struct device *dev,
824 			struct device_attribute *attr, char *buf)
825 {
826 	struct lis3lv02d *lis3 = dev_get_drvdata(dev);
827 	int odr_idx;
828 
829 	lis3lv02d_sysfs_poweron(lis3);
830 
831 	odr_idx = lis3lv02d_get_odr_index(lis3);
832 	return sprintf(buf, "%d\n", lis3->odrs[odr_idx]);
833 }
834 
835 static ssize_t lis3lv02d_rate_set(struct device *dev,
836 				struct device_attribute *attr, const char *buf,
837 				size_t count)
838 {
839 	struct lis3lv02d *lis3 = dev_get_drvdata(dev);
840 	unsigned long rate;
841 	int ret;
842 
843 	ret = kstrtoul(buf, 0, &rate);
844 	if (ret)
845 		return ret;
846 
847 	lis3lv02d_sysfs_poweron(lis3);
848 	if (lis3lv02d_set_odr(lis3, rate))
849 		return -EINVAL;
850 
851 	return count;
852 }
853 
854 static DEVICE_ATTR(selftest, S_IRUSR, lis3lv02d_selftest_show, NULL);
855 static DEVICE_ATTR(position, S_IRUGO, lis3lv02d_position_show, NULL);
856 static DEVICE_ATTR(rate, S_IRUGO | S_IWUSR, lis3lv02d_rate_show,
857 					    lis3lv02d_rate_set);
858 
859 static struct attribute *lis3lv02d_attributes[] = {
860 	&dev_attr_selftest.attr,
861 	&dev_attr_position.attr,
862 	&dev_attr_rate.attr,
863 	NULL
864 };
865 
866 static const struct attribute_group lis3lv02d_attribute_group = {
867 	.attrs = lis3lv02d_attributes
868 };
869 
870 
871 static int lis3lv02d_add_fs(struct lis3lv02d *lis3)
872 {
873 	lis3->pdev = platform_device_register_simple(DRIVER_NAME, -1, NULL, 0);
874 	if (IS_ERR(lis3->pdev))
875 		return PTR_ERR(lis3->pdev);
876 
877 	platform_set_drvdata(lis3->pdev, lis3);
878 	return sysfs_create_group(&lis3->pdev->dev.kobj, &lis3lv02d_attribute_group);
879 }
880 
881 void lis3lv02d_remove_fs(struct lis3lv02d *lis3)
882 {
883 	sysfs_remove_group(&lis3->pdev->dev.kobj, &lis3lv02d_attribute_group);
884 	platform_device_unregister(lis3->pdev);
885 	if (lis3->pm_dev) {
886 		/* Barrier after the sysfs remove */
887 		pm_runtime_barrier(lis3->pm_dev);
888 
889 		/* SYSFS may have left chip running. Turn off if necessary */
890 		if (!pm_runtime_suspended(lis3->pm_dev))
891 			lis3lv02d_poweroff(lis3);
892 
893 		pm_runtime_disable(lis3->pm_dev);
894 		pm_runtime_set_suspended(lis3->pm_dev);
895 	}
896 	kfree(lis3->reg_cache);
897 }
898 EXPORT_SYMBOL_GPL(lis3lv02d_remove_fs);
899 
900 static void lis3lv02d_8b_configure(struct lis3lv02d *lis3,
901 				struct lis3lv02d_platform_data *p)
902 {
903 	int err;
904 	int ctrl2 = p->hipass_ctrl;
905 
906 	if (p->click_flags) {
907 		lis3->write(lis3, CLICK_CFG, p->click_flags);
908 		lis3->write(lis3, CLICK_TIMELIMIT, p->click_time_limit);
909 		lis3->write(lis3, CLICK_LATENCY, p->click_latency);
910 		lis3->write(lis3, CLICK_WINDOW, p->click_window);
911 		lis3->write(lis3, CLICK_THSZ, p->click_thresh_z & 0xf);
912 		lis3->write(lis3, CLICK_THSY_X,
913 			(p->click_thresh_x & 0xf) |
914 			(p->click_thresh_y << 4));
915 
916 		if (lis3->idev) {
917 			input_set_capability(lis3->idev, EV_KEY, BTN_X);
918 			input_set_capability(lis3->idev, EV_KEY, BTN_Y);
919 			input_set_capability(lis3->idev, EV_KEY, BTN_Z);
920 		}
921 	}
922 
923 	if (p->wakeup_flags) {
924 		lis3->write(lis3, FF_WU_CFG_1, p->wakeup_flags);
925 		lis3->write(lis3, FF_WU_THS_1, p->wakeup_thresh & 0x7f);
926 		/* pdata value + 1 to keep this backward compatible*/
927 		lis3->write(lis3, FF_WU_DURATION_1, p->duration1 + 1);
928 		ctrl2 ^= HP_FF_WU1; /* Xor to keep compatible with old pdata*/
929 	}
930 
931 	if (p->wakeup_flags2) {
932 		lis3->write(lis3, FF_WU_CFG_2, p->wakeup_flags2);
933 		lis3->write(lis3, FF_WU_THS_2, p->wakeup_thresh2 & 0x7f);
934 		/* pdata value + 1 to keep this backward compatible*/
935 		lis3->write(lis3, FF_WU_DURATION_2, p->duration2 + 1);
936 		ctrl2 ^= HP_FF_WU2; /* Xor to keep compatible with old pdata*/
937 	}
938 	/* Configure hipass filters */
939 	lis3->write(lis3, CTRL_REG2, ctrl2);
940 
941 	if (p->irq2) {
942 		err = request_threaded_irq(p->irq2,
943 					NULL,
944 					lis302dl_interrupt_thread2_8b,
945 					IRQF_TRIGGER_RISING | IRQF_ONESHOT |
946 					(p->irq_flags2 & IRQF_TRIGGER_MASK),
947 					DRIVER_NAME, lis3);
948 		if (err < 0)
949 			pr_err("No second IRQ. Limited functionality\n");
950 	}
951 }
952 
953 #ifdef CONFIG_OF
954 int lis3lv02d_init_dt(struct lis3lv02d *lis3)
955 {
956 	struct lis3lv02d_platform_data *pdata;
957 	struct device_node *np = lis3->of_node;
958 	u32 val;
959 	s32 sval;
960 
961 	if (!lis3->of_node)
962 		return 0;
963 
964 	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
965 	if (!pdata)
966 		return -ENOMEM;
967 
968 	if (of_property_read_bool(np, "st,click-single-x"))
969 		pdata->click_flags |= LIS3_CLICK_SINGLE_X;
970 	if (of_property_read_bool(np, "st,click-double-x"))
971 		pdata->click_flags |= LIS3_CLICK_DOUBLE_X;
972 
973 	if (of_property_read_bool(np, "st,click-single-y"))
974 		pdata->click_flags |= LIS3_CLICK_SINGLE_Y;
975 	if (of_property_read_bool(np, "st,click-double-y"))
976 		pdata->click_flags |= LIS3_CLICK_DOUBLE_Y;
977 
978 	if (of_property_read_bool(np, "st,click-single-z"))
979 		pdata->click_flags |= LIS3_CLICK_SINGLE_Z;
980 	if (of_property_read_bool(np, "st,click-double-z"))
981 		pdata->click_flags |= LIS3_CLICK_DOUBLE_Z;
982 
983 	if (!of_property_read_u32(np, "st,click-threshold-x", &val))
984 		pdata->click_thresh_x = val;
985 	if (!of_property_read_u32(np, "st,click-threshold-y", &val))
986 		pdata->click_thresh_y = val;
987 	if (!of_property_read_u32(np, "st,click-threshold-z", &val))
988 		pdata->click_thresh_z = val;
989 
990 	if (!of_property_read_u32(np, "st,click-time-limit", &val))
991 		pdata->click_time_limit = val;
992 	if (!of_property_read_u32(np, "st,click-latency", &val))
993 		pdata->click_latency = val;
994 	if (!of_property_read_u32(np, "st,click-window", &val))
995 		pdata->click_window = val;
996 
997 	if (of_property_read_bool(np, "st,irq1-disable"))
998 		pdata->irq_cfg |= LIS3_IRQ1_DISABLE;
999 	if (of_property_read_bool(np, "st,irq1-ff-wu-1"))
1000 		pdata->irq_cfg |= LIS3_IRQ1_FF_WU_1;
1001 	if (of_property_read_bool(np, "st,irq1-ff-wu-2"))
1002 		pdata->irq_cfg |= LIS3_IRQ1_FF_WU_2;
1003 	if (of_property_read_bool(np, "st,irq1-data-ready"))
1004 		pdata->irq_cfg |= LIS3_IRQ1_DATA_READY;
1005 	if (of_property_read_bool(np, "st,irq1-click"))
1006 		pdata->irq_cfg |= LIS3_IRQ1_CLICK;
1007 
1008 	if (of_property_read_bool(np, "st,irq2-disable"))
1009 		pdata->irq_cfg |= LIS3_IRQ2_DISABLE;
1010 	if (of_property_read_bool(np, "st,irq2-ff-wu-1"))
1011 		pdata->irq_cfg |= LIS3_IRQ2_FF_WU_1;
1012 	if (of_property_read_bool(np, "st,irq2-ff-wu-2"))
1013 		pdata->irq_cfg |= LIS3_IRQ2_FF_WU_2;
1014 	if (of_property_read_bool(np, "st,irq2-data-ready"))
1015 		pdata->irq_cfg |= LIS3_IRQ2_DATA_READY;
1016 	if (of_property_read_bool(np, "st,irq2-click"))
1017 		pdata->irq_cfg |= LIS3_IRQ2_CLICK;
1018 
1019 	if (of_property_read_bool(np, "st,irq-open-drain"))
1020 		pdata->irq_cfg |= LIS3_IRQ_OPEN_DRAIN;
1021 	if (of_property_read_bool(np, "st,irq-active-low"))
1022 		pdata->irq_cfg |= LIS3_IRQ_ACTIVE_LOW;
1023 
1024 	if (!of_property_read_u32(np, "st,wu-duration-1", &val))
1025 		pdata->duration1 = val;
1026 	if (!of_property_read_u32(np, "st,wu-duration-2", &val))
1027 		pdata->duration2 = val;
1028 
1029 	if (of_property_read_bool(np, "st,wakeup-x-lo"))
1030 		pdata->wakeup_flags |= LIS3_WAKEUP_X_LO;
1031 	if (of_property_read_bool(np, "st,wakeup-x-hi"))
1032 		pdata->wakeup_flags |= LIS3_WAKEUP_X_HI;
1033 	if (of_property_read_bool(np, "st,wakeup-y-lo"))
1034 		pdata->wakeup_flags |= LIS3_WAKEUP_Y_LO;
1035 	if (of_property_read_bool(np, "st,wakeup-y-hi"))
1036 		pdata->wakeup_flags |= LIS3_WAKEUP_Y_HI;
1037 	if (of_property_read_bool(np, "st,wakeup-z-lo"))
1038 		pdata->wakeup_flags |= LIS3_WAKEUP_Z_LO;
1039 	if (of_property_read_bool(np, "st,wakeup-z-hi"))
1040 		pdata->wakeup_flags |= LIS3_WAKEUP_Z_HI;
1041 	if (of_get_property(np, "st,wakeup-threshold", &val))
1042 		pdata->wakeup_thresh = val;
1043 
1044 	if (of_property_read_bool(np, "st,wakeup2-x-lo"))
1045 		pdata->wakeup_flags2 |= LIS3_WAKEUP_X_LO;
1046 	if (of_property_read_bool(np, "st,wakeup2-x-hi"))
1047 		pdata->wakeup_flags2 |= LIS3_WAKEUP_X_HI;
1048 	if (of_property_read_bool(np, "st,wakeup2-y-lo"))
1049 		pdata->wakeup_flags2 |= LIS3_WAKEUP_Y_LO;
1050 	if (of_property_read_bool(np, "st,wakeup2-y-hi"))
1051 		pdata->wakeup_flags2 |= LIS3_WAKEUP_Y_HI;
1052 	if (of_property_read_bool(np, "st,wakeup2-z-lo"))
1053 		pdata->wakeup_flags2 |= LIS3_WAKEUP_Z_LO;
1054 	if (of_property_read_bool(np, "st,wakeup2-z-hi"))
1055 		pdata->wakeup_flags2 |= LIS3_WAKEUP_Z_HI;
1056 	if (of_get_property(np, "st,wakeup2-threshold", &val))
1057 		pdata->wakeup_thresh2 = val;
1058 
1059 	if (!of_property_read_u32(np, "st,highpass-cutoff-hz", &val)) {
1060 		switch (val) {
1061 		case 1:
1062 			pdata->hipass_ctrl = LIS3_HIPASS_CUTFF_1HZ;
1063 			break;
1064 		case 2:
1065 			pdata->hipass_ctrl = LIS3_HIPASS_CUTFF_2HZ;
1066 			break;
1067 		case 4:
1068 			pdata->hipass_ctrl = LIS3_HIPASS_CUTFF_4HZ;
1069 			break;
1070 		case 8:
1071 			pdata->hipass_ctrl = LIS3_HIPASS_CUTFF_8HZ;
1072 			break;
1073 		}
1074 	}
1075 
1076 	if (of_property_read_bool(np, "st,hipass1-disable"))
1077 		pdata->hipass_ctrl |= LIS3_HIPASS1_DISABLE;
1078 	if (of_property_read_bool(np, "st,hipass2-disable"))
1079 		pdata->hipass_ctrl |= LIS3_HIPASS2_DISABLE;
1080 
1081 	if (of_property_read_s32(np, "st,axis-x", &sval) == 0)
1082 		pdata->axis_x = sval;
1083 	if (of_property_read_s32(np, "st,axis-y", &sval) == 0)
1084 		pdata->axis_y = sval;
1085 	if (of_property_read_s32(np, "st,axis-z", &sval) == 0)
1086 		pdata->axis_z = sval;
1087 
1088 	if (of_property_read_u32(np, "st,default-rate", &val) == 0)
1089 		pdata->default_rate = val;
1090 
1091 	if (of_property_read_s32(np, "st,min-limit-x", &sval) == 0)
1092 		pdata->st_min_limits[0] = sval;
1093 	if (of_property_read_s32(np, "st,min-limit-y", &sval) == 0)
1094 		pdata->st_min_limits[1] = sval;
1095 	if (of_property_read_s32(np, "st,min-limit-z", &sval) == 0)
1096 		pdata->st_min_limits[2] = sval;
1097 
1098 	if (of_property_read_s32(np, "st,max-limit-x", &sval) == 0)
1099 		pdata->st_max_limits[0] = sval;
1100 	if (of_property_read_s32(np, "st,max-limit-y", &sval) == 0)
1101 		pdata->st_max_limits[1] = sval;
1102 	if (of_property_read_s32(np, "st,max-limit-z", &sval) == 0)
1103 		pdata->st_max_limits[2] = sval;
1104 
1105 
1106 	lis3->pdata = pdata;
1107 
1108 	return 0;
1109 }
1110 
1111 #else
1112 int lis3lv02d_init_dt(struct lis3lv02d *lis3)
1113 {
1114 	return 0;
1115 }
1116 #endif
1117 EXPORT_SYMBOL_GPL(lis3lv02d_init_dt);
1118 
1119 /*
1120  * Initialise the accelerometer and the various subsystems.
1121  * Should be rather independent of the bus system.
1122  */
1123 int lis3lv02d_init_device(struct lis3lv02d *lis3)
1124 {
1125 	int err;
1126 	irq_handler_t thread_fn;
1127 	int irq_flags = 0;
1128 
1129 	lis3->whoami = lis3lv02d_read_8(lis3, WHO_AM_I);
1130 
1131 	switch (lis3->whoami) {
1132 	case WAI_12B:
1133 		pr_info("12 bits sensor found\n");
1134 		lis3->read_data = lis3lv02d_read_12;
1135 		lis3->mdps_max_val = 2048;
1136 		lis3->pwron_delay = LIS3_PWRON_DELAY_WAI_12B;
1137 		lis3->odrs = lis3_12_rates;
1138 		lis3->odr_mask = CTRL1_DF0 | CTRL1_DF1;
1139 		lis3->scale = LIS3_SENSITIVITY_12B;
1140 		lis3->regs = lis3_wai12_regs;
1141 		lis3->regs_size = ARRAY_SIZE(lis3_wai12_regs);
1142 		break;
1143 	case WAI_8B:
1144 		pr_info("8 bits sensor found\n");
1145 		lis3->read_data = lis3lv02d_read_8;
1146 		lis3->mdps_max_val = 128;
1147 		lis3->pwron_delay = LIS3_PWRON_DELAY_WAI_8B;
1148 		lis3->odrs = lis3_8_rates;
1149 		lis3->odr_mask = CTRL1_DR;
1150 		lis3->scale = LIS3_SENSITIVITY_8B;
1151 		lis3->regs = lis3_wai8_regs;
1152 		lis3->regs_size = ARRAY_SIZE(lis3_wai8_regs);
1153 		break;
1154 	case WAI_3DC:
1155 		pr_info("8 bits 3DC sensor found\n");
1156 		lis3->read_data = lis3lv02d_read_8;
1157 		lis3->mdps_max_val = 128;
1158 		lis3->pwron_delay = LIS3_PWRON_DELAY_WAI_8B;
1159 		lis3->odrs = lis3_3dc_rates;
1160 		lis3->odr_mask = CTRL1_ODR0|CTRL1_ODR1|CTRL1_ODR2|CTRL1_ODR3;
1161 		lis3->scale = LIS3_SENSITIVITY_8B;
1162 		break;
1163 	case WAI_3DLH:
1164 		pr_info("16 bits lis331dlh sensor found\n");
1165 		lis3->read_data = lis331dlh_read_data;
1166 		lis3->mdps_max_val = 2048; /* 12 bits for 2G */
1167 		lis3->shift_adj = SHIFT_ADJ_2G;
1168 		lis3->pwron_delay = LIS3_PWRON_DELAY_WAI_8B;
1169 		lis3->odrs = lis3_3dlh_rates;
1170 		lis3->odr_mask = CTRL1_DR0 | CTRL1_DR1;
1171 		lis3->scale = LIS3DLH_SENSITIVITY_2G;
1172 		break;
1173 	default:
1174 		pr_err("unknown sensor type 0x%X\n", lis3->whoami);
1175 		return -ENODEV;
1176 	}
1177 
1178 	lis3->reg_cache = kzalloc(max(sizeof(lis3_wai8_regs),
1179 				     sizeof(lis3_wai12_regs)), GFP_KERNEL);
1180 
1181 	if (lis3->reg_cache == NULL)
1182 		return -ENOMEM;
1183 
1184 	mutex_init(&lis3->mutex);
1185 	atomic_set(&lis3->wake_thread, 0);
1186 
1187 	lis3lv02d_add_fs(lis3);
1188 	err = lis3lv02d_poweron(lis3);
1189 	if (err) {
1190 		lis3lv02d_remove_fs(lis3);
1191 		return err;
1192 	}
1193 
1194 	if (lis3->pm_dev) {
1195 		pm_runtime_set_active(lis3->pm_dev);
1196 		pm_runtime_enable(lis3->pm_dev);
1197 	}
1198 
1199 	if (lis3lv02d_joystick_enable(lis3))
1200 		pr_err("joystick initialization failed\n");
1201 
1202 	/* passing in platform specific data is purely optional and only
1203 	 * used by the SPI transport layer at the moment */
1204 	if (lis3->pdata) {
1205 		struct lis3lv02d_platform_data *p = lis3->pdata;
1206 
1207 		if (lis3->whoami == WAI_8B)
1208 			lis3lv02d_8b_configure(lis3, p);
1209 
1210 		irq_flags = p->irq_flags1 & IRQF_TRIGGER_MASK;
1211 
1212 		lis3->irq_cfg = p->irq_cfg;
1213 		if (p->irq_cfg)
1214 			lis3->write(lis3, CTRL_REG3, p->irq_cfg);
1215 
1216 		if (p->default_rate)
1217 			lis3lv02d_set_odr(lis3, p->default_rate);
1218 	}
1219 
1220 	/* bail if we did not get an IRQ from the bus layer */
1221 	if (!lis3->irq) {
1222 		pr_debug("No IRQ. Disabling /dev/freefall\n");
1223 		goto out;
1224 	}
1225 
1226 	/*
1227 	 * The sensor can generate interrupts for free-fall and direction
1228 	 * detection (distinguishable with FF_WU_SRC and DD_SRC) but to keep
1229 	 * the things simple and _fast_ we activate it only for free-fall, so
1230 	 * no need to read register (very slow with ACPI). For the same reason,
1231 	 * we forbid shared interrupts.
1232 	 *
1233 	 * IRQF_TRIGGER_RISING seems pointless on HP laptops because the
1234 	 * io-apic is not configurable (and generates a warning) but I keep it
1235 	 * in case of support for other hardware.
1236 	 */
1237 	if (lis3->pdata && lis3->whoami == WAI_8B)
1238 		thread_fn = lis302dl_interrupt_thread1_8b;
1239 	else
1240 		thread_fn = NULL;
1241 
1242 	err = request_threaded_irq(lis3->irq, lis302dl_interrupt,
1243 				thread_fn,
1244 				IRQF_TRIGGER_RISING | IRQF_ONESHOT |
1245 				irq_flags,
1246 				DRIVER_NAME, lis3);
1247 
1248 	if (err < 0) {
1249 		pr_err("Cannot get IRQ\n");
1250 		goto out;
1251 	}
1252 
1253 	lis3->miscdev.minor	= MISC_DYNAMIC_MINOR;
1254 	lis3->miscdev.name	= "freefall";
1255 	lis3->miscdev.fops	= &lis3lv02d_misc_fops;
1256 
1257 	if (misc_register(&lis3->miscdev))
1258 		pr_err("misc_register failed\n");
1259 out:
1260 	return 0;
1261 }
1262 EXPORT_SYMBOL_GPL(lis3lv02d_init_device);
1263 
1264 MODULE_DESCRIPTION("ST LIS3LV02Dx three-axis digital accelerometer driver");
1265 MODULE_AUTHOR("Yan Burman, Eric Piel, Pavel Machek");
1266 MODULE_LICENSE("GPL");
1267