14Srgrimes// SPDX-License-Identifier: GPL-2.0 24Srgrimes 34Srgrimes#include <linux/bitfield.h> 44Srgrimes#include <linux/completion.h> 54Srgrimes#include <linux/i2c.h> 64Srgrimes#include <linux/interrupt.h> 74Srgrimes#include <linux/kernel.h> 84Srgrimes#include <linux/module.h> 94Srgrimes#include <linux/power_supply.h> 104Srgrimes#include <linux/regmap.h> 114Srgrimes#include <linux/usb/pd.h> 124Srgrimes#include <linux/usb/role.h> 134Srgrimes#include <linux/usb/typec.h> 144Srgrimes 154Srgrimes#define RT1719_REG_TXCTRL1 0x03 164Srgrimes#define RT1719_REG_TXCTRL2 0x04 174Srgrimes#define RT1719_REG_POLICYINFO 0x0E 184Srgrimes#define RT1719_REG_SRCPDO1 0x11 194Srgrimes#define RT1719_REG_MASKS 0x2D 204Srgrimes#define RT1719_REG_EVENTS 0x33 214Srgrimes#define RT1719_REG_STATS 0x37 224Srgrimes#define RT1719_REG_PSELINFO 0x3C 234Srgrimes#define RT1719_REG_USBSETINFO 0x3E 244Srgrimes#define RT1719_REG_VENID 0x82 254Srgrimes 264Srgrimes#define RT1719_UNIQUE_PID 0x1719 274Srgrimes#define RT1719_REQDRSWAP_MASK BIT(7) 284Srgrimes#define RT1719_EVALMODE_MASK BIT(4) 294Srgrimes#define RT1719_REQSRCPDO_MASK GENMASK(2, 0) 304Srgrimes#define RT1719_TXSPDOREQ_MASK BIT(7) 314Srgrimes#define RT1719_INT_DRSW_ACCEPT BIT(23) 324Srgrimes#define RT1719_INT_RX_SRCCAP BIT(21) 334Srgrimes#define RT1719_INT_VBUS_DCT BIT(6) 344Srgrimes#define RT1719_INT_VBUS_PRESENT BIT(5) 354Srgrimes#define RT1719_INT_PE_SNK_RDY BIT(2) 36556Srgrimes#define RT1719_CC1_STAT GENMASK(9, 8) 371321Sdg#define RT1719_CC2_STAT GENMASK(11, 10) 384Srgrimes#define RT1719_POLARITY_MASK BIT(23) 394Srgrimes#define RT1719_DATAROLE_MASK BIT(22) 404Srgrimes#define RT1719_PDSPECREV_MASK GENMASK(21, 20) 41757Sdg#define RT1719_SPDOSEL_MASK GENMASK(18, 16) 42757Sdg#define RT1719_SPDONUM_MASK GENMASK(15, 13) 43757Sdg#define RT1719_ATTACH_VBUS BIT(12) 44757Sdg#define RT1719_ATTACH_DBG BIT(10) 45757Sdg#define RT1719_ATTACH_SNK BIT(9) 464Srgrimes#define RT1719_ATTACHDEV_MASK (RT1719_ATTACH_VBUS | RT1719_ATTACH_DBG | \ 474Srgrimes RT1719_ATTACH_SNK) 48757Sdg#define RT1719_PE_EXP_CONTRACT BIT(2) 49757Sdg#define RT1719_PSEL_SUPPORT BIT(15) 50757Sdg#define RT1719_TBLSEL_MASK BIT(6) 51757Sdg#define RT1719_LATPSEL_MASK GENMASK(5, 0) 52757Sdg#define RT1719_USBINFO_MASK GENMASK(1, 0) 53757Sdg#define RT1719_USB_DFPUFP 3 54757Sdg#define RT1719_MAX_SRCPDO 7 55757Sdg 56757Sdgenum { 574Srgrimes SNK_PWR_OPEN = 0, 584Srgrimes SNK_PWR_DEF, 59757Sdg SNK_PWR_1P5A, 60757Sdg SNK_PWR_3A 614Srgrimes}; 624Srgrimes 634Srgrimesenum { 644Srgrimes USBPD_SPECREV_1_0 = 0, 654Srgrimes USBPD_SPECREV_2_0, 66200Sdg USBPD_SPECREV_3_0 674Srgrimes}; 684Srgrimes 694Srgrimesenum rt1719_snkcap { 70592Srgrimes RT1719_SNKCAP_5V = 0, 71592Srgrimes RT1719_SNKCAP_9V, 72592Srgrimes RT1719_SNKCAP_12V, 73757Sdg RT1719_SNKCAP_15V, 74592Srgrimes RT1719_SNKCAP_20V, 75757Sdg RT1719_MAX_SNKCAP 76608Srgrimes}; 774Srgrimes 784Srgrimesstruct rt1719_psel_cap { 794Srgrimes u8 lomask; 804Srgrimes u8 himask; 814Srgrimes u32 milliwatt; 82592Srgrimes u32 milliamp; 83592Srgrimes}; 84592Srgrimes 85757Sdgstruct rt1719_data { 864Srgrimes struct device *dev; 874Srgrimes struct regmap *regmap; 884Srgrimes struct typec_port *port; 894Srgrimes struct usb_role_switch *role_sw; 904Srgrimes struct power_supply *psy; 914Srgrimes struct typec_partner *partner; 92570Srgrimes struct power_supply_desc psy_desc; 93134Sdg struct usb_pd_identity partner_ident; 944Srgrimes struct typec_partner_desc partner_desc; 95556Srgrimes struct completion req_completion; 96556Srgrimes enum power_supply_usb_type usb_type; 97556Srgrimes bool attached; 98556Srgrimes bool pd_capable; 99556Srgrimes bool drswap_support; 100757Sdg u32 voltage; 101134Sdg u32 req_voltage; 102592Srgrimes u32 max_current; 103134Sdg u32 op_current; 104592Srgrimes u32 spdos[RT1719_MAX_SRCPDO]; 105757Sdg u16 snkcaps[RT1719_MAX_SNKCAP]; 106757Sdg int spdo_num; 107757Sdg int spdo_sel; 108757Sdg u32 conn_info; 1094Srgrimes u16 conn_stat; 110757Sdg}; 111757Sdg 112757Sdgstatic const enum power_supply_usb_type rt1719_psy_usb_types[] = { 113592Srgrimes POWER_SUPPLY_USB_TYPE_C, 114757Sdg POWER_SUPPLY_USB_TYPE_PD, 115757Sdg POWER_SUPPLY_USB_TYPE_PD_PPS 1164Srgrimes}; 117757Sdg 118757Sdgstatic const enum power_supply_property rt1719_psy_properties[] = { 119718Swollman POWER_SUPPLY_PROP_ONLINE, 120757Sdg POWER_SUPPLY_PROP_USB_TYPE, 121757Sdg POWER_SUPPLY_PROP_VOLTAGE_NOW, 122134Sdg POWER_SUPPLY_PROP_CURRENT_MAX, 123757Sdg POWER_SUPPLY_PROP_CURRENT_NOW 124757Sdg}; 1251321Sdg 126757Sdgstatic int rt1719_read16(struct rt1719_data *data, unsigned int reg, u16 *val) 127718Swollman{ 128757Sdg __le16 regval; 129974Sdg int ret; 1304Srgrimes 131134Sdg ret = regmap_raw_read(data->regmap, reg, ®val, sizeof(regval)); 132134Sdg if (ret) 133556Srgrimes return ret; 134556Srgrimes 135556Srgrimes *val = le16_to_cpu(regval); 1364Srgrimes return 0; 137134Sdg} 138134Sdg 139200Sdgstatic int rt1719_read32(struct rt1719_data *data, unsigned int reg, u32 *val) 140200Sdg{ 141134Sdg __le32 regval; 1421321Sdg int ret; 143757Sdg 1444Srgrimes ret = regmap_raw_read(data->regmap, reg, ®val, sizeof(regval)); 1451321Sdg if (ret) 1464Srgrimes return ret; 1474Srgrimes 148556Srgrimes *val = le32_to_cpu(regval); 1494Srgrimes return 0; 1504Srgrimes} 1514Srgrimes 1524Srgrimesstatic int rt1719_write32(struct rt1719_data *data, unsigned int reg, u32 val) 1534Srgrimes{ 154570Srgrimes __le32 regval = cpu_to_le32(val); 1554Srgrimes 156570Srgrimes return regmap_raw_write(data->regmap, reg, ®val, sizeof(regval)); 1574Srgrimes} 158570Srgrimes 159556Srgrimesstatic enum typec_pwr_opmode rt1719_get_pwr_opmode(u32 conn, u16 stat) 160570Srgrimes{ 161570Srgrimes u16 cc1, cc2, cc_stat; 162975Smartin 163975Smartin cc1 = FIELD_GET(RT1719_CC1_STAT, stat); 164975Smartin cc2 = FIELD_GET(RT1719_CC2_STAT, stat); 165975Smartin 1661688Sdg if (conn & RT1719_ATTACH_SNK) { 167975Smartin if (conn & RT1719_POLARITY_MASK) 168975Smartin cc_stat = cc2; 169975Smartin else 1704Srgrimes cc_stat = cc1; 171556Srgrimes 172556Srgrimes switch (cc_stat) { 173556Srgrimes case SNK_PWR_3A: 174556Srgrimes return TYPEC_PWR_MODE_3_0A; 175556Srgrimes case SNK_PWR_1P5A: 176556Srgrimes return TYPEC_PWR_MODE_1_5A; 177556Srgrimes } 178556Srgrimes } else if (conn & RT1719_ATTACH_DBG) { 179556Srgrimes if ((cc1 == SNK_PWR_1P5A && cc2 == SNK_PWR_DEF) || 180556Srgrimes (cc1 == SNK_PWR_DEF && cc2 == SNK_PWR_1P5A)) 181556Srgrimes return TYPEC_PWR_MODE_1_5A; 182556Srgrimes else if ((cc1 == SNK_PWR_3A && cc2 == SNK_PWR_DEF) || 183556Srgrimes (cc1 == SNK_PWR_DEF && cc2 == SNK_PWR_3A)) 184556Srgrimes return TYPEC_PWR_MODE_3_0A; 1851321Sdg } 186556Srgrimes 187556Srgrimes return TYPEC_PWR_MODE_USB; 188570Srgrimes} 189556Srgrimes 190570Srgrimesstatic enum typec_data_role rt1719_get_data_role(u32 conn) 191556Srgrimes{ 192556Srgrimes if (conn & RT1719_DATAROLE_MASK) 1934Srgrimes return TYPEC_HOST; 1944Srgrimes return TYPEC_DEVICE; 1954Srgrimes} 1964Srgrimes 1974Srgrimesstatic void rt1719_set_data_role(struct rt1719_data *data, 1984Srgrimes enum typec_data_role data_role, 1994Srgrimes bool attached) 2004Srgrimes{ 2014Srgrimes enum usb_role usb_role = USB_ROLE_NONE; 2024Srgrimes 2034Srgrimes if (attached) { 2044Srgrimes if (data_role == TYPEC_HOST) 2054Srgrimes usb_role = USB_ROLE_HOST; 2064Srgrimes else 207757Sdg usb_role = USB_ROLE_DEVICE; 2084Srgrimes } 209570Srgrimes 210570Srgrimes usb_role_switch_set_role(data->role_sw, usb_role); 211570Srgrimes typec_set_data_role(data->port, data_role); 212570Srgrimes} 213974Sdg 214570Srgrimesstatic void rt1719_update_data_role(struct rt1719_data *data) 215570Srgrimes{ 2164Srgrimes if (!data->attached) 217570Srgrimes return; 218757Sdg 2194Srgrimes rt1719_set_data_role(data, rt1719_get_data_role(data->conn_info), true); 2201321Sdg} 221757Sdg 2224Srgrimesstatic void rt1719_register_partner(struct rt1719_data *data) 223757Sdg{ 224570Srgrimes u16 spec_rev = 0; 225760Srgrimes 226757Sdg if (data->pd_capable) { 2274Srgrimes u32 rev; 2284Srgrimes 2294Srgrimes rev = FIELD_GET(RT1719_PDSPECREV_MASK, data->conn_info); 2304Srgrimes switch (rev) { 231608Srgrimes case USBPD_SPECREV_3_0: 232974Sdg spec_rev = 0x0300; 233974Sdg break; 234974Sdg case USBPD_SPECREV_2_0: 235974Sdg spec_rev = 0x0200; 236757Sdg break; 237757Sdg default: 238608Srgrimes spec_rev = 0x0100; 239757Sdg break; 240608Srgrimes } 241757Sdg } 242757Sdg 243974Sdg /* Just to prevent multiple times attach */ 244757Sdg if (data->partner) 245757Sdg typec_unregister_partner(data->partner); 246757Sdg 247757Sdg memset(&data->partner_ident, 0, sizeof(data->partner_ident)); 248757Sdg data->partner_desc.usb_pd = data->pd_capable; 249757Sdg data->partner_desc.pd_revision = spec_rev; 250570Srgrimes 2514Srgrimes if (data->conn_info & RT1719_ATTACH_DBG) 252592Srgrimes data->partner_desc.accessory = TYPEC_ACCESSORY_DEBUG; 253592Srgrimes else 254592Srgrimes data->partner_desc.accessory = TYPEC_ACCESSORY_NONE; 255592Srgrimes 256592Srgrimes data->partner = typec_register_partner(data->port, &data->partner_desc); 257592Srgrimes} 2584Srgrimes 2594Srgrimesstatic void rt1719_attach(struct rt1719_data *data) 260570Srgrimes{ 2614Srgrimes enum typec_pwr_opmode pwr_opmode; 2624Srgrimes enum typec_data_role data_role; 2634Srgrimes u32 volt = 5000, curr = 500; 2644Srgrimes 2654Srgrimes if (!(data->conn_info & RT1719_ATTACHDEV_MASK)) 2664Srgrimes return; 2674Srgrimes 2684Srgrimes pwr_opmode = rt1719_get_pwr_opmode(data->conn_info, data->conn_stat); 269757Sdg data_role = rt1719_get_data_role(data->conn_info); 270757Sdg 271757Sdg typec_set_pwr_opmode(data->port, pwr_opmode); 272757Sdg rt1719_set_data_role(data, data_role, true); 273757Sdg 274200Sdg if (data->conn_info & RT1719_ATTACH_SNK) 275200Sdg rt1719_register_partner(data); 276200Sdg 277757Sdg if (pwr_opmode == TYPEC_PWR_MODE_3_0A) 2781549Srgrimes curr = 3000; 279757Sdg else if (pwr_opmode == TYPEC_PWR_MODE_1_5A) 280757Sdg curr = 1500; 2814Srgrimes 2824Srgrimes data->voltage = volt * 1000; 283757Sdg data->max_current = data->op_current = curr * 1000; 284757Sdg data->attached = true; 285757Sdg 286757Sdg power_supply_changed(data->psy); 287757Sdg} 288757Sdg 289757Sdgstatic void rt1719_detach(struct rt1719_data *data) 290757Sdg{ 291757Sdg if (!data->attached || (data->conn_info & RT1719_ATTACHDEV_MASK)) 292757Sdg return; 293757Sdg 294757Sdg typec_unregister_partner(data->partner); 295757Sdg data->partner = NULL; 296757Sdg 297757Sdg typec_set_pwr_opmode(data->port, TYPEC_PWR_MODE_USB); 298757Sdg rt1719_set_data_role(data, TYPEC_DEVICE, false); 2991321Sdg 300757Sdg memset32(data->spdos, 0, RT1719_MAX_SRCPDO); 301757Sdg data->spdo_num = 0; 302757Sdg data->voltage = data->max_current = data->op_current = 0; 303974Sdg data->attached = data->pd_capable = false; 304757Sdg 305757Sdg data->usb_type = POWER_SUPPLY_USB_TYPE_C; 3061549Srgrimes 307757Sdg power_supply_changed(data->psy); 308757Sdg} 309757Sdg 310757Sdgstatic void rt1719_update_operating_status(struct rt1719_data *data) 311757Sdg{ 3121321Sdg enum power_supply_usb_type usb_type = POWER_SUPPLY_USB_TYPE_PD; 3134Srgrimes u32 voltage, max_current, op_current; 3144Srgrimes int i, snk_sel; 315757Sdg 316757Sdg for (i = 0; i < data->spdo_num; i++) { 317757Sdg u32 pdo = data->spdos[i]; 3181046Sdg enum pd_pdo_type type = pdo_type(pdo); 319757Sdg 3204Srgrimes if (type == PDO_TYPE_APDO) { 3214Srgrimes usb_type = POWER_SUPPLY_USB_TYPE_PD_PPS; 3224Srgrimes break; 3234Srgrimes } 324757Sdg } 325757Sdg 326757Sdg data->spdo_sel = FIELD_GET(RT1719_SPDOSEL_MASK, data->conn_info); 327757Sdg if (data->spdo_sel <= 0) 328757Sdg return; 329757Sdg 330757Sdg data->usb_type = usb_type; 3314Srgrimes 3324Srgrimes voltage = pdo_fixed_voltage(data->spdos[data->spdo_sel - 1]); 3334Srgrimes max_current = pdo_max_current(data->spdos[data->spdo_sel - 1]); 334757Sdg 3354Srgrimes switch (voltage) { 3364Srgrimes case 5000: 337757Sdg snk_sel = RT1719_SNKCAP_5V; 338757Sdg break; 339757Sdg case 9000: 3404Srgrimes snk_sel = RT1719_SNKCAP_9V; 341757Sdg break; 342974Sdg case 12000: 343757Sdg snk_sel = RT1719_SNKCAP_12V; 3444Srgrimes break; 3454Srgrimes case 15000: 3464Srgrimes snk_sel = RT1719_SNKCAP_15V; 347757Sdg break; 348757Sdg case 20000: 349757Sdg snk_sel = RT1719_SNKCAP_20V; 3504Srgrimes break; 3514Srgrimes default: 352757Sdg return; 353757Sdg } 354757Sdg 3554Srgrimes op_current = min(max_current, pdo_max_current(data->snkcaps[snk_sel])); 356757Sdg 3574Srgrimes /* covert mV/mA to uV/uA */ 3584Srgrimes data->voltage = voltage * 1000; 359757Sdg data->max_current = max_current * 1000; 3604Srgrimes data->op_current = op_current * 1000; 361570Srgrimes 3624Srgrimes power_supply_changed(data->psy); 3634Srgrimes} 3644Srgrimes 3654Srgrimesstatic void rt1719_update_pwr_opmode(struct rt1719_data *data) 3664Srgrimes{ 367757Sdg if (!data->attached) 368570Srgrimes return; 3694Srgrimes 3704Srgrimes if (!data->pd_capable) { 3711688Sdg data->pd_capable = true; 372757Sdg 3734Srgrimes typec_set_pwr_opmode(data->port, TYPEC_PWR_MODE_PD); 374570Srgrimes rt1719_register_partner(data); 3754Srgrimes } 3764Srgrimes 3774Srgrimes rt1719_update_operating_status(data); 378757Sdg} 379757Sdg 3804Srgrimesstatic void rt1719_update_source_pdos(struct rt1719_data *data) 381570Srgrimes{ 3824Srgrimes int spdo_num = FIELD_GET(RT1719_SPDONUM_MASK, data->conn_info); 383570Srgrimes __le32 src_pdos[RT1719_MAX_SRCPDO] = { }; 384757Sdg int i, ret; 3854Srgrimes 386570Srgrimes if (!data->attached) 3874Srgrimes return; 388570Srgrimes 3894Srgrimes ret = regmap_raw_read(data->regmap, RT1719_REG_SRCPDO1, src_pdos, 390570Srgrimes sizeof(__le32) * spdo_num); 3914Srgrimes if (ret) 3924Srgrimes return; 3931688Sdg 394757Sdg data->spdo_num = spdo_num; 3954Srgrimes for (i = 0; i < spdo_num; i++) 3964Srgrimes data->spdos[i] = le32_to_cpu(src_pdos[i]); 3974Srgrimes} 3984Srgrimes 3994Srgrimesstatic int rt1719_dr_set(struct typec_port *port, enum typec_data_role role) 4004Srgrimes{ 4014Srgrimes struct rt1719_data *data = typec_get_drvdata(port); 4021321Sdg enum typec_data_role cur_role; 4034Srgrimes int ret; 404592Srgrimes 405757Sdg if (!data->attached || !data->pd_capable || !data->drswap_support) 406570Srgrimes return -EOPNOTSUPP; 407757Sdg 408757Sdg if (data->spdo_num > 0 && !(data->spdos[0] & PDO_FIXED_DATA_SWAP)) 409757Sdg return -EINVAL; 410757Sdg 4114Srgrimes cur_role = rt1719_get_data_role(data->conn_info); 412757Sdg if (cur_role == role) 4134Srgrimes return 0; 4144Srgrimes 415570Srgrimes ret = regmap_update_bits(data->regmap, RT1719_REG_TXCTRL1, 4164Srgrimes RT1719_REQDRSWAP_MASK, RT1719_REQDRSWAP_MASK); 417757Sdg if (ret) 418757Sdg return ret; 419592Srgrimes 420757Sdg reinit_completion(&data->req_completion); 421757Sdg ret = wait_for_completion_timeout(&data->req_completion, 422757Sdg msecs_to_jiffies(400)); 423757Sdg if (ret == 0) 424570Srgrimes return -ETIMEDOUT; 4254Srgrimes 4264Srgrimes cur_role = rt1719_get_data_role(data->conn_info); 4274Srgrimes if (cur_role != role) 428757Sdg return -EAGAIN; 429570Srgrimes 430757Sdg rt1719_set_data_role(data, role, true); 4314Srgrimes return 0; 432570Srgrimes} 433570Srgrimes 4344Srgrimesstatic const struct typec_operations rt1719_port_ops = { 435757Sdg .dr_set = rt1719_dr_set, 4364Srgrimes}; 4374Srgrimes 438757Sdgstatic int rt1719_usbpd_request_voltage(struct rt1719_data *data) 4394Srgrimes{ 4404Srgrimes u32 src_voltage; 4411321Sdg int snk_sel, src_sel = -1; 442757Sdg int i, ret; 4434Srgrimes 4444Srgrimes if (!data->attached || !data->pd_capable || data->spdo_sel <= 0) 4454Srgrimes return -EINVAL; 4464Srgrimes 4474Srgrimes src_voltage = pdo_fixed_voltage(data->spdos[data->spdo_sel - 1]); 4484Srgrimes if (src_voltage == data->req_voltage) 4491321Sdg return 0; 4504Srgrimes 451608Srgrimes switch (data->req_voltage) { 452608Srgrimes case 5000: 453608Srgrimes snk_sel = RT1719_SNKCAP_5V; 454974Sdg break; 455608Srgrimes case 9000: 456757Sdg snk_sel = RT1719_SNKCAP_9V; 457757Sdg break; 4581549Srgrimes case 12000: 459200Sdg snk_sel = RT1719_SNKCAP_12V; 4601549Srgrimes break; 4614Srgrimes case 15000: 4621549Srgrimes snk_sel = RT1719_SNKCAP_15V; 4631549Srgrimes break; 4641549Srgrimes case 20000: 4651549Srgrimes snk_sel = RT1719_SNKCAP_20V; 4661549Srgrimes break; 4671549Srgrimes default: 4681549Srgrimes return -EINVAL; 4691549Srgrimes } 4701549Srgrimes 4711549Srgrimes if (!(data->snkcaps[snk_sel] & RT1719_PSEL_SUPPORT)) 4721549Srgrimes return -EINVAL; 4731549Srgrimes 4741549Srgrimes for (i = 0; i < data->spdo_num; i++) { 475757Sdg enum pd_pdo_type type = pdo_type(data->spdos[i]); 4764Srgrimes 4771549Srgrimes if (type != PDO_TYPE_FIXED) 4781549Srgrimes continue; 479134Sdg 480570Srgrimes src_voltage = pdo_fixed_voltage(data->spdos[i]); 481570Srgrimes if (src_voltage == data->req_voltage) { 4821058Sdg src_sel = i; 4831058Sdg break; 4841058Sdg } 4851058Sdg } 4861058Sdg 4871058Sdg if (src_sel == -1) 4881058Sdg return -EOPNOTSUPP; 4891058Sdg 4901058Sdg ret = regmap_update_bits(data->regmap, RT1719_REG_TXCTRL1, 491134Sdg RT1719_EVALMODE_MASK | RT1719_REQSRCPDO_MASK, 492134Sdg RT1719_EVALMODE_MASK | (src_sel + 1)); 493134Sdg ret |= regmap_update_bits(data->regmap, RT1719_REG_TXCTRL2, 4941058Sdg RT1719_TXSPDOREQ_MASK, RT1719_TXSPDOREQ_MASK); 4954Srgrimes if (ret) 4964Srgrimes return ret; 4971549Srgrimes 4984Srgrimes reinit_completion(&data->req_completion); 4994Srgrimes ret = wait_for_completion_timeout(&data->req_completion, 500757Sdg msecs_to_jiffies(400)); 501757Sdg if (!ret) 5021549Srgrimes return -ETIMEDOUT; 5034Srgrimes 5041549Srgrimes return 0; 5054Srgrimes} 506200Sdg 507592Srgrimesstatic int rt1719_psy_set_property(struct power_supply *psy, 508757Sdg enum power_supply_property psp, 509757Sdg const union power_supply_propval *val) 5104Srgrimes{ 511757Sdg struct rt1719_data *data = power_supply_get_drvdata(psy); 512757Sdg 513757Sdg if (psp == POWER_SUPPLY_PROP_VOLTAGE_NOW) { 514757Sdg data->req_voltage = val->intval / 1000; 5154Srgrimes return rt1719_usbpd_request_voltage(data); 5164Srgrimes } 5174Srgrimes 5184Srgrimes return -EINVAL; 519} 520 521static 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 552static 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 560static 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 591static 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 634static 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 655static 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 692static 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 759static 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 771static 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 784static 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 800static 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 820static 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 837static const struct regmap_config rt1719_regmap_config = { 838 .reg_bits = 8, 839 .val_bits = 8, 840 .max_register = 0xff, 841}; 842 843static 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 925err_role_put: 926 usb_role_switch_put(data->role_sw); 927err_fwnode_put: 928 fwnode_handle_put(fwnode); 929 930 return ret; 931} 932 933static 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 941static const struct of_device_id __maybe_unused rt1719_device_table[] = { 942 { .compatible = "richtek,rt1719", }, 943 { } 944}; 945MODULE_DEVICE_TABLE(of, rt1719_device_table); 946 947static struct i2c_driver rt1719_driver = { 948 .driver = { 949 .name = "rt1719", 950 .of_match_table = rt1719_device_table, 951 }, 952 .probe = rt1719_probe, 953 .remove = rt1719_remove, 954}; 955module_i2c_driver(rt1719_driver); 956 957MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>"); 958MODULE_DESCRIPTION("Richtek RT1719 Sink Only USBPD Controller Driver"); 959MODULE_LICENSE("GPL v2"); 960