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