1 files changed, 190 insertions, 55 deletions

diff --git a/drivers/hwmon/lis3lv02d.c b/drivers/hwmon/lis3lv02d.c
index b2f2277cad3c..6138f036b159 100644
--- a/drivers/hwmon/lis3lv02d.c
+++ b/drivers/hwmon/lis3lv02d.c
@@ -41,6 +41,8 @@
 
 /* joystick device poll interval in milliseconds */
 #define MDPS_POLL_INTERVAL 50
+#define MDPS_POLL_MIN      0
+#define MDPS_POLL_MAX      2000
 /*
  * The sensor can also generate interrupts (DRDY) but it's pretty pointless
  * because they are generated even if the data do not change. So it's better
@@ -121,11 +123,9 @@ static void lis3lv02d_get_xyz(struct lis3lv02d *lis3, int *x, int *y, int *z)
         int position[3];
         int i;
 
-        mutex_lock(&lis3->mutex);
         position[0] = lis3->read_data(lis3, OUTX);
         position[1] = lis3->read_data(lis3, OUTY);
         position[2] = lis3->read_data(lis3, OUTZ);
-        mutex_unlock(&lis3->mutex);
 
         for (i = 0; i < 3; i++)
                 position[i] = (position[i] * lis3->scale) / LIS3_ACCURACY;
@@ -249,8 +249,24 @@ void lis3lv02d_poweron(struct lis3lv02d *lis3)
 EXPORT_SYMBOL_GPL(lis3lv02d_poweron);
 
 
+static void lis3lv02d_joystick_poll(struct input_polled_dev *pidev)
+{
+        int x, y, z;
+
+        mutex_lock(&lis3_dev.mutex);
+        lis3lv02d_get_xyz(&lis3_dev, &x, &y, &z);
+        input_report_abs(pidev->input, ABS_X, x);
+        input_report_abs(pidev->input, ABS_Y, y);
+        input_report_abs(pidev->input, ABS_Z, z);
+        input_sync(pidev->input);
+        mutex_unlock(&lis3_dev.mutex);
+}
+
 static irqreturn_t lis302dl_interrupt(int irq, void *dummy)
 {
+        if (!test_bit(0, &lis3_dev.misc_opened))
+                goto out;
+
         /*
          * Be careful: on some HP laptops the bios force DD when on battery and
          * the lid is closed. This leads to interrupts as soon as a little move
@@ -260,44 +276,93 @@ static irqreturn_t lis302dl_interrupt(int irq, void *dummy)
 
         wake_up_interruptible(&lis3_dev.misc_wait);
         kill_fasync(&lis3_dev.async_queue, SIGIO, POLL_IN);
+out:
+        if (lis3_dev.whoami == WAI_8B && lis3_dev.idev &&
+            lis3_dev.idev->input->users)
+                return IRQ_WAKE_THREAD;
         return IRQ_HANDLED;
 }
 
-static int lis3lv02d_misc_open(struct inode *inode, struct file *file)
+static void lis302dl_interrupt_handle_click(struct lis3lv02d *lis3)
 {
-        int ret;
+        struct input_dev *dev = lis3->idev->input;
+        u8 click_src;
 
-        if (test_and_set_bit(0, &lis3_dev.misc_opened))
-                return -EBUSY; /* already open */
+        mutex_lock(&lis3->mutex);
+        lis3->read(lis3, CLICK_SRC, &click_src);
 
-        atomic_set(&lis3_dev.count, 0);
+        if (click_src & CLICK_SINGLE_X) {
+                input_report_key(dev, lis3->mapped_btns[0], 1);
+                input_report_key(dev, lis3->mapped_btns[0], 0);
+        }
 
-        /*
-         * The sensor can generate interrupts for free-fall and direction
-         * detection (distinguishable with FF_WU_SRC and DD_SRC) but to keep
-         * the things simple and _fast_ we activate it only for free-fall, so
-         * no need to read register (very slow with ACPI). For the same reason,
-         * we forbid shared interrupts.
-         *
-         * IRQF_TRIGGER_RISING seems pointless on HP laptops because the
-         * io-apic is not configurable (and generates a warning) but I keep it
-         * in case of support for other hardware.
-         */
-        ret = request_irq(lis3_dev.irq, lis302dl_interrupt, IRQF_TRIGGER_RISING,
-                          DRIVER_NAME, &lis3_dev);
+        if (click_src & CLICK_SINGLE_Y) {
+                input_report_key(dev, lis3->mapped_btns[1], 1);
+                input_report_key(dev, lis3->mapped_btns[1], 0);
+        }
 
-        if (ret) {
-                clear_bit(0, &lis3_dev.misc_opened);
-                printk(KERN_ERR DRIVER_NAME ": IRQ%d allocation failed\n", lis3_dev.irq);
-                return -EBUSY;
+        if (click_src & CLICK_SINGLE_Z) {
+                input_report_key(dev, lis3->mapped_btns[2], 1);
+                input_report_key(dev, lis3->mapped_btns[2], 0);
         }
+        input_sync(dev);
+        mutex_unlock(&lis3->mutex);
+}
+
+static void lis302dl_interrupt_handle_ff_wu(struct lis3lv02d *lis3)
+{
+        u8 wu1_src;
+        u8 wu2_src;
+
+        lis3->read(lis3, FF_WU_SRC_1, &wu1_src);
+        lis3->read(lis3, FF_WU_SRC_2, &wu2_src);
+
+        wu1_src = wu1_src & FF_WU_SRC_IA ? wu1_src : 0;
+        wu2_src = wu2_src & FF_WU_SRC_IA ? wu2_src : 0;
+
+        /* joystick poll is internally protected by the lis3->mutex. */
+        if (wu1_src || wu2_src)
+                lis3lv02d_joystick_poll(lis3_dev.idev);
+}
+
+static irqreturn_t lis302dl_interrupt_thread1_8b(int irq, void *data)
+{
+
+        struct lis3lv02d *lis3 = data;
+
+        if ((lis3->pdata->irq_cfg & LIS3_IRQ1_MASK) == LIS3_IRQ1_CLICK)
+                lis302dl_interrupt_handle_click(lis3);
+        else
+                lis302dl_interrupt_handle_ff_wu(lis3);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t lis302dl_interrupt_thread2_8b(int irq, void *data)
+{
+
+        struct lis3lv02d *lis3 = data;
+
+        if ((lis3->pdata->irq_cfg & LIS3_IRQ2_MASK) == LIS3_IRQ2_CLICK)
+                lis302dl_interrupt_handle_click(lis3);
+        else
+                lis302dl_interrupt_handle_ff_wu(lis3);
+
+        return IRQ_HANDLED;
+}
+
+static int lis3lv02d_misc_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(0, &lis3_dev.misc_opened))
+                return -EBUSY; /* already open */
+
+        atomic_set(&lis3_dev.count, 0);
         return 0;
 }
 
 static int lis3lv02d_misc_release(struct inode *inode, struct file *file)
 {
         fasync_helper(-1, file, 0, &lis3_dev.async_queue);
-        free_irq(lis3_dev.irq, &lis3_dev);
         clear_bit(0, &lis3_dev.misc_opened); /* release the device */
         return 0;
 }
@@ -380,22 +445,12 @@ static struct miscdevice lis3lv02d_misc_device = {
         .fops    = &lis3lv02d_misc_fops,
 };
 
-static void lis3lv02d_joystick_poll(struct input_polled_dev *pidev)
-{
-        int x, y, z;
-
-        lis3lv02d_get_xyz(&lis3_dev, &x, &y, &z);
-        input_report_abs(pidev->input, ABS_X, x);
-        input_report_abs(pidev->input, ABS_Y, y);
-        input_report_abs(pidev->input, ABS_Z, z);
-        input_sync(pidev->input);
-}
-
 int lis3lv02d_joystick_enable(void)
 {
         struct input_dev *input_dev;
         int err;
         int max_val, fuzz, flat;
+        int btns[] = {BTN_X, BTN_Y, BTN_Z};
 
         if (lis3_dev.idev)
                 return -EINVAL;
@@ -406,6 +461,8 @@ int lis3lv02d_joystick_enable(void)
 
         lis3_dev.idev->poll = lis3lv02d_joystick_poll;
         lis3_dev.idev->poll_interval = MDPS_POLL_INTERVAL;
+        lis3_dev.idev->poll_interval_min = MDPS_POLL_MIN;
+        lis3_dev.idev->poll_interval_max = MDPS_POLL_MAX;
         input_dev = lis3_dev.idev->input;
 
         input_dev->name       = "ST LIS3LV02DL Accelerometer";
@@ -422,6 +479,10 @@ int lis3lv02d_joystick_enable(void)
         input_set_abs_params(input_dev, ABS_Y, -max_val, max_val, fuzz, flat);
         input_set_abs_params(input_dev, ABS_Z, -max_val, max_val, fuzz, flat);
 
+        lis3_dev.mapped_btns[0] = lis3lv02d_get_axis(abs(lis3_dev.ac.x), btns);
+        lis3_dev.mapped_btns[1] = lis3lv02d_get_axis(abs(lis3_dev.ac.y), btns);
+        lis3_dev.mapped_btns[2] = lis3lv02d_get_axis(abs(lis3_dev.ac.z), btns);
+
         err = input_register_polled_device(lis3_dev.idev);
         if (err) {
                 input_free_polled_device(lis3_dev.idev);
@@ -434,6 +495,11 @@ EXPORT_SYMBOL_GPL(lis3lv02d_joystick_enable);
 
 void lis3lv02d_joystick_disable(void)
 {
+        if (lis3_dev.irq)
+                free_irq(lis3_dev.irq, &lis3_dev);
+        if (lis3_dev.pdata && lis3_dev.pdata->irq2)
+                free_irq(lis3_dev.pdata->irq2, &lis3_dev);
+
         if (!lis3_dev.idev)
                 return;
 
@@ -462,7 +528,9 @@ static ssize_t lis3lv02d_position_show(struct device *dev,
 {
         int x, y, z;
 
+        mutex_lock(&lis3_dev.mutex);
         lis3lv02d_get_xyz(&lis3_dev, &x, &y, &z);
+        mutex_unlock(&lis3_dev.mutex);
         return sprintf(buf, "(%d,%d,%d)\n", x, y, z);
 }
 
@@ -521,12 +589,70 @@ int lis3lv02d_remove_fs(struct lis3lv02d *lis3)
 }
 EXPORT_SYMBOL_GPL(lis3lv02d_remove_fs);
 
+static void lis3lv02d_8b_configure(struct lis3lv02d *dev,
+                                struct lis3lv02d_platform_data *p)
+{
+        int err;
+        int ctrl2 = p->hipass_ctrl;
+
+        if (p->click_flags) {
+                dev->write(dev, CLICK_CFG, p->click_flags);
+                dev->write(dev, CLICK_TIMELIMIT, p->click_time_limit);
+                dev->write(dev, CLICK_LATENCY, p->click_latency);
+                dev->write(dev, CLICK_WINDOW, p->click_window);
+                dev->write(dev, CLICK_THSZ, p->click_thresh_z & 0xf);
+                dev->write(dev, CLICK_THSY_X,
+                        (p->click_thresh_x & 0xf) |
+                        (p->click_thresh_y << 4));
+
+                if (dev->idev) {
+                        struct input_dev *input_dev = lis3_dev.idev->input;
+                        input_set_capability(input_dev, EV_KEY, BTN_X);
+                        input_set_capability(input_dev, EV_KEY, BTN_Y);
+                        input_set_capability(input_dev, EV_KEY, BTN_Z);
+                }
+        }
+
+        if (p->wakeup_flags) {
+                dev->write(dev, FF_WU_CFG_1, p->wakeup_flags);
+                dev->write(dev, FF_WU_THS_1, p->wakeup_thresh & 0x7f);
+                /* default to 2.5ms for now */
+                dev->write(dev, FF_WU_DURATION_1, 1);
+                ctrl2 ^= HP_FF_WU1; /* Xor to keep compatible with old pdata*/
+        }
+
+        if (p->wakeup_flags2) {
+                dev->write(dev, FF_WU_CFG_2, p->wakeup_flags2);
+                dev->write(dev, FF_WU_THS_2, p->wakeup_thresh2 & 0x7f);
+                /* default to 2.5ms for now */
+                dev->write(dev, FF_WU_DURATION_2, 1);
+                ctrl2 ^= HP_FF_WU2; /* Xor to keep compatible with old pdata*/
+        }
+        /* Configure hipass filters */
+        dev->write(dev, CTRL_REG2, ctrl2);
+
+        if (p->irq2) {
+                err = request_threaded_irq(p->irq2,
+                                        NULL,
+                                        lis302dl_interrupt_thread2_8b,
+                                        IRQF_TRIGGER_RISING |
+                                        IRQF_ONESHOT,
+                                        DRIVER_NAME, &lis3_dev);
+                if (err < 0)
+                        printk(KERN_ERR DRIVER_NAME
+                                "No second IRQ. Limited functionality\n");
+        }
+}
+
 /*
  * Initialise the accelerometer and the various subsystems.
  * Should be rather independent of the bus system.
  */
 int lis3lv02d_init_device(struct lis3lv02d *dev)
 {
+        int err;
+        irq_handler_t thread_fn;
+
         dev->whoami = lis3lv02d_read_8(dev, WHO_AM_I);
 
         switch (dev->whoami) {
@@ -567,25 +693,8 @@ int lis3lv02d_init_device(struct lis3lv02d *dev)
         if (dev->pdata) {
                 struct lis3lv02d_platform_data *p = dev->pdata;
 
-                if (p->click_flags && (dev->whoami == WAI_8B)) {
-                        dev->write(dev, CLICK_CFG, p->click_flags);
-                        dev->write(dev, CLICK_TIMELIMIT, p->click_time_limit);
-                        dev->write(dev, CLICK_LATENCY, p->click_latency);
-                        dev->write(dev, CLICK_WINDOW, p->click_window);
-                        dev->write(dev, CLICK_THSZ, p->click_thresh_z & 0xf);
-                        dev->write(dev, CLICK_THSY_X,
-                                        (p->click_thresh_x & 0xf) |
-                                        (p->click_thresh_y << 4));
-                }
-
-                if (p->wakeup_flags && (dev->whoami == WAI_8B)) {
-                        dev->write(dev, FF_WU_CFG_1, p->wakeup_flags);
-                        dev->write(dev, FF_WU_THS_1, p->wakeup_thresh & 0x7f);
-                        /* default to 2.5ms for now */
-                        dev->write(dev, FF_WU_DURATION_1, 1);
-                        /* enable high pass filter for both free-fall units */
-                        dev->write(dev, CTRL_REG2, HP_FF_WU1 | HP_FF_WU2);
-                }
+                if (dev->whoami == WAI_8B)
+                        lis3lv02d_8b_configure(dev, p);
 
                 if (p->irq_cfg)
                         dev->write(dev, CTRL_REG3, p->irq_cfg);
@@ -598,6 +707,32 @@ int lis3lv02d_init_device(struct lis3lv02d *dev)
                 goto out;
         }
 
+        /*
+         * The sensor can generate interrupts for free-fall and direction
+         * detection (distinguishable with FF_WU_SRC and DD_SRC) but to keep
+         * the things simple and _fast_ we activate it only for free-fall, so
+         * no need to read register (very slow with ACPI). For the same reason,
+         * we forbid shared interrupts.
+         *
+         * IRQF_TRIGGER_RISING seems pointless on HP laptops because the
+         * io-apic is not configurable (and generates a warning) but I keep it
+         * in case of support for other hardware.
+         */
+        if (dev->whoami == WAI_8B)
+                thread_fn = lis302dl_interrupt_thread1_8b;
+        else
+                thread_fn = NULL;
+
+        err = request_threaded_irq(dev->irq, lis302dl_interrupt,
+                                thread_fn,
+                                IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+                                DRIVER_NAME, &lis3_dev);
+
+        if (err < 0) {
+                printk(KERN_ERR DRIVER_NAME "Cannot get IRQ\n");
+                goto out;
+        }
+
         if (misc_register(&lis3lv02d_misc_device))
                 printk(KERN_ERR DRIVER_NAME ": misc_register failed\n");
 out: