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