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