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