drivers/extcon/extcon-usb-gpio.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * drivers/extcon/extcon-usb-gpio.c - USB GPIO extcon driver
   4  *
   5  * Copyright (C) 2015 Texas Instruments Incorporated - https://www.ti.com
   6  * Author: Roger Quadros <rogerq@ti.com>
   7  */
   8
   9 #include <linux/extcon-provider.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/init.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/irq.h>
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/slab.h>
  18 #include <linux/workqueue.h>
  19 #include <linux/pinctrl/consumer.h>
  20 #include <linux/mod_devicetable.h>
  21
  22 #define USB_GPIO_DEBOUNCE_MS    20      /* ms */
  23
  24 struct usb_extcon_info {
  25         struct device *dev;
  26         struct extcon_dev *edev;
  27
  28         struct gpio_desc *id_gpiod;
  29         struct gpio_desc *vbus_gpiod;
  30         int id_irq;
  31         int vbus_irq;
  32
  33         unsigned long debounce_jiffies;
  34         struct delayed_work wq_detcable;
  35 };
  36
  37 static const unsigned int usb_extcon_cable[] = {
  38         EXTCON_USB,
  39         EXTCON_USB_HOST,
  40         EXTCON_NONE,
  41 };
  42
  43 /*
  44  * "USB" = VBUS and "USB-HOST" = !ID, so we have:
  45  * Both "USB" and "USB-HOST" can't be set as active at the
  46  * same time so if "USB-HOST" is active (i.e. ID is 0)  we keep "USB" inactive
  47  * even if VBUS is on.
  48  *
  49  *  State              |    ID   |   VBUS
  50  * ----------------------------------------
  51  *  [1] USB            |    H    |    H
  52  *  [2] none           |    H    |    L
  53  *  [3] USB-HOST       |    L    |    H
  54  *  [4] USB-HOST       |    L    |    L
  55  *
  56  * In case we have only one of these signals:
  57  * - VBUS only - we want to distinguish between [1] and [2], so ID is always 1.
  58  * - ID only - we want to distinguish between [1] and [4], so VBUS = ID.
  59 */
  60 static void usb_extcon_detect_cable(struct work_struct *work)
  61 {
  62         int id, vbus;
  63         struct usb_extcon_info *info = container_of(to_delayed_work(work),
  64                                                     struct usb_extcon_info,
  65                                                     wq_detcable);
  66
  67         /* check ID and VBUS and update cable state */
  68         id = info->id_gpiod ?
  69                 gpiod_get_value_cansleep(info->id_gpiod) : 1;
  70         vbus = info->vbus_gpiod ?
  71                 gpiod_get_value_cansleep(info->vbus_gpiod) : id;
  72
  73         /* at first we clean states which are no longer active */
  74         if (id)
  75                 extcon_set_state_sync(info->edev, EXTCON_USB_HOST, false);
  76         if (!vbus)
  77                 extcon_set_state_sync(info->edev, EXTCON_USB, false);
  78
  79         if (!id) {
  80                 extcon_set_state_sync(info->edev, EXTCON_USB_HOST, true);
  81         } else {
  82                 if (vbus)
  83                         extcon_set_state_sync(info->edev, EXTCON_USB, true);
  84         }
  85 }
  86
  87 static irqreturn_t usb_irq_handler(int irq, void *dev_id)
  88 {
  89         struct usb_extcon_info *info = dev_id;
  90
  91         queue_delayed_work(system_power_efficient_wq, &info->wq_detcable,
  92                            info->debounce_jiffies);
  93
  94         return IRQ_HANDLED;
  95 }
  96
  97 static int usb_extcon_probe(struct platform_device *pdev)
  98 {
  99         struct device *dev = &pdev->dev;
 100         struct device_node *np = dev->of_node;
 101         struct usb_extcon_info *info;
 102         int ret;
 103
 104         if (!np)
 105                 return -EINVAL;
 106
 107         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
 108         if (!info)
 109                 return -ENOMEM;
 110
 111         info->dev = dev;
 112         info->id_gpiod = devm_gpiod_get_optional(&pdev->dev, "id", GPIOD_IN);
 113         info->vbus_gpiod = devm_gpiod_get_optional(&pdev->dev, "vbus",
 114                                                    GPIOD_IN);
 115
 116         if (!info->id_gpiod && !info->vbus_gpiod) {
 117                 dev_err(dev, "failed to get gpios\n");
 118                 return -ENODEV;
 119         }
 120
 121         if (IS_ERR(info->id_gpiod))
 122                 return PTR_ERR(info->id_gpiod);
 123
 124         if (IS_ERR(info->vbus_gpiod))
 125                 return PTR_ERR(info->vbus_gpiod);
 126
 127         info->edev = devm_extcon_dev_allocate(dev, usb_extcon_cable);
 128         if (IS_ERR(info->edev)) {
 129                 dev_err(dev, "failed to allocate extcon device\n");
 130                 return -ENOMEM;
 131         }
 132
 133         ret = devm_extcon_dev_register(dev, info->edev);
 134         if (ret < 0) {
 135                 dev_err(dev, "failed to register extcon device\n");
 136                 return ret;
 137         }
 138
 139         if (info->id_gpiod)
 140                 ret = gpiod_set_debounce(info->id_gpiod,
 141                                          USB_GPIO_DEBOUNCE_MS * 1000);
 142         if (!ret && info->vbus_gpiod)
 143                 ret = gpiod_set_debounce(info->vbus_gpiod,
 144                                          USB_GPIO_DEBOUNCE_MS * 1000);
 145
 146         if (ret < 0)
 147                 info->debounce_jiffies = msecs_to_jiffies(USB_GPIO_DEBOUNCE_MS);
 148
 149         INIT_DELAYED_WORK(&info->wq_detcable, usb_extcon_detect_cable);
 150
 151         if (info->id_gpiod) {
 152                 info->id_irq = gpiod_to_irq(info->id_gpiod);
 153                 if (info->id_irq < 0) {
 154                         dev_err(dev, "failed to get ID IRQ\n");
 155                         return info->id_irq;
 156                 }
 157
 158                 ret = devm_request_threaded_irq(dev, info->id_irq, NULL,
 159                                                 usb_irq_handler,
 160                                                 IRQF_TRIGGER_RISING |
 161                                                 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 162                                                 pdev->name, info);
 163                 if (ret < 0) {
 164                         dev_err(dev, "failed to request handler for ID IRQ\n");
 165                         return ret;
 166                 }
 167         }
 168
 169         if (info->vbus_gpiod) {
 170                 info->vbus_irq = gpiod_to_irq(info->vbus_gpiod);
 171                 if (info->vbus_irq < 0) {
 172                         dev_err(dev, "failed to get VBUS IRQ\n");
 173                         return info->vbus_irq;
 174                 }
 175
 176                 ret = devm_request_threaded_irq(dev, info->vbus_irq, NULL,
 177                                                 usb_irq_handler,
 178                                                 IRQF_TRIGGER_RISING |
 179                                                 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 180                                                 pdev->name, info);
 181                 if (ret < 0) {
 182                         dev_err(dev, "failed to request handler for VBUS IRQ\n");
 183                         return ret;
 184                 }
 185         }
 186
 187         platform_set_drvdata(pdev, info);
 188         device_set_wakeup_capable(&pdev->dev, true);
 189
 190         /* Perform initial detection */
 191         usb_extcon_detect_cable(&info->wq_detcable.work);
 192
 193         return 0;
 194 }
 195
 196 static int usb_extcon_remove(struct platform_device *pdev)
 197 {
 198         struct usb_extcon_info *info = platform_get_drvdata(pdev);
 199
 200         cancel_delayed_work_sync(&info->wq_detcable);
 201         device_init_wakeup(&pdev->dev, false);
 202
 203         return 0;
 204 }
 205
 206 #ifdef CONFIG_PM_SLEEP
 207 static int usb_extcon_suspend(struct device *dev)
 208 {
 209         struct usb_extcon_info *info = dev_get_drvdata(dev);
 210         int ret = 0;
 211
 212         if (device_may_wakeup(dev)) {
 213                 if (info->id_gpiod) {
 214                         ret = enable_irq_wake(info->id_irq);
 215                         if (ret)
 216                                 return ret;
 217                 }
 218                 if (info->vbus_gpiod) {
 219                         ret = enable_irq_wake(info->vbus_irq);
 220                         if (ret) {
 221                                 if (info->id_gpiod)
 222                                         disable_irq_wake(info->id_irq);
 223
 224                                 return ret;
 225                         }
 226                 }
 227         }
 228
 229         if (!device_may_wakeup(dev))
 230                 pinctrl_pm_select_sleep_state(dev);
 231
 232         return ret;
 233 }
 234
 235 static int usb_extcon_resume(struct device *dev)
 236 {
 237         struct usb_extcon_info *info = dev_get_drvdata(dev);
 238         int ret = 0;
 239
 240         if (!device_may_wakeup(dev))
 241                 pinctrl_pm_select_default_state(dev);
 242
 243         if (device_may_wakeup(dev)) {
 244                 if (info->id_gpiod) {
 245                         ret = disable_irq_wake(info->id_irq);
 246                         if (ret)
 247                                 return ret;
 248                 }
 249                 if (info->vbus_gpiod) {
 250                         ret = disable_irq_wake(info->vbus_irq);
 251                         if (ret) {
 252                                 if (info->id_gpiod)
 253                                         enable_irq_wake(info->id_irq);
 254
 255                                 return ret;
 256                         }
 257                 }
 258         }
 259
 260         queue_delayed_work(system_power_efficient_wq,
 261                            &info->wq_detcable, 0);
 262
 263         return ret;
 264 }
 265 #endif
 266
 267 static SIMPLE_DEV_PM_OPS(usb_extcon_pm_ops,
 268                          usb_extcon_suspend, usb_extcon_resume);
 269
 270 static const struct of_device_id usb_extcon_dt_match[] = {
 271         { .compatible = "linux,extcon-usb-gpio", },
 272         { /* sentinel */ }
 273 };
 274 MODULE_DEVICE_TABLE(of, usb_extcon_dt_match);
 275
 276 static const struct platform_device_id usb_extcon_platform_ids[] = {
 277         { .name = "extcon-usb-gpio", },
 278         { /* sentinel */ }
 279 };
 280 MODULE_DEVICE_TABLE(platform, usb_extcon_platform_ids);
 281
 282 static struct platform_driver usb_extcon_driver = {
 283         .probe          = usb_extcon_probe,
 284         .remove         = usb_extcon_remove,
 285         .driver         = {
 286                 .name   = "extcon-usb-gpio",
 287                 .pm     = &usb_extcon_pm_ops,
 288                 .of_match_table = usb_extcon_dt_match,
 289         },
 290         .id_table = usb_extcon_platform_ids,
 291 };
 292
 293 module_platform_driver(usb_extcon_driver);
 294
 295 MODULE_AUTHOR("Roger Quadros <rogerq@ti.com>");
 296 MODULE_DESCRIPTION("USB GPIO extcon driver");
 297 MODULE_LICENSE("GPL v2");