1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * drivers/extcon/extcon-tusb320.c - TUSB320 extcon driver 4 * 5 * Copyright (C) 2020 National Instruments Corporation 6 * Author: Michael Auchter <michael.auchter@ni.com> 7 */ 8 9 #include <linux/bitfield.h> 10 #include <linux/extcon-provider.h> 11 #include <linux/i2c.h> 12 #include <linux/init.h> 13 #include <linux/interrupt.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/regmap.h> 17 #include <linux/usb/typec.h> 18 #include <linux/usb/typec_altmode.h> 19 #include <linux/usb/role.h> 20 #include <linux/irq.h> 21 22 #define TUSB320_REG8 0x8 23 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE GENMASK(7, 6) 24 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE_USB 0x0 25 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE_15A 0x1 26 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE_30A 0x2 27 #define TUSB320_REG8_CURRENT_MODE_DETECT GENMASK(5, 4) 28 #define TUSB320_REG8_CURRENT_MODE_DETECT_DEF 0x0 29 #define TUSB320_REG8_CURRENT_MODE_DETECT_MED 0x1 30 #define TUSB320_REG8_CURRENT_MODE_DETECT_ACC 0x2 31 #define TUSB320_REG8_CURRENT_MODE_DETECT_HI 0x3 32 #define TUSB320_REG8_ACCESSORY_CONNECTED GENMASK(3, 1) 33 #define TUSB320_REG8_ACCESSORY_CONNECTED_NONE 0x0 34 #define TUSB320_REG8_ACCESSORY_CONNECTED_AUDIO 0x4 35 #define TUSB320_REG8_ACCESSORY_CONNECTED_ACHRG 0x5 36 #define TUSB320_REG8_ACCESSORY_CONNECTED_DBGDFP 0x6 37 #define TUSB320_REG8_ACCESSORY_CONNECTED_DBGUFP 0x7 38 #define TUSB320_REG8_ACTIVE_CABLE_DETECTION BIT(0) 39 40 #define TUSB320_REG9 0x9 41 #define TUSB320_REG9_ATTACHED_STATE GENMASK(7, 6) 42 #define TUSB320_REG9_CABLE_DIRECTION BIT(5) 43 #define TUSB320_REG9_INTERRUPT_STATUS BIT(4) 44 45 #define TUSB320_REGA 0xa 46 #define TUSB320L_REGA_DISABLE_TERM BIT(0) 47 #define TUSB320_REGA_I2C_SOFT_RESET BIT(3) 48 #define TUSB320_REGA_MODE_SELECT_SHIFT 4 49 #define TUSB320_REGA_MODE_SELECT_MASK 0x3 50 51 #define TUSB320L_REGA0_REVISION 0xa0 52 53 enum tusb320_attached_state { 54 TUSB320_ATTACHED_STATE_NONE, 55 TUSB320_ATTACHED_STATE_DFP, 56 TUSB320_ATTACHED_STATE_UFP, 57 TUSB320_ATTACHED_STATE_ACC, 58 }; 59 60 enum tusb320_mode { 61 TUSB320_MODE_PORT, 62 TUSB320_MODE_UFP, 63 TUSB320_MODE_DFP, 64 TUSB320_MODE_DRP, 65 }; 66 67 struct tusb320_priv; 68 69 struct tusb320_ops { 70 int (*set_mode)(struct tusb320_priv *priv, enum tusb320_mode mode); 71 int (*get_revision)(struct tusb320_priv *priv, unsigned int *revision); 72 }; 73 74 struct tusb320_priv { 75 struct device *dev; 76 struct regmap *regmap; 77 struct extcon_dev *edev; 78 struct tusb320_ops *ops; 79 enum tusb320_attached_state state; 80 struct typec_port *port; 81 struct typec_capability cap; 82 enum typec_port_type port_type; 83 enum typec_pwr_opmode pwr_opmode; 84 struct fwnode_handle *connector_fwnode; 85 struct usb_role_switch *role_sw; 86 }; 87 88 static const char * const tusb_attached_states[] = { 89 [TUSB320_ATTACHED_STATE_NONE] = "not attached", 90 [TUSB320_ATTACHED_STATE_DFP] = "downstream facing port", 91 [TUSB320_ATTACHED_STATE_UFP] = "upstream facing port", 92 [TUSB320_ATTACHED_STATE_ACC] = "accessory", 93 }; 94 95 static const unsigned int tusb320_extcon_cable[] = { 96 EXTCON_USB, 97 EXTCON_USB_HOST, 98 EXTCON_NONE, 99 }; 100 101 static int tusb320_check_signature(struct tusb320_priv *priv) 102 { 103 static const char sig[] = { '\0', 'T', 'U', 'S', 'B', '3', '2', '0' }; 104 unsigned val; 105 int i, ret; 106 107 for (i = 0; i < sizeof(sig); i++) { 108 ret = regmap_read(priv->regmap, sizeof(sig) - 1 - i, &val); 109 if (ret < 0) 110 return ret; 111 if (val != sig[i]) { 112 dev_err(priv->dev, "signature mismatch!\n"); 113 return -ENODEV; 114 } 115 } 116 117 return 0; 118 } 119 120 static int tusb320_set_mode(struct tusb320_priv *priv, enum tusb320_mode mode) 121 { 122 int ret; 123 124 /* Mode cannot be changed while cable is attached */ 125 if (priv->state != TUSB320_ATTACHED_STATE_NONE) 126 return -EBUSY; 127 128 /* Write mode */ 129 ret = regmap_write_bits(priv->regmap, TUSB320_REGA, 130 TUSB320_REGA_MODE_SELECT_MASK << TUSB320_REGA_MODE_SELECT_SHIFT, 131 mode << TUSB320_REGA_MODE_SELECT_SHIFT); 132 if (ret) { 133 dev_err(priv->dev, "failed to write mode: %d\n", ret); 134 return ret; 135 } 136 137 return 0; 138 } 139 140 static int tusb320l_set_mode(struct tusb320_priv *priv, enum tusb320_mode mode) 141 { 142 int ret; 143 144 /* Disable CC state machine */ 145 ret = regmap_write_bits(priv->regmap, TUSB320_REGA, 146 TUSB320L_REGA_DISABLE_TERM, 1); 147 if (ret) { 148 dev_err(priv->dev, 149 "failed to disable CC state machine: %d\n", ret); 150 return ret; 151 } 152 153 /* Write mode */ 154 ret = regmap_write_bits(priv->regmap, TUSB320_REGA, 155 TUSB320_REGA_MODE_SELECT_MASK << TUSB320_REGA_MODE_SELECT_SHIFT, 156 mode << TUSB320_REGA_MODE_SELECT_SHIFT); 157 if (ret) { 158 dev_err(priv->dev, "failed to write mode: %d\n", ret); 159 goto err; 160 } 161 162 msleep(5); 163 err: 164 /* Re-enable CC state machine */ 165 ret = regmap_write_bits(priv->regmap, TUSB320_REGA, 166 TUSB320L_REGA_DISABLE_TERM, 0); 167 if (ret) 168 dev_err(priv->dev, 169 "failed to re-enable CC state machine: %d\n", ret); 170 171 return ret; 172 } 173 174 static int tusb320_reset(struct tusb320_priv *priv) 175 { 176 int ret; 177 178 /* Set mode to default (follow PORT pin) */ 179 ret = priv->ops->set_mode(priv, TUSB320_MODE_PORT); 180 if (ret && ret != -EBUSY) { 181 dev_err(priv->dev, 182 "failed to set mode to PORT: %d\n", ret); 183 return ret; 184 } 185 186 /* Perform soft reset */ 187 ret = regmap_write_bits(priv->regmap, TUSB320_REGA, 188 TUSB320_REGA_I2C_SOFT_RESET, 1); 189 if (ret) { 190 dev_err(priv->dev, 191 "failed to write soft reset bit: %d\n", ret); 192 return ret; 193 } 194 195 /* Wait for chip to go through reset */ 196 msleep(95); 197 198 return 0; 199 } 200 201 static int tusb320l_get_revision(struct tusb320_priv *priv, unsigned int *revision) 202 { 203 return regmap_read(priv->regmap, TUSB320L_REGA0_REVISION, revision); 204 } 205 206 static struct tusb320_ops tusb320_ops = { 207 .set_mode = tusb320_set_mode, 208 }; 209 210 static struct tusb320_ops tusb320l_ops = { 211 .set_mode = tusb320l_set_mode, 212 .get_revision = tusb320l_get_revision, 213 }; 214 215 static int tusb320_set_adv_pwr_mode(struct tusb320_priv *priv) 216 { 217 u8 mode; 218 219 if (priv->pwr_opmode == TYPEC_PWR_MODE_USB) 220 mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_USB; 221 else if (priv->pwr_opmode == TYPEC_PWR_MODE_1_5A) 222 mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_15A; 223 else if (priv->pwr_opmode == TYPEC_PWR_MODE_3_0A) 224 mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_30A; 225 else /* No other mode is supported. */ 226 return -EINVAL; 227 228 return regmap_write_bits(priv->regmap, TUSB320_REG8, 229 TUSB320_REG8_CURRENT_MODE_ADVERTISE, 230 FIELD_PREP(TUSB320_REG8_CURRENT_MODE_ADVERTISE, 231 mode)); 232 } 233 234 static int tusb320_port_type_set(struct typec_port *port, 235 enum typec_port_type type) 236 { 237 struct tusb320_priv *priv = typec_get_drvdata(port); 238 239 if (type == TYPEC_PORT_SRC) 240 return priv->ops->set_mode(priv, TUSB320_MODE_DFP); 241 else if (type == TYPEC_PORT_SNK) 242 return priv->ops->set_mode(priv, TUSB320_MODE_UFP); 243 else if (type == TYPEC_PORT_DRP) 244 return priv->ops->set_mode(priv, TUSB320_MODE_DRP); 245 else 246 return priv->ops->set_mode(priv, TUSB320_MODE_PORT); 247 } 248 249 static const struct typec_operations tusb320_typec_ops = { 250 .port_type_set = tusb320_port_type_set, 251 }; 252 253 static void tusb320_extcon_irq_handler(struct tusb320_priv *priv, u8 reg) 254 { 255 int state, polarity; 256 257 state = FIELD_GET(TUSB320_REG9_ATTACHED_STATE, reg); 258 polarity = !!(reg & TUSB320_REG9_CABLE_DIRECTION); 259 260 dev_dbg(priv->dev, "attached state: %s, polarity: %d\n", 261 tusb_attached_states[state], polarity); 262 263 extcon_set_state(priv->edev, EXTCON_USB, 264 state == TUSB320_ATTACHED_STATE_UFP); 265 extcon_set_state(priv->edev, EXTCON_USB_HOST, 266 state == TUSB320_ATTACHED_STATE_DFP); 267 extcon_set_property(priv->edev, EXTCON_USB, 268 EXTCON_PROP_USB_TYPEC_POLARITY, 269 (union extcon_property_value)polarity); 270 extcon_set_property(priv->edev, EXTCON_USB_HOST, 271 EXTCON_PROP_USB_TYPEC_POLARITY, 272 (union extcon_property_value)polarity); 273 extcon_sync(priv->edev, EXTCON_USB); 274 extcon_sync(priv->edev, EXTCON_USB_HOST); 275 276 priv->state = state; 277 } 278 279 static void tusb320_typec_irq_handler(struct tusb320_priv *priv, u8 reg9) 280 { 281 struct typec_port *port = priv->port; 282 struct device *dev = priv->dev; 283 int typec_mode; 284 enum usb_role usb_role; 285 enum typec_role pwr_role; 286 enum typec_data_role data_role; 287 u8 state, mode, accessory; 288 int ret, reg8; 289 bool ori; 290 291 ret = regmap_read(priv->regmap, TUSB320_REG8, ®8); 292 if (ret) { 293 dev_err(dev, "error during reg8 i2c read, ret=%d!\n", ret); 294 return; 295 } 296 297 ori = reg9 & TUSB320_REG9_CABLE_DIRECTION; 298 typec_set_orientation(port, ori ? TYPEC_ORIENTATION_REVERSE : 299 TYPEC_ORIENTATION_NORMAL); 300 301 state = FIELD_GET(TUSB320_REG9_ATTACHED_STATE, reg9); 302 accessory = FIELD_GET(TUSB320_REG8_ACCESSORY_CONNECTED, reg8); 303 304 switch (state) { 305 case TUSB320_ATTACHED_STATE_DFP: 306 typec_mode = TYPEC_MODE_USB2; 307 usb_role = USB_ROLE_HOST; 308 pwr_role = TYPEC_SOURCE; 309 data_role = TYPEC_HOST; 310 break; 311 case TUSB320_ATTACHED_STATE_UFP: 312 typec_mode = TYPEC_MODE_USB2; 313 usb_role = USB_ROLE_DEVICE; 314 pwr_role = TYPEC_SINK; 315 data_role = TYPEC_DEVICE; 316 break; 317 case TUSB320_ATTACHED_STATE_ACC: 318 /* 319 * Accessory detected. For debug accessories, just make some 320 * qualified guesses as to the role for lack of a better option. 321 */ 322 if (accessory == TUSB320_REG8_ACCESSORY_CONNECTED_AUDIO || 323 accessory == TUSB320_REG8_ACCESSORY_CONNECTED_ACHRG) { 324 typec_mode = TYPEC_MODE_AUDIO; 325 usb_role = USB_ROLE_NONE; 326 pwr_role = TYPEC_SINK; 327 data_role = TYPEC_DEVICE; 328 break; 329 } else if (accessory == 330 TUSB320_REG8_ACCESSORY_CONNECTED_DBGDFP) { 331 typec_mode = TYPEC_MODE_DEBUG; 332 pwr_role = TYPEC_SOURCE; 333 usb_role = USB_ROLE_HOST; 334 data_role = TYPEC_HOST; 335 break; 336 } else if (accessory == 337 TUSB320_REG8_ACCESSORY_CONNECTED_DBGUFP) { 338 typec_mode = TYPEC_MODE_DEBUG; 339 pwr_role = TYPEC_SINK; 340 usb_role = USB_ROLE_DEVICE; 341 data_role = TYPEC_DEVICE; 342 break; 343 } 344 345 dev_warn(priv->dev, "unexpected ACCESSORY_CONNECTED state %d\n", 346 accessory); 347 348 fallthrough; 349 default: 350 typec_mode = TYPEC_MODE_USB2; 351 usb_role = USB_ROLE_NONE; 352 pwr_role = TYPEC_SINK; 353 data_role = TYPEC_DEVICE; 354 break; 355 } 356 357 typec_set_vconn_role(port, pwr_role); 358 typec_set_pwr_role(port, pwr_role); 359 typec_set_data_role(port, data_role); 360 typec_set_mode(port, typec_mode); 361 usb_role_switch_set_role(priv->role_sw, usb_role); 362 363 mode = FIELD_GET(TUSB320_REG8_CURRENT_MODE_DETECT, reg8); 364 if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_DEF) 365 typec_set_pwr_opmode(port, TYPEC_PWR_MODE_USB); 366 else if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_MED) 367 typec_set_pwr_opmode(port, TYPEC_PWR_MODE_1_5A); 368 else if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_HI) 369 typec_set_pwr_opmode(port, TYPEC_PWR_MODE_3_0A); 370 else /* Charge through accessory */ 371 typec_set_pwr_opmode(port, TYPEC_PWR_MODE_USB); 372 } 373 374 static irqreturn_t tusb320_state_update_handler(struct tusb320_priv *priv, 375 bool force_update) 376 { 377 unsigned int reg; 378 379 if (regmap_read(priv->regmap, TUSB320_REG9, ®)) { 380 dev_err(priv->dev, "error during i2c read!\n"); 381 return IRQ_NONE; 382 } 383 384 if (!force_update && !(reg & TUSB320_REG9_INTERRUPT_STATUS)) 385 return IRQ_NONE; 386 387 tusb320_extcon_irq_handler(priv, reg); 388 389 /* 390 * Type-C support is optional. Only call the Type-C handler if a 391 * port had been registered previously. 392 */ 393 if (priv->port) 394 tusb320_typec_irq_handler(priv, reg); 395 396 regmap_write(priv->regmap, TUSB320_REG9, reg); 397 398 return IRQ_HANDLED; 399 } 400 401 static irqreturn_t tusb320_irq_handler(int irq, void *dev_id) 402 { 403 struct tusb320_priv *priv = dev_id; 404 405 return tusb320_state_update_handler(priv, false); 406 } 407 408 static const struct regmap_config tusb320_regmap_config = { 409 .reg_bits = 8, 410 .val_bits = 8, 411 }; 412 413 static int tusb320_extcon_probe(struct tusb320_priv *priv) 414 { 415 int ret; 416 417 priv->edev = devm_extcon_dev_allocate(priv->dev, tusb320_extcon_cable); 418 if (IS_ERR(priv->edev)) { 419 dev_err(priv->dev, "failed to allocate extcon device\n"); 420 return PTR_ERR(priv->edev); 421 } 422 423 ret = devm_extcon_dev_register(priv->dev, priv->edev); 424 if (ret < 0) { 425 dev_err(priv->dev, "failed to register extcon device\n"); 426 return ret; 427 } 428 429 extcon_set_property_capability(priv->edev, EXTCON_USB, 430 EXTCON_PROP_USB_TYPEC_POLARITY); 431 extcon_set_property_capability(priv->edev, EXTCON_USB_HOST, 432 EXTCON_PROP_USB_TYPEC_POLARITY); 433 434 return 0; 435 } 436 437 static int tusb320_typec_probe(struct i2c_client *client, 438 struct tusb320_priv *priv) 439 { 440 struct fwnode_handle *connector; 441 const char *cap_str; 442 int ret; 443 444 /* The Type-C connector is optional, for backward compatibility. */ 445 connector = device_get_named_child_node(&client->dev, "connector"); 446 if (!connector) 447 return 0; 448 449 /* Type-C connector found. */ 450 ret = typec_get_fw_cap(&priv->cap, connector); 451 if (ret) 452 goto err_put; 453 454 priv->port_type = priv->cap.type; 455 456 /* This goes into register 0x8 field CURRENT_MODE_ADVERTISE */ 457 ret = fwnode_property_read_string(connector, "typec-power-opmode", &cap_str); 458 if (ret) 459 goto err_put; 460 461 ret = typec_find_pwr_opmode(cap_str); 462 if (ret < 0) 463 goto err_put; 464 465 priv->pwr_opmode = ret; 466 467 /* Initialize the hardware with the devicetree settings. */ 468 ret = tusb320_set_adv_pwr_mode(priv); 469 if (ret) 470 goto err_put; 471 472 priv->cap.revision = USB_TYPEC_REV_1_1; 473 priv->cap.accessory[0] = TYPEC_ACCESSORY_AUDIO; 474 priv->cap.accessory[1] = TYPEC_ACCESSORY_DEBUG; 475 priv->cap.orientation_aware = true; 476 priv->cap.driver_data = priv; 477 priv->cap.ops = &tusb320_typec_ops; 478 priv->cap.fwnode = connector; 479 480 priv->port = typec_register_port(&client->dev, &priv->cap); 481 if (IS_ERR(priv->port)) { 482 ret = PTR_ERR(priv->port); 483 goto err_put; 484 } 485 486 /* Find any optional USB role switch that needs reporting to */ 487 priv->role_sw = fwnode_usb_role_switch_get(connector); 488 if (IS_ERR(priv->role_sw)) { 489 ret = PTR_ERR(priv->role_sw); 490 goto err_unreg; 491 } 492 493 priv->connector_fwnode = connector; 494 495 return 0; 496 497 err_unreg: 498 typec_unregister_port(priv->port); 499 500 err_put: 501 fwnode_handle_put(connector); 502 503 return ret; 504 } 505 506 static void tusb320_typec_remove(struct tusb320_priv *priv) 507 { 508 usb_role_switch_put(priv->role_sw); 509 typec_unregister_port(priv->port); 510 fwnode_handle_put(priv->connector_fwnode); 511 } 512 513 static int tusb320_probe(struct i2c_client *client) 514 { 515 struct tusb320_priv *priv; 516 const void *match_data; 517 unsigned int revision; 518 int ret; 519 u32 irq_trigger_type = IRQF_TRIGGER_FALLING; 520 struct irq_data *irq_d; 521 522 priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL); 523 if (!priv) 524 return -ENOMEM; 525 526 priv->dev = &client->dev; 527 i2c_set_clientdata(client, priv); 528 529 priv->regmap = devm_regmap_init_i2c(client, &tusb320_regmap_config); 530 if (IS_ERR(priv->regmap)) 531 return PTR_ERR(priv->regmap); 532 533 ret = tusb320_check_signature(priv); 534 if (ret) 535 return ret; 536 537 match_data = device_get_match_data(&client->dev); 538 if (!match_data) 539 return -EINVAL; 540 541 priv->ops = (struct tusb320_ops*)match_data; 542 543 if (priv->ops->get_revision) { 544 ret = priv->ops->get_revision(priv, &revision); 545 if (ret) 546 dev_warn(priv->dev, 547 "failed to read revision register: %d\n", ret); 548 else 549 dev_info(priv->dev, "chip revision %d\n", revision); 550 } 551 552 ret = tusb320_extcon_probe(priv); 553 if (ret) 554 return ret; 555 556 ret = tusb320_typec_probe(client, priv); 557 if (ret) 558 return ret; 559 560 /* update initial state */ 561 tusb320_state_update_handler(priv, true); 562 563 /* Reset chip to its default state */ 564 ret = tusb320_reset(priv); 565 if (ret) 566 dev_warn(priv->dev, "failed to reset chip: %d\n", ret); 567 else 568 /* 569 * State and polarity might change after a reset, so update 570 * them again and make sure the interrupt status bit is cleared. 571 */ 572 tusb320_state_update_handler(priv, true); 573 574 irq_d = irq_get_irq_data(client->irq); 575 if (irq_d) 576 irq_trigger_type = irqd_get_trigger_type(irq_d); 577 578 ret = devm_request_threaded_irq(priv->dev, client->irq, NULL, 579 tusb320_irq_handler, 580 IRQF_ONESHOT | irq_trigger_type, 581 client->name, priv); 582 if (ret) 583 tusb320_typec_remove(priv); 584 585 return ret; 586 } 587 588 static void tusb320_remove(struct i2c_client *client) 589 { 590 struct tusb320_priv *priv = i2c_get_clientdata(client); 591 592 tusb320_typec_remove(priv); 593 } 594 595 static const struct of_device_id tusb320_extcon_dt_match[] = { 596 { .compatible = "ti,tusb320", .data = &tusb320_ops, }, 597 { .compatible = "ti,tusb320l", .data = &tusb320l_ops, }, 598 { } 599 }; 600 MODULE_DEVICE_TABLE(of, tusb320_extcon_dt_match); 601 602 static struct i2c_driver tusb320_extcon_driver = { 603 .probe = tusb320_probe, 604 .remove = tusb320_remove, 605 .driver = { 606 .name = "extcon-tusb320", 607 .of_match_table = tusb320_extcon_dt_match, 608 }, 609 }; 610 611 static int __init tusb320_init(void) 612 { 613 return i2c_add_driver(&tusb320_extcon_driver); 614 } 615 subsys_initcall(tusb320_init); 616 617 static void __exit tusb320_exit(void) 618 { 619 i2c_del_driver(&tusb320_extcon_driver); 620 } 621 module_exit(tusb320_exit); 622 623 MODULE_AUTHOR("Michael Auchter <michael.auchter@ni.com>"); 624 MODULE_DESCRIPTION("TI TUSB320 extcon driver"); 625 MODULE_LICENSE("GPL v2"); 626