/drivers/misc/lis3lv02d/lis3lv02d.c

http://github.com/mirrors/linux · C · 1258 lines · 937 code · 205 blank · 116 comment · 192 complexity · 84f869bcce279b0d0e82632850d02923 MD5 · raw file

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