board/freescale/t1040qds/eth.c

   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[6] = 7;
 220                 lane_to_slot[7] = 7;
 221                 break;
 222         case 0x8d:
 223                 lane_to_slot[1] = 7;
 224                 lane_to_slot[2] = 7;
 225                 lane_to_slot[3] = 7;
 226                 lane_to_slot[5] = 3;
 227                 lane_to_slot[6] = 3;
 228                 lane_to_slot[7] = 3;
 229                 break;
 230         case 0x8F:
 231         case 0x85:
 232                 lane_to_slot[1] = 7;
 233                 lane_to_slot[2] = 6;
 234                 lane_to_slot[3] = 5;
 235                 lane_to_slot[6] = 3;
 236                 lane_to_slot[7] = 3;
 237                 break;
 238         case 0xA5:
 239                 lane_to_slot[1] = 7;
 240                 lane_to_slot[6] = 3;
 241                 lane_to_slot[7] = 3;
 242                 break;
 243         case 0xA7:
 244                 lane_to_slot[1] = 7;
 245                 lane_to_slot[2] = 6;
 246                 lane_to_slot[3] = 5;
 247                 lane_to_slot[7] = 7;
 248                 break;
 249         case 0xAA:
 250                 lane_to_slot[1] = 7;
 251                 lane_to_slot[6] = 7;
 252                 lane_to_slot[7] = 7;
 253                 break;
 254         case 0x40:
 255                 lane_to_slot[2] = 7;
 256                 lane_to_slot[3] = 7;
 257                 break;
 258         default:
 259                 printf("qds: Fman: Unsupported SerDes Protocol 0x%02x\n",
 260                        serdes1_prtcl);
 261                 break;
 262         }
 263 }
 264
 265 /*
 266  * Given the following ...
 267  *
 268  * 1) A pointer to an Fman Ethernet node (as identified by the 'compat'
 269  * compatible string and 'addr' physical address)
 270  *
 271  * 2) An Fman port
 272  *
 273  * ... update the phy-handle property of the Ethernet node to point to the
 274  * right PHY. This assumes that we already know the PHY for each port.
 275  *
 276  * The offset of the Fman Ethernet node is also passed in for convenience, but
 277  * it is not used, and we recalculate the offset anyway.
 278  *
 279  * Note that what we call "Fman ports" (enum fm_port) is really an Fman MAC.
 280  * Inside the Fman, "ports" are things that connect to MACs. We only call them
 281  * ports in U-Boot because on previous Ethernet devices (e.g. Gianfar), MACs
 282  * and ports are the same thing.
 283  *
 284  */
 285 void board_ft_fman_fixup_port(void *fdt, char *compat, phys_addr_t addr,
 286                               enum fm_port port, int offset)
 287 {
 288         phy_interface_t intf = fm_info_get_enet_if(port);
 289         char phy[16];
 290
 291         /* The RGMII PHY is identified by the MAC connected to it */
 292         if (intf == PHY_INTERFACE_MODE_RGMII) {
 293                 sprintf(phy, "rgmii_phy%u", port == FM1_DTSEC4 ? 1 : 2);
 294                 fdt_set_phy_handle(fdt, compat, addr, phy);
 295         }
 296
 297         /* The SGMII PHY is identified by the MAC connected to it */
 298         if (intf == PHY_INTERFACE_MODE_SGMII) {
 299                 int lane = serdes_get_first_lane(FSL_SRDS_1, SGMII_FM1_DTSEC1
 300                                                  + port);
 301                 u8 slot;
 302                 if (lane < 0)
 303                         return;
 304                 slot = lane_to_slot[lane];
 305                 if (slot) {
 306                         /* Slot housing a SGMII riser card */
 307                         sprintf(phy, "phy_s%x_%02x", slot,
 308                                 (fm_info_get_phy_address(port - FM1_DTSEC1)-
 309                                 CONFIG_SYS_FM1_DTSEC1_RISER_PHY_ADDR + 1));
 310                         fdt_set_phy_handle(fdt, compat, addr, phy);
 311                 }
 312         }
 313 }
 314
 315 void fdt_fixup_board_enet(void *fdt)
 316 {
 317         int i, lane, idx;
 318
 319         for (i = FM1_DTSEC1; i < FM1_DTSEC1 + CONFIG_SYS_NUM_FM1_DTSEC; i++) {
 320                 idx = i - FM1_DTSEC1;
 321                 switch (fm_info_get_enet_if(i)) {
 322                 case PHY_INTERFACE_MODE_SGMII:
 323                         lane = serdes_get_first_lane(FSL_SRDS_1,
 324                                                      SGMII_FM1_DTSEC1 + idx);
 325                         if (lane < 0)
 326                                 break;
 327
 328                         switch (mdio_mux[i]) {
 329                         case EMI1_SLOT3:
 330                                 fdt_status_okay_by_alias(fdt, "emi1_slot3");
 331                                 break;
 332                         case EMI1_SLOT5:
 333                                 fdt_status_okay_by_alias(fdt, "emi1_slot5");
 334                                 break;
 335                         case EMI1_SLOT6:
 336                                 fdt_status_okay_by_alias(fdt, "emi1_slot6");
 337                                 break;
 338                         case EMI1_SLOT7:
 339                                 fdt_status_okay_by_alias(fdt, "emi1_slot7");
 340                                 break;
 341                         }
 342                 break;
 343                 case PHY_INTERFACE_MODE_RGMII:
 344                         if (i == FM1_DTSEC4)
 345                                 fdt_status_okay_by_alias(fdt, "emi1_rgmii0");
 346
 347                         if (i == FM1_DTSEC5)
 348                                 fdt_status_okay_by_alias(fdt, "emi1_rgmii1");
 349                         break;
 350                 default:
 351                         break;
 352                 }
 353         }
 354 }
 355 #endif /* #ifdef CONFIG_FMAN_ENET */
 356
 357 static void set_brdcfg9_for_gtx_clk(void)
 358 {
 359         u8 brdcfg9;
 360         brdcfg9 = QIXIS_READ(brdcfg[9]);
 361 /* Initializing EPHY2 clock to RGMII mode */
 362         brdcfg9 &= ~(BRDCFG9_EPHY2_MASK);
 363         brdcfg9 |= (BRDCFG9_EPHY2_VAL);
 364         QIXIS_WRITE(brdcfg[9], brdcfg9);
 365 }
 366
 367 void t1040_handle_phy_interface_sgmii(int i)
 368 {
 369         int lane, idx, slot;
 370         idx = i - FM1_DTSEC1;
 371         lane = serdes_get_first_lane(FSL_SRDS_1,
 372                         SGMII_FM1_DTSEC1 + idx);
 373
 374         if (lane < 0)
 375                 return;
 376         slot = lane_to_slot[lane];
 377
 378         switch (slot) {
 379         case 1:
 380                 mdio_mux[i] = EMI1_SLOT1;
 381                 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i]));
 382                 break;
 383         case 3:
 384                 if (FM1_DTSEC4 == i)
 385                         fm_info_set_phy_address(i, riser_phy_addr[0]);
 386                 if (FM1_DTSEC5 == i)
 387                         fm_info_set_phy_address(i, riser_phy_addr[1]);
 388
 389                 mdio_mux[i] = EMI1_SLOT3;
 390
 391                 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i]));
 392                 break;
 393         case 4:
 394                 mdio_mux[i] = EMI1_SLOT4;
 395                 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i]));
 396                 break;
 397         case 5:
 398                 /* Slot housing a SGMII riser card? */
 399                 fm_info_set_phy_address(i, riser_phy_addr[0]);
 400                 mdio_mux[i] = EMI1_SLOT5;
 401                 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i]));
 402                 break;
 403         case 6:
 404                 /* Slot housing a SGMII riser card? */
 405                 fm_info_set_phy_address(i, riser_phy_addr[0]);
 406                 mdio_mux[i] = EMI1_SLOT6;
 407                 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i]));
 408                 break;
 409         case 7:
 410                 if (FM1_DTSEC1 == i)
 411                         fm_info_set_phy_address(i, riser_phy_addr[0]);
 412                 if (FM1_DTSEC2 == i)
 413                         fm_info_set_phy_address(i, riser_phy_addr[1]);
 414                 if (FM1_DTSEC3 == i)
 415                         fm_info_set_phy_address(i, riser_phy_addr[2]);
 416                 if (FM1_DTSEC5 == i)
 417                         fm_info_set_phy_address(i, riser_phy_addr[3]);
 418
 419                 mdio_mux[i] = EMI1_SLOT7;
 420                 fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i]));
 421                 break;
 422         default:
 423                 break;
 424         }
 425         fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i]));
 426 }
 427 void t1040_handle_phy_interface_rgmii(int i)
 428 {
 429         fm_info_set_phy_address(i, i == FM1_DTSEC5 ?
 430                         CONFIG_SYS_FM1_DTSEC5_PHY_ADDR :
 431                         CONFIG_SYS_FM1_DTSEC4_PHY_ADDR);
 432         mdio_mux[i] = (i == FM1_DTSEC5) ? EMI1_RGMII1 :
 433                 EMI1_RGMII0;
 434         fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i]));
 435 }
 436
 437 int board_eth_init(bd_t *bis)
 438 {
 439 #ifdef CONFIG_FMAN_ENET
 440         struct memac_mdio_info memac_mdio_info;
 441         unsigned int i;
 442
 443         printf("Initializing Fman\n");
 444         set_brdcfg9_for_gtx_clk();
 445
 446         initialize_lane_to_slot();
 447
 448         /* Initialize the mdio_mux array so we can recognize empty elements */
 449         for (i = 0; i < NUM_FM_PORTS; i++)
 450                 mdio_mux[i] = EMI_NONE;
 451
 452         memac_mdio_info.regs =
 453                 (struct memac_mdio_controller *)CONFIG_SYS_FM1_DTSEC_MDIO_ADDR;
 454         memac_mdio_info.name = DEFAULT_FM_MDIO_NAME;
 455
 456         /* Register the real 1G MDIO bus */
 457         fm_memac_mdio_init(bis, &memac_mdio_info);
 458
 459         /* Register the muxing front-ends to the MDIO buses */
 460         t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_RGMII0);
 461         t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_RGMII1);
 462         t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT1);
 463         t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT3);
 464         t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT4);
 465         t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT5);
 466         t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT6);
 467         t1040_qds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT7);
 468
 469         /*
 470          * Program on board RGMII PHY addresses. If the SGMII Riser
 471          * card used, we'll override the PHY address later. For any DTSEC that
 472          * is RGMII, we'll also override its PHY address later. We assume that
 473          * DTSEC4 and DTSEC5 are used for RGMII.
 474          */
 475         fm_info_set_phy_address(FM1_DTSEC4, CONFIG_SYS_FM1_DTSEC4_PHY_ADDR);
 476         fm_info_set_phy_address(FM1_DTSEC5, CONFIG_SYS_FM1_DTSEC5_PHY_ADDR);
 477
 478         for (i = FM1_DTSEC1; i < FM1_DTSEC1 + CONFIG_SYS_NUM_FM1_DTSEC; i++) {
 479                 switch (fm_info_get_enet_if(i)) {
 480                 case PHY_INTERFACE_MODE_QSGMII:
 481                         break;
 482                 case PHY_INTERFACE_MODE_SGMII:
 483                         t1040_handle_phy_interface_sgmii(i);
 484                         break;
 485
 486                 case PHY_INTERFACE_MODE_RGMII:
 487                         /* Only DTSEC4 and DTSEC5 can be routed to RGMII */
 488                         t1040_handle_phy_interface_rgmii(i);
 489                         break;
 490                 default:
 491                         break;
 492                 }
 493         }
 494
 495         cpu_eth_init(bis);
 496 #endif
 497
 498         return pci_eth_init(bis);
 499 }