add (disabled) fixup-handler

[ms2-fixes] / debounce.c

diff --git a/debounce.c b/debounce.c
index 0f45a4b09752dd2b832e2cf337856896ebf366d8..399e97bbdb28fdecf0b572fced0dc995487f5cb3 100644 (file)
--- a/debounce.c
+++ b/debounce.c
@@ -2,6 +2,8 @@
 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/gpio_event.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
 #include <mach/gpio.h>
 
 #define PREFIX "debounce: "
@@ -10,6 +12,7 @@ static unsigned old_flags = 0;
 static ktime_t old_debounce_delay;
 static ktime_t old_settle_time;
 static ktime_t old_poll_time;
+static int (*old_sw_fixup)(int index);
 static struct gpio_event_matrix_info *gpio_evmi = NULL;
 static int hw_debounce = 0;
 static int hw_debounce_time = 0;
@@ -45,6 +48,42 @@ static void hw_debounce_set(int enable, int time) {
        }
 }
 
+static void set_irq_types(void) {
+       int err;
+       unsigned int irq;
+       unsigned long type;
+       int i;
+
+       if (gpio_evmi == NULL)
+               return;
+
+       switch (gpio_evmi->flags & (GPIOKPF_ACTIVE_HIGH|GPIOKPF_LEVEL_TRIGGERED_IRQ)) {
+       default:
+               type = IRQ_TYPE_EDGE_FALLING;
+               break;
+       case GPIOKPF_ACTIVE_HIGH:
+               type = IRQ_TYPE_EDGE_RISING;
+               break;
+       case GPIOKPF_LEVEL_TRIGGERED_IRQ:
+               type = IRQ_TYPE_LEVEL_LOW;
+               break;
+       case GPIOKPF_LEVEL_TRIGGERED_IRQ | GPIOKPF_ACTIVE_HIGH:
+               type = IRQ_TYPE_LEVEL_HIGH;
+               break;
+       }
+
+       printk(KERN_INFO PREFIX "Settinhg IRQ type to 0x%lx\n", type);
+
+       for (i = 0; i < gpio_evmi->ninputs; i++) {
+
+               err = irq = gpio_to_irq(gpio_evmi->input_gpios[i]);
+
+               if (err < 0)
+                       return;
+
+               err = set_irq_type(irq, type);
+       }
+}
 
 static ssize_t show_debounce_delay(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -309,6 +348,36 @@ static ssize_t store_active_high_flag(struct device *dev, struct device_attribut
                gpio_evmi->flags &= ~GPIOKPF_ACTIVE_HIGH;
        }
 
+       set_irq_types();
+
+       return count;
+}
+
+static ssize_t show_level_triggered_irq_flag(struct device *dev, struct device_attribute *attr, char *buf)
+{
+       if (!gpio_evmi) 
+               return -ENODEV;
+
+       return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_LEVEL_TRIGGERED_IRQ) ? 1 : 0);
+}
+
+static ssize_t store_level_triggered_irq_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+       unsigned flag;
+
+       if (!gpio_evmi) 
+               return -ENODEV;
+
+       sscanf(buf, "%u", &flag);
+
+       if (flag) {
+               gpio_evmi->flags |= GPIOKPF_LEVEL_TRIGGERED_IRQ;
+       } else {
+               gpio_evmi->flags &= ~GPIOKPF_LEVEL_TRIGGERED_IRQ;
+       }
+
+       set_irq_types();
+
        return count;
 }
 
@@ -354,8 +423,10 @@ static ssize_t store_hw_debounce(struct device *dev, struct device_attribute *at
                hw_debounce = 1;
        }
        else {
+               hw_debounce_set(-1, 0);
                hw_debounce_set(0, -1);
                hw_debounce = 0;
+               hw_debounce_time = 0;
        }
 
        return count;
@@ -375,6 +446,9 @@ static ssize_t store_hw_debounce_time(struct device *dev, struct device_attribut
        if ((time < 0) || (time > 0xff))
                return count;
 
+       if (!hw_debounce)
+               return count;
+
        hw_debounce_set(-1, time);
        hw_debounce_time = time;
 
@@ -390,11 +464,27 @@ static DEVICE_ATTR(remove_some_phantom_keys_flag, (S_IRUGO | S_IWUGO), show_remo
 static DEVICE_ATTR(print_unmapped_keys_flag, (S_IRUGO | S_IWUGO), show_print_unmapped_keys_flag, store_print_unmapped_keys_flag);
 static DEVICE_ATTR(print_mapped_keys_flag, (S_IRUGO | S_IWUGO), show_print_mapped_keys_flag, store_print_mapped_keys_flag);
 static DEVICE_ATTR(print_phantom_keys_flag, (S_IRUGO | S_IWUGO), show_print_phantom_keys_flag, store_print_phantom_keys_flag);
-static DEVICE_ATTR(active_high_flag, (S_IRUGO), show_active_high_flag, store_active_high_flag);
+static DEVICE_ATTR(active_high_flag, (S_IRUGO | S_IWUGO), show_active_high_flag, store_active_high_flag);
+static DEVICE_ATTR(level_triggered_irq_flag, (S_IRUGO | S_IWUGO), show_level_triggered_irq_flag, store_level_triggered_irq_flag);
 static DEVICE_ATTR(drive_inactive_flag, (S_IRUGO | S_IWUGO), show_drive_inactive_flag, store_drive_inactive_flag);
 static DEVICE_ATTR(hw_debounce, (S_IRUGO | S_IWUGO), show_hw_debounce, store_hw_debounce);
 static DEVICE_ATTR(hw_debounce_time, (S_IRUGO | S_IWUGO), show_hw_debounce_time, store_hw_debounce_time);
 
+#if 0
+static int debounce_fixup(int index)
+{
+       int ret;
+
+       printk(KERN_INFO PREFIX "0x%x\n", index);
+
+       ret = old_sw_fixup(index);
+       if (!ret)
+               printk(KERN_INFO PREFIX "IGNORED!\n");
+
+       return ret;
+}
+#endif
+
 static void debounce_release(struct device *dev)
 {
 }
@@ -440,6 +530,7 @@ static int __init debounce_init(void)
        err = device_create_file(&debounce_device, &dev_attr_print_mapped_keys_flag);
        err = device_create_file(&debounce_device, &dev_attr_print_phantom_keys_flag);
        err = device_create_file(&debounce_device, &dev_attr_active_high_flag);
+       err = device_create_file(&debounce_device, &dev_attr_level_triggered_irq_flag);
        err = device_create_file(&debounce_device, &dev_attr_drive_inactive_flag);
        err = device_create_file(&debounce_device, &dev_attr_hw_debounce);
        err = device_create_file(&debounce_device, &dev_attr_hw_debounce_time);
@@ -453,8 +544,12 @@ static int __init debounce_init(void)
        old_settle_time = gpio_evmi->settle_time;
        old_poll_time = gpio_evmi->poll_time;
        old_flags = gpio_evmi->flags;
+       old_sw_fixup = gpio_evmi->sw_fixup;
 
-       printk(KERN_INFO PREFIX "flags: 0x%x\n", gpio_evmi->flags);
+#if 0
+       printk(KERN_INFO PREFIX "Registering fixup handler\n");
+       gpio_evmi->sw_fixup = debounce_fixup;
+#endif
 
        return 0;
 }
@@ -471,9 +566,15 @@ static void __exit debounce_exit(void)
                        printk(KERN_INFO PREFIX "Restoring flags\n");
                        gpio_evmi->flags = old_flags;
                        printk(KERN_INFO PREFIX "flags: 0x%x\n", gpio_evmi->flags);
+                       set_irq_types();
                }
                gpio_evmi->settle_time = old_settle_time;
                gpio_evmi->poll_time = old_poll_time;
+
+               if (gpio_evmi->sw_fixup != old_sw_fixup) {
+                       printk(KERN_INFO PREFIX "Restoring fixup handler\n");
+                       gpio_evmi->sw_fixup = old_sw_fixup;
+               }
        }
        hw_debounce_set(0, 0);
        device_remove_file(&debounce_device, &dev_attr_debounce_delay);
@@ -486,6 +587,7 @@ static void __exit debounce_exit(void)
        device_remove_file(&debounce_device, &dev_attr_print_mapped_keys_flag);
        device_remove_file(&debounce_device, &dev_attr_print_phantom_keys_flag);
        device_remove_file(&debounce_device, &dev_attr_active_high_flag);
+       device_remove_file(&debounce_device, &dev_attr_level_triggered_irq_flag);
        device_remove_file(&debounce_device, &dev_attr_drive_inactive_flag);
        device_remove_file(&debounce_device, &dev_attr_hw_debounce);
        device_remove_file(&debounce_device, &dev_attr_hw_debounce_time);