drivers/extcon/extcon-gpio.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * extcon_gpio.c - Single-state GPIO extcon driver based on extcon class
   4  *
   5  * Copyright (C) 2008 Google, Inc.
   6  * Author: Mike Lockwood <lockwood@android.com>
   7  *
   8  * Modified by MyungJoo Ham <myungjoo.ham@samsung.com> to support extcon
   9  * (originally switch class is supported)
  10  */
  11
  12 #include <linux/extcon-provider.h>
  13 #include <linux/gpio/consumer.h>
  14 #include <linux/init.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/slab.h>
  20 #include <linux/workqueue.h>
  21
  22 /**
  23  * struct gpio_extcon_data - A simple GPIO-controlled extcon device state container.
  24  * @edev:               Extcon device.
  25  * @work:               Work fired by the interrupt.
  26  * @debounce_jiffies:   Number of jiffies to wait for the GPIO to stabilize, from the debounce
  27  *                      value.
  28  * @gpiod:              GPIO descriptor for this external connector.
  29  * @extcon_id:          The unique id of specific external connector.
  30  * @debounce:           Debounce time for GPIO IRQ in ms.
  31  * @check_on_resume:    Boolean describing whether to check the state of gpio
  32  *                      while resuming from sleep.
  33  */
  34 struct gpio_extcon_data {
  35         struct extcon_dev *edev;
  36         struct delayed_work work;
  37         unsigned long debounce_jiffies;
  38         struct gpio_desc *gpiod;
  39         unsigned int extcon_id;
  40         unsigned long debounce;
  41         bool check_on_resume;
  42 };
  43
  44 static void gpio_extcon_work(struct work_struct *work)
  45 {
  46         int state;
  47         struct gpio_extcon_data *data =
  48                 container_of(to_delayed_work(work), struct gpio_extcon_data,
  49                              work);
  50
  51         state = gpiod_get_value_cansleep(data->gpiod);
  52         extcon_set_state_sync(data->edev, data->extcon_id, state);
  53 }
  54
  55 static irqreturn_t gpio_irq_handler(int irq, void *dev_id)
  56 {
  57         struct gpio_extcon_data *data = dev_id;
  58
  59         queue_delayed_work(system_power_efficient_wq, &data->work,
  60                               data->debounce_jiffies);
  61         return IRQ_HANDLED;
  62 }
  63
  64 static int gpio_extcon_probe(struct platform_device *pdev)
  65 {
  66         struct gpio_extcon_data *data;
  67         struct device *dev = &pdev->dev;
  68         unsigned long irq_flags;
  69         int irq;
  70         int ret;
  71
  72         data = devm_kzalloc(dev, sizeof(struct gpio_extcon_data), GFP_KERNEL);
  73         if (!data)
  74                 return -ENOMEM;
  75
  76         /*
  77          * FIXME: extcon_id represents the unique identifier of external
  78          * connectors such as EXTCON_USB, EXTCON_DISP_HDMI and so on. extcon_id
  79          * is necessary to register the extcon device. But, it's not yet
  80          * developed to get the extcon id from device-tree or others.
  81          * On later, it have to be solved.
  82          */
  83         if (data->extcon_id > EXTCON_NONE)
  84                 return -EINVAL;
  85
  86         data->gpiod = devm_gpiod_get(dev, "extcon", GPIOD_IN);
  87         if (IS_ERR(data->gpiod))
  88                 return PTR_ERR(data->gpiod);
  89         irq = gpiod_to_irq(data->gpiod);
  90         if (irq <= 0)
  91                 return irq;
  92
  93         /*
  94          * It is unlikely that this is an acknowledged interrupt that goes
  95          * away after handling, what we are looking for are falling edges
  96          * if the signal is active low, and rising edges if the signal is
  97          * active high.
  98          */
  99         if (gpiod_is_active_low(data->gpiod))
 100                 irq_flags = IRQF_TRIGGER_FALLING;
 101         else
 102                 irq_flags = IRQF_TRIGGER_RISING;
 103
 104         /* Allocate the memory of extcon devie and register extcon device */
 105         data->edev = devm_extcon_dev_allocate(dev, &data->extcon_id);
 106         if (IS_ERR(data->edev)) {
 107                 dev_err(dev, "failed to allocate extcon device\n");
 108                 return -ENOMEM;
 109         }
 110
 111         ret = devm_extcon_dev_register(dev, data->edev);
 112         if (ret < 0)
 113                 return ret;
 114
 115         INIT_DELAYED_WORK(&data->work, gpio_extcon_work);
 116
 117         /*
 118          * Request the interrupt of gpio to detect whether external connector
 119          * is attached or detached.
 120          */
 121         ret = devm_request_any_context_irq(dev, irq,
 122                                         gpio_irq_handler, irq_flags,
 123                                         pdev->name, data);
 124         if (ret < 0)
 125                 return ret;
 126
 127         platform_set_drvdata(pdev, data);
 128         /* Perform initial detection */
 129         gpio_extcon_work(&data->work.work);
 130
 131         return 0;
 132 }
 133
 134 static int gpio_extcon_remove(struct platform_device *pdev)
 135 {
 136         struct gpio_extcon_data *data = platform_get_drvdata(pdev);
 137
 138         cancel_delayed_work_sync(&data->work);
 139
 140         return 0;
 141 }
 142
 143 #ifdef CONFIG_PM_SLEEP
 144 static int gpio_extcon_resume(struct device *dev)
 145 {
 146         struct gpio_extcon_data *data;
 147
 148         data = dev_get_drvdata(dev);
 149         if (data->check_on_resume)
 150                 queue_delayed_work(system_power_efficient_wq,
 151                         &data->work, data->debounce_jiffies);
 152
 153         return 0;
 154 }
 155 #endif
 156
 157 static SIMPLE_DEV_PM_OPS(gpio_extcon_pm_ops, NULL, gpio_extcon_resume);
 158
 159 static struct platform_driver gpio_extcon_driver = {
 160         .probe          = gpio_extcon_probe,
 161         .remove         = gpio_extcon_remove,
 162         .driver         = {
 163                 .name   = "extcon-gpio",
 164                 .pm     = &gpio_extcon_pm_ops,
 165         },
 166 };
 167
 168 module_platform_driver(gpio_extcon_driver);
 169
 170 MODULE_AUTHOR("Mike Lockwood <lockwood@android.com>");
 171 MODULE_DESCRIPTION("GPIO extcon driver");
 172 MODULE_LICENSE("GPL");