1 /* 2 * Copyright 2013 Freescale Semiconductor, Inc. 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 /* 8 * The RGMII PHYs are provided by the two on-board PHY connected to 9 * dTSEC instances 4 and 5. The SGMII PHYs are provided by one on-board 10 * PHY or by the standard four-port SGMII riser card (VSC). 11 */ 12 13 #include <common.h> 14 #include <netdev.h> 15 #include <asm/fsl_serdes.h> 16 #include <asm/immap_85xx.h> 17 #include <fm_eth.h> 18 #include <fsl_mdio.h> 19 #include <malloc.h> 20 #include <asm/fsl_dtsec.h> 21 22 #include "../common/fman.h" 23 #include "../common/qixis.h" 24 25 #include "t1040qds_qixis.h" 26 27 #ifdef CONFIG_FMAN_ENET 28 /* - In T1040 there are only 8 SERDES lanes, spread across 2 SERDES banks. 29 * Bank 1 -> Lanes A, B, C, D 30 * Bank 2 -> Lanes E, F, G, H 31 */ 32 33 /* Mapping of 8 SERDES lanes to T1040 QDS board slots. A value of '0' here 34 * means that the mapping must be determined dynamically, or that the lane 35 * maps to something other than a board slot. 36 */ 37 static u8 lane_to_slot[] = { 38 0, 0, 0, 0, 0, 0, 0, 0 39 }; 40 41 /* On the Vitesse VSC8234XHG SGMII riser card there are 4 SGMII PHYs 42 * housed. 43 */ 44 static int riser_phy_addr[] = { 45 CONFIG_SYS_FM1_DTSEC1_RISER_PHY_ADDR, 46 CONFIG_SYS_FM1_DTSEC2_RISER_PHY_ADDR, 47 CONFIG_SYS_FM1_DTSEC3_RISER_PHY_ADDR, 48 CONFIG_SYS_FM1_DTSEC4_RISER_PHY_ADDR, 49 }; 50 51 /* Slot2 does not have EMI connections */ 52 #define EMI_NONE 0xFFFFFFFF 53 #define EMI1_RGMII0 0 54 #define EMI1_RGMII1 1 55 #define EMI1_SLOT1 2 56 #define EMI1_SLOT3 3 57 #define EMI1_SLOT4 4 58 #define EMI1_SLOT5 5 59 #define EMI1_SLOT6 6 60 #define EMI1_SLOT7 7 61 #define EMI2 8 62 63 static int mdio_mux[NUM_FM_PORTS]; 64 65 static const char * const mdio_names[] = { 66 "T1040_QDS_MDIO0", 67 "T1040_QDS_MDIO1", 68 "T1040_QDS_MDIO2", 69 "T1040_QDS_MDIO3", 70 "T1040_QDS_MDIO4", 71 "T1040_QDS_MDIO5", 72 "T1040_QDS_MDIO6", 73 "T1040_QDS_MDIO7", 74 }; 75 76 struct t1040_qds_mdio { 77 u8 muxval; 78 struct mii_dev *realbus; 79 }; 80 81 static const char *t1040_qds_mdio_name_for_muxval(u8 muxval) 82 { 83 return mdio_names[muxval]; 84 } 85 86 struct mii_dev *mii_dev_for_muxval(u8 muxval) 87 { 88 struct mii_dev *bus; 89 const char *name = t1040_qds_mdio_name_for_muxval(muxval); 90 91 if (!name) { 92 printf("No bus for muxval %x\n", muxval); 93 return NULL; 94 } 95 96 bus = miiphy_get_dev_by_name(name); 97 98 if (!bus) { 99 printf("No bus by name %s\n", name); 100 return NULL; 101 } 102 103 return bus; 104 } 105 106 static void t1040_qds_mux_mdio(u8 muxval) 107 { 108 u8 brdcfg4; 109 if (muxval <= 7) { 110 brdcfg4 = QIXIS_READ(brdcfg[4]); 111 brdcfg4 &= ~BRDCFG4_EMISEL_MASK; 112 brdcfg4 |= (muxval << BRDCFG4_EMISEL_SHIFT); 113 QIXIS_WRITE(brdcfg[4], brdcfg4); 114 } 115 } 116 117 static int t1040_qds_mdio_read(struct mii_dev *bus, int addr, int devad, 118 int regnum) 119 { 120 struct t1040_qds_mdio *priv = bus->priv; 121 122 t1040_qds_mux_mdio(priv->muxval); 123 124 return priv->realbus->read(priv->realbus, addr, devad, regnum); 125 } 126 127 static int t1040_qds_mdio_write(struct mii_dev *bus, int addr, int devad, 128 int regnum, u16 value) 129 { 130 struct t1040_qds_mdio *priv = bus->priv; 131 132 t1040_qds_mux_mdio(priv->muxval); 133 134 return priv->realbus->write(priv->realbus, addr, devad, regnum, value); 135 } 136 137 static int t1040_qds_mdio_reset(struct mii_dev *bus) 138 { 139 struct t1040_qds_mdio *priv = bus->priv; 140 141 return priv->realbus->reset(priv->realbus); 142 } 143 144 static int t1040_qds_mdio_init(char *realbusname, u8 muxval) 145 { 146 struct t1040_qds_mdio *pmdio; 147 struct mii_dev *bus = mdio_alloc(); 148 149 if (!bus) { 150 printf("Failed to allocate t1040_qds MDIO bus\n"); 151 return -1; 152 } 153 154 pmdio = malloc(sizeof(*pmdio)); 155 if (!pmdio) { 156 printf("Failed to allocate t1040_qds private data\n"); 157 free(bus); 158 return -1; 159 } 160 161 bus->read = t1040_qds_mdio_read; 162 bus->write = t1040_qds_mdio_write; 163 bus->reset = t1040_qds_mdio_reset; 164 sprintf(bus->name, t1040_qds_mdio_name_for_muxval(muxval)); 165 166 pmdio->realbus = miiphy_get_dev_by_name(realbusname); 167 168 if (!pmdio->realbus) { 169 printf("No bus with name %s\n", realbusname); 170 free(bus); 171 free(pmdio); 172 return -1; 173 } 174 175 pmdio->muxval = muxval; 176 bus->priv = pmdio; 177 178 return mdio_register(bus); 179 } 180 181 /* 182 * Initialize the lane_to_slot[] array. 183 * 184 * On the T1040QDS board the mapping is controlled by ?? register. 185 */ 186 static void initialize_lane_to_slot(void) 187 { 188 ccsr_gur_t *gur = (void *)CONFIG_SYS_MPC85xx_GUTS_ADDR; 189 int serdes1_prtcl = (in_be32(&gur->rcwsr[4]) & 190 FSL_CORENET2_RCWSR4_SRDS1_PRTCL) 191 >> FSL_CORENET2_RCWSR4_SRDS1_PRTCL_SHIFT; 192 193 QIXIS_WRITE(cms[0], 0x07); 194 195 switch (serdes1_prtcl) { 196 case 0x60: 197 case 0x66: 198 case 0x67: 199 case 0x69: 200 lane_to_slot[1] = 7; 201 lane_to_slot[2] = 6; 202 lane_to_slot[3] = 5; 203 break; 204 case 0x86: 205 lane_to_slot[1] = 7; 206 lane_to_slot[2] = 7; 207 lane_to_slot[3] = 7; 208 break; 209 case 0x87: 210 lane_to_slot[1] = 7; 211 lane_to_slot[2] = 7; 212 lane_to_slot[3] = 7; 213 lane_to_slot[7] = 7; 214 break; 215 case 0x89: 216 lane_to_slot[1] = 7; 217 lane_to_slot[2] = 7; 218 lane_to_slot[3] = 7; 219 lane_to_slot[7] = 7; 220 break; 221 case 0x8d: 222 lane_to_slot[1] = 7; 223 lane_to_slot[2] = 7; 224 lane_to_slot[3] = 7; 225 lane_to_slot[5] = 3; 226 lane_to_slot[6] = 3; 227 lane_to_slot[7] = 3; 228 break; 229 case 0x8F: 230 case 0x85: 231 lane_to_slot[1] = 7; 232 lane_to_slot[2] = 6; 233 lane_to_slot[3] = 5; 234 lane_to_slot[6] = 3; 235 lane_to_slot[7] = 3; 236 break; 237 case 0xA5: 238 lane_to_slot[1] = 7; 239 lane_to_slot[6] = 3; 240 lane_to_slot[7] = 3; 241 break; 242 case 0xA7: 243 lane_to_slot[1] = 7; 244 lane_to_slot[7] = 7; 245 break; 246 case 0xAA: 247 lane_to_slot[1] = 7; 248 lane_to_slot[6] = 7; 249 lane_to_slot[7] = 7; 250 break; 251 case 0x40: 252 lane_to_slot[2] = 7; 253 lane_to_slot[3] = 7; 254 break; 255 default: 256 printf("qds: Fman: Unsupported SerDes Protocol 0x%02x\n", 257 serdes1_prtcl); 258 break; 259 } 260 } 261 262 /* 263 * Given the following ... 264 * 265 * 1) A pointer to an Fman Ethernet node (as identified by the 'compat' 266 * compatible string and 'addr' physical address) 267 * 268 * 2) An Fman port 269 * 270 * ... update the phy-handle property of the Ethernet node to point to the 271 * right PHY. This assumes that we already know the PHY for each port. 272 * 273 * The offset of the Fman Ethernet node is also passed in for convenience, but 274 * it is not used, and we recalculate the offset anyway. 275 * 276 * Note that what we call "Fman ports" (enum fm_port) is really an Fman MAC. 277 * Inside the Fman, "ports" are things that connect to MACs. We only call them 278 * ports in U-Boot because on previous Ethernet devices (e.g. Gianfar), MACs 279 * and ports are the same thing. 280 * 281 */ 282 void board_ft_fman_fixup_port(void *fdt, char *compat, phys_addr_t addr, 283 enum fm_port port, int offset) 284 { 285 phy_interface_t intf = fm_info_get_enet_if(port); 286 char phy[16]; 287 288 /* The RGMII PHY is identified by the MAC connected to it */ 289 if (intf == PHY_INTERFACE_MODE_RGMII) { 290 sprintf(phy, "rgmii_phy%u", port == FM1_DTSEC4 ? 1 : 2); 291 fdt_set_phy_handle(fdt, compat, addr, phy); 292 } 293 294 /* The SGMII PHY is identified by the MAC connected to it */ 295 if (intf == PHY_INTERFACE_MODE_SGMII) { 296 int lane = serdes_get_first_lane(FSL_SRDS_1, SGMII_FM1_DTSEC1 297 + port); 298 u8 slot; 299 if (lane < 0) 300 return; 301 slot = lane_to_slot[lane]; 302 if (slot) { 303 /* Slot housing a SGMII riser card */ 304 sprintf(phy, "phy_s%x_%02x", slot, 305 (fm_info_get_phy_address(port - FM1_DTSEC1)- 306 CONFIG_SYS_FM1_DTSEC1_RISER_PHY_ADDR + 1)); 307 fdt_set_phy_handle(fdt, compat, addr, phy); 308 } 309 } 310 } 311 312 void fdt_fixup_board_enet(void *fdt) 313 { 314 int i, lane, idx; 315 316 for (i = FM1_DTSEC1; i < FM1_DTSEC1 + CONFIG_SYS_NUM_FM1_DTSEC; i++) { 317 idx = i - FM1_DTSEC1; 318 switch (fm_info_get_enet_if(i)) { 319 case PHY_INTERFACE_MODE_SGMII: 320 lane = serdes_get_first_lane(FSL_SRDS_1, 321 SGMII_FM1_DTSEC1 + idx); 322 if (lane < 0) 323 break; 324 325 switch (mdio_mux[i]) { 326 case EMI1_SLOT3: 327 fdt_status_okay_by_alias(fdt, "emi1_slot3"); 328 break; 329 case EMI1_SLOT5: 330 fdt_status_okay_by_alias(fdt, "emi1_slot5"); 331 break; 332 case EMI1_SLOT6: 333 fdt_status_okay_by_alias(fdt, "emi1_slot6"); 334 break; 335 case EMI1_SLOT7: 336 fdt_status_okay_by_alias(fdt, "emi1_slot7"); 337 break; 338 } 339 break; 340 case PHY_INTERFACE_MODE_RGMII: 341 if (i == FM1_DTSEC4) 342 fdt_status_okay_by_alias(fdt, "emi1_rgmii0"); 343 344 if (i == FM1_DTSEC5) 345 fdt_status_okay_by_alias(fdt, "emi1_rgmii1"); 346 break; 347 default: 348 break; 349 } 350 } 351 } 352 #endif /* #ifdef CONFIG_FMAN_ENET */ 353 354 static void set_brdcfg9_for_gtx_clk(void) 355 { 356 u8 brdcfg9; 357 brdcfg9 = QIXIS_READ(brdcfg[9]); 358 /* Initializing EPHY2 clock to RGMII mode */ 359 brdcfg9 &= ~(BRDCFG9_EPHY2_MASK); 360 brdcfg9 |= (BRDCFG9_EPHY2_VAL); 361 QIXIS_WRITE(brdcfg[9], brdcfg9); 362 } 363 364 void t1040_handle_phy_interface_sgmii(int i) 365 { 366 int lane, idx, slot; 367 idx = i - FM1_DTSEC1; 368 lane = serdes_get_first_lane(FSL_SRDS_1, 369 SGMII_FM1_DTSEC1 + idx); 370 371 if (lane < 0) 372 return; 373 slot = lane_to_slot[lane]; 374 375 switch (slot) { 376 case 1: 377 mdio_mux[i] = EMI1_SLOT1; 378 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i])); 379 break; 380 case 3: 381 if (FM1_DTSEC4 == i) 382 fm_info_set_phy_address(i, riser_phy_addr[0]); 383 if (FM1_DTSEC5 == i) 384 fm_info_set_phy_address(i, riser_phy_addr[1]); 385 386 mdio_mux[i] = EMI1_SLOT3; 387 388 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i])); 389 break; 390 case 4: 391 mdio_mux[i] = EMI1_SLOT4; 392 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i])); 393 break; 394 case 5: 395 /* Slot housing a SGMII riser card? */ 396 fm_info_set_phy_address(i, riser_phy_addr[0]); 397 mdio_mux[i] = EMI1_SLOT5; 398 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i])); 399 break; 400 case 6: 401 /* Slot housing a SGMII riser card? */ 402 fm_info_set_phy_address(i, riser_phy_addr[0]); 403 mdio_mux[i] = EMI1_SLOT6; 404 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i])); 405 break; 406 case 7: 407 if (FM1_DTSEC1 == i) 408 fm_info_set_phy_address(i, riser_phy_addr[0]); 409 if (FM1_DTSEC2 == i) 410 fm_info_set_phy_address(i, riser_phy_addr[1]); 411 if (FM1_DTSEC3 == i) 412 fm_info_set_phy_address(i, riser_phy_addr[2]); 413 414 mdio_mux[i] = EMI1_SLOT7; 415 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i])); 416 break; 417 default: 418 break; 419 } 420 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i])); 421 } 422 void t1040_handle_phy_interface_rgmii(int i) 423 { 424 fm_info_set_phy_address(i, i == FM1_DTSEC5 ? 425 CONFIG_SYS_FM1_DTSEC5_PHY_ADDR : 426 CONFIG_SYS_FM1_DTSEC4_PHY_ADDR); 427 mdio_mux[i] = (i == FM1_DTSEC5) ? EMI1_RGMII1 : 428 EMI1_RGMII0; 429 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i])); 430 } 431 432 int board_eth_init(bd_t *bis) 433 { 434 #ifdef CONFIG_FMAN_ENET 435 struct memac_mdio_info memac_mdio_info; 436 unsigned int i; 437 438 printf("Initializing Fman\n"); 439 set_brdcfg9_for_gtx_clk(); 440 441 initialize_lane_to_slot(); 442 443 /* Initialize the mdio_mux array so we can recognize empty elements */ 444 for (i = 0; i < NUM_FM_PORTS; i++) 445 mdio_mux[i] = EMI_NONE; 446 447 memac_mdio_info.regs = 448 (struct memac_mdio_controller *)CONFIG_SYS_FM1_DTSEC_MDIO_ADDR; 449 memac_mdio_info.name = DEFAULT_FM_MDIO_NAME; 450 451 /* Register the real 1G MDIO bus */ 452 fm_memac_mdio_init(bis, &memac_mdio_info); 453 454 /* Register the muxing front-ends to the MDIO buses */ 455 t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_RGMII0); 456 t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_RGMII1); 457 t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT1); 458 t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT3); 459 t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT4); 460 t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT5); 461 t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT6); 462 t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT7); 463 464 /* 465 * Program on board RGMII PHY addresses. If the SGMII Riser 466 * card used, we'll override the PHY address later. For any DTSEC that 467 * is RGMII, we'll also override its PHY address later. We assume that 468 * DTSEC4 and DTSEC5 are used for RGMII. 469 */ 470 fm_info_set_phy_address(FM1_DTSEC4, CONFIG_SYS_FM1_DTSEC4_PHY_ADDR); 471 fm_info_set_phy_address(FM1_DTSEC5, CONFIG_SYS_FM1_DTSEC5_PHY_ADDR); 472 473 for (i = FM1_DTSEC1; i < FM1_DTSEC1 + CONFIG_SYS_NUM_FM1_DTSEC; i++) { 474 switch (fm_info_get_enet_if(i)) { 475 case PHY_INTERFACE_MODE_QSGMII: 476 break; 477 case PHY_INTERFACE_MODE_SGMII: 478 t1040_handle_phy_interface_sgmii(i); 479 break; 480 481 case PHY_INTERFACE_MODE_RGMII: 482 /* Only DTSEC4 and DTSEC5 can be routed to RGMII */ 483 t1040_handle_phy_interface_rgmii(i); 484 break; 485 default: 486 break; 487 } 488 } 489 490 cpu_eth_init(bis); 491 #endif 492 493 return pci_eth_init(bis); 494 } 495