2 net-3-driver for the SKNET MCA-based cards
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.
7 Copyright 1999 by Alfred Arnold (alfred@ccac.rwth-aachen.de,
8 alfred.arnold@lancom.de)
10 This driver is based both on the 3C523 driver and the SK_G16 driver.
13 'PC Hardware: Aufbau, Funktionsweise, Programmierung' by
14 Hans-Peter Messmer for the basic Microchannel stuff
16 'Linux Geraetetreiber' by Allesandro Rubini, Kalle Dalheimer
17 for help on Ethernet driver programming
19 'Ethernet/IEEE 802.3 Family 1992 World Network Data Book/Handbook' by AMD
20 for documentation on the AM7990 LANCE
22 'SKNET Personal Technisches Manual', Version 1.2 by Schneider&Koch
23 for documentation on the Junior board
25 'SK-NET MC2+ Technical Manual", Version 1.1 by Schneider&Koch for
26 documentation on the MC2 bord
28 A big thank you to the S&K support for providing me so quickly with
31 Also see http://www.syskonnect.com/
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
44 added private structure, methods
45 begun building data structures in RAM
47 can receive frames, send frames
49 modularized initialization of LANCE
54 support for multiple devices
55 display media type for MC2+
57 fixed problem in GetLANCE leaving interrupts turned off
58 increase TX queue to 4 packets to improve send performance
60 a few corrections in statistics, caught rcvr overruns
61 reinitialization of LANCE/board in critical situations
63 implemented LANCE multicast filter
65 additions for Linux 2.2
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...
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-)
75 added handling of the remaining interrupt conditions. That
76 should cure the spurious hangs.
78 newer kernels automatically probe more than one board, so the
79 'startslot' as a variable is also needed here
81 added changes for recent 2.3 kernels
83 *************************************************************************/
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>
101 #include <asm/processor.h>
104 #define _SK_MCA_DRIVER_
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 * ------------------------------------------------------------------------ */
112 static char *MediaNames[Media_Count] =
113 { "10Base2", "10BaseT", "10Base5", "Unknown" };
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
120 /* ------------------------------------------------------------------------
121 * private subfunctions
122 * ------------------------------------------------------------------------ */
124 /* dump parts of shared memory - only needed during debugging */
127 static void dumpmem(struct net_device *dev, u32 start, u32 len)
129 skmca_priv *priv = netdev_priv(dev);
132 for (z = 0; z < len; z++) {
135 printk(" %02x", readb(priv->base + start + z));
141 /* print exact time - ditto */
143 static void PrTime(void)
147 do_gettimeofday(&tv);
148 printk("%9d:%06d: ", tv.tv_sec, tv.tv_usec);
152 /* deduce resources out of POS registers */
154 static void __init getaddrs(int slot, int junior, int *base, int *irq,
155 skmca_medium * medium)
157 u_char pos0, pos1, pos2;
160 pos0 = mca_read_stored_pos(slot, 2);
161 *base = ((pos0 & 0x0e) << 13) + 0xc0000;
162 *irq = ((pos0 & 0x10) >> 4) + 10;
163 *medium = Media_Unknown;
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... */
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);
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) {
191 *medium = (pos2 >> 6) & 3;
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 :-( */
200 static int __init dofind(int *junior, int firstslot)
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);
210 if (id == SKNET_MCA_ID)
213 if (id == SKNET_JUNIOR_MCA_ID)
219 /* reset the whole board */
221 static void ResetBoard(struct net_device *dev)
223 skmca_priv *priv = netdev_priv(dev);
225 writeb(CTRL_RESET_ON, priv->ctrladdr);
227 writeb(CTRL_RESET_OFF, priv->ctrladdr);
230 /* wait for LANCE interface to become not busy */
232 static int WaitLANCE(struct net_device *dev)
234 skmca_priv *priv = netdev_priv(dev);
237 while ((readb(priv->ctrladdr) & STAT_IO_BUSY) ==
241 printk("%s: LANCE access timeout", dev->name);
249 /* set LANCE register - must be atomic */
251 static void SetLANCE(struct net_device *dev, u16 addr, u16 value)
253 skmca_priv *priv = netdev_priv(dev);
256 /* disable interrupts */
258 spin_lock_irqsave(&priv->lock, flags);
260 /* wait until no transfer is pending */
264 /* transfer register address to RAP */
266 writeb(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_RAP, priv->ctrladdr);
267 writew(addr, priv->ioregaddr);
268 writeb(IOCMD_GO, priv->cmdaddr);
272 /* transfer data to register */
274 writeb(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_DATA, priv->ctrladdr);
275 writew(value, priv->ioregaddr);
276 writeb(IOCMD_GO, priv->cmdaddr);
280 /* reenable interrupts */
282 spin_unlock_irqrestore(&priv->lock, flags);
285 /* get LANCE register */
287 static u16 GetLANCE(struct net_device *dev, u16 addr)
289 skmca_priv *priv = netdev_priv(dev);
293 /* disable interrupts */
295 spin_lock_irqsave(&priv->lock, flags);
297 /* wait until no transfer is pending */
301 /* transfer register address to RAP */
303 writeb(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_RAP, priv->ctrladdr);
304 writew(addr, priv->ioregaddr);
305 writeb(IOCMD_GO, priv->cmdaddr);
309 /* transfer data from register */
311 writeb(CTRL_RESET_OFF | CTRL_RW_READ | CTRL_ADR_DATA, priv->ctrladdr);
312 writeb(IOCMD_GO, priv->cmdaddr);
315 res = readw(priv->ioregaddr);
317 /* reenable interrupts */
319 spin_unlock_irqrestore(&priv->lock, flags);
324 /* build up descriptors in shared RAM */
326 static void InitDscrs(struct net_device *dev)
328 skmca_priv *priv = netdev_priv(dev);
331 /* Set up Tx descriptors. The board has only 16K RAM so bits 16..23
334 bufaddr = RAM_DATABASE;
339 for (z = 0; z < TXCOUNT; z++) {
340 descr.LowAddr = bufaddr;
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;
352 /* do the same for the Rx descriptors */
358 for (z = 0; z < RXCOUNT; z++) {
359 descr.LowAddr = bufaddr;
360 descr.Flags = RXDSCR_FLAGS_OWN;
361 descr.MaxLen = -RAM_BUFSIZE;
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;
372 /* calculate the hash bit position for a given multicast address
373 taken more or less directly from the AMD datasheet... */
375 static void UpdateCRC(unsigned char *CRC, int bit)
379 /* shift CRC one bit */
381 memmove(CRC + 1, CRC, 32 * sizeof(unsigned char));
384 /* if bit XOR controlbit = 1, set CRC = CRC XOR polynomial */
387 for (j = 0; j < 32; j++)
391 static unsigned int GetHash(char *address)
393 unsigned char CRC[33];
394 int i, byte, hashcode;
396 /* a multicast address has bit 0 in the first byte set */
398 if ((address[0] & 1) == 0)
403 memset(CRC, 1, sizeof(CRC));
405 /* loop through address bits */
407 for (byte = 0; byte < 6; byte++)
408 for (i = 0; i < 8; i++)
409 UpdateCRC(CRC, (address[byte] >> i) & 1);
411 /* hashcode is the 6 least significant bits of the CRC */
414 for (i = 0; i < 6; i++)
415 hashcode = (hashcode << 1) + CRC[i];
419 /* feed ready-built initialization block into LANCE */
421 static void InitLANCE(struct net_device *dev)
423 skmca_priv *priv = netdev_priv(dev);
425 /* build up descriptors. */
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. */
435 /* no TX descriptors active */
437 priv->nexttxput = priv->nexttxdone = priv->txbusy = 0;
439 /* set up the LANCE bus control register - constant for SKnet boards */
441 SetLANCE(dev, LANCE_CSR3,
442 CSR3_BSWAP_OFF | CSR3_ALE_LOW | CSR3_BCON_HOLD);
444 /* write address of initialization block into LANCE */
446 SetLANCE(dev, LANCE_CSR1, RAM_INITBASE & 0xffff);
447 SetLANCE(dev, LANCE_CSR2, (RAM_INITBASE >> 16) & 0xff);
449 /* we don't get ready until the LANCE has read the init block */
451 netif_stop_queue(dev);
453 /* let LANCE read the initialization block. LANCE is ready
454 when we receive the corresponding interrupt. */
456 SetLANCE(dev, LANCE_CSR0, CSR0_INEA | CSR0_INIT);
459 /* stop the LANCE so we can reinitialize it */
461 static void StopLANCE(struct net_device *dev)
463 /* can't take frames any more */
465 netif_stop_queue(dev);
467 /* disable interrupts, stop it */
469 SetLANCE(dev, LANCE_CSR0, CSR0_STOP);
472 /* initialize card and LANCE for proper operation */
474 static void InitBoard(struct net_device *dev)
476 skmca_priv *priv = netdev_priv(dev);
477 LANCE_InitBlock block;
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. */
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);
491 memcpy_toio(priv->base + RAM_INITBASE, &block, sizeof(block));
493 /* initialize LANCE. Implicitly sets up other structures in RAM. */
498 /* deinitialize card and LANCE */
500 static void DeinitBoard(struct net_device *dev)
511 /* probe for device's irq */
513 static int __init ProbeIRQ(struct net_device *dev)
515 unsigned long imaskval, njiffies, irq;
518 /* enable all interrupts */
520 imaskval = probe_irq_on();
522 /* initialize the board. Wait for interrupt 'Initialization done'. */
527 njiffies = jiffies + HZ;
529 csr0val = GetLANCE(dev, LANCE_CSR0);
531 while (((csr0val & CSR0_IDON) == 0) && (jiffies != njiffies));
533 /* turn of interrupts again */
535 irq = probe_irq_off(imaskval);
537 /* if we found something, ack the interrupt */
540 SetLANCE(dev, LANCE_CSR0, csr0val | CSR0_IDON);
542 /* back to idle state */
549 /* ------------------------------------------------------------------------
550 * interrupt handler(s)
551 * ------------------------------------------------------------------------ */
553 /* LANCE has read initialization block -> start it */
555 static u16 irqstart_handler(struct net_device *dev, u16 oldcsr0)
557 /* now we're ready to transmit */
559 netif_wake_queue(dev);
561 /* reset IDON bit, start LANCE */
563 SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_IDON | CSR0_STRT);
564 return GetLANCE(dev, LANCE_CSR0);
567 /* did we lose blocks due to a FIFO overrun ? */
569 static u16 irqmiss_handler(struct net_device *dev, u16 oldcsr0)
571 skmca_priv *priv = netdev_priv(dev);
573 /* update statistics */
575 priv->stat.rx_fifo_errors++;
579 SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_MISS);
580 return GetLANCE(dev, LANCE_CSR0);
583 /* receive interrupt */
585 static u16 irqrx_handler(struct net_device *dev, u16 oldcsr0)
587 skmca_priv *priv = netdev_priv(dev);
589 unsigned int descraddr;
591 /* run through queue until we reach a descriptor we do not own */
593 descraddr = RAM_RXBASE + (priv->nextrx * sizeof(LANCE_RxDescr));
595 /* read descriptor */
596 memcpy_fromio(&descr, priv->base + descraddr,
597 sizeof(LANCE_RxDescr));
599 /* if we reach a descriptor we do not own, we're done */
600 if ((descr.Flags & RXDSCR_FLAGS_OWN) != 0)
605 printk("Receive packet on descr %d len %d\n", priv->nextrx,
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++;
624 skb = dev_alloc_skb(descr.Len + 2);
626 priv->stat.rx_dropped++;
628 memcpy_fromio(skb_put(skb, descr.Len),
630 descr.LowAddr, descr.Len);
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;
637 dev->last_rx = jiffies;
641 /* give descriptor back to LANCE */
643 descr.Flags |= RXDSCR_FLAGS_OWN;
645 /* update descriptor in shared RAM */
646 memcpy_toio(priv->base + descraddr, &descr,
647 sizeof(LANCE_RxDescr));
649 /* go to next descriptor */
651 descraddr += sizeof(LANCE_RxDescr);
652 if (priv->nextrx >= RXCOUNT) {
654 descraddr = RAM_RXBASE;
660 SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_RINT);
661 return GetLANCE(dev, LANCE_CSR0);
664 /* transmit interrupt */
666 static u16 irqtx_handler(struct net_device *dev, u16 oldcsr0)
668 skmca_priv *priv = netdev_priv(dev);
670 unsigned int descraddr;
672 /* check descriptors at most until no busy one is left */
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));
681 /* if the LANCE still owns this one, we've worked out all sent packets */
682 if ((descr.Flags & TXDSCR_FLAGS_OWN) != 0)
687 printk("Send packet done on descr %d\n", priv->nexttxdone);
690 /* update statistics */
691 if ((descr.Flags & TXDSCR_FLAGS_ERR) == 0) {
692 priv->stat.tx_packets++;
693 priv->stat.tx_bytes++;
695 priv->stat.tx_errors++;
696 if ((descr.Status & TXDSCR_STATUS_UFLO) != 0) {
697 priv->stat.tx_fifo_errors++;
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++;
709 /* go to next descriptor */
711 descraddr += sizeof(LANCE_TxDescr);
712 if (priv->nexttxdone >= TXCOUNT) {
713 priv->nexttxdone = 0;
714 descraddr = RAM_TXBASE;
719 /* reset TX interrupt bit */
721 SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_TINT);
722 oldcsr0 = GetLANCE(dev, LANCE_CSR0);
724 /* at least one descriptor is freed. Therefore we can accept
726 /* inform upper layers we're in business again */
728 netif_wake_queue(dev);
733 /* general interrupt entry */
735 static irqreturn_t irq_handler(int irq, void *device, struct pt_regs *regs)
737 struct net_device *dev = (struct net_device *) device;
740 /* read CSR0 to get interrupt cause */
742 csr0val = GetLANCE(dev, LANCE_CSR0);
744 /* in case we're not meant... */
746 if ((csr0val & CSR0_INTR) == 0)
750 set_bit(LINK_STATE_RXSEM, &dev->state);
753 /* loop through the interrupt bits until everything is clear */
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);
768 if ((csr0val & CSR0_BABL) != 0) {
769 SetLANCE(dev, LANCE_CSR0, csr0val | CSR0_BABL);
770 csr0val = GetLANCE(dev, LANCE_CSR0);
773 while ((csr0val & CSR0_INTR) != 0);
776 clear_bit(LINK_STATE_RXSEM, &dev->state);
781 /* ------------------------------------------------------------------------
783 * ------------------------------------------------------------------------ */
787 static int skmca_getinfo(char *buf, int slot, void *d)
790 struct net_device *dev = (struct net_device *) d;
793 /* can't say anything about an uninitialized device... */
797 priv = netdev_priv(dev);
801 len += sprintf(buf + len, "IRQ: %d\n", priv->realirq);
802 len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start,
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]);
817 /* open driver. Means also initialization and start of LANCE */
819 static int skmca_open(struct net_device *dev)
822 skmca_priv *priv = netdev_priv(dev);
824 /* register resources - only necessary for IRQ */
826 request_irq(priv->realirq, irq_handler,
827 IRQF_SHARED | IRQF_SAMPLE_RANDOM, "sk_mca", dev);
829 printk("%s: failed to register irq %d\n", dev->name,
833 dev->irq = priv->realirq;
835 /* set up the card and LANCE */
841 netif_start_queue(dev);
846 /* close driver. Shut down board and free allocated resources */
848 static int skmca_close(struct net_device *dev)
853 /* release resources */
855 free_irq(dev->irq, dev);
861 /* transmit a block. */
863 static int skmca_tx(struct sk_buff *skb, struct net_device *dev)
865 skmca_priv *priv = netdev_priv(dev);
867 unsigned int address;
868 int tmplen, retval = 0;
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: */
877 return 0; /* don't try to free the block here ;-) */
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++;
889 /* get TX descriptor */
890 address = RAM_TXBASE + (priv->nexttxput * sizeof(LANCE_TxDescr));
891 memcpy_fromio(&descr, priv->base + address, sizeof(LANCE_TxDescr));
893 /* enter packet length as 2s complement - assure minimum length */
897 descr.Len = 65536 - tmplen;
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);
906 while (destoffs < tmplen) {
907 memcpy_toio(priv->base + descr.LowAddr +
913 /* do the real data copying */
914 memcpy_toio(priv->base + descr.LowAddr, skb->data, skb->len);
916 /* hand descriptor over to LANCE - this is the first and last chunk */
918 TXDSCR_FLAGS_OWN | TXDSCR_FLAGS_STP | TXDSCR_FLAGS_ENP;
922 printk("Send packet on descr %d len %d\n", priv->nexttxput,
926 /* one more descriptor busy */
928 spin_lock_irqsave(&priv->lock, flags);
931 if (priv->nexttxput >= TXCOUNT)
935 /* are we saturated ? */
937 if (priv->txbusy >= TXCOUNT)
938 netif_stop_queue(dev);
940 /* write descriptor back to RAM */
941 memcpy_toio(priv->base + address, &descr, sizeof(LANCE_TxDescr));
943 /* if no descriptors were active, give the LANCE a hint to read it
946 if (priv->txbusy == 0)
947 SetLANCE(dev, LANCE_CSR0, CSR0_INEA | CSR0_TDMD);
949 spin_unlock_irqrestore(&priv->lock, flags);
958 /* return pointer to Ethernet statistics */
960 static struct net_device_stats *skmca_stats(struct net_device *dev)
962 skmca_priv *priv = netdev_priv(dev);
964 return &(priv->stat);
967 /* switch receiver mode. We use the LANCE's multicast filter to prefilter
968 multicast addresses. */
970 static void skmca_set_multicast_list(struct net_device *dev)
972 skmca_priv *priv = netdev_priv(dev);
973 LANCE_InitBlock block;
975 /* first stop the LANCE... */
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;
983 block.Mode &= ~LANCE_INIT_PROM;
985 if (dev->flags & IFF_ALLMULTI) { /* get all multicasts */
986 memset(block.LAdrF, 0xff, sizeof(block.LAdrF));
987 } else { /* get selected/no multicasts */
989 struct dev_mc_list *mptr;
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);
999 memcpy_toio(priv->base + RAM_INITBASE, &block, sizeof(block));
1001 /* ...then reinit LANCE with the correct flags */
1005 /* ------------------------------------------------------------------------
1007 * ------------------------------------------------------------------------ */
1009 static int startslot; /* counts through slots when probing multiple devices */
1011 static void cleanup_card(struct net_device *dev)
1013 skmca_priv *priv = netdev_priv(dev);
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);
1022 struct net_device * __init skmca_probe(int unit)
1024 struct net_device *dev;
1025 int force_detect = 0;
1026 int junior, slot, i;
1027 int base = 0, irq = 0;
1029 skmca_medium medium;
1032 /* can't work without an MCA bus ;-) */
1035 return ERR_PTR(-ENODEV);
1037 dev = alloc_etherdev(sizeof(skmca_priv));
1039 return ERR_PTR(-ENOMEM);
1042 sprintf(dev->name, "eth%d", unit);
1043 netdev_boot_setup_check(dev);
1046 SET_MODULE_OWNER(dev);
1048 /* start address of 1 --> forced detection */
1050 if (dev->mem_start == 1)
1053 /* search through slots */
1055 base = dev->mem_start;
1056 irq = dev->base_addr;
1057 for (slot = startslot; (slot = dofind(&junior, slot)) != -1; slot++) {
1058 /* deduce card addresses */
1060 getaddrs(slot, junior, &base, &irq, &medium);
1062 /* slot already in use ? */
1064 if (mca_is_adapter_used(slot))
1067 /* were we looking for something different ? */
1069 if (dev->irq && dev->irq != irq)
1071 if (dev->mem_start && dev->mem_start != base)
1074 /* found something that matches */
1079 /* nothing found ? */
1083 return (base || irq) ? ERR_PTR(-ENXIO) : ERR_PTR(-ENODEV);
1086 /* make procfs entries */
1089 mca_set_adapter_name(slot,
1090 "SKNET junior MC2 Ethernet Adapter");
1092 mca_set_adapter_name(slot, "SKNET MC2+ Ethernet Adapter");
1093 mca_set_adapter_procfn(slot, (MCA_ProcFn) skmca_getinfo, dev);
1095 mca_mark_as_used(slot);
1097 /* announce success */
1098 printk("%s: SKNet %s adapter found in slot %d\n", dev->name,
1099 junior ? "Junior MC2" : "MC2+", slot + 1);
1101 priv = netdev_priv(dev);
1102 priv->base = ioremap(base, 0x4000);
1104 mca_set_adapter_procfn(slot, NULL, NULL);
1105 mca_mark_as_unused(slot);
1107 return ERR_PTR(-ENOMEM);
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);
1119 /* set base + irq for this device (irq not allocated so far) */
1121 dev->mem_start = base;
1122 dev->mem_end = base + 0x4000;
1129 ("%s: ambigous POS bit combination, must probe for IRQ...\n",
1131 nirq = ProbeIRQ(dev);
1133 printk("%s: IRQ probe failed, assuming IRQ %d",
1134 dev->name, priv->realirq = -irq);
1136 priv->realirq = nirq;
1138 priv->realirq = irq;
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;
1149 /* copy out MAC address */
1150 for (i = 0; i < 6; i++)
1151 dev->dev_addr[i] = readb(priv->macbase + (i << 1));
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]);
1165 startslot = slot + 1;
1167 err = register_netdev(dev);
1176 /* ------------------------------------------------------------------------
1177 * modularization support
1178 * ------------------------------------------------------------------------ */
1181 MODULE_LICENSE("GPL");
1185 static struct net_device *moddevs[DEVMAX];
1187 int init_module(void)
1192 for (z = 0; z < DEVMAX; z++) {
1193 struct net_device *dev = skmca_probe(-1);
1203 void cleanup_module(void)
1207 for (z = 0; z < DEVMAX; z++) {
1208 struct net_device *dev = moddevs[z];
1210 unregister_netdev(dev);