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