Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * extcon-axp288.c - X-Power AXP288 PMIC extcon cable detection driver
4 *
5 * Copyright (c) 2017-2018 Hans de Goede <hdegoede@redhat.com>
6 * Copyright (C) 2015 Intel Corporation
7 * Author: Ramakrishna Pallala <ramakrishna.pallala@intel.com>
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#include <asm/iosf_mbi.h>
28
29/* Power source status register */
30#define PS_STAT_VBUS_TRIGGER BIT(0)
31#define PS_STAT_BAT_CHRG_DIR BIT(2)
32#define PS_STAT_VBUS_ABOVE_VHOLD BIT(3)
33#define PS_STAT_VBUS_VALID BIT(4)
34#define PS_STAT_VBUS_PRESENT BIT(5)
35
36/* BC module global register */
37#define BC_GLOBAL_RUN BIT(0)
38#define BC_GLOBAL_DET_STAT BIT(2)
39#define BC_GLOBAL_DBP_TOUT BIT(3)
40#define BC_GLOBAL_VLGC_COM_SEL BIT(4)
41#define BC_GLOBAL_DCD_TOUT_MASK (BIT(6)|BIT(5))
42#define BC_GLOBAL_DCD_TOUT_300MS 0
43#define BC_GLOBAL_DCD_TOUT_100MS 1
44#define BC_GLOBAL_DCD_TOUT_500MS 2
45#define BC_GLOBAL_DCD_TOUT_900MS 3
46#define BC_GLOBAL_DCD_DET_SEL BIT(7)
47
48/* BC module vbus control and status register */
49#define VBUS_CNTL_DPDM_PD_EN BIT(4)
50#define VBUS_CNTL_DPDM_FD_EN BIT(5)
51#define VBUS_CNTL_FIRST_PO_STAT BIT(6)
52
53/* BC USB status register */
54#define USB_STAT_BUS_STAT_MASK (BIT(3)|BIT(2)|BIT(1)|BIT(0))
55#define USB_STAT_BUS_STAT_SHIFT 0
56#define USB_STAT_BUS_STAT_ATHD 0
57#define USB_STAT_BUS_STAT_CONN 1
58#define USB_STAT_BUS_STAT_SUSP 2
59#define USB_STAT_BUS_STAT_CONF 3
60#define USB_STAT_USB_SS_MODE BIT(4)
61#define USB_STAT_DEAD_BAT_DET BIT(6)
62#define USB_STAT_DBP_UNCFG BIT(7)
63
64/* BC detect status register */
65#define DET_STAT_MASK (BIT(7)|BIT(6)|BIT(5))
66#define DET_STAT_SHIFT 5
67#define DET_STAT_SDP 1
68#define DET_STAT_CDP 2
69#define DET_STAT_DCP 3
70
71enum axp288_extcon_reg {
72 AXP288_PS_STAT_REG = 0x00,
73 AXP288_PS_BOOT_REASON_REG = 0x02,
74 AXP288_BC_GLOBAL_REG = 0x2c,
75 AXP288_BC_VBUS_CNTL_REG = 0x2d,
76 AXP288_BC_USB_STAT_REG = 0x2e,
77 AXP288_BC_DET_STAT_REG = 0x2f,
78};
79
80enum axp288_extcon_irq {
81 VBUS_FALLING_IRQ = 0,
82 VBUS_RISING_IRQ,
83 MV_CHNG_IRQ,
84 BC_USB_CHNG_IRQ,
85 EXTCON_IRQ_END,
86};
87
88static const unsigned int axp288_extcon_cables[] = {
89 EXTCON_CHG_USB_SDP,
90 EXTCON_CHG_USB_CDP,
91 EXTCON_CHG_USB_DCP,
92 EXTCON_USB,
93 EXTCON_NONE,
94};
95
96struct axp288_extcon_info {
97 struct device *dev;
98 struct regmap *regmap;
99 struct regmap_irq_chip_data *regmap_irqc;
100 struct usb_role_switch *role_sw;
101 struct work_struct role_work;
102 int irq[EXTCON_IRQ_END];
103 struct extcon_dev *edev;
104 struct extcon_dev *id_extcon;
105 struct notifier_block id_nb;
106 unsigned int previous_cable;
107 bool vbus_attach;
108};
109
110static const struct x86_cpu_id cherry_trail_cpu_ids[] = {
111 X86_MATCH_INTEL_FAM6_MODEL(ATOM_AIRMONT, NULL),
112 {}
113};
114
115/* Power up/down reason string array */
116static const char * const axp288_pwr_up_down_info[] = {
117 "Last wake caused by user pressing the power button",
118 "Last wake caused by a charger insertion",
119 "Last wake caused by a battery insertion",
120 "Last wake caused by SOC initiated global reset",
121 "Last wake caused by cold reset",
122 "Last shutdown caused by PMIC UVLO threshold",
123 "Last shutdown caused by SOC initiated cold off",
124 "Last shutdown caused by user pressing the power button",
125};
126
127/*
128 * Decode and log the given "reset source indicator" (rsi)
129 * register and then clear it.
130 */
131static void axp288_extcon_log_rsi(struct axp288_extcon_info *info)
132{
133 unsigned int val, i, clear_mask = 0;
134 unsigned long bits;
135 int ret;
136
137 ret = regmap_read(info->regmap, AXP288_PS_BOOT_REASON_REG, &val);
138 if (ret < 0) {
139 dev_err(info->dev, "failed to read reset source indicator\n");
140 return;
141 }
142
143 bits = val & GENMASK(ARRAY_SIZE(axp288_pwr_up_down_info) - 1, 0);
144 for_each_set_bit(i, &bits, ARRAY_SIZE(axp288_pwr_up_down_info))
145 dev_dbg(info->dev, "%s\n", axp288_pwr_up_down_info[i]);
146 clear_mask = bits;
147
148 /* Clear the register value for next reboot (write 1 to clear bit) */
149 regmap_write(info->regmap, AXP288_PS_BOOT_REASON_REG, clear_mask);
150}
151
152/*
153 * The below code to control the USB role-switch on devices with an AXP288
154 * may seem out of place, but there are 2 reasons why this is the best place
155 * to control the USB role-switch on such devices:
156 * 1) On many devices the USB role is controlled by AML code, but the AML code
157 * only switches between the host and none roles, because of Windows not
158 * really using device mode. To make device mode work we need to toggle
159 * between the none/device roles based on Vbus presence, and this driver
160 * gets interrupts on Vbus insertion / removal.
161 * 2) In order for our BC1.2 charger detection to work properly the role
162 * mux must be properly set to device mode before we do the detection.
163 */
164
165/* Returns the id-pin value, note pulled low / false == host-mode */
166static bool axp288_get_id_pin(struct axp288_extcon_info *info)
167{
168 enum usb_role role;
169
170 if (info->id_extcon)
171 return extcon_get_state(info->id_extcon, EXTCON_USB_HOST) <= 0;
172
173 /* We cannot access the id-pin, see what mode the AML code has set */
174 role = usb_role_switch_get_role(info->role_sw);
175 return role != USB_ROLE_HOST;
176}
177
178static void axp288_usb_role_work(struct work_struct *work)
179{
180 struct axp288_extcon_info *info =
181 container_of(work, struct axp288_extcon_info, role_work);
182 enum usb_role role;
183 bool id_pin;
184 int ret;
185
186 id_pin = axp288_get_id_pin(info);
187 if (!id_pin)
188 role = USB_ROLE_HOST;
189 else if (info->vbus_attach)
190 role = USB_ROLE_DEVICE;
191 else
192 role = USB_ROLE_NONE;
193
194 ret = usb_role_switch_set_role(info->role_sw, role);
195 if (ret)
196 dev_err(info->dev, "failed to set role: %d\n", ret);
197}
198
199static bool axp288_get_vbus_attach(struct axp288_extcon_info *info)
200{
201 int ret, pwr_stat;
202
203 ret = regmap_read(info->regmap, AXP288_PS_STAT_REG, &pwr_stat);
204 if (ret < 0) {
205 dev_err(info->dev, "failed to read vbus status\n");
206 return false;
207 }
208
209 return !!(pwr_stat & PS_STAT_VBUS_VALID);
210}
211
212static int axp288_handle_chrg_det_event(struct axp288_extcon_info *info)
213{
214 int ret, stat, cfg;
215 u8 chrg_type;
216 unsigned int cable = info->previous_cable;
217 bool vbus_attach = false;
218
219 ret = iosf_mbi_block_punit_i2c_access();
220 if (ret < 0)
221 return ret;
222
223 vbus_attach = axp288_get_vbus_attach(info);
224 if (!vbus_attach)
225 goto no_vbus;
226
227 /* Check charger detection completion status */
228 ret = regmap_read(info->regmap, AXP288_BC_GLOBAL_REG, &cfg);
229 if (ret < 0)
230 goto dev_det_ret;
231 if (cfg & BC_GLOBAL_DET_STAT) {
232 dev_dbg(info->dev, "can't complete the charger detection\n");
233 goto dev_det_ret;
234 }
235
236 ret = regmap_read(info->regmap, AXP288_BC_DET_STAT_REG, &stat);
237 if (ret < 0)
238 goto dev_det_ret;
239
240 chrg_type = (stat & DET_STAT_MASK) >> DET_STAT_SHIFT;
241
242 switch (chrg_type) {
243 case DET_STAT_SDP:
244 dev_dbg(info->dev, "sdp cable is connected\n");
245 cable = EXTCON_CHG_USB_SDP;
246 break;
247 case DET_STAT_CDP:
248 dev_dbg(info->dev, "cdp cable is connected\n");
249 cable = EXTCON_CHG_USB_CDP;
250 break;
251 case DET_STAT_DCP:
252 dev_dbg(info->dev, "dcp cable is connected\n");
253 cable = EXTCON_CHG_USB_DCP;
254 break;
255 default:
256 dev_warn(info->dev, "unknown (reserved) bc detect result\n");
257 cable = EXTCON_CHG_USB_SDP;
258 }
259
260no_vbus:
261 iosf_mbi_unblock_punit_i2c_access();
262
263 extcon_set_state_sync(info->edev, info->previous_cable, false);
264 if (info->previous_cable == EXTCON_CHG_USB_SDP)
265 extcon_set_state_sync(info->edev, EXTCON_USB, false);
266
267 if (vbus_attach) {
268 extcon_set_state_sync(info->edev, cable, vbus_attach);
269 if (cable == EXTCON_CHG_USB_SDP)
270 extcon_set_state_sync(info->edev, EXTCON_USB,
271 vbus_attach);
272
273 info->previous_cable = cable;
274 }
275
276 if (info->role_sw && info->vbus_attach != vbus_attach) {
277 info->vbus_attach = vbus_attach;
278 /* Setting the role can take a while */
279 queue_work(system_long_wq, &info->role_work);
280 }
281
282 return 0;
283
284dev_det_ret:
285 iosf_mbi_unblock_punit_i2c_access();
286
287 if (ret < 0)
288 dev_err(info->dev, "failed to detect BC Mod\n");
289
290 return ret;
291}
292
293static int axp288_extcon_id_evt(struct notifier_block *nb,
294 unsigned long event, void *param)
295{
296 struct axp288_extcon_info *info =
297 container_of(nb, struct axp288_extcon_info, id_nb);
298
299 /* We may not sleep and setting the role can take a while */
300 queue_work(system_long_wq, &info->role_work);
301
302 return NOTIFY_OK;
303}
304
305static irqreturn_t axp288_extcon_isr(int irq, void *data)
306{
307 struct axp288_extcon_info *info = data;
308 int ret;
309
310 ret = axp288_handle_chrg_det_event(info);
311 if (ret < 0)
312 dev_err(info->dev, "failed to handle the interrupt\n");
313
314 return IRQ_HANDLED;
315}
316
317static int axp288_extcon_enable(struct axp288_extcon_info *info)
318{
319 int ret = 0;
320
321 ret = iosf_mbi_block_punit_i2c_access();
322 if (ret < 0)
323 return ret;
324
325 regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
326 BC_GLOBAL_RUN, 0);
327 /* Enable the charger detection logic */
328 regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
329 BC_GLOBAL_RUN, BC_GLOBAL_RUN);
330
331 iosf_mbi_unblock_punit_i2c_access();
332
333 return ret;
334}
335
336static void axp288_put_role_sw(void *data)
337{
338 struct axp288_extcon_info *info = data;
339
340 cancel_work_sync(&info->role_work);
341 usb_role_switch_put(info->role_sw);
342}
343
344static int axp288_extcon_find_role_sw(struct axp288_extcon_info *info)
345{
346 const struct software_node *swnode;
347 struct fwnode_handle *fwnode;
348
349 if (!x86_match_cpu(cherry_trail_cpu_ids))
350 return 0;
351
352 swnode = software_node_find_by_name(NULL, "intel-xhci-usb-sw");
353 if (!swnode)
354 return -EPROBE_DEFER;
355
356 fwnode = software_node_fwnode(swnode);
357 info->role_sw = usb_role_switch_find_by_fwnode(fwnode);
358 fwnode_handle_put(fwnode);
359
360 return info->role_sw ? 0 : -EPROBE_DEFER;
361}
362
363static int axp288_extcon_probe(struct platform_device *pdev)
364{
365 struct axp288_extcon_info *info;
366 struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
367 struct device *dev = &pdev->dev;
368 struct acpi_device *adev;
369 int ret, i, pirq;
370
371 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
372 if (!info)
373 return -ENOMEM;
374
375 info->dev = &pdev->dev;
376 info->regmap = axp20x->regmap;
377 info->regmap_irqc = axp20x->regmap_irqc;
378 info->previous_cable = EXTCON_NONE;
379 INIT_WORK(&info->role_work, axp288_usb_role_work);
380 info->id_nb.notifier_call = axp288_extcon_id_evt;
381
382 platform_set_drvdata(pdev, info);
383
384 ret = axp288_extcon_find_role_sw(info);
385 if (ret)
386 return ret;
387
388 if (info->role_sw) {
389 ret = devm_add_action_or_reset(dev, axp288_put_role_sw, info);
390 if (ret)
391 return ret;
392
393 adev = acpi_dev_get_first_match_dev("INT3496", NULL, -1);
394 if (adev) {
395 info->id_extcon = extcon_get_extcon_dev(acpi_dev_name(adev));
396 acpi_dev_put(adev);
397 if (IS_ERR(info->id_extcon))
398 return PTR_ERR(info->id_extcon);
399
400 dev_info(dev, "controlling USB role\n");
401 } else {
402 dev_info(dev, "controlling USB role based on Vbus presence\n");
403 }
404 }
405
406 ret = iosf_mbi_block_punit_i2c_access();
407 if (ret < 0)
408 return ret;
409
410 info->vbus_attach = axp288_get_vbus_attach(info);
411
412 axp288_extcon_log_rsi(info);
413
414 iosf_mbi_unblock_punit_i2c_access();
415
416 /* Initialize extcon device */
417 info->edev = devm_extcon_dev_allocate(&pdev->dev,
418 axp288_extcon_cables);
419 if (IS_ERR(info->edev)) {
420 dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
421 return PTR_ERR(info->edev);
422 }
423
424 /* Register extcon device */
425 ret = devm_extcon_dev_register(&pdev->dev, info->edev);
426 if (ret) {
427 dev_err(&pdev->dev, "failed to register extcon device\n");
428 return ret;
429 }
430
431 for (i = 0; i < EXTCON_IRQ_END; i++) {
432 pirq = platform_get_irq(pdev, i);
433 if (pirq < 0)
434 return pirq;
435
436 info->irq[i] = regmap_irq_get_virq(info->regmap_irqc, pirq);
437 if (info->irq[i] < 0) {
438 dev_err(&pdev->dev,
439 "failed to get virtual interrupt=%d\n", pirq);
440 ret = info->irq[i];
441 return ret;
442 }
443
444 ret = devm_request_threaded_irq(&pdev->dev, info->irq[i],
445 NULL, axp288_extcon_isr,
446 IRQF_ONESHOT | IRQF_NO_SUSPEND,
447 pdev->name, info);
448 if (ret) {
449 dev_err(&pdev->dev, "failed to request interrupt=%d\n",
450 info->irq[i]);
451 return ret;
452 }
453 }
454
455 if (info->id_extcon) {
456 ret = devm_extcon_register_notifier_all(dev, info->id_extcon,
457 &info->id_nb);
458 if (ret)
459 return ret;
460 }
461
462 /* Make sure the role-sw is set correctly before doing BC detection */
463 if (info->role_sw) {
464 queue_work(system_long_wq, &info->role_work);
465 flush_work(&info->role_work);
466 }
467
468 /* Start charger cable type detection */
469 ret = axp288_extcon_enable(info);
470 if (ret < 0)
471 return ret;
472
473 device_init_wakeup(dev, true);
474 platform_set_drvdata(pdev, info);
475
476 return 0;
477}
478
479static int __maybe_unused axp288_extcon_suspend(struct device *dev)
480{
481 struct axp288_extcon_info *info = dev_get_drvdata(dev);
482
483 if (device_may_wakeup(dev))
484 enable_irq_wake(info->irq[VBUS_RISING_IRQ]);
485
486 return 0;
487}
488
489static int __maybe_unused axp288_extcon_resume(struct device *dev)
490{
491 struct axp288_extcon_info *info = dev_get_drvdata(dev);
492
493 /*
494 * Wakeup when a charger is connected to do charger-type
495 * connection and generate an extcon event which makes the
496 * axp288 charger driver set the input current limit.
497 */
498 if (device_may_wakeup(dev))
499 disable_irq_wake(info->irq[VBUS_RISING_IRQ]);
500
501 return 0;
502}
503
504static SIMPLE_DEV_PM_OPS(axp288_extcon_pm_ops, axp288_extcon_suspend,
505 axp288_extcon_resume);
506
507static const struct platform_device_id axp288_extcon_table[] = {
508 { .name = "axp288_extcon" },
509 {},
510};
511MODULE_DEVICE_TABLE(platform, axp288_extcon_table);
512
513static struct platform_driver axp288_extcon_driver = {
514 .probe = axp288_extcon_probe,
515 .id_table = axp288_extcon_table,
516 .driver = {
517 .name = "axp288_extcon",
518 .pm = &axp288_extcon_pm_ops,
519 },
520};
521module_platform_driver(axp288_extcon_driver);
522
523MODULE_AUTHOR("Ramakrishna Pallala <ramakrishna.pallala@intel.com>");
524MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
525MODULE_DESCRIPTION("X-Powers AXP288 extcon driver");
526MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * extcon-axp288.c - X-Power AXP288 PMIC extcon cable detection driver
4 *
5 * Copyright (c) 2017-2018 Hans de Goede <hdegoede@redhat.com>
6 * Copyright (C) 2015 Intel Corporation
7 * Author: Ramakrishna Pallala <ramakrishna.pallala@intel.com>
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/* Power source status register */
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/* BC module global register */
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/* BC module vbus control and status register */
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/* BC USB status register */
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/* BC detect status register */
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
70enum 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
79enum 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
87static 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
95struct 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
109static 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/* Power up/down reason string array */
115static 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 * Decode and log the given "reset source indicator" (rsi)
128 * register and then clear it.
129 */
130static 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 /* Clear the register value for next reboot (write 1 to clear bit) */
148 regmap_write(info->regmap, AXP288_PS_BOOT_REASON_REG, clear_mask);
149}
150
151/*
152 * The below code to control the USB role-switch on devices with an AXP288
153 * may seem out of place, but there are 2 reasons why this is the best place
154 * to control the USB role-switch on such devices:
155 * 1) On many devices the USB role is controlled by AML code, but the AML code
156 * only switches between the host and none roles, because of Windows not
157 * really using device mode. To make device mode work we need to toggle
158 * between the none/device roles based on Vbus presence, and this driver
159 * gets interrupts on Vbus insertion / removal.
160 * 2) In order for our BC1.2 charger detection to work properly the role
161 * mux must be properly set to device mode before we do the detection.
162 */
163
164/* Returns the id-pin value, note pulled low / false == host-mode */
165static 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 /* We cannot access the id-pin, see what mode the AML code has set */
173 role = usb_role_switch_get_role(info->role_sw);
174 return role != USB_ROLE_HOST;
175}
176
177static 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
198static 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
211static 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 /* Check charger detection completion status */
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
255no_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 /* Setting the role can take a while */
272 queue_work(system_long_wq, &info->role_work);
273 }
274
275 return 0;
276
277dev_det_ret:
278 if (ret < 0)
279 dev_err(info->dev, "failed to detect BC Mod\n");
280
281 return ret;
282}
283
284static 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 /* We may not sleep and setting the role can take a while */
291 queue_work(system_long_wq, &info->role_work);
292
293 return NOTIFY_OK;
294}
295
296static 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
308static 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 /* Enable the charger detection logic */
313 regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
314 BC_GLOBAL_RUN, BC_GLOBAL_RUN);
315}
316
317static 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
325static 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 /* Initialize extcon device */
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 /* Register extcon device */
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 /* Make sure the role-sw is set correctly before doing BC detection */
418 if (info->role_sw) {
419 queue_work(system_long_wq, &info->role_work);
420 flush_work(&info->role_work);
421 }
422
423 /* Start charger cable type detection */
424 axp288_extcon_enable(info);
425
426 return 0;
427}
428
429static const struct platform_device_id axp288_extcon_table[] = {
430 { .name = "axp288_extcon" },
431 {},
432};
433MODULE_DEVICE_TABLE(platform, axp288_extcon_table);
434
435static struct platform_driver axp288_extcon_driver = {
436 .probe = axp288_extcon_probe,
437 .id_table = axp288_extcon_table,
438 .driver = {
439 .name = "axp288_extcon",
440 },
441};
442
443static struct device_connection axp288_extcon_role_sw_conn = {
444 .endpoint[0] = "axp288_extcon",
445 .endpoint[1] = "intel_xhci_usb_sw-role-switch",
446 .id = "usb-role-switch",
447};
448
449static int __init axp288_extcon_init(void)
450{
451 if (x86_match_cpu(cherry_trail_cpu_ids))
452 device_connection_add(&axp288_extcon_role_sw_conn);
453
454 return platform_driver_register(&axp288_extcon_driver);
455}
456module_init(axp288_extcon_init);
457
458static void __exit axp288_extcon_exit(void)
459{
460 if (x86_match_cpu(cherry_trail_cpu_ids))
461 device_connection_remove(&axp288_extcon_role_sw_conn);
462
463 platform_driver_unregister(&axp288_extcon_driver);
464}
465module_exit(axp288_extcon_exit);
466
467MODULE_AUTHOR("Ramakrishna Pallala <ramakrishna.pallala@intel.com>");
468MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
469MODULE_DESCRIPTION("X-Powers AXP288 extcon driver");
470MODULE_LICENSE("GPL v2");