1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Intel Combo-PHY driver 4 * 5 * Copyright (C) 2019-2020 Intel Corporation. 6 */ 7 8 #include <linux/bitfield.h> 9 #include <linux/clk.h> 10 #include <linux/iopoll.h> 11 #include <linux/mfd/syscon.h> 12 #include <linux/module.h> 13 #include <linux/mutex.h> 14 #include <linux/of.h> 15 #include <linux/phy/phy.h> 16 #include <linux/platform_device.h> 17 #include <linux/regmap.h> 18 #include <linux/reset.h> 19 20 #include <dt-bindings/phy/phy.h> 21 22 #define PCIE_PHY_GEN_CTRL 0x00 23 #define PCIE_PHY_CLK_PAD BIT(17) 24 25 #define PAD_DIS_CFG 0x174 26 27 #define PCS_XF_ATE_OVRD_IN_2 0x3008 28 #define ADAPT_REQ_MSK GENMASK(5, 4) 29 30 #define PCS_XF_RX_ADAPT_ACK 0x3010 31 #define RX_ADAPT_ACK_BIT BIT(0) 32 33 #define CR_ADDR(addr, lane) (((addr) + (lane) * 0x100) << 2) 34 #define REG_COMBO_MODE(x) ((x) * 0x200) 35 #define REG_CLK_DISABLE(x) ((x) * 0x200 + 0x124) 36 37 #define COMBO_PHY_ID(x) ((x)->parent->id) 38 #define PHY_ID(x) ((x)->id) 39 40 #define CLK_100MHZ 100000000 41 #define CLK_156_25MHZ 156250000 42 43 static const unsigned long intel_iphy_clk_rates[] = { 44 CLK_100MHZ, CLK_156_25MHZ, CLK_100MHZ, 45 }; 46 47 enum { 48 PHY_0, 49 PHY_1, 50 PHY_MAX_NUM 51 }; 52 53 /* 54 * Clock Register bit fields to enable clocks 55 * for ComboPhy according to the mode. 56 */ 57 enum intel_phy_mode { 58 PHY_PCIE_MODE = 0, 59 PHY_XPCS_MODE, 60 PHY_SATA_MODE, 61 }; 62 63 /* ComboPhy mode Register values */ 64 enum intel_combo_mode { 65 PCIE0_PCIE1_MODE = 0, 66 PCIE_DL_MODE, 67 RXAUI_MODE, 68 XPCS0_XPCS1_MODE, 69 SATA0_SATA1_MODE, 70 }; 71 72 enum aggregated_mode { 73 PHY_SL_MODE, 74 PHY_DL_MODE, 75 }; 76 77 struct intel_combo_phy; 78 79 struct intel_cbphy_iphy { 80 struct phy *phy; 81 struct intel_combo_phy *parent; 82 struct reset_control *app_rst; 83 u32 id; 84 }; 85 86 struct intel_combo_phy { 87 struct device *dev; 88 struct clk *core_clk; 89 unsigned long clk_rate; 90 void __iomem *app_base; 91 void __iomem *cr_base; 92 struct regmap *syscfg; 93 struct regmap *hsiocfg; 94 u32 id; 95 u32 bid; 96 struct reset_control *phy_rst; 97 struct reset_control *core_rst; 98 struct intel_cbphy_iphy iphy[PHY_MAX_NUM]; 99 enum intel_phy_mode phy_mode; 100 enum aggregated_mode aggr_mode; 101 u32 init_cnt; 102 struct mutex lock; 103 }; 104 105 static int intel_cbphy_iphy_enable(struct intel_cbphy_iphy *iphy, bool set) 106 { 107 struct intel_combo_phy *cbphy = iphy->parent; 108 u32 mask = BIT(cbphy->phy_mode * 2 + iphy->id); 109 u32 val; 110 111 /* Register: 0 is enable, 1 is disable */ 112 val = set ? 0 : mask; 113 114 return regmap_update_bits(cbphy->hsiocfg, REG_CLK_DISABLE(cbphy->bid), 115 mask, val); 116 } 117 118 static int intel_cbphy_pcie_refclk_cfg(struct intel_cbphy_iphy *iphy, bool set) 119 { 120 struct intel_combo_phy *cbphy = iphy->parent; 121 u32 mask = BIT(cbphy->id * 2 + iphy->id); 122 u32 val; 123 124 /* Register: 0 is enable, 1 is disable */ 125 val = set ? 0 : mask; 126 127 return regmap_update_bits(cbphy->syscfg, PAD_DIS_CFG, mask, val); 128 } 129 130 static inline void combo_phy_w32_off_mask(void __iomem *base, unsigned int reg, 131 u32 mask, u32 val) 132 { 133 u32 reg_val; 134 135 reg_val = readl(base + reg); 136 reg_val &= ~mask; 137 reg_val |= val; 138 writel(reg_val, base + reg); 139 } 140 141 static int intel_cbphy_iphy_cfg(struct intel_cbphy_iphy *iphy, 142 int (*phy_cfg)(struct intel_cbphy_iphy *)) 143 { 144 struct intel_combo_phy *cbphy = iphy->parent; 145 int ret; 146 147 ret = phy_cfg(iphy); 148 if (ret) 149 return ret; 150 151 if (cbphy->aggr_mode != PHY_DL_MODE) 152 return 0; 153 154 return phy_cfg(&cbphy->iphy[PHY_1]); 155 } 156 157 static int intel_cbphy_pcie_en_pad_refclk(struct intel_cbphy_iphy *iphy) 158 { 159 struct intel_combo_phy *cbphy = iphy->parent; 160 int ret; 161 162 ret = intel_cbphy_pcie_refclk_cfg(iphy, true); 163 if (ret) { 164 dev_err(cbphy->dev, "Failed to enable PCIe pad refclk\n"); 165 return ret; 166 } 167 168 if (cbphy->init_cnt) 169 return 0; 170 171 combo_phy_w32_off_mask(cbphy->app_base, PCIE_PHY_GEN_CTRL, 172 PCIE_PHY_CLK_PAD, FIELD_PREP(PCIE_PHY_CLK_PAD, 0)); 173 174 /* Delay for stable clock PLL */ 175 usleep_range(50, 100); 176 177 return 0; 178 } 179 180 static int intel_cbphy_pcie_dis_pad_refclk(struct intel_cbphy_iphy *iphy) 181 { 182 struct intel_combo_phy *cbphy = iphy->parent; 183 int ret; 184 185 ret = intel_cbphy_pcie_refclk_cfg(iphy, false); 186 if (ret) { 187 dev_err(cbphy->dev, "Failed to disable PCIe pad refclk\n"); 188 return ret; 189 } 190 191 if (cbphy->init_cnt) 192 return 0; 193 194 combo_phy_w32_off_mask(cbphy->app_base, PCIE_PHY_GEN_CTRL, 195 PCIE_PHY_CLK_PAD, FIELD_PREP(PCIE_PHY_CLK_PAD, 1)); 196 197 return 0; 198 } 199 200 static int intel_cbphy_set_mode(struct intel_combo_phy *cbphy) 201 { 202 enum intel_combo_mode cb_mode; 203 enum aggregated_mode aggr = cbphy->aggr_mode; 204 struct device *dev = cbphy->dev; 205 enum intel_phy_mode mode; 206 int ret; 207 208 mode = cbphy->phy_mode; 209 210 switch (mode) { 211 case PHY_PCIE_MODE: 212 cb_mode = (aggr == PHY_DL_MODE) ? PCIE_DL_MODE : PCIE0_PCIE1_MODE; 213 break; 214 215 case PHY_XPCS_MODE: 216 cb_mode = (aggr == PHY_DL_MODE) ? RXAUI_MODE : XPCS0_XPCS1_MODE; 217 break; 218 219 case PHY_SATA_MODE: 220 if (aggr == PHY_DL_MODE) { 221 dev_err(dev, "Mode:%u not support dual lane!\n", mode); 222 return -EINVAL; 223 } 224 225 cb_mode = SATA0_SATA1_MODE; 226 break; 227 default: 228 return -EINVAL; 229 } 230 231 ret = regmap_write(cbphy->hsiocfg, REG_COMBO_MODE(cbphy->bid), cb_mode); 232 if (ret) 233 dev_err(dev, "Failed to set ComboPhy mode: %d\n", ret); 234 235 return ret; 236 } 237 238 static void intel_cbphy_rst_assert(struct intel_combo_phy *cbphy) 239 { 240 reset_control_assert(cbphy->core_rst); 241 reset_control_assert(cbphy->phy_rst); 242 } 243 244 static void intel_cbphy_rst_deassert(struct intel_combo_phy *cbphy) 245 { 246 reset_control_deassert(cbphy->core_rst); 247 reset_control_deassert(cbphy->phy_rst); 248 /* Delay to ensure reset process is done */ 249 usleep_range(10, 20); 250 } 251 252 static int intel_cbphy_iphy_power_on(struct intel_cbphy_iphy *iphy) 253 { 254 struct intel_combo_phy *cbphy = iphy->parent; 255 int ret; 256 257 if (!cbphy->init_cnt) { 258 ret = clk_prepare_enable(cbphy->core_clk); 259 if (ret) { 260 dev_err(cbphy->dev, "Clock enable failed!\n"); 261 return ret; 262 } 263 264 ret = clk_set_rate(cbphy->core_clk, cbphy->clk_rate); 265 if (ret) { 266 dev_err(cbphy->dev, "Clock freq set to %lu failed!\n", 267 cbphy->clk_rate); 268 goto clk_err; 269 } 270 271 intel_cbphy_rst_assert(cbphy); 272 intel_cbphy_rst_deassert(cbphy); 273 ret = intel_cbphy_set_mode(cbphy); 274 if (ret) 275 goto clk_err; 276 } 277 278 ret = intel_cbphy_iphy_enable(iphy, true); 279 if (ret) { 280 dev_err(cbphy->dev, "Failed enabling PHY core\n"); 281 goto clk_err; 282 } 283 284 ret = reset_control_deassert(iphy->app_rst); 285 if (ret) { 286 dev_err(cbphy->dev, "PHY(%u:%u) reset deassert failed!\n", 287 COMBO_PHY_ID(iphy), PHY_ID(iphy)); 288 goto clk_err; 289 } 290 291 /* Delay to ensure reset process is done */ 292 udelay(1); 293 294 return 0; 295 296 clk_err: 297 clk_disable_unprepare(cbphy->core_clk); 298 299 return ret; 300 } 301 302 static int intel_cbphy_iphy_power_off(struct intel_cbphy_iphy *iphy) 303 { 304 struct intel_combo_phy *cbphy = iphy->parent; 305 int ret; 306 307 ret = reset_control_assert(iphy->app_rst); 308 if (ret) { 309 dev_err(cbphy->dev, "PHY(%u:%u) reset assert failed!\n", 310 COMBO_PHY_ID(iphy), PHY_ID(iphy)); 311 return ret; 312 } 313 314 ret = intel_cbphy_iphy_enable(iphy, false); 315 if (ret) { 316 dev_err(cbphy->dev, "Failed disabling PHY core\n"); 317 return ret; 318 } 319 320 if (cbphy->init_cnt) 321 return 0; 322 323 clk_disable_unprepare(cbphy->core_clk); 324 intel_cbphy_rst_assert(cbphy); 325 326 return 0; 327 } 328 329 static int intel_cbphy_init(struct phy *phy) 330 { 331 struct intel_cbphy_iphy *iphy = phy_get_drvdata(phy); 332 struct intel_combo_phy *cbphy = iphy->parent; 333 int ret; 334 335 mutex_lock(&cbphy->lock); 336 ret = intel_cbphy_iphy_cfg(iphy, intel_cbphy_iphy_power_on); 337 if (ret) 338 goto err; 339 340 if (cbphy->phy_mode == PHY_PCIE_MODE) { 341 ret = intel_cbphy_iphy_cfg(iphy, intel_cbphy_pcie_en_pad_refclk); 342 if (ret) 343 goto err; 344 } 345 346 cbphy->init_cnt++; 347 348 err: 349 mutex_unlock(&cbphy->lock); 350 351 return ret; 352 } 353 354 static int intel_cbphy_exit(struct phy *phy) 355 { 356 struct intel_cbphy_iphy *iphy = phy_get_drvdata(phy); 357 struct intel_combo_phy *cbphy = iphy->parent; 358 int ret; 359 360 mutex_lock(&cbphy->lock); 361 cbphy->init_cnt--; 362 if (cbphy->phy_mode == PHY_PCIE_MODE) { 363 ret = intel_cbphy_iphy_cfg(iphy, intel_cbphy_pcie_dis_pad_refclk); 364 if (ret) 365 goto err; 366 } 367 368 ret = intel_cbphy_iphy_cfg(iphy, intel_cbphy_iphy_power_off); 369 370 err: 371 mutex_unlock(&cbphy->lock); 372 373 return ret; 374 } 375 376 static int intel_cbphy_calibrate(struct phy *phy) 377 { 378 struct intel_cbphy_iphy *iphy = phy_get_drvdata(phy); 379 struct intel_combo_phy *cbphy = iphy->parent; 380 void __iomem *cr_base = cbphy->cr_base; 381 int val, ret, id; 382 383 if (cbphy->phy_mode != PHY_XPCS_MODE) 384 return 0; 385 386 id = PHY_ID(iphy); 387 388 /* trigger auto RX adaptation */ 389 combo_phy_w32_off_mask(cr_base, CR_ADDR(PCS_XF_ATE_OVRD_IN_2, id), 390 ADAPT_REQ_MSK, FIELD_PREP(ADAPT_REQ_MSK, 3)); 391 /* Wait RX adaptation to finish */ 392 ret = readl_poll_timeout(cr_base + CR_ADDR(PCS_XF_RX_ADAPT_ACK, id), 393 val, val & RX_ADAPT_ACK_BIT, 10, 5000); 394 if (ret) 395 dev_err(cbphy->dev, "RX Adaptation failed!\n"); 396 else 397 dev_dbg(cbphy->dev, "RX Adaptation success!\n"); 398 399 /* Stop RX adaptation */ 400 combo_phy_w32_off_mask(cr_base, CR_ADDR(PCS_XF_ATE_OVRD_IN_2, id), 401 ADAPT_REQ_MSK, FIELD_PREP(ADAPT_REQ_MSK, 0)); 402 403 return ret; 404 } 405 406 static int intel_cbphy_fwnode_parse(struct intel_combo_phy *cbphy) 407 { 408 struct device *dev = cbphy->dev; 409 struct platform_device *pdev = to_platform_device(dev); 410 struct fwnode_handle *fwnode = dev_fwnode(dev); 411 struct fwnode_reference_args ref; 412 int ret; 413 u32 val; 414 415 cbphy->core_clk = devm_clk_get(dev, NULL); 416 if (IS_ERR(cbphy->core_clk)) 417 return dev_err_probe(dev, PTR_ERR(cbphy->core_clk), 418 "Get clk failed!\n"); 419 420 cbphy->core_rst = devm_reset_control_get_optional(dev, "core"); 421 if (IS_ERR(cbphy->core_rst)) 422 return dev_err_probe(dev, PTR_ERR(cbphy->core_rst), 423 "Get core reset control err!\n"); 424 425 cbphy->phy_rst = devm_reset_control_get_optional(dev, "phy"); 426 if (IS_ERR(cbphy->phy_rst)) 427 return dev_err_probe(dev, PTR_ERR(cbphy->phy_rst), 428 "Get PHY reset control err!\n"); 429 430 cbphy->iphy[0].app_rst = devm_reset_control_get_optional(dev, "iphy0"); 431 if (IS_ERR(cbphy->iphy[0].app_rst)) 432 return dev_err_probe(dev, PTR_ERR(cbphy->iphy[0].app_rst), 433 "Get phy0 reset control err!\n"); 434 435 cbphy->iphy[1].app_rst = devm_reset_control_get_optional(dev, "iphy1"); 436 if (IS_ERR(cbphy->iphy[1].app_rst)) 437 return dev_err_probe(dev, PTR_ERR(cbphy->iphy[1].app_rst), 438 "Get phy1 reset control err!\n"); 439 440 cbphy->app_base = devm_platform_ioremap_resource_byname(pdev, "app"); 441 if (IS_ERR(cbphy->app_base)) 442 return PTR_ERR(cbphy->app_base); 443 444 cbphy->cr_base = devm_platform_ioremap_resource_byname(pdev, "core"); 445 if (IS_ERR(cbphy->cr_base)) 446 return PTR_ERR(cbphy->cr_base); 447 448 /* 449 * syscfg and hsiocfg variables stores the handle of the registers set 450 * in which ComboPhy subsystem specific registers are subset. Using 451 * Register map framework to access the registers set. 452 */ 453 ret = fwnode_property_get_reference_args(fwnode, "intel,syscfg", NULL, 454 1, 0, &ref); 455 if (ret < 0) 456 return ret; 457 458 cbphy->id = ref.args[0]; 459 cbphy->syscfg = device_node_to_regmap(to_of_node(ref.fwnode)); 460 fwnode_handle_put(ref.fwnode); 461 462 ret = fwnode_property_get_reference_args(fwnode, "intel,hsio", NULL, 1, 463 0, &ref); 464 if (ret < 0) 465 return ret; 466 467 cbphy->bid = ref.args[0]; 468 cbphy->hsiocfg = device_node_to_regmap(to_of_node(ref.fwnode)); 469 fwnode_handle_put(ref.fwnode); 470 471 ret = fwnode_property_read_u32_array(fwnode, "intel,phy-mode", &val, 1); 472 if (ret) 473 return ret; 474 475 switch (val) { 476 case PHY_TYPE_PCIE: 477 cbphy->phy_mode = PHY_PCIE_MODE; 478 break; 479 480 case PHY_TYPE_SATA: 481 cbphy->phy_mode = PHY_SATA_MODE; 482 break; 483 484 case PHY_TYPE_XPCS: 485 cbphy->phy_mode = PHY_XPCS_MODE; 486 break; 487 488 default: 489 dev_err(dev, "Invalid PHY mode: %u\n", val); 490 return -EINVAL; 491 } 492 493 cbphy->clk_rate = intel_iphy_clk_rates[cbphy->phy_mode]; 494 495 if (fwnode_property_present(fwnode, "intel,aggregation")) 496 cbphy->aggr_mode = PHY_DL_MODE; 497 else 498 cbphy->aggr_mode = PHY_SL_MODE; 499 500 return 0; 501 } 502 503 static const struct phy_ops intel_cbphy_ops = { 504 .init = intel_cbphy_init, 505 .exit = intel_cbphy_exit, 506 .calibrate = intel_cbphy_calibrate, 507 .owner = THIS_MODULE, 508 }; 509 510 static struct phy *intel_cbphy_xlate(struct device *dev, 511 struct of_phandle_args *args) 512 { 513 struct intel_combo_phy *cbphy = dev_get_drvdata(dev); 514 u32 iphy_id; 515 516 if (args->args_count < 1) { 517 dev_err(dev, "Invalid number of arguments\n"); 518 return ERR_PTR(-EINVAL); 519 } 520 521 iphy_id = args->args[0]; 522 if (iphy_id >= PHY_MAX_NUM) { 523 dev_err(dev, "Invalid phy instance %d\n", iphy_id); 524 return ERR_PTR(-EINVAL); 525 } 526 527 if (cbphy->aggr_mode == PHY_DL_MODE && iphy_id == PHY_1) { 528 dev_err(dev, "Invalid. ComboPhy is in Dual lane mode %d\n", iphy_id); 529 return ERR_PTR(-EINVAL); 530 } 531 532 return cbphy->iphy[iphy_id].phy; 533 } 534 535 static int intel_cbphy_create(struct intel_combo_phy *cbphy) 536 { 537 struct phy_provider *phy_provider; 538 struct device *dev = cbphy->dev; 539 struct intel_cbphy_iphy *iphy; 540 int i; 541 542 for (i = 0; i < PHY_MAX_NUM; i++) { 543 iphy = &cbphy->iphy[i]; 544 iphy->parent = cbphy; 545 iphy->id = i; 546 547 /* In dual lane mode skip phy creation for the second phy */ 548 if (cbphy->aggr_mode == PHY_DL_MODE && iphy->id == PHY_1) 549 continue; 550 551 iphy->phy = devm_phy_create(dev, NULL, &intel_cbphy_ops); 552 if (IS_ERR(iphy->phy)) { 553 dev_err(dev, "PHY[%u:%u]: create PHY instance failed!\n", 554 COMBO_PHY_ID(iphy), PHY_ID(iphy)); 555 556 return PTR_ERR(iphy->phy); 557 } 558 559 phy_set_drvdata(iphy->phy, iphy); 560 } 561 562 dev_set_drvdata(dev, cbphy); 563 phy_provider = devm_of_phy_provider_register(dev, intel_cbphy_xlate); 564 if (IS_ERR(phy_provider)) 565 dev_err(dev, "Register PHY provider failed!\n"); 566 567 return PTR_ERR_OR_ZERO(phy_provider); 568 } 569 570 static int intel_cbphy_probe(struct platform_device *pdev) 571 { 572 struct device *dev = &pdev->dev; 573 struct intel_combo_phy *cbphy; 574 int ret; 575 576 cbphy = devm_kzalloc(dev, sizeof(*cbphy), GFP_KERNEL); 577 if (!cbphy) 578 return -ENOMEM; 579 580 cbphy->dev = dev; 581 cbphy->init_cnt = 0; 582 mutex_init(&cbphy->lock); 583 ret = intel_cbphy_fwnode_parse(cbphy); 584 if (ret) 585 return ret; 586 587 platform_set_drvdata(pdev, cbphy); 588 589 return intel_cbphy_create(cbphy); 590 } 591 592 static void intel_cbphy_remove(struct platform_device *pdev) 593 { 594 struct intel_combo_phy *cbphy = platform_get_drvdata(pdev); 595 596 intel_cbphy_rst_assert(cbphy); 597 clk_disable_unprepare(cbphy->core_clk); 598 } 599 600 static const struct of_device_id of_intel_cbphy_match[] = { 601 { .compatible = "intel,combo-phy" }, 602 { .compatible = "intel,combophy-lgm" }, 603 {} 604 }; 605 606 static struct platform_driver intel_cbphy_driver = { 607 .probe = intel_cbphy_probe, 608 .remove_new = intel_cbphy_remove, 609 .driver = { 610 .name = "intel-combo-phy", 611 .of_match_table = of_intel_cbphy_match, 612 } 613 }; 614 615 module_platform_driver(intel_cbphy_driver); 616 617 MODULE_DESCRIPTION("Intel Combo-phy driver"); 618