Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 
0003 #include <linux/bitfield.h>
0004 #include <linux/completion.h>
0005 #include <linux/i2c.h>
0006 #include <linux/interrupt.h>
0007 #include <linux/kernel.h>
0008 #include <linux/module.h>
0009 #include <linux/power_supply.h>
0010 #include <linux/regmap.h>
0011 #include <linux/usb/pd.h>
0012 #include <linux/usb/role.h>
0013 #include <linux/usb/typec.h>
0014 
0015 #define RT1719_REG_TXCTRL1  0x03
0016 #define RT1719_REG_TXCTRL2  0x04
0017 #define RT1719_REG_POLICYINFO   0x0E
0018 #define RT1719_REG_SRCPDO1  0x11
0019 #define RT1719_REG_MASKS    0x2D
0020 #define RT1719_REG_EVENTS   0x33
0021 #define RT1719_REG_STATS    0x37
0022 #define RT1719_REG_PSELINFO 0x3C
0023 #define RT1719_REG_USBSETINFO   0x3E
0024 #define RT1719_REG_VENID    0x82
0025 
0026 #define RT1719_UNIQUE_PID   0x1719
0027 #define RT1719_REQDRSWAP_MASK   BIT(7)
0028 #define RT1719_EVALMODE_MASK    BIT(4)
0029 #define RT1719_REQSRCPDO_MASK   GENMASK(2, 0)
0030 #define RT1719_TXSPDOREQ_MASK   BIT(7)
0031 #define RT1719_INT_DRSW_ACCEPT  BIT(23)
0032 #define RT1719_INT_RX_SRCCAP    BIT(21)
0033 #define RT1719_INT_VBUS_DCT BIT(6)
0034 #define RT1719_INT_VBUS_PRESENT BIT(5)
0035 #define RT1719_INT_PE_SNK_RDY   BIT(2)
0036 #define RT1719_CC1_STAT     GENMASK(9, 8)
0037 #define RT1719_CC2_STAT     GENMASK(11, 10)
0038 #define RT1719_POLARITY_MASK    BIT(23)
0039 #define RT1719_DATAROLE_MASK    BIT(22)
0040 #define RT1719_PDSPECREV_MASK   GENMASK(21, 20)
0041 #define RT1719_SPDOSEL_MASK GENMASK(18, 16)
0042 #define RT1719_SPDONUM_MASK GENMASK(15, 13)
0043 #define RT1719_ATTACH_VBUS  BIT(12)
0044 #define RT1719_ATTACH_DBG   BIT(10)
0045 #define RT1719_ATTACH_SNK   BIT(9)
0046 #define RT1719_ATTACHDEV_MASK   (RT1719_ATTACH_VBUS | RT1719_ATTACH_DBG | \
0047                  RT1719_ATTACH_SNK)
0048 #define RT1719_PE_EXP_CONTRACT  BIT(2)
0049 #define RT1719_PSEL_SUPPORT BIT(15)
0050 #define RT1719_TBLSEL_MASK  BIT(6)
0051 #define RT1719_LATPSEL_MASK GENMASK(5, 0)
0052 #define RT1719_USBINFO_MASK GENMASK(1, 0)
0053 #define RT1719_USB_DFPUFP   3
0054 #define RT1719_MAX_SRCPDO   7
0055 
0056 enum {
0057     SNK_PWR_OPEN = 0,
0058     SNK_PWR_DEF,
0059     SNK_PWR_1P5A,
0060     SNK_PWR_3A
0061 };
0062 
0063 enum {
0064     USBPD_SPECREV_1_0 = 0,
0065     USBPD_SPECREV_2_0,
0066     USBPD_SPECREV_3_0
0067 };
0068 
0069 enum rt1719_snkcap {
0070     RT1719_SNKCAP_5V = 0,
0071     RT1719_SNKCAP_9V,
0072     RT1719_SNKCAP_12V,
0073     RT1719_SNKCAP_15V,
0074     RT1719_SNKCAP_20V,
0075     RT1719_MAX_SNKCAP
0076 };
0077 
0078 struct rt1719_psel_cap {
0079     u8 lomask;
0080     u8 himask;
0081     u32 milliwatt;
0082     u32 milliamp;
0083 };
0084 
0085 struct rt1719_data {
0086     struct device *dev;
0087     struct regmap *regmap;
0088     struct typec_port *port;
0089     struct usb_role_switch *role_sw;
0090     struct power_supply *psy;
0091     struct typec_partner *partner;
0092     struct power_supply_desc psy_desc;
0093     struct usb_pd_identity partner_ident;
0094     struct typec_partner_desc partner_desc;
0095     struct completion req_completion;
0096     enum power_supply_usb_type usb_type;
0097     bool attached;
0098     bool pd_capable;
0099     bool drswap_support;
0100     u32 voltage;
0101     u32 req_voltage;
0102     u32 max_current;
0103     u32 op_current;
0104     u32 spdos[RT1719_MAX_SRCPDO];
0105     u16 snkcaps[RT1719_MAX_SNKCAP];
0106     int spdo_num;
0107     int spdo_sel;
0108     u32 conn_info;
0109     u16 conn_stat;
0110 };
0111 
0112 static const enum power_supply_usb_type rt1719_psy_usb_types[] = {
0113     POWER_SUPPLY_USB_TYPE_C,
0114     POWER_SUPPLY_USB_TYPE_PD,
0115     POWER_SUPPLY_USB_TYPE_PD_PPS
0116 };
0117 
0118 static const enum power_supply_property rt1719_psy_properties[] = {
0119     POWER_SUPPLY_PROP_ONLINE,
0120     POWER_SUPPLY_PROP_USB_TYPE,
0121     POWER_SUPPLY_PROP_VOLTAGE_NOW,
0122     POWER_SUPPLY_PROP_CURRENT_MAX,
0123     POWER_SUPPLY_PROP_CURRENT_NOW
0124 };
0125 
0126 static int rt1719_read16(struct rt1719_data *data, unsigned int reg, u16 *val)
0127 {
0128     __le16 regval;
0129     int ret;
0130 
0131     ret = regmap_raw_read(data->regmap, reg, &regval, sizeof(regval));
0132     if (ret)
0133         return ret;
0134 
0135     *val = le16_to_cpu(regval);
0136     return 0;
0137 }
0138 
0139 static int rt1719_read32(struct rt1719_data *data, unsigned int reg, u32 *val)
0140 {
0141     __le32 regval;
0142     int ret;
0143 
0144     ret = regmap_raw_read(data->regmap, reg, &regval, sizeof(regval));
0145     if (ret)
0146         return ret;
0147 
0148     *val = le32_to_cpu(regval);
0149     return 0;
0150 }
0151 
0152 static int rt1719_write32(struct rt1719_data *data, unsigned int reg, u32 val)
0153 {
0154     __le32 regval = cpu_to_le32(val);
0155 
0156     return regmap_raw_write(data->regmap, reg, &regval, sizeof(regval));
0157 }
0158 
0159 static enum typec_pwr_opmode rt1719_get_pwr_opmode(u32 conn, u16 stat)
0160 {
0161     u16 cc1, cc2, cc_stat;
0162 
0163     cc1 = FIELD_GET(RT1719_CC1_STAT, stat);
0164     cc2 = FIELD_GET(RT1719_CC2_STAT, stat);
0165 
0166     if (conn & RT1719_ATTACH_SNK) {
0167         if (conn & RT1719_POLARITY_MASK)
0168             cc_stat = cc2;
0169         else
0170             cc_stat = cc1;
0171 
0172         switch (cc_stat) {
0173         case SNK_PWR_3A:
0174             return TYPEC_PWR_MODE_3_0A;
0175         case SNK_PWR_1P5A:
0176             return TYPEC_PWR_MODE_1_5A;
0177         }
0178     } else if (conn & RT1719_ATTACH_DBG) {
0179         if ((cc1 == SNK_PWR_1P5A && cc2 == SNK_PWR_DEF) ||
0180             (cc1 == SNK_PWR_DEF && cc2 == SNK_PWR_1P5A))
0181             return TYPEC_PWR_MODE_1_5A;
0182         else if ((cc1 == SNK_PWR_3A && cc2 == SNK_PWR_DEF) ||
0183              (cc1 == SNK_PWR_DEF && cc2 == SNK_PWR_3A))
0184             return TYPEC_PWR_MODE_3_0A;
0185     }
0186 
0187     return TYPEC_PWR_MODE_USB;
0188 }
0189 
0190 static enum typec_data_role rt1719_get_data_role(u32 conn)
0191 {
0192     if (conn & RT1719_DATAROLE_MASK)
0193         return TYPEC_HOST;
0194     return TYPEC_DEVICE;
0195 }
0196 
0197 static void rt1719_set_data_role(struct rt1719_data *data,
0198                  enum typec_data_role data_role,
0199                  bool attached)
0200 {
0201     enum usb_role usb_role = USB_ROLE_NONE;
0202 
0203     if (attached) {
0204         if (data_role == TYPEC_HOST)
0205             usb_role = USB_ROLE_HOST;
0206         else
0207             usb_role = USB_ROLE_DEVICE;
0208     }
0209 
0210     usb_role_switch_set_role(data->role_sw, usb_role);
0211     typec_set_data_role(data->port, data_role);
0212 }
0213 
0214 static void rt1719_update_data_role(struct rt1719_data *data)
0215 {
0216     if (!data->attached)
0217         return;
0218 
0219     rt1719_set_data_role(data, rt1719_get_data_role(data->conn_info), true);
0220 }
0221 
0222 static void rt1719_register_partner(struct rt1719_data *data)
0223 {
0224     u16 spec_rev = 0;
0225 
0226     if (data->pd_capable) {
0227         u32 rev;
0228 
0229         rev = FIELD_GET(RT1719_PDSPECREV_MASK, data->conn_info);
0230         switch (rev) {
0231         case USBPD_SPECREV_3_0:
0232             spec_rev = 0x0300;
0233             break;
0234         case USBPD_SPECREV_2_0:
0235             spec_rev = 0x0200;
0236             break;
0237         default:
0238             spec_rev = 0x0100;
0239             break;
0240         }
0241     }
0242 
0243     /* Just to prevent multiple times attach */
0244     if (data->partner)
0245         typec_unregister_partner(data->partner);
0246 
0247     memset(&data->partner_ident, 0, sizeof(data->partner_ident));
0248     data->partner_desc.usb_pd = data->pd_capable;
0249     data->partner_desc.pd_revision = spec_rev;
0250 
0251     if (data->conn_info & RT1719_ATTACH_DBG)
0252         data->partner_desc.accessory = TYPEC_ACCESSORY_DEBUG;
0253     else
0254         data->partner_desc.accessory = TYPEC_ACCESSORY_NONE;
0255 
0256     data->partner = typec_register_partner(data->port, &data->partner_desc);
0257 }
0258 
0259 static void rt1719_attach(struct rt1719_data *data)
0260 {
0261     enum typec_pwr_opmode pwr_opmode;
0262     enum typec_data_role data_role;
0263     u32 volt = 5000, curr = 500;
0264 
0265     if (!(data->conn_info & RT1719_ATTACHDEV_MASK))
0266         return;
0267 
0268     pwr_opmode = rt1719_get_pwr_opmode(data->conn_info, data->conn_stat);
0269     data_role = rt1719_get_data_role(data->conn_info);
0270 
0271     typec_set_pwr_opmode(data->port, pwr_opmode);
0272     rt1719_set_data_role(data, data_role, true);
0273 
0274     if (data->conn_info & RT1719_ATTACH_SNK)
0275         rt1719_register_partner(data);
0276 
0277     if (pwr_opmode == TYPEC_PWR_MODE_3_0A)
0278         curr = 3000;
0279     else if (pwr_opmode == TYPEC_PWR_MODE_1_5A)
0280         curr = 1500;
0281 
0282     data->voltage = volt * 1000;
0283     data->max_current = data->op_current = curr * 1000;
0284     data->attached = true;
0285 
0286     power_supply_changed(data->psy);
0287 }
0288 
0289 static void rt1719_detach(struct rt1719_data *data)
0290 {
0291     if (!data->attached || (data->conn_info & RT1719_ATTACHDEV_MASK))
0292         return;
0293 
0294     typec_unregister_partner(data->partner);
0295     data->partner = NULL;
0296 
0297     typec_set_pwr_opmode(data->port, TYPEC_PWR_MODE_USB);
0298     rt1719_set_data_role(data, TYPEC_DEVICE, false);
0299 
0300     memset32(data->spdos, 0, RT1719_MAX_SRCPDO);
0301     data->spdo_num = 0;
0302     data->voltage = data->max_current = data->op_current = 0;
0303     data->attached = data->pd_capable = false;
0304 
0305     data->usb_type = POWER_SUPPLY_USB_TYPE_C;
0306 
0307     power_supply_changed(data->psy);
0308 }
0309 
0310 static void rt1719_update_operating_status(struct rt1719_data *data)
0311 {
0312     enum power_supply_usb_type usb_type = POWER_SUPPLY_USB_TYPE_PD;
0313     u32 voltage, max_current, op_current;
0314     int i, snk_sel;
0315 
0316     for (i = 0; i < data->spdo_num; i++) {
0317         u32 pdo = data->spdos[i];
0318         enum pd_pdo_type type = pdo_type(pdo);
0319 
0320         if (type == PDO_TYPE_APDO) {
0321             usb_type = POWER_SUPPLY_USB_TYPE_PD_PPS;
0322             break;
0323         }
0324     }
0325 
0326     data->spdo_sel = FIELD_GET(RT1719_SPDOSEL_MASK, data->conn_info);
0327     if (data->spdo_sel <= 0)
0328         return;
0329 
0330     data->usb_type = usb_type;
0331 
0332     voltage = pdo_fixed_voltage(data->spdos[data->spdo_sel - 1]);
0333     max_current = pdo_max_current(data->spdos[data->spdo_sel - 1]);
0334 
0335     switch (voltage) {
0336     case 5000:
0337         snk_sel = RT1719_SNKCAP_5V;
0338         break;
0339     case 9000:
0340         snk_sel = RT1719_SNKCAP_9V;
0341         break;
0342     case 12000:
0343         snk_sel = RT1719_SNKCAP_12V;
0344         break;
0345     case 15000:
0346         snk_sel = RT1719_SNKCAP_15V;
0347         break;
0348     case 20000:
0349         snk_sel = RT1719_SNKCAP_20V;
0350         break;
0351     default:
0352         return;
0353     }
0354 
0355     op_current = min(max_current, pdo_max_current(data->snkcaps[snk_sel]));
0356 
0357     /* covert mV/mA to uV/uA */
0358     data->voltage = voltage * 1000;
0359     data->max_current = max_current * 1000;
0360     data->op_current = op_current * 1000;
0361 
0362     power_supply_changed(data->psy);
0363 }
0364 
0365 static void rt1719_update_pwr_opmode(struct rt1719_data *data)
0366 {
0367     if (!data->attached)
0368         return;
0369 
0370     if (!data->pd_capable) {
0371         data->pd_capable = true;
0372 
0373         typec_set_pwr_opmode(data->port, TYPEC_PWR_MODE_PD);
0374         rt1719_register_partner(data);
0375     }
0376 
0377     rt1719_update_operating_status(data);
0378 }
0379 
0380 static void rt1719_update_source_pdos(struct rt1719_data *data)
0381 {
0382     int spdo_num = FIELD_GET(RT1719_SPDONUM_MASK, data->conn_info);
0383     __le32 src_pdos[RT1719_MAX_SRCPDO] = { };
0384     int i, ret;
0385 
0386     if (!data->attached)
0387         return;
0388 
0389     ret = regmap_raw_read(data->regmap, RT1719_REG_SRCPDO1, src_pdos,
0390                   sizeof(__le32) * spdo_num);
0391     if (ret)
0392         return;
0393 
0394     data->spdo_num = spdo_num;
0395     for (i = 0; i < spdo_num; i++)
0396         data->spdos[i] = le32_to_cpu(src_pdos[i]);
0397 }
0398 
0399 static int rt1719_dr_set(struct typec_port *port, enum typec_data_role role)
0400 {
0401     struct rt1719_data *data = typec_get_drvdata(port);
0402     enum typec_data_role cur_role;
0403     int ret;
0404 
0405     if (!data->attached || !data->pd_capable || !data->drswap_support)
0406         return -EOPNOTSUPP;
0407 
0408     if (data->spdo_num > 0 && !(data->spdos[0] & PDO_FIXED_DATA_SWAP))
0409         return -EINVAL;
0410 
0411     cur_role = rt1719_get_data_role(data->conn_info);
0412     if (cur_role == role)
0413         return 0;
0414 
0415     ret = regmap_update_bits(data->regmap, RT1719_REG_TXCTRL1,
0416                  RT1719_REQDRSWAP_MASK, RT1719_REQDRSWAP_MASK);
0417     if (ret)
0418         return ret;
0419 
0420     reinit_completion(&data->req_completion);
0421     ret = wait_for_completion_timeout(&data->req_completion,
0422                       msecs_to_jiffies(400));
0423     if (ret == 0)
0424         return -ETIMEDOUT;
0425 
0426     cur_role = rt1719_get_data_role(data->conn_info);
0427     if (cur_role != role)
0428         return -EAGAIN;
0429 
0430     rt1719_set_data_role(data, role, true);
0431     return 0;
0432 }
0433 
0434 static const struct typec_operations rt1719_port_ops = {
0435     .dr_set = rt1719_dr_set,
0436 };
0437 
0438 static int rt1719_usbpd_request_voltage(struct rt1719_data *data)
0439 {
0440     u32 src_voltage;
0441     int snk_sel, src_sel = -1;
0442     int i, ret;
0443 
0444     if (!data->attached || !data->pd_capable || data->spdo_sel <= 0)
0445         return -EINVAL;
0446 
0447     src_voltage = pdo_fixed_voltage(data->spdos[data->spdo_sel - 1]);
0448     if (src_voltage == data->req_voltage)
0449         return 0;
0450 
0451     switch (data->req_voltage) {
0452     case 5000:
0453         snk_sel = RT1719_SNKCAP_5V;
0454         break;
0455     case 9000:
0456         snk_sel = RT1719_SNKCAP_9V;
0457         break;
0458     case 12000:
0459         snk_sel = RT1719_SNKCAP_12V;
0460         break;
0461     case 15000:
0462         snk_sel = RT1719_SNKCAP_15V;
0463         break;
0464     case 20000:
0465         snk_sel = RT1719_SNKCAP_20V;
0466         break;
0467     default:
0468         return -EINVAL;
0469     }
0470 
0471     if (!(data->snkcaps[snk_sel] & RT1719_PSEL_SUPPORT))
0472         return -EINVAL;
0473 
0474     for (i = 0; i < data->spdo_num; i++) {
0475         enum pd_pdo_type type = pdo_type(data->spdos[i]);
0476 
0477         if (type != PDO_TYPE_FIXED)
0478             continue;
0479 
0480         src_voltage = pdo_fixed_voltage(data->spdos[i]);
0481         if (src_voltage == data->req_voltage) {
0482             src_sel = i;
0483             break;
0484         }
0485     }
0486 
0487     if (src_sel == -1)
0488         return -EOPNOTSUPP;
0489 
0490     ret = regmap_update_bits(data->regmap, RT1719_REG_TXCTRL1,
0491                  RT1719_EVALMODE_MASK | RT1719_REQSRCPDO_MASK,
0492                  RT1719_EVALMODE_MASK | (src_sel + 1));
0493     ret |= regmap_update_bits(data->regmap, RT1719_REG_TXCTRL2,
0494                   RT1719_TXSPDOREQ_MASK, RT1719_TXSPDOREQ_MASK);
0495     if (ret)
0496         return ret;
0497 
0498     reinit_completion(&data->req_completion);
0499     ret = wait_for_completion_timeout(&data->req_completion,
0500                       msecs_to_jiffies(400));
0501     if (!ret)
0502         return -ETIMEDOUT;
0503 
0504     return 0;
0505 }
0506 
0507 static int rt1719_psy_set_property(struct power_supply *psy,
0508                    enum power_supply_property psp,
0509                    const union power_supply_propval *val)
0510 {
0511     struct rt1719_data *data = power_supply_get_drvdata(psy);
0512 
0513     if (psp == POWER_SUPPLY_PROP_VOLTAGE_NOW) {
0514         data->req_voltage = val->intval / 1000;
0515         return rt1719_usbpd_request_voltage(data);
0516     }
0517 
0518     return -EINVAL;
0519 }
0520 
0521 static int rt1719_psy_get_property(struct power_supply *psy,
0522                    enum power_supply_property psp,
0523                    union power_supply_propval *val)
0524 {
0525     struct rt1719_data *data = power_supply_get_drvdata(psy);
0526     int ret = 0;
0527 
0528     switch (psp) {
0529     case POWER_SUPPLY_PROP_ONLINE:
0530         val->intval = data->attached ? 1 : 0;
0531         break;
0532     case POWER_SUPPLY_PROP_USB_TYPE:
0533         val->intval = data->usb_type;
0534         break;
0535     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
0536         val->intval = data->voltage;
0537         break;
0538     case POWER_SUPPLY_PROP_CURRENT_MAX:
0539         val->intval = data->max_current;
0540         break;
0541     case POWER_SUPPLY_PROP_CURRENT_NOW:
0542         val->intval = data->op_current;
0543         break;
0544     default:
0545         ret = -EINVAL;
0546         break;
0547     }
0548 
0549     return ret;
0550 }
0551 
0552 static int rt1719_psy_property_is_writeable(struct power_supply *psy,
0553                         enum power_supply_property psp)
0554 {
0555     if (psp == POWER_SUPPLY_PROP_VOLTAGE_NOW)
0556         return 1;
0557     return 0;
0558 }
0559 
0560 static int devm_rt1719_psy_register(struct rt1719_data *data)
0561 {
0562     struct power_supply_config psy_cfg = { };
0563     char *psy_name;
0564 
0565     psy_cfg.fwnode = dev_fwnode(data->dev);
0566     psy_cfg.drv_data = data;
0567 
0568     psy_name = devm_kasprintf(data->dev, GFP_KERNEL, "rt1719-source-psy-%s",
0569                   dev_name(data->dev));
0570     if (!psy_name)
0571         return -ENOMEM;
0572 
0573     data->psy_desc.name = psy_name;
0574     data->psy_desc.type = POWER_SUPPLY_TYPE_USB;
0575     data->psy_desc.usb_types = rt1719_psy_usb_types;
0576     data->psy_desc.num_usb_types = ARRAY_SIZE(rt1719_psy_usb_types);
0577     data->psy_desc.properties = rt1719_psy_properties;
0578     data->psy_desc.num_properties = ARRAY_SIZE(rt1719_psy_properties);
0579     data->psy_desc.get_property = rt1719_psy_get_property;
0580     data->psy_desc.set_property = rt1719_psy_set_property;
0581     data->psy_desc.property_is_writeable = rt1719_psy_property_is_writeable;
0582 
0583     data->usb_type = POWER_SUPPLY_USB_TYPE_C;
0584 
0585     data->psy = devm_power_supply_register(data->dev, &data->psy_desc,
0586                            &psy_cfg);
0587 
0588     return PTR_ERR_OR_ZERO(data->psy);
0589 }
0590 
0591 static irqreturn_t rt1719_irq_handler(int irq, void *priv)
0592 {
0593     struct rt1719_data *data = priv;
0594     u32 events, conn_info;
0595     u16 conn_stat;
0596     int ret;
0597 
0598     ret = rt1719_read32(data, RT1719_REG_EVENTS, &events);
0599     ret |= rt1719_read32(data, RT1719_REG_POLICYINFO, &conn_info);
0600     ret |= rt1719_read16(data, RT1719_REG_STATS, &conn_stat);
0601     if (ret)
0602         return IRQ_NONE;
0603 
0604     data->conn_info = conn_info;
0605     data->conn_stat = conn_stat;
0606 
0607     events &= (RT1719_INT_DRSW_ACCEPT | RT1719_INT_RX_SRCCAP |
0608            RT1719_INT_VBUS_PRESENT | RT1719_INT_VBUS_DCT |
0609            RT1719_INT_PE_SNK_RDY);
0610 
0611     if (events & RT1719_INT_DRSW_ACCEPT)
0612         rt1719_update_data_role(data);
0613 
0614     if (events & RT1719_INT_VBUS_PRESENT)
0615         rt1719_attach(data);
0616 
0617     if (events & RT1719_INT_VBUS_DCT)
0618         rt1719_detach(data);
0619 
0620     if (events & RT1719_INT_RX_SRCCAP)
0621         rt1719_update_source_pdos(data);
0622 
0623     if (events & RT1719_INT_PE_SNK_RDY) {
0624         complete(&data->req_completion);
0625         rt1719_update_pwr_opmode(data);
0626     }
0627 
0628     /* Write 1 to clear already handled events */
0629     rt1719_write32(data, RT1719_REG_EVENTS, events);
0630 
0631     return IRQ_HANDLED;
0632 }
0633 
0634 static int rt1719_irq_init(struct rt1719_data *data)
0635 {
0636     struct i2c_client *i2c = to_i2c_client(data->dev);
0637     u32 irq_enable;
0638     int ret;
0639 
0640     irq_enable = RT1719_INT_DRSW_ACCEPT | RT1719_INT_RX_SRCCAP |
0641              RT1719_INT_VBUS_DCT | RT1719_INT_VBUS_PRESENT |
0642              RT1719_INT_PE_SNK_RDY;
0643 
0644     ret = rt1719_write32(data, RT1719_REG_MASKS, irq_enable);
0645     if (ret) {
0646         dev_err(&i2c->dev, "Failed to config irq enable\n");
0647         return ret;
0648     }
0649 
0650     return devm_request_threaded_irq(&i2c->dev, i2c->irq, NULL,
0651                      rt1719_irq_handler, IRQF_ONESHOT,
0652                      dev_name(&i2c->dev), data);
0653 }
0654 
0655 static int rt1719_init_attach_state(struct rt1719_data *data)
0656 {
0657     u32 conn_info, irq_clear;
0658     u16 conn_stat;
0659     int ret;
0660 
0661     irq_clear = RT1719_INT_DRSW_ACCEPT | RT1719_INT_RX_SRCCAP |
0662             RT1719_INT_VBUS_DCT | RT1719_INT_VBUS_PRESENT |
0663             RT1719_INT_PE_SNK_RDY;
0664 
0665     ret = rt1719_read32(data, RT1719_REG_POLICYINFO, &conn_info);
0666     ret |= rt1719_read16(data, RT1719_REG_STATS, &conn_stat);
0667     ret |= rt1719_write32(data, RT1719_REG_EVENTS, irq_clear);
0668     if (ret)
0669         return ret;
0670 
0671     data->conn_info = conn_info;
0672     data->conn_stat = conn_stat;
0673 
0674     if (conn_info & RT1719_ATTACHDEV_MASK)
0675         rt1719_attach(data);
0676 
0677     if (conn_info & RT1719_PE_EXP_CONTRACT) {
0678         rt1719_update_source_pdos(data);
0679         rt1719_update_pwr_opmode(data);
0680     }
0681 
0682     return 0;
0683 }
0684 
0685 #define RT1719_PSEL_CAPINFO(_lomask, _milliwatt, _himask, _milliamp) { \
0686     .lomask     = _lomask, \
0687     .milliwatt  = _milliwatt, \
0688     .himask     = _himask, \
0689     .milliamp   = _milliamp, \
0690 }
0691 
0692 static const struct rt1719_psel_cap rt1719_psel_caps[] = {
0693     RT1719_PSEL_CAPINFO(0x18, 75000, 0x10, 5000),
0694     RT1719_PSEL_CAPINFO(0x18, 60000, 0x10, 4500),
0695     RT1719_PSEL_CAPINFO(0x18, 45000, 0x10, 4000),
0696     RT1719_PSEL_CAPINFO(0x18, 30000, 0x10, 3500),
0697     RT1719_PSEL_CAPINFO(0x18, 25000, 0x10, 3000),
0698     RT1719_PSEL_CAPINFO(0x18, 20000, 0x10, 2500),
0699     RT1719_PSEL_CAPINFO(0x18, 15000, 0x10, 2000),
0700     RT1719_PSEL_CAPINFO(0x18, 10000, 0x10, 1000),
0701     RT1719_PSEL_CAPINFO(0x1C, 60000, 0x1F, 5000),
0702     RT1719_PSEL_CAPINFO(0x1C, 45000, 0x1F, 4500),
0703     RT1719_PSEL_CAPINFO(0x1C, 30000, 0x1F, 4000),
0704     RT1719_PSEL_CAPINFO(0x1C, 24000, 0x1F, 3500),
0705     RT1719_PSEL_CAPINFO(0x1C, 15000, 0x1F, 3000),
0706     RT1719_PSEL_CAPINFO(0x1C, 10000, 0x1F, 2500),
0707     RT1719_PSEL_CAPINFO(0x0C, 60000, 0x1F, 2000),
0708     RT1719_PSEL_CAPINFO(0x0C, 45000, 0x1F, 1000),
0709     RT1719_PSEL_CAPINFO(0x0C, 36000, 0x08, 5000),
0710     RT1719_PSEL_CAPINFO(0x0C, 30000, 0x08, 4500),
0711     RT1719_PSEL_CAPINFO(0x0C, 24000, 0x08, 4000),
0712     RT1719_PSEL_CAPINFO(0x0C, 15000, 0x08, 3500),
0713     RT1719_PSEL_CAPINFO(0x0C, 10000, 0x08, 3000),
0714     RT1719_PSEL_CAPINFO(0x1E, 45000, 0x08, 2500),
0715     RT1719_PSEL_CAPINFO(0x1E, 36000, 0x08, 2000),
0716     RT1719_PSEL_CAPINFO(0x1E, 27000, 0x08, 1500),
0717     RT1719_PSEL_CAPINFO(0x1E, 20000, 0x08, 1000),
0718     RT1719_PSEL_CAPINFO(0x1E, 15000, 0x0F, 5000),
0719     RT1719_PSEL_CAPINFO(0x1E, 9000, 0x0F, 4500),
0720     RT1719_PSEL_CAPINFO(0x0E, 45000, 0x0F, 4000),
0721     RT1719_PSEL_CAPINFO(0x0E, 36000, 0x0F, 3500),
0722     RT1719_PSEL_CAPINFO(0x0E, 27000, 0x0F, 3000),
0723     RT1719_PSEL_CAPINFO(0x0E, 20000, 0x0F, 2500),
0724     RT1719_PSEL_CAPINFO(0x0E, 15000, 0x0F, 2000),
0725     RT1719_PSEL_CAPINFO(0x0E, 9000, 0x0F, 1500),
0726     RT1719_PSEL_CAPINFO(0x06, 45000, 0x0F, 1000),
0727     RT1719_PSEL_CAPINFO(0x06, 36000, 0x0F, 500),
0728     RT1719_PSEL_CAPINFO(0x06, 27000, 0x04, 5000),
0729     RT1719_PSEL_CAPINFO(0x06, 24000, 0x04, 4500),
0730     RT1719_PSEL_CAPINFO(0x06, 18000, 0x04, 4000),
0731     RT1719_PSEL_CAPINFO(0x06, 12000, 0x04, 3500),
0732     RT1719_PSEL_CAPINFO(0x06, 9000, 0x04, 3000),
0733     RT1719_PSEL_CAPINFO(0x1F, 25000, 0x04, 2500),
0734     RT1719_PSEL_CAPINFO(0x1F, 20000, 0x04, 2000),
0735     RT1719_PSEL_CAPINFO(0x1F, 15000, 0x04, 1500),
0736     RT1719_PSEL_CAPINFO(0x1F, 10000, 0x04, 1000),
0737     RT1719_PSEL_CAPINFO(0x1F, 7500, 0x07, 5000),
0738     RT1719_PSEL_CAPINFO(0x0F, 25000, 0x07, 4500),
0739     RT1719_PSEL_CAPINFO(0x0F, 20000, 0x07, 4000),
0740     RT1719_PSEL_CAPINFO(0x0F, 15000, 0x07, 3500),
0741     RT1719_PSEL_CAPINFO(0x0F, 10000, 0x07, 3000),
0742     RT1719_PSEL_CAPINFO(0x0F, 7500, 0x07, 2500),
0743     RT1719_PSEL_CAPINFO(0x07, 25000, 0x07, 2000),
0744     RT1719_PSEL_CAPINFO(0x07, 20000, 0x07, 1500),
0745     RT1719_PSEL_CAPINFO(0x07, 15000, 0x07, 1000),
0746     RT1719_PSEL_CAPINFO(0x07, 10000, 0x07, 500),
0747     RT1719_PSEL_CAPINFO(0x07, 7500, 0x03, 5000),
0748     RT1719_PSEL_CAPINFO(0x03, 25000, 0x03, 4500),
0749     RT1719_PSEL_CAPINFO(0x03, 20000, 0x03, 4000),
0750     RT1719_PSEL_CAPINFO(0x03, 15000, 0x03, 3500),
0751     RT1719_PSEL_CAPINFO(0x03, 10000, 0x03, 3000),
0752     RT1719_PSEL_CAPINFO(0x03, 7500, 0x03, 2500),
0753     RT1719_PSEL_CAPINFO(0x01, 15000, 0x03, 2000),
0754     RT1719_PSEL_CAPINFO(0x01, 10000, 0x03, 1500),
0755     RT1719_PSEL_CAPINFO(0x01, 7500, 0x03, 1000),
0756     RT1719_PSEL_CAPINFO(0x01, 2500, 0x03, 500)
0757 };
0758 
0759 static u16 rt1719_gen_snkcap_by_current(const struct rt1719_psel_cap *psel_cap,
0760                     enum rt1719_snkcap capsel)
0761 {
0762     u16 cap = RT1719_PSEL_SUPPORT;
0763 
0764     if (!(psel_cap->himask & BIT(capsel)))
0765         return 0;
0766 
0767     cap |= psel_cap->milliamp / 10;
0768     return cap;
0769 }
0770 
0771 static u16 rt1719_gen_snkcap_by_watt(const struct rt1719_psel_cap *psel_cap,
0772                      enum rt1719_snkcap capsel)
0773 {
0774     u32 volt_div[RT1719_MAX_SNKCAP] = { 5, 9, 12, 15, 20 };
0775     u16 cap = RT1719_PSEL_SUPPORT;
0776 
0777     if (!(psel_cap->lomask & BIT(capsel)))
0778         return 0;
0779 
0780     cap |= min(psel_cap->milliwatt / volt_div[capsel], (u32)5000) / 10;
0781     return cap;
0782 }
0783 
0784 static u16 rt1719_gen_snkcap(unsigned int pselinfo, enum rt1719_snkcap capsel)
0785 {
0786     int psel = FIELD_GET(RT1719_LATPSEL_MASK, pselinfo);
0787     const struct rt1719_psel_cap *psel_cap;
0788     bool by_current = false;
0789 
0790     if (pselinfo & RT1719_TBLSEL_MASK)
0791         by_current = true;
0792 
0793     psel_cap = rt1719_psel_caps + psel;
0794     if (by_current)
0795         return rt1719_gen_snkcap_by_current(psel_cap, capsel);
0796 
0797     return rt1719_gen_snkcap_by_watt(psel_cap, capsel);
0798 }
0799 
0800 static int rt1719_get_caps(struct rt1719_data *data)
0801 {
0802     unsigned int pselinfo, usbinfo;
0803     int i, ret;
0804 
0805     ret = regmap_read(data->regmap, RT1719_REG_PSELINFO, &pselinfo);
0806     ret |= regmap_read(data->regmap, RT1719_REG_USBSETINFO, &usbinfo);
0807     if (ret)
0808         return ret;
0809 
0810     for (i = 0; i < RT1719_MAX_SNKCAP; i++)
0811         data->snkcaps[i] = rt1719_gen_snkcap(pselinfo, i);
0812 
0813     usbinfo = FIELD_GET(RT1719_USBINFO_MASK, usbinfo);
0814     if (usbinfo == RT1719_USB_DFPUFP)
0815         data->drswap_support = true;
0816 
0817     return 0;
0818 }
0819 
0820 static int rt1719_check_exist(struct rt1719_data *data)
0821 {
0822     u16 pid;
0823     int ret;
0824 
0825     ret = rt1719_read16(data, RT1719_REG_VENID, &pid);
0826     if (ret)
0827         return ret;
0828 
0829     if (pid != RT1719_UNIQUE_PID) {
0830         dev_err(data->dev, "Incorrect PID 0x%04x\n", pid);
0831         return -ENODEV;
0832     }
0833 
0834     return 0;
0835 }
0836 
0837 static const struct regmap_config rt1719_regmap_config = {
0838     .reg_bits = 8,
0839     .val_bits = 8,
0840     .max_register = 0xff,
0841 };
0842 
0843 static int rt1719_probe(struct i2c_client *i2c)
0844 {
0845     struct rt1719_data *data;
0846     struct fwnode_handle *fwnode;
0847     struct typec_capability typec_cap = { };
0848     int ret;
0849 
0850     data = devm_kzalloc(&i2c->dev, sizeof(*data), GFP_KERNEL);
0851     if (!data)
0852         return -ENOMEM;
0853 
0854     data->dev = &i2c->dev;
0855     init_completion(&data->req_completion);
0856 
0857     data->regmap = devm_regmap_init_i2c(i2c, &rt1719_regmap_config);
0858     if (IS_ERR(data->regmap)) {
0859         ret = PTR_ERR(data->regmap);
0860         dev_err(&i2c->dev, "Failed to init regmap (%d)\n", ret);
0861         return ret;
0862     }
0863 
0864     ret = rt1719_check_exist(data);
0865     if (ret)
0866         return ret;
0867 
0868     ret = rt1719_get_caps(data);
0869     if (ret)
0870         return ret;
0871 
0872     fwnode = device_get_named_child_node(&i2c->dev, "connector");
0873     if (!fwnode)
0874         return -ENODEV;
0875 
0876     data->role_sw = fwnode_usb_role_switch_get(fwnode);
0877     if (IS_ERR(data->role_sw)) {
0878         ret = PTR_ERR(data->role_sw);
0879         dev_err(&i2c->dev, "Failed to get usb role switch (%d)\n", ret);
0880         goto err_fwnode_put;
0881     }
0882 
0883     ret = devm_rt1719_psy_register(data);
0884     if (ret) {
0885         dev_err(&i2c->dev, "Failed to register psy (%d)\n", ret);
0886         goto err_role_put;
0887     }
0888 
0889     typec_cap.revision = USB_TYPEC_REV_1_2;
0890     typec_cap.pd_revision = 0x300;  /* USB-PD spec release 3.0 */
0891     typec_cap.type = TYPEC_PORT_SNK;
0892     typec_cap.data = TYPEC_PORT_DRD;
0893     typec_cap.ops = &rt1719_port_ops;
0894     typec_cap.fwnode = fwnode;
0895     typec_cap.driver_data = data;
0896     typec_cap.accessory[0] = TYPEC_ACCESSORY_DEBUG;
0897 
0898     data->partner_desc.identity = &data->partner_ident;
0899 
0900     data->port = typec_register_port(&i2c->dev, &typec_cap);
0901     if (IS_ERR(data->port)) {
0902         ret = PTR_ERR(data->port);
0903         dev_err(&i2c->dev, "Failed to register typec port (%d)\n", ret);
0904         goto err_role_put;
0905     }
0906 
0907     ret = rt1719_init_attach_state(data);
0908     if (ret) {
0909         dev_err(&i2c->dev, "Failed to init attach state (%d)\n", ret);
0910         goto err_role_put;
0911     }
0912 
0913     ret = rt1719_irq_init(data);
0914     if (ret) {
0915         dev_err(&i2c->dev, "Failed to init irq\n");
0916         goto err_role_put;
0917     }
0918 
0919     fwnode_handle_put(fwnode);
0920 
0921     i2c_set_clientdata(i2c, data);
0922 
0923     return 0;
0924 
0925 err_role_put:
0926     usb_role_switch_put(data->role_sw);
0927 err_fwnode_put:
0928     fwnode_handle_put(fwnode);
0929 
0930     return ret;
0931 }
0932 
0933 static int rt1719_remove(struct i2c_client *i2c)
0934 {
0935     struct rt1719_data *data = i2c_get_clientdata(i2c);
0936 
0937     typec_unregister_port(data->port);
0938     usb_role_switch_put(data->role_sw);
0939 
0940     return 0;
0941 }
0942 
0943 static const struct of_device_id __maybe_unused rt1719_device_table[] = {
0944     { .compatible = "richtek,rt1719", },
0945     { }
0946 };
0947 MODULE_DEVICE_TABLE(of, rt1719_device_table);
0948 
0949 static struct i2c_driver rt1719_driver = {
0950     .driver = {
0951         .name = "rt1719",
0952         .of_match_table = rt1719_device_table,
0953     },
0954     .probe_new = rt1719_probe,
0955     .remove = rt1719_remove,
0956 };
0957 module_i2c_driver(rt1719_driver);
0958 
0959 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>");
0960 MODULE_DESCRIPTION("Richtek RT1719 Sink Only USBPD Controller Driver");
0961 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!