blob: bed8e0ebaf1979b6b1c2200e06b30ca10ba4f4ec [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* at1700.c: A network device driver for the Allied Telesis AT1700.
2
3 Written 1993-98 by Donald Becker.
4
5 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
16 This is a device driver for the Allied Telesis AT1700, and
17 Fujitsu FMV-181/182/181A/182A/183/184/183A/184A, which are
18 straight-forward Fujitsu MB86965 implementations.
19
20 Modification for Fujitsu FMV-18X cards is done by Yutaka Tamiya
Jeff Garzik6aa20a22006-09-13 13:24:59 -040021 (tamy@flab.fujitsu.co.jp).
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
23 Sources:
24 The Fujitsu MB86965 datasheet.
25
26 After the initial version of this driver was written Gerry Sawkins of
27 ATI provided their EEPROM configuration code header file.
28 Thanks to NIIBE Yutaka <gniibe@mri.co.jp> for bug fixes.
29
30 MCA bus (AT1720) support by Rene Schmit <rene@bss.lu>
31
32 Bugs:
33 The MB86965 has a design flaw that makes all probes unreliable. Not
34 only is it difficult to detect, it also moves around in I/O space in
35 response to inb()s from other device probes!
36*/
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/errno.h>
39#include <linux/netdevice.h>
40#include <linux/etherdevice.h>
41#include <linux/mca-legacy.h>
42#include <linux/module.h>
43#include <linux/kernel.h>
44#include <linux/types.h>
45#include <linux/fcntl.h>
46#include <linux/interrupt.h>
47#include <linux/ioport.h>
48#include <linux/in.h>
49#include <linux/skbuff.h>
50#include <linux/slab.h>
51#include <linux/string.h>
52#include <linux/init.h>
53#include <linux/crc32.h>
54#include <linux/bitops.h>
55
56#include <asm/system.h>
57#include <asm/io.h>
58#include <asm/dma.h>
59
60static char version[] __initdata =
Andy Gospodarekd5b20692006-09-11 17:39:18 -040061 "at1700.c:v1.16 9/11/06 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63#define DRV_NAME "at1700"
64
65/* Tunable parameters. */
66
67/* When to switch from the 64-entry multicast filter to Rx-all-multicast. */
68#define MC_FILTERBREAK 64
69
70/* These unusual address orders are used to verify the CONFIG register. */
71
72static int fmv18x_probe_list[] __initdata = {
73 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
74};
75
76/*
77 * ISA
78 */
79
80static unsigned at1700_probe_list[] __initdata = {
81 0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
82};
83
84/*
85 * MCA
86 */
87#ifdef CONFIG_MCA_LEGACY
88static int at1700_ioaddr_pattern[] __initdata = {
89 0x00, 0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07
90};
91
92static int at1700_mca_probe_list[] __initdata = {
93 0x400, 0x1400, 0x2400, 0x3400, 0x4400, 0x5400, 0x6400, 0x7400, 0
94};
95
96static int at1700_irq_pattern[] __initdata = {
97 0x00, 0x00, 0x00, 0x30, 0x70, 0xb0, 0x00, 0x00,
98 0x00, 0xf0, 0x34, 0x74, 0xb4, 0x00, 0x00, 0xf4, 0x00
99};
100#endif
101
102/* use 0 for production, 1 for verification, >2 for debug */
103#ifndef NET_DEBUG
104#define NET_DEBUG 1
105#endif
106static unsigned int net_debug = NET_DEBUG;
107
108typedef unsigned char uchar;
109
110/* Information that need to be kept for each board. */
111struct net_local {
112 struct net_device_stats stats;
113 spinlock_t lock;
114 unsigned char mc_filter[8];
115 uint jumpered:1; /* Set iff the board has jumper config. */
116 uint tx_started:1; /* Packets are on the Tx queue. */
117 uint tx_queue_ready:1; /* Tx queue is ready to be sent. */
118 uint rx_started:1; /* Packets are Rxing. */
119 uchar tx_queue; /* Number of packet on the Tx queue. */
120 char mca_slot; /* -1 means ISA */
121 ushort tx_queue_len; /* Current length of the Tx queue. */
122};
123
124
125/* Offsets from the base address. */
126#define STATUS 0
127#define TX_STATUS 0
128#define RX_STATUS 1
129#define TX_INTR 2 /* Bit-mapped interrupt enable registers. */
130#define RX_INTR 3
131#define TX_MODE 4
132#define RX_MODE 5
133#define CONFIG_0 6 /* Misc. configuration settings. */
134#define CONFIG_1 7
135/* Run-time register bank 2 definitions. */
136#define DATAPORT 8 /* Word-wide DMA or programmed-I/O dataport. */
137#define TX_START 10
138#define COL16CNTL 11 /* Controll Reg for 16 collisions */
139#define MODE13 13
140#define RX_CTRL 14
141/* Configuration registers only on the '865A/B chips. */
142#define EEPROM_Ctrl 16
143#define EEPROM_Data 17
144#define CARDSTATUS 16 /* FMV-18x Card Status */
145#define CARDSTATUS1 17 /* FMV-18x Card Status */
146#define IOCONFIG 18 /* Either read the jumper, or move the I/O. */
147#define IOCONFIG1 19
148#define SAPROM 20 /* The station address PROM, if no EEPROM. */
149#define MODE24 24
150#define RESET 31 /* Write to reset some parts of the chip. */
151#define AT1700_IO_EXTENT 32
152#define PORT_OFFSET(o) (o)
153
154
155#define TX_TIMEOUT 10
156
157
158/* Index to functions, as function prototypes. */
159
160static int at1700_probe1(struct net_device *dev, int ioaddr);
161static int read_eeprom(long ioaddr, int location);
162static int net_open(struct net_device *dev);
163static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100164static irqreturn_t net_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165static void net_rx(struct net_device *dev);
166static int net_close(struct net_device *dev);
167static struct net_device_stats *net_get_stats(struct net_device *dev);
168static void set_rx_mode(struct net_device *dev);
169static void net_tx_timeout (struct net_device *dev);
170
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172#ifdef CONFIG_MCA_LEGACY
173struct at1720_mca_adapters_struct {
174 char* name;
175 int id;
176};
177/* rEnE : maybe there are others I don't know off... */
178
179static struct at1720_mca_adapters_struct at1720_mca_adapters[] __initdata = {
180 { "Allied Telesys AT1720AT", 0x6410 },
181 { "Allied Telesys AT1720BT", 0x6413 },
182 { "Allied Telesys AT1720T", 0x6416 },
183 { NULL, 0 },
184};
185#endif
186
187/* Check for a network adaptor of this type, and return '0' iff one exists.
188 If dev->base_addr == 0, probe all likely locations.
189 If dev->base_addr == 1, always return failure.
190 If dev->base_addr == 2, allocate space for the device and return success
191 (detachable devices only).
192 */
193
194static int io = 0x260;
195
196static int irq;
197
198static void cleanup_card(struct net_device *dev)
199{
200#ifdef CONFIG_MCA_LEGACY
201 struct net_local *lp = netdev_priv(dev);
202 if (lp->mca_slot >= 0)
203 mca_mark_as_unused(lp->mca_slot);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400204#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 free_irq(dev->irq, NULL);
206 release_region(dev->base_addr, AT1700_IO_EXTENT);
207}
208
209struct net_device * __init at1700_probe(int unit)
210{
211 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
212 unsigned *port;
213 int err = 0;
214
215 if (!dev)
216 return ERR_PTR(-ENODEV);
217
218 if (unit >= 0) {
219 sprintf(dev->name, "eth%d", unit);
220 netdev_boot_setup_check(dev);
221 io = dev->base_addr;
222 irq = dev->irq;
223 } else {
224 dev->base_addr = io;
225 dev->irq = irq;
226 }
227
228 SET_MODULE_OWNER(dev);
229
230 if (io > 0x1ff) { /* Check a single specified location. */
231 err = at1700_probe1(dev, io);
232 } else if (io != 0) { /* Don't probe at all. */
233 err = -ENXIO;
234 } else {
235 for (port = at1700_probe_list; *port; port++) {
236 if (at1700_probe1(dev, *port) == 0)
237 break;
238 dev->irq = irq;
239 }
240 if (!*port)
241 err = -ENODEV;
242 }
243 if (err)
244 goto out;
245 err = register_netdev(dev);
246 if (err)
247 goto out1;
248 return dev;
249out1:
250 cleanup_card(dev);
251out:
252 free_netdev(dev);
253 return ERR_PTR(err);
254}
255
256/* The Fujitsu datasheet suggests that the NIC be probed for by checking its
257 "signature", the default bit pattern after a reset. This *doesn't* work --
258 there is no way to reset the bus interface without a complete power-cycle!
259
260 It turns out that ATI came to the same conclusion I did: the only thing
261 that can be done is checking a few bits and then diving right into an
262 EEPROM read. */
263
264static int __init at1700_probe1(struct net_device *dev, int ioaddr)
265{
266 char fmv_irqmap[4] = {3, 7, 10, 15};
267 char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
268 char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
269 unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
270 int slot, ret = -ENODEV;
271 struct net_local *lp = netdev_priv(dev);
272
273 if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
274 return -EBUSY;
275
276 /* Resetting the chip doesn't reset the ISA interface, so don't bother.
277 That means we have to be careful with the register values we probe
278 for.
279 */
280#ifdef notdef
281 printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
282 ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
283 read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
284#endif
285
286#ifdef CONFIG_MCA_LEGACY
287 /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
288
289 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
290 modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
291 to support standard MCA probing. */
292
293 /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
294 /* now works as a module */
295
296 if (MCA_bus) {
297 int j;
298 int l_i;
299 u_char pos3, pos4;
300
301 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
302 slot = 0;
303 while (slot != MCA_NOTFOUND) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400304
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
306 if (slot == MCA_NOTFOUND) break;
307
308 /* if we get this far, an adapter has been detected and is
309 enabled */
310
311 pos3 = mca_read_stored_pos( slot, 3 );
312 pos4 = mca_read_stored_pos( slot, 4 );
313
314 for (l_i = 0; l_i < 0x09; l_i++)
315 if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
316 break;
317 ioaddr = at1700_mca_probe_list[l_i];
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 for (irq = 0; irq < 0x10; irq++)
320 if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
321 break;
322
323 /* probing for a card at a particular IO/IRQ */
324 if ((dev->irq && dev->irq != irq) ||
325 (dev->base_addr && dev->base_addr != ioaddr)) {
326 slot++; /* probing next slot */
327 continue;
328 }
329
330 dev->irq = irq;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400331
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 /* claim the slot */
333 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
334 mca_mark_as_used(slot);
335
336 goto found;
337 }
338 }
339 /* if we get here, we didn't find an MCA adapter - try ISA */
340 }
341#endif
342 slot = -1;
343 /* We must check for the EEPROM-config boards first, else accessing
344 IOCONFIG0 will move the board! */
345 if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr
346 && read_eeprom(ioaddr, 4) == 0x0000
347 && (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
348 is_at1700 = 1;
349 else if (inb(ioaddr + SAPROM ) == 0x00
350 && inb(ioaddr + SAPROM + 1) == 0x00
351 && inb(ioaddr + SAPROM + 2) == 0x0e)
352 is_fmv18x = 1;
353 else {
354 goto err_out;
355 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400356
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357#ifdef CONFIG_MCA_LEGACY
358found:
359#endif
360
361 /* Reset the internal state machines. */
362 outb(0, ioaddr + RESET);
363
364 if (is_at1700) {
365 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
366 | (read_eeprom(ioaddr, 0)>>14)];
367 } else {
368 /* Check PnP mode for FMV-183/184/183A/184A. */
369 /* This PnP routine is very poor. IO and IRQ should be known. */
370 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
371 irq = dev->irq;
372 for (i = 0; i < 8; i++) {
373 if (irq == fmv_irqmap_pnp[i])
374 break;
375 }
376 if (i == 8) {
377 goto err_mca;
378 }
379 } else {
380 if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
381 goto err_mca;
382 irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
383 }
384 }
385
386 printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
387 is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
388
389 dev->base_addr = ioaddr;
390 dev->irq = irq;
391
392 if (is_at1700) {
393 for(i = 0; i < 3; i++) {
394 unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
395 printk("%04x", eeprom_val);
396 ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
397 }
398 } else {
399 for(i = 0; i < 6; i++) {
400 unsigned char val = inb(ioaddr + SAPROM + i);
401 printk("%02x", val);
402 dev->dev_addr[i] = val;
403 }
404 }
405
406 /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
407 rather than 150 ohm shielded twisted pair compensation.
408 0x0000 == auto-sense the interface
409 0x0800 == use TP interface
410 0x1800 == use coax interface
411 */
412 {
413 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
414 if (is_at1700) {
415 ushort setup_value = read_eeprom(ioaddr, 12);
416 dev->if_port = setup_value >> 8;
417 } else {
418 ushort setup_value = inb(ioaddr + CARDSTATUS);
419 switch (setup_value & 0x07) {
420 case 0x01: /* 10base5 */
421 case 0x02: /* 10base2 */
422 dev->if_port = 0x18; break;
423 case 0x04: /* 10baseT */
424 dev->if_port = 0x08; break;
425 default: /* auto-sense */
426 dev->if_port = 0x00; break;
427 }
428 }
429 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
430 }
431
432 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
433 bus access, two 4K Tx queues, and disabled Tx and Rx. */
434 outb(0xda, ioaddr + CONFIG_0);
435
436 /* Set the station address in bank zero. */
437 outb(0x00, ioaddr + CONFIG_1);
438 for (i = 0; i < 6; i++)
439 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
440
441 /* Switch to bank 1 and set the multicast table to accept none. */
442 outb(0x04, ioaddr + CONFIG_1);
443 for (i = 0; i < 8; i++)
444 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
445
446
447 /* Switch to bank 2 */
448 /* Lock our I/O address, and set manual processing mode for 16 collisions. */
449 outb(0x08, ioaddr + CONFIG_1);
450 outb(dev->if_port, ioaddr + MODE13);
451 outb(0x00, ioaddr + COL16CNTL);
452
453 if (net_debug)
454 printk(version);
455
456 memset(lp, 0, sizeof(struct net_local));
457
458 dev->open = net_open;
459 dev->stop = net_close;
460 dev->hard_start_xmit = net_send_packet;
461 dev->get_stats = net_get_stats;
462 dev->set_multicast_list = &set_rx_mode;
463 dev->tx_timeout = net_tx_timeout;
464 dev->watchdog_timeo = TX_TIMEOUT;
465
466 spin_lock_init(&lp->lock);
467
468 lp->jumpered = is_fmv18x;
469 lp->mca_slot = slot;
470 /* Snarf the interrupt vector now. */
471 ret = request_irq(irq, &net_interrupt, 0, DRV_NAME, dev);
472 if (ret) {
473 printk (" AT1700 at %#3x is unusable due to a conflict on"
474 "IRQ %d.\n", ioaddr, irq);
475 goto err_mca;
476 }
477
478 return 0;
479
480err_mca:
481#ifdef CONFIG_MCA_LEGACY
482 if (slot >= 0)
483 mca_mark_as_unused(slot);
484#endif
485err_out:
486 release_region(ioaddr, AT1700_IO_EXTENT);
487 return ret;
488}
489
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400490
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491/* EEPROM_Ctrl bits. */
492#define EE_SHIFT_CLK 0x40 /* EEPROM shift clock, in reg. 16. */
493#define EE_CS 0x20 /* EEPROM chip select, in reg. 16. */
494#define EE_DATA_WRITE 0x80 /* EEPROM chip data in, in reg. 17. */
495#define EE_DATA_READ 0x80 /* EEPROM chip data out, in reg. 17. */
496
497/* The EEPROM commands include the alway-set leading bit. */
498#define EE_WRITE_CMD (5 << 6)
499#define EE_READ_CMD (6 << 6)
500#define EE_ERASE_CMD (7 << 6)
501
502static int __init read_eeprom(long ioaddr, int location)
503{
504 int i;
505 unsigned short retval = 0;
506 long ee_addr = ioaddr + EEPROM_Ctrl;
507 long ee_daddr = ioaddr + EEPROM_Data;
508 int read_cmd = location | EE_READ_CMD;
509
510 /* Shift the read command bits out. */
511 for (i = 9; i >= 0; i--) {
512 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
513 outb(EE_CS, ee_addr);
514 outb(dataval, ee_daddr);
515 outb(EE_CS | EE_SHIFT_CLK, ee_addr); /* EEPROM clock tick. */
516 }
517 outb(EE_DATA_WRITE, ee_daddr);
518 for (i = 16; i > 0; i--) {
519 outb(EE_CS, ee_addr);
520 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
521 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
522 }
523
524 /* Terminate the EEPROM access. */
525 outb(EE_CS, ee_addr);
526 outb(EE_SHIFT_CLK, ee_addr);
527 outb(0, ee_addr);
528 return retval;
529}
530
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400531
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
533static int net_open(struct net_device *dev)
534{
535 struct net_local *lp = netdev_priv(dev);
536 int ioaddr = dev->base_addr;
537
538 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
539 bus access, and two 4K Tx queues. */
540 outb(0x5a, ioaddr + CONFIG_0);
541
542 /* Powerup, switch to register bank 2, and enable the Rx and Tx. */
543 outb(0xe8, ioaddr + CONFIG_1);
544
545 lp->tx_started = 0;
546 lp->tx_queue_ready = 1;
547 lp->rx_started = 0;
548 lp->tx_queue = 0;
549 lp->tx_queue_len = 0;
550
551 /* Turn on hardware Tx and Rx interrupts. */
552 outb(0x82, ioaddr + TX_INTR);
553 outb(0x81, ioaddr + RX_INTR);
554
555 /* Enable the IRQ on boards of fmv18x it is feasible. */
556 if (lp->jumpered) {
557 outb(0x80, ioaddr + IOCONFIG1);
558 }
559
560 netif_start_queue(dev);
561 return 0;
562}
563
564static void net_tx_timeout (struct net_device *dev)
565{
566 struct net_local *lp = netdev_priv(dev);
567 int ioaddr = dev->base_addr;
568
569 printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
570 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
571 ? "IRQ conflict" : "network cable problem");
572 printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
573 dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
574 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
575 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
576 lp->stats.tx_errors++;
577 /* ToDo: We should try to restart the adaptor... */
578 outw(0xffff, ioaddr + MODE24);
579 outw (0xffff, ioaddr + TX_STATUS);
580 outb (0x5a, ioaddr + CONFIG_0);
581 outb (0xe8, ioaddr + CONFIG_1);
582 outw (0x8182, ioaddr + TX_INTR);
583 outb (0x00, ioaddr + TX_START);
584 outb (0x03, ioaddr + COL16CNTL);
585
586 dev->trans_start = jiffies;
587
588 lp->tx_started = 0;
589 lp->tx_queue_ready = 1;
590 lp->rx_started = 0;
591 lp->tx_queue = 0;
592 lp->tx_queue_len = 0;
593
594 netif_wake_queue(dev);
595}
596
597
598static int net_send_packet (struct sk_buff *skb, struct net_device *dev)
599{
600 struct net_local *lp = netdev_priv(dev);
601 int ioaddr = dev->base_addr;
602 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
603 short len = skb->len;
604 unsigned char *buf = skb->data;
605 static u8 pad[ETH_ZLEN];
606
607 netif_stop_queue (dev);
608
609 /* We may not start transmitting unless we finish transferring
610 a packet into the Tx queue. During executing the following
611 codes we possibly catch a Tx interrupt. Thus we flag off
612 tx_queue_ready, so that we prevent the interrupt routine
613 (net_interrupt) to start transmitting. */
614 lp->tx_queue_ready = 0;
615 {
616 outw (length, ioaddr + DATAPORT);
617 /* Packet data */
618 outsw (ioaddr + DATAPORT, buf, len >> 1);
619 /* Check for dribble byte */
620 if (len & 1) {
621 outw(skb->data[skb->len-1], ioaddr + DATAPORT);
622 len++;
623 }
624 /* Check for packet padding */
625 if (length != skb->len)
626 outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
627
628 lp->tx_queue++;
629 lp->tx_queue_len += length + 2;
630 }
631 lp->tx_queue_ready = 1;
632
633 if (lp->tx_started == 0) {
634 /* If the Tx is idle, always trigger a transmit. */
635 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
636 lp->tx_queue = 0;
637 lp->tx_queue_len = 0;
638 dev->trans_start = jiffies;
639 lp->tx_started = 1;
640 netif_start_queue (dev);
641 } else if (lp->tx_queue_len < 4096 - 1502)
642 /* Yes, there is room for one more packet. */
643 netif_start_queue (dev);
644 dev_kfree_skb (skb);
645
646 return 0;
647}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649/* The typical workload of the driver:
650 Handle the network interface interrupts. */
David Howells7d12e782006-10-05 14:55:46 +0100651static irqreturn_t net_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652{
653 struct net_device *dev = dev_id;
654 struct net_local *lp;
655 int ioaddr, status;
656 int handled = 0;
657
658 if (dev == NULL) {
659 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
660 return IRQ_NONE;
661 }
662
663 ioaddr = dev->base_addr;
664 lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 spin_lock (&lp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400667
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 status = inw(ioaddr + TX_STATUS);
669 outw(status, ioaddr + TX_STATUS);
670
671 if (net_debug > 4)
672 printk("%s: Interrupt with status %04x.\n", dev->name, status);
673 if (lp->rx_started == 0 &&
674 (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
675 /* Got a packet(s).
676 We cannot execute net_rx more than once at the same time for
677 the same device. During executing net_rx, we possibly catch a
678 Tx interrupt. Thus we flag on rx_started, so that we prevent
679 the interrupt routine (net_interrupt) to dive into net_rx
680 again. */
681 handled = 1;
682 lp->rx_started = 1;
683 outb(0x00, ioaddr + RX_INTR); /* Disable RX intr. */
684 net_rx(dev);
685 outb(0x81, ioaddr + RX_INTR); /* Enable RX intr. */
686 lp->rx_started = 0;
687 }
688 if (status & 0x00ff) {
689 handled = 1;
690 if (status & 0x02) {
691 /* More than 16 collisions occurred */
692 if (net_debug > 4)
693 printk("%s: 16 Collision occur during Txing.\n", dev->name);
694 /* Cancel sending a packet. */
695 outb(0x03, ioaddr + COL16CNTL);
696 lp->stats.collisions++;
697 }
698 if (status & 0x82) {
699 lp->stats.tx_packets++;
700 /* The Tx queue has any packets and is not being
701 transferred a packet from the host, start
702 transmitting. */
703 if (lp->tx_queue && lp->tx_queue_ready) {
704 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
705 lp->tx_queue = 0;
706 lp->tx_queue_len = 0;
707 dev->trans_start = jiffies;
708 netif_wake_queue (dev);
709 } else {
710 lp->tx_started = 0;
711 netif_wake_queue (dev);
712 }
713 }
714 }
715
716 spin_unlock (&lp->lock);
717 return IRQ_RETVAL(handled);
718}
719
720/* We have a good packet(s), get it/them out of the buffers. */
721static void
722net_rx(struct net_device *dev)
723{
724 struct net_local *lp = netdev_priv(dev);
725 int ioaddr = dev->base_addr;
726 int boguscount = 5;
727
728 while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
729 ushort status = inw(ioaddr + DATAPORT);
730 ushort pkt_len = inw(ioaddr + DATAPORT);
731
732 if (net_debug > 4)
733 printk("%s: Rxing packet mode %02x status %04x.\n",
734 dev->name, inb(ioaddr + RX_MODE), status);
735#ifndef final_version
736 if (status == 0) {
737 outb(0x05, ioaddr + RX_CTRL);
738 break;
739 }
740#endif
741
742 if ((status & 0xF0) != 0x20) { /* There was an error. */
743 lp->stats.rx_errors++;
744 if (status & 0x08) lp->stats.rx_length_errors++;
745 if (status & 0x04) lp->stats.rx_frame_errors++;
746 if (status & 0x02) lp->stats.rx_crc_errors++;
747 if (status & 0x01) lp->stats.rx_over_errors++;
748 } else {
749 /* Malloc up new buffer. */
750 struct sk_buff *skb;
751
752 if (pkt_len > 1550) {
753 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
754 dev->name, pkt_len);
755 /* Prime the FIFO and then flush the packet. */
756 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
757 outb(0x05, ioaddr + RX_CTRL);
758 lp->stats.rx_errors++;
759 break;
760 }
761 skb = dev_alloc_skb(pkt_len+3);
762 if (skb == NULL) {
763 printk("%s: Memory squeeze, dropping packet (len %d).\n",
764 dev->name, pkt_len);
765 /* Prime the FIFO and then flush the packet. */
766 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
767 outb(0x05, ioaddr + RX_CTRL);
768 lp->stats.rx_dropped++;
769 break;
770 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 skb_reserve(skb,2);
772
773 insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
774 skb->protocol=eth_type_trans(skb, dev);
775 netif_rx(skb);
776 dev->last_rx = jiffies;
777 lp->stats.rx_packets++;
778 lp->stats.rx_bytes += pkt_len;
779 }
780 if (--boguscount <= 0)
781 break;
782 }
783
784 /* If any worth-while packets have been received, dev_rint()
785 has done a mark_bh(NET_BH) for us and will work on them
786 when we get to the bottom-half routine. */
787 {
788 int i;
789 for (i = 0; i < 20; i++) {
790 if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
791 break;
792 inw(ioaddr + DATAPORT); /* dummy status read */
793 outb(0x05, ioaddr + RX_CTRL);
794 }
795
796 if (net_debug > 5)
797 printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
798 dev->name, inb(ioaddr + RX_MODE), i);
799 }
800 return;
801}
802
803/* The inverse routine to net_open(). */
804static int net_close(struct net_device *dev)
805{
806 struct net_local *lp = netdev_priv(dev);
807 int ioaddr = dev->base_addr;
808
809 netif_stop_queue(dev);
810
811 /* Set configuration register 0 to disable Tx and Rx. */
812 outb(0xda, ioaddr + CONFIG_0);
813
814 /* No statistic counters on the chip to update. */
815
816 /* Disable the IRQ on boards of fmv18x where it is feasible. */
817 if (lp->jumpered) {
818 outb(0x00, ioaddr + IOCONFIG1);
819 free_irq(dev->irq, dev);
820 }
821
822 /* Power-down the chip. Green, green, green! */
823 outb(0x00, ioaddr + CONFIG_1);
824 return 0;
825}
826
827/* Get the current statistics.
828 This may be called with the card open or closed.
829 There are no on-chip counters, so this function is trivial.
830*/
831static struct net_device_stats *
832net_get_stats(struct net_device *dev)
833{
834 struct net_local *lp = netdev_priv(dev);
835 return &lp->stats;
836}
837
838/*
839 Set the multicast/promiscuous mode for this adaptor.
840*/
841
842static void
843set_rx_mode(struct net_device *dev)
844{
845 int ioaddr = dev->base_addr;
846 struct net_local *lp = netdev_priv(dev);
847 unsigned char mc_filter[8]; /* Multicast hash filter */
848 unsigned long flags;
849 int i;
850
851 if (dev->flags & IFF_PROMISC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 memset(mc_filter, 0xff, sizeof(mc_filter));
853 outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */
854 } else if (dev->mc_count > MC_FILTERBREAK
855 || (dev->flags & IFF_ALLMULTI)) {
856 /* Too many to filter perfectly -- accept all multicasts. */
857 memset(mc_filter, 0xff, sizeof(mc_filter));
858 outb(2, ioaddr + RX_MODE); /* Use normal mode. */
859 } else if (dev->mc_count == 0) {
860 memset(mc_filter, 0x00, sizeof(mc_filter));
861 outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */
862 } else {
863 struct dev_mc_list *mclist;
864 int i;
865
866 memset(mc_filter, 0, sizeof(mc_filter));
867 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
868 i++, mclist = mclist->next) {
869 unsigned int bit =
870 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
871 mc_filter[bit >> 3] |= (1 << bit);
872 }
873 outb(0x02, ioaddr + RX_MODE); /* Use normal mode. */
874 }
875
876 spin_lock_irqsave (&lp->lock, flags);
877 if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
878 int saved_bank = inw(ioaddr + CONFIG_0);
879 /* Switch to bank 1 and set the multicast table. */
880 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
881 for (i = 0; i < 8; i++)
882 outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
883 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
884 outw(saved_bank, ioaddr + CONFIG_0);
885 }
886 spin_unlock_irqrestore (&lp->lock, flags);
887 return;
888}
889
890#ifdef MODULE
891static struct net_device *dev_at1700;
892
893module_param(io, int, 0);
894module_param(irq, int, 0);
895module_param(net_debug, int, 0);
896MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
897MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
898MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
899
Andrew Morton5d930102006-08-14 22:59:59 -0700900int __init init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901{
902 if (io == 0)
903 printk("at1700: You should not use auto-probing with insmod!\n");
904 dev_at1700 = at1700_probe(-1);
905 if (IS_ERR(dev_at1700))
906 return PTR_ERR(dev_at1700);
907 return 0;
908}
909
Al Viroafc8eb42006-06-14 18:50:53 -0400910void __exit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911cleanup_module(void)
912{
913 unregister_netdev(dev_at1700);
914 cleanup_card(dev_at1700);
915 free_netdev(dev_at1700);
916}
917#endif /* MODULE */
918MODULE_LICENSE("GPL");
919
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400920
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921/*
922 * Local variables:
923 * compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
924 * alt-compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
925 * tab-width: 4
926 * c-basic-offset: 4
927 * c-indent-level: 4
928 * End:
929 */
930