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_DEFAULT 3 22 #define PD_RETRY_COUNT_3_0_OR_HIGHER 2 23 #define AUTO_DISCHARGE_DEFAULT_THRESHOLD_MV 3500 24 #define AUTO_DISCHARGE_PD_HEADROOM_MV 850 25 #define AUTO_DISCHARGE_PPS_HEADROOM_MV 1250 26 27 struct tcpci { 28 struct device *dev; 29 30 struct tcpm_port *port; 31 32 struct regmap *regmap; 33 34 bool controls_vbus; 35 36 struct tcpc_dev tcpc; 37 struct tcpci_data *data; 38 }; 39 40 struct tcpci_chip { 41 struct tcpci *tcpci; 42 struct tcpci_data data; 43 }; 44 45 struct tcpm_port *tcpci_get_tcpm_port(struct tcpci *tcpci) 46 { 47 return tcpci->port; 48 } 49 EXPORT_SYMBOL_GPL(tcpci_get_tcpm_port); 50 51 static inline struct tcpci *tcpc_to_tcpci(struct tcpc_dev *tcpc) 52 { 53 return container_of(tcpc, struct tcpci, tcpc); 54 } 55 56 static int tcpci_read16(struct tcpci *tcpci, unsigned int reg, u16 *val) 57 { 58 return regmap_raw_read(tcpci->regmap, reg, val, sizeof(u16)); 59 } 60 61 static int tcpci_write16(struct tcpci *tcpci, unsigned int reg, u16 val) 62 { 63 return regmap_raw_write(tcpci->regmap, reg, &val, sizeof(u16)); 64 } 65 66 static int tcpci_set_cc(struct tcpc_dev *tcpc, enum typec_cc_status cc) 67 { 68 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 69 unsigned int reg; 70 int ret; 71 72 switch (cc) { 73 case TYPEC_CC_RA: 74 reg = (TCPC_ROLE_CTRL_CC_RA << TCPC_ROLE_CTRL_CC1_SHIFT) | 75 (TCPC_ROLE_CTRL_CC_RA << TCPC_ROLE_CTRL_CC2_SHIFT); 76 break; 77 case TYPEC_CC_RD: 78 reg = (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) | 79 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT); 80 break; 81 case TYPEC_CC_RP_DEF: 82 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 83 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) | 84 (TCPC_ROLE_CTRL_RP_VAL_DEF << 85 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 86 break; 87 case TYPEC_CC_RP_1_5: 88 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 89 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) | 90 (TCPC_ROLE_CTRL_RP_VAL_1_5 << 91 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 92 break; 93 case TYPEC_CC_RP_3_0: 94 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 95 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) | 96 (TCPC_ROLE_CTRL_RP_VAL_3_0 << 97 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 98 break; 99 case TYPEC_CC_OPEN: 100 default: 101 reg = (TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC1_SHIFT) | 102 (TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC2_SHIFT); 103 break; 104 } 105 106 ret = regmap_write(tcpci->regmap, TCPC_ROLE_CTRL, reg); 107 if (ret < 0) 108 return ret; 109 110 return 0; 111 } 112 113 static int tcpci_start_toggling(struct tcpc_dev *tcpc, 114 enum typec_port_type port_type, 115 enum typec_cc_status cc) 116 { 117 int ret; 118 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 119 unsigned int reg = TCPC_ROLE_CTRL_DRP; 120 121 if (port_type != TYPEC_PORT_DRP) 122 return -EOPNOTSUPP; 123 124 /* Handle vendor drp toggling */ 125 if (tcpci->data->start_drp_toggling) { 126 ret = tcpci->data->start_drp_toggling(tcpci, tcpci->data, cc); 127 if (ret < 0) 128 return ret; 129 } 130 131 switch (cc) { 132 default: 133 case TYPEC_CC_RP_DEF: 134 reg |= (TCPC_ROLE_CTRL_RP_VAL_DEF << 135 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 136 break; 137 case TYPEC_CC_RP_1_5: 138 reg |= (TCPC_ROLE_CTRL_RP_VAL_1_5 << 139 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 140 break; 141 case TYPEC_CC_RP_3_0: 142 reg |= (TCPC_ROLE_CTRL_RP_VAL_3_0 << 143 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 144 break; 145 } 146 147 if (cc == TYPEC_CC_RD) 148 reg |= (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) | 149 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT); 150 else 151 reg |= (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 152 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT); 153 ret = regmap_write(tcpci->regmap, TCPC_ROLE_CTRL, reg); 154 if (ret < 0) 155 return ret; 156 return regmap_write(tcpci->regmap, TCPC_COMMAND, 157 TCPC_CMD_LOOK4CONNECTION); 158 } 159 160 static enum typec_cc_status tcpci_to_typec_cc(unsigned int cc, bool sink) 161 { 162 switch (cc) { 163 case 0x1: 164 return sink ? TYPEC_CC_RP_DEF : TYPEC_CC_RA; 165 case 0x2: 166 return sink ? TYPEC_CC_RP_1_5 : TYPEC_CC_RD; 167 case 0x3: 168 if (sink) 169 return TYPEC_CC_RP_3_0; 170 fallthrough; 171 case 0x0: 172 default: 173 return TYPEC_CC_OPEN; 174 } 175 } 176 177 static int tcpci_get_cc(struct tcpc_dev *tcpc, 178 enum typec_cc_status *cc1, enum typec_cc_status *cc2) 179 { 180 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 181 unsigned int reg; 182 int ret; 183 184 ret = regmap_read(tcpci->regmap, TCPC_CC_STATUS, ®); 185 if (ret < 0) 186 return ret; 187 188 *cc1 = tcpci_to_typec_cc((reg >> TCPC_CC_STATUS_CC1_SHIFT) & 189 TCPC_CC_STATUS_CC1_MASK, 190 reg & TCPC_CC_STATUS_TERM); 191 *cc2 = tcpci_to_typec_cc((reg >> TCPC_CC_STATUS_CC2_SHIFT) & 192 TCPC_CC_STATUS_CC2_MASK, 193 reg & TCPC_CC_STATUS_TERM); 194 195 return 0; 196 } 197 198 static int tcpci_set_polarity(struct tcpc_dev *tcpc, 199 enum typec_cc_polarity polarity) 200 { 201 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 202 unsigned int reg; 203 int ret; 204 enum typec_cc_status cc1, cc2; 205 206 /* Obtain Rp setting from role control */ 207 ret = regmap_read(tcpci->regmap, TCPC_ROLE_CTRL, ®); 208 if (ret < 0) 209 return ret; 210 211 ret = tcpci_get_cc(tcpc, &cc1, &cc2); 212 if (ret < 0) 213 return ret; 214 215 /* 216 * When port has drp toggling enabled, ROLE_CONTROL would only have the initial 217 * terminations for the toggling and does not indicate the final cc 218 * terminations when ConnectionResult is 0 i.e. drp toggling stops and 219 * the connection is resolbed. Infer port role from TCPC_CC_STATUS based on the 220 * terminations seen. The port role is then used to set the cc terminations. 221 */ 222 if (reg & TCPC_ROLE_CTRL_DRP) { 223 /* Disable DRP for the OPEN setting to take effect */ 224 reg = reg & ~TCPC_ROLE_CTRL_DRP; 225 226 if (polarity == TYPEC_POLARITY_CC2) { 227 reg &= ~(TCPC_ROLE_CTRL_CC2_MASK << TCPC_ROLE_CTRL_CC2_SHIFT); 228 /* Local port is source */ 229 if (cc2 == TYPEC_CC_RD) 230 /* Role control would have the Rp setting when DRP was enabled */ 231 reg |= TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT; 232 else 233 reg |= TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT; 234 } else { 235 reg &= ~(TCPC_ROLE_CTRL_CC1_MASK << TCPC_ROLE_CTRL_CC1_SHIFT); 236 /* Local port is source */ 237 if (cc1 == TYPEC_CC_RD) 238 /* Role control would have the Rp setting when DRP was enabled */ 239 reg |= TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT; 240 else 241 reg |= TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT; 242 } 243 } 244 245 if (polarity == TYPEC_POLARITY_CC2) 246 reg |= TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC1_SHIFT; 247 else 248 reg |= TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC2_SHIFT; 249 ret = regmap_write(tcpci->regmap, TCPC_ROLE_CTRL, reg); 250 if (ret < 0) 251 return ret; 252 253 return regmap_write(tcpci->regmap, TCPC_TCPC_CTRL, 254 (polarity == TYPEC_POLARITY_CC2) ? 255 TCPC_TCPC_CTRL_ORIENTATION : 0); 256 } 257 258 static void tcpci_set_partner_usb_comm_capable(struct tcpc_dev *tcpc, bool capable) 259 { 260 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 261 262 if (tcpci->data->set_partner_usb_comm_capable) 263 tcpci->data->set_partner_usb_comm_capable(tcpci, tcpci->data, capable); 264 } 265 266 static int tcpci_set_vconn(struct tcpc_dev *tcpc, bool enable) 267 { 268 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 269 int ret; 270 271 /* Handle vendor set vconn */ 272 if (tcpci->data->set_vconn) { 273 ret = tcpci->data->set_vconn(tcpci, tcpci->data, enable); 274 if (ret < 0) 275 return ret; 276 } 277 278 return regmap_update_bits(tcpci->regmap, TCPC_POWER_CTRL, 279 TCPC_POWER_CTRL_VCONN_ENABLE, 280 enable ? TCPC_POWER_CTRL_VCONN_ENABLE : 0); 281 } 282 283 static int tcpci_enable_auto_vbus_discharge(struct tcpc_dev *dev, bool enable) 284 { 285 struct tcpci *tcpci = tcpc_to_tcpci(dev); 286 int ret; 287 288 ret = regmap_update_bits(tcpci->regmap, TCPC_POWER_CTRL, TCPC_POWER_CTRL_AUTO_DISCHARGE, 289 enable ? TCPC_POWER_CTRL_AUTO_DISCHARGE : 0); 290 return ret; 291 } 292 293 static int tcpci_set_auto_vbus_discharge_threshold(struct tcpc_dev *dev, enum typec_pwr_opmode mode, 294 bool pps_active, u32 requested_vbus_voltage_mv) 295 { 296 struct tcpci *tcpci = tcpc_to_tcpci(dev); 297 unsigned int pwr_ctrl, threshold = 0; 298 int ret; 299 300 /* 301 * Indicates that vbus is going to go away due PR_SWAP, hard reset etc. 302 * Do not discharge vbus here. 303 */ 304 if (requested_vbus_voltage_mv == 0) 305 goto write_thresh; 306 307 ret = regmap_read(tcpci->regmap, TCPC_POWER_CTRL, &pwr_ctrl); 308 if (ret < 0) 309 return ret; 310 311 if (pwr_ctrl & TCPC_FAST_ROLE_SWAP_EN) { 312 /* To prevent disconnect when the source is fast role swap is capable. */ 313 threshold = AUTO_DISCHARGE_DEFAULT_THRESHOLD_MV; 314 } else if (mode == TYPEC_PWR_MODE_PD) { 315 if (pps_active) 316 threshold = (95 * requested_vbus_voltage_mv / 100) - 317 AUTO_DISCHARGE_PD_HEADROOM_MV; 318 else 319 threshold = (95 * requested_vbus_voltage_mv / 100) - 320 AUTO_DISCHARGE_PPS_HEADROOM_MV; 321 } else { 322 /* 3.5V for non-pd sink */ 323 threshold = AUTO_DISCHARGE_DEFAULT_THRESHOLD_MV; 324 } 325 326 threshold = threshold / TCPC_VBUS_SINK_DISCONNECT_THRESH_LSB_MV; 327 328 if (threshold > TCPC_VBUS_SINK_DISCONNECT_THRESH_MAX) 329 return -EINVAL; 330 331 write_thresh: 332 return tcpci_write16(tcpci, TCPC_VBUS_SINK_DISCONNECT_THRESH, threshold); 333 } 334 335 static int tcpci_enable_frs(struct tcpc_dev *dev, bool enable) 336 { 337 struct tcpci *tcpci = tcpc_to_tcpci(dev); 338 int ret; 339 340 /* To prevent disconnect during FRS, set disconnect threshold to 3.5V */ 341 ret = tcpci_write16(tcpci, TCPC_VBUS_SINK_DISCONNECT_THRESH, enable ? 0 : 0x8c); 342 if (ret < 0) 343 return ret; 344 345 ret = regmap_update_bits(tcpci->regmap, TCPC_POWER_CTRL, TCPC_FAST_ROLE_SWAP_EN, enable ? 346 TCPC_FAST_ROLE_SWAP_EN : 0); 347 348 return ret; 349 } 350 351 static void tcpci_frs_sourcing_vbus(struct tcpc_dev *dev) 352 { 353 struct tcpci *tcpci = tcpc_to_tcpci(dev); 354 355 if (tcpci->data->frs_sourcing_vbus) 356 tcpci->data->frs_sourcing_vbus(tcpci, tcpci->data); 357 } 358 359 static int tcpci_set_bist_data(struct tcpc_dev *tcpc, bool enable) 360 { 361 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 362 363 return regmap_update_bits(tcpci->regmap, TCPC_TCPC_CTRL, TCPC_TCPC_CTRL_BIST_TM, 364 enable ? TCPC_TCPC_CTRL_BIST_TM : 0); 365 } 366 367 static int tcpci_set_roles(struct tcpc_dev *tcpc, bool attached, 368 enum typec_role role, enum typec_data_role data) 369 { 370 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 371 unsigned int reg; 372 int ret; 373 374 reg = PD_REV20 << TCPC_MSG_HDR_INFO_REV_SHIFT; 375 if (role == TYPEC_SOURCE) 376 reg |= TCPC_MSG_HDR_INFO_PWR_ROLE; 377 if (data == TYPEC_HOST) 378 reg |= TCPC_MSG_HDR_INFO_DATA_ROLE; 379 ret = regmap_write(tcpci->regmap, TCPC_MSG_HDR_INFO, reg); 380 if (ret < 0) 381 return ret; 382 383 return 0; 384 } 385 386 static int tcpci_set_pd_rx(struct tcpc_dev *tcpc, bool enable) 387 { 388 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 389 unsigned int reg = 0; 390 int ret; 391 392 if (enable) 393 reg = TCPC_RX_DETECT_SOP | TCPC_RX_DETECT_HARD_RESET; 394 ret = regmap_write(tcpci->regmap, TCPC_RX_DETECT, reg); 395 if (ret < 0) 396 return ret; 397 398 return 0; 399 } 400 401 static int tcpci_get_vbus(struct tcpc_dev *tcpc) 402 { 403 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 404 unsigned int reg; 405 int ret; 406 407 ret = regmap_read(tcpci->regmap, TCPC_POWER_STATUS, ®); 408 if (ret < 0) 409 return ret; 410 411 return !!(reg & TCPC_POWER_STATUS_VBUS_PRES); 412 } 413 414 static bool tcpci_is_vbus_vsafe0v(struct tcpc_dev *tcpc) 415 { 416 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 417 unsigned int reg; 418 int ret; 419 420 ret = regmap_read(tcpci->regmap, TCPC_EXTENDED_STATUS, ®); 421 if (ret < 0) 422 return false; 423 424 return !!(reg & TCPC_EXTENDED_STATUS_VSAFE0V); 425 } 426 427 static int tcpci_set_vbus(struct tcpc_dev *tcpc, bool source, bool sink) 428 { 429 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 430 int ret; 431 432 if (tcpci->data->set_vbus) { 433 ret = tcpci->data->set_vbus(tcpci, tcpci->data, source, sink); 434 /* Bypass when ret > 0 */ 435 if (ret != 0) 436 return ret < 0 ? ret : 0; 437 } 438 439 /* Disable both source and sink first before enabling anything */ 440 441 if (!source) { 442 ret = regmap_write(tcpci->regmap, TCPC_COMMAND, 443 TCPC_CMD_DISABLE_SRC_VBUS); 444 if (ret < 0) 445 return ret; 446 } 447 448 if (!sink) { 449 ret = regmap_write(tcpci->regmap, TCPC_COMMAND, 450 TCPC_CMD_DISABLE_SINK_VBUS); 451 if (ret < 0) 452 return ret; 453 } 454 455 if (source) { 456 ret = regmap_write(tcpci->regmap, TCPC_COMMAND, 457 TCPC_CMD_SRC_VBUS_DEFAULT); 458 if (ret < 0) 459 return ret; 460 } 461 462 if (sink) { 463 ret = regmap_write(tcpci->regmap, TCPC_COMMAND, 464 TCPC_CMD_SINK_VBUS); 465 if (ret < 0) 466 return ret; 467 } 468 469 return 0; 470 } 471 472 static int tcpci_pd_transmit(struct tcpc_dev *tcpc, enum tcpm_transmit_type type, 473 const struct pd_message *msg, unsigned int negotiated_rev) 474 { 475 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 476 u16 header = msg ? le16_to_cpu(msg->header) : 0; 477 unsigned int reg, cnt; 478 int ret; 479 480 cnt = msg ? pd_header_cnt(header) * 4 : 0; 481 /** 482 * TCPCI spec forbids direct access of TCPC_TX_DATA. 483 * But, since some of the chipsets offer this capability, 484 * it's fair to support both. 485 */ 486 if (tcpci->data->TX_BUF_BYTE_x_hidden) { 487 u8 buf[TCPC_TRANSMIT_BUFFER_MAX_LEN] = {0,}; 488 u8 pos = 0; 489 490 /* Payload + header + TCPC_TX_BYTE_CNT */ 491 buf[pos++] = cnt + 2; 492 493 if (msg) 494 memcpy(&buf[pos], &msg->header, sizeof(msg->header)); 495 496 pos += sizeof(header); 497 498 if (cnt > 0) 499 memcpy(&buf[pos], msg->payload, cnt); 500 501 pos += cnt; 502 ret = regmap_raw_write(tcpci->regmap, TCPC_TX_BYTE_CNT, buf, pos); 503 if (ret < 0) 504 return ret; 505 } else { 506 ret = regmap_write(tcpci->regmap, TCPC_TX_BYTE_CNT, cnt + 2); 507 if (ret < 0) 508 return ret; 509 510 ret = tcpci_write16(tcpci, TCPC_TX_HDR, header); 511 if (ret < 0) 512 return ret; 513 514 if (cnt > 0) { 515 ret = regmap_raw_write(tcpci->regmap, TCPC_TX_DATA, &msg->payload, cnt); 516 if (ret < 0) 517 return ret; 518 } 519 } 520 521 /* nRetryCount is 3 in PD2.0 spec where 2 in PD3.0 spec */ 522 reg = ((negotiated_rev > PD_REV20 ? PD_RETRY_COUNT_3_0_OR_HIGHER : PD_RETRY_COUNT_DEFAULT) 523 << TCPC_TRANSMIT_RETRY_SHIFT) | (type << TCPC_TRANSMIT_TYPE_SHIFT); 524 ret = regmap_write(tcpci->regmap, TCPC_TRANSMIT, reg); 525 if (ret < 0) 526 return ret; 527 528 return 0; 529 } 530 531 static int tcpci_init(struct tcpc_dev *tcpc) 532 { 533 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 534 unsigned long timeout = jiffies + msecs_to_jiffies(2000); /* XXX */ 535 unsigned int reg; 536 int ret; 537 538 while (time_before_eq(jiffies, timeout)) { 539 ret = regmap_read(tcpci->regmap, TCPC_POWER_STATUS, ®); 540 if (ret < 0) 541 return ret; 542 if (!(reg & TCPC_POWER_STATUS_UNINIT)) 543 break; 544 usleep_range(10000, 20000); 545 } 546 if (time_after(jiffies, timeout)) 547 return -ETIMEDOUT; 548 549 /* Handle vendor init */ 550 if (tcpci->data->init) { 551 ret = tcpci->data->init(tcpci, tcpci->data); 552 if (ret < 0) 553 return ret; 554 } 555 556 /* Clear all events */ 557 ret = tcpci_write16(tcpci, TCPC_ALERT, 0xffff); 558 if (ret < 0) 559 return ret; 560 561 if (tcpci->controls_vbus) 562 reg = TCPC_POWER_STATUS_VBUS_PRES; 563 else 564 reg = 0; 565 ret = regmap_write(tcpci->regmap, TCPC_POWER_STATUS_MASK, reg); 566 if (ret < 0) 567 return ret; 568 569 /* Enable Vbus detection */ 570 ret = regmap_write(tcpci->regmap, TCPC_COMMAND, 571 TCPC_CMD_ENABLE_VBUS_DETECT); 572 if (ret < 0) 573 return ret; 574 575 reg = TCPC_ALERT_TX_SUCCESS | TCPC_ALERT_TX_FAILED | 576 TCPC_ALERT_TX_DISCARDED | TCPC_ALERT_RX_STATUS | 577 TCPC_ALERT_RX_HARD_RST | TCPC_ALERT_CC_STATUS; 578 if (tcpci->controls_vbus) 579 reg |= TCPC_ALERT_POWER_STATUS; 580 /* Enable VSAFE0V status interrupt when detecting VSAFE0V is supported */ 581 if (tcpci->data->vbus_vsafe0v) { 582 reg |= TCPC_ALERT_EXTENDED_STATUS; 583 ret = regmap_write(tcpci->regmap, TCPC_EXTENDED_STATUS_MASK, 584 TCPC_EXTENDED_STATUS_VSAFE0V); 585 if (ret < 0) 586 return ret; 587 } 588 return tcpci_write16(tcpci, TCPC_ALERT_MASK, reg); 589 } 590 591 irqreturn_t tcpci_irq(struct tcpci *tcpci) 592 { 593 u16 status; 594 int ret; 595 unsigned int raw; 596 597 tcpci_read16(tcpci, TCPC_ALERT, &status); 598 599 /* 600 * Clear alert status for everything except RX_STATUS, which shouldn't 601 * be cleared until we have successfully retrieved message. 602 */ 603 if (status & ~TCPC_ALERT_RX_STATUS) 604 tcpci_write16(tcpci, TCPC_ALERT, 605 status & ~TCPC_ALERT_RX_STATUS); 606 607 if (status & TCPC_ALERT_CC_STATUS) 608 tcpm_cc_change(tcpci->port); 609 610 if (status & TCPC_ALERT_POWER_STATUS) { 611 regmap_read(tcpci->regmap, TCPC_POWER_STATUS_MASK, &raw); 612 /* 613 * If power status mask has been reset, then the TCPC 614 * has reset. 615 */ 616 if (raw == 0xff) 617 tcpm_tcpc_reset(tcpci->port); 618 else 619 tcpm_vbus_change(tcpci->port); 620 } 621 622 if (status & TCPC_ALERT_RX_STATUS) { 623 struct pd_message msg; 624 unsigned int cnt, payload_cnt; 625 u16 header; 626 627 regmap_read(tcpci->regmap, TCPC_RX_BYTE_CNT, &cnt); 628 /* 629 * 'cnt' corresponds to READABLE_BYTE_COUNT in section 4.4.14 630 * of the TCPCI spec [Rev 2.0 Ver 1.0 October 2017] and is 631 * defined in table 4-36 as one greater than the number of 632 * bytes received. And that number includes the header. So: 633 */ 634 if (cnt > 3) 635 payload_cnt = cnt - (1 + sizeof(msg.header)); 636 else 637 payload_cnt = 0; 638 639 tcpci_read16(tcpci, TCPC_RX_HDR, &header); 640 msg.header = cpu_to_le16(header); 641 642 if (WARN_ON(payload_cnt > sizeof(msg.payload))) 643 payload_cnt = sizeof(msg.payload); 644 645 if (payload_cnt > 0) 646 regmap_raw_read(tcpci->regmap, TCPC_RX_DATA, 647 &msg.payload, payload_cnt); 648 649 /* Read complete, clear RX status alert bit */ 650 tcpci_write16(tcpci, TCPC_ALERT, TCPC_ALERT_RX_STATUS); 651 652 tcpm_pd_receive(tcpci->port, &msg); 653 } 654 655 if (status & TCPC_ALERT_EXTENDED_STATUS) { 656 ret = regmap_read(tcpci->regmap, TCPC_EXTENDED_STATUS, &raw); 657 if (!ret && (raw & TCPC_EXTENDED_STATUS_VSAFE0V)) 658 tcpm_vbus_change(tcpci->port); 659 } 660 661 if (status & TCPC_ALERT_RX_HARD_RST) 662 tcpm_pd_hard_reset(tcpci->port); 663 664 if (status & TCPC_ALERT_TX_SUCCESS) 665 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_SUCCESS); 666 else if (status & TCPC_ALERT_TX_DISCARDED) 667 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_DISCARDED); 668 else if (status & TCPC_ALERT_TX_FAILED) 669 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_FAILED); 670 671 return IRQ_HANDLED; 672 } 673 EXPORT_SYMBOL_GPL(tcpci_irq); 674 675 static irqreturn_t _tcpci_irq(int irq, void *dev_id) 676 { 677 struct tcpci_chip *chip = dev_id; 678 679 return tcpci_irq(chip->tcpci); 680 } 681 682 static const struct regmap_config tcpci_regmap_config = { 683 .reg_bits = 8, 684 .val_bits = 8, 685 686 .max_register = 0x7F, /* 0x80 .. 0xFF are vendor defined */ 687 }; 688 689 static int tcpci_parse_config(struct tcpci *tcpci) 690 { 691 tcpci->controls_vbus = true; /* XXX */ 692 693 tcpci->tcpc.fwnode = device_get_named_child_node(tcpci->dev, 694 "connector"); 695 if (!tcpci->tcpc.fwnode) { 696 dev_err(tcpci->dev, "Can't find connector node.\n"); 697 return -EINVAL; 698 } 699 700 return 0; 701 } 702 703 struct tcpci *tcpci_register_port(struct device *dev, struct tcpci_data *data) 704 { 705 struct tcpci *tcpci; 706 int err; 707 708 tcpci = devm_kzalloc(dev, sizeof(*tcpci), GFP_KERNEL); 709 if (!tcpci) 710 return ERR_PTR(-ENOMEM); 711 712 tcpci->dev = dev; 713 tcpci->data = data; 714 tcpci->regmap = data->regmap; 715 716 tcpci->tcpc.init = tcpci_init; 717 tcpci->tcpc.get_vbus = tcpci_get_vbus; 718 tcpci->tcpc.set_vbus = tcpci_set_vbus; 719 tcpci->tcpc.set_cc = tcpci_set_cc; 720 tcpci->tcpc.get_cc = tcpci_get_cc; 721 tcpci->tcpc.set_polarity = tcpci_set_polarity; 722 tcpci->tcpc.set_vconn = tcpci_set_vconn; 723 tcpci->tcpc.start_toggling = tcpci_start_toggling; 724 725 tcpci->tcpc.set_pd_rx = tcpci_set_pd_rx; 726 tcpci->tcpc.set_roles = tcpci_set_roles; 727 tcpci->tcpc.pd_transmit = tcpci_pd_transmit; 728 tcpci->tcpc.set_bist_data = tcpci_set_bist_data; 729 tcpci->tcpc.enable_frs = tcpci_enable_frs; 730 tcpci->tcpc.frs_sourcing_vbus = tcpci_frs_sourcing_vbus; 731 tcpci->tcpc.set_partner_usb_comm_capable = tcpci_set_partner_usb_comm_capable; 732 733 if (tcpci->data->auto_discharge_disconnect) { 734 tcpci->tcpc.enable_auto_vbus_discharge = tcpci_enable_auto_vbus_discharge; 735 tcpci->tcpc.set_auto_vbus_discharge_threshold = 736 tcpci_set_auto_vbus_discharge_threshold; 737 regmap_update_bits(tcpci->regmap, TCPC_POWER_CTRL, TCPC_POWER_CTRL_BLEED_DISCHARGE, 738 TCPC_POWER_CTRL_BLEED_DISCHARGE); 739 } 740 741 if (tcpci->data->vbus_vsafe0v) 742 tcpci->tcpc.is_vbus_vsafe0v = tcpci_is_vbus_vsafe0v; 743 744 err = tcpci_parse_config(tcpci); 745 if (err < 0) 746 return ERR_PTR(err); 747 748 tcpci->port = tcpm_register_port(tcpci->dev, &tcpci->tcpc); 749 if (IS_ERR(tcpci->port)) 750 return ERR_CAST(tcpci->port); 751 752 return tcpci; 753 } 754 EXPORT_SYMBOL_GPL(tcpci_register_port); 755 756 void tcpci_unregister_port(struct tcpci *tcpci) 757 { 758 tcpm_unregister_port(tcpci->port); 759 } 760 EXPORT_SYMBOL_GPL(tcpci_unregister_port); 761 762 static int tcpci_probe(struct i2c_client *client, 763 const struct i2c_device_id *i2c_id) 764 { 765 struct tcpci_chip *chip; 766 int err; 767 u16 val = 0; 768 769 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); 770 if (!chip) 771 return -ENOMEM; 772 773 chip->data.regmap = devm_regmap_init_i2c(client, &tcpci_regmap_config); 774 if (IS_ERR(chip->data.regmap)) 775 return PTR_ERR(chip->data.regmap); 776 777 i2c_set_clientdata(client, chip); 778 779 /* Disable chip interrupts before requesting irq */ 780 err = regmap_raw_write(chip->data.regmap, TCPC_ALERT_MASK, &val, 781 sizeof(u16)); 782 if (err < 0) 783 return err; 784 785 chip->tcpci = tcpci_register_port(&client->dev, &chip->data); 786 if (IS_ERR(chip->tcpci)) 787 return PTR_ERR(chip->tcpci); 788 789 err = devm_request_threaded_irq(&client->dev, client->irq, NULL, 790 _tcpci_irq, 791 IRQF_ONESHOT | IRQF_TRIGGER_LOW, 792 dev_name(&client->dev), chip); 793 if (err < 0) { 794 tcpci_unregister_port(chip->tcpci); 795 return err; 796 } 797 798 return 0; 799 } 800 801 static int tcpci_remove(struct i2c_client *client) 802 { 803 struct tcpci_chip *chip = i2c_get_clientdata(client); 804 int err; 805 806 /* Disable chip interrupts before unregistering port */ 807 err = tcpci_write16(chip->tcpci, TCPC_ALERT_MASK, 0); 808 if (err < 0) 809 return err; 810 811 tcpci_unregister_port(chip->tcpci); 812 813 return 0; 814 } 815 816 static const struct i2c_device_id tcpci_id[] = { 817 { "tcpci", 0 }, 818 { } 819 }; 820 MODULE_DEVICE_TABLE(i2c, tcpci_id); 821 822 #ifdef CONFIG_OF 823 static const struct of_device_id tcpci_of_match[] = { 824 { .compatible = "nxp,ptn5110", }, 825 {}, 826 }; 827 MODULE_DEVICE_TABLE(of, tcpci_of_match); 828 #endif 829 830 static struct i2c_driver tcpci_i2c_driver = { 831 .driver = { 832 .name = "tcpci", 833 .of_match_table = of_match_ptr(tcpci_of_match), 834 }, 835 .probe = tcpci_probe, 836 .remove = tcpci_remove, 837 .id_table = tcpci_id, 838 }; 839 module_i2c_driver(tcpci_i2c_driver); 840 841 MODULE_DESCRIPTION("USB Type-C Port Controller Interface driver"); 842 MODULE_LICENSE("GPL"); 843