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(desc: info->id_gpiod) : 1; |
70 | vbus = info->vbus_gpiod ? |
71 | gpiod_get_value_cansleep(desc: info->vbus_gpiod) : id; |
72 | |
73 | /* at first we clean states which are no longer active */ |
74 | if (id) |
75 | extcon_set_state_sync(edev: info->edev, EXTCON_USB_HOST, state: false); |
76 | if (!vbus) |
77 | extcon_set_state_sync(edev: info->edev, EXTCON_USB, state: false); |
78 | |
79 | if (!id) { |
80 | extcon_set_state_sync(edev: info->edev, EXTCON_USB_HOST, state: true); |
81 | } else { |
82 | if (vbus) |
83 | extcon_set_state_sync(edev: info->edev, EXTCON_USB, state: 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(wq: system_power_efficient_wq, dwork: &info->wq_detcable, |
92 | delay: 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(dev: &pdev->dev, size: sizeof(*info), GFP_KERNEL); |
108 | if (!info) |
109 | return -ENOMEM; |
110 | |
111 | info->dev = dev; |
112 | info->id_gpiod = devm_gpiod_get_optional(dev: &pdev->dev, con_id: "id" , flags: GPIOD_IN); |
113 | info->vbus_gpiod = devm_gpiod_get_optional(dev: &pdev->dev, con_id: "vbus" , |
114 | flags: 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(ptr: info->id_gpiod)) |
122 | return PTR_ERR(ptr: info->id_gpiod); |
123 | |
124 | if (IS_ERR(ptr: info->vbus_gpiod)) |
125 | return PTR_ERR(ptr: info->vbus_gpiod); |
126 | |
127 | info->edev = devm_extcon_dev_allocate(dev, cable: usb_extcon_cable); |
128 | if (IS_ERR(ptr: info->edev)) { |
129 | dev_err(dev, "failed to allocate extcon device\n" ); |
130 | return -ENOMEM; |
131 | } |
132 | |
133 | ret = devm_extcon_dev_register(dev, edev: 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(desc: info->id_gpiod, |
141 | USB_GPIO_DEBOUNCE_MS * 1000); |
142 | if (!ret && info->vbus_gpiod) |
143 | ret = gpiod_set_debounce(desc: 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(desc: 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, irq: info->id_irq, NULL, |
159 | thread_fn: usb_irq_handler, |
160 | IRQF_TRIGGER_RISING | |
161 | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
162 | devname: pdev->name, dev_id: 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(desc: 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, irq: info->vbus_irq, NULL, |
177 | thread_fn: usb_irq_handler, |
178 | IRQF_TRIGGER_RISING | |
179 | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
180 | devname: pdev->name, dev_id: 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, data: info); |
188 | device_set_wakeup_capable(dev: &pdev->dev, capable: true); |
189 | |
190 | /* Perform initial detection */ |
191 | usb_extcon_detect_cable(work: &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(dwork: &info->wq_detcable); |
201 | device_init_wakeup(dev: &pdev->dev, enable: 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(irq: info->id_irq); |
215 | if (ret) |
216 | return ret; |
217 | } |
218 | if (info->vbus_gpiod) { |
219 | ret = enable_irq_wake(irq: info->vbus_irq); |
220 | if (ret) { |
221 | if (info->id_gpiod) |
222 | disable_irq_wake(irq: 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(irq: info->id_irq); |
246 | if (ret) |
247 | return ret; |
248 | } |
249 | if (info->vbus_gpiod) { |
250 | ret = disable_irq_wake(irq: info->vbus_irq); |
251 | if (ret) { |
252 | if (info->id_gpiod) |
253 | enable_irq_wake(irq: info->id_irq); |
254 | |
255 | return ret; |
256 | } |
257 | } |
258 | } |
259 | |
260 | queue_delayed_work(wq: system_power_efficient_wq, |
261 | dwork: &info->wq_detcable, delay: 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" ); |
298 | |