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