1 /*
2 * sy6982c/sy6982e 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/rk_keys.h>
28 #include <linux/workqueue.h>
29
30 enum charger_t {
31 USB_TYPE_UNKNOWN_CHARGER,
32 USB_TYPE_NONE_CHARGER,
33 USB_TYPE_USB_CHARGER,
34 USB_TYPE_AC_CHARGER,
35 USB_TYPE_CDP_CHARGER,
36 DC_TYPE_DC_CHARGER,
37 DC_TYPE_NONE_CHARGER,
38 };
39
40 struct sy6982c_charger {
41 struct device *dev;
42 struct power_supply *usb_psy;
43 struct workqueue_struct *usb_charger_wq;
44 struct delayed_work usb_work;
45 struct workqueue_struct *dc_charger_wq;
46 struct delayed_work dc_work;
47 struct delayed_work discnt_work;
48 struct notifier_block cable_cg_nb;
49 struct notifier_block cable_discnt_nb;
50 unsigned int bc_event;
51 enum charger_t usb_charger;
52 enum charger_t dc_charger;
53 bool extcon;
54 struct extcon_dev *cable_edev;
55 struct gpio_desc *dc_det_pin;
56 bool support_dc_det;
57 };
58
sy6982c_cg_bc_evt_worker(struct work_struct * work)59 static void sy6982c_cg_bc_evt_worker(struct work_struct *work)
60 {
61 struct sy6982c_charger *cg = container_of(work,
62 struct sy6982c_charger, usb_work.work);
63 struct extcon_dev *edev = cg->cable_edev;
64 enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
65 const char *event[5] = {"UN", "NONE", "USB", "AC", "CDP1.5A"};
66
67 /* Determine cable/charger type */
68 if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0)
69 charger = USB_TYPE_USB_CHARGER;
70 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0)
71 charger = USB_TYPE_AC_CHARGER;
72 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0)
73 charger = USB_TYPE_CDP_CHARGER;
74 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) == 0)
75 charger = USB_TYPE_NONE_CHARGER;
76 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) == 0)
77 charger = USB_TYPE_NONE_CHARGER;
78
79 if (charger != USB_TYPE_UNKNOWN_CHARGER) {
80 dev_info(cg->dev, "receive type-c notifier event: %s...\n",
81 event[charger]);
82 cg->usb_charger = charger;
83 }
84 }
85
sy6982c_cg_charger_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)86 static int sy6982c_cg_charger_evt_notifier(struct notifier_block *nb,
87 unsigned long event,
88 void *ptr)
89 {
90 struct sy6982c_charger *cg =
91 container_of(nb, struct sy6982c_charger, cable_cg_nb);
92
93 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
94 msecs_to_jiffies(10));
95
96 return NOTIFY_DONE;
97 }
98
sy6982c_cg_discnt_evt_worker(struct work_struct * work)99 static void sy6982c_cg_discnt_evt_worker(struct work_struct *work)
100 {
101 struct sy6982c_charger *cg = container_of(work,
102 struct sy6982c_charger, discnt_work.work);
103
104 if (extcon_get_cable_state_(cg->cable_edev, EXTCON_USB) == 0) {
105 dev_info(cg->dev, "receive type-c notifier event: DISCNT...\n");
106 cg->usb_charger = USB_TYPE_NONE_CHARGER;
107 }
108 }
109
sy6982c_cg_discnt_evt_notfier(struct notifier_block * nb,unsigned long event,void * ptr)110 static int sy6982c_cg_discnt_evt_notfier(struct notifier_block *nb,
111 unsigned long event, void *ptr)
112 {
113 struct sy6982c_charger *cg =
114 container_of(nb, struct sy6982c_charger, cable_discnt_nb);
115
116 queue_delayed_work(cg->usb_charger_wq, &cg->discnt_work,
117 msecs_to_jiffies(10));
118
119 return NOTIFY_DONE;
120 }
121
sy6982c_cg_init_usb(struct sy6982c_charger * cg)122 static int sy6982c_cg_init_usb(struct sy6982c_charger *cg)
123 {
124 struct device *dev = cg->dev;
125 int ret;
126 struct extcon_dev *edev;
127
128 if (!cg->extcon)
129 return -1;
130
131 edev = extcon_get_edev_by_phandle(dev, 0);
132 if (IS_ERR(edev)) {
133 if (PTR_ERR(edev) != -EPROBE_DEFER)
134 dev_err(dev, "Invalid or missing extcon\n");
135 return PTR_ERR(edev);
136 }
137
138 cg->usb_charger_wq = alloc_ordered_workqueue("%s",
139 WQ_MEM_RECLAIM | WQ_FREEZABLE,
140 "sy6982c-usb-wq");
141 cg->usb_charger = USB_TYPE_NONE_CHARGER;
142
143 /* Register chargers */
144 INIT_DELAYED_WORK(&cg->usb_work, sy6982c_cg_bc_evt_worker);
145 cg->cable_cg_nb.notifier_call = sy6982c_cg_charger_evt_notifier;
146 ret = devm_extcon_register_notifier(dev, edev, EXTCON_CHG_USB_SDP,
147 &cg->cable_cg_nb);
148 if (ret < 0) {
149 dev_err(dev, "failed to register notifier for SDP\n");
150 goto __fail;
151 }
152
153 ret = devm_extcon_register_notifier(dev, edev, EXTCON_CHG_USB_DCP,
154 &cg->cable_cg_nb);
155 if (ret < 0) {
156 dev_err(dev, "failed to register notifier for DCP\n");
157 goto __fail;
158 }
159
160 ret = devm_extcon_register_notifier(dev, edev, EXTCON_CHG_USB_CDP,
161 &cg->cable_cg_nb);
162 if (ret < 0) {
163 dev_err(dev, "failed to register notifier for CDP\n");
164 goto __fail;
165 }
166
167 /* Register discnt usb */
168 INIT_DELAYED_WORK(&cg->discnt_work, sy6982c_cg_discnt_evt_worker);
169 cg->cable_discnt_nb.notifier_call = sy6982c_cg_discnt_evt_notfier;
170 ret = devm_extcon_register_notifier(dev, edev, EXTCON_USB,
171 &cg->cable_discnt_nb);
172 if (ret < 0) {
173 dev_err(dev, "failed to register notifier for HOST\n");
174 goto __fail;
175 }
176
177 cg->cable_edev = edev;
178 schedule_delayed_work(&cg->usb_work, 0);
179 dev_info(cg->dev, "register extcon evt notifier\n");
180
181 return 0;
182
183 __fail:
184 destroy_workqueue(cg->usb_charger_wq);
185 return ret;
186 }
187
188 static enum power_supply_property sy6982c_usb_props[] = {
189 POWER_SUPPLY_PROP_ONLINE,
190 POWER_SUPPLY_PROP_STATUS,
191 };
192
sy6982c_cg_usb_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)193 static int sy6982c_cg_usb_get_property(struct power_supply *psy,
194 enum power_supply_property psp,
195 union power_supply_propval *val)
196 {
197 struct sy6982c_charger *cg = power_supply_get_drvdata(psy);
198 int online = 0;
199 int ret = 0;
200
201 if (cg->usb_charger != USB_TYPE_UNKNOWN_CHARGER &&
202 cg->usb_charger != USB_TYPE_NONE_CHARGER)
203 online = 1;
204 if (cg->dc_charger != DC_TYPE_NONE_CHARGER)
205 online = 1;
206 switch (psp) {
207 case POWER_SUPPLY_PROP_ONLINE:
208 val->intval = online;
209
210 dev_dbg(cg->dev, "report online: %d\n", val->intval);
211 break;
212 case POWER_SUPPLY_PROP_STATUS:
213 if (online)
214 val->intval = POWER_SUPPLY_STATUS_CHARGING;
215 else
216 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
217
218 dev_dbg(cg->dev, "report prop: %d\n", val->intval);
219 break;
220 default:
221 ret = -EINVAL;
222 break;
223 }
224
225 return ret;
226 }
227
228 static const struct power_supply_desc sy6982c_usb_desc = {
229 .name = "sy6982c_usb",
230 .type = POWER_SUPPLY_TYPE_USB,
231 .properties = sy6982c_usb_props,
232 .num_properties = ARRAY_SIZE(sy6982c_usb_props),
233 .get_property = sy6982c_cg_usb_get_property,
234 };
235
sy6982c_cg_init_power_supply(struct sy6982c_charger * cg)236 static int sy6982c_cg_init_power_supply(struct sy6982c_charger *cg)
237 {
238 struct power_supply_config psy_cfg = { .drv_data = cg, };
239
240 cg->usb_psy = devm_power_supply_register(cg->dev, &sy6982c_usb_desc,
241 &psy_cfg);
242 if (IS_ERR(cg->usb_psy)) {
243 dev_err(cg->dev, "register usb power supply fail\n");
244 return PTR_ERR(cg->usb_psy);
245 }
246
247 return 0;
248 }
249
250 #ifdef CONFIG_OF
sy6982c_charger_parse_dt(struct sy6982c_charger * cg)251 static int sy6982c_charger_parse_dt(struct sy6982c_charger *cg)
252 {
253 struct device *dev = cg->dev;
254
255 cg->dc_det_pin = devm_gpiod_get_optional(dev, "dc-det",
256 GPIOD_IN);
257 if (!IS_ERR_OR_NULL(cg->dc_det_pin)) {
258 cg->support_dc_det = true;
259 } else {
260 dev_err(dev, "invalid dc det gpio!\n");
261 cg->support_dc_det = false;
262 }
263
264 return 0;
265 }
266 #else
sy6982c_charger_parse_dt(struct sy6982c_charger * cg)267 static int sy6982c_charger_parse_dt(struct sy6982c_charger *cg)
268 {
269 return -ENODEV;
270 }
271 #endif
272
sy6982c_charger_get_dc_state(struct sy6982c_charger * cg)273 static enum charger_t sy6982c_charger_get_dc_state(struct sy6982c_charger *cg)
274 {
275 return (gpiod_get_value(cg->dc_det_pin)) ?
276 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
277 }
278
sy6982c_charger_dc_det_worker(struct work_struct * work)279 static void sy6982c_charger_dc_det_worker(struct work_struct *work)
280 {
281 enum charger_t charger;
282 struct sy6982c_charger *cg = container_of(work,
283 struct sy6982c_charger, dc_work.work);
284
285 charger = sy6982c_charger_get_dc_state(cg);
286 if (charger == DC_TYPE_DC_CHARGER)
287 cg->dc_charger = charger;
288 else
289 cg->dc_charger = DC_TYPE_NONE_CHARGER;
290
291 rk_send_wakeup_key();
292 }
293
sy6982c_charger_dc_det_isr(int irq,void * charger)294 static irqreturn_t sy6982c_charger_dc_det_isr(int irq, void *charger)
295 {
296 struct sy6982c_charger *cg = (struct sy6982c_charger *)charger;
297
298 queue_delayed_work(cg->dc_charger_wq, &cg->dc_work,
299 msecs_to_jiffies(10));
300
301 return IRQ_HANDLED;
302 }
303
sy6982c_charger_init_dc(struct sy6982c_charger * cg)304 static int sy6982c_charger_init_dc(struct sy6982c_charger *cg)
305 {
306 int ret;
307 unsigned long irq_flags;
308 unsigned int dc_det_irq;
309
310 if (!cg->support_dc_det)
311 return 0;
312
313 cg->dc_charger_wq = alloc_ordered_workqueue("%s",
314 WQ_MEM_RECLAIM | WQ_FREEZABLE,
315 "sy6982c-dc-wq");
316 if (!cg->dc_charger_wq)
317 return -EINVAL;
318
319 INIT_DELAYED_WORK(&cg->dc_work, sy6982c_charger_dc_det_worker);
320 cg->dc_charger = DC_TYPE_NONE_CHARGER;
321
322 if (gpiod_get_value(cg->dc_det_pin))
323 cg->dc_charger = DC_TYPE_DC_CHARGER;
324 else
325 cg->dc_charger = DC_TYPE_NONE_CHARGER;
326
327 irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
328 dc_det_irq = gpiod_to_irq(cg->dc_det_pin);
329 ret = devm_request_irq(cg->dev, dc_det_irq, sy6982c_charger_dc_det_isr,
330 irq_flags, "sy6982c_dc_det", cg);
331 if (ret != 0) {
332 dev_err(cg->dev, "sy6982c_dc_det_irq request failed!\n");
333 return ret;
334 }
335
336 enable_irq_wake(dc_det_irq);
337
338 return 0;
339 }
340
sy6982c_charger_probe(struct platform_device * pdev)341 static int sy6982c_charger_probe(struct platform_device *pdev)
342 {
343 struct sy6982c_charger *cg;
344 int ret;
345
346 cg = devm_kzalloc(&pdev->dev, sizeof(*cg), GFP_KERNEL);
347 if (!cg)
348 return -ENOMEM;
349
350 cg->dev = &pdev->dev;
351 sy6982c_charger_parse_dt(cg);
352 sy6982c_charger_init_dc(cg);
353 cg->extcon = device_property_read_bool(cg->dev, "extcon");
354 ret = sy6982c_cg_init_usb(cg);
355 if (ret) {
356 dev_err(cg->dev, "init usb failed!\n");
357 return ret;
358 }
359
360 ret = sy6982c_cg_init_power_supply(cg);
361 if (ret) {
362 dev_err(cg->dev, "init power supply fail!\n");
363 return ret;
364 }
365
366 dev_info(cg->dev, "driver registered\n");
367
368 return 0;
369 }
370
sy6982c_charger_remove(struct platform_device * pdev)371 static int sy6982c_charger_remove(struct platform_device *pdev)
372 {
373 struct sy6982c_charger *cg = platform_get_drvdata(pdev);
374
375 if (cg->usb_charger_wq)
376 destroy_workqueue(cg->usb_charger_wq);
377
378 return 0;
379 }
380
381 static const struct of_device_id sy6982c_charger_match[] = {
382 {
383 .compatible = "sy6982c-charger",
384 },
385 {},
386 };
387
388 static struct platform_driver sy6982c_charger_driver = {
389 .probe = sy6982c_charger_probe,
390 .remove = sy6982c_charger_remove,
391 .driver = {
392 .name = "sy6982c-charger",
393 .of_match_table = sy6982c_charger_match,
394 },
395 };
396
397 module_platform_driver(sy6982c_charger_driver);
398
399 MODULE_LICENSE("GPL");
400 MODULE_ALIAS("platform:sy6982c-charger");
401 MODULE_AUTHOR("chen Shunqing<csq@rock-chips.com>");
402