net: use symbolic values for ndo_start_xmit() return codes
[linux-2.6.git] / drivers / net / sun3lance.c
1 /* sun3lance.c: Ethernet driver for SUN3 Lance chip */
2 /*
3
4   Sun3 Lance ethernet driver, by Sam Creasey (sammy@users.qual.net).
5   This driver is a part of the linux kernel, and is thus distributed
6   under the GNU General Public License.
7
8   The values used in LANCE_OBIO and LANCE_IRQ seem to be empirically
9   true for the correct IRQ and address of the lance registers.  They
10   have not been widely tested, however.  What we probably need is a
11   "proper" way to search for a device in the sun3's prom, but, alas,
12   linux has no such thing.
13
14   This driver is largely based on atarilance.c, by Roman Hodek.  Other
15   sources of inspiration were the NetBSD sun3 am7990 driver, and the
16   linux sparc lance driver (sunlance.c).
17
18   There are more assumptions made throughout this driver, it almost
19   certainly still needs work, but it does work at least for RARP/BOOTP and
20   mounting the root NFS filesystem.
21
22 */
23
24 static char *version = "sun3lance.c: v1.2 1/12/2001  Sam Creasey (sammy@sammy.net)\n";
25
26 #include <linux/module.h>
27 #include <linux/stddef.h>
28 #include <linux/kernel.h>
29 #include <linux/string.h>
30 #include <linux/errno.h>
31 #include <linux/slab.h>
32 #include <linux/interrupt.h>
33 #include <linux/init.h>
34 #include <linux/ioport.h>
35 #include <linux/delay.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
38 #include <linux/skbuff.h>
39 #include <linux/bitops.h>
40
41 #include <asm/cacheflush.h>
42 #include <asm/setup.h>
43 #include <asm/irq.h>
44 #include <asm/io.h>
45 #include <asm/pgtable.h>
46 #include <asm/dvma.h>
47 #include <asm/idprom.h>
48 #include <asm/machines.h>
49
50 #ifdef CONFIG_SUN3
51 #include <asm/sun3mmu.h>
52 #else
53 #include <asm/sun3xprom.h>
54 #endif
55
56 /* sun3/60 addr/irq for the lance chip.  If your sun is different,
57    change this. */
58 #define LANCE_OBIO 0x120000
59 #define LANCE_IRQ IRQ_AUTO_3
60
61 /* Debug level:
62  *  0 = silent, print only serious errors
63  *  1 = normal, print error messages
64  *  2 = debug, print debug infos
65  *  3 = debug, print even more debug infos (packet data)
66  */
67
68 #define LANCE_DEBUG     0
69
70 #ifdef LANCE_DEBUG
71 static int lance_debug = LANCE_DEBUG;
72 #else
73 static int lance_debug = 1;
74 #endif
75 module_param(lance_debug, int, 0);
76 MODULE_PARM_DESC(lance_debug, "SUN3 Lance debug level (0-3)");
77 MODULE_LICENSE("GPL");
78
79 #define DPRINTK(n,a) \
80         do {  \
81                 if (lance_debug >= n)  \
82                         printk a; \
83         } while( 0 )
84
85
86 /* we're only using 32k of memory, so we use 4 TX
87    buffers and 16 RX buffers.  These values are expressed as log2. */
88
89 #define TX_LOG_RING_SIZE                        3
90 #define RX_LOG_RING_SIZE                        5
91
92 /* These are the derived values */
93
94 #define TX_RING_SIZE                    (1 << TX_LOG_RING_SIZE)
95 #define TX_RING_LEN_BITS                (TX_LOG_RING_SIZE << 5)
96 #define TX_RING_MOD_MASK                (TX_RING_SIZE - 1)
97
98 #define RX_RING_SIZE                    (1 << RX_LOG_RING_SIZE)
99 #define RX_RING_LEN_BITS                (RX_LOG_RING_SIZE << 5)
100 #define RX_RING_MOD_MASK                (RX_RING_SIZE - 1)
101
102 /* Definitions for packet buffer access: */
103 #define PKT_BUF_SZ              1544
104
105 /* Get the address of a packet buffer corresponding to a given buffer head */
106 #define PKTBUF_ADDR(head)       (void *)((unsigned long)(MEM) | (head)->base)
107
108
109 /* The LANCE Rx and Tx ring descriptors. */
110 struct lance_rx_head {
111         unsigned short  base;           /* Low word of base addr */
112         volatile unsigned char  flag;
113         unsigned char  base_hi; /* High word of base addr (unused) */
114         short buf_length;       /* This length is 2s complement! */
115         volatile short msg_length;      /* This length is "normal". */
116 };
117
118 struct lance_tx_head {
119         unsigned short base;            /* Low word of base addr */
120         volatile unsigned char  flag;
121         unsigned char base_hi;  /* High word of base addr (unused) */
122         short length;           /* Length is 2s complement! */
123         volatile short misc;
124 };
125
126 /* The LANCE initialization block, described in databook. */
127 struct lance_init_block {
128         unsigned short  mode;           /* Pre-set mode */
129         unsigned char   hwaddr[6];      /* Physical ethernet address */
130         unsigned int    filter[2];      /* Multicast filter (unused). */
131         /* Receive and transmit ring base, along with length bits. */
132         unsigned short rdra;
133         unsigned short rlen;
134         unsigned short tdra;
135         unsigned short tlen;
136         unsigned short pad[4]; /* is thie needed? */
137 };
138
139 /* The whole layout of the Lance shared memory */
140 struct lance_memory {
141         struct lance_init_block init;
142         struct lance_tx_head    tx_head[TX_RING_SIZE];
143         struct lance_rx_head    rx_head[RX_RING_SIZE];
144         char   rx_data[RX_RING_SIZE][PKT_BUF_SZ];
145         char   tx_data[TX_RING_SIZE][PKT_BUF_SZ];
146 };
147
148 /* The driver's private device structure */
149
150 struct lance_private {
151         volatile unsigned short *iobase;
152         struct lance_memory     *mem;
153         int new_rx, new_tx;     /* The next free ring entry */
154         int old_tx, old_rx;     /* ring entry to be processed */
155 /* These two must be longs for set_bit() */
156         long        tx_full;
157         long        lock;
158 };
159
160 /* I/O register access macros */
161
162 #define MEM     lp->mem
163 #define DREG    lp->iobase[0]
164 #define AREG    lp->iobase[1]
165 #define REGA(a) (*( AREG = (a), &DREG ))
166
167 /* Definitions for the Lance */
168
169 /* tx_head flags */
170 #define TMD1_ENP                0x01    /* end of packet */
171 #define TMD1_STP                0x02    /* start of packet */
172 #define TMD1_DEF                0x04    /* deferred */
173 #define TMD1_ONE                0x08    /* one retry needed */
174 #define TMD1_MORE               0x10    /* more than one retry needed */
175 #define TMD1_ERR                0x40    /* error summary */
176 #define TMD1_OWN                0x80    /* ownership (set: chip owns) */
177
178 #define TMD1_OWN_CHIP   TMD1_OWN
179 #define TMD1_OWN_HOST   0
180
181 /* tx_head misc field */
182 #define TMD3_TDR                0x03FF  /* Time Domain Reflectometry counter */
183 #define TMD3_RTRY               0x0400  /* failed after 16 retries */
184 #define TMD3_LCAR               0x0800  /* carrier lost */
185 #define TMD3_LCOL               0x1000  /* late collision */
186 #define TMD3_UFLO               0x4000  /* underflow (late memory) */
187 #define TMD3_BUFF               0x8000  /* buffering error (no ENP) */
188
189 /* rx_head flags */
190 #define RMD1_ENP                0x01    /* end of packet */
191 #define RMD1_STP                0x02    /* start of packet */
192 #define RMD1_BUFF               0x04    /* buffer error */
193 #define RMD1_CRC                0x08    /* CRC error */
194 #define RMD1_OFLO               0x10    /* overflow */
195 #define RMD1_FRAM               0x20    /* framing error */
196 #define RMD1_ERR                0x40    /* error summary */
197 #define RMD1_OWN                0x80    /* ownership (set: ship owns) */
198
199 #define RMD1_OWN_CHIP   RMD1_OWN
200 #define RMD1_OWN_HOST   0
201
202 /* register names */
203 #define CSR0    0               /* mode/status */
204 #define CSR1    1               /* init block addr (low) */
205 #define CSR2    2               /* init block addr (high) */
206 #define CSR3    3               /* misc */
207 #define CSR8    8               /* address filter */
208 #define CSR15   15              /* promiscuous mode */
209
210 /* CSR0 */
211 /* (R=readable, W=writeable, S=set on write, C=clear on write) */
212 #define CSR0_INIT       0x0001          /* initialize (RS) */
213 #define CSR0_STRT       0x0002          /* start (RS) */
214 #define CSR0_STOP       0x0004          /* stop (RS) */
215 #define CSR0_TDMD       0x0008          /* transmit demand (RS) */
216 #define CSR0_TXON       0x0010          /* transmitter on (R) */
217 #define CSR0_RXON       0x0020          /* receiver on (R) */
218 #define CSR0_INEA       0x0040          /* interrupt enable (RW) */
219 #define CSR0_INTR       0x0080          /* interrupt active (R) */
220 #define CSR0_IDON       0x0100          /* initialization done (RC) */
221 #define CSR0_TINT       0x0200          /* transmitter interrupt (RC) */
222 #define CSR0_RINT       0x0400          /* receiver interrupt (RC) */
223 #define CSR0_MERR       0x0800          /* memory error (RC) */
224 #define CSR0_MISS       0x1000          /* missed frame (RC) */
225 #define CSR0_CERR       0x2000          /* carrier error (no heartbeat :-) (RC) */
226 #define CSR0_BABL       0x4000          /* babble: tx-ed too many bits (RC) */
227 #define CSR0_ERR        0x8000          /* error (RC) */
228
229 /* CSR3 */
230 #define CSR3_BCON       0x0001          /* byte control */
231 #define CSR3_ACON       0x0002          /* ALE control */
232 #define CSR3_BSWP       0x0004          /* byte swap (1=big endian) */
233
234 /***************************** Prototypes *****************************/
235
236 static int lance_probe( struct net_device *dev);
237 static int lance_open( struct net_device *dev );
238 static void lance_init_ring( struct net_device *dev );
239 static int lance_start_xmit( struct sk_buff *skb, struct net_device *dev );
240 static irqreturn_t lance_interrupt( int irq, void *dev_id);
241 static int lance_rx( struct net_device *dev );
242 static int lance_close( struct net_device *dev );
243 static void set_multicast_list( struct net_device *dev );
244
245 /************************* End of Prototypes **************************/
246
247 struct net_device * __init sun3lance_probe(int unit)
248 {
249         struct net_device *dev;
250         static int found;
251         int err = -ENODEV;
252
253         if (!MACH_IS_SUN3 && !MACH_IS_SUN3X)
254                 return ERR_PTR(-ENODEV);
255
256         /* check that this machine has an onboard lance */
257         switch(idprom->id_machtype) {
258         case SM_SUN3|SM_3_50:
259         case SM_SUN3|SM_3_60:
260         case SM_SUN3X|SM_3_80:
261                 /* these machines have lance */
262                 break;
263
264         default:
265                 return ERR_PTR(-ENODEV);
266         }
267
268         if (found)
269                 return ERR_PTR(-ENODEV);
270
271         dev = alloc_etherdev(sizeof(struct lance_private));
272         if (!dev)
273                 return ERR_PTR(-ENOMEM);
274         if (unit >= 0) {
275                 sprintf(dev->name, "eth%d", unit);
276                 netdev_boot_setup_check(dev);
277         }
278
279         if (!lance_probe(dev))
280                 goto out;
281
282         err = register_netdev(dev);
283         if (err)
284                 goto out1;
285         found = 1;
286         return dev;
287
288 out1:
289 #ifdef CONFIG_SUN3
290         iounmap((void __iomem *)dev->base_addr);
291 #endif
292 out:
293         free_netdev(dev);
294         return ERR_PTR(err);
295 }
296
297 static const struct net_device_ops lance_netdev_ops = {
298         .ndo_open               = lance_open,
299         .ndo_stop               = lance_close,
300         .ndo_start_xmit         = lance_start_xmit,
301         .ndo_set_multicast_list = set_multicast_list,
302         .ndo_set_mac_address    = NULL,
303         .ndo_change_mtu         = eth_change_mtu,
304         .ndo_validate_addr      = eth_validate_addr,
305 };
306
307 static int __init lance_probe( struct net_device *dev)
308 {
309         unsigned long ioaddr;
310
311         struct lance_private    *lp;
312         int                     i;
313         static int              did_version;
314         volatile unsigned short *ioaddr_probe;
315         unsigned short tmp1, tmp2;
316
317 #ifdef CONFIG_SUN3
318         ioaddr = (unsigned long)ioremap(LANCE_OBIO, PAGE_SIZE);
319         if (!ioaddr)
320                 return 0;
321 #else
322         ioaddr = SUN3X_LANCE;
323 #endif
324
325         /* test to see if there's really a lance here */
326         /* (CSRO_INIT shouldn't be readable) */
327
328         ioaddr_probe = (volatile unsigned short *)ioaddr;
329         tmp1 = ioaddr_probe[0];
330         tmp2 = ioaddr_probe[1];
331
332         ioaddr_probe[1] = CSR0;
333         ioaddr_probe[0] = CSR0_INIT | CSR0_STOP;
334
335         if(ioaddr_probe[0] != CSR0_STOP) {
336                 ioaddr_probe[0] = tmp1;
337                 ioaddr_probe[1] = tmp2;
338
339 #ifdef CONFIG_SUN3
340                 iounmap((void __iomem *)ioaddr);
341 #endif
342                 return 0;
343         }
344
345         lp = netdev_priv(dev);
346
347         /* XXX - leak? */
348         MEM = dvma_malloc_align(sizeof(struct lance_memory), 0x10000);
349         if (MEM == NULL) {
350 #ifdef CONFIG_SUN3
351                 iounmap((void __iomem *)ioaddr);
352 #endif
353                 printk(KERN_WARNING "SUN3 Lance couldn't allocate DVMA memory\n");
354                 return 0;
355         }
356
357         lp->iobase = (volatile unsigned short *)ioaddr;
358         dev->base_addr = (unsigned long)ioaddr; /* informational only */
359
360         REGA(CSR0) = CSR0_STOP;
361
362         if (request_irq(LANCE_IRQ, lance_interrupt, IRQF_DISABLED, "SUN3 Lance", dev) < 0) {
363 #ifdef CONFIG_SUN3
364                 iounmap((void __iomem *)ioaddr);
365 #endif
366                 dvma_free((void *)MEM);
367                 printk(KERN_WARNING "SUN3 Lance unable to allocate IRQ\n");
368                 return 0;
369         }
370         dev->irq = (unsigned short)LANCE_IRQ;
371
372
373         printk("%s: SUN3 Lance at io %#lx, mem %#lx, irq %d, hwaddr ",
374                    dev->name,
375                    (unsigned long)ioaddr,
376                    (unsigned long)MEM,
377                    dev->irq);
378
379         /* copy in the ethernet address from the prom */
380         for(i = 0; i < 6 ; i++)
381              dev->dev_addr[i] = idprom->id_ethaddr[i];
382
383         /* tell the card it's ether address, bytes swapped */
384         MEM->init.hwaddr[0] = dev->dev_addr[1];
385         MEM->init.hwaddr[1] = dev->dev_addr[0];
386         MEM->init.hwaddr[2] = dev->dev_addr[3];
387         MEM->init.hwaddr[3] = dev->dev_addr[2];
388         MEM->init.hwaddr[4] = dev->dev_addr[5];
389         MEM->init.hwaddr[5] = dev->dev_addr[4];
390
391         printk("%pM\n", dev->dev_addr);
392
393         MEM->init.mode = 0x0000;
394         MEM->init.filter[0] = 0x00000000;
395         MEM->init.filter[1] = 0x00000000;
396         MEM->init.rdra = dvma_vtob(MEM->rx_head);
397         MEM->init.rlen    = (RX_LOG_RING_SIZE << 13) |
398                 (dvma_vtob(MEM->rx_head) >> 16);
399         MEM->init.tdra = dvma_vtob(MEM->tx_head);
400         MEM->init.tlen    = (TX_LOG_RING_SIZE << 13) |
401                 (dvma_vtob(MEM->tx_head) >> 16);
402
403         DPRINTK(2, ("initaddr: %08lx rx_ring: %08lx tx_ring: %08lx\n",
404                dvma_vtob(&(MEM->init)), dvma_vtob(MEM->rx_head),
405                (dvma_vtob(MEM->tx_head))));
406
407         if (did_version++ == 0)
408                 printk( version );
409
410         dev->netdev_ops = &lance_netdev_ops;
411 //      KLUDGE -- REMOVE ME
412         set_bit(__LINK_STATE_PRESENT, &dev->state);
413
414
415         return 1;
416 }
417
418 static int lance_open( struct net_device *dev )
419 {
420         struct lance_private *lp = netdev_priv(dev);
421         int i;
422
423         DPRINTK( 2, ( "%s: lance_open()\n", dev->name ));
424
425         REGA(CSR0) = CSR0_STOP;
426
427         lance_init_ring(dev);
428
429         /* From now on, AREG is kept to point to CSR0 */
430         REGA(CSR0) = CSR0_INIT;
431
432         i = 1000000;
433         while (--i > 0)
434                 if (DREG & CSR0_IDON)
435                         break;
436         if (i <= 0 || (DREG & CSR0_ERR)) {
437                 DPRINTK( 2, ( "lance_open(): opening %s failed, i=%d, csr0=%04x\n",
438                                           dev->name, i, DREG ));
439                 DREG = CSR0_STOP;
440                 return( -EIO );
441         }
442
443         DREG = CSR0_IDON | CSR0_STRT | CSR0_INEA;
444
445         netif_start_queue(dev);
446
447         DPRINTK( 2, ( "%s: LANCE is open, csr0 %04x\n", dev->name, DREG ));
448
449         return( 0 );
450 }
451
452
453 /* Initialize the LANCE Rx and Tx rings. */
454
455 static void lance_init_ring( struct net_device *dev )
456 {
457         struct lance_private *lp = netdev_priv(dev);
458         int i;
459
460         lp->lock = 0;
461         lp->tx_full = 0;
462         lp->new_rx = lp->new_tx = 0;
463         lp->old_rx = lp->old_tx = 0;
464
465         for( i = 0; i < TX_RING_SIZE; i++ ) {
466                 MEM->tx_head[i].base = dvma_vtob(MEM->tx_data[i]);
467                 MEM->tx_head[i].flag = 0;
468                 MEM->tx_head[i].base_hi =
469                         (dvma_vtob(MEM->tx_data[i])) >>16;
470                 MEM->tx_head[i].length = 0;
471                 MEM->tx_head[i].misc = 0;
472         }
473
474         for( i = 0; i < RX_RING_SIZE; i++ ) {
475                 MEM->rx_head[i].base = dvma_vtob(MEM->rx_data[i]);
476                 MEM->rx_head[i].flag = RMD1_OWN_CHIP;
477                 MEM->rx_head[i].base_hi =
478                         (dvma_vtob(MEM->rx_data[i])) >> 16;
479                 MEM->rx_head[i].buf_length = -PKT_BUF_SZ | 0xf000;
480                 MEM->rx_head[i].msg_length = 0;
481         }
482
483         /* tell the card it's ether address, bytes swapped */
484         MEM->init.hwaddr[0] = dev->dev_addr[1];
485         MEM->init.hwaddr[1] = dev->dev_addr[0];
486         MEM->init.hwaddr[2] = dev->dev_addr[3];
487         MEM->init.hwaddr[3] = dev->dev_addr[2];
488         MEM->init.hwaddr[4] = dev->dev_addr[5];
489         MEM->init.hwaddr[5] = dev->dev_addr[4];
490
491         MEM->init.mode = 0x0000;
492         MEM->init.filter[0] = 0x00000000;
493         MEM->init.filter[1] = 0x00000000;
494         MEM->init.rdra = dvma_vtob(MEM->rx_head);
495         MEM->init.rlen    = (RX_LOG_RING_SIZE << 13) |
496                 (dvma_vtob(MEM->rx_head) >> 16);
497         MEM->init.tdra = dvma_vtob(MEM->tx_head);
498         MEM->init.tlen    = (TX_LOG_RING_SIZE << 13) |
499                 (dvma_vtob(MEM->tx_head) >> 16);
500
501
502         /* tell the lance the address of its init block */
503         REGA(CSR1) = dvma_vtob(&(MEM->init));
504         REGA(CSR2) = dvma_vtob(&(MEM->init)) >> 16;
505
506 #ifdef CONFIG_SUN3X
507         REGA(CSR3) = CSR3_BSWP | CSR3_ACON | CSR3_BCON;
508 #else
509         REGA(CSR3) = CSR3_BSWP;
510 #endif
511
512 }
513
514
515 static int lance_start_xmit( struct sk_buff *skb, struct net_device *dev )
516 {
517         struct lance_private *lp = netdev_priv(dev);
518         int entry, len;
519         struct lance_tx_head *head;
520         unsigned long flags;
521
522         DPRINTK( 1, ( "%s: transmit start.\n",
523                       dev->name));
524
525         /* Transmitter timeout, serious problems. */
526         if (netif_queue_stopped(dev)) {
527                 int tickssofar = jiffies - dev->trans_start;
528                 if (tickssofar < 20)
529                         return NETDEV_TX_BUSY;
530
531                 DPRINTK( 1, ( "%s: transmit timed out, status %04x, resetting.\n",
532                                           dev->name, DREG ));
533                 DREG = CSR0_STOP;
534                 /*
535                  * Always set BSWP after a STOP as STOP puts it back into
536                  * little endian mode.
537                  */
538                 REGA(CSR3) = CSR3_BSWP;
539                 dev->stats.tx_errors++;
540
541                 if(lance_debug >= 2) {
542                         int i;
543                         printk("Ring data: old_tx %d new_tx %d%s new_rx %d\n",
544                                lp->old_tx, lp->new_tx,
545                                lp->tx_full ? " (full)" : "",
546                                lp->new_rx );
547                         for( i = 0 ; i < RX_RING_SIZE; i++ )
548                                 printk( "rx #%d: base=%04x blen=%04x mlen=%04x\n",
549                                         i, MEM->rx_head[i].base,
550                                         -MEM->rx_head[i].buf_length,
551                                         MEM->rx_head[i].msg_length);
552                         for( i = 0 ; i < TX_RING_SIZE; i++ )
553                                 printk("tx #%d: base=%04x len=%04x misc=%04x\n",
554                                        i, MEM->tx_head[i].base,
555                                        -MEM->tx_head[i].length,
556                                        MEM->tx_head[i].misc );
557                 }
558
559                 lance_init_ring(dev);
560                 REGA( CSR0 ) = CSR0_INEA | CSR0_INIT | CSR0_STRT;
561
562                 netif_start_queue(dev);
563                 dev->trans_start = jiffies;
564
565                 return 0;
566         }
567
568
569         /* Block a timer-based transmit from overlapping.  This could better be
570            done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
571
572         /* Block a timer-based transmit from overlapping with us by
573            stopping the queue for a bit... */
574
575         netif_stop_queue(dev);
576
577         if (test_and_set_bit( 0, (void*)&lp->lock ) != 0) {
578                 printk( "%s: tx queue lock!.\n", dev->name);
579                 /* don't clear dev->tbusy flag. */
580                 return NETDEV_TX_BUSY;
581         }
582
583         AREG = CSR0;
584         DPRINTK( 2, ( "%s: lance_start_xmit() called, csr0 %4.4x.\n",
585                                   dev->name, DREG ));
586
587 #ifdef CONFIG_SUN3X
588         /* this weirdness doesn't appear on sun3... */
589         if(!(DREG & CSR0_INIT)) {
590                 DPRINTK( 1, ("INIT not set, reinitializing...\n"));
591                 REGA( CSR0 ) = CSR0_STOP;
592                 lance_init_ring(dev);
593                 REGA( CSR0 ) = CSR0_INIT | CSR0_STRT;
594         }
595 #endif
596
597         /* Fill in a Tx ring entry */
598 #if 0
599         if (lance_debug >= 2) {
600                 printk( "%s: TX pkt %d type 0x%04x"
601                         " from %s to %s"
602                         " data at 0x%08x len %d\n",
603                         dev->name, lp->new_tx, ((u_short *)skb->data)[6],
604                         DEV_ADDR(&skb->data[6]), DEV_ADDR(skb->data),
605                         (int)skb->data, (int)skb->len );
606         }
607 #endif
608         /* We're not prepared for the int until the last flags are set/reset.
609          * And the int may happen already after setting the OWN_CHIP... */
610         local_irq_save(flags);
611
612         /* Mask to ring buffer boundary. */
613         entry = lp->new_tx;
614         head  = &(MEM->tx_head[entry]);
615
616         /* Caution: the write order is important here, set the "ownership" bits
617          * last.
618          */
619
620         /* the sun3's lance needs it's buffer padded to the minimum
621            size */
622         len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
623
624 //      head->length = -len;
625         head->length = (-len) | 0xf000;
626         head->misc = 0;
627
628         skb_copy_from_linear_data(skb, PKTBUF_ADDR(head), skb->len);
629         if (len != skb->len)
630                 memset(PKTBUF_ADDR(head) + skb->len, 0, len-skb->len);
631
632         head->flag = TMD1_OWN_CHIP | TMD1_ENP | TMD1_STP;
633         lp->new_tx = (lp->new_tx + 1) & TX_RING_MOD_MASK;
634         dev->stats.tx_bytes += skb->len;
635
636         /* Trigger an immediate send poll. */
637         REGA(CSR0) = CSR0_INEA | CSR0_TDMD | CSR0_STRT;
638         AREG = CSR0;
639         DPRINTK( 2, ( "%s: lance_start_xmit() exiting, csr0 %4.4x.\n",
640                                   dev->name, DREG ));
641         dev->trans_start = jiffies;
642         dev_kfree_skb( skb );
643
644         lp->lock = 0;
645         if ((MEM->tx_head[(entry+1) & TX_RING_MOD_MASK].flag & TMD1_OWN) ==
646             TMD1_OWN_HOST)
647                 netif_start_queue(dev);
648
649         local_irq_restore(flags);
650
651         return 0;
652 }
653
654 /* The LANCE interrupt handler. */
655
656 static irqreturn_t lance_interrupt( int irq, void *dev_id)
657 {
658         struct net_device *dev = dev_id;
659         struct lance_private *lp = netdev_priv(dev);
660         int csr0;
661         static int in_interrupt;
662
663         if (dev == NULL) {
664                 DPRINTK( 1, ( "lance_interrupt(): invalid dev_id\n" ));
665                 return IRQ_NONE;
666         }
667
668         if (in_interrupt)
669                 DPRINTK( 2, ( "%s: Re-entering the interrupt handler.\n", dev->name ));
670         in_interrupt = 1;
671
672  still_more:
673         flush_cache_all();
674
675         AREG = CSR0;
676         csr0 = DREG;
677
678         /* ack interrupts */
679         DREG = csr0 & (CSR0_TINT | CSR0_RINT | CSR0_IDON);
680
681         /* clear errors */
682         if(csr0 & CSR0_ERR)
683                 DREG = CSR0_BABL | CSR0_MERR | CSR0_CERR | CSR0_MISS;
684
685
686         DPRINTK( 2, ( "%s: interrupt  csr0=%04x new csr=%04x.\n",
687                       dev->name, csr0, DREG ));
688
689         if (csr0 & CSR0_TINT) {                 /* Tx-done interrupt */
690                 int old_tx = lp->old_tx;
691
692 //              if(lance_debug >= 3) {
693 //                      int i;
694 //
695 //                      printk("%s: tx int\n", dev->name);
696 //
697 //                      for(i = 0; i < TX_RING_SIZE; i++)
698 //                              printk("ring %d flag=%04x\n", i,
699 //                                     MEM->tx_head[i].flag);
700 //              }
701
702                 while( old_tx != lp->new_tx) {
703                         struct lance_tx_head *head = &(MEM->tx_head[old_tx]);
704
705                         DPRINTK(3, ("on tx_ring %d\n", old_tx));
706
707                         if (head->flag & TMD1_OWN_CHIP)
708                                 break; /* It still hasn't been Txed */
709
710                         if (head->flag & TMD1_ERR) {
711                                 int status = head->misc;
712                                 dev->stats.tx_errors++;
713                                 if (status & TMD3_RTRY) dev->stats.tx_aborted_errors++;
714                                 if (status & TMD3_LCAR) dev->stats.tx_carrier_errors++;
715                                 if (status & TMD3_LCOL) dev->stats.tx_window_errors++;
716                                 if (status & (TMD3_UFLO | TMD3_BUFF)) {
717                                         dev->stats.tx_fifo_errors++;
718                                         printk("%s: Tx FIFO error\n",
719                                                dev->name);
720                                         REGA(CSR0) = CSR0_STOP;
721                                         REGA(CSR3) = CSR3_BSWP;
722                                         lance_init_ring(dev);
723                                         REGA(CSR0) = CSR0_STRT | CSR0_INEA;
724                                         return IRQ_HANDLED;
725                                 }
726                         } else if(head->flag & (TMD1_ENP | TMD1_STP)) {
727
728                                 head->flag &= ~(TMD1_ENP | TMD1_STP);
729                                 if(head->flag & (TMD1_ONE | TMD1_MORE))
730                                         dev->stats.collisions++;
731
732                                 dev->stats.tx_packets++;
733                                 DPRINTK(3, ("cleared tx ring %d\n", old_tx));
734                         }
735                         old_tx = (old_tx +1) & TX_RING_MOD_MASK;
736                 }
737
738                 lp->old_tx = old_tx;
739         }
740
741
742         if (netif_queue_stopped(dev)) {
743                 /* The ring is no longer full, clear tbusy. */
744                 netif_start_queue(dev);
745                 netif_wake_queue(dev);
746         }
747
748         if (csr0 & CSR0_RINT)                   /* Rx interrupt */
749                 lance_rx( dev );
750
751         /* Log misc errors. */
752         if (csr0 & CSR0_BABL) dev->stats.tx_errors++; /* Tx babble. */
753         if (csr0 & CSR0_MISS) dev->stats.rx_errors++; /* Missed a Rx frame. */
754         if (csr0 & CSR0_MERR) {
755                 DPRINTK( 1, ( "%s: Bus master arbitration failure (?!?), "
756                               "status %04x.\n", dev->name, csr0 ));
757                 /* Restart the chip. */
758                 REGA(CSR0) = CSR0_STOP;
759                 REGA(CSR3) = CSR3_BSWP;
760                 lance_init_ring(dev);
761                 REGA(CSR0) = CSR0_STRT | CSR0_INEA;
762         }
763
764
765     /* Clear any other interrupt, and set interrupt enable. */
766 //      DREG = CSR0_BABL | CSR0_CERR | CSR0_MISS | CSR0_MERR |
767 //                 CSR0_IDON | CSR0_INEA;
768
769         REGA(CSR0) = CSR0_INEA;
770
771         if(DREG & (CSR0_RINT | CSR0_TINT)) {
772              DPRINTK(2, ("restarting interrupt, csr0=%#04x\n", DREG));
773              goto still_more;
774         }
775
776         DPRINTK( 2, ( "%s: exiting interrupt, csr0=%#04x.\n",
777                                   dev->name, DREG ));
778         in_interrupt = 0;
779         return IRQ_HANDLED;
780 }
781
782 /* get packet, toss into skbuff */
783 static int lance_rx( struct net_device *dev )
784 {
785         struct lance_private *lp = netdev_priv(dev);
786         int entry = lp->new_rx;
787
788         /* If we own the next entry, it's a new packet. Send it up. */
789         while( (MEM->rx_head[entry].flag & RMD1_OWN) == RMD1_OWN_HOST ) {
790                 struct lance_rx_head *head = &(MEM->rx_head[entry]);
791                 int status = head->flag;
792
793                 if (status != (RMD1_ENP|RMD1_STP)) {  /* There was an error. */
794                         /* There is a tricky error noted by John Murphy,
795                            <murf@perftech.com> to Russ Nelson: Even with
796                            full-sized buffers it's possible for a jabber packet to use two
797                            buffers, with only the last correctly noting the error. */
798                         if (status & RMD1_ENP)  /* Only count a general error at the */
799                                 dev->stats.rx_errors++; /* end of a packet.*/
800                         if (status & RMD1_FRAM) dev->stats.rx_frame_errors++;
801                         if (status & RMD1_OFLO) dev->stats.rx_over_errors++;
802                         if (status & RMD1_CRC) dev->stats.rx_crc_errors++;
803                         if (status & RMD1_BUFF) dev->stats.rx_fifo_errors++;
804                         head->flag &= (RMD1_ENP|RMD1_STP);
805                 } else {
806                         /* Malloc up new buffer, compatible with net-3. */
807 //                      short pkt_len = head->msg_length;// & 0xfff;
808                         short pkt_len = (head->msg_length & 0xfff) - 4;
809                         struct sk_buff *skb;
810
811                         if (pkt_len < 60) {
812                                 printk( "%s: Runt packet!\n", dev->name );
813                                 dev->stats.rx_errors++;
814                         }
815                         else {
816                                 skb = dev_alloc_skb( pkt_len+2 );
817                                 if (skb == NULL) {
818                                         DPRINTK( 1, ( "%s: Memory squeeze, deferring packet.\n",
819                                                       dev->name ));
820
821                                         dev->stats.rx_dropped++;
822                                         head->msg_length = 0;
823                                         head->flag |= RMD1_OWN_CHIP;
824                                         lp->new_rx = (lp->new_rx+1) &
825                                              RX_RING_MOD_MASK;
826                                 }
827
828 #if 0
829                                 if (lance_debug >= 3) {
830                                         u_char *data = PKTBUF_ADDR(head);
831                                         printk("%s: RX pkt %d type 0x%04x"
832                                                " from %pM to %pM",
833                                                dev->name, lp->new_tx, ((u_short *)data)[6],
834                                                &data[6], data);
835
836                                         printk(" data %02x %02x %02x %02x %02x %02x %02x %02x "
837                                                "len %d at %08x\n",
838                                                data[15], data[16], data[17], data[18],
839                                                data[19], data[20], data[21], data[22],
840                                                pkt_len, data);
841                                 }
842 #endif
843                                 if (lance_debug >= 3) {
844                                         u_char *data = PKTBUF_ADDR(head);
845                                         printk( "%s: RX pkt %d type 0x%04x len %d\n ", dev->name, entry, ((u_short *)data)[6], pkt_len);
846                                 }
847
848
849                                 skb_reserve( skb, 2 );  /* 16 byte align */
850                                 skb_put( skb, pkt_len );        /* Make room */
851                                 skb_copy_to_linear_data(skb,
852                                                  PKTBUF_ADDR(head),
853                                                  pkt_len);
854
855                                 skb->protocol = eth_type_trans( skb, dev );
856                                 netif_rx( skb );
857                                 dev->stats.rx_packets++;
858                                 dev->stats.rx_bytes += pkt_len;
859                         }
860                 }
861
862 //              head->buf_length = -PKT_BUF_SZ | 0xf000;
863                 head->msg_length = 0;
864                 head->flag = RMD1_OWN_CHIP;
865
866                 entry = lp->new_rx = (lp->new_rx +1) & RX_RING_MOD_MASK;
867         }
868
869         /* From lance.c (Donald Becker): */
870         /* We should check that at least two ring entries are free.
871            If not, we should free one and mark stats->rx_dropped++. */
872
873         return 0;
874 }
875
876
877 static int lance_close( struct net_device *dev )
878 {
879         struct lance_private *lp = netdev_priv(dev);
880
881         netif_stop_queue(dev);
882
883         AREG = CSR0;
884
885         DPRINTK( 2, ( "%s: Shutting down ethercard, status was %2.2x.\n",
886                                   dev->name, DREG ));
887
888         /* We stop the LANCE here -- it occasionally polls
889            memory if we don't. */
890         DREG = CSR0_STOP;
891         return 0;
892 }
893
894
895 /* Set or clear the multicast filter for this adaptor.
896    num_addrs == -1              Promiscuous mode, receive all packets
897    num_addrs == 0               Normal mode, clear multicast list
898    num_addrs > 0                Multicast mode, receive normal and MC packets, and do
899                                                 best-effort filtering.
900  */
901
902 /* completely untested on a sun3 */
903 static void set_multicast_list( struct net_device *dev )
904 {
905         struct lance_private *lp = netdev_priv(dev);
906
907         if(netif_queue_stopped(dev))
908                 /* Only possible if board is already started */
909                 return;
910
911         /* We take the simple way out and always enable promiscuous mode. */
912         DREG = CSR0_STOP; /* Temporarily stop the lance. */
913
914         if (dev->flags & IFF_PROMISC) {
915                 /* Log any net taps. */
916                 DPRINTK( 3, ( "%s: Promiscuous mode enabled.\n", dev->name ));
917                 REGA( CSR15 ) = 0x8000; /* Set promiscuous mode */
918         } else {
919                 short multicast_table[4];
920                 int num_addrs = dev->mc_count;
921                 int i;
922                 /* We don't use the multicast table, but rely on upper-layer
923                  * filtering. */
924                 memset( multicast_table, (num_addrs == 0) ? 0 : -1,
925                                 sizeof(multicast_table) );
926                 for( i = 0; i < 4; i++ )
927                         REGA( CSR8+i ) = multicast_table[i];
928                 REGA( CSR15 ) = 0; /* Unset promiscuous mode */
929         }
930
931         /*
932          * Always set BSWP after a STOP as STOP puts it back into
933          * little endian mode.
934          */
935         REGA( CSR3 ) = CSR3_BSWP;
936
937         /* Resume normal operation and reset AREG to CSR0 */
938         REGA( CSR0 ) = CSR0_IDON | CSR0_INEA | CSR0_STRT;
939 }
940
941
942 #ifdef MODULE
943
944 static struct net_device *sun3lance_dev;
945
946 int __init init_module(void)
947 {
948         sun3lance_dev = sun3lance_probe(-1);
949         if (IS_ERR(sun3lance_dev))
950                 return PTR_ERR(sun3lance_dev);
951         return 0;
952 }
953
954 void __exit cleanup_module(void)
955 {
956         unregister_netdev(sun3lance_dev);
957 #ifdef CONFIG_SUN3
958         iounmap((void __iomem *)sun3lance_dev->base_addr);
959 #endif
960         free_netdev(sun3lance_dev);
961 }
962
963 #endif /* MODULE */
964