Merge from Etherboot 5.4
[people/balajirrao/gpxe.git] / src / drivers / net / pcnet32.c
1 /**************************************************************************
2 *
3 *    pcnet32.c -- Etherboot device driver for the AMD PCnet32
4 *    Written 2003-2003 by Timothy Legge <tlegge@rogers.com>
5 *
6 *    This program is free software; you can redistribute it and/or modify
7 *    it under the terms of the GNU General Public License as published by
8 *    the Free Software Foundation; either version 2 of the License, or
9 *    (at your option) any later version.
10 *
11 *    This program is distributed in the hope that it will be useful,
12 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
13 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 *    GNU General Public License for more details.
15 *
16 *    You should have received a copy of the GNU General Public License
17 *    along with this program; if not, write to the Free Software
18 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 *
20 *    Portions of this code based on:
21 *               pcnet32.c: An AMD PCnet32 ethernet driver for linux:
22 *
23 *       (C) 1996-1999 Thomas Bogendoerfer
24 *               See Linux Driver for full information
25 *       
26 *       The transmit and poll functions were written with reference to:
27 *       lance.c - LANCE NIC driver for Etherboot written by Ken Yap 
28 *       
29 *       Linux Driver Version 1.27a, 10.02.2002
30
31
32 *    REVISION HISTORY:
33 *    ================
34 *    v1.0       08-06-2003      timlegge        Initial port of Linux driver
35 *    v1.1       08-23-2003      timlegge        Add multicast support
36 *    v1.2       01-17-2004      timlegge        Initial driver output cleanup
37 *    v1.3       03-29-2004      timlegge        More driver cleanup
38 *    
39 *    Indent Options: indent -kr -i8
40 ***************************************************************************/
41
42 /* to get some global routines like printf */
43 #include "etherboot.h"
44 /* to get the interface to the body of the program */
45 #include "nic.h"
46 /* to get the PCI support functions, if this is a PCI NIC */
47 #include "pci.h"
48 /* Include the time functions */
49 #include "timer.h"
50 #include "mii.h"
51 /* void hex_dump(const char *data, const unsigned int len); */
52
53 /* Etherboot Specific definations */
54 #define drv_version "v1.3"
55 #define drv_date "03-29-2004"
56
57 static u32 ioaddr;              /* Globally used for the card's io address */
58 static struct nic_operations pcnet32_operations;
59 static struct pci_driver pcnet32_driver;
60
61 #ifdef EDEBUG
62 #define dprintf(x) printf x
63 #else
64 #define dprintf(x)
65 #endif
66
67 /* Condensed operations for readability. */
68 #define virt_to_le32desc(addr)  cpu_to_le32(virt_to_bus(addr))
69 #define le32desc_to_virt(addr)  bus_to_virt(le32_to_cpu(addr))
70
71 /* End Etherboot Specific */
72
73 int cards_found /* __initdata */ ;
74
75 #ifdef REMOVE
76 /* FIXME: Remove these they are probably pointless */
77
78 /* 
79  * VLB I/O addresses 
80  */
81 static unsigned int pcnet32_portlist[] /*__initdata */  =
82 { 0x300, 0x320, 0x340, 0x360, 0 };
83
84 static int pcnet32_debug = 1;
85 static int tx_start = 1;        /* Mapping -- 0:20, 1:64, 2:128, 3:~220 (depends on chip vers) */
86 static int pcnet32vlb;          /* check for VLB cards ? */
87
88 static struct net_device *pcnet32_dev;
89
90 static int max_interrupt_work = 80;
91 static int rx_copybreak = 200;
92 #endif
93 #define PCNET32_PORT_AUI      0x00
94 #define PCNET32_PORT_10BT     0x01
95 #define PCNET32_PORT_GPSI     0x02
96 #define PCNET32_PORT_MII      0x03
97
98 #define PCNET32_PORT_PORTSEL  0x03
99 #define PCNET32_PORT_ASEL     0x04
100 #define PCNET32_PORT_100      0x40
101 #define PCNET32_PORT_FD       0x80
102
103 #define PCNET32_DMA_MASK 0xffffffff
104
105 /*
106  * table to translate option values from tulip
107  * to internal options
108  */
109 static unsigned char options_mapping[] = {
110         PCNET32_PORT_ASEL,      /*  0 Auto-select      */
111         PCNET32_PORT_AUI,       /*  1 BNC/AUI          */
112         PCNET32_PORT_AUI,       /*  2 AUI/BNC          */
113         PCNET32_PORT_ASEL,      /*  3 not supported    */
114         PCNET32_PORT_10BT | PCNET32_PORT_FD,    /*  4 10baseT-FD       */
115         PCNET32_PORT_ASEL,      /*  5 not supported    */
116         PCNET32_PORT_ASEL,      /*  6 not supported    */
117         PCNET32_PORT_ASEL,      /*  7 not supported    */
118         PCNET32_PORT_ASEL,      /*  8 not supported    */
119         PCNET32_PORT_MII,       /*  9 MII 10baseT      */
120         PCNET32_PORT_MII | PCNET32_PORT_FD,     /* 10 MII 10baseT-FD   */
121         PCNET32_PORT_MII,       /* 11 MII (autosel)    */
122         PCNET32_PORT_10BT,      /* 12 10BaseT          */
123         PCNET32_PORT_MII | PCNET32_PORT_100,    /* 13 MII 100BaseTx    */
124         PCNET32_PORT_MII | PCNET32_PORT_100 | PCNET32_PORT_FD,  /* 14 MII 100BaseTx-FD */
125         PCNET32_PORT_ASEL       /* 15 not supported    */
126 };
127
128 #define MAX_UNITS 8             /* More are supported, limit only on options */
129 static int options[MAX_UNITS];
130 static int full_duplex[MAX_UNITS];
131
132 /*
133  *                              Theory of Operation
134  * 
135  * This driver uses the same software structure as the normal lance
136  * driver. So look for a verbose description in lance.c. The differences
137  * to the normal lance driver is the use of the 32bit mode of PCnet32
138  * and PCnetPCI chips. Because these chips are 32bit chips, there is no
139  * 16MB limitation and we don't need bounce buffers.
140  */
141
142
143
144 /*
145  * Set the number of Tx and Rx buffers, using Log_2(# buffers).
146  * Reasonable default values are 4 Tx buffers, and 16 Rx buffers.
147  * That translates to 2 (4 == 2^^2) and 4 (16 == 2^^4).
148  */
149 #ifndef PCNET32_LOG_TX_BUFFERS
150 #define PCNET32_LOG_TX_BUFFERS 1
151 #define PCNET32_LOG_RX_BUFFERS 2
152 #endif
153
154 #define TX_RING_SIZE            (1 << (PCNET32_LOG_TX_BUFFERS))
155 #define TX_RING_MOD_MASK        (TX_RING_SIZE - 1)
156 /* FIXME: Fix this to allow multiple tx_ring descriptors */
157 #define TX_RING_LEN_BITS        0x0000  /*PCNET32_LOG_TX_BUFFERS) << 12) */
158
159 #define RX_RING_SIZE            (1 << (PCNET32_LOG_RX_BUFFERS))
160 #define RX_RING_MOD_MASK        (RX_RING_SIZE - 1)
161 #define RX_RING_LEN_BITS        ((PCNET32_LOG_RX_BUFFERS) << 4)
162
163 #define PKT_BUF_SZ              1544
164
165 /* Offsets from base I/O address. */
166 #define PCNET32_WIO_RDP         0x10
167 #define PCNET32_WIO_RAP         0x12
168 #define PCNET32_WIO_RESET       0x14
169 #define PCNET32_WIO_BDP         0x16
170
171 #define PCNET32_DWIO_RDP        0x10
172 #define PCNET32_DWIO_RAP        0x14
173 #define PCNET32_DWIO_RESET      0x18
174 #define PCNET32_DWIO_BDP        0x1C
175
176 #define PCNET32_TOTAL_SIZE      0x20
177
178 /* The PCNET32 Rx and Tx ring descriptors. */
179 struct pcnet32_rx_head {
180         u32 base;
181         s16 buf_length;
182         s16 status;
183         u32 msg_length;
184         u32 reserved;
185 };
186
187 struct pcnet32_tx_head {
188         u32 base;
189         s16 length;
190         s16 status;
191         u32 misc;
192         u32 reserved;
193 };
194
195 /* The PCNET32 32-Bit initialization block, described in databook. */
196 struct pcnet32_init_block {
197         u16 mode;
198         u16 tlen_rlen;
199         u8 phys_addr[6];
200         u16 reserved;
201         u32 filter[2];
202         /* Receive and transmit ring base, along with extra bits. */
203         u32 rx_ring;
204         u32 tx_ring;
205 };
206 /* PCnet32 access functions */
207 struct pcnet32_access {
208         u16(*read_csr) (unsigned long, int);
209         void (*write_csr) (unsigned long, int, u16);
210          u16(*read_bcr) (unsigned long, int);
211         void (*write_bcr) (unsigned long, int, u16);
212          u16(*read_rap) (unsigned long);
213         void (*write_rap) (unsigned long, u16);
214         void (*reset) (unsigned long);
215 };
216
217 /* Define the TX and RX Descriptors and Rings */
218 struct {
219         struct pcnet32_tx_head tx_ring[TX_RING_SIZE]
220         __attribute__ ((aligned(16)));
221         struct pcnet32_rx_head rx_ring[RX_RING_SIZE]
222         __attribute__ ((aligned(16)));
223         unsigned char txb[PKT_BUF_SZ * TX_RING_SIZE];
224         unsigned char rxb[RX_RING_SIZE * PKT_BUF_SZ];
225 } pcnet32_bufs __shared;
226
227 /* May need to be moved to mii.h */
228 struct mii_if_info {
229         int phy_id;
230         int advertising;
231         unsigned int full_duplex:1;     /* is full duplex? */
232 };
233
234 /*
235  * The first three fields of pcnet32_private are read by the ethernet device 
236  * so we allocate the structure should be allocated by pci_alloc_consistent().
237  */
238 #define MII_CNT 4
239 struct pcnet32_private {
240         struct pcnet32_init_block init_block;
241         struct pci_dev *pci_dev;        /* Pointer to the associated pci device structure */
242         const char *name;
243         /* The saved address of a sent-in-place packet/buffer, for skfree(). */
244         struct sk_buff *tx_skbuff[TX_RING_SIZE];
245         struct sk_buff *rx_skbuff[RX_RING_SIZE];
246         struct pcnet32_access a;
247         unsigned int cur_rx, cur_tx;    /* The next free ring entry */
248         char tx_full;
249         int options;
250         int shared_irq:1,       /* shared irq possible */
251          ltint:1,               /* enable TxDone-intr inhibitor */
252          dxsuflo:1,             /* disable transmit stop on uflo */
253          mii:1;                 /* mii port available */
254         struct mii_if_info mii_if;
255         unsigned char phys[MII_CNT];
256         struct net_device *next;
257         int full_duplex:1;
258 } lpx;
259
260 static struct pcnet32_private *lp;
261
262 static int mdio_read(struct nic *nic __unused, int phy_id, int reg_num);
263 #if 0
264 static void mdio_write(struct nic *nic __unused, int phy_id, int reg_num,
265                        int val);
266 #endif
267 enum pci_flags_bit {
268         PCI_USES_IO = 1, PCI_USES_MEM = 2, PCI_USES_MASTER = 4,
269         PCI_ADDR0 = 0x10 << 0, PCI_ADDR1 = 0x10 << 1, PCI_ADDR2 =
270             0x10 << 2, PCI_ADDR3 = 0x10 << 3,
271 };
272
273
274 static u16 pcnet32_wio_read_csr(unsigned long addr, int index)
275 {
276         outw(index, addr + PCNET32_WIO_RAP);
277         return inw(addr + PCNET32_WIO_RDP);
278 }
279
280 static void pcnet32_wio_write_csr(unsigned long addr, int index, u16 val)
281 {
282         outw(index, addr + PCNET32_WIO_RAP);
283         outw(val, addr + PCNET32_WIO_RDP);
284 }
285
286 static u16 pcnet32_wio_read_bcr(unsigned long addr, int index)
287 {
288         outw(index, addr + PCNET32_WIO_RAP);
289         return inw(addr + PCNET32_WIO_BDP);
290 }
291
292 static void pcnet32_wio_write_bcr(unsigned long addr, int index, u16 val)
293 {
294         outw(index, addr + PCNET32_WIO_RAP);
295         outw(val, addr + PCNET32_WIO_BDP);
296 }
297
298 static u16 pcnet32_wio_read_rap(unsigned long addr)
299 {
300         return inw(addr + PCNET32_WIO_RAP);
301 }
302
303 static void pcnet32_wio_write_rap(unsigned long addr, u16 val)
304 {
305         outw(val, addr + PCNET32_WIO_RAP);
306 }
307
308 static void pcnet32_wio_reset(unsigned long addr)
309 {
310         inw(addr + PCNET32_WIO_RESET);
311 }
312
313 static int pcnet32_wio_check(unsigned long addr)
314 {
315         outw(88, addr + PCNET32_WIO_RAP);
316         return (inw(addr + PCNET32_WIO_RAP) == 88);
317 }
318
319 static struct pcnet32_access pcnet32_wio = {
320       read_csr:pcnet32_wio_read_csr,
321       write_csr:pcnet32_wio_write_csr,
322       read_bcr:pcnet32_wio_read_bcr,
323       write_bcr:pcnet32_wio_write_bcr,
324       read_rap:pcnet32_wio_read_rap,
325       write_rap:pcnet32_wio_write_rap,
326       reset:pcnet32_wio_reset
327 };
328
329 static u16 pcnet32_dwio_read_csr(unsigned long addr, int index)
330 {
331         outl(index, addr + PCNET32_DWIO_RAP);
332         return (inl(addr + PCNET32_DWIO_RDP) & 0xffff);
333 }
334
335 static void pcnet32_dwio_write_csr(unsigned long addr, int index, u16 val)
336 {
337         outl(index, addr + PCNET32_DWIO_RAP);
338         outl(val, addr + PCNET32_DWIO_RDP);
339 }
340
341 static u16 pcnet32_dwio_read_bcr(unsigned long addr, int index)
342 {
343         outl(index, addr + PCNET32_DWIO_RAP);
344         return (inl(addr + PCNET32_DWIO_BDP) & 0xffff);
345 }
346
347 static void pcnet32_dwio_write_bcr(unsigned long addr, int index, u16 val)
348 {
349         outl(index, addr + PCNET32_DWIO_RAP);
350         outl(val, addr + PCNET32_DWIO_BDP);
351 }
352
353 static u16 pcnet32_dwio_read_rap(unsigned long addr)
354 {
355         return (inl(addr + PCNET32_DWIO_RAP) & 0xffff);
356 }
357
358 static void pcnet32_dwio_write_rap(unsigned long addr, u16 val)
359 {
360         outl(val, addr + PCNET32_DWIO_RAP);
361 }
362
363 static void pcnet32_dwio_reset(unsigned long addr)
364 {
365         inl(addr + PCNET32_DWIO_RESET);
366 }
367
368 static int pcnet32_dwio_check(unsigned long addr)
369 {
370         outl(88, addr + PCNET32_DWIO_RAP);
371         return ((inl(addr + PCNET32_DWIO_RAP) & 0xffff) == 88);
372 }
373
374 static struct pcnet32_access pcnet32_dwio = {
375       read_csr:pcnet32_dwio_read_csr,
376       write_csr:pcnet32_dwio_write_csr,
377       read_bcr:pcnet32_dwio_read_bcr,
378       write_bcr:pcnet32_dwio_write_bcr,
379       read_rap:pcnet32_dwio_read_rap,
380       write_rap:pcnet32_dwio_write_rap,
381       reset:pcnet32_dwio_reset
382 };
383
384
385 /* Initialize the PCNET32 Rx and Tx rings. */
386 static int pcnet32_init_ring(struct nic *nic)
387 {
388         int i;
389
390         lp->tx_full = 0;
391         lp->cur_rx = lp->cur_tx = 0;
392
393         for (i = 0; i < RX_RING_SIZE; i++) {
394                 pcnet32_bufs.rx_ring[i].base =
395                         virt_to_le32desc(&pcnet32_bufs.rxb[i]);
396                 pcnet32_bufs.rx_ring[i].buf_length = le16_to_cpu(-PKT_BUF_SZ);
397                 pcnet32_bufs.rx_ring[i].status = le16_to_cpu(0x8000);
398         }
399
400         /* The Tx buffer address is filled in as needed, but we do need to clear
401            the upper ownership bit. */
402         for (i = 0; i < TX_RING_SIZE; i++) {
403                 pcnet32_bufs.tx_ring[i].base = 0;
404                 pcnet32_bufs.tx_ring[i].status = 0;
405         }
406
407
408         lp->init_block.tlen_rlen =
409             le16_to_cpu(TX_RING_LEN_BITS | RX_RING_LEN_BITS);
410         for (i = 0; i < 6; i++)
411                 lp->init_block.phys_addr[i] = nic->node_addr[i];
412         lp->init_block.rx_ring = virt_to_le32desc(&pcnet32_bufs.rx_ring[0]);
413         lp->init_block.tx_ring = virt_to_le32desc(&pcnet32_bufs.tx_ring[0]);
414         return 0;
415 }
416
417 /**************************************************************************
418 RESET - Reset adapter
419 ***************************************************************************/
420 static void pcnet32_reset(struct nic *nic)
421 {
422         /* put the card in its initial state */
423         u16 val;
424         int i;
425
426         /* Reset the PCNET32 */
427         lp->a.reset(ioaddr);
428
429         /* switch pcnet32 to 32bit mode */
430         lp->a.write_bcr(ioaddr, 20, 2);
431
432         /* set/reset autoselect bit */
433         val = lp->a.read_bcr(ioaddr, 2) & ~2;
434         if (lp->options & PCNET32_PORT_ASEL)
435                 val |= 2;
436         lp->a.write_bcr(ioaddr, 2, val);
437
438         /* handle full duplex setting */
439         if (lp->full_duplex) {
440                 val = lp->a.read_bcr(ioaddr, 9) & ~3;
441                 if (lp->options & PCNET32_PORT_FD) {
442                         val |= 1;
443                         if (lp->options ==
444                             (PCNET32_PORT_FD | PCNET32_PORT_AUI))
445                                 val |= 2;
446                 } else if (lp->options & PCNET32_PORT_ASEL) {
447                         /* workaround of xSeries250, turn on for 79C975 only */
448                         i = ((lp->a.
449                               read_csr(ioaddr,
450                                        88) | (lp->a.read_csr(ioaddr,
451                                                              89) << 16)) >>
452                              12) & 0xffff;
453                         if (i == 0x2627)
454                                 val |= 3;
455                 }
456                 lp->a.write_bcr(ioaddr, 9, val);
457         }
458
459         /* set/reset GPSI bit in test register */
460         val = lp->a.read_csr(ioaddr, 124) & ~0x10;
461         if ((lp->options & PCNET32_PORT_PORTSEL) == PCNET32_PORT_GPSI)
462                 val |= 0x10;
463         lp->a.write_csr(ioaddr, 124, val);
464
465         if (lp->mii && !(lp->options & PCNET32_PORT_ASEL)) {
466                 val = lp->a.read_bcr(ioaddr, 32) & ~0x38;       /* disable Auto Negotiation, set 10Mpbs, HD */
467                 if (lp->options & PCNET32_PORT_FD)
468                         val |= 0x10;
469                 if (lp->options & PCNET32_PORT_100)
470                         val |= 0x08;
471                 lp->a.write_bcr(ioaddr, 32, val);
472         } else {
473                 if (lp->options & PCNET32_PORT_ASEL) {  /* enable auto negotiate, setup, disable fd */
474                         val = lp->a.read_bcr(ioaddr, 32) & ~0x98;
475                         val |= 0x20;
476                         lp->a.write_bcr(ioaddr, 32, val);
477                 }
478         }
479
480 #ifdef DO_DXSUFLO
481         if (lp->dxsuflo) {      /* Disable transmit stop on underflow */
482                 val = lp->a.read_csr(ioaddr, 3);
483                 val |= 0x40;
484                 lp->a.write_csr(ioaddr, 3, val);
485         }
486 #endif
487         if (1)
488         {
489                 //disable interrupts
490                 val = lp->a.read_csr(ioaddr, 3);
491                 val = val
492                         | (1 << 14) //BABLM intr disabled
493                         | (1 << 12) //MISSM missed frame mask intr disabled
494                         | (1 << 10) //RINTM receive intr disabled
495                         | (1 << 9) //TINTM transmit intr disabled
496                         | (1 << 8) //IDONM init done intr disabled
497                         ;
498                 lp->a.write_csr(ioaddr, 3, val);
499         }
500
501         if (lp->ltint) {        /* Enable TxDone-intr inhibitor */
502                 val = lp->a.read_csr(ioaddr, 5);
503                 val |= (1 << 14);
504                 lp->a.write_csr(ioaddr, 5, val);
505         }
506         lp->init_block.mode =
507             le16_to_cpu((lp->options & PCNET32_PORT_PORTSEL) << 7);
508         lp->init_block.filter[0] = 0xffffffff;
509         lp->init_block.filter[1] = 0xffffffff;
510
511         pcnet32_init_ring(nic);
512
513
514         /* Re-initialize the PCNET32, and start it when done. */
515         lp->a.write_csr(ioaddr, 1,
516                         (virt_to_bus(&lp->init_block)) & 0xffff);
517         lp->a.write_csr(ioaddr, 2, (virt_to_bus(&lp->init_block)) >> 16);
518         lp->a.write_csr(ioaddr, 4, 0x0915);
519         lp->a.write_csr(ioaddr, 0, 0x0001);
520
521
522         i = 0;
523         while (i++ < 100)
524                 if (lp->a.read_csr(ioaddr, 0) & 0x0100)
525                         break;
526         /* 
527          * We used to clear the InitDone bit, 0x0100, here but Mark Stockton
528          * reports that doing so triggers a bug in the '974.
529          */
530         lp->a.write_csr(ioaddr, 0, 0x0042);
531
532         dprintf(("pcnet32 open, csr0 %hX.\n", lp->a.read_csr(ioaddr, 0)));
533
534 }
535
536 /**************************************************************************
537 POLL - Wait for a frame
538 ***************************************************************************/
539 static int pcnet32_poll(struct nic *nic __unused, int retrieve)
540 {
541         /* return true if there's an ethernet packet ready to read */
542         /* nic->packet should contain data on return */
543         /* nic->packetlen should contain length of data */
544
545         signed char status;
546         int entry;
547
548         entry = lp->cur_rx & RX_RING_MOD_MASK;
549         status = (le16_to_cpu(pcnet32_bufs.rx_ring[entry].status) >> 8);
550
551         if (status < 0)
552                 return 0;
553
554         if ( ! retrieve ) return 1;
555
556         if (status == 0x03) {
557                 nic->packetlen =
558                         (le32_to_cpu(pcnet32_bufs.rx_ring[entry].msg_length)
559                          & 0xfff) - 4;
560                 memcpy(nic->packet, &pcnet32_bufs.rxb[entry], nic->packetlen);
561
562                 /* Andrew Boyd of QNX reports that some revs of the 79C765
563                  * clear the buffer length */
564                 pcnet32_bufs.rx_ring[entry].buf_length
565                         = le16_to_cpu(-PKT_BUF_SZ);
566                 /* prime for next receive */
567                 pcnet32_bufs.rx_ring[entry].status |= le16_to_cpu(0x8000);
568                 /* Switch to the next Rx ring buffer */
569                 lp->cur_rx++;
570
571         } else {
572                 return 0;
573         }
574
575         return 1;
576 }
577
578 /**************************************************************************
579 TRANSMIT - Transmit a frame
580 ***************************************************************************/
581 static void pcnet32_transmit(struct nic *nic __unused, const char *d,   /* Destination */
582                              unsigned int t,    /* Type */
583                              unsigned int s,    /* size */
584                              const char *p)
585 {                               /* Packet */
586         /* send the packet to destination */
587         unsigned long time;
588         u8 *ptxb;
589         u16 nstype;
590         u16 status;
591         int entry = 0;          /*lp->cur_tx & TX_RING_MOD_MASK; */
592
593         status = 0x8300;
594         /* point to the current txb incase multiple tx_rings are used */
595         ptxb = pcnet32_bufs.txb + (lp->cur_tx * PKT_BUF_SZ);
596
597         /* copy the packet to ring buffer */
598         memcpy(ptxb, d, ETH_ALEN);      /* dst */
599         memcpy(ptxb + ETH_ALEN, nic->node_addr, ETH_ALEN);      /* src */
600         nstype = htons((u16) t);        /* type */
601         memcpy(ptxb + 2 * ETH_ALEN, (u8 *) & nstype, 2);        /* type */
602         memcpy(ptxb + ETH_HLEN, p, s);
603
604         s += ETH_HLEN;
605         while (s < ETH_ZLEN)    /* pad to min length */
606                 ptxb[s++] = '\0';
607
608         pcnet32_bufs.tx_ring[entry].length = le16_to_cpu(-s);
609         pcnet32_bufs.tx_ring[entry].misc = 0x00000000;
610         pcnet32_bufs.tx_ring[entry].base = (u32) virt_to_le32desc(ptxb);
611
612         /* we set the top byte as the very last thing */
613         pcnet32_bufs.tx_ring[entry].status = le16_to_cpu(status);
614
615
616         /* Trigger an immediate send poll */
617         lp->a.write_csr(ioaddr, 0, 0x0048);
618
619         /* wait for transmit complete */
620         lp->cur_tx = 0;         /* (lp->cur_tx + 1); */
621         time = currticks() + TICKS_PER_SEC;     /* wait one second */
622         while (currticks() < time &&
623                ((short) le16_to_cpu(pcnet32_bufs.tx_ring[entry].status) < 0));
624
625         if ((short) le16_to_cpu(pcnet32_bufs.tx_ring[entry].status) < 0)
626                 printf("PCNET32 timed out on transmit\n");
627
628         /* Stop pointing at the current txb
629          * otherwise the card continues to send the packet */
630         pcnet32_bufs.tx_ring[entry].base = 0;
631
632 }
633
634 /**************************************************************************
635 DISABLE - Turn off ethernet interface
636 ***************************************************************************/
637 static void pcnet32_disable ( struct nic *nic __unused ) {
638         /* Stop the PCNET32 here -- it ocassionally polls memory if we don't */
639         lp->a.write_csr(ioaddr, 0, 0x0004);
640
641         /*
642          * Switch back to 16-bit mode to avoid problems with dumb 
643          * DOS packet driver after a warm reboot
644          */
645         lp->a.write_bcr(ioaddr, 20, 0);
646 }
647
648 /**************************************************************************
649 IRQ - Enable, Disable, or Force interrupts
650 ***************************************************************************/
651 static void pcnet32_irq(struct nic *nic __unused, irq_action_t action __unused)
652 {
653   switch ( action ) {
654   case DISABLE :
655     break;
656   case ENABLE :
657     break;
658   case FORCE :
659     break;
660   }
661 }
662
663 /**************************************************************************
664 PROBE - Look for an adapter, this routine's visible to the outside
665 You should omit the last argument struct pci_device * for a non-PCI NIC
666 ***************************************************************************/
667 static int pcnet32_probe ( struct nic *nic, struct pci_device *pci ) {
668
669         int i, media;
670         int fdx, mii, fset, dxsuflo, ltint;
671         int chip_version;
672         char *chipname;
673         struct pcnet32_access *a = NULL;
674         u8 promaddr[6];
675         int shared = 1;
676
677         if (pci->ioaddr == 0)
678                 return 0;
679
680         /* BASE is used throughout to address the card */
681         ioaddr = pci->ioaddr;
682         printf("pcnet32.c: Found %s, Vendor=0x%hX Device=0x%hX\n",
683                pci->name, pci->vendor_id, pci->device_id);
684
685         nic->irqno  = 0;
686         pci_fill_nic ( nic, pci );
687         nic->ioaddr = pci->ioaddr & ~3;
688
689         /* reset the chip */
690         pcnet32_wio_reset(ioaddr);
691
692         /* NOTE: 16-bit check is first, otherwise some older PCnet chips fail */
693         if (pcnet32_wio_read_csr(ioaddr, 0) == 4
694             && pcnet32_wio_check(ioaddr)) {
695                 a = &pcnet32_wio;
696         } else {
697                 pcnet32_dwio_reset(ioaddr);
698                 if (pcnet32_dwio_read_csr(ioaddr, 0) == 4
699                     && pcnet32_dwio_check(ioaddr)) {
700                         a = &pcnet32_dwio;
701                 } else
702                         return 0;
703         }
704
705         chip_version =
706             a->read_csr(ioaddr, 88) | (a->read_csr(ioaddr, 89) << 16);
707
708         dprintf(("PCnet chip version is 0x%X\n", chip_version));
709         if ((chip_version & 0xfff) != 0x003)
710                 return 0;
711
712         /* initialize variables */
713         fdx = mii = fset = dxsuflo = ltint = 0;
714         chip_version = (chip_version >> 12) & 0xffff;
715
716         switch (chip_version) {
717         case 0x2420:
718                 chipname = "PCnet/PCI 79C970";  /* PCI */
719                 break;
720         case 0x2430:
721                 if (shared)
722                         chipname = "PCnet/PCI 79C970";  /* 970 gives the wrong chip id back */
723                 else
724                         chipname = "PCnet/32 79C965";   /* 486/VL bus */
725                 break;
726         case 0x2621:
727                 chipname = "PCnet/PCI II 79C970A";      /* PCI */
728                 fdx = 1;
729                 break;
730         case 0x2623:
731                 chipname = "PCnet/FAST 79C971"; /* PCI */
732                 fdx = 1;
733                 mii = 1;
734                 fset = 1;
735                 ltint = 1;
736                 break;
737         case 0x2624:
738                 chipname = "PCnet/FAST+ 79C972";        /* PCI */
739                 fdx = 1;
740                 mii = 1;
741                 fset = 1;
742                 break;
743         case 0x2625:
744                 chipname = "PCnet/FAST III 79C973";     /* PCI */
745                 fdx = 1;
746                 mii = 1;
747                 break;
748         case 0x2626:
749                 chipname = "PCnet/Home 79C978"; /* PCI */
750                 fdx = 1;
751                 /* 
752                  * This is based on specs published at www.amd.com.  This section
753                  * assumes that a card with a 79C978 wants to go into 1Mb HomePNA
754                  * mode.  The 79C978 can also go into standard ethernet, and there
755                  * probably should be some sort of module option to select the
756                  * mode by which the card should operate
757                  */
758                 /* switch to home wiring mode */
759                 media = a->read_bcr(ioaddr, 49);
760
761                 printf("media reset to %#x.\n", media);
762                 a->write_bcr(ioaddr, 49, media);
763                 break;
764         case 0x2627:
765                 chipname = "PCnet/FAST III 79C975";     /* PCI */
766                 fdx = 1;
767                 mii = 1;
768                 break;
769         default:
770                 chipname = "UNKNOWN";
771                 printf("PCnet version %#x, no PCnet32 chip.\n",
772                        chip_version);
773                 return 0;
774         }
775
776         /*
777          *  On selected chips turn on the BCR18:NOUFLO bit. This stops transmit
778          *  starting until the packet is loaded. Strike one for reliability, lose
779          *  one for latency - although on PCI this isnt a big loss. Older chips 
780          *  have FIFO's smaller than a packet, so you can't do this.
781          */
782
783         if (fset) {
784                 a->write_bcr(ioaddr, 18,
785                              (a->read_bcr(ioaddr, 18) | 0x0800));
786                 a->write_csr(ioaddr, 80,
787                              (a->read_csr(ioaddr, 80) & 0x0C00) | 0x0c00);
788                 dxsuflo = 1;
789                 ltint = 1;
790         }
791
792         dprintf(("%s at %hX,", chipname, ioaddr));
793
794         /* read PROM address */
795         for (i = 0; i < 6; i++)
796                 promaddr[i] = inb(ioaddr + i);
797
798         /* Update the nic structure with the MAC Address */
799         for (i = 0; i < ETH_ALEN; i++) {
800                 nic->node_addr[i] = promaddr[i];
801         }
802         /* Print out some hardware info */
803         printf("%s: %! at ioaddr 0x%hX, ", chipname, nic->node_addr,
804                ioaddr);
805
806         /* Set to pci bus master */
807         adjust_pci_device(pci);
808
809         /* point to private storage */
810         lp = &lpx;
811
812 #if EBDEBUG
813         if (((chip_version + 1) & 0xfffe) == 0x2624) {  /* Version 0x2623 or 0x2624 */
814                 i = a->read_csr(ioaddr, 80) & 0x0C00;   /* Check tx_start_pt */
815                 dprintf(("    tx_start_pt(0x%hX):", i));
816                 switch (i >> 10) {
817                 case 0:
818                         dprintf(("  20 bytes,"));
819                         break;
820                 case 1:
821                         dprintf(("  64 bytes,"));
822                         break;
823                 case 2:
824                         dprintf((" 128 bytes,"));
825                         break;
826                 case 3:
827                         dprintf(("~220 bytes,"));
828                         break;
829                 }
830                 i = a->read_bcr(ioaddr, 18);    /* Check Burst/Bus control */
831                 dprintf((" BCR18(%hX):", i & 0xffff));
832                 if (i & (1 << 5))
833                         dprintf(("BurstWrEn "));
834                 if (i & (1 << 6))
835                         dprintf(("BurstRdEn "));
836                 if (i & (1 << 7))
837                         dprintf(("DWordIO "));
838                 if (i & (1 << 11))
839                         dprintf(("NoUFlow "));
840                 i = a->read_bcr(ioaddr, 25);
841                 dprintf(("    SRAMSIZE=0x%hX,", i << 8));
842                 i = a->read_bcr(ioaddr, 26);
843                 dprintf((" SRAM_BND=0x%hX,", i << 8));
844                 i = a->read_bcr(ioaddr, 27);
845                 if (i & (1 << 14))
846                         dprintf(("LowLatRx"));
847         }
848 #endif
849         lp->name = chipname;
850         lp->shared_irq = shared;
851         lp->full_duplex = fdx;
852         lp->dxsuflo = dxsuflo;
853         lp->ltint = ltint;
854         lp->mii = mii;
855         /* FIXME: Fix Options for only one card */
856         if ((cards_found >= MAX_UNITS)
857             || ((unsigned int) options[cards_found] > sizeof(options_mapping)))
858                 lp->options = PCNET32_PORT_ASEL;
859         else
860                 lp->options = options_mapping[options[cards_found]];
861
862         if (fdx && !(lp->options & PCNET32_PORT_ASEL) &&
863             ((cards_found >= MAX_UNITS) || full_duplex[cards_found]))
864                 lp->options |= PCNET32_PORT_FD;
865
866         if (!a) {
867                 printf("No access methods\n");
868                 return 0;
869         }
870         lp->a = *a;
871
872         /* detect special T1/E1 WAN card by checking for MAC address */
873         if (nic->node_addr[0] == 0x00 && nic->node_addr[1] == 0xe0
874             && nic->node_addr[2] == 0x75)
875                 lp->options = PCNET32_PORT_FD | PCNET32_PORT_GPSI;
876
877         lp->init_block.mode = le16_to_cpu(0x0003);      /* Disable Rx and Tx. */
878         lp->init_block.tlen_rlen =
879             le16_to_cpu(TX_RING_LEN_BITS | RX_RING_LEN_BITS);
880         for (i = 0; i < 6; i++)
881                 lp->init_block.phys_addr[i] = nic->node_addr[i];
882         lp->init_block.filter[0] = 0xffffffff;
883         lp->init_block.filter[1] = 0xffffffff;
884         lp->init_block.rx_ring = virt_to_bus(&pcnet32_bufs.rx_ring);
885         lp->init_block.tx_ring = virt_to_bus(&pcnet32_bufs.tx_ring);
886
887         /* switch pcnet32 to 32bit mode */
888         a->write_bcr(ioaddr, 20, 2);
889
890         a->write_csr(ioaddr, 1, (virt_to_bus(&lp->init_block)) & 0xffff);
891         a->write_csr(ioaddr, 2, (virt_to_bus(&lp->init_block)) >> 16);
892
893         /* 
894          * To auto-IRQ we enable the initialization-done and DMA error
895          * interrupts. For ISA boards we get a DMA error, but VLB and PCI
896          * boards will work.
897          */
898         /* Trigger an initialization just for the interrupt. */
899
900         
901 //      a->write_csr(ioaddr, 0, 0x41); 
902 //      mdelay(1);
903
904         cards_found++;
905
906         /* point to NIC specific routines */
907         pcnet32_reset(nic);
908         if (mii) {
909                 int tmp;
910                 int phy, phy_idx = 0;
911                 u16 mii_lpa;
912                 lp->phys[0] = 1;        /* Default Setting */
913                 for (phy = 1; phy < 32 && phy_idx < MII_CNT; phy++) {
914                         int mii_status = mdio_read(nic, phy, MII_BMSR);
915                         if (mii_status != 0xffff && mii_status != 0x0000) {
916                                 lp->phys[phy_idx++] = phy;
917                                 lp->mii_if.advertising =
918                                     mdio_read(nic, phy, MII_ADVERTISE);
919                                 if ((mii_status & 0x0040) == 0) {
920                                   tmp = phy;
921                                   dprintf (("MII PHY found at address %d, status " 
922                                             "%hX advertising %hX\n", phy, mii_status, 
923                                             lp->mii_if.advertising));
924                                 }
925                         }
926                 }
927                 if (phy_idx == 0)
928                         printf("No MII transceiver found!\n");
929                 lp->mii_if.phy_id = lp->phys[0];
930
931                 lp->mii_if.advertising =
932                     mdio_read(nic, lp->phys[0], MII_ADVERTISE);
933
934                 mii_lpa = mdio_read(nic, lp->phys[0], MII_LPA);
935                 lp->mii_if.advertising &= mii_lpa;
936                 if (lp->mii_if.advertising & ADVERTISE_100FULL)
937                         printf("100Mbps Full-Duplex\n");
938                 else if (lp->mii_if.advertising & ADVERTISE_100HALF)
939                         printf("100Mbps Half-Duplex\n");
940                 else if (lp->mii_if.advertising & ADVERTISE_10FULL)
941                         printf("10Mbps Full-Duplex\n");
942                 else if (lp->mii_if.advertising & ADVERTISE_10HALF)
943                         printf("10Mbps Half-Duplex\n");
944                 else
945                         printf("\n");
946         } else {
947                 /* The older chips are fixed 10Mbps, and some support full duplex,
948                  * although not via autonegotiation, but only via configuration.  */
949                 if (fdx)
950                         printf("10Mbps Full-Duplex\n");
951                 else
952                         printf("10Mbps Half-Duplex\n");
953         }
954
955         nic->nic_op     = &pcnet32_operations;
956
957         return 1;
958 }
959 static int mdio_read(struct nic *nic __unused, int phy_id, int reg_num)
960 {
961         u16 val_out;
962         int phyaddr;
963
964         if (!lp->mii)
965                 return 0;
966
967         phyaddr = lp->a.read_bcr(ioaddr, 33);
968
969         lp->a.write_bcr(ioaddr, 33,
970                         ((phy_id & 0x1f) << 5) | (reg_num & 0x1f));
971         val_out = lp->a.read_bcr(ioaddr, 34);
972         lp->a.write_bcr(ioaddr, 33, phyaddr);
973
974         return val_out;
975 }
976
977 #if 0
978 static void mdio_write(struct nic *nic __unused, int phy_id, int reg_num,
979                        int val)
980 {
981         int phyaddr;
982
983         if (!lp->mii)
984                 return;
985
986         phyaddr = lp->a.read_bcr(ioaddr, 33);
987
988         lp->a.write_bcr(ioaddr, 33,
989                         ((phy_id & 0x1f) << 5) | (reg_num & 0x1f));
990         lp->a.write_bcr(ioaddr, 34, val);
991         lp->a.write_bcr(ioaddr, 33, phyaddr);
992 }
993 #endif
994
995 static struct nic_operations pcnet32_operations = {
996         .connect        = dummy_connect,
997         .poll           = pcnet32_poll,
998         .transmit       = pcnet32_transmit,
999         .irq            = pcnet32_irq,
1000
1001 };
1002
1003 static struct pci_id pcnet32_nics[] = {
1004         PCI_ROM(0x1022, 0x2000, "pcnet32", "AMD PCnet/PCI"),
1005         PCI_ROM(0x1022, 0x2625, "pcnetfastiii", "AMD PCNet FAST III"),
1006         PCI_ROM(0x1022, 0x2001, "amdhomepna", "AMD PCnet/HomePNA"),
1007 };
1008
1009 PCI_DRIVER ( pcnet32_driver, pcnet32_nics, PCI_NO_CLASS );
1010
1011 DRIVER ( "PCNET32/PCI", nic_driver, pci_driver, pcnet32_driver,
1012          pcnet32_probe, pcnet32_disable );