1 /*
2 * universal charger driver
3 *
4 * Copyright (C) 2016 Fuzhou Rockchip Electronics Co., Ltd
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 */
16
17 #include <linux/extcon.h>
18 #include <linux/interrupt.h>
19 #include <linux/irq.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/of_gpio.h>
23 #include <linux/platform_device.h>
24 #include <linux/power_supply.h>
25 #include <linux/power/rk_usbbc.h>
26 #include <linux/property.h>
27 #include <linux/workqueue.h>
28
29 enum charger_t {
30 USB_TYPE_UNKNOWN_CHARGER,
31 USB_TYPE_NONE_CHARGER,
32 USB_TYPE_USB_CHARGER,
33 USB_TYPE_AC_CHARGER,
34 USB_TYPE_CDP_CHARGER,
35 DC_TYPE_DC_CHARGER,
36 DC_TYPE_NONE_CHARGER,
37 };
38
39 struct universal_charger {
40 struct device *dev;
41 struct power_supply *usb_psy;
42 struct workqueue_struct *usb_charger_wq;
43 struct delayed_work usb_work;
44 struct workqueue_struct *dc_charger_wq;
45 struct delayed_work dc_work;
46 struct delayed_work discnt_work;
47 struct notifier_block cable_cg_nb;
48 struct notifier_block cable_discnt_nb;
49 unsigned int bc_event;
50 enum charger_t usb_charger;
51 enum charger_t dc_charger;
52 bool extcon;
53 struct extcon_dev *cable_edev;
54 struct gpio_desc *dc_det_pin;
55 bool support_dc_det;
56 };
57
universal_cg_bc_evt_worker(struct work_struct * work)58 static void universal_cg_bc_evt_worker(struct work_struct *work)
59 {
60 struct universal_charger *cg =
61 container_of(work, struct universal_charger, usb_work.work);
62 struct extcon_dev *edev = cg->cable_edev;
63 enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
64 const char *event[5] = {"UN", "NONE", "USB", "AC", "CDP1.5A"};
65
66 /* Determine cable/charger type */
67 if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0)
68 charger = USB_TYPE_USB_CHARGER;
69 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0)
70 charger = USB_TYPE_AC_CHARGER;
71 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0)
72 charger = USB_TYPE_CDP_CHARGER;
73 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) == 0)
74 charger = USB_TYPE_NONE_CHARGER;
75 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) == 0)
76 charger = USB_TYPE_NONE_CHARGER;
77
78 if (charger != USB_TYPE_UNKNOWN_CHARGER) {
79 dev_info(cg->dev, "receive usb notifier event: %s...\n",
80 event[charger]);
81 cg->usb_charger = charger;
82 }
83 }
84
universal_cg_charger_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)85 static int universal_cg_charger_evt_notifier(struct notifier_block *nb,
86 unsigned long event,
87 void *ptr)
88 {
89 struct universal_charger *cg =
90 container_of(nb, struct universal_charger, cable_cg_nb);
91
92 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
93 msecs_to_jiffies(10));
94
95 return NOTIFY_DONE;
96 }
97
universal_cg_discnt_evt_worker(struct work_struct * work)98 static void universal_cg_discnt_evt_worker(struct work_struct *work)
99 {
100 struct universal_charger *cg = container_of(work,
101 struct universal_charger, discnt_work.work);
102
103 if (extcon_get_cable_state_(cg->cable_edev, EXTCON_USB) == 0) {
104 dev_info(cg->dev, "receive usb notifier event: DISCNT...\n");
105 cg->usb_charger = USB_TYPE_NONE_CHARGER;
106 }
107 }
108
universal_cg_discnt_evt_notfier(struct notifier_block * nb,unsigned long event,void * ptr)109 static int universal_cg_discnt_evt_notfier(struct notifier_block *nb,
110 unsigned long event, void *ptr)
111 {
112 struct universal_charger *cg =
113 container_of(nb, struct universal_charger, cable_discnt_nb);
114
115 queue_delayed_work(cg->usb_charger_wq, &cg->discnt_work,
116 msecs_to_jiffies(10));
117
118 return NOTIFY_DONE;
119 }
120
universal_cg_init_usb(struct universal_charger * cg)121 static int universal_cg_init_usb(struct universal_charger *cg)
122 {
123 struct device *dev = cg->dev;
124 int ret;
125 struct extcon_dev *edev;
126
127 if (!cg->extcon)
128 return 0;
129
130 edev = extcon_get_edev_by_phandle(dev, 0);
131 if (IS_ERR(edev)) {
132 if (PTR_ERR(edev) != -EPROBE_DEFER)
133 dev_err(dev, "Invalid or missing extcon\n");
134 return PTR_ERR(edev);
135 }
136
137 cg->usb_charger_wq = alloc_ordered_workqueue("%s",
138 WQ_MEM_RECLAIM | WQ_FREEZABLE,
139 "universal-usb-wq");
140 if (!cg->usb_charger_wq)
141 return -ENOMEM;
142
143 cg->usb_charger = USB_TYPE_NONE_CHARGER;
144
145 /* Register chargers */
146 INIT_DELAYED_WORK(&cg->usb_work, universal_cg_bc_evt_worker);
147 cg->cable_cg_nb.notifier_call = universal_cg_charger_evt_notifier;
148 ret = devm_extcon_register_notifier(dev, edev, EXTCON_CHG_USB_SDP,
149 &cg->cable_cg_nb);
150 if (ret < 0) {
151 dev_err(dev, "failed to register notifier for SDP\n");
152 goto __fail;
153 }
154
155 ret = devm_extcon_register_notifier(dev, edev, EXTCON_CHG_USB_DCP,
156 &cg->cable_cg_nb);
157 if (ret < 0) {
158 dev_err(dev, "failed to register notifier for DCP\n");
159 goto __fail;
160 }
161
162 ret = devm_extcon_register_notifier(dev, edev, EXTCON_CHG_USB_CDP,
163 &cg->cable_cg_nb);
164 if (ret < 0) {
165 dev_err(dev, "failed to register notifier for CDP\n");
166 goto __fail;
167 }
168
169 /* Register discnt usb */
170 INIT_DELAYED_WORK(&cg->discnt_work, universal_cg_discnt_evt_worker);
171 cg->cable_discnt_nb.notifier_call = universal_cg_discnt_evt_notfier;
172 ret = devm_extcon_register_notifier(dev, edev, EXTCON_USB,
173 &cg->cable_discnt_nb);
174 if (ret < 0) {
175 dev_err(dev, "failed to register notifier for HOST\n");
176 goto __fail;
177 }
178
179 cg->cable_edev = edev;
180 schedule_delayed_work(&cg->usb_work, 0);
181 dev_info(cg->dev, "register extcon evt notifier\n");
182
183 return 0;
184
185 __fail:
186 destroy_workqueue(cg->usb_charger_wq);
187 return ret;
188 }
189
190 static enum power_supply_property universal_usb_props[] = {
191 POWER_SUPPLY_PROP_ONLINE,
192 POWER_SUPPLY_PROP_STATUS,
193 };
194
universal_cg_usb_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)195 static int universal_cg_usb_get_property(struct power_supply *psy,
196 enum power_supply_property psp,
197 union power_supply_propval *val)
198 {
199 struct universal_charger *cg = power_supply_get_drvdata(psy);
200 int online = 0;
201 int ret = 0;
202
203 if (cg->usb_charger != USB_TYPE_UNKNOWN_CHARGER &&
204 cg->usb_charger != USB_TYPE_NONE_CHARGER)
205 online = 1;
206 if (cg->dc_charger != DC_TYPE_NONE_CHARGER)
207 online = 1;
208 switch (psp) {
209 case POWER_SUPPLY_PROP_ONLINE:
210 val->intval = online;
211
212 dev_dbg(cg->dev, "report online: %d\n", val->intval);
213 break;
214 case POWER_SUPPLY_PROP_STATUS:
215 if (online)
216 val->intval = POWER_SUPPLY_STATUS_CHARGING;
217 else
218 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
219
220 dev_dbg(cg->dev, "report prop: %d\n", val->intval);
221 break;
222 default:
223 ret = -EINVAL;
224 break;
225 }
226
227 return ret;
228 }
229
230 static const struct power_supply_desc universal_usb_desc = {
231 .name = "universal_usb",
232 .type = POWER_SUPPLY_TYPE_USB,
233 .properties = universal_usb_props,
234 .num_properties = ARRAY_SIZE(universal_usb_props),
235 .get_property = universal_cg_usb_get_property,
236 };
237
universal_cg_init_power_supply(struct universal_charger * cg)238 static int universal_cg_init_power_supply(struct universal_charger *cg)
239 {
240 struct power_supply_config psy_cfg = { .drv_data = cg, };
241
242 cg->usb_psy = devm_power_supply_register(cg->dev, &universal_usb_desc,
243 &psy_cfg);
244 if (IS_ERR(cg->usb_psy)) {
245 dev_err(cg->dev, "register usb power supply fail\n");
246 return PTR_ERR(cg->usb_psy);
247 }
248
249 return 0;
250 }
251
252 #ifdef CONFIG_OF
universal_charger_parse_dt(struct universal_charger * cg)253 static int universal_charger_parse_dt(struct universal_charger *cg)
254 {
255 struct device *dev = cg->dev;
256
257 cg->dc_det_pin = devm_gpiod_get_optional(dev, "dc-det",
258 GPIOD_IN);
259 if (!IS_ERR_OR_NULL(cg->dc_det_pin)) {
260 cg->support_dc_det = true;
261 } else {
262 dev_err(dev, "invalid dc det gpio!\n");
263 cg->support_dc_det = false;
264 }
265
266 return 0;
267 }
268 #else
universal_charger_parse_dt(struct universal_charger * cg)269 static int universal_charger_parse_dt(struct universal_charger *cg)
270 {
271 return -ENODEV;
272 }
273 #endif
274
275 static enum
universal_charger_get_dc_state(struct universal_charger * cg)276 charger_t universal_charger_get_dc_state(struct universal_charger *cg)
277 {
278 return (gpiod_get_value(cg->dc_det_pin)) ?
279 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
280 }
281
universal_charger_dc_det_worker(struct work_struct * work)282 static void universal_charger_dc_det_worker(struct work_struct *work)
283 {
284 enum charger_t charger;
285 struct universal_charger *cg = container_of(work,
286 struct universal_charger, dc_work.work);
287
288 charger = universal_charger_get_dc_state(cg);
289 if (charger == DC_TYPE_DC_CHARGER)
290 cg->dc_charger = charger;
291 else
292 cg->dc_charger = DC_TYPE_NONE_CHARGER;
293 }
294
universal_charger_dc_det_isr(int irq,void * charger)295 static irqreturn_t universal_charger_dc_det_isr(int irq, void *charger)
296 {
297 struct universal_charger *cg = (struct universal_charger *)charger;
298
299 queue_delayed_work(cg->dc_charger_wq, &cg->dc_work,
300 msecs_to_jiffies(10));
301
302 return IRQ_HANDLED;
303 }
304
universal_charger_init_dc(struct universal_charger * cg)305 static int universal_charger_init_dc(struct universal_charger *cg)
306 {
307 int ret;
308 unsigned long irq_flags;
309 unsigned int dc_det_irq;
310
311 if (!cg->support_dc_det)
312 return 0;
313
314 cg->dc_charger_wq = alloc_ordered_workqueue("%s",
315 WQ_MEM_RECLAIM | WQ_FREEZABLE,
316 "universal-dc-wq");
317 if (!cg->dc_charger_wq)
318 return -ENOMEM;
319
320 INIT_DELAYED_WORK(&cg->dc_work, universal_charger_dc_det_worker);
321 cg->dc_charger = DC_TYPE_NONE_CHARGER;
322
323 if (gpiod_get_value(cg->dc_det_pin))
324 cg->dc_charger = DC_TYPE_DC_CHARGER;
325 else
326 cg->dc_charger = DC_TYPE_NONE_CHARGER;
327
328 irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
329 dc_det_irq = gpiod_to_irq(cg->dc_det_pin);
330 ret = devm_request_irq(cg->dev, dc_det_irq,
331 universal_charger_dc_det_isr,
332 irq_flags, "universal_dc_det", cg);
333 if (ret != 0) {
334 destroy_workqueue(cg->dc_charger_wq);
335 dev_err(cg->dev, "universal_dc_det_irq request failed!\n");
336 return ret;
337 }
338
339 enable_irq_wake(dc_det_irq);
340
341 return 0;
342 }
343
universal_charger_probe(struct platform_device * pdev)344 static int universal_charger_probe(struct platform_device *pdev)
345 {
346 struct universal_charger *cg;
347 int ret;
348
349 cg = devm_kzalloc(&pdev->dev, sizeof(*cg), GFP_KERNEL);
350 if (!cg)
351 return -ENOMEM;
352
353 cg->dev = &pdev->dev;
354 universal_charger_parse_dt(cg);
355 ret = universal_charger_init_dc(cg);
356 if (ret) {
357 dev_err(cg->dev, "init dc failed!\n");
358 return ret;
359 }
360 cg->extcon = device_property_read_bool(cg->dev, "extcon");
361 ret = universal_cg_init_usb(cg);
362 if (ret) {
363 dev_err(cg->dev, "init usb failed!\n");
364 goto __init_usb_fail;
365 }
366
367 ret = universal_cg_init_power_supply(cg);
368 if (ret) {
369 dev_err(cg->dev, "init power supply fail!\n");
370 goto ___init_psy_fail;
371 }
372
373 dev_info(cg->dev, "driver registered\n");
374
375 return 0;
376
377 ___init_psy_fail:
378 if (cg->usb_charger_wq)
379 destroy_workqueue(cg->usb_charger_wq);
380 __init_usb_fail:
381 if (cg->dc_charger_wq)
382 destroy_workqueue(cg->dc_charger_wq);
383
384 return ret;
385 }
386
universal_charger_remove(struct platform_device * pdev)387 static int universal_charger_remove(struct platform_device *pdev)
388 {
389 struct universal_charger *cg = platform_get_drvdata(pdev);
390
391 if (cg->usb_charger_wq)
392 destroy_workqueue(cg->usb_charger_wq);
393 if (cg->dc_charger_wq)
394 destroy_workqueue(cg->dc_charger_wq);
395
396 return 0;
397 }
398
399 static const struct of_device_id universal_charger_match[] = {
400 {
401 .compatible = "universal-charger",
402 },
403 {},
404 };
405
406 static struct platform_driver universal_charger_driver = {
407 .probe = universal_charger_probe,
408 .remove = universal_charger_remove,
409 .driver = {
410 .name = "universal-charger",
411 .of_match_table = universal_charger_match,
412 },
413 };
414
415 module_platform_driver(universal_charger_driver);
416
417 MODULE_LICENSE("GPL");
418 MODULE_ALIAS("platform:universal-charger");
419 MODULE_AUTHOR("chen Shunqing<csq@rock-chips.com>");
420