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