1 /* 2 * rtl8139.c : U-Boot driver for the RealTek RTL8139 3 * 4 * Masami Komiya (mkomiya@sonare.it) 5 * 6 * Most part is taken from rtl8139.c of etherboot 7 * 8 */ 9 10 /* rtl8139.c - etherboot driver for the Realtek 8139 chipset 11 12 ported from the linux driver written by Donald Becker 13 by Rainer Bawidamann (Rainer.Bawidamann@informatik.uni-ulm.de) 1999 14 15 This software may be used and distributed according to the terms 16 of the GNU Public License, incorporated herein by reference. 17 18 changes to the original driver: 19 - removed support for interrupts, switching to polling mode (yuck!) 20 - removed support for the 8129 chip (external MII) 21 22 */ 23 24 /*********************************************************************/ 25 /* Revision History */ 26 /*********************************************************************/ 27 28 /* 29 28 Dec 2002 ken_yap@users.sourceforge.net (Ken Yap) 30 Put in virt_to_bus calls to allow Etherboot relocation. 31 32 06 Apr 2001 ken_yap@users.sourceforge.net (Ken Yap) 33 Following email from Hyun-Joon Cha, added a disable routine, otherwise 34 NIC remains live and can crash the kernel later. 35 36 4 Feb 2000 espenlaub@informatik.uni-ulm.de (Klaus Espenlaub) 37 Shuffled things around, removed the leftovers from the 8129 support 38 that was in the Linux driver and added a bit more 8139 definitions. 39 Moved the 8K receive buffer to a fixed, available address outside the 40 0x98000-0x9ffff range. This is a bit of a hack, but currently the only 41 way to make room for the Etherboot features that need substantial amounts 42 of code like the ANSI console support. Currently the buffer is just below 43 0x10000, so this even conforms to the tagged boot image specification, 44 which reserves the ranges 0x00000-0x10000 and 0x98000-0xA0000. My 45 interpretation of this "reserved" is that Etherboot may do whatever it 46 likes, as long as its environment is kept intact (like the BIOS 47 variables). Hopefully fixed rtl_poll() once and for all. The symptoms 48 were that if Etherboot was left at the boot menu for several minutes, the 49 first eth_poll failed. Seems like I am the only person who does this. 50 First of all I fixed the debugging code and then set out for a long bug 51 hunting session. It took me about a week full time work - poking around 52 various places in the driver, reading Don Becker's and Jeff Garzik's Linux 53 driver and even the FreeBSD driver (what a piece of crap!) - and 54 eventually spotted the nasty thing: the transmit routine was acknowledging 55 each and every interrupt pending, including the RxOverrun and RxFIFIOver 56 interrupts. This confused the RTL8139 thoroughly. It destroyed the 57 Rx ring contents by dumping the 2K FIFO contents right where we wanted to 58 get the next packet. Oh well, what fun. 59 60 18 Jan 2000 mdc@thinguin.org (Marty Connor) 61 Drastically simplified error handling. Basically, if any error 62 in transmission or reception occurs, the card is reset. 63 Also, pointed all transmit descriptors to the same buffer to 64 save buffer space. This should decrease driver size and avoid 65 corruption because of exceeding 32K during runtime. 66 67 28 Jul 1999 (Matthias Meixner - meixner@rbg.informatik.tu-darmstadt.de) 68 rtl_poll was quite broken: it used the RxOK interrupt flag instead 69 of the RxBufferEmpty flag which often resulted in very bad 70 transmission performace - below 1kBytes/s. 71 72 */ 73 74 #include <common.h> 75 #include <malloc.h> 76 #include <net.h> 77 #include <asm/io.h> 78 #include <pci.h> 79 80 #define RTL_TIMEOUT 100000 81 82 #define ETH_FRAME_LEN 1514 83 #define ETH_ALEN 6 84 #define ETH_ZLEN 60 85 86 /* PCI Tuning Parameters 87 Threshold is bytes transferred to chip before transmission starts. */ 88 #define TX_FIFO_THRESH 256 /* In bytes, rounded down to 32 byte units. */ 89 #define RX_FIFO_THRESH 4 /* Rx buffer level before first PCI xfer. */ 90 #define RX_DMA_BURST 4 /* Maximum PCI burst, '4' is 256 bytes */ 91 #define TX_DMA_BURST 4 /* Calculate as 16<<val. */ 92 #define NUM_TX_DESC 4 /* Number of Tx descriptor registers. */ 93 #define TX_BUF_SIZE ETH_FRAME_LEN /* FCS is added by the chip */ 94 #define RX_BUF_LEN_IDX 0 /* 0, 1, 2 is allowed - 8,16,32K rx buffer */ 95 #define RX_BUF_LEN (8192 << RX_BUF_LEN_IDX) 96 97 #undef DEBUG_TX 98 #undef DEBUG_RX 99 100 #define currticks() get_timer(0) 101 #define bus_to_phys(a) pci_mem_to_phys((pci_dev_t)dev->priv, a) 102 #define phys_to_bus(a) pci_phys_to_mem((pci_dev_t)dev->priv, a) 103 104 /* Symbolic offsets to registers. */ 105 enum RTL8139_registers { 106 MAC0=0, /* Ethernet hardware address. */ 107 MAR0=8, /* Multicast filter. */ 108 TxStatus0=0x10, /* Transmit status (four 32bit registers). */ 109 TxAddr0=0x20, /* Tx descriptors (also four 32bit). */ 110 RxBuf=0x30, RxEarlyCnt=0x34, RxEarlyStatus=0x36, 111 ChipCmd=0x37, RxBufPtr=0x38, RxBufAddr=0x3A, 112 IntrMask=0x3C, IntrStatus=0x3E, 113 TxConfig=0x40, RxConfig=0x44, 114 Timer=0x48, /* general-purpose counter. */ 115 RxMissed=0x4C, /* 24 bits valid, write clears. */ 116 Cfg9346=0x50, Config0=0x51, Config1=0x52, 117 TimerIntrReg=0x54, /* intr if gp counter reaches this value */ 118 MediaStatus=0x58, 119 Config3=0x59, 120 MultiIntr=0x5C, 121 RevisionID=0x5E, /* revision of the RTL8139 chip */ 122 TxSummary=0x60, 123 MII_BMCR=0x62, MII_BMSR=0x64, NWayAdvert=0x66, NWayLPAR=0x68, 124 NWayExpansion=0x6A, 125 DisconnectCnt=0x6C, FalseCarrierCnt=0x6E, 126 NWayTestReg=0x70, 127 RxCnt=0x72, /* packet received counter */ 128 CSCR=0x74, /* chip status and configuration register */ 129 PhyParm1=0x78,TwisterParm=0x7c,PhyParm2=0x80, /* undocumented */ 130 /* from 0x84 onwards are a number of power management/wakeup frame 131 * definitions we will probably never need to know about. */ 132 }; 133 134 enum ChipCmdBits { 135 CmdReset=0x10, CmdRxEnb=0x08, CmdTxEnb=0x04, RxBufEmpty=0x01, }; 136 137 /* Interrupt register bits, using my own meaningful names. */ 138 enum IntrStatusBits { 139 PCIErr=0x8000, PCSTimeout=0x4000, CableLenChange= 0x2000, 140 RxFIFOOver=0x40, RxUnderrun=0x20, RxOverflow=0x10, 141 TxErr=0x08, TxOK=0x04, RxErr=0x02, RxOK=0x01, 142 }; 143 enum TxStatusBits { 144 TxHostOwns=0x2000, TxUnderrun=0x4000, TxStatOK=0x8000, 145 TxOutOfWindow=0x20000000, TxAborted=0x40000000, 146 TxCarrierLost=0x80000000, 147 }; 148 enum RxStatusBits { 149 RxMulticast=0x8000, RxPhysical=0x4000, RxBroadcast=0x2000, 150 RxBadSymbol=0x0020, RxRunt=0x0010, RxTooLong=0x0008, RxCRCErr=0x0004, 151 RxBadAlign=0x0002, RxStatusOK=0x0001, 152 }; 153 154 enum MediaStatusBits { 155 MSRTxFlowEnable=0x80, MSRRxFlowEnable=0x40, MSRSpeed10=0x08, 156 MSRLinkFail=0x04, MSRRxPauseFlag=0x02, MSRTxPauseFlag=0x01, 157 }; 158 159 enum MIIBMCRBits { 160 BMCRReset=0x8000, BMCRSpeed100=0x2000, BMCRNWayEnable=0x1000, 161 BMCRRestartNWay=0x0200, BMCRDuplex=0x0100, 162 }; 163 164 enum CSCRBits { 165 CSCR_LinkOKBit=0x0400, CSCR_LinkChangeBit=0x0800, 166 CSCR_LinkStatusBits=0x0f000, CSCR_LinkDownOffCmd=0x003c0, 167 CSCR_LinkDownCmd=0x0f3c0, 168 }; 169 170 /* Bits in RxConfig. */ 171 enum rx_mode_bits { 172 RxCfgWrap=0x80, 173 AcceptErr=0x20, AcceptRunt=0x10, AcceptBroadcast=0x08, 174 AcceptMulticast=0x04, AcceptMyPhys=0x02, AcceptAllPhys=0x01, 175 }; 176 177 static int ioaddr; 178 static unsigned int cur_rx,cur_tx; 179 180 /* The RTL8139 can only transmit from a contiguous, aligned memory block. */ 181 static unsigned char tx_buffer[TX_BUF_SIZE] __attribute__((aligned(4))); 182 static unsigned char rx_ring[RX_BUF_LEN+16] __attribute__((aligned(4))); 183 184 static int rtl8139_probe(struct eth_device *dev, bd_t *bis); 185 static int read_eeprom(int location, int addr_len); 186 static void rtl_reset(struct eth_device *dev); 187 static int rtl_transmit(struct eth_device *dev, volatile void *packet, int length); 188 static int rtl_poll(struct eth_device *dev); 189 static void rtl_disable(struct eth_device *dev); 190 #ifdef CONFIG_MCAST_TFTP/* This driver already accepts all b/mcast */ 191 static int rtl_bcast_addr (struct eth_device *dev, u8 bcast_mac, u8 set) 192 { 193 return (0); 194 } 195 #endif 196 197 static struct pci_device_id supported[] = { 198 {PCI_VENDOR_ID_REALTEK, PCI_DEVICE_ID_REALTEK_8139}, 199 {PCI_VENDOR_ID_DLINK, PCI_DEVICE_ID_DLINK_8139}, 200 {} 201 }; 202 203 int rtl8139_initialize(bd_t *bis) 204 { 205 pci_dev_t devno; 206 int card_number = 0; 207 struct eth_device *dev; 208 u32 iobase; 209 int idx=0; 210 211 while(1){ 212 /* Find RTL8139 */ 213 if ((devno = pci_find_devices(supported, idx++)) < 0) 214 break; 215 216 pci_read_config_dword(devno, PCI_BASE_ADDRESS_1, &iobase); 217 iobase &= ~0xf; 218 219 debug ("rtl8139: REALTEK RTL8139 @0x%x\n", iobase); 220 221 dev = (struct eth_device *)malloc(sizeof *dev); 222 223 sprintf (dev->name, "RTL8139#%d", card_number); 224 225 dev->priv = (void *) devno; 226 dev->iobase = (int)bus_to_phys(iobase); 227 dev->init = rtl8139_probe; 228 dev->halt = rtl_disable; 229 dev->send = rtl_transmit; 230 dev->recv = rtl_poll; 231 #ifdef CONFIG_MCAST_TFTP 232 dev->mcast = rtl_bcast_addr; 233 #endif 234 235 eth_register (dev); 236 237 card_number++; 238 239 pci_write_config_byte (devno, PCI_LATENCY_TIMER, 0x20); 240 241 udelay (10 * 1000); 242 } 243 244 return card_number; 245 } 246 247 static int rtl8139_probe(struct eth_device *dev, bd_t *bis) 248 { 249 int i; 250 int speed10, fullduplex; 251 int addr_len; 252 unsigned short *ap = (unsigned short *)dev->enetaddr; 253 254 ioaddr = dev->iobase; 255 256 /* Bring the chip out of low-power mode. */ 257 outb(0x00, ioaddr + Config1); 258 259 addr_len = read_eeprom(0,8) == 0x8129 ? 8 : 6; 260 for (i = 0; i < 3; i++) 261 *ap++ = le16_to_cpu (read_eeprom(i + 7, addr_len)); 262 263 speed10 = inb(ioaddr + MediaStatus) & MSRSpeed10; 264 fullduplex = inw(ioaddr + MII_BMCR) & BMCRDuplex; 265 266 rtl_reset(dev); 267 268 if (inb(ioaddr + MediaStatus) & MSRLinkFail) { 269 printf("Cable not connected or other link failure\n"); 270 return -1 ; 271 } 272 273 return 0; 274 } 275 276 /* Serial EEPROM section. */ 277 278 /* EEPROM_Ctrl bits. */ 279 #define EE_SHIFT_CLK 0x04 /* EEPROM shift clock. */ 280 #define EE_CS 0x08 /* EEPROM chip select. */ 281 #define EE_DATA_WRITE 0x02 /* EEPROM chip data in. */ 282 #define EE_WRITE_0 0x00 283 #define EE_WRITE_1 0x02 284 #define EE_DATA_READ 0x01 /* EEPROM chip data out. */ 285 #define EE_ENB (0x80 | EE_CS) 286 287 /* 288 Delay between EEPROM clock transitions. 289 No extra delay is needed with 33Mhz PCI, but 66Mhz may change this. 290 */ 291 292 #define eeprom_delay() inl(ee_addr) 293 294 /* The EEPROM commands include the alway-set leading bit. */ 295 #define EE_WRITE_CMD (5) 296 #define EE_READ_CMD (6) 297 #define EE_ERASE_CMD (7) 298 299 static int read_eeprom(int location, int addr_len) 300 { 301 int i; 302 unsigned int retval = 0; 303 long ee_addr = ioaddr + Cfg9346; 304 int read_cmd = location | (EE_READ_CMD << addr_len); 305 306 outb(EE_ENB & ~EE_CS, ee_addr); 307 outb(EE_ENB, ee_addr); 308 eeprom_delay(); 309 310 /* Shift the read command bits out. */ 311 for (i = 4 + addr_len; i >= 0; i--) { 312 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0; 313 outb(EE_ENB | dataval, ee_addr); 314 eeprom_delay(); 315 outb(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr); 316 eeprom_delay(); 317 } 318 outb(EE_ENB, ee_addr); 319 eeprom_delay(); 320 321 for (i = 16; i > 0; i--) { 322 outb(EE_ENB | EE_SHIFT_CLK, ee_addr); 323 eeprom_delay(); 324 retval = (retval << 1) | ((inb(ee_addr) & EE_DATA_READ) ? 1 : 0); 325 outb(EE_ENB, ee_addr); 326 eeprom_delay(); 327 } 328 329 /* Terminate the EEPROM access. */ 330 outb(~EE_CS, ee_addr); 331 eeprom_delay(); 332 return retval; 333 } 334 335 static const unsigned int rtl8139_rx_config = 336 (RX_BUF_LEN_IDX << 11) | 337 (RX_FIFO_THRESH << 13) | 338 (RX_DMA_BURST << 8); 339 340 static void set_rx_mode(struct eth_device *dev) { 341 unsigned int mc_filter[2]; 342 int rx_mode; 343 /* !IFF_PROMISC */ 344 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys; 345 mc_filter[1] = mc_filter[0] = 0xffffffff; 346 347 outl(rtl8139_rx_config | rx_mode, ioaddr + RxConfig); 348 349 outl(mc_filter[0], ioaddr + MAR0 + 0); 350 outl(mc_filter[1], ioaddr + MAR0 + 4); 351 } 352 353 static void rtl_reset(struct eth_device *dev) 354 { 355 int i; 356 357 outb(CmdReset, ioaddr + ChipCmd); 358 359 cur_rx = 0; 360 cur_tx = 0; 361 362 /* Give the chip 10ms to finish the reset. */ 363 for (i=0; i<100; ++i){ 364 if ((inb(ioaddr + ChipCmd) & CmdReset) == 0) break; 365 udelay (100); /* wait 100us */ 366 } 367 368 369 for (i = 0; i < ETH_ALEN; i++) 370 outb(dev->enetaddr[i], ioaddr + MAC0 + i); 371 372 /* Must enable Tx/Rx before setting transfer thresholds! */ 373 outb(CmdRxEnb | CmdTxEnb, ioaddr + ChipCmd); 374 outl((RX_FIFO_THRESH<<13) | (RX_BUF_LEN_IDX<<11) | (RX_DMA_BURST<<8), 375 ioaddr + RxConfig); /* accept no frames yet! */ 376 outl((TX_DMA_BURST<<8)|0x03000000, ioaddr + TxConfig); 377 378 /* The Linux driver changes Config1 here to use a different LED pattern 379 * for half duplex or full/autodetect duplex (for full/autodetect, the 380 * outputs are TX/RX, Link10/100, FULL, while for half duplex it uses 381 * TX/RX, Link100, Link10). This is messy, because it doesn't match 382 * the inscription on the mounting bracket. It should not be changed 383 * from the configuration EEPROM default, because the card manufacturer 384 * should have set that to match the card. */ 385 386 #ifdef DEBUG_RX 387 printf("rx ring address is %X\n",(unsigned long)rx_ring); 388 #endif 389 flush_cache((unsigned long)rx_ring, RX_BUF_LEN); 390 outl(phys_to_bus((int)rx_ring), ioaddr + RxBuf); 391 392 /* If we add multicast support, the MAR0 register would have to be 393 * initialized to 0xffffffffffffffff (two 32 bit accesses). Etherboot 394 * only needs broadcast (for ARP/RARP/BOOTP/DHCP) and unicast. */ 395 396 outb(CmdRxEnb | CmdTxEnb, ioaddr + ChipCmd); 397 398 outl(rtl8139_rx_config, ioaddr + RxConfig); 399 400 /* Start the chip's Tx and Rx process. */ 401 outl(0, ioaddr + RxMissed); 402 403 /* set_rx_mode */ 404 set_rx_mode(dev); 405 406 /* Disable all known interrupts by setting the interrupt mask. */ 407 outw(0, ioaddr + IntrMask); 408 } 409 410 static int rtl_transmit(struct eth_device *dev, volatile void *packet, int length) 411 { 412 unsigned int status; 413 unsigned long txstatus; 414 unsigned int len = length; 415 int i = 0; 416 417 ioaddr = dev->iobase; 418 419 memcpy((char *)tx_buffer, (char *)packet, (int)length); 420 421 #ifdef DEBUG_TX 422 printf("sending %d bytes\n", len); 423 #endif 424 425 /* Note: RTL8139 doesn't auto-pad, send minimum payload (another 4 426 * bytes are sent automatically for the FCS, totalling to 64 bytes). */ 427 while (len < ETH_ZLEN) { 428 tx_buffer[len++] = '\0'; 429 } 430 431 flush_cache((unsigned long)tx_buffer, length); 432 outl(phys_to_bus((int)tx_buffer), ioaddr + TxAddr0 + cur_tx*4); 433 outl(((TX_FIFO_THRESH<<11) & 0x003f0000) | len, 434 ioaddr + TxStatus0 + cur_tx*4); 435 436 do { 437 status = inw(ioaddr + IntrStatus); 438 /* Only acknlowledge interrupt sources we can properly handle 439 * here - the RxOverflow/RxFIFOOver MUST be handled in the 440 * rtl_poll() function. */ 441 outw(status & (TxOK | TxErr | PCIErr), ioaddr + IntrStatus); 442 if ((status & (TxOK | TxErr | PCIErr)) != 0) break; 443 udelay(10); 444 } while (i++ < RTL_TIMEOUT); 445 446 txstatus = inl(ioaddr + TxStatus0 + cur_tx*4); 447 448 if (status & TxOK) { 449 cur_tx = (cur_tx + 1) % NUM_TX_DESC; 450 #ifdef DEBUG_TX 451 printf("tx done (%d ticks), status %hX txstatus %X\n", 452 to-currticks(), status, txstatus); 453 #endif 454 return length; 455 } else { 456 #ifdef DEBUG_TX 457 printf("tx timeout/error (%d usecs), status %hX txstatus %X\n", 458 10*i, status, txstatus); 459 #endif 460 rtl_reset(dev); 461 462 return 0; 463 } 464 } 465 466 static int rtl_poll(struct eth_device *dev) 467 { 468 unsigned int status; 469 unsigned int ring_offs; 470 unsigned int rx_size, rx_status; 471 int length=0; 472 473 ioaddr = dev->iobase; 474 475 if (inb(ioaddr + ChipCmd) & RxBufEmpty) { 476 return 0; 477 } 478 479 status = inw(ioaddr + IntrStatus); 480 /* See below for the rest of the interrupt acknowledges. */ 481 outw(status & ~(RxFIFOOver | RxOverflow | RxOK), ioaddr + IntrStatus); 482 483 #ifdef DEBUG_RX 484 printf("rtl_poll: int %hX ", status); 485 #endif 486 487 ring_offs = cur_rx % RX_BUF_LEN; 488 /* ring_offs is guaranteed being 4-byte aligned */ 489 rx_status = le32_to_cpu(*(unsigned int *)(rx_ring + ring_offs)); 490 rx_size = rx_status >> 16; 491 rx_status &= 0xffff; 492 493 if ((rx_status & (RxBadSymbol|RxRunt|RxTooLong|RxCRCErr|RxBadAlign)) || 494 (rx_size < ETH_ZLEN) || (rx_size > ETH_FRAME_LEN + 4)) { 495 printf("rx error %hX\n", rx_status); 496 rtl_reset(dev); /* this clears all interrupts still pending */ 497 return 0; 498 } 499 500 /* Received a good packet */ 501 length = rx_size - 4; /* no one cares about the FCS */ 502 if (ring_offs+4+rx_size-4 > RX_BUF_LEN) { 503 int semi_count = RX_BUF_LEN - ring_offs - 4; 504 unsigned char rxdata[RX_BUF_LEN]; 505 506 memcpy(rxdata, rx_ring + ring_offs + 4, semi_count); 507 memcpy(&(rxdata[semi_count]), rx_ring, rx_size-4-semi_count); 508 509 NetReceive(rxdata, length); 510 #ifdef DEBUG_RX 511 printf("rx packet %d+%d bytes", semi_count,rx_size-4-semi_count); 512 #endif 513 } else { 514 NetReceive(rx_ring + ring_offs + 4, length); 515 #ifdef DEBUG_RX 516 printf("rx packet %d bytes", rx_size-4); 517 #endif 518 } 519 flush_cache((unsigned long)rx_ring, RX_BUF_LEN); 520 521 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3; 522 outw(cur_rx - 16, ioaddr + RxBufPtr); 523 /* See RTL8139 Programming Guide V0.1 for the official handling of 524 * Rx overflow situations. The document itself contains basically no 525 * usable information, except for a few exception handling rules. */ 526 outw(status & (RxFIFOOver | RxOverflow | RxOK), ioaddr + IntrStatus); 527 return length; 528 } 529 530 static void rtl_disable(struct eth_device *dev) 531 { 532 int i; 533 534 ioaddr = dev->iobase; 535 536 /* reset the chip */ 537 outb(CmdReset, ioaddr + ChipCmd); 538 539 /* Give the chip 10ms to finish the reset. */ 540 for (i=0; i<100; ++i){ 541 if ((inb(ioaddr + ChipCmd) & CmdReset) == 0) break; 542 udelay (100); /* wait 100us */ 543 } 544 } 545