drivers/staging/android/switch/switch_gpio.c

   1 /*
   2  * switch_gpio.c
   3  *
   4  * Copyright (C) 2008 Google, Inc.
   5  * Author: Mike Lockwood <lockwood@android.com>
   6  *
   7  * This software is licensed under the terms of the GNU General Public
   8  * License version 2, as published by the Free Software Foundation, and
   9  * may be copied, distributed, and modified under those terms.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16 */
  17
  18 #include <linux/module.h>
  19 #include <linux/kernel.h>
  20 #include <linux/init.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/slab.h>
  24 #include <linux/workqueue.h>
  25 #include <linux/gpio.h>
  26 #include "switch.h"
  27
  28 struct gpio_switch_data {
  29         struct switch_dev sdev;
  30         unsigned gpio;
  31         const char *name_on;
  32         const char *name_off;
  33         const char *state_on;
  34         const char *state_off;
  35         int irq;
  36         struct work_struct work;
  37 };
  38
  39 static void gpio_switch_work(struct work_struct *work)
  40 {
  41         int state;
  42         struct gpio_switch_data *data =
  43                 container_of(work, struct gpio_switch_data, work);
  44
  45         state = gpio_get_value(data->gpio);
  46         switch_set_state(&data->sdev, state);
  47 }
  48
  49 static irqreturn_t gpio_irq_handler(int irq, void *dev_id)
  50 {
  51         struct gpio_switch_data *switch_data =
  52             (struct gpio_switch_data *)dev_id;
  53
  54         schedule_work(&switch_data->work);
  55         return IRQ_HANDLED;
  56 }
  57
  58 static ssize_t switch_gpio_print_state(struct switch_dev *sdev, char *buf)
  59 {
  60         struct gpio_switch_data *switch_data =
  61                 container_of(sdev, struct gpio_switch_data, sdev);
  62         const char *state;
  63         if (switch_get_state(sdev))
  64                 state = switch_data->state_on;
  65         else
  66                 state = switch_data->state_off;
  67
  68         if (state)
  69                 return sprintf(buf, "%s\n", state);
  70         return -1;
  71 }
  72
  73 static int gpio_switch_probe(struct platform_device *pdev)
  74 {
  75         struct gpio_switch_platform_data *pdata = pdev->dev.platform_data;
  76         struct gpio_switch_data *switch_data;
  77         int ret = 0;
  78
  79         if (!pdata)
  80                 return -EBUSY;
  81
  82         switch_data = kzalloc(sizeof(struct gpio_switch_data), GFP_KERNEL);
  83         if (!switch_data)
  84                 return -ENOMEM;
  85
  86         switch_data->sdev.name = pdata->name;
  87         switch_data->gpio = pdata->gpio;
  88         switch_data->name_on = pdata->name_on;
  89         switch_data->name_off = pdata->name_off;
  90         switch_data->state_on = pdata->state_on;
  91         switch_data->state_off = pdata->state_off;
  92         switch_data->sdev.print_state = switch_gpio_print_state;
  93
  94         ret = switch_dev_register(&switch_data->sdev);
  95         if (ret < 0)
  96                 goto err_switch_dev_register;
  97
  98         ret = gpio_request(switch_data->gpio, pdev->name);
  99         if (ret < 0)
 100                 goto err_request_gpio;
 101
 102         ret = gpio_direction_input(switch_data->gpio);
 103         if (ret < 0)
 104                 goto err_set_gpio_input;
 105
 106         INIT_WORK(&switch_data->work, gpio_switch_work);
 107
 108         switch_data->irq = gpio_to_irq(switch_data->gpio);
 109         if (switch_data->irq < 0) {
 110                 ret = switch_data->irq;
 111                 goto err_detect_irq_num_failed;
 112         }
 113
 114         ret = request_irq(switch_data->irq, gpio_irq_handler,
 115                           IRQF_TRIGGER_LOW, pdev->name, switch_data);
 116         if (ret < 0)
 117                 goto err_request_irq;
 118
 119         /* Perform initial detection */
 120         gpio_switch_work(&switch_data->work);
 121
 122         return 0;
 123
 124 err_request_irq:
 125 err_detect_irq_num_failed:
 126 err_set_gpio_input:
 127         gpio_free(switch_data->gpio);
 128 err_request_gpio:
 129         switch_dev_unregister(&switch_data->sdev);
 130 err_switch_dev_register:
 131         kfree(switch_data);
 132
 133         return ret;
 134 }
 135
 136 static int __devexit gpio_switch_remove(struct platform_device *pdev)
 137 {
 138         struct gpio_switch_data *switch_data = platform_get_drvdata(pdev);
 139
 140         cancel_work_sync(&switch_data->work);
 141         gpio_free(switch_data->gpio);
 142         switch_dev_unregister(&switch_data->sdev);
 143         kfree(switch_data);
 144
 145         return 0;
 146 }
 147
 148 static struct platform_driver gpio_switch_driver = {
 149         .probe          = gpio_switch_probe,
 150         .remove         = __devexit_p(gpio_switch_remove),
 151         .driver         = {
 152                 .name   = "switch-gpio",
 153                 .owner  = THIS_MODULE,
 154         },
 155 };
 156
 157 static int __init gpio_switch_init(void)
 158 {
 159         return platform_driver_register(&gpio_switch_driver);
 160 }
 161
 162 static void __exit gpio_switch_exit(void)
 163 {
 164         platform_driver_unregister(&gpio_switch_driver);
 165 }
 166
 167 module_init(gpio_switch_init);
 168 module_exit(gpio_switch_exit);
 169
 170 MODULE_AUTHOR("Mike Lockwood <lockwood@android.com>");
 171 MODULE_DESCRIPTION("GPIO Switch driver");
 172 MODULE_LICENSE("GPL");