diff options
Diffstat (limited to 'drivers/hwmon/lis3lv02d.c')
-rw-r--r-- | drivers/hwmon/lis3lv02d.c | 187 |
1 files changed, 74 insertions, 113 deletions
diff --git a/drivers/hwmon/lis3lv02d.c b/drivers/hwmon/lis3lv02d.c index 778eb7795983..271338bdb6be 100644 --- a/drivers/hwmon/lis3lv02d.c +++ b/drivers/hwmon/lis3lv02d.c | |||
@@ -27,9 +27,7 @@ | |||
27 | #include <linux/types.h> | 27 | #include <linux/types.h> |
28 | #include <linux/platform_device.h> | 28 | #include <linux/platform_device.h> |
29 | #include <linux/interrupt.h> | 29 | #include <linux/interrupt.h> |
30 | #include <linux/input.h> | 30 | #include <linux/input-polldev.h> |
31 | #include <linux/kthread.h> | ||
32 | #include <linux/semaphore.h> | ||
33 | #include <linux/delay.h> | 31 | #include <linux/delay.h> |
34 | #include <linux/wait.h> | 32 | #include <linux/wait.h> |
35 | #include <linux/poll.h> | 33 | #include <linux/poll.h> |
@@ -105,56 +103,39 @@ static void lis3lv02d_get_xyz(struct lis3lv02d *lis3, int *x, int *y, int *z) | |||
105 | { | 103 | { |
106 | int position[3]; | 104 | int position[3]; |
107 | 105 | ||
108 | position[0] = lis3_dev.read_data(lis3, OUTX); | 106 | position[0] = lis3->read_data(lis3, OUTX); |
109 | position[1] = lis3_dev.read_data(lis3, OUTY); | 107 | position[1] = lis3->read_data(lis3, OUTY); |
110 | position[2] = lis3_dev.read_data(lis3, OUTZ); | 108 | position[2] = lis3->read_data(lis3, OUTZ); |
111 | 109 | ||
112 | *x = lis3lv02d_get_axis(lis3_dev.ac.x, position); | 110 | *x = lis3lv02d_get_axis(lis3->ac.x, position); |
113 | *y = lis3lv02d_get_axis(lis3_dev.ac.y, position); | 111 | *y = lis3lv02d_get_axis(lis3->ac.y, position); |
114 | *z = lis3lv02d_get_axis(lis3_dev.ac.z, position); | 112 | *z = lis3lv02d_get_axis(lis3->ac.z, position); |
115 | } | 113 | } |
116 | 114 | ||
117 | void lis3lv02d_poweroff(struct lis3lv02d *lis3) | 115 | void lis3lv02d_poweroff(struct lis3lv02d *lis3) |
118 | { | 116 | { |
119 | lis3_dev.is_on = 0; | 117 | /* disable X,Y,Z axis and power down */ |
118 | lis3->write(lis3, CTRL_REG1, 0x00); | ||
120 | } | 119 | } |
121 | EXPORT_SYMBOL_GPL(lis3lv02d_poweroff); | 120 | EXPORT_SYMBOL_GPL(lis3lv02d_poweroff); |
122 | 121 | ||
123 | void lis3lv02d_poweron(struct lis3lv02d *lis3) | 122 | void lis3lv02d_poweron(struct lis3lv02d *lis3) |
124 | { | 123 | { |
125 | lis3_dev.is_on = 1; | 124 | u8 reg; |
126 | lis3_dev.init(lis3); | ||
127 | } | ||
128 | EXPORT_SYMBOL_GPL(lis3lv02d_poweron); | ||
129 | 125 | ||
130 | /* | 126 | lis3->init(lis3); |
131 | * To be called before starting to use the device. It makes sure that the | ||
132 | * device will always be on until a call to lis3lv02d_decrease_use(). Not to be | ||
133 | * used from interrupt context. | ||
134 | */ | ||
135 | static void lis3lv02d_increase_use(struct lis3lv02d *dev) | ||
136 | { | ||
137 | mutex_lock(&dev->lock); | ||
138 | dev->usage++; | ||
139 | if (dev->usage == 1) { | ||
140 | if (!dev->is_on) | ||
141 | lis3lv02d_poweron(dev); | ||
142 | } | ||
143 | mutex_unlock(&dev->lock); | ||
144 | } | ||
145 | 127 | ||
146 | /* | 128 | /* |
147 | * To be called whenever a usage of the device is stopped. | 129 | * Common configuration |
148 | * It will make sure to turn off the device when there is not usage. | 130 | * BDU: LSB and MSB values are not updated until both have been read. |
149 | */ | 131 | * So the value read will always be correct. |
150 | static void lis3lv02d_decrease_use(struct lis3lv02d *dev) | 132 | */ |
151 | { | 133 | lis3->read(lis3, CTRL_REG2, ®); |
152 | mutex_lock(&dev->lock); | 134 | reg |= CTRL2_BDU; |
153 | dev->usage--; | 135 | lis3->write(lis3, CTRL_REG2, reg); |
154 | if (dev->usage == 0) | ||
155 | lis3lv02d_poweroff(dev); | ||
156 | mutex_unlock(&dev->lock); | ||
157 | } | 136 | } |
137 | EXPORT_SYMBOL_GPL(lis3lv02d_poweron); | ||
138 | |||
158 | 139 | ||
159 | static irqreturn_t lis302dl_interrupt(int irq, void *dummy) | 140 | static irqreturn_t lis302dl_interrupt(int irq, void *dummy) |
160 | { | 141 | { |
@@ -198,15 +179,12 @@ static int lis3lv02d_misc_open(struct inode *inode, struct file *file) | |||
198 | printk(KERN_ERR DRIVER_NAME ": IRQ%d allocation failed\n", lis3_dev.irq); | 179 | printk(KERN_ERR DRIVER_NAME ": IRQ%d allocation failed\n", lis3_dev.irq); |
199 | return -EBUSY; | 180 | return -EBUSY; |
200 | } | 181 | } |
201 | lis3lv02d_increase_use(&lis3_dev); | ||
202 | printk("lis3: registered interrupt %d\n", lis3_dev.irq); | ||
203 | return 0; | 182 | return 0; |
204 | } | 183 | } |
205 | 184 | ||
206 | static int lis3lv02d_misc_release(struct inode *inode, struct file *file) | 185 | static int lis3lv02d_misc_release(struct inode *inode, struct file *file) |
207 | { | 186 | { |
208 | fasync_helper(-1, file, 0, &lis3_dev.async_queue); | 187 | fasync_helper(-1, file, 0, &lis3_dev.async_queue); |
209 | lis3lv02d_decrease_use(&lis3_dev); | ||
210 | free_irq(lis3_dev.irq, &lis3_dev); | 188 | free_irq(lis3_dev.irq, &lis3_dev); |
211 | clear_bit(0, &lis3_dev.misc_opened); /* release the device */ | 189 | clear_bit(0, &lis3_dev.misc_opened); /* release the device */ |
212 | return 0; | 190 | return 0; |
@@ -290,46 +268,16 @@ static struct miscdevice lis3lv02d_misc_device = { | |||
290 | .fops = &lis3lv02d_misc_fops, | 268 | .fops = &lis3lv02d_misc_fops, |
291 | }; | 269 | }; |
292 | 270 | ||
293 | /** | 271 | static void lis3lv02d_joystick_poll(struct input_polled_dev *pidev) |
294 | * lis3lv02d_joystick_kthread - Kthread polling function | ||
295 | * @data: unused - here to conform to threadfn prototype | ||
296 | */ | ||
297 | static int lis3lv02d_joystick_kthread(void *data) | ||
298 | { | 272 | { |
299 | int x, y, z; | 273 | int x, y, z; |
300 | 274 | ||
301 | while (!kthread_should_stop()) { | 275 | lis3lv02d_get_xyz(&lis3_dev, &x, &y, &z); |
302 | lis3lv02d_get_xyz(&lis3_dev, &x, &y, &z); | 276 | input_report_abs(pidev->input, ABS_X, x - lis3_dev.xcalib); |
303 | input_report_abs(lis3_dev.idev, ABS_X, x - lis3_dev.xcalib); | 277 | input_report_abs(pidev->input, ABS_Y, y - lis3_dev.ycalib); |
304 | input_report_abs(lis3_dev.idev, ABS_Y, y - lis3_dev.ycalib); | 278 | input_report_abs(pidev->input, ABS_Z, z - lis3_dev.zcalib); |
305 | input_report_abs(lis3_dev.idev, ABS_Z, z - lis3_dev.zcalib); | ||
306 | |||
307 | input_sync(lis3_dev.idev); | ||
308 | |||
309 | try_to_freeze(); | ||
310 | msleep_interruptible(MDPS_POLL_INTERVAL); | ||
311 | } | ||
312 | |||
313 | return 0; | ||
314 | } | ||
315 | |||
316 | static int lis3lv02d_joystick_open(struct input_dev *input) | ||
317 | { | ||
318 | lis3lv02d_increase_use(&lis3_dev); | ||
319 | lis3_dev.kthread = kthread_run(lis3lv02d_joystick_kthread, NULL, "klis3lv02d"); | ||
320 | if (IS_ERR(lis3_dev.kthread)) { | ||
321 | lis3lv02d_decrease_use(&lis3_dev); | ||
322 | return PTR_ERR(lis3_dev.kthread); | ||
323 | } | ||
324 | |||
325 | return 0; | ||
326 | } | 279 | } |
327 | 280 | ||
328 | static void lis3lv02d_joystick_close(struct input_dev *input) | ||
329 | { | ||
330 | kthread_stop(lis3_dev.kthread); | ||
331 | lis3lv02d_decrease_use(&lis3_dev); | ||
332 | } | ||
333 | 281 | ||
334 | static inline void lis3lv02d_calibrate_joystick(void) | 282 | static inline void lis3lv02d_calibrate_joystick(void) |
335 | { | 283 | { |
@@ -339,33 +287,36 @@ static inline void lis3lv02d_calibrate_joystick(void) | |||
339 | 287 | ||
340 | int lis3lv02d_joystick_enable(void) | 288 | int lis3lv02d_joystick_enable(void) |
341 | { | 289 | { |
290 | struct input_dev *input_dev; | ||
342 | int err; | 291 | int err; |
343 | 292 | ||
344 | if (lis3_dev.idev) | 293 | if (lis3_dev.idev) |
345 | return -EINVAL; | 294 | return -EINVAL; |
346 | 295 | ||
347 | lis3_dev.idev = input_allocate_device(); | 296 | lis3_dev.idev = input_allocate_polled_device(); |
348 | if (!lis3_dev.idev) | 297 | if (!lis3_dev.idev) |
349 | return -ENOMEM; | 298 | return -ENOMEM; |
350 | 299 | ||
300 | lis3_dev.idev->poll = lis3lv02d_joystick_poll; | ||
301 | lis3_dev.idev->poll_interval = MDPS_POLL_INTERVAL; | ||
302 | input_dev = lis3_dev.idev->input; | ||
303 | |||
351 | lis3lv02d_calibrate_joystick(); | 304 | lis3lv02d_calibrate_joystick(); |
352 | 305 | ||
353 | lis3_dev.idev->name = "ST LIS3LV02DL Accelerometer"; | 306 | input_dev->name = "ST LIS3LV02DL Accelerometer"; |
354 | lis3_dev.idev->phys = DRIVER_NAME "/input0"; | 307 | input_dev->phys = DRIVER_NAME "/input0"; |
355 | lis3_dev.idev->id.bustype = BUS_HOST; | 308 | input_dev->id.bustype = BUS_HOST; |
356 | lis3_dev.idev->id.vendor = 0; | 309 | input_dev->id.vendor = 0; |
357 | lis3_dev.idev->dev.parent = &lis3_dev.pdev->dev; | 310 | input_dev->dev.parent = &lis3_dev.pdev->dev; |
358 | lis3_dev.idev->open = lis3lv02d_joystick_open; | ||
359 | lis3_dev.idev->close = lis3lv02d_joystick_close; | ||
360 | 311 | ||
361 | set_bit(EV_ABS, lis3_dev.idev->evbit); | 312 | set_bit(EV_ABS, input_dev->evbit); |
362 | input_set_abs_params(lis3_dev.idev, ABS_X, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3); | 313 | input_set_abs_params(input_dev, ABS_X, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3); |
363 | input_set_abs_params(lis3_dev.idev, ABS_Y, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3); | 314 | input_set_abs_params(input_dev, ABS_Y, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3); |
364 | input_set_abs_params(lis3_dev.idev, ABS_Z, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3); | 315 | input_set_abs_params(input_dev, ABS_Z, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3); |
365 | 316 | ||
366 | err = input_register_device(lis3_dev.idev); | 317 | err = input_register_polled_device(lis3_dev.idev); |
367 | if (err) { | 318 | if (err) { |
368 | input_free_device(lis3_dev.idev); | 319 | input_free_polled_device(lis3_dev.idev); |
369 | lis3_dev.idev = NULL; | 320 | lis3_dev.idev = NULL; |
370 | } | 321 | } |
371 | 322 | ||
@@ -378,8 +329,9 @@ void lis3lv02d_joystick_disable(void) | |||
378 | if (!lis3_dev.idev) | 329 | if (!lis3_dev.idev) |
379 | return; | 330 | return; |
380 | 331 | ||
381 | misc_deregister(&lis3lv02d_misc_device); | 332 | if (lis3_dev.irq) |
382 | input_unregister_device(lis3_dev.idev); | 333 | misc_deregister(&lis3lv02d_misc_device); |
334 | input_unregister_polled_device(lis3_dev.idev); | ||
383 | lis3_dev.idev = NULL; | 335 | lis3_dev.idev = NULL; |
384 | } | 336 | } |
385 | EXPORT_SYMBOL_GPL(lis3lv02d_joystick_disable); | 337 | EXPORT_SYMBOL_GPL(lis3lv02d_joystick_disable); |
@@ -390,9 +342,7 @@ static ssize_t lis3lv02d_position_show(struct device *dev, | |||
390 | { | 342 | { |
391 | int x, y, z; | 343 | int x, y, z; |
392 | 344 | ||
393 | lis3lv02d_increase_use(&lis3_dev); | ||
394 | lis3lv02d_get_xyz(&lis3_dev, &x, &y, &z); | 345 | lis3lv02d_get_xyz(&lis3_dev, &x, &y, &z); |
395 | lis3lv02d_decrease_use(&lis3_dev); | ||
396 | return sprintf(buf, "(%d,%d,%d)\n", x, y, z); | 346 | return sprintf(buf, "(%d,%d,%d)\n", x, y, z); |
397 | } | 347 | } |
398 | 348 | ||
@@ -406,9 +356,7 @@ static ssize_t lis3lv02d_calibrate_store(struct device *dev, | |||
406 | struct device_attribute *attr, | 356 | struct device_attribute *attr, |
407 | const char *buf, size_t count) | 357 | const char *buf, size_t count) |
408 | { | 358 | { |
409 | lis3lv02d_increase_use(&lis3_dev); | ||
410 | lis3lv02d_calibrate_joystick(); | 359 | lis3lv02d_calibrate_joystick(); |
411 | lis3lv02d_decrease_use(&lis3_dev); | ||
412 | return count; | 360 | return count; |
413 | } | 361 | } |
414 | 362 | ||
@@ -420,9 +368,7 @@ static ssize_t lis3lv02d_rate_show(struct device *dev, | |||
420 | u8 ctrl; | 368 | u8 ctrl; |
421 | int val; | 369 | int val; |
422 | 370 | ||
423 | lis3lv02d_increase_use(&lis3_dev); | ||
424 | lis3_dev.read(&lis3_dev, CTRL_REG1, &ctrl); | 371 | lis3_dev.read(&lis3_dev, CTRL_REG1, &ctrl); |
425 | lis3lv02d_decrease_use(&lis3_dev); | ||
426 | val = (ctrl & (CTRL1_DF0 | CTRL1_DF1)) >> 4; | 372 | val = (ctrl & (CTRL1_DF0 | CTRL1_DF1)) >> 4; |
427 | return sprintf(buf, "%d\n", lis3lv02dl_df_val[val]); | 373 | return sprintf(buf, "%d\n", lis3lv02dl_df_val[val]); |
428 | } | 374 | } |
@@ -446,17 +392,17 @@ static struct attribute_group lis3lv02d_attribute_group = { | |||
446 | 392 | ||
447 | static int lis3lv02d_add_fs(struct lis3lv02d *lis3) | 393 | static int lis3lv02d_add_fs(struct lis3lv02d *lis3) |
448 | { | 394 | { |
449 | lis3_dev.pdev = platform_device_register_simple(DRIVER_NAME, -1, NULL, 0); | 395 | lis3->pdev = platform_device_register_simple(DRIVER_NAME, -1, NULL, 0); |
450 | if (IS_ERR(lis3_dev.pdev)) | 396 | if (IS_ERR(lis3->pdev)) |
451 | return PTR_ERR(lis3_dev.pdev); | 397 | return PTR_ERR(lis3->pdev); |
452 | 398 | ||
453 | return sysfs_create_group(&lis3_dev.pdev->dev.kobj, &lis3lv02d_attribute_group); | 399 | return sysfs_create_group(&lis3->pdev->dev.kobj, &lis3lv02d_attribute_group); |
454 | } | 400 | } |
455 | 401 | ||
456 | int lis3lv02d_remove_fs(void) | 402 | int lis3lv02d_remove_fs(struct lis3lv02d *lis3) |
457 | { | 403 | { |
458 | sysfs_remove_group(&lis3_dev.pdev->dev.kobj, &lis3lv02d_attribute_group); | 404 | sysfs_remove_group(&lis3->pdev->dev.kobj, &lis3lv02d_attribute_group); |
459 | platform_device_unregister(lis3_dev.pdev); | 405 | platform_device_unregister(lis3->pdev); |
460 | return 0; | 406 | return 0; |
461 | } | 407 | } |
462 | EXPORT_SYMBOL_GPL(lis3lv02d_remove_fs); | 408 | EXPORT_SYMBOL_GPL(lis3lv02d_remove_fs); |
@@ -482,18 +428,35 @@ int lis3lv02d_init_device(struct lis3lv02d *dev) | |||
482 | break; | 428 | break; |
483 | default: | 429 | default: |
484 | printk(KERN_ERR DRIVER_NAME | 430 | printk(KERN_ERR DRIVER_NAME |
485 | ": unknown sensor type 0x%X\n", lis3_dev.whoami); | 431 | ": unknown sensor type 0x%X\n", dev->whoami); |
486 | return -EINVAL; | 432 | return -EINVAL; |
487 | } | 433 | } |
488 | 434 | ||
489 | mutex_init(&dev->lock); | ||
490 | lis3lv02d_add_fs(dev); | 435 | lis3lv02d_add_fs(dev); |
491 | lis3lv02d_increase_use(dev); | 436 | lis3lv02d_poweron(dev); |
492 | 437 | ||
493 | if (lis3lv02d_joystick_enable()) | 438 | if (lis3lv02d_joystick_enable()) |
494 | printk(KERN_ERR DRIVER_NAME ": joystick initialization failed\n"); | 439 | printk(KERN_ERR DRIVER_NAME ": joystick initialization failed\n"); |
495 | 440 | ||
496 | printk("lis3_init_device: irq %d\n", dev->irq); | 441 | /* passing in platform specific data is purely optional and only |
442 | * used by the SPI transport layer at the moment */ | ||
443 | if (dev->pdata) { | ||
444 | struct lis3lv02d_platform_data *p = dev->pdata; | ||
445 | |||
446 | if (p->click_flags && (dev->whoami == LIS_SINGLE_ID)) { | ||
447 | dev->write(dev, CLICK_CFG, p->click_flags); | ||
448 | dev->write(dev, CLICK_TIMELIMIT, p->click_time_limit); | ||
449 | dev->write(dev, CLICK_LATENCY, p->click_latency); | ||
450 | dev->write(dev, CLICK_WINDOW, p->click_window); | ||
451 | dev->write(dev, CLICK_THSZ, p->click_thresh_z & 0xf); | ||
452 | dev->write(dev, CLICK_THSY_X, | ||
453 | (p->click_thresh_x & 0xf) | | ||
454 | (p->click_thresh_y << 4)); | ||
455 | } | ||
456 | |||
457 | if (p->irq_cfg) | ||
458 | dev->write(dev, CTRL_REG3, p->irq_cfg); | ||
459 | } | ||
497 | 460 | ||
498 | /* bail if we did not get an IRQ from the bus layer */ | 461 | /* bail if we did not get an IRQ from the bus layer */ |
499 | if (!dev->irq) { | 462 | if (!dev->irq) { |
@@ -502,11 +465,9 @@ int lis3lv02d_init_device(struct lis3lv02d *dev) | |||
502 | goto out; | 465 | goto out; |
503 | } | 466 | } |
504 | 467 | ||
505 | printk("lis3: registering device\n"); | ||
506 | if (misc_register(&lis3lv02d_misc_device)) | 468 | if (misc_register(&lis3lv02d_misc_device)) |
507 | printk(KERN_ERR DRIVER_NAME ": misc_register failed\n"); | 469 | printk(KERN_ERR DRIVER_NAME ": misc_register failed\n"); |
508 | out: | 470 | out: |
509 | lis3lv02d_decrease_use(dev); | ||
510 | return 0; | 471 | return 0; |
511 | } | 472 | } |
512 | EXPORT_SYMBOL_GPL(lis3lv02d_init_device); | 473 | EXPORT_SYMBOL_GPL(lis3lv02d_init_device); |