[PATCH] pcmcia: more IDs for TDK multifunction cards
[linux-2.6] / drivers / net / 3c527.c
1 /* 3c527.c: 3Com Etherlink/MC32 driver for Linux 2.4 and 2.6.
2  *
3  *      (c) Copyright 1998 Red Hat Software Inc
4  *      Written by Alan Cox. 
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>
8  *
9  *      Based on skeleton.c written 1993-94 by Donald Becker and ne2.c
10  *      (for the MCA stuff) written by Wim Dumon.
11  *
12  *      Thanks to 3Com for making this possible by providing me with the
13  *      documentation.
14  *
15  *      This software may be used and distributed according to the terms
16  *      of the GNU General Public License, incorporated herein by reference.
17  *
18  */
19
20 #define DRV_NAME                "3c527"
21 #define DRV_VERSION             "0.7-SMP"
22 #define DRV_RELDATE             "2003/09/21"
23
24 static const char *version =
25 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Richard Procter <rnp@paradise.net.nz>\n";
26
27 /**
28  * DOC: Traps for the unwary
29  *
30  *      The diagram (Figure 1-1) and the POS summary disagree with the
31  *      "Interrupt Level" section in the manual.
32  *
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. 
36  *
37  *      Setting the SAV BP bit does not save bad packets, but
38  *      only enables RX on-card stats collection. 
39  *
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.
43  *
44  * DOC: Theory Of Operation
45  *
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.
52  *
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.
62  *
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.
67  *       
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().  
74  *
75  * DOC: Notes
76  *      
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.
79  *
80  *      The on-board 82586 NIC has trouble receiving multiple
81  *      back-to-back frames and so is likely to drop packets from fast
82  *      senders.
83 **/
84
85 #include <linux/module.h>
86
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>
98 #include <linux/in.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>
105 #include <linux/bitops.h>
106
107 #include <asm/semaphore.h>
108 #include <asm/uaccess.h>
109 #include <asm/system.h>
110 #include <asm/io.h>
111 #include <asm/dma.h>
112
113 #include "3c527.h"
114
115 MODULE_LICENSE("GPL");
116
117 /*
118  * The name of the card. Is used for messages and in the requests for
119  * io regions, irqs and dma channels
120  */
121 static const char* cardname = DRV_NAME;
122
123 /* use 0 for production, 1 for verification, >2 for debug */
124 #ifndef NET_DEBUG
125 #define NET_DEBUG 2
126 #endif
127
128 #undef DEBUG_IRQ
129
130 static unsigned int mc32_debug = NET_DEBUG;
131
132 /* The number of low I/O ports used by the ethercard. */
133 #define MC32_IO_EXTENT  8
134
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        /*     "       "        "          */
138
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 */
142
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;
147
148 /* Pointers to buffers and their on-card records */
149 struct mc32_ring_desc 
150 {
151         volatile struct skb_header *p;                    
152         struct sk_buff *skb;          
153 };
154
155 /* Information that needs to be kept for each board. */
156 struct mc32_local 
157 {
158         int slot;
159
160         u32 base;
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 */
170
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 */
175
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 */
178
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 */
182
183         u16 rx_ring_tail;       /* index to rx de-queue end */ 
184
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 */
188 };
189
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
194
195 struct mca_adapters_t {
196         unsigned int    id;
197         char            *name;
198 };
199
200 static const struct mca_adapters_t mc32_adapters[] = {
201         { 0x0041, "3COM EtherLink MC/32" },
202         { 0x8EF5, "IBM High Performance Lan Adapter" },
203         { 0x0000, NULL }
204 };
205
206
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); };
210
211 static inline u16 next_tx(u16 tx) { return (tx+1)&(TX_RING_LEN-1); };
212
213
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;
226
227 static void cleanup_card(struct net_device *dev)
228 {
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);
235 }
236
237 /**
238  * mc32_probe   -       Search for supported boards
239  * @unit: interface number to use
240  *
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
244  * in particular.
245  */
246
247 struct net_device *__init mc32_probe(int unit)
248 {
249         struct net_device *dev = alloc_etherdev(sizeof(struct mc32_local));
250         static int current_mca_slot = -1;
251         int i;
252         int err;
253
254         if (!dev)
255                 return ERR_PTR(-ENOMEM);
256
257         if (unit >= 0)
258                 sprintf(dev->name, "eth%d", unit);
259
260         SET_MODULE_OWNER(dev);
261
262         /* Do not check any supplied i/o locations. 
263            POS registers usually don't fail :) */
264
265         /* MCA cards have POS registers.  
266            Autodetecting MCA cards is extremely simple. 
267            Just search for the card. */
268
269         for(i = 0; (mc32_adapters[i].name != NULL); i++) {
270                 current_mca_slot = 
271                         mca_find_unused_adapter(mc32_adapters[i].id, 0);
272
273                 if(current_mca_slot != MCA_NOTFOUND) {
274                         if(!mc32_probe1(dev, current_mca_slot))
275                         {
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);
280                                 if (err) {
281                                         cleanup_card(dev);
282                                         free_netdev(dev);
283                                         dev = ERR_PTR(err);
284                                 }
285                                 return dev;
286                         }
287                         
288                 }
289         }
290         free_netdev(dev);
291         return ERR_PTR(-ENODEV);
292 }
293
294 /**
295  * mc32_probe1  -       Check a given slot for a board and test the card
296  * @dev:  Device structure to fill in
297  * @slot: The MCA bus slot being used by this card
298  *
299  * Decode the slot data and configure the card structures. Having done this we
300  * can reset the card and configure it. The card does a full self test cycle
301  * in firmware so we have to wait for it to return and post us either a 
302  * failure case or some addresses we use to find the board internals.
303  */
304
305 static int __init mc32_probe1(struct net_device *dev, int slot)
306 {
307         static unsigned version_printed;
308         int i, err;
309         u8 POS;
310         u32 base;
311         struct mc32_local *lp = netdev_priv(dev);
312         static u16 mca_io_bases[]={
313                 0x7280,0x7290,
314                 0x7680,0x7690,
315                 0x7A80,0x7A90,
316                 0x7E80,0x7E90
317         };
318         static u32 mca_mem_bases[]={
319                 0x00C0000,
320                 0x00C4000,
321                 0x00C8000,
322                 0x00CC000,
323                 0x00D0000,
324                 0x00D4000,
325                 0x00D8000,
326                 0x00DC000
327         };
328         static char *failures[]={
329                 "Processor instruction",
330                 "Processor data bus",
331                 "Processor data bus",
332                 "Processor data bus",
333                 "Adapter bus",
334                 "ROM checksum",
335                 "Base RAM",
336                 "Extended RAM",
337                 "82586 internal loopback",
338                 "82586 initialisation failure",
339                 "Adapter list configuration error"
340         };
341
342         /* Time to play MCA games */
343
344         if (mc32_debug  &&  version_printed++ == 0)
345                 printk(KERN_DEBUG "%s", version);
346
347         printk(KERN_INFO "%s: %s found in slot %d:", dev->name, cardname, slot);
348
349         POS = mca_read_stored_pos(slot, 2);
350         
351         if(!(POS&1))
352         {
353                 printk(" disabled.\n");
354                 return -ENODEV;
355         }
356
357         /* Fill in the 'dev' fields. */
358         dev->base_addr = mca_io_bases[(POS>>1)&7];
359         dev->mem_start = mca_mem_bases[(POS>>4)&7];
360         
361         POS = mca_read_stored_pos(slot, 4);
362         if(!(POS&1))
363         {
364                 printk("memory window disabled.\n");
365                 return -ENODEV;
366         }
367
368         POS = mca_read_stored_pos(slot, 5);
369         
370         i=(POS>>4)&3;
371         if(i==3)
372         {
373                 printk("invalid memory window.\n");
374                 return -ENODEV;
375         }
376         
377         i*=16384;
378         i+=16384;
379         
380         dev->mem_end=dev->mem_start + i;
381         
382         dev->irq = ((POS>>2)&3)+9;
383         
384         if(!request_region(dev->base_addr, MC32_IO_EXTENT, cardname))
385         {
386                 printk("io 0x%3lX, which is busy.\n", dev->base_addr);
387                 return -EBUSY;
388         }
389
390         printk("io 0x%3lX irq %d mem 0x%lX (%dK)\n",
391                 dev->base_addr, dev->irq, dev->mem_start, i/1024);
392         
393         
394         /* We ought to set the cache line size here.. */
395         
396         
397         /*
398          *      Go PROM browsing
399          */
400          
401         printk("%s: Address ", dev->name);
402          
403         /* Retrieve and print the ethernet address. */
404         for (i = 0; i < 6; i++)
405         {
406                 mca_write_pos(slot, 6, i+12);
407                 mca_write_pos(slot, 7, 0);
408         
409                 printk(" %2.2x", dev->dev_addr[i] = mca_read_pos(slot,3));
410         }
411
412         mca_write_pos(slot, 6, 0);
413         mca_write_pos(slot, 7, 0);
414
415         POS = mca_read_stored_pos(slot, 4);
416         
417         if(POS&2)
418                 printk(" : BNC port selected.\n");
419         else 
420                 printk(" : AUI port selected.\n");
421                 
422         POS=inb(dev->base_addr+HOST_CTRL);
423         POS|=HOST_CTRL_ATTN|HOST_CTRL_RESET;
424         POS&=~HOST_CTRL_INTE;
425         outb(POS, dev->base_addr+HOST_CTRL);
426         /* Reset adapter */
427         udelay(100);
428         /* Reset off */
429         POS&=~(HOST_CTRL_ATTN|HOST_CTRL_RESET);
430         outb(POS, dev->base_addr+HOST_CTRL);
431         
432         udelay(300);
433         
434         /*
435          *      Grab the IRQ
436          */
437
438         err = request_irq(dev->irq, &mc32_interrupt, SA_SHIRQ | SA_SAMPLE_RANDOM, DRV_NAME, dev);
439         if (err) {
440                 release_region(dev->base_addr, MC32_IO_EXTENT);
441                 printk(KERN_ERR "%s: unable to get IRQ %d.\n", DRV_NAME, dev->irq);
442                 goto err_exit_ports;
443         }
444
445         memset(lp, 0, sizeof(struct mc32_local));
446         lp->slot = slot;
447
448         i=0;
449
450         base = inb(dev->base_addr);
451         
452         while(base == 0xFF)
453         {
454                 i++;
455                 if(i == 1000)
456                 {
457                         printk(KERN_ERR "%s: failed to boot adapter.\n", dev->name);
458                         err = -ENODEV; 
459                         goto err_exit_irq;
460                 }
461                 udelay(1000);
462                 if(inb(dev->base_addr+2)&(1<<5))
463                         base = inb(dev->base_addr);
464         }
465
466         if(base>0)
467         {
468                 if(base < 0x0C)
469                         printk(KERN_ERR "%s: %s%s.\n", dev->name, failures[base-1],
470                                 base<0x0A?" test failure":"");
471                 else
472                         printk(KERN_ERR "%s: unknown failure %d.\n", dev->name, base);
473                 err = -ENODEV; 
474                 goto err_exit_irq;
475         }
476         
477         base=0;
478         for(i=0;i<4;i++)
479         {
480                 int n=0;
481         
482                 while(!(inb(dev->base_addr+2)&(1<<5)))
483                 {
484                         n++;
485                         udelay(50);
486                         if(n>100)
487                         {
488                                 printk(KERN_ERR "%s: mailbox read fail (%d).\n", dev->name, i);
489                                 err = -ENODEV;
490                                 goto err_exit_irq;
491                         }
492                 }
493
494                 base|=(inb(dev->base_addr)<<(8*i));
495         }
496         
497         lp->exec_box=isa_bus_to_virt(dev->mem_start+base);
498         
499         base=lp->exec_box->data[1]<<16|lp->exec_box->data[0];  
500         
501         lp->base = dev->mem_start+base;
502         
503         lp->rx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[2]); 
504         lp->tx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[3]);
505         
506         lp->stats = isa_bus_to_virt(lp->base + lp->exec_box->data[5]);
507
508         /*
509          *      Descriptor chains (card relative)
510          */
511          
512         lp->tx_chain            = lp->exec_box->data[8];   /* Transmit list start offset */
513         lp->rx_chain            = lp->exec_box->data[10];  /* Receive list start offset */
514         lp->tx_len              = lp->exec_box->data[9];   /* Transmit list count */ 
515         lp->rx_len              = lp->exec_box->data[11];  /* Receive list count */
516
517         init_MUTEX_LOCKED(&lp->cmd_mutex);
518         init_completion(&lp->execution_cmd);
519         init_completion(&lp->xceiver_cmd);
520         
521         printk("%s: Firmware Rev %d. %d RX buffers, %d TX buffers. Base of 0x%08X.\n",
522                 dev->name, lp->exec_box->data[12], lp->rx_len, lp->tx_len, lp->base);
523
524         dev->open               = mc32_open;
525         dev->stop               = mc32_close;
526         dev->hard_start_xmit    = mc32_send_packet;
527         dev->get_stats          = mc32_get_stats;
528         dev->set_multicast_list = mc32_set_multicast_list;
529         dev->tx_timeout         = mc32_timeout;
530         dev->watchdog_timeo     = HZ*5; /* Board does all the work */
531         dev->ethtool_ops        = &netdev_ethtool_ops;
532
533         return 0;
534
535 err_exit_irq:
536         free_irq(dev->irq, dev);
537 err_exit_ports:
538         release_region(dev->base_addr, MC32_IO_EXTENT);
539         return err;
540 }
541
542
543 /**
544  *      mc32_ready_poll         -       wait until we can feed it a command
545  *      @dev:   The device to wait for
546  *      
547  *      Wait until the card becomes ready to accept a command via the
548  *      command register. This tells us nothing about the completion
549  *      status of any pending commands and takes very little time at all.
550  */
551  
552 static inline void mc32_ready_poll(struct net_device *dev)
553 {
554         int ioaddr = dev->base_addr;
555         while(!(inb(ioaddr+HOST_STATUS)&HOST_STATUS_CRR));
556 }
557
558
559 /**
560  *      mc32_command_nowait     -       send a command non blocking
561  *      @dev: The 3c527 to issue the command to
562  *      @cmd: The command word to write to the mailbox
563  *      @data: A data block if the command expects one
564  *      @len: Length of the data block
565  *
566  *      Send a command from interrupt state. If there is a command
567  *      currently being executed then we return an error of -1. It
568  *      simply isn't viable to wait around as commands may be
569  *      slow. This can theoretically be starved on SMP, but it's hard
570  *      to see a realistic situation.  We do not wait for the command
571  *      to complete --- we rely on the interrupt handler to tidy up
572  *      after us.
573  */
574
575 static int mc32_command_nowait(struct net_device *dev, u16 cmd, void *data, int len)
576 {
577         struct mc32_local *lp = netdev_priv(dev);
578         int ioaddr = dev->base_addr;
579         int ret = -1;
580
581         if (down_trylock(&lp->cmd_mutex) == 0)
582         {
583                 lp->cmd_nonblocking=1;
584                 lp->exec_box->mbox=0;
585                 lp->exec_box->mbox=cmd;
586                 memcpy((void *)lp->exec_box->data, data, len);
587                 barrier();      /* the memcpy forgot the volatile so be sure */
588
589                 /* Send the command */
590                 mc32_ready_poll(dev);
591                 outb(1<<6, ioaddr+HOST_CMD);
592
593                 ret = 0;
594
595                 /* Interrupt handler will signal mutex on completion */
596         }
597
598         return ret;
599 }
600
601
602 /**
603  *      mc32_command    -       send a command and sleep until completion
604  *      @dev: The 3c527 card to issue the command to
605  *      @cmd: The command word to write to the mailbox
606  *      @data: A data block if the command expects one
607  *      @len: Length of the data block
608  *
609  *      Sends exec commands in a user context. This permits us to wait around
610  *      for the replies and also to wait for the command buffer to complete
611  *      from a previous command before we execute our command. After our 
612  *      command completes we will attempt any pending multicast reload
613  *      we blocked off by hogging the exec buffer.
614  *
615  *      You feed the card a command, you wait, it interrupts you get a 
616  *      reply. All well and good. The complication arises because you use
617  *      commands for filter list changes which come in at bh level from things
618  *      like IPV6 group stuff.
619  */
620   
621 static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len)
622 {
623         struct mc32_local *lp = netdev_priv(dev);
624         int ioaddr = dev->base_addr;
625         int ret = 0;
626         
627         down(&lp->cmd_mutex);
628
629         /*
630          *     My Turn
631          */
632
633         lp->cmd_nonblocking=0;
634         lp->exec_box->mbox=0;
635         lp->exec_box->mbox=cmd;
636         memcpy((void *)lp->exec_box->data, data, len);
637         barrier();      /* the memcpy forgot the volatile so be sure */
638
639         mc32_ready_poll(dev);
640         outb(1<<6, ioaddr+HOST_CMD);
641
642         wait_for_completion(&lp->execution_cmd);
643         
644         if(lp->exec_box->mbox&(1<<13))
645                 ret = -1;
646
647         up(&lp->cmd_mutex);
648
649         /*
650          *      A multicast set got blocked - try it now
651          */
652
653         if(lp->mc_reload_wait)
654         {
655                 mc32_reset_multicast_list(dev);
656         }
657
658         return ret;
659 }
660
661
662 /**
663  *      mc32_start_transceiver  -       tell board to restart tx/rx
664  *      @dev: The 3c527 card to issue the command to
665  *
666  *      This may be called from the interrupt state, where it is used
667  *      to restart the rx ring if the card runs out of rx buffers. 
668  *      
669  *      We must first check if it's ok to (re)start the transceiver. See
670  *      mc32_close for details.
671  */
672
673 static void mc32_start_transceiver(struct net_device *dev) {
674
675         struct mc32_local *lp = netdev_priv(dev);
676         int ioaddr = dev->base_addr;
677
678         /* Ignore RX overflow on device closure */ 
679         if (lp->xceiver_desired_state==HALTED)
680                 return; 
681
682         /* Give the card the offset to the post-EOL-bit RX descriptor */
683         mc32_ready_poll(dev); 
684         lp->rx_box->mbox=0;
685         lp->rx_box->data[0]=lp->rx_ring[prev_rx(lp->rx_ring_tail)].p->next; 
686         outb(HOST_CMD_START_RX, ioaddr+HOST_CMD);      
687
688         mc32_ready_poll(dev); 
689         lp->tx_box->mbox=0;
690         outb(HOST_CMD_RESTRT_TX, ioaddr+HOST_CMD);   /* card ignores this on RX restart */ 
691         
692         /* We are not interrupted on start completion */ 
693 }
694
695
696 /**
697  *      mc32_halt_transceiver   -       tell board to stop tx/rx
698  *      @dev: The 3c527 card to issue the command to
699  *
700  *      We issue the commands to halt the card's transceiver. In fact,
701  *      after some experimenting we now simply tell the card to
702  *      suspend. When issuing aborts occasionally odd things happened.
703  *
704  *      We then sleep until the card has notified us that both rx and
705  *      tx have been suspended.
706  */ 
707
708 static void mc32_halt_transceiver(struct net_device *dev) 
709 {
710         struct mc32_local *lp = netdev_priv(dev);
711         int ioaddr = dev->base_addr;
712
713         mc32_ready_poll(dev);   
714         lp->rx_box->mbox=0;
715         outb(HOST_CMD_SUSPND_RX, ioaddr+HOST_CMD);                      
716         wait_for_completion(&lp->xceiver_cmd);
717
718         mc32_ready_poll(dev); 
719         lp->tx_box->mbox=0;
720         outb(HOST_CMD_SUSPND_TX, ioaddr+HOST_CMD);      
721         wait_for_completion(&lp->xceiver_cmd);
722 }
723
724
725 /**
726  *      mc32_load_rx_ring       -       load the ring of receive buffers
727  *      @dev: 3c527 to build the ring for
728  *
729  *      This initalises the on-card and driver datastructures to
730  *      the point where mc32_start_transceiver() can be called.
731  *
732  *      The card sets up the receive ring for us. We are required to use the
733  *      ring it provides, although the size of the ring is configurable.
734  *
735  *      We allocate an sk_buff for each ring entry in turn and
736  *      initalise its house-keeping info. At the same time, we read
737  *      each 'next' pointer in our rx_ring array. This reduces slow
738  *      shared-memory reads and makes it easy to access predecessor
739  *      descriptors.
740  *
741  *      We then set the end-of-list bit for the last entry so that the
742  *      card will know when it has run out of buffers.
743  */
744          
745 static int mc32_load_rx_ring(struct net_device *dev)
746 {
747         struct mc32_local *lp = netdev_priv(dev);
748         int i;
749         u16 rx_base;
750         volatile struct skb_header *p;
751         
752         rx_base=lp->rx_chain;
753
754         for(i=0; i<RX_RING_LEN; i++) {
755                 lp->rx_ring[i].skb=alloc_skb(1532, GFP_KERNEL);
756                 if (lp->rx_ring[i].skb==NULL) {
757                         for (;i>=0;i--)
758                                 kfree_skb(lp->rx_ring[i].skb);
759                         return -ENOBUFS;
760                 }
761                 skb_reserve(lp->rx_ring[i].skb, 18);
762
763                 p=isa_bus_to_virt(lp->base+rx_base);
764                                 
765                 p->control=0;
766                 p->data=isa_virt_to_bus(lp->rx_ring[i].skb->data);
767                 p->status=0;
768                 p->length=1532;
769         
770                 lp->rx_ring[i].p=p; 
771                 rx_base=p->next; 
772         }
773
774         lp->rx_ring[i-1].p->control |= CONTROL_EOL;
775
776         lp->rx_ring_tail=0;
777
778         return 0;
779 }       
780
781
782 /**
783  *      mc32_flush_rx_ring      -       free the ring of receive buffers
784  *      @lp: Local data of 3c527 to flush the rx ring of
785  *
786  *      Free the buffer for each ring slot. This may be called 
787  *      before mc32_load_rx_ring(), eg. on error in mc32_open().
788  *      Requires rx skb pointers to point to a valid skb, or NULL.
789  */
790
791 static void mc32_flush_rx_ring(struct net_device *dev)
792 {
793         struct mc32_local *lp = netdev_priv(dev);
794         int i; 
795
796         for(i=0; i < RX_RING_LEN; i++) 
797         { 
798                 if (lp->rx_ring[i].skb) {
799                         dev_kfree_skb(lp->rx_ring[i].skb);
800                         lp->rx_ring[i].skb = NULL;
801                 }
802                 lp->rx_ring[i].p=NULL; 
803         } 
804 }
805
806
807 /**
808  *      mc32_load_tx_ring       -       load transmit ring
809  *      @dev: The 3c527 card to issue the command to
810  *
811  *      This sets up the host transmit data-structures. 
812  *
813  *      First, we obtain from the card it's current postion in the tx
814  *      ring, so that we will know where to begin transmitting
815  *      packets.
816  *      
817  *      Then, we read the 'next' pointers from the on-card tx ring into
818  *      our tx_ring array to reduce slow shared-mem reads. Finally, we
819  *      intitalise the tx house keeping variables.
820  * 
821  */ 
822
823 static void mc32_load_tx_ring(struct net_device *dev)
824
825         struct mc32_local *lp = netdev_priv(dev);
826         volatile struct skb_header *p;
827         int i; 
828         u16 tx_base;
829
830         tx_base=lp->tx_box->data[0]; 
831
832         for(i=0 ; i<TX_RING_LEN ; i++)
833         {
834                 p=isa_bus_to_virt(lp->base+tx_base);
835                 lp->tx_ring[i].p=p; 
836                 lp->tx_ring[i].skb=NULL;
837
838                 tx_base=p->next;
839         }
840
841         /* -1 so that tx_ring_head cannot "lap" tx_ring_tail */
842         /* see mc32_tx_ring */
843
844         atomic_set(&lp->tx_count, TX_RING_LEN-1); 
845         atomic_set(&lp->tx_ring_head, 0); 
846         lp->tx_ring_tail=0; 
847
848
849
850 /**
851  *      mc32_flush_tx_ring      -       free transmit ring
852  *      @lp: Local data of 3c527 to flush the tx ring of
853  *
854  *      If the ring is non-empty, zip over the it, freeing any
855  *      allocated skb_buffs.  The tx ring house-keeping variables are
856  *      then reset. Requires rx skb pointers to point to a valid skb,
857  *      or NULL.
858  */
859
860 static void mc32_flush_tx_ring(struct net_device *dev)
861 {
862         struct mc32_local *lp = netdev_priv(dev);
863         int i;
864
865         for (i=0; i < TX_RING_LEN; i++)
866         {
867                 if (lp->tx_ring[i].skb)
868                 {
869                         dev_kfree_skb(lp->tx_ring[i].skb);
870                         lp->tx_ring[i].skb = NULL;
871                 }
872         }
873
874         atomic_set(&lp->tx_count, 0); 
875         atomic_set(&lp->tx_ring_head, 0); 
876         lp->tx_ring_tail=0;
877 }
878         
879
880 /**
881  *      mc32_open       -       handle 'up' of card
882  *      @dev: device to open
883  *
884  *      The user is trying to bring the card into ready state. This requires
885  *      a brief dialogue with the card. Firstly we enable interrupts and then
886  *      'indications'. Without these enabled the card doesn't bother telling
887  *      us what it has done. This had me puzzled for a week.
888  *
889  *      We configure the number of card descriptors, then load the network
890  *      address and multicast filters. Turn on the workaround mode. This
891  *      works around a bug in the 82586 - it asks the firmware to do
892  *      so. It has a performance (latency) hit but is needed on busy
893  *      [read most] lans. We load the ring with buffers then we kick it
894  *      all off.
895  */
896
897 static int mc32_open(struct net_device *dev)
898 {
899         int ioaddr = dev->base_addr;
900         struct mc32_local *lp = netdev_priv(dev);
901         u8 one=1;
902         u8 regs;
903         u16 descnumbuffs[2] = {TX_RING_LEN, RX_RING_LEN};
904
905         /*
906          *      Interrupts enabled
907          */
908
909         regs=inb(ioaddr+HOST_CTRL);
910         regs|=HOST_CTRL_INTE;
911         outb(regs, ioaddr+HOST_CTRL);
912         
913         /*
914          *      Allow ourselves to issue commands
915          */
916
917         up(&lp->cmd_mutex);
918
919
920         /*
921          *      Send the indications on command
922          */
923
924         mc32_command(dev, 4, &one, 2);
925
926         /*
927          *      Poke it to make sure it's really dead. 
928          */
929
930         mc32_halt_transceiver(dev); 
931         mc32_flush_tx_ring(dev); 
932
933         /* 
934          *      Ask card to set up on-card descriptors to our spec 
935          */ 
936
937         if(mc32_command(dev, 8, descnumbuffs, 4)) { 
938                 printk("%s: %s rejected our buffer configuration!\n",
939                        dev->name, cardname);
940                 mc32_close(dev); 
941                 return -ENOBUFS; 
942         }
943         
944         /* Report new configuration */ 
945         mc32_command(dev, 6, NULL, 0); 
946
947         lp->tx_chain            = lp->exec_box->data[8];   /* Transmit list start offset */
948         lp->rx_chain            = lp->exec_box->data[10];  /* Receive list start offset */
949         lp->tx_len              = lp->exec_box->data[9];   /* Transmit list count */ 
950         lp->rx_len              = lp->exec_box->data[11];  /* Receive list count */
951  
952         /* Set Network Address */
953         mc32_command(dev, 1, dev->dev_addr, 6);
954         
955         /* Set the filters */
956         mc32_set_multicast_list(dev);
957                    
958         if (WORKAROUND_82586) { 
959                 u16 zero_word=0;
960                 mc32_command(dev, 0x0D, &zero_word, 2);   /* 82586 bug workaround on  */
961         }
962
963         mc32_load_tx_ring(dev);
964         
965         if(mc32_load_rx_ring(dev)) 
966         {
967                 mc32_close(dev);
968                 return -ENOBUFS;
969         }
970
971         lp->xceiver_desired_state = RUNNING;
972         
973         /* And finally, set the ball rolling... */
974         mc32_start_transceiver(dev);
975
976         netif_start_queue(dev);
977
978         return 0;
979 }
980
981
982 /**
983  *      mc32_timeout    -       handle a timeout from the network layer
984  *      @dev: 3c527 that timed out
985  *
986  *      Handle a timeout on transmit from the 3c527. This normally means
987  *      bad things as the hardware handles cable timeouts and mess for
988  *      us.
989  *
990  */
991
992 static void mc32_timeout(struct net_device *dev)
993 {
994         printk(KERN_WARNING "%s: transmit timed out?\n", dev->name);
995         /* Try to restart the adaptor. */
996         netif_wake_queue(dev);
997 }
998
999
1000 /**
1001  *      mc32_send_packet        -       queue a frame for transmit
1002  *      @skb: buffer to transmit
1003  *      @dev: 3c527 to send it out of
1004  *
1005  *      Transmit a buffer. This normally means throwing the buffer onto
1006  *      the transmit queue as the queue is quite large. If the queue is
1007  *      full then we set tx_busy and return. Once the interrupt handler
1008  *      gets messages telling it to reclaim transmit queue entries, we will
1009  *      clear tx_busy and the kernel will start calling this again.
1010  *
1011  *      We do not disable interrupts or acquire any locks; this can
1012  *      run concurrently with mc32_tx_ring(), and the function itself
1013  *      is serialised at a higher layer. However, similarly for the
1014  *      card itself, we must ensure that we update tx_ring_head only
1015  *      after we've established a valid packet on the tx ring (and
1016  *      before we let the card "see" it, to prevent it racing with the
1017  *      irq handler).
1018  * 
1019  */
1020
1021 static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev)
1022 {
1023         struct mc32_local *lp = netdev_priv(dev);
1024         u32 head = atomic_read(&lp->tx_ring_head);
1025         
1026         volatile struct skb_header *p, *np;
1027
1028         netif_stop_queue(dev);
1029
1030         if(atomic_read(&lp->tx_count)==0) {
1031                 return 1;
1032         }
1033
1034         skb = skb_padto(skb, ETH_ZLEN);
1035         if (skb == NULL) {
1036                 netif_wake_queue(dev);
1037                 return 0;
1038         }
1039
1040         atomic_dec(&lp->tx_count); 
1041
1042         /* P is the last sending/sent buffer as a pointer */
1043         p=lp->tx_ring[head].p;
1044                 
1045         head = next_tx(head);
1046
1047         /* NP is the buffer we will be loading */
1048         np=lp->tx_ring[head].p; 
1049         
1050         /* We will need this to flush the buffer out */
1051         lp->tx_ring[head].skb=skb;
1052
1053         np->length      = unlikely(skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;                  
1054         np->data        = isa_virt_to_bus(skb->data);
1055         np->status      = 0;
1056         np->control     = CONTROL_EOP | CONTROL_EOL;     
1057         wmb();
1058                 
1059         /*
1060          * The new frame has been setup; we can now
1061          * let the interrupt handler and card "see" it
1062          */
1063
1064         atomic_set(&lp->tx_ring_head, head); 
1065         p->control     &= ~CONTROL_EOL;
1066
1067         netif_wake_queue(dev);
1068         return 0;
1069 }
1070
1071
1072 /**
1073  *      mc32_update_stats       -       pull off the on board statistics
1074  *      @dev: 3c527 to service
1075  *
1076  * 
1077  *      Query and reset the on-card stats. There's the small possibility
1078  *      of a race here, which would result in an underestimation of
1079  *      actual errors. As such, we'd prefer to keep all our stats
1080  *      collection in software. As a rule, we do. However it can't be
1081  *      used for rx errors and collisions as, by default, the card discards
1082  *      bad rx packets. 
1083  *
1084  *      Setting the SAV BP in the rx filter command supposedly
1085  *      stops this behaviour. However, testing shows that it only seems to
1086  *      enable the collation of on-card rx statistics --- the driver
1087  *      never sees an RX descriptor with an error status set.
1088  *
1089  */
1090
1091 static void mc32_update_stats(struct net_device *dev)
1092 {
1093         struct mc32_local *lp = netdev_priv(dev);
1094         volatile struct mc32_stats *st = lp->stats; 
1095
1096         u32 rx_errors=0; 
1097       
1098         rx_errors+=lp->net_stats.rx_crc_errors   +=st->rx_crc_errors;         
1099                                                    st->rx_crc_errors=0;
1100         rx_errors+=lp->net_stats.rx_fifo_errors  +=st->rx_overrun_errors;   
1101                                                    st->rx_overrun_errors=0; 
1102         rx_errors+=lp->net_stats.rx_frame_errors +=st->rx_alignment_errors; 
1103                                                    st->rx_alignment_errors=0;
1104         rx_errors+=lp->net_stats.rx_length_errors+=st->rx_tooshort_errors; 
1105                                                    st->rx_tooshort_errors=0;
1106         rx_errors+=lp->net_stats.rx_missed_errors+=st->rx_outofresource_errors;
1107                                                    st->rx_outofresource_errors=0; 
1108         lp->net_stats.rx_errors=rx_errors; 
1109                                                    
1110         /* Number of packets which saw one collision */
1111         lp->net_stats.collisions+=st->dataC[10];
1112         st->dataC[10]=0; 
1113
1114         /* Number of packets which saw 2--15 collisions */ 
1115         lp->net_stats.collisions+=st->dataC[11]; 
1116         st->dataC[11]=0; 
1117 }       
1118
1119
1120 /**
1121  *      mc32_rx_ring    -       process the receive ring
1122  *      @dev: 3c527 that needs its receive ring processing
1123  *
1124  *
1125  *      We have received one or more indications from the card that a
1126  *      receive has completed. The buffer ring thus contains dirty
1127  *      entries. We walk the ring by iterating over the circular rx_ring
1128  *      array, starting at the next dirty buffer (which happens to be the
1129  *      one we finished up at last time around).
1130  *
1131  *      For each completed packet, we will either copy it and pass it up
1132  *      the stack or, if the packet is near MTU sized, we allocate
1133  *      another buffer and flip the old one up the stack.
1134  * 
1135  *      We must succeed in keeping a buffer on the ring. If necessary we
1136  *      will toss a received packet rather than lose a ring entry. Once
1137  *      the first uncompleted descriptor is found, we move the
1138  *      End-Of-List bit to include the buffers just processed.
1139  *
1140  */
1141
1142 static void mc32_rx_ring(struct net_device *dev)
1143 {
1144         struct mc32_local *lp = netdev_priv(dev);
1145         volatile struct skb_header *p;
1146         u16 rx_ring_tail;
1147         u16 rx_old_tail;
1148         int x=0;
1149
1150         rx_old_tail = rx_ring_tail = lp->rx_ring_tail;
1151         
1152         do
1153         { 
1154                 p=lp->rx_ring[rx_ring_tail].p; 
1155
1156                 if(!(p->status & (1<<7))) { /* Not COMPLETED */ 
1157                         break;
1158                 } 
1159                 if(p->status & (1<<6)) /* COMPLETED_OK */
1160                 {                       
1161
1162                         u16 length=p->length;
1163                         struct sk_buff *skb; 
1164                         struct sk_buff *newskb; 
1165
1166                         /* Try to save time by avoiding a copy on big frames */
1167
1168                         if ((length > RX_COPYBREAK) 
1169                             && ((newskb=dev_alloc_skb(1532)) != NULL)) 
1170                         { 
1171                                 skb=lp->rx_ring[rx_ring_tail].skb;
1172                                 skb_put(skb, length);
1173                                 
1174                                 skb_reserve(newskb,18); 
1175                                 lp->rx_ring[rx_ring_tail].skb=newskb;  
1176                                 p->data=isa_virt_to_bus(newskb->data);  
1177                         } 
1178                         else 
1179                         {
1180                                 skb=dev_alloc_skb(length+2);  
1181
1182                                 if(skb==NULL) {
1183                                         lp->net_stats.rx_dropped++; 
1184                                         goto dropped; 
1185                                 }
1186
1187                                 skb_reserve(skb,2);
1188                                 memcpy(skb_put(skb, length),
1189                                        lp->rx_ring[rx_ring_tail].skb->data, length);
1190                         }
1191                         
1192                         skb->protocol=eth_type_trans(skb,dev); 
1193                         skb->dev=dev; 
1194                         dev->last_rx = jiffies;
1195                         lp->net_stats.rx_packets++; 
1196                         lp->net_stats.rx_bytes += length; 
1197                         netif_rx(skb);
1198                 }
1199
1200         dropped:
1201                 p->length = 1532; 
1202                 p->status = 0;
1203                 
1204                 rx_ring_tail=next_rx(rx_ring_tail); 
1205         }
1206         while(x++<48);  
1207
1208         /* If there was actually a frame to be processed, place the EOL bit */ 
1209         /* at the descriptor prior to the one to be filled next */ 
1210
1211         if (rx_ring_tail != rx_old_tail) 
1212         { 
1213                 lp->rx_ring[prev_rx(rx_ring_tail)].p->control |=  CONTROL_EOL; 
1214                 lp->rx_ring[prev_rx(rx_old_tail)].p->control  &= ~CONTROL_EOL; 
1215
1216                 lp->rx_ring_tail=rx_ring_tail; 
1217         }
1218 }
1219
1220
1221 /**
1222  *      mc32_tx_ring    -       process completed transmits
1223  *      @dev: 3c527 that needs its transmit ring processing
1224  *
1225  *
1226  *      This operates in a similar fashion to mc32_rx_ring. We iterate
1227  *      over the transmit ring. For each descriptor which has been
1228  *      processed by the card, we free its associated buffer and note
1229  *      any errors. This continues until the transmit ring is emptied
1230  *      or we reach a descriptor that hasn't yet been processed by the
1231  *      card.
1232  * 
1233  */
1234
1235 static void mc32_tx_ring(struct net_device *dev) 
1236 {
1237         struct mc32_local *lp = netdev_priv(dev);
1238         volatile struct skb_header *np;
1239
1240         /*
1241          * We rely on head==tail to mean 'queue empty'.
1242          * This is why lp->tx_count=TX_RING_LEN-1: in order to prevent
1243          * tx_ring_head wrapping to tail and confusing a 'queue empty'
1244          * condition with 'queue full'
1245          */
1246
1247         while (lp->tx_ring_tail != atomic_read(&lp->tx_ring_head))  
1248         {   
1249                 u16 t; 
1250
1251                 t=next_tx(lp->tx_ring_tail); 
1252                 np=lp->tx_ring[t].p; 
1253
1254                 if(!(np->status & (1<<7))) 
1255                 {
1256                         /* Not COMPLETED */ 
1257                         break; 
1258                 } 
1259                 lp->net_stats.tx_packets++;
1260                 if(!(np->status & (1<<6))) /* Not COMPLETED_OK */
1261                 {
1262                         lp->net_stats.tx_errors++;   
1263
1264                         switch(np->status&0x0F)
1265                         {
1266                                 case 1:
1267                                         lp->net_stats.tx_aborted_errors++;
1268                                         break; /* Max collisions */ 
1269                                 case 2:
1270                                         lp->net_stats.tx_fifo_errors++;
1271                                         break;
1272                                 case 3:
1273                                         lp->net_stats.tx_carrier_errors++;
1274                                         break;
1275                                 case 4:
1276                                         lp->net_stats.tx_window_errors++;
1277                                         break;  /* CTS Lost */ 
1278                                 case 5:
1279                                         lp->net_stats.tx_aborted_errors++;
1280                                         break; /* Transmit timeout */ 
1281                         }
1282                 }
1283                 /* Packets are sent in order - this is
1284                     basically a FIFO queue of buffers matching
1285                     the card ring */
1286                 lp->net_stats.tx_bytes+=lp->tx_ring[t].skb->len;
1287                 dev_kfree_skb_irq(lp->tx_ring[t].skb);
1288                 lp->tx_ring[t].skb=NULL;
1289                 atomic_inc(&lp->tx_count);
1290                 netif_wake_queue(dev);
1291
1292                 lp->tx_ring_tail=t; 
1293         }
1294
1295
1296
1297
1298 /**
1299  *      mc32_interrupt          -       handle an interrupt from a 3c527
1300  *      @irq: Interrupt number
1301  *      @dev_id: 3c527 that requires servicing
1302  *      @regs: Registers (unused)
1303  *
1304  *
1305  *      An interrupt is raised whenever the 3c527 writes to the command
1306  *      register. This register contains the message it wishes to send us
1307  *      packed into a single byte field. We keep reading status entries
1308  *      until we have processed all the control items, but simply count
1309  *      transmit and receive reports. When all reports are in we empty the
1310  *      transceiver rings as appropriate. This saves the overhead of
1311  *      multiple command requests.
1312  *
1313  *      Because MCA is level-triggered, we shouldn't miss indications.
1314  *      Therefore, we needn't ask the card to suspend interrupts within
1315  *      this handler. The card receives an implicit acknowledgment of the
1316  *      current interrupt when we read the command register.
1317  *
1318  */
1319
1320 static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1321 {
1322         struct net_device *dev = dev_id;
1323         struct mc32_local *lp;
1324         int ioaddr, status, boguscount = 0;
1325         int rx_event = 0;
1326         int tx_event = 0; 
1327         
1328         if (dev == NULL) {
1329                 printk(KERN_WARNING "%s: irq %d for unknown device.\n", cardname, irq);
1330                 return IRQ_NONE;
1331         }
1332  
1333         ioaddr = dev->base_addr;
1334         lp = netdev_priv(dev);
1335
1336         /* See whats cooking */
1337
1338         while((inb(ioaddr+HOST_STATUS)&HOST_STATUS_CWR) && boguscount++<2000)
1339         {
1340                 status=inb(ioaddr+HOST_CMD);
1341
1342 #ifdef DEBUG_IRQ                
1343                 printk("Status TX%d RX%d EX%d OV%d BC%d\n",
1344                         (status&7), (status>>3)&7, (status>>6)&1,
1345                         (status>>7)&1, boguscount);
1346 #endif
1347                         
1348                 switch(status&7)
1349                 {
1350                         case 0:
1351                                 break;
1352                         case 6: /* TX fail */
1353                         case 2: /* TX ok */
1354                                 tx_event = 1; 
1355                                 break;
1356                         case 3: /* Halt */
1357                         case 4: /* Abort */
1358                                 complete(&lp->xceiver_cmd);
1359                                 break;
1360                         default:
1361                                 printk("%s: strange tx ack %d\n", dev->name, status&7);
1362                 }
1363                 status>>=3;
1364                 switch(status&7)
1365                 {
1366                         case 0:
1367                                 break;
1368                         case 2: /* RX */
1369                                 rx_event=1; 
1370                                 break;
1371                         case 3: /* Halt */
1372                         case 4: /* Abort */
1373                                 complete(&lp->xceiver_cmd);
1374                                 break;
1375                         case 6:
1376                                 /* Out of RX buffers stat */
1377                                 /* Must restart rx */
1378                                 lp->net_stats.rx_dropped++;
1379                                 mc32_rx_ring(dev); 
1380                                 mc32_start_transceiver(dev); 
1381                                 break;
1382                         default:
1383                                 printk("%s: strange rx ack %d\n", 
1384                                         dev->name, status&7);                   
1385                 }
1386                 status>>=3;
1387                 if(status&1)
1388                 {
1389                         /*
1390                          * No thread is waiting: we need to tidy
1391                          * up ourself.
1392                          */
1393                                    
1394                         if (lp->cmd_nonblocking) {
1395                                 up(&lp->cmd_mutex);
1396                                 if (lp->mc_reload_wait) 
1397                                         mc32_reset_multicast_list(dev);
1398                         }
1399                         else complete(&lp->execution_cmd);
1400                 }
1401                 if(status&2)
1402                 {
1403                         /*
1404                          *      We get interrupted once per
1405                          *      counter that is about to overflow. 
1406                          */
1407
1408                         mc32_update_stats(dev);                 
1409                 }
1410         }
1411
1412
1413         /*
1414          *      Process the transmit and receive rings 
1415          */
1416
1417         if(tx_event) 
1418                 mc32_tx_ring(dev);
1419          
1420         if(rx_event) 
1421                 mc32_rx_ring(dev);
1422
1423         return IRQ_HANDLED;
1424 }
1425
1426
1427 /**
1428  *      mc32_close      -       user configuring the 3c527 down
1429  *      @dev: 3c527 card to shut down
1430  *
1431  *      The 3c527 is a bus mastering device. We must be careful how we
1432  *      shut it down. It may also be running shared interrupt so we have
1433  *      to be sure to silence it properly
1434  *
1435  *      We indicate that the card is closing to the rest of the
1436  *      driver.  Otherwise, it is possible that the card may run out
1437  *      of receive buffers and restart the transceiver while we're
1438  *      trying to close it.
1439  * 
1440  *      We abort any receive and transmits going on and then wait until
1441  *      any pending exec commands have completed in other code threads.
1442  *      In theory we can't get here while that is true, in practice I am
1443  *      paranoid
1444  *
1445  *      We turn off the interrupt enable for the board to be sure it can't
1446  *      intefere with other devices.
1447  */
1448
1449 static int mc32_close(struct net_device *dev)
1450 {
1451         struct mc32_local *lp = netdev_priv(dev);
1452         int ioaddr = dev->base_addr;
1453
1454         u8 regs;
1455         u16 one=1;
1456         
1457         lp->xceiver_desired_state = HALTED;
1458         netif_stop_queue(dev);
1459
1460         /*
1461          *      Send the indications on command (handy debug check)
1462          */
1463
1464         mc32_command(dev, 4, &one, 2);
1465
1466         /* Shut down the transceiver */
1467
1468         mc32_halt_transceiver(dev); 
1469         
1470         /* Ensure we issue no more commands beyond this point */
1471
1472         down(&lp->cmd_mutex);
1473         
1474         /* Ok the card is now stopping */       
1475         
1476         regs=inb(ioaddr+HOST_CTRL);
1477         regs&=~HOST_CTRL_INTE;
1478         outb(regs, ioaddr+HOST_CTRL);
1479
1480         mc32_flush_rx_ring(dev);
1481         mc32_flush_tx_ring(dev);
1482                 
1483         mc32_update_stats(dev); 
1484
1485         return 0;
1486 }
1487
1488
1489 /**
1490  *      mc32_get_stats          -       hand back stats to network layer
1491  *      @dev: The 3c527 card to handle
1492  *
1493  *      We've collected all the stats we can in software already. Now
1494  *      it's time to update those kept on-card and return the lot. 
1495  * 
1496  */
1497
1498 static struct net_device_stats *mc32_get_stats(struct net_device *dev)
1499 {
1500         struct mc32_local *lp = netdev_priv(dev);
1501         
1502         mc32_update_stats(dev); 
1503         return &lp->net_stats;
1504 }
1505
1506
1507 /**
1508  *      do_mc32_set_multicast_list      -       attempt to update multicasts
1509  *      @dev: 3c527 device to load the list on
1510  *      @retry: indicates this is not the first call. 
1511  *
1512  *
1513  *      Actually set or clear the multicast filter for this adaptor. The
1514  *      locking issues are handled by this routine. We have to track
1515  *      state as it may take multiple calls to get the command sequence
1516  *      completed. We just keep trying to schedule the loads until we
1517  *      manage to process them all.
1518  * 
1519  *      num_addrs == -1 Promiscuous mode, receive all packets
1520  * 
1521  *      num_addrs == 0  Normal mode, clear multicast list
1522  * 
1523  *      num_addrs > 0   Multicast mode, receive normal and MC packets, 
1524  *                      and do best-effort filtering. 
1525  *
1526  *      See mc32_update_stats() regards setting the SAV BP bit. 
1527  *
1528  */
1529
1530 static void do_mc32_set_multicast_list(struct net_device *dev, int retry)
1531 {
1532         struct mc32_local *lp = netdev_priv(dev);
1533         u16 filt = (1<<2); /* Save Bad Packets, for stats purposes */ 
1534
1535         if (dev->flags&IFF_PROMISC)
1536                 /* Enable promiscuous mode */
1537                 filt |= 1;
1538         else if((dev->flags&IFF_ALLMULTI) || dev->mc_count > 10)
1539         {
1540                 dev->flags|=IFF_PROMISC;
1541                 filt |= 1;
1542         }
1543         else if(dev->mc_count)
1544         {
1545                 unsigned char block[62];
1546                 unsigned char *bp;
1547                 struct dev_mc_list *dmc=dev->mc_list;
1548                 
1549                 int i;
1550                
1551                 if(retry==0)
1552                         lp->mc_list_valid = 0;
1553                 if(!lp->mc_list_valid)
1554                 {
1555                         block[1]=0;
1556                         block[0]=dev->mc_count;
1557                         bp=block+2;
1558                 
1559                         for(i=0;i<dev->mc_count;i++)
1560                         {
1561                                 memcpy(bp, dmc->dmi_addr, 6);
1562                                 bp+=6;
1563                                 dmc=dmc->next;
1564                         }
1565                         if(mc32_command_nowait(dev, 2, block, 2+6*dev->mc_count)==-1)
1566                         {
1567                                 lp->mc_reload_wait = 1;
1568                                 return;
1569                         }
1570                         lp->mc_list_valid=1;
1571                 }
1572         }
1573         
1574         if(mc32_command_nowait(dev, 0, &filt, 2)==-1) 
1575         {
1576                 lp->mc_reload_wait = 1;
1577         } 
1578         else { 
1579                 lp->mc_reload_wait = 0;
1580         }
1581 }
1582
1583
1584 /**
1585  *      mc32_set_multicast_list -       queue multicast list update
1586  *      @dev: The 3c527 to use
1587  *
1588  *      Commence loading the multicast list. This is called when the kernel
1589  *      changes the lists. It will override any pending list we are trying to
1590  *      load.
1591  */
1592
1593 static void mc32_set_multicast_list(struct net_device *dev)
1594 {
1595         do_mc32_set_multicast_list(dev,0);
1596 }
1597
1598
1599 /**
1600  *      mc32_reset_multicast_list       -       reset multicast list
1601  *      @dev: The 3c527 to use
1602  *
1603  *      Attempt the next step in loading the multicast lists. If this attempt
1604  *      fails to complete then it will be scheduled and this function called
1605  *      again later from elsewhere.
1606  */
1607
1608 static void mc32_reset_multicast_list(struct net_device *dev)
1609 {
1610         do_mc32_set_multicast_list(dev,1);
1611 }
1612
1613 static void netdev_get_drvinfo(struct net_device *dev,
1614                                struct ethtool_drvinfo *info)
1615 {
1616         strcpy(info->driver, DRV_NAME);
1617         strcpy(info->version, DRV_VERSION);
1618         sprintf(info->bus_info, "MCA 0x%lx", dev->base_addr);
1619 }
1620
1621 static u32 netdev_get_msglevel(struct net_device *dev)
1622 {
1623         return mc32_debug;
1624 }
1625
1626 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1627 {
1628         mc32_debug = level;
1629 }
1630
1631 static struct ethtool_ops netdev_ethtool_ops = {
1632         .get_drvinfo            = netdev_get_drvinfo,
1633         .get_msglevel           = netdev_get_msglevel,
1634         .set_msglevel           = netdev_set_msglevel,
1635 };
1636
1637 #ifdef MODULE
1638
1639 static struct net_device *this_device;
1640
1641 /**
1642  *      init_module             -       entry point
1643  *
1644  *      Probe and locate a 3c527 card. This really should probe and locate
1645  *      all the 3c527 cards in the machine not just one of them. Yes you can
1646  *      insmod multiple modules for now but it's a hack.
1647  */
1648
1649 int init_module(void)
1650 {
1651         this_device = mc32_probe(-1);
1652         if (IS_ERR(this_device))
1653                 return PTR_ERR(this_device);
1654         return 0;
1655 }
1656
1657 /**
1658  *      cleanup_module  -       free resources for an unload
1659  *
1660  *      Unloading time. We release the MCA bus resources and the interrupt
1661  *      at which point everything is ready to unload. The card must be stopped
1662  *      at this point or we would not have been called. When we unload we
1663  *      leave the card stopped but not totally shut down. When the card is
1664  *      initialized it must be rebooted or the rings reloaded before any
1665  *      transmit operations are allowed to start scribbling into memory.
1666  */
1667
1668 void cleanup_module(void)
1669 {
1670         unregister_netdev(this_device);
1671         cleanup_card(this_device);
1672         free_netdev(this_device);
1673 }
1674
1675 #endif /* MODULE */