1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2023, Linaro Limited 4 */ 5 6 #include <linux/module.h> 7 #include <linux/platform_device.h> 8 #include <linux/regulator/consumer.h> 9 #include <linux/regmap.h> 10 #include <linux/of.h> 11 #include <linux/phy/phy.h> 12 13 /* eUSB2 status registers */ 14 #define EUSB2_RPTR_STATUS 0x08 15 #define RPTR_OK BIT(7) 16 17 /* eUSB2 control registers */ 18 #define EUSB2_EN_CTL1 0x46 19 #define EUSB2_RPTR_EN BIT(7) 20 21 #define EUSB2_FORCE_EN_5 0xe8 22 #define F_CLK_19P2M_EN BIT(6) 23 24 #define EUSB2_FORCE_VAL_5 0xeD 25 #define V_CLK_19P2M_EN BIT(6) 26 27 #define EUSB2_TUNE_USB2_CROSSOVER 0x50 28 #define EUSB2_TUNE_IUSB2 0x51 29 #define EUSB2_TUNE_RES_FSDIF 0x52 30 #define EUSB2_TUNE_HSDISC 0x53 31 #define EUSB2_TUNE_SQUELCH_U 0x54 32 #define EUSB2_TUNE_USB2_SLEW 0x55 33 #define EUSB2_TUNE_USB2_EQU 0x56 34 #define EUSB2_TUNE_USB2_PREEM 0x57 35 #define EUSB2_TUNE_USB2_HS_COMP_CUR 0x58 36 #define EUSB2_TUNE_EUSB_SLEW 0x59 37 #define EUSB2_TUNE_EUSB_EQU 0x5A 38 #define EUSB2_TUNE_EUSB_HS_COMP_CUR 0x5B 39 40 struct eusb2_repeater_init_tbl_reg { 41 unsigned int reg; 42 unsigned int value; 43 }; 44 45 struct eusb2_repeater_cfg { 46 const struct eusb2_repeater_init_tbl_reg *init_tbl; 47 int init_tbl_num; 48 const char * const *vreg_list; 49 int num_vregs; 50 }; 51 52 struct eusb2_repeater { 53 struct device *dev; 54 struct regmap *regmap; 55 struct phy *phy; 56 struct regulator_bulk_data *vregs; 57 const struct eusb2_repeater_cfg *cfg; 58 u32 base; 59 enum phy_mode mode; 60 }; 61 62 static const char * const pm8550b_vreg_l[] = { 63 "vdd18", "vdd3", 64 }; 65 66 static const struct eusb2_repeater_init_tbl_reg pm8550b_init_tbl[] = { 67 { EUSB2_TUNE_IUSB2, 0x8 }, 68 { EUSB2_TUNE_SQUELCH_U, 0x3 }, 69 { EUSB2_TUNE_USB2_PREEM, 0x5 }, 70 }; 71 72 static const struct eusb2_repeater_init_tbl_reg smb2360_init_tbl[] = { 73 { EUSB2_TUNE_IUSB2, 0x5 }, 74 { EUSB2_TUNE_SQUELCH_U, 0x3 }, 75 { EUSB2_TUNE_USB2_PREEM, 0x2 }, 76 }; 77 78 static const struct eusb2_repeater_cfg pm8550b_eusb2_cfg = { 79 .init_tbl = pm8550b_init_tbl, 80 .init_tbl_num = ARRAY_SIZE(pm8550b_init_tbl), 81 .vreg_list = pm8550b_vreg_l, 82 .num_vregs = ARRAY_SIZE(pm8550b_vreg_l), 83 }; 84 85 static const struct eusb2_repeater_cfg smb2360_eusb2_cfg = { 86 .init_tbl = smb2360_init_tbl, 87 .init_tbl_num = ARRAY_SIZE(smb2360_init_tbl), 88 .vreg_list = pm8550b_vreg_l, 89 .num_vregs = ARRAY_SIZE(pm8550b_vreg_l), 90 }; 91 92 static int eusb2_repeater_init_vregs(struct eusb2_repeater *rptr) 93 { 94 int num = rptr->cfg->num_vregs; 95 struct device *dev = rptr->dev; 96 int i; 97 98 rptr->vregs = devm_kcalloc(dev, num, sizeof(*rptr->vregs), GFP_KERNEL); 99 if (!rptr->vregs) 100 return -ENOMEM; 101 102 for (i = 0; i < num; i++) 103 rptr->vregs[i].supply = rptr->cfg->vreg_list[i]; 104 105 return devm_regulator_bulk_get(dev, num, rptr->vregs); 106 } 107 108 static int eusb2_repeater_init(struct phy *phy) 109 { 110 struct eusb2_repeater *rptr = phy_get_drvdata(phy); 111 struct device_node *np = rptr->dev->of_node; 112 struct regmap *regmap = rptr->regmap; 113 u32 base = rptr->base; 114 u32 poll_val; 115 int ret; 116 u8 val; 117 118 ret = regulator_bulk_enable(rptr->cfg->num_vregs, rptr->vregs); 119 if (ret) 120 return ret; 121 122 regmap_write(regmap, base + EUSB2_EN_CTL1, EUSB2_RPTR_EN); 123 124 /* Write registers from init table */ 125 for (int i = 0; i < rptr->cfg->init_tbl_num; i++) 126 regmap_write(regmap, base + rptr->cfg->init_tbl[i].reg, 127 rptr->cfg->init_tbl[i].value); 128 129 /* Override registers from devicetree values */ 130 if (!of_property_read_u8(np, "qcom,tune-usb2-amplitude", &val)) 131 regmap_write(regmap, base + EUSB2_TUNE_USB2_PREEM, val); 132 133 if (!of_property_read_u8(np, "qcom,tune-usb2-disc-thres", &val)) 134 regmap_write(regmap, base + EUSB2_TUNE_HSDISC, val); 135 136 if (!of_property_read_u8(np, "qcom,tune-usb2-preem", &val)) 137 regmap_write(regmap, base + EUSB2_TUNE_IUSB2, val); 138 139 /* Wait for status OK */ 140 ret = regmap_read_poll_timeout(regmap, base + EUSB2_RPTR_STATUS, poll_val, 141 poll_val & RPTR_OK, 10, 5); 142 if (ret) 143 dev_err(rptr->dev, "initialization timed-out\n"); 144 145 return ret; 146 } 147 148 static int eusb2_repeater_set_mode(struct phy *phy, 149 enum phy_mode mode, int submode) 150 { 151 struct eusb2_repeater *rptr = phy_get_drvdata(phy); 152 struct regmap *regmap = rptr->regmap; 153 u32 base = rptr->base; 154 155 switch (mode) { 156 case PHY_MODE_USB_HOST: 157 /* 158 * CM.Lx is prohibited when repeater is already into Lx state as 159 * per eUSB 1.2 Spec. Below implement software workaround until 160 * PHY and controller is fixing seen observation. 161 */ 162 regmap_write(regmap, base + EUSB2_FORCE_EN_5, F_CLK_19P2M_EN); 163 regmap_write(regmap, base + EUSB2_FORCE_VAL_5, V_CLK_19P2M_EN); 164 break; 165 case PHY_MODE_USB_DEVICE: 166 /* 167 * In device mode clear host mode related workaround as there 168 * is no repeater reset available, and enable/disable of 169 * repeater doesn't clear previous value due to shared 170 * regulators (say host <-> device mode switch). 171 */ 172 regmap_write(regmap, base + EUSB2_FORCE_EN_5, 0); 173 regmap_write(regmap, base + EUSB2_FORCE_VAL_5, 0); 174 break; 175 default: 176 return -EINVAL; 177 } 178 179 return 0; 180 } 181 182 static int eusb2_repeater_exit(struct phy *phy) 183 { 184 struct eusb2_repeater *rptr = phy_get_drvdata(phy); 185 186 return regulator_bulk_disable(rptr->cfg->num_vregs, rptr->vregs); 187 } 188 189 static const struct phy_ops eusb2_repeater_ops = { 190 .init = eusb2_repeater_init, 191 .exit = eusb2_repeater_exit, 192 .set_mode = eusb2_repeater_set_mode, 193 .owner = THIS_MODULE, 194 }; 195 196 static int eusb2_repeater_probe(struct platform_device *pdev) 197 { 198 struct eusb2_repeater *rptr; 199 struct device *dev = &pdev->dev; 200 struct phy_provider *phy_provider; 201 struct device_node *np = dev->of_node; 202 u32 res; 203 int ret; 204 205 rptr = devm_kzalloc(dev, sizeof(*rptr), GFP_KERNEL); 206 if (!rptr) 207 return -ENOMEM; 208 209 rptr->dev = dev; 210 dev_set_drvdata(dev, rptr); 211 212 rptr->cfg = of_device_get_match_data(dev); 213 if (!rptr->cfg) 214 return -EINVAL; 215 216 rptr->regmap = dev_get_regmap(dev->parent, NULL); 217 if (!rptr->regmap) 218 return -ENODEV; 219 220 ret = of_property_read_u32(np, "reg", &res); 221 if (ret < 0) 222 return ret; 223 224 rptr->base = res; 225 226 ret = eusb2_repeater_init_vregs(rptr); 227 if (ret < 0) { 228 dev_err(dev, "unable to get supplies\n"); 229 return ret; 230 } 231 232 rptr->phy = devm_phy_create(dev, np, &eusb2_repeater_ops); 233 if (IS_ERR(rptr->phy)) { 234 dev_err(dev, "failed to create PHY: %d\n", ret); 235 return PTR_ERR(rptr->phy); 236 } 237 238 phy_set_drvdata(rptr->phy, rptr); 239 240 phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate); 241 if (IS_ERR(phy_provider)) 242 return PTR_ERR(phy_provider); 243 244 return 0; 245 } 246 247 static void eusb2_repeater_remove(struct platform_device *pdev) 248 { 249 struct eusb2_repeater *rptr = platform_get_drvdata(pdev); 250 251 if (!rptr) 252 return; 253 254 eusb2_repeater_exit(rptr->phy); 255 } 256 257 static const struct of_device_id eusb2_repeater_of_match_table[] = { 258 { 259 .compatible = "qcom,pm8550b-eusb2-repeater", 260 .data = &pm8550b_eusb2_cfg, 261 }, 262 { 263 .compatible = "qcom,smb2360-eusb2-repeater", 264 .data = &smb2360_eusb2_cfg, 265 }, 266 { }, 267 }; 268 MODULE_DEVICE_TABLE(of, eusb2_repeater_of_match_table); 269 270 static struct platform_driver eusb2_repeater_driver = { 271 .probe = eusb2_repeater_probe, 272 .remove = eusb2_repeater_remove, 273 .driver = { 274 .name = "qcom-eusb2-repeater", 275 .of_match_table = eusb2_repeater_of_match_table, 276 }, 277 }; 278 279 module_platform_driver(eusb2_repeater_driver); 280 281 MODULE_DESCRIPTION("Qualcomm PMIC eUSB2 Repeater driver"); 282 MODULE_LICENSE("GPL"); 283