1 /* 2 ns8382x.c: A U-Boot driver for the NatSemi DP8382[01]. 3 ported by: Mark A. Rakes (mark_rakes@vivato.net) 4 5 Adapted from: 6 1. an Etherboot driver for DP8381[56] written by: 7 Copyright (C) 2001 Entity Cyber, Inc. 8 9 This development of this Etherboot driver was funded by 10 Sicom Systems: http://www.sicompos.com/ 11 12 Author: Marty Connor (mdc@thinguin.org) 13 Adapted from a Linux driver which was written by Donald Becker 14 15 This software may be used and distributed according to the terms 16 of the GNU Public License (GPL), incorporated herein by reference. 17 18 2. A Linux driver by Donald Becker, ns820.c: 19 Written/copyright 1999-2002 by Donald Becker. 20 21 This software may be used and distributed according to the terms of 22 the GNU General Public License (GPL), incorporated herein by reference. 23 Drivers based on or derived from this code fall under the GPL and must 24 retain the authorship, copyright and license notice. This file is not 25 a complete program and may only be used when the entire operating 26 system is licensed under the GPL. License for under other terms may be 27 available. Contact the original author for details. 28 29 The original author may be reached as becker@scyld.com, or at 30 Scyld Computing Corporation 31 410 Severn Ave., Suite 210 32 Annapolis MD 21403 33 34 Support information and updates available at 35 http://www.scyld.com/network/netsemi.html 36 37 Datasheets available from: 38 http://www.national.com/pf/DP/DP83820.html 39 http://www.national.com/pf/DP/DP83821.html 40 */ 41 42 /* Revision History 43 * October 2002 mar 1.0 44 * Initial U-Boot Release. 45 * Tested with Netgear GA622T (83820) 46 * and SMC9452TX (83821) 47 * NOTE: custom boards with these chips may (likely) require 48 * a programmed EEPROM device (if present) in order to work 49 * correctly. 50 */ 51 52 /* Includes */ 53 #include <common.h> 54 #include <malloc.h> 55 #include <net.h> 56 #include <asm/io.h> 57 #include <pci.h> 58 59 /* defines */ 60 #define DSIZE 0x00000FFF 61 #define ETH_ALEN 6 62 #define CRC_SIZE 4 63 #define TOUT_LOOP 500000 64 #define TX_BUF_SIZE 1536 65 #define RX_BUF_SIZE 1536 66 #define NUM_RX_DESC 4 /* Number of Rx descriptor registers. */ 67 68 enum register_offsets { 69 ChipCmd = 0x00, 70 ChipConfig = 0x04, 71 EECtrl = 0x08, 72 IntrMask = 0x14, 73 IntrEnable = 0x18, 74 TxRingPtr = 0x20, 75 TxRingPtrHi = 0x24, 76 TxConfig = 0x28, 77 RxRingPtr = 0x30, 78 RxRingPtrHi = 0x34, 79 RxConfig = 0x38, 80 PriQueue = 0x3C, 81 RxFilterAddr = 0x48, 82 RxFilterData = 0x4C, 83 ClkRun = 0xCC, 84 PCIPM = 0x44, 85 }; 86 87 enum ChipCmdBits { 88 ChipReset = 0x100, 89 RxReset = 0x20, 90 TxReset = 0x10, 91 RxOff = 0x08, 92 RxOn = 0x04, 93 TxOff = 0x02, 94 TxOn = 0x01 95 }; 96 97 enum ChipConfigBits { 98 LinkSts = 0x80000000, 99 GigSpeed = 0x40000000, 100 HundSpeed = 0x20000000, 101 FullDuplex = 0x10000000, 102 TBIEn = 0x01000000, 103 Mode1000 = 0x00400000, 104 T64En = 0x00004000, 105 D64En = 0x00001000, 106 M64En = 0x00000800, 107 PhyRst = 0x00000400, 108 PhyDis = 0x00000200, 109 ExtStEn = 0x00000100, 110 BEMode = 0x00000001, 111 }; 112 #define SpeedStatus_Polarity ( GigSpeed | HundSpeed | FullDuplex) 113 114 enum TxConfig_bits { 115 TxDrthMask = 0x000000ff, 116 TxFlthMask = 0x0000ff00, 117 TxMxdmaMask = 0x00700000, 118 TxMxdma_8 = 0x00100000, 119 TxMxdma_16 = 0x00200000, 120 TxMxdma_32 = 0x00300000, 121 TxMxdma_64 = 0x00400000, 122 TxMxdma_128 = 0x00500000, 123 TxMxdma_256 = 0x00600000, 124 TxMxdma_512 = 0x00700000, 125 TxMxdma_1024 = 0x00000000, 126 TxCollRetry = 0x00800000, 127 TxAutoPad = 0x10000000, 128 TxMacLoop = 0x20000000, 129 TxHeartIgn = 0x40000000, 130 TxCarrierIgn = 0x80000000 131 }; 132 133 enum RxConfig_bits { 134 RxDrthMask = 0x0000003e, 135 RxMxdmaMask = 0x00700000, 136 RxMxdma_8 = 0x00100000, 137 RxMxdma_16 = 0x00200000, 138 RxMxdma_32 = 0x00300000, 139 RxMxdma_64 = 0x00400000, 140 RxMxdma_128 = 0x00500000, 141 RxMxdma_256 = 0x00600000, 142 RxMxdma_512 = 0x00700000, 143 RxMxdma_1024 = 0x00000000, 144 RxAcceptLenErr = 0x04000000, 145 RxAcceptLong = 0x08000000, 146 RxAcceptTx = 0x10000000, 147 RxStripCRC = 0x20000000, 148 RxAcceptRunt = 0x40000000, 149 RxAcceptErr = 0x80000000, 150 }; 151 152 /* Bits in the RxMode register. */ 153 enum rx_mode_bits { 154 RxFilterEnable = 0x80000000, 155 AcceptAllBroadcast = 0x40000000, 156 AcceptAllMulticast = 0x20000000, 157 AcceptAllUnicast = 0x10000000, 158 AcceptPerfectMatch = 0x08000000, 159 }; 160 161 typedef struct _BufferDesc { 162 u32 link; 163 u32 bufptr; 164 vu_long cmdsts; 165 u32 extsts; /*not used here */ 166 } BufferDesc; 167 168 /* Bits in network_desc.status */ 169 enum desc_status_bits { 170 DescOwn = 0x80000000, DescMore = 0x40000000, DescIntr = 0x20000000, 171 DescNoCRC = 0x10000000, DescPktOK = 0x08000000, 172 DescSizeMask = 0xfff, 173 174 DescTxAbort = 0x04000000, DescTxFIFO = 0x02000000, 175 DescTxCarrier = 0x01000000, DescTxDefer = 0x00800000, 176 DescTxExcDefer = 0x00400000, DescTxOOWCol = 0x00200000, 177 DescTxExcColl = 0x00100000, DescTxCollCount = 0x000f0000, 178 179 DescRxAbort = 0x04000000, DescRxOver = 0x02000000, 180 DescRxDest = 0x01800000, DescRxLong = 0x00400000, 181 DescRxRunt = 0x00200000, DescRxInvalid = 0x00100000, 182 DescRxCRC = 0x00080000, DescRxAlign = 0x00040000, 183 DescRxLoop = 0x00020000, DesRxColl = 0x00010000, 184 }; 185 186 /* Bits in MEAR */ 187 enum mii_reg_bits { 188 MDIO_ShiftClk = 0x0040, 189 MDIO_EnbOutput = 0x0020, 190 MDIO_Data = 0x0010, 191 }; 192 193 /* PHY Register offsets. */ 194 enum phy_reg_offsets { 195 BMCR = 0x00, 196 BMSR = 0x01, 197 PHYIDR1 = 0x02, 198 PHYIDR2 = 0x03, 199 ANAR = 0x04, 200 KTCR = 0x09, 201 }; 202 203 /* basic mode control register bits */ 204 enum bmcr_bits { 205 Bmcr_Reset = 0x8000, 206 Bmcr_Loop = 0x4000, 207 Bmcr_Speed0 = 0x2000, 208 Bmcr_AutoNegEn = 0x1000, /*if set ignores Duplex, Speed[01] */ 209 Bmcr_RstAutoNeg = 0x0200, 210 Bmcr_Duplex = 0x0100, 211 Bmcr_Speed1 = 0x0040, 212 Bmcr_Force10H = 0x0000, 213 Bmcr_Force10F = 0x0100, 214 Bmcr_Force100H = 0x2000, 215 Bmcr_Force100F = 0x2100, 216 Bmcr_Force1000H = 0x0040, 217 Bmcr_Force1000F = 0x0140, 218 }; 219 220 /* auto negotiation advertisement register */ 221 enum anar_bits { 222 anar_adv_100F = 0x0100, 223 anar_adv_100H = 0x0080, 224 anar_adv_10F = 0x0040, 225 anar_adv_10H = 0x0020, 226 anar_ieee_8023 = 0x0001, 227 }; 228 229 /* 1K-base T control register */ 230 enum ktcr_bits { 231 ktcr_adv_1000H = 0x0100, 232 ktcr_adv_1000F = 0x0200, 233 }; 234 235 /* Globals */ 236 static u32 SavedClkRun; 237 static unsigned int cur_rx; 238 static unsigned int rx_config; 239 static unsigned int tx_config; 240 241 /* Note: transmit and receive buffers and descriptors must be 242 long long word aligned */ 243 static BufferDesc txd __attribute__ ((aligned(8))); 244 static BufferDesc rxd[NUM_RX_DESC] __attribute__ ((aligned(8))); 245 static unsigned char txb[TX_BUF_SIZE] __attribute__ ((aligned(8))); 246 static unsigned char rxb[NUM_RX_DESC * RX_BUF_SIZE] 247 __attribute__ ((aligned(8))); 248 249 /* Function Prototypes */ 250 static int mdio_read(struct eth_device *dev, int phy_id, int addr); 251 static void mdio_write(struct eth_device *dev, int phy_id, int addr, int value); 252 static void mdio_sync(struct eth_device *dev, u32 offset); 253 static int ns8382x_init(struct eth_device *dev, bd_t * bis); 254 static void ns8382x_reset(struct eth_device *dev); 255 static void ns8382x_init_rxfilter(struct eth_device *dev); 256 static void ns8382x_init_txd(struct eth_device *dev); 257 static void ns8382x_init_rxd(struct eth_device *dev); 258 static void ns8382x_set_rx_mode(struct eth_device *dev); 259 static void ns8382x_check_duplex(struct eth_device *dev); 260 static int ns8382x_send(struct eth_device *dev, volatile void *packet, 261 int length); 262 static int ns8382x_poll(struct eth_device *dev); 263 static void ns8382x_disable(struct eth_device *dev); 264 265 static struct pci_device_id supported[] = { 266 {PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_83820}, 267 {} 268 }; 269 270 #define bus_to_phys(a) pci_mem_to_phys((pci_dev_t)dev->priv, a) 271 #define phys_to_bus(a) pci_phys_to_mem((pci_dev_t)dev->priv, a) 272 273 static inline int 274 INW(struct eth_device *dev, u_long addr) 275 { 276 return le16_to_cpu(*(vu_short *) (addr + dev->iobase)); 277 } 278 279 static int 280 INL(struct eth_device *dev, u_long addr) 281 { 282 return le32_to_cpu(*(vu_long *) (addr + dev->iobase)); 283 } 284 285 static inline void 286 OUTW(struct eth_device *dev, int command, u_long addr) 287 { 288 *(vu_short *) ((addr + dev->iobase)) = cpu_to_le16(command); 289 } 290 291 static inline void 292 OUTL(struct eth_device *dev, int command, u_long addr) 293 { 294 *(vu_long *) ((addr + dev->iobase)) = cpu_to_le32(command); 295 } 296 297 /* Function: ns8382x_initialize 298 * Description: Retrieves the MAC address of the card, and sets up some 299 * globals required by other routines, and initializes the NIC, making it 300 * ready to send and receive packets. 301 * Side effects: initializes ns8382xs, ready to recieve packets. 302 * Returns: int: number of cards found 303 */ 304 305 int 306 ns8382x_initialize(bd_t * bis) 307 { 308 pci_dev_t devno; 309 int card_number = 0; 310 struct eth_device *dev; 311 u32 iobase, status; 312 int i, idx = 0; 313 u32 phyAddress; 314 u32 tmp; 315 u32 chip_config; 316 317 while (1) { /* Find PCI device(s) */ 318 if ((devno = pci_find_devices(supported, idx++)) < 0) 319 break; 320 321 pci_read_config_dword(devno, PCI_BASE_ADDRESS_1, &iobase); 322 iobase &= ~0x3; /* 1: unused and 0:I/O Space Indicator */ 323 324 #ifdef NS8382X_DEBUG 325 printf("ns8382x: NatSemi dp8382x @ 0x%x\n", iobase); 326 #endif 327 328 pci_write_config_dword(devno, PCI_COMMAND, 329 PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER); 330 331 /* Check if I/O accesses and Bus Mastering are enabled. */ 332 pci_read_config_dword(devno, PCI_COMMAND, &status); 333 if (!(status & PCI_COMMAND_MEMORY)) { 334 printf("Error: Can not enable MEM access.\n"); 335 continue; 336 } else if (!(status & PCI_COMMAND_MASTER)) { 337 printf("Error: Can not enable Bus Mastering.\n"); 338 continue; 339 } 340 341 dev = (struct eth_device *) malloc(sizeof *dev); 342 343 sprintf(dev->name, "dp8382x#%d", card_number); 344 dev->iobase = bus_to_phys(iobase); 345 dev->priv = (void *) devno; 346 dev->init = ns8382x_init; 347 dev->halt = ns8382x_disable; 348 dev->send = ns8382x_send; 349 dev->recv = ns8382x_poll; 350 351 /* ns8382x has a non-standard PM control register 352 * in PCI config space. Some boards apparently need 353 * to be brought to D0 in this manner. */ 354 pci_read_config_dword(devno, PCIPM, &tmp); 355 if (tmp & (0x03 | 0x100)) { /* D0 state, disable PME assertion */ 356 u32 newtmp = tmp & ~(0x03 | 0x100); 357 pci_write_config_dword(devno, PCIPM, newtmp); 358 } 359 360 /* get MAC address */ 361 for (i = 0; i < 3; i++) { 362 u32 data; 363 char *mac = (char *)&dev->enetaddr[i * 2]; 364 365 OUTL(dev, i * 2, RxFilterAddr); 366 data = INL(dev, RxFilterData); 367 *mac++ = data; 368 *mac++ = data >> 8; 369 } 370 /* get PHY address, can't be zero */ 371 for (phyAddress = 1; phyAddress < 32; phyAddress++) { 372 u32 rev, phy1; 373 374 phy1 = mdio_read(dev, phyAddress, PHYIDR1); 375 if (phy1 == 0x2000) { /*check for 83861/91 */ 376 rev = mdio_read(dev, phyAddress, PHYIDR2); 377 if ((rev & ~(0x000f)) == 0x00005c50 || 378 (rev & ~(0x000f)) == 0x00005c60) { 379 #ifdef NS8382X_DEBUG 380 printf("phy rev is %x\n", rev); 381 printf("phy address is %x\n", 382 phyAddress); 383 #endif 384 break; 385 } 386 } 387 } 388 389 /* set phy to autonegotiate && advertise everything */ 390 mdio_write(dev, phyAddress, KTCR, 391 (ktcr_adv_1000H | ktcr_adv_1000F)); 392 mdio_write(dev, phyAddress, ANAR, 393 (anar_adv_100F | anar_adv_100H | anar_adv_10H | 394 anar_adv_10F | anar_ieee_8023)); 395 mdio_write(dev, phyAddress, BMCR, 0x0); /*restore */ 396 mdio_write(dev, phyAddress, BMCR, 397 (Bmcr_AutoNegEn | Bmcr_RstAutoNeg)); 398 /* Reset the chip to erase any previous misconfiguration. */ 399 OUTL(dev, (ChipReset), ChipCmd); 400 401 chip_config = INL(dev, ChipConfig); 402 /* reset the phy */ 403 OUTL(dev, (chip_config | PhyRst), ChipConfig); 404 /* power up and initialize transceiver */ 405 OUTL(dev, (chip_config & ~(PhyDis)), ChipConfig); 406 407 mdio_sync(dev, EECtrl); 408 #ifdef NS8382X_DEBUG 409 { 410 u32 chpcfg = 411 INL(dev, ChipConfig) ^ SpeedStatus_Polarity; 412 413 printf("%s: Transceiver 10%s %s duplex.\n", dev->name, 414 (chpcfg & GigSpeed) ? "00" : (chpcfg & HundSpeed) 415 ? "0" : "", 416 chpcfg & FullDuplex ? "full" : "half"); 417 printf("%s: %02x:%02x:%02x:%02x:%02x:%02x\n", dev->name, 418 dev->enetaddr[0], dev->enetaddr[1], 419 dev->enetaddr[2], dev->enetaddr[3], 420 dev->enetaddr[4], dev->enetaddr[5]); 421 } 422 #endif 423 /* Disable PME: 424 * The PME bit is initialized from the EEPROM contents. 425 * PCI cards probably have PME disabled, but motherboard 426 * implementations may have PME set to enable WakeOnLan. 427 * With PME set the chip will scan incoming packets but 428 * nothing will be written to memory. */ 429 SavedClkRun = INL(dev, ClkRun); 430 OUTL(dev, SavedClkRun & ~0x100, ClkRun); 431 432 eth_register(dev); 433 434 card_number++; 435 436 pci_write_config_byte(devno, PCI_LATENCY_TIMER, 0x60); 437 438 udelay(10 * 1000); 439 } 440 return card_number; 441 } 442 443 /* MII transceiver control section. 444 Read and write MII registers using software-generated serial MDIO 445 protocol. See the MII specifications or DP83840A data sheet for details. 446 447 The maximum data clock rate is 2.5 Mhz. To meet minimum timing we 448 must flush writes to the PCI bus with a PCI read. */ 449 #define mdio_delay(mdio_addr) INL(dev, mdio_addr) 450 451 #define MDIO_EnbIn (0) 452 #define MDIO_WRITE0 (MDIO_EnbOutput) 453 #define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput) 454 455 /* Generate the preamble required for initial synchronization and 456 a few older transceivers. */ 457 static void 458 mdio_sync(struct eth_device *dev, u32 offset) 459 { 460 int bits = 32; 461 462 /* Establish sync by sending at least 32 logic ones. */ 463 while (--bits >= 0) { 464 OUTL(dev, MDIO_WRITE1, offset); 465 mdio_delay(offset); 466 OUTL(dev, MDIO_WRITE1 | MDIO_ShiftClk, offset); 467 mdio_delay(offset); 468 } 469 } 470 471 static int 472 mdio_read(struct eth_device *dev, int phy_id, int addr) 473 { 474 int mii_cmd = (0xf6 << 10) | (phy_id << 5) | addr; 475 int i, retval = 0; 476 477 /* Shift the read command bits out. */ 478 for (i = 15; i >= 0; i--) { 479 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0; 480 481 OUTL(dev, dataval, EECtrl); 482 mdio_delay(EECtrl); 483 OUTL(dev, dataval | MDIO_ShiftClk, EECtrl); 484 mdio_delay(EECtrl); 485 } 486 /* Read the two transition, 16 data, and wire-idle bits. */ 487 for (i = 19; i > 0; i--) { 488 OUTL(dev, MDIO_EnbIn, EECtrl); 489 mdio_delay(EECtrl); 490 retval = 491 (retval << 1) | ((INL(dev, EECtrl) & MDIO_Data) ? 1 : 0); 492 OUTL(dev, MDIO_EnbIn | MDIO_ShiftClk, EECtrl); 493 mdio_delay(EECtrl); 494 } 495 return (retval >> 1) & 0xffff; 496 } 497 498 static void 499 mdio_write(struct eth_device *dev, int phy_id, int addr, int value) 500 { 501 int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (addr << 18) | value; 502 int i; 503 504 /* Shift the command bits out. */ 505 for (i = 31; i >= 0; i--) { 506 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0; 507 508 OUTL(dev, dataval, EECtrl); 509 mdio_delay(EECtrl); 510 OUTL(dev, dataval | MDIO_ShiftClk, EECtrl); 511 mdio_delay(EECtrl); 512 } 513 /* Clear out extra bits. */ 514 for (i = 2; i > 0; i--) { 515 OUTL(dev, MDIO_EnbIn, EECtrl); 516 mdio_delay(EECtrl); 517 OUTL(dev, MDIO_EnbIn | MDIO_ShiftClk, EECtrl); 518 mdio_delay(EECtrl); 519 } 520 return; 521 } 522 523 /* Function: ns8382x_init 524 * Description: resets the ethernet controller chip and configures 525 * registers and data structures required for sending and receiving packets. 526 * Arguments: struct eth_device *dev: NIC data structure 527 * returns: int. 528 */ 529 530 static int 531 ns8382x_init(struct eth_device *dev, bd_t * bis) 532 { 533 u32 config; 534 535 ns8382x_reset(dev); 536 537 /* Disable PME: 538 * The PME bit is initialized from the EEPROM contents. 539 * PCI cards probably have PME disabled, but motherboard 540 * implementations may have PME set to enable WakeOnLan. 541 * With PME set the chip will scan incoming packets but 542 * nothing will be written to memory. */ 543 OUTL(dev, SavedClkRun & ~0x100, ClkRun); 544 545 ns8382x_init_rxfilter(dev); 546 ns8382x_init_txd(dev); 547 ns8382x_init_rxd(dev); 548 549 /*set up ChipConfig */ 550 config = INL(dev, ChipConfig); 551 /*turn off 64 bit ops && Ten-bit interface 552 * && big-endian mode && extended status */ 553 config &= ~(TBIEn | Mode1000 | T64En | D64En | M64En | BEMode | PhyDis | ExtStEn); 554 OUTL(dev, config, ChipConfig); 555 556 /* Configure the PCI bus bursts and FIFO thresholds. */ 557 tx_config = TxCarrierIgn | TxHeartIgn | TxAutoPad 558 | TxCollRetry | TxMxdma_1024 | (0x1002); 559 rx_config = RxMxdma_1024 | 0x20; 560 #ifdef NS8382X_DEBUG 561 printf("%s: Setting TxConfig Register %#08X\n", dev->name, tx_config); 562 printf("%s: Setting RxConfig Register %#08X\n", dev->name, rx_config); 563 #endif 564 OUTL(dev, tx_config, TxConfig); 565 OUTL(dev, rx_config, RxConfig); 566 567 /*turn off priority queueing */ 568 OUTL(dev, 0x0, PriQueue); 569 570 ns8382x_check_duplex(dev); 571 ns8382x_set_rx_mode(dev); 572 573 OUTL(dev, (RxOn | TxOn), ChipCmd); 574 return 1; 575 } 576 577 /* Function: ns8382x_reset 578 * Description: soft resets the controller chip 579 * Arguments: struct eth_device *dev: NIC data structure 580 * Returns: void. 581 */ 582 static void 583 ns8382x_reset(struct eth_device *dev) 584 { 585 OUTL(dev, ChipReset, ChipCmd); 586 while (INL(dev, ChipCmd)) 587 /*wait until done */ ; 588 OUTL(dev, 0, IntrMask); 589 OUTL(dev, 0, IntrEnable); 590 } 591 592 /* Function: ns8382x_init_rxfilter 593 * Description: sets receive filter address to our MAC address 594 * Arguments: struct eth_device *dev: NIC data structure 595 * returns: void. 596 */ 597 598 static void 599 ns8382x_init_rxfilter(struct eth_device *dev) 600 { 601 int i; 602 603 for (i = 0; i < ETH_ALEN; i += 2) { 604 OUTL(dev, i, RxFilterAddr); 605 OUTW(dev, dev->enetaddr[i] + (dev->enetaddr[i + 1] << 8), 606 RxFilterData); 607 } 608 } 609 610 /* Function: ns8382x_init_txd 611 * Description: initializes the Tx descriptor 612 * Arguments: struct eth_device *dev: NIC data structure 613 * returns: void. 614 */ 615 616 static void 617 ns8382x_init_txd(struct eth_device *dev) 618 { 619 txd.link = (u32) 0; 620 txd.bufptr = cpu_to_le32((u32) & txb[0]); 621 txd.cmdsts = (u32) 0; 622 txd.extsts = (u32) 0; 623 624 OUTL(dev, 0x0, TxRingPtrHi); 625 OUTL(dev, phys_to_bus((u32)&txd), TxRingPtr); 626 #ifdef NS8382X_DEBUG 627 printf("ns8382x_init_txd: TX descriptor register loaded with: %#08X (&txd: %p)\n", 628 INL(dev, TxRingPtr), &txd); 629 #endif 630 } 631 632 /* Function: ns8382x_init_rxd 633 * Description: initializes the Rx descriptor ring 634 * Arguments: struct eth_device *dev: NIC data structure 635 * Returns: void. 636 */ 637 638 static void 639 ns8382x_init_rxd(struct eth_device *dev) 640 { 641 int i; 642 643 OUTL(dev, 0x0, RxRingPtrHi); 644 645 cur_rx = 0; 646 for (i = 0; i < NUM_RX_DESC; i++) { 647 rxd[i].link = 648 cpu_to_le32((i + 1 < 649 NUM_RX_DESC) ? (u32) & rxd[i + 650 1] : (u32) & 651 rxd[0]); 652 rxd[i].extsts = cpu_to_le32((u32) 0x0); 653 rxd[i].cmdsts = cpu_to_le32((u32) RX_BUF_SIZE); 654 rxd[i].bufptr = cpu_to_le32((u32) & rxb[i * RX_BUF_SIZE]); 655 #ifdef NS8382X_DEBUG 656 printf 657 ("ns8382x_init_rxd: rxd[%d]=%p link=%X cmdsts=%X bufptr=%X\n", 658 i, &rxd[i], le32_to_cpu(rxd[i].link), 659 le32_to_cpu(rxd[i].cmdsts), le32_to_cpu(rxd[i].bufptr)); 660 #endif 661 } 662 OUTL(dev, phys_to_bus((u32) & rxd), RxRingPtr); 663 664 #ifdef NS8382X_DEBUG 665 printf("ns8382x_init_rxd: RX descriptor register loaded with: %X\n", 666 INL(dev, RxRingPtr)); 667 #endif 668 } 669 670 /* Function: ns8382x_set_rx_mode 671 * Description: 672 * sets the receive mode to accept all broadcast packets and packets 673 * with our MAC address, and reject all multicast packets. 674 * Arguments: struct eth_device *dev: NIC data structure 675 * Returns: void. 676 */ 677 678 static void 679 ns8382x_set_rx_mode(struct eth_device *dev) 680 { 681 u32 rx_mode = 0x0; 682 /*spec says RxFilterEnable has to be 0 for rest of 683 * this stuff to be properly configured. Linux driver 684 * seems to support this*/ 685 /* OUTL(dev, rx_mode, RxFilterAddr);*/ 686 rx_mode = (RxFilterEnable | AcceptAllBroadcast | AcceptPerfectMatch); 687 OUTL(dev, rx_mode, RxFilterAddr); 688 printf("ns8382x_set_rx_mode: set to %X\n", rx_mode); 689 /*now we turn RxFilterEnable back on */ 690 /*rx_mode |= RxFilterEnable; 691 OUTL(dev, rx_mode, RxFilterAddr);*/ 692 } 693 694 static void 695 ns8382x_check_duplex(struct eth_device *dev) 696 { 697 int gig = 0; 698 int hun = 0; 699 int duplex = 0; 700 int config = (INL(dev, ChipConfig) ^ SpeedStatus_Polarity); 701 702 duplex = (config & FullDuplex) ? 1 : 0; 703 gig = (config & GigSpeed) ? 1 : 0; 704 hun = (config & HundSpeed) ? 1 : 0; 705 #ifdef NS8382X_DEBUG 706 printf("%s: Setting 10%s %s-duplex based on negotiated link" 707 " capability.\n", dev->name, (gig) ? "00" : (hun) ? "0" : "", 708 duplex ? "full" : "half"); 709 #endif 710 if (duplex) { 711 rx_config |= RxAcceptTx; 712 tx_config |= (TxCarrierIgn | TxHeartIgn); 713 } else { 714 rx_config &= ~RxAcceptTx; 715 tx_config &= ~(TxCarrierIgn | TxHeartIgn); 716 } 717 #ifdef NS8382X_DEBUG 718 printf("%s: Resetting TxConfig Register %#08X\n", dev->name, tx_config); 719 printf("%s: Resetting RxConfig Register %#08X\n", dev->name, rx_config); 720 #endif 721 OUTL(dev, tx_config, TxConfig); 722 OUTL(dev, rx_config, RxConfig); 723 724 /*if speed is 10 or 100, remove MODE1000, 725 * if it's 1000, then set it */ 726 config = INL(dev, ChipConfig); 727 if (gig) 728 config |= Mode1000; 729 else 730 config &= ~Mode1000; 731 732 #ifdef NS8382X_DEBUG 733 printf("%s: %setting Mode1000\n", dev->name, (gig) ? "S" : "Uns"); 734 #endif 735 OUTL(dev, config, ChipConfig); 736 } 737 738 /* Function: ns8382x_send 739 * Description: transmits a packet and waits for completion or timeout. 740 * Returns: void. */ 741 static int 742 ns8382x_send(struct eth_device *dev, volatile void *packet, int length) 743 { 744 u32 i, status = 0; 745 vu_long tx_stat = 0; 746 747 /* Stop the transmitter */ 748 OUTL(dev, TxOff, ChipCmd); 749 #ifdef NS8382X_DEBUG 750 printf("ns8382x_send: sending %d bytes\n", (int)length); 751 #endif 752 753 /* set the transmit buffer descriptor and enable Transmit State Machine */ 754 txd.link = cpu_to_le32(0x0); 755 txd.bufptr = cpu_to_le32(phys_to_bus((u32)packet)); 756 txd.extsts = cpu_to_le32(0x0); 757 txd.cmdsts = cpu_to_le32(DescOwn | length); 758 759 /* load Transmit Descriptor Register */ 760 OUTL(dev, phys_to_bus((u32) & txd), TxRingPtr); 761 #ifdef NS8382X_DEBUG 762 printf("ns8382x_send: TX descriptor register loaded with: %#08X\n", 763 INL(dev, TxRingPtr)); 764 printf("\ttxd.link:%X\tbufp:%X\texsts:%X\tcmdsts:%X\n", 765 le32_to_cpu(txd.link), le32_to_cpu(txd.bufptr), 766 le32_to_cpu(txd.extsts), le32_to_cpu(txd.cmdsts)); 767 #endif 768 /* restart the transmitter */ 769 OUTL(dev, TxOn, ChipCmd); 770 771 for (i = 0; (tx_stat = le32_to_cpu(txd.cmdsts)) & DescOwn; i++) { 772 if (i >= TOUT_LOOP) { 773 printf ("%s: tx error buffer not ready: txd.cmdsts %#X\n", 774 dev->name, tx_stat); 775 goto Done; 776 } 777 } 778 779 if (!(tx_stat & DescPktOK)) { 780 printf("ns8382x_send: Transmit error, Tx status %X.\n", tx_stat); 781 goto Done; 782 } 783 #ifdef NS8382X_DEBUG 784 printf("ns8382x_send: tx_stat: %#08X\n", tx_stat); 785 #endif 786 787 status = 1; 788 Done: 789 return status; 790 } 791 792 /* Function: ns8382x_poll 793 * Description: checks for a received packet and returns it if found. 794 * Arguments: struct eth_device *dev: NIC data structure 795 * Returns: 1 if packet was received. 796 * 0 if no packet was received. 797 * Side effects: 798 * Returns (copies) the packet to the array dev->packet. 799 * Returns the length of the packet. 800 */ 801 802 static int 803 ns8382x_poll(struct eth_device *dev) 804 { 805 int retstat = 0; 806 int length = 0; 807 vu_long rx_status = le32_to_cpu(rxd[cur_rx].cmdsts); 808 809 if (!(rx_status & (u32) DescOwn)) 810 return retstat; 811 #ifdef NS8382X_DEBUG 812 printf("ns8382x_poll: got a packet: cur_rx:%u, status:%lx\n", 813 cur_rx, rx_status); 814 #endif 815 length = (rx_status & DSIZE) - CRC_SIZE; 816 817 if ((rx_status & (DescMore | DescPktOK | DescRxLong)) != DescPktOK) { 818 /* corrupted packet received */ 819 printf("ns8382x_poll: Corrupted packet, status:%lx\n", rx_status); 820 retstat = 0; 821 } else { 822 /* give packet to higher level routine */ 823 NetReceive((rxb + cur_rx * RX_BUF_SIZE), length); 824 retstat = 1; 825 } 826 827 /* return the descriptor and buffer to receive ring */ 828 rxd[cur_rx].cmdsts = cpu_to_le32(RX_BUF_SIZE); 829 rxd[cur_rx].bufptr = cpu_to_le32((u32) & rxb[cur_rx * RX_BUF_SIZE]); 830 831 if (++cur_rx == NUM_RX_DESC) 832 cur_rx = 0; 833 834 /* re-enable the potentially idle receive state machine */ 835 OUTL(dev, RxOn, ChipCmd); 836 837 return retstat; 838 } 839 840 /* Function: ns8382x_disable 841 * Description: Turns off interrupts and stops Tx and Rx engines 842 * Arguments: struct eth_device *dev: NIC data structure 843 * Returns: void. 844 */ 845 846 static void 847 ns8382x_disable(struct eth_device *dev) 848 { 849 /* Disable interrupts using the mask. */ 850 OUTL(dev, 0, IntrMask); 851 OUTL(dev, 0, IntrEnable); 852 853 /* Stop the chip's Tx and Rx processes. */ 854 OUTL(dev, (RxOff | TxOff), ChipCmd); 855 856 /* Restore PME enable bit */ 857 OUTL(dev, SavedClkRun, ClkRun); 858 } 859