[PATCH] irq-flags: drivers/net: Use the new IRQF_ constants
[linux-2.6.git] / 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, IRQF_SHARED | IRQF_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         if (skb_padto(skb, ETH_ZLEN)) {
1035                 netif_wake_queue(dev);
1036                 return 0;
1037         }
1038
1039         atomic_dec(&lp->tx_count); 
1040
1041         /* P is the last sending/sent buffer as a pointer */
1042         p=lp->tx_ring[head].p;
1043                 
1044         head = next_tx(head);
1045
1046         /* NP is the buffer we will be loading */
1047         np=lp->tx_ring[head].p; 
1048         
1049         /* We will need this to flush the buffer out */
1050         lp->tx_ring[head].skb=skb;
1051
1052         np->length      = unlikely(skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;                  
1053         np->data        = isa_virt_to_bus(skb->data);
1054         np->status      = 0;
1055         np->control     = CONTROL_EOP | CONTROL_EOL;     
1056         wmb();
1057                 
1058         /*
1059          * The new frame has been setup; we can now
1060          * let the interrupt handler and card "see" it
1061          */
1062
1063         atomic_set(&lp->tx_ring_head, head); 
1064         p->control     &= ~CONTROL_EOL;
1065
1066         netif_wake_queue(dev);
1067         return 0;
1068 }
1069
1070
1071 /**
1072  *      mc32_update_stats       -       pull off the on board statistics
1073  *      @dev: 3c527 to service
1074  *
1075  * 
1076  *      Query and reset the on-card stats. There's the small possibility
1077  *      of a race here, which would result in an underestimation of
1078  *      actual errors. As such, we'd prefer to keep all our stats
1079  *      collection in software. As a rule, we do. However it can't be
1080  *      used for rx errors and collisions as, by default, the card discards
1081  *      bad rx packets. 
1082  *
1083  *      Setting the SAV BP in the rx filter command supposedly
1084  *      stops this behaviour. However, testing shows that it only seems to
1085  *      enable the collation of on-card rx statistics --- the driver
1086  *      never sees an RX descriptor with an error status set.
1087  *
1088  */
1089
1090 static void mc32_update_stats(struct net_device *dev)
1091 {
1092         struct mc32_local *lp = netdev_priv(dev);
1093         volatile struct mc32_stats *st = lp->stats; 
1094
1095         u32 rx_errors=0; 
1096       
1097         rx_errors+=lp->net_stats.rx_crc_errors   +=st->rx_crc_errors;         
1098                                                    st->rx_crc_errors=0;
1099         rx_errors+=lp->net_stats.rx_fifo_errors  +=st->rx_overrun_errors;   
1100                                                    st->rx_overrun_errors=0; 
1101         rx_errors+=lp->net_stats.rx_frame_errors +=st->rx_alignment_errors; 
1102                                                    st->rx_alignment_errors=0;
1103         rx_errors+=lp->net_stats.rx_length_errors+=st->rx_tooshort_errors; 
1104                                                    st->rx_tooshort_errors=0;
1105         rx_errors+=lp->net_stats.rx_missed_errors+=st->rx_outofresource_errors;
1106                                                    st->rx_outofresource_errors=0; 
1107         lp->net_stats.rx_errors=rx_errors; 
1108                                                    
1109         /* Number of packets which saw one collision */
1110         lp->net_stats.collisions+=st->dataC[10];
1111         st->dataC[10]=0; 
1112
1113         /* Number of packets which saw 2--15 collisions */ 
1114         lp->net_stats.collisions+=st->dataC[11]; 
1115         st->dataC[11]=0; 
1116 }       
1117
1118
1119 /**
1120  *      mc32_rx_ring    -       process the receive ring
1121  *      @dev: 3c527 that needs its receive ring processing
1122  *
1123  *
1124  *      We have received one or more indications from the card that a
1125  *      receive has completed. The buffer ring thus contains dirty
1126  *      entries. We walk the ring by iterating over the circular rx_ring
1127  *      array, starting at the next dirty buffer (which happens to be the
1128  *      one we finished up at last time around).
1129  *
1130  *      For each completed packet, we will either copy it and pass it up
1131  *      the stack or, if the packet is near MTU sized, we allocate
1132  *      another buffer and flip the old one up the stack.
1133  * 
1134  *      We must succeed in keeping a buffer on the ring. If necessary we
1135  *      will toss a received packet rather than lose a ring entry. Once
1136  *      the first uncompleted descriptor is found, we move the
1137  *      End-Of-List bit to include the buffers just processed.
1138  *
1139  */
1140
1141 static void mc32_rx_ring(struct net_device *dev)
1142 {
1143         struct mc32_local *lp = netdev_priv(dev);
1144         volatile struct skb_header *p;
1145         u16 rx_ring_tail;
1146         u16 rx_old_tail;
1147         int x=0;
1148
1149         rx_old_tail = rx_ring_tail = lp->rx_ring_tail;
1150         
1151         do
1152         { 
1153                 p=lp->rx_ring[rx_ring_tail].p; 
1154
1155                 if(!(p->status & (1<<7))) { /* Not COMPLETED */ 
1156                         break;
1157                 } 
1158                 if(p->status & (1<<6)) /* COMPLETED_OK */
1159                 {                       
1160
1161                         u16 length=p->length;
1162                         struct sk_buff *skb; 
1163                         struct sk_buff *newskb; 
1164
1165                         /* Try to save time by avoiding a copy on big frames */
1166
1167                         if ((length > RX_COPYBREAK) 
1168                             && ((newskb=dev_alloc_skb(1532)) != NULL)) 
1169                         { 
1170                                 skb=lp->rx_ring[rx_ring_tail].skb;
1171                                 skb_put(skb, length);
1172                                 
1173                                 skb_reserve(newskb,18); 
1174                                 lp->rx_ring[rx_ring_tail].skb=newskb;  
1175                                 p->data=isa_virt_to_bus(newskb->data);  
1176                         } 
1177                         else 
1178                         {
1179                                 skb=dev_alloc_skb(length+2);  
1180
1181                                 if(skb==NULL) {
1182                                         lp->net_stats.rx_dropped++; 
1183                                         goto dropped; 
1184                                 }
1185
1186                                 skb_reserve(skb,2);
1187                                 memcpy(skb_put(skb, length),
1188                                        lp->rx_ring[rx_ring_tail].skb->data, length);
1189                         }
1190                         
1191                         skb->protocol=eth_type_trans(skb,dev); 
1192                         skb->dev=dev; 
1193                         dev->last_rx = jiffies;
1194                         lp->net_stats.rx_packets++; 
1195                         lp->net_stats.rx_bytes += length; 
1196                         netif_rx(skb);
1197                 }
1198
1199         dropped:
1200                 p->length = 1532; 
1201                 p->status = 0;
1202                 
1203                 rx_ring_tail=next_rx(rx_ring_tail); 
1204         }
1205         while(x++<48);  
1206
1207         /* If there was actually a frame to be processed, place the EOL bit */ 
1208         /* at the descriptor prior to the one to be filled next */ 
1209
1210         if (rx_ring_tail != rx_old_tail) 
1211         { 
1212                 lp->rx_ring[prev_rx(rx_ring_tail)].p->control |=  CONTROL_EOL; 
1213                 lp->rx_ring[prev_rx(rx_old_tail)].p->control  &= ~CONTROL_EOL; 
1214
1215                 lp->rx_ring_tail=rx_ring_tail; 
1216         }
1217 }
1218
1219
1220 /**
1221  *      mc32_tx_ring    -       process completed transmits
1222  *      @dev: 3c527 that needs its transmit ring processing
1223  *
1224  *
1225  *      This operates in a similar fashion to mc32_rx_ring. We iterate
1226  *      over the transmit ring. For each descriptor which has been
1227  *      processed by the card, we free its associated buffer and note
1228  *      any errors. This continues until the transmit ring is emptied
1229  *      or we reach a descriptor that hasn't yet been processed by the
1230  *      card.
1231  * 
1232  */
1233
1234 static void mc32_tx_ring(struct net_device *dev) 
1235 {
1236         struct mc32_local *lp = netdev_priv(dev);
1237         volatile struct skb_header *np;
1238
1239         /*
1240          * We rely on head==tail to mean 'queue empty'.
1241          * This is why lp->tx_count=TX_RING_LEN-1: in order to prevent
1242          * tx_ring_head wrapping to tail and confusing a 'queue empty'
1243          * condition with 'queue full'
1244          */
1245
1246         while (lp->tx_ring_tail != atomic_read(&lp->tx_ring_head))  
1247         {   
1248                 u16 t; 
1249
1250                 t=next_tx(lp->tx_ring_tail); 
1251                 np=lp->tx_ring[t].p; 
1252
1253                 if(!(np->status & (1<<7))) 
1254                 {
1255                         /* Not COMPLETED */ 
1256                         break; 
1257                 } 
1258                 lp->net_stats.tx_packets++;
1259                 if(!(np->status & (1<<6))) /* Not COMPLETED_OK */
1260                 {
1261                         lp->net_stats.tx_errors++;   
1262
1263                         switch(np->status&0x0F)
1264                         {
1265                                 case 1:
1266                                         lp->net_stats.tx_aborted_errors++;
1267                                         break; /* Max collisions */ 
1268                                 case 2:
1269                                         lp->net_stats.tx_fifo_errors++;
1270                                         break;
1271                                 case 3:
1272                                         lp->net_stats.tx_carrier_errors++;
1273                                         break;
1274                                 case 4:
1275                                         lp->net_stats.tx_window_errors++;
1276                                         break;  /* CTS Lost */ 
1277                                 case 5:
1278                                         lp->net_stats.tx_aborted_errors++;
1279                                         break; /* Transmit timeout */ 
1280                         }
1281                 }
1282                 /* Packets are sent in order - this is
1283                     basically a FIFO queue of buffers matching
1284                     the card ring */
1285                 lp->net_stats.tx_bytes+=lp->tx_ring[t].skb->len;
1286                 dev_kfree_skb_irq(lp->tx_ring[t].skb);
1287                 lp->tx_ring[t].skb=NULL;
1288                 atomic_inc(&lp->tx_count);
1289                 netif_wake_queue(dev);
1290
1291                 lp->tx_ring_tail=t; 
1292         }
1293
1294
1295
1296
1297 /**
1298  *      mc32_interrupt          -       handle an interrupt from a 3c527
1299  *      @irq: Interrupt number
1300  *      @dev_id: 3c527 that requires servicing
1301  *      @regs: Registers (unused)
1302  *
1303  *
1304  *      An interrupt is raised whenever the 3c527 writes to the command
1305  *      register. This register contains the message it wishes to send us
1306  *      packed into a single byte field. We keep reading status entries
1307  *      until we have processed all the control items, but simply count
1308  *      transmit and receive reports. When all reports are in we empty the
1309  *      transceiver rings as appropriate. This saves the overhead of
1310  *      multiple command requests.
1311  *
1312  *      Because MCA is level-triggered, we shouldn't miss indications.
1313  *      Therefore, we needn't ask the card to suspend interrupts within
1314  *      this handler. The card receives an implicit acknowledgment of the
1315  *      current interrupt when we read the command register.
1316  *
1317  */
1318
1319 static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1320 {
1321         struct net_device *dev = dev_id;
1322         struct mc32_local *lp;
1323         int ioaddr, status, boguscount = 0;
1324         int rx_event = 0;
1325         int tx_event = 0; 
1326         
1327         if (dev == NULL) {
1328                 printk(KERN_WARNING "%s: irq %d for unknown device.\n", cardname, irq);
1329                 return IRQ_NONE;
1330         }
1331  
1332         ioaddr = dev->base_addr;
1333         lp = netdev_priv(dev);
1334
1335         /* See whats cooking */
1336
1337         while((inb(ioaddr+HOST_STATUS)&HOST_STATUS_CWR) && boguscount++<2000)
1338         {
1339                 status=inb(ioaddr+HOST_CMD);
1340
1341 #ifdef DEBUG_IRQ                
1342                 printk("Status TX%d RX%d EX%d OV%d BC%d\n",
1343                         (status&7), (status>>3)&7, (status>>6)&1,
1344                         (status>>7)&1, boguscount);
1345 #endif
1346                         
1347                 switch(status&7)
1348                 {
1349                         case 0:
1350                                 break;
1351                         case 6: /* TX fail */
1352                         case 2: /* TX ok */
1353                                 tx_event = 1; 
1354                                 break;
1355                         case 3: /* Halt */
1356                         case 4: /* Abort */
1357                                 complete(&lp->xceiver_cmd);
1358                                 break;
1359                         default:
1360                                 printk("%s: strange tx ack %d\n", dev->name, status&7);
1361                 }
1362                 status>>=3;
1363                 switch(status&7)
1364                 {
1365                         case 0:
1366                                 break;
1367                         case 2: /* RX */
1368                                 rx_event=1; 
1369                                 break;
1370                         case 3: /* Halt */
1371                         case 4: /* Abort */
1372                                 complete(&lp->xceiver_cmd);
1373                                 break;
1374                         case 6:
1375                                 /* Out of RX buffers stat */
1376                                 /* Must restart rx */
1377                                 lp->net_stats.rx_dropped++;
1378                                 mc32_rx_ring(dev); 
1379                                 mc32_start_transceiver(dev); 
1380                                 break;
1381                         default:
1382                                 printk("%s: strange rx ack %d\n", 
1383                                         dev->name, status&7);                   
1384                 }
1385                 status>>=3;
1386                 if(status&1)
1387                 {
1388                         /*
1389                          * No thread is waiting: we need to tidy
1390                          * up ourself.
1391                          */
1392                                    
1393                         if (lp->cmd_nonblocking) {
1394                                 up(&lp->cmd_mutex);
1395                                 if (lp->mc_reload_wait) 
1396                                         mc32_reset_multicast_list(dev);
1397                         }
1398                         else complete(&lp->execution_cmd);
1399                 }
1400                 if(status&2)
1401                 {
1402                         /*
1403                          *      We get interrupted once per
1404                          *      counter that is about to overflow. 
1405                          */
1406
1407                         mc32_update_stats(dev);                 
1408                 }
1409         }
1410
1411
1412         /*
1413          *      Process the transmit and receive rings 
1414          */
1415
1416         if(tx_event) 
1417                 mc32_tx_ring(dev);
1418          
1419         if(rx_event) 
1420                 mc32_rx_ring(dev);
1421
1422         return IRQ_HANDLED;
1423 }
1424
1425
1426 /**
1427  *      mc32_close      -       user configuring the 3c527 down
1428  *      @dev: 3c527 card to shut down
1429  *
1430  *      The 3c527 is a bus mastering device. We must be careful how we
1431  *      shut it down. It may also be running shared interrupt so we have
1432  *      to be sure to silence it properly
1433  *
1434  *      We indicate that the card is closing to the rest of the
1435  *      driver.  Otherwise, it is possible that the card may run out
1436  *      of receive buffers and restart the transceiver while we're
1437  *      trying to close it.
1438  * 
1439  *      We abort any receive and transmits going on and then wait until
1440  *      any pending exec commands have completed in other code threads.
1441  *      In theory we can't get here while that is true, in practice I am
1442  *      paranoid
1443  *
1444  *      We turn off the interrupt enable for the board to be sure it can't
1445  *      intefere with other devices.
1446  */
1447
1448 static int mc32_close(struct net_device *dev)
1449 {
1450         struct mc32_local *lp = netdev_priv(dev);
1451         int ioaddr = dev->base_addr;
1452
1453         u8 regs;
1454         u16 one=1;
1455         
1456         lp->xceiver_desired_state = HALTED;
1457         netif_stop_queue(dev);
1458
1459         /*
1460          *      Send the indications on command (handy debug check)
1461          */
1462
1463         mc32_command(dev, 4, &one, 2);
1464
1465         /* Shut down the transceiver */
1466
1467         mc32_halt_transceiver(dev); 
1468         
1469         /* Ensure we issue no more commands beyond this point */
1470
1471         down(&lp->cmd_mutex);
1472         
1473         /* Ok the card is now stopping */       
1474         
1475         regs=inb(ioaddr+HOST_CTRL);
1476         regs&=~HOST_CTRL_INTE;
1477         outb(regs, ioaddr+HOST_CTRL);
1478
1479         mc32_flush_rx_ring(dev);
1480         mc32_flush_tx_ring(dev);
1481                 
1482         mc32_update_stats(dev); 
1483
1484         return 0;
1485 }
1486
1487
1488 /**
1489  *      mc32_get_stats          -       hand back stats to network layer
1490  *      @dev: The 3c527 card to handle
1491  *
1492  *      We've collected all the stats we can in software already. Now
1493  *      it's time to update those kept on-card and return the lot. 
1494  * 
1495  */
1496
1497 static struct net_device_stats *mc32_get_stats(struct net_device *dev)
1498 {
1499         struct mc32_local *lp = netdev_priv(dev);
1500         
1501         mc32_update_stats(dev); 
1502         return &lp->net_stats;
1503 }
1504
1505
1506 /**
1507  *      do_mc32_set_multicast_list      -       attempt to update multicasts
1508  *      @dev: 3c527 device to load the list on
1509  *      @retry: indicates this is not the first call. 
1510  *
1511  *
1512  *      Actually set or clear the multicast filter for this adaptor. The
1513  *      locking issues are handled by this routine. We have to track
1514  *      state as it may take multiple calls to get the command sequence
1515  *      completed. We just keep trying to schedule the loads until we
1516  *      manage to process them all.
1517  * 
1518  *      num_addrs == -1 Promiscuous mode, receive all packets
1519  * 
1520  *      num_addrs == 0  Normal mode, clear multicast list
1521  * 
1522  *      num_addrs > 0   Multicast mode, receive normal and MC packets, 
1523  *                      and do best-effort filtering. 
1524  *
1525  *      See mc32_update_stats() regards setting the SAV BP bit. 
1526  *
1527  */
1528
1529 static void do_mc32_set_multicast_list(struct net_device *dev, int retry)
1530 {
1531         struct mc32_local *lp = netdev_priv(dev);
1532         u16 filt = (1<<2); /* Save Bad Packets, for stats purposes */ 
1533
1534         if (dev->flags&IFF_PROMISC)
1535                 /* Enable promiscuous mode */
1536                 filt |= 1;
1537         else if((dev->flags&IFF_ALLMULTI) || dev->mc_count > 10)
1538         {
1539                 dev->flags|=IFF_PROMISC;
1540                 filt |= 1;
1541         }
1542         else if(dev->mc_count)
1543         {
1544                 unsigned char block[62];
1545                 unsigned char *bp;
1546                 struct dev_mc_list *dmc=dev->mc_list;
1547                 
1548                 int i;
1549                
1550                 if(retry==0)
1551                         lp->mc_list_valid = 0;
1552                 if(!lp->mc_list_valid)
1553                 {
1554                         block[1]=0;
1555                         block[0]=dev->mc_count;
1556                         bp=block+2;
1557                 
1558                         for(i=0;i<dev->mc_count;i++)
1559                         {
1560                                 memcpy(bp, dmc->dmi_addr, 6);
1561                                 bp+=6;
1562                                 dmc=dmc->next;
1563                         }
1564                         if(mc32_command_nowait(dev, 2, block, 2+6*dev->mc_count)==-1)
1565                         {
1566                                 lp->mc_reload_wait = 1;
1567                                 return;
1568                         }
1569                         lp->mc_list_valid=1;
1570                 }
1571         }
1572         
1573         if(mc32_command_nowait(dev, 0, &filt, 2)==-1) 
1574         {
1575                 lp->mc_reload_wait = 1;
1576         } 
1577         else { 
1578                 lp->mc_reload_wait = 0;
1579         }
1580 }
1581
1582
1583 /**
1584  *      mc32_set_multicast_list -       queue multicast list update
1585  *      @dev: The 3c527 to use
1586  *
1587  *      Commence loading the multicast list. This is called when the kernel
1588  *      changes the lists. It will override any pending list we are trying to
1589  *      load.
1590  */
1591
1592 static void mc32_set_multicast_list(struct net_device *dev)
1593 {
1594         do_mc32_set_multicast_list(dev,0);
1595 }
1596
1597
1598 /**
1599  *      mc32_reset_multicast_list       -       reset multicast list
1600  *      @dev: The 3c527 to use
1601  *
1602  *      Attempt the next step in loading the multicast lists. If this attempt
1603  *      fails to complete then it will be scheduled and this function called
1604  *      again later from elsewhere.
1605  */
1606
1607 static void mc32_reset_multicast_list(struct net_device *dev)
1608 {
1609         do_mc32_set_multicast_list(dev,1);
1610 }
1611
1612 static void netdev_get_drvinfo(struct net_device *dev,
1613                                struct ethtool_drvinfo *info)
1614 {
1615         strcpy(info->driver, DRV_NAME);
1616         strcpy(info->version, DRV_VERSION);
1617         sprintf(info->bus_info, "MCA 0x%lx", dev->base_addr);
1618 }
1619
1620 static u32 netdev_get_msglevel(struct net_device *dev)
1621 {
1622         return mc32_debug;
1623 }
1624
1625 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1626 {
1627         mc32_debug = level;
1628 }
1629
1630 static struct ethtool_ops netdev_ethtool_ops = {
1631         .get_drvinfo            = netdev_get_drvinfo,
1632         .get_msglevel           = netdev_get_msglevel,
1633         .set_msglevel           = netdev_set_msglevel,
1634 };
1635
1636 #ifdef MODULE
1637
1638 static struct net_device *this_device;
1639
1640 /**
1641  *      init_module             -       entry point
1642  *
1643  *      Probe and locate a 3c527 card. This really should probe and locate
1644  *      all the 3c527 cards in the machine not just one of them. Yes you can
1645  *      insmod multiple modules for now but it's a hack.
1646  */
1647
1648 int __init init_module(void)
1649 {
1650         this_device = mc32_probe(-1);
1651         if (IS_ERR(this_device))
1652                 return PTR_ERR(this_device);
1653         return 0;
1654 }
1655
1656 /**
1657  *      cleanup_module  -       free resources for an unload
1658  *
1659  *      Unloading time. We release the MCA bus resources and the interrupt
1660  *      at which point everything is ready to unload. The card must be stopped
1661  *      at this point or we would not have been called. When we unload we
1662  *      leave the card stopped but not totally shut down. When the card is
1663  *      initialized it must be rebooted or the rings reloaded before any
1664  *      transmit operations are allowed to start scribbling into memory.
1665  */
1666
1667 void cleanup_module(void)
1668 {
1669         unregister_netdev(this_device);
1670         cleanup_card(this_device);
1671         free_netdev(this_device);
1672 }
1673
1674 #endif /* MODULE */