1 /* 2 * (C) Copyright 2000 3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <command.h> 10 #include <commproc.h> 11 #include <malloc.h> 12 #include <net.h> 13 #include <asm/io.h> 14 15 #include <phy.h> 16 17 DECLARE_GLOBAL_DATA_PTR; 18 19 /* define WANT_MII when MII support is required */ 20 #if defined(CONFIG_SYS_DISCOVER_PHY) || defined(CONFIG_FEC1_PHY) || defined(CONFIG_FEC2_PHY) 21 #define WANT_MII 22 #else 23 #undef WANT_MII 24 #endif 25 26 #if defined(WANT_MII) 27 #include <miiphy.h> 28 29 #if !(defined(CONFIG_MII) || defined(CONFIG_CMD_MII)) 30 #error "CONFIG_MII has to be defined!" 31 #endif 32 33 #endif 34 35 #if defined(CONFIG_RMII) && !defined(WANT_MII) 36 #error RMII support is unusable without a working PHY. 37 #endif 38 39 #ifdef CONFIG_SYS_DISCOVER_PHY 40 static int mii_discover_phy(struct eth_device *dev); 41 #endif 42 43 int fec8xx_miiphy_read(struct mii_dev *bus, int addr, int devad, int reg); 44 int fec8xx_miiphy_write(struct mii_dev *bus, int addr, int devad, int reg, 45 u16 value); 46 47 static struct ether_fcc_info_s 48 { 49 int ether_index; 50 int fecp_offset; 51 int phy_addr; 52 int actual_phy_addr; 53 int initialized; 54 } 55 ether_fcc_info[] = { 56 #if defined(CONFIG_ETHER_ON_FEC1) 57 { 58 0, 59 offsetof(immap_t, im_cpm.cp_fec1), 60 CONFIG_FEC1_PHY, 61 -1, 62 0, 63 64 }, 65 #endif 66 #if defined(CONFIG_ETHER_ON_FEC2) 67 { 68 1, 69 offsetof(immap_t, im_cpm.cp_fec2), 70 CONFIG_FEC2_PHY, 71 -1, 72 0, 73 }, 74 #endif 75 }; 76 77 /* Ethernet Transmit and Receive Buffers */ 78 #define DBUF_LENGTH 1520 79 80 #define TX_BUF_CNT 2 81 82 #define TOUT_LOOP 100 83 84 #define PKT_MAXBUF_SIZE 1518 85 #define PKT_MINBUF_SIZE 64 86 #define PKT_MAXBLR_SIZE 1520 87 88 #ifdef __GNUC__ 89 static char txbuf[DBUF_LENGTH] __aligned(8); 90 #else 91 #error txbuf must be aligned. 92 #endif 93 94 static uint rxIdx; /* index of the current RX buffer */ 95 static uint txIdx; /* index of the current TX buffer */ 96 97 /* 98 * FEC Ethernet Tx and Rx buffer descriptors allocated at the 99 * immr->udata_bd address on Dual-Port RAM 100 * Provide for Double Buffering 101 */ 102 103 struct common_buf_desc { 104 cbd_t rxbd[PKTBUFSRX]; /* Rx BD */ 105 cbd_t txbd[TX_BUF_CNT]; /* Tx BD */ 106 }; 107 108 static struct common_buf_desc __iomem *rtx; 109 110 static int fec_send(struct eth_device *dev, void *packet, int length); 111 static int fec_recv(struct eth_device *dev); 112 static int fec_init(struct eth_device *dev, bd_t *bd); 113 static void fec_halt(struct eth_device *dev); 114 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 115 static void __mii_init(void); 116 #endif 117 118 int fec_initialize(bd_t *bis) 119 { 120 struct eth_device *dev; 121 struct ether_fcc_info_s *efis; 122 int i; 123 124 for (i = 0; i < ARRAY_SIZE(ether_fcc_info); i++) { 125 dev = malloc(sizeof(*dev)); 126 if (dev == NULL) 127 hang(); 128 129 memset(dev, 0, sizeof(*dev)); 130 131 /* for FEC1 make sure that the name of the interface is the same 132 as the old one for compatibility reasons */ 133 if (i == 0) 134 strcpy(dev->name, "FEC"); 135 else 136 sprintf(dev->name, "FEC%d", 137 ether_fcc_info[i].ether_index + 1); 138 139 efis = ðer_fcc_info[i]; 140 141 /* 142 * reset actual phy addr 143 */ 144 efis->actual_phy_addr = -1; 145 146 dev->priv = efis; 147 dev->init = fec_init; 148 dev->halt = fec_halt; 149 dev->send = fec_send; 150 dev->recv = fec_recv; 151 152 eth_register(dev); 153 154 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 155 int retval; 156 struct mii_dev *mdiodev = mdio_alloc(); 157 if (!mdiodev) 158 return -ENOMEM; 159 strncpy(mdiodev->name, dev->name, MDIO_NAME_LEN); 160 mdiodev->read = fec8xx_miiphy_read; 161 mdiodev->write = fec8xx_miiphy_write; 162 163 retval = mdio_register(mdiodev); 164 if (retval < 0) 165 return retval; 166 #endif 167 } 168 return 1; 169 } 170 171 static int fec_send(struct eth_device *dev, void *packet, int length) 172 { 173 int j, rc; 174 struct ether_fcc_info_s *efis = dev->priv; 175 fec_t __iomem *fecp = 176 (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset); 177 178 /* section 16.9.23.3 179 * Wait for ready 180 */ 181 j = 0; 182 while ((in_be16(&rtx->txbd[txIdx].cbd_sc) & BD_ENET_TX_READY) && 183 (j < TOUT_LOOP)) { 184 udelay(1); 185 j++; 186 } 187 if (j >= TOUT_LOOP) 188 printf("TX not ready\n"); 189 190 out_be32(&rtx->txbd[txIdx].cbd_bufaddr, (uint)packet); 191 out_be16(&rtx->txbd[txIdx].cbd_datlen, length); 192 setbits_be16(&rtx->txbd[txIdx].cbd_sc, 193 BD_ENET_TX_READY | BD_ENET_TX_LAST); 194 195 /* Activate transmit Buffer Descriptor polling */ 196 /* Descriptor polling active */ 197 out_be32(&fecp->fec_x_des_active, 0x01000000); 198 199 j = 0; 200 while ((in_be16(&rtx->txbd[txIdx].cbd_sc) & BD_ENET_TX_READY) && 201 (j < TOUT_LOOP)) { 202 udelay(1); 203 j++; 204 } 205 if (j >= TOUT_LOOP) 206 printf("TX timeout\n"); 207 208 /* return only status bits */; 209 rc = in_be16(&rtx->txbd[txIdx].cbd_sc) & BD_ENET_TX_STATS; 210 211 txIdx = (txIdx + 1) % TX_BUF_CNT; 212 213 return rc; 214 } 215 216 static int fec_recv(struct eth_device *dev) 217 { 218 struct ether_fcc_info_s *efis = dev->priv; 219 fec_t __iomem *fecp = 220 (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset); 221 int length; 222 223 for (;;) { 224 /* section 16.9.23.2 */ 225 if (in_be16(&rtx->rxbd[rxIdx].cbd_sc) & BD_ENET_RX_EMPTY) { 226 length = -1; 227 break; /* nothing received - leave for() loop */ 228 } 229 230 length = in_be16(&rtx->rxbd[rxIdx].cbd_datlen); 231 232 if (!(in_be16(&rtx->rxbd[rxIdx].cbd_sc) & 0x003f)) { 233 uchar *rx = net_rx_packets[rxIdx]; 234 235 length -= 4; 236 237 #if defined(CONFIG_CMD_CDP) 238 if ((rx[0] & 1) != 0 && 239 memcmp((uchar *)rx, net_bcast_ethaddr, 6) != 0 && 240 !is_cdp_packet((uchar *)rx)) 241 rx = NULL; 242 #endif 243 /* 244 * Pass the packet up to the protocol layers. 245 */ 246 if (rx != NULL) 247 net_process_received_packet(rx, length); 248 } 249 250 /* Give the buffer back to the FEC. */ 251 out_be16(&rtx->rxbd[rxIdx].cbd_datlen, 0); 252 253 /* wrap around buffer index when necessary */ 254 if ((rxIdx + 1) >= PKTBUFSRX) { 255 out_be16(&rtx->rxbd[PKTBUFSRX - 1].cbd_sc, 256 BD_ENET_RX_WRAP | BD_ENET_RX_EMPTY); 257 rxIdx = 0; 258 } else { 259 out_be16(&rtx->rxbd[rxIdx].cbd_sc, BD_ENET_RX_EMPTY); 260 rxIdx++; 261 } 262 263 /* Try to fill Buffer Descriptors */ 264 /* Descriptor polling active */ 265 out_be32(&fecp->fec_r_des_active, 0x01000000); 266 } 267 268 return length; 269 } 270 271 /************************************************************** 272 * 273 * FEC Ethernet Initialization Routine 274 * 275 *************************************************************/ 276 277 #define FEC_ECNTRL_PINMUX 0x00000004 278 #define FEC_ECNTRL_ETHER_EN 0x00000002 279 #define FEC_ECNTRL_RESET 0x00000001 280 281 #define FEC_RCNTRL_BC_REJ 0x00000010 282 #define FEC_RCNTRL_PROM 0x00000008 283 #define FEC_RCNTRL_MII_MODE 0x00000004 284 #define FEC_RCNTRL_DRT 0x00000002 285 #define FEC_RCNTRL_LOOP 0x00000001 286 287 #define FEC_TCNTRL_FDEN 0x00000004 288 #define FEC_TCNTRL_HBC 0x00000002 289 #define FEC_TCNTRL_GTS 0x00000001 290 291 #define FEC_RESET_DELAY 50 292 293 #if defined(CONFIG_RMII) 294 295 static inline void fec_10Mbps(struct eth_device *dev) 296 { 297 struct ether_fcc_info_s *efis = dev->priv; 298 int fecidx = efis->ether_index; 299 uint mask = (fecidx == 0) ? 0x0000010 : 0x0000008; 300 immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR; 301 302 if ((unsigned int)fecidx >= 2) 303 hang(); 304 305 setbits_be32(&immr->im_cpm.cp_cptr, mask); 306 } 307 308 static inline void fec_100Mbps(struct eth_device *dev) 309 { 310 struct ether_fcc_info_s *efis = dev->priv; 311 int fecidx = efis->ether_index; 312 uint mask = (fecidx == 0) ? 0x0000010 : 0x0000008; 313 immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR; 314 315 if ((unsigned int)fecidx >= 2) 316 hang(); 317 318 clrbits_be32(&immr->im_cpm.cp_cptr, mask); 319 } 320 321 #endif 322 323 static inline void fec_full_duplex(struct eth_device *dev) 324 { 325 struct ether_fcc_info_s *efis = dev->priv; 326 fec_t __iomem *fecp = 327 (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset); 328 329 clrbits_be32(&fecp->fec_r_cntrl, FEC_RCNTRL_DRT); 330 setbits_be32(&fecp->fec_x_cntrl, FEC_TCNTRL_FDEN); /* FD enable */ 331 } 332 333 static inline void fec_half_duplex(struct eth_device *dev) 334 { 335 struct ether_fcc_info_s *efis = dev->priv; 336 fec_t __iomem *fecp = 337 (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset); 338 339 setbits_be32(&fecp->fec_r_cntrl, FEC_RCNTRL_DRT); 340 clrbits_be32(&fecp->fec_x_cntrl, FEC_TCNTRL_FDEN); /* FD disable */ 341 } 342 343 static void fec_pin_init(int fecidx) 344 { 345 bd_t *bd = gd->bd; 346 immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR; 347 348 /* 349 * Set MII speed to 2.5 MHz or slightly below. 350 * 351 * According to the MPC860T (Rev. D) Fast ethernet controller user 352 * manual (6.2.14), 353 * the MII management interface clock must be less than or equal 354 * to 2.5 MHz. 355 * This MDC frequency is equal to system clock / (2 * MII_SPEED). 356 * Then MII_SPEED = system_clock / 2 * 2,5 MHz. 357 * 358 * All MII configuration is done via FEC1 registers: 359 */ 360 out_be32(&immr->im_cpm.cp_fec1.fec_mii_speed, 361 ((bd->bi_intfreq + 4999999) / 5000000) << 1); 362 363 #if defined(CONFIG_MPC885) && defined(WANT_MII) 364 /* use MDC for MII */ 365 setbits_be16(&immr->im_ioport.iop_pdpar, 0x0080); 366 clrbits_be16(&immr->im_ioport.iop_pddir, 0x0080); 367 #endif 368 369 if (fecidx == 0) { 370 #if defined(CONFIG_ETHER_ON_FEC1) 371 372 #if defined(CONFIG_MPC885) /* MPC87x/88x have got 2 FECs and different pinout */ 373 374 #if !defined(CONFIG_RMII) 375 376 setbits_be16(&immr->im_ioport.iop_papar, 0xf830); 377 setbits_be16(&immr->im_ioport.iop_padir, 0x0830); 378 clrbits_be16(&immr->im_ioport.iop_padir, 0xf000); 379 380 setbits_be32(&immr->im_cpm.cp_pbpar, 0x00001001); 381 clrbits_be32(&immr->im_cpm.cp_pbdir, 0x00001001); 382 383 setbits_be16(&immr->im_ioport.iop_pcpar, 0x000c); 384 clrbits_be16(&immr->im_ioport.iop_pcdir, 0x000c); 385 386 setbits_be32(&immr->im_cpm.cp_pepar, 0x00000003); 387 setbits_be32(&immr->im_cpm.cp_pedir, 0x00000003); 388 clrbits_be32(&immr->im_cpm.cp_peso, 0x00000003); 389 390 clrbits_be32(&immr->im_cpm.cp_cptr, 0x00000100); 391 392 #else 393 394 #if !defined(CONFIG_FEC1_PHY_NORXERR) 395 setbits_be16(&immr->im_ioport.iop_papar, 0x1000); 396 clrbits_be16(&immr->im_ioport.iop_padir, 0x1000); 397 #endif 398 setbits_be16(&immr->im_ioport.iop_papar, 0xe810); 399 setbits_be16(&immr->im_ioport.iop_padir, 0x0810); 400 clrbits_be16(&immr->im_ioport.iop_padir, 0xe000); 401 402 setbits_be32(&immr->im_cpm.cp_pbpar, 0x00000001); 403 clrbits_be32(&immr->im_cpm.cp_pbdir, 0x00000001); 404 405 setbits_be32(&immr->im_cpm.cp_cptr, 0x00000100); 406 clrbits_be32(&immr->im_cpm.cp_cptr, 0x00000050); 407 408 #endif /* !CONFIG_RMII */ 409 410 #else 411 /* 412 * Configure all of port D for MII. 413 */ 414 out_be16(&immr->im_ioport.iop_pdpar, 0x1fff); 415 out_be16(&immr->im_ioport.iop_pddir, 0x1fff); 416 #endif 417 418 #endif /* CONFIG_ETHER_ON_FEC1 */ 419 } else if (fecidx == 1) { 420 #if defined(CONFIG_ETHER_ON_FEC2) 421 422 #if defined(CONFIG_MPC885) /* MPC87x/88x have got 2 FECs and different pinout */ 423 424 #if !defined(CONFIG_RMII) 425 setbits_be32(&immr->im_cpm.cp_pepar, 0x0003fffc); 426 setbits_be32(&immr->im_cpm.cp_pedir, 0x0003fffc); 427 clrbits_be32(&immr->im_cpm.cp_peso, 0x000087fc); 428 setbits_be32(&immr->im_cpm.cp_peso, 0x00037800); 429 430 clrbits_be32(&immr->im_cpm.cp_cptr, 0x00000080); 431 #else 432 433 #if !defined(CONFIG_FEC2_PHY_NORXERR) 434 setbits_be32(&immr->im_cpm.cp_pepar, 0x00000010); 435 setbits_be32(&immr->im_cpm.cp_pedir, 0x00000010); 436 clrbits_be32(&immr->im_cpm.cp_peso, 0x00000010); 437 #endif 438 setbits_be32(&immr->im_cpm.cp_pepar, 0x00039620); 439 setbits_be32(&immr->im_cpm.cp_pedir, 0x00039620); 440 setbits_be32(&immr->im_cpm.cp_peso, 0x00031000); 441 clrbits_be32(&immr->im_cpm.cp_peso, 0x00008620); 442 443 setbits_be32(&immr->im_cpm.cp_cptr, 0x00000080); 444 clrbits_be32(&immr->im_cpm.cp_cptr, 0x00000028); 445 #endif /* CONFIG_RMII */ 446 447 #endif /* CONFIG_MPC885 */ 448 449 #endif /* CONFIG_ETHER_ON_FEC2 */ 450 } 451 } 452 453 static int fec_reset(fec_t __iomem *fecp) 454 { 455 int i; 456 457 /* Whack a reset. 458 * A delay is required between a reset of the FEC block and 459 * initialization of other FEC registers because the reset takes 460 * some time to complete. If you don't delay, subsequent writes 461 * to FEC registers might get killed by the reset routine which is 462 * still in progress. 463 */ 464 465 out_be32(&fecp->fec_ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET); 466 for (i = 0; (in_be32(&fecp->fec_ecntrl) & FEC_ECNTRL_RESET) && 467 (i < FEC_RESET_DELAY); ++i) 468 udelay(1); 469 470 if (i == FEC_RESET_DELAY) 471 return -1; 472 473 return 0; 474 } 475 476 static int fec_init(struct eth_device *dev, bd_t *bd) 477 { 478 struct ether_fcc_info_s *efis = dev->priv; 479 immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR; 480 fec_t __iomem *fecp = 481 (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset); 482 int i; 483 484 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 485 /* the MII interface is connected to FEC1 486 * so for the miiphy_xxx function to work we must 487 * call mii_init since fec_halt messes the thing up 488 */ 489 if (efis->ether_index != 0) 490 __mii_init(); 491 #endif 492 493 if (fec_reset(fecp) < 0) 494 printf("FEC_RESET_DELAY timeout\n"); 495 496 /* We use strictly polling mode only 497 */ 498 out_be32(&fecp->fec_imask, 0); 499 500 /* Clear any pending interrupt 501 */ 502 out_be32(&fecp->fec_ievent, 0xffc0); 503 504 /* No need to set the IVEC register */ 505 506 /* Set station address 507 */ 508 #define ea dev->enetaddr 509 out_be32(&fecp->fec_addr_low, (ea[0] << 24) | (ea[1] << 16) | 510 (ea[2] << 8) | ea[3]); 511 out_be16(&fecp->fec_addr_high, (ea[4] << 8) | ea[5]); 512 #undef ea 513 514 #if defined(CONFIG_CMD_CDP) 515 /* 516 * Turn on multicast address hash table 517 */ 518 out_be32(&fecp->fec_hash_table_high, 0xffffffff); 519 out_be32(&fecp->fec_hash_table_low, 0xffffffff); 520 #else 521 /* Clear multicast address hash table 522 */ 523 out_be32(&fecp->fec_hash_table_high, 0); 524 out_be32(&fecp->fec_hash_table_low, 0); 525 #endif 526 527 /* Set maximum receive buffer size. 528 */ 529 out_be32(&fecp->fec_r_buff_size, PKT_MAXBLR_SIZE); 530 531 /* Set maximum frame length 532 */ 533 out_be32(&fecp->fec_r_hash, PKT_MAXBUF_SIZE); 534 535 /* 536 * Setup Buffers and Buffer Descriptors 537 */ 538 rxIdx = 0; 539 txIdx = 0; 540 541 if (!rtx) 542 rtx = (struct common_buf_desc __iomem *) 543 (immr->im_cpm.cp_dpmem + CPM_FEC_BASE); 544 /* 545 * Setup Receiver Buffer Descriptors (13.14.24.18) 546 * Settings: 547 * Empty, Wrap 548 */ 549 for (i = 0; i < PKTBUFSRX; i++) { 550 out_be16(&rtx->rxbd[i].cbd_sc, BD_ENET_RX_EMPTY); 551 out_be16(&rtx->rxbd[i].cbd_datlen, 0); /* Reset */ 552 out_be32(&rtx->rxbd[i].cbd_bufaddr, (uint)net_rx_packets[i]); 553 } 554 setbits_be16(&rtx->rxbd[PKTBUFSRX - 1].cbd_sc, BD_ENET_RX_WRAP); 555 556 /* 557 * Setup Ethernet Transmitter Buffer Descriptors (13.14.24.19) 558 * Settings: 559 * Last, Tx CRC 560 */ 561 for (i = 0; i < TX_BUF_CNT; i++) { 562 out_be16(&rtx->txbd[i].cbd_sc, BD_ENET_TX_LAST | BD_ENET_TX_TC); 563 out_be16(&rtx->txbd[i].cbd_datlen, 0); /* Reset */ 564 out_be32(&rtx->txbd[i].cbd_bufaddr, (uint)txbuf); 565 } 566 setbits_be16(&rtx->txbd[TX_BUF_CNT - 1].cbd_sc, BD_ENET_TX_WRAP); 567 568 /* Set receive and transmit descriptor base 569 */ 570 out_be32(&fecp->fec_r_des_start, (__force unsigned int)rtx->rxbd); 571 out_be32(&fecp->fec_x_des_start, (__force unsigned int)rtx->txbd); 572 573 /* Enable MII mode 574 */ 575 /* Half duplex mode */ 576 out_be32(&fecp->fec_r_cntrl, FEC_RCNTRL_MII_MODE | FEC_RCNTRL_DRT); 577 out_be32(&fecp->fec_x_cntrl, 0); 578 579 /* Enable big endian and don't care about SDMA FC. 580 */ 581 out_be32(&fecp->fec_fun_code, 0x78000000); 582 583 /* 584 * Setup the pin configuration of the FEC 585 */ 586 fec_pin_init(efis->ether_index); 587 588 rxIdx = 0; 589 txIdx = 0; 590 591 /* 592 * Now enable the transmit and receive processing 593 */ 594 out_be32(&fecp->fec_ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN); 595 596 if (efis->phy_addr == -1) { 597 #ifdef CONFIG_SYS_DISCOVER_PHY 598 /* 599 * wait for the PHY to wake up after reset 600 */ 601 efis->actual_phy_addr = mii_discover_phy(dev); 602 603 if (efis->actual_phy_addr == -1) { 604 printf("Unable to discover phy!\n"); 605 return -1; 606 } 607 #else 608 efis->actual_phy_addr = -1; 609 #endif 610 } else { 611 efis->actual_phy_addr = efis->phy_addr; 612 } 613 614 #if defined(CONFIG_MII) && defined(CONFIG_RMII) 615 /* 616 * adapt the RMII speed to the speed of the phy 617 */ 618 if (miiphy_speed(dev->name, efis->actual_phy_addr) == _100BASET) 619 fec_100Mbps(dev); 620 else 621 fec_10Mbps(dev); 622 #endif 623 624 #if defined(CONFIG_MII) 625 /* 626 * adapt to the half/full speed settings 627 */ 628 if (miiphy_duplex(dev->name, efis->actual_phy_addr) == FULL) 629 fec_full_duplex(dev); 630 else 631 fec_half_duplex(dev); 632 #endif 633 634 /* And last, try to fill Rx Buffer Descriptors */ 635 /* Descriptor polling active */ 636 out_be32(&fecp->fec_r_des_active, 0x01000000); 637 638 efis->initialized = 1; 639 640 return 0; 641 } 642 643 644 static void fec_halt(struct eth_device *dev) 645 { 646 struct ether_fcc_info_s *efis = dev->priv; 647 fec_t __iomem *fecp = 648 (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset); 649 int i; 650 651 /* avoid halt if initialized; mii gets stuck otherwise */ 652 if (!efis->initialized) 653 return; 654 655 /* Whack a reset. 656 * A delay is required between a reset of the FEC block and 657 * initialization of other FEC registers because the reset takes 658 * some time to complete. If you don't delay, subsequent writes 659 * to FEC registers might get killed by the reset routine which is 660 * still in progress. 661 */ 662 663 out_be32(&fecp->fec_ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET); 664 for (i = 0; (in_be32(&fecp->fec_ecntrl) & FEC_ECNTRL_RESET) && 665 (i < FEC_RESET_DELAY); ++i) 666 udelay(1); 667 668 if (i == FEC_RESET_DELAY) { 669 printf("FEC_RESET_DELAY timeout\n"); 670 return; 671 } 672 673 efis->initialized = 0; 674 } 675 676 #if defined(CONFIG_SYS_DISCOVER_PHY) || defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 677 678 /* Make MII read/write commands for the FEC. 679 */ 680 681 #define mk_mii_read(ADDR, REG) (0x60020000 | ((ADDR << 23) | \ 682 (REG & 0x1f) << 18)) 683 684 #define mk_mii_write(ADDR, REG, VAL) (0x50020000 | ((ADDR << 23) | \ 685 (REG & 0x1f) << 18) | \ 686 (VAL & 0xffff)) 687 688 /* Interrupt events/masks. 689 */ 690 #define FEC_ENET_HBERR ((uint)0x80000000) /* Heartbeat error */ 691 #define FEC_ENET_BABR ((uint)0x40000000) /* Babbling receiver */ 692 #define FEC_ENET_BABT ((uint)0x20000000) /* Babbling transmitter */ 693 #define FEC_ENET_GRA ((uint)0x10000000) /* Graceful stop complete */ 694 #define FEC_ENET_TXF ((uint)0x08000000) /* Full frame transmitted */ 695 #define FEC_ENET_TXB ((uint)0x04000000) /* A buffer was transmitted */ 696 #define FEC_ENET_RXF ((uint)0x02000000) /* Full frame received */ 697 #define FEC_ENET_RXB ((uint)0x01000000) /* A buffer was received */ 698 #define FEC_ENET_MII ((uint)0x00800000) /* MII interrupt */ 699 #define FEC_ENET_EBERR ((uint)0x00400000) /* SDMA bus error */ 700 701 /* send command to phy using mii, wait for result */ 702 static uint 703 mii_send(uint mii_cmd) 704 { 705 uint mii_reply; 706 fec_t __iomem *ep; 707 int cnt; 708 immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR; 709 710 ep = &immr->im_cpm.cp_fec; 711 712 out_be32(&ep->fec_mii_data, mii_cmd); /* command to phy */ 713 714 /* wait for mii complete */ 715 cnt = 0; 716 while (!(in_be32(&ep->fec_ievent) & FEC_ENET_MII)) { 717 if (++cnt > 1000) { 718 printf("mii_send STUCK!\n"); 719 break; 720 } 721 } 722 mii_reply = in_be32(&ep->fec_mii_data); /* result from phy */ 723 out_be32(&ep->fec_ievent, FEC_ENET_MII); /* clear MII complete */ 724 return mii_reply & 0xffff; /* data read from phy */ 725 } 726 #endif 727 728 #if defined(CONFIG_SYS_DISCOVER_PHY) 729 static int mii_discover_phy(struct eth_device *dev) 730 { 731 #define MAX_PHY_PASSES 11 732 uint phyno; 733 int pass; 734 uint phytype; 735 int phyaddr; 736 737 phyaddr = -1; /* didn't find a PHY yet */ 738 for (pass = 1; pass <= MAX_PHY_PASSES && phyaddr < 0; ++pass) { 739 if (pass > 1) { 740 /* PHY may need more time to recover from reset. 741 * The LXT970 needs 50ms typical, no maximum is 742 * specified, so wait 10ms before try again. 743 * With 11 passes this gives it 100ms to wake up. 744 */ 745 udelay(10000); /* wait 10ms */ 746 } 747 for (phyno = 0; phyno < 32 && phyaddr < 0; ++phyno) { 748 phytype = mii_send(mk_mii_read(phyno, MII_PHYSID2)); 749 if (phytype != 0xffff) { 750 phyaddr = phyno; 751 phytype |= mii_send(mk_mii_read(phyno, 752 MII_PHYSID1)) << 16; 753 } 754 } 755 } 756 if (phyaddr < 0) 757 printf("No PHY device found.\n"); 758 759 return phyaddr; 760 } 761 #endif /* CONFIG_SYS_DISCOVER_PHY */ 762 763 #if (defined(CONFIG_MII) || defined(CONFIG_CMD_MII)) && !defined(CONFIG_BITBANGMII) 764 765 /**************************************************************************** 766 * mii_init -- Initialize the MII via FEC 1 for MII command without ethernet 767 * This function is a subset of eth_init 768 **************************************************************************** 769 */ 770 static void __mii_init(void) 771 { 772 immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR; 773 fec_t __iomem *fecp = &immr->im_cpm.cp_fec; 774 775 if (fec_reset(fecp) < 0) 776 printf("FEC_RESET_DELAY timeout\n"); 777 778 /* We use strictly polling mode only 779 */ 780 out_be32(&fecp->fec_imask, 0); 781 782 /* Clear any pending interrupt 783 */ 784 out_be32(&fecp->fec_ievent, 0xffc0); 785 786 /* Now enable the transmit and receive processing 787 */ 788 out_be32(&fecp->fec_ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN); 789 } 790 791 void mii_init(void) 792 { 793 int i; 794 795 __mii_init(); 796 797 /* Setup the pin configuration of the FEC(s) 798 */ 799 for (i = 0; i < ARRAY_SIZE(ether_fcc_info); i++) 800 fec_pin_init(ether_fcc_info[i].ether_index); 801 } 802 803 /***************************************************************************** 804 * Read and write a MII PHY register, routines used by MII Utilities 805 * 806 * FIXME: These routines are expected to return 0 on success, but mii_send 807 * does _not_ return an error code. Maybe 0xFFFF means error, i.e. 808 * no PHY connected... 809 * For now always return 0. 810 * FIXME: These routines only work after calling eth_init() at least once! 811 * Otherwise they hang in mii_send() !!! Sorry! 812 *****************************************************************************/ 813 814 int fec8xx_miiphy_read(struct mii_dev *bus, int addr, int devad, int reg) 815 { 816 unsigned short value = 0; 817 short rdreg; /* register working value */ 818 819 rdreg = mii_send(mk_mii_read(addr, reg)); 820 821 value = rdreg; 822 return value; 823 } 824 825 int fec8xx_miiphy_write(struct mii_dev *bus, int addr, int devad, int reg, 826 u16 value) 827 { 828 (void)mii_send(mk_mii_write(addr, reg, value)); 829 830 return 0; 831 } 832 #endif 833