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 <dm.h> 9 #include <i2c.h> 10 #include <asm/gpio.h> 11 #include <power/power_delivery/pd.h> 12 #include <power/power_delivery/tcpm.h> 13 #include <power/power_delivery/typec.h> 14 #include <power/power_delivery/power_delivery.h> 15 16 #include "tcpci.h" 17 18 #define PD_RETRY_COUNT 3 19 20 #define tcpc_presenting_cc1_rd(reg) \ 21 (!(TCPC_ROLE_CTRL_DRP & (reg)) && \ 22 (((reg) & (TCPC_ROLE_CTRL_CC1_MASK << TCPC_ROLE_CTRL_CC1_SHIFT)) == \ 23 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT))) 24 #define tcpc_presenting_cc2_rd(reg) \ 25 (!(TCPC_ROLE_CTRL_DRP & (reg)) && \ 26 (((reg) & (TCPC_ROLE_CTRL_CC2_MASK << TCPC_ROLE_CTRL_CC2_SHIFT)) == \ 27 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT))) 28 29 struct tcpci { 30 struct udevice *dev; 31 32 struct tcpm_port *port; 33 34 bool controls_vbus; 35 bool gpio_cc_int_present; 36 37 struct tcpc_dev tcpc; 38 struct tcpci_data *data; 39 struct gpio_desc gpio_cc_int; 40 }; 41 42 struct tcpci_chip { 43 struct udevice *udev; 44 struct tcpci *tcpci; 45 struct tcpci_data data; 46 }; 47 48 static inline struct tcpci *tcpc_to_tcpci(struct tcpc_dev *tcpc) 49 { 50 return container_of(tcpc, struct tcpci, tcpc); 51 } 52 53 static int tcpci_read16(struct tcpci *tcpci, unsigned int reg, u16 *val) 54 { 55 int ret = 0; 56 u8 buffer[2]; 57 58 ret = dm_i2c_read(tcpci->dev, reg, buffer, 2); 59 if (ret) { 60 printf("%s: cannot read %02x, ret=%d\n", 61 __func__, reg, ret); 62 return ret; 63 } 64 65 *val = ((buffer[1] << 8) & 0xFF00) | (buffer[0] & 0xFF); 66 67 return ret; 68 } 69 70 static int tcpci_block_read(struct tcpci *tcpci, unsigned int reg, 71 u8 *data, u8 length) 72 { 73 int ret = 0; 74 75 ret = dm_i2c_read(tcpci->dev, reg, data, length); 76 if (ret) 77 printf("%s: cannot block read 0x%02x, len=%d, ret=%d\n", 78 __func__, reg, length, ret); 79 80 return ret; 81 } 82 83 static int tcpci_write16(struct tcpci *tcpci, unsigned int reg, u16 val) 84 { 85 int ret = 0; 86 u8 buffer[2]; 87 88 buffer[0] = val & 0xFF; 89 buffer[1] = (val >> 8) & 0xFF; 90 ret = dm_i2c_write(tcpci->dev, reg, buffer, 2); 91 if (ret) 92 printf("%s: cannot write 0x%02x, ret=%d\n", 93 __func__, reg, ret); 94 95 return ret; 96 } 97 98 static int tcpci_block_write(struct tcpci *tcpci, unsigned int reg, 99 u8 *data, u8 length) 100 { 101 int ret = 0; 102 103 ret = dm_i2c_write(tcpci->dev, reg, data, length); 104 if (ret) 105 printf("%s: cannot block write 0x%02x, len=%d, ret=%d\n", 106 __func__, reg, length, ret); 107 108 return ret; 109 } 110 111 static int tcpci_set_cc(struct tcpc_dev *tcpc, enum typec_cc_status cc) 112 { 113 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 114 unsigned int reg; 115 int ret; 116 117 switch (cc) { 118 case TYPEC_CC_RA: 119 reg = (TCPC_ROLE_CTRL_CC_RA << TCPC_ROLE_CTRL_CC1_SHIFT) | 120 (TCPC_ROLE_CTRL_CC_RA << TCPC_ROLE_CTRL_CC2_SHIFT); 121 break; 122 case TYPEC_CC_RD: 123 reg = (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) | 124 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT); 125 break; 126 case TYPEC_CC_RP_DEF: 127 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 128 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) | 129 (TCPC_ROLE_CTRL_RP_VAL_DEF << 130 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 131 break; 132 case TYPEC_CC_RP_1_5: 133 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 134 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) | 135 (TCPC_ROLE_CTRL_RP_VAL_1_5 << 136 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 137 break; 138 case TYPEC_CC_RP_3_0: 139 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 140 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) | 141 (TCPC_ROLE_CTRL_RP_VAL_3_0 << 142 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 143 break; 144 case TYPEC_CC_OPEN: 145 default: 146 reg = (TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC1_SHIFT) | 147 (TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC2_SHIFT); 148 break; 149 } 150 151 ret = dm_i2c_reg_write(tcpci->dev, TCPC_ROLE_CTRL, reg); 152 if (ret) 153 return ret; 154 155 return 0; 156 } 157 158 static int tcpci_start_toggling(struct tcpc_dev *tcpc, 159 enum typec_port_type port_type, 160 enum typec_cc_status cc) 161 { 162 int ret; 163 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 164 unsigned int reg = TCPC_ROLE_CTRL_DRP; 165 166 if (port_type != TYPEC_PORT_DRP) 167 return -EOPNOTSUPP; 168 169 /* Handle vendor drp toggling */ 170 if (tcpci->data->start_drp_toggling) { 171 ret = tcpci->data->start_drp_toggling(tcpci, tcpci->data, cc); 172 if (ret < 0) 173 return ret; 174 } 175 176 switch (cc) { 177 default: 178 case TYPEC_CC_RP_DEF: 179 reg |= (TCPC_ROLE_CTRL_RP_VAL_DEF << 180 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 181 break; 182 case TYPEC_CC_RP_1_5: 183 reg |= (TCPC_ROLE_CTRL_RP_VAL_1_5 << 184 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 185 break; 186 case TYPEC_CC_RP_3_0: 187 reg |= (TCPC_ROLE_CTRL_RP_VAL_3_0 << 188 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 189 break; 190 } 191 192 if (cc == TYPEC_CC_RD) 193 reg |= (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) | 194 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT); 195 else 196 reg |= (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 197 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT); 198 ret = dm_i2c_reg_write(tcpci->dev, TCPC_ROLE_CTRL, reg); 199 if (ret < 0) 200 return ret; 201 return dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND, 202 TCPC_CMD_LOOK4CONNECTION); 203 } 204 205 static enum typec_cc_status tcpci_to_typec_cc(unsigned int cc, bool sink) 206 { 207 switch (cc) { 208 case 0x1: 209 return sink ? TYPEC_CC_RP_DEF : TYPEC_CC_RA; 210 case 0x2: 211 return sink ? TYPEC_CC_RP_1_5 : TYPEC_CC_RD; 212 case 0x3: 213 if (sink) 214 return TYPEC_CC_RP_3_0; 215 /* fall through */ 216 case 0x0: 217 default: 218 return TYPEC_CC_OPEN; 219 } 220 } 221 222 static int tcpci_get_cc(struct tcpc_dev *tcpc, 223 enum typec_cc_status *cc1, enum typec_cc_status *cc2) 224 { 225 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 226 unsigned int reg, role_control; 227 228 role_control = dm_i2c_reg_read(tcpci->dev, TCPC_ROLE_CTRL); 229 if (role_control < 0) 230 return role_control; 231 232 reg = dm_i2c_reg_read(tcpci->dev, TCPC_CC_STATUS); 233 if (reg < 0) 234 return reg; 235 236 *cc1 = tcpci_to_typec_cc((reg >> TCPC_CC_STATUS_CC1_SHIFT) & 237 TCPC_CC_STATUS_CC1_MASK, 238 reg & TCPC_CC_STATUS_TERM || 239 tcpc_presenting_cc1_rd(role_control)); 240 *cc2 = tcpci_to_typec_cc((reg >> TCPC_CC_STATUS_CC2_SHIFT) & 241 TCPC_CC_STATUS_CC2_MASK, 242 reg & TCPC_CC_STATUS_TERM || 243 tcpc_presenting_cc2_rd(role_control)); 244 245 return 0; 246 } 247 248 static int tcpci_set_polarity(struct tcpc_dev *tcpc, 249 enum typec_cc_polarity polarity) 250 { 251 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 252 unsigned int reg; 253 int ret; 254 enum typec_cc_status cc1, cc2; 255 256 /* Obtain Rp setting from role control */ 257 reg = dm_i2c_reg_read(tcpci->dev, TCPC_ROLE_CTRL); 258 if (reg < 0) 259 return reg; 260 261 ret = tcpci_get_cc(tcpc, &cc1, &cc2); 262 if (ret < 0) 263 return ret; 264 265 /* 266 * When port has drp toggling enabled, ROLE_CONTROL would only have the initial 267 * terminations for the toggling and does not indicate the final cc 268 * terminations when ConnectionResult is 0 i.e. drp toggling stops and 269 * the connection is resolbed. Infer port role from TCPC_CC_STATUS based on the 270 * terminations seen. The port role is then used to set the cc terminations. 271 */ 272 if (reg & TCPC_ROLE_CTRL_DRP) { 273 /* Disable DRP for the OPEN setting to take effect */ 274 reg = reg & ~TCPC_ROLE_CTRL_DRP; 275 276 if (polarity == TYPEC_POLARITY_CC2) { 277 reg &= ~(TCPC_ROLE_CTRL_CC2_MASK << TCPC_ROLE_CTRL_CC2_SHIFT); 278 /* Local port is source */ 279 if (cc2 == TYPEC_CC_RD) 280 /* Role control would have the Rp setting when DRP was enabled */ 281 reg |= TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT; 282 else 283 reg |= TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT; 284 } else { 285 reg &= ~(TCPC_ROLE_CTRL_CC1_MASK << TCPC_ROLE_CTRL_CC1_SHIFT); 286 /* Local port is source */ 287 if (cc1 == TYPEC_CC_RD) 288 /* Role control would have the Rp setting when DRP was enabled */ 289 reg |= TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT; 290 else 291 reg |= TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT; 292 } 293 } 294 295 if (polarity == TYPEC_POLARITY_CC2) 296 reg |= TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC1_SHIFT; 297 else 298 reg |= TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC2_SHIFT; 299 ret = dm_i2c_reg_write(tcpci->dev, TCPC_ROLE_CTRL, reg); 300 if (ret < 0) 301 return ret; 302 303 return dm_i2c_reg_write(tcpci->dev, TCPC_TCPC_CTRL, 304 (polarity == TYPEC_POLARITY_CC2) ? 305 TCPC_TCPC_CTRL_ORIENTATION : 0); 306 } 307 308 static int tcpci_set_vconn(struct tcpc_dev *tcpc, bool enable) 309 { 310 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 311 int ret; 312 unsigned int reg; 313 314 /* Handle vendor set vconn */ 315 if (tcpci->data->set_vconn) { 316 ret = tcpci->data->set_vconn(tcpci, tcpci->data, enable); 317 if (ret < 0) 318 return ret; 319 } 320 321 reg = dm_i2c_reg_read(tcpci->dev, TCPC_POWER_CTRL); 322 if (reg) 323 return reg; 324 reg &= ~TCPC_POWER_CTRL_VCONN_ENABLE; 325 reg |= enable ? TCPC_POWER_CTRL_VCONN_ENABLE : 0; 326 return dm_i2c_reg_write(tcpci->dev, TCPC_POWER_CTRL, reg); 327 } 328 329 static int tcpci_set_roles(struct tcpc_dev *tcpc, bool attached, 330 enum typec_role role, enum typec_data_role data) 331 { 332 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 333 unsigned int reg; 334 int ret; 335 336 reg = PD_REV20 << TCPC_MSG_HDR_INFO_REV_SHIFT; 337 if (role == TYPEC_SOURCE) 338 reg |= TCPC_MSG_HDR_INFO_PWR_ROLE; 339 if (data == TYPEC_HOST) 340 reg |= TCPC_MSG_HDR_INFO_DATA_ROLE; 341 ret = dm_i2c_reg_write(tcpci->dev, TCPC_MSG_HDR_INFO, reg); 342 if (ret < 0) 343 return ret; 344 345 return 0; 346 } 347 348 static int tcpci_set_pd_rx(struct tcpc_dev *tcpc, bool enable) 349 { 350 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 351 unsigned int reg = 0; 352 int ret; 353 354 if (enable) 355 reg = TCPC_RX_DETECT_SOP | TCPC_RX_DETECT_HARD_RESET; 356 ret = dm_i2c_reg_write(tcpci->dev, TCPC_RX_DETECT, reg); 357 if (ret < 0) 358 return ret; 359 360 return 0; 361 } 362 363 static int tcpci_get_vbus(struct tcpc_dev *tcpc) 364 { 365 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 366 unsigned int reg; 367 368 reg = dm_i2c_reg_read(tcpci->dev, TCPC_POWER_STATUS); 369 if (reg < 0) 370 return reg; 371 372 return !!(reg & TCPC_POWER_STATUS_VBUS_PRES); 373 } 374 375 static int tcpci_set_vbus(struct tcpc_dev *tcpc, bool source, bool sink) 376 { 377 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 378 int ret; 379 380 /* Disable both source and sink first before enabling anything */ 381 382 if (!source) { 383 ret = dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND, 384 TCPC_CMD_DISABLE_SRC_VBUS); 385 if (ret < 0) 386 return ret; 387 } 388 389 if (!sink) { 390 ret = dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND, 391 TCPC_CMD_DISABLE_SINK_VBUS); 392 if (ret < 0) 393 return ret; 394 } 395 396 if (source) { 397 ret = dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND, 398 TCPC_CMD_SRC_VBUS_DEFAULT); 399 if (ret < 0) 400 return ret; 401 } 402 403 if (sink) { 404 ret = dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND, 405 TCPC_CMD_SINK_VBUS); 406 if (ret < 0) 407 return ret; 408 } 409 410 return 0; 411 } 412 413 static int tcpci_pd_transmit(struct tcpc_dev *tcpc, 414 enum tcpm_transmit_type type, 415 const struct pd_message *msg, 416 unsigned int negotiated_rev) 417 { 418 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 419 u16 header = msg ? le16_to_cpu(msg->header) : 0; 420 unsigned int reg, cnt; 421 int ret; 422 423 cnt = msg ? pd_header_cnt(header) * 4 : 0; 424 ret = dm_i2c_reg_write(tcpci->dev, TCPC_TX_BYTE_CNT, cnt + 2); 425 if (ret < 0) 426 return ret; 427 428 ret = tcpci_write16(tcpci, TCPC_TX_HDR, header); 429 if (ret < 0) 430 return ret; 431 432 if (cnt > 0) { 433 ret = tcpci_block_write(tcpci, TCPC_TX_DATA, 434 (u8 *)&msg->payload, cnt); 435 if (ret < 0) 436 return ret; 437 } 438 439 reg = (PD_RETRY_COUNT << TCPC_TRANSMIT_RETRY_SHIFT) | 440 (type << TCPC_TRANSMIT_TYPE_SHIFT); 441 ret = dm_i2c_reg_write(tcpci->dev, TCPC_TRANSMIT, reg); 442 if (ret < 0) 443 return ret; 444 445 return 0; 446 } 447 448 static int tcpci_init(struct tcpc_dev *tcpc) 449 { 450 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 451 unsigned int timeout = 0; /* XXX */ 452 unsigned int reg; 453 int ret; 454 455 while (timeout < 100) { 456 reg = dm_i2c_reg_read(tcpci->dev, TCPC_POWER_STATUS); 457 if (reg < 0) 458 return reg; 459 if (!(reg & TCPC_POWER_STATUS_UNINIT)) 460 break; 461 timeout++; 462 udelay(200); 463 } 464 if (timeout >= 100) 465 return -ETIMEDOUT; 466 467 /* Handle vendor init */ 468 if (tcpci->data->init) { 469 ret = tcpci->data->init(tcpci, tcpci->data); 470 if (ret < 0) 471 return ret; 472 } 473 474 /* Clear all events */ 475 ret = tcpci_write16(tcpci, TCPC_ALERT, 0xffff); 476 if (ret < 0) 477 return ret; 478 479 if (tcpci->controls_vbus) 480 reg = TCPC_POWER_STATUS_VBUS_PRES; 481 else 482 reg = 0; 483 ret = dm_i2c_reg_write(tcpci->dev, TCPC_POWER_STATUS_MASK, reg); 484 if (ret < 0) 485 return ret; 486 487 /* Enable Vbus detection */ 488 ret = dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND, 489 TCPC_CMD_ENABLE_VBUS_DETECT); 490 if (ret < 0) 491 return ret; 492 493 reg = TCPC_ALERT_TX_SUCCESS | TCPC_ALERT_TX_FAILED | 494 TCPC_ALERT_TX_DISCARDED | TCPC_ALERT_RX_STATUS | 495 TCPC_ALERT_RX_HARD_RST | TCPC_ALERT_CC_STATUS; 496 if (tcpci->controls_vbus) 497 reg |= TCPC_ALERT_POWER_STATUS; 498 return tcpci_write16(tcpci, TCPC_ALERT_MASK, reg); 499 } 500 501 static void tcpci_poll_event(struct tcpc_dev *tcpc) 502 { 503 u16 status; 504 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 505 506 if (tcpci->gpio_cc_int_present) 507 if (!dm_gpio_get_value(&tcpci->gpio_cc_int)) 508 return; 509 510 tcpci_read16(tcpci, TCPC_ALERT, &status); 511 512 /* 513 * Clear alert status for everything except RX_STATUS, which shouldn't 514 * be cleared until we have successfully retrieved message. 515 */ 516 if (status & ~TCPC_ALERT_RX_STATUS) 517 tcpci_write16(tcpci, TCPC_ALERT, 518 status & ~TCPC_ALERT_RX_STATUS); 519 520 if (status & TCPC_ALERT_CC_STATUS) 521 tcpm_cc_change(tcpci->port); 522 523 if (status & TCPC_ALERT_POWER_STATUS) { 524 unsigned int reg; 525 526 reg = dm_i2c_reg_read(tcpci->dev, TCPC_POWER_STATUS_MASK); 527 if (reg < 0) 528 return; 529 530 /* 531 * If power status mask has been reset, then the TCPC 532 * has reset. 533 */ 534 if (reg == 0xff) 535 tcpm_tcpc_reset(tcpci->port); 536 else 537 tcpm_vbus_change(tcpci->port); 538 } 539 540 if (status & TCPC_ALERT_RX_STATUS) { 541 struct pd_message msg; 542 unsigned int cnt, payload_cnt; 543 u16 header; 544 545 cnt = dm_i2c_reg_read(tcpci->dev, TCPC_RX_BYTE_CNT); 546 if (cnt < 0) 547 return; 548 /* 549 * 'cnt' corresponds to READABLE_BYTE_COUNT in section 4.4.14 550 * of the TCPCI spec [Rev 2.0 Ver 1.0 October 2017] and is 551 * defined in table 4-36 as one greater than the number of 552 * bytes received. And that number includes the header. So: 553 */ 554 if (cnt > 3) 555 payload_cnt = cnt - (1 + sizeof(msg.header)); 556 else 557 payload_cnt = 0; 558 559 tcpci_read16(tcpci, TCPC_RX_HDR, &header); 560 msg.header = cpu_to_le16(header); 561 562 if (WARN_ON(payload_cnt > sizeof(msg.payload))) 563 payload_cnt = sizeof(msg.payload); 564 565 if (payload_cnt > 0) 566 tcpci_block_read(tcpci, TCPC_RX_DATA, 567 (u8 *)&msg.payload, payload_cnt); 568 569 /* Read complete, clear RX status alert bit */ 570 tcpci_write16(tcpci, TCPC_ALERT, TCPC_ALERT_RX_STATUS); 571 572 tcpm_pd_receive(tcpci->port, &msg); 573 } 574 575 if (status & TCPC_ALERT_RX_HARD_RST) 576 tcpm_pd_hard_reset(tcpci->port); 577 578 if (status & TCPC_ALERT_TX_SUCCESS) 579 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_SUCCESS); 580 else if (status & TCPC_ALERT_TX_DISCARDED) 581 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_DISCARDED); 582 else if (status & TCPC_ALERT_TX_FAILED) 583 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_FAILED); 584 } 585 586 static int tcpci_enter_low_power_mode(struct tcpc_dev *tcpc, 587 bool attached, bool pd_capable) 588 { 589 int ret; 590 struct tcpci *tcpci = tcpc_to_tcpci(tcpc); 591 unsigned int reg; 592 593 /* Disable chip interrupts before unregistering port */ 594 ret = tcpci_write16(tcpci, TCPC_ALERT_MASK, 0); 595 if (ret < 0) 596 return ret; 597 598 reg = dm_i2c_reg_read(tcpci->dev, TCPC_BMCIO_CTRL); 599 if (reg < 0) 600 return reg; 601 /* 602 * For Type-C devices with PD capability, Only disable VBUS detect, 603 * do not diable 24M oscillator for BMC communication. Otherwise, 604 * data packets cannot be received. 605 */ 606 if (attached && pd_capable) 607 reg &= ~TCPC_BMCIO_VBUS_DETECT_MASK; 608 else 609 reg &= ~(TCPC_BMCIO_VBUS_DETECT_MASK | TCPC_BMCIO_24M_OSC_MASK); 610 return dm_i2c_reg_write(tcpci->dev, TCPC_BMCIO_CTRL, reg); 611 } 612 613 static int tcpci_parse_config(struct tcpci *tcpci) 614 { 615 tcpci->controls_vbus = true; /* XXX */ 616 617 tcpci->tcpc.connector_node = dev_read_subnode(tcpci->dev, "connector"); 618 if (!ofnode_valid(tcpci->tcpc.connector_node)) { 619 printf("%s: 'connector' node is not found\n", __func__); 620 return -EINVAL; 621 } 622 623 return 0; 624 } 625 626 struct tcpci *tcpci_register_port(struct udevice *dev, struct tcpci_data *data) 627 { 628 struct tcpci *tcpci; 629 int err; 630 631 tcpci = devm_kzalloc(dev, sizeof(*tcpci), GFP_KERNEL); 632 if (!tcpci) 633 return ERR_PTR(-ENOMEM); 634 635 err = gpio_request_by_name(dev, "int-n-gpios", 0, &tcpci->gpio_cc_int, GPIOD_IS_IN); 636 if (err) { 637 printf("%s: fail to get int GPIO: err=%d\n", __func__, err); 638 tcpci->gpio_cc_int_present = false; 639 } else { 640 tcpci->gpio_cc_int_present = true; 641 } 642 643 tcpci->dev = dev; 644 tcpci->data = data; 645 646 tcpci->tcpc.init = tcpci_init; 647 tcpci->tcpc.get_vbus = tcpci_get_vbus; 648 tcpci->tcpc.set_vbus = tcpci_set_vbus; 649 tcpci->tcpc.set_cc = tcpci_set_cc; 650 tcpci->tcpc.get_cc = tcpci_get_cc; 651 tcpci->tcpc.set_polarity = tcpci_set_polarity; 652 tcpci->tcpc.set_vconn = tcpci_set_vconn; 653 tcpci->tcpc.start_toggling = tcpci_start_toggling; 654 655 tcpci->tcpc.set_pd_rx = tcpci_set_pd_rx; 656 tcpci->tcpc.set_roles = tcpci_set_roles; 657 tcpci->tcpc.pd_transmit = tcpci_pd_transmit; 658 tcpci->tcpc.poll_event = tcpci_poll_event; 659 tcpci->tcpc.enter_low_power_mode = tcpci_enter_low_power_mode; 660 661 err = tcpci_parse_config(tcpci); 662 if (err < 0) 663 return ERR_PTR(err); 664 665 tcpci->port = tcpm_port_init(tcpci->dev, &tcpci->tcpc); 666 if (IS_ERR(tcpci->port)) { 667 printf("%s: failed to tcpm port init\n", __func__); 668 return ERR_CAST(tcpci->port); 669 } 670 671 tcpm_poll_event(tcpci->port); 672 673 return tcpci; 674 } 675 EXPORT_SYMBOL_GPL(tcpci_register_port); 676 677 void tcpci_unregister_port(struct tcpci *tcpci) 678 { 679 tcpm_uninit_port(tcpci->port); 680 } 681 EXPORT_SYMBOL_GPL(tcpci_unregister_port); 682 683 int tcpci_get_voltage_fun(struct tcpci *tcpci) 684 { 685 return tcpm_get_voltage(tcpci->port); 686 } 687 EXPORT_SYMBOL_GPL(tcpci_get_voltage_fun); 688 689 int tcpci_get_current_fun(struct tcpci *tcpci) 690 { 691 return tcpm_get_current(tcpci->port); 692 } 693 EXPORT_SYMBOL_GPL(tcpci_get_current_fun); 694 695 int tcpci_get_online_fun(struct tcpci *tcpci) 696 { 697 return tcpm_get_online(tcpci->port); 698 } 699 EXPORT_SYMBOL_GPL(tcpci_get_online_fun); 700 701 static int tcpci_probe(struct udevice *dev) 702 { 703 struct tcpci_chip *chip = dev_get_priv(dev); 704 int err; 705 u16 val = 0; 706 707 chip->udev = dev; 708 709 /* Disable chip interrupts before requesting irq */ 710 err = tcpci_write16(chip->tcpci, TCPC_ALERT_MASK, val); 711 if (err < 0) 712 return err; 713 714 chip->tcpci = tcpci_register_port(chip->udev, &chip->data); 715 if (IS_ERR(chip->tcpci)) 716 return PTR_ERR(chip->tcpci); 717 718 return 0; 719 } 720 721 static int tcpci_remove(struct udevice *dev) 722 { 723 struct tcpci_chip *chip = dev_get_priv(dev); 724 int err; 725 726 /* Disable chip interrupts before unregistering port */ 727 err = tcpci_write16(chip->tcpci, TCPC_ALERT_MASK, 0); 728 if (err < 0) 729 return err; 730 731 tcpci_unregister_port(chip->tcpci); 732 733 return 0; 734 } 735 736 static int tcpci_get_voltage(struct udevice *dev) 737 { 738 struct tcpci_chip *chip = dev_get_priv(dev); 739 740 return tcpm_get_voltage(chip->tcpci->port); 741 } 742 743 static int tcpci_get_current(struct udevice *dev) 744 { 745 struct tcpci_chip *chip = dev_get_priv(dev); 746 747 return tcpm_get_current(chip->tcpci->port); 748 } 749 750 static int tcpci_get_online(struct udevice *dev) 751 { 752 struct tcpci_chip *chip = dev_get_priv(dev); 753 754 return tcpm_get_online(chip->tcpci->port); 755 } 756 757 static struct dm_power_delivery_ops tcpci_ops = { 758 .get_voltage = tcpci_get_voltage, 759 .get_current = tcpci_get_current, 760 .get_online = tcpci_get_online, 761 }; 762 763 static const struct udevice_id tcpci_ids[] = { 764 { .compatible = "nxp,ptn5110", }, 765 {}, 766 }; 767 768 U_BOOT_DRIVER(tcpci) = { 769 .name = "tcpci", 770 .id = UCLASS_PD, 771 .of_match = tcpci_ids, 772 .ops = &tcpci_ops, 773 .probe = tcpci_probe, 774 .remove = tcpci_remove, 775 .priv_auto_alloc_size = sizeof(struct tcpci_chip), 776 } 777 778 MODULE_DESCRIPTION("USB Type-C Port Controller Interface driver"); 779 MODULE_LICENSE("GPL"); 780