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