1 /* 3c527.c: 3Com Etherlink/MC32 driver for Linux 2.4 and 2.6.
3 * (c) Copyright 1998 Red Hat Software Inc
5 * Further debugging by Carl Drougge.
6 * Initial SMP support by Felipe W Damasio <felipewd@terra.com.br>
7 * Heavily modified by Richard Procter <rnp@paradise.net.nz>
9 * Based on skeleton.c written 1993-94 by Donald Becker and ne2.c
10 * (for the MCA stuff) written by Wim Dumon.
12 * Thanks to 3Com for making this possible by providing me with the
15 * This software may be used and distributed according to the terms
16 * of the GNU General Public License, incorporated herein by reference.
20 #define DRV_NAME "3c527"
21 #define DRV_VERSION "0.7-SMP"
22 #define DRV_RELDATE "2003/09/21"
24 static const char *version =
25 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Richard Procter <rnp@paradise.net.nz>\n";
28 * DOC: Traps for the unwary
30 * The diagram (Figure 1-1) and the POS summary disagree with the
31 * "Interrupt Level" section in the manual.
33 * The manual contradicts itself when describing the minimum number
34 * buffers in the 'configure lists' command.
35 * My card accepts a buffer config of 4/4.
37 * Setting the SAV BP bit does not save bad packets, but
38 * only enables RX on-card stats collection.
40 * The documentation in places seems to miss things. In actual fact
41 * I've always eventually found everything is documented, it just
42 * requires careful study.
44 * DOC: Theory Of Operation
46 * The 3com 3c527 is a 32bit MCA bus mastering adapter with a large
47 * amount of on board intelligence that housekeeps a somewhat dumber
48 * Intel NIC. For performance we want to keep the transmit queue deep
49 * as the card can transmit packets while fetching others from main
50 * memory by bus master DMA. Transmission and reception are driven by
51 * circular buffer queues.
53 * The mailboxes can be used for controlling how the card traverses
54 * its buffer rings, but are used only for inital setup in this
55 * implementation. The exec mailbox allows a variety of commands to
56 * be executed. Each command must complete before the next is
57 * executed. Primarily we use the exec mailbox for controlling the
58 * multicast lists. We have to do a certain amount of interesting
59 * hoop jumping as the multicast list changes can occur in interrupt
60 * state when the card has an exec command pending. We defer such
61 * events until the command completion interrupt.
63 * A copy break scheme (taken from 3c59x.c) is employed whereby
64 * received frames exceeding a configurable length are passed
65 * directly to the higher networking layers without incuring a copy,
66 * in what amounts to a time/space trade-off.
68 * The card also keeps a large amount of statistical information
69 * on-board. In a perfect world, these could be used safely at no
70 * cost. However, lacking information to the contrary, processing
71 * them without races would involve so much extra complexity as to
72 * make it unworthwhile to do so. In the end, a hybrid SW/HW
73 * implementation was made necessary --- see mc32_update_stats().
77 * It should be possible to use two or more cards, but at this stage
78 * only by loading two copies of the same module.
80 * The on-board 82586 NIC has trouble receiving multiple
81 * back-to-back frames and so is likely to drop packets from fast
85 #include <linux/module.h>
87 #include <linux/errno.h>
88 #include <linux/netdevice.h>
89 #include <linux/etherdevice.h>
90 #include <linux/if_ether.h>
91 #include <linux/init.h>
92 #include <linux/kernel.h>
93 #include <linux/types.h>
94 #include <linux/fcntl.h>
95 #include <linux/interrupt.h>
96 #include <linux/mca-legacy.h>
97 #include <linux/ioport.h>
99 #include <linux/skbuff.h>
100 #include <linux/slab.h>
101 #include <linux/string.h>
102 #include <linux/wait.h>
103 #include <linux/ethtool.h>
104 #include <linux/completion.h>
106 #include <asm/semaphore.h>
107 #include <asm/uaccess.h>
108 #include <asm/system.h>
109 #include <asm/bitops.h>
115 MODULE_LICENSE("GPL");
118 * The name of the card. Is used for messages and in the requests for
119 * io regions, irqs and dma channels
121 static const char* cardname = DRV_NAME;
123 /* use 0 for production, 1 for verification, >2 for debug */
130 static unsigned int mc32_debug = NET_DEBUG;
132 /* The number of low I/O ports used by the ethercard. */
133 #define MC32_IO_EXTENT 8
135 /* As implemented, values must be a power-of-2 -- 4/8/16/32 */
136 #define TX_RING_LEN 32 /* Typically the card supports 37 */
137 #define RX_RING_LEN 8 /* " " " */
139 /* Copy break point, see above for details.
140 * Setting to > 1512 effectively disables this feature. */
141 #define RX_COPYBREAK 200 /* Value from 3c59x.c */
143 /* Issue the 82586 workaround command - this is for "busy lans", but
144 * basically means for all lans now days - has a performance (latency)
145 * cost, but best set. */
146 static const int WORKAROUND_82586=1;
148 /* Pointers to buffers and their on-card records */
149 struct mc32_ring_desc
151 volatile struct skb_header *p;
155 /* Information that needs to be kept for each board. */
161 struct net_device_stats net_stats;
162 volatile struct mc32_mailbox *rx_box;
163 volatile struct mc32_mailbox *tx_box;
164 volatile struct mc32_mailbox *exec_box;
165 volatile struct mc32_stats *stats; /* Start of on-card statistics */
166 u16 tx_chain; /* Transmit list start offset */
167 u16 rx_chain; /* Receive list start offset */
168 u16 tx_len; /* Transmit list count */
169 u16 rx_len; /* Receive list count */
171 u16 xceiver_desired_state; /* HALTED or RUNNING */
172 u16 cmd_nonblocking; /* Thread is uninterested in command result */
173 u16 mc_reload_wait; /* A multicast load request is pending */
174 u32 mc_list_valid; /* True when the mclist is set */
176 struct mc32_ring_desc tx_ring[TX_RING_LEN]; /* Host Transmit ring */
177 struct mc32_ring_desc rx_ring[RX_RING_LEN]; /* Host Receive ring */
179 atomic_t tx_count; /* buffers left */
180 atomic_t tx_ring_head; /* index to tx en-queue end */
181 u16 tx_ring_tail; /* index to tx de-queue end */
183 u16 rx_ring_tail; /* index to rx de-queue end */
185 struct semaphore cmd_mutex; /* Serialises issuing of execute commands */
186 struct completion execution_cmd; /* Card has completed an execute command */
187 struct completion xceiver_cmd; /* Card has completed a tx or rx command */
190 /* The station (ethernet) address prefix, used for a sanity check. */
191 #define SA_ADDR0 0x02
192 #define SA_ADDR1 0x60
193 #define SA_ADDR2 0xAC
195 struct mca_adapters_t {
200 const struct mca_adapters_t mc32_adapters[] = {
201 { 0x0041, "3COM EtherLink MC/32" },
202 { 0x8EF5, "IBM High Performance Lan Adapter" },
207 /* Macros for ring index manipulations */
208 static inline u16 next_rx(u16 rx) { return (rx+1)&(RX_RING_LEN-1); };
209 static inline u16 prev_rx(u16 rx) { return (rx-1)&(RX_RING_LEN-1); };
211 static inline u16 next_tx(u16 tx) { return (tx+1)&(TX_RING_LEN-1); };
214 /* Index to functions, as function prototypes. */
215 static int mc32_probe1(struct net_device *dev, int ioaddr);
216 static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len);
217 static int mc32_open(struct net_device *dev);
218 static void mc32_timeout(struct net_device *dev);
219 static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev);
220 static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs *regs);
221 static int mc32_close(struct net_device *dev);
222 static struct net_device_stats *mc32_get_stats(struct net_device *dev);
223 static void mc32_set_multicast_list(struct net_device *dev);
224 static void mc32_reset_multicast_list(struct net_device *dev);
225 static struct ethtool_ops netdev_ethtool_ops;
227 static void cleanup_card(struct net_device *dev)
229 struct mc32_local *lp = netdev_priv(dev);
230 unsigned slot = lp->slot;
231 mca_mark_as_unused(slot);
232 mca_set_adapter_name(slot, NULL);
233 free_irq(dev->irq, dev);
234 release_region(dev->base_addr, MC32_IO_EXTENT);
238 * mc32_probe - Search for supported boards
239 * @unit: interface number to use
241 * Because MCA bus is a real bus and we can scan for cards we could do a
242 * single scan for all boards here. Right now we use the passed in device
243 * structure and scan for only one board. This needs fixing for modules
247 struct net_device *__init mc32_probe(int unit)
249 struct net_device *dev = alloc_etherdev(sizeof(struct mc32_local));
250 static int current_mca_slot = -1;
255 return ERR_PTR(-ENOMEM);
258 sprintf(dev->name, "eth%d", unit);
260 SET_MODULE_OWNER(dev);
262 /* Do not check any supplied i/o locations.
263 POS registers usually don't fail :) */
265 /* MCA cards have POS registers.
266 Autodetecting MCA cards is extremely simple.
267 Just search for the card. */
269 for(i = 0; (mc32_adapters[i].name != NULL); i++) {
271 mca_find_unused_adapter(mc32_adapters[i].id, 0);
273 if(current_mca_slot != MCA_NOTFOUND) {
274 if(!mc32_probe1(dev, current_mca_slot))
276 mca_set_adapter_name(current_mca_slot,
277 mc32_adapters[i].name);
278 mca_mark_as_used(current_mca_slot);
279 err = register_netdev(dev);
290 return ERR_PTR(-ENODEV);
294 * mc32_probe1 - Check a given slot for a board and test the card
295 * @dev: Device structure to fill in
296 * @slot: The MCA bus slot being used by this card
298 * Decode the slot data and configure the card structures. Having done this we
299 * can reset the card and configure it. The card does a full self test cycle
300 * in firmware so we have to wait for it to return and post us either a
301 * failure case or some addresses we use to find the board internals.
304 static int __init mc32_probe1(struct net_device *dev, int slot)
306 static unsigned version_printed;
310 struct mc32_local *lp = netdev_priv(dev);
311 static u16 mca_io_bases[]={
317 static u32 mca_mem_bases[]={
327 static char *failures[]={
328 "Processor instruction",
329 "Processor data bus",
330 "Processor data bus",
331 "Processor data bus",
336 "82586 internal loopback",
337 "82586 initialisation failure",
338 "Adapter list configuration error"
341 /* Time to play MCA games */
343 if (mc32_debug && version_printed++ == 0)
344 printk(KERN_DEBUG "%s", version);
346 printk(KERN_INFO "%s: %s found in slot %d:", dev->name, cardname, slot);
348 POS = mca_read_stored_pos(slot, 2);
352 printk(" disabled.\n");
356 /* Fill in the 'dev' fields. */
357 dev->base_addr = mca_io_bases[(POS>>1)&7];
358 dev->mem_start = mca_mem_bases[(POS>>4)&7];
360 POS = mca_read_stored_pos(slot, 4);
363 printk("memory window disabled.\n");
367 POS = mca_read_stored_pos(slot, 5);
372 printk("invalid memory window.\n");
379 dev->mem_end=dev->mem_start + i;
381 dev->irq = ((POS>>2)&3)+9;
383 if(!request_region(dev->base_addr, MC32_IO_EXTENT, cardname))
385 printk("io 0x%3lX, which is busy.\n", dev->base_addr);
389 printk("io 0x%3lX irq %d mem 0x%lX (%dK)\n",
390 dev->base_addr, dev->irq, dev->mem_start, i/1024);
393 /* We ought to set the cache line size here.. */
400 printk("%s: Address ", dev->name);
402 /* Retrieve and print the ethernet address. */
403 for (i = 0; i < 6; i++)
405 mca_write_pos(slot, 6, i+12);
406 mca_write_pos(slot, 7, 0);
408 printk(" %2.2x", dev->dev_addr[i] = mca_read_pos(slot,3));
411 mca_write_pos(slot, 6, 0);
412 mca_write_pos(slot, 7, 0);
414 POS = mca_read_stored_pos(slot, 4);
417 printk(" : BNC port selected.\n");
419 printk(" : AUI port selected.\n");
421 POS=inb(dev->base_addr+HOST_CTRL);
422 POS|=HOST_CTRL_ATTN|HOST_CTRL_RESET;
423 POS&=~HOST_CTRL_INTE;
424 outb(POS, dev->base_addr+HOST_CTRL);
428 POS&=~(HOST_CTRL_ATTN|HOST_CTRL_RESET);
429 outb(POS, dev->base_addr+HOST_CTRL);
437 err = request_irq(dev->irq, &mc32_interrupt, SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
439 release_region(dev->base_addr, MC32_IO_EXTENT);
440 printk(KERN_ERR "%s: unable to get IRQ %d.\n", dev->name, dev->irq);
444 memset(lp, 0, sizeof(struct mc32_local));
449 base = inb(dev->base_addr);
456 printk(KERN_ERR "%s: failed to boot adapter.\n", dev->name);
461 if(inb(dev->base_addr+2)&(1<<5))
462 base = inb(dev->base_addr);
468 printk(KERN_ERR "%s: %s%s.\n", dev->name, failures[base-1],
469 base<0x0A?" test failure":"");
471 printk(KERN_ERR "%s: unknown failure %d.\n", dev->name, base);
481 while(!(inb(dev->base_addr+2)&(1<<5)))
487 printk(KERN_ERR "%s: mailbox read fail (%d).\n", dev->name, i);
493 base|=(inb(dev->base_addr)<<(8*i));
496 lp->exec_box=isa_bus_to_virt(dev->mem_start+base);
498 base=lp->exec_box->data[1]<<16|lp->exec_box->data[0];
500 lp->base = dev->mem_start+base;
502 lp->rx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[2]);
503 lp->tx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[3]);
505 lp->stats = isa_bus_to_virt(lp->base + lp->exec_box->data[5]);
508 * Descriptor chains (card relative)
511 lp->tx_chain = lp->exec_box->data[8]; /* Transmit list start offset */
512 lp->rx_chain = lp->exec_box->data[10]; /* Receive list start offset */
513 lp->tx_len = lp->exec_box->data[9]; /* Transmit list count */
514 lp->rx_len = lp->exec_box->data[11]; /* Receive list count */
516 init_MUTEX_LOCKED(&lp->cmd_mutex);
517 init_completion(&lp->execution_cmd);
518 init_completion(&lp->xceiver_cmd);
520 printk("%s: Firmware Rev %d. %d RX buffers, %d TX buffers. Base of 0x%08X.\n",
521 dev->name, lp->exec_box->data[12], lp->rx_len, lp->tx_len, lp->base);
523 dev->open = mc32_open;
524 dev->stop = mc32_close;
525 dev->hard_start_xmit = mc32_send_packet;
526 dev->get_stats = mc32_get_stats;
527 dev->set_multicast_list = mc32_set_multicast_list;
528 dev->tx_timeout = mc32_timeout;
529 dev->watchdog_timeo = HZ*5; /* Board does all the work */
530 dev->ethtool_ops = &netdev_ethtool_ops;
535 free_irq(dev->irq, dev);
537 release_region(dev->base_addr, MC32_IO_EXTENT);
543 * mc32_ready_poll - wait until we can feed it a command
544 * @dev: The device to wait for
546 * Wait until the card becomes ready to accept a command via the
547 * command register. This tells us nothing about the completion
548 * status of any pending commands and takes very little time at all.
551 static inline void mc32_ready_poll(struct net_device *dev)
553 int ioaddr = dev->base_addr;
554 while(!(inb(ioaddr+HOST_STATUS)&HOST_STATUS_CRR));
559 * mc32_command_nowait - send a command non blocking
560 * @dev: The 3c527 to issue the command to
561 * @cmd: The command word to write to the mailbox
562 * @data: A data block if the command expects one
563 * @len: Length of the data block
565 * Send a command from interrupt state. If there is a command
566 * currently being executed then we return an error of -1. It
567 * simply isn't viable to wait around as commands may be
568 * slow. This can theoretically be starved on SMP, but it's hard
569 * to see a realistic situation. We do not wait for the command
570 * to complete --- we rely on the interrupt handler to tidy up
574 static int mc32_command_nowait(struct net_device *dev, u16 cmd, void *data, int len)
576 struct mc32_local *lp = netdev_priv(dev);
577 int ioaddr = dev->base_addr;
580 if (down_trylock(&lp->cmd_mutex) == 0)
582 lp->cmd_nonblocking=1;
583 lp->exec_box->mbox=0;
584 lp->exec_box->mbox=cmd;
585 memcpy((void *)lp->exec_box->data, data, len);
586 barrier(); /* the memcpy forgot the volatile so be sure */
588 /* Send the command */
589 mc32_ready_poll(dev);
590 outb(1<<6, ioaddr+HOST_CMD);
594 /* Interrupt handler will signal mutex on completion */
602 * mc32_command - send a command and sleep until completion
603 * @dev: The 3c527 card to issue the command to
604 * @cmd: The command word to write to the mailbox
605 * @data: A data block if the command expects one
606 * @len: Length of the data block
608 * Sends exec commands in a user context. This permits us to wait around
609 * for the replies and also to wait for the command buffer to complete
610 * from a previous command before we execute our command. After our
611 * command completes we will attempt any pending multicast reload
612 * we blocked off by hogging the exec buffer.
614 * You feed the card a command, you wait, it interrupts you get a
615 * reply. All well and good. The complication arises because you use
616 * commands for filter list changes which come in at bh level from things
617 * like IPV6 group stuff.
620 static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len)
622 struct mc32_local *lp = netdev_priv(dev);
623 int ioaddr = dev->base_addr;
626 down(&lp->cmd_mutex);
632 lp->cmd_nonblocking=0;
633 lp->exec_box->mbox=0;
634 lp->exec_box->mbox=cmd;
635 memcpy((void *)lp->exec_box->data, data, len);
636 barrier(); /* the memcpy forgot the volatile so be sure */
638 mc32_ready_poll(dev);
639 outb(1<<6, ioaddr+HOST_CMD);
641 wait_for_completion(&lp->execution_cmd);
643 if(lp->exec_box->mbox&(1<<13))
649 * A multicast set got blocked - try it now
652 if(lp->mc_reload_wait)
654 mc32_reset_multicast_list(dev);
662 * mc32_start_transceiver - tell board to restart tx/rx
663 * @dev: The 3c527 card to issue the command to
665 * This may be called from the interrupt state, where it is used
666 * to restart the rx ring if the card runs out of rx buffers.
668 * We must first check if it's ok to (re)start the transceiver. See
669 * mc32_close for details.
672 static void mc32_start_transceiver(struct net_device *dev) {
674 struct mc32_local *lp = netdev_priv(dev);
675 int ioaddr = dev->base_addr;
677 /* Ignore RX overflow on device closure */
678 if (lp->xceiver_desired_state==HALTED)
681 /* Give the card the offset to the post-EOL-bit RX descriptor */
682 mc32_ready_poll(dev);
684 lp->rx_box->data[0]=lp->rx_ring[prev_rx(lp->rx_ring_tail)].p->next;
685 outb(HOST_CMD_START_RX, ioaddr+HOST_CMD);
687 mc32_ready_poll(dev);
689 outb(HOST_CMD_RESTRT_TX, ioaddr+HOST_CMD); /* card ignores this on RX restart */
691 /* We are not interrupted on start completion */
696 * mc32_halt_transceiver - tell board to stop tx/rx
697 * @dev: The 3c527 card to issue the command to
699 * We issue the commands to halt the card's transceiver. In fact,
700 * after some experimenting we now simply tell the card to
701 * suspend. When issuing aborts occasionally odd things happened.
703 * We then sleep until the card has notified us that both rx and
704 * tx have been suspended.
707 static void mc32_halt_transceiver(struct net_device *dev)
709 struct mc32_local *lp = netdev_priv(dev);
710 int ioaddr = dev->base_addr;
712 mc32_ready_poll(dev);
714 outb(HOST_CMD_SUSPND_RX, ioaddr+HOST_CMD);
715 wait_for_completion(&lp->xceiver_cmd);
717 mc32_ready_poll(dev);
719 outb(HOST_CMD_SUSPND_TX, ioaddr+HOST_CMD);
720 wait_for_completion(&lp->xceiver_cmd);
725 * mc32_load_rx_ring - load the ring of receive buffers
726 * @dev: 3c527 to build the ring for
728 * This initalises the on-card and driver datastructures to
729 * the point where mc32_start_transceiver() can be called.
731 * The card sets up the receive ring for us. We are required to use the
732 * ring it provides, although the size of the ring is configurable.
734 * We allocate an sk_buff for each ring entry in turn and
735 * initalise its house-keeping info. At the same time, we read
736 * each 'next' pointer in our rx_ring array. This reduces slow
737 * shared-memory reads and makes it easy to access predecessor
740 * We then set the end-of-list bit for the last entry so that the
741 * card will know when it has run out of buffers.
744 static int mc32_load_rx_ring(struct net_device *dev)
746 struct mc32_local *lp = netdev_priv(dev);
749 volatile struct skb_header *p;
751 rx_base=lp->rx_chain;
753 for(i=0; i<RX_RING_LEN; i++)
755 lp->rx_ring[i].skb=alloc_skb(1532, GFP_KERNEL);
756 skb_reserve(lp->rx_ring[i].skb, 18);
758 if(lp->rx_ring[i].skb==NULL)
761 kfree_skb(lp->rx_ring[i].skb);
765 p=isa_bus_to_virt(lp->base+rx_base);
768 p->data=isa_virt_to_bus(lp->rx_ring[i].skb->data);
776 lp->rx_ring[i-1].p->control |= CONTROL_EOL;
785 * mc32_flush_rx_ring - free the ring of receive buffers
786 * @lp: Local data of 3c527 to flush the rx ring of
788 * Free the buffer for each ring slot. This may be called
789 * before mc32_load_rx_ring(), eg. on error in mc32_open().
790 * Requires rx skb pointers to point to a valid skb, or NULL.
793 static void mc32_flush_rx_ring(struct net_device *dev)
795 struct mc32_local *lp = netdev_priv(dev);
798 for(i=0; i < RX_RING_LEN; i++)
800 if (lp->rx_ring[i].skb) {
801 dev_kfree_skb(lp->rx_ring[i].skb);
802 lp->rx_ring[i].skb = NULL;
804 lp->rx_ring[i].p=NULL;
810 * mc32_load_tx_ring - load transmit ring
811 * @dev: The 3c527 card to issue the command to
813 * This sets up the host transmit data-structures.
815 * First, we obtain from the card it's current postion in the tx
816 * ring, so that we will know where to begin transmitting
819 * Then, we read the 'next' pointers from the on-card tx ring into
820 * our tx_ring array to reduce slow shared-mem reads. Finally, we
821 * intitalise the tx house keeping variables.
825 static void mc32_load_tx_ring(struct net_device *dev)
827 struct mc32_local *lp = netdev_priv(dev);
828 volatile struct skb_header *p;
832 tx_base=lp->tx_box->data[0];
834 for(i=0 ; i<TX_RING_LEN ; i++)
836 p=isa_bus_to_virt(lp->base+tx_base);
838 lp->tx_ring[i].skb=NULL;
843 /* -1 so that tx_ring_head cannot "lap" tx_ring_tail */
844 /* see mc32_tx_ring */
846 atomic_set(&lp->tx_count, TX_RING_LEN-1);
847 atomic_set(&lp->tx_ring_head, 0);
853 * mc32_flush_tx_ring - free transmit ring
854 * @lp: Local data of 3c527 to flush the tx ring of
856 * If the ring is non-empty, zip over the it, freeing any
857 * allocated skb_buffs. The tx ring house-keeping variables are
858 * then reset. Requires rx skb pointers to point to a valid skb,
862 static void mc32_flush_tx_ring(struct net_device *dev)
864 struct mc32_local *lp = netdev_priv(dev);
867 for (i=0; i < TX_RING_LEN; i++)
869 if (lp->tx_ring[i].skb)
871 dev_kfree_skb(lp->tx_ring[i].skb);
872 lp->tx_ring[i].skb = NULL;
876 atomic_set(&lp->tx_count, 0);
877 atomic_set(&lp->tx_ring_head, 0);
883 * mc32_open - handle 'up' of card
884 * @dev: device to open
886 * The user is trying to bring the card into ready state. This requires
887 * a brief dialogue with the card. Firstly we enable interrupts and then
888 * 'indications'. Without these enabled the card doesn't bother telling
889 * us what it has done. This had me puzzled for a week.
891 * We configure the number of card descriptors, then load the network
892 * address and multicast filters. Turn on the workaround mode. This
893 * works around a bug in the 82586 - it asks the firmware to do
894 * so. It has a performance (latency) hit but is needed on busy
895 * [read most] lans. We load the ring with buffers then we kick it
899 static int mc32_open(struct net_device *dev)
901 int ioaddr = dev->base_addr;
902 struct mc32_local *lp = netdev_priv(dev);
905 u16 descnumbuffs[2] = {TX_RING_LEN, RX_RING_LEN};
911 regs=inb(ioaddr+HOST_CTRL);
912 regs|=HOST_CTRL_INTE;
913 outb(regs, ioaddr+HOST_CTRL);
916 * Allow ourselves to issue commands
923 * Send the indications on command
926 mc32_command(dev, 4, &one, 2);
929 * Poke it to make sure it's really dead.
932 mc32_halt_transceiver(dev);
933 mc32_flush_tx_ring(dev);
936 * Ask card to set up on-card descriptors to our spec
939 if(mc32_command(dev, 8, descnumbuffs, 4)) {
940 printk("%s: %s rejected our buffer configuration!\n",
941 dev->name, cardname);
946 /* Report new configuration */
947 mc32_command(dev, 6, NULL, 0);
949 lp->tx_chain = lp->exec_box->data[8]; /* Transmit list start offset */
950 lp->rx_chain = lp->exec_box->data[10]; /* Receive list start offset */
951 lp->tx_len = lp->exec_box->data[9]; /* Transmit list count */
952 lp->rx_len = lp->exec_box->data[11]; /* Receive list count */
954 /* Set Network Address */
955 mc32_command(dev, 1, dev->dev_addr, 6);
957 /* Set the filters */
958 mc32_set_multicast_list(dev);
960 if (WORKAROUND_82586) {
962 mc32_command(dev, 0x0D, &zero_word, 2); /* 82586 bug workaround on */
965 mc32_load_tx_ring(dev);
967 if(mc32_load_rx_ring(dev))
973 lp->xceiver_desired_state = RUNNING;
975 /* And finally, set the ball rolling... */
976 mc32_start_transceiver(dev);
978 netif_start_queue(dev);
985 * mc32_timeout - handle a timeout from the network layer
986 * @dev: 3c527 that timed out
988 * Handle a timeout on transmit from the 3c527. This normally means
989 * bad things as the hardware handles cable timeouts and mess for
994 static void mc32_timeout(struct net_device *dev)
996 printk(KERN_WARNING "%s: transmit timed out?\n", dev->name);
997 /* Try to restart the adaptor. */
998 netif_wake_queue(dev);
1003 * mc32_send_packet - queue a frame for transmit
1004 * @skb: buffer to transmit
1005 * @dev: 3c527 to send it out of
1007 * Transmit a buffer. This normally means throwing the buffer onto
1008 * the transmit queue as the queue is quite large. If the queue is
1009 * full then we set tx_busy and return. Once the interrupt handler
1010 * gets messages telling it to reclaim transmit queue entries, we will
1011 * clear tx_busy and the kernel will start calling this again.
1013 * We do not disable interrupts or acquire any locks; this can
1014 * run concurrently with mc32_tx_ring(), and the function itself
1015 * is serialised at a higher layer. However, similarly for the
1016 * card itself, we must ensure that we update tx_ring_head only
1017 * after we've established a valid packet on the tx ring (and
1018 * before we let the card "see" it, to prevent it racing with the
1023 static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev)
1025 struct mc32_local *lp = netdev_priv(dev);
1026 u32 head = atomic_read(&lp->tx_ring_head);
1028 volatile struct skb_header *p, *np;
1030 netif_stop_queue(dev);
1032 if(atomic_read(&lp->tx_count)==0) {
1036 skb = skb_padto(skb, ETH_ZLEN);
1038 netif_wake_queue(dev);
1042 atomic_dec(&lp->tx_count);
1044 /* P is the last sending/sent buffer as a pointer */
1045 p=lp->tx_ring[head].p;
1047 head = next_tx(head);
1049 /* NP is the buffer we will be loading */
1050 np=lp->tx_ring[head].p;
1052 /* We will need this to flush the buffer out */
1053 lp->tx_ring[head].skb=skb;
1055 np->length = unlikely(skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
1056 np->data = isa_virt_to_bus(skb->data);
1058 np->control = CONTROL_EOP | CONTROL_EOL;
1062 * The new frame has been setup; we can now
1063 * let the interrupt handler and card "see" it
1066 atomic_set(&lp->tx_ring_head, head);
1067 p->control &= ~CONTROL_EOL;
1069 netif_wake_queue(dev);
1075 * mc32_update_stats - pull off the on board statistics
1076 * @dev: 3c527 to service
1079 * Query and reset the on-card stats. There's the small possibility
1080 * of a race here, which would result in an underestimation of
1081 * actual errors. As such, we'd prefer to keep all our stats
1082 * collection in software. As a rule, we do. However it can't be
1083 * used for rx errors and collisions as, by default, the card discards
1086 * Setting the SAV BP in the rx filter command supposedly
1087 * stops this behaviour. However, testing shows that it only seems to
1088 * enable the collation of on-card rx statistics --- the driver
1089 * never sees an RX descriptor with an error status set.
1093 static void mc32_update_stats(struct net_device *dev)
1095 struct mc32_local *lp = netdev_priv(dev);
1096 volatile struct mc32_stats *st = lp->stats;
1100 rx_errors+=lp->net_stats.rx_crc_errors +=st->rx_crc_errors;
1101 st->rx_crc_errors=0;
1102 rx_errors+=lp->net_stats.rx_fifo_errors +=st->rx_overrun_errors;
1103 st->rx_overrun_errors=0;
1104 rx_errors+=lp->net_stats.rx_frame_errors +=st->rx_alignment_errors;
1105 st->rx_alignment_errors=0;
1106 rx_errors+=lp->net_stats.rx_length_errors+=st->rx_tooshort_errors;
1107 st->rx_tooshort_errors=0;
1108 rx_errors+=lp->net_stats.rx_missed_errors+=st->rx_outofresource_errors;
1109 st->rx_outofresource_errors=0;
1110 lp->net_stats.rx_errors=rx_errors;
1112 /* Number of packets which saw one collision */
1113 lp->net_stats.collisions+=st->dataC[10];
1116 /* Number of packets which saw 2--15 collisions */
1117 lp->net_stats.collisions+=st->dataC[11];
1123 * mc32_rx_ring - process the receive ring
1124 * @dev: 3c527 that needs its receive ring processing
1127 * We have received one or more indications from the card that a
1128 * receive has completed. The buffer ring thus contains dirty
1129 * entries. We walk the ring by iterating over the circular rx_ring
1130 * array, starting at the next dirty buffer (which happens to be the
1131 * one we finished up at last time around).
1133 * For each completed packet, we will either copy it and pass it up
1134 * the stack or, if the packet is near MTU sized, we allocate
1135 * another buffer and flip the old one up the stack.
1137 * We must succeed in keeping a buffer on the ring. If necessary we
1138 * will toss a received packet rather than lose a ring entry. Once
1139 * the first uncompleted descriptor is found, we move the
1140 * End-Of-List bit to include the buffers just processed.
1144 static void mc32_rx_ring(struct net_device *dev)
1146 struct mc32_local *lp = netdev_priv(dev);
1147 volatile struct skb_header *p;
1152 rx_old_tail = rx_ring_tail = lp->rx_ring_tail;
1156 p=lp->rx_ring[rx_ring_tail].p;
1158 if(!(p->status & (1<<7))) { /* Not COMPLETED */
1161 if(p->status & (1<<6)) /* COMPLETED_OK */
1164 u16 length=p->length;
1165 struct sk_buff *skb;
1166 struct sk_buff *newskb;
1168 /* Try to save time by avoiding a copy on big frames */
1170 if ((length > RX_COPYBREAK)
1171 && ((newskb=dev_alloc_skb(1532)) != NULL))
1173 skb=lp->rx_ring[rx_ring_tail].skb;
1174 skb_put(skb, length);
1176 skb_reserve(newskb,18);
1177 lp->rx_ring[rx_ring_tail].skb=newskb;
1178 p->data=isa_virt_to_bus(newskb->data);
1182 skb=dev_alloc_skb(length+2);
1185 lp->net_stats.rx_dropped++;
1190 memcpy(skb_put(skb, length),
1191 lp->rx_ring[rx_ring_tail].skb->data, length);
1194 skb->protocol=eth_type_trans(skb,dev);
1196 dev->last_rx = jiffies;
1197 lp->net_stats.rx_packets++;
1198 lp->net_stats.rx_bytes += length;
1206 rx_ring_tail=next_rx(rx_ring_tail);
1210 /* If there was actually a frame to be processed, place the EOL bit */
1211 /* at the descriptor prior to the one to be filled next */
1213 if (rx_ring_tail != rx_old_tail)
1215 lp->rx_ring[prev_rx(rx_ring_tail)].p->control |= CONTROL_EOL;
1216 lp->rx_ring[prev_rx(rx_old_tail)].p->control &= ~CONTROL_EOL;
1218 lp->rx_ring_tail=rx_ring_tail;
1224 * mc32_tx_ring - process completed transmits
1225 * @dev: 3c527 that needs its transmit ring processing
1228 * This operates in a similar fashion to mc32_rx_ring. We iterate
1229 * over the transmit ring. For each descriptor which has been
1230 * processed by the card, we free its associated buffer and note
1231 * any errors. This continues until the transmit ring is emptied
1232 * or we reach a descriptor that hasn't yet been processed by the
1237 static void mc32_tx_ring(struct net_device *dev)
1239 struct mc32_local *lp = netdev_priv(dev);
1240 volatile struct skb_header *np;
1243 * We rely on head==tail to mean 'queue empty'.
1244 * This is why lp->tx_count=TX_RING_LEN-1: in order to prevent
1245 * tx_ring_head wrapping to tail and confusing a 'queue empty'
1246 * condition with 'queue full'
1249 while (lp->tx_ring_tail != atomic_read(&lp->tx_ring_head))
1253 t=next_tx(lp->tx_ring_tail);
1254 np=lp->tx_ring[t].p;
1256 if(!(np->status & (1<<7)))
1261 lp->net_stats.tx_packets++;
1262 if(!(np->status & (1<<6))) /* Not COMPLETED_OK */
1264 lp->net_stats.tx_errors++;
1266 switch(np->status&0x0F)
1269 lp->net_stats.tx_aborted_errors++;
1270 break; /* Max collisions */
1272 lp->net_stats.tx_fifo_errors++;
1275 lp->net_stats.tx_carrier_errors++;
1278 lp->net_stats.tx_window_errors++;
1279 break; /* CTS Lost */
1281 lp->net_stats.tx_aborted_errors++;
1282 break; /* Transmit timeout */
1285 /* Packets are sent in order - this is
1286 basically a FIFO queue of buffers matching
1288 lp->net_stats.tx_bytes+=lp->tx_ring[t].skb->len;
1289 dev_kfree_skb_irq(lp->tx_ring[t].skb);
1290 lp->tx_ring[t].skb=NULL;
1291 atomic_inc(&lp->tx_count);
1292 netif_wake_queue(dev);
1301 * mc32_interrupt - handle an interrupt from a 3c527
1302 * @irq: Interrupt number
1303 * @dev_id: 3c527 that requires servicing
1304 * @regs: Registers (unused)
1307 * An interrupt is raised whenever the 3c527 writes to the command
1308 * register. This register contains the message it wishes to send us
1309 * packed into a single byte field. We keep reading status entries
1310 * until we have processed all the control items, but simply count
1311 * transmit and receive reports. When all reports are in we empty the
1312 * transceiver rings as appropriate. This saves the overhead of
1313 * multiple command requests.
1315 * Because MCA is level-triggered, we shouldn't miss indications.
1316 * Therefore, we needn't ask the card to suspend interrupts within
1317 * this handler. The card receives an implicit acknowledgment of the
1318 * current interrupt when we read the command register.
1322 static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1324 struct net_device *dev = dev_id;
1325 struct mc32_local *lp;
1326 int ioaddr, status, boguscount = 0;
1331 printk(KERN_WARNING "%s: irq %d for unknown device.\n", cardname, irq);
1335 ioaddr = dev->base_addr;
1336 lp = netdev_priv(dev);
1338 /* See whats cooking */
1340 while((inb(ioaddr+HOST_STATUS)&HOST_STATUS_CWR) && boguscount++<2000)
1342 status=inb(ioaddr+HOST_CMD);
1345 printk("Status TX%d RX%d EX%d OV%d BC%d\n",
1346 (status&7), (status>>3)&7, (status>>6)&1,
1347 (status>>7)&1, boguscount);
1354 case 6: /* TX fail */
1360 complete(&lp->xceiver_cmd);
1363 printk("%s: strange tx ack %d\n", dev->name, status&7);
1375 complete(&lp->xceiver_cmd);
1378 /* Out of RX buffers stat */
1379 /* Must restart rx */
1380 lp->net_stats.rx_dropped++;
1382 mc32_start_transceiver(dev);
1385 printk("%s: strange rx ack %d\n",
1386 dev->name, status&7);
1392 * No thread is waiting: we need to tidy
1396 if (lp->cmd_nonblocking) {
1398 if (lp->mc_reload_wait)
1399 mc32_reset_multicast_list(dev);
1401 else complete(&lp->execution_cmd);
1406 * We get interrupted once per
1407 * counter that is about to overflow.
1410 mc32_update_stats(dev);
1416 * Process the transmit and receive rings
1430 * mc32_close - user configuring the 3c527 down
1431 * @dev: 3c527 card to shut down
1433 * The 3c527 is a bus mastering device. We must be careful how we
1434 * shut it down. It may also be running shared interrupt so we have
1435 * to be sure to silence it properly
1437 * We indicate that the card is closing to the rest of the
1438 * driver. Otherwise, it is possible that the card may run out
1439 * of receive buffers and restart the transceiver while we're
1440 * trying to close it.
1442 * We abort any receive and transmits going on and then wait until
1443 * any pending exec commands have completed in other code threads.
1444 * In theory we can't get here while that is true, in practice I am
1447 * We turn off the interrupt enable for the board to be sure it can't
1448 * intefere with other devices.
1451 static int mc32_close(struct net_device *dev)
1453 struct mc32_local *lp = netdev_priv(dev);
1454 int ioaddr = dev->base_addr;
1459 lp->xceiver_desired_state = HALTED;
1460 netif_stop_queue(dev);
1463 * Send the indications on command (handy debug check)
1466 mc32_command(dev, 4, &one, 2);
1468 /* Shut down the transceiver */
1470 mc32_halt_transceiver(dev);
1472 /* Ensure we issue no more commands beyond this point */
1474 down(&lp->cmd_mutex);
1476 /* Ok the card is now stopping */
1478 regs=inb(ioaddr+HOST_CTRL);
1479 regs&=~HOST_CTRL_INTE;
1480 outb(regs, ioaddr+HOST_CTRL);
1482 mc32_flush_rx_ring(dev);
1483 mc32_flush_tx_ring(dev);
1485 mc32_update_stats(dev);
1492 * mc32_get_stats - hand back stats to network layer
1493 * @dev: The 3c527 card to handle
1495 * We've collected all the stats we can in software already. Now
1496 * it's time to update those kept on-card and return the lot.
1500 static struct net_device_stats *mc32_get_stats(struct net_device *dev)
1502 struct mc32_local *lp = netdev_priv(dev);
1504 mc32_update_stats(dev);
1505 return &lp->net_stats;
1510 * do_mc32_set_multicast_list - attempt to update multicasts
1511 * @dev: 3c527 device to load the list on
1512 * @retry: indicates this is not the first call.
1515 * Actually set or clear the multicast filter for this adaptor. The
1516 * locking issues are handled by this routine. We have to track
1517 * state as it may take multiple calls to get the command sequence
1518 * completed. We just keep trying to schedule the loads until we
1519 * manage to process them all.
1521 * num_addrs == -1 Promiscuous mode, receive all packets
1523 * num_addrs == 0 Normal mode, clear multicast list
1525 * num_addrs > 0 Multicast mode, receive normal and MC packets,
1526 * and do best-effort filtering.
1528 * See mc32_update_stats() regards setting the SAV BP bit.
1532 static void do_mc32_set_multicast_list(struct net_device *dev, int retry)
1534 struct mc32_local *lp = netdev_priv(dev);
1535 u16 filt = (1<<2); /* Save Bad Packets, for stats purposes */
1537 if (dev->flags&IFF_PROMISC)
1538 /* Enable promiscuous mode */
1540 else if((dev->flags&IFF_ALLMULTI) || dev->mc_count > 10)
1542 dev->flags|=IFF_PROMISC;
1545 else if(dev->mc_count)
1547 unsigned char block[62];
1549 struct dev_mc_list *dmc=dev->mc_list;
1554 lp->mc_list_valid = 0;
1555 if(!lp->mc_list_valid)
1558 block[0]=dev->mc_count;
1561 for(i=0;i<dev->mc_count;i++)
1563 memcpy(bp, dmc->dmi_addr, 6);
1567 if(mc32_command_nowait(dev, 2, block, 2+6*dev->mc_count)==-1)
1569 lp->mc_reload_wait = 1;
1572 lp->mc_list_valid=1;
1576 if(mc32_command_nowait(dev, 0, &filt, 2)==-1)
1578 lp->mc_reload_wait = 1;
1581 lp->mc_reload_wait = 0;
1587 * mc32_set_multicast_list - queue multicast list update
1588 * @dev: The 3c527 to use
1590 * Commence loading the multicast list. This is called when the kernel
1591 * changes the lists. It will override any pending list we are trying to
1595 static void mc32_set_multicast_list(struct net_device *dev)
1597 do_mc32_set_multicast_list(dev,0);
1602 * mc32_reset_multicast_list - reset multicast list
1603 * @dev: The 3c527 to use
1605 * Attempt the next step in loading the multicast lists. If this attempt
1606 * fails to complete then it will be scheduled and this function called
1607 * again later from elsewhere.
1610 static void mc32_reset_multicast_list(struct net_device *dev)
1612 do_mc32_set_multicast_list(dev,1);
1615 static void netdev_get_drvinfo(struct net_device *dev,
1616 struct ethtool_drvinfo *info)
1618 strcpy(info->driver, DRV_NAME);
1619 strcpy(info->version, DRV_VERSION);
1620 sprintf(info->bus_info, "MCA 0x%lx", dev->base_addr);
1623 static u32 netdev_get_msglevel(struct net_device *dev)
1628 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1633 static struct ethtool_ops netdev_ethtool_ops = {
1634 .get_drvinfo = netdev_get_drvinfo,
1635 .get_msglevel = netdev_get_msglevel,
1636 .set_msglevel = netdev_set_msglevel,
1641 static struct net_device *this_device;
1644 * init_module - entry point
1646 * Probe and locate a 3c527 card. This really should probe and locate
1647 * all the 3c527 cards in the machine not just one of them. Yes you can
1648 * insmod multiple modules for now but it's a hack.
1651 int init_module(void)
1653 this_device = mc32_probe(-1);
1654 if (IS_ERR(this_device))
1655 return PTR_ERR(this_device);
1660 * cleanup_module - free resources for an unload
1662 * Unloading time. We release the MCA bus resources and the interrupt
1663 * at which point everything is ready to unload. The card must be stopped
1664 * at this point or we would not have been called. When we unload we
1665 * leave the card stopped but not totally shut down. When the card is
1666 * initialized it must be rebooted or the rings reloaded before any
1667 * transmit operations are allowed to start scribbling into memory.
1670 void cleanup_module(void)
1672 unregister_netdev(this_device);
1673 cleanup_card(this_device);
1674 free_netdev(this_device);