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 <netdev.h>
57 #include <asm/io.h>
58 #include <pci.h>
59
60 /* defines */
61 #define DSIZE 0x00000FFF
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, void *packet, int length);
261 static int ns8382x_poll(struct eth_device *dev);
262 static void ns8382x_disable(struct eth_device *dev);
263
264 static struct pci_device_id supported[] = {
265 {PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_83820},
266 {}
267 };
268
269 #define bus_to_phys(a) pci_mem_to_phys((pci_dev_t)dev->priv, a)
270 #define phys_to_bus(a) pci_phys_to_mem((pci_dev_t)dev->priv, a)
271
272 static inline int
INW(struct eth_device * dev,u_long addr)273 INW(struct eth_device *dev, u_long addr)
274 {
275 return le16_to_cpu(*(vu_short *) (addr + dev->iobase));
276 }
277
278 static int
INL(struct eth_device * dev,u_long addr)279 INL(struct eth_device *dev, u_long addr)
280 {
281 return le32_to_cpu(*(vu_long *) (addr + dev->iobase));
282 }
283
284 static inline void
OUTW(struct eth_device * dev,int command,u_long addr)285 OUTW(struct eth_device *dev, int command, u_long addr)
286 {
287 *(vu_short *) ((addr + dev->iobase)) = cpu_to_le16(command);
288 }
289
290 static inline void
OUTL(struct eth_device * dev,int command,u_long addr)291 OUTL(struct eth_device *dev, int command, u_long addr)
292 {
293 *(vu_long *) ((addr + dev->iobase)) = cpu_to_le32(command);
294 }
295
296 /* Function: ns8382x_initialize
297 * Description: Retrieves the MAC address of the card, and sets up some
298 * globals required by other routines, and initializes the NIC, making it
299 * ready to send and receive packets.
300 * Side effects: initializes ns8382xs, ready to receive packets.
301 * Returns: int: number of cards found
302 */
303
304 int
ns8382x_initialize(bd_t * bis)305 ns8382x_initialize(bd_t * bis)
306 {
307 pci_dev_t devno;
308 int card_number = 0;
309 struct eth_device *dev;
310 u32 iobase, status;
311 int i, idx = 0;
312 u32 phyAddress;
313 u32 tmp;
314 u32 chip_config;
315
316 while (1) { /* Find PCI device(s) */
317 if ((devno = pci_find_devices(supported, idx++)) < 0)
318 break;
319
320 pci_read_config_dword(devno, PCI_BASE_ADDRESS_1, &iobase);
321 iobase &= ~0x3; /* 1: unused and 0:I/O Space Indicator */
322
323 debug("ns8382x: NatSemi dp8382x @ 0x%x\n", iobase);
324
325 pci_write_config_dword(devno, PCI_COMMAND,
326 PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
327
328 /* Check if I/O accesses and Bus Mastering are enabled. */
329 pci_read_config_dword(devno, PCI_COMMAND, &status);
330 if (!(status & PCI_COMMAND_MEMORY)) {
331 printf("Error: Can not enable MEM access.\n");
332 continue;
333 } else if (!(status & PCI_COMMAND_MASTER)) {
334 printf("Error: Can not enable Bus Mastering.\n");
335 continue;
336 }
337
338 dev = (struct eth_device *) malloc(sizeof *dev);
339 if (!dev) {
340 printf("ns8382x: Can not allocate memory\n");
341 break;
342 }
343 memset(dev, 0, sizeof(*dev));
344
345 sprintf(dev->name, "dp8382x#%d", card_number);
346 dev->iobase = bus_to_phys(iobase);
347 dev->priv = (void *) devno;
348 dev->init = ns8382x_init;
349 dev->halt = ns8382x_disable;
350 dev->send = ns8382x_send;
351 dev->recv = ns8382x_poll;
352
353 /* ns8382x has a non-standard PM control register
354 * in PCI config space. Some boards apparently need
355 * to be brought to D0 in this manner. */
356 pci_read_config_dword(devno, PCIPM, &tmp);
357 if (tmp & (0x03 | 0x100)) { /* D0 state, disable PME assertion */
358 u32 newtmp = tmp & ~(0x03 | 0x100);
359 pci_write_config_dword(devno, PCIPM, newtmp);
360 }
361
362 /* get MAC address */
363 for (i = 0; i < 3; i++) {
364 u32 data;
365 char *mac = (char *)&dev->enetaddr[i * 2];
366
367 OUTL(dev, i * 2, RxFilterAddr);
368 data = INL(dev, RxFilterData);
369 *mac++ = data;
370 *mac++ = data >> 8;
371 }
372 /* get PHY address, can't be zero */
373 for (phyAddress = 1; phyAddress < 32; phyAddress++) {
374 u32 rev, phy1;
375
376 phy1 = mdio_read(dev, phyAddress, PHYIDR1);
377 if (phy1 == 0x2000) { /*check for 83861/91 */
378 rev = mdio_read(dev, phyAddress, PHYIDR2);
379 if ((rev & ~(0x000f)) == 0x00005c50 ||
380 (rev & ~(0x000f)) == 0x00005c60) {
381 debug("phy rev is %x\n", rev);
382 debug("phy address is %x\n",
383 phyAddress);
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
409 {
410 u32 chpcfg =
411 INL(dev, ChipConfig) ^ SpeedStatus_Polarity;
412
413 debug("%s: Transceiver 10%s %s duplex.\n", dev->name,
414 (chpcfg & GigSpeed) ? "00" : (chpcfg & HundSpeed)
415 ? "0" : "",
416 chpcfg & FullDuplex ? "full" : "half");
417 debug("%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
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
mdio_sync(struct eth_device * dev,u32 offset)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
mdio_read(struct eth_device * dev,int phy_id,int addr)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
mdio_write(struct eth_device * dev,int phy_id,int addr,int value)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
ns8382x_init(struct eth_device * dev,bd_t * bis)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
561 debug("%s: Setting TxConfig Register %#08X\n", dev->name, tx_config);
562 debug("%s: Setting RxConfig Register %#08X\n", dev->name, rx_config);
563
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
ns8382x_reset(struct eth_device * dev)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
ns8382x_init_rxfilter(struct eth_device * dev)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
ns8382x_init_txd(struct eth_device * dev)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
627 debug("ns8382x_init_txd: TX descriptor register loaded with: %#08X (&txd: %p)\n",
628 INL(dev, TxRingPtr), &txd);
629 }
630
631 /* Function: ns8382x_init_rxd
632 * Description: initializes the Rx descriptor ring
633 * Arguments: struct eth_device *dev: NIC data structure
634 * Returns: void.
635 */
636
637 static void
ns8382x_init_rxd(struct eth_device * dev)638 ns8382x_init_rxd(struct eth_device *dev)
639 {
640 int i;
641
642 OUTL(dev, 0x0, RxRingPtrHi);
643
644 cur_rx = 0;
645 for (i = 0; i < NUM_RX_DESC; i++) {
646 rxd[i].link =
647 cpu_to_le32((i + 1 <
648 NUM_RX_DESC) ? (u32) & rxd[i +
649 1] : (u32) &
650 rxd[0]);
651 rxd[i].extsts = cpu_to_le32((u32) 0x0);
652 rxd[i].cmdsts = cpu_to_le32((u32) RX_BUF_SIZE);
653 rxd[i].bufptr = cpu_to_le32((u32) & rxb[i * RX_BUF_SIZE]);
654
655 debug
656 ("ns8382x_init_rxd: rxd[%d]=%p link=%X cmdsts=%X bufptr=%X\n",
657 i, &rxd[i], le32_to_cpu(rxd[i].link),
658 le32_to_cpu(rxd[i].cmdsts), le32_to_cpu(rxd[i].bufptr));
659 }
660 OUTL(dev, phys_to_bus((u32) & rxd), RxRingPtr);
661
662 debug("ns8382x_init_rxd: RX descriptor register loaded with: %X\n",
663 INL(dev, RxRingPtr));
664 }
665
666 /* Function: ns8382x_set_rx_mode
667 * Description:
668 * sets the receive mode to accept all broadcast packets and packets
669 * with our MAC address, and reject all multicast packets.
670 * Arguments: struct eth_device *dev: NIC data structure
671 * Returns: void.
672 */
673
674 static void
ns8382x_set_rx_mode(struct eth_device * dev)675 ns8382x_set_rx_mode(struct eth_device *dev)
676 {
677 u32 rx_mode = 0x0;
678 /*spec says RxFilterEnable has to be 0 for rest of
679 * this stuff to be properly configured. Linux driver
680 * seems to support this*/
681 /* OUTL(dev, rx_mode, RxFilterAddr);*/
682 rx_mode = (RxFilterEnable | AcceptAllBroadcast | AcceptPerfectMatch);
683 OUTL(dev, rx_mode, RxFilterAddr);
684 printf("ns8382x_set_rx_mode: set to %X\n", rx_mode);
685 /*now we turn RxFilterEnable back on */
686 /*rx_mode |= RxFilterEnable;
687 OUTL(dev, rx_mode, RxFilterAddr);*/
688 }
689
690 static void
ns8382x_check_duplex(struct eth_device * dev)691 ns8382x_check_duplex(struct eth_device *dev)
692 {
693 int gig = 0;
694 int hun = 0;
695 int duplex = 0;
696 int config = (INL(dev, ChipConfig) ^ SpeedStatus_Polarity);
697
698 duplex = (config & FullDuplex) ? 1 : 0;
699 gig = (config & GigSpeed) ? 1 : 0;
700 hun = (config & HundSpeed) ? 1 : 0;
701
702 debug("%s: Setting 10%s %s-duplex based on negotiated link"
703 " capability.\n", dev->name, (gig) ? "00" : (hun) ? "0" : "",
704 duplex ? "full" : "half");
705
706 if (duplex) {
707 rx_config |= RxAcceptTx;
708 tx_config |= (TxCarrierIgn | TxHeartIgn);
709 } else {
710 rx_config &= ~RxAcceptTx;
711 tx_config &= ~(TxCarrierIgn | TxHeartIgn);
712 }
713
714 debug("%s: Resetting TxConfig Register %#08X\n", dev->name, tx_config);
715 debug("%s: Resetting RxConfig Register %#08X\n", dev->name, rx_config);
716
717 OUTL(dev, tx_config, TxConfig);
718 OUTL(dev, rx_config, RxConfig);
719
720 /*if speed is 10 or 100, remove MODE1000,
721 * if it's 1000, then set it */
722 config = INL(dev, ChipConfig);
723 if (gig)
724 config |= Mode1000;
725 else
726 config &= ~Mode1000;
727
728 debug("%s: %setting Mode1000\n", dev->name, (gig) ? "S" : "Uns");
729
730 OUTL(dev, config, ChipConfig);
731 }
732
733 /* Function: ns8382x_send
734 * Description: transmits a packet and waits for completion or timeout.
735 * Returns: void. */
ns8382x_send(struct eth_device * dev,void * packet,int length)736 static int ns8382x_send(struct eth_device *dev, void *packet, int length)
737 {
738 u32 i, status = 0;
739 vu_long tx_stat = 0;
740
741 /* Stop the transmitter */
742 OUTL(dev, TxOff, ChipCmd);
743
744 debug("ns8382x_send: sending %d bytes\n", (int)length);
745
746 /* set the transmit buffer descriptor and enable Transmit State Machine */
747 txd.link = cpu_to_le32(0x0);
748 txd.bufptr = cpu_to_le32(phys_to_bus((u32)packet));
749 txd.extsts = cpu_to_le32(0x0);
750 txd.cmdsts = cpu_to_le32(DescOwn | length);
751
752 /* load Transmit Descriptor Register */
753 OUTL(dev, phys_to_bus((u32) & txd), TxRingPtr);
754
755 debug("ns8382x_send: TX descriptor register loaded with: %#08X\n",
756 INL(dev, TxRingPtr));
757 debug("\ttxd.link:%X\tbufp:%X\texsts:%X\tcmdsts:%X\n",
758 le32_to_cpu(txd.link), le32_to_cpu(txd.bufptr),
759 le32_to_cpu(txd.extsts), le32_to_cpu(txd.cmdsts));
760
761 /* restart the transmitter */
762 OUTL(dev, TxOn, ChipCmd);
763
764 for (i = 0; (tx_stat = le32_to_cpu(txd.cmdsts)) & DescOwn; i++) {
765 if (i >= TOUT_LOOP) {
766 printf ("%s: tx error buffer not ready: txd.cmdsts %#lX\n",
767 dev->name, tx_stat);
768 goto Done;
769 }
770 }
771
772 if (!(tx_stat & DescPktOK)) {
773 printf("ns8382x_send: Transmit error, Tx status %lX.\n", tx_stat);
774 goto Done;
775 }
776
777 debug("ns8382x_send: tx_stat: %#08lX\n", tx_stat);
778
779 status = 1;
780 Done:
781 return status;
782 }
783
784 /* Function: ns8382x_poll
785 * Description: checks for a received packet and returns it if found.
786 * Arguments: struct eth_device *dev: NIC data structure
787 * Returns: 1 if packet was received.
788 * 0 if no packet was received.
789 * Side effects:
790 * Returns (copies) the packet to the array dev->packet.
791 * Returns the length of the packet.
792 */
793
794 static int
ns8382x_poll(struct eth_device * dev)795 ns8382x_poll(struct eth_device *dev)
796 {
797 int retstat = 0;
798 int length = 0;
799 vu_long rx_status = le32_to_cpu(rxd[cur_rx].cmdsts);
800
801 if (!(rx_status & (u32) DescOwn))
802 return retstat;
803
804 debug("ns8382x_poll: got a packet: cur_rx:%u, status:%lx\n",
805 cur_rx, rx_status);
806
807 length = (rx_status & DSIZE) - CRC_SIZE;
808
809 if ((rx_status & (DescMore | DescPktOK | DescRxLong)) != DescPktOK) {
810 /* corrupted packet received */
811 printf("ns8382x_poll: Corrupted packet, status:%lx\n",
812 rx_status);
813 retstat = 0;
814 } else {
815 /* give packet to higher level routine */
816 net_process_received_packet((rxb + cur_rx * RX_BUF_SIZE),
817 length);
818 retstat = 1;
819 }
820
821 /* return the descriptor and buffer to receive ring */
822 rxd[cur_rx].cmdsts = cpu_to_le32(RX_BUF_SIZE);
823 rxd[cur_rx].bufptr = cpu_to_le32((u32) & rxb[cur_rx * RX_BUF_SIZE]);
824
825 if (++cur_rx == NUM_RX_DESC)
826 cur_rx = 0;
827
828 /* re-enable the potentially idle receive state machine */
829 OUTL(dev, RxOn, ChipCmd);
830
831 return retstat;
832 }
833
834 /* Function: ns8382x_disable
835 * Description: Turns off interrupts and stops Tx and Rx engines
836 * Arguments: struct eth_device *dev: NIC data structure
837 * Returns: void.
838 */
839
840 static void
ns8382x_disable(struct eth_device * dev)841 ns8382x_disable(struct eth_device *dev)
842 {
843 /* Disable interrupts using the mask. */
844 OUTL(dev, 0, IntrMask);
845 OUTL(dev, 0, IntrEnable);
846
847 /* Stop the chip's Tx and Rx processes. */
848 OUTL(dev, (RxOff | TxOff), ChipCmd);
849
850 /* Restore PME enable bit */
851 OUTL(dev, SavedClkRun, ClkRun);
852 }
853