This source file includes following definitions.
- axp288_extcon_log_rsi
- axp288_get_id_pin
- axp288_usb_role_work
- axp288_get_vbus_attach
- axp288_handle_chrg_det_event
- axp288_extcon_id_evt
- axp288_extcon_isr
- axp288_extcon_enable
- axp288_put_role_sw
- axp288_extcon_probe
- axp288_extcon_suspend
- axp288_extcon_resume
- axp288_extcon_init
- axp288_extcon_exit
1
2
3
4
5
6
7
8
9
10 #include <linux/acpi.h>
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/io.h>
14 #include <linux/slab.h>
15 #include <linux/interrupt.h>
16 #include <linux/platform_device.h>
17 #include <linux/property.h>
18 #include <linux/notifier.h>
19 #include <linux/extcon-provider.h>
20 #include <linux/regmap.h>
21 #include <linux/mfd/axp20x.h>
22 #include <linux/usb/role.h>
23 #include <linux/workqueue.h>
24
25 #include <asm/cpu_device_id.h>
26 #include <asm/intel-family.h>
27
28
29 #define PS_STAT_VBUS_TRIGGER BIT(0)
30 #define PS_STAT_BAT_CHRG_DIR BIT(2)
31 #define PS_STAT_VBUS_ABOVE_VHOLD BIT(3)
32 #define PS_STAT_VBUS_VALID BIT(4)
33 #define PS_STAT_VBUS_PRESENT BIT(5)
34
35
36 #define BC_GLOBAL_RUN BIT(0)
37 #define BC_GLOBAL_DET_STAT BIT(2)
38 #define BC_GLOBAL_DBP_TOUT BIT(3)
39 #define BC_GLOBAL_VLGC_COM_SEL BIT(4)
40 #define BC_GLOBAL_DCD_TOUT_MASK (BIT(6)|BIT(5))
41 #define BC_GLOBAL_DCD_TOUT_300MS 0
42 #define BC_GLOBAL_DCD_TOUT_100MS 1
43 #define BC_GLOBAL_DCD_TOUT_500MS 2
44 #define BC_GLOBAL_DCD_TOUT_900MS 3
45 #define BC_GLOBAL_DCD_DET_SEL BIT(7)
46
47
48 #define VBUS_CNTL_DPDM_PD_EN BIT(4)
49 #define VBUS_CNTL_DPDM_FD_EN BIT(5)
50 #define VBUS_CNTL_FIRST_PO_STAT BIT(6)
51
52
53 #define USB_STAT_BUS_STAT_MASK (BIT(3)|BIT(2)|BIT(1)|BIT(0))
54 #define USB_STAT_BUS_STAT_SHIFT 0
55 #define USB_STAT_BUS_STAT_ATHD 0
56 #define USB_STAT_BUS_STAT_CONN 1
57 #define USB_STAT_BUS_STAT_SUSP 2
58 #define USB_STAT_BUS_STAT_CONF 3
59 #define USB_STAT_USB_SS_MODE BIT(4)
60 #define USB_STAT_DEAD_BAT_DET BIT(6)
61 #define USB_STAT_DBP_UNCFG BIT(7)
62
63
64 #define DET_STAT_MASK (BIT(7)|BIT(6)|BIT(5))
65 #define DET_STAT_SHIFT 5
66 #define DET_STAT_SDP 1
67 #define DET_STAT_CDP 2
68 #define DET_STAT_DCP 3
69
70 enum axp288_extcon_reg {
71 AXP288_PS_STAT_REG = 0x00,
72 AXP288_PS_BOOT_REASON_REG = 0x02,
73 AXP288_BC_GLOBAL_REG = 0x2c,
74 AXP288_BC_VBUS_CNTL_REG = 0x2d,
75 AXP288_BC_USB_STAT_REG = 0x2e,
76 AXP288_BC_DET_STAT_REG = 0x2f,
77 };
78
79 enum axp288_extcon_irq {
80 VBUS_FALLING_IRQ = 0,
81 VBUS_RISING_IRQ,
82 MV_CHNG_IRQ,
83 BC_USB_CHNG_IRQ,
84 EXTCON_IRQ_END,
85 };
86
87 static const unsigned int axp288_extcon_cables[] = {
88 EXTCON_CHG_USB_SDP,
89 EXTCON_CHG_USB_CDP,
90 EXTCON_CHG_USB_DCP,
91 EXTCON_USB,
92 EXTCON_NONE,
93 };
94
95 struct axp288_extcon_info {
96 struct device *dev;
97 struct regmap *regmap;
98 struct regmap_irq_chip_data *regmap_irqc;
99 struct usb_role_switch *role_sw;
100 struct work_struct role_work;
101 int irq[EXTCON_IRQ_END];
102 struct extcon_dev *edev;
103 struct extcon_dev *id_extcon;
104 struct notifier_block id_nb;
105 unsigned int previous_cable;
106 bool vbus_attach;
107 };
108
109 static const struct x86_cpu_id cherry_trail_cpu_ids[] = {
110 { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_AIRMONT, X86_FEATURE_ANY },
111 {}
112 };
113
114
115 static const char * const axp288_pwr_up_down_info[] = {
116 "Last wake caused by user pressing the power button",
117 "Last wake caused by a charger insertion",
118 "Last wake caused by a battery insertion",
119 "Last wake caused by SOC initiated global reset",
120 "Last wake caused by cold reset",
121 "Last shutdown caused by PMIC UVLO threshold",
122 "Last shutdown caused by SOC initiated cold off",
123 "Last shutdown caused by user pressing the power button",
124 };
125
126
127
128
129
130 static void axp288_extcon_log_rsi(struct axp288_extcon_info *info)
131 {
132 unsigned int val, i, clear_mask = 0;
133 unsigned long bits;
134 int ret;
135
136 ret = regmap_read(info->regmap, AXP288_PS_BOOT_REASON_REG, &val);
137 if (ret < 0) {
138 dev_err(info->dev, "failed to read reset source indicator\n");
139 return;
140 }
141
142 bits = val & GENMASK(ARRAY_SIZE(axp288_pwr_up_down_info) - 1, 0);
143 for_each_set_bit(i, &bits, ARRAY_SIZE(axp288_pwr_up_down_info))
144 dev_dbg(info->dev, "%s\n", axp288_pwr_up_down_info[i]);
145 clear_mask = bits;
146
147
148 regmap_write(info->regmap, AXP288_PS_BOOT_REASON_REG, clear_mask);
149 }
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165 static bool axp288_get_id_pin(struct axp288_extcon_info *info)
166 {
167 enum usb_role role;
168
169 if (info->id_extcon)
170 return extcon_get_state(info->id_extcon, EXTCON_USB_HOST) <= 0;
171
172
173 role = usb_role_switch_get_role(info->role_sw);
174 return role != USB_ROLE_HOST;
175 }
176
177 static void axp288_usb_role_work(struct work_struct *work)
178 {
179 struct axp288_extcon_info *info =
180 container_of(work, struct axp288_extcon_info, role_work);
181 enum usb_role role;
182 bool id_pin;
183 int ret;
184
185 id_pin = axp288_get_id_pin(info);
186 if (!id_pin)
187 role = USB_ROLE_HOST;
188 else if (info->vbus_attach)
189 role = USB_ROLE_DEVICE;
190 else
191 role = USB_ROLE_NONE;
192
193 ret = usb_role_switch_set_role(info->role_sw, role);
194 if (ret)
195 dev_err(info->dev, "failed to set role: %d\n", ret);
196 }
197
198 static bool axp288_get_vbus_attach(struct axp288_extcon_info *info)
199 {
200 int ret, pwr_stat;
201
202 ret = regmap_read(info->regmap, AXP288_PS_STAT_REG, &pwr_stat);
203 if (ret < 0) {
204 dev_err(info->dev, "failed to read vbus status\n");
205 return false;
206 }
207
208 return !!(pwr_stat & PS_STAT_VBUS_VALID);
209 }
210
211 static int axp288_handle_chrg_det_event(struct axp288_extcon_info *info)
212 {
213 int ret, stat, cfg;
214 u8 chrg_type;
215 unsigned int cable = info->previous_cable;
216 bool vbus_attach = false;
217
218 vbus_attach = axp288_get_vbus_attach(info);
219 if (!vbus_attach)
220 goto no_vbus;
221
222
223 ret = regmap_read(info->regmap, AXP288_BC_GLOBAL_REG, &cfg);
224 if (ret < 0)
225 goto dev_det_ret;
226 if (cfg & BC_GLOBAL_DET_STAT) {
227 dev_dbg(info->dev, "can't complete the charger detection\n");
228 goto dev_det_ret;
229 }
230
231 ret = regmap_read(info->regmap, AXP288_BC_DET_STAT_REG, &stat);
232 if (ret < 0)
233 goto dev_det_ret;
234
235 chrg_type = (stat & DET_STAT_MASK) >> DET_STAT_SHIFT;
236
237 switch (chrg_type) {
238 case DET_STAT_SDP:
239 dev_dbg(info->dev, "sdp cable is connected\n");
240 cable = EXTCON_CHG_USB_SDP;
241 break;
242 case DET_STAT_CDP:
243 dev_dbg(info->dev, "cdp cable is connected\n");
244 cable = EXTCON_CHG_USB_CDP;
245 break;
246 case DET_STAT_DCP:
247 dev_dbg(info->dev, "dcp cable is connected\n");
248 cable = EXTCON_CHG_USB_DCP;
249 break;
250 default:
251 dev_warn(info->dev, "unknown (reserved) bc detect result\n");
252 cable = EXTCON_CHG_USB_SDP;
253 }
254
255 no_vbus:
256 extcon_set_state_sync(info->edev, info->previous_cable, false);
257 if (info->previous_cable == EXTCON_CHG_USB_SDP)
258 extcon_set_state_sync(info->edev, EXTCON_USB, false);
259
260 if (vbus_attach) {
261 extcon_set_state_sync(info->edev, cable, vbus_attach);
262 if (cable == EXTCON_CHG_USB_SDP)
263 extcon_set_state_sync(info->edev, EXTCON_USB,
264 vbus_attach);
265
266 info->previous_cable = cable;
267 }
268
269 if (info->role_sw && info->vbus_attach != vbus_attach) {
270 info->vbus_attach = vbus_attach;
271
272 queue_work(system_long_wq, &info->role_work);
273 }
274
275 return 0;
276
277 dev_det_ret:
278 if (ret < 0)
279 dev_err(info->dev, "failed to detect BC Mod\n");
280
281 return ret;
282 }
283
284 static int axp288_extcon_id_evt(struct notifier_block *nb,
285 unsigned long event, void *param)
286 {
287 struct axp288_extcon_info *info =
288 container_of(nb, struct axp288_extcon_info, id_nb);
289
290
291 queue_work(system_long_wq, &info->role_work);
292
293 return NOTIFY_OK;
294 }
295
296 static irqreturn_t axp288_extcon_isr(int irq, void *data)
297 {
298 struct axp288_extcon_info *info = data;
299 int ret;
300
301 ret = axp288_handle_chrg_det_event(info);
302 if (ret < 0)
303 dev_err(info->dev, "failed to handle the interrupt\n");
304
305 return IRQ_HANDLED;
306 }
307
308 static void axp288_extcon_enable(struct axp288_extcon_info *info)
309 {
310 regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
311 BC_GLOBAL_RUN, 0);
312
313 regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
314 BC_GLOBAL_RUN, BC_GLOBAL_RUN);
315 }
316
317 static void axp288_put_role_sw(void *data)
318 {
319 struct axp288_extcon_info *info = data;
320
321 cancel_work_sync(&info->role_work);
322 usb_role_switch_put(info->role_sw);
323 }
324
325 static int axp288_extcon_probe(struct platform_device *pdev)
326 {
327 struct axp288_extcon_info *info;
328 struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
329 struct device *dev = &pdev->dev;
330 struct acpi_device *adev;
331 int ret, i, pirq;
332
333 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
334 if (!info)
335 return -ENOMEM;
336
337 info->dev = &pdev->dev;
338 info->regmap = axp20x->regmap;
339 info->regmap_irqc = axp20x->regmap_irqc;
340 info->previous_cable = EXTCON_NONE;
341 INIT_WORK(&info->role_work, axp288_usb_role_work);
342 info->id_nb.notifier_call = axp288_extcon_id_evt;
343
344 platform_set_drvdata(pdev, info);
345
346 info->role_sw = usb_role_switch_get(dev);
347 if (IS_ERR(info->role_sw))
348 return PTR_ERR(info->role_sw);
349 if (info->role_sw) {
350 ret = devm_add_action_or_reset(dev, axp288_put_role_sw, info);
351 if (ret)
352 return ret;
353
354 adev = acpi_dev_get_first_match_dev("INT3496", NULL, -1);
355 if (adev) {
356 info->id_extcon = extcon_get_extcon_dev(acpi_dev_name(adev));
357 put_device(&adev->dev);
358 if (!info->id_extcon)
359 return -EPROBE_DEFER;
360
361 dev_info(dev, "controlling USB role\n");
362 } else {
363 dev_info(dev, "controlling USB role based on Vbus presence\n");
364 }
365 }
366
367 info->vbus_attach = axp288_get_vbus_attach(info);
368
369 axp288_extcon_log_rsi(info);
370
371
372 info->edev = devm_extcon_dev_allocate(&pdev->dev,
373 axp288_extcon_cables);
374 if (IS_ERR(info->edev)) {
375 dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
376 return PTR_ERR(info->edev);
377 }
378
379
380 ret = devm_extcon_dev_register(&pdev->dev, info->edev);
381 if (ret) {
382 dev_err(&pdev->dev, "failed to register extcon device\n");
383 return ret;
384 }
385
386 for (i = 0; i < EXTCON_IRQ_END; i++) {
387 pirq = platform_get_irq(pdev, i);
388 if (pirq < 0)
389 return pirq;
390
391 info->irq[i] = regmap_irq_get_virq(info->regmap_irqc, pirq);
392 if (info->irq[i] < 0) {
393 dev_err(&pdev->dev,
394 "failed to get virtual interrupt=%d\n", pirq);
395 ret = info->irq[i];
396 return ret;
397 }
398
399 ret = devm_request_threaded_irq(&pdev->dev, info->irq[i],
400 NULL, axp288_extcon_isr,
401 IRQF_ONESHOT | IRQF_NO_SUSPEND,
402 pdev->name, info);
403 if (ret) {
404 dev_err(&pdev->dev, "failed to request interrupt=%d\n",
405 info->irq[i]);
406 return ret;
407 }
408 }
409
410 if (info->id_extcon) {
411 ret = devm_extcon_register_notifier_all(dev, info->id_extcon,
412 &info->id_nb);
413 if (ret)
414 return ret;
415 }
416
417
418 if (info->role_sw) {
419 queue_work(system_long_wq, &info->role_work);
420 flush_work(&info->role_work);
421 }
422
423
424 axp288_extcon_enable(info);
425
426 device_init_wakeup(dev, true);
427 platform_set_drvdata(pdev, info);
428
429 return 0;
430 }
431
432 static int __maybe_unused axp288_extcon_suspend(struct device *dev)
433 {
434 struct axp288_extcon_info *info = dev_get_drvdata(dev);
435
436 if (device_may_wakeup(dev))
437 enable_irq_wake(info->irq[VBUS_RISING_IRQ]);
438
439 return 0;
440 }
441
442 static int __maybe_unused axp288_extcon_resume(struct device *dev)
443 {
444 struct axp288_extcon_info *info = dev_get_drvdata(dev);
445
446
447
448
449
450
451 if (device_may_wakeup(dev))
452 disable_irq_wake(info->irq[VBUS_RISING_IRQ]);
453
454 return 0;
455 }
456
457 static SIMPLE_DEV_PM_OPS(axp288_extcon_pm_ops, axp288_extcon_suspend,
458 axp288_extcon_resume);
459
460 static const struct platform_device_id axp288_extcon_table[] = {
461 { .name = "axp288_extcon" },
462 {},
463 };
464 MODULE_DEVICE_TABLE(platform, axp288_extcon_table);
465
466 static struct platform_driver axp288_extcon_driver = {
467 .probe = axp288_extcon_probe,
468 .id_table = axp288_extcon_table,
469 .driver = {
470 .name = "axp288_extcon",
471 .pm = &axp288_extcon_pm_ops,
472 },
473 };
474
475 static struct device_connection axp288_extcon_role_sw_conn = {
476 .endpoint[0] = "axp288_extcon",
477 .endpoint[1] = "intel_xhci_usb_sw-role-switch",
478 .id = "usb-role-switch",
479 };
480
481 static int __init axp288_extcon_init(void)
482 {
483 if (x86_match_cpu(cherry_trail_cpu_ids))
484 device_connection_add(&axp288_extcon_role_sw_conn);
485
486 return platform_driver_register(&axp288_extcon_driver);
487 }
488 module_init(axp288_extcon_init);
489
490 static void __exit axp288_extcon_exit(void)
491 {
492 if (x86_match_cpu(cherry_trail_cpu_ids))
493 device_connection_remove(&axp288_extcon_role_sw_conn);
494
495 platform_driver_unregister(&axp288_extcon_driver);
496 }
497 module_exit(axp288_extcon_exit);
498
499 MODULE_AUTHOR("Ramakrishna Pallala <ramakrishna.pallala@intel.com>");
500 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
501 MODULE_DESCRIPTION("X-Powers AXP288 extcon driver");
502 MODULE_LICENSE("GPL v2");