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