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