1 /* 3c527.c: 3Com Etherlink/MC32 driver for Linux 2.4
3 * (c) Copyright 1998 Red Hat Software Inc
5 * Further debugging by Carl Drougge.
6 * Modified by Richard Procter (rnp@netlink.co.nz)
8 * Based on skeleton.c written 1993-94 by Donald Becker and ne2.c
9 * (for the MCA stuff) written by Wim Dumon.
11 * Thanks to 3Com for making this possible by providing me with the
14 * This software may be used and distributed according to the terms
15 * of the GNU General Public License, incorporated herein by reference.
19 #define DRV_NAME "3c527"
20 #define DRV_VERSION "0.6a"
21 #define DRV_RELDATE "2001/11/17"
23 static const char *version =
24 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Richard Proctor (rnp@netlink.co.nz)\n";
27 * DOC: Traps for the unwary
29 * The diagram (Figure 1-1) and the POS summary disagree with the
30 * "Interrupt Level" section in the manual.
32 * The manual contradicts itself when describing the minimum number
33 * buffers in the 'configure lists' command.
34 * My card accepts a buffer config of 4/4.
36 * Setting the SAV BP bit does not save bad packets, but
37 * only enables RX on-card stats collection.
39 * The documentation in places seems to miss things. In actual fact
40 * I've always eventually found everything is documented, it just
41 * requires careful study.
43 * DOC: Theory Of Operation
45 * The 3com 3c527 is a 32bit MCA bus mastering adapter with a large
46 * amount of on board intelligence that housekeeps a somewhat dumber
47 * Intel NIC. For performance we want to keep the transmit queue deep
48 * as the card can transmit packets while fetching others from main
49 * memory by bus master DMA. Transmission and reception are driven by
50 * circular buffer queues.
52 * The mailboxes can be used for controlling how the card traverses
53 * its buffer rings, but are used only for inital setup in this
54 * implementation. The exec mailbox allows a variety of commands to
55 * be executed. Each command must complete before the next is
56 * executed. Primarily we use the exec mailbox for controlling the
57 * multicast lists. We have to do a certain amount of interesting
58 * hoop jumping as the multicast list changes can occur in interrupt
59 * state when the card has an exec command pending. We defer such
60 * events until the command completion interrupt.
62 * A copy break scheme (taken from 3c59x.c) is employed whereby
63 * received frames exceeding a configurable length are passed
64 * directly to the higher networking layers without incuring a copy,
65 * in what amounts to a time/space trade-off.
67 * The card also keeps a large amount of statistical information
68 * on-board. In a perfect world, these could be used safely at no
69 * cost. However, lacking information to the contrary, processing
70 * them without races would involve so much extra complexity as to
71 * make it unworthwhile to do so. In the end, a hybrid SW/HW
72 * implementation was made necessary --- see mc32_update_stats().
76 * It should be possible to use two or more cards, but at this stage
77 * only by loading two copies of the same module.
79 * The on-board 82586 NIC has trouble receiving multiple
80 * back-to-back frames and so is likely to drop packets from fast
84 #include <linux/module.h>
86 #include <linux/kernel.h>
87 #include <linux/sched.h>
88 #include <linux/types.h>
89 #include <linux/fcntl.h>
90 #include <linux/interrupt.h>
91 #include <linux/ptrace.h>
92 #include <linux/mca.h>
93 #include <linux/ioport.h>
95 #include <linux/slab.h>
96 #include <linux/string.h>
97 #include <linux/ethtool.h>
99 #include <asm/uaccess.h>
100 #include <asm/system.h>
101 #include <asm/bitops.h>
104 #include <linux/errno.h>
105 #include <linux/init.h>
107 #include <linux/netdevice.h>
108 #include <linux/etherdevice.h>
109 #include <linux/skbuff.h>
110 #include <linux/if_ether.h>
115 * The name of the card. Is used for messages and in the requests for
116 * io regions, irqs and dma channels
118 static const char* cardname = DRV_NAME;
120 /* use 0 for production, 1 for verification, >2 for debug */
127 static unsigned int mc32_debug = NET_DEBUG;
129 /* The number of low I/O ports used by the ethercard. */
130 #define MC32_IO_EXTENT 8
132 /* As implemented, values must be a power-of-2 -- 4/8/16/32 */
133 #define TX_RING_LEN 32 /* Typically the card supports 37 */
134 #define RX_RING_LEN 8 /* " " " */
136 /* Copy break point, see above for details.
137 * Setting to > 1512 effectively disables this feature. */
138 #define RX_COPYBREAK 200 /* Value from 3c59x.c */
140 /* Issue the 82586 workaround command - this is for "busy lans", but
141 * basically means for all lans now days - has a performance (latency)
142 * cost, but best set. */
143 static const int WORKAROUND_82586=1;
145 /* Pointers to buffers and their on-card records */
147 struct mc32_ring_desc
149 volatile struct skb_header *p;
154 /* Information that needs to be kept for each board. */
157 struct net_device_stats net_stats;
159 volatile struct mc32_mailbox *rx_box;
160 volatile struct mc32_mailbox *tx_box;
161 volatile struct mc32_mailbox *exec_box;
162 volatile struct mc32_stats *stats; /* Start of on-card statistics */
163 u16 tx_chain; /* Transmit list start offset */
164 u16 rx_chain; /* Receive list start offset */
165 u16 tx_len; /* Transmit list count */
166 u16 rx_len; /* Receive list count */
170 u16 mc_reload_wait; /* a multicast load request is pending */
171 u32 mc_list_valid; /* True when the mclist is set */
172 u16 xceiver_state; /* Current transceiver state. bitmapped */
173 u16 desired_state; /* The state we want the transceiver to be in */
174 atomic_t tx_count; /* buffers left */
175 wait_queue_head_t event;
177 struct mc32_ring_desc tx_ring[TX_RING_LEN]; /* Host Transmit ring */
178 struct mc32_ring_desc rx_ring[RX_RING_LEN]; /* Host Receive ring */
180 u16 tx_ring_tail; /* index to tx de-queue end */
181 u16 tx_ring_head; /* index to tx en-queue end */
183 u16 rx_ring_tail; /* index to rx de-queue end */
186 /* The station (ethernet) address prefix, used for a sanity check. */
187 #define SA_ADDR0 0x02
188 #define SA_ADDR1 0x60
189 #define SA_ADDR2 0xAC
191 struct mca_adapters_t {
196 const struct mca_adapters_t mc32_adapters[] = {
197 { 0x0041, "3COM EtherLink MC/32" },
198 { 0x8EF5, "IBM High Performance Lan Adapter" },
203 /* Macros for ring index manipulations */
204 static inline u16 next_rx(u16 rx) { return (rx+1)&(RX_RING_LEN-1); };
205 static inline u16 prev_rx(u16 rx) { return (rx-1)&(RX_RING_LEN-1); };
207 static inline u16 next_tx(u16 tx) { return (tx+1)&(TX_RING_LEN-1); };
210 /* Index to functions, as function prototypes. */
211 extern int mc32_probe(struct net_device *dev);
213 static int mc32_probe1(struct net_device *dev, int ioaddr);
214 static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len);
215 static int mc32_open(struct net_device *dev);
216 static void mc32_timeout(struct net_device *dev);
217 static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev);
218 static void mc32_interrupt(int irq, void *dev_id, struct pt_regs *regs);
219 static int mc32_close(struct net_device *dev);
220 static struct net_device_stats *mc32_get_stats(struct net_device *dev);
221 static void mc32_set_multicast_list(struct net_device *dev);
222 static void mc32_reset_multicast_list(struct net_device *dev);
223 static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
226 * mc32_probe - Search for supported boards
227 * @dev: device to probe
229 * Because MCA bus is a real bus and we can scan for cards we could do a
230 * single scan for all boards here. Right now we use the passed in device
231 * structure and scan for only one board. This needs fixing for modules
235 int __init mc32_probe(struct net_device *dev)
237 static int current_mca_slot = -1;
239 int adapter_found = 0;
241 SET_MODULE_OWNER(dev);
243 /* Do not check any supplied i/o locations.
244 POS registers usually don't fail :) */
246 /* MCA cards have POS registers.
247 Autodetecting MCA cards is extremely simple.
248 Just search for the card. */
250 for(i = 0; (mc32_adapters[i].name != NULL) && !adapter_found; i++) {
252 mca_find_unused_adapter(mc32_adapters[i].id, 0);
254 if((current_mca_slot != MCA_NOTFOUND) && !adapter_found) {
255 if(!mc32_probe1(dev, current_mca_slot))
257 mca_set_adapter_name(current_mca_slot,
258 mc32_adapters[i].name);
259 mca_mark_as_used(current_mca_slot);
269 * mc32_probe1 - Check a given slot for a board and test the card
270 * @dev: Device structure to fill in
271 * @slot: The MCA bus slot being used by this card
273 * Decode the slot data and configure the card structures. Having done this we
274 * can reset the card and configure it. The card does a full self test cycle
275 * in firmware so we have to wait for it to return and post us either a
276 * failure case or some addresses we use to find the board internals.
279 static int __init mc32_probe1(struct net_device *dev, int slot)
281 static unsigned version_printed;
285 struct mc32_local *lp;
286 static u16 mca_io_bases[]={
292 static u32 mca_mem_bases[]={
302 static char *failures[]={
303 "Processor instruction",
304 "Processor data bus",
305 "Processor data bus",
306 "Processor data bus",
311 "82586 internal loopback",
312 "82586 initialisation failure",
313 "Adapter list configuration error"
316 /* Time to play MCA games */
318 if (mc32_debug && version_printed++ == 0)
319 printk(KERN_DEBUG "%s", version);
321 printk(KERN_INFO "%s: %s found in slot %d:", dev->name, cardname, slot);
323 POS = mca_read_stored_pos(slot, 2);
327 printk(" disabled.\n");
331 /* Fill in the 'dev' fields. */
332 dev->base_addr = mca_io_bases[(POS>>1)&7];
333 dev->mem_start = mca_mem_bases[(POS>>4)&7];
335 POS = mca_read_stored_pos(slot, 4);
338 printk("memory window disabled.\n");
342 POS = mca_read_stored_pos(slot, 5);
347 printk("invalid memory window.\n");
354 dev->mem_end=dev->mem_start + i;
356 dev->irq = ((POS>>2)&3)+9;
358 if(!request_region(dev->base_addr, MC32_IO_EXTENT, cardname))
360 printk("io 0x%3lX, which is busy.\n", dev->base_addr);
364 printk("io 0x%3lX irq %d mem 0x%lX (%dK)\n",
365 dev->base_addr, dev->irq, dev->mem_start, i/1024);
368 /* We ought to set the cache line size here.. */
375 printk("%s: Address ", dev->name);
377 /* Retrieve and print the ethernet address. */
378 for (i = 0; i < 6; i++)
380 mca_write_pos(slot, 6, i+12);
381 mca_write_pos(slot, 7, 0);
383 printk(" %2.2x", dev->dev_addr[i] = mca_read_pos(slot,3));
386 mca_write_pos(slot, 6, 0);
387 mca_write_pos(slot, 7, 0);
389 POS = mca_read_stored_pos(slot, 4);
392 printk(" : BNC port selected.\n");
394 printk(" : AUI port selected.\n");
396 POS=inb(dev->base_addr+HOST_CTRL);
397 POS|=HOST_CTRL_ATTN|HOST_CTRL_RESET;
398 POS&=~HOST_CTRL_INTE;
399 outb(POS, dev->base_addr+HOST_CTRL);
403 POS&=~(HOST_CTRL_ATTN|HOST_CTRL_RESET);
404 outb(POS, dev->base_addr+HOST_CTRL);
412 i = request_irq(dev->irq, &mc32_interrupt, SA_SHIRQ, dev->name, dev);
414 release_region(dev->base_addr, MC32_IO_EXTENT);
415 printk(KERN_ERR "%s: unable to get IRQ %d.\n", dev->name, dev->irq);
420 /* Initialize the device structure. */
421 dev->priv = kmalloc(sizeof(struct mc32_local), GFP_KERNEL);
422 if (dev->priv == NULL)
428 memset(dev->priv, 0, sizeof(struct mc32_local));
434 base = inb(dev->base_addr);
441 printk(KERN_ERR "%s: failed to boot adapter.\n", dev->name);
446 if(inb(dev->base_addr+2)&(1<<5))
447 base = inb(dev->base_addr);
453 printk(KERN_ERR "%s: %s%s.\n", dev->name, failures[base-1],
454 base<0x0A?" test failure":"");
456 printk(KERN_ERR "%s: unknown failure %d.\n", dev->name, base);
466 while(!(inb(dev->base_addr+2)&(1<<5)))
472 printk(KERN_ERR "%s: mailbox read fail (%d).\n", dev->name, i);
478 base|=(inb(dev->base_addr)<<(8*i));
481 lp->exec_box=bus_to_virt(dev->mem_start+base);
483 base=lp->exec_box->data[1]<<16|lp->exec_box->data[0];
485 lp->base = dev->mem_start+base;
487 lp->rx_box=bus_to_virt(lp->base + lp->exec_box->data[2]);
488 lp->tx_box=bus_to_virt(lp->base + lp->exec_box->data[3]);
490 lp->stats = bus_to_virt(lp->base + lp->exec_box->data[5]);
493 * Descriptor chains (card relative)
496 lp->tx_chain = lp->exec_box->data[8]; /* Transmit list start offset */
497 lp->rx_chain = lp->exec_box->data[10]; /* Receive list start offset */
498 lp->tx_len = lp->exec_box->data[9]; /* Transmit list count */
499 lp->rx_len = lp->exec_box->data[11]; /* Receive list count */
501 init_waitqueue_head(&lp->event);
503 printk("%s: Firmware Rev %d. %d RX buffers, %d TX buffers. Base of 0x%08X.\n",
504 dev->name, lp->exec_box->data[12], lp->rx_len, lp->tx_len, lp->base);
506 dev->open = mc32_open;
507 dev->stop = mc32_close;
508 dev->hard_start_xmit = mc32_send_packet;
509 dev->get_stats = mc32_get_stats;
510 dev->set_multicast_list = mc32_set_multicast_list;
511 dev->tx_timeout = mc32_timeout;
512 dev->watchdog_timeo = HZ*5; /* Board does all the work */
513 dev->do_ioctl = netdev_ioctl;
515 lp->xceiver_state = HALTED;
517 lp->tx_ring_tail=lp->tx_ring_head=0;
519 /* Fill in the fields of the device structure with ethernet values. */
527 free_irq(dev->irq, dev);
528 release_region(dev->base_addr, MC32_IO_EXTENT);
534 * mc32_ready_poll - wait until we can feed it a command
535 * @dev: The device to wait for
537 * Wait until the card becomes ready to accept a command via the
538 * command register. This tells us nothing about the completion
539 * status of any pending commands and takes very little time at all.
542 static void mc32_ready_poll(struct net_device *dev)
544 int ioaddr = dev->base_addr;
545 while(!(inb(ioaddr+HOST_STATUS)&HOST_STATUS_CRR));
550 * mc32_command_nowait - send a command non blocking
551 * @dev: The 3c527 to issue the command to
552 * @cmd: The command word to write to the mailbox
553 * @data: A data block if the command expects one
554 * @len: Length of the data block
556 * Send a command from interrupt state. If there is a command
557 * currently being executed then we return an error of -1. It simply
558 * isn't viable to wait around as commands may be slow. Providing we
559 * get in, we busy wait for the board to become ready to accept the
560 * command and issue it. We do not wait for the command to complete
561 * --- the card will interrupt us when it's done.
564 static int mc32_command_nowait(struct net_device *dev, u16 cmd, void *data, int len)
566 struct mc32_local *lp = (struct mc32_local *)dev->priv;
567 int ioaddr = dev->base_addr;
573 lp->exec_box->mbox=0;
574 lp->exec_box->mbox=cmd;
575 memcpy((void *)lp->exec_box->data, data, len);
576 barrier(); /* the memcpy forgot the volatile so be sure */
578 /* Send the command */
579 while(!(inb(ioaddr+HOST_STATUS)&HOST_STATUS_CRR));
580 outb(1<<6, ioaddr+HOST_CMD);
586 * mc32_command - send a command and sleep until completion
587 * @dev: The 3c527 card to issue the command to
588 * @cmd: The command word to write to the mailbox
589 * @data: A data block if the command expects one
590 * @len: Length of the data block
592 * Sends exec commands in a user context. This permits us to wait around
593 * for the replies and also to wait for the command buffer to complete
594 * from a previous command before we execute our command. After our
595 * command completes we will complete any pending multicast reload
596 * we blocked off by hogging the exec buffer.
598 * You feed the card a command, you wait, it interrupts you get a
599 * reply. All well and good. The complication arises because you use
600 * commands for filter list changes which come in at bh level from things
601 * like IPV6 group stuff.
603 * We have a simple state machine
607 * 1 - command issued, wait reply
609 * 2 - reply waiting - reader then goes to state 0
611 * 3 - command issued, trash reply. In which case the irq
612 * takes it back to state 0
616 static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len)
618 struct mc32_local *lp = (struct mc32_local *)dev->priv;
619 int ioaddr = dev->base_addr;
630 while(lp->exec_pending)
631 sleep_on(&lp->event);
639 restore_flags(flags);
641 lp->exec_box->mbox=0;
642 lp->exec_box->mbox=cmd;
643 memcpy((void *)lp->exec_box->data, data, len);
644 barrier(); /* the memcpy forgot the volatile so be sure */
646 /* Send the command */
647 while(!(inb(ioaddr+HOST_STATUS)&HOST_STATUS_CRR));
648 outb(1<<6, ioaddr+HOST_CMD);
653 while(lp->exec_pending!=2)
654 sleep_on(&lp->event);
656 restore_flags(flags);
658 if(lp->exec_box->mbox&(1<<13))
662 * A multicast set got blocked - do it now
665 if(lp->mc_reload_wait)
667 mc32_reset_multicast_list(dev);
675 * mc32_start_transceiver - tell board to restart tx/rx
676 * @dev: The 3c527 card to issue the command to
678 * This may be called from the interrupt state, where it is used
679 * to restart the rx ring if the card runs out of rx buffers.
681 * First, we check if it's ok to start the transceiver. We then show
682 * the card where to start in the rx ring and issue the
683 * commands to start reception and transmission. We don't wait
684 * around for these to complete.
687 static void mc32_start_transceiver(struct net_device *dev) {
689 struct mc32_local *lp = (struct mc32_local *)dev->priv;
690 int ioaddr = dev->base_addr;
692 /* Ignore RX overflow on device closure */
693 if (lp->desired_state==HALTED)
696 mc32_ready_poll(dev);
701 /* Give the card the offset to the post-EOL-bit RX descriptor */
702 lp->rx_box->data[0]=lp->rx_ring[prev_rx(lp->rx_ring_tail)].p->next;
704 outb(HOST_CMD_START_RX, ioaddr+HOST_CMD);
706 mc32_ready_poll(dev);
707 outb(HOST_CMD_RESTRT_TX, ioaddr+HOST_CMD); /* card ignores this on RX restart */
709 /* We are not interrupted on start completion */
710 lp->xceiver_state=RUNNING;
715 * mc32_halt_transceiver - tell board to stop tx/rx
716 * @dev: The 3c527 card to issue the command to
718 * We issue the commands to halt the card's transceiver. In fact,
719 * after some experimenting we now simply tell the card to
720 * suspend. When issuing aborts occasionally odd things happened.
722 * We then sleep until the card has notified us that both rx and
723 * tx have been suspended.
726 static void mc32_halt_transceiver(struct net_device *dev)
728 struct mc32_local *lp = (struct mc32_local *)dev->priv;
729 int ioaddr = dev->base_addr;
732 mc32_ready_poll(dev);
737 outb(HOST_CMD_SUSPND_RX, ioaddr+HOST_CMD);
738 mc32_ready_poll(dev);
739 outb(HOST_CMD_SUSPND_TX, ioaddr+HOST_CMD);
744 while(lp->xceiver_state!=HALTED)
745 sleep_on(&lp->event);
747 restore_flags(flags);
752 * mc32_load_rx_ring - load the ring of receive buffers
753 * @dev: 3c527 to build the ring for
755 * This initalises the on-card and driver datastructures to
756 * the point where mc32_start_transceiver() can be called.
758 * The card sets up the receive ring for us. We are required to use the
759 * ring it provides although we can change the size of the ring.
761 * We allocate an sk_buff for each ring entry in turn and
762 * initalise its house-keeping info. At the same time, we read
763 * each 'next' pointer in our rx_ring array. This reduces slow
764 * shared-memory reads and makes it easy to access predecessor
767 * We then set the end-of-list bit for the last entry so that the
768 * card will know when it has run out of buffers.
771 static int mc32_load_rx_ring(struct net_device *dev)
773 struct mc32_local *lp = (struct mc32_local *)dev->priv;
776 volatile struct skb_header *p;
778 rx_base=lp->rx_chain;
780 for(i=0;i<RX_RING_LEN;i++)
782 lp->rx_ring[i].skb=alloc_skb(1532, GFP_KERNEL);
783 skb_reserve(lp->rx_ring[i].skb, 18);
785 if(lp->rx_ring[i].skb==NULL)
788 kfree_skb(lp->rx_ring[i].skb);
792 p=bus_to_virt(lp->base+rx_base);
795 p->data=virt_to_bus(lp->rx_ring[i].skb->data);
803 lp->rx_ring[i-1].p->control |= CONTROL_EOL;
812 * mc32_flush_rx_ring - free the ring of receive buffers
813 * @lp: Local data of 3c527 to flush the rx ring of
815 * Free the buffer for each ring slot. This may be called
816 * before mc32_load_rx_ring(), eg. on error in mc32_open().
819 static void mc32_flush_rx_ring(struct net_device *dev)
821 struct mc32_local *lp = (struct mc32_local *)dev->priv;
826 for(i=0; i < RX_RING_LEN; i++)
828 skb = lp->rx_ring[i].skb;
833 lp->rx_ring[i].p=NULL;
839 * mc32_load_tx_ring - load transmit ring
840 * @dev: The 3c527 card to issue the command to
842 * This sets up the host transmit data-structures.
844 * First, we obtain from the card it's current postion in the tx
845 * ring, so that we will know where to begin transmitting
848 * Then, we read the 'next' pointers from the on-card tx ring into
849 * our tx_ring array to reduce slow shared-mem reads. Finally, we
850 * intitalise the tx house keeping variables.
854 static void mc32_load_tx_ring(struct net_device *dev)
856 struct mc32_local *lp = (struct mc32_local *)dev->priv;
857 volatile struct skb_header *p;
861 tx_base=lp->tx_box->data[0];
863 for(i=0;i<lp->tx_len;i++)
865 p=bus_to_virt(lp->base+tx_base);
867 lp->tx_ring[i].skb=NULL;
872 /* -1 so that tx_ring_head cannot "lap" tx_ring_tail, */
873 /* which would be bad news for mc32_tx_ring as cur. implemented */
875 atomic_set(&lp->tx_count, TX_RING_LEN-1);
876 lp->tx_ring_head=lp->tx_ring_tail=0;
881 * mc32_flush_tx_ring - free transmit ring
882 * @lp: Local data of 3c527 to flush the tx ring of
884 * We have to consider two cases here. We want to free the pending
885 * buffers only. If the ring buffer head is past the start then the
886 * ring segment we wish to free wraps through zero. The tx ring
887 * house-keeping variables are then reset.
890 static void mc32_flush_tx_ring(struct net_device *dev)
892 struct mc32_local *lp = (struct mc32_local *)dev->priv;
894 if(lp->tx_ring_tail!=lp->tx_ring_head)
897 if(lp->tx_ring_tail < lp->tx_ring_head)
899 for(i=lp->tx_ring_tail;i<lp->tx_ring_head;i++)
901 dev_kfree_skb(lp->tx_ring[i].skb);
902 lp->tx_ring[i].skb=NULL;
903 lp->tx_ring[i].p=NULL;
908 for(i=lp->tx_ring_tail; i<TX_RING_LEN; i++)
910 dev_kfree_skb(lp->tx_ring[i].skb);
911 lp->tx_ring[i].skb=NULL;
912 lp->tx_ring[i].p=NULL;
914 for(i=0; i<lp->tx_ring_head; i++)
916 dev_kfree_skb(lp->tx_ring[i].skb);
917 lp->tx_ring[i].skb=NULL;
918 lp->tx_ring[i].p=NULL;
923 atomic_set(&lp->tx_count, 0);
924 lp->tx_ring_tail=lp->tx_ring_head=0;
929 * mc32_open - handle 'up' of card
930 * @dev: device to open
932 * The user is trying to bring the card into ready state. This requires
933 * a brief dialogue with the card. Firstly we enable interrupts and then
934 * 'indications'. Without these enabled the card doesn't bother telling
935 * us what it has done. This had me puzzled for a week.
937 * We configure the number of card descriptors, then load the network
938 * address and multicast filters. Turn on the workaround mode. This
939 * works around a bug in the 82586 - it asks the firmware to do
940 * so. It has a performance (latency) hit but is needed on busy
941 * [read most] lans. We load the ring with buffers then we kick it
945 static int mc32_open(struct net_device *dev)
947 int ioaddr = dev->base_addr;
948 struct mc32_local *lp = (struct mc32_local *)dev->priv;
951 u16 descnumbuffs[2] = {TX_RING_LEN, RX_RING_LEN};
957 regs=inb(ioaddr+HOST_CTRL);
958 regs|=HOST_CTRL_INTE;
959 outb(regs, ioaddr+HOST_CTRL);
963 * Send the indications on command
966 mc32_command(dev, 4, &one, 2);
969 * Poke it to make sure it's really dead.
972 mc32_halt_transceiver(dev);
973 mc32_flush_tx_ring(dev);
976 * Ask card to set up on-card descriptors to our spec
979 if(mc32_command(dev, 8, descnumbuffs, 4)) {
980 printk("%s: %s rejected our buffer configuration!\n",
981 dev->name, cardname);
986 /* Report new configuration */
987 mc32_command(dev, 6, NULL, 0);
989 lp->tx_chain = lp->exec_box->data[8]; /* Transmit list start offset */
990 lp->rx_chain = lp->exec_box->data[10]; /* Receive list start offset */
991 lp->tx_len = lp->exec_box->data[9]; /* Transmit list count */
992 lp->rx_len = lp->exec_box->data[11]; /* Receive list count */
994 /* Set Network Address */
995 mc32_command(dev, 1, dev->dev_addr, 6);
997 /* Set the filters */
998 mc32_set_multicast_list(dev);
1000 if (WORKAROUND_82586) {
1002 mc32_command(dev, 0x0D, &zero_word, 2); /* 82586 bug workaround on */
1005 mc32_load_tx_ring(dev);
1007 if(mc32_load_rx_ring(dev))
1013 lp->desired_state = RUNNING;
1015 /* And finally, set the ball rolling... */
1016 mc32_start_transceiver(dev);
1018 netif_start_queue(dev);
1025 * mc32_timeout - handle a timeout from the network layer
1026 * @dev: 3c527 that timed out
1028 * Handle a timeout on transmit from the 3c527. This normally means
1029 * bad things as the hardware handles cable timeouts and mess for
1034 static void mc32_timeout(struct net_device *dev)
1036 printk(KERN_WARNING "%s: transmit timed out?\n", dev->name);
1037 /* Try to restart the adaptor. */
1038 netif_wake_queue(dev);
1043 * mc32_send_packet - queue a frame for transmit
1044 * @skb: buffer to transmit
1045 * @dev: 3c527 to send it out of
1047 * Transmit a buffer. This normally means throwing the buffer onto
1048 * the transmit queue as the queue is quite large. If the queue is
1049 * full then we set tx_busy and return. Once the interrupt handler
1050 * gets messages telling it to reclaim transmit queue entries we will
1051 * clear tx_busy and the kernel will start calling this again.
1053 * We use cli rather than spinlocks. Since I have no access to an SMP
1054 * MCA machine I don't plan to change it. It is probably the top
1055 * performance hit for this driver on SMP however.
1058 static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev)
1060 struct mc32_local *lp = (struct mc32_local *)dev->priv;
1061 unsigned long flags;
1063 volatile struct skb_header *p, *np;
1065 netif_stop_queue(dev);
1070 if(atomic_read(&lp->tx_count)==0)
1072 restore_flags(flags);
1076 atomic_dec(&lp->tx_count);
1078 /* P is the last sending/sent buffer as a pointer */
1079 p=lp->tx_ring[lp->tx_ring_head].p;
1081 lp->tx_ring_head=next_tx(lp->tx_ring_head);
1083 /* NP is the buffer we will be loading */
1084 np=lp->tx_ring[lp->tx_ring_head].p;
1086 /* We will need this to flush the buffer out */
1087 lp->tx_ring[lp->tx_ring_head].skb=skb;
1089 np->length = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
1091 np->data = virt_to_bus(skb->data);
1093 np->control = CONTROL_EOP | CONTROL_EOL;
1096 p->control &= ~CONTROL_EOL; /* Clear EOL on p */
1098 restore_flags(flags);
1100 netif_wake_queue(dev);
1106 * mc32_update_stats - pull off the on board statistics
1107 * @dev: 3c527 to service
1110 * Query and reset the on-card stats. There's the small possibility
1111 * of a race here, which would result in an underestimation of
1112 * actual errors. As such, we'd prefer to keep all our stats
1113 * collection in software. As a rule, we do. However it can't be
1114 * used for rx errors and collisions as, by default, the card discards
1117 * Setting the SAV BP in the rx filter command supposedly
1118 * stops this behaviour. However, testing shows that it only seems to
1119 * enable the collation of on-card rx statistics --- the driver
1120 * never sees an RX descriptor with an error status set.
1124 static void mc32_update_stats(struct net_device *dev)
1126 struct mc32_local *lp = (struct mc32_local *)dev->priv;
1127 volatile struct mc32_stats *st = lp->stats;
1131 rx_errors+=lp->net_stats.rx_crc_errors +=st->rx_crc_errors;
1132 st->rx_crc_errors=0;
1133 rx_errors+=lp->net_stats.rx_fifo_errors +=st->rx_overrun_errors;
1134 st->rx_overrun_errors=0;
1135 rx_errors+=lp->net_stats.rx_frame_errors +=st->rx_alignment_errors;
1136 st->rx_alignment_errors=0;
1137 rx_errors+=lp->net_stats.rx_length_errors+=st->rx_tooshort_errors;
1138 st->rx_tooshort_errors=0;
1139 rx_errors+=lp->net_stats.rx_missed_errors+=st->rx_outofresource_errors;
1140 st->rx_outofresource_errors=0;
1141 lp->net_stats.rx_errors=rx_errors;
1143 /* Number of packets which saw one collision */
1144 lp->net_stats.collisions+=st->dataC[10];
1147 /* Number of packets which saw 2--15 collisions */
1148 lp->net_stats.collisions+=st->dataC[11];
1154 * mc32_rx_ring - process the receive ring
1155 * @dev: 3c527 that needs its receive ring processing
1158 * We have received one or more indications from the card that a
1159 * receive has completed. The buffer ring thus contains dirty
1160 * entries. We walk the ring by iterating over the circular rx_ring
1161 * array, starting at the next dirty buffer (which happens to be the
1162 * one we finished up at last time around).
1164 * For each completed packet, we will either copy it and pass it up
1165 * the stack or, if the packet is near MTU sized, we allocate
1166 * another buffer and flip the old one up the stack.
1168 * We must succeed in keeping a buffer on the ring. If neccessary we
1169 * will toss a received packet rather than lose a ring entry. Once
1170 * the first uncompleted descriptor is found, we move the
1171 * End-Of-List bit to include the buffers just processed.
1175 static void mc32_rx_ring(struct net_device *dev)
1177 struct mc32_local *lp=dev->priv;
1178 volatile struct skb_header *p;
1179 u16 rx_ring_tail = lp->rx_ring_tail;
1180 u16 rx_old_tail = rx_ring_tail;
1186 p=lp->rx_ring[rx_ring_tail].p;
1188 if(!(p->status & (1<<7))) { /* Not COMPLETED */
1191 if(p->status & (1<<6)) /* COMPLETED_OK */
1194 u16 length=p->length;
1195 struct sk_buff *skb;
1196 struct sk_buff *newskb;
1198 /* Try to save time by avoiding a copy on big frames */
1200 if ((length > RX_COPYBREAK)
1201 && ((newskb=dev_alloc_skb(1532)) != NULL))
1203 skb=lp->rx_ring[rx_ring_tail].skb;
1204 skb_put(skb, length);
1206 skb_reserve(newskb,18);
1207 lp->rx_ring[rx_ring_tail].skb=newskb;
1208 p->data=virt_to_bus(newskb->data);
1212 skb=dev_alloc_skb(length+2);
1215 lp->net_stats.rx_dropped++;
1220 memcpy(skb_put(skb, length),
1221 lp->rx_ring[rx_ring_tail].skb->data, length);
1224 skb->protocol=eth_type_trans(skb,dev);
1226 dev->last_rx = jiffies;
1227 lp->net_stats.rx_packets++;
1228 lp->net_stats.rx_bytes += length;
1236 rx_ring_tail=next_rx(rx_ring_tail);
1240 /* If there was actually a frame to be processed, place the EOL bit */
1241 /* at the descriptor prior to the one to be filled next */
1243 if (rx_ring_tail != rx_old_tail)
1245 lp->rx_ring[prev_rx(rx_ring_tail)].p->control |= CONTROL_EOL;
1246 lp->rx_ring[prev_rx(rx_old_tail)].p->control &= ~CONTROL_EOL;
1248 lp->rx_ring_tail=rx_ring_tail;
1254 * mc32_tx_ring - process completed transmits
1255 * @dev: 3c527 that needs its transmit ring processing
1258 * This operates in a similar fashion to mc32_rx_ring. We iterate
1259 * over the transmit ring. For each descriptor which has been
1260 * processed by the card, we free its associated buffer and note
1261 * any errors. This continues until the transmit ring is emptied
1262 * or we reach a descriptor that hasn't yet been processed by the
1267 static void mc32_tx_ring(struct net_device *dev)
1269 struct mc32_local *lp=(struct mc32_local *)dev->priv;
1270 volatile struct skb_header *np;
1272 /* NB: lp->tx_count=TX_RING_LEN-1 so that tx_ring_head cannot "lap" tail here */
1274 while (lp->tx_ring_tail != lp->tx_ring_head)
1278 t=next_tx(lp->tx_ring_tail);
1279 np=lp->tx_ring[t].p;
1281 if(!(np->status & (1<<7)))
1286 lp->net_stats.tx_packets++;
1287 if(!(np->status & (1<<6))) /* Not COMPLETED_OK */
1289 lp->net_stats.tx_errors++;
1291 switch(np->status&0x0F)
1294 lp->net_stats.tx_aborted_errors++;
1295 break; /* Max collisions */
1297 lp->net_stats.tx_fifo_errors++;
1300 lp->net_stats.tx_carrier_errors++;
1303 lp->net_stats.tx_window_errors++;
1304 break; /* CTS Lost */
1306 lp->net_stats.tx_aborted_errors++;
1307 break; /* Transmit timeout */
1310 /* Packets are sent in order - this is
1311 basically a FIFO queue of buffers matching
1313 lp->net_stats.tx_bytes+=lp->tx_ring[t].skb->len;
1314 dev_kfree_skb_irq(lp->tx_ring[t].skb);
1315 lp->tx_ring[t].skb=NULL;
1316 atomic_inc(&lp->tx_count);
1317 netif_wake_queue(dev);
1326 * mc32_interrupt - handle an interrupt from a 3c527
1327 * @irq: Interrupt number
1328 * @dev_id: 3c527 that requires servicing
1329 * @regs: Registers (unused)
1332 * An interrupt is raised whenever the 3c527 writes to the command
1333 * register. This register contains the message it wishes to send us
1334 * packed into a single byte field. We keep reading status entries
1335 * until we have processed all the control items, but simply count
1336 * transmit and receive reports. When all reports are in we empty the
1337 * transceiver rings as appropriate. This saves the overhead of
1338 * multiple command requests.
1340 * Because MCA is level-triggered, we shouldn't miss indications.
1341 * Therefore, we needn't ask the card to suspend interrupts within
1342 * this handler. The card receives an implicit acknowledgment of the
1343 * current interrupt when we read the command register.
1347 static void mc32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1349 struct net_device *dev = dev_id;
1350 struct mc32_local *lp;
1351 int ioaddr, status, boguscount = 0;
1356 printk(KERN_WARNING "%s: irq %d for unknown device.\n", cardname, irq);
1360 ioaddr = dev->base_addr;
1361 lp = (struct mc32_local *)dev->priv;
1363 /* See whats cooking */
1365 while((inb(ioaddr+HOST_STATUS)&HOST_STATUS_CWR) && boguscount++<2000)
1367 status=inb(ioaddr+HOST_CMD);
1370 printk("Status TX%d RX%d EX%d OV%d BC%d\n",
1371 (status&7), (status>>3)&7, (status>>6)&1,
1372 (status>>7)&1, boguscount);
1379 case 6: /* TX fail */
1385 lp->xceiver_state |= TX_HALTED;
1386 wake_up(&lp->event);
1389 printk("%s: strange tx ack %d\n", dev->name, status&7);
1401 lp->xceiver_state |= RX_HALTED;
1402 wake_up(&lp->event);
1405 /* Out of RX buffers stat */
1406 /* Must restart rx */
1407 lp->net_stats.rx_dropped++;
1409 mc32_start_transceiver(dev);
1412 printk("%s: strange rx ack %d\n",
1413 dev->name, status&7);
1419 /* 0=no 1=yes 2=replied, get cmd, 3 = wait reply & dump it */
1421 if(lp->exec_pending!=3) {
1423 wake_up(&lp->event);
1429 /* A new multicast set may have been
1430 blocked while the old one was
1431 running. If so, do it now. */
1433 if (lp->mc_reload_wait)
1434 mc32_reset_multicast_list(dev);
1436 wake_up(&lp->event);
1442 * We get interrupted once per
1443 * counter that is about to overflow.
1446 mc32_update_stats(dev);
1452 * Process the transmit and receive rings
1466 * mc32_close - user configuring the 3c527 down
1467 * @dev: 3c527 card to shut down
1469 * The 3c527 is a bus mastering device. We must be careful how we
1470 * shut it down. It may also be running shared interrupt so we have
1471 * to be sure to silence it properly
1473 * We indicate that the card is closing to the rest of the
1474 * driver. Otherwise, it is possible that the card may run out
1475 * of receive buffers and restart the transceiver while we're
1476 * trying to close it.
1478 * We abort any receive and transmits going on and then wait until
1479 * any pending exec commands have completed in other code threads.
1480 * In theory we can't get here while that is true, in practice I am
1483 * We turn off the interrupt enable for the board to be sure it can't
1484 * intefere with other devices.
1487 static int mc32_close(struct net_device *dev)
1489 struct mc32_local *lp = (struct mc32_local *)dev->priv;
1491 int ioaddr = dev->base_addr;
1495 lp->desired_state = HALTED;
1496 netif_stop_queue(dev);
1499 * Send the indications on command (handy debug check)
1502 mc32_command(dev, 4, &one, 2);
1504 /* Shut down the transceiver */
1506 mc32_halt_transceiver(dev);
1508 /* Catch any waiting commands */
1510 while(lp->exec_pending==1)
1511 sleep_on(&lp->event);
1513 /* Ok the card is now stopping */
1515 regs=inb(ioaddr+HOST_CTRL);
1516 regs&=~HOST_CTRL_INTE;
1517 outb(regs, ioaddr+HOST_CTRL);
1519 mc32_flush_rx_ring(dev);
1520 mc32_flush_tx_ring(dev);
1522 mc32_update_stats(dev);
1529 * mc32_get_stats - hand back stats to network layer
1530 * @dev: The 3c527 card to handle
1532 * We've collected all the stats we can in software already. Now
1533 * it's time to update those kept on-card and return the lot.
1537 static struct net_device_stats *mc32_get_stats(struct net_device *dev)
1539 struct mc32_local *lp;
1541 mc32_update_stats(dev);
1543 lp = (struct mc32_local *)dev->priv;
1545 return &lp->net_stats;
1550 * do_mc32_set_multicast_list - attempt to update multicasts
1551 * @dev: 3c527 device to load the list on
1552 * @retry: indicates this is not the first call.
1555 * Actually set or clear the multicast filter for this adaptor. The
1556 * locking issues are handled by this routine. We have to track
1557 * state as it may take multiple calls to get the command sequence
1558 * completed. We just keep trying to schedule the loads until we
1559 * manage to process them all.
1561 * num_addrs == -1 Promiscuous mode, receive all packets
1563 * num_addrs == 0 Normal mode, clear multicast list
1565 * num_addrs > 0 Multicast mode, receive normal and MC packets,
1566 * and do best-effort filtering.
1568 * See mc32_update_stats() regards setting the SAV BP bit.
1572 static void do_mc32_set_multicast_list(struct net_device *dev, int retry)
1574 struct mc32_local *lp = (struct mc32_local *)dev->priv;
1575 u16 filt = (1<<2); /* Save Bad Packets, for stats purposes */
1577 if (dev->flags&IFF_PROMISC)
1578 /* Enable promiscuous mode */
1580 else if((dev->flags&IFF_ALLMULTI) || dev->mc_count > 10)
1582 dev->flags|=IFF_PROMISC;
1585 else if(dev->mc_count)
1587 unsigned char block[62];
1589 struct dev_mc_list *dmc=dev->mc_list;
1594 lp->mc_list_valid = 0;
1595 if(!lp->mc_list_valid)
1598 block[0]=dev->mc_count;
1601 for(i=0;i<dev->mc_count;i++)
1603 memcpy(bp, dmc->dmi_addr, 6);
1607 if(mc32_command_nowait(dev, 2, block, 2+6*dev->mc_count)==-1)
1609 lp->mc_reload_wait = 1;
1612 lp->mc_list_valid=1;
1616 if(mc32_command_nowait(dev, 0, &filt, 2)==-1)
1618 lp->mc_reload_wait = 1;
1621 lp->mc_reload_wait = 0;
1627 * mc32_set_multicast_list - queue multicast list update
1628 * @dev: The 3c527 to use
1630 * Commence loading the multicast list. This is called when the kernel
1631 * changes the lists. It will override any pending list we are trying to
1635 static void mc32_set_multicast_list(struct net_device *dev)
1637 do_mc32_set_multicast_list(dev,0);
1642 * mc32_reset_multicast_list - reset multicast list
1643 * @dev: The 3c527 to use
1645 * Attempt the next step in loading the multicast lists. If this attempt
1646 * fails to complete then it will be scheduled and this function called
1647 * again later from elsewhere.
1650 static void mc32_reset_multicast_list(struct net_device *dev)
1652 do_mc32_set_multicast_list(dev,1);
1656 * netdev_ethtool_ioctl: Handle network interface SIOCETHTOOL ioctls
1657 * @dev: network interface on which out-of-band action is to be performed
1658 * @useraddr: userspace address to which data is to be read and returned
1660 * Process the various commands of the SIOCETHTOOL interface.
1663 static int netdev_ethtool_ioctl (struct net_device *dev, void *useraddr)
1667 /* dev_ioctl() in ../../net/core/dev.c has already checked
1668 capable(CAP_NET_ADMIN), so don't bother with that here. */
1670 if (get_user(ethcmd, (u32 *)useraddr))
1675 case ETHTOOL_GDRVINFO: {
1676 struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
1677 strcpy (info.driver, DRV_NAME);
1678 strcpy (info.version, DRV_VERSION);
1679 sprintf(info.bus_info, "MCA 0x%lx", dev->base_addr);
1680 if (copy_to_user (useraddr, &info, sizeof (info)))
1685 /* get message-level */
1686 case ETHTOOL_GMSGLVL: {
1687 struct ethtool_value edata = {ETHTOOL_GMSGLVL};
1688 edata.data = mc32_debug;
1689 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1693 /* set message-level */
1694 case ETHTOOL_SMSGLVL: {
1695 struct ethtool_value edata;
1696 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1698 mc32_debug = edata.data;
1710 * netdev_ioctl: Handle network interface ioctls
1711 * @dev: network interface on which out-of-band action is to be performed
1712 * @rq: user request data
1713 * @cmd: command issued by user
1715 * Process the various out-of-band ioctls passed to this driver.
1718 static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
1724 rc = netdev_ethtool_ioctl(dev, (void *) rq->ifr_data);
1737 static struct net_device this_device;
1740 * init_module - entry point
1742 * Probe and locate a 3c527 card. This really should probe and locate
1743 * all the 3c527 cards in the machine not just one of them. Yes you can
1744 * insmod multiple modules for now but it's a hack.
1747 int init_module(void)
1751 this_device.init = mc32_probe;
1752 if ((result = register_netdev(&this_device)) != 0)
1759 * cleanup_module - free resources for an unload
1761 * Unloading time. We release the MCA bus resources and the interrupt
1762 * at which point everything is ready to unload. The card must be stopped
1763 * at this point or we would not have been called. When we unload we
1764 * leave the card stopped but not totally shut down. When the card is
1765 * initialized it must be rebooted or the rings reloaded before any
1766 * transmit operations are allowed to start scribbling into memory.
1769 void cleanup_module(void)
1773 /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
1774 unregister_netdev(&this_device);
1777 * If we don't do this, we can't re-insmod it later.
1780 if (this_device.priv)
1782 struct mc32_local *lp=this_device.priv;
1784 mca_mark_as_unused(slot);
1785 mca_set_adapter_name(slot, NULL);
1786 kfree(this_device.priv);
1788 free_irq(this_device.irq, &this_device);
1789 release_region(this_device.base_addr, MC32_IO_EXTENT);