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  * @irq:                Interrupt line for the external connector.
  26  * @work:               Work fired by the interrupt.
  27  * @debounce_jiffies:   Number of jiffies to wait for the GPIO to stabilize, from the debounce
  28  *                      value.
  29  * @gpiod:              GPIO descriptor for this external connector.
  30  * @extcon_id:          The unique id of specific external connector.
  31  * @debounce:           Debounce time for GPIO IRQ in ms.
  32  * @irq_flags:          IRQ Flags (e.g., IRQF_TRIGGER_LOW).
  33  * @check_on_resume:    Boolean describing whether to check the state of gpio
  34  *                      while resuming from sleep.
  35  */
  36 struct gpio_extcon_data {
  37         struct extcon_dev *edev;
  38         int irq;
  39         struct delayed_work work;
  40         unsigned long debounce_jiffies;
  41         struct gpio_desc *gpiod;
  42         unsigned int extcon_id;
  43         unsigned long debounce;
  44         unsigned long irq_flags;
  45         bool check_on_resume;
  46 };
  47
  48 static void gpio_extcon_work(struct work_struct *work)
  49 {
  50         int state;
  51         struct gpio_extcon_data *data =
  52                 container_of(to_delayed_work(work), struct gpio_extcon_data,
  53                              work);
  54
  55         state = gpiod_get_value_cansleep(data->gpiod);
  56         extcon_set_state_sync(data->edev, data->extcon_id, state);
  57 }
  58
  59 static irqreturn_t gpio_irq_handler(int irq, void *dev_id)
  60 {
  61         struct gpio_extcon_data *data = dev_id;
  62
  63         queue_delayed_work(system_power_efficient_wq, &data->work,
  64                               data->debounce_jiffies);
  65         return IRQ_HANDLED;
  66 }
  67
  68 static int gpio_extcon_probe(struct platform_device *pdev)
  69 {
  70         struct gpio_extcon_data *data;
  71         struct device *dev = &pdev->dev;
  72         int ret;
  73
  74         data = devm_kzalloc(dev, sizeof(struct gpio_extcon_data), GFP_KERNEL);
  75         if (!data)
  76                 return -ENOMEM;
  77
  78         /*
  79          * FIXME: extcon_id represents the unique identifier of external
  80          * connectors such as EXTCON_USB, EXTCON_DISP_HDMI and so on. extcon_id
  81          * is necessary to register the extcon device. But, it's not yet
  82          * developed to get the extcon id from device-tree or others.
  83          * On later, it have to be solved.
  84          */
  85         if (!data->irq_flags || data->extcon_id > EXTCON_NONE)
  86                 return -EINVAL;
  87
  88         data->gpiod = devm_gpiod_get(dev, "extcon", GPIOD_IN);
  89         if (IS_ERR(data->gpiod))
  90                 return PTR_ERR(data->gpiod);
  91         data->irq = gpiod_to_irq(data->gpiod);
  92         if (data->irq <= 0)
  93                 return data->irq;
  94
  95         /* Allocate the memory of extcon devie and register extcon device */
  96         data->edev = devm_extcon_dev_allocate(dev, &data->extcon_id);
  97         if (IS_ERR(data->edev)) {
  98                 dev_err(dev, "failed to allocate extcon device\n");
  99                 return -ENOMEM;
 100         }
 101
 102         ret = devm_extcon_dev_register(dev, data->edev);
 103         if (ret < 0)
 104                 return ret;
 105
 106         INIT_DELAYED_WORK(&data->work, gpio_extcon_work);
 107
 108         /*
 109          * Request the interrupt of gpio to detect whether external connector
 110          * is attached or detached.
 111          */
 112         ret = devm_request_any_context_irq(dev, data->irq,
 113                                         gpio_irq_handler, data->irq_flags,
 114                                         pdev->name, data);
 115         if (ret < 0)
 116                 return ret;
 117
 118         platform_set_drvdata(pdev, data);
 119         /* Perform initial detection */
 120         gpio_extcon_work(&data->work.work);
 121
 122         return 0;
 123 }
 124
 125 static int gpio_extcon_remove(struct platform_device *pdev)
 126 {
 127         struct gpio_extcon_data *data = platform_get_drvdata(pdev);
 128
 129         cancel_delayed_work_sync(&data->work);
 130
 131         return 0;
 132 }
 133
 134 #ifdef CONFIG_PM_SLEEP
 135 static int gpio_extcon_resume(struct device *dev)
 136 {
 137         struct gpio_extcon_data *data;
 138
 139         data = dev_get_drvdata(dev);
 140         if (data->check_on_resume)
 141                 queue_delayed_work(system_power_efficient_wq,
 142                         &data->work, data->debounce_jiffies);
 143
 144         return 0;
 145 }
 146 #endif
 147
 148 static SIMPLE_DEV_PM_OPS(gpio_extcon_pm_ops, NULL, gpio_extcon_resume);
 149
 150 static struct platform_driver gpio_extcon_driver = {
 151         .probe          = gpio_extcon_probe,
 152         .remove         = gpio_extcon_remove,
 153         .driver         = {
 154                 .name   = "extcon-gpio",
 155                 .pm     = &gpio_extcon_pm_ops,
 156         },
 157 };
 158
 159 module_platform_driver(gpio_extcon_driver);
 160
 161 MODULE_AUTHOR("Mike Lockwood <lockwood@android.com>");
 162 MODULE_DESCRIPTION("GPIO extcon driver");
 163 MODULE_LICENSE("GPL");