arch/arm/plat-omap/gpio-switch.c

   1 /*
   2  *  linux/arch/arm/plat-omap/gpio-switch.c
   3  *
   4  *  Copyright (C) 2004-2006 Nokia Corporation
   5  *  Written by Juha Yrjölä <juha.yrjola@nokia.com>
   6  *         and Paul Mundt <paul.mundt@nokia.com>
   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 version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/sched.h>
  14 #include <linux/init.h>
  15 #include <linux/list.h>
  16 #include <linux/irq.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/module.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/timer.h>
  21 #include <linux/err.h>
  22 #include <mach/hardware.h>
  23 #include <mach/gpio.h>
  24 #include <mach/irqs.h>
  25 #include <mach/mux.h>
  26 #include <mach/board.h>
  27 #include <mach/gpio-switch.h>
  28
  29 struct gpio_switch {
  30         char            name[14];
  31         u16             gpio;
  32         unsigned        flags:4;
  33         unsigned        type:4;
  34         unsigned        state:1;
  35         unsigned        both_edges:1;
  36
  37         u16             debounce_rising;
  38         u16             debounce_falling;
  39
  40         void (* notify)(void *data, int state);
  41         void *notify_data;
  42
  43         struct work_struct      work;
  44         struct timer_list       timer;
  45         struct platform_device  pdev;
  46
  47         struct list_head        node;
  48 };
  49
  50 static LIST_HEAD(gpio_switches);
  51 static struct platform_device *gpio_sw_platform_dev;
  52 static struct platform_driver gpio_sw_driver;
  53
  54 static const struct omap_gpio_switch *board_gpio_sw_table;
  55 static int board_gpio_sw_count;
  56
  57 static const char *cover_str[2] = { "open", "closed" };
  58 static const char *connection_str[2] = { "disconnected", "connected" };
  59 static const char *activity_str[2] = { "inactive", "active" };
  60
  61 /*
  62  * GPIO switch state default debounce delay in ms
  63  */
  64 #define OMAP_GPIO_SW_DEFAULT_DEBOUNCE           10
  65
  66 static const char **get_sw_str(struct gpio_switch *sw)
  67 {
  68         switch (sw->type) {
  69         case OMAP_GPIO_SWITCH_TYPE_COVER:
  70                 return cover_str;
  71         case OMAP_GPIO_SWITCH_TYPE_CONNECTION:
  72                 return connection_str;
  73         case OMAP_GPIO_SWITCH_TYPE_ACTIVITY:
  74                 return activity_str;
  75         default:
  76                 BUG();
  77                 return NULL;
  78         }
  79 }
  80
  81 static const char *get_sw_type(struct gpio_switch *sw)
  82 {
  83         switch (sw->type) {
  84         case OMAP_GPIO_SWITCH_TYPE_COVER:
  85                 return "cover";
  86         case OMAP_GPIO_SWITCH_TYPE_CONNECTION:
  87                 return "connection";
  88         case OMAP_GPIO_SWITCH_TYPE_ACTIVITY:
  89                 return "activity";
  90         default:
  91                 BUG();
  92                 return NULL;
  93         }
  94 }
  95
  96 static void print_sw_state(struct gpio_switch *sw, int state)
  97 {
  98         const char **str;
  99
 100         str = get_sw_str(sw);
 101         if (str != NULL)
 102                 printk(KERN_INFO "%s (GPIO %d) is now %s\n", sw->name, sw->gpio, str[state]);
 103 }
 104
 105 static int gpio_sw_get_state(struct gpio_switch *sw)
 106 {
 107         int state;
 108
 109         state = gpio_get_value(sw->gpio);
 110         if (sw->flags & OMAP_GPIO_SWITCH_FLAG_INVERTED)
 111                 state = !state;
 112
 113         return state;
 114 }
 115
 116 static ssize_t gpio_sw_state_store(struct device *dev,
 117                                    struct device_attribute *attr,
 118                                    const char *buf,
 119                                    size_t count)
 120 {
 121         struct gpio_switch *sw = dev_get_drvdata(dev);
 122         const char **str;
 123         char state[16];
 124         int enable;
 125
 126         if (!(sw->flags & OMAP_GPIO_SWITCH_FLAG_OUTPUT))
 127                 return -EPERM;
 128
 129         if (sscanf(buf, "%15s", state) != 1)
 130                 return -EINVAL;
 131
 132         str = get_sw_str(sw);
 133         if (strcmp(state, str[0]) == 0)
 134                 sw->state = enable = 0;
 135         else if (strcmp(state, str[1]) == 0)
 136                 sw->state = enable = 1;
 137         else
 138                 return -EINVAL;
 139
 140         if (sw->flags & OMAP_GPIO_SWITCH_FLAG_INVERTED)
 141                 enable = !enable;
 142         gpio_set_value(sw->gpio, enable);
 143
 144         return count;
 145 }
 146
 147 static ssize_t gpio_sw_state_show(struct device *dev,
 148                                   struct device_attribute *attr,
 149                                   char *buf)
 150 {
 151         struct gpio_switch *sw = dev_get_drvdata(dev);
 152         const char **str;
 153
 154         str = get_sw_str(sw);
 155         return sprintf(buf, "%s\n", str[sw->state]);
 156 }
 157
 158 static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, gpio_sw_state_show,
 159                    gpio_sw_state_store);
 160
 161 static ssize_t gpio_sw_type_show(struct device *dev,
 162                                  struct device_attribute *attr,
 163                                  char *buf)
 164 {
 165         struct gpio_switch *sw = dev_get_drvdata(dev);
 166
 167         return sprintf(buf, "%s\n", get_sw_type(sw));
 168 }
 169
 170 static DEVICE_ATTR(type, S_IRUGO, gpio_sw_type_show, NULL);
 171
 172 static ssize_t gpio_sw_direction_show(struct device *dev,
 173                                       struct device_attribute *attr,
 174                                       char *buf)
 175 {
 176         struct gpio_switch *sw = dev_get_drvdata(dev);
 177         int is_output;
 178
 179         is_output = sw->flags & OMAP_GPIO_SWITCH_FLAG_OUTPUT;
 180         return sprintf(buf, "%s\n", is_output ? "output" : "input");
 181 }
 182
 183 static DEVICE_ATTR(direction, S_IRUGO, gpio_sw_direction_show, NULL);
 184
 185
 186 static irqreturn_t gpio_sw_irq_handler(int irq, void *arg)
 187 {
 188         struct gpio_switch *sw = arg;
 189         unsigned long timeout;
 190         int state;
 191
 192         if (!sw->both_edges) {
 193                 if (gpio_get_value(sw->gpio))
 194                         set_irq_type(OMAP_GPIO_IRQ(sw->gpio), IRQ_TYPE_EDGE_FALLING);
 195                 else
 196                         set_irq_type(OMAP_GPIO_IRQ(sw->gpio), IRQ_TYPE_EDGE_RISING);
 197         }
 198
 199         state = gpio_sw_get_state(sw);
 200         if (sw->state == state)
 201                 return IRQ_HANDLED;
 202
 203         if (state)
 204                 timeout = sw->debounce_rising;
 205         else
 206                 timeout = sw->debounce_falling;
 207         if (!timeout)
 208                 schedule_work(&sw->work);
 209         else
 210                 mod_timer(&sw->timer, jiffies + msecs_to_jiffies(timeout));
 211
 212         return IRQ_HANDLED;
 213 }
 214
 215 static void gpio_sw_timer(unsigned long arg)
 216 {
 217         struct gpio_switch *sw = (struct gpio_switch *) arg;
 218
 219         schedule_work(&sw->work);
 220 }
 221
 222 static void gpio_sw_handler(struct work_struct *work)
 223 {
 224         struct gpio_switch *sw = container_of(work, struct gpio_switch, work);
 225         int state;
 226
 227         state = gpio_sw_get_state(sw);
 228         if (sw->state == state)
 229                 return;
 230
 231         sw->state = state;
 232         if (sw->notify != NULL)
 233                 sw->notify(sw->notify_data, state);
 234         sysfs_notify(&sw->pdev.dev.kobj, NULL, "state");
 235         print_sw_state(sw, state);
 236 }
 237
 238 static int __init can_do_both_edges(struct gpio_switch *sw)
 239 {
 240         if (!cpu_class_is_omap1())
 241                 return 1;
 242         if (OMAP_GPIO_IS_MPUIO(sw->gpio))
 243                 return 0;
 244         else
 245                 return 1;
 246 }
 247
 248 static void gpio_sw_release(struct device *dev)
 249 {
 250 }
 251
 252 static int __init new_switch(struct gpio_switch *sw)
 253 {
 254         int r, direction, trigger;
 255
 256         switch (sw->type) {
 257         case OMAP_GPIO_SWITCH_TYPE_COVER:
 258         case OMAP_GPIO_SWITCH_TYPE_CONNECTION:
 259         case OMAP_GPIO_SWITCH_TYPE_ACTIVITY:
 260                 break;
 261         default:
 262                 printk(KERN_ERR "invalid GPIO switch type: %d\n", sw->type);
 263                 return -EINVAL;
 264         }
 265
 266         sw->pdev.name   = sw->name;
 267         sw->pdev.id     = -1;
 268
 269         sw->pdev.dev.parent = &gpio_sw_platform_dev->dev;
 270         sw->pdev.dev.driver = &gpio_sw_driver.driver;
 271         sw->pdev.dev.release = gpio_sw_release;
 272
 273         r = platform_device_register(&sw->pdev);
 274         if (r) {
 275                 printk(KERN_ERR "gpio-switch: platform device registration "
 276                        "failed for %s", sw->name);
 277                 return r;
 278         }
 279         dev_set_drvdata(&sw->pdev.dev, sw);
 280
 281         r = omap_request_gpio(sw->gpio);
 282         if (r < 0) {
 283                 platform_device_unregister(&sw->pdev);
 284                 return r;
 285         }
 286
 287         /* input: 1, output: 0 */
 288         direction = !(sw->flags & OMAP_GPIO_SWITCH_FLAG_OUTPUT);
 289         omap_set_gpio_direction(sw->gpio, direction);
 290
 291         sw->state = gpio_sw_get_state(sw);
 292
 293         r = 0;
 294         r |= device_create_file(&sw->pdev.dev, &dev_attr_state);
 295         r |= device_create_file(&sw->pdev.dev, &dev_attr_type);
 296         r |= device_create_file(&sw->pdev.dev, &dev_attr_direction);
 297         if (r)
 298                 printk(KERN_ERR "gpio-switch: attribute file creation "
 299                        "failed for %s\n", sw->name);
 300
 301         if (!direction)
 302                 return 0;
 303
 304         if (can_do_both_edges(sw)) {
 305                 trigger = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING;
 306                 sw->both_edges = 1;
 307         } else {
 308                 if (gpio_get_value(sw->gpio))
 309                         trigger = IRQF_TRIGGER_FALLING;
 310                 else
 311                         trigger = IRQF_TRIGGER_RISING;
 312         }
 313         r = request_irq(OMAP_GPIO_IRQ(sw->gpio), gpio_sw_irq_handler,
 314                         IRQF_SHARED | trigger, sw->name, sw);
 315         if (r < 0) {
 316                 printk(KERN_ERR "gpio-switch: request_irq() failed "
 317                        "for GPIO %d\n", sw->gpio);
 318                 platform_device_unregister(&sw->pdev);
 319                 omap_free_gpio(sw->gpio);
 320                 return r;
 321         }
 322
 323         INIT_WORK(&sw->work, gpio_sw_handler);
 324         init_timer(&sw->timer);
 325
 326         sw->timer.function = gpio_sw_timer;
 327         sw->timer.data = (unsigned long)sw;
 328
 329         list_add(&sw->node, &gpio_switches);
 330
 331         return 0;
 332 }
 333
 334 static int __init add_atag_switches(void)
 335 {
 336         const struct omap_gpio_switch_config *cfg;
 337         struct gpio_switch *sw;
 338         int i, r;
 339
 340         for (i = 0; ; i++) {
 341                 cfg = omap_get_nr_config(OMAP_TAG_GPIO_SWITCH,
 342                                          struct omap_gpio_switch_config, i);
 343                 if (cfg == NULL)
 344                         break;
 345                 sw = kzalloc(sizeof(*sw), GFP_KERNEL);
 346                 if (sw == NULL) {
 347                         printk(KERN_ERR "gpio-switch: kmalloc failed\n");
 348                         return -ENOMEM;
 349                 }
 350                 strncpy(sw->name, cfg->name, sizeof(cfg->name));
 351                 sw->gpio = cfg->gpio;
 352                 sw->flags = cfg->flags;
 353                 sw->type = cfg->type;
 354                 sw->debounce_rising = OMAP_GPIO_SW_DEFAULT_DEBOUNCE;
 355                 sw->debounce_falling = OMAP_GPIO_SW_DEFAULT_DEBOUNCE;
 356                 if ((r = new_switch(sw)) < 0) {
 357                         kfree(sw);
 358                         return r;
 359                 }
 360         }
 361         return 0;
 362 }
 363
 364 static struct gpio_switch * __init find_switch(int gpio, const char *name)
 365 {
 366         struct gpio_switch *sw;
 367
 368         list_for_each_entry(sw, &gpio_switches, node) {
 369                 if ((gpio < 0 || sw->gpio != gpio) &&
 370                     (name == NULL || strcmp(sw->name, name) != 0))
 371                         continue;
 372
 373                 if (gpio < 0 || name == NULL)
 374                         goto no_check;
 375
 376                 if (strcmp(sw->name, name) != 0)
 377                         printk("gpio-switch: name mismatch for %d (%s, %s)\n",
 378                                gpio, name, sw->name);
 379                 else if (sw->gpio != gpio)
 380                         printk("gpio-switch: GPIO mismatch for %s (%d, %d)\n",
 381                                name, gpio, sw->gpio);
 382 no_check:
 383                 return sw;
 384         }
 385         return NULL;
 386 }
 387
 388 static int __init add_board_switches(void)
 389 {
 390         int i;
 391
 392         for (i = 0; i < board_gpio_sw_count; i++) {
 393                 const struct omap_gpio_switch *cfg;
 394                 struct gpio_switch *sw;
 395                 int r;
 396
 397                 cfg = board_gpio_sw_table + i;
 398                 if (strlen(cfg->name) > sizeof(sw->name) - 1)
 399                         return -EINVAL;
 400                 /* Check whether we only update an existing switch
 401                  * or add a new switch. */
 402                 sw = find_switch(cfg->gpio, cfg->name);
 403                 if (sw != NULL) {
 404                         sw->debounce_rising = cfg->debounce_rising;
 405                         sw->debounce_falling = cfg->debounce_falling;
 406                         sw->notify = cfg->notify;
 407                         sw->notify_data = cfg->notify_data;
 408                         continue;
 409                 } else {
 410                         if (cfg->gpio < 0 || cfg->name == NULL) {
 411                                 printk("gpio-switch: required switch not "
 412                                        "found (%d, %s)\n", cfg->gpio,
 413                                        cfg->name);
 414                                 continue;
 415                         }
 416                 }
 417                 sw = kzalloc(sizeof(*sw), GFP_KERNEL);
 418                 if (sw == NULL) {
 419                         printk(KERN_ERR "gpio-switch: kmalloc failed\n");
 420                         return -ENOMEM;
 421                 }
 422                 strlcpy(sw->name, cfg->name, sizeof(sw->name));
 423                 sw->gpio = cfg->gpio;
 424                 sw->flags = cfg->flags;
 425                 sw->type = cfg->type;
 426                 sw->debounce_rising = cfg->debounce_rising;
 427                 sw->debounce_falling = cfg->debounce_falling;
 428                 sw->notify = cfg->notify;
 429                 sw->notify_data = cfg->notify_data;
 430                 if ((r = new_switch(sw)) < 0) {
 431                         kfree(sw);
 432                         return r;
 433                 }
 434         }
 435         return 0;
 436 }
 437
 438 static void gpio_sw_cleanup(void)
 439 {
 440         struct gpio_switch *sw = NULL, *old = NULL;
 441
 442         list_for_each_entry(sw, &gpio_switches, node) {
 443                 if (old != NULL)
 444                         kfree(old);
 445                 flush_scheduled_work();
 446                 del_timer_sync(&sw->timer);
 447
 448                 free_irq(OMAP_GPIO_IRQ(sw->gpio), sw);
 449
 450                 device_remove_file(&sw->pdev.dev, &dev_attr_state);
 451                 device_remove_file(&sw->pdev.dev, &dev_attr_type);
 452                 device_remove_file(&sw->pdev.dev, &dev_attr_direction);
 453
 454                 platform_device_unregister(&sw->pdev);
 455                 omap_free_gpio(sw->gpio);
 456                 old = sw;
 457         }
 458         kfree(old);
 459 }
 460
 461 static void __init report_initial_state(void)
 462 {
 463         struct gpio_switch *sw;
 464
 465         list_for_each_entry(sw, &gpio_switches, node) {
 466                 int state;
 467
 468                 state = gpio_get_value(sw->gpio);
 469                 if (sw->flags & OMAP_GPIO_SWITCH_FLAG_INVERTED)
 470                         state = !state;
 471                 if (sw->notify != NULL)
 472                         sw->notify(sw->notify_data, state);
 473                 print_sw_state(sw, state);
 474         }
 475 }
 476
 477 static int gpio_sw_remove(struct platform_device *dev)
 478 {
 479         return 0;
 480 }
 481
 482 static struct platform_driver gpio_sw_driver = {
 483         .remove         = gpio_sw_remove,
 484         .driver         = {
 485                 .name   = "gpio-switch",
 486         },
 487 };
 488
 489 void __init omap_register_gpio_switches(const struct omap_gpio_switch *tbl,
 490                                         int count)
 491 {
 492         BUG_ON(board_gpio_sw_table != NULL);
 493
 494         board_gpio_sw_table = tbl;
 495         board_gpio_sw_count = count;
 496 }
 497
 498 static int __init gpio_sw_init(void)
 499 {
 500         int r;
 501
 502         printk(KERN_INFO "OMAP GPIO switch handler initializing\n");
 503
 504         r = platform_driver_register(&gpio_sw_driver);
 505         if (r)
 506                 return r;
 507
 508         gpio_sw_platform_dev = platform_device_register_simple("gpio-switch",
 509                                                                -1, NULL, 0);
 510         if (IS_ERR(gpio_sw_platform_dev)) {
 511                 r = PTR_ERR(gpio_sw_platform_dev);
 512                 goto err1;
 513         }
 514
 515         r = add_atag_switches();
 516         if (r < 0)
 517                 goto err2;
 518
 519         r = add_board_switches();
 520         if (r < 0)
 521                 goto err2;
 522
 523         report_initial_state();
 524
 525         return 0;
 526 err2:
 527         gpio_sw_cleanup();
 528         platform_device_unregister(gpio_sw_platform_dev);
 529 err1:
 530         platform_driver_unregister(&gpio_sw_driver);
 531         return r;
 532 }
 533
 534 static void __exit gpio_sw_exit(void)
 535 {
 536         gpio_sw_cleanup();
 537         platform_device_unregister(gpio_sw_platform_dev);
 538         platform_driver_unregister(&gpio_sw_driver);
 539 }
 540
 541 #ifndef MODULE
 542 late_initcall(gpio_sw_init);
 543 #else
 544 module_init(gpio_sw_init);
 545 #endif
 546 module_exit(gpio_sw_exit);
 547
 548 MODULE_AUTHOR("Juha Yrjölä <juha.yrjola@nokia.com>, Paul Mundt <paul.mundt@nokia.com");
 549 MODULE_DESCRIPTION("GPIO switch driver");
 550 MODULE_LICENSE("GPL");