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/version.h>
97 #include <linux/netdevice.h>
98 #include <linux/etherdevice.h>
99 #include <linux/skbuff.h>
101 #include <asm/processor.h>
102 #include <asm/bitops.h>
105 #define _SK_MCA_DRIVER_
108 /* ------------------------------------------------------------------------
109 * global static data - not more since we can handle multiple boards and
110 * have to pack all state info into the device struct!
111 * ------------------------------------------------------------------------ */
113 static char *MediaNames[Media_Count] =
114 { "10Base2", "10BaseT", "10Base5", "Unknown" };
116 static unsigned char poly[] =
117 { 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0,
118 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0
121 /* ------------------------------------------------------------------------
122 * private subfunctions
123 * ------------------------------------------------------------------------ */
125 /* dump parts of shared memory - only needed during debugging */
128 static void dumpmem(struct net_device *dev, u32 start, u32 len)
132 for (z = 0; z < len; z++) {
135 printk(" %02x", SKMCA_READB(dev->mem_start + 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 = (skmca_priv *) dev->priv;
225 SKMCA_WRITEB(CTRL_RESET_ON, priv->ctrladdr);
227 SKMCA_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 = (skmca_priv *) dev->priv;
237 while ((SKMCA_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 = (skmca_priv *) dev->priv;
256 /* disable interrupts */
258 spin_lock_irqsave(&priv->lock, flags);
260 /* wait until no transfer is pending */
264 /* transfer register address to RAP */
266 SKMCA_WRITEB(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_RAP,
268 SKMCA_WRITEW(addr, priv->ioregaddr);
269 SKMCA_WRITEB(IOCMD_GO, priv->cmdaddr);
273 /* transfer data to register */
275 SKMCA_WRITEB(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_DATA,
277 SKMCA_WRITEW(value, priv->ioregaddr);
278 SKMCA_WRITEB(IOCMD_GO, priv->cmdaddr);
282 /* reenable interrupts */
284 spin_unlock_irqrestore(&priv->lock, flags);
287 /* get LANCE register */
289 static u16 GetLANCE(struct net_device *dev, u16 addr)
291 skmca_priv *priv = (skmca_priv *) dev->priv;
295 /* disable interrupts */
297 spin_lock_irqsave(&priv->lock, flags);
299 /* wait until no transfer is pending */
303 /* transfer register address to RAP */
305 SKMCA_WRITEB(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_RAP,
307 SKMCA_WRITEW(addr, priv->ioregaddr);
308 SKMCA_WRITEB(IOCMD_GO, priv->cmdaddr);
312 /* transfer data from register */
314 SKMCA_WRITEB(CTRL_RESET_OFF | CTRL_RW_READ | CTRL_ADR_DATA,
316 SKMCA_WRITEB(IOCMD_GO, priv->cmdaddr);
319 res = SKMCA_READW(priv->ioregaddr);
321 /* reenable interrupts */
323 spin_unlock_irqrestore(&priv->lock, flags);
328 /* build up descriptors in shared RAM */
330 static void InitDscrs(struct net_device *dev)
334 /* Set up Tx descriptors. The board has only 16K RAM so bits 16..23
337 bufaddr = RAM_DATABASE;
342 for (z = 0; z < TXCOUNT; z++) {
343 descr.LowAddr = bufaddr;
347 SKMCA_TOIO(dev->mem_start + RAM_TXBASE +
348 (z * sizeof(LANCE_TxDescr)), &descr,
349 sizeof(LANCE_TxDescr));
350 SKMCA_SETIO(dev->mem_start + bufaddr, 0,
352 bufaddr += RAM_BUFSIZE;
356 /* do the same for the Rx descriptors */
362 for (z = 0; z < RXCOUNT; z++) {
363 descr.LowAddr = bufaddr;
364 descr.Flags = RXDSCR_FLAGS_OWN;
365 descr.MaxLen = -RAM_BUFSIZE;
367 SKMCA_TOIO(dev->mem_start + RAM_RXBASE +
368 (z * sizeof(LANCE_RxDescr)), &descr,
369 sizeof(LANCE_RxDescr));
370 SKMCA_SETIO(dev->mem_start + bufaddr, 0,
372 bufaddr += RAM_BUFSIZE;
377 /* calculate the hash bit position for a given multicast address
378 taken more or less directly from the AMD datasheet... */
380 static void UpdateCRC(unsigned char *CRC, int bit)
384 /* shift CRC one bit */
386 memmove(CRC + 1, CRC, 32 * sizeof(unsigned char));
389 /* if bit XOR controlbit = 1, set CRC = CRC XOR polynomial */
392 for (j = 0; j < 32; j++)
396 static unsigned int GetHash(char *address)
398 unsigned char CRC[33];
399 int i, byte, hashcode;
401 /* a multicast address has bit 0 in the first byte set */
403 if ((address[0] & 1) == 0)
408 memset(CRC, 1, sizeof(CRC));
410 /* loop through address bits */
412 for (byte = 0; byte < 6; byte++)
413 for (i = 0; i < 8; i++)
414 UpdateCRC(CRC, (address[byte] >> i) & 1);
416 /* hashcode is the 6 least significant bits of the CRC */
419 for (i = 0; i < 6; i++)
420 hashcode = (hashcode << 1) + CRC[i];
424 /* feed ready-built initialization block into LANCE */
426 static void InitLANCE(struct net_device *dev)
428 skmca_priv *priv = (skmca_priv *) dev->priv;
430 /* build up descriptors. */
434 /* next RX descriptor to be read is the first one. Since the LANCE
435 will start from the beginning after initialization, we have to
436 reset out pointers too. */
440 /* no TX descriptors active */
442 priv->nexttxput = priv->nexttxdone = priv->txbusy = 0;
444 /* set up the LANCE bus control register - constant for SKnet boards */
446 SetLANCE(dev, LANCE_CSR3,
447 CSR3_BSWAP_OFF | CSR3_ALE_LOW | CSR3_BCON_HOLD);
449 /* write address of initialization block into LANCE */
451 SetLANCE(dev, LANCE_CSR1, RAM_INITBASE & 0xffff);
452 SetLANCE(dev, LANCE_CSR2, (RAM_INITBASE >> 16) & 0xff);
454 /* we don't get ready until the LANCE has read the init block */
456 netif_stop_queue(dev);
458 /* let LANCE read the initialization block. LANCE is ready
459 when we receive the corresponding interrupt. */
461 SetLANCE(dev, LANCE_CSR0, CSR0_INEA | CSR0_INIT);
464 /* stop the LANCE so we can reinitialize it */
466 static void StopLANCE(struct net_device *dev)
468 /* can't take frames any more */
470 netif_stop_queue(dev);
472 /* disable interrupts, stop it */
474 SetLANCE(dev, LANCE_CSR0, CSR0_STOP);
477 /* initialize card and LANCE for proper operation */
479 static void InitBoard(struct net_device *dev)
481 LANCE_InitBlock block;
483 /* Lay out the shared RAM - first we create the init block for the LANCE.
484 We do not overwrite it later because we need it again when we switch
485 promiscous mode on/off. */
488 if (dev->flags & IFF_PROMISC)
489 block.Mode |= LANCE_INIT_PROM;
490 memcpy(block.PAdr, dev->dev_addr, 6);
491 memset(block.LAdrF, 0, sizeof(block.LAdrF));
492 block.RdrP = (RAM_RXBASE & 0xffffff) | (LRXCOUNT << 29);
493 block.TdrP = (RAM_TXBASE & 0xffffff) | (LTXCOUNT << 29);
495 SKMCA_TOIO(dev->mem_start + RAM_INITBASE, &block, sizeof(block));
497 /* initialize LANCE. Implicitly sets up other structures in RAM. */
502 /* deinitialize card and LANCE */
504 static void DeinitBoard(struct net_device *dev)
515 /* probe for device's irq */
517 static int __init ProbeIRQ(struct net_device *dev)
519 unsigned long imaskval, njiffies, irq;
522 /* enable all interrupts */
524 imaskval = probe_irq_on();
526 /* initialize the board. Wait for interrupt 'Initialization done'. */
531 njiffies = jiffies + HZ;
533 csr0val = GetLANCE(dev, LANCE_CSR0);
535 while (((csr0val & CSR0_IDON) == 0) && (jiffies != njiffies));
537 /* turn of interrupts again */
539 irq = probe_irq_off(imaskval);
541 /* if we found something, ack the interrupt */
544 SetLANCE(dev, LANCE_CSR0, csr0val | CSR0_IDON);
546 /* back to idle state */
553 /* ------------------------------------------------------------------------
554 * interrupt handler(s)
555 * ------------------------------------------------------------------------ */
557 /* LANCE has read initialization block -> start it */
559 static u16 irqstart_handler(struct net_device *dev, u16 oldcsr0)
561 /* now we're ready to transmit */
563 netif_wake_queue(dev);
565 /* reset IDON bit, start LANCE */
567 SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_IDON | CSR0_STRT);
568 return GetLANCE(dev, LANCE_CSR0);
571 /* did we lose blocks due to a FIFO overrun ? */
573 static u16 irqmiss_handler(struct net_device *dev, u16 oldcsr0)
575 skmca_priv *priv = (skmca_priv *) dev->priv;
577 /* update statistics */
579 priv->stat.rx_fifo_errors++;
583 SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_MISS);
584 return GetLANCE(dev, LANCE_CSR0);
587 /* receive interrupt */
589 static u16 irqrx_handler(struct net_device *dev, u16 oldcsr0)
591 skmca_priv *priv = (skmca_priv *) dev->priv;
593 unsigned int descraddr;
595 /* run through queue until we reach a descriptor we do not own */
597 descraddr = RAM_RXBASE + (priv->nextrx * sizeof(LANCE_RxDescr));
599 /* read descriptor */
600 SKMCA_FROMIO(&descr, dev->mem_start + descraddr,
601 sizeof(LANCE_RxDescr));
603 /* if we reach a descriptor we do not own, we're done */
604 if ((descr.Flags & RXDSCR_FLAGS_OWN) != 0)
609 printk("Receive packet on descr %d len %d\n", priv->nextrx,
613 /* erroneous packet ? */
614 if ((descr.Flags & RXDSCR_FLAGS_ERR) != 0) {
615 priv->stat.rx_errors++;
616 if ((descr.Flags & RXDSCR_FLAGS_CRC) != 0)
617 priv->stat.rx_crc_errors++;
618 else if ((descr.Flags & RXDSCR_FLAGS_CRC) != 0)
619 priv->stat.rx_frame_errors++;
620 else if ((descr.Flags & RXDSCR_FLAGS_OFLO) != 0)
621 priv->stat.rx_fifo_errors++;
628 skb = dev_alloc_skb(descr.Len + 2);
630 priv->stat.rx_dropped++;
632 SKMCA_FROMIO(skb_put(skb, descr.Len),
634 descr.LowAddr, descr.Len);
636 skb->protocol = eth_type_trans(skb, dev);
637 skb->ip_summed = CHECKSUM_NONE;
638 priv->stat.rx_packets++;
639 priv->stat.rx_bytes += descr.Len;
641 dev->last_rx = jiffies;
645 /* give descriptor back to LANCE */
647 descr.Flags |= RXDSCR_FLAGS_OWN;
649 /* update descriptor in shared RAM */
650 SKMCA_TOIO(dev->mem_start + descraddr, &descr,
651 sizeof(LANCE_RxDescr));
653 /* go to next descriptor */
655 descraddr += sizeof(LANCE_RxDescr);
656 if (priv->nextrx >= RXCOUNT) {
658 descraddr = RAM_RXBASE;
664 SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_RINT);
665 return GetLANCE(dev, LANCE_CSR0);
668 /* transmit interrupt */
670 static u16 irqtx_handler(struct net_device *dev, u16 oldcsr0)
672 skmca_priv *priv = (skmca_priv *) dev->priv;
674 unsigned int descraddr;
676 /* check descriptors at most until no busy one is left */
679 RAM_TXBASE + (priv->nexttxdone * sizeof(LANCE_TxDescr));
680 while (priv->txbusy > 0) {
681 /* read descriptor */
682 SKMCA_FROMIO(&descr, dev->mem_start + descraddr,
683 sizeof(LANCE_TxDescr));
685 /* if the LANCE still owns this one, we've worked out all sent packets */
686 if ((descr.Flags & TXDSCR_FLAGS_OWN) != 0)
691 printk("Send packet done on descr %d\n", priv->nexttxdone);
694 /* update statistics */
695 if ((descr.Flags & TXDSCR_FLAGS_ERR) == 0) {
696 priv->stat.tx_packets++;
697 priv->stat.tx_bytes++;
699 priv->stat.tx_errors++;
700 if ((descr.Status & TXDSCR_STATUS_UFLO) != 0) {
701 priv->stat.tx_fifo_errors++;
705 if ((descr.Status & TXDSCR_STATUS_LCOL) !=
706 0) priv->stat.tx_window_errors++;
707 else if ((descr.Status & TXDSCR_STATUS_LCAR) != 0)
708 priv->stat.tx_carrier_errors++;
709 else if ((descr.Status & TXDSCR_STATUS_RTRY) != 0)
710 priv->stat.tx_aborted_errors++;
713 /* go to next descriptor */
715 descraddr += sizeof(LANCE_TxDescr);
716 if (priv->nexttxdone >= TXCOUNT) {
717 priv->nexttxdone = 0;
718 descraddr = RAM_TXBASE;
723 /* reset TX interrupt bit */
725 SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_TINT);
726 oldcsr0 = GetLANCE(dev, LANCE_CSR0);
728 /* at least one descriptor is freed. Therefore we can accept
730 /* inform upper layers we're in business again */
732 netif_wake_queue(dev);
737 /* general interrupt entry */
739 static irqreturn_t irq_handler(int irq, void *device, struct pt_regs *regs)
741 struct net_device *dev = (struct net_device *) device;
744 /* read CSR0 to get interrupt cause */
746 csr0val = GetLANCE(dev, LANCE_CSR0);
748 /* in case we're not meant... */
750 if ((csr0val & CSR0_INTR) == 0)
754 set_bit(LINK_STATE_RXSEM, &dev->state);
757 /* loop through the interrupt bits until everything is clear */
760 if ((csr0val & CSR0_IDON) != 0)
761 csr0val = irqstart_handler(dev, csr0val);
762 if ((csr0val & CSR0_RINT) != 0)
763 csr0val = irqrx_handler(dev, csr0val);
764 if ((csr0val & CSR0_MISS) != 0)
765 csr0val = irqmiss_handler(dev, csr0val);
766 if ((csr0val & CSR0_TINT) != 0)
767 csr0val = irqtx_handler(dev, csr0val);
768 if ((csr0val & CSR0_MERR) != 0) {
769 SetLANCE(dev, LANCE_CSR0, csr0val | CSR0_MERR);
770 csr0val = GetLANCE(dev, LANCE_CSR0);
772 if ((csr0val & CSR0_BABL) != 0) {
773 SetLANCE(dev, LANCE_CSR0, csr0val | CSR0_BABL);
774 csr0val = GetLANCE(dev, LANCE_CSR0);
777 while ((csr0val & CSR0_INTR) != 0);
780 clear_bit(LINK_STATE_RXSEM, &dev->state);
785 /* ------------------------------------------------------------------------
787 * ------------------------------------------------------------------------ */
791 static int skmca_getinfo(char *buf, int slot, void *d)
794 struct net_device *dev = (struct net_device *) d;
797 /* can't say anything about an uninitialized device... */
801 if (dev->priv == NULL)
803 priv = (skmca_priv *) dev->priv;
807 len += sprintf(buf + len, "IRQ: %d\n", priv->realirq);
808 len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start,
811 sprintf(buf + len, "Transceiver: %s\n",
812 MediaNames[priv->medium]);
813 len += sprintf(buf + len, "Device: %s\n", dev->name);
814 len += sprintf(buf + len, "MAC address:");
815 for (i = 0; i < 6; i++)
816 len += sprintf(buf + len, " %02x", dev->dev_addr[i]);
823 /* open driver. Means also initialization and start of LANCE */
825 static int skmca_open(struct net_device *dev)
828 skmca_priv *priv = (skmca_priv *) dev->priv;
830 /* register resources - only necessary for IRQ */
832 request_irq(priv->realirq, irq_handler,
833 SA_SHIRQ | SA_SAMPLE_RANDOM, "sk_mca", dev);
835 printk("%s: failed to register irq %d\n", dev->name,
839 dev->irq = priv->realirq;
841 /* set up the card and LANCE */
847 netif_start_queue(dev);
852 /* close driver. Shut down board and free allocated resources */
854 static int skmca_close(struct net_device *dev)
859 /* release resources */
861 free_irq(dev->irq, dev);
867 /* transmit a block. */
869 static int skmca_tx(struct sk_buff *skb, struct net_device *dev)
871 skmca_priv *priv = (skmca_priv *) dev->priv;
873 unsigned int address;
874 int tmplen, retval = 0;
877 /* if we get called with a NULL descriptor, the Ethernet layer thinks
878 our card is stuck an we should reset it. We'll do this completely: */
883 return 0; /* don't try to free the block here ;-) */
886 /* is there space in the Tx queue ? If no, the upper layer gave us a
887 packet in spite of us not being ready and is really in trouble.
888 We'll do the dropping for him: */
889 if (priv->txbusy >= TXCOUNT) {
890 priv->stat.tx_dropped++;
895 /* get TX descriptor */
896 address = RAM_TXBASE + (priv->nexttxput * sizeof(LANCE_TxDescr));
897 SKMCA_FROMIO(&descr, dev->mem_start + address,
898 sizeof(LANCE_TxDescr));
900 /* enter packet length as 2s complement - assure minimum length */
904 descr.Len = 65536 - tmplen;
906 /* copy filler into RAM - in case we're filling up...
907 we're filling a bit more than necessary, but that doesn't harm
908 since the buffer is far larger... */
909 if (tmplen > skb->len) {
910 char *fill = "NetBSD is a nice OS too! ";
911 unsigned int destoffs = 0, l = strlen(fill);
913 while (destoffs < tmplen) {
914 SKMCA_TOIO(dev->mem_start + descr.LowAddr +
920 /* do the real data copying */
921 SKMCA_TOIO(dev->mem_start + descr.LowAddr, skb->data, skb->len);
923 /* hand descriptor over to LANCE - this is the first and last chunk */
925 TXDSCR_FLAGS_OWN | TXDSCR_FLAGS_STP | TXDSCR_FLAGS_ENP;
929 printk("Send packet on descr %d len %d\n", priv->nexttxput,
933 /* one more descriptor busy */
935 spin_lock_irqsave(&priv->lock, flags);
938 if (priv->nexttxput >= TXCOUNT)
942 /* are we saturated ? */
944 if (priv->txbusy >= TXCOUNT)
945 netif_stop_queue(dev);
947 /* write descriptor back to RAM */
948 SKMCA_TOIO(dev->mem_start + address, &descr,
949 sizeof(LANCE_TxDescr));
951 /* if no descriptors were active, give the LANCE a hint to read it
954 if (priv->txbusy == 0)
955 SetLANCE(dev, LANCE_CSR0, CSR0_INEA | CSR0_TDMD);
957 spin_unlock_irqrestore(&priv->lock, flags);
966 /* return pointer to Ethernet statistics */
968 static struct net_device_stats *skmca_stats(struct net_device *dev)
970 skmca_priv *priv = (skmca_priv *) dev->priv;
972 return &(priv->stat);
975 /* we don't support runtime reconfiguration, since an MCA card can
976 be unambigously identified by its POS registers. */
978 static int skmca_config(struct net_device *dev, struct ifmap *map)
983 /* switch receiver mode. We use the LANCE's multicast filter to prefilter
984 multicast addresses. */
986 static void skmca_set_multicast_list(struct net_device *dev)
988 LANCE_InitBlock block;
990 /* first stop the LANCE... */
993 /* ...then modify the initialization block... */
994 SKMCA_FROMIO(&block, dev->mem_start + RAM_INITBASE, sizeof(block));
995 if (dev->flags & IFF_PROMISC)
996 block.Mode |= LANCE_INIT_PROM;
998 block.Mode &= ~LANCE_INIT_PROM;
1000 if (dev->flags & IFF_ALLMULTI) { /* get all multicasts */
1001 memset(block.LAdrF, 0xff, sizeof(block.LAdrF));
1002 } else { /* get selected/no multicasts */
1004 struct dev_mc_list *mptr;
1007 memset(block.LAdrF, 0, sizeof(block.LAdrF));
1008 for (mptr = dev->mc_list; mptr != NULL; mptr = mptr->next) {
1009 code = GetHash(mptr->dmi_addr);
1010 block.LAdrF[(code >> 3) & 7] |= 1 << (code & 7);
1014 SKMCA_TOIO(dev->mem_start + RAM_INITBASE, &block, sizeof(block));
1016 /* ...then reinit LANCE with the correct flags */
1020 /* ------------------------------------------------------------------------
1022 * ------------------------------------------------------------------------ */
1024 static int startslot; /* counts through slots when probing multiple devices */
1026 static void cleanup_card(struct net_device *dev)
1028 skmca_priv *priv = dev->priv;
1031 free_irq(dev->irq, dev);
1032 mca_mark_as_unused(priv->slot);
1033 mca_set_adapter_procfn(priv->slot, NULL, NULL);
1036 struct net_device * __init skmca_probe(int unit)
1038 struct net_device *dev;
1039 int force_detect = 0;
1040 int junior, slot, i;
1041 int base = 0, irq = 0;
1043 skmca_medium medium;
1046 /* can't work without an MCA bus ;-) */
1049 return ERR_PTR(-ENODEV);
1051 dev = alloc_etherdev(sizeof(skmca_priv));
1053 return ERR_PTR(-ENOMEM);
1056 sprintf(dev->name, "eth%d", unit);
1057 netdev_boot_setup_check(dev);
1060 SET_MODULE_OWNER(dev);
1062 /* start address of 1 --> forced detection */
1064 if (dev->mem_start == 1)
1067 /* search through slots */
1069 base = dev->mem_start;
1070 irq = dev->base_addr;
1071 for (slot = startslot; (slot = dofind(&junior, slot)) != -1; slot++) {
1072 /* deduce card addresses */
1074 getaddrs(slot, junior, &base, &irq, &medium);
1076 /* slot already in use ? */
1078 if (mca_is_adapter_used(slot))
1081 /* were we looking for something different ? */
1083 if (dev->irq && dev->irq != irq)
1085 if (dev->mem_start && dev->mem_start != base)
1088 /* found something that matches */
1093 /* nothing found ? */
1097 return (base || irq) ? ERR_PTR(-ENXIO) : ERR_PTR(-ENODEV);
1100 /* make procfs entries */
1103 mca_set_adapter_name(slot,
1104 "SKNET junior MC2 Ethernet Adapter");
1106 mca_set_adapter_name(slot, "SKNET MC2+ Ethernet Adapter");
1107 mca_set_adapter_procfn(slot, (MCA_ProcFn) skmca_getinfo, dev);
1109 mca_mark_as_used(slot);
1111 /* announce success */
1112 printk("%s: SKNet %s adapter found in slot %d\n", dev->name,
1113 junior ? "Junior MC2" : "MC2+", slot + 1);
1115 /* allocate structure */
1118 priv->macbase = base + 0x3fc0;
1119 priv->ioregaddr = base + 0x3ff0;
1120 priv->ctrladdr = base + 0x3ff2;
1121 priv->cmdaddr = base + 0x3ff3;
1122 priv->medium = medium;
1123 memset(&priv->stat, 0, sizeof(struct net_device_stats));
1124 spin_lock_init(&priv->lock);
1126 /* set base + irq for this device (irq not allocated so far) */
1128 dev->mem_start = base;
1129 dev->mem_end = base + 0x4000;
1136 ("%s: ambigous POS bit combination, must probe for IRQ...\n",
1138 nirq = ProbeIRQ(dev);
1140 printk("%s: IRQ probe failed, assuming IRQ %d",
1141 dev->name, priv->realirq = -irq);
1143 priv->realirq = nirq;
1145 priv->realirq = irq;
1148 dev->open = skmca_open;
1149 dev->stop = skmca_close;
1150 dev->set_config = skmca_config;
1151 dev->hard_start_xmit = skmca_tx;
1152 dev->do_ioctl = NULL;
1153 dev->get_stats = skmca_stats;
1154 dev->set_multicast_list = skmca_set_multicast_list;
1155 dev->flags |= IFF_MULTICAST;
1157 /* copy out MAC address */
1158 for (i = 0; i < 6; i++)
1159 dev->dev_addr[i] = SKMCA_READB(priv->macbase + (i << 1));
1162 printk("%s: IRQ %d, memory %#lx-%#lx, "
1163 "MAC address %02x:%02x:%02x:%02x:%02x:%02x.\n",
1164 dev->name, priv->realirq, dev->mem_start, dev->mem_end - 1,
1165 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
1166 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
1167 printk("%s: %s medium\n", dev->name, MediaNames[priv->medium]);
1173 startslot = slot + 1;
1175 err = register_netdev(dev);
1184 /* ------------------------------------------------------------------------
1185 * modularization support
1186 * ------------------------------------------------------------------------ */
1189 MODULE_LICENSE("GPL");
1193 static struct net_device *moddevs[DEVMAX];
1195 int init_module(void)
1200 for (z = 0; z < DEVMAX; z++) {
1201 struct net_device *dev = skmca_probe(-1);
1211 void cleanup_module(void)
1215 for (z = 0; z < DEVMAX; z++) {
1216 struct net_device *dev = moddevs[z];
1218 unregister_netdev(dev);