1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2015-2017 Google, Inc 4 * 5 * USB Type-C Port Controller Interface. 6 */ 7 8 #include <linux/delay.h> 9 #include <linux/kernel.h> 10 #include <linux/module.h> 11 #include <linux/i2c.h> 12 #include <linux/interrupt.h> 13 #include <linux/property.h> 14 #include <linux/regmap.h> 15 #include <linux/usb/pd.h> 16 #include <linux/usb/tcpm.h> 17 #include <linux/usb/typec.h> 18 19 #include "tcpci.h" 20 21 #define PD_RETRY_COUNT 3 22 23 struct tcpci { 24 struct device *dev; 25 26 struct tcpm_port *port; 27 28 struct regmap *regmap; 29 30 bool controls_vbus; 31 32 struct tcpc_dev tcpc; 33 struct tcpci_data *data; 34 }; 35 36 struct tcpci_chip { 37 struct tcpci *tcpci; 38 struct tcpci_data data; 39 }; 40 41 static inline struct tcpci *tcpc_to_tcpci(struct tcpc_dev *tcpc) 42 { 43 return container_of(tcpc, struct tcpci, tcpc); 44 } 45 46 static int tcpci_read16(struct tcpci *tcpci, unsigned int reg, u16 *val) 47 { 48 return regmap_raw_read(tcpci->regmap, reg, val, sizeof(u16)); 49 } 50 51 static int tcpci_write16(struct tcpci *tcpci, unsigned int reg, u16 val) 52 { 53 return regmap_raw_write(tcpci->regmap, reg, &val, sizeof(u16)); 54 } 55 56 static int tcpci_set_cc(struct tcpc_dev *tcpc, enum typec_cc_status cc) 57 { 58 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 59 unsigned int reg; 60 int ret; 61 62 switch (cc) { 63 case TYPEC_CC_RA: 64 reg = (TCPC_ROLE_CTRL_CC_RA << TCPC_ROLE_CTRL_CC1_SHIFT) | 65 (TCPC_ROLE_CTRL_CC_RA << TCPC_ROLE_CTRL_CC2_SHIFT); 66 break; 67 case TYPEC_CC_RD: 68 reg = (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) | 69 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT); 70 break; 71 case TYPEC_CC_RP_DEF: 72 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 73 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) | 74 (TCPC_ROLE_CTRL_RP_VAL_DEF << 75 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 76 break; 77 case TYPEC_CC_RP_1_5: 78 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 79 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) | 80 (TCPC_ROLE_CTRL_RP_VAL_1_5 << 81 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 82 break; 83 case TYPEC_CC_RP_3_0: 84 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 85 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) | 86 (TCPC_ROLE_CTRL_RP_VAL_3_0 << 87 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 88 break; 89 case TYPEC_CC_OPEN: 90 default: 91 reg = (TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC1_SHIFT) | 92 (TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC2_SHIFT); 93 break; 94 } 95 96 ret = regmap_write(tcpci->regmap, TCPC_ROLE_CTRL, reg); 97 if (ret < 0) 98 return ret; 99 100 return 0; 101 } 102 103 static int tcpci_start_toggling(struct tcpc_dev *tcpc, 104 enum typec_port_type port_type, 105 enum typec_cc_status cc) 106 { 107 int ret; 108 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 109 unsigned int reg = TCPC_ROLE_CTRL_DRP; 110 111 if (port_type != TYPEC_PORT_DRP) 112 return -EOPNOTSUPP; 113 114 /* Handle vendor drp toggling */ 115 if (tcpci->data->start_drp_toggling) { 116 ret = tcpci->data->start_drp_toggling(tcpci, tcpci->data, cc); 117 if (ret < 0) 118 return ret; 119 } 120 121 switch (cc) { 122 default: 123 case TYPEC_CC_RP_DEF: 124 reg |= (TCPC_ROLE_CTRL_RP_VAL_DEF << 125 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 126 break; 127 case TYPEC_CC_RP_1_5: 128 reg |= (TCPC_ROLE_CTRL_RP_VAL_1_5 << 129 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 130 break; 131 case TYPEC_CC_RP_3_0: 132 reg |= (TCPC_ROLE_CTRL_RP_VAL_3_0 << 133 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 134 break; 135 } 136 137 if (cc == TYPEC_CC_RD) 138 reg |= (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) | 139 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT); 140 else 141 reg |= (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 142 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT); 143 ret = regmap_write(tcpci->regmap, TCPC_ROLE_CTRL, reg); 144 if (ret < 0) 145 return ret; 146 return regmap_write(tcpci->regmap, TCPC_COMMAND, 147 TCPC_CMD_LOOK4CONNECTION); 148 } 149 150 static enum typec_cc_status tcpci_to_typec_cc(unsigned int cc, bool sink) 151 { 152 switch (cc) { 153 case 0x1: 154 return sink ? TYPEC_CC_RP_DEF : TYPEC_CC_RA; 155 case 0x2: 156 return sink ? TYPEC_CC_RP_1_5 : TYPEC_CC_RD; 157 case 0x3: 158 if (sink) 159 return TYPEC_CC_RP_3_0; 160 fallthrough; 161 case 0x0: 162 default: 163 return TYPEC_CC_OPEN; 164 } 165 } 166 167 static int tcpci_get_cc(struct tcpc_dev *tcpc, 168 enum typec_cc_status *cc1, enum typec_cc_status *cc2) 169 { 170 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 171 unsigned int reg; 172 int ret; 173 174 ret = regmap_read(tcpci->regmap, TCPC_CC_STATUS, ®); 175 if (ret < 0) 176 return ret; 177 178 *cc1 = tcpci_to_typec_cc((reg >> TCPC_CC_STATUS_CC1_SHIFT) & 179 TCPC_CC_STATUS_CC1_MASK, 180 reg & TCPC_CC_STATUS_TERM); 181 *cc2 = tcpci_to_typec_cc((reg >> TCPC_CC_STATUS_CC2_SHIFT) & 182 TCPC_CC_STATUS_CC2_MASK, 183 reg & TCPC_CC_STATUS_TERM); 184 185 return 0; 186 } 187 188 static int tcpci_set_polarity(struct tcpc_dev *tcpc, 189 enum typec_cc_polarity polarity) 190 { 191 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 192 unsigned int reg; 193 int ret; 194 195 /* Keep the disconnect cc line open */ 196 ret = regmap_read(tcpci->regmap, TCPC_ROLE_CTRL, ®); 197 if (ret < 0) 198 return ret; 199 200 if (polarity == TYPEC_POLARITY_CC2) 201 reg |= TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC1_SHIFT; 202 else 203 reg |= TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC2_SHIFT; 204 ret = regmap_write(tcpci->regmap, TCPC_ROLE_CTRL, reg); 205 if (ret < 0) 206 return ret; 207 208 return regmap_write(tcpci->regmap, TCPC_TCPC_CTRL, 209 (polarity == TYPEC_POLARITY_CC2) ? 210 TCPC_TCPC_CTRL_ORIENTATION : 0); 211 } 212 213 static int tcpci_set_vconn(struct tcpc_dev *tcpc, bool enable) 214 { 215 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 216 int ret; 217 218 /* Handle vendor set vconn */ 219 if (tcpci->data->set_vconn) { 220 ret = tcpci->data->set_vconn(tcpci, tcpci->data, enable); 221 if (ret < 0) 222 return ret; 223 } 224 225 return regmap_update_bits(tcpci->regmap, TCPC_POWER_CTRL, 226 TCPC_POWER_CTRL_VCONN_ENABLE, 227 enable ? TCPC_POWER_CTRL_VCONN_ENABLE : 0); 228 } 229 230 static int tcpci_set_bist_data(struct tcpc_dev *tcpc, bool enable) 231 { 232 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 233 234 return regmap_update_bits(tcpci->regmap, TCPC_TCPC_CTRL, TCPC_TCPC_CTRL_BIST_TM, 235 enable ? TCPC_TCPC_CTRL_BIST_TM : 0); 236 } 237 238 static int tcpci_set_roles(struct tcpc_dev *tcpc, bool attached, 239 enum typec_role role, enum typec_data_role data) 240 { 241 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 242 unsigned int reg; 243 int ret; 244 245 reg = PD_REV20 << TCPC_MSG_HDR_INFO_REV_SHIFT; 246 if (role == TYPEC_SOURCE) 247 reg |= TCPC_MSG_HDR_INFO_PWR_ROLE; 248 if (data == TYPEC_HOST) 249 reg |= TCPC_MSG_HDR_INFO_DATA_ROLE; 250 ret = regmap_write(tcpci->regmap, TCPC_MSG_HDR_INFO, reg); 251 if (ret < 0) 252 return ret; 253 254 return 0; 255 } 256 257 static int tcpci_set_pd_rx(struct tcpc_dev *tcpc, bool enable) 258 { 259 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 260 unsigned int reg = 0; 261 int ret; 262 263 if (enable) 264 reg = TCPC_RX_DETECT_SOP | TCPC_RX_DETECT_HARD_RESET; 265 ret = regmap_write(tcpci->regmap, TCPC_RX_DETECT, reg); 266 if (ret < 0) 267 return ret; 268 269 return 0; 270 } 271 272 static int tcpci_get_vbus(struct tcpc_dev *tcpc) 273 { 274 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 275 unsigned int reg; 276 int ret; 277 278 ret = regmap_read(tcpci->regmap, TCPC_POWER_STATUS, ®); 279 if (ret < 0) 280 return ret; 281 282 return !!(reg & TCPC_POWER_STATUS_VBUS_PRES); 283 } 284 285 static int tcpci_set_vbus(struct tcpc_dev *tcpc, bool source, bool sink) 286 { 287 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 288 int ret; 289 290 /* Disable both source and sink first before enabling anything */ 291 292 if (!source) { 293 ret = regmap_write(tcpci->regmap, TCPC_COMMAND, 294 TCPC_CMD_DISABLE_SRC_VBUS); 295 if (ret < 0) 296 return ret; 297 } 298 299 if (!sink) { 300 ret = regmap_write(tcpci->regmap, TCPC_COMMAND, 301 TCPC_CMD_DISABLE_SINK_VBUS); 302 if (ret < 0) 303 return ret; 304 } 305 306 if (source) { 307 ret = regmap_write(tcpci->regmap, TCPC_COMMAND, 308 TCPC_CMD_SRC_VBUS_DEFAULT); 309 if (ret < 0) 310 return ret; 311 } 312 313 if (sink) { 314 ret = regmap_write(tcpci->regmap, TCPC_COMMAND, 315 TCPC_CMD_SINK_VBUS); 316 if (ret < 0) 317 return ret; 318 } 319 320 return 0; 321 } 322 323 static int tcpci_pd_transmit(struct tcpc_dev *tcpc, 324 enum tcpm_transmit_type type, 325 const struct pd_message *msg) 326 { 327 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 328 u16 header = msg ? le16_to_cpu(msg->header) : 0; 329 unsigned int reg, cnt; 330 int ret; 331 332 cnt = msg ? pd_header_cnt(header) * 4 : 0; 333 ret = regmap_write(tcpci->regmap, TCPC_TX_BYTE_CNT, cnt + 2); 334 if (ret < 0) 335 return ret; 336 337 ret = tcpci_write16(tcpci, TCPC_TX_HDR, header); 338 if (ret < 0) 339 return ret; 340 341 if (cnt > 0) { 342 ret = regmap_raw_write(tcpci->regmap, TCPC_TX_DATA, 343 &msg->payload, cnt); 344 if (ret < 0) 345 return ret; 346 } 347 348 reg = (PD_RETRY_COUNT << TCPC_TRANSMIT_RETRY_SHIFT) | 349 (type << TCPC_TRANSMIT_TYPE_SHIFT); 350 ret = regmap_write(tcpci->regmap, TCPC_TRANSMIT, reg); 351 if (ret < 0) 352 return ret; 353 354 return 0; 355 } 356 357 static int tcpci_init(struct tcpc_dev *tcpc) 358 { 359 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 360 unsigned long timeout = jiffies + msecs_to_jiffies(2000); /* XXX */ 361 unsigned int reg; 362 int ret; 363 364 while (time_before_eq(jiffies, timeout)) { 365 ret = regmap_read(tcpci->regmap, TCPC_POWER_STATUS, ®); 366 if (ret < 0) 367 return ret; 368 if (!(reg & TCPC_POWER_STATUS_UNINIT)) 369 break; 370 usleep_range(10000, 20000); 371 } 372 if (time_after(jiffies, timeout)) 373 return -ETIMEDOUT; 374 375 /* Handle vendor init */ 376 if (tcpci->data->init) { 377 ret = tcpci->data->init(tcpci, tcpci->data); 378 if (ret < 0) 379 return ret; 380 } 381 382 /* Clear all events */ 383 ret = tcpci_write16(tcpci, TCPC_ALERT, 0xffff); 384 if (ret < 0) 385 return ret; 386 387 if (tcpci->controls_vbus) 388 reg = TCPC_POWER_STATUS_VBUS_PRES; 389 else 390 reg = 0; 391 ret = regmap_write(tcpci->regmap, TCPC_POWER_STATUS_MASK, reg); 392 if (ret < 0) 393 return ret; 394 395 /* Enable Vbus detection */ 396 ret = regmap_write(tcpci->regmap, TCPC_COMMAND, 397 TCPC_CMD_ENABLE_VBUS_DETECT); 398 if (ret < 0) 399 return ret; 400 401 reg = TCPC_ALERT_TX_SUCCESS | TCPC_ALERT_TX_FAILED | 402 TCPC_ALERT_TX_DISCARDED | TCPC_ALERT_RX_STATUS | 403 TCPC_ALERT_RX_HARD_RST | TCPC_ALERT_CC_STATUS; 404 if (tcpci->controls_vbus) 405 reg |= TCPC_ALERT_POWER_STATUS; 406 return tcpci_write16(tcpci, TCPC_ALERT_MASK, reg); 407 } 408 409 irqreturn_t tcpci_irq(struct tcpci *tcpci) 410 { 411 u16 status; 412 413 tcpci_read16(tcpci, TCPC_ALERT, &status); 414 415 /* 416 * Clear alert status for everything except RX_STATUS, which shouldn't 417 * be cleared until we have successfully retrieved message. 418 */ 419 if (status & ~TCPC_ALERT_RX_STATUS) 420 tcpci_write16(tcpci, TCPC_ALERT, 421 status & ~TCPC_ALERT_RX_STATUS); 422 423 if (status & TCPC_ALERT_CC_STATUS) 424 tcpm_cc_change(tcpci->port); 425 426 if (status & TCPC_ALERT_POWER_STATUS) { 427 unsigned int reg; 428 429 regmap_read(tcpci->regmap, TCPC_POWER_STATUS_MASK, ®); 430 431 /* 432 * If power status mask has been reset, then the TCPC 433 * has reset. 434 */ 435 if (reg == 0xff) 436 tcpm_tcpc_reset(tcpci->port); 437 else 438 tcpm_vbus_change(tcpci->port); 439 } 440 441 if (status & TCPC_ALERT_RX_STATUS) { 442 struct pd_message msg; 443 unsigned int cnt, payload_cnt; 444 u16 header; 445 446 regmap_read(tcpci->regmap, TCPC_RX_BYTE_CNT, &cnt); 447 /* 448 * 'cnt' corresponds to READABLE_BYTE_COUNT in section 4.4.14 449 * of the TCPCI spec [Rev 2.0 Ver 1.0 October 2017] and is 450 * defined in table 4-36 as one greater than the number of 451 * bytes received. And that number includes the header. So: 452 */ 453 if (cnt > 3) 454 payload_cnt = cnt - (1 + sizeof(msg.header)); 455 else 456 payload_cnt = 0; 457 458 tcpci_read16(tcpci, TCPC_RX_HDR, &header); 459 msg.header = cpu_to_le16(header); 460 461 if (WARN_ON(payload_cnt > sizeof(msg.payload))) 462 payload_cnt = sizeof(msg.payload); 463 464 if (payload_cnt > 0) 465 regmap_raw_read(tcpci->regmap, TCPC_RX_DATA, 466 &msg.payload, payload_cnt); 467 468 /* Read complete, clear RX status alert bit */ 469 tcpci_write16(tcpci, TCPC_ALERT, TCPC_ALERT_RX_STATUS); 470 471 tcpm_pd_receive(tcpci->port, &msg); 472 } 473 474 if (status & TCPC_ALERT_RX_HARD_RST) 475 tcpm_pd_hard_reset(tcpci->port); 476 477 if (status & TCPC_ALERT_TX_SUCCESS) 478 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_SUCCESS); 479 else if (status & TCPC_ALERT_TX_DISCARDED) 480 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_DISCARDED); 481 else if (status & TCPC_ALERT_TX_FAILED) 482 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_FAILED); 483 484 return IRQ_HANDLED; 485 } 486 EXPORT_SYMBOL_GPL(tcpci_irq); 487 488 static irqreturn_t _tcpci_irq(int irq, void *dev_id) 489 { 490 struct tcpci_chip *chip = dev_id; 491 492 return tcpci_irq(chip->tcpci); 493 } 494 495 static const struct regmap_config tcpci_regmap_config = { 496 .reg_bits = 8, 497 .val_bits = 8, 498 499 .max_register = 0x7F, /* 0x80 .. 0xFF are vendor defined */ 500 }; 501 502 static int tcpci_parse_config(struct tcpci *tcpci) 503 { 504 tcpci->controls_vbus = true; /* XXX */ 505 506 tcpci->tcpc.fwnode = device_get_named_child_node(tcpci->dev, 507 "connector"); 508 if (!tcpci->tcpc.fwnode) { 509 dev_err(tcpci->dev, "Can't find connector node.\n"); 510 return -EINVAL; 511 } 512 513 return 0; 514 } 515 516 struct tcpci *tcpci_register_port(struct device *dev, struct tcpci_data *data) 517 { 518 struct tcpci *tcpci; 519 int err; 520 521 tcpci = devm_kzalloc(dev, sizeof(*tcpci), GFP_KERNEL); 522 if (!tcpci) 523 return ERR_PTR(-ENOMEM); 524 525 tcpci->dev = dev; 526 tcpci->data = data; 527 tcpci->regmap = data->regmap; 528 529 tcpci->tcpc.init = tcpci_init; 530 tcpci->tcpc.get_vbus = tcpci_get_vbus; 531 tcpci->tcpc.set_vbus = tcpci_set_vbus; 532 tcpci->tcpc.set_cc = tcpci_set_cc; 533 tcpci->tcpc.get_cc = tcpci_get_cc; 534 tcpci->tcpc.set_polarity = tcpci_set_polarity; 535 tcpci->tcpc.set_vconn = tcpci_set_vconn; 536 tcpci->tcpc.start_toggling = tcpci_start_toggling; 537 538 tcpci->tcpc.set_pd_rx = tcpci_set_pd_rx; 539 tcpci->tcpc.set_roles = tcpci_set_roles; 540 tcpci->tcpc.pd_transmit = tcpci_pd_transmit; 541 tcpci->tcpc.set_bist_data = tcpci_set_bist_data; 542 543 err = tcpci_parse_config(tcpci); 544 if (err < 0) 545 return ERR_PTR(err); 546 547 tcpci->port = tcpm_register_port(tcpci->dev, &tcpci->tcpc); 548 if (IS_ERR(tcpci->port)) 549 return ERR_CAST(tcpci->port); 550 551 return tcpci; 552 } 553 EXPORT_SYMBOL_GPL(tcpci_register_port); 554 555 void tcpci_unregister_port(struct tcpci *tcpci) 556 { 557 tcpm_unregister_port(tcpci->port); 558 } 559 EXPORT_SYMBOL_GPL(tcpci_unregister_port); 560 561 static int tcpci_probe(struct i2c_client *client, 562 const struct i2c_device_id *i2c_id) 563 { 564 struct tcpci_chip *chip; 565 int err; 566 u16 val = 0; 567 568 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); 569 if (!chip) 570 return -ENOMEM; 571 572 chip->data.regmap = devm_regmap_init_i2c(client, &tcpci_regmap_config); 573 if (IS_ERR(chip->data.regmap)) 574 return PTR_ERR(chip->data.regmap); 575 576 i2c_set_clientdata(client, chip); 577 578 /* Disable chip interrupts before requesting irq */ 579 err = regmap_raw_write(chip->data.regmap, TCPC_ALERT_MASK, &val, 580 sizeof(u16)); 581 if (err < 0) 582 return err; 583 584 chip->tcpci = tcpci_register_port(&client->dev, &chip->data); 585 if (IS_ERR(chip->tcpci)) 586 return PTR_ERR(chip->tcpci); 587 588 err = devm_request_threaded_irq(&client->dev, client->irq, NULL, 589 _tcpci_irq, 590 IRQF_ONESHOT | IRQF_TRIGGER_LOW, 591 dev_name(&client->dev), chip); 592 if (err < 0) { 593 tcpci_unregister_port(chip->tcpci); 594 return err; 595 } 596 597 return 0; 598 } 599 600 static int tcpci_remove(struct i2c_client *client) 601 { 602 struct tcpci_chip *chip = i2c_get_clientdata(client); 603 int err; 604 605 /* Disable chip interrupts before unregistering port */ 606 err = tcpci_write16(chip->tcpci, TCPC_ALERT_MASK, 0); 607 if (err < 0) 608 return err; 609 610 tcpci_unregister_port(chip->tcpci); 611 612 return 0; 613 } 614 615 static const struct i2c_device_id tcpci_id[] = { 616 { "tcpci", 0 }, 617 { } 618 }; 619 MODULE_DEVICE_TABLE(i2c, tcpci_id); 620 621 #ifdef CONFIG_OF 622 static const struct of_device_id tcpci_of_match[] = { 623 { .compatible = "nxp,ptn5110", }, 624 {}, 625 }; 626 MODULE_DEVICE_TABLE(of, tcpci_of_match); 627 #endif 628 629 static struct i2c_driver tcpci_i2c_driver = { 630 .driver = { 631 .name = "tcpci", 632 .of_match_table = of_match_ptr(tcpci_of_match), 633 }, 634 .probe = tcpci_probe, 635 .remove = tcpci_remove, 636 .id_table = tcpci_id, 637 }; 638 module_i2c_driver(tcpci_i2c_driver); 639 640 MODULE_DESCRIPTION("USB Type-C Port Controller Interface driver"); 641 MODULE_LICENSE("GPL"); 642