blob: 9d34056147ad5c4c026b74e58a59ffc99cb1ec62 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 8390.c: A general NS8390 ethernet driver core for linux. */
2/*
3 Written 1992-94 by Donald Becker.
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency.
7
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
10
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
15
Jeff Garzik6aa20a22006-09-13 13:24:59 -040016
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 This is the chip-specific code for many 8390-based ethernet adaptors.
18 This is not a complete driver, it must be combined with board-specific
19 code such as ne.c, wd.c, 3c503.c, etc.
20
21 Seeing how at least eight drivers use this code, (not counting the
22 PCMCIA ones either) it is easy to break some card by what seems like
23 a simple innocent change. Please contact me or Donald if you think
24 you have found something that needs changing. -- PG
25
26
27 Changelog:
28
29 Paul Gortmaker : remove set_bit lock, other cleanups.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040030 Paul Gortmaker : add ei_get_8390_hdr() so we can pass skb's to
Linus Torvalds1da177e2005-04-16 15:20:36 -070031 ei_block_input() for eth_io_copy_and_sum().
32 Paul Gortmaker : exchange static int ei_pingpong for a #define,
33 also add better Tx error handling.
34 Paul Gortmaker : rewrite Rx overrun handling as per NS specs.
35 Alexey Kuznetsov : use the 8390's six bit hash multicast filter.
36 Paul Gortmaker : tweak ANK's above multicast changes a bit.
37 Paul Gortmaker : update packet statistics for v2.1.x
38 Alan Cox : support arbitary stupid port mappings on the
39 68K Macintosh. Support >16bit I/O spaces
40 Paul Gortmaker : add kmod support for auto-loading of the 8390
41 module by all drivers that require it.
42 Alan Cox : Spinlocking work, added 'BUG_83C690'
43 Paul Gortmaker : Separate out Tx timeout code from Tx path.
44 Paul Gortmaker : Remove old unused single Tx buffer code.
45 Hayato Fujiwara : Add m32r support.
46 Paul Gortmaker : use skb_padto() instead of stack scratch area
47
48 Sources:
49 The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
50
51 */
52
53static const char version[] =
54 "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
55
56#include <linux/module.h>
57#include <linux/kernel.h>
58#include <linux/jiffies.h>
59#include <linux/fs.h>
60#include <linux/types.h>
61#include <linux/string.h>
62#include <linux/bitops.h>
63#include <asm/system.h>
64#include <asm/uaccess.h>
65#include <asm/io.h>
66#include <asm/irq.h>
67#include <linux/delay.h>
68#include <linux/errno.h>
69#include <linux/fcntl.h>
70#include <linux/in.h>
71#include <linux/interrupt.h>
72#include <linux/init.h>
73#include <linux/crc32.h>
74
75#include <linux/netdevice.h>
76#include <linux/etherdevice.h>
77
78#define NS8390_CORE
79#include "8390.h"
80
81#define BUG_83C690
82
83/* These are the operational function interfaces to board-specific
84 routines.
85 void reset_8390(struct net_device *dev)
86 Resets the board associated with DEV, including a hardware reset of
87 the 8390. This is only called when there is a transmit timeout, and
88 it is always followed by 8390_init().
89 void block_output(struct net_device *dev, int count, const unsigned char *buf,
90 int start_page)
91 Write the COUNT bytes of BUF to the packet buffer at START_PAGE. The
92 "page" value uses the 8390's 256-byte pages.
93 void get_8390_hdr(struct net_device *dev, struct e8390_hdr *hdr, int ring_page)
94 Read the 4 byte, page aligned 8390 header. *If* there is a
95 subsequent read, it will be of the rest of the packet.
96 void block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
Jeff Garzik6aa20a22006-09-13 13:24:59 -040097 Read COUNT bytes from the packet buffer into the skb data area. Start
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 reading from RING_OFFSET, the address as the 8390 sees it. This will always
Jeff Garzik6aa20a22006-09-13 13:24:59 -040099 follow the read of the 8390 header.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100*/
101#define ei_reset_8390 (ei_local->reset_8390)
102#define ei_block_output (ei_local->block_output)
103#define ei_block_input (ei_local->block_input)
104#define ei_get_8390_hdr (ei_local->get_8390_hdr)
105
106/* use 0 for production, 1 for verification, >2 for debug */
107#ifndef ei_debug
108int ei_debug = 1;
109#endif
110
111/* Index to functions. */
112static void ei_tx_intr(struct net_device *dev);
113static void ei_tx_err(struct net_device *dev);
114static void ei_tx_timeout(struct net_device *dev);
115static void ei_receive(struct net_device *dev);
116static void ei_rx_overrun(struct net_device *dev);
117
118/* Routines generic to NS8390-based boards. */
119static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
120 int start_page);
121static void set_multicast_list(struct net_device *dev);
122static void do_set_multicast_list(struct net_device *dev);
123
124/*
125 * SMP and the 8390 setup.
126 *
127 * The 8390 isnt exactly designed to be multithreaded on RX/TX. There is
128 * a page register that controls bank and packet buffer access. We guard
129 * this with ei_local->page_lock. Nobody should assume or set the page other
130 * than zero when the lock is not held. Lock holders must restore page 0
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400131 * before unlocking. Even pure readers must take the lock to protect in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 * page 0.
133 *
134 * To make life difficult the chip can also be very slow. We therefore can't
135 * just use spinlocks. For the longer lockups we disable the irq the device
136 * sits on and hold the lock. We must hold the lock because there is a dual
137 * processor case other than interrupts (get stats/set multicast list in
138 * parallel with each other and transmit).
139 *
140 * Note: in theory we can just disable the irq on the card _but_ there is
141 * a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs"
142 * enter lock, take the queued irq. So we waddle instead of flying.
143 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400144 * Finally by special arrangement for the purpose of being generally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 * annoying the transmit function is called bh atomic. That places
146 * restrictions on the user context callers as disable_irq won't save
147 * them.
148 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400150
151
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152/**
153 * ei_open - Open/initialize the board.
154 * @dev: network device to initialize
155 *
156 * This routine goes all-out, setting everything
157 * up anew at each open, even though many of these registers should only
158 * need to be set once at boot.
159 */
160int ei_open(struct net_device *dev)
161{
162 unsigned long flags;
163 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
164
165 /* The card I/O part of the driver (e.g. 3c503) can hook a Tx timeout
166 wrapper that does e.g. media check & then calls ei_tx_timeout. */
167 if (dev->tx_timeout == NULL)
168 dev->tx_timeout = ei_tx_timeout;
169 if (dev->watchdog_timeo <= 0)
170 dev->watchdog_timeo = TX_TIMEOUT;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 /*
173 * Grab the page lock so we own the register set, then call
174 * the init function.
175 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400176
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 spin_lock_irqsave(&ei_local->page_lock, flags);
178 NS8390_init(dev, 1);
179 /* Set the flag before we drop the lock, That way the IRQ arrives
180 after its set and we get no silly warnings */
181 netif_start_queue(dev);
182 spin_unlock_irqrestore(&ei_local->page_lock, flags);
183 ei_local->irqlock = 0;
184 return 0;
185}
186
187/**
188 * ei_close - shut down network device
189 * @dev: network device to close
190 *
191 * Opposite of ei_open(). Only used when "ifconfig <devname> down" is done.
192 */
193int ei_close(struct net_device *dev)
194{
195 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
196 unsigned long flags;
197
198 /*
199 * Hold the page lock during close
200 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 spin_lock_irqsave(&ei_local->page_lock, flags);
203 NS8390_init(dev, 0);
204 spin_unlock_irqrestore(&ei_local->page_lock, flags);
205 netif_stop_queue(dev);
206 return 0;
207}
208
209/**
210 * ei_tx_timeout - handle transmit time out condition
211 * @dev: network device which has apparently fallen asleep
212 *
213 * Called by kernel when device never acknowledges a transmit has
214 * completed (or failed) - i.e. never posted a Tx related interrupt.
215 */
216
217void ei_tx_timeout(struct net_device *dev)
218{
219 long e8390_base = dev->base_addr;
220 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
221 int txsr, isr, tickssofar = jiffies - dev->trans_start;
222 unsigned long flags;
223
224#if defined(CONFIG_M32R) && defined(CONFIG_SMP)
225 unsigned long icucr;
226
227 local_irq_save(flags);
Hirokazu Takata0adbb442005-06-21 17:16:16 -0700228 icucr = inl(M32R_ICU_CR1_PORTL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 icucr |= M32R_ICUCR_ISMOD11;
Hirokazu Takata0adbb442005-06-21 17:16:16 -0700230 outl(icucr, M32R_ICU_CR1_PORTL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 local_irq_restore(flags);
232#endif
233 ei_local->stat.tx_errors++;
234
235 spin_lock_irqsave(&ei_local->page_lock, flags);
236 txsr = inb(e8390_base+EN0_TSR);
237 isr = inb(e8390_base+EN0_ISR);
238 spin_unlock_irqrestore(&ei_local->page_lock, flags);
239
240 printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
241 dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
242 (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
243
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400244 if (!isr && !ei_local->stat.tx_packets)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 {
246 /* The 8390 probably hasn't gotten on the cable yet. */
247 ei_local->interface_num ^= 1; /* Try a different xcvr. */
248 }
249
250 /* Ugly but a reset can be slow, yet must be protected */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400251
Ingo Molnare7451652006-07-03 00:25:23 -0700252 disable_irq_nosync_lockdep(dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 spin_lock(&ei_local->page_lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400254
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 /* Try to restart the card. Perhaps the user has fixed something. */
256 ei_reset_8390(dev);
257 NS8390_init(dev, 1);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 spin_unlock(&ei_local->page_lock);
Ingo Molnare7451652006-07-03 00:25:23 -0700260 enable_irq_lockdep(dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 netif_wake_queue(dev);
262}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264/**
265 * ei_start_xmit - begin packet transmission
266 * @skb: packet to be sent
267 * @dev: network device to which packet is sent
268 *
269 * Sends a packet to an 8390 network device.
270 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272static int ei_start_xmit(struct sk_buff *skb, struct net_device *dev)
273{
274 long e8390_base = dev->base_addr;
275 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
276 int send_length = skb->len, output_page;
277 unsigned long flags;
Alan Coxaa95abe2006-06-22 14:25:34 +0100278 char buf[ETH_ZLEN];
279 char *data = skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
281 if (skb->len < ETH_ZLEN) {
Alan Coxaa95abe2006-06-22 14:25:34 +0100282 memset(buf, 0, ETH_ZLEN); /* more efficient than doing just the needed bits */
283 memcpy(buf, data, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 send_length = ETH_ZLEN;
Alan Coxaa95abe2006-06-22 14:25:34 +0100285 data = buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 }
287
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400288 /* Mask interrupts from the ethercard.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 SMP: We have to grab the lock here otherwise the IRQ handler
290 on another CPU can flip window and race the IRQ mask set. We end
291 up trashing the mcast filter not disabling irqs if we don't lock */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 spin_lock_irqsave(&ei_local->page_lock, flags);
294 outb_p(0x00, e8390_base + EN0_IMR);
295 spin_unlock_irqrestore(&ei_local->page_lock, flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400296
297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 /*
299 * Slow phase with lock held.
300 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400301
Arjan van de Vene8106b92006-09-29 02:01:08 -0700302 disable_irq_nosync_lockdep_irqsave(dev->irq, &flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400303
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 spin_lock(&ei_local->page_lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400305
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 ei_local->irqlock = 1;
307
308 /*
309 * We have two Tx slots available for use. Find the first free
310 * slot, and then perform some sanity checks. With two Tx bufs,
311 * you get very close to transmitting back-to-back packets. With
312 * only one Tx buf, the transmitter sits idle while you reload the
313 * card, leaving a substantial gap between each transmitted packet.
314 */
315
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400316 if (ei_local->tx1 == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 {
318 output_page = ei_local->tx_start_page;
319 ei_local->tx1 = send_length;
320 if (ei_debug && ei_local->tx2 > 0)
321 printk(KERN_DEBUG "%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
322 dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing);
323 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400324 else if (ei_local->tx2 == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 {
326 output_page = ei_local->tx_start_page + TX_PAGES/2;
327 ei_local->tx2 = send_length;
328 if (ei_debug && ei_local->tx1 > 0)
329 printk(KERN_DEBUG "%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
330 dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing);
331 }
332 else
333 { /* We should never get here. */
334 if (ei_debug)
335 printk(KERN_DEBUG "%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
336 dev->name, ei_local->tx1, ei_local->tx2, ei_local->lasttx);
337 ei_local->irqlock = 0;
338 netif_stop_queue(dev);
339 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
340 spin_unlock(&ei_local->page_lock);
Arjan van de Vene8106b92006-09-29 02:01:08 -0700341 enable_irq_lockdep_irqrestore(dev->irq, &flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 ei_local->stat.tx_errors++;
343 return 1;
344 }
345
346 /*
347 * Okay, now upload the packet and trigger a send if the transmitter
348 * isn't already sending. If it is busy, the interrupt handler will
349 * trigger the send later, upon receiving a Tx done interrupt.
350 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400351
Alan Coxaa95abe2006-06-22 14:25:34 +0100352 ei_block_output(dev, send_length, data, output_page);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400353
354 if (! ei_local->txing)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 {
356 ei_local->txing = 1;
357 NS8390_trigger_send(dev, send_length, output_page);
358 dev->trans_start = jiffies;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400359 if (output_page == ei_local->tx_start_page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 {
361 ei_local->tx1 = -1;
362 ei_local->lasttx = -1;
363 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400364 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 {
366 ei_local->tx2 = -1;
367 ei_local->lasttx = -2;
368 }
369 }
370 else ei_local->txqueue++;
371
372 if (ei_local->tx1 && ei_local->tx2)
373 netif_stop_queue(dev);
374 else
375 netif_start_queue(dev);
376
377 /* Turn 8390 interrupts back on. */
378 ei_local->irqlock = 0;
379 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 spin_unlock(&ei_local->page_lock);
Arjan van de Vene8106b92006-09-29 02:01:08 -0700382 enable_irq_lockdep_irqrestore(dev->irq, &flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
384 dev_kfree_skb (skb);
385 ei_local->stat.tx_bytes += send_length;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 return 0;
388}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390/**
391 * ei_interrupt - handle the interrupts from an 8390
392 * @irq: interrupt number
393 * @dev_id: a pointer to the net_device
394 * @regs: unused
395 *
396 * Handle the ether interface interrupts. We pull packets from
397 * the 8390 via the card specific functions and fire them at the networking
398 * stack. We also handle transmit completions and wake the transmit path if
399 * necessary. We also update the counters and do other housekeeping as
400 * needed.
401 */
402
403irqreturn_t ei_interrupt(int irq, void *dev_id, struct pt_regs * regs)
404{
405 struct net_device *dev = dev_id;
406 long e8390_base;
407 int interrupts, nr_serviced = 0;
408 struct ei_device *ei_local;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400409
410 if (dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 {
412 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
413 return IRQ_NONE;
414 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 e8390_base = dev->base_addr;
417 ei_local = (struct ei_device *) netdev_priv(dev);
418
419 /*
420 * Protect the irq test too.
421 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400422
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 spin_lock(&ei_local->page_lock);
424
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400425 if (ei_local->irqlock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 {
427#if 1 /* This might just be an interrupt for a PCI device sharing this line */
428 /* The "irqlock" check is only for testing. */
429 printk(ei_local->irqlock
430 ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
431 : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
432 dev->name, inb_p(e8390_base + EN0_ISR),
433 inb_p(e8390_base + EN0_IMR));
434#endif
435 spin_unlock(&ei_local->page_lock);
436 return IRQ_NONE;
437 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 /* Change to page 0 and read the intr status reg. */
440 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
441 if (ei_debug > 3)
442 printk(KERN_DEBUG "%s: interrupt(isr=%#2.2x).\n", dev->name,
443 inb_p(e8390_base + EN0_ISR));
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400444
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 /* !!Assumption!! -- we stay in page 0. Don't break this. */
446 while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400447 && ++nr_serviced < MAX_SERVICE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 {
449 if (!netif_running(dev)) {
450 printk(KERN_WARNING "%s: interrupt from stopped card\n", dev->name);
451 /* rmk - acknowledge the interrupts */
452 outb_p(interrupts, e8390_base + EN0_ISR);
453 interrupts = 0;
454 break;
455 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400456 if (interrupts & ENISR_OVER)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 ei_rx_overrun(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400458 else if (interrupts & (ENISR_RX+ENISR_RX_ERR))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 {
460 /* Got a good (?) packet. */
461 ei_receive(dev);
462 }
463 /* Push the next to-transmit packet through. */
464 if (interrupts & ENISR_TX)
465 ei_tx_intr(dev);
466 else if (interrupts & ENISR_TX_ERR)
467 ei_tx_err(dev);
468
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400469 if (interrupts & ENISR_COUNTERS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 {
471 ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
472 ei_local->stat.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1);
473 ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
474 outb_p(ENISR_COUNTERS, e8390_base + EN0_ISR); /* Ack intr. */
475 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 /* Ignore any RDC interrupts that make it back to here. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400478 if (interrupts & ENISR_RDC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 {
480 outb_p(ENISR_RDC, e8390_base + EN0_ISR);
481 }
482
483 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
484 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400485
486 if (interrupts && ei_debug)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 {
488 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400489 if (nr_serviced >= MAX_SERVICE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 {
491 /* 0xFF is valid for a card removal */
492 if(interrupts!=0xFF)
493 printk(KERN_WARNING "%s: Too much work at interrupt, status %#2.2x\n",
494 dev->name, interrupts);
495 outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */
496 } else {
497 printk(KERN_WARNING "%s: unknown interrupt %#2x\n", dev->name, interrupts);
498 outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
499 }
500 }
501 spin_unlock(&ei_local->page_lock);
502 return IRQ_RETVAL(nr_serviced > 0);
503}
504
505#ifdef CONFIG_NET_POLL_CONTROLLER
506void ei_poll(struct net_device *dev)
507{
Arjan van de Ven22ad8522006-07-05 20:36:40 +0200508 disable_irq_lockdep(dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 ei_interrupt(dev->irq, dev, NULL);
Arjan van de Ven22ad8522006-07-05 20:36:40 +0200510 enable_irq_lockdep(dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511}
512#endif
513
514/**
515 * ei_tx_err - handle transmitter error
516 * @dev: network device which threw the exception
517 *
518 * A transmitter error has happened. Most likely excess collisions (which
519 * is a fairly normal condition). If the error is one where the Tx will
520 * have been aborted, we try and send another one right away, instead of
521 * letting the failed packet sit and collect dust in the Tx buffer. This
522 * is a much better solution as it avoids kernel based Tx timeouts, and
523 * an unnecessary card reset.
524 *
525 * Called with lock held.
526 */
527
528static void ei_tx_err(struct net_device *dev)
529{
530 long e8390_base = dev->base_addr;
531 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
532 unsigned char txsr = inb_p(e8390_base+EN0_TSR);
533 unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU);
534
535#ifdef VERBOSE_ERROR_DUMP
536 printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr);
537 if (txsr & ENTSR_ABT)
538 printk("excess-collisions ");
539 if (txsr & ENTSR_ND)
540 printk("non-deferral ");
541 if (txsr & ENTSR_CRS)
542 printk("lost-carrier ");
543 if (txsr & ENTSR_FU)
544 printk("FIFO-underrun ");
545 if (txsr & ENTSR_CDH)
546 printk("lost-heartbeat ");
547 printk("\n");
548#endif
549
550 outb_p(ENISR_TX_ERR, e8390_base + EN0_ISR); /* Ack intr. */
551
552 if (tx_was_aborted)
553 ei_tx_intr(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400554 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 {
556 ei_local->stat.tx_errors++;
557 if (txsr & ENTSR_CRS) ei_local->stat.tx_carrier_errors++;
558 if (txsr & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++;
559 if (txsr & ENTSR_OWC) ei_local->stat.tx_window_errors++;
560 }
561}
562
563/**
564 * ei_tx_intr - transmit interrupt handler
565 * @dev: network device for which tx intr is handled
566 *
567 * We have finished a transmit: check for errors and then trigger the next
568 * packet to be sent. Called with lock held.
569 */
570
571static void ei_tx_intr(struct net_device *dev)
572{
573 long e8390_base = dev->base_addr;
574 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
575 int status = inb(e8390_base + EN0_TSR);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 outb_p(ENISR_TX, e8390_base + EN0_ISR); /* Ack intr. */
578
579 /*
580 * There are two Tx buffers, see which one finished, and trigger
581 * the send of another one if it exists.
582 */
583 ei_local->txqueue--;
584
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400585 if (ei_local->tx1 < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 {
587 if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
588 printk(KERN_ERR "%s: bogus last_tx_buffer %d, tx1=%d.\n",
589 ei_local->name, ei_local->lasttx, ei_local->tx1);
590 ei_local->tx1 = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400591 if (ei_local->tx2 > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 {
593 ei_local->txing = 1;
594 NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
595 dev->trans_start = jiffies;
596 ei_local->tx2 = -1,
597 ei_local->lasttx = 2;
598 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400599 else ei_local->lasttx = 20, ei_local->txing = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400601 else if (ei_local->tx2 < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 {
603 if (ei_local->lasttx != 2 && ei_local->lasttx != -2)
604 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
605 ei_local->name, ei_local->lasttx, ei_local->tx2);
606 ei_local->tx2 = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400607 if (ei_local->tx1 > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 {
609 ei_local->txing = 1;
610 NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
611 dev->trans_start = jiffies;
612 ei_local->tx1 = -1;
613 ei_local->lasttx = 1;
614 }
615 else
616 ei_local->lasttx = 10, ei_local->txing = 0;
617 }
618// else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n",
619// dev->name, ei_local->lasttx);
620
621 /* Minimize Tx latency: update the statistics after we restart TXing. */
622 if (status & ENTSR_COL)
623 ei_local->stat.collisions++;
624 if (status & ENTSR_PTX)
625 ei_local->stat.tx_packets++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400626 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 {
628 ei_local->stat.tx_errors++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400629 if (status & ENTSR_ABT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 {
631 ei_local->stat.tx_aborted_errors++;
632 ei_local->stat.collisions += 16;
633 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400634 if (status & ENTSR_CRS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 ei_local->stat.tx_carrier_errors++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400636 if (status & ENTSR_FU)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 ei_local->stat.tx_fifo_errors++;
638 if (status & ENTSR_CDH)
639 ei_local->stat.tx_heartbeat_errors++;
640 if (status & ENTSR_OWC)
641 ei_local->stat.tx_window_errors++;
642 }
643 netif_wake_queue(dev);
644}
645
646/**
647 * ei_receive - receive some packets
648 * @dev: network device with which receive will be run
649 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400650 * We have a good packet(s), get it/them out of the buffers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 * Called with lock held.
652 */
653
654static void ei_receive(struct net_device *dev)
655{
656 long e8390_base = dev->base_addr;
657 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
658 unsigned char rxing_page, this_frame, next_frame;
659 unsigned short current_offset;
660 int rx_pkt_count = 0;
661 struct e8390_pkt_hdr rx_frame;
662 int num_rx_pages = ei_local->stop_page-ei_local->rx_start_page;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400663
664 while (++rx_pkt_count < 10)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 {
666 int pkt_len, pkt_stat;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400667
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 /* Get the rx page (incoming packet pointer). */
669 outb_p(E8390_NODMA+E8390_PAGE1, e8390_base + E8390_CMD);
670 rxing_page = inb_p(e8390_base + EN1_CURPAG);
671 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400672
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 /* Remove one frame from the ring. Boundary is always a page behind. */
674 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
675 if (this_frame >= ei_local->stop_page)
676 this_frame = ei_local->rx_start_page;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400677
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 /* Someday we'll omit the previous, iff we never get this message.
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400679 (There is at least one clone claimed to have a problem.)
680
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 Keep quiet if it looks like a card removal. One problem here
682 is that some clones crash in roughly the same way.
683 */
684 if (ei_debug > 0 && this_frame != ei_local->current_page && (this_frame!=0x0 || rxing_page!=0xFF))
685 printk(KERN_ERR "%s: mismatched read page pointers %2x vs %2x.\n",
686 dev->name, this_frame, ei_local->current_page);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400687
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 if (this_frame == rxing_page) /* Read all the frames? */
689 break; /* Done for now */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400690
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 current_offset = this_frame << 8;
692 ei_get_8390_hdr(dev, &rx_frame, this_frame);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400693
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
695 pkt_stat = rx_frame.status;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400696
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400698
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 /* Check for bogosity warned by 3c503 book: the status byte is never
700 written. This happened a lot during testing! This code should be
701 cleaned up someday. */
702 if (rx_frame.next != next_frame
703 && rx_frame.next != next_frame + 1
704 && rx_frame.next != next_frame - num_rx_pages
705 && rx_frame.next != next_frame + 1 - num_rx_pages) {
706 ei_local->current_page = rxing_page;
707 outb(ei_local->current_page-1, e8390_base+EN0_BOUNDARY);
708 ei_local->stat.rx_errors++;
709 continue;
710 }
711
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400712 if (pkt_len < 60 || pkt_len > 1518)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 {
714 if (ei_debug)
715 printk(KERN_DEBUG "%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
716 dev->name, rx_frame.count, rx_frame.status,
717 rx_frame.next);
718 ei_local->stat.rx_errors++;
719 ei_local->stat.rx_length_errors++;
720 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400721 else if ((pkt_stat & 0x0F) == ENRSR_RXOK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 {
723 struct sk_buff *skb;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400724
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 skb = dev_alloc_skb(pkt_len+2);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400726 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 {
728 if (ei_debug > 1)
729 printk(KERN_DEBUG "%s: Couldn't allocate a sk_buff of size %d.\n",
730 dev->name, pkt_len);
731 ei_local->stat.rx_dropped++;
732 break;
733 }
734 else
735 {
736 skb_reserve(skb,2); /* IP headers on 16 byte boundaries */
737 skb->dev = dev;
738 skb_put(skb, pkt_len); /* Make room */
739 ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
740 skb->protocol=eth_type_trans(skb,dev);
741 netif_rx(skb);
742 dev->last_rx = jiffies;
743 ei_local->stat.rx_packets++;
744 ei_local->stat.rx_bytes += pkt_len;
745 if (pkt_stat & ENRSR_PHY)
746 ei_local->stat.multicast++;
747 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400748 }
749 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 {
751 if (ei_debug)
752 printk(KERN_DEBUG "%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
753 dev->name, rx_frame.status, rx_frame.next,
754 rx_frame.count);
755 ei_local->stat.rx_errors++;
756 /* NB: The NIC counts CRC, frame and missed errors. */
757 if (pkt_stat & ENRSR_FO)
758 ei_local->stat.rx_fifo_errors++;
759 }
760 next_frame = rx_frame.next;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400761
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 /* This _should_ never happen: it's here for avoiding bad clones. */
763 if (next_frame >= ei_local->stop_page) {
764 printk("%s: next frame inconsistency, %#2x\n", dev->name,
765 next_frame);
766 next_frame = ei_local->rx_start_page;
767 }
768 ei_local->current_page = next_frame;
769 outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
770 }
771
772 /* We used to also ack ENISR_OVER here, but that would sometimes mask
773 a real overrun, leaving the 8390 in a stopped state with rec'vr off. */
774 outb_p(ENISR_RX+ENISR_RX_ERR, e8390_base+EN0_ISR);
775 return;
776}
777
778/**
779 * ei_rx_overrun - handle receiver overrun
780 * @dev: network device which threw exception
781 *
782 * We have a receiver overrun: we have to kick the 8390 to get it started
783 * again. Problem is that you have to kick it exactly as NS prescribes in
784 * the updated datasheets, or "the NIC may act in an unpredictable manner."
785 * This includes causing "the NIC to defer indefinitely when it is stopped
786 * on a busy network." Ugh.
787 * Called with lock held. Don't call this with the interrupts off or your
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400788 * computer will hate you - it takes 10ms or so.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 */
790
791static void ei_rx_overrun(struct net_device *dev)
792{
793 long e8390_base = dev->base_addr;
794 unsigned char was_txing, must_resend = 0;
795 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400796
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 /*
798 * Record whether a Tx was in progress and then issue the
799 * stop command.
800 */
801 was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS;
802 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400803
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 if (ei_debug > 1)
805 printk(KERN_DEBUG "%s: Receiver overrun.\n", dev->name);
806 ei_local->stat.rx_over_errors++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400807
808 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
810 * Early datasheets said to poll the reset bit, but now they say that
811 * it "is not a reliable indicator and subsequently should be ignored."
812 * We wait at least 10ms.
813 */
814
815 mdelay(10);
816
817 /*
818 * Reset RBCR[01] back to zero as per magic incantation.
819 */
820 outb_p(0x00, e8390_base+EN0_RCNTLO);
821 outb_p(0x00, e8390_base+EN0_RCNTHI);
822
823 /*
824 * See if any Tx was interrupted or not. According to NS, this
825 * step is vital, and skipping it will cause no end of havoc.
826 */
827
828 if (was_txing)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400829 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR);
831 if (!tx_completed)
832 must_resend = 1;
833 }
834
835 /*
836 * Have to enter loopback mode and then restart the NIC before
837 * you are allowed to slurp packets up off the ring.
838 */
839 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
840 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
841
842 /*
843 * Clear the Rx ring of all the debris, and ack the interrupt.
844 */
845 ei_receive(dev);
846 outb_p(ENISR_OVER, e8390_base+EN0_ISR);
847
848 /*
849 * Leave loopback mode, and resend any packet that got stopped.
850 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400851 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 if (must_resend)
853 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD);
854}
855
856/*
857 * Collect the stats. This is called unlocked and from several contexts.
858 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400859
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860static struct net_device_stats *get_stats(struct net_device *dev)
861{
862 long ioaddr = dev->base_addr;
863 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
864 unsigned long flags;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400865
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 /* If the card is stopped, just return the present stats. */
867 if (!netif_running(dev))
868 return &ei_local->stat;
869
870 spin_lock_irqsave(&ei_local->page_lock,flags);
871 /* Read the counter registers, assuming we are in page 0. */
872 ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
873 ei_local->stat.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1);
874 ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
875 spin_unlock_irqrestore(&ei_local->page_lock, flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400876
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 return &ei_local->stat;
878}
879
880/*
881 * Form the 64 bit 8390 multicast table from the linked list of addresses
882 * associated with this dev structure.
883 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400884
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885static inline void make_mc_bits(u8 *bits, struct net_device *dev)
886{
887 struct dev_mc_list *dmi;
888
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400889 for (dmi=dev->mc_list; dmi; dmi=dmi->next)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 {
891 u32 crc;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400892 if (dmi->dmi_addrlen != ETH_ALEN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 {
894 printk(KERN_INFO "%s: invalid multicast address length given.\n", dev->name);
895 continue;
896 }
897 crc = ether_crc(ETH_ALEN, dmi->dmi_addr);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400898 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 * The 8390 uses the 6 most significant bits of the
900 * CRC to index the multicast table.
901 */
902 bits[crc>>29] |= (1<<((crc>>26)&7));
903 }
904}
905
906/**
907 * do_set_multicast_list - set/clear multicast filter
908 * @dev: net device for which multicast filter is adjusted
909 *
910 * Set or clear the multicast filter for this adaptor. May be called
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400911 * from a BH in 2.1.x. Must be called with lock held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400913
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914static void do_set_multicast_list(struct net_device *dev)
915{
916 long e8390_base = dev->base_addr;
917 int i;
918 struct ei_device *ei_local = (struct ei_device*)netdev_priv(dev);
919
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400920 if (!(dev->flags&(IFF_PROMISC|IFF_ALLMULTI)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 {
922 memset(ei_local->mcfilter, 0, 8);
923 if (dev->mc_list)
924 make_mc_bits(ei_local->mcfilter, dev);
925 }
926 else
927 memset(ei_local->mcfilter, 0xFF, 8); /* mcast set to accept-all */
928
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400929 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 * DP8390 manuals don't specify any magic sequence for altering
931 * the multicast regs on an already running card. To be safe, we
932 * ensure multicast mode is off prior to loading up the new hash
933 * table. If this proves to be not enough, we can always resort
934 * to stopping the NIC, loading the table and then restarting.
935 *
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400936 * Bug Alert! The MC regs on the SMC 83C690 (SMC Elite and SMC
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 * Elite16) appear to be write-only. The NS 8390 data sheet lists
938 * them as r/w so this is a bug. The SMC 83C790 (SMC Ultra and
939 * Ultra32 EISA) appears to have this bug fixed.
940 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400941
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 if (netif_running(dev))
943 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
944 outb_p(E8390_NODMA + E8390_PAGE1, e8390_base + E8390_CMD);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400945 for(i = 0; i < 8; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 {
947 outb_p(ei_local->mcfilter[i], e8390_base + EN1_MULT_SHIFT(i));
948#ifndef BUG_83C690
949 if(inb_p(e8390_base + EN1_MULT_SHIFT(i))!=ei_local->mcfilter[i])
950 printk(KERN_ERR "Multicast filter read/write mismap %d\n",i);
951#endif
952 }
953 outb_p(E8390_NODMA + E8390_PAGE0, e8390_base + E8390_CMD);
954
955 if(dev->flags&IFF_PROMISC)
956 outb_p(E8390_RXCONFIG | 0x18, e8390_base + EN0_RXCR);
957 else if(dev->flags&IFF_ALLMULTI || dev->mc_list)
958 outb_p(E8390_RXCONFIG | 0x08, e8390_base + EN0_RXCR);
959 else
960 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
961 }
962
963/*
964 * Called without lock held. This is invoked from user context and may
965 * be parallel to just about everything else. Its also fairly quick and
966 * not called too often. Must protect against both bh and irq users
967 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400968
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969static void set_multicast_list(struct net_device *dev)
970{
971 unsigned long flags;
972 struct ei_device *ei_local = (struct ei_device*)netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400973
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 spin_lock_irqsave(&ei_local->page_lock, flags);
975 do_set_multicast_list(dev);
976 spin_unlock_irqrestore(&ei_local->page_lock, flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400977}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
979/**
980 * ethdev_setup - init rest of 8390 device struct
981 * @dev: network device structure to init
982 *
983 * Initialize the rest of the 8390 device structure. Do NOT __init
984 * this, as it is used by 8390 based modular drivers too.
985 */
986
987static void ethdev_setup(struct net_device *dev)
988{
989 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
990 if (ei_debug > 1)
991 printk(version);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400992
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 dev->hard_start_xmit = &ei_start_xmit;
994 dev->get_stats = get_stats;
995 dev->set_multicast_list = &set_multicast_list;
996
997 ether_setup(dev);
998
999 spin_lock_init(&ei_local->page_lock);
1000}
1001
1002/**
1003 * alloc_ei_netdev - alloc_etherdev counterpart for 8390
1004 * @size: extra bytes to allocate
1005 *
1006 * Allocate 8390-specific net_device.
1007 */
1008struct net_device *__alloc_ei_netdev(int size)
1009{
1010 return alloc_netdev(sizeof(struct ei_device) + size, "eth%d",
1011 ethdev_setup);
1012}
1013
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
1016
1017/* This page of functions should be 8390 generic */
1018/* Follow National Semi's recommendations for initializing the "NIC". */
1019
1020/**
1021 * NS8390_init - initialize 8390 hardware
1022 * @dev: network device to initialize
1023 * @startp: boolean. non-zero value to initiate chip processing
1024 *
1025 * Must be called with lock held.
1026 */
1027
1028void NS8390_init(struct net_device *dev, int startp)
1029{
1030 long e8390_base = dev->base_addr;
1031 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1032 int i;
1033 int endcfg = ei_local->word16
1034 ? (0x48 | ENDCFG_WTS | (ei_local->bigendian ? ENDCFG_BOS : 0))
1035 : 0x48;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001036
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 if(sizeof(struct e8390_pkt_hdr)!=4)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001038 panic("8390.c: header struct mispacked\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 /* Follow National Semi's recommendations for initing the DP83902. */
1040 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); /* 0x21 */
1041 outb_p(endcfg, e8390_base + EN0_DCFG); /* 0x48 or 0x49 */
1042 /* Clear the remote byte count registers. */
1043 outb_p(0x00, e8390_base + EN0_RCNTLO);
1044 outb_p(0x00, e8390_base + EN0_RCNTHI);
1045 /* Set to monitor and loopback mode -- this is vital!. */
1046 outb_p(E8390_RXOFF, e8390_base + EN0_RXCR); /* 0x20 */
1047 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
1048 /* Set the transmit page and receive ring. */
1049 outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
1050 ei_local->tx1 = ei_local->tx2 = 0;
1051 outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
1052 outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/
1053 ei_local->current_page = ei_local->rx_start_page; /* assert boundary+1 */
1054 outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
1055 /* Clear the pending interrupts and mask. */
1056 outb_p(0xFF, e8390_base + EN0_ISR);
1057 outb_p(0x00, e8390_base + EN0_IMR);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001058
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 /* Copy the station address into the DS8390 registers. */
1060
1061 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base+E8390_CMD); /* 0x61 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001062 for(i = 0; i < 6; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 {
1064 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS_SHIFT(i));
1065 if (ei_debug > 1 && inb_p(e8390_base + EN1_PHYS_SHIFT(i))!=dev->dev_addr[i])
1066 printk(KERN_ERR "Hw. address read/write mismap %d\n",i);
1067 }
1068
1069 outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
1070 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1071
1072 netif_start_queue(dev);
1073 ei_local->tx1 = ei_local->tx2 = 0;
1074 ei_local->txing = 0;
1075
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001076 if (startp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 {
1078 outb_p(0xff, e8390_base + EN0_ISR);
1079 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1080 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1081 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
1082 /* 3c503 TechMan says rxconfig only after the NIC is started. */
1083 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR); /* rx on, */
1084 do_set_multicast_list(dev); /* (re)load the mcast table */
1085 }
1086}
1087
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001088/* Trigger a transmit start, assuming the length is valid.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 Always called with the page lock held */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001090
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
1092 int start_page)
1093{
1094 long e8390_base = dev->base_addr;
1095 struct ei_device *ei_local __attribute((unused)) = (struct ei_device *) netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001096
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base+E8390_CMD);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001098
1099 if (inb_p(e8390_base + E8390_CMD) & E8390_TRANS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 {
1101 printk(KERN_WARNING "%s: trigger_send() called with the transmitter busy.\n",
1102 dev->name);
1103 return;
1104 }
1105 outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
1106 outb_p(length >> 8, e8390_base + EN0_TCNTHI);
1107 outb_p(start_page, e8390_base + EN0_TPSR);
1108 outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base+E8390_CMD);
1109}
1110
1111EXPORT_SYMBOL(ei_open);
1112EXPORT_SYMBOL(ei_close);
1113EXPORT_SYMBOL(ei_interrupt);
1114#ifdef CONFIG_NET_POLL_CONTROLLER
1115EXPORT_SYMBOL(ei_poll);
1116#endif
1117EXPORT_SYMBOL(NS8390_init);
1118EXPORT_SYMBOL(__alloc_ei_netdev);
1119
1120#if defined(MODULE)
1121
1122int init_module(void)
1123{
1124 return 0;
1125}
1126
1127void cleanup_module(void)
1128{
1129}
1130
1131#endif /* MODULE */
1132MODULE_LICENSE("GPL");