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 static const int squelch_detector[] = { 41 [0] = -6000, 42 [1] = -5000, 43 [2] = -4000, 44 [3] = -3000, 45 [4] = -2000, 46 [5] = -1000, 47 [6] = 0, 48 [7] = 1000, 49 }; 50 51 struct eusb2_repeater_init_tbl_reg { 52 unsigned int reg; 53 unsigned int value; 54 }; 55 56 struct eusb2_repeater_cfg { 57 const struct eusb2_repeater_init_tbl_reg *init_tbl; 58 int init_tbl_num; 59 const char * const *vreg_list; 60 int num_vregs; 61 }; 62 63 struct eusb2_repeater { 64 struct device *dev; 65 struct regmap *regmap; 66 struct phy *phy; 67 struct regulator_bulk_data *vregs; 68 const struct eusb2_repeater_cfg *cfg; 69 u32 base; 70 enum phy_mode mode; 71 }; 72 73 static const char * const pm8550b_vreg_l[] = { 74 "vdd18", "vdd3", 75 }; 76 77 static const struct eusb2_repeater_init_tbl_reg pm8550b_init_tbl[] = { 78 { EUSB2_TUNE_IUSB2, 0x8 }, 79 { EUSB2_TUNE_SQUELCH_U, 0x3 }, 80 { EUSB2_TUNE_USB2_PREEM, 0x5 }, 81 }; 82 83 static const struct eusb2_repeater_init_tbl_reg smb2360_init_tbl[] = { 84 { EUSB2_TUNE_IUSB2, 0x5 }, 85 { EUSB2_TUNE_SQUELCH_U, 0x3 }, 86 { EUSB2_TUNE_USB2_PREEM, 0x2 }, 87 }; 88 89 static const struct eusb2_repeater_init_tbl_reg smb2370_init_tbl[] = { 90 { EUSB2_TUNE_IUSB2, 0x4 }, 91 { EUSB2_TUNE_SQUELCH_U, 0x3 }, 92 { EUSB2_TUNE_USB2_SLEW, 0x7 }, 93 { EUSB2_TUNE_USB2_PREEM, 0x0 }, 94 }; 95 96 static const struct eusb2_repeater_cfg pm8550b_eusb2_cfg = { 97 .init_tbl = pm8550b_init_tbl, 98 .init_tbl_num = ARRAY_SIZE(pm8550b_init_tbl), 99 .vreg_list = pm8550b_vreg_l, 100 .num_vregs = ARRAY_SIZE(pm8550b_vreg_l), 101 }; 102 103 static const struct eusb2_repeater_cfg pmiv0104_eusb2_cfg = { 104 /* No PMIC-specific init sequence, only board level tuning via DT */ 105 .init_tbl = (struct eusb2_repeater_init_tbl_reg[]) {}, 106 .init_tbl_num = 0, 107 .vreg_list = pm8550b_vreg_l, 108 .num_vregs = ARRAY_SIZE(pm8550b_vreg_l), 109 }; 110 111 static const struct eusb2_repeater_cfg smb2360_eusb2_cfg = { 112 .init_tbl = smb2360_init_tbl, 113 .init_tbl_num = ARRAY_SIZE(smb2360_init_tbl), 114 .vreg_list = pm8550b_vreg_l, 115 .num_vregs = ARRAY_SIZE(pm8550b_vreg_l), 116 }; 117 118 static const struct eusb2_repeater_cfg smb2370_eusb2_cfg = { 119 .init_tbl = smb2370_init_tbl, 120 .init_tbl_num = ARRAY_SIZE(smb2370_init_tbl), 121 .vreg_list = pm8550b_vreg_l, 122 .num_vregs = ARRAY_SIZE(pm8550b_vreg_l), 123 }; 124 125 static int eusb2_repeater_init_vregs(struct eusb2_repeater *rptr) 126 { 127 int num = rptr->cfg->num_vregs; 128 struct device *dev = rptr->dev; 129 int i; 130 131 rptr->vregs = devm_kcalloc(dev, num, sizeof(*rptr->vregs), GFP_KERNEL); 132 if (!rptr->vregs) 133 return -ENOMEM; 134 135 for (i = 0; i < num; i++) 136 rptr->vregs[i].supply = rptr->cfg->vreg_list[i]; 137 138 return devm_regulator_bulk_get(dev, num, rptr->vregs); 139 } 140 141 static int eusb2_repeater_init(struct phy *phy) 142 { 143 struct eusb2_repeater *rptr = phy_get_drvdata(phy); 144 struct device_node *np = rptr->dev->of_node; 145 struct regmap *regmap = rptr->regmap; 146 u32 base = rptr->base; 147 u32 poll_val; 148 s32 dt_val; 149 int ret; 150 int i; 151 u8 val; 152 153 ret = regulator_bulk_enable(rptr->cfg->num_vregs, rptr->vregs); 154 if (ret) 155 return ret; 156 157 regmap_write(regmap, base + EUSB2_EN_CTL1, EUSB2_RPTR_EN); 158 159 /* Write registers from init table */ 160 for (int i = 0; i < rptr->cfg->init_tbl_num; i++) 161 regmap_write(regmap, base + rptr->cfg->init_tbl[i].reg, 162 rptr->cfg->init_tbl[i].value); 163 164 /* Override registers from devicetree values */ 165 if (!of_property_read_u8(np, "qcom,tune-usb2-preem", &val)) 166 regmap_write(regmap, base + EUSB2_TUNE_USB2_PREEM, val); 167 168 if (!of_property_read_u8(np, "qcom,tune-usb2-disc-thres", &val)) 169 regmap_write(regmap, base + EUSB2_TUNE_HSDISC, val); 170 171 if (!of_property_read_u8(np, "qcom,tune-usb2-amplitude", &val)) 172 regmap_write(regmap, base + EUSB2_TUNE_IUSB2, val); 173 174 if (!of_property_read_u8(np, "qcom,tune-res-fsdif", &val)) 175 regmap_write(regmap, base + EUSB2_TUNE_RES_FSDIF, val); 176 177 if (!of_property_read_s32(np, "qcom,squelch-detector-bp", &dt_val)) { 178 for (i = 0; i < ARRAY_SIZE(squelch_detector); i++) { 179 if (squelch_detector[i] == dt_val) { 180 regmap_write(regmap, base + EUSB2_TUNE_SQUELCH_U, i); 181 break; 182 } 183 } 184 } 185 186 /* Wait for status OK */ 187 ret = regmap_read_poll_timeout(regmap, base + EUSB2_RPTR_STATUS, poll_val, 188 poll_val & RPTR_OK, 10, 5); 189 if (ret) 190 dev_err(rptr->dev, "initialization timed-out\n"); 191 192 return ret; 193 } 194 195 static int eusb2_repeater_set_mode(struct phy *phy, 196 enum phy_mode mode, int submode) 197 { 198 struct eusb2_repeater *rptr = phy_get_drvdata(phy); 199 struct regmap *regmap = rptr->regmap; 200 u32 base = rptr->base; 201 202 switch (mode) { 203 case PHY_MODE_USB_HOST: 204 /* 205 * CM.Lx is prohibited when repeater is already into Lx state as 206 * per eUSB 1.2 Spec. Below implement software workaround until 207 * PHY and controller is fixing seen observation. 208 */ 209 regmap_write(regmap, base + EUSB2_FORCE_EN_5, F_CLK_19P2M_EN); 210 regmap_write(regmap, base + EUSB2_FORCE_VAL_5, V_CLK_19P2M_EN); 211 break; 212 case PHY_MODE_USB_DEVICE: 213 /* 214 * In device mode clear host mode related workaround as there 215 * is no repeater reset available, and enable/disable of 216 * repeater doesn't clear previous value due to shared 217 * regulators (say host <-> device mode switch). 218 */ 219 regmap_write(regmap, base + EUSB2_FORCE_EN_5, 0); 220 regmap_write(regmap, base + EUSB2_FORCE_VAL_5, 0); 221 break; 222 default: 223 return -EINVAL; 224 } 225 226 return 0; 227 } 228 229 static int eusb2_repeater_exit(struct phy *phy) 230 { 231 struct eusb2_repeater *rptr = phy_get_drvdata(phy); 232 233 return regulator_bulk_disable(rptr->cfg->num_vregs, rptr->vregs); 234 } 235 236 static const struct phy_ops eusb2_repeater_ops = { 237 .init = eusb2_repeater_init, 238 .exit = eusb2_repeater_exit, 239 .set_mode = eusb2_repeater_set_mode, 240 .owner = THIS_MODULE, 241 }; 242 243 static int eusb2_repeater_probe(struct platform_device *pdev) 244 { 245 struct eusb2_repeater *rptr; 246 struct device *dev = &pdev->dev; 247 struct phy_provider *phy_provider; 248 struct device_node *np = dev->of_node; 249 u32 res; 250 int ret; 251 252 rptr = devm_kzalloc(dev, sizeof(*rptr), GFP_KERNEL); 253 if (!rptr) 254 return -ENOMEM; 255 256 rptr->dev = dev; 257 dev_set_drvdata(dev, rptr); 258 259 rptr->cfg = of_device_get_match_data(dev); 260 if (!rptr->cfg) 261 return -EINVAL; 262 263 rptr->regmap = dev_get_regmap(dev->parent, NULL); 264 if (!rptr->regmap) 265 return -ENODEV; 266 267 ret = of_property_read_u32(np, "reg", &res); 268 if (ret < 0) 269 return ret; 270 271 rptr->base = res; 272 273 ret = eusb2_repeater_init_vregs(rptr); 274 if (ret < 0) { 275 dev_err(dev, "unable to get supplies\n"); 276 return ret; 277 } 278 279 rptr->phy = devm_phy_create(dev, np, &eusb2_repeater_ops); 280 if (IS_ERR(rptr->phy)) { 281 dev_err(dev, "failed to create PHY: %d\n", ret); 282 return PTR_ERR(rptr->phy); 283 } 284 285 phy_set_drvdata(rptr->phy, rptr); 286 287 phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate); 288 if (IS_ERR(phy_provider)) 289 return PTR_ERR(phy_provider); 290 291 return 0; 292 } 293 294 static void eusb2_repeater_remove(struct platform_device *pdev) 295 { 296 struct eusb2_repeater *rptr = platform_get_drvdata(pdev); 297 298 if (!rptr) 299 return; 300 301 eusb2_repeater_exit(rptr->phy); 302 } 303 304 static const struct of_device_id eusb2_repeater_of_match_table[] = { 305 { 306 .compatible = "qcom,pm8550b-eusb2-repeater", 307 .data = &pm8550b_eusb2_cfg, 308 }, 309 { 310 .compatible = "qcom,pmiv0104-eusb2-repeater", 311 .data = &pmiv0104_eusb2_cfg, 312 }, 313 { 314 .compatible = "qcom,smb2360-eusb2-repeater", 315 .data = &smb2360_eusb2_cfg, 316 }, 317 { 318 .compatible = "qcom,smb2370-eusb2-repeater", 319 .data = &smb2370_eusb2_cfg, 320 }, 321 { }, 322 }; 323 MODULE_DEVICE_TABLE(of, eusb2_repeater_of_match_table); 324 325 static struct platform_driver eusb2_repeater_driver = { 326 .probe = eusb2_repeater_probe, 327 .remove = eusb2_repeater_remove, 328 .driver = { 329 .name = "qcom-eusb2-repeater", 330 .of_match_table = eusb2_repeater_of_match_table, 331 }, 332 }; 333 334 module_platform_driver(eusb2_repeater_driver); 335 336 MODULE_DESCRIPTION("Qualcomm PMIC eUSB2 Repeater driver"); 337 MODULE_LICENSE("GPL"); 338