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