drivers/usb/typec/tipd/core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Driver for TI TPS6598x USB Power Delivery controller family
   4  *
   5  * Copyright (C) 2017, Intel Corporation
   6  * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
   7  */
   8
   9 #include <linux/i2c.h>
  10 #include <linux/acpi.h>
  11 #include <linux/module.h>
  12 #include <linux/power_supply.h>
  13 #include <linux/regmap.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/usb/typec.h>
  16 #include <linux/usb/role.h>
  17
  18 #include "tps6598x.h"
  19 #include "trace.h"
  20
  21 /* Register offsets */
  22 #define TPS_REG_VID                     0x00
  23 #define TPS_REG_MODE                    0x03
  24 #define TPS_REG_CMD1                    0x08
  25 #define TPS_REG_DATA1                   0x09
  26 #define TPS_REG_INT_EVENT1              0x14
  27 #define TPS_REG_INT_EVENT2              0x15
  28 #define TPS_REG_INT_MASK1               0x16
  29 #define TPS_REG_INT_MASK2               0x17
  30 #define TPS_REG_INT_CLEAR1              0x18
  31 #define TPS_REG_INT_CLEAR2              0x19
  32 #define TPS_REG_STATUS                  0x1a
  33 #define TPS_REG_SYSTEM_CONF             0x28
  34 #define TPS_REG_CTRL_CONF               0x29
  35 #define TPS_REG_POWER_STATUS            0x3f
  36 #define TPS_REG_RX_IDENTITY_SOP         0x48
  37 #define TPS_REG_DATA_STATUS             0x5f
  38
  39 /* TPS_REG_SYSTEM_CONF bits */
  40 #define TPS_SYSCONF_PORTINFO(c)         ((c) & 7)
  41
  42 enum {
  43         TPS_PORTINFO_SINK,
  44         TPS_PORTINFO_SINK_ACCESSORY,
  45         TPS_PORTINFO_DRP_UFP,
  46         TPS_PORTINFO_DRP_UFP_DRD,
  47         TPS_PORTINFO_DRP_DFP,
  48         TPS_PORTINFO_DRP_DFP_DRD,
  49         TPS_PORTINFO_SOURCE,
  50 };
  51
  52 /* TPS_REG_RX_IDENTITY_SOP */
  53 struct tps6598x_rx_identity_reg {
  54         u8 status;
  55         struct usb_pd_identity identity;
  56 } __packed;
  57
  58 /* Standard Task return codes */
  59 #define TPS_TASK_TIMEOUT                1
  60 #define TPS_TASK_REJECTED               3
  61
  62 enum {
  63         TPS_MODE_APP,
  64         TPS_MODE_BOOT,
  65         TPS_MODE_BIST,
  66         TPS_MODE_DISC,
  67 };
  68
  69 static const char *const modes[] = {
  70         [TPS_MODE_APP]  = "APP ",
  71         [TPS_MODE_BOOT] = "BOOT",
  72         [TPS_MODE_BIST] = "BIST",
  73         [TPS_MODE_DISC] = "DISC",
  74 };
  75
  76 /* Unrecognized commands will be replaced with "!CMD" */
  77 #define INVALID_CMD(_cmd_)              (_cmd_ == 0x444d4321)
  78
  79 struct tps6598x {
  80         struct device *dev;
  81         struct regmap *regmap;
  82         struct mutex lock; /* device lock */
  83         u8 i2c_protocol:1;
  84
  85         struct typec_port *port;
  86         struct typec_partner *partner;
  87         struct usb_pd_identity partner_identity;
  88         struct usb_role_switch *role_sw;
  89         struct typec_capability typec_cap;
  90
  91         struct power_supply *psy;
  92         struct power_supply_desc psy_desc;
  93         enum power_supply_usb_type usb_type;
  94 };
  95
  96 static enum power_supply_property tps6598x_psy_props[] = {
  97         POWER_SUPPLY_PROP_USB_TYPE,
  98         POWER_SUPPLY_PROP_ONLINE,
  99 };
 100
 101 static enum power_supply_usb_type tps6598x_psy_usb_types[] = {
 102         POWER_SUPPLY_USB_TYPE_C,
 103         POWER_SUPPLY_USB_TYPE_PD,
 104 };
 105
 106 static const char *tps6598x_psy_name_prefix = "tps6598x-source-psy-";
 107
 108 /*
 109  * Max data bytes for Data1, Data2, and other registers. See ch 1.3.2:
 110  * https://www.ti.com/lit/ug/slvuan1a/slvuan1a.pdf
 111  */
 112 #define TPS_MAX_LEN     64
 113
 114 static int
 115 tps6598x_block_read(struct tps6598x *tps, u8 reg, void *val, size_t len)
 116 {
 117         u8 data[TPS_MAX_LEN + 1];
 118         int ret;
 119
 120         if (WARN_ON(len + 1 > sizeof(data)))
 121                 return -EINVAL;
 122
 123         if (!tps->i2c_protocol)
 124                 return regmap_raw_read(tps->regmap, reg, val, len);
 125
 126         ret = regmap_raw_read(tps->regmap, reg, data, sizeof(data));
 127         if (ret)
 128                 return ret;
 129
 130         if (data[0] < len)
 131                 return -EIO;
 132
 133         memcpy(val, &data[1], len);
 134         return 0;
 135 }
 136
 137 static int tps6598x_block_write(struct tps6598x *tps, u8 reg,
 138                                 const void *val, size_t len)
 139 {
 140         u8 data[TPS_MAX_LEN + 1];
 141
 142         if (!tps->i2c_protocol)
 143                 return regmap_raw_write(tps->regmap, reg, val, len);
 144
 145         data[0] = len;
 146         memcpy(&data[1], val, len);
 147
 148         return regmap_raw_write(tps->regmap, reg, data, sizeof(data));
 149 }
 150
 151 static inline int tps6598x_read16(struct tps6598x *tps, u8 reg, u16 *val)
 152 {
 153         return tps6598x_block_read(tps, reg, val, sizeof(u16));
 154 }
 155
 156 static inline int tps6598x_read32(struct tps6598x *tps, u8 reg, u32 *val)
 157 {
 158         return tps6598x_block_read(tps, reg, val, sizeof(u32));
 159 }
 160
 161 static inline int tps6598x_read64(struct tps6598x *tps, u8 reg, u64 *val)
 162 {
 163         return tps6598x_block_read(tps, reg, val, sizeof(u64));
 164 }
 165
 166 static inline int tps6598x_write16(struct tps6598x *tps, u8 reg, u16 val)
 167 {
 168         return tps6598x_block_write(tps, reg, &val, sizeof(u16));
 169 }
 170
 171 static inline int tps6598x_write32(struct tps6598x *tps, u8 reg, u32 val)
 172 {
 173         return tps6598x_block_write(tps, reg, &val, sizeof(u32));
 174 }
 175
 176 static inline int tps6598x_write64(struct tps6598x *tps, u8 reg, u64 val)
 177 {
 178         return tps6598x_block_write(tps, reg, &val, sizeof(u64));
 179 }
 180
 181 static inline int
 182 tps6598x_write_4cc(struct tps6598x *tps, u8 reg, const char *val)
 183 {
 184         return tps6598x_block_write(tps, reg, val, 4);
 185 }
 186
 187 static int tps6598x_read_partner_identity(struct tps6598x *tps)
 188 {
 189         struct tps6598x_rx_identity_reg id;
 190         int ret;
 191
 192         ret = tps6598x_block_read(tps, TPS_REG_RX_IDENTITY_SOP,
 193                                   &id, sizeof(id));
 194         if (ret)
 195                 return ret;
 196
 197         tps->partner_identity = id.identity;
 198
 199         return 0;
 200 }
 201
 202 static void tps6598x_set_data_role(struct tps6598x *tps,
 203                                    enum typec_data_role role, bool connected)
 204 {
 205         enum usb_role role_val;
 206
 207         if (role == TYPEC_HOST)
 208                 role_val = USB_ROLE_HOST;
 209         else
 210                 role_val = USB_ROLE_DEVICE;
 211
 212         if (!connected)
 213                 role_val = USB_ROLE_NONE;
 214
 215         usb_role_switch_set_role(tps->role_sw, role_val);
 216         typec_set_data_role(tps->port, role);
 217 }
 218
 219 static int tps6598x_connect(struct tps6598x *tps, u32 status)
 220 {
 221         struct typec_partner_desc desc;
 222         enum typec_pwr_opmode mode;
 223         u16 pwr_status;
 224         int ret;
 225
 226         if (tps->partner)
 227                 return 0;
 228
 229         ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status);
 230         if (ret < 0)
 231                 return ret;
 232
 233         mode = TPS_POWER_STATUS_PWROPMODE(pwr_status);
 234
 235         desc.usb_pd = mode == TYPEC_PWR_MODE_PD;
 236         desc.accessory = TYPEC_ACCESSORY_NONE; /* XXX: handle accessories */
 237         desc.identity = NULL;
 238
 239         if (desc.usb_pd) {
 240                 ret = tps6598x_read_partner_identity(tps);
 241                 if (ret)
 242                         return ret;
 243                 desc.identity = &tps->partner_identity;
 244         }
 245
 246         typec_set_pwr_opmode(tps->port, mode);
 247         typec_set_pwr_role(tps->port, TPS_STATUS_TO_TYPEC_PORTROLE(status));
 248         typec_set_vconn_role(tps->port, TPS_STATUS_TO_TYPEC_VCONN(status));
 249         tps6598x_set_data_role(tps, TPS_STATUS_TO_TYPEC_DATAROLE(status), true);
 250
 251         tps->partner = typec_register_partner(tps->port, &desc);
 252         if (IS_ERR(tps->partner))
 253                 return PTR_ERR(tps->partner);
 254
 255         if (desc.identity)
 256                 typec_partner_set_identity(tps->partner);
 257
 258         power_supply_changed(tps->psy);
 259
 260         return 0;
 261 }
 262
 263 static void tps6598x_disconnect(struct tps6598x *tps, u32 status)
 264 {
 265         if (!IS_ERR(tps->partner))
 266                 typec_unregister_partner(tps->partner);
 267         tps->partner = NULL;
 268         typec_set_pwr_opmode(tps->port, TYPEC_PWR_MODE_USB);
 269         typec_set_pwr_role(tps->port, TPS_STATUS_TO_TYPEC_PORTROLE(status));
 270         typec_set_vconn_role(tps->port, TPS_STATUS_TO_TYPEC_VCONN(status));
 271         tps6598x_set_data_role(tps, TPS_STATUS_TO_TYPEC_DATAROLE(status), false);
 272
 273         power_supply_changed(tps->psy);
 274 }
 275
 276 static int tps6598x_exec_cmd(struct tps6598x *tps, const char *cmd,
 277                              size_t in_len, u8 *in_data,
 278                              size_t out_len, u8 *out_data)
 279 {
 280         unsigned long timeout;
 281         u32 val;
 282         int ret;
 283
 284         ret = tps6598x_read32(tps, TPS_REG_CMD1, &val);
 285         if (ret)
 286                 return ret;
 287         if (val && !INVALID_CMD(val))
 288                 return -EBUSY;
 289
 290         if (in_len) {
 291                 ret = tps6598x_block_write(tps, TPS_REG_DATA1,
 292                                            in_data, in_len);
 293                 if (ret)
 294                         return ret;
 295         }
 296
 297         ret = tps6598x_write_4cc(tps, TPS_REG_CMD1, cmd);
 298         if (ret < 0)
 299                 return ret;
 300
 301         /* XXX: Using 1s for now, but it may not be enough for every command. */
 302         timeout = jiffies + msecs_to_jiffies(1000);
 303
 304         do {
 305                 ret = tps6598x_read32(tps, TPS_REG_CMD1, &val);
 306                 if (ret)
 307                         return ret;
 308                 if (INVALID_CMD(val))
 309                         return -EINVAL;
 310
 311                 if (time_is_before_jiffies(timeout))
 312                         return -ETIMEDOUT;
 313         } while (val);
 314
 315         if (out_len) {
 316                 ret = tps6598x_block_read(tps, TPS_REG_DATA1,
 317                                           out_data, out_len);
 318                 if (ret)
 319                         return ret;
 320                 val = out_data[0];
 321         } else {
 322                 ret = tps6598x_block_read(tps, TPS_REG_DATA1, &val, sizeof(u8));
 323                 if (ret)
 324                         return ret;
 325         }
 326
 327         switch (val) {
 328         case TPS_TASK_TIMEOUT:
 329                 return -ETIMEDOUT;
 330         case TPS_TASK_REJECTED:
 331                 return -EPERM;
 332         default:
 333                 break;
 334         }
 335
 336         return 0;
 337 }
 338
 339 static int tps6598x_dr_set(struct typec_port *port, enum typec_data_role role)
 340 {
 341         const char *cmd = (role == TYPEC_DEVICE) ? "SWUF" : "SWDF";
 342         struct tps6598x *tps = typec_get_drvdata(port);
 343         u32 status;
 344         int ret;
 345
 346         mutex_lock(&tps->lock);
 347
 348         ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL);
 349         if (ret)
 350                 goto out_unlock;
 351
 352         ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
 353         if (ret)
 354                 goto out_unlock;
 355
 356         if (role != TPS_STATUS_TO_TYPEC_DATAROLE(status)) {
 357                 ret = -EPROTO;
 358                 goto out_unlock;
 359         }
 360
 361         tps6598x_set_data_role(tps, role, true);
 362
 363 out_unlock:
 364         mutex_unlock(&tps->lock);
 365
 366         return ret;
 367 }
 368
 369 static int tps6598x_pr_set(struct typec_port *port, enum typec_role role)
 370 {
 371         const char *cmd = (role == TYPEC_SINK) ? "SWSk" : "SWSr";
 372         struct tps6598x *tps = typec_get_drvdata(port);
 373         u32 status;
 374         int ret;
 375
 376         mutex_lock(&tps->lock);
 377
 378         ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL);
 379         if (ret)
 380                 goto out_unlock;
 381
 382         ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
 383         if (ret)
 384                 goto out_unlock;
 385
 386         if (role != TPS_STATUS_TO_TYPEC_PORTROLE(status)) {
 387                 ret = -EPROTO;
 388                 goto out_unlock;
 389         }
 390
 391         typec_set_pwr_role(tps->port, role);
 392
 393 out_unlock:
 394         mutex_unlock(&tps->lock);
 395
 396         return ret;
 397 }
 398
 399 static const struct typec_operations tps6598x_ops = {
 400         .dr_set = tps6598x_dr_set,
 401         .pr_set = tps6598x_pr_set,
 402 };
 403
 404 static irqreturn_t tps6598x_interrupt(int irq, void *data)
 405 {
 406         struct tps6598x *tps = data;
 407         u64 event1;
 408         u64 event2;
 409         u32 status, data_status;
 410         u16 pwr_status;
 411         int ret;
 412
 413         mutex_lock(&tps->lock);
 414
 415         ret = tps6598x_read64(tps, TPS_REG_INT_EVENT1, &event1);
 416         ret |= tps6598x_read64(tps, TPS_REG_INT_EVENT2, &event2);
 417         if (ret) {
 418                 dev_err(tps->dev, "%s: failed to read events\n", __func__);
 419                 goto err_unlock;
 420         }
 421         trace_tps6598x_irq(event1, event2);
 422
 423         ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
 424         if (ret) {
 425                 dev_err(tps->dev, "%s: failed to read status\n", __func__);
 426                 goto err_clear_ints;
 427         }
 428         trace_tps6598x_status(status);
 429
 430         if ((event1 | event2) & TPS_REG_INT_POWER_STATUS_UPDATE) {
 431                 ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status);
 432                 if (ret < 0) {
 433                         dev_err(tps->dev, "failed to read power status: %d\n", ret);
 434                         goto err_clear_ints;
 435                 }
 436                 trace_tps6598x_power_status(pwr_status);
 437         }
 438
 439         if ((event1 | event2) & TPS_REG_INT_DATA_STATUS_UPDATE) {
 440                 ret = tps6598x_read32(tps, TPS_REG_DATA_STATUS, &data_status);
 441                 if (ret < 0) {
 442                         dev_err(tps->dev, "failed to read data status: %d\n", ret);
 443                         goto err_clear_ints;
 444                 }
 445                 trace_tps6598x_data_status(data_status);
 446         }
 447
 448         /* Handle plug insert or removal */
 449         if ((event1 | event2) & TPS_REG_INT_PLUG_EVENT) {
 450                 if (status & TPS_STATUS_PLUG_PRESENT) {
 451                         ret = tps6598x_connect(tps, status);
 452                         if (ret)
 453                                 dev_err(tps->dev,
 454                                         "failed to register partner\n");
 455                 } else {
 456                         tps6598x_disconnect(tps, status);
 457                 }
 458         }
 459
 460 err_clear_ints:
 461         tps6598x_write64(tps, TPS_REG_INT_CLEAR1, event1);
 462         tps6598x_write64(tps, TPS_REG_INT_CLEAR2, event2);
 463
 464 err_unlock:
 465         mutex_unlock(&tps->lock);
 466
 467         return IRQ_HANDLED;
 468 }
 469
 470 static int tps6598x_check_mode(struct tps6598x *tps)
 471 {
 472         char mode[5] = { };
 473         int ret;
 474
 475         ret = tps6598x_read32(tps, TPS_REG_MODE, (void *)mode);
 476         if (ret)
 477                 return ret;
 478
 479         switch (match_string(modes, ARRAY_SIZE(modes), mode)) {
 480         case TPS_MODE_APP:
 481                 return 0;
 482         case TPS_MODE_BOOT:
 483                 dev_warn(tps->dev, "dead-battery condition\n");
 484                 return 0;
 485         case TPS_MODE_BIST:
 486         case TPS_MODE_DISC:
 487         default:
 488                 dev_err(tps->dev, "controller in unsupported mode \"%s\"\n",
 489                         mode);
 490                 break;
 491         }
 492
 493         return -ENODEV;
 494 }
 495
 496 static const struct regmap_config tps6598x_regmap_config = {
 497         .reg_bits = 8,
 498         .val_bits = 8,
 499         .max_register = 0x7F,
 500 };
 501
 502 static int tps6598x_psy_get_online(struct tps6598x *tps,
 503                                    union power_supply_propval *val)
 504 {
 505         int ret;
 506         u16 pwr_status;
 507
 508         ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status);
 509         if (ret < 0)
 510                 return ret;
 511
 512         if (TPS_POWER_STATUS_CONNECTION(pwr_status) &&
 513             TPS_POWER_STATUS_SOURCESINK(pwr_status)) {
 514                 val->intval = 1;
 515         } else {
 516                 val->intval = 0;
 517         }
 518         return 0;
 519 }
 520
 521 static int tps6598x_psy_get_prop(struct power_supply *psy,
 522                                  enum power_supply_property psp,
 523                                  union power_supply_propval *val)
 524 {
 525         struct tps6598x *tps = power_supply_get_drvdata(psy);
 526         u16 pwr_status;
 527         int ret = 0;
 528
 529         switch (psp) {
 530         case POWER_SUPPLY_PROP_USB_TYPE:
 531                 ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status);
 532                 if (ret < 0)
 533                         return ret;
 534                 if (TPS_POWER_STATUS_PWROPMODE(pwr_status) == TYPEC_PWR_MODE_PD)
 535                         val->intval = POWER_SUPPLY_USB_TYPE_PD;
 536                 else
 537                         val->intval = POWER_SUPPLY_USB_TYPE_C;
 538                 break;
 539         case POWER_SUPPLY_PROP_ONLINE:
 540                 ret = tps6598x_psy_get_online(tps, val);
 541                 break;
 542         default:
 543                 ret = -EINVAL;
 544                 break;
 545         }
 546
 547         return ret;
 548 }
 549
 550 static int devm_tps6598_psy_register(struct tps6598x *tps)
 551 {
 552         struct power_supply_config psy_cfg = {};
 553         const char *port_dev_name = dev_name(tps->dev);
 554         char *psy_name;
 555
 556         psy_cfg.drv_data = tps;
 557         psy_cfg.fwnode = dev_fwnode(tps->dev);
 558
 559         psy_name = devm_kasprintf(tps->dev, GFP_KERNEL, "%s%s", tps6598x_psy_name_prefix,
 560                                   port_dev_name);
 561         if (!psy_name)
 562                 return -ENOMEM;
 563
 564         tps->psy_desc.name = psy_name;
 565         tps->psy_desc.type = POWER_SUPPLY_TYPE_USB;
 566         tps->psy_desc.usb_types = tps6598x_psy_usb_types;
 567         tps->psy_desc.num_usb_types = ARRAY_SIZE(tps6598x_psy_usb_types);
 568         tps->psy_desc.properties = tps6598x_psy_props;
 569         tps->psy_desc.num_properties = ARRAY_SIZE(tps6598x_psy_props);
 570         tps->psy_desc.get_property = tps6598x_psy_get_prop;
 571
 572         tps->usb_type = POWER_SUPPLY_USB_TYPE_C;
 573
 574         tps->psy = devm_power_supply_register(tps->dev, &tps->psy_desc,
 575                                                &psy_cfg);
 576         return PTR_ERR_OR_ZERO(tps->psy);
 577 }
 578
 579 static int tps6598x_probe(struct i2c_client *client)
 580 {
 581         struct typec_capability typec_cap = { };
 582         struct tps6598x *tps;
 583         struct fwnode_handle *fwnode;
 584         u32 status;
 585         u32 conf;
 586         u32 vid;
 587         int ret;
 588
 589         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
 590         if (!tps)
 591                 return -ENOMEM;
 592
 593         mutex_init(&tps->lock);
 594         tps->dev = &client->dev;
 595
 596         tps->regmap = devm_regmap_init_i2c(client, &tps6598x_regmap_config);
 597         if (IS_ERR(tps->regmap))
 598                 return PTR_ERR(tps->regmap);
 599
 600         ret = tps6598x_read32(tps, TPS_REG_VID, &vid);
 601         if (ret < 0 || !vid)
 602                 return -ENODEV;
 603
 604         /*
 605          * Checking can the adapter handle SMBus protocol. If it can not, the
 606          * driver needs to take care of block reads separately.
 607          *
 608          * FIXME: Testing with I2C_FUNC_I2C. regmap-i2c uses I2C protocol
 609          * unconditionally if the adapter has I2C_FUNC_I2C set.
 610          */
 611         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 612                 tps->i2c_protocol = true;
 613
 614         /* Make sure the controller has application firmware running */
 615         ret = tps6598x_check_mode(tps);
 616         if (ret)
 617                 return ret;
 618
 619         ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
 620         if (ret < 0)
 621                 return ret;
 622         trace_tps6598x_status(status);
 623
 624         ret = tps6598x_read32(tps, TPS_REG_SYSTEM_CONF, &conf);
 625         if (ret < 0)
 626                 return ret;
 627
 628         fwnode = device_get_named_child_node(&client->dev, "connector");
 629         if (!fwnode)
 630                 return -ENODEV;
 631
 632         tps->role_sw = fwnode_usb_role_switch_get(fwnode);
 633         if (IS_ERR(tps->role_sw)) {
 634                 ret = PTR_ERR(tps->role_sw);
 635                 goto err_fwnode_put;
 636         }
 637
 638         typec_cap.revision = USB_TYPEC_REV_1_2;
 639         typec_cap.pd_revision = 0x200;
 640         typec_cap.prefer_role = TYPEC_NO_PREFERRED_ROLE;
 641         typec_cap.driver_data = tps;
 642         typec_cap.ops = &tps6598x_ops;
 643         typec_cap.fwnode = fwnode;
 644
 645         switch (TPS_SYSCONF_PORTINFO(conf)) {
 646         case TPS_PORTINFO_SINK_ACCESSORY:
 647         case TPS_PORTINFO_SINK:
 648                 typec_cap.type = TYPEC_PORT_SNK;
 649                 typec_cap.data = TYPEC_PORT_UFP;
 650                 break;
 651         case TPS_PORTINFO_DRP_UFP_DRD:
 652         case TPS_PORTINFO_DRP_DFP_DRD:
 653                 typec_cap.type = TYPEC_PORT_DRP;
 654                 typec_cap.data = TYPEC_PORT_DRD;
 655                 break;
 656         case TPS_PORTINFO_DRP_UFP:
 657                 typec_cap.type = TYPEC_PORT_DRP;
 658                 typec_cap.data = TYPEC_PORT_UFP;
 659                 break;
 660         case TPS_PORTINFO_DRP_DFP:
 661                 typec_cap.type = TYPEC_PORT_DRP;
 662                 typec_cap.data = TYPEC_PORT_DFP;
 663                 break;
 664         case TPS_PORTINFO_SOURCE:
 665                 typec_cap.type = TYPEC_PORT_SRC;
 666                 typec_cap.data = TYPEC_PORT_DFP;
 667                 break;
 668         default:
 669                 ret = -ENODEV;
 670                 goto err_role_put;
 671         }
 672
 673         ret = devm_tps6598_psy_register(tps);
 674         if (ret)
 675                 return ret;
 676
 677         tps->port = typec_register_port(&client->dev, &typec_cap);
 678         if (IS_ERR(tps->port)) {
 679                 ret = PTR_ERR(tps->port);
 680                 goto err_role_put;
 681         }
 682         fwnode_handle_put(fwnode);
 683
 684         if (status & TPS_STATUS_PLUG_PRESENT) {
 685                 ret = tps6598x_connect(tps, status);
 686                 if (ret)
 687                         dev_err(&client->dev, "failed to register partner\n");
 688         }
 689
 690         ret = devm_request_threaded_irq(&client->dev, client->irq, NULL,
 691                                         tps6598x_interrupt,
 692                                         IRQF_SHARED | IRQF_ONESHOT,
 693                                         dev_name(&client->dev), tps);
 694         if (ret) {
 695                 tps6598x_disconnect(tps, 0);
 696                 typec_unregister_port(tps->port);
 697                 goto err_role_put;
 698         }
 699
 700         i2c_set_clientdata(client, tps);
 701
 702         return 0;
 703
 704 err_role_put:
 705         usb_role_switch_put(tps->role_sw);
 706 err_fwnode_put:
 707         fwnode_handle_put(fwnode);
 708
 709         return ret;
 710 }
 711
 712 static int tps6598x_remove(struct i2c_client *client)
 713 {
 714         struct tps6598x *tps = i2c_get_clientdata(client);
 715
 716         tps6598x_disconnect(tps, 0);
 717         typec_unregister_port(tps->port);
 718         usb_role_switch_put(tps->role_sw);
 719
 720         return 0;
 721 }
 722
 723 static const struct of_device_id tps6598x_of_match[] = {
 724         { .compatible = "ti,tps6598x", },
 725         {}
 726 };
 727 MODULE_DEVICE_TABLE(of, tps6598x_of_match);
 728
 729 static const struct i2c_device_id tps6598x_id[] = {
 730         { "tps6598x" },
 731         { }
 732 };
 733 MODULE_DEVICE_TABLE(i2c, tps6598x_id);
 734
 735 static struct i2c_driver tps6598x_i2c_driver = {
 736         .driver = {
 737                 .name = "tps6598x",
 738                 .of_match_table = tps6598x_of_match,
 739         },
 740         .probe_new = tps6598x_probe,
 741         .remove = tps6598x_remove,
 742         .id_table = tps6598x_id,
 743 };
 744 module_i2c_driver(tps6598x_i2c_driver);
 745
 746 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
 747 MODULE_LICENSE("GPL v2");
 748 MODULE_DESCRIPTION("TI TPS6598x USB Power Delivery Controller Driver");