drivers/usb/typec/tcpm/tcpci.c

   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, &reg);
 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, &reg);
 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 int tcpci_set_vconn(struct tcpc_dev *tcpc, bool enable)
 259 {
 260         struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
 261         int ret;
 262
 263         /* Handle vendor set vconn */
 264         if (tcpci->data->set_vconn) {
 265                 ret = tcpci->data->set_vconn(tcpci, tcpci->data, enable);
 266                 if (ret < 0)
 267                         return ret;
 268         }
 269
 270         return regmap_update_bits(tcpci->regmap, TCPC_POWER_CTRL,
 271                                 TCPC_POWER_CTRL_VCONN_ENABLE,
 272                                 enable ? TCPC_POWER_CTRL_VCONN_ENABLE : 0);
 273 }
 274
 275 static int tcpci_enable_auto_vbus_discharge(struct tcpc_dev *dev, bool enable)
 276 {
 277         struct tcpci *tcpci = tcpc_to_tcpci(dev);
 278         int ret;
 279
 280         ret = regmap_update_bits(tcpci->regmap, TCPC_POWER_CTRL, TCPC_POWER_CTRL_AUTO_DISCHARGE,
 281                                  enable ? TCPC_POWER_CTRL_AUTO_DISCHARGE : 0);
 282         return ret;
 283 }
 284
 285 static int tcpci_set_auto_vbus_discharge_threshold(struct tcpc_dev *dev, enum typec_pwr_opmode mode,
 286                                                    bool pps_active, u32 requested_vbus_voltage_mv)
 287 {
 288         struct tcpci *tcpci = tcpc_to_tcpci(dev);
 289         unsigned int pwr_ctrl, threshold = 0;
 290         int ret;
 291
 292         /*
 293          * Indicates that vbus is going to go away due PR_SWAP, hard reset etc.
 294          * Do not discharge vbus here.
 295          */
 296         if (requested_vbus_voltage_mv == 0)
 297                 goto write_thresh;
 298
 299         ret = regmap_read(tcpci->regmap, TCPC_POWER_CTRL, &pwr_ctrl);
 300         if (ret < 0)
 301                 return ret;
 302
 303         if (pwr_ctrl & TCPC_FAST_ROLE_SWAP_EN) {
 304                 /* To prevent disconnect when the source is fast role swap is capable. */
 305                 threshold = AUTO_DISCHARGE_DEFAULT_THRESHOLD_MV;
 306         } else if (mode == TYPEC_PWR_MODE_PD) {
 307                 if (pps_active)
 308                         threshold = (95 * requested_vbus_voltage_mv / 100) -
 309                                 AUTO_DISCHARGE_PD_HEADROOM_MV;
 310                 else
 311                         threshold = (95 * requested_vbus_voltage_mv / 100) -
 312                                 AUTO_DISCHARGE_PPS_HEADROOM_MV;
 313         } else {
 314                 /* 3.5V for non-pd sink */
 315                 threshold = AUTO_DISCHARGE_DEFAULT_THRESHOLD_MV;
 316         }
 317
 318         threshold = threshold / TCPC_VBUS_SINK_DISCONNECT_THRESH_LSB_MV;
 319
 320         if (threshold > TCPC_VBUS_SINK_DISCONNECT_THRESH_MAX)
 321                 return -EINVAL;
 322
 323 write_thresh:
 324         return tcpci_write16(tcpci, TCPC_VBUS_SINK_DISCONNECT_THRESH, threshold);
 325 }
 326
 327 static int tcpci_enable_frs(struct tcpc_dev *dev, bool enable)
 328 {
 329         struct tcpci *tcpci = tcpc_to_tcpci(dev);
 330         int ret;
 331
 332         /* To prevent disconnect during FRS, set disconnect threshold to 3.5V */
 333         ret = tcpci_write16(tcpci, TCPC_VBUS_SINK_DISCONNECT_THRESH, enable ? 0 : 0x8c);
 334         if (ret < 0)
 335                 return ret;
 336
 337         ret = regmap_update_bits(tcpci->regmap, TCPC_POWER_CTRL, TCPC_FAST_ROLE_SWAP_EN, enable ?
 338                                  TCPC_FAST_ROLE_SWAP_EN : 0);
 339
 340         return ret;
 341 }
 342
 343 static void tcpci_frs_sourcing_vbus(struct tcpc_dev *dev)
 344 {
 345         struct tcpci *tcpci = tcpc_to_tcpci(dev);
 346
 347         if (tcpci->data->frs_sourcing_vbus)
 348                 tcpci->data->frs_sourcing_vbus(tcpci, tcpci->data);
 349 }
 350
 351 static int tcpci_set_bist_data(struct tcpc_dev *tcpc, bool enable)
 352 {
 353         struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
 354
 355         return regmap_update_bits(tcpci->regmap, TCPC_TCPC_CTRL, TCPC_TCPC_CTRL_BIST_TM,
 356                                  enable ? TCPC_TCPC_CTRL_BIST_TM : 0);
 357 }
 358
 359 static int tcpci_set_roles(struct tcpc_dev *tcpc, bool attached,
 360                            enum typec_role role, enum typec_data_role data)
 361 {
 362         struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
 363         unsigned int reg;
 364         int ret;
 365
 366         reg = PD_REV20 << TCPC_MSG_HDR_INFO_REV_SHIFT;
 367         if (role == TYPEC_SOURCE)
 368                 reg |= TCPC_MSG_HDR_INFO_PWR_ROLE;
 369         if (data == TYPEC_HOST)
 370                 reg |= TCPC_MSG_HDR_INFO_DATA_ROLE;
 371         ret = regmap_write(tcpci->regmap, TCPC_MSG_HDR_INFO, reg);
 372         if (ret < 0)
 373                 return ret;
 374
 375         return 0;
 376 }
 377
 378 static int tcpci_set_pd_rx(struct tcpc_dev *tcpc, bool enable)
 379 {
 380         struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
 381         unsigned int reg = 0;
 382         int ret;
 383
 384         if (enable)
 385                 reg = TCPC_RX_DETECT_SOP | TCPC_RX_DETECT_HARD_RESET;
 386         ret = regmap_write(tcpci->regmap, TCPC_RX_DETECT, reg);
 387         if (ret < 0)
 388                 return ret;
 389
 390         return 0;
 391 }
 392
 393 static int tcpci_get_vbus(struct tcpc_dev *tcpc)
 394 {
 395         struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
 396         unsigned int reg;
 397         int ret;
 398
 399         ret = regmap_read(tcpci->regmap, TCPC_POWER_STATUS, &reg);
 400         if (ret < 0)
 401                 return ret;
 402
 403         return !!(reg & TCPC_POWER_STATUS_VBUS_PRES);
 404 }
 405
 406 static bool tcpci_is_vbus_vsafe0v(struct tcpc_dev *tcpc)
 407 {
 408         struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
 409         unsigned int reg;
 410         int ret;
 411
 412         ret = regmap_read(tcpci->regmap, TCPC_EXTENDED_STATUS, &reg);
 413         if (ret < 0)
 414                 return false;
 415
 416         return !!(reg & TCPC_EXTENDED_STATUS_VSAFE0V);
 417 }
 418
 419 static int tcpci_set_vbus(struct tcpc_dev *tcpc, bool source, bool sink)
 420 {
 421         struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
 422         int ret;
 423
 424         if (tcpci->data->set_vbus) {
 425                 ret = tcpci->data->set_vbus(tcpci, tcpci->data, source, sink);
 426                 /* Bypass when ret > 0 */
 427                 if (ret != 0)
 428                         return ret < 0 ? ret : 0;
 429         }
 430
 431         /* Disable both source and sink first before enabling anything */
 432
 433         if (!source) {
 434                 ret = regmap_write(tcpci->regmap, TCPC_COMMAND,
 435                                    TCPC_CMD_DISABLE_SRC_VBUS);
 436                 if (ret < 0)
 437                         return ret;
 438         }
 439
 440         if (!sink) {
 441                 ret = regmap_write(tcpci->regmap, TCPC_COMMAND,
 442                                    TCPC_CMD_DISABLE_SINK_VBUS);
 443                 if (ret < 0)
 444                         return ret;
 445         }
 446
 447         if (source) {
 448                 ret = regmap_write(tcpci->regmap, TCPC_COMMAND,
 449                                    TCPC_CMD_SRC_VBUS_DEFAULT);
 450                 if (ret < 0)
 451                         return ret;
 452         }
 453
 454         if (sink) {
 455                 ret = regmap_write(tcpci->regmap, TCPC_COMMAND,
 456                                    TCPC_CMD_SINK_VBUS);
 457                 if (ret < 0)
 458                         return ret;
 459         }
 460
 461         return 0;
 462 }
 463
 464 static int tcpci_pd_transmit(struct tcpc_dev *tcpc, enum tcpm_transmit_type type,
 465                              const struct pd_message *msg, unsigned int negotiated_rev)
 466 {
 467         struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
 468         u16 header = msg ? le16_to_cpu(msg->header) : 0;
 469         unsigned int reg, cnt;
 470         int ret;
 471
 472         cnt = msg ? pd_header_cnt(header) * 4 : 0;
 473         /**
 474          * TCPCI spec forbids direct access of TCPC_TX_DATA.
 475          * But, since some of the chipsets offer this capability,
 476          * it's fair to support both.
 477          */
 478         if (tcpci->data->TX_BUF_BYTE_x_hidden) {
 479                 u8 buf[TCPC_TRANSMIT_BUFFER_MAX_LEN] = {0,};
 480                 u8 pos = 0;
 481
 482                 /* Payload + header + TCPC_TX_BYTE_CNT */
 483                 buf[pos++] = cnt + 2;
 484
 485                 if (msg)
 486                         memcpy(&buf[pos], &msg->header, sizeof(msg->header));
 487
 488                 pos += sizeof(header);
 489
 490                 if (cnt > 0)
 491                         memcpy(&buf[pos], msg->payload, cnt);
 492
 493                 pos += cnt;
 494                 ret = regmap_raw_write(tcpci->regmap, TCPC_TX_BYTE_CNT, buf, pos);
 495                 if (ret < 0)
 496                         return ret;
 497         } else {
 498                 ret = regmap_write(tcpci->regmap, TCPC_TX_BYTE_CNT, cnt + 2);
 499                 if (ret < 0)
 500                         return ret;
 501
 502                 ret = tcpci_write16(tcpci, TCPC_TX_HDR, header);
 503                 if (ret < 0)
 504                         return ret;
 505
 506                 if (cnt > 0) {
 507                         ret = regmap_raw_write(tcpci->regmap, TCPC_TX_DATA, &msg->payload, cnt);
 508                         if (ret < 0)
 509                                 return ret;
 510                 }
 511         }
 512
 513         /* nRetryCount is 3 in PD2.0 spec where 2 in PD3.0 spec */
 514         reg = ((negotiated_rev > PD_REV20 ? PD_RETRY_COUNT_3_0_OR_HIGHER : PD_RETRY_COUNT_DEFAULT)
 515                << TCPC_TRANSMIT_RETRY_SHIFT) | (type << TCPC_TRANSMIT_TYPE_SHIFT);
 516         ret = regmap_write(tcpci->regmap, TCPC_TRANSMIT, reg);
 517         if (ret < 0)
 518                 return ret;
 519
 520         return 0;
 521 }
 522
 523 static int tcpci_init(struct tcpc_dev *tcpc)
 524 {
 525         struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
 526         unsigned long timeout = jiffies + msecs_to_jiffies(2000); /* XXX */
 527         unsigned int reg;
 528         int ret;
 529
 530         while (time_before_eq(jiffies, timeout)) {
 531                 ret = regmap_read(tcpci->regmap, TCPC_POWER_STATUS, &reg);
 532                 if (ret < 0)
 533                         return ret;
 534                 if (!(reg & TCPC_POWER_STATUS_UNINIT))
 535                         break;
 536                 usleep_range(10000, 20000);
 537         }
 538         if (time_after(jiffies, timeout))
 539                 return -ETIMEDOUT;
 540
 541         /* Handle vendor init */
 542         if (tcpci->data->init) {
 543                 ret = tcpci->data->init(tcpci, tcpci->data);
 544                 if (ret < 0)
 545                         return ret;
 546         }
 547
 548         /* Clear all events */
 549         ret = tcpci_write16(tcpci, TCPC_ALERT, 0xffff);
 550         if (ret < 0)
 551                 return ret;
 552
 553         if (tcpci->controls_vbus)
 554                 reg = TCPC_POWER_STATUS_VBUS_PRES;
 555         else
 556                 reg = 0;
 557         ret = regmap_write(tcpci->regmap, TCPC_POWER_STATUS_MASK, reg);
 558         if (ret < 0)
 559                 return ret;
 560
 561         /* Enable Vbus detection */
 562         ret = regmap_write(tcpci->regmap, TCPC_COMMAND,
 563                            TCPC_CMD_ENABLE_VBUS_DETECT);
 564         if (ret < 0)
 565                 return ret;
 566
 567         reg = TCPC_ALERT_TX_SUCCESS | TCPC_ALERT_TX_FAILED |
 568                 TCPC_ALERT_TX_DISCARDED | TCPC_ALERT_RX_STATUS |
 569                 TCPC_ALERT_RX_HARD_RST | TCPC_ALERT_CC_STATUS;
 570         if (tcpci->controls_vbus)
 571                 reg |= TCPC_ALERT_POWER_STATUS;
 572         /* Enable VSAFE0V status interrupt when detecting VSAFE0V is supported */
 573         if (tcpci->data->vbus_vsafe0v) {
 574                 reg |= TCPC_ALERT_EXTENDED_STATUS;
 575                 ret = regmap_write(tcpci->regmap, TCPC_EXTENDED_STATUS_MASK,
 576                                    TCPC_EXTENDED_STATUS_VSAFE0V);
 577                 if (ret < 0)
 578                         return ret;
 579         }
 580         return tcpci_write16(tcpci, TCPC_ALERT_MASK, reg);
 581 }
 582
 583 irqreturn_t tcpci_irq(struct tcpci *tcpci)
 584 {
 585         u16 status;
 586         int ret;
 587         unsigned int raw;
 588
 589         tcpci_read16(tcpci, TCPC_ALERT, &status);
 590
 591         /*
 592          * Clear alert status for everything except RX_STATUS, which shouldn't
 593          * be cleared until we have successfully retrieved message.
 594          */
 595         if (status & ~TCPC_ALERT_RX_STATUS)
 596                 tcpci_write16(tcpci, TCPC_ALERT,
 597                               status & ~TCPC_ALERT_RX_STATUS);
 598
 599         if (status & TCPC_ALERT_CC_STATUS)
 600                 tcpm_cc_change(tcpci->port);
 601
 602         if (status & TCPC_ALERT_POWER_STATUS) {
 603                 regmap_read(tcpci->regmap, TCPC_POWER_STATUS_MASK, &raw);
 604                 /*
 605                  * If power status mask has been reset, then the TCPC
 606                  * has reset.
 607                  */
 608                 if (raw == 0xff)
 609                         tcpm_tcpc_reset(tcpci->port);
 610                 else
 611                         tcpm_vbus_change(tcpci->port);
 612         }
 613
 614         if (status & TCPC_ALERT_RX_STATUS) {
 615                 struct pd_message msg;
 616                 unsigned int cnt, payload_cnt;
 617                 u16 header;
 618
 619                 regmap_read(tcpci->regmap, TCPC_RX_BYTE_CNT, &cnt);
 620                 /*
 621                  * 'cnt' corresponds to READABLE_BYTE_COUNT in section 4.4.14
 622                  * of the TCPCI spec [Rev 2.0 Ver 1.0 October 2017] and is
 623                  * defined in table 4-36 as one greater than the number of
 624                  * bytes received. And that number includes the header. So:
 625                  */
 626                 if (cnt > 3)
 627                         payload_cnt = cnt - (1 + sizeof(msg.header));
 628                 else
 629                         payload_cnt = 0;
 630
 631                 tcpci_read16(tcpci, TCPC_RX_HDR, &header);
 632                 msg.header = cpu_to_le16(header);
 633
 634                 if (WARN_ON(payload_cnt > sizeof(msg.payload)))
 635                         payload_cnt = sizeof(msg.payload);
 636
 637                 if (payload_cnt > 0)
 638                         regmap_raw_read(tcpci->regmap, TCPC_RX_DATA,
 639                                         &msg.payload, payload_cnt);
 640
 641                 /* Read complete, clear RX status alert bit */
 642                 tcpci_write16(tcpci, TCPC_ALERT, TCPC_ALERT_RX_STATUS);
 643
 644                 tcpm_pd_receive(tcpci->port, &msg);
 645         }
 646
 647         if (status & TCPC_ALERT_EXTENDED_STATUS) {
 648                 ret = regmap_read(tcpci->regmap, TCPC_EXTENDED_STATUS, &raw);
 649                 if (!ret && (raw & TCPC_EXTENDED_STATUS_VSAFE0V))
 650                         tcpm_vbus_change(tcpci->port);
 651         }
 652
 653         if (status & TCPC_ALERT_RX_HARD_RST)
 654                 tcpm_pd_hard_reset(tcpci->port);
 655
 656         if (status & TCPC_ALERT_TX_SUCCESS)
 657                 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_SUCCESS);
 658         else if (status & TCPC_ALERT_TX_DISCARDED)
 659                 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_DISCARDED);
 660         else if (status & TCPC_ALERT_TX_FAILED)
 661                 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_FAILED);
 662
 663         return IRQ_HANDLED;
 664 }
 665 EXPORT_SYMBOL_GPL(tcpci_irq);
 666
 667 static irqreturn_t _tcpci_irq(int irq, void *dev_id)
 668 {
 669         struct tcpci_chip *chip = dev_id;
 670
 671         return tcpci_irq(chip->tcpci);
 672 }
 673
 674 static const struct regmap_config tcpci_regmap_config = {
 675         .reg_bits = 8,
 676         .val_bits = 8,
 677
 678         .max_register = 0x7F, /* 0x80 .. 0xFF are vendor defined */
 679 };
 680
 681 static int tcpci_parse_config(struct tcpci *tcpci)
 682 {
 683         tcpci->controls_vbus = true; /* XXX */
 684
 685         tcpci->tcpc.fwnode = device_get_named_child_node(tcpci->dev,
 686                                                          "connector");
 687         if (!tcpci->tcpc.fwnode) {
 688                 dev_err(tcpci->dev, "Can't find connector node.\n");
 689                 return -EINVAL;
 690         }
 691
 692         return 0;
 693 }
 694
 695 struct tcpci *tcpci_register_port(struct device *dev, struct tcpci_data *data)
 696 {
 697         struct tcpci *tcpci;
 698         int err;
 699
 700         tcpci = devm_kzalloc(dev, sizeof(*tcpci), GFP_KERNEL);
 701         if (!tcpci)
 702                 return ERR_PTR(-ENOMEM);
 703
 704         tcpci->dev = dev;
 705         tcpci->data = data;
 706         tcpci->regmap = data->regmap;
 707
 708         tcpci->tcpc.init = tcpci_init;
 709         tcpci->tcpc.get_vbus = tcpci_get_vbus;
 710         tcpci->tcpc.set_vbus = tcpci_set_vbus;
 711         tcpci->tcpc.set_cc = tcpci_set_cc;
 712         tcpci->tcpc.get_cc = tcpci_get_cc;
 713         tcpci->tcpc.set_polarity = tcpci_set_polarity;
 714         tcpci->tcpc.set_vconn = tcpci_set_vconn;
 715         tcpci->tcpc.start_toggling = tcpci_start_toggling;
 716
 717         tcpci->tcpc.set_pd_rx = tcpci_set_pd_rx;
 718         tcpci->tcpc.set_roles = tcpci_set_roles;
 719         tcpci->tcpc.pd_transmit = tcpci_pd_transmit;
 720         tcpci->tcpc.set_bist_data = tcpci_set_bist_data;
 721         tcpci->tcpc.enable_frs = tcpci_enable_frs;
 722         tcpci->tcpc.frs_sourcing_vbus = tcpci_frs_sourcing_vbus;
 723
 724         if (tcpci->data->auto_discharge_disconnect) {
 725                 tcpci->tcpc.enable_auto_vbus_discharge = tcpci_enable_auto_vbus_discharge;
 726                 tcpci->tcpc.set_auto_vbus_discharge_threshold =
 727                         tcpci_set_auto_vbus_discharge_threshold;
 728                 regmap_update_bits(tcpci->regmap, TCPC_POWER_CTRL, TCPC_POWER_CTRL_BLEED_DISCHARGE,
 729                                    TCPC_POWER_CTRL_BLEED_DISCHARGE);
 730         }
 731
 732         if (tcpci->data->vbus_vsafe0v)
 733                 tcpci->tcpc.is_vbus_vsafe0v = tcpci_is_vbus_vsafe0v;
 734
 735         err = tcpci_parse_config(tcpci);
 736         if (err < 0)
 737                 return ERR_PTR(err);
 738
 739         tcpci->port = tcpm_register_port(tcpci->dev, &tcpci->tcpc);
 740         if (IS_ERR(tcpci->port))
 741                 return ERR_CAST(tcpci->port);
 742
 743         return tcpci;
 744 }
 745 EXPORT_SYMBOL_GPL(tcpci_register_port);
 746
 747 void tcpci_unregister_port(struct tcpci *tcpci)
 748 {
 749         tcpm_unregister_port(tcpci->port);
 750 }
 751 EXPORT_SYMBOL_GPL(tcpci_unregister_port);
 752
 753 static int tcpci_probe(struct i2c_client *client,
 754                        const struct i2c_device_id *i2c_id)
 755 {
 756         struct tcpci_chip *chip;
 757         int err;
 758         u16 val = 0;
 759
 760         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
 761         if (!chip)
 762                 return -ENOMEM;
 763
 764         chip->data.regmap = devm_regmap_init_i2c(client, &tcpci_regmap_config);
 765         if (IS_ERR(chip->data.regmap))
 766                 return PTR_ERR(chip->data.regmap);
 767
 768         i2c_set_clientdata(client, chip);
 769
 770         /* Disable chip interrupts before requesting irq */
 771         err = regmap_raw_write(chip->data.regmap, TCPC_ALERT_MASK, &val,
 772                                sizeof(u16));
 773         if (err < 0)
 774                 return err;
 775
 776         chip->tcpci = tcpci_register_port(&client->dev, &chip->data);
 777         if (IS_ERR(chip->tcpci))
 778                 return PTR_ERR(chip->tcpci);
 779
 780         err = devm_request_threaded_irq(&client->dev, client->irq, NULL,
 781                                         _tcpci_irq,
 782                                         IRQF_ONESHOT | IRQF_TRIGGER_LOW,
 783                                         dev_name(&client->dev), chip);
 784         if (err < 0) {
 785                 tcpci_unregister_port(chip->tcpci);
 786                 return err;
 787         }
 788
 789         return 0;
 790 }
 791
 792 static int tcpci_remove(struct i2c_client *client)
 793 {
 794         struct tcpci_chip *chip = i2c_get_clientdata(client);
 795         int err;
 796
 797         /* Disable chip interrupts before unregistering port */
 798         err = tcpci_write16(chip->tcpci, TCPC_ALERT_MASK, 0);
 799         if (err < 0)
 800                 return err;
 801
 802         tcpci_unregister_port(chip->tcpci);
 803
 804         return 0;
 805 }
 806
 807 static const struct i2c_device_id tcpci_id[] = {
 808         { "tcpci", 0 },
 809         { }
 810 };
 811 MODULE_DEVICE_TABLE(i2c, tcpci_id);
 812
 813 #ifdef CONFIG_OF
 814 static const struct of_device_id tcpci_of_match[] = {
 815         { .compatible = "nxp,ptn5110", },
 816         {},
 817 };
 818 MODULE_DEVICE_TABLE(of, tcpci_of_match);
 819 #endif
 820
 821 static struct i2c_driver tcpci_i2c_driver = {
 822         .driver = {
 823                 .name = "tcpci",
 824                 .of_match_table = of_match_ptr(tcpci_of_match),
 825         },
 826         .probe = tcpci_probe,
 827         .remove = tcpci_remove,
 828         .id_table = tcpci_id,
 829 };
 830 module_i2c_driver(tcpci_i2c_driver);
 831
 832 MODULE_DESCRIPTION("USB Type-C Port Controller Interface driver");
 833 MODULE_LICENSE("GPL");