366190609c73c10c04830db52706a623c2191bc6
[sfrench/cifs-2.6.git] / drivers / hwmon / lis3lv02d.c
1 /*
2  *  lis3lv02d.c - ST LIS3LV02DL accelerometer driver
3  *
4  *  Copyright (C) 2007-2008 Yan Burman
5  *  Copyright (C) 2008 Eric Piel
6  *  Copyright (C) 2008-2009 Pavel Machek
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or
11  *  (at your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *  GNU General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License
19  *  along with this program; if not, write to the Free Software
20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 #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 /* joystick device poll interval in milliseconds */
43 #define MDPS_POLL_INTERVAL 50
44 /*
45  * The sensor can also generate interrupts (DRDY) but it's pretty pointless
46  * because their are generated even if the data do not change. So it's better
47  * to keep the interrupt for the free-fall event. The values are updated at
48  * 40Hz (at the lowest frequency), but as it can be pretty time consuming on
49  * some low processor, we poll the sensor only at 20Hz... enough for the
50  * joystick.
51  */
52
53 struct lis3lv02d lis3_dev = {
54         .misc_wait   = __WAIT_QUEUE_HEAD_INITIALIZER(lis3_dev.misc_wait),
55 };
56
57 EXPORT_SYMBOL_GPL(lis3_dev);
58
59 static 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
68 static 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         /* In "12 bit right justified" mode, bit 6, bit 7, bit 8 = bit 5 */
75         return (s16)((hi << 8) | lo);
76 }
77
78 /**
79  * lis3lv02d_get_axis - For the given axis, give the value converted
80  * @axis:      1,2,3 - can also be negative
81  * @hw_values: raw values returned by the hardware
82  *
83  * Returns the converted value.
84  */
85 static 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  * lis3lv02d_get_xyz - Get X, Y and Z axis values from the accelerometer
95  * @lis3: pointer to the device struct
96  * @x:    where to store the X axis value
97  * @y:    where to store the Y axis value
98  * @z:    where to store the Z axis value
99  *
100  * Note that 40Hz input device can eat up about 10% CPU at 800MHZ
101  */
102 static 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
115 void lis3lv02d_poweroff(struct lis3lv02d *lis3)
116 {
117         /* disable X,Y,Z axis and power down */
118         lis3->write(lis3, CTRL_REG1, 0x00);
119 }
120 EXPORT_SYMBOL_GPL(lis3lv02d_poweroff);
121
122 void lis3lv02d_poweron(struct lis3lv02d *lis3)
123 {
124         u8 reg;
125
126         lis3->init(lis3);
127
128         /*
129          * Common configuration
130          * BDU: LSB and MSB values are not updated until both have been read.
131          *      So the value read will always be correct.
132          */
133         lis3->read(lis3, CTRL_REG2, &reg);
134         reg |= CTRL2_BDU;
135         lis3->write(lis3, CTRL_REG2, reg);
136 }
137 EXPORT_SYMBOL_GPL(lis3lv02d_poweron);
138
139
140 static irqreturn_t lis302dl_interrupt(int irq, void *dummy)
141 {
142         /*
143          * Be careful: on some HP laptops the bios force DD when on battery and
144          * the lid is closed. This leads to interrupts as soon as a little move
145          * is done.
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
154 static 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; /* already open */
160
161         atomic_set(&lis3_dev.count, 0);
162
163         /*
164          * The sensor can generate interrupts for free-fall and direction
165          * detection (distinguishable with FF_WU_SRC and DD_SRC) but to keep
166          * the things simple and _fast_ we activate it only for free-fall, so
167          * no need to read register (very slow with ACPI). For the same reason,
168          * we forbid shared interrupts.
169          *
170          * IRQF_TRIGGER_RISING seems pointless on HP laptops because the
171          * io-apic is not configurable (and generates a warning) but I keep it
172          * in case of support for other hardware.
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
185 static 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); /* release the device */
190         return 0;
191 }
192
193 static 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         /* make sure we are not going into copy_to_user() with
230          * TASK_INTERRUPTIBLE state */
231         set_current_state(TASK_RUNNING);
232         if (copy_to_user(buf, &byte_data, sizeof(byte_data)))
233                 retval = -EFAULT;
234
235 out:
236         __set_current_state(TASK_RUNNING);
237         remove_wait_queue(&lis3_dev.misc_wait, &wait);
238
239         return retval;
240 }
241
242 static 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
250 static 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
255 static 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
265 static struct miscdevice lis3lv02d_misc_device = {
266         .minor   = MISC_DYNAMIC_MINOR,
267         .name    = "freefall",
268         .fops    = &lis3lv02d_misc_fops,
269 };
270
271 static 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
282 static 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
288 int 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 }
325 EXPORT_SYMBOL_GPL(lis3lv02d_joystick_enable);
326
327 void 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 }
337 EXPORT_SYMBOL_GPL(lis3lv02d_joystick_disable);
338
339 /* Sysfs stuff */
340 static 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
349 static 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
355 static 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 /* conversion btw sampling rate and the register values */
364 static int lis3lv02dl_df_val[4] = {40, 160, 640, 2560};
365 static 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
376 static DEVICE_ATTR(position, S_IRUGO, lis3lv02d_position_show, NULL);
377 static DEVICE_ATTR(calibrate, S_IRUGO|S_IWUSR, lis3lv02d_calibrate_show,
378         lis3lv02d_calibrate_store);
379 static DEVICE_ATTR(rate, S_IRUGO, lis3lv02d_rate_show, NULL);
380
381 static struct attribute *lis3lv02d_attributes[] = {
382         &dev_attr_position.attr,
383         &dev_attr_calibrate.attr,
384         &dev_attr_rate.attr,
385         NULL
386 };
387
388 static struct attribute_group lis3lv02d_attribute_group = {
389         .attrs = lis3lv02d_attributes
390 };
391
392
393 static 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
402 int 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 }
408 EXPORT_SYMBOL_GPL(lis3lv02d_remove_fs);
409
410 /*
411  * Initialise the accelerometer and the various subsystems.
412  * Should be rather independant of the bus system.
413  */
414 int 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         /* bail if we did not get an IRQ from the bus layer */
442         if (!dev->irq) {
443                 printk(KERN_ERR DRIVER_NAME
444                         ": No IRQ. Disabling /dev/freefall\n");
445                 goto out;
446         }
447
448         if (misc_register(&lis3lv02d_misc_device))
449                 printk(KERN_ERR DRIVER_NAME ": misc_register failed\n");
450 out:
451         return 0;
452 }
453 EXPORT_SYMBOL_GPL(lis3lv02d_init_device);
454
455 MODULE_DESCRIPTION("ST LIS3LV02Dx three-axis digital accelerometer driver");
456 MODULE_AUTHOR("Yan Burman, Eric Piel, Pavel Machek");
457 MODULE_LICENSE("GPL");
458