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/of.h>
  13 #include <linux/power_supply.h>
  14 #include <linux/regmap.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/usb/typec.h>
  17 #include <linux/usb/typec_altmode.h>
  18 #include <linux/usb/role.h>
  19 #include <linux/workqueue.h>
  20
  21 #include "tps6598x.h"
  22 #include "trace.h"
  23
  24 /* Register offsets */
  25 #define TPS_REG_VID                     0x00
  26 #define TPS_REG_MODE                    0x03
  27 #define TPS_REG_CMD1                    0x08
  28 #define TPS_REG_DATA1                   0x09
  29 #define TPS_REG_INT_EVENT1              0x14
  30 #define TPS_REG_INT_EVENT2              0x15
  31 #define TPS_REG_INT_MASK1               0x16
  32 #define TPS_REG_INT_MASK2               0x17
  33 #define TPS_REG_INT_CLEAR1              0x18
  34 #define TPS_REG_INT_CLEAR2              0x19
  35 #define TPS_REG_SYSTEM_POWER_STATE      0x20
  36 #define TPS_REG_STATUS                  0x1a
  37 #define TPS_REG_SYSTEM_CONF             0x28
  38 #define TPS_REG_CTRL_CONF               0x29
  39 #define TPS_REG_POWER_STATUS            0x3f
  40 #define TPS_REG_RX_IDENTITY_SOP         0x48
  41 #define TPS_REG_DATA_STATUS             0x5f
  42
  43 /* TPS_REG_SYSTEM_CONF bits */
  44 #define TPS_SYSCONF_PORTINFO(c)         ((c) & 7)
  45
  46 enum {
  47         TPS_PORTINFO_SINK,
  48         TPS_PORTINFO_SINK_ACCESSORY,
  49         TPS_PORTINFO_DRP_UFP,
  50         TPS_PORTINFO_DRP_UFP_DRD,
  51         TPS_PORTINFO_DRP_DFP,
  52         TPS_PORTINFO_DRP_DFP_DRD,
  53         TPS_PORTINFO_SOURCE,
  54 };
  55
  56 /* TPS_REG_RX_IDENTITY_SOP */
  57 struct tps6598x_rx_identity_reg {
  58         u8 status;
  59         struct usb_pd_identity identity;
  60 } __packed;
  61
  62 /* Standard Task return codes */
  63 #define TPS_TASK_TIMEOUT                1
  64 #define TPS_TASK_REJECTED               3
  65
  66 enum {
  67         TPS_MODE_APP,
  68         TPS_MODE_BOOT,
  69         TPS_MODE_BIST,
  70         TPS_MODE_DISC,
  71 };
  72
  73 static const char *const modes[] = {
  74         [TPS_MODE_APP]  = "APP ",
  75         [TPS_MODE_BOOT] = "BOOT",
  76         [TPS_MODE_BIST] = "BIST",
  77         [TPS_MODE_DISC] = "DISC",
  78 };
  79
  80 /* Unrecognized commands will be replaced with "!CMD" */
  81 #define INVALID_CMD(_cmd_)              (_cmd_ == 0x444d4321)
  82
  83 struct tps6598x {
  84         struct device *dev;
  85         struct regmap *regmap;
  86         struct mutex lock; /* device lock */
  87         u8 i2c_protocol:1;
  88
  89         struct typec_port *port;
  90         struct typec_partner *partner;
  91         struct usb_pd_identity partner_identity;
  92         struct usb_role_switch *role_sw;
  93         struct typec_capability typec_cap;
  94
  95         struct power_supply *psy;
  96         struct power_supply_desc psy_desc;
  97         enum power_supply_usb_type usb_type;
  98
  99         int wakeup;
 100         u16 pwr_status;
 101         struct delayed_work     wq_poll;
 102         irq_handler_t irq_handler;
 103 };
 104
 105 static enum power_supply_property tps6598x_psy_props[] = {
 106         POWER_SUPPLY_PROP_USB_TYPE,
 107         POWER_SUPPLY_PROP_ONLINE,
 108 };
 109
 110 static enum power_supply_usb_type tps6598x_psy_usb_types[] = {
 111         POWER_SUPPLY_USB_TYPE_C,
 112         POWER_SUPPLY_USB_TYPE_PD,
 113 };
 114
 115 static const char *tps6598x_psy_name_prefix = "tps6598x-source-psy-";
 116
 117 /*
 118  * Max data bytes for Data1, Data2, and other registers. See ch 1.3.2:
 119  * https://www.ti.com/lit/ug/slvuan1a/slvuan1a.pdf
 120  */
 121 #define TPS_MAX_LEN     64
 122
 123 static int
 124 tps6598x_block_read(struct tps6598x *tps, u8 reg, void *val, size_t len)
 125 {
 126         u8 data[TPS_MAX_LEN + 1];
 127         int ret;
 128
 129         if (len + 1 > sizeof(data))
 130                 return -EINVAL;
 131
 132         if (!tps->i2c_protocol)
 133                 return regmap_raw_read(tps->regmap, reg, val, len);
 134
 135         ret = regmap_raw_read(tps->regmap, reg, data, len + 1);
 136         if (ret)
 137                 return ret;
 138
 139         if (data[0] < len)
 140                 return -EIO;
 141
 142         memcpy(val, &data[1], len);
 143         return 0;
 144 }
 145
 146 static int tps6598x_block_write(struct tps6598x *tps, u8 reg,
 147                                 const void *val, size_t len)
 148 {
 149         u8 data[TPS_MAX_LEN + 1];
 150
 151         if (len + 1 > sizeof(data))
 152                 return -EINVAL;
 153
 154         if (!tps->i2c_protocol)
 155                 return regmap_raw_write(tps->regmap, reg, val, len);
 156
 157         data[0] = len;
 158         memcpy(&data[1], val, len);
 159
 160         return regmap_raw_write(tps->regmap, reg, data, len + 1);
 161 }
 162
 163 static inline int tps6598x_read8(struct tps6598x *tps, u8 reg, u8 *val)
 164 {
 165         return tps6598x_block_read(tps, reg, val, sizeof(u8));
 166 }
 167
 168 static inline int tps6598x_read16(struct tps6598x *tps, u8 reg, u16 *val)
 169 {
 170         return tps6598x_block_read(tps, reg, val, sizeof(u16));
 171 }
 172
 173 static inline int tps6598x_read32(struct tps6598x *tps, u8 reg, u32 *val)
 174 {
 175         return tps6598x_block_read(tps, reg, val, sizeof(u32));
 176 }
 177
 178 static inline int tps6598x_read64(struct tps6598x *tps, u8 reg, u64 *val)
 179 {
 180         return tps6598x_block_read(tps, reg, val, sizeof(u64));
 181 }
 182
 183 static inline int tps6598x_write64(struct tps6598x *tps, u8 reg, u64 val)
 184 {
 185         return tps6598x_block_write(tps, reg, &val, sizeof(u64));
 186 }
 187
 188 static inline int
 189 tps6598x_write_4cc(struct tps6598x *tps, u8 reg, const char *val)
 190 {
 191         return tps6598x_block_write(tps, reg, val, 4);
 192 }
 193
 194 static int tps6598x_read_partner_identity(struct tps6598x *tps)
 195 {
 196         struct tps6598x_rx_identity_reg id;
 197         int ret;
 198
 199         ret = tps6598x_block_read(tps, TPS_REG_RX_IDENTITY_SOP,
 200                                   &id, sizeof(id));
 201         if (ret)
 202                 return ret;
 203
 204         tps->partner_identity = id.identity;
 205
 206         return 0;
 207 }
 208
 209 static void tps6598x_set_data_role(struct tps6598x *tps,
 210                                    enum typec_data_role role, bool connected)
 211 {
 212         enum usb_role role_val;
 213
 214         if (role == TYPEC_HOST)
 215                 role_val = USB_ROLE_HOST;
 216         else
 217                 role_val = USB_ROLE_DEVICE;
 218
 219         if (!connected)
 220                 role_val = USB_ROLE_NONE;
 221
 222         usb_role_switch_set_role(tps->role_sw, role_val);
 223         typec_set_data_role(tps->port, role);
 224 }
 225
 226 static int tps6598x_connect(struct tps6598x *tps, u32 status)
 227 {
 228         struct typec_partner_desc desc;
 229         enum typec_pwr_opmode mode;
 230         int ret;
 231
 232         if (tps->partner)
 233                 return 0;
 234
 235         mode = TPS_POWER_STATUS_PWROPMODE(tps->pwr_status);
 236
 237         desc.usb_pd = mode == TYPEC_PWR_MODE_PD;
 238         desc.accessory = TYPEC_ACCESSORY_NONE; /* XXX: handle accessories */
 239         desc.identity = NULL;
 240
 241         if (desc.usb_pd) {
 242                 ret = tps6598x_read_partner_identity(tps);
 243                 if (ret)
 244                         return ret;
 245                 desc.identity = &tps->partner_identity;
 246         }
 247
 248         typec_set_pwr_opmode(tps->port, mode);
 249         typec_set_pwr_role(tps->port, TPS_STATUS_TO_TYPEC_PORTROLE(status));
 250         typec_set_vconn_role(tps->port, TPS_STATUS_TO_TYPEC_VCONN(status));
 251         if (TPS_STATUS_TO_UPSIDE_DOWN(status))
 252                 typec_set_orientation(tps->port, TYPEC_ORIENTATION_REVERSE);
 253         else
 254                 typec_set_orientation(tps->port, TYPEC_ORIENTATION_NORMAL);
 255         typec_set_mode(tps->port, TYPEC_STATE_USB);
 256         tps6598x_set_data_role(tps, TPS_STATUS_TO_TYPEC_DATAROLE(status), true);
 257
 258         tps->partner = typec_register_partner(tps->port, &desc);
 259         if (IS_ERR(tps->partner))
 260                 return PTR_ERR(tps->partner);
 261
 262         if (desc.identity)
 263                 typec_partner_set_identity(tps->partner);
 264
 265         power_supply_changed(tps->psy);
 266
 267         return 0;
 268 }
 269
 270 static void tps6598x_disconnect(struct tps6598x *tps, u32 status)
 271 {
 272         if (!IS_ERR(tps->partner))
 273                 typec_unregister_partner(tps->partner);
 274         tps->partner = NULL;
 275         typec_set_pwr_opmode(tps->port, TYPEC_PWR_MODE_USB);
 276         typec_set_pwr_role(tps->port, TPS_STATUS_TO_TYPEC_PORTROLE(status));
 277         typec_set_vconn_role(tps->port, TPS_STATUS_TO_TYPEC_VCONN(status));
 278         typec_set_orientation(tps->port, TYPEC_ORIENTATION_NONE);
 279         typec_set_mode(tps->port, TYPEC_STATE_SAFE);
 280         tps6598x_set_data_role(tps, TPS_STATUS_TO_TYPEC_DATAROLE(status), false);
 281
 282         power_supply_changed(tps->psy);
 283 }
 284
 285 static int tps6598x_exec_cmd(struct tps6598x *tps, const char *cmd,
 286                              size_t in_len, u8 *in_data,
 287                              size_t out_len, u8 *out_data)
 288 {
 289         unsigned long timeout;
 290         u32 val;
 291         int ret;
 292
 293         ret = tps6598x_read32(tps, TPS_REG_CMD1, &val);
 294         if (ret)
 295                 return ret;
 296         if (val && !INVALID_CMD(val))
 297                 return -EBUSY;
 298
 299         if (in_len) {
 300                 ret = tps6598x_block_write(tps, TPS_REG_DATA1,
 301                                            in_data, in_len);
 302                 if (ret)
 303                         return ret;
 304         }
 305
 306         ret = tps6598x_write_4cc(tps, TPS_REG_CMD1, cmd);
 307         if (ret < 0)
 308                 return ret;
 309
 310         /* XXX: Using 1s for now, but it may not be enough for every command. */
 311         timeout = jiffies + msecs_to_jiffies(1000);
 312
 313         do {
 314                 ret = tps6598x_read32(tps, TPS_REG_CMD1, &val);
 315                 if (ret)
 316                         return ret;
 317                 if (INVALID_CMD(val))
 318                         return -EINVAL;
 319
 320                 if (time_is_before_jiffies(timeout))
 321                         return -ETIMEDOUT;
 322         } while (val);
 323
 324         if (out_len) {
 325                 ret = tps6598x_block_read(tps, TPS_REG_DATA1,
 326                                           out_data, out_len);
 327                 if (ret)
 328                         return ret;
 329                 val = out_data[0];
 330         } else {
 331                 ret = tps6598x_block_read(tps, TPS_REG_DATA1, &val, sizeof(u8));
 332                 if (ret)
 333                         return ret;
 334         }
 335
 336         switch (val) {
 337         case TPS_TASK_TIMEOUT:
 338                 return -ETIMEDOUT;
 339         case TPS_TASK_REJECTED:
 340                 return -EPERM;
 341         default:
 342                 break;
 343         }
 344
 345         return 0;
 346 }
 347
 348 static int tps6598x_dr_set(struct typec_port *port, enum typec_data_role role)
 349 {
 350         const char *cmd = (role == TYPEC_DEVICE) ? "SWUF" : "SWDF";
 351         struct tps6598x *tps = typec_get_drvdata(port);
 352         u32 status;
 353         int ret;
 354
 355         mutex_lock(&tps->lock);
 356
 357         ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL);
 358         if (ret)
 359                 goto out_unlock;
 360
 361         ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
 362         if (ret)
 363                 goto out_unlock;
 364
 365         if (role != TPS_STATUS_TO_TYPEC_DATAROLE(status)) {
 366                 ret = -EPROTO;
 367                 goto out_unlock;
 368         }
 369
 370         tps6598x_set_data_role(tps, role, true);
 371
 372 out_unlock:
 373         mutex_unlock(&tps->lock);
 374
 375         return ret;
 376 }
 377
 378 static int tps6598x_pr_set(struct typec_port *port, enum typec_role role)
 379 {
 380         const char *cmd = (role == TYPEC_SINK) ? "SWSk" : "SWSr";
 381         struct tps6598x *tps = typec_get_drvdata(port);
 382         u32 status;
 383         int ret;
 384
 385         mutex_lock(&tps->lock);
 386
 387         ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL);
 388         if (ret)
 389                 goto out_unlock;
 390
 391         ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
 392         if (ret)
 393                 goto out_unlock;
 394
 395         if (role != TPS_STATUS_TO_TYPEC_PORTROLE(status)) {
 396                 ret = -EPROTO;
 397                 goto out_unlock;
 398         }
 399
 400         typec_set_pwr_role(tps->port, role);
 401
 402 out_unlock:
 403         mutex_unlock(&tps->lock);
 404
 405         return ret;
 406 }
 407
 408 static const struct typec_operations tps6598x_ops = {
 409         .dr_set = tps6598x_dr_set,
 410         .pr_set = tps6598x_pr_set,
 411 };
 412
 413 static bool tps6598x_read_status(struct tps6598x *tps, u32 *status)
 414 {
 415         int ret;
 416
 417         ret = tps6598x_read32(tps, TPS_REG_STATUS, status);
 418         if (ret) {
 419                 dev_err(tps->dev, "%s: failed to read status\n", __func__);
 420                 return false;
 421         }
 422         trace_tps6598x_status(*status);
 423
 424         return true;
 425 }
 426
 427 static bool tps6598x_read_data_status(struct tps6598x *tps)
 428 {
 429         u32 data_status;
 430         int ret;
 431
 432         ret = tps6598x_read32(tps, TPS_REG_DATA_STATUS, &data_status);
 433         if (ret < 0) {
 434                 dev_err(tps->dev, "failed to read data status: %d\n", ret);
 435                 return false;
 436         }
 437         trace_tps6598x_data_status(data_status);
 438
 439         return true;
 440 }
 441
 442 static bool tps6598x_read_power_status(struct tps6598x *tps)
 443 {
 444         u16 pwr_status;
 445         int ret;
 446
 447         ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status);
 448         if (ret < 0) {
 449                 dev_err(tps->dev, "failed to read power status: %d\n", ret);
 450                 return false;
 451         }
 452         tps->pwr_status = pwr_status;
 453         trace_tps6598x_power_status(pwr_status);
 454
 455         return true;
 456 }
 457
 458 static void tps6598x_handle_plug_event(struct tps6598x *tps, u32 status)
 459 {
 460         int ret;
 461
 462         if (status & TPS_STATUS_PLUG_PRESENT) {
 463                 ret = tps6598x_connect(tps, status);
 464                 if (ret)
 465                         dev_err(tps->dev, "failed to register partner\n");
 466         } else {
 467                 tps6598x_disconnect(tps, status);
 468         }
 469 }
 470
 471 static irqreturn_t cd321x_interrupt(int irq, void *data)
 472 {
 473         struct tps6598x *tps = data;
 474         u64 event = 0;
 475         u32 status;
 476         int ret;
 477
 478         mutex_lock(&tps->lock);
 479
 480         ret = tps6598x_read64(tps, TPS_REG_INT_EVENT1, &event);
 481         if (ret) {
 482                 dev_err(tps->dev, "%s: failed to read events\n", __func__);
 483                 goto err_unlock;
 484         }
 485         trace_cd321x_irq(event);
 486
 487         if (!event)
 488                 goto err_unlock;
 489
 490         if (!tps6598x_read_status(tps, &status))
 491                 goto err_clear_ints;
 492
 493         if (event & APPLE_CD_REG_INT_POWER_STATUS_UPDATE)
 494                 if (!tps6598x_read_power_status(tps))
 495                         goto err_clear_ints;
 496
 497         if (event & APPLE_CD_REG_INT_DATA_STATUS_UPDATE)
 498                 if (!tps6598x_read_data_status(tps))
 499                         goto err_clear_ints;
 500
 501         /* Handle plug insert or removal */
 502         if (event & APPLE_CD_REG_INT_PLUG_EVENT)
 503                 tps6598x_handle_plug_event(tps, status);
 504
 505 err_clear_ints:
 506         tps6598x_write64(tps, TPS_REG_INT_CLEAR1, event);
 507
 508 err_unlock:
 509         mutex_unlock(&tps->lock);
 510
 511         if (event)
 512                 return IRQ_HANDLED;
 513         return IRQ_NONE;
 514 }
 515
 516 static irqreturn_t tps6598x_interrupt(int irq, void *data)
 517 {
 518         struct tps6598x *tps = data;
 519         u64 event1 = 0;
 520         u64 event2 = 0;
 521         u32 status;
 522         int ret;
 523
 524         mutex_lock(&tps->lock);
 525
 526         ret = tps6598x_read64(tps, TPS_REG_INT_EVENT1, &event1);
 527         ret |= tps6598x_read64(tps, TPS_REG_INT_EVENT2, &event2);
 528         if (ret) {
 529                 dev_err(tps->dev, "%s: failed to read events\n", __func__);
 530                 goto err_unlock;
 531         }
 532         trace_tps6598x_irq(event1, event2);
 533
 534         if (!(event1 | event2))
 535                 goto err_unlock;
 536
 537         if (!tps6598x_read_status(tps, &status))
 538                 goto err_clear_ints;
 539
 540         if ((event1 | event2) & TPS_REG_INT_POWER_STATUS_UPDATE)
 541                 if (!tps6598x_read_power_status(tps))
 542                         goto err_clear_ints;
 543
 544         if ((event1 | event2) & TPS_REG_INT_DATA_STATUS_UPDATE)
 545                 if (!tps6598x_read_data_status(tps))
 546                         goto err_clear_ints;
 547
 548         /* Handle plug insert or removal */
 549         if ((event1 | event2) & TPS_REG_INT_PLUG_EVENT)
 550                 tps6598x_handle_plug_event(tps, status);
 551
 552 err_clear_ints:
 553         tps6598x_write64(tps, TPS_REG_INT_CLEAR1, event1);
 554         tps6598x_write64(tps, TPS_REG_INT_CLEAR2, event2);
 555
 556 err_unlock:
 557         mutex_unlock(&tps->lock);
 558
 559         if (event1 | event2)
 560                 return IRQ_HANDLED;
 561         return IRQ_NONE;
 562 }
 563
 564 /* Time interval for Polling */
 565 #define POLL_INTERVAL   500 /* msecs */
 566 static void tps6598x_poll_work(struct work_struct *work)
 567 {
 568         struct tps6598x *tps = container_of(to_delayed_work(work),
 569                                             struct tps6598x, wq_poll);
 570
 571         tps->irq_handler(0, tps);
 572         queue_delayed_work(system_power_efficient_wq,
 573                            &tps->wq_poll, msecs_to_jiffies(POLL_INTERVAL));
 574 }
 575
 576 static int tps6598x_check_mode(struct tps6598x *tps)
 577 {
 578         char mode[5] = { };
 579         int ret;
 580
 581         ret = tps6598x_read32(tps, TPS_REG_MODE, (void *)mode);
 582         if (ret)
 583                 return ret;
 584
 585         switch (match_string(modes, ARRAY_SIZE(modes), mode)) {
 586         case TPS_MODE_APP:
 587                 return 0;
 588         case TPS_MODE_BOOT:
 589                 dev_warn(tps->dev, "dead-battery condition\n");
 590                 return 0;
 591         case TPS_MODE_BIST:
 592         case TPS_MODE_DISC:
 593         default:
 594                 dev_err(tps->dev, "controller in unsupported mode \"%s\"\n",
 595                         mode);
 596                 break;
 597         }
 598
 599         return -ENODEV;
 600 }
 601
 602 static const struct regmap_config tps6598x_regmap_config = {
 603         .reg_bits = 8,
 604         .val_bits = 8,
 605         .max_register = 0x7F,
 606 };
 607
 608 static int tps6598x_psy_get_online(struct tps6598x *tps,
 609                                    union power_supply_propval *val)
 610 {
 611         if (TPS_POWER_STATUS_CONNECTION(tps->pwr_status) &&
 612             TPS_POWER_STATUS_SOURCESINK(tps->pwr_status)) {
 613                 val->intval = 1;
 614         } else {
 615                 val->intval = 0;
 616         }
 617         return 0;
 618 }
 619
 620 static int tps6598x_psy_get_prop(struct power_supply *psy,
 621                                  enum power_supply_property psp,
 622                                  union power_supply_propval *val)
 623 {
 624         struct tps6598x *tps = power_supply_get_drvdata(psy);
 625         int ret = 0;
 626
 627         switch (psp) {
 628         case POWER_SUPPLY_PROP_USB_TYPE:
 629                 if (TPS_POWER_STATUS_PWROPMODE(tps->pwr_status) == TYPEC_PWR_MODE_PD)
 630                         val->intval = POWER_SUPPLY_USB_TYPE_PD;
 631                 else
 632                         val->intval = POWER_SUPPLY_USB_TYPE_C;
 633                 break;
 634         case POWER_SUPPLY_PROP_ONLINE:
 635                 ret = tps6598x_psy_get_online(tps, val);
 636                 break;
 637         default:
 638                 ret = -EINVAL;
 639                 break;
 640         }
 641
 642         return ret;
 643 }
 644
 645 static int cd321x_switch_power_state(struct tps6598x *tps, u8 target_state)
 646 {
 647         u8 state;
 648         int ret;
 649
 650         ret = tps6598x_read8(tps, TPS_REG_SYSTEM_POWER_STATE, &state);
 651         if (ret)
 652                 return ret;
 653
 654         if (state == target_state)
 655                 return 0;
 656
 657         ret = tps6598x_exec_cmd(tps, "SSPS", sizeof(u8), &target_state, 0, NULL);
 658         if (ret)
 659                 return ret;
 660
 661         ret = tps6598x_read8(tps, TPS_REG_SYSTEM_POWER_STATE, &state);
 662         if (ret)
 663                 return ret;
 664
 665         if (state != target_state)
 666                 return -EINVAL;
 667
 668         return 0;
 669 }
 670
 671 static int devm_tps6598_psy_register(struct tps6598x *tps)
 672 {
 673         struct power_supply_config psy_cfg = {};
 674         const char *port_dev_name = dev_name(tps->dev);
 675         char *psy_name;
 676
 677         psy_cfg.drv_data = tps;
 678         psy_cfg.fwnode = dev_fwnode(tps->dev);
 679
 680         psy_name = devm_kasprintf(tps->dev, GFP_KERNEL, "%s%s", tps6598x_psy_name_prefix,
 681                                   port_dev_name);
 682         if (!psy_name)
 683                 return -ENOMEM;
 684
 685         tps->psy_desc.name = psy_name;
 686         tps->psy_desc.type = POWER_SUPPLY_TYPE_USB;
 687         tps->psy_desc.usb_types = tps6598x_psy_usb_types;
 688         tps->psy_desc.num_usb_types = ARRAY_SIZE(tps6598x_psy_usb_types);
 689         tps->psy_desc.properties = tps6598x_psy_props;
 690         tps->psy_desc.num_properties = ARRAY_SIZE(tps6598x_psy_props);
 691         tps->psy_desc.get_property = tps6598x_psy_get_prop;
 692
 693         tps->usb_type = POWER_SUPPLY_USB_TYPE_C;
 694
 695         tps->psy = devm_power_supply_register(tps->dev, &tps->psy_desc,
 696                                                &psy_cfg);
 697         return PTR_ERR_OR_ZERO(tps->psy);
 698 }
 699
 700 static int tps6598x_probe(struct i2c_client *client)
 701 {
 702         irq_handler_t irq_handler = tps6598x_interrupt;
 703         struct device_node *np = client->dev.of_node;
 704         struct typec_capability typec_cap = { };
 705         struct tps6598x *tps;
 706         struct fwnode_handle *fwnode;
 707         u32 status;
 708         u32 conf;
 709         u32 vid;
 710         int ret;
 711         u64 mask1;
 712
 713         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
 714         if (!tps)
 715                 return -ENOMEM;
 716
 717         mutex_init(&tps->lock);
 718         tps->dev = &client->dev;
 719
 720         tps->regmap = devm_regmap_init_i2c(client, &tps6598x_regmap_config);
 721         if (IS_ERR(tps->regmap))
 722                 return PTR_ERR(tps->regmap);
 723
 724         ret = tps6598x_read32(tps, TPS_REG_VID, &vid);
 725         if (ret < 0 || !vid)
 726                 return -ENODEV;
 727
 728         /*
 729          * Checking can the adapter handle SMBus protocol. If it can not, the
 730          * driver needs to take care of block reads separately.
 731          */
 732         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 733                 tps->i2c_protocol = true;
 734
 735         if (np && of_device_is_compatible(np, "apple,cd321x")) {
 736                 /* Switch CD321X chips to the correct system power state */
 737                 ret = cd321x_switch_power_state(tps, TPS_SYSTEM_POWER_STATE_S0);
 738                 if (ret)
 739                         return ret;
 740
 741                 /* CD321X chips have all interrupts masked initially */
 742                 mask1 = APPLE_CD_REG_INT_POWER_STATUS_UPDATE |
 743                         APPLE_CD_REG_INT_DATA_STATUS_UPDATE |
 744                         APPLE_CD_REG_INT_PLUG_EVENT;
 745
 746                 irq_handler = cd321x_interrupt;
 747         } else {
 748                 /* Enable power status, data status and plug event interrupts */
 749                 mask1 = TPS_REG_INT_POWER_STATUS_UPDATE |
 750                         TPS_REG_INT_DATA_STATUS_UPDATE |
 751                         TPS_REG_INT_PLUG_EVENT;
 752         }
 753
 754         tps->irq_handler = irq_handler;
 755         /* Make sure the controller has application firmware running */
 756         ret = tps6598x_check_mode(tps);
 757         if (ret)
 758                 return ret;
 759
 760         ret = tps6598x_write64(tps, TPS_REG_INT_MASK1, mask1);
 761         if (ret)
 762                 return ret;
 763
 764         ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
 765         if (ret < 0)
 766                 goto err_clear_mask;
 767         trace_tps6598x_status(status);
 768
 769         ret = tps6598x_read32(tps, TPS_REG_SYSTEM_CONF, &conf);
 770         if (ret < 0)
 771                 goto err_clear_mask;
 772
 773         /*
 774          * This fwnode has a "compatible" property, but is never populated as a
 775          * struct device. Instead we simply parse it to read the properties.
 776          * This breaks fw_devlink=on. To maintain backward compatibility
 777          * with existing DT files, we work around this by deleting any
 778          * fwnode_links to/from this fwnode.
 779          */
 780         fwnode = device_get_named_child_node(&client->dev, "connector");
 781         if (fwnode)
 782                 fw_devlink_purge_absent_suppliers(fwnode);
 783
 784         tps->role_sw = fwnode_usb_role_switch_get(fwnode);
 785         if (IS_ERR(tps->role_sw)) {
 786                 ret = PTR_ERR(tps->role_sw);
 787                 goto err_fwnode_put;
 788         }
 789
 790         typec_cap.revision = USB_TYPEC_REV_1_2;
 791         typec_cap.pd_revision = 0x200;
 792         typec_cap.prefer_role = TYPEC_NO_PREFERRED_ROLE;
 793         typec_cap.driver_data = tps;
 794         typec_cap.ops = &tps6598x_ops;
 795         typec_cap.fwnode = fwnode;
 796
 797         switch (TPS_SYSCONF_PORTINFO(conf)) {
 798         case TPS_PORTINFO_SINK_ACCESSORY:
 799         case TPS_PORTINFO_SINK:
 800                 typec_cap.type = TYPEC_PORT_SNK;
 801                 typec_cap.data = TYPEC_PORT_UFP;
 802                 break;
 803         case TPS_PORTINFO_DRP_UFP_DRD:
 804         case TPS_PORTINFO_DRP_DFP_DRD:
 805                 typec_cap.type = TYPEC_PORT_DRP;
 806                 typec_cap.data = TYPEC_PORT_DRD;
 807                 break;
 808         case TPS_PORTINFO_DRP_UFP:
 809                 typec_cap.type = TYPEC_PORT_DRP;
 810                 typec_cap.data = TYPEC_PORT_UFP;
 811                 break;
 812         case TPS_PORTINFO_DRP_DFP:
 813                 typec_cap.type = TYPEC_PORT_DRP;
 814                 typec_cap.data = TYPEC_PORT_DFP;
 815                 break;
 816         case TPS_PORTINFO_SOURCE:
 817                 typec_cap.type = TYPEC_PORT_SRC;
 818                 typec_cap.data = TYPEC_PORT_DFP;
 819                 break;
 820         default:
 821                 ret = -ENODEV;
 822                 goto err_role_put;
 823         }
 824
 825         ret = devm_tps6598_psy_register(tps);
 826         if (ret)
 827                 goto err_role_put;
 828
 829         tps->port = typec_register_port(&client->dev, &typec_cap);
 830         if (IS_ERR(tps->port)) {
 831                 ret = PTR_ERR(tps->port);
 832                 goto err_role_put;
 833         }
 834
 835         if (status & TPS_STATUS_PLUG_PRESENT) {
 836                 ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &tps->pwr_status);
 837                 if (ret < 0) {
 838                         dev_err(tps->dev, "failed to read power status: %d\n", ret);
 839                         goto err_unregister_port;
 840                 }
 841                 ret = tps6598x_connect(tps, status);
 842                 if (ret)
 843                         dev_err(&client->dev, "failed to register partner\n");
 844         }
 845
 846         if (client->irq) {
 847                 ret = devm_request_threaded_irq(&client->dev, client->irq, NULL,
 848                                                 irq_handler,
 849                                                 IRQF_SHARED | IRQF_ONESHOT,
 850                                                 dev_name(&client->dev), tps);
 851         } else {
 852                 dev_warn(tps->dev, "Unable to find the interrupt, switching to polling\n");
 853                 INIT_DELAYED_WORK(&tps->wq_poll, tps6598x_poll_work);
 854                 queue_delayed_work(system_power_efficient_wq, &tps->wq_poll,
 855                                    msecs_to_jiffies(POLL_INTERVAL));
 856         }
 857
 858         if (ret)
 859                 goto err_disconnect;
 860
 861         i2c_set_clientdata(client, tps);
 862         fwnode_handle_put(fwnode);
 863
 864         tps->wakeup = device_property_read_bool(tps->dev, "wakeup-source");
 865         if (tps->wakeup && client->irq) {
 866                 device_init_wakeup(&client->dev, true);
 867                 enable_irq_wake(client->irq);
 868         }
 869
 870         return 0;
 871
 872 err_disconnect:
 873         tps6598x_disconnect(tps, 0);
 874 err_unregister_port:
 875         typec_unregister_port(tps->port);
 876 err_role_put:
 877         usb_role_switch_put(tps->role_sw);
 878 err_fwnode_put:
 879         fwnode_handle_put(fwnode);
 880 err_clear_mask:
 881         tps6598x_write64(tps, TPS_REG_INT_MASK1, 0);
 882         return ret;
 883 }
 884
 885 static void tps6598x_remove(struct i2c_client *client)
 886 {
 887         struct tps6598x *tps = i2c_get_clientdata(client);
 888
 889         if (!client->irq)
 890                 cancel_delayed_work_sync(&tps->wq_poll);
 891
 892         tps6598x_disconnect(tps, 0);
 893         typec_unregister_port(tps->port);
 894         usb_role_switch_put(tps->role_sw);
 895 }
 896
 897 static int __maybe_unused tps6598x_suspend(struct device *dev)
 898 {
 899         struct i2c_client *client = to_i2c_client(dev);
 900         struct tps6598x *tps = i2c_get_clientdata(client);
 901
 902         if (tps->wakeup) {
 903                 disable_irq(client->irq);
 904                 enable_irq_wake(client->irq);
 905         }
 906
 907         if (!client->irq)
 908                 cancel_delayed_work_sync(&tps->wq_poll);
 909
 910         return 0;
 911 }
 912
 913 static int __maybe_unused tps6598x_resume(struct device *dev)
 914 {
 915         struct i2c_client *client = to_i2c_client(dev);
 916         struct tps6598x *tps = i2c_get_clientdata(client);
 917
 918         if (tps->wakeup) {
 919                 disable_irq_wake(client->irq);
 920                 enable_irq(client->irq);
 921         }
 922
 923         if (client->irq)
 924                 queue_delayed_work(system_power_efficient_wq, &tps->wq_poll,
 925                                    msecs_to_jiffies(POLL_INTERVAL));
 926
 927         return 0;
 928 }
 929
 930 static const struct dev_pm_ops tps6598x_pm_ops = {
 931         SET_SYSTEM_SLEEP_PM_OPS(tps6598x_suspend, tps6598x_resume)
 932 };
 933
 934 static const struct of_device_id tps6598x_of_match[] = {
 935         { .compatible = "ti,tps6598x", },
 936         { .compatible = "apple,cd321x", },
 937         {}
 938 };
 939 MODULE_DEVICE_TABLE(of, tps6598x_of_match);
 940
 941 static const struct i2c_device_id tps6598x_id[] = {
 942         { "tps6598x" },
 943         { }
 944 };
 945 MODULE_DEVICE_TABLE(i2c, tps6598x_id);
 946
 947 static struct i2c_driver tps6598x_i2c_driver = {
 948         .driver = {
 949                 .name = "tps6598x",
 950                 .pm = &tps6598x_pm_ops,
 951                 .of_match_table = tps6598x_of_match,
 952         },
 953         .probe_new = tps6598x_probe,
 954         .remove = tps6598x_remove,
 955         .id_table = tps6598x_id,
 956 };
 957 module_i2c_driver(tps6598x_i2c_driver);
 958
 959 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
 960 MODULE_LICENSE("GPL v2");
 961 MODULE_DESCRIPTION("TI TPS6598x USB Power Delivery Controller Driver");