1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/kernel.h>
24#include <linux/init.h>
25#include <linux/dmi.h>
26#include <linux/module.h>
27#include <linux/types.h>
28#include <linux/platform_device.h>
29#include <linux/interrupt.h>
30#include <linux/input-polldev.h>
31#include <linux/delay.h>
32#include <linux/wait.h>
33#include <linux/poll.h>
34#include <linux/freezer.h>
35#include <linux/uaccess.h>
36#include <linux/miscdevice.h>
37#include <asm/atomic.h>
38#include "lis3lv02d.h"
39
40#define DRIVER_NAME "lis3lv02d"
41
42
43#define MDPS_POLL_INTERVAL 50
44
45
46
47
48
49
50
51
52
53struct lis3lv02d lis3_dev = {
54 .misc_wait = __WAIT_QUEUE_HEAD_INITIALIZER(lis3_dev.misc_wait),
55};
56
57EXPORT_SYMBOL_GPL(lis3_dev);
58
59static s16 lis3lv02d_read_8(struct lis3lv02d *lis3, int reg)
60{
61 s8 lo;
62 if (lis3->read(lis3, reg, &lo) < 0)
63 return 0;
64
65 return lo;
66}
67
68static s16 lis3lv02d_read_16(struct lis3lv02d *lis3, int reg)
69{
70 u8 lo, hi;
71
72 lis3->read(lis3, reg - 1, &lo);
73 lis3->read(lis3, reg, &hi);
74
75 return (s16)((hi << 8) | lo);
76}
77
78
79
80
81
82
83
84
85static inline int lis3lv02d_get_axis(s8 axis, int hw_values[3])
86{
87 if (axis > 0)
88 return hw_values[axis - 1];
89 else
90 return -hw_values[-axis - 1];
91}
92
93
94
95
96
97
98
99
100
101
102static void lis3lv02d_get_xyz(struct lis3lv02d *lis3, int *x, int *y, int *z)
103{
104 int position[3];
105
106 position[0] = lis3->read_data(lis3, OUTX);
107 position[1] = lis3->read_data(lis3, OUTY);
108 position[2] = lis3->read_data(lis3, OUTZ);
109
110 *x = lis3lv02d_get_axis(lis3->ac.x, position);
111 *y = lis3lv02d_get_axis(lis3->ac.y, position);
112 *z = lis3lv02d_get_axis(lis3->ac.z, position);
113}
114
115void lis3lv02d_poweroff(struct lis3lv02d *lis3)
116{
117
118 lis3->write(lis3, CTRL_REG1, 0x00);
119}
120EXPORT_SYMBOL_GPL(lis3lv02d_poweroff);
121
122void lis3lv02d_poweron(struct lis3lv02d *lis3)
123{
124 u8 reg;
125
126 lis3->init(lis3);
127
128
129
130
131
132
133 lis3->read(lis3, CTRL_REG2, ®);
134 reg |= CTRL2_BDU;
135 lis3->write(lis3, CTRL_REG2, reg);
136}
137EXPORT_SYMBOL_GPL(lis3lv02d_poweron);
138
139
140static irqreturn_t lis302dl_interrupt(int irq, void *dummy)
141{
142
143
144
145
146
147 atomic_inc(&lis3_dev.count);
148
149 wake_up_interruptible(&lis3_dev.misc_wait);
150 kill_fasync(&lis3_dev.async_queue, SIGIO, POLL_IN);
151 return IRQ_HANDLED;
152}
153
154static int lis3lv02d_misc_open(struct inode *inode, struct file *file)
155{
156 int ret;
157
158 if (test_and_set_bit(0, &lis3_dev.misc_opened))
159 return -EBUSY;
160
161 atomic_set(&lis3_dev.count, 0);
162
163
164
165
166
167
168
169
170
171
172
173
174 ret = request_irq(lis3_dev.irq, lis302dl_interrupt, IRQF_TRIGGER_RISING,
175 DRIVER_NAME, &lis3_dev);
176
177 if (ret) {
178 clear_bit(0, &lis3_dev.misc_opened);
179 printk(KERN_ERR DRIVER_NAME ": IRQ%d allocation failed\n", lis3_dev.irq);
180 return -EBUSY;
181 }
182 return 0;
183}
184
185static int lis3lv02d_misc_release(struct inode *inode, struct file *file)
186{
187 fasync_helper(-1, file, 0, &lis3_dev.async_queue);
188 free_irq(lis3_dev.irq, &lis3_dev);
189 clear_bit(0, &lis3_dev.misc_opened);
190 return 0;
191}
192
193static ssize_t lis3lv02d_misc_read(struct file *file, char __user *buf,
194 size_t count, loff_t *pos)
195{
196 DECLARE_WAITQUEUE(wait, current);
197 u32 data;
198 unsigned char byte_data;
199 ssize_t retval = 1;
200
201 if (count < 1)
202 return -EINVAL;
203
204 add_wait_queue(&lis3_dev.misc_wait, &wait);
205 while (true) {
206 set_current_state(TASK_INTERRUPTIBLE);
207 data = atomic_xchg(&lis3_dev.count, 0);
208 if (data)
209 break;
210
211 if (file->f_flags & O_NONBLOCK) {
212 retval = -EAGAIN;
213 goto out;
214 }
215
216 if (signal_pending(current)) {
217 retval = -ERESTARTSYS;
218 goto out;
219 }
220
221 schedule();
222 }
223
224 if (data < 255)
225 byte_data = data;
226 else
227 byte_data = 255;
228
229
230
231 set_current_state(TASK_RUNNING);
232 if (copy_to_user(buf, &byte_data, sizeof(byte_data)))
233 retval = -EFAULT;
234
235out:
236 __set_current_state(TASK_RUNNING);
237 remove_wait_queue(&lis3_dev.misc_wait, &wait);
238
239 return retval;
240}
241
242static unsigned int lis3lv02d_misc_poll(struct file *file, poll_table *wait)
243{
244 poll_wait(file, &lis3_dev.misc_wait, wait);
245 if (atomic_read(&lis3_dev.count))
246 return POLLIN | POLLRDNORM;
247 return 0;
248}
249
250static int lis3lv02d_misc_fasync(int fd, struct file *file, int on)
251{
252 return fasync_helper(fd, file, on, &lis3_dev.async_queue);
253}
254
255static const struct file_operations lis3lv02d_misc_fops = {
256 .owner = THIS_MODULE,
257 .llseek = no_llseek,
258 .read = lis3lv02d_misc_read,
259 .open = lis3lv02d_misc_open,
260 .release = lis3lv02d_misc_release,
261 .poll = lis3lv02d_misc_poll,
262 .fasync = lis3lv02d_misc_fasync,
263};
264
265static struct miscdevice lis3lv02d_misc_device = {
266 .minor = MISC_DYNAMIC_MINOR,
267 .name = "freefall",
268 .fops = &lis3lv02d_misc_fops,
269};
270
271static void lis3lv02d_joystick_poll(struct input_polled_dev *pidev)
272{
273 int x, y, z;
274
275 lis3lv02d_get_xyz(&lis3_dev, &x, &y, &z);
276 input_report_abs(pidev->input, ABS_X, x - lis3_dev.xcalib);
277 input_report_abs(pidev->input, ABS_Y, y - lis3_dev.ycalib);
278 input_report_abs(pidev->input, ABS_Z, z - lis3_dev.zcalib);
279}
280
281
282static inline void lis3lv02d_calibrate_joystick(void)
283{
284 lis3lv02d_get_xyz(&lis3_dev,
285 &lis3_dev.xcalib, &lis3_dev.ycalib, &lis3_dev.zcalib);
286}
287
288int lis3lv02d_joystick_enable(void)
289{
290 struct input_dev *input_dev;
291 int err;
292
293 if (lis3_dev.idev)
294 return -EINVAL;
295
296 lis3_dev.idev = input_allocate_polled_device();
297 if (!lis3_dev.idev)
298 return -ENOMEM;
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
304 lis3lv02d_calibrate_joystick();
305
306 input_dev->name = "ST LIS3LV02DL Accelerometer";
307 input_dev->phys = DRIVER_NAME "/input0";
308 input_dev->id.bustype = BUS_HOST;
309 input_dev->id.vendor = 0;
310 input_dev->dev.parent = &lis3_dev.pdev->dev;
311
312 set_bit(EV_ABS, input_dev->evbit);
313 input_set_abs_params(input_dev, ABS_X, -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);
315 input_set_abs_params(input_dev, ABS_Z, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3);
316
317 err = input_register_polled_device(lis3_dev.idev);
318 if (err) {
319 input_free_polled_device(lis3_dev.idev);
320 lis3_dev.idev = NULL;
321 }
322
323 return err;
324}
325EXPORT_SYMBOL_GPL(lis3lv02d_joystick_enable);
326
327void lis3lv02d_joystick_disable(void)
328{
329 if (!lis3_dev.idev)
330 return;
331
332 if (lis3_dev.irq)
333 misc_deregister(&lis3lv02d_misc_device);
334 input_unregister_polled_device(lis3_dev.idev);
335 lis3_dev.idev = NULL;
336}
337EXPORT_SYMBOL_GPL(lis3lv02d_joystick_disable);
338
339
340static ssize_t lis3lv02d_position_show(struct device *dev,
341 struct device_attribute *attr, char *buf)
342{
343 int x, y, z;
344
345 lis3lv02d_get_xyz(&lis3_dev, &x, &y, &z);
346 return sprintf(buf, "(%d,%d,%d)\n", x, y, z);
347}
348
349static ssize_t lis3lv02d_calibrate_show(struct device *dev,
350 struct device_attribute *attr, char *buf)
351{
352 return sprintf(buf, "(%d,%d,%d)\n", lis3_dev.xcalib, lis3_dev.ycalib, lis3_dev.zcalib);
353}
354
355static ssize_t lis3lv02d_calibrate_store(struct device *dev,
356 struct device_attribute *attr,
357 const char *buf, size_t count)
358{
359 lis3lv02d_calibrate_joystick();
360 return count;
361}
362
363
364static int lis3lv02dl_df_val[4] = {40, 160, 640, 2560};
365static ssize_t lis3lv02d_rate_show(struct device *dev,
366 struct device_attribute *attr, char *buf)
367{
368 u8 ctrl;
369 int val;
370
371 lis3_dev.read(&lis3_dev, CTRL_REG1, &ctrl);
372 val = (ctrl & (CTRL1_DF0 | CTRL1_DF1)) >> 4;
373 return sprintf(buf, "%d\n", lis3lv02dl_df_val[val]);
374}
375
376static DEVICE_ATTR(position, S_IRUGO, lis3lv02d_position_show, NULL);
377static DEVICE_ATTR(calibrate, S_IRUGO|S_IWUSR, lis3lv02d_calibrate_show,
378 lis3lv02d_calibrate_store);
379static DEVICE_ATTR(rate, S_IRUGO, lis3lv02d_rate_show, NULL);
380
381static struct attribute *lis3lv02d_attributes[] = {
382 &dev_attr_position.attr,
383 &dev_attr_calibrate.attr,
384 &dev_attr_rate.attr,
385 NULL
386};
387
388static struct attribute_group lis3lv02d_attribute_group = {
389 .attrs = lis3lv02d_attributes
390};
391
392
393static int lis3lv02d_add_fs(struct lis3lv02d *lis3)
394{
395 lis3->pdev = platform_device_register_simple(DRIVER_NAME, -1, NULL, 0);
396 if (IS_ERR(lis3->pdev))
397 return PTR_ERR(lis3->pdev);
398
399 return sysfs_create_group(&lis3->pdev->dev.kobj, &lis3lv02d_attribute_group);
400}
401
402int lis3lv02d_remove_fs(struct lis3lv02d *lis3)
403{
404 sysfs_remove_group(&lis3->pdev->dev.kobj, &lis3lv02d_attribute_group);
405 platform_device_unregister(lis3->pdev);
406 return 0;
407}
408EXPORT_SYMBOL_GPL(lis3lv02d_remove_fs);
409
410
411
412
413
414int lis3lv02d_init_device(struct lis3lv02d *dev)
415{
416 dev->whoami = lis3lv02d_read_8(dev, WHO_AM_I);
417
418 switch (dev->whoami) {
419 case LIS_DOUBLE_ID:
420 printk(KERN_INFO DRIVER_NAME ": 2-byte sensor found\n");
421 dev->read_data = lis3lv02d_read_16;
422 dev->mdps_max_val = 2048;
423 break;
424 case LIS_SINGLE_ID:
425 printk(KERN_INFO DRIVER_NAME ": 1-byte sensor found\n");
426 dev->read_data = lis3lv02d_read_8;
427 dev->mdps_max_val = 128;
428 break;
429 default:
430 printk(KERN_ERR DRIVER_NAME
431 ": unknown sensor type 0x%X\n", dev->whoami);
432 return -EINVAL;
433 }
434
435 lis3lv02d_add_fs(dev);
436 lis3lv02d_poweron(dev);
437
438 if (lis3lv02d_joystick_enable())
439 printk(KERN_ERR DRIVER_NAME ": joystick initialization failed\n");
440
441
442
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->wakeup_flags && (dev->whoami == LIS_SINGLE_ID)) {
458 dev->write(dev, FF_WU_CFG_1, p->wakeup_flags);
459 dev->write(dev, FF_WU_THS_1, p->wakeup_thresh & 0x7f);
460
461 dev->write(dev, FF_WU_DURATION_1, 1);
462
463 dev->write(dev, CTRL_REG2, HP_FF_WU1 | HP_FF_WU2);
464 }
465
466 if (p->irq_cfg)
467 dev->write(dev, CTRL_REG3, p->irq_cfg);
468 }
469
470
471 if (!dev->irq) {
472 printk(KERN_ERR DRIVER_NAME
473 ": No IRQ. Disabling /dev/freefall\n");
474 goto out;
475 }
476
477 if (misc_register(&lis3lv02d_misc_device))
478 printk(KERN_ERR DRIVER_NAME ": misc_register failed\n");
479out:
480 return 0;
481}
482EXPORT_SYMBOL_GPL(lis3lv02d_init_device);
483
484MODULE_DESCRIPTION("ST LIS3LV02Dx three-axis digital accelerometer driver");
485MODULE_AUTHOR("Yan Burman, Eric Piel, Pavel Machek");
486MODULE_LICENSE("GPL");
487
488