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         if (direction)
 290                 gpio_direction_input(sw->gpio);
 291         else
 292                 gpio_direction_output(sw->gpio, true);
 293
 294         sw->state = gpio_sw_get_state(sw);
 295
 296         r = 0;
 297         r |= device_create_file(&sw->pdev.dev, &dev_attr_state);
 298         r |= device_create_file(&sw->pdev.dev, &dev_attr_type);
 299         r |= device_create_file(&sw->pdev.dev, &dev_attr_direction);
 300         if (r)
 301                 printk(KERN_ERR "gpio-switch: attribute file creation "
 302                        "failed for %s\n", sw->name);
 303
 304         if (!direction)
 305                 return 0;
 306
 307         if (can_do_both_edges(sw)) {
 308                 trigger = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING;
 309                 sw->both_edges = 1;
 310         } else {
 311                 if (gpio_get_value(sw->gpio))
 312                         trigger = IRQF_TRIGGER_FALLING;
 313                 else
 314                         trigger = IRQF_TRIGGER_RISING;
 315         }
 316         r = request_irq(OMAP_GPIO_IRQ(sw->gpio), gpio_sw_irq_handler,
 317                         IRQF_SHARED | trigger, sw->name, sw);
 318         if (r < 0) {
 319                 printk(KERN_ERR "gpio-switch: request_irq() failed "
 320                        "for GPIO %d\n", sw->gpio);
 321                 platform_device_unregister(&sw->pdev);
 322                 omap_free_gpio(sw->gpio);
 323                 return r;
 324         }
 325
 326         INIT_WORK(&sw->work, gpio_sw_handler);
 327         init_timer(&sw->timer);
 328
 329         sw->timer.function = gpio_sw_timer;
 330         sw->timer.data = (unsigned long)sw;
 331
 332         list_add(&sw->node, &gpio_switches);
 333
 334         return 0;
 335 }
 336
 337 static int __init add_atag_switches(void)
 338 {
 339         const struct omap_gpio_switch_config *cfg;
 340         struct gpio_switch *sw;
 341         int i, r;
 342
 343         for (i = 0; ; i++) {
 344                 cfg = omap_get_nr_config(OMAP_TAG_GPIO_SWITCH,
 345                                          struct omap_gpio_switch_config, i);
 346                 if (cfg == NULL)
 347                         break;
 348                 sw = kzalloc(sizeof(*sw), GFP_KERNEL);
 349                 if (sw == NULL) {
 350                         printk(KERN_ERR "gpio-switch: kmalloc failed\n");
 351                         return -ENOMEM;
 352                 }
 353                 strncpy(sw->name, cfg->name, sizeof(cfg->name));
 354                 sw->gpio = cfg->gpio;
 355                 sw->flags = cfg->flags;
 356                 sw->type = cfg->type;
 357                 sw->debounce_rising = OMAP_GPIO_SW_DEFAULT_DEBOUNCE;
 358                 sw->debounce_falling = OMAP_GPIO_SW_DEFAULT_DEBOUNCE;
 359                 if ((r = new_switch(sw)) < 0) {
 360                         kfree(sw);
 361                         return r;
 362                 }
 363         }
 364         return 0;
 365 }
 366
 367 static struct gpio_switch * __init find_switch(int gpio, const char *name)
 368 {
 369         struct gpio_switch *sw;
 370
 371         list_for_each_entry(sw, &gpio_switches, node) {
 372                 if ((gpio < 0 || sw->gpio != gpio) &&
 373                     (name == NULL || strcmp(sw->name, name) != 0))
 374                         continue;
 375
 376                 if (gpio < 0 || name == NULL)
 377                         goto no_check;
 378
 379                 if (strcmp(sw->name, name) != 0)
 380                         printk("gpio-switch: name mismatch for %d (%s, %s)\n",
 381                                gpio, name, sw->name);
 382                 else if (sw->gpio != gpio)
 383                         printk("gpio-switch: GPIO mismatch for %s (%d, %d)\n",
 384                                name, gpio, sw->gpio);
 385 no_check:
 386                 return sw;
 387         }
 388         return NULL;
 389 }
 390
 391 static int __init add_board_switches(void)
 392 {
 393         int i;
 394
 395         for (i = 0; i < board_gpio_sw_count; i++) {
 396                 const struct omap_gpio_switch *cfg;
 397                 struct gpio_switch *sw;
 398                 int r;
 399
 400                 cfg = board_gpio_sw_table + i;
 401                 if (strlen(cfg->name) > sizeof(sw->name) - 1)
 402                         return -EINVAL;
 403                 /* Check whether we only update an existing switch
 404                  * or add a new switch. */
 405                 sw = find_switch(cfg->gpio, cfg->name);
 406                 if (sw != NULL) {
 407                         sw->debounce_rising = cfg->debounce_rising;
 408                         sw->debounce_falling = cfg->debounce_falling;
 409                         sw->notify = cfg->notify;
 410                         sw->notify_data = cfg->notify_data;
 411                         continue;
 412                 } else {
 413                         if (cfg->gpio < 0 || cfg->name == NULL) {
 414                                 printk("gpio-switch: required switch not "
 415                                        "found (%d, %s)\n", cfg->gpio,
 416                                        cfg->name);
 417                                 continue;
 418                         }
 419                 }
 420                 sw = kzalloc(sizeof(*sw), GFP_KERNEL);
 421                 if (sw == NULL) {
 422                         printk(KERN_ERR "gpio-switch: kmalloc failed\n");
 423                         return -ENOMEM;
 424                 }
 425                 strlcpy(sw->name, cfg->name, sizeof(sw->name));
 426                 sw->gpio = cfg->gpio;
 427                 sw->flags = cfg->flags;
 428                 sw->type = cfg->type;
 429                 sw->debounce_rising = cfg->debounce_rising;
 430                 sw->debounce_falling = cfg->debounce_falling;
 431                 sw->notify = cfg->notify;
 432                 sw->notify_data = cfg->notify_data;
 433                 if ((r = new_switch(sw)) < 0) {
 434                         kfree(sw);
 435                         return r;
 436                 }
 437         }
 438         return 0;
 439 }
 440
 441 static void gpio_sw_cleanup(void)
 442 {
 443         struct gpio_switch *sw = NULL, *old = NULL;
 444
 445         list_for_each_entry(sw, &gpio_switches, node) {
 446                 if (old != NULL)
 447                         kfree(old);
 448                 flush_scheduled_work();
 449                 del_timer_sync(&sw->timer);
 450
 451                 free_irq(OMAP_GPIO_IRQ(sw->gpio), sw);
 452
 453                 device_remove_file(&sw->pdev.dev, &dev_attr_state);
 454                 device_remove_file(&sw->pdev.dev, &dev_attr_type);
 455                 device_remove_file(&sw->pdev.dev, &dev_attr_direction);
 456
 457                 platform_device_unregister(&sw->pdev);
 458                 omap_free_gpio(sw->gpio);
 459                 old = sw;
 460         }
 461         kfree(old);
 462 }
 463
 464 static void __init report_initial_state(void)
 465 {
 466         struct gpio_switch *sw;
 467
 468         list_for_each_entry(sw, &gpio_switches, node) {
 469                 int state;
 470
 471                 state = gpio_get_value(sw->gpio);
 472                 if (sw->flags & OMAP_GPIO_SWITCH_FLAG_INVERTED)
 473                         state = !state;
 474                 if (sw->notify != NULL)
 475                         sw->notify(sw->notify_data, state);
 476                 print_sw_state(sw, state);
 477         }
 478 }
 479
 480 static int gpio_sw_remove(struct platform_device *dev)
 481 {
 482         return 0;
 483 }
 484
 485 static struct platform_driver gpio_sw_driver = {
 486         .remove         = gpio_sw_remove,
 487         .driver         = {
 488                 .name   = "gpio-switch",
 489         },
 490 };
 491
 492 void __init omap_register_gpio_switches(const struct omap_gpio_switch *tbl,
 493                                         int count)
 494 {
 495         BUG_ON(board_gpio_sw_table != NULL);
 496
 497         board_gpio_sw_table = tbl;
 498         board_gpio_sw_count = count;
 499 }
 500
 501 static int __init gpio_sw_init(void)
 502 {
 503         int r;
 504
 505         printk(KERN_INFO "OMAP GPIO switch handler initializing\n");
 506
 507         r = platform_driver_register(&gpio_sw_driver);
 508         if (r)
 509                 return r;
 510
 511         gpio_sw_platform_dev = platform_device_register_simple("gpio-switch",
 512                                                                -1, NULL, 0);
 513         if (IS_ERR(gpio_sw_platform_dev)) {
 514                 r = PTR_ERR(gpio_sw_platform_dev);
 515                 goto err1;
 516         }
 517
 518         r = add_atag_switches();
 519         if (r < 0)
 520                 goto err2;
 521
 522         r = add_board_switches();
 523         if (r < 0)
 524                 goto err2;
 525
 526         report_initial_state();
 527
 528         return 0;
 529 err2:
 530         gpio_sw_cleanup();
 531         platform_device_unregister(gpio_sw_platform_dev);
 532 err1:
 533         platform_driver_unregister(&gpio_sw_driver);
 534         return r;
 535 }
 536
 537 static void __exit gpio_sw_exit(void)
 538 {
 539         gpio_sw_cleanup();
 540         platform_device_unregister(gpio_sw_platform_dev);
 541         platform_driver_unregister(&gpio_sw_driver);
 542 }
 543
 544 #ifndef MODULE
 545 late_initcall(gpio_sw_init);
 546 #else
 547 module_init(gpio_sw_init);
 548 #endif
 549 module_exit(gpio_sw_exit);
 550
 551 MODULE_AUTHOR("Juha Yrjölä <juha.yrjola@nokia.com>, Paul Mundt <paul.mundt@nokia.com");
 552 MODULE_DESCRIPTION("GPIO switch driver");
 553 MODULE_LICENSE("GPL");