96e06c51b75d36790a989e4ce4f11794836f2af5
[linux-3.10.git] / drivers / net / sk_mca.c
1 /*
2 net-3-driver for the SKNET MCA-based cards
3
4 This is an extension to the Linux operating system, and is covered by the
5 same GNU General Public License that covers that work.
6
7 Copyright 1999 by Alfred Arnold (alfred@ccac.rwth-aachen.de,
8                                  alfred.arnold@lancom.de)
9
10 This driver is based both on the 3C523 driver and the SK_G16 driver.
11
12 paper sources:
13   'PC Hardware: Aufbau, Funktionsweise, Programmierung' by
14   Hans-Peter Messmer for the basic Microchannel stuff
15
16   'Linux Geraetetreiber' by Allesandro Rubini, Kalle Dalheimer
17   for help on Ethernet driver programming
18
19   'Ethernet/IEEE 802.3 Family 1992 World Network Data Book/Handbook' by AMD
20   for documentation on the AM7990 LANCE
21
22   'SKNET Personal Technisches Manual', Version 1.2 by Schneider&Koch
23   for documentation on the Junior board
24
25   'SK-NET MC2+ Technical Manual", Version 1.1 by Schneider&Koch for
26   documentation on the MC2 bord
27
28   A big thank you to the S&K support for providing me so quickly with
29   documentation!
30
31   Also see http://www.syskonnect.com/
32
33   Missing things:
34
35   -> set debug level via ioctl instead of compile-time switches
36   -> I didn't follow the development of the 2.1.x kernels, so my
37      assumptions about which things changed with which kernel version
38      are probably nonsense
39
40 History:
41   May 16th, 1999
42         startup
43   May 22st, 1999
44         added private structure, methods
45         begun building data structures in RAM
46   May 23nd, 1999
47         can receive frames, send frames
48   May 24th, 1999
49         modularized initialization of LANCE
50         loadable as module
51         still Tx problem :-(
52   May 26th, 1999
53         MC2 works
54         support for multiple devices
55         display media type for MC2+
56   May 28th, 1999
57         fixed problem in GetLANCE leaving interrupts turned off
58         increase TX queue to 4 packets to improve send performance
59   May 29th, 1999
60         a few corrections in statistics, caught rcvr overruns
61         reinitialization of LANCE/board in critical situations
62         MCA info implemented
63         implemented LANCE multicast filter
64   Jun 6th, 1999
65         additions for Linux 2.2
66   Dec 25th, 1999
67         unfortunately there seem to be newer MC2+ boards that react
68         on IRQ 3/5/9/10 instead of 3/5/10/11, so we have to autoprobe
69         in questionable cases...
70   Dec 28th, 1999
71         integrated patches from David Weinehall & Bill Wendling for 2.3
72         kernels (isa_...functions).  Things are defined in a way that
73         it still works with 2.0.x 8-)
74   Dec 30th, 1999
75         added handling of the remaining interrupt conditions.  That
76         should cure the spurious hangs.
77   Jan 30th, 2000
78         newer kernels automatically probe more than one board, so the
79         'startslot' as a variable is also needed here
80   June 1st, 2000
81         added changes for recent 2.3 kernels
82
83  *************************************************************************/
84
85 #include <linux/kernel.h>
86 #include <linux/string.h>
87 #include <linux/errno.h>
88 #include <linux/ioport.h>
89 #include <linux/slab.h>
90 #include <linux/interrupt.h>
91 #include <linux/delay.h>
92 #include <linux/time.h>
93 #include <linux/mca-legacy.h>
94 #include <linux/init.h>
95 #include <linux/module.h>
96 #include <linux/netdevice.h>
97 #include <linux/etherdevice.h>
98 #include <linux/skbuff.h>
99 #include <linux/bitops.h>
100
101 #include <asm/processor.h>
102 #include <asm/io.h>
103
104 #define _SK_MCA_DRIVER_
105 #include "sk_mca.h"
106
107 /* ------------------------------------------------------------------------
108  * global static data - not more since we can handle multiple boards and
109  * have to pack all state info into the device struct!
110  * ------------------------------------------------------------------------ */
111
112 static char *MediaNames[Media_Count] =
113     { "10Base2", "10BaseT", "10Base5", "Unknown" };
114
115 static unsigned char poly[] =
116     { 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0,
117         1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0
118 };
119
120 /* ------------------------------------------------------------------------
121  * private subfunctions
122  * ------------------------------------------------------------------------ */
123
124 /* dump parts of shared memory - only needed during debugging */
125
126 #ifdef DEBUG
127 static void dumpmem(struct net_device *dev, u32 start, u32 len)
128 {
129         skmca_priv *priv = netdev_priv(dev);
130         int z;
131
132         for (z = 0; z < len; z++) {
133                 if ((z & 15) == 0)
134                         printk("%04x:", z);
135                 printk(" %02x", readb(priv->base + start + z));
136                 if ((z & 15) == 15)
137                         printk("\n");
138         }
139 }
140
141 /* print exact time - ditto */
142
143 static void PrTime(void)
144 {
145         struct timeval tv;
146
147         do_gettimeofday(&tv);
148         printk("%9d:%06d: ", tv.tv_sec, tv.tv_usec);
149 }
150 #endif
151
152 /* deduce resources out of POS registers */
153
154 static void __init getaddrs(int slot, int junior, int *base, int *irq,
155                      skmca_medium * medium)
156 {
157         u_char pos0, pos1, pos2;
158
159         if (junior) {
160                 pos0 = mca_read_stored_pos(slot, 2);
161                 *base = ((pos0 & 0x0e) << 13) + 0xc0000;
162                 *irq = ((pos0 & 0x10) >> 4) + 10;
163                 *medium = Media_Unknown;
164         } else {
165                 /* reset POS 104 Bits 0+1 so the shared memory region goes to the
166                    configured area between 640K and 1M.  Afterwards, enable the MC2.
167                    I really don't know what rode SK to do this... */
168
169                 mca_write_pos(slot, 4,
170                               mca_read_stored_pos(slot, 4) & 0xfc);
171                 mca_write_pos(slot, 2,
172                               mca_read_stored_pos(slot, 2) | 0x01);
173
174                 pos1 = mca_read_stored_pos(slot, 3);
175                 pos2 = mca_read_stored_pos(slot, 4);
176                 *base = ((pos1 & 0x07) << 14) + 0xc0000;
177                 switch (pos2 & 0x0c) {
178                 case 0:
179                         *irq = 3;
180                         break;
181                 case 4:
182                         *irq = 5;
183                         break;
184                 case 8:
185                         *irq = -10;
186                         break;
187                 case 12:
188                         *irq = -11;
189                         break;
190                 }
191                 *medium = (pos2 >> 6) & 3;
192         }
193 }
194
195 /* check for both cards:
196    When the MC2 is turned off, it was configured for more than 15MB RAM,
197    is disabled and won't get detected using the standard probe.  We
198    therefore have to scan the slots manually :-( */
199
200 static int __init dofind(int *junior, int firstslot)
201 {
202         int slot;
203         unsigned int id;
204
205         for (slot = firstslot; slot < MCA_MAX_SLOT_NR; slot++) {
206                 id = mca_read_stored_pos(slot, 0)
207                     + (((unsigned int) mca_read_stored_pos(slot, 1)) << 8);
208
209                 *junior = 0;
210                 if (id == SKNET_MCA_ID)
211                         return slot;
212                 *junior = 1;
213                 if (id == SKNET_JUNIOR_MCA_ID)
214                         return slot;
215         }
216         return MCA_NOTFOUND;
217 }
218
219 /* reset the whole board */
220
221 static void ResetBoard(struct net_device *dev)
222 {
223         skmca_priv *priv = netdev_priv(dev);
224
225         writeb(CTRL_RESET_ON, priv->ctrladdr);
226         udelay(10);
227         writeb(CTRL_RESET_OFF, priv->ctrladdr);
228 }
229
230 /* wait for LANCE interface to become not busy */
231
232 static int WaitLANCE(struct net_device *dev)
233 {
234         skmca_priv *priv = netdev_priv(dev);
235         int t = 0;
236
237         while ((readb(priv->ctrladdr) & STAT_IO_BUSY) ==
238                STAT_IO_BUSY) {
239                 udelay(1);
240                 if (++t > 1000) {
241                         printk("%s: LANCE access timeout", dev->name);
242                         return 0;
243                 }
244         }
245
246         return 1;
247 }
248
249 /* set LANCE register - must be atomic */
250
251 static void SetLANCE(struct net_device *dev, u16 addr, u16 value)
252 {
253         skmca_priv *priv = netdev_priv(dev);
254         unsigned long flags;
255
256         /* disable interrupts */
257
258         spin_lock_irqsave(&priv->lock, flags);
259
260         /* wait until no transfer is pending */
261
262         WaitLANCE(dev);
263
264         /* transfer register address to RAP */
265
266         writeb(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_RAP, priv->ctrladdr);
267         writew(addr, priv->ioregaddr);
268         writeb(IOCMD_GO, priv->cmdaddr);
269         udelay(1);
270         WaitLANCE(dev);
271
272         /* transfer data to register */
273
274         writeb(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_DATA, priv->ctrladdr);
275         writew(value, priv->ioregaddr);
276         writeb(IOCMD_GO, priv->cmdaddr);
277         udelay(1);
278         WaitLANCE(dev);
279
280         /* reenable interrupts */
281
282         spin_unlock_irqrestore(&priv->lock, flags);
283 }
284
285 /* get LANCE register */
286
287 static u16 GetLANCE(struct net_device *dev, u16 addr)
288 {
289         skmca_priv *priv = netdev_priv(dev);
290         unsigned long flags;
291         unsigned int res;
292
293         /* disable interrupts */
294
295         spin_lock_irqsave(&priv->lock, flags);
296
297         /* wait until no transfer is pending */
298
299         WaitLANCE(dev);
300
301         /* transfer register address to RAP */
302
303         writeb(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_RAP, priv->ctrladdr);
304         writew(addr, priv->ioregaddr);
305         writeb(IOCMD_GO, priv->cmdaddr);
306         udelay(1);
307         WaitLANCE(dev);
308
309         /* transfer data from register */
310
311         writeb(CTRL_RESET_OFF | CTRL_RW_READ | CTRL_ADR_DATA, priv->ctrladdr);
312         writeb(IOCMD_GO, priv->cmdaddr);
313         udelay(1);
314         WaitLANCE(dev);
315         res = readw(priv->ioregaddr);
316
317         /* reenable interrupts */
318
319         spin_unlock_irqrestore(&priv->lock, flags);
320
321         return res;
322 }
323
324 /* build up descriptors in shared RAM */
325
326 static void InitDscrs(struct net_device *dev)
327 {
328         skmca_priv *priv = netdev_priv(dev);
329         u32 bufaddr;
330
331         /* Set up Tx descriptors. The board has only 16K RAM so bits 16..23
332            are always 0. */
333
334         bufaddr = RAM_DATABASE;
335         {
336                 LANCE_TxDescr descr;
337                 int z;
338
339                 for (z = 0; z < TXCOUNT; z++) {
340                         descr.LowAddr = bufaddr;
341                         descr.Flags = 0;
342                         descr.Len = 0xf000;
343                         descr.Status = 0;
344                         memcpy_toio(priv->base + RAM_TXBASE +
345                                    (z * sizeof(LANCE_TxDescr)), &descr,
346                                    sizeof(LANCE_TxDescr));
347                         memset_io(priv->base + bufaddr, 0, RAM_BUFSIZE);
348                         bufaddr += RAM_BUFSIZE;
349                 }
350         }
351
352         /* do the same for the Rx descriptors */
353
354         {
355                 LANCE_RxDescr descr;
356                 int z;
357
358                 for (z = 0; z < RXCOUNT; z++) {
359                         descr.LowAddr = bufaddr;
360                         descr.Flags = RXDSCR_FLAGS_OWN;
361                         descr.MaxLen = -RAM_BUFSIZE;
362                         descr.Len = 0;
363                         memcpy_toio(priv->base + RAM_RXBASE +
364                                    (z * sizeof(LANCE_RxDescr)), &descr,
365                                    sizeof(LANCE_RxDescr));
366                         memset_io(priv->base + bufaddr, 0, RAM_BUFSIZE);
367                         bufaddr += RAM_BUFSIZE;
368                 }
369         }
370 }
371
372 /* calculate the hash bit position for a given multicast address
373    taken more or less directly from the AMD datasheet... */
374
375 static void UpdateCRC(unsigned char *CRC, int bit)
376 {
377         int j;
378
379         /* shift CRC one bit */
380
381         memmove(CRC + 1, CRC, 32 * sizeof(unsigned char));
382         CRC[0] = 0;
383
384         /* if bit XOR controlbit = 1, set CRC = CRC XOR polynomial */
385
386         if (bit ^ CRC[32])
387                 for (j = 0; j < 32; j++)
388                         CRC[j] ^= poly[j];
389 }
390
391 static unsigned int GetHash(char *address)
392 {
393         unsigned char CRC[33];
394         int i, byte, hashcode;
395
396         /* a multicast address has bit 0 in the first byte set */
397
398         if ((address[0] & 1) == 0)
399                 return -1;
400
401         /* initialize CRC */
402
403         memset(CRC, 1, sizeof(CRC));
404
405         /* loop through address bits */
406
407         for (byte = 0; byte < 6; byte++)
408                 for (i = 0; i < 8; i++)
409                         UpdateCRC(CRC, (address[byte] >> i) & 1);
410
411         /* hashcode is the 6 least significant bits of the CRC */
412
413         hashcode = 0;
414         for (i = 0; i < 6; i++)
415                 hashcode = (hashcode << 1) + CRC[i];
416         return hashcode;
417 }
418
419 /* feed ready-built initialization block into LANCE */
420
421 static void InitLANCE(struct net_device *dev)
422 {
423         skmca_priv *priv = netdev_priv(dev);
424
425         /* build up descriptors. */
426
427         InitDscrs(dev);
428
429         /* next RX descriptor to be read is the first one.  Since the LANCE
430            will start from the beginning after initialization, we have to
431            reset out pointers too. */
432
433         priv->nextrx = 0;
434
435         /* no TX descriptors active */
436
437         priv->nexttxput = priv->nexttxdone = priv->txbusy = 0;
438
439         /* set up the LANCE bus control register - constant for SKnet boards */
440
441         SetLANCE(dev, LANCE_CSR3,
442                  CSR3_BSWAP_OFF | CSR3_ALE_LOW | CSR3_BCON_HOLD);
443
444         /* write address of initialization block into LANCE */
445
446         SetLANCE(dev, LANCE_CSR1, RAM_INITBASE & 0xffff);
447         SetLANCE(dev, LANCE_CSR2, (RAM_INITBASE >> 16) & 0xff);
448
449         /* we don't get ready until the LANCE has read the init block */
450
451         netif_stop_queue(dev);
452
453         /* let LANCE read the initialization block.  LANCE is ready
454            when we receive the corresponding interrupt. */
455
456         SetLANCE(dev, LANCE_CSR0, CSR0_INEA | CSR0_INIT);
457 }
458
459 /* stop the LANCE so we can reinitialize it */
460
461 static void StopLANCE(struct net_device *dev)
462 {
463         /* can't take frames any more */
464
465         netif_stop_queue(dev);
466
467         /* disable interrupts, stop it */
468
469         SetLANCE(dev, LANCE_CSR0, CSR0_STOP);
470 }
471
472 /* initialize card and LANCE for proper operation */
473
474 static void InitBoard(struct net_device *dev)
475 {
476         skmca_priv *priv = netdev_priv(dev);
477         LANCE_InitBlock block;
478
479         /* Lay out the shared RAM - first we create the init block for the LANCE.
480            We do not overwrite it later because we need it again when we switch
481            promiscous mode on/off. */
482
483         block.Mode = 0;
484         if (dev->flags & IFF_PROMISC)
485                 block.Mode |= LANCE_INIT_PROM;
486         memcpy(block.PAdr, dev->dev_addr, 6);
487         memset(block.LAdrF, 0, sizeof(block.LAdrF));
488         block.RdrP = (RAM_RXBASE & 0xffffff) | (LRXCOUNT << 29);
489         block.TdrP = (RAM_TXBASE & 0xffffff) | (LTXCOUNT << 29);
490
491         memcpy_toio(priv->base + RAM_INITBASE, &block, sizeof(block));
492
493         /* initialize LANCE. Implicitly sets up other structures in RAM. */
494
495         InitLANCE(dev);
496 }
497
498 /* deinitialize card and LANCE */
499
500 static void DeinitBoard(struct net_device *dev)
501 {
502         /* stop LANCE */
503
504         StopLANCE(dev);
505
506         /* reset board */
507
508         ResetBoard(dev);
509 }
510
511 /* probe for device's irq */
512
513 static int __init ProbeIRQ(struct net_device *dev)
514 {
515         unsigned long imaskval, njiffies, irq;
516         u16 csr0val;
517
518         /* enable all interrupts */
519
520         imaskval = probe_irq_on();
521
522         /* initialize the board. Wait for interrupt 'Initialization done'. */
523
524         ResetBoard(dev);
525         InitBoard(dev);
526
527         njiffies = jiffies + HZ;
528         do {
529                 csr0val = GetLANCE(dev, LANCE_CSR0);
530         }
531         while (((csr0val & CSR0_IDON) == 0) && (jiffies != njiffies));
532
533         /* turn of interrupts again */
534
535         irq = probe_irq_off(imaskval);
536
537         /* if we found something, ack the interrupt */
538
539         if (irq)
540                 SetLANCE(dev, LANCE_CSR0, csr0val | CSR0_IDON);
541
542         /* back to idle state */
543
544         DeinitBoard(dev);
545
546         return irq;
547 }
548
549 /* ------------------------------------------------------------------------
550  * interrupt handler(s)
551  * ------------------------------------------------------------------------ */
552
553 /* LANCE has read initialization block -> start it */
554
555 static u16 irqstart_handler(struct net_device *dev, u16 oldcsr0)
556 {
557         /* now we're ready to transmit */
558
559         netif_wake_queue(dev);
560
561         /* reset IDON bit, start LANCE */
562
563         SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_IDON | CSR0_STRT);
564         return GetLANCE(dev, LANCE_CSR0);
565 }
566
567 /* did we lose blocks due to a FIFO overrun ? */
568
569 static u16 irqmiss_handler(struct net_device *dev, u16 oldcsr0)
570 {
571         skmca_priv *priv = netdev_priv(dev);
572
573         /* update statistics */
574
575         priv->stat.rx_fifo_errors++;
576
577         /* reset MISS bit */
578
579         SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_MISS);
580         return GetLANCE(dev, LANCE_CSR0);
581 }
582
583 /* receive interrupt */
584
585 static u16 irqrx_handler(struct net_device *dev, u16 oldcsr0)
586 {
587         skmca_priv *priv = netdev_priv(dev);
588         LANCE_RxDescr descr;
589         unsigned int descraddr;
590
591         /* run through queue until we reach a descriptor we do not own */
592
593         descraddr = RAM_RXBASE + (priv->nextrx * sizeof(LANCE_RxDescr));
594         while (1) {
595                 /* read descriptor */
596                 memcpy_fromio(&descr, priv->base + descraddr,
597                              sizeof(LANCE_RxDescr));
598
599                 /* if we reach a descriptor we do not own, we're done */
600                 if ((descr.Flags & RXDSCR_FLAGS_OWN) != 0)
601                         break;
602
603 #ifdef DEBUG
604                 PrTime();
605                 printk("Receive packet on descr %d len %d\n", priv->nextrx,
606                        descr.Len);
607 #endif
608
609                 /* erroneous packet ? */
610                 if ((descr.Flags & RXDSCR_FLAGS_ERR) != 0) {
611                         priv->stat.rx_errors++;
612                         if ((descr.Flags & RXDSCR_FLAGS_CRC) != 0)
613                                 priv->stat.rx_crc_errors++;
614                         else if ((descr.Flags & RXDSCR_FLAGS_CRC) != 0)
615                                 priv->stat.rx_frame_errors++;
616                         else if ((descr.Flags & RXDSCR_FLAGS_OFLO) != 0)
617                                 priv->stat.rx_fifo_errors++;
618                 }
619
620                 /* good packet ? */
621                 else {
622                         struct sk_buff *skb;
623
624                         skb = dev_alloc_skb(descr.Len + 2);
625                         if (skb == NULL)
626                                 priv->stat.rx_dropped++;
627                         else {
628                                 memcpy_fromio(skb_put(skb, descr.Len),
629                                              priv->base +
630                                              descr.LowAddr, descr.Len);
631                                 skb->dev = dev;
632                                 skb->protocol = eth_type_trans(skb, dev);
633                                 skb->ip_summed = CHECKSUM_NONE;
634                                 priv->stat.rx_packets++;
635                                 priv->stat.rx_bytes += descr.Len;
636                                 netif_rx(skb);
637                                 dev->last_rx = jiffies;
638                         }
639                 }
640
641                 /* give descriptor back to LANCE */
642                 descr.Len = 0;
643                 descr.Flags |= RXDSCR_FLAGS_OWN;
644
645                 /* update descriptor in shared RAM */
646                 memcpy_toio(priv->base + descraddr, &descr,
647                            sizeof(LANCE_RxDescr));
648
649                 /* go to next descriptor */
650                 priv->nextrx++;
651                 descraddr += sizeof(LANCE_RxDescr);
652                 if (priv->nextrx >= RXCOUNT) {
653                         priv->nextrx = 0;
654                         descraddr = RAM_RXBASE;
655                 }
656         }
657
658         /* reset RINT bit */
659
660         SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_RINT);
661         return GetLANCE(dev, LANCE_CSR0);
662 }
663
664 /* transmit interrupt */
665
666 static u16 irqtx_handler(struct net_device *dev, u16 oldcsr0)
667 {
668         skmca_priv *priv = netdev_priv(dev);
669         LANCE_TxDescr descr;
670         unsigned int descraddr;
671
672         /* check descriptors at most until no busy one is left */
673
674         descraddr =
675             RAM_TXBASE + (priv->nexttxdone * sizeof(LANCE_TxDescr));
676         while (priv->txbusy > 0) {
677                 /* read descriptor */
678                 memcpy_fromio(&descr, priv->base + descraddr,
679                              sizeof(LANCE_TxDescr));
680
681                 /* if the LANCE still owns this one, we've worked out all sent packets */
682                 if ((descr.Flags & TXDSCR_FLAGS_OWN) != 0)
683                         break;
684
685 #ifdef DEBUG
686                 PrTime();
687                 printk("Send packet done on descr %d\n", priv->nexttxdone);
688 #endif
689
690                 /* update statistics */
691                 if ((descr.Flags & TXDSCR_FLAGS_ERR) == 0) {
692                         priv->stat.tx_packets++;
693                         priv->stat.tx_bytes++;
694                 } else {
695                         priv->stat.tx_errors++;
696                         if ((descr.Status & TXDSCR_STATUS_UFLO) != 0) {
697                                 priv->stat.tx_fifo_errors++;
698                                 InitLANCE(dev);
699                         }
700                                 else
701                             if ((descr.Status & TXDSCR_STATUS_LCOL) !=
702                                 0) priv->stat.tx_window_errors++;
703                         else if ((descr.Status & TXDSCR_STATUS_LCAR) != 0)
704                                 priv->stat.tx_carrier_errors++;
705                         else if ((descr.Status & TXDSCR_STATUS_RTRY) != 0)
706                                 priv->stat.tx_aborted_errors++;
707                 }
708
709                 /* go to next descriptor */
710                 priv->nexttxdone++;
711                 descraddr += sizeof(LANCE_TxDescr);
712                 if (priv->nexttxdone >= TXCOUNT) {
713                         priv->nexttxdone = 0;
714                         descraddr = RAM_TXBASE;
715                 }
716                 priv->txbusy--;
717         }
718
719         /* reset TX interrupt bit */
720
721         SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_TINT);
722         oldcsr0 = GetLANCE(dev, LANCE_CSR0);
723
724         /* at least one descriptor is freed.  Therefore we can accept
725            a new one */
726         /* inform upper layers we're in business again */
727
728         netif_wake_queue(dev);
729
730         return oldcsr0;
731 }
732
733 /* general interrupt entry */
734
735 static irqreturn_t irq_handler(int irq, void *device)
736 {
737         struct net_device *dev = (struct net_device *) device;
738         u16 csr0val;
739
740         /* read CSR0 to get interrupt cause */
741
742         csr0val = GetLANCE(dev, LANCE_CSR0);
743
744         /* in case we're not meant... */
745
746         if ((csr0val & CSR0_INTR) == 0)
747                 return IRQ_NONE;
748
749 #if 0
750         set_bit(LINK_STATE_RXSEM, &dev->state);
751 #endif
752
753         /* loop through the interrupt bits until everything is clear */
754
755         do {
756                 if ((csr0val & CSR0_IDON) != 0)
757                         csr0val = irqstart_handler(dev, csr0val);
758                 if ((csr0val & CSR0_RINT) != 0)
759                         csr0val = irqrx_handler(dev, csr0val);
760                 if ((csr0val & CSR0_MISS) != 0)
761                         csr0val = irqmiss_handler(dev, csr0val);
762                 if ((csr0val & CSR0_TINT) != 0)
763                         csr0val = irqtx_handler(dev, csr0val);
764                 if ((csr0val & CSR0_MERR) != 0) {
765                         SetLANCE(dev, LANCE_CSR0, csr0val | CSR0_MERR);
766                         csr0val = GetLANCE(dev, LANCE_CSR0);
767                 }
768                 if ((csr0val & CSR0_BABL) != 0) {
769                         SetLANCE(dev, LANCE_CSR0, csr0val | CSR0_BABL);
770                         csr0val = GetLANCE(dev, LANCE_CSR0);
771                 }
772         }
773         while ((csr0val & CSR0_INTR) != 0);
774
775 #if 0
776         clear_bit(LINK_STATE_RXSEM, &dev->state);
777 #endif
778         return IRQ_HANDLED;
779 }
780
781 /* ------------------------------------------------------------------------
782  * driver methods
783  * ------------------------------------------------------------------------ */
784
785 /* MCA info */
786
787 static int skmca_getinfo(char *buf, int slot, void *d)
788 {
789         int len = 0, i;
790         struct net_device *dev = (struct net_device *) d;
791         skmca_priv *priv;
792
793         /* can't say anything about an uninitialized device... */
794
795         if (dev == NULL)
796                 return len;
797         priv = netdev_priv(dev);
798
799         /* print info */
800
801         len += sprintf(buf + len, "IRQ: %d\n", priv->realirq);
802         len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start,
803                        dev->mem_end - 1);
804         len +=
805             sprintf(buf + len, "Transceiver: %s\n",
806                     MediaNames[priv->medium]);
807         len += sprintf(buf + len, "Device: %s\n", dev->name);
808         len += sprintf(buf + len, "MAC address:");
809         for (i = 0; i < 6; i++)
810                 len += sprintf(buf + len, " %02x", dev->dev_addr[i]);
811         buf[len++] = '\n';
812         buf[len] = 0;
813
814         return len;
815 }
816
817 /* open driver.  Means also initialization and start of LANCE */
818
819 static int skmca_open(struct net_device *dev)
820 {
821         int result;
822         skmca_priv *priv = netdev_priv(dev);
823
824         /* register resources - only necessary for IRQ */
825         result =
826             request_irq(priv->realirq, irq_handler,
827                         IRQF_SHARED | IRQF_SAMPLE_RANDOM, "sk_mca", dev);
828         if (result != 0) {
829                 printk("%s: failed to register irq %d\n", dev->name,
830                        dev->irq);
831                 return result;
832         }
833         dev->irq = priv->realirq;
834
835         /* set up the card and LANCE */
836
837         InitBoard(dev);
838
839         /* set up flags */
840
841         netif_start_queue(dev);
842
843         return 0;
844 }
845
846 /* close driver.  Shut down board and free allocated resources */
847
848 static int skmca_close(struct net_device *dev)
849 {
850         /* turn off board */
851         DeinitBoard(dev);
852
853         /* release resources */
854         if (dev->irq != 0)
855                 free_irq(dev->irq, dev);
856         dev->irq = 0;
857
858         return 0;
859 }
860
861 /* transmit a block. */
862
863 static int skmca_tx(struct sk_buff *skb, struct net_device *dev)
864 {
865         skmca_priv *priv = netdev_priv(dev);
866         LANCE_TxDescr descr;
867         unsigned int address;
868         int tmplen, retval = 0;
869         unsigned long flags;
870
871         /* if we get called with a NULL descriptor, the Ethernet layer thinks
872            our card is stuck an we should reset it.  We'll do this completely: */
873
874         if (skb == NULL) {
875                 DeinitBoard(dev);
876                 InitBoard(dev);
877                 return 0;       /* don't try to free the block here ;-) */
878         }
879
880         /* is there space in the Tx queue ? If no, the upper layer gave us a
881            packet in spite of us not being ready and is really in trouble.
882            We'll do the dropping for him: */
883         if (priv->txbusy >= TXCOUNT) {
884                 priv->stat.tx_dropped++;
885                 retval = -EIO;
886                 goto tx_done;
887         }
888
889         /* get TX descriptor */
890         address = RAM_TXBASE + (priv->nexttxput * sizeof(LANCE_TxDescr));
891         memcpy_fromio(&descr, priv->base + address, sizeof(LANCE_TxDescr));
892
893         /* enter packet length as 2s complement - assure minimum length */
894         tmplen = skb->len;
895         if (tmplen < 60)
896                 tmplen = 60;
897         descr.Len = 65536 - tmplen;
898
899         /* copy filler into RAM - in case we're filling up...
900            we're filling a bit more than necessary, but that doesn't harm
901            since the buffer is far larger... */
902         if (tmplen > skb->len) {
903                 char *fill = "NetBSD is a nice OS too! ";
904                 unsigned int destoffs = 0, l = strlen(fill);
905
906                 while (destoffs < tmplen) {
907                         memcpy_toio(priv->base + descr.LowAddr +
908                                    destoffs, fill, l);
909                         destoffs += l;
910                 }
911         }
912
913         /* do the real data copying */
914         memcpy_toio(priv->base + descr.LowAddr, skb->data, skb->len);
915
916         /* hand descriptor over to LANCE - this is the first and last chunk */
917         descr.Flags =
918             TXDSCR_FLAGS_OWN | TXDSCR_FLAGS_STP | TXDSCR_FLAGS_ENP;
919
920 #ifdef DEBUG
921         PrTime();
922         printk("Send packet on descr %d len %d\n", priv->nexttxput,
923                skb->len);
924 #endif
925
926         /* one more descriptor busy */
927
928         spin_lock_irqsave(&priv->lock, flags);
929
930         priv->nexttxput++;
931         if (priv->nexttxput >= TXCOUNT)
932                 priv->nexttxput = 0;
933         priv->txbusy++;
934
935         /* are we saturated ? */
936
937         if (priv->txbusy >= TXCOUNT)
938                 netif_stop_queue(dev);
939
940         /* write descriptor back to RAM */
941         memcpy_toio(priv->base + address, &descr, sizeof(LANCE_TxDescr));
942
943         /* if no descriptors were active, give the LANCE a hint to read it
944            immediately */
945
946         if (priv->txbusy == 0)
947                 SetLANCE(dev, LANCE_CSR0, CSR0_INEA | CSR0_TDMD);
948
949         spin_unlock_irqrestore(&priv->lock, flags);
950
951       tx_done:
952
953         dev_kfree_skb(skb);
954
955         return retval;
956 }
957
958 /* return pointer to Ethernet statistics */
959
960 static struct net_device_stats *skmca_stats(struct net_device *dev)
961 {
962         skmca_priv *priv = netdev_priv(dev);
963
964         return &(priv->stat);
965 }
966
967 /* switch receiver mode.  We use the LANCE's multicast filter to prefilter
968    multicast addresses. */
969
970 static void skmca_set_multicast_list(struct net_device *dev)
971 {
972         skmca_priv *priv = netdev_priv(dev);
973         LANCE_InitBlock block;
974
975         /* first stop the LANCE... */
976         StopLANCE(dev);
977
978         /* ...then modify the initialization block... */
979         memcpy_fromio(&block, priv->base + RAM_INITBASE, sizeof(block));
980         if (dev->flags & IFF_PROMISC)
981                 block.Mode |= LANCE_INIT_PROM;
982         else
983                 block.Mode &= ~LANCE_INIT_PROM;
984
985         if (dev->flags & IFF_ALLMULTI) {        /* get all multicasts */
986                 memset(block.LAdrF, 0xff, sizeof(block.LAdrF));
987         } else {                /* get selected/no multicasts */
988
989                 struct dev_mc_list *mptr;
990                 int code;
991
992                 memset(block.LAdrF, 0, sizeof(block.LAdrF));
993                 for (mptr = dev->mc_list; mptr != NULL; mptr = mptr->next) {
994                         code = GetHash(mptr->dmi_addr);
995                         block.LAdrF[(code >> 3) & 7] |= 1 << (code & 7);
996                 }
997         }
998
999         memcpy_toio(priv->base + RAM_INITBASE, &block, sizeof(block));
1000
1001         /* ...then reinit LANCE with the correct flags */
1002         InitLANCE(dev);
1003 }
1004
1005 /* ------------------------------------------------------------------------
1006  * hardware check
1007  * ------------------------------------------------------------------------ */
1008
1009 static int startslot;           /* counts through slots when probing multiple devices */
1010
1011 static void cleanup_card(struct net_device *dev)
1012 {
1013         skmca_priv *priv = netdev_priv(dev);
1014         DeinitBoard(dev);
1015         if (dev->irq != 0)
1016                 free_irq(dev->irq, dev);
1017         iounmap(priv->base);
1018         mca_mark_as_unused(priv->slot);
1019         mca_set_adapter_procfn(priv->slot, NULL, NULL);
1020 }
1021
1022 struct net_device * __init skmca_probe(int unit)
1023 {
1024         struct net_device *dev;
1025         int force_detect = 0;
1026         int junior, slot, i;
1027         int base = 0, irq = 0;
1028         skmca_priv *priv;
1029         skmca_medium medium;
1030         int err;
1031
1032         /* can't work without an MCA bus ;-) */
1033
1034         if (MCA_bus == 0)
1035                 return ERR_PTR(-ENODEV);
1036
1037         dev = alloc_etherdev(sizeof(skmca_priv));
1038         if (!dev)
1039                 return ERR_PTR(-ENOMEM);
1040
1041         if (unit >= 0) {
1042                 sprintf(dev->name, "eth%d", unit);
1043                 netdev_boot_setup_check(dev);
1044         }
1045
1046         SET_MODULE_OWNER(dev);
1047
1048         /* start address of 1 --> forced detection */
1049
1050         if (dev->mem_start == 1)
1051                 force_detect = 1;
1052
1053         /* search through slots */
1054
1055         base = dev->mem_start;
1056         irq = dev->base_addr;
1057         for (slot = startslot; (slot = dofind(&junior, slot)) != -1; slot++) {
1058                 /* deduce card addresses */
1059
1060                 getaddrs(slot, junior, &base, &irq, &medium);
1061
1062                 /* slot already in use ? */
1063
1064                 if (mca_is_adapter_used(slot))
1065                         continue;
1066
1067                 /* were we looking for something different ? */
1068
1069                 if (dev->irq && dev->irq != irq)
1070                         continue;
1071                 if (dev->mem_start && dev->mem_start != base)
1072                         continue;
1073
1074                 /* found something that matches */
1075
1076                 break;
1077         }
1078
1079         /* nothing found ? */
1080
1081         if (slot == -1) {
1082                 free_netdev(dev);
1083                 return (base || irq) ? ERR_PTR(-ENXIO) : ERR_PTR(-ENODEV);
1084         }
1085
1086         /* make procfs entries */
1087
1088         if (junior)
1089                 mca_set_adapter_name(slot,
1090                                      "SKNET junior MC2 Ethernet Adapter");
1091         else
1092                 mca_set_adapter_name(slot, "SKNET MC2+ Ethernet Adapter");
1093         mca_set_adapter_procfn(slot, (MCA_ProcFn) skmca_getinfo, dev);
1094
1095         mca_mark_as_used(slot);
1096
1097         /* announce success */
1098         printk("%s: SKNet %s adapter found in slot %d\n", dev->name,
1099                junior ? "Junior MC2" : "MC2+", slot + 1);
1100
1101         priv = netdev_priv(dev);
1102         priv->base = ioremap(base, 0x4000);
1103         if (!priv->base) {
1104                 mca_set_adapter_procfn(slot, NULL, NULL);
1105                 mca_mark_as_unused(slot);
1106                 free_netdev(dev);
1107                 return ERR_PTR(-ENOMEM);
1108         }
1109
1110         priv->slot = slot;
1111         priv->macbase = priv->base + 0x3fc0;
1112         priv->ioregaddr = priv->base + 0x3ff0;
1113         priv->ctrladdr = priv->base + 0x3ff2;
1114         priv->cmdaddr = priv->base + 0x3ff3;
1115         priv->medium = medium;
1116         memset(&priv->stat, 0, sizeof(struct net_device_stats));
1117         spin_lock_init(&priv->lock);
1118
1119         /* set base + irq for this device (irq not allocated so far) */
1120         dev->irq = 0;
1121         dev->mem_start = base;
1122         dev->mem_end = base + 0x4000;
1123
1124         /* autoprobe ? */
1125         if (irq < 0) {
1126                 int nirq;
1127
1128                 printk
1129                     ("%s: ambigous POS bit combination, must probe for IRQ...\n",
1130                      dev->name);
1131                 nirq = ProbeIRQ(dev);
1132                 if (nirq <= 0)
1133                         printk("%s: IRQ probe failed, assuming IRQ %d",
1134                                dev->name, priv->realirq = -irq);
1135                 else
1136                         priv->realirq = nirq;
1137         } else
1138                 priv->realirq = irq;
1139
1140         /* set methods */
1141         dev->open = skmca_open;
1142         dev->stop = skmca_close;
1143         dev->hard_start_xmit = skmca_tx;
1144         dev->do_ioctl = NULL;
1145         dev->get_stats = skmca_stats;
1146         dev->set_multicast_list = skmca_set_multicast_list;
1147         dev->flags |= IFF_MULTICAST;
1148
1149         /* copy out MAC address */
1150         for (i = 0; i < 6; i++)
1151                 dev->dev_addr[i] = readb(priv->macbase + (i << 1));
1152
1153         /* print config */
1154         printk("%s: IRQ %d, memory %#lx-%#lx, "
1155                "MAC address %02x:%02x:%02x:%02x:%02x:%02x.\n",
1156                dev->name, priv->realirq, dev->mem_start, dev->mem_end - 1,
1157                dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
1158                dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
1159         printk("%s: %s medium\n", dev->name, MediaNames[priv->medium]);
1160
1161         /* reset board */
1162
1163         ResetBoard(dev);
1164
1165         startslot = slot + 1;
1166
1167         err = register_netdev(dev);
1168         if (err) {
1169                 cleanup_card(dev);
1170                 free_netdev(dev);
1171                 dev = ERR_PTR(err);
1172         }
1173         return dev;
1174 }
1175
1176 /* ------------------------------------------------------------------------
1177  * modularization support
1178  * ------------------------------------------------------------------------ */
1179
1180 #ifdef MODULE
1181 MODULE_LICENSE("GPL");
1182
1183 #define DEVMAX 5
1184
1185 static struct net_device *moddevs[DEVMAX];
1186
1187 int init_module(void)
1188 {
1189         int z;
1190
1191         startslot = 0;
1192         for (z = 0; z < DEVMAX; z++) {
1193                 struct net_device *dev = skmca_probe(-1);
1194                 if (IS_ERR(dev))
1195                         break;
1196                 moddevs[z] = dev;
1197         }
1198         if (!z)
1199                 return -EIO;
1200         return 0;
1201 }
1202
1203 void cleanup_module(void)
1204 {
1205         int z;
1206
1207         for (z = 0; z < DEVMAX; z++) {
1208                 struct net_device *dev = moddevs[z];
1209                 if (dev) {
1210                         unregister_netdev(dev);
1211                         cleanup_card(dev);
1212                         free_netdev(dev);
1213                 }
1214         }
1215 }
1216 #endif                          /* MODULE */