drivers/usb/typec/rt1719.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include <linux/bitfield.h>
   4 #include <linux/completion.h>
   5 #include <linux/i2c.h>
   6 #include <linux/interrupt.h>
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/power_supply.h>
  10 #include <linux/regmap.h>
  11 #include <linux/usb/pd.h>
  12 #include <linux/usb/role.h>
  13 #include <linux/usb/typec.h>
  14
  15 #define RT1719_REG_TXCTRL1      0x03
  16 #define RT1719_REG_TXCTRL2      0x04
  17 #define RT1719_REG_POLICYINFO   0x0E
  18 #define RT1719_REG_SRCPDO1      0x11
  19 #define RT1719_REG_MASKS        0x2D
  20 #define RT1719_REG_EVENTS       0x33
  21 #define RT1719_REG_STATS        0x37
  22 #define RT1719_REG_PSELINFO     0x3C
  23 #define RT1719_REG_USBSETINFO   0x3E
  24 #define RT1719_REG_VENID        0x82
  25
  26 #define RT1719_UNIQUE_PID       0x1719
  27 #define RT1719_REQDRSWAP_MASK   BIT(7)
  28 #define RT1719_EVALMODE_MASK    BIT(4)
  29 #define RT1719_REQSRCPDO_MASK   GENMASK(2, 0)
  30 #define RT1719_TXSPDOREQ_MASK   BIT(7)
  31 #define RT1719_INT_DRSW_ACCEPT  BIT(23)
  32 #define RT1719_INT_RX_SRCCAP    BIT(21)
  33 #define RT1719_INT_VBUS_DCT     BIT(6)
  34 #define RT1719_INT_VBUS_PRESENT BIT(5)
  35 #define RT1719_INT_PE_SNK_RDY   BIT(2)
  36 #define RT1719_CC1_STAT         GENMASK(9, 8)
  37 #define RT1719_CC2_STAT         GENMASK(11, 10)
  38 #define RT1719_POLARITY_MASK    BIT(23)
  39 #define RT1719_DATAROLE_MASK    BIT(22)
  40 #define RT1719_PDSPECREV_MASK   GENMASK(21, 20)
  41 #define RT1719_SPDOSEL_MASK     GENMASK(18, 16)
  42 #define RT1719_SPDONUM_MASK     GENMASK(15, 13)
  43 #define RT1719_ATTACH_VBUS      BIT(12)
  44 #define RT1719_ATTACH_DBG       BIT(10)
  45 #define RT1719_ATTACH_SNK       BIT(9)
  46 #define RT1719_ATTACHDEV_MASK   (RT1719_ATTACH_VBUS | RT1719_ATTACH_DBG | \
  47                                  RT1719_ATTACH_SNK)
  48 #define RT1719_PE_EXP_CONTRACT  BIT(2)
  49 #define RT1719_PSEL_SUPPORT     BIT(15)
  50 #define RT1719_TBLSEL_MASK      BIT(6)
  51 #define RT1719_LATPSEL_MASK     GENMASK(5, 0)
  52 #define RT1719_USBINFO_MASK     GENMASK(1, 0)
  53 #define RT1719_USB_DFPUFP       3
  54 #define RT1719_MAX_SRCPDO       7
  55
  56 enum {
  57         SNK_PWR_OPEN = 0,
  58         SNK_PWR_DEF,
  59         SNK_PWR_1P5A,
  60         SNK_PWR_3A
  61 };
  62
  63 enum {
  64         USBPD_SPECREV_1_0 = 0,
  65         USBPD_SPECREV_2_0,
  66         USBPD_SPECREV_3_0
  67 };
  68
  69 enum rt1719_snkcap {
  70         RT1719_SNKCAP_5V = 0,
  71         RT1719_SNKCAP_9V,
  72         RT1719_SNKCAP_12V,
  73         RT1719_SNKCAP_15V,
  74         RT1719_SNKCAP_20V,
  75         RT1719_MAX_SNKCAP
  76 };
  77
  78 struct rt1719_psel_cap {
  79         u8 lomask;
  80         u8 himask;
  81         u32 milliwatt;
  82         u32 milliamp;
  83 };
  84
  85 struct rt1719_data {
  86         struct device *dev;
  87         struct regmap *regmap;
  88         struct typec_port *port;
  89         struct usb_role_switch *role_sw;
  90         struct power_supply *psy;
  91         struct typec_partner *partner;
  92         struct power_supply_desc psy_desc;
  93         struct usb_pd_identity partner_ident;
  94         struct typec_partner_desc partner_desc;
  95         struct completion req_completion;
  96         enum power_supply_usb_type usb_type;
  97         bool attached;
  98         bool pd_capable;
  99         bool drswap_support;
 100         u32 voltage;
 101         u32 req_voltage;
 102         u32 max_current;
 103         u32 op_current;
 104         u32 spdos[RT1719_MAX_SRCPDO];
 105         u16 snkcaps[RT1719_MAX_SNKCAP];
 106         int spdo_num;
 107         int spdo_sel;
 108         u32 conn_info;
 109         u16 conn_stat;
 110 };
 111
 112 static const enum power_supply_usb_type rt1719_psy_usb_types[] = {
 113         POWER_SUPPLY_USB_TYPE_C,
 114         POWER_SUPPLY_USB_TYPE_PD,
 115         POWER_SUPPLY_USB_TYPE_PD_PPS
 116 };
 117
 118 static const enum power_supply_property rt1719_psy_properties[] = {
 119         POWER_SUPPLY_PROP_ONLINE,
 120         POWER_SUPPLY_PROP_USB_TYPE,
 121         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 122         POWER_SUPPLY_PROP_CURRENT_MAX,
 123         POWER_SUPPLY_PROP_CURRENT_NOW
 124 };
 125
 126 static int rt1719_read16(struct rt1719_data *data, unsigned int reg, u16 *val)
 127 {
 128         __le16 regval;
 129         int ret;
 130
 131         ret = regmap_raw_read(data->regmap, reg, &regval, sizeof(regval));
 132         if (ret)
 133                 return ret;
 134
 135         *val = le16_to_cpu(regval);
 136         return 0;
 137 }
 138
 139 static int rt1719_read32(struct rt1719_data *data, unsigned int reg, u32 *val)
 140 {
 141         __le32 regval;
 142         int ret;
 143
 144         ret = regmap_raw_read(data->regmap, reg, &regval, sizeof(regval));
 145         if (ret)
 146                 return ret;
 147
 148         *val = le32_to_cpu(regval);
 149         return 0;
 150 }
 151
 152 static int rt1719_write32(struct rt1719_data *data, unsigned int reg, u32 val)
 153 {
 154         __le32 regval = cpu_to_le32(val);
 155
 156         return regmap_raw_write(data->regmap, reg, &regval, sizeof(regval));
 157 }
 158
 159 static enum typec_pwr_opmode rt1719_get_pwr_opmode(u32 conn, u16 stat)
 160 {
 161         u16 cc1, cc2, cc_stat;
 162
 163         cc1 = FIELD_GET(RT1719_CC1_STAT, stat);
 164         cc2 = FIELD_GET(RT1719_CC2_STAT, stat);
 165
 166         if (conn & RT1719_ATTACH_SNK) {
 167                 if (conn & RT1719_POLARITY_MASK)
 168                         cc_stat = cc2;
 169                 else
 170                         cc_stat = cc1;
 171
 172                 switch (cc_stat) {
 173                 case SNK_PWR_3A:
 174                         return TYPEC_PWR_MODE_3_0A;
 175                 case SNK_PWR_1P5A:
 176                         return TYPEC_PWR_MODE_1_5A;
 177                 }
 178         } else if (conn & RT1719_ATTACH_DBG) {
 179                 if ((cc1 == SNK_PWR_1P5A && cc2 == SNK_PWR_DEF) ||
 180                     (cc1 == SNK_PWR_DEF && cc2 == SNK_PWR_1P5A))
 181                         return TYPEC_PWR_MODE_1_5A;
 182                 else if ((cc1 == SNK_PWR_3A && cc2 == SNK_PWR_DEF) ||
 183                          (cc1 == SNK_PWR_DEF && cc2 == SNK_PWR_3A))
 184                         return TYPEC_PWR_MODE_3_0A;
 185         }
 186
 187         return TYPEC_PWR_MODE_USB;
 188 }
 189
 190 static enum typec_data_role rt1719_get_data_role(u32 conn)
 191 {
 192         if (conn & RT1719_DATAROLE_MASK)
 193                 return TYPEC_HOST;
 194         return TYPEC_DEVICE;
 195 }
 196
 197 static void rt1719_set_data_role(struct rt1719_data *data,
 198                                  enum typec_data_role data_role,
 199                                  bool attached)
 200 {
 201         enum usb_role usb_role = USB_ROLE_NONE;
 202
 203         if (attached) {
 204                 if (data_role == TYPEC_HOST)
 205                         usb_role = USB_ROLE_HOST;
 206                 else
 207                         usb_role = USB_ROLE_DEVICE;
 208         }
 209
 210         usb_role_switch_set_role(data->role_sw, usb_role);
 211         typec_set_data_role(data->port, data_role);
 212 }
 213
 214 static void rt1719_update_data_role(struct rt1719_data *data)
 215 {
 216         if (!data->attached)
 217                 return;
 218
 219         rt1719_set_data_role(data, rt1719_get_data_role(data->conn_info), true);
 220 }
 221
 222 static void rt1719_register_partner(struct rt1719_data *data)
 223 {
 224         u16 spec_rev = 0;
 225
 226         if (data->pd_capable) {
 227                 u32 rev;
 228
 229                 rev = FIELD_GET(RT1719_PDSPECREV_MASK, data->conn_info);
 230                 switch (rev) {
 231                 case USBPD_SPECREV_3_0:
 232                         spec_rev = 0x0300;
 233                         break;
 234                 case USBPD_SPECREV_2_0:
 235                         spec_rev = 0x0200;
 236                         break;
 237                 default:
 238                         spec_rev = 0x0100;
 239                         break;
 240                 }
 241         }
 242
 243         /* Just to prevent multiple times attach */
 244         if (data->partner)
 245                 typec_unregister_partner(data->partner);
 246
 247         memset(&data->partner_ident, 0, sizeof(data->partner_ident));
 248         data->partner_desc.usb_pd = data->pd_capable;
 249         data->partner_desc.pd_revision = spec_rev;
 250
 251         if (data->conn_info & RT1719_ATTACH_DBG)
 252                 data->partner_desc.accessory = TYPEC_ACCESSORY_DEBUG;
 253         else
 254                 data->partner_desc.accessory = TYPEC_ACCESSORY_NONE;
 255
 256         data->partner = typec_register_partner(data->port, &data->partner_desc);
 257 }
 258
 259 static void rt1719_attach(struct rt1719_data *data)
 260 {
 261         enum typec_pwr_opmode pwr_opmode;
 262         enum typec_data_role data_role;
 263         u32 volt = 5000, curr = 500;
 264
 265         if (!(data->conn_info & RT1719_ATTACHDEV_MASK))
 266                 return;
 267
 268         pwr_opmode = rt1719_get_pwr_opmode(data->conn_info, data->conn_stat);
 269         data_role = rt1719_get_data_role(data->conn_info);
 270
 271         typec_set_pwr_opmode(data->port, pwr_opmode);
 272         rt1719_set_data_role(data, data_role, true);
 273
 274         if (data->conn_info & RT1719_ATTACH_SNK)
 275                 rt1719_register_partner(data);
 276
 277         if (pwr_opmode == TYPEC_PWR_MODE_3_0A)
 278                 curr = 3000;
 279         else if (pwr_opmode == TYPEC_PWR_MODE_1_5A)
 280                 curr = 1500;
 281
 282         data->voltage = volt * 1000;
 283         data->max_current = data->op_current = curr * 1000;
 284         data->attached = true;
 285
 286         power_supply_changed(data->psy);
 287 }
 288
 289 static void rt1719_detach(struct rt1719_data *data)
 290 {
 291         if (!data->attached || (data->conn_info & RT1719_ATTACHDEV_MASK))
 292                 return;
 293
 294         typec_unregister_partner(data->partner);
 295         data->partner = NULL;
 296
 297         typec_set_pwr_opmode(data->port, TYPEC_PWR_MODE_USB);
 298         rt1719_set_data_role(data, TYPEC_DEVICE, false);
 299
 300         memset32(data->spdos, 0, RT1719_MAX_SRCPDO);
 301         data->spdo_num = 0;
 302         data->voltage = data->max_current = data->op_current = 0;
 303         data->attached = data->pd_capable = false;
 304
 305         data->usb_type = POWER_SUPPLY_USB_TYPE_C;
 306
 307         power_supply_changed(data->psy);
 308 }
 309
 310 static void rt1719_update_operating_status(struct rt1719_data *data)
 311 {
 312         enum power_supply_usb_type usb_type = POWER_SUPPLY_USB_TYPE_PD;
 313         u32 voltage, max_current, op_current;
 314         int i, snk_sel;
 315
 316         for (i = 0; i < data->spdo_num; i++) {
 317                 u32 pdo = data->spdos[i];
 318                 enum pd_pdo_type type = pdo_type(pdo);
 319
 320                 if (type == PDO_TYPE_APDO) {
 321                         usb_type = POWER_SUPPLY_USB_TYPE_PD_PPS;
 322                         break;
 323                 }
 324         }
 325
 326         data->spdo_sel = FIELD_GET(RT1719_SPDOSEL_MASK, data->conn_info);
 327         if (data->spdo_sel <= 0)
 328                 return;
 329
 330         data->usb_type = usb_type;
 331
 332         voltage = pdo_fixed_voltage(data->spdos[data->spdo_sel - 1]);
 333         max_current = pdo_max_current(data->spdos[data->spdo_sel - 1]);
 334
 335         switch (voltage) {
 336         case 5000:
 337                 snk_sel = RT1719_SNKCAP_5V;
 338                 break;
 339         case 9000:
 340                 snk_sel = RT1719_SNKCAP_9V;
 341                 break;
 342         case 12000:
 343                 snk_sel = RT1719_SNKCAP_12V;
 344                 break;
 345         case 15000:
 346                 snk_sel = RT1719_SNKCAP_15V;
 347                 break;
 348         case 20000:
 349                 snk_sel = RT1719_SNKCAP_20V;
 350                 break;
 351         default:
 352                 return;
 353         }
 354
 355         op_current = min(max_current, pdo_max_current(data->snkcaps[snk_sel]));
 356
 357         /* covert mV/mA to uV/uA */
 358         data->voltage = voltage * 1000;
 359         data->max_current = max_current * 1000;
 360         data->op_current = op_current * 1000;
 361
 362         power_supply_changed(data->psy);
 363 }
 364
 365 static void rt1719_update_pwr_opmode(struct rt1719_data *data)
 366 {
 367         if (!data->attached)
 368                 return;
 369
 370         if (!data->pd_capable) {
 371                 data->pd_capable = true;
 372
 373                 typec_set_pwr_opmode(data->port, TYPEC_PWR_MODE_PD);
 374                 rt1719_register_partner(data);
 375         }
 376
 377         rt1719_update_operating_status(data);
 378 }
 379
 380 static void rt1719_update_source_pdos(struct rt1719_data *data)
 381 {
 382         int spdo_num = FIELD_GET(RT1719_SPDONUM_MASK, data->conn_info);
 383         __le32 src_pdos[RT1719_MAX_SRCPDO] = { };
 384         int i, ret;
 385
 386         if (!data->attached)
 387                 return;
 388
 389         ret = regmap_raw_read(data->regmap, RT1719_REG_SRCPDO1, src_pdos,
 390                               sizeof(__le32) * spdo_num);
 391         if (ret)
 392                 return;
 393
 394         data->spdo_num = spdo_num;
 395         for (i = 0; i < spdo_num; i++)
 396                 data->spdos[i] = le32_to_cpu(src_pdos[i]);
 397 }
 398
 399 static int rt1719_dr_set(struct typec_port *port, enum typec_data_role role)
 400 {
 401         struct rt1719_data *data = typec_get_drvdata(port);
 402         enum typec_data_role cur_role;
 403         int ret;
 404
 405         if (!data->attached || !data->pd_capable || !data->drswap_support)
 406                 return -EOPNOTSUPP;
 407
 408         if (data->spdo_num > 0 && !(data->spdos[0] & PDO_FIXED_DATA_SWAP))
 409                 return -EINVAL;
 410
 411         cur_role = rt1719_get_data_role(data->conn_info);
 412         if (cur_role == role)
 413                 return 0;
 414
 415         ret = regmap_update_bits(data->regmap, RT1719_REG_TXCTRL1,
 416                                  RT1719_REQDRSWAP_MASK, RT1719_REQDRSWAP_MASK);
 417         if (ret)
 418                 return ret;
 419
 420         reinit_completion(&data->req_completion);
 421         ret = wait_for_completion_timeout(&data->req_completion,
 422                                           msecs_to_jiffies(400));
 423         if (ret == 0)
 424                 return -ETIMEDOUT;
 425
 426         cur_role = rt1719_get_data_role(data->conn_info);
 427         if (cur_role != role)
 428                 return -EAGAIN;
 429
 430         rt1719_set_data_role(data, role, true);
 431         return 0;
 432 }
 433
 434 static const struct typec_operations rt1719_port_ops = {
 435         .dr_set = rt1719_dr_set,
 436 };
 437
 438 static int rt1719_usbpd_request_voltage(struct rt1719_data *data)
 439 {
 440         u32 src_voltage;
 441         int snk_sel, src_sel = -1;
 442         int i, ret;
 443
 444         if (!data->attached || !data->pd_capable || data->spdo_sel <= 0)
 445                 return -EINVAL;
 446
 447         src_voltage = pdo_fixed_voltage(data->spdos[data->spdo_sel - 1]);
 448         if (src_voltage == data->req_voltage)
 449                 return 0;
 450
 451         switch (data->req_voltage) {
 452         case 5000:
 453                 snk_sel = RT1719_SNKCAP_5V;
 454                 break;
 455         case 9000:
 456                 snk_sel = RT1719_SNKCAP_9V;
 457                 break;
 458         case 12000:
 459                 snk_sel = RT1719_SNKCAP_12V;
 460                 break;
 461         case 15000:
 462                 snk_sel = RT1719_SNKCAP_15V;
 463                 break;
 464         case 20000:
 465                 snk_sel = RT1719_SNKCAP_20V;
 466                 break;
 467         default:
 468                 return -EINVAL;
 469         }
 470
 471         if (!(data->snkcaps[snk_sel] & RT1719_PSEL_SUPPORT))
 472                 return -EINVAL;
 473
 474         for (i = 0; i < data->spdo_num; i++) {
 475                 enum pd_pdo_type type = pdo_type(data->spdos[i]);
 476
 477                 if (type != PDO_TYPE_FIXED)
 478                         continue;
 479
 480                 src_voltage = pdo_fixed_voltage(data->spdos[i]);
 481                 if (src_voltage == data->req_voltage) {
 482                         src_sel = i;
 483                         break;
 484                 }
 485         }
 486
 487         if (src_sel == -1)
 488                 return -EOPNOTSUPP;
 489
 490         ret = regmap_update_bits(data->regmap, RT1719_REG_TXCTRL1,
 491                                  RT1719_EVALMODE_MASK | RT1719_REQSRCPDO_MASK,
 492                                  RT1719_EVALMODE_MASK | (src_sel + 1));
 493         ret |= regmap_update_bits(data->regmap, RT1719_REG_TXCTRL2,
 494                                   RT1719_TXSPDOREQ_MASK, RT1719_TXSPDOREQ_MASK);
 495         if (ret)
 496                 return ret;
 497
 498         reinit_completion(&data->req_completion);
 499         ret = wait_for_completion_timeout(&data->req_completion,
 500                                           msecs_to_jiffies(400));
 501         if (!ret)
 502                 return -ETIMEDOUT;
 503
 504         return 0;
 505 }
 506
 507 static int rt1719_psy_set_property(struct power_supply *psy,
 508                                    enum power_supply_property psp,
 509                                    const union power_supply_propval *val)
 510 {
 511         struct rt1719_data *data = power_supply_get_drvdata(psy);
 512
 513         if (psp == POWER_SUPPLY_PROP_VOLTAGE_NOW) {
 514                 data->req_voltage = val->intval / 1000;
 515                 return rt1719_usbpd_request_voltage(data);
 516         }
 517
 518         return -EINVAL;
 519 }
 520
 521 static int rt1719_psy_get_property(struct power_supply *psy,
 522                                    enum power_supply_property psp,
 523                                    union power_supply_propval *val)
 524 {
 525         struct rt1719_data *data = power_supply_get_drvdata(psy);
 526         int ret = 0;
 527
 528         switch (psp) {
 529         case POWER_SUPPLY_PROP_ONLINE:
 530                 val->intval = data->attached ? 1 : 0;
 531                 break;
 532         case POWER_SUPPLY_PROP_USB_TYPE:
 533                 val->intval = data->usb_type;
 534                 break;
 535         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 536                 val->intval = data->voltage;
 537                 break;
 538         case POWER_SUPPLY_PROP_CURRENT_MAX:
 539                 val->intval = data->max_current;
 540                 break;
 541         case POWER_SUPPLY_PROP_CURRENT_NOW:
 542                 val->intval = data->op_current;
 543                 break;
 544         default:
 545                 ret = -EINVAL;
 546                 break;
 547         }
 548
 549         return ret;
 550 }
 551
 552 static int rt1719_psy_property_is_writeable(struct power_supply *psy,
 553                                             enum power_supply_property psp)
 554 {
 555         if (psp == POWER_SUPPLY_PROP_VOLTAGE_NOW)
 556                 return 1;
 557         return 0;
 558 }
 559
 560 static int devm_rt1719_psy_register(struct rt1719_data *data)
 561 {
 562         struct power_supply_config psy_cfg = { };
 563         char *psy_name;
 564
 565         psy_cfg.fwnode = dev_fwnode(data->dev);
 566         psy_cfg.drv_data = data;
 567
 568         psy_name = devm_kasprintf(data->dev, GFP_KERNEL, "rt1719-source-psy-%s",
 569                                   dev_name(data->dev));
 570         if (!psy_name)
 571                 return -ENOMEM;
 572
 573         data->psy_desc.name = psy_name;
 574         data->psy_desc.type = POWER_SUPPLY_TYPE_USB;
 575         data->psy_desc.usb_types = rt1719_psy_usb_types;
 576         data->psy_desc.num_usb_types = ARRAY_SIZE(rt1719_psy_usb_types);
 577         data->psy_desc.properties = rt1719_psy_properties;
 578         data->psy_desc.num_properties = ARRAY_SIZE(rt1719_psy_properties);
 579         data->psy_desc.get_property = rt1719_psy_get_property;
 580         data->psy_desc.set_property = rt1719_psy_set_property;
 581         data->psy_desc.property_is_writeable = rt1719_psy_property_is_writeable;
 582
 583         data->usb_type = POWER_SUPPLY_USB_TYPE_C;
 584
 585         data->psy = devm_power_supply_register(data->dev, &data->psy_desc,
 586                                                &psy_cfg);
 587
 588         return PTR_ERR_OR_ZERO(data->psy);
 589 }
 590
 591 static irqreturn_t rt1719_irq_handler(int irq, void *priv)
 592 {
 593         struct rt1719_data *data = priv;
 594         u32 events, conn_info;
 595         u16 conn_stat;
 596         int ret;
 597
 598         ret = rt1719_read32(data, RT1719_REG_EVENTS, &events);
 599         ret |= rt1719_read32(data, RT1719_REG_POLICYINFO, &conn_info);
 600         ret |= rt1719_read16(data, RT1719_REG_STATS, &conn_stat);
 601         if (ret)
 602                 return IRQ_NONE;
 603
 604         data->conn_info = conn_info;
 605         data->conn_stat = conn_stat;
 606
 607         events &= (RT1719_INT_DRSW_ACCEPT | RT1719_INT_RX_SRCCAP |
 608                    RT1719_INT_VBUS_PRESENT | RT1719_INT_VBUS_DCT |
 609                    RT1719_INT_PE_SNK_RDY);
 610
 611         if (events & RT1719_INT_DRSW_ACCEPT)
 612                 rt1719_update_data_role(data);
 613
 614         if (events & RT1719_INT_VBUS_PRESENT)
 615                 rt1719_attach(data);
 616
 617         if (events & RT1719_INT_VBUS_DCT)
 618                 rt1719_detach(data);
 619
 620         if (events & RT1719_INT_RX_SRCCAP)
 621                 rt1719_update_source_pdos(data);
 622
 623         if (events & RT1719_INT_PE_SNK_RDY) {
 624                 complete(&data->req_completion);
 625                 rt1719_update_pwr_opmode(data);
 626         }
 627
 628         /* Write 1 to clear already handled events */
 629         rt1719_write32(data, RT1719_REG_EVENTS, events);
 630
 631         return IRQ_HANDLED;
 632 }
 633
 634 static int rt1719_irq_init(struct rt1719_data *data)
 635 {
 636         struct i2c_client *i2c = to_i2c_client(data->dev);
 637         u32 irq_enable;
 638         int ret;
 639
 640         irq_enable = RT1719_INT_DRSW_ACCEPT | RT1719_INT_RX_SRCCAP |
 641                      RT1719_INT_VBUS_DCT | RT1719_INT_VBUS_PRESENT |
 642                      RT1719_INT_PE_SNK_RDY;
 643
 644         ret = rt1719_write32(data, RT1719_REG_MASKS, irq_enable);
 645         if (ret) {
 646                 dev_err(&i2c->dev, "Failed to config irq enable\n");
 647                 return ret;
 648         }
 649
 650         return devm_request_threaded_irq(&i2c->dev, i2c->irq, NULL,
 651                                          rt1719_irq_handler, IRQF_ONESHOT,
 652                                          dev_name(&i2c->dev), data);
 653 }
 654
 655 static int rt1719_init_attach_state(struct rt1719_data *data)
 656 {
 657         u32 conn_info, irq_clear;
 658         u16 conn_stat;
 659         int ret;
 660
 661         irq_clear = RT1719_INT_DRSW_ACCEPT | RT1719_INT_RX_SRCCAP |
 662                     RT1719_INT_VBUS_DCT | RT1719_INT_VBUS_PRESENT |
 663                     RT1719_INT_PE_SNK_RDY;
 664
 665         ret = rt1719_read32(data, RT1719_REG_POLICYINFO, &conn_info);
 666         ret |= rt1719_read16(data, RT1719_REG_STATS, &conn_stat);
 667         ret |= rt1719_write32(data, RT1719_REG_EVENTS, irq_clear);
 668         if (ret)
 669                 return ret;
 670
 671         data->conn_info = conn_info;
 672         data->conn_stat = conn_stat;
 673
 674         if (conn_info & RT1719_ATTACHDEV_MASK)
 675                 rt1719_attach(data);
 676
 677         if (conn_info & RT1719_PE_EXP_CONTRACT) {
 678                 rt1719_update_source_pdos(data);
 679                 rt1719_update_pwr_opmode(data);
 680         }
 681
 682         return 0;
 683 }
 684
 685 #define RT1719_PSEL_CAPINFO(_lomask, _milliwatt, _himask, _milliamp) { \
 686         .lomask         = _lomask, \
 687         .milliwatt      = _milliwatt, \
 688         .himask         = _himask, \
 689         .milliamp       = _milliamp, \
 690 }
 691
 692 static const struct rt1719_psel_cap rt1719_psel_caps[] = {
 693         RT1719_PSEL_CAPINFO(0x18, 75000, 0x10, 5000),
 694         RT1719_PSEL_CAPINFO(0x18, 60000, 0x10, 4500),
 695         RT1719_PSEL_CAPINFO(0x18, 45000, 0x10, 4000),
 696         RT1719_PSEL_CAPINFO(0x18, 30000, 0x10, 3500),
 697         RT1719_PSEL_CAPINFO(0x18, 25000, 0x10, 3000),
 698         RT1719_PSEL_CAPINFO(0x18, 20000, 0x10, 2500),
 699         RT1719_PSEL_CAPINFO(0x18, 15000, 0x10, 2000),
 700         RT1719_PSEL_CAPINFO(0x18, 10000, 0x10, 1000),
 701         RT1719_PSEL_CAPINFO(0x1C, 60000, 0x1F, 5000),
 702         RT1719_PSEL_CAPINFO(0x1C, 45000, 0x1F, 4500),
 703         RT1719_PSEL_CAPINFO(0x1C, 30000, 0x1F, 4000),
 704         RT1719_PSEL_CAPINFO(0x1C, 24000, 0x1F, 3500),
 705         RT1719_PSEL_CAPINFO(0x1C, 15000, 0x1F, 3000),
 706         RT1719_PSEL_CAPINFO(0x1C, 10000, 0x1F, 2500),
 707         RT1719_PSEL_CAPINFO(0x0C, 60000, 0x1F, 2000),
 708         RT1719_PSEL_CAPINFO(0x0C, 45000, 0x1F, 1000),
 709         RT1719_PSEL_CAPINFO(0x0C, 36000, 0x08, 5000),
 710         RT1719_PSEL_CAPINFO(0x0C, 30000, 0x08, 4500),
 711         RT1719_PSEL_CAPINFO(0x0C, 24000, 0x08, 4000),
 712         RT1719_PSEL_CAPINFO(0x0C, 15000, 0x08, 3500),
 713         RT1719_PSEL_CAPINFO(0x0C, 10000, 0x08, 3000),
 714         RT1719_PSEL_CAPINFO(0x1E, 45000, 0x08, 2500),
 715         RT1719_PSEL_CAPINFO(0x1E, 36000, 0x08, 2000),
 716         RT1719_PSEL_CAPINFO(0x1E, 27000, 0x08, 1500),
 717         RT1719_PSEL_CAPINFO(0x1E, 20000, 0x08, 1000),
 718         RT1719_PSEL_CAPINFO(0x1E, 15000, 0x0F, 5000),
 719         RT1719_PSEL_CAPINFO(0x1E, 9000, 0x0F, 4500),
 720         RT1719_PSEL_CAPINFO(0x0E, 45000, 0x0F, 4000),
 721         RT1719_PSEL_CAPINFO(0x0E, 36000, 0x0F, 3500),
 722         RT1719_PSEL_CAPINFO(0x0E, 27000, 0x0F, 3000),
 723         RT1719_PSEL_CAPINFO(0x0E, 20000, 0x0F, 2500),
 724         RT1719_PSEL_CAPINFO(0x0E, 15000, 0x0F, 2000),
 725         RT1719_PSEL_CAPINFO(0x0E, 9000, 0x0F, 1500),
 726         RT1719_PSEL_CAPINFO(0x06, 45000, 0x0F, 1000),
 727         RT1719_PSEL_CAPINFO(0x06, 36000, 0x0F, 500),
 728         RT1719_PSEL_CAPINFO(0x06, 27000, 0x04, 5000),
 729         RT1719_PSEL_CAPINFO(0x06, 24000, 0x04, 4500),
 730         RT1719_PSEL_CAPINFO(0x06, 18000, 0x04, 4000),
 731         RT1719_PSEL_CAPINFO(0x06, 12000, 0x04, 3500),
 732         RT1719_PSEL_CAPINFO(0x06, 9000, 0x04, 3000),
 733         RT1719_PSEL_CAPINFO(0x1F, 25000, 0x04, 2500),
 734         RT1719_PSEL_CAPINFO(0x1F, 20000, 0x04, 2000),
 735         RT1719_PSEL_CAPINFO(0x1F, 15000, 0x04, 1500),
 736         RT1719_PSEL_CAPINFO(0x1F, 10000, 0x04, 1000),
 737         RT1719_PSEL_CAPINFO(0x1F, 7500, 0x07, 5000),
 738         RT1719_PSEL_CAPINFO(0x0F, 25000, 0x07, 4500),
 739         RT1719_PSEL_CAPINFO(0x0F, 20000, 0x07, 4000),
 740         RT1719_PSEL_CAPINFO(0x0F, 15000, 0x07, 3500),
 741         RT1719_PSEL_CAPINFO(0x0F, 10000, 0x07, 3000),
 742         RT1719_PSEL_CAPINFO(0x0F, 7500, 0x07, 2500),
 743         RT1719_PSEL_CAPINFO(0x07, 25000, 0x07, 2000),
 744         RT1719_PSEL_CAPINFO(0x07, 20000, 0x07, 1500),
 745         RT1719_PSEL_CAPINFO(0x07, 15000, 0x07, 1000),
 746         RT1719_PSEL_CAPINFO(0x07, 10000, 0x07, 500),
 747         RT1719_PSEL_CAPINFO(0x07, 7500, 0x03, 5000),
 748         RT1719_PSEL_CAPINFO(0x03, 25000, 0x03, 4500),
 749         RT1719_PSEL_CAPINFO(0x03, 20000, 0x03, 4000),
 750         RT1719_PSEL_CAPINFO(0x03, 15000, 0x03, 3500),
 751         RT1719_PSEL_CAPINFO(0x03, 10000, 0x03, 3000),
 752         RT1719_PSEL_CAPINFO(0x03, 7500, 0x03, 2500),
 753         RT1719_PSEL_CAPINFO(0x01, 15000, 0x03, 2000),
 754         RT1719_PSEL_CAPINFO(0x01, 10000, 0x03, 1500),
 755         RT1719_PSEL_CAPINFO(0x01, 7500, 0x03, 1000),
 756         RT1719_PSEL_CAPINFO(0x01, 2500, 0x03, 500)
 757 };
 758
 759 static u16 rt1719_gen_snkcap_by_current(const struct rt1719_psel_cap *psel_cap,
 760                                         enum rt1719_snkcap capsel)
 761 {
 762         u16 cap = RT1719_PSEL_SUPPORT;
 763
 764         if (!(psel_cap->himask & BIT(capsel)))
 765                 return 0;
 766
 767         cap |= psel_cap->milliamp / 10;
 768         return cap;
 769 }
 770
 771 static u16 rt1719_gen_snkcap_by_watt(const struct rt1719_psel_cap *psel_cap,
 772                                      enum rt1719_snkcap capsel)
 773 {
 774         u32 volt_div[RT1719_MAX_SNKCAP] = { 5, 9, 12, 15, 20 };
 775         u16 cap = RT1719_PSEL_SUPPORT;
 776
 777         if (!(psel_cap->lomask & BIT(capsel)))
 778                 return 0;
 779
 780         cap |= min(psel_cap->milliwatt / volt_div[capsel], (u32)5000) / 10;
 781         return cap;
 782 }
 783
 784 static u16 rt1719_gen_snkcap(unsigned int pselinfo, enum rt1719_snkcap capsel)
 785 {
 786         int psel = FIELD_GET(RT1719_LATPSEL_MASK, pselinfo);
 787         const struct rt1719_psel_cap *psel_cap;
 788         bool by_current = false;
 789
 790         if (pselinfo & RT1719_TBLSEL_MASK)
 791                 by_current = true;
 792
 793         psel_cap = rt1719_psel_caps + psel;
 794         if (by_current)
 795                 return rt1719_gen_snkcap_by_current(psel_cap, capsel);
 796
 797         return rt1719_gen_snkcap_by_watt(psel_cap, capsel);
 798 }
 799
 800 static int rt1719_get_caps(struct rt1719_data *data)
 801 {
 802         unsigned int pselinfo, usbinfo;
 803         int i, ret;
 804
 805         ret = regmap_read(data->regmap, RT1719_REG_PSELINFO, &pselinfo);
 806         ret |= regmap_read(data->regmap, RT1719_REG_USBSETINFO, &usbinfo);
 807         if (ret)
 808                 return ret;
 809
 810         for (i = 0; i < RT1719_MAX_SNKCAP; i++)
 811                 data->snkcaps[i] = rt1719_gen_snkcap(pselinfo, i);
 812
 813         usbinfo = FIELD_GET(RT1719_USBINFO_MASK, usbinfo);
 814         if (usbinfo == RT1719_USB_DFPUFP)
 815                 data->drswap_support = true;
 816
 817         return 0;
 818 }
 819
 820 static int rt1719_check_exist(struct rt1719_data *data)
 821 {
 822         u16 pid;
 823         int ret;
 824
 825         ret = rt1719_read16(data, RT1719_REG_VENID, &pid);
 826         if (ret)
 827                 return ret;
 828
 829         if (pid != RT1719_UNIQUE_PID) {
 830                 dev_err(data->dev, "Incorrect PID 0x%04x\n", pid);
 831                 return -ENODEV;
 832         }
 833
 834         return 0;
 835 }
 836
 837 static const struct regmap_config rt1719_regmap_config = {
 838         .reg_bits = 8,
 839         .val_bits = 8,
 840         .max_register = 0xff,
 841 };
 842
 843 static int rt1719_probe(struct i2c_client *i2c)
 844 {
 845         struct rt1719_data *data;
 846         struct fwnode_handle *fwnode;
 847         struct typec_capability typec_cap = { };
 848         int ret;
 849
 850         data = devm_kzalloc(&i2c->dev, sizeof(*data), GFP_KERNEL);
 851         if (!data)
 852                 return -ENOMEM;
 853
 854         data->dev = &i2c->dev;
 855         init_completion(&data->req_completion);
 856
 857         data->regmap = devm_regmap_init_i2c(i2c, &rt1719_regmap_config);
 858         if (IS_ERR(data->regmap)) {
 859                 ret = PTR_ERR(data->regmap);
 860                 dev_err(&i2c->dev, "Failed to init regmap (%d)\n", ret);
 861                 return ret;
 862         }
 863
 864         ret = rt1719_check_exist(data);
 865         if (ret)
 866                 return ret;
 867
 868         ret = rt1719_get_caps(data);
 869         if (ret)
 870                 return ret;
 871
 872         fwnode = device_get_named_child_node(&i2c->dev, "connector");
 873         if (!fwnode)
 874                 return -ENODEV;
 875
 876         data->role_sw = fwnode_usb_role_switch_get(fwnode);
 877         if (IS_ERR(data->role_sw)) {
 878                 ret = PTR_ERR(data->role_sw);
 879                 dev_err(&i2c->dev, "Failed to get usb role switch (%d)\n", ret);
 880                 goto err_fwnode_put;
 881         }
 882
 883         ret = devm_rt1719_psy_register(data);
 884         if (ret) {
 885                 dev_err(&i2c->dev, "Failed to register psy (%d)\n", ret);
 886                 goto err_role_put;
 887         }
 888
 889         typec_cap.revision = USB_TYPEC_REV_1_2;
 890         typec_cap.pd_revision = 0x300;  /* USB-PD spec release 3.0 */
 891         typec_cap.type = TYPEC_PORT_SNK;
 892         typec_cap.data = TYPEC_PORT_DRD;
 893         typec_cap.ops = &rt1719_port_ops;
 894         typec_cap.fwnode = fwnode;
 895         typec_cap.driver_data = data;
 896         typec_cap.accessory[0] = TYPEC_ACCESSORY_DEBUG;
 897
 898         data->partner_desc.identity = &data->partner_ident;
 899
 900         data->port = typec_register_port(&i2c->dev, &typec_cap);
 901         if (IS_ERR(data->port)) {
 902                 ret = PTR_ERR(data->port);
 903                 dev_err(&i2c->dev, "Failed to register typec port (%d)\n", ret);
 904                 goto err_role_put;
 905         }
 906
 907         ret = rt1719_init_attach_state(data);
 908         if (ret) {
 909                 dev_err(&i2c->dev, "Failed to init attach state (%d)\n", ret);
 910                 goto err_role_put;
 911         }
 912
 913         ret = rt1719_irq_init(data);
 914         if (ret) {
 915                 dev_err(&i2c->dev, "Failed to init irq\n");
 916                 goto err_role_put;
 917         }
 918
 919         fwnode_handle_put(fwnode);
 920
 921         i2c_set_clientdata(i2c, data);
 922
 923         return 0;
 924
 925 err_role_put:
 926         usb_role_switch_put(data->role_sw);
 927 err_fwnode_put:
 928         fwnode_handle_put(fwnode);
 929
 930         return ret;
 931 }
 932
 933 static void rt1719_remove(struct i2c_client *i2c)
 934 {
 935         struct rt1719_data *data = i2c_get_clientdata(i2c);
 936
 937         typec_unregister_port(data->port);
 938         usb_role_switch_put(data->role_sw);
 939 }
 940
 941 static const struct of_device_id __maybe_unused rt1719_device_table[] = {
 942         { .compatible = "richtek,rt1719", },
 943         { }
 944 };
 945 MODULE_DEVICE_TABLE(of, rt1719_device_table);
 946
 947 static struct i2c_driver rt1719_driver = {
 948         .driver = {
 949                 .name = "rt1719",
 950                 .of_match_table = rt1719_device_table,
 951         },
 952         .probe_new = rt1719_probe,
 953         .remove = rt1719_remove,
 954 };
 955 module_i2c_driver(rt1719_driver);
 956
 957 MODULE_AUTHOR("ChiYuan Huang <[email protected]>");
 958 MODULE_DESCRIPTION("Richtek RT1719 Sink Only USBPD Controller Driver");
 959 MODULE_LICENSE("GPL v2");