cvs.zerfleddert.de Git - ms2-fixes/blob - debounce.c

   1 #include <linux/module.h>
   2 #include <linux/device.h>
   3 #include <linux/platform_device.h>
   4 #include <linux/gpio_event.h>
   5 #include <mach/gpio.h>
   6
   7 #define PREFIX "debounce: "
   8
   9 static unsigned old_flags = 0;
  10 static ktime_t old_debounce_delay;
  11 static ktime_t old_settle_time;
  12 static ktime_t old_poll_time;
  13 static struct gpio_event_matrix_info *gpio_evmi = NULL;
  14 static int hw_debounce = 0;
  15 static int hw_debounce_time = 0;
  16
  17 static int find_ms2_dev(struct device *dev, void *data)
  18 {
  19         if (!strncmp((char*)data, dev_name(dev), strlen((char*)data))) {
  20                 printk(KERN_INFO PREFIX "Found it\n");
  21                 return 1;
  22         }
  23         return 0;
  24 }
  25
  26 /* hardware debounce: (time + 1) * 31us */
  27 static void hw_debounce_set(int enable, int time) {
  28         int i;
  29
  30         if (gpio_evmi == NULL)
  31                 return;
  32
  33         for (i = 0; i < gpio_evmi->ninputs; i++) {
  34                 int gpio = gpio_evmi->input_gpios[i];
  35
  36                 if ((time != -1) && (time != hw_debounce_time) && hw_debounce) {
  37                         printk(KERN_INFO PREFIX "Setting hardware debounce time for GPIO %d to %d (%dus)\n", gpio, time, (time+1)*31);
  38                         omap_set_gpio_debounce_time(gpio, time);
  39                 }
  40
  41                 if ((enable != -1) && (enable != hw_debounce)) {
  42                         printk(KERN_INFO PREFIX "%sabling hardware debounce for GPIO %d\n", (enable?"En":"Dis"), gpio);
  43                         omap_set_gpio_debounce(gpio, enable);
  44                 }
  45         }
  46 }
  47
  48
  49 static ssize_t show_debounce_delay(struct device *dev, struct device_attribute *attr, char *buf)
  50 {
  51         if (!gpio_evmi)
  52                 return -ENODEV;
  53
  54         return snprintf(buf, PAGE_SIZE, "%ld\n", (gpio_evmi->debounce_delay.tv.nsec / NSEC_PER_MSEC));
  55 }
  56
  57 static void set_debounce_delay(long delay)
  58 {
  59         if (gpio_evmi->debounce_delay.tv.nsec != delay * NSEC_PER_MSEC) {
  60                 printk(KERN_INFO PREFIX "Changing debounce_delay\n");
  61                 gpio_evmi->debounce_delay.tv.nsec = delay * NSEC_PER_MSEC;
  62                 printk(KERN_INFO PREFIX "debounce_delay: %u\n", gpio_evmi->debounce_delay.tv.nsec);
  63         }
  64
  65 #if 0
  66         if (gpio_evmi->debounce_delay.tv.nsec != 0) {
  67                 if (!(gpio_evmi->flags & GPIOKPF_DEBOUNCE)) {
  68                         printk(KERN_INFO PREFIX "Activating debounce\n");
  69                         gpio_evmi->flags |= GPIOKPF_DEBOUNCE;
  70                 }
  71         } else {
  72                 if (gpio_evmi->flags & GPIOKPF_DEBOUNCE) {
  73                         printk(KERN_INFO PREFIX "Deactivating debounce\n");
  74                         gpio_evmi->flags &= ~GPIOKPF_DEBOUNCE;
  75                 }
  76         }
  77 #endif
  78 }
  79
  80 static ssize_t store_debounce_delay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
  81 {
  82         long int delay;
  83
  84         if (!gpio_evmi)
  85                 return -ENODEV;
  86
  87         sscanf(buf, "%ld", &delay);
  88         set_debounce_delay(delay);
  89
  90         return count;
  91 }
  92
  93 static ssize_t show_settle_time(struct device *dev, struct device_attribute *attr, char *buf)
  94 {
  95         if (!gpio_evmi)
  96                 return -ENODEV;
  97
  98         return snprintf(buf, PAGE_SIZE, "%ld\n", (gpio_evmi->settle_time.tv.nsec / NSEC_PER_USEC));
  99 }
 100
 101 static ssize_t store_settle_time(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 102 {
 103         long int delay;
 104
 105         if (!gpio_evmi)
 106                 return -ENODEV;
 107
 108         sscanf(buf, "%ld", &delay);
 109         gpio_evmi->settle_time.tv.nsec = delay * NSEC_PER_USEC;
 110
 111         return count;
 112 }
 113
 114 static ssize_t show_poll_time(struct device *dev, struct device_attribute *attr, char *buf)
 115 {
 116         if (!gpio_evmi)
 117                 return -ENODEV;
 118
 119         return snprintf(buf, PAGE_SIZE, "%ld\n", (gpio_evmi->poll_time.tv.nsec / NSEC_PER_MSEC));
 120 }
 121
 122 static ssize_t store_poll_time(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 123 {
 124         long int delay;
 125
 126         if (!gpio_evmi)
 127                 return -ENODEV;
 128
 129         sscanf(buf, "%ld", &delay);
 130         gpio_evmi->poll_time.tv.nsec = delay * NSEC_PER_MSEC;
 131
 132         return count;
 133 }
 134
 135 static ssize_t show_flags(struct device *dev, struct device_attribute *attr, char *buf)
 136 {
 137         if (!gpio_evmi)
 138                 return -ENODEV;
 139
 140         return snprintf(buf, PAGE_SIZE, "0x%x\n", gpio_evmi->flags);
 141 }
 142
 143 static ssize_t store_flags(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 144 {
 145         unsigned flags;
 146
 147         if (!gpio_evmi)
 148                 return -ENODEV;
 149
 150         sscanf(buf, "0x%x", &flags);
 151
 152         printk(KERN_INFO PREFIX "flags: 0x%x\n", flags);
 153
 154         gpio_evmi->flags = flags;
 155
 156         return count;
 157 }
 158
 159 static ssize_t show_debounce_flag(struct device *dev, struct device_attribute *attr, char *buf)
 160 {
 161         if (!gpio_evmi)
 162                 return -ENODEV;
 163
 164         return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_DEBOUNCE) ? 1 : 0);
 165 }
 166
 167 static ssize_t store_debounce_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 168 {
 169         unsigned flag;
 170
 171         if (!gpio_evmi)
 172                 return -ENODEV;
 173
 174         sscanf(buf, "%u", &flag);
 175
 176         if (flag) {
 177                 gpio_evmi->flags |= GPIOKPF_DEBOUNCE;
 178         } else {
 179                 gpio_evmi->flags &= ~GPIOKPF_DEBOUNCE;
 180         }
 181
 182         return count;
 183 }
 184
 185 static ssize_t show_remove_some_phantom_keys_flag(struct device *dev, struct device_attribute *attr, char *buf)
 186 {
 187         if (!gpio_evmi)
 188                 return -ENODEV;
 189
 190         return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_REMOVE_SOME_PHANTOM_KEYS) ? 1 : 0);
 191 }
 192
 193 static ssize_t store_remove_some_phantom_keys_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 194 {
 195         unsigned flag;
 196
 197         if (!gpio_evmi)
 198                 return -ENODEV;
 199
 200         sscanf(buf, "%u", &flag);
 201
 202         if (flag) {
 203                 gpio_evmi->flags |= GPIOKPF_REMOVE_SOME_PHANTOM_KEYS;
 204         } else {
 205                 gpio_evmi->flags &= ~GPIOKPF_REMOVE_SOME_PHANTOM_KEYS;
 206         }
 207
 208         return count;
 209 }
 210
 211 static ssize_t show_print_unmapped_keys_flag(struct device *dev, struct device_attribute *attr, char *buf)
 212 {
 213         if (!gpio_evmi)
 214                 return -ENODEV;
 215
 216         return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS) ? 1 : 0);
 217 }
 218
 219 static ssize_t store_print_unmapped_keys_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 220 {
 221         unsigned flag;
 222
 223         if (!gpio_evmi)
 224                 return -ENODEV;
 225
 226         sscanf(buf, "%u", &flag);
 227
 228         if (flag) {
 229                 gpio_evmi->flags |= GPIOKPF_PRINT_UNMAPPED_KEYS;
 230         } else {
 231                 gpio_evmi->flags &= ~GPIOKPF_PRINT_UNMAPPED_KEYS;
 232         }
 233
 234         return count;
 235 }
 236
 237 static ssize_t show_print_mapped_keys_flag(struct device *dev, struct device_attribute *attr, char *buf)
 238 {
 239         if (!gpio_evmi)
 240                 return -ENODEV;
 241
 242         return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_PRINT_MAPPED_KEYS) ? 1 : 0);
 243 }
 244
 245 static ssize_t store_print_mapped_keys_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 246 {
 247         unsigned flag;
 248
 249         if (!gpio_evmi)
 250                 return -ENODEV;
 251
 252         sscanf(buf, "%u", &flag);
 253
 254         if (flag) {
 255                 gpio_evmi->flags |= GPIOKPF_PRINT_MAPPED_KEYS;
 256         } else {
 257                 gpio_evmi->flags &= ~GPIOKPF_PRINT_MAPPED_KEYS;
 258         }
 259
 260         return count;
 261 }
 262
 263 static ssize_t show_print_phantom_keys_flag(struct device *dev, struct device_attribute *attr, char *buf)
 264 {
 265         if (!gpio_evmi)
 266                 return -ENODEV;
 267
 268         return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_PRINT_PHANTOM_KEYS) ? 1 : 0);
 269 }
 270
 271 static ssize_t store_print_phantom_keys_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 272 {
 273         unsigned flag;
 274
 275         if (!gpio_evmi)
 276                 return -ENODEV;
 277
 278         sscanf(buf, "%u", &flag);
 279
 280         if (flag) {
 281                 gpio_evmi->flags |= GPIOKPF_PRINT_PHANTOM_KEYS;
 282         } else {
 283                 gpio_evmi->flags &= ~GPIOKPF_PRINT_PHANTOM_KEYS;
 284         }
 285
 286         return count;
 287 }
 288
 289 static ssize_t show_active_high_flag(struct device *dev, struct device_attribute *attr, char *buf)
 290 {
 291         if (!gpio_evmi)
 292                 return -ENODEV;
 293
 294         return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_ACTIVE_HIGH) ? 1 : 0);
 295 }
 296
 297 static ssize_t store_active_high_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 298 {
 299         unsigned flag;
 300
 301         if (!gpio_evmi)
 302                 return -ENODEV;
 303
 304         sscanf(buf, "%u", &flag);
 305
 306         if (flag) {
 307                 gpio_evmi->flags |= GPIOKPF_ACTIVE_HIGH;
 308         } else {
 309                 gpio_evmi->flags &= ~GPIOKPF_ACTIVE_HIGH;
 310         }
 311
 312         return count;
 313 }
 314
 315 static ssize_t show_drive_inactive_flag(struct device *dev, struct device_attribute *attr, char *buf)
 316 {
 317         if (!gpio_evmi)
 318                 return -ENODEV;
 319
 320         return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_DRIVE_INACTIVE) ? 1 : 0);
 321 }
 322
 323 static ssize_t store_drive_inactive_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 324 {
 325         unsigned flag;
 326
 327         if (!gpio_evmi)
 328                 return -ENODEV;
 329
 330         sscanf(buf, "%u", &flag);
 331
 332         if (flag) {
 333                 gpio_evmi->flags |= GPIOKPF_DRIVE_INACTIVE;
 334         } else {
 335                 gpio_evmi->flags &= ~GPIOKPF_DRIVE_INACTIVE;
 336         }
 337
 338         return count;
 339 }
 340
 341 static ssize_t show_hw_debounce(struct device *dev, struct device_attribute *attr, char *buf)
 342 {
 343         return snprintf(buf, PAGE_SIZE, "%d\n", hw_debounce);
 344 }
 345
 346 static ssize_t store_hw_debounce(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 347 {
 348         int enable;
 349
 350         sscanf(buf, "%d", &enable);
 351
 352         if (enable) {
 353                 hw_debounce_set(1, -1);
 354                 hw_debounce = 1;
 355                 hw_debounce_set(-1, 0);
 356                 hw_debounce_time = 0;
 357         }
 358         else {
 359                 hw_debounce_set(-1, 0);
 360                 hw_debounce_set(0, -1);
 361                 hw_debounce = 0;
 362                 hw_debounce_time = 0;
 363         }
 364
 365         return count;
 366 }
 367
 368 static ssize_t show_hw_debounce_time(struct device *dev, struct device_attribute *attr, char *buf)
 369 {
 370         return snprintf(buf, PAGE_SIZE, "%d\n", hw_debounce_time);
 371 }
 372
 373 static ssize_t store_hw_debounce_time(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 374 {
 375         int time;
 376
 377         sscanf(buf, "%d", &time);
 378
 379         if ((time < 0) || (time > 0xff))
 380                 return count;
 381
 382         hw_debounce_set(-1, time);
 383         hw_debounce_time = time;
 384
 385         return count;
 386 }
 387
 388 static DEVICE_ATTR(debounce_delay, (S_IRUGO | S_IWUGO), show_debounce_delay, store_debounce_delay);
 389 static DEVICE_ATTR(settle_time, (S_IRUGO | S_IWUGO), show_settle_time, store_settle_time);
 390 static DEVICE_ATTR(poll_time, (S_IRUGO | S_IWUGO), show_poll_time, store_poll_time);
 391 static DEVICE_ATTR(flags, (S_IRUGO), show_flags, store_flags);
 392 static DEVICE_ATTR(debounce_flag, (S_IRUGO | S_IWUGO), show_debounce_flag, store_debounce_flag);
 393 static DEVICE_ATTR(remove_some_phantom_keys_flag, (S_IRUGO | S_IWUGO), show_remove_some_phantom_keys_flag, store_remove_some_phantom_keys_flag);
 394 static DEVICE_ATTR(print_unmapped_keys_flag, (S_IRUGO | S_IWUGO), show_print_unmapped_keys_flag, store_print_unmapped_keys_flag);
 395 static DEVICE_ATTR(print_mapped_keys_flag, (S_IRUGO | S_IWUGO), show_print_mapped_keys_flag, store_print_mapped_keys_flag);
 396 static DEVICE_ATTR(print_phantom_keys_flag, (S_IRUGO | S_IWUGO), show_print_phantom_keys_flag, store_print_phantom_keys_flag);
 397 static DEVICE_ATTR(active_high_flag, (S_IRUGO), show_active_high_flag, store_active_high_flag);
 398 static DEVICE_ATTR(drive_inactive_flag, (S_IRUGO | S_IWUGO), show_drive_inactive_flag, store_drive_inactive_flag);
 399 static DEVICE_ATTR(hw_debounce, (S_IRUGO | S_IWUGO), show_hw_debounce, store_hw_debounce);
 400 static DEVICE_ATTR(hw_debounce_time, (S_IRUGO | S_IWUGO), show_hw_debounce_time, store_hw_debounce_time);
 401
 402 static void debounce_release(struct device *dev)
 403 {
 404 }
 405
 406 static struct device debounce_device = {
 407         .init_name = "debounce",
 408         .release = debounce_release,
 409 };
 410
 411 static int __init debounce_init(void)
 412 {
 413         struct device *event_dev = NULL;
 414         struct gpio_event_platform_data *gpio_epd;
 415         struct gpio_event_info *gpio_ei;
 416         int err = 0;
 417
 418         printk(KERN_INFO PREFIX "Searching for " GPIO_EVENT_DEV_NAME "...\n");
 419
 420         event_dev = device_find_child(&platform_bus, GPIO_EVENT_DEV_NAME, find_ms2_dev);
 421         if (event_dev == NULL)
 422                 return -ENODEV;
 423
 424         gpio_epd = (struct gpio_event_platform_data*)event_dev->platform_data;
 425         printk(KERN_INFO PREFIX "And there is a %s connected...\n", gpio_epd->name);
 426         if (strcmp(gpio_epd->name, "sholes-keypad"))
 427                 return -ENODEV;
 428
 429         gpio_ei = (struct gpio_event_info*)gpio_epd->info[0];
 430         gpio_evmi = container_of(gpio_ei, struct gpio_event_matrix_info, info);
 431
 432         err = device_register(&debounce_device);
 433         if (err) {
 434                 return err;
 435         }
 436
 437         err = device_create_file(&debounce_device, &dev_attr_debounce_delay);
 438         err = device_create_file(&debounce_device, &dev_attr_settle_time);
 439         err = device_create_file(&debounce_device, &dev_attr_poll_time);
 440         err = device_create_file(&debounce_device, &dev_attr_flags);
 441         err = device_create_file(&debounce_device, &dev_attr_debounce_flag);
 442         err = device_create_file(&debounce_device, &dev_attr_remove_some_phantom_keys_flag);
 443         err = device_create_file(&debounce_device, &dev_attr_print_unmapped_keys_flag);
 444         err = device_create_file(&debounce_device, &dev_attr_print_mapped_keys_flag);
 445         err = device_create_file(&debounce_device, &dev_attr_print_phantom_keys_flag);
 446         err = device_create_file(&debounce_device, &dev_attr_active_high_flag);
 447         err = device_create_file(&debounce_device, &dev_attr_drive_inactive_flag);
 448         err = device_create_file(&debounce_device, &dev_attr_hw_debounce);
 449         err = device_create_file(&debounce_device, &dev_attr_hw_debounce_time);
 450
 451         printk(KERN_INFO PREFIX "settle_time: %u\n", gpio_evmi->settle_time.tv.nsec);
 452         printk(KERN_INFO PREFIX "poll_time: %u\n", gpio_evmi->poll_time.tv.nsec);
 453         printk(KERN_INFO PREFIX "debounce_delay: %u\n", gpio_evmi->debounce_delay.tv.nsec);
 454         printk(KERN_INFO PREFIX "flags: 0x%x\n", gpio_evmi->flags);
 455
 456         old_debounce_delay = gpio_evmi->debounce_delay;
 457         old_settle_time = gpio_evmi->settle_time;
 458         old_poll_time = gpio_evmi->poll_time;
 459         old_flags = gpio_evmi->flags;
 460
 461         printk(KERN_INFO PREFIX "flags: 0x%x\n", gpio_evmi->flags);
 462
 463         return 0;
 464 }
 465
 466 static void __exit debounce_exit(void)
 467 {
 468         if (gpio_evmi) {
 469                 if (gpio_evmi->debounce_delay.tv.nsec != old_debounce_delay.tv.nsec) {
 470                         printk(KERN_INFO PREFIX "Restoring debounce_delay\n");
 471                         gpio_evmi->debounce_delay = old_debounce_delay;
 472                         printk(KERN_INFO PREFIX "debounce_delay: %u\n", gpio_evmi->debounce_delay.tv.nsec);
 473                 }
 474                 if (gpio_evmi->flags != old_flags) {
 475                         printk(KERN_INFO PREFIX "Restoring flags\n");
 476                         gpio_evmi->flags = old_flags;
 477                         printk(KERN_INFO PREFIX "flags: 0x%x\n", gpio_evmi->flags);
 478                 }
 479                 gpio_evmi->settle_time = old_settle_time;
 480                 gpio_evmi->poll_time = old_poll_time;
 481         }
 482         hw_debounce_set(0, 0);
 483         device_remove_file(&debounce_device, &dev_attr_debounce_delay);
 484         device_remove_file(&debounce_device, &dev_attr_settle_time);
 485         device_remove_file(&debounce_device, &dev_attr_poll_time);
 486         device_remove_file(&debounce_device, &dev_attr_flags);
 487         device_remove_file(&debounce_device, &dev_attr_debounce_flag);
 488         device_remove_file(&debounce_device, &dev_attr_remove_some_phantom_keys_flag);
 489         device_remove_file(&debounce_device, &dev_attr_print_unmapped_keys_flag);
 490         device_remove_file(&debounce_device, &dev_attr_print_mapped_keys_flag);
 491         device_remove_file(&debounce_device, &dev_attr_print_phantom_keys_flag);
 492         device_remove_file(&debounce_device, &dev_attr_active_high_flag);
 493         device_remove_file(&debounce_device, &dev_attr_drive_inactive_flag);
 494         device_remove_file(&debounce_device, &dev_attr_hw_debounce);
 495         device_remove_file(&debounce_device, &dev_attr_hw_debounce_time);
 496         device_unregister(&debounce_device);
 497 }
 498
 499 module_init(debounce_init);
 500 module_exit(debounce_exit);
 501
 502 MODULE_LICENSE("GPL");
 503 MODULE_AUTHOR("Michael Gernoth <michael@gernoth.net>");