blob: 72ea6e378f8dda5dec528cdad250c23cd6ce6677 [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 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 spinlock_t lock;
113 unsigned char mc_filter[8];
114 uint jumpered:1; /* Set iff the board has jumper config. */
115 uint tx_started:1; /* Packets are on the Tx queue. */
116 uint tx_queue_ready:1; /* Tx queue is ready to be sent. */
117 uint rx_started:1; /* Packets are Rxing. */
118 uchar tx_queue; /* Number of packet on the Tx queue. */
119 char mca_slot; /* -1 means ISA */
120 ushort tx_queue_len; /* Current length of the Tx queue. */
121};
122
123
124/* Offsets from the base address. */
125#define STATUS 0
126#define TX_STATUS 0
127#define RX_STATUS 1
128#define TX_INTR 2 /* Bit-mapped interrupt enable registers. */
129#define RX_INTR 3
130#define TX_MODE 4
131#define RX_MODE 5
132#define CONFIG_0 6 /* Misc. configuration settings. */
133#define CONFIG_1 7
134/* Run-time register bank 2 definitions. */
135#define DATAPORT 8 /* Word-wide DMA or programmed-I/O dataport. */
136#define TX_START 10
137#define COL16CNTL 11 /* Controll Reg for 16 collisions */
138#define MODE13 13
139#define RX_CTRL 14
140/* Configuration registers only on the '865A/B chips. */
141#define EEPROM_Ctrl 16
142#define EEPROM_Data 17
143#define CARDSTATUS 16 /* FMV-18x Card Status */
144#define CARDSTATUS1 17 /* FMV-18x Card Status */
145#define IOCONFIG 18 /* Either read the jumper, or move the I/O. */
146#define IOCONFIG1 19
147#define SAPROM 20 /* The station address PROM, if no EEPROM. */
148#define MODE24 24
149#define RESET 31 /* Write to reset some parts of the chip. */
150#define AT1700_IO_EXTENT 32
151#define PORT_OFFSET(o) (o)
152
153
154#define TX_TIMEOUT 10
155
156
157/* Index to functions, as function prototypes. */
158
159static int at1700_probe1(struct net_device *dev, int ioaddr);
160static int read_eeprom(long ioaddr, int location);
161static int net_open(struct net_device *dev);
162static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100163static irqreturn_t net_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164static void net_rx(struct net_device *dev);
165static int net_close(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166static void set_rx_mode(struct net_device *dev);
167static void net_tx_timeout (struct net_device *dev);
168
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400169
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170#ifdef CONFIG_MCA_LEGACY
171struct at1720_mca_adapters_struct {
172 char* name;
173 int id;
174};
175/* rEnE : maybe there are others I don't know off... */
176
177static struct at1720_mca_adapters_struct at1720_mca_adapters[] __initdata = {
178 { "Allied Telesys AT1720AT", 0x6410 },
179 { "Allied Telesys AT1720BT", 0x6413 },
180 { "Allied Telesys AT1720T", 0x6416 },
181 { NULL, 0 },
182};
183#endif
184
185/* Check for a network adaptor of this type, and return '0' iff one exists.
186 If dev->base_addr == 0, probe all likely locations.
187 If dev->base_addr == 1, always return failure.
188 If dev->base_addr == 2, allocate space for the device and return success
189 (detachable devices only).
190 */
191
192static int io = 0x260;
193
194static int irq;
195
196static void cleanup_card(struct net_device *dev)
197{
198#ifdef CONFIG_MCA_LEGACY
199 struct net_local *lp = netdev_priv(dev);
200 if (lp->mca_slot >= 0)
201 mca_mark_as_unused(lp->mca_slot);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400202#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 free_irq(dev->irq, NULL);
204 release_region(dev->base_addr, AT1700_IO_EXTENT);
205}
206
207struct net_device * __init at1700_probe(int unit)
208{
209 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
210 unsigned *port;
211 int err = 0;
212
213 if (!dev)
214 return ERR_PTR(-ENODEV);
215
216 if (unit >= 0) {
217 sprintf(dev->name, "eth%d", unit);
218 netdev_boot_setup_check(dev);
219 io = dev->base_addr;
220 irq = dev->irq;
221 } else {
222 dev->base_addr = io;
223 dev->irq = irq;
224 }
225
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 if (io > 0x1ff) { /* Check a single specified location. */
227 err = at1700_probe1(dev, io);
228 } else if (io != 0) { /* Don't probe at all. */
229 err = -ENXIO;
230 } else {
231 for (port = at1700_probe_list; *port; port++) {
232 if (at1700_probe1(dev, *port) == 0)
233 break;
234 dev->irq = irq;
235 }
236 if (!*port)
237 err = -ENODEV;
238 }
239 if (err)
240 goto out;
241 err = register_netdev(dev);
242 if (err)
243 goto out1;
244 return dev;
245out1:
246 cleanup_card(dev);
247out:
248 free_netdev(dev);
249 return ERR_PTR(err);
250}
251
252/* The Fujitsu datasheet suggests that the NIC be probed for by checking its
253 "signature", the default bit pattern after a reset. This *doesn't* work --
254 there is no way to reset the bus interface without a complete power-cycle!
255
256 It turns out that ATI came to the same conclusion I did: the only thing
257 that can be done is checking a few bits and then diving right into an
258 EEPROM read. */
259
260static int __init at1700_probe1(struct net_device *dev, int ioaddr)
261{
262 char fmv_irqmap[4] = {3, 7, 10, 15};
263 char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
264 char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
265 unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
266 int slot, ret = -ENODEV;
267 struct net_local *lp = netdev_priv(dev);
268
269 if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
270 return -EBUSY;
271
272 /* Resetting the chip doesn't reset the ISA interface, so don't bother.
273 That means we have to be careful with the register values we probe
274 for.
275 */
276#ifdef notdef
277 printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
278 ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
279 read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
280#endif
281
282#ifdef CONFIG_MCA_LEGACY
283 /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
284
285 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
286 modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
287 to support standard MCA probing. */
288
289 /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
290 /* now works as a module */
291
292 if (MCA_bus) {
293 int j;
294 int l_i;
295 u_char pos3, pos4;
296
297 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
298 slot = 0;
299 while (slot != MCA_NOTFOUND) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400300
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
302 if (slot == MCA_NOTFOUND) break;
303
304 /* if we get this far, an adapter has been detected and is
305 enabled */
306
307 pos3 = mca_read_stored_pos( slot, 3 );
308 pos4 = mca_read_stored_pos( slot, 4 );
309
310 for (l_i = 0; l_i < 0x09; l_i++)
311 if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
312 break;
313 ioaddr = at1700_mca_probe_list[l_i];
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400314
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 for (irq = 0; irq < 0x10; irq++)
316 if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
317 break;
318
319 /* probing for a card at a particular IO/IRQ */
320 if ((dev->irq && dev->irq != irq) ||
321 (dev->base_addr && dev->base_addr != ioaddr)) {
322 slot++; /* probing next slot */
323 continue;
324 }
325
326 dev->irq = irq;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400327
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 /* claim the slot */
329 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
330 mca_mark_as_used(slot);
331
332 goto found;
333 }
334 }
335 /* if we get here, we didn't find an MCA adapter - try ISA */
336 }
337#endif
338 slot = -1;
339 /* We must check for the EEPROM-config boards first, else accessing
340 IOCONFIG0 will move the board! */
341 if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr
342 && read_eeprom(ioaddr, 4) == 0x0000
343 && (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
344 is_at1700 = 1;
345 else if (inb(ioaddr + SAPROM ) == 0x00
346 && inb(ioaddr + SAPROM + 1) == 0x00
347 && inb(ioaddr + SAPROM + 2) == 0x0e)
348 is_fmv18x = 1;
349 else {
350 goto err_out;
351 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353#ifdef CONFIG_MCA_LEGACY
354found:
355#endif
356
357 /* Reset the internal state machines. */
358 outb(0, ioaddr + RESET);
359
360 if (is_at1700) {
361 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
362 | (read_eeprom(ioaddr, 0)>>14)];
363 } else {
364 /* Check PnP mode for FMV-183/184/183A/184A. */
365 /* This PnP routine is very poor. IO and IRQ should be known. */
366 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
367 irq = dev->irq;
368 for (i = 0; i < 8; i++) {
369 if (irq == fmv_irqmap_pnp[i])
370 break;
371 }
372 if (i == 8) {
373 goto err_mca;
374 }
375 } else {
376 if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
377 goto err_mca;
378 irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
379 }
380 }
381
382 printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
383 is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
384
385 dev->base_addr = ioaddr;
386 dev->irq = irq;
387
388 if (is_at1700) {
389 for(i = 0; i < 3; i++) {
390 unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
392 }
393 } else {
394 for(i = 0; i < 6; i++) {
395 unsigned char val = inb(ioaddr + SAPROM + i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 dev->dev_addr[i] = val;
397 }
398 }
Johannes Berge1749612008-10-27 15:59:26 -0700399 printk("%pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
401 /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
402 rather than 150 ohm shielded twisted pair compensation.
403 0x0000 == auto-sense the interface
404 0x0800 == use TP interface
405 0x1800 == use coax interface
406 */
407 {
408 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
409 if (is_at1700) {
410 ushort setup_value = read_eeprom(ioaddr, 12);
411 dev->if_port = setup_value >> 8;
412 } else {
413 ushort setup_value = inb(ioaddr + CARDSTATUS);
414 switch (setup_value & 0x07) {
415 case 0x01: /* 10base5 */
416 case 0x02: /* 10base2 */
417 dev->if_port = 0x18; break;
418 case 0x04: /* 10baseT */
419 dev->if_port = 0x08; break;
420 default: /* auto-sense */
421 dev->if_port = 0x00; break;
422 }
423 }
424 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
425 }
426
427 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
428 bus access, two 4K Tx queues, and disabled Tx and Rx. */
429 outb(0xda, ioaddr + CONFIG_0);
430
431 /* Set the station address in bank zero. */
432 outb(0x00, ioaddr + CONFIG_1);
433 for (i = 0; i < 6; i++)
434 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
435
436 /* Switch to bank 1 and set the multicast table to accept none. */
437 outb(0x04, ioaddr + CONFIG_1);
438 for (i = 0; i < 8; i++)
439 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
440
441
442 /* Switch to bank 2 */
443 /* Lock our I/O address, and set manual processing mode for 16 collisions. */
444 outb(0x08, ioaddr + CONFIG_1);
445 outb(dev->if_port, ioaddr + MODE13);
446 outb(0x00, ioaddr + COL16CNTL);
447
448 if (net_debug)
449 printk(version);
450
451 memset(lp, 0, sizeof(struct net_local));
452
453 dev->open = net_open;
454 dev->stop = net_close;
455 dev->hard_start_xmit = net_send_packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 dev->set_multicast_list = &set_rx_mode;
457 dev->tx_timeout = net_tx_timeout;
458 dev->watchdog_timeo = TX_TIMEOUT;
459
460 spin_lock_init(&lp->lock);
461
462 lp->jumpered = is_fmv18x;
463 lp->mca_slot = slot;
464 /* Snarf the interrupt vector now. */
465 ret = request_irq(irq, &net_interrupt, 0, DRV_NAME, dev);
466 if (ret) {
Jeff Garzikcba05162007-11-23 21:50:34 -0500467 printk(KERN_ERR "AT1700 at %#3x is unusable due to a "
468 "conflict on IRQ %d.\n",
469 ioaddr, irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 goto err_mca;
471 }
472
473 return 0;
474
475err_mca:
476#ifdef CONFIG_MCA_LEGACY
477 if (slot >= 0)
478 mca_mark_as_unused(slot);
479#endif
480err_out:
481 release_region(ioaddr, AT1700_IO_EXTENT);
482 return ret;
483}
484
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400485
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486/* EEPROM_Ctrl bits. */
487#define EE_SHIFT_CLK 0x40 /* EEPROM shift clock, in reg. 16. */
488#define EE_CS 0x20 /* EEPROM chip select, in reg. 16. */
489#define EE_DATA_WRITE 0x80 /* EEPROM chip data in, in reg. 17. */
490#define EE_DATA_READ 0x80 /* EEPROM chip data out, in reg. 17. */
491
492/* The EEPROM commands include the alway-set leading bit. */
493#define EE_WRITE_CMD (5 << 6)
494#define EE_READ_CMD (6 << 6)
495#define EE_ERASE_CMD (7 << 6)
496
497static int __init read_eeprom(long ioaddr, int location)
498{
499 int i;
500 unsigned short retval = 0;
501 long ee_addr = ioaddr + EEPROM_Ctrl;
502 long ee_daddr = ioaddr + EEPROM_Data;
503 int read_cmd = location | EE_READ_CMD;
504
505 /* Shift the read command bits out. */
506 for (i = 9; i >= 0; i--) {
507 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
508 outb(EE_CS, ee_addr);
509 outb(dataval, ee_daddr);
510 outb(EE_CS | EE_SHIFT_CLK, ee_addr); /* EEPROM clock tick. */
511 }
512 outb(EE_DATA_WRITE, ee_daddr);
513 for (i = 16; i > 0; i--) {
514 outb(EE_CS, ee_addr);
515 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
516 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
517 }
518
519 /* Terminate the EEPROM access. */
520 outb(EE_CS, ee_addr);
521 outb(EE_SHIFT_CLK, ee_addr);
522 outb(0, ee_addr);
523 return retval;
524}
525
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
528static int net_open(struct net_device *dev)
529{
530 struct net_local *lp = netdev_priv(dev);
531 int ioaddr = dev->base_addr;
532
533 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
534 bus access, and two 4K Tx queues. */
535 outb(0x5a, ioaddr + CONFIG_0);
536
537 /* Powerup, switch to register bank 2, and enable the Rx and Tx. */
538 outb(0xe8, ioaddr + CONFIG_1);
539
540 lp->tx_started = 0;
541 lp->tx_queue_ready = 1;
542 lp->rx_started = 0;
543 lp->tx_queue = 0;
544 lp->tx_queue_len = 0;
545
546 /* Turn on hardware Tx and Rx interrupts. */
547 outb(0x82, ioaddr + TX_INTR);
548 outb(0x81, ioaddr + RX_INTR);
549
550 /* Enable the IRQ on boards of fmv18x it is feasible. */
551 if (lp->jumpered) {
552 outb(0x80, ioaddr + IOCONFIG1);
553 }
554
555 netif_start_queue(dev);
556 return 0;
557}
558
559static void net_tx_timeout (struct net_device *dev)
560{
561 struct net_local *lp = netdev_priv(dev);
562 int ioaddr = dev->base_addr;
563
564 printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
565 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
566 ? "IRQ conflict" : "network cable problem");
567 printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
568 dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
569 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
570 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700571 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 /* ToDo: We should try to restart the adaptor... */
573 outw(0xffff, ioaddr + MODE24);
574 outw (0xffff, ioaddr + TX_STATUS);
575 outb (0x5a, ioaddr + CONFIG_0);
576 outb (0xe8, ioaddr + CONFIG_1);
577 outw (0x8182, ioaddr + TX_INTR);
578 outb (0x00, ioaddr + TX_START);
579 outb (0x03, ioaddr + COL16CNTL);
580
581 dev->trans_start = jiffies;
582
583 lp->tx_started = 0;
584 lp->tx_queue_ready = 1;
585 lp->rx_started = 0;
586 lp->tx_queue = 0;
587 lp->tx_queue_len = 0;
588
589 netif_wake_queue(dev);
590}
591
592
593static int net_send_packet (struct sk_buff *skb, struct net_device *dev)
594{
595 struct net_local *lp = netdev_priv(dev);
596 int ioaddr = dev->base_addr;
597 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
598 short len = skb->len;
599 unsigned char *buf = skb->data;
600 static u8 pad[ETH_ZLEN];
601
602 netif_stop_queue (dev);
603
604 /* We may not start transmitting unless we finish transferring
605 a packet into the Tx queue. During executing the following
606 codes we possibly catch a Tx interrupt. Thus we flag off
607 tx_queue_ready, so that we prevent the interrupt routine
608 (net_interrupt) to start transmitting. */
609 lp->tx_queue_ready = 0;
610 {
611 outw (length, ioaddr + DATAPORT);
612 /* Packet data */
613 outsw (ioaddr + DATAPORT, buf, len >> 1);
614 /* Check for dribble byte */
615 if (len & 1) {
616 outw(skb->data[skb->len-1], ioaddr + DATAPORT);
617 len++;
618 }
619 /* Check for packet padding */
620 if (length != skb->len)
621 outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
622
623 lp->tx_queue++;
624 lp->tx_queue_len += length + 2;
625 }
626 lp->tx_queue_ready = 1;
627
628 if (lp->tx_started == 0) {
629 /* If the Tx is idle, always trigger a transmit. */
630 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
631 lp->tx_queue = 0;
632 lp->tx_queue_len = 0;
633 dev->trans_start = jiffies;
634 lp->tx_started = 1;
635 netif_start_queue (dev);
636 } else if (lp->tx_queue_len < 4096 - 1502)
637 /* Yes, there is room for one more packet. */
638 netif_start_queue (dev);
639 dev_kfree_skb (skb);
640
641 return 0;
642}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400643
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644/* The typical workload of the driver:
645 Handle the network interface interrupts. */
David Howells7d12e782006-10-05 14:55:46 +0100646static irqreturn_t net_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647{
648 struct net_device *dev = dev_id;
649 struct net_local *lp;
650 int ioaddr, status;
651 int handled = 0;
652
653 if (dev == NULL) {
654 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
655 return IRQ_NONE;
656 }
657
658 ioaddr = dev->base_addr;
659 lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 spin_lock (&lp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400662
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 status = inw(ioaddr + TX_STATUS);
664 outw(status, ioaddr + TX_STATUS);
665
666 if (net_debug > 4)
667 printk("%s: Interrupt with status %04x.\n", dev->name, status);
668 if (lp->rx_started == 0 &&
669 (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
670 /* Got a packet(s).
671 We cannot execute net_rx more than once at the same time for
672 the same device. During executing net_rx, we possibly catch a
673 Tx interrupt. Thus we flag on rx_started, so that we prevent
674 the interrupt routine (net_interrupt) to dive into net_rx
675 again. */
676 handled = 1;
677 lp->rx_started = 1;
678 outb(0x00, ioaddr + RX_INTR); /* Disable RX intr. */
679 net_rx(dev);
680 outb(0x81, ioaddr + RX_INTR); /* Enable RX intr. */
681 lp->rx_started = 0;
682 }
683 if (status & 0x00ff) {
684 handled = 1;
685 if (status & 0x02) {
686 /* More than 16 collisions occurred */
687 if (net_debug > 4)
688 printk("%s: 16 Collision occur during Txing.\n", dev->name);
689 /* Cancel sending a packet. */
690 outb(0x03, ioaddr + COL16CNTL);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700691 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 }
693 if (status & 0x82) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700694 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 /* The Tx queue has any packets and is not being
696 transferred a packet from the host, start
697 transmitting. */
698 if (lp->tx_queue && lp->tx_queue_ready) {
699 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
700 lp->tx_queue = 0;
701 lp->tx_queue_len = 0;
702 dev->trans_start = jiffies;
703 netif_wake_queue (dev);
704 } else {
705 lp->tx_started = 0;
706 netif_wake_queue (dev);
707 }
708 }
709 }
710
711 spin_unlock (&lp->lock);
712 return IRQ_RETVAL(handled);
713}
714
715/* We have a good packet(s), get it/them out of the buffers. */
716static void
717net_rx(struct net_device *dev)
718{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 int ioaddr = dev->base_addr;
720 int boguscount = 5;
721
722 while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
723 ushort status = inw(ioaddr + DATAPORT);
724 ushort pkt_len = inw(ioaddr + DATAPORT);
725
726 if (net_debug > 4)
727 printk("%s: Rxing packet mode %02x status %04x.\n",
728 dev->name, inb(ioaddr + RX_MODE), status);
729#ifndef final_version
730 if (status == 0) {
731 outb(0x05, ioaddr + RX_CTRL);
732 break;
733 }
734#endif
735
736 if ((status & 0xF0) != 0x20) { /* There was an error. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700737 dev->stats.rx_errors++;
738 if (status & 0x08) dev->stats.rx_length_errors++;
739 if (status & 0x04) dev->stats.rx_frame_errors++;
740 if (status & 0x02) dev->stats.rx_crc_errors++;
741 if (status & 0x01) dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 } else {
743 /* Malloc up new buffer. */
744 struct sk_buff *skb;
745
746 if (pkt_len > 1550) {
747 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
748 dev->name, pkt_len);
749 /* Prime the FIFO and then flush the packet. */
750 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
751 outb(0x05, ioaddr + RX_CTRL);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700752 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 break;
754 }
755 skb = dev_alloc_skb(pkt_len+3);
756 if (skb == NULL) {
757 printk("%s: Memory squeeze, dropping packet (len %d).\n",
758 dev->name, pkt_len);
759 /* Prime the FIFO and then flush the packet. */
760 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
761 outb(0x05, ioaddr + RX_CTRL);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700762 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 break;
764 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 skb_reserve(skb,2);
766
767 insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
768 skb->protocol=eth_type_trans(skb, dev);
769 netif_rx(skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700770 dev->stats.rx_packets++;
771 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 }
773 if (--boguscount <= 0)
774 break;
775 }
776
777 /* If any worth-while packets have been received, dev_rint()
778 has done a mark_bh(NET_BH) for us and will work on them
779 when we get to the bottom-half routine. */
780 {
781 int i;
782 for (i = 0; i < 20; i++) {
783 if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
784 break;
785 inw(ioaddr + DATAPORT); /* dummy status read */
786 outb(0x05, ioaddr + RX_CTRL);
787 }
788
789 if (net_debug > 5)
790 printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
791 dev->name, inb(ioaddr + RX_MODE), i);
792 }
793 return;
794}
795
796/* The inverse routine to net_open(). */
797static int net_close(struct net_device *dev)
798{
799 struct net_local *lp = netdev_priv(dev);
800 int ioaddr = dev->base_addr;
801
802 netif_stop_queue(dev);
803
804 /* Set configuration register 0 to disable Tx and Rx. */
805 outb(0xda, ioaddr + CONFIG_0);
806
807 /* No statistic counters on the chip to update. */
808
809 /* Disable the IRQ on boards of fmv18x where it is feasible. */
810 if (lp->jumpered) {
811 outb(0x00, ioaddr + IOCONFIG1);
812 free_irq(dev->irq, dev);
813 }
814
815 /* Power-down the chip. Green, green, green! */
816 outb(0x00, ioaddr + CONFIG_1);
817 return 0;
818}
819
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820/*
821 Set the multicast/promiscuous mode for this adaptor.
822*/
823
824static void
825set_rx_mode(struct net_device *dev)
826{
827 int ioaddr = dev->base_addr;
828 struct net_local *lp = netdev_priv(dev);
829 unsigned char mc_filter[8]; /* Multicast hash filter */
830 unsigned long flags;
831 int i;
832
833 if (dev->flags & IFF_PROMISC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 memset(mc_filter, 0xff, sizeof(mc_filter));
835 outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */
836 } else if (dev->mc_count > MC_FILTERBREAK
837 || (dev->flags & IFF_ALLMULTI)) {
838 /* Too many to filter perfectly -- accept all multicasts. */
839 memset(mc_filter, 0xff, sizeof(mc_filter));
840 outb(2, ioaddr + RX_MODE); /* Use normal mode. */
841 } else if (dev->mc_count == 0) {
842 memset(mc_filter, 0x00, sizeof(mc_filter));
843 outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */
844 } else {
845 struct dev_mc_list *mclist;
846 int i;
847
848 memset(mc_filter, 0, sizeof(mc_filter));
849 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
850 i++, mclist = mclist->next) {
851 unsigned int bit =
852 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
853 mc_filter[bit >> 3] |= (1 << bit);
854 }
855 outb(0x02, ioaddr + RX_MODE); /* Use normal mode. */
856 }
857
858 spin_lock_irqsave (&lp->lock, flags);
859 if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
860 int saved_bank = inw(ioaddr + CONFIG_0);
861 /* Switch to bank 1 and set the multicast table. */
862 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
863 for (i = 0; i < 8; i++)
864 outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
865 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
866 outw(saved_bank, ioaddr + CONFIG_0);
867 }
868 spin_unlock_irqrestore (&lp->lock, flags);
869 return;
870}
871
872#ifdef MODULE
873static struct net_device *dev_at1700;
874
875module_param(io, int, 0);
876module_param(irq, int, 0);
877module_param(net_debug, int, 0);
878MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
879MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
880MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
881
Jon Schindler5250f332008-02-28 01:31:12 -0600882static int __init at1700_module_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883{
884 if (io == 0)
885 printk("at1700: You should not use auto-probing with insmod!\n");
886 dev_at1700 = at1700_probe(-1);
887 if (IS_ERR(dev_at1700))
888 return PTR_ERR(dev_at1700);
889 return 0;
890}
891
Jon Schindler5250f332008-02-28 01:31:12 -0600892static void __exit at1700_module_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893{
894 unregister_netdev(dev_at1700);
895 cleanup_card(dev_at1700);
896 free_netdev(dev_at1700);
897}
Jon Schindler5250f332008-02-28 01:31:12 -0600898module_init(at1700_module_init);
899module_exit(at1700_module_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900#endif /* MODULE */
901MODULE_LICENSE("GPL");