ia64/linux-2.6.18-xen.hg

view drivers/net/3c507.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /* 3c507.c: An EtherLink16 device driver for Linux. */
2 /*
3 Written 1993,1994 by Donald Becker.
5 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency.
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
11 The author may be reached as becker@scyld.com, or C/O
12 Scyld Computing Corporation
13 410 Severn Ave., Suite 210
14 Annapolis MD 21403
17 Thanks go to jennings@Montrouge.SMR.slb.com ( Patrick Jennings)
18 and jrs@world.std.com (Rick Sladkey) for testing and bugfixes.
19 Mark Salazar <leslie@access.digex.net> made the changes for cards with
20 only 16K packet buffers.
22 Things remaining to do:
23 Verify that the tx and rx buffers don't have fencepost errors.
24 Move the theory of operation and memory map documentation.
25 The statistics need to be updated correctly.
26 */
28 #define DRV_NAME "3c507"
29 #define DRV_VERSION "1.10a"
30 #define DRV_RELDATE "11/17/2001"
32 static const char version[] =
33 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Donald Becker (becker@scyld.com)\n";
35 /*
36 Sources:
37 This driver wouldn't have been written with the availability of the
38 Crynwr driver source code. It provided a known-working implementation
39 that filled in the gaping holes of the Intel documentation. Three cheers
40 for Russ Nelson.
42 Intel Microcommunications Databook, Vol. 1, 1990. It provides just enough
43 info that the casual reader might think that it documents the i82586 :-<.
44 */
46 #include <linux/module.h>
47 #include <linux/kernel.h>
48 #include <linux/types.h>
49 #include <linux/fcntl.h>
50 #include <linux/interrupt.h>
51 #include <linux/ioport.h>
52 #include <linux/in.h>
53 #include <linux/string.h>
54 #include <linux/spinlock.h>
55 #include <linux/ethtool.h>
56 #include <linux/errno.h>
57 #include <linux/netdevice.h>
58 #include <linux/etherdevice.h>
59 #include <linux/skbuff.h>
60 #include <linux/slab.h>
61 #include <linux/init.h>
62 #include <linux/bitops.h>
64 #include <asm/dma.h>
65 #include <asm/io.h>
66 #include <asm/system.h>
67 #include <asm/uaccess.h>
69 /* use 0 for production, 1 for verification, 2..7 for debug */
70 #ifndef NET_DEBUG
71 #define NET_DEBUG 1
72 #endif
73 static unsigned int net_debug = NET_DEBUG;
74 #define debug net_debug
77 /*
78 Details of the i82586.
80 You'll really need the databook to understand the details of this part,
81 but the outline is that the i82586 has two separate processing units.
82 Both are started from a list of three configuration tables, of which only
83 the last, the System Control Block (SCB), is used after reset-time. The SCB
84 has the following fields:
85 Status word
86 Command word
87 Tx/Command block addr.
88 Rx block addr.
89 The command word accepts the following controls for the Tx and Rx units:
90 */
92 #define CUC_START 0x0100
93 #define CUC_RESUME 0x0200
94 #define CUC_SUSPEND 0x0300
95 #define RX_START 0x0010
96 #define RX_RESUME 0x0020
97 #define RX_SUSPEND 0x0030
99 /* The Rx unit uses a list of frame descriptors and a list of data buffer
100 descriptors. We use full-sized (1518 byte) data buffers, so there is
101 a one-to-one pairing of frame descriptors to buffer descriptors.
103 The Tx ("command") unit executes a list of commands that look like:
104 Status word Written by the 82586 when the command is done.
105 Command word Command in lower 3 bits, post-command action in upper 3
106 Link word The address of the next command.
107 Parameters (as needed).
109 Some definitions related to the Command Word are:
110 */
111 #define CMD_EOL 0x8000 /* The last command of the list, stop. */
112 #define CMD_SUSP 0x4000 /* Suspend after doing cmd. */
113 #define CMD_INTR 0x2000 /* Interrupt after doing cmd. */
115 enum commands {
116 CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
117 CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7};
119 /* Information that need to be kept for each board. */
120 struct net_local {
121 struct net_device_stats stats;
122 int last_restart;
123 ushort rx_head;
124 ushort rx_tail;
125 ushort tx_head;
126 ushort tx_cmd_link;
127 ushort tx_reap;
128 ushort tx_pkts_in_ring;
129 spinlock_t lock;
130 void __iomem *base;
131 };
133 /*
134 Details of the EtherLink16 Implementation
135 The 3c507 is a generic shared-memory i82586 implementation.
136 The host can map 16K, 32K, 48K, or 64K of the 64K memory into
137 0x0[CD][08]0000, or all 64K into 0xF[02468]0000.
138 */
140 /* Offsets from the base I/O address. */
141 #define SA_DATA 0 /* Station address data, or 3Com signature. */
142 #define MISC_CTRL 6 /* Switch the SA_DATA banks, and bus config bits. */
143 #define RESET_IRQ 10 /* Reset the latched IRQ line. */
144 #define SIGNAL_CA 11 /* Frob the 82586 Channel Attention line. */
145 #define ROM_CONFIG 13
146 #define MEM_CONFIG 14
147 #define IRQ_CONFIG 15
148 #define EL16_IO_EXTENT 16
150 /* The ID port is used at boot-time to locate the ethercard. */
151 #define ID_PORT 0x100
153 /* Offsets to registers in the mailbox (SCB). */
154 #define iSCB_STATUS 0x8
155 #define iSCB_CMD 0xA
156 #define iSCB_CBL 0xC /* Command BLock offset. */
157 #define iSCB_RFA 0xE /* Rx Frame Area offset. */
159 /* Since the 3c507 maps the shared memory window so that the last byte is
160 at 82586 address FFFF, the first byte is at 82586 address 0, 16K, 32K, or
161 48K corresponding to window sizes of 64K, 48K, 32K and 16K respectively.
162 We can account for this be setting the 'SBC Base' entry in the ISCP table
163 below for all the 16 bit offset addresses, and also adding the 'SCB Base'
164 value to all 24 bit physical addresses (in the SCP table and the TX and RX
165 Buffer Descriptors).
166 -Mark
167 */
168 #define SCB_BASE ((unsigned)64*1024 - (dev->mem_end - dev->mem_start))
170 /*
171 What follows in 'init_words[]' is the "program" that is downloaded to the
172 82586 memory. It's mostly tables and command blocks, and starts at the
173 reset address 0xfffff6. This is designed to be similar to the EtherExpress,
174 thus the unusual location of the SCB at 0x0008.
176 Even with the additional "don't care" values, doing it this way takes less
177 program space than initializing the individual tables, and I feel it's much
178 cleaner.
180 The databook is particularly useless for the first two structures, I had
181 to use the Crynwr driver as an example.
183 The memory setup is as follows:
184 */
186 #define CONFIG_CMD 0x0018
187 #define SET_SA_CMD 0x0024
188 #define SA_OFFSET 0x002A
189 #define IDLELOOP 0x30
190 #define TDR_CMD 0x38
191 #define TDR_TIME 0x3C
192 #define DUMP_CMD 0x40
193 #define DIAG_CMD 0x48
194 #define SET_MC_CMD 0x4E
195 #define DUMP_DATA 0x56 /* A 170 byte buffer for dump and Set-MC into. */
197 #define TX_BUF_START 0x0100
198 #define NUM_TX_BUFS 5
199 #define TX_BUF_SIZE (1518+14+20+16) /* packet+header+TBD */
201 #define RX_BUF_START 0x2000
202 #define RX_BUF_SIZE (1518+14+18) /* packet+header+RBD */
203 #define RX_BUF_END (dev->mem_end - dev->mem_start)
205 #define TX_TIMEOUT 5
207 /*
208 That's it: only 86 bytes to set up the beast, including every extra
209 command available. The 170 byte buffer at DUMP_DATA is shared between the
210 Dump command (called only by the diagnostic program) and the SetMulticastList
211 command.
213 To complete the memory setup you only have to write the station address at
214 SA_OFFSET and create the Tx & Rx buffer lists.
216 The Tx command chain and buffer list is setup as follows:
217 A Tx command table, with the data buffer pointing to...
218 A Tx data buffer descriptor. The packet is in a single buffer, rather than
219 chaining together several smaller buffers.
220 A NoOp command, which initially points to itself,
221 And the packet data.
223 A transmit is done by filling in the Tx command table and data buffer,
224 re-writing the NoOp command, and finally changing the offset of the last
225 command to point to the current Tx command. When the Tx command is finished,
226 it jumps to the NoOp, when it loops until the next Tx command changes the
227 "link offset" in the NoOp. This way the 82586 never has to go through the
228 slow restart sequence.
230 The Rx buffer list is set up in the obvious ring structure. We have enough
231 memory (and low enough interrupt latency) that we can avoid the complicated
232 Rx buffer linked lists by alway associating a full-size Rx data buffer with
233 each Rx data frame.
235 I current use four transmit buffers starting at TX_BUF_START (0x0100), and
236 use the rest of memory, from RX_BUF_START to RX_BUF_END, for Rx buffers.
238 */
240 static unsigned short init_words[] = {
241 /* System Configuration Pointer (SCP). */
242 0x0000, /* Set bus size to 16 bits. */
243 0,0, /* pad words. */
244 0x0000,0x0000, /* ISCP phys addr, set in init_82586_mem(). */
246 /* Intermediate System Configuration Pointer (ISCP). */
247 0x0001, /* Status word that's cleared when init is done. */
248 0x0008,0,0, /* SCB offset, (skip, skip) */
250 /* System Control Block (SCB). */
251 0,0xf000|RX_START|CUC_START, /* SCB status and cmd. */
252 CONFIG_CMD, /* Command list pointer, points to Configure. */
253 RX_BUF_START, /* Rx block list. */
254 0,0,0,0, /* Error count: CRC, align, buffer, overrun. */
256 /* 0x0018: Configure command. Change to put MAC data with packet. */
257 0, CmdConfigure, /* Status, command. */
258 SET_SA_CMD, /* Next command is Set Station Addr. */
259 0x0804, /* "4" bytes of config data, 8 byte FIFO. */
260 0x2e40, /* Magic values, including MAC data location. */
261 0, /* Unused pad word. */
263 /* 0x0024: Setup station address command. */
264 0, CmdSASetup,
265 SET_MC_CMD, /* Next command. */
266 0xaa00,0xb000,0x0bad, /* Station address (to be filled in) */
268 /* 0x0030: NOP, looping back to itself. Point to first Tx buffer to Tx. */
269 0, CmdNOp, IDLELOOP, 0 /* pad */,
271 /* 0x0038: A unused Time-Domain Reflectometer command. */
272 0, CmdTDR, IDLELOOP, 0,
274 /* 0x0040: An unused Dump State command. */
275 0, CmdDump, IDLELOOP, DUMP_DATA,
277 /* 0x0048: An unused Diagnose command. */
278 0, CmdDiagnose, IDLELOOP,
280 /* 0x004E: An empty set-multicast-list command. */
281 0, CmdMulticastList, IDLELOOP, 0,
282 };
284 /* Index to functions, as function prototypes. */
286 static int el16_probe1(struct net_device *dev, int ioaddr);
287 static int el16_open(struct net_device *dev);
288 static int el16_send_packet(struct sk_buff *skb, struct net_device *dev);
289 static irqreturn_t el16_interrupt(int irq, void *dev_id, struct pt_regs *regs);
290 static void el16_rx(struct net_device *dev);
291 static int el16_close(struct net_device *dev);
292 static struct net_device_stats *el16_get_stats(struct net_device *dev);
293 static void el16_tx_timeout (struct net_device *dev);
295 static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad);
296 static void init_82586_mem(struct net_device *dev);
297 static struct ethtool_ops netdev_ethtool_ops;
298 static void init_rx_bufs(struct net_device *);
300 static int io = 0x300;
301 static int irq;
302 static int mem_start;
305 /* Check for a network adaptor of this type, and return '0' iff one exists.
306 If dev->base_addr == 0, probe all likely locations.
307 If dev->base_addr == 1, always return failure.
308 If dev->base_addr == 2, (detachable devices only) allocate space for the
309 device and return success.
310 */
312 struct net_device * __init el16_probe(int unit)
313 {
314 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
315 static unsigned ports[] = { 0x300, 0x320, 0x340, 0x280, 0};
316 unsigned *port;
317 int err = -ENODEV;
319 if (!dev)
320 return ERR_PTR(-ENODEV);
322 if (unit >= 0) {
323 sprintf(dev->name, "eth%d", unit);
324 netdev_boot_setup_check(dev);
325 io = dev->base_addr;
326 irq = dev->irq;
327 mem_start = dev->mem_start & 15;
328 }
330 SET_MODULE_OWNER(dev);
332 if (io > 0x1ff) /* Check a single specified location. */
333 err = el16_probe1(dev, io);
334 else if (io != 0)
335 err = -ENXIO; /* Don't probe at all. */
336 else {
337 for (port = ports; *port; port++) {
338 err = el16_probe1(dev, *port);
339 if (!err)
340 break;
341 }
342 }
344 if (err)
345 goto out;
346 err = register_netdev(dev);
347 if (err)
348 goto out1;
349 return dev;
350 out1:
351 free_irq(dev->irq, dev);
352 iounmap(((struct net_local *)netdev_priv(dev))->base);
353 release_region(dev->base_addr, EL16_IO_EXTENT);
354 out:
355 free_netdev(dev);
356 return ERR_PTR(err);
357 }
359 static int __init el16_probe1(struct net_device *dev, int ioaddr)
360 {
361 static unsigned char init_ID_done, version_printed;
362 int i, irq, irqval, retval;
363 struct net_local *lp;
365 if (init_ID_done == 0) {
366 ushort lrs_state = 0xff;
367 /* Send the ID sequence to the ID_PORT to enable the board(s). */
368 outb(0x00, ID_PORT);
369 for(i = 0; i < 255; i++) {
370 outb(lrs_state, ID_PORT);
371 lrs_state <<= 1;
372 if (lrs_state & 0x100)
373 lrs_state ^= 0xe7;
374 }
375 outb(0x00, ID_PORT);
376 init_ID_done = 1;
377 }
379 if (!request_region(ioaddr, EL16_IO_EXTENT, DRV_NAME))
380 return -ENODEV;
382 if ((inb(ioaddr) != '*') || (inb(ioaddr + 1) != '3') ||
383 (inb(ioaddr + 2) != 'C') || (inb(ioaddr + 3) != 'O')) {
384 retval = -ENODEV;
385 goto out;
386 }
388 if (net_debug && version_printed++ == 0)
389 printk(version);
391 printk("%s: 3c507 at %#x,", dev->name, ioaddr);
393 /* We should make a few more checks here, like the first three octets of
394 the S.A. for the manufacturer's code. */
396 irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
398 irqval = request_irq(irq, &el16_interrupt, 0, DRV_NAME, dev);
399 if (irqval) {
400 printk(KERN_ERR "3c507: unable to get IRQ %d (irqval=%d).\n", irq, irqval);
401 retval = -EAGAIN;
402 goto out;
403 }
405 /* We've committed to using the board, and can start filling in *dev. */
406 dev->base_addr = ioaddr;
408 outb(0x01, ioaddr + MISC_CTRL);
409 for (i = 0; i < 6; i++) {
410 dev->dev_addr[i] = inb(ioaddr + i);
411 printk(" %02x", dev->dev_addr[i]);
412 }
414 if (mem_start)
415 net_debug = mem_start & 7;
417 #ifdef MEM_BASE
418 dev->mem_start = MEM_BASE;
419 dev->mem_end = dev->mem_start + 0x10000;
420 #else
421 {
422 int base;
423 int size;
424 char mem_config = inb(ioaddr + MEM_CONFIG);
425 if (mem_config & 0x20) {
426 size = 64*1024;
427 base = 0xf00000 + (mem_config & 0x08 ? 0x080000
428 : ((mem_config & 3) << 17));
429 } else {
430 size = ((mem_config & 3) + 1) << 14;
431 base = 0x0c0000 + ( (mem_config & 0x18) << 12);
432 }
433 dev->mem_start = base;
434 dev->mem_end = base + size;
435 }
436 #endif
438 dev->if_port = (inb(ioaddr + ROM_CONFIG) & 0x80) ? 1 : 0;
439 dev->irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
441 printk(", IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->irq,
442 dev->if_port ? "ex" : "in", dev->mem_start, dev->mem_end-1);
444 if (net_debug)
445 printk(version);
447 lp = netdev_priv(dev);
448 memset(lp, 0, sizeof(*lp));
449 spin_lock_init(&lp->lock);
450 lp->base = ioremap(dev->mem_start, RX_BUF_END);
451 if (!lp->base) {
452 printk(KERN_ERR "3c507: unable to remap memory\n");
453 retval = -EAGAIN;
454 goto out1;
455 }
457 dev->open = el16_open;
458 dev->stop = el16_close;
459 dev->hard_start_xmit = el16_send_packet;
460 dev->get_stats = el16_get_stats;
461 dev->tx_timeout = el16_tx_timeout;
462 dev->watchdog_timeo = TX_TIMEOUT;
463 dev->ethtool_ops = &netdev_ethtool_ops;
464 dev->flags &= ~IFF_MULTICAST; /* Multicast doesn't work */
465 return 0;
466 out1:
467 free_irq(dev->irq, dev);
468 out:
469 release_region(ioaddr, EL16_IO_EXTENT);
470 return retval;
471 }
473 static int el16_open(struct net_device *dev)
474 {
475 /* Initialize the 82586 memory and start it. */
476 init_82586_mem(dev);
478 netif_start_queue(dev);
479 return 0;
480 }
483 static void el16_tx_timeout (struct net_device *dev)
484 {
485 struct net_local *lp = netdev_priv(dev);
486 int ioaddr = dev->base_addr;
487 void __iomem *shmem = lp->base;
489 if (net_debug > 1)
490 printk ("%s: transmit timed out, %s? ", dev->name,
491 readw(shmem + iSCB_STATUS) & 0x8000 ? "IRQ conflict" :
492 "network cable problem");
493 /* Try to restart the adaptor. */
494 if (lp->last_restart == lp->stats.tx_packets) {
495 if (net_debug > 1)
496 printk ("Resetting board.\n");
497 /* Completely reset the adaptor. */
498 init_82586_mem (dev);
499 lp->tx_pkts_in_ring = 0;
500 } else {
501 /* Issue the channel attention signal and hope it "gets better". */
502 if (net_debug > 1)
503 printk ("Kicking board.\n");
504 writew(0xf000 | CUC_START | RX_START, shmem + iSCB_CMD);
505 outb (0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
506 lp->last_restart = lp->stats.tx_packets;
507 }
508 dev->trans_start = jiffies;
509 netif_wake_queue (dev);
510 }
513 static int el16_send_packet (struct sk_buff *skb, struct net_device *dev)
514 {
515 struct net_local *lp = netdev_priv(dev);
516 int ioaddr = dev->base_addr;
517 unsigned long flags;
518 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
519 unsigned char *buf = skb->data;
521 netif_stop_queue (dev);
523 spin_lock_irqsave (&lp->lock, flags);
525 lp->stats.tx_bytes += length;
526 /* Disable the 82586's input to the interrupt line. */
527 outb (0x80, ioaddr + MISC_CTRL);
529 hardware_send_packet (dev, buf, skb->len, length - skb->len);
531 dev->trans_start = jiffies;
532 /* Enable the 82586 interrupt input. */
533 outb (0x84, ioaddr + MISC_CTRL);
535 spin_unlock_irqrestore (&lp->lock, flags);
537 dev_kfree_skb (skb);
539 /* You might need to clean up and record Tx statistics here. */
541 return 0;
542 }
544 /* The typical workload of the driver:
545 Handle the network interface interrupts. */
546 static irqreturn_t el16_interrupt(int irq, void *dev_id, struct pt_regs *regs)
547 {
548 struct net_device *dev = dev_id;
549 struct net_local *lp;
550 int ioaddr, status, boguscount = 0;
551 ushort ack_cmd = 0;
552 void __iomem *shmem;
554 if (dev == NULL) {
555 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
556 return IRQ_NONE;
557 }
559 ioaddr = dev->base_addr;
560 lp = netdev_priv(dev);
561 shmem = lp->base;
563 spin_lock(&lp->lock);
565 status = readw(shmem+iSCB_STATUS);
567 if (net_debug > 4) {
568 printk("%s: 3c507 interrupt, status %4.4x.\n", dev->name, status);
569 }
571 /* Disable the 82586's input to the interrupt line. */
572 outb(0x80, ioaddr + MISC_CTRL);
574 /* Reap the Tx packet buffers. */
575 while (lp->tx_pkts_in_ring) {
576 unsigned short tx_status = readw(shmem+lp->tx_reap);
577 if (!(tx_status & 0x8000)) {
578 if (net_debug > 5)
579 printk("Tx command incomplete (%#x).\n", lp->tx_reap);
580 break;
581 }
582 /* Tx unsuccessful or some interesting status bit set. */
583 if (!(tx_status & 0x2000) || (tx_status & 0x0f3f)) {
584 lp->stats.tx_errors++;
585 if (tx_status & 0x0600) lp->stats.tx_carrier_errors++;
586 if (tx_status & 0x0100) lp->stats.tx_fifo_errors++;
587 if (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++;
588 if (tx_status & 0x0020) lp->stats.tx_aborted_errors++;
589 lp->stats.collisions += tx_status & 0xf;
590 }
591 lp->stats.tx_packets++;
592 if (net_debug > 5)
593 printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
594 lp->tx_reap += TX_BUF_SIZE;
595 if (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
596 lp->tx_reap = TX_BUF_START;
598 lp->tx_pkts_in_ring--;
599 /* There is always more space in the Tx ring buffer now. */
600 netif_wake_queue(dev);
602 if (++boguscount > 10)
603 break;
604 }
606 if (status & 0x4000) { /* Packet received. */
607 if (net_debug > 5)
608 printk("Received packet, rx_head %04x.\n", lp->rx_head);
609 el16_rx(dev);
610 }
612 /* Acknowledge the interrupt sources. */
613 ack_cmd = status & 0xf000;
615 if ((status & 0x0700) != 0x0200 && netif_running(dev)) {
616 if (net_debug)
617 printk("%s: Command unit stopped, status %04x, restarting.\n",
618 dev->name, status);
619 /* If this ever occurs we should really re-write the idle loop, reset
620 the Tx list, and do a complete restart of the command unit.
621 For now we rely on the Tx timeout if the resume doesn't work. */
622 ack_cmd |= CUC_RESUME;
623 }
625 if ((status & 0x0070) != 0x0040 && netif_running(dev)) {
626 /* The Rx unit is not ready, it must be hung. Restart the receiver by
627 initializing the rx buffers, and issuing an Rx start command. */
628 if (net_debug)
629 printk("%s: Rx unit stopped, status %04x, restarting.\n",
630 dev->name, status);
631 init_rx_bufs(dev);
632 writew(RX_BUF_START,shmem+iSCB_RFA);
633 ack_cmd |= RX_START;
634 }
636 writew(ack_cmd,shmem+iSCB_CMD);
637 outb(0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
639 /* Clear the latched interrupt. */
640 outb(0, ioaddr + RESET_IRQ);
642 /* Enable the 82586's interrupt input. */
643 outb(0x84, ioaddr + MISC_CTRL);
644 spin_unlock(&lp->lock);
645 return IRQ_HANDLED;
646 }
648 static int el16_close(struct net_device *dev)
649 {
650 struct net_local *lp = netdev_priv(dev);
651 int ioaddr = dev->base_addr;
652 void __iomem *shmem = lp->base;
654 netif_stop_queue(dev);
656 /* Flush the Tx and disable Rx. */
657 writew(RX_SUSPEND | CUC_SUSPEND,shmem+iSCB_CMD);
658 outb(0, ioaddr + SIGNAL_CA);
660 /* Disable the 82586's input to the interrupt line. */
661 outb(0x80, ioaddr + MISC_CTRL);
663 /* We always physically use the IRQ line, so we don't do free_irq(). */
665 /* Update the statistics here. */
667 return 0;
668 }
670 /* Get the current statistics. This may be called with the card open or
671 closed. */
672 static struct net_device_stats *el16_get_stats(struct net_device *dev)
673 {
674 struct net_local *lp = netdev_priv(dev);
676 /* ToDo: decide if there are any useful statistics from the SCB. */
678 return &lp->stats;
679 }
681 /* Initialize the Rx-block list. */
682 static void init_rx_bufs(struct net_device *dev)
683 {
684 struct net_local *lp = netdev_priv(dev);
685 void __iomem *write_ptr;
686 unsigned short SCB_base = SCB_BASE;
688 int cur_rxbuf = lp->rx_head = RX_BUF_START;
690 /* Initialize each Rx frame + data buffer. */
691 do { /* While there is room for one more. */
693 write_ptr = lp->base + cur_rxbuf;
695 writew(0x0000,write_ptr); /* Status */
696 writew(0x0000,write_ptr+=2); /* Command */
697 writew(cur_rxbuf + RX_BUF_SIZE,write_ptr+=2); /* Link */
698 writew(cur_rxbuf + 22,write_ptr+=2); /* Buffer offset */
699 writew(0x0000,write_ptr+=2); /* Pad for dest addr. */
700 writew(0x0000,write_ptr+=2);
701 writew(0x0000,write_ptr+=2);
702 writew(0x0000,write_ptr+=2); /* Pad for source addr. */
703 writew(0x0000,write_ptr+=2);
704 writew(0x0000,write_ptr+=2);
705 writew(0x0000,write_ptr+=2); /* Pad for protocol. */
707 writew(0x0000,write_ptr+=2); /* Buffer: Actual count */
708 writew(-1,write_ptr+=2); /* Buffer: Next (none). */
709 writew(cur_rxbuf + 0x20 + SCB_base,write_ptr+=2);/* Buffer: Address low */
710 writew(0x0000,write_ptr+=2);
711 /* Finally, the number of bytes in the buffer. */
712 writew(0x8000 + RX_BUF_SIZE-0x20,write_ptr+=2);
714 lp->rx_tail = cur_rxbuf;
715 cur_rxbuf += RX_BUF_SIZE;
716 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
718 /* Terminate the list by setting the EOL bit, and wrap the pointer to make
719 the list a ring. */
720 write_ptr = lp->base + lp->rx_tail + 2;
721 writew(0xC000,write_ptr); /* Command, mark as last. */
722 writew(lp->rx_head,write_ptr+2); /* Link */
723 }
725 static void init_82586_mem(struct net_device *dev)
726 {
727 struct net_local *lp = netdev_priv(dev);
728 short ioaddr = dev->base_addr;
729 void __iomem *shmem = lp->base;
731 /* Enable loopback to protect the wire while starting up,
732 and hold the 586 in reset during the memory initialization. */
733 outb(0x20, ioaddr + MISC_CTRL);
735 /* Fix the ISCP address and base. */
736 init_words[3] = SCB_BASE;
737 init_words[7] = SCB_BASE;
739 /* Write the words at 0xfff6 (address-aliased to 0xfffff6). */
740 memcpy_toio(lp->base + RX_BUF_END - 10, init_words, 10);
742 /* Write the words at 0x0000. */
743 memcpy_toio(lp->base, init_words + 5, sizeof(init_words) - 10);
745 /* Fill in the station address. */
746 memcpy_toio(lp->base+SA_OFFSET, dev->dev_addr,
747 sizeof(dev->dev_addr));
749 /* The Tx-block list is written as needed. We just set up the values. */
750 lp->tx_cmd_link = IDLELOOP + 4;
751 lp->tx_head = lp->tx_reap = TX_BUF_START;
753 init_rx_bufs(dev);
755 /* Start the 586 by releasing the reset line, but leave loopback. */
756 outb(0xA0, ioaddr + MISC_CTRL);
758 /* This was time consuming to track down: you need to give two channel
759 attention signals to reliably start up the i82586. */
760 outb(0, ioaddr + SIGNAL_CA);
762 {
763 int boguscnt = 50;
764 while (readw(shmem+iSCB_STATUS) == 0)
765 if (--boguscnt == 0) {
766 printk("%s: i82586 initialization timed out with status %04x,"
767 "cmd %04x.\n", dev->name,
768 readw(shmem+iSCB_STATUS), readw(shmem+iSCB_CMD));
769 break;
770 }
771 /* Issue channel-attn -- the 82586 won't start. */
772 outb(0, ioaddr + SIGNAL_CA);
773 }
775 /* Disable loopback and enable interrupts. */
776 outb(0x84, ioaddr + MISC_CTRL);
777 if (net_debug > 4)
778 printk("%s: Initialized 82586, status %04x.\n", dev->name,
779 readw(shmem+iSCB_STATUS));
780 return;
781 }
783 static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad)
784 {
785 struct net_local *lp = netdev_priv(dev);
786 short ioaddr = dev->base_addr;
787 ushort tx_block = lp->tx_head;
788 void __iomem *write_ptr = lp->base + tx_block;
789 static char padding[ETH_ZLEN];
791 /* Set the write pointer to the Tx block, and put out the header. */
792 writew(0x0000,write_ptr); /* Tx status */
793 writew(CMD_INTR|CmdTx,write_ptr+=2); /* Tx command */
794 writew(tx_block+16,write_ptr+=2); /* Next command is a NoOp. */
795 writew(tx_block+8,write_ptr+=2); /* Data Buffer offset. */
797 /* Output the data buffer descriptor. */
798 writew((pad + length) | 0x8000,write_ptr+=2); /* Byte count parameter. */
799 writew(-1,write_ptr+=2); /* No next data buffer. */
800 writew(tx_block+22+SCB_BASE,write_ptr+=2); /* Buffer follows the NoOp command. */
801 writew(0x0000,write_ptr+=2); /* Buffer address high bits (always zero). */
803 /* Output the Loop-back NoOp command. */
804 writew(0x0000,write_ptr+=2); /* Tx status */
805 writew(CmdNOp,write_ptr+=2); /* Tx command */
806 writew(tx_block+16,write_ptr+=2); /* Next is myself. */
808 /* Output the packet at the write pointer. */
809 memcpy_toio(write_ptr+2, buf, length);
810 if (pad)
811 memcpy_toio(write_ptr+length+2, padding, pad);
813 /* Set the old command link pointing to this send packet. */
814 writew(tx_block,lp->base + lp->tx_cmd_link);
815 lp->tx_cmd_link = tx_block + 20;
817 /* Set the next free tx region. */
818 lp->tx_head = tx_block + TX_BUF_SIZE;
819 if (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
820 lp->tx_head = TX_BUF_START;
822 if (net_debug > 4) {
823 printk("%s: 3c507 @%x send length = %d, tx_block %3x, next %3x.\n",
824 dev->name, ioaddr, length, tx_block, lp->tx_head);
825 }
827 /* Grimly block further packets if there has been insufficient reaping. */
828 if (++lp->tx_pkts_in_ring < NUM_TX_BUFS)
829 netif_wake_queue(dev);
830 }
832 static void el16_rx(struct net_device *dev)
833 {
834 struct net_local *lp = netdev_priv(dev);
835 void __iomem *shmem = lp->base;
836 ushort rx_head = lp->rx_head;
837 ushort rx_tail = lp->rx_tail;
838 ushort boguscount = 10;
839 short frame_status;
841 while ((frame_status = readw(shmem+rx_head)) < 0) { /* Command complete */
842 void __iomem *read_frame = lp->base + rx_head;
843 ushort rfd_cmd = readw(read_frame+2);
844 ushort next_rx_frame = readw(read_frame+4);
845 ushort data_buffer_addr = readw(read_frame+6);
846 void __iomem *data_frame = lp->base + data_buffer_addr;
847 ushort pkt_len = readw(data_frame);
849 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
850 || (pkt_len & 0xC000) != 0xC000) {
851 printk("%s: Rx frame at %#x corrupted, status %04x cmd %04x"
852 "next %04x data-buf @%04x %04x.\n", dev->name, rx_head,
853 frame_status, rfd_cmd, next_rx_frame, data_buffer_addr,
854 pkt_len);
855 } else if ((frame_status & 0x2000) == 0) {
856 /* Frame Rxed, but with error. */
857 lp->stats.rx_errors++;
858 if (frame_status & 0x0800) lp->stats.rx_crc_errors++;
859 if (frame_status & 0x0400) lp->stats.rx_frame_errors++;
860 if (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
861 if (frame_status & 0x0100) lp->stats.rx_over_errors++;
862 if (frame_status & 0x0080) lp->stats.rx_length_errors++;
863 } else {
864 /* Malloc up new buffer. */
865 struct sk_buff *skb;
867 pkt_len &= 0x3fff;
868 skb = dev_alloc_skb(pkt_len+2);
869 if (skb == NULL) {
870 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
871 lp->stats.rx_dropped++;
872 break;
873 }
875 skb_reserve(skb,2);
876 skb->dev = dev;
878 /* 'skb->data' points to the start of sk_buff data area. */
879 memcpy_fromio(skb_put(skb,pkt_len), data_frame + 10, pkt_len);
881 skb->protocol=eth_type_trans(skb,dev);
882 netif_rx(skb);
883 dev->last_rx = jiffies;
884 lp->stats.rx_packets++;
885 lp->stats.rx_bytes += pkt_len;
886 }
888 /* Clear the status word and set End-of-List on the rx frame. */
889 writew(0,read_frame);
890 writew(0xC000,read_frame+2);
891 /* Clear the end-of-list on the prev. RFD. */
892 writew(0x0000,lp->base + rx_tail + 2);
894 rx_tail = rx_head;
895 rx_head = next_rx_frame;
896 if (--boguscount == 0)
897 break;
898 }
900 lp->rx_head = rx_head;
901 lp->rx_tail = rx_tail;
902 }
904 static void netdev_get_drvinfo(struct net_device *dev,
905 struct ethtool_drvinfo *info)
906 {
907 strcpy(info->driver, DRV_NAME);
908 strcpy(info->version, DRV_VERSION);
909 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
910 }
912 static u32 netdev_get_msglevel(struct net_device *dev)
913 {
914 return debug;
915 }
917 static void netdev_set_msglevel(struct net_device *dev, u32 level)
918 {
919 debug = level;
920 }
922 static struct ethtool_ops netdev_ethtool_ops = {
923 .get_drvinfo = netdev_get_drvinfo,
924 .get_msglevel = netdev_get_msglevel,
925 .set_msglevel = netdev_set_msglevel,
926 };
928 #ifdef MODULE
929 static struct net_device *dev_3c507;
930 module_param(io, int, 0);
931 module_param(irq, int, 0);
932 MODULE_PARM_DESC(io, "EtherLink16 I/O base address");
933 MODULE_PARM_DESC(irq, "(ignored)");
935 int __init init_module(void)
936 {
937 if (io == 0)
938 printk("3c507: You should not use auto-probing with insmod!\n");
939 dev_3c507 = el16_probe(-1);
940 return IS_ERR(dev_3c507) ? PTR_ERR(dev_3c507) : 0;
941 }
943 void
944 cleanup_module(void)
945 {
946 struct net_device *dev = dev_3c507;
947 unregister_netdev(dev);
948 free_irq(dev->irq, dev);
949 iounmap(((struct net_local *)netdev_priv(dev))->base);
950 release_region(dev->base_addr, EL16_IO_EXTENT);
951 free_netdev(dev);
952 }
953 #endif /* MODULE */
954 MODULE_LICENSE("GPL");
957 /*
958 * Local variables:
959 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -I/usr/src/linux/drivers/net -Wall -Wstrict-prototypes -O6 -m486 -c 3c507.c"
960 * version-control: t
961 * kept-new-versions: 5
962 * tab-width: 4
963 * c-indent-level: 4
964 * End:
965 */