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 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 /* Power up/down reason string array */ 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 NULL, 125 }; 126 127 /* 128 * Decode and log the given "reset source indicator" (rsi) 129 * register and then clear it. 130 */ 131 static void axp288_extcon_log_rsi(struct axp288_extcon_info *info) 132 { 133 const char * const *rsi; 134 unsigned int val, i, clear_mask = 0; 135 int ret; 136 137 ret = regmap_read(info->regmap, AXP288_PS_BOOT_REASON_REG, &val); 138 for (i = 0, rsi = axp288_pwr_up_down_info; *rsi; rsi++, i++) { 139 if (val & BIT(i)) { 140 dev_dbg(info->dev, "%s\n", *rsi); 141 clear_mask |= BIT(i); 142 } 143 } 144 145 /* Clear the register value for next reboot (write 1 to clear bit) */ 146 regmap_write(info->regmap, AXP288_PS_BOOT_REASON_REG, clear_mask); 147 } 148 149 /* 150 * The below code to control the USB role-switch on devices with an AXP288 151 * may seem out of place, but there are 2 reasons why this is the best place 152 * to control the USB role-switch on such devices: 153 * 1) On many devices the USB role is controlled by AML code, but the AML code 154 * only switches between the host and none roles, because of Windows not 155 * really using device mode. To make device mode work we need to toggle 156 * between the none/device roles based on Vbus presence, and this driver 157 * gets interrupts on Vbus insertion / removal. 158 * 2) In order for our BC1.2 charger detection to work properly the role 159 * mux must be properly set to device mode before we do the detection. 160 */ 161 162 /* Returns the id-pin value, note pulled low / false == host-mode */ 163 static bool axp288_get_id_pin(struct axp288_extcon_info *info) 164 { 165 enum usb_role role; 166 167 if (info->id_extcon) 168 return extcon_get_state(info->id_extcon, EXTCON_USB_HOST) <= 0; 169 170 /* We cannot access the id-pin, see what mode the AML code has set */ 171 role = usb_role_switch_get_role(info->role_sw); 172 return role != USB_ROLE_HOST; 173 } 174 175 static void axp288_usb_role_work(struct work_struct *work) 176 { 177 struct axp288_extcon_info *info = 178 container_of(work, struct axp288_extcon_info, role_work); 179 enum usb_role role; 180 bool id_pin; 181 int ret; 182 183 id_pin = axp288_get_id_pin(info); 184 if (!id_pin) 185 role = USB_ROLE_HOST; 186 else if (info->vbus_attach) 187 role = USB_ROLE_DEVICE; 188 else 189 role = USB_ROLE_NONE; 190 191 ret = usb_role_switch_set_role(info->role_sw, role); 192 if (ret) 193 dev_err(info->dev, "failed to set role: %d\n", ret); 194 } 195 196 static bool axp288_get_vbus_attach(struct axp288_extcon_info *info) 197 { 198 int ret, pwr_stat; 199 200 ret = regmap_read(info->regmap, AXP288_PS_STAT_REG, &pwr_stat); 201 if (ret < 0) { 202 dev_err(info->dev, "failed to read vbus status\n"); 203 return false; 204 } 205 206 return !!(pwr_stat & PS_STAT_VBUS_VALID); 207 } 208 209 static int axp288_handle_chrg_det_event(struct axp288_extcon_info *info) 210 { 211 int ret, stat, cfg; 212 u8 chrg_type; 213 unsigned int cable = info->previous_cable; 214 bool vbus_attach = false; 215 216 vbus_attach = axp288_get_vbus_attach(info); 217 if (!vbus_attach) 218 goto no_vbus; 219 220 /* Check charger detection completion status */ 221 ret = regmap_read(info->regmap, AXP288_BC_GLOBAL_REG, &cfg); 222 if (ret < 0) 223 goto dev_det_ret; 224 if (cfg & BC_GLOBAL_DET_STAT) { 225 dev_dbg(info->dev, "can't complete the charger detection\n"); 226 goto dev_det_ret; 227 } 228 229 ret = regmap_read(info->regmap, AXP288_BC_DET_STAT_REG, &stat); 230 if (ret < 0) 231 goto dev_det_ret; 232 233 chrg_type = (stat & DET_STAT_MASK) >> DET_STAT_SHIFT; 234 235 switch (chrg_type) { 236 case DET_STAT_SDP: 237 dev_dbg(info->dev, "sdp cable is connected\n"); 238 cable = EXTCON_CHG_USB_SDP; 239 break; 240 case DET_STAT_CDP: 241 dev_dbg(info->dev, "cdp cable is connected\n"); 242 cable = EXTCON_CHG_USB_CDP; 243 break; 244 case DET_STAT_DCP: 245 dev_dbg(info->dev, "dcp cable is connected\n"); 246 cable = EXTCON_CHG_USB_DCP; 247 break; 248 default: 249 dev_warn(info->dev, "unknown (reserved) bc detect result\n"); 250 cable = EXTCON_CHG_USB_SDP; 251 } 252 253 no_vbus: 254 extcon_set_state_sync(info->edev, info->previous_cable, false); 255 if (info->previous_cable == EXTCON_CHG_USB_SDP) 256 extcon_set_state_sync(info->edev, EXTCON_USB, false); 257 258 if (vbus_attach) { 259 extcon_set_state_sync(info->edev, cable, vbus_attach); 260 if (cable == EXTCON_CHG_USB_SDP) 261 extcon_set_state_sync(info->edev, EXTCON_USB, 262 vbus_attach); 263 264 info->previous_cable = cable; 265 } 266 267 if (info->role_sw && info->vbus_attach != vbus_attach) { 268 info->vbus_attach = vbus_attach; 269 /* Setting the role can take a while */ 270 queue_work(system_long_wq, &info->role_work); 271 } 272 273 return 0; 274 275 dev_det_ret: 276 if (ret < 0) 277 dev_err(info->dev, "failed to detect BC Mod\n"); 278 279 return ret; 280 } 281 282 static int axp288_extcon_id_evt(struct notifier_block *nb, 283 unsigned long event, void *param) 284 { 285 struct axp288_extcon_info *info = 286 container_of(nb, struct axp288_extcon_info, id_nb); 287 288 /* We may not sleep and setting the role can take a while */ 289 queue_work(system_long_wq, &info->role_work); 290 291 return NOTIFY_OK; 292 } 293 294 static irqreturn_t axp288_extcon_isr(int irq, void *data) 295 { 296 struct axp288_extcon_info *info = data; 297 int ret; 298 299 ret = axp288_handle_chrg_det_event(info); 300 if (ret < 0) 301 dev_err(info->dev, "failed to handle the interrupt\n"); 302 303 return IRQ_HANDLED; 304 } 305 306 static void axp288_extcon_enable(struct axp288_extcon_info *info) 307 { 308 regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG, 309 BC_GLOBAL_RUN, 0); 310 /* Enable the charger detection logic */ 311 regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG, 312 BC_GLOBAL_RUN, BC_GLOBAL_RUN); 313 } 314 315 static void axp288_put_role_sw(void *data) 316 { 317 struct axp288_extcon_info *info = data; 318 319 cancel_work_sync(&info->role_work); 320 usb_role_switch_put(info->role_sw); 321 } 322 323 static int axp288_extcon_probe(struct platform_device *pdev) 324 { 325 struct axp288_extcon_info *info; 326 struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent); 327 struct device *dev = &pdev->dev; 328 struct acpi_device *adev; 329 int ret, i, pirq; 330 331 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL); 332 if (!info) 333 return -ENOMEM; 334 335 info->dev = &pdev->dev; 336 info->regmap = axp20x->regmap; 337 info->regmap_irqc = axp20x->regmap_irqc; 338 info->previous_cable = EXTCON_NONE; 339 INIT_WORK(&info->role_work, axp288_usb_role_work); 340 info->id_nb.notifier_call = axp288_extcon_id_evt; 341 342 platform_set_drvdata(pdev, info); 343 344 info->role_sw = usb_role_switch_get(dev); 345 if (IS_ERR(info->role_sw)) 346 return PTR_ERR(info->role_sw); 347 if (info->role_sw) { 348 ret = devm_add_action_or_reset(dev, axp288_put_role_sw, info); 349 if (ret) 350 return ret; 351 352 adev = acpi_dev_get_first_match_dev("INT3496", NULL, -1); 353 if (adev) { 354 info->id_extcon = extcon_get_extcon_dev(acpi_dev_name(adev)); 355 put_device(&adev->dev); 356 if (!info->id_extcon) 357 return -EPROBE_DEFER; 358 359 dev_info(dev, "controlling USB role\n"); 360 } else { 361 dev_info(dev, "controlling USB role based on Vbus presence\n"); 362 } 363 } 364 365 info->vbus_attach = axp288_get_vbus_attach(info); 366 367 axp288_extcon_log_rsi(info); 368 369 /* Initialize extcon device */ 370 info->edev = devm_extcon_dev_allocate(&pdev->dev, 371 axp288_extcon_cables); 372 if (IS_ERR(info->edev)) { 373 dev_err(&pdev->dev, "failed to allocate memory for extcon\n"); 374 return PTR_ERR(info->edev); 375 } 376 377 /* Register extcon device */ 378 ret = devm_extcon_dev_register(&pdev->dev, info->edev); 379 if (ret) { 380 dev_err(&pdev->dev, "failed to register extcon device\n"); 381 return ret; 382 } 383 384 for (i = 0; i < EXTCON_IRQ_END; i++) { 385 pirq = platform_get_irq(pdev, i); 386 if (pirq < 0) 387 return pirq; 388 389 info->irq[i] = regmap_irq_get_virq(info->regmap_irqc, pirq); 390 if (info->irq[i] < 0) { 391 dev_err(&pdev->dev, 392 "failed to get virtual interrupt=%d\n", pirq); 393 ret = info->irq[i]; 394 return ret; 395 } 396 397 ret = devm_request_threaded_irq(&pdev->dev, info->irq[i], 398 NULL, axp288_extcon_isr, 399 IRQF_ONESHOT | IRQF_NO_SUSPEND, 400 pdev->name, info); 401 if (ret) { 402 dev_err(&pdev->dev, "failed to request interrupt=%d\n", 403 info->irq[i]); 404 return ret; 405 } 406 } 407 408 if (info->id_extcon) { 409 ret = devm_extcon_register_notifier_all(dev, info->id_extcon, 410 &info->id_nb); 411 if (ret) 412 return ret; 413 } 414 415 /* Make sure the role-sw is set correctly before doing BC detection */ 416 if (info->role_sw) { 417 queue_work(system_long_wq, &info->role_work); 418 flush_work(&info->role_work); 419 } 420 421 /* Start charger cable type detection */ 422 axp288_extcon_enable(info); 423 424 return 0; 425 } 426 427 static const struct platform_device_id axp288_extcon_table[] = { 428 { .name = "axp288_extcon" }, 429 {}, 430 }; 431 MODULE_DEVICE_TABLE(platform, axp288_extcon_table); 432 433 static struct platform_driver axp288_extcon_driver = { 434 .probe = axp288_extcon_probe, 435 .id_table = axp288_extcon_table, 436 .driver = { 437 .name = "axp288_extcon", 438 }, 439 }; 440 441 static struct device_connection axp288_extcon_role_sw_conn = { 442 .endpoint[0] = "axp288_extcon", 443 .endpoint[1] = "intel_xhci_usb_sw-role-switch", 444 .id = "usb-role-switch", 445 }; 446 447 static int __init axp288_extcon_init(void) 448 { 449 if (x86_match_cpu(cherry_trail_cpu_ids)) 450 device_connection_add(&axp288_extcon_role_sw_conn); 451 452 return platform_driver_register(&axp288_extcon_driver); 453 } 454 module_init(axp288_extcon_init); 455 456 static void __exit axp288_extcon_exit(void) 457 { 458 if (x86_match_cpu(cherry_trail_cpu_ids)) 459 device_connection_remove(&axp288_extcon_role_sw_conn); 460 461 platform_driver_unregister(&axp288_extcon_driver); 462 } 463 module_exit(axp288_extcon_exit); 464 465 MODULE_AUTHOR("Ramakrishna Pallala <ramakrishna.pallala@intel.com>"); 466 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); 467 MODULE_DESCRIPTION("X-Powers AXP288 extcon driver"); 468 MODULE_LICENSE("GPL v2"); 469