ia64/linux-2.6.18-xen.hg

view drivers/net/a2065.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 /*
2 * Amiga Linux/68k A2065 Ethernet Driver
3 *
4 * (C) Copyright 1995-2003 by Geert Uytterhoeven <geert@linux-m68k.org>
5 *
6 * Fixes and tips by:
7 * - Janos Farkas (CHEXUM@sparta.banki.hu)
8 * - Jes Degn Soerensen (jds@kom.auc.dk)
9 * - Matt Domsch (Matt_Domsch@dell.com)
10 *
11 * ----------------------------------------------------------------------------
12 *
13 * This program is based on
14 *
15 * ariadne.?: Amiga Linux/68k Ariadne Ethernet Driver
16 * (C) Copyright 1995 by Geert Uytterhoeven,
17 * Peter De Schrijver
18 *
19 * lance.c: An AMD LANCE ethernet driver for linux.
20 * Written 1993-94 by Donald Becker.
21 *
22 * Am79C960: PCnet(tm)-ISA Single-Chip Ethernet Controller
23 * Advanced Micro Devices
24 * Publication #16907, Rev. B, Amendment/0, May 1994
25 *
26 * ----------------------------------------------------------------------------
27 *
28 * This file is subject to the terms and conditions of the GNU General Public
29 * License. See the file COPYING in the main directory of the Linux
30 * distribution for more details.
31 *
32 * ----------------------------------------------------------------------------
33 *
34 * The A2065 is a Zorro-II board made by Commodore/Ameristar. It contains:
35 *
36 * - an Am7990 Local Area Network Controller for Ethernet (LANCE) with
37 * both 10BASE-2 (thin coax) and AUI (DB-15) connectors
38 */
40 #include <linux/errno.h>
41 #include <linux/netdevice.h>
42 #include <linux/etherdevice.h>
43 #include <linux/module.h>
44 #include <linux/stddef.h>
45 #include <linux/kernel.h>
46 #include <linux/interrupt.h>
47 #include <linux/ioport.h>
48 #include <linux/skbuff.h>
49 #include <linux/slab.h>
50 #include <linux/string.h>
51 #include <linux/init.h>
52 #include <linux/crc32.h>
53 #include <linux/zorro.h>
54 #include <linux/bitops.h>
56 #include <asm/irq.h>
57 #include <asm/amigaints.h>
58 #include <asm/amigahw.h>
60 #include "a2065.h"
63 /*
64 * Transmit/Receive Ring Definitions
65 */
67 #define LANCE_LOG_TX_BUFFERS (2)
68 #define LANCE_LOG_RX_BUFFERS (4)
70 #define TX_RING_SIZE (1<<LANCE_LOG_TX_BUFFERS)
71 #define RX_RING_SIZE (1<<LANCE_LOG_RX_BUFFERS)
73 #define TX_RING_MOD_MASK (TX_RING_SIZE-1)
74 #define RX_RING_MOD_MASK (RX_RING_SIZE-1)
76 #define PKT_BUF_SIZE (1544)
77 #define RX_BUFF_SIZE PKT_BUF_SIZE
78 #define TX_BUFF_SIZE PKT_BUF_SIZE
81 /*
82 * Layout of the Lance's RAM Buffer
83 */
86 struct lance_init_block {
87 unsigned short mode; /* Pre-set mode (reg. 15) */
88 unsigned char phys_addr[6]; /* Physical ethernet address */
89 unsigned filter[2]; /* Multicast filter. */
91 /* Receive and transmit ring base, along with extra bits. */
92 unsigned short rx_ptr; /* receive descriptor addr */
93 unsigned short rx_len; /* receive len and high addr */
94 unsigned short tx_ptr; /* transmit descriptor addr */
95 unsigned short tx_len; /* transmit len and high addr */
97 /* The Tx and Rx ring entries must aligned on 8-byte boundaries. */
98 struct lance_rx_desc brx_ring[RX_RING_SIZE];
99 struct lance_tx_desc btx_ring[TX_RING_SIZE];
101 char rx_buf [RX_RING_SIZE][RX_BUFF_SIZE];
102 char tx_buf [TX_RING_SIZE][TX_BUFF_SIZE];
103 };
106 /*
107 * Private Device Data
108 */
110 struct lance_private {
111 char *name;
112 volatile struct lance_regs *ll;
113 volatile struct lance_init_block *init_block; /* Hosts view */
114 volatile struct lance_init_block *lance_init_block; /* Lance view */
116 int rx_new, tx_new;
117 int rx_old, tx_old;
119 int lance_log_rx_bufs, lance_log_tx_bufs;
120 int rx_ring_mod_mask, tx_ring_mod_mask;
122 struct net_device_stats stats;
123 int tpe; /* cable-selection is TPE */
124 int auto_select; /* cable-selection by carrier */
125 unsigned short busmaster_regval;
127 #ifdef CONFIG_SUNLANCE
128 struct Linux_SBus_DMA *ledma; /* if set this points to ledma and arch=4m */
129 int burst_sizes; /* ledma SBus burst sizes */
130 #endif
131 struct timer_list multicast_timer;
132 };
134 #define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
135 lp->tx_old+lp->tx_ring_mod_mask-lp->tx_new:\
136 lp->tx_old - lp->tx_new-1)
139 #define LANCE_ADDR(x) ((int)(x) & ~0xff000000)
141 /* Load the CSR registers */
142 static void load_csrs (struct lance_private *lp)
143 {
144 volatile struct lance_regs *ll = lp->ll;
145 volatile struct lance_init_block *aib = lp->lance_init_block;
146 int leptr;
148 leptr = LANCE_ADDR (aib);
150 ll->rap = LE_CSR1;
151 ll->rdp = (leptr & 0xFFFF);
152 ll->rap = LE_CSR2;
153 ll->rdp = leptr >> 16;
154 ll->rap = LE_CSR3;
155 ll->rdp = lp->busmaster_regval;
157 /* Point back to csr0 */
158 ll->rap = LE_CSR0;
159 }
161 #define ZERO 0
163 /* Setup the Lance Rx and Tx rings */
164 static void lance_init_ring (struct net_device *dev)
165 {
166 struct lance_private *lp = netdev_priv(dev);
167 volatile struct lance_init_block *ib = lp->init_block;
168 volatile struct lance_init_block *aib; /* for LANCE_ADDR computations */
169 int leptr;
170 int i;
172 aib = lp->lance_init_block;
174 /* Lock out other processes while setting up hardware */
175 netif_stop_queue(dev);
176 lp->rx_new = lp->tx_new = 0;
177 lp->rx_old = lp->tx_old = 0;
179 ib->mode = 0;
181 /* Copy the ethernet address to the lance init block
182 * Note that on the sparc you need to swap the ethernet address.
183 */
184 ib->phys_addr [0] = dev->dev_addr [1];
185 ib->phys_addr [1] = dev->dev_addr [0];
186 ib->phys_addr [2] = dev->dev_addr [3];
187 ib->phys_addr [3] = dev->dev_addr [2];
188 ib->phys_addr [4] = dev->dev_addr [5];
189 ib->phys_addr [5] = dev->dev_addr [4];
191 if (ZERO)
192 printk(KERN_DEBUG "TX rings:\n");
194 /* Setup the Tx ring entries */
195 for (i = 0; i <= (1<<lp->lance_log_tx_bufs); i++) {
196 leptr = LANCE_ADDR(&aib->tx_buf[i][0]);
197 ib->btx_ring [i].tmd0 = leptr;
198 ib->btx_ring [i].tmd1_hadr = leptr >> 16;
199 ib->btx_ring [i].tmd1_bits = 0;
200 ib->btx_ring [i].length = 0xf000; /* The ones required by tmd2 */
201 ib->btx_ring [i].misc = 0;
202 if (i < 3 && ZERO)
203 printk(KERN_DEBUG "%d: 0x%8.8x\n", i, leptr);
204 }
206 /* Setup the Rx ring entries */
207 if (ZERO)
208 printk(KERN_DEBUG "RX rings:\n");
209 for (i = 0; i < (1<<lp->lance_log_rx_bufs); i++) {
210 leptr = LANCE_ADDR(&aib->rx_buf[i][0]);
212 ib->brx_ring [i].rmd0 = leptr;
213 ib->brx_ring [i].rmd1_hadr = leptr >> 16;
214 ib->brx_ring [i].rmd1_bits = LE_R1_OWN;
215 ib->brx_ring [i].length = -RX_BUFF_SIZE | 0xf000;
216 ib->brx_ring [i].mblength = 0;
217 if (i < 3 && ZERO)
218 printk(KERN_DEBUG "%d: 0x%8.8x\n", i, leptr);
219 }
221 /* Setup the initialization block */
223 /* Setup rx descriptor pointer */
224 leptr = LANCE_ADDR(&aib->brx_ring);
225 ib->rx_len = (lp->lance_log_rx_bufs << 13) | (leptr >> 16);
226 ib->rx_ptr = leptr;
227 if (ZERO)
228 printk(KERN_DEBUG "RX ptr: %8.8x\n", leptr);
230 /* Setup tx descriptor pointer */
231 leptr = LANCE_ADDR(&aib->btx_ring);
232 ib->tx_len = (lp->lance_log_tx_bufs << 13) | (leptr >> 16);
233 ib->tx_ptr = leptr;
234 if (ZERO)
235 printk(KERN_DEBUG "TX ptr: %8.8x\n", leptr);
237 /* Clear the multicast filter */
238 ib->filter [0] = 0;
239 ib->filter [1] = 0;
240 }
242 static int init_restart_lance (struct lance_private *lp)
243 {
244 volatile struct lance_regs *ll = lp->ll;
245 int i;
247 ll->rap = LE_CSR0;
248 ll->rdp = LE_C0_INIT;
250 /* Wait for the lance to complete initialization */
251 for (i = 0; (i < 100) && !(ll->rdp & (LE_C0_ERR | LE_C0_IDON)); i++)
252 barrier();
253 if ((i == 100) || (ll->rdp & LE_C0_ERR)) {
254 printk(KERN_ERR "LANCE unopened after %d ticks, csr0=%4.4x.\n",
255 i, ll->rdp);
256 return -EIO;
257 }
259 /* Clear IDON by writing a "1", enable interrupts and start lance */
260 ll->rdp = LE_C0_IDON;
261 ll->rdp = LE_C0_INEA | LE_C0_STRT;
263 return 0;
264 }
266 static int lance_rx (struct net_device *dev)
267 {
268 struct lance_private *lp = netdev_priv(dev);
269 volatile struct lance_init_block *ib = lp->init_block;
270 volatile struct lance_regs *ll = lp->ll;
271 volatile struct lance_rx_desc *rd;
272 unsigned char bits;
273 int len = 0; /* XXX shut up gcc warnings */
274 struct sk_buff *skb = 0; /* XXX shut up gcc warnings */
276 #ifdef TEST_HITS
277 int i;
278 printk(KERN_DEBUG "[");
279 for (i = 0; i < RX_RING_SIZE; i++) {
280 if (i == lp->rx_new)
281 printk ("%s",
282 ib->brx_ring [i].rmd1_bits & LE_R1_OWN ? "_" : "X");
283 else
284 printk ("%s",
285 ib->brx_ring [i].rmd1_bits & LE_R1_OWN ? "." : "1");
286 }
287 printk ("]\n");
288 #endif
290 ll->rdp = LE_C0_RINT|LE_C0_INEA;
291 for (rd = &ib->brx_ring [lp->rx_new];
292 !((bits = rd->rmd1_bits) & LE_R1_OWN);
293 rd = &ib->brx_ring [lp->rx_new]) {
295 /* We got an incomplete frame? */
296 if ((bits & LE_R1_POK) != LE_R1_POK) {
297 lp->stats.rx_over_errors++;
298 lp->stats.rx_errors++;
299 continue;
300 } else if (bits & LE_R1_ERR) {
301 /* Count only the end frame as a rx error,
302 * not the beginning
303 */
304 if (bits & LE_R1_BUF) lp->stats.rx_fifo_errors++;
305 if (bits & LE_R1_CRC) lp->stats.rx_crc_errors++;
306 if (bits & LE_R1_OFL) lp->stats.rx_over_errors++;
307 if (bits & LE_R1_FRA) lp->stats.rx_frame_errors++;
308 if (bits & LE_R1_EOP) lp->stats.rx_errors++;
309 } else {
310 len = (rd->mblength & 0xfff) - 4;
311 skb = dev_alloc_skb (len+2);
313 if (skb == 0) {
314 printk(KERN_WARNING "%s: Memory squeeze, "
315 "deferring packet.\n", dev->name);
316 lp->stats.rx_dropped++;
317 rd->mblength = 0;
318 rd->rmd1_bits = LE_R1_OWN;
319 lp->rx_new = (lp->rx_new + 1) & lp->rx_ring_mod_mask;
320 return 0;
321 }
323 skb->dev = dev;
324 skb_reserve (skb, 2); /* 16 byte align */
325 skb_put (skb, len); /* make room */
326 eth_copy_and_sum(skb,
327 (unsigned char *)&(ib->rx_buf [lp->rx_new][0]),
328 len, 0);
329 skb->protocol = eth_type_trans (skb, dev);
330 netif_rx (skb);
331 dev->last_rx = jiffies;
332 lp->stats.rx_packets++;
333 lp->stats.rx_bytes += len;
334 }
336 /* Return the packet to the pool */
337 rd->mblength = 0;
338 rd->rmd1_bits = LE_R1_OWN;
339 lp->rx_new = (lp->rx_new + 1) & lp->rx_ring_mod_mask;
340 }
341 return 0;
342 }
344 static int lance_tx (struct net_device *dev)
345 {
346 struct lance_private *lp = netdev_priv(dev);
347 volatile struct lance_init_block *ib = lp->init_block;
348 volatile struct lance_regs *ll = lp->ll;
349 volatile struct lance_tx_desc *td;
350 int i, j;
351 int status;
353 /* csr0 is 2f3 */
354 ll->rdp = LE_C0_TINT | LE_C0_INEA;
355 /* csr0 is 73 */
357 j = lp->tx_old;
358 for (i = j; i != lp->tx_new; i = j) {
359 td = &ib->btx_ring [i];
361 /* If we hit a packet not owned by us, stop */
362 if (td->tmd1_bits & LE_T1_OWN)
363 break;
365 if (td->tmd1_bits & LE_T1_ERR) {
366 status = td->misc;
368 lp->stats.tx_errors++;
369 if (status & LE_T3_RTY) lp->stats.tx_aborted_errors++;
370 if (status & LE_T3_LCOL) lp->stats.tx_window_errors++;
372 if (status & LE_T3_CLOS) {
373 lp->stats.tx_carrier_errors++;
374 if (lp->auto_select) {
375 lp->tpe = 1 - lp->tpe;
376 printk(KERN_ERR "%s: Carrier Lost, "
377 "trying %s\n", dev->name,
378 lp->tpe?"TPE":"AUI");
379 /* Stop the lance */
380 ll->rap = LE_CSR0;
381 ll->rdp = LE_C0_STOP;
382 lance_init_ring (dev);
383 load_csrs (lp);
384 init_restart_lance (lp);
385 return 0;
386 }
387 }
389 /* buffer errors and underflows turn off the transmitter */
390 /* Restart the adapter */
391 if (status & (LE_T3_BUF|LE_T3_UFL)) {
392 lp->stats.tx_fifo_errors++;
394 printk(KERN_ERR "%s: Tx: ERR_BUF|ERR_UFL, "
395 "restarting\n", dev->name);
396 /* Stop the lance */
397 ll->rap = LE_CSR0;
398 ll->rdp = LE_C0_STOP;
399 lance_init_ring (dev);
400 load_csrs (lp);
401 init_restart_lance (lp);
402 return 0;
403 }
404 } else if ((td->tmd1_bits & LE_T1_POK) == LE_T1_POK) {
405 /*
406 * So we don't count the packet more than once.
407 */
408 td->tmd1_bits &= ~(LE_T1_POK);
410 /* One collision before packet was sent. */
411 if (td->tmd1_bits & LE_T1_EONE)
412 lp->stats.collisions++;
414 /* More than one collision, be optimistic. */
415 if (td->tmd1_bits & LE_T1_EMORE)
416 lp->stats.collisions += 2;
418 lp->stats.tx_packets++;
419 }
421 j = (j + 1) & lp->tx_ring_mod_mask;
422 }
423 lp->tx_old = j;
424 ll->rdp = LE_C0_TINT | LE_C0_INEA;
425 return 0;
426 }
428 static irqreturn_t
429 lance_interrupt (int irq, void *dev_id, struct pt_regs *regs)
430 {
431 struct net_device *dev;
432 struct lance_private *lp;
433 volatile struct lance_regs *ll;
434 int csr0;
436 dev = (struct net_device *) dev_id;
438 lp = netdev_priv(dev);
439 ll = lp->ll;
441 ll->rap = LE_CSR0; /* LANCE Controller Status */
442 csr0 = ll->rdp;
444 if (!(csr0 & LE_C0_INTR)) /* Check if any interrupt has */
445 return IRQ_NONE; /* been generated by the Lance. */
447 /* Acknowledge all the interrupt sources ASAP */
448 ll->rdp = csr0 & ~(LE_C0_INEA|LE_C0_TDMD|LE_C0_STOP|LE_C0_STRT|
449 LE_C0_INIT);
451 if ((csr0 & LE_C0_ERR)) {
452 /* Clear the error condition */
453 ll->rdp = LE_C0_BABL|LE_C0_ERR|LE_C0_MISS|LE_C0_INEA;
454 }
456 if (csr0 & LE_C0_RINT)
457 lance_rx (dev);
459 if (csr0 & LE_C0_TINT)
460 lance_tx (dev);
462 /* Log misc errors. */
463 if (csr0 & LE_C0_BABL)
464 lp->stats.tx_errors++; /* Tx babble. */
465 if (csr0 & LE_C0_MISS)
466 lp->stats.rx_errors++; /* Missed a Rx frame. */
467 if (csr0 & LE_C0_MERR) {
468 printk(KERN_ERR "%s: Bus master arbitration failure, status "
469 "%4.4x.\n", dev->name, csr0);
470 /* Restart the chip. */
471 ll->rdp = LE_C0_STRT;
472 }
474 if (netif_queue_stopped(dev) && TX_BUFFS_AVAIL > 0)
475 netif_wake_queue(dev);
477 ll->rap = LE_CSR0;
478 ll->rdp = LE_C0_BABL|LE_C0_CERR|LE_C0_MISS|LE_C0_MERR|
479 LE_C0_IDON|LE_C0_INEA;
480 return IRQ_HANDLED;
481 }
483 struct net_device *last_dev = 0;
485 static int lance_open (struct net_device *dev)
486 {
487 struct lance_private *lp = netdev_priv(dev);
488 volatile struct lance_regs *ll = lp->ll;
489 int ret;
491 last_dev = dev;
493 /* Stop the Lance */
494 ll->rap = LE_CSR0;
495 ll->rdp = LE_C0_STOP;
497 /* Install the Interrupt handler */
498 ret = request_irq(IRQ_AMIGA_PORTS, lance_interrupt, IRQF_SHARED,
499 dev->name, dev);
500 if (ret) return ret;
502 load_csrs (lp);
503 lance_init_ring (dev);
505 netif_start_queue(dev);
507 return init_restart_lance (lp);
508 }
510 static int lance_close (struct net_device *dev)
511 {
512 struct lance_private *lp = netdev_priv(dev);
513 volatile struct lance_regs *ll = lp->ll;
515 netif_stop_queue(dev);
516 del_timer_sync(&lp->multicast_timer);
518 /* Stop the card */
519 ll->rap = LE_CSR0;
520 ll->rdp = LE_C0_STOP;
522 free_irq(IRQ_AMIGA_PORTS, dev);
523 return 0;
524 }
526 static inline int lance_reset (struct net_device *dev)
527 {
528 struct lance_private *lp = netdev_priv(dev);
529 volatile struct lance_regs *ll = lp->ll;
530 int status;
532 /* Stop the lance */
533 ll->rap = LE_CSR0;
534 ll->rdp = LE_C0_STOP;
536 load_csrs (lp);
538 lance_init_ring (dev);
539 dev->trans_start = jiffies;
540 netif_start_queue(dev);
542 status = init_restart_lance (lp);
543 #ifdef DEBUG_DRIVER
544 printk(KERN_DEBUG "Lance restart=%d\n", status);
545 #endif
546 return status;
547 }
549 static void lance_tx_timeout(struct net_device *dev)
550 {
551 struct lance_private *lp = netdev_priv(dev);
552 volatile struct lance_regs *ll = lp->ll;
554 printk(KERN_ERR "%s: transmit timed out, status %04x, reset\n",
555 dev->name, ll->rdp);
556 lance_reset(dev);
557 netif_wake_queue(dev);
558 }
560 static int lance_start_xmit (struct sk_buff *skb, struct net_device *dev)
561 {
562 struct lance_private *lp = netdev_priv(dev);
563 volatile struct lance_regs *ll = lp->ll;
564 volatile struct lance_init_block *ib = lp->init_block;
565 int entry, skblen, len;
566 int status = 0;
567 static int outs;
568 unsigned long flags;
570 skblen = skb->len;
571 len = skblen;
573 if (len < ETH_ZLEN) {
574 len = ETH_ZLEN;
575 if (skb_padto(skb, ETH_ZLEN))
576 return 0;
577 }
579 local_irq_save(flags);
581 if (!TX_BUFFS_AVAIL){
582 local_irq_restore(flags);
583 return -1;
584 }
586 #ifdef DEBUG_DRIVER
587 /* dump the packet */
588 {
589 int i;
591 for (i = 0; i < 64; i++) {
592 if ((i % 16) == 0)
593 printk("\n" KERN_DEBUG);
594 printk ("%2.2x ", skb->data [i]);
595 }
596 printk("\n");
597 }
598 #endif
599 entry = lp->tx_new & lp->tx_ring_mod_mask;
600 ib->btx_ring [entry].length = (-len) | 0xf000;
601 ib->btx_ring [entry].misc = 0;
603 memcpy ((char *)&ib->tx_buf [entry][0], skb->data, skblen);
605 /* Clear the slack of the packet, do I need this? */
606 if (len != skblen)
607 memset ((char *) &ib->tx_buf [entry][skblen], 0, len - skblen);
609 /* Now, give the packet to the lance */
610 ib->btx_ring [entry].tmd1_bits = (LE_T1_POK|LE_T1_OWN);
611 lp->tx_new = (lp->tx_new+1) & lp->tx_ring_mod_mask;
613 outs++;
615 if (TX_BUFFS_AVAIL <= 0)
616 netif_stop_queue(dev);
618 /* Kick the lance: transmit now */
619 ll->rdp = LE_C0_INEA | LE_C0_TDMD;
620 dev->trans_start = jiffies;
621 dev_kfree_skb (skb);
623 local_irq_restore(flags);
625 return status;
626 }
628 static struct net_device_stats *lance_get_stats (struct net_device *dev)
629 {
630 struct lance_private *lp = netdev_priv(dev);
632 return &lp->stats;
633 }
635 /* taken from the depca driver */
636 static void lance_load_multicast (struct net_device *dev)
637 {
638 struct lance_private *lp = netdev_priv(dev);
639 volatile struct lance_init_block *ib = lp->init_block;
640 volatile u16 *mcast_table = (u16 *)&ib->filter;
641 struct dev_mc_list *dmi=dev->mc_list;
642 char *addrs;
643 int i;
644 u32 crc;
646 /* set all multicast bits */
647 if (dev->flags & IFF_ALLMULTI){
648 ib->filter [0] = 0xffffffff;
649 ib->filter [1] = 0xffffffff;
650 return;
651 }
652 /* clear the multicast filter */
653 ib->filter [0] = 0;
654 ib->filter [1] = 0;
656 /* Add addresses */
657 for (i = 0; i < dev->mc_count; i++){
658 addrs = dmi->dmi_addr;
659 dmi = dmi->next;
661 /* multicast address? */
662 if (!(*addrs & 1))
663 continue;
665 crc = ether_crc_le(6, addrs);
666 crc = crc >> 26;
667 mcast_table [crc >> 4] |= 1 << (crc & 0xf);
668 }
669 return;
670 }
672 static void lance_set_multicast (struct net_device *dev)
673 {
674 struct lance_private *lp = netdev_priv(dev);
675 volatile struct lance_init_block *ib = lp->init_block;
676 volatile struct lance_regs *ll = lp->ll;
678 if (!netif_running(dev))
679 return;
681 if (lp->tx_old != lp->tx_new) {
682 mod_timer(&lp->multicast_timer, jiffies + 4);
683 netif_wake_queue(dev);
684 return;
685 }
687 netif_stop_queue(dev);
689 ll->rap = LE_CSR0;
690 ll->rdp = LE_C0_STOP;
691 lance_init_ring (dev);
693 if (dev->flags & IFF_PROMISC) {
694 ib->mode |= LE_MO_PROM;
695 } else {
696 ib->mode &= ~LE_MO_PROM;
697 lance_load_multicast (dev);
698 }
699 load_csrs (lp);
700 init_restart_lance (lp);
701 netif_wake_queue(dev);
702 }
704 static int __devinit a2065_init_one(struct zorro_dev *z,
705 const struct zorro_device_id *ent);
706 static void __devexit a2065_remove_one(struct zorro_dev *z);
709 static struct zorro_device_id a2065_zorro_tbl[] __devinitdata = {
710 { ZORRO_PROD_CBM_A2065_1 },
711 { ZORRO_PROD_CBM_A2065_2 },
712 { ZORRO_PROD_AMERISTAR_A2065 },
713 { 0 }
714 };
716 static struct zorro_driver a2065_driver = {
717 .name = "a2065",
718 .id_table = a2065_zorro_tbl,
719 .probe = a2065_init_one,
720 .remove = __devexit_p(a2065_remove_one),
721 };
723 static int __devinit a2065_init_one(struct zorro_dev *z,
724 const struct zorro_device_id *ent)
725 {
726 struct net_device *dev;
727 struct lance_private *priv;
728 unsigned long board, base_addr, mem_start;
729 struct resource *r1, *r2;
730 int err;
732 board = z->resource.start;
733 base_addr = board+A2065_LANCE;
734 mem_start = board+A2065_RAM;
736 r1 = request_mem_region(base_addr, sizeof(struct lance_regs),
737 "Am7990");
738 if (!r1)
739 return -EBUSY;
740 r2 = request_mem_region(mem_start, A2065_RAM_SIZE, "RAM");
741 if (!r2) {
742 release_resource(r1);
743 return -EBUSY;
744 }
746 dev = alloc_etherdev(sizeof(struct lance_private));
747 if (dev == NULL) {
748 release_resource(r1);
749 release_resource(r2);
750 return -ENOMEM;
751 }
753 SET_MODULE_OWNER(dev);
754 priv = netdev_priv(dev);
756 r1->name = dev->name;
757 r2->name = dev->name;
759 dev->dev_addr[0] = 0x00;
760 if (z->id != ZORRO_PROD_AMERISTAR_A2065) { /* Commodore */
761 dev->dev_addr[1] = 0x80;
762 dev->dev_addr[2] = 0x10;
763 } else { /* Ameristar */
764 dev->dev_addr[1] = 0x00;
765 dev->dev_addr[2] = 0x9f;
766 }
767 dev->dev_addr[3] = (z->rom.er_SerialNumber>>16) & 0xff;
768 dev->dev_addr[4] = (z->rom.er_SerialNumber>>8) & 0xff;
769 dev->dev_addr[5] = z->rom.er_SerialNumber & 0xff;
770 dev->base_addr = ZTWO_VADDR(base_addr);
771 dev->mem_start = ZTWO_VADDR(mem_start);
772 dev->mem_end = dev->mem_start+A2065_RAM_SIZE;
774 priv->ll = (volatile struct lance_regs *)dev->base_addr;
775 priv->init_block = (struct lance_init_block *)dev->mem_start;
776 priv->lance_init_block = (struct lance_init_block *)A2065_RAM;
777 priv->auto_select = 0;
778 priv->busmaster_regval = LE_C3_BSWP;
780 priv->lance_log_rx_bufs = LANCE_LOG_RX_BUFFERS;
781 priv->lance_log_tx_bufs = LANCE_LOG_TX_BUFFERS;
782 priv->rx_ring_mod_mask = RX_RING_MOD_MASK;
783 priv->tx_ring_mod_mask = TX_RING_MOD_MASK;
785 dev->open = &lance_open;
786 dev->stop = &lance_close;
787 dev->hard_start_xmit = &lance_start_xmit;
788 dev->tx_timeout = &lance_tx_timeout;
789 dev->watchdog_timeo = 5*HZ;
790 dev->get_stats = &lance_get_stats;
791 dev->set_multicast_list = &lance_set_multicast;
792 dev->dma = 0;
794 init_timer(&priv->multicast_timer);
795 priv->multicast_timer.data = (unsigned long) dev;
796 priv->multicast_timer.function =
797 (void (*)(unsigned long)) &lance_set_multicast;
799 err = register_netdev(dev);
800 if (err) {
801 release_resource(r1);
802 release_resource(r2);
803 free_netdev(dev);
804 return err;
805 }
806 zorro_set_drvdata(z, dev);
808 printk(KERN_INFO "%s: A2065 at 0x%08lx, Ethernet Address "
809 "%02x:%02x:%02x:%02x:%02x:%02x\n", dev->name, board,
810 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
811 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
813 return 0;
814 }
817 static void __devexit a2065_remove_one(struct zorro_dev *z)
818 {
819 struct net_device *dev = zorro_get_drvdata(z);
821 unregister_netdev(dev);
822 release_mem_region(ZTWO_PADDR(dev->base_addr),
823 sizeof(struct lance_regs));
824 release_mem_region(ZTWO_PADDR(dev->mem_start), A2065_RAM_SIZE);
825 free_netdev(dev);
826 }
828 static int __init a2065_init_module(void)
829 {
830 return zorro_register_driver(&a2065_driver);
831 }
833 static void __exit a2065_cleanup_module(void)
834 {
835 zorro_unregister_driver(&a2065_driver);
836 }
838 module_init(a2065_init_module);
839 module_exit(a2065_cleanup_module);
841 MODULE_LICENSE("GPL");