blob: 6aca0c640f13949ae2033cac47df4e1ba3b4783d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 3c527.c: 3Com Etherlink/MC32 driver for Linux 2.4 and 2.6.
2 *
3 * (c) Copyright 1998 Red Hat Software Inc
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004 * Written by Alan Cox.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * 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
24static const char *version =
25DRV_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 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -040033 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 *
37 * Setting the SAV BP bit does not save bad packets, but
Jeff Garzik6aa20a22006-09-13 13:24:59 -040038 * only enables RX on-card stats collection.
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 *
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.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040067 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 * 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040073 * implementation was made necessary --- see mc32_update_stats().
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 *
75 * DOC: Notes
Jeff Garzik6aa20a22006-09-13 13:24:59 -040076 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 * 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>
Matthew Wilcox6188e102008-04-18 22:21:05 -0400106#include <linux/semaphore.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108#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
115MODULE_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 */
121static 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
130static 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400135/* As implemented, values must be a power-of-2 -- 4/8/16/32 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136#define TX_RING_LEN 32 /* Typically the card supports 37 */
137#define RX_RING_LEN 8 /* " " " */
138
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400139/* Copy break point, see above for details.
140 * Setting to > 1512 effectively disables this feature. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141#define RX_COPYBREAK 200 /* Value from 3c59x.c */
142
143/* Issue the 82586 workaround command - this is for "busy lans", but
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400144 * basically means for all lans now days - has a performance (latency)
145 * cost, but best set. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146static const int WORKAROUND_82586=1;
147
148/* Pointers to buffers and their on-card records */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400149struct mc32_ring_desc
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400151 volatile struct skb_header *p;
152 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153};
154
155/* Information that needs to be kept for each board. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400156struct mc32_local
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
158 int slot;
159
160 u32 base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 volatile struct mc32_mailbox *rx_box;
162 volatile struct mc32_mailbox *tx_box;
163 volatile struct mc32_mailbox *exec_box;
164 volatile struct mc32_stats *stats; /* Start of on-card statistics */
165 u16 tx_chain; /* Transmit list start offset */
166 u16 rx_chain; /* Receive list start offset */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400167 u16 tx_len; /* Transmit list count */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 u16 rx_len; /* Receive list count */
169
170 u16 xceiver_desired_state; /* HALTED or RUNNING */
171 u16 cmd_nonblocking; /* Thread is uninterested in command result */
172 u16 mc_reload_wait; /* A multicast load request is pending */
173 u32 mc_list_valid; /* True when the mclist is set */
174
175 struct mc32_ring_desc tx_ring[TX_RING_LEN]; /* Host Transmit ring */
176 struct mc32_ring_desc rx_ring[RX_RING_LEN]; /* Host Receive ring */
177
178 atomic_t tx_count; /* buffers left */
179 atomic_t tx_ring_head; /* index to tx en-queue end */
180 u16 tx_ring_tail; /* index to tx de-queue end */
181
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400182 u16 rx_ring_tail; /* index to rx de-queue end */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
184 struct semaphore cmd_mutex; /* Serialises issuing of execute commands */
185 struct completion execution_cmd; /* Card has completed an execute command */
186 struct completion xceiver_cmd; /* Card has completed a tx or rx command */
187};
188
189/* The station (ethernet) address prefix, used for a sanity check. */
190#define SA_ADDR0 0x02
191#define SA_ADDR1 0x60
192#define SA_ADDR2 0xAC
193
194struct mca_adapters_t {
195 unsigned int id;
196 char *name;
197};
198
199static const struct mca_adapters_t mc32_adapters[] = {
200 { 0x0041, "3COM EtherLink MC/32" },
201 { 0x8EF5, "IBM High Performance Lan Adapter" },
202 { 0x0000, NULL }
203};
204
205
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400206/* Macros for ring index manipulations */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207static inline u16 next_rx(u16 rx) { return (rx+1)&(RX_RING_LEN-1); };
208static inline u16 prev_rx(u16 rx) { return (rx-1)&(RX_RING_LEN-1); };
209
210static inline u16 next_tx(u16 tx) { return (tx+1)&(TX_RING_LEN-1); };
211
212
213/* Index to functions, as function prototypes. */
214static int mc32_probe1(struct net_device *dev, int ioaddr);
215static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len);
216static int mc32_open(struct net_device *dev);
217static void mc32_timeout(struct net_device *dev);
218static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100219static irqreturn_t mc32_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220static int mc32_close(struct net_device *dev);
221static struct net_device_stats *mc32_get_stats(struct net_device *dev);
222static void mc32_set_multicast_list(struct net_device *dev);
223static void mc32_reset_multicast_list(struct net_device *dev);
Jeff Garzik7282d492006-09-13 14:30:00 -0400224static const struct ethtool_ops netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226static void cleanup_card(struct net_device *dev)
227{
228 struct mc32_local *lp = netdev_priv(dev);
229 unsigned slot = lp->slot;
230 mca_mark_as_unused(slot);
231 mca_set_adapter_name(slot, NULL);
232 free_irq(dev->irq, dev);
233 release_region(dev->base_addr, MC32_IO_EXTENT);
234}
235
236/**
237 * mc32_probe - Search for supported boards
238 * @unit: interface number to use
239 *
240 * Because MCA bus is a real bus and we can scan for cards we could do a
241 * single scan for all boards here. Right now we use the passed in device
242 * structure and scan for only one board. This needs fixing for modules
243 * in particular.
244 */
245
246struct net_device *__init mc32_probe(int unit)
247{
248 struct net_device *dev = alloc_etherdev(sizeof(struct mc32_local));
249 static int current_mca_slot = -1;
250 int i;
251 int err;
252
253 if (!dev)
254 return ERR_PTR(-ENOMEM);
255
256 if (unit >= 0)
257 sprintf(dev->name, "eth%d", unit);
258
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400259 /* Do not check any supplied i/o locations.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 POS registers usually don't fail :) */
261
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400262 /* MCA cards have POS registers.
263 Autodetecting MCA cards is extremely simple.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 Just search for the card. */
265
266 for(i = 0; (mc32_adapters[i].name != NULL); i++) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400267 current_mca_slot =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 mca_find_unused_adapter(mc32_adapters[i].id, 0);
269
270 if(current_mca_slot != MCA_NOTFOUND) {
271 if(!mc32_probe1(dev, current_mca_slot))
272 {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400273 mca_set_adapter_name(current_mca_slot,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 mc32_adapters[i].name);
275 mca_mark_as_used(current_mca_slot);
276 err = register_netdev(dev);
277 if (err) {
278 cleanup_card(dev);
279 free_netdev(dev);
280 dev = ERR_PTR(err);
281 }
282 return dev;
283 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400284
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 }
286 }
287 free_netdev(dev);
288 return ERR_PTR(-ENODEV);
289}
290
291/**
292 * mc32_probe1 - Check a given slot for a board and test the card
293 * @dev: Device structure to fill in
294 * @slot: The MCA bus slot being used by this card
295 *
296 * Decode the slot data and configure the card structures. Having done this we
297 * can reset the card and configure it. The card does a full self test cycle
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400298 * in firmware so we have to wait for it to return and post us either a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 * failure case or some addresses we use to find the board internals.
300 */
301
302static int __init mc32_probe1(struct net_device *dev, int slot)
303{
304 static unsigned version_printed;
305 int i, err;
306 u8 POS;
307 u32 base;
308 struct mc32_local *lp = netdev_priv(dev);
309 static u16 mca_io_bases[]={
310 0x7280,0x7290,
311 0x7680,0x7690,
312 0x7A80,0x7A90,
313 0x7E80,0x7E90
314 };
315 static u32 mca_mem_bases[]={
316 0x00C0000,
317 0x00C4000,
318 0x00C8000,
319 0x00CC000,
320 0x00D0000,
321 0x00D4000,
322 0x00D8000,
323 0x00DC000
324 };
325 static char *failures[]={
326 "Processor instruction",
327 "Processor data bus",
328 "Processor data bus",
329 "Processor data bus",
330 "Adapter bus",
331 "ROM checksum",
332 "Base RAM",
333 "Extended RAM",
334 "82586 internal loopback",
335 "82586 initialisation failure",
336 "Adapter list configuration error"
337 };
Joe Perches0795af52007-10-03 17:59:30 -0700338 DECLARE_MAC_BUF(mac);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
340 /* Time to play MCA games */
341
342 if (mc32_debug && version_printed++ == 0)
343 printk(KERN_DEBUG "%s", version);
344
345 printk(KERN_INFO "%s: %s found in slot %d:", dev->name, cardname, slot);
346
347 POS = mca_read_stored_pos(slot, 2);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 if(!(POS&1))
350 {
351 printk(" disabled.\n");
352 return -ENODEV;
353 }
354
355 /* Fill in the 'dev' fields. */
356 dev->base_addr = mca_io_bases[(POS>>1)&7];
357 dev->mem_start = mca_mem_bases[(POS>>4)&7];
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 POS = mca_read_stored_pos(slot, 4);
360 if(!(POS&1))
361 {
362 printk("memory window disabled.\n");
363 return -ENODEV;
364 }
365
366 POS = mca_read_stored_pos(slot, 5);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400367
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 i=(POS>>4)&3;
369 if(i==3)
370 {
371 printk("invalid memory window.\n");
372 return -ENODEV;
373 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 i*=16384;
376 i+=16384;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 dev->mem_end=dev->mem_start + i;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 dev->irq = ((POS>>2)&3)+9;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400381
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 if(!request_region(dev->base_addr, MC32_IO_EXTENT, cardname))
383 {
384 printk("io 0x%3lX, which is busy.\n", dev->base_addr);
385 return -EBUSY;
386 }
387
388 printk("io 0x%3lX irq %d mem 0x%lX (%dK)\n",
389 dev->base_addr, dev->irq, dev->mem_start, i/1024);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400390
391
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 /* We ought to set the cache line size here.. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400393
394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 /*
396 * Go PROM browsing
397 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 /* Retrieve and print the ethernet address. */
400 for (i = 0; i < 6; i++)
401 {
402 mca_write_pos(slot, 6, i+12);
403 mca_write_pos(slot, 7, 0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400404
Joe Perches0795af52007-10-03 17:59:30 -0700405 dev->dev_addr[i] = mca_read_pos(slot,3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 }
407
Joe Perches0795af52007-10-03 17:59:30 -0700408 printk("%s: Address %s", dev->name, print_mac(mac, dev->dev_addr));
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 mca_write_pos(slot, 6, 0);
411 mca_write_pos(slot, 7, 0);
412
413 POS = mca_read_stored_pos(slot, 4);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 if(POS&2)
416 printk(" : BNC port selected.\n");
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400417 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 printk(" : AUI port selected.\n");
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 POS=inb(dev->base_addr+HOST_CTRL);
421 POS|=HOST_CTRL_ATTN|HOST_CTRL_RESET;
422 POS&=~HOST_CTRL_INTE;
423 outb(POS, dev->base_addr+HOST_CTRL);
424 /* Reset adapter */
425 udelay(100);
426 /* Reset off */
427 POS&=~(HOST_CTRL_ATTN|HOST_CTRL_RESET);
428 outb(POS, dev->base_addr+HOST_CTRL);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400429
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 udelay(300);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 /*
433 * Grab the IRQ
434 */
435
Thomas Gleixner1fb9df52006-07-01 19:29:39 -0700436 err = request_irq(dev->irq, &mc32_interrupt, IRQF_SHARED | IRQF_SAMPLE_RANDOM, DRV_NAME, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 if (err) {
438 release_region(dev->base_addr, MC32_IO_EXTENT);
439 printk(KERN_ERR "%s: unable to get IRQ %d.\n", DRV_NAME, dev->irq);
440 goto err_exit_ports;
441 }
442
443 memset(lp, 0, sizeof(struct mc32_local));
444 lp->slot = slot;
445
446 i=0;
447
448 base = inb(dev->base_addr);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 while(base == 0xFF)
451 {
452 i++;
453 if(i == 1000)
454 {
455 printk(KERN_ERR "%s: failed to boot adapter.\n", dev->name);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400456 err = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 goto err_exit_irq;
458 }
459 udelay(1000);
460 if(inb(dev->base_addr+2)&(1<<5))
461 base = inb(dev->base_addr);
462 }
463
464 if(base>0)
465 {
466 if(base < 0x0C)
467 printk(KERN_ERR "%s: %s%s.\n", dev->name, failures[base-1],
468 base<0x0A?" test failure":"");
469 else
470 printk(KERN_ERR "%s: unknown failure %d.\n", dev->name, base);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400471 err = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 goto err_exit_irq;
473 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400474
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 base=0;
476 for(i=0;i<4;i++)
477 {
478 int n=0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 while(!(inb(dev->base_addr+2)&(1<<5)))
481 {
482 n++;
483 udelay(50);
484 if(n>100)
485 {
486 printk(KERN_ERR "%s: mailbox read fail (%d).\n", dev->name, i);
487 err = -ENODEV;
488 goto err_exit_irq;
489 }
490 }
491
492 base|=(inb(dev->base_addr)<<(8*i));
493 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400494
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 lp->exec_box=isa_bus_to_virt(dev->mem_start+base);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400496
497 base=lp->exec_box->data[1]<<16|lp->exec_box->data[0];
498
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 lp->base = dev->mem_start+base;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400500
501 lp->rx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[2]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 lp->tx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[3]);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400503
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 lp->stats = isa_bus_to_virt(lp->base + lp->exec_box->data[5]);
505
506 /*
507 * Descriptor chains (card relative)
508 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400509
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 lp->tx_chain = lp->exec_box->data[8]; /* Transmit list start offset */
511 lp->rx_chain = lp->exec_box->data[10]; /* Receive list start offset */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400512 lp->tx_len = lp->exec_box->data[9]; /* Transmit list count */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 lp->rx_len = lp->exec_box->data[11]; /* Receive list count */
514
515 init_MUTEX_LOCKED(&lp->cmd_mutex);
516 init_completion(&lp->execution_cmd);
517 init_completion(&lp->xceiver_cmd);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400518
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 printk("%s: Firmware Rev %d. %d RX buffers, %d TX buffers. Base of 0x%08X.\n",
520 dev->name, lp->exec_box->data[12], lp->rx_len, lp->tx_len, lp->base);
521
522 dev->open = mc32_open;
523 dev->stop = mc32_close;
524 dev->hard_start_xmit = mc32_send_packet;
525 dev->get_stats = mc32_get_stats;
526 dev->set_multicast_list = mc32_set_multicast_list;
527 dev->tx_timeout = mc32_timeout;
528 dev->watchdog_timeo = HZ*5; /* Board does all the work */
529 dev->ethtool_ops = &netdev_ethtool_ops;
530
531 return 0;
532
533err_exit_irq:
534 free_irq(dev->irq, dev);
535err_exit_ports:
536 release_region(dev->base_addr, MC32_IO_EXTENT);
537 return err;
538}
539
540
541/**
542 * mc32_ready_poll - wait until we can feed it a command
543 * @dev: The device to wait for
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400544 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 * Wait until the card becomes ready to accept a command via the
546 * command register. This tells us nothing about the completion
547 * status of any pending commands and takes very little time at all.
548 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550static inline void mc32_ready_poll(struct net_device *dev)
551{
552 int ioaddr = dev->base_addr;
553 while(!(inb(ioaddr+HOST_STATUS)&HOST_STATUS_CRR));
554}
555
556
557/**
558 * mc32_command_nowait - send a command non blocking
559 * @dev: The 3c527 to issue the command to
560 * @cmd: The command word to write to the mailbox
561 * @data: A data block if the command expects one
562 * @len: Length of the data block
563 *
564 * Send a command from interrupt state. If there is a command
565 * currently being executed then we return an error of -1. It
566 * simply isn't viable to wait around as commands may be
567 * slow. This can theoretically be starved on SMP, but it's hard
568 * to see a realistic situation. We do not wait for the command
569 * to complete --- we rely on the interrupt handler to tidy up
570 * after us.
571 */
572
573static int mc32_command_nowait(struct net_device *dev, u16 cmd, void *data, int len)
574{
575 struct mc32_local *lp = netdev_priv(dev);
576 int ioaddr = dev->base_addr;
577 int ret = -1;
578
579 if (down_trylock(&lp->cmd_mutex) == 0)
580 {
581 lp->cmd_nonblocking=1;
582 lp->exec_box->mbox=0;
583 lp->exec_box->mbox=cmd;
584 memcpy((void *)lp->exec_box->data, data, len);
585 barrier(); /* the memcpy forgot the volatile so be sure */
586
587 /* Send the command */
588 mc32_ready_poll(dev);
589 outb(1<<6, ioaddr+HOST_CMD);
590
591 ret = 0;
592
593 /* Interrupt handler will signal mutex on completion */
594 }
595
596 return ret;
597}
598
599
600/**
601 * mc32_command - send a command and sleep until completion
602 * @dev: The 3c527 card to issue the command to
603 * @cmd: The command word to write to the mailbox
604 * @data: A data block if the command expects one
605 * @len: Length of the data block
606 *
607 * Sends exec commands in a user context. This permits us to wait around
608 * for the replies and also to wait for the command buffer to complete
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400609 * from a previous command before we execute our command. After our
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 * command completes we will attempt any pending multicast reload
611 * we blocked off by hogging the exec buffer.
612 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400613 * You feed the card a command, you wait, it interrupts you get a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 * reply. All well and good. The complication arises because you use
615 * commands for filter list changes which come in at bh level from things
616 * like IPV6 group stuff.
617 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400618
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len)
620{
621 struct mc32_local *lp = netdev_priv(dev);
622 int ioaddr = dev->base_addr;
623 int ret = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 down(&lp->cmd_mutex);
626
627 /*
628 * My Turn
629 */
630
631 lp->cmd_nonblocking=0;
632 lp->exec_box->mbox=0;
633 lp->exec_box->mbox=cmd;
634 memcpy((void *)lp->exec_box->data, data, len);
635 barrier(); /* the memcpy forgot the volatile so be sure */
636
637 mc32_ready_poll(dev);
638 outb(1<<6, ioaddr+HOST_CMD);
639
640 wait_for_completion(&lp->execution_cmd);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400641
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 if(lp->exec_box->mbox&(1<<13))
643 ret = -1;
644
645 up(&lp->cmd_mutex);
646
647 /*
648 * A multicast set got blocked - try it now
649 */
650
651 if(lp->mc_reload_wait)
652 {
653 mc32_reset_multicast_list(dev);
654 }
655
656 return ret;
657}
658
659
660/**
661 * mc32_start_transceiver - tell board to restart tx/rx
662 * @dev: The 3c527 card to issue the command to
663 *
664 * This may be called from the interrupt state, where it is used
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400665 * to restart the rx ring if the card runs out of rx buffers.
666 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 * We must first check if it's ok to (re)start the transceiver. See
668 * mc32_close for details.
669 */
670
671static void mc32_start_transceiver(struct net_device *dev) {
672
673 struct mc32_local *lp = netdev_priv(dev);
674 int ioaddr = dev->base_addr;
675
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400676 /* Ignore RX overflow on device closure */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 if (lp->xceiver_desired_state==HALTED)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400678 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
680 /* Give the card the offset to the post-EOL-bit RX descriptor */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400681 mc32_ready_poll(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 lp->rx_box->mbox=0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400683 lp->rx_box->data[0]=lp->rx_ring[prev_rx(lp->rx_ring_tail)].p->next;
684 outb(HOST_CMD_START_RX, ioaddr+HOST_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400686 mc32_ready_poll(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 lp->tx_box->mbox=0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400688 outb(HOST_CMD_RESTRT_TX, ioaddr+HOST_CMD); /* card ignores this on RX restart */
689
690 /* We are not interrupted on start completion */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691}
692
693
694/**
695 * mc32_halt_transceiver - tell board to stop tx/rx
696 * @dev: The 3c527 card to issue the command to
697 *
698 * We issue the commands to halt the card's transceiver. In fact,
699 * after some experimenting we now simply tell the card to
700 * suspend. When issuing aborts occasionally odd things happened.
701 *
702 * We then sleep until the card has notified us that both rx and
703 * tx have been suspended.
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400704 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400706static void mc32_halt_transceiver(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
708 struct mc32_local *lp = netdev_priv(dev);
709 int ioaddr = dev->base_addr;
710
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400711 mc32_ready_poll(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 lp->rx_box->mbox=0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400713 outb(HOST_CMD_SUSPND_RX, ioaddr+HOST_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 wait_for_completion(&lp->xceiver_cmd);
715
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400716 mc32_ready_poll(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 lp->tx_box->mbox=0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400718 outb(HOST_CMD_SUSPND_TX, ioaddr+HOST_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 wait_for_completion(&lp->xceiver_cmd);
720}
721
722
723/**
724 * mc32_load_rx_ring - load the ring of receive buffers
725 * @dev: 3c527 to build the ring for
726 *
727 * This initalises the on-card and driver datastructures to
728 * the point where mc32_start_transceiver() can be called.
729 *
730 * The card sets up the receive ring for us. We are required to use the
731 * ring it provides, although the size of the ring is configurable.
732 *
733 * We allocate an sk_buff for each ring entry in turn and
734 * initalise its house-keeping info. At the same time, we read
735 * each 'next' pointer in our rx_ring array. This reduces slow
736 * shared-memory reads and makes it easy to access predecessor
737 * descriptors.
738 *
739 * We then set the end-of-list bit for the last entry so that the
740 * card will know when it has run out of buffers.
741 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400742
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743static int mc32_load_rx_ring(struct net_device *dev)
744{
745 struct mc32_local *lp = netdev_priv(dev);
746 int i;
747 u16 rx_base;
748 volatile struct skb_header *p;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 rx_base=lp->rx_chain;
751
752 for(i=0; i<RX_RING_LEN; i++) {
753 lp->rx_ring[i].skb=alloc_skb(1532, GFP_KERNEL);
754 if (lp->rx_ring[i].skb==NULL) {
755 for (;i>=0;i--)
756 kfree_skb(lp->rx_ring[i].skb);
757 return -ENOBUFS;
758 }
759 skb_reserve(lp->rx_ring[i].skb, 18);
760
761 p=isa_bus_to_virt(lp->base+rx_base);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 p->control=0;
764 p->data=isa_virt_to_bus(lp->rx_ring[i].skb->data);
765 p->status=0;
766 p->length=1532;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400767
768 lp->rx_ring[i].p=p;
769 rx_base=p->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 }
771
772 lp->rx_ring[i-1].p->control |= CONTROL_EOL;
773
774 lp->rx_ring_tail=0;
775
776 return 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400777}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
779
780/**
781 * mc32_flush_rx_ring - free the ring of receive buffers
782 * @lp: Local data of 3c527 to flush the rx ring of
783 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400784 * Free the buffer for each ring slot. This may be called
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 * before mc32_load_rx_ring(), eg. on error in mc32_open().
786 * Requires rx skb pointers to point to a valid skb, or NULL.
787 */
788
789static void mc32_flush_rx_ring(struct net_device *dev)
790{
791 struct mc32_local *lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400792 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400794 for(i=0; i < RX_RING_LEN; i++)
795 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 if (lp->rx_ring[i].skb) {
797 dev_kfree_skb(lp->rx_ring[i].skb);
798 lp->rx_ring[i].skb = NULL;
799 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400800 lp->rx_ring[i].p=NULL;
801 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802}
803
804
805/**
806 * mc32_load_tx_ring - load transmit ring
807 * @dev: The 3c527 card to issue the command to
808 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400809 * This sets up the host transmit data-structures.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 *
811 * First, we obtain from the card it's current postion in the tx
812 * ring, so that we will know where to begin transmitting
813 * packets.
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400814 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 * Then, we read the 'next' pointers from the on-card tx ring into
816 * our tx_ring array to reduce slow shared-mem reads. Finally, we
817 * intitalise the tx house keeping variables.
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400818 *
819 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820
821static void mc32_load_tx_ring(struct net_device *dev)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400822{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 struct mc32_local *lp = netdev_priv(dev);
824 volatile struct skb_header *p;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400825 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 u16 tx_base;
827
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400828 tx_base=lp->tx_box->data[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
830 for(i=0 ; i<TX_RING_LEN ; i++)
831 {
832 p=isa_bus_to_virt(lp->base+tx_base);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400833 lp->tx_ring[i].p=p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 lp->tx_ring[i].skb=NULL;
835
836 tx_base=p->next;
837 }
838
839 /* -1 so that tx_ring_head cannot "lap" tx_ring_tail */
840 /* see mc32_tx_ring */
841
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400842 atomic_set(&lp->tx_count, TX_RING_LEN-1);
843 atomic_set(&lp->tx_ring_head, 0);
844 lp->tx_ring_tail=0;
845}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846
847
848/**
849 * mc32_flush_tx_ring - free transmit ring
850 * @lp: Local data of 3c527 to flush the tx ring of
851 *
852 * If the ring is non-empty, zip over the it, freeing any
853 * allocated skb_buffs. The tx ring house-keeping variables are
854 * then reset. Requires rx skb pointers to point to a valid skb,
855 * or NULL.
856 */
857
858static void mc32_flush_tx_ring(struct net_device *dev)
859{
860 struct mc32_local *lp = netdev_priv(dev);
861 int i;
862
863 for (i=0; i < TX_RING_LEN; i++)
864 {
865 if (lp->tx_ring[i].skb)
866 {
867 dev_kfree_skb(lp->tx_ring[i].skb);
868 lp->tx_ring[i].skb = NULL;
869 }
870 }
871
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400872 atomic_set(&lp->tx_count, 0);
873 atomic_set(&lp->tx_ring_head, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 lp->tx_ring_tail=0;
875}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400876
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
878/**
879 * mc32_open - handle 'up' of card
880 * @dev: device to open
881 *
882 * The user is trying to bring the card into ready state. This requires
883 * a brief dialogue with the card. Firstly we enable interrupts and then
884 * 'indications'. Without these enabled the card doesn't bother telling
885 * us what it has done. This had me puzzled for a week.
886 *
887 * We configure the number of card descriptors, then load the network
888 * address and multicast filters. Turn on the workaround mode. This
889 * works around a bug in the 82586 - it asks the firmware to do
890 * so. It has a performance (latency) hit but is needed on busy
891 * [read most] lans. We load the ring with buffers then we kick it
892 * all off.
893 */
894
895static int mc32_open(struct net_device *dev)
896{
897 int ioaddr = dev->base_addr;
898 struct mc32_local *lp = netdev_priv(dev);
899 u8 one=1;
900 u8 regs;
901 u16 descnumbuffs[2] = {TX_RING_LEN, RX_RING_LEN};
902
903 /*
904 * Interrupts enabled
905 */
906
907 regs=inb(ioaddr+HOST_CTRL);
908 regs|=HOST_CTRL_INTE;
909 outb(regs, ioaddr+HOST_CTRL);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400910
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 /*
912 * Allow ourselves to issue commands
913 */
914
915 up(&lp->cmd_mutex);
916
917
918 /*
919 * Send the indications on command
920 */
921
922 mc32_command(dev, 4, &one, 2);
923
924 /*
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400925 * Poke it to make sure it's really dead.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 */
927
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400928 mc32_halt_transceiver(dev);
929 mc32_flush_tx_ring(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400931 /*
932 * Ask card to set up on-card descriptors to our spec
933 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400935 if(mc32_command(dev, 8, descnumbuffs, 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 printk("%s: %s rejected our buffer configuration!\n",
937 dev->name, cardname);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400938 mc32_close(dev);
939 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400941
942 /* Report new configuration */
943 mc32_command(dev, 6, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
945 lp->tx_chain = lp->exec_box->data[8]; /* Transmit list start offset */
946 lp->rx_chain = lp->exec_box->data[10]; /* Receive list start offset */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400947 lp->tx_len = lp->exec_box->data[9]; /* Transmit list count */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 lp->rx_len = lp->exec_box->data[11]; /* Receive list count */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 /* Set Network Address */
951 mc32_command(dev, 1, dev->dev_addr, 6);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400952
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 /* Set the filters */
954 mc32_set_multicast_list(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400955
956 if (WORKAROUND_82586) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 u16 zero_word=0;
958 mc32_command(dev, 0x0D, &zero_word, 2); /* 82586 bug workaround on */
959 }
960
961 mc32_load_tx_ring(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400962
963 if(mc32_load_rx_ring(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 {
965 mc32_close(dev);
966 return -ENOBUFS;
967 }
968
969 lp->xceiver_desired_state = RUNNING;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400970
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 /* And finally, set the ball rolling... */
972 mc32_start_transceiver(dev);
973
974 netif_start_queue(dev);
975
976 return 0;
977}
978
979
980/**
981 * mc32_timeout - handle a timeout from the network layer
982 * @dev: 3c527 that timed out
983 *
984 * Handle a timeout on transmit from the 3c527. This normally means
985 * bad things as the hardware handles cable timeouts and mess for
986 * us.
987 *
988 */
989
990static void mc32_timeout(struct net_device *dev)
991{
992 printk(KERN_WARNING "%s: transmit timed out?\n", dev->name);
993 /* Try to restart the adaptor. */
994 netif_wake_queue(dev);
995}
996
997
998/**
999 * mc32_send_packet - queue a frame for transmit
1000 * @skb: buffer to transmit
1001 * @dev: 3c527 to send it out of
1002 *
1003 * Transmit a buffer. This normally means throwing the buffer onto
1004 * the transmit queue as the queue is quite large. If the queue is
1005 * full then we set tx_busy and return. Once the interrupt handler
1006 * gets messages telling it to reclaim transmit queue entries, we will
1007 * clear tx_busy and the kernel will start calling this again.
1008 *
1009 * We do not disable interrupts or acquire any locks; this can
1010 * run concurrently with mc32_tx_ring(), and the function itself
1011 * is serialised at a higher layer. However, similarly for the
1012 * card itself, we must ensure that we update tx_ring_head only
1013 * after we've established a valid packet on the tx ring (and
1014 * before we let the card "see" it, to prevent it racing with the
1015 * irq handler).
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001016 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 */
1018
1019static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev)
1020{
1021 struct mc32_local *lp = netdev_priv(dev);
1022 u32 head = atomic_read(&lp->tx_ring_head);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001023
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 volatile struct skb_header *p, *np;
1025
1026 netif_stop_queue(dev);
1027
1028 if(atomic_read(&lp->tx_count)==0) {
1029 return 1;
1030 }
1031
Herbert Xu5b057c62006-06-23 02:06:41 -07001032 if (skb_padto(skb, ETH_ZLEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 netif_wake_queue(dev);
1034 return 0;
1035 }
1036
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001037 atomic_dec(&lp->tx_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
1039 /* P is the last sending/sent buffer as a pointer */
1040 p=lp->tx_ring[head].p;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001041
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 head = next_tx(head);
1043
1044 /* NP is the buffer we will be loading */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001045 np=lp->tx_ring[head].p;
1046
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 /* We will need this to flush the buffer out */
1048 lp->tx_ring[head].skb=skb;
1049
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001050 np->length = unlikely(skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 np->data = isa_virt_to_bus(skb->data);
1052 np->status = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001053 np->control = CONTROL_EOP | CONTROL_EOL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 wmb();
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001055
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 /*
1057 * The new frame has been setup; we can now
1058 * let the interrupt handler and card "see" it
1059 */
1060
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001061 atomic_set(&lp->tx_ring_head, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 p->control &= ~CONTROL_EOL;
1063
1064 netif_wake_queue(dev);
1065 return 0;
1066}
1067
1068
1069/**
1070 * mc32_update_stats - pull off the on board statistics
1071 * @dev: 3c527 to service
1072 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001073 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 * Query and reset the on-card stats. There's the small possibility
1075 * of a race here, which would result in an underestimation of
1076 * actual errors. As such, we'd prefer to keep all our stats
1077 * collection in software. As a rule, we do. However it can't be
1078 * used for rx errors and collisions as, by default, the card discards
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001079 * bad rx packets.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 *
1081 * Setting the SAV BP in the rx filter command supposedly
1082 * stops this behaviour. However, testing shows that it only seems to
1083 * enable the collation of on-card rx statistics --- the driver
1084 * never sees an RX descriptor with an error status set.
1085 *
1086 */
1087
1088static void mc32_update_stats(struct net_device *dev)
1089{
1090 struct mc32_local *lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001091 volatile struct mc32_stats *st = lp->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001093 u32 rx_errors=0;
1094
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001095 rx_errors+=dev->stats.rx_crc_errors +=st->rx_crc_errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 st->rx_crc_errors=0;
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001097 rx_errors+=dev->stats.rx_fifo_errors +=st->rx_overrun_errors;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001098 st->rx_overrun_errors=0;
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001099 rx_errors+=dev->stats.rx_frame_errors +=st->rx_alignment_errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 st->rx_alignment_errors=0;
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001101 rx_errors+=dev->stats.rx_length_errors+=st->rx_tooshort_errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 st->rx_tooshort_errors=0;
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001103 rx_errors+=dev->stats.rx_missed_errors+=st->rx_outofresource_errors;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001104 st->rx_outofresource_errors=0;
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001105 dev->stats.rx_errors=rx_errors;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001106
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 /* Number of packets which saw one collision */
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001108 dev->stats.collisions+=st->dataC[10];
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001109 st->dataC[10]=0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001111 /* Number of packets which saw 2--15 collisions */
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001112 dev->stats.collisions+=st->dataC[11];
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001113 st->dataC[11]=0;
1114}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
1116
1117/**
1118 * mc32_rx_ring - process the receive ring
1119 * @dev: 3c527 that needs its receive ring processing
1120 *
1121 *
1122 * We have received one or more indications from the card that a
1123 * receive has completed. The buffer ring thus contains dirty
1124 * entries. We walk the ring by iterating over the circular rx_ring
1125 * array, starting at the next dirty buffer (which happens to be the
1126 * one we finished up at last time around).
1127 *
1128 * For each completed packet, we will either copy it and pass it up
1129 * the stack or, if the packet is near MTU sized, we allocate
1130 * another buffer and flip the old one up the stack.
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001131 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 * We must succeed in keeping a buffer on the ring. If necessary we
1133 * will toss a received packet rather than lose a ring entry. Once
1134 * the first uncompleted descriptor is found, we move the
1135 * End-Of-List bit to include the buffers just processed.
1136 *
1137 */
1138
1139static void mc32_rx_ring(struct net_device *dev)
1140{
1141 struct mc32_local *lp = netdev_priv(dev);
1142 volatile struct skb_header *p;
1143 u16 rx_ring_tail;
1144 u16 rx_old_tail;
1145 int x=0;
1146
1147 rx_old_tail = rx_ring_tail = lp->rx_ring_tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001149 do
1150 {
1151 p=lp->rx_ring[rx_ring_tail].p;
1152
1153 if(!(p->status & (1<<7))) { /* Not COMPLETED */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 break;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001155 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 if(p->status & (1<<6)) /* COMPLETED_OK */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001157 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
1159 u16 length=p->length;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001160 struct sk_buff *skb;
1161 struct sk_buff *newskb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
1163 /* Try to save time by avoiding a copy on big frames */
1164
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001165 if ((length > RX_COPYBREAK)
1166 && ((newskb=dev_alloc_skb(1532)) != NULL))
1167 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 skb=lp->rx_ring[rx_ring_tail].skb;
1169 skb_put(skb, length);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001170
1171 skb_reserve(newskb,18);
1172 lp->rx_ring[rx_ring_tail].skb=newskb;
1173 p->data=isa_virt_to_bus(newskb->data);
1174 }
1175 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001177 skb=dev_alloc_skb(length+2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
1179 if(skb==NULL) {
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001180 dev->stats.rx_dropped++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001181 goto dropped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 }
1183
1184 skb_reserve(skb,2);
1185 memcpy(skb_put(skb, length),
1186 lp->rx_ring[rx_ring_tail].skb->data, length);
1187 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001188
1189 skb->protocol=eth_type_trans(skb,dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 dev->last_rx = jiffies;
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001191 dev->stats.rx_packets++;
1192 dev->stats.rx_bytes += length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 netif_rx(skb);
1194 }
1195
1196 dropped:
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001197 p->length = 1532;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 p->status = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001199
1200 rx_ring_tail=next_rx(rx_ring_tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001202 while(x++<48);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001204 /* If there was actually a frame to be processed, place the EOL bit */
1205 /* at the descriptor prior to the one to be filled next */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001207 if (rx_ring_tail != rx_old_tail)
1208 {
1209 lp->rx_ring[prev_rx(rx_ring_tail)].p->control |= CONTROL_EOL;
1210 lp->rx_ring[prev_rx(rx_old_tail)].p->control &= ~CONTROL_EOL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001212 lp->rx_ring_tail=rx_ring_tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 }
1214}
1215
1216
1217/**
1218 * mc32_tx_ring - process completed transmits
1219 * @dev: 3c527 that needs its transmit ring processing
1220 *
1221 *
1222 * This operates in a similar fashion to mc32_rx_ring. We iterate
1223 * over the transmit ring. For each descriptor which has been
1224 * processed by the card, we free its associated buffer and note
1225 * any errors. This continues until the transmit ring is emptied
1226 * or we reach a descriptor that hasn't yet been processed by the
1227 * card.
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001228 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 */
1230
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001231static void mc32_tx_ring(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232{
1233 struct mc32_local *lp = netdev_priv(dev);
1234 volatile struct skb_header *np;
1235
1236 /*
1237 * We rely on head==tail to mean 'queue empty'.
1238 * This is why lp->tx_count=TX_RING_LEN-1: in order to prevent
1239 * tx_ring_head wrapping to tail and confusing a 'queue empty'
1240 * condition with 'queue full'
1241 */
1242
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001243 while (lp->tx_ring_tail != atomic_read(&lp->tx_ring_head))
1244 {
1245 u16 t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001247 t=next_tx(lp->tx_ring_tail);
1248 np=lp->tx_ring[t].p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001250 if(!(np->status & (1<<7)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001252 /* Not COMPLETED */
1253 break;
1254 }
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001255 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 if(!(np->status & (1<<6))) /* Not COMPLETED_OK */
1257 {
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001258 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
1260 switch(np->status&0x0F)
1261 {
1262 case 1:
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001263 dev->stats.tx_aborted_errors++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001264 break; /* Max collisions */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 case 2:
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001266 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 break;
1268 case 3:
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001269 dev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 break;
1271 case 4:
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001272 dev->stats.tx_window_errors++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001273 break; /* CTS Lost */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 case 5:
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001275 dev->stats.tx_aborted_errors++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001276 break; /* Transmit timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 }
1278 }
1279 /* Packets are sent in order - this is
1280 basically a FIFO queue of buffers matching
1281 the card ring */
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001282 dev->stats.tx_bytes+=lp->tx_ring[t].skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 dev_kfree_skb_irq(lp->tx_ring[t].skb);
1284 lp->tx_ring[t].skb=NULL;
1285 atomic_inc(&lp->tx_count);
1286 netif_wake_queue(dev);
1287
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001288 lp->tx_ring_tail=t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 }
1290
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001291}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292
1293
1294/**
1295 * mc32_interrupt - handle an interrupt from a 3c527
1296 * @irq: Interrupt number
1297 * @dev_id: 3c527 that requires servicing
1298 * @regs: Registers (unused)
1299 *
1300 *
1301 * An interrupt is raised whenever the 3c527 writes to the command
1302 * register. This register contains the message it wishes to send us
1303 * packed into a single byte field. We keep reading status entries
1304 * until we have processed all the control items, but simply count
1305 * transmit and receive reports. When all reports are in we empty the
1306 * transceiver rings as appropriate. This saves the overhead of
1307 * multiple command requests.
1308 *
1309 * Because MCA is level-triggered, we shouldn't miss indications.
1310 * Therefore, we needn't ask the card to suspend interrupts within
1311 * this handler. The card receives an implicit acknowledgment of the
1312 * current interrupt when we read the command register.
1313 *
1314 */
1315
David Howells7d12e782006-10-05 14:55:46 +01001316static irqreturn_t mc32_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317{
1318 struct net_device *dev = dev_id;
1319 struct mc32_local *lp;
1320 int ioaddr, status, boguscount = 0;
1321 int rx_event = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001322 int tx_event = 0;
1323
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 ioaddr = dev->base_addr;
1325 lp = netdev_priv(dev);
1326
1327 /* See whats cooking */
1328
1329 while((inb(ioaddr+HOST_STATUS)&HOST_STATUS_CWR) && boguscount++<2000)
1330 {
1331 status=inb(ioaddr+HOST_CMD);
1332
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001333#ifdef DEBUG_IRQ
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 printk("Status TX%d RX%d EX%d OV%d BC%d\n",
1335 (status&7), (status>>3)&7, (status>>6)&1,
1336 (status>>7)&1, boguscount);
1337#endif
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001338
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 switch(status&7)
1340 {
1341 case 0:
1342 break;
1343 case 6: /* TX fail */
1344 case 2: /* TX ok */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001345 tx_event = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 break;
1347 case 3: /* Halt */
1348 case 4: /* Abort */
1349 complete(&lp->xceiver_cmd);
1350 break;
1351 default:
1352 printk("%s: strange tx ack %d\n", dev->name, status&7);
1353 }
1354 status>>=3;
1355 switch(status&7)
1356 {
1357 case 0:
1358 break;
1359 case 2: /* RX */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001360 rx_event=1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 break;
1362 case 3: /* Halt */
1363 case 4: /* Abort */
1364 complete(&lp->xceiver_cmd);
1365 break;
1366 case 6:
1367 /* Out of RX buffers stat */
1368 /* Must restart rx */
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001369 dev->stats.rx_dropped++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001370 mc32_rx_ring(dev);
1371 mc32_start_transceiver(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 break;
1373 default:
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001374 printk("%s: strange rx ack %d\n",
1375 dev->name, status&7);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 }
1377 status>>=3;
1378 if(status&1)
1379 {
1380 /*
1381 * No thread is waiting: we need to tidy
1382 * up ourself.
1383 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001384
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 if (lp->cmd_nonblocking) {
1386 up(&lp->cmd_mutex);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001387 if (lp->mc_reload_wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 mc32_reset_multicast_list(dev);
1389 }
1390 else complete(&lp->execution_cmd);
1391 }
1392 if(status&2)
1393 {
1394 /*
1395 * We get interrupted once per
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001396 * counter that is about to overflow.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 */
1398
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001399 mc32_update_stats(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 }
1401 }
1402
1403
1404 /*
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001405 * Process the transmit and receive rings
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 */
1407
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001408 if(tx_event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 mc32_tx_ring(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001410
1411 if(rx_event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 mc32_rx_ring(dev);
1413
1414 return IRQ_HANDLED;
1415}
1416
1417
1418/**
1419 * mc32_close - user configuring the 3c527 down
1420 * @dev: 3c527 card to shut down
1421 *
1422 * The 3c527 is a bus mastering device. We must be careful how we
1423 * shut it down. It may also be running shared interrupt so we have
1424 * to be sure to silence it properly
1425 *
1426 * We indicate that the card is closing to the rest of the
1427 * driver. Otherwise, it is possible that the card may run out
1428 * of receive buffers and restart the transceiver while we're
1429 * trying to close it.
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001430 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 * We abort any receive and transmits going on and then wait until
1432 * any pending exec commands have completed in other code threads.
1433 * In theory we can't get here while that is true, in practice I am
1434 * paranoid
1435 *
1436 * We turn off the interrupt enable for the board to be sure it can't
1437 * intefere with other devices.
1438 */
1439
1440static int mc32_close(struct net_device *dev)
1441{
1442 struct mc32_local *lp = netdev_priv(dev);
1443 int ioaddr = dev->base_addr;
1444
1445 u8 regs;
1446 u16 one=1;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 lp->xceiver_desired_state = HALTED;
1449 netif_stop_queue(dev);
1450
1451 /*
1452 * Send the indications on command (handy debug check)
1453 */
1454
1455 mc32_command(dev, 4, &one, 2);
1456
1457 /* Shut down the transceiver */
1458
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001459 mc32_halt_transceiver(dev);
1460
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 /* Ensure we issue no more commands beyond this point */
1462
1463 down(&lp->cmd_mutex);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001464
1465 /* Ok the card is now stopping */
1466
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 regs=inb(ioaddr+HOST_CTRL);
1468 regs&=~HOST_CTRL_INTE;
1469 outb(regs, ioaddr+HOST_CTRL);
1470
1471 mc32_flush_rx_ring(dev);
1472 mc32_flush_tx_ring(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001473
1474 mc32_update_stats(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475
1476 return 0;
1477}
1478
1479
1480/**
1481 * mc32_get_stats - hand back stats to network layer
1482 * @dev: The 3c527 card to handle
1483 *
1484 * We've collected all the stats we can in software already. Now
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001485 * it's time to update those kept on-card and return the lot.
1486 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 */
1488
1489static struct net_device_stats *mc32_get_stats(struct net_device *dev)
1490{
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001491 mc32_update_stats(dev);
Paulius Zaleckas4711c842008-04-29 12:09:38 +03001492 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493}
1494
1495
1496/**
1497 * do_mc32_set_multicast_list - attempt to update multicasts
1498 * @dev: 3c527 device to load the list on
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001499 * @retry: indicates this is not the first call.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 *
1501 *
1502 * Actually set or clear the multicast filter for this adaptor. The
1503 * locking issues are handled by this routine. We have to track
1504 * state as it may take multiple calls to get the command sequence
1505 * completed. We just keep trying to schedule the loads until we
1506 * manage to process them all.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001508 * num_addrs == -1 Promiscuous mode, receive all packets
1509 *
1510 * num_addrs == 0 Normal mode, clear multicast list
1511 *
1512 * num_addrs > 0 Multicast mode, receive normal and MC packets,
1513 * and do best-effort filtering.
1514 *
1515 * See mc32_update_stats() regards setting the SAV BP bit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 *
1517 */
1518
1519static void do_mc32_set_multicast_list(struct net_device *dev, int retry)
1520{
1521 struct mc32_local *lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001522 u16 filt = (1<<2); /* Save Bad Packets, for stats purposes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523
1524 if (dev->flags&IFF_PROMISC)
1525 /* Enable promiscuous mode */
1526 filt |= 1;
1527 else if((dev->flags&IFF_ALLMULTI) || dev->mc_count > 10)
1528 {
1529 dev->flags|=IFF_PROMISC;
1530 filt |= 1;
1531 }
1532 else if(dev->mc_count)
1533 {
1534 unsigned char block[62];
1535 unsigned char *bp;
1536 struct dev_mc_list *dmc=dev->mc_list;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001537
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 int i;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001539
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 if(retry==0)
1541 lp->mc_list_valid = 0;
1542 if(!lp->mc_list_valid)
1543 {
1544 block[1]=0;
1545 block[0]=dev->mc_count;
1546 bp=block+2;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001547
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 for(i=0;i<dev->mc_count;i++)
1549 {
1550 memcpy(bp, dmc->dmi_addr, 6);
1551 bp+=6;
1552 dmc=dmc->next;
1553 }
1554 if(mc32_command_nowait(dev, 2, block, 2+6*dev->mc_count)==-1)
1555 {
1556 lp->mc_reload_wait = 1;
1557 return;
1558 }
1559 lp->mc_list_valid=1;
1560 }
1561 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001562
1563 if(mc32_command_nowait(dev, 0, &filt, 2)==-1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 {
1565 lp->mc_reload_wait = 1;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001566 }
1567 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 lp->mc_reload_wait = 0;
1569 }
1570}
1571
1572
1573/**
1574 * mc32_set_multicast_list - queue multicast list update
1575 * @dev: The 3c527 to use
1576 *
1577 * Commence loading the multicast list. This is called when the kernel
1578 * changes the lists. It will override any pending list we are trying to
1579 * load.
1580 */
1581
1582static void mc32_set_multicast_list(struct net_device *dev)
1583{
1584 do_mc32_set_multicast_list(dev,0);
1585}
1586
1587
1588/**
1589 * mc32_reset_multicast_list - reset multicast list
1590 * @dev: The 3c527 to use
1591 *
1592 * Attempt the next step in loading the multicast lists. If this attempt
1593 * fails to complete then it will be scheduled and this function called
1594 * again later from elsewhere.
1595 */
1596
1597static void mc32_reset_multicast_list(struct net_device *dev)
1598{
1599 do_mc32_set_multicast_list(dev,1);
1600}
1601
1602static void netdev_get_drvinfo(struct net_device *dev,
1603 struct ethtool_drvinfo *info)
1604{
1605 strcpy(info->driver, DRV_NAME);
1606 strcpy(info->version, DRV_VERSION);
1607 sprintf(info->bus_info, "MCA 0x%lx", dev->base_addr);
1608}
1609
1610static u32 netdev_get_msglevel(struct net_device *dev)
1611{
1612 return mc32_debug;
1613}
1614
1615static void netdev_set_msglevel(struct net_device *dev, u32 level)
1616{
1617 mc32_debug = level;
1618}
1619
Jeff Garzik7282d492006-09-13 14:30:00 -04001620static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 .get_drvinfo = netdev_get_drvinfo,
1622 .get_msglevel = netdev_get_msglevel,
1623 .set_msglevel = netdev_set_msglevel,
1624};
1625
1626#ifdef MODULE
1627
1628static struct net_device *this_device;
1629
1630/**
1631 * init_module - entry point
1632 *
1633 * Probe and locate a 3c527 card. This really should probe and locate
1634 * all the 3c527 cards in the machine not just one of them. Yes you can
1635 * insmod multiple modules for now but it's a hack.
1636 */
1637
Randy Dunlap96e672c2006-06-10 13:33:48 -07001638int __init init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639{
1640 this_device = mc32_probe(-1);
1641 if (IS_ERR(this_device))
1642 return PTR_ERR(this_device);
1643 return 0;
1644}
1645
1646/**
1647 * cleanup_module - free resources for an unload
1648 *
1649 * Unloading time. We release the MCA bus resources and the interrupt
1650 * at which point everything is ready to unload. The card must be stopped
1651 * at this point or we would not have been called. When we unload we
1652 * leave the card stopped but not totally shut down. When the card is
1653 * initialized it must be rebooted or the rings reloaded before any
1654 * transmit operations are allowed to start scribbling into memory.
1655 */
1656
Al Viroafc8eb42006-06-14 18:50:53 -04001657void __exit cleanup_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658{
1659 unregister_netdev(this_device);
1660 cleanup_card(this_device);
1661 free_netdev(this_device);
1662}
1663
1664#endif /* MODULE */