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