blob: 65a78f965dd25c5f30442e9a010ecac849c761ce [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <linux/string.h>
51#include <linux/init.h>
52#include <linux/crc32.h>
53#include <linux/bitops.h>
54
55#include <asm/system.h>
56#include <asm/io.h>
57#include <asm/dma.h>
58
59static char version[] __initdata =
Andy Gospodarekd5b20692006-09-11 17:39:18 -040060 "at1700.c:v1.16 9/11/06 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62#define DRV_NAME "at1700"
63
64/* Tunable parameters. */
65
66/* When to switch from the 64-entry multicast filter to Rx-all-multicast. */
67#define MC_FILTERBREAK 64
68
69/* These unusual address orders are used to verify the CONFIG register. */
70
71static int fmv18x_probe_list[] __initdata = {
72 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
73};
74
75/*
76 * ISA
77 */
78
79static unsigned at1700_probe_list[] __initdata = {
80 0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
81};
82
83/*
84 * MCA
85 */
86#ifdef CONFIG_MCA_LEGACY
87static int at1700_ioaddr_pattern[] __initdata = {
88 0x00, 0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07
89};
90
91static int at1700_mca_probe_list[] __initdata = {
92 0x400, 0x1400, 0x2400, 0x3400, 0x4400, 0x5400, 0x6400, 0x7400, 0
93};
94
95static int at1700_irq_pattern[] __initdata = {
96 0x00, 0x00, 0x00, 0x30, 0x70, 0xb0, 0x00, 0x00,
97 0x00, 0xf0, 0x34, 0x74, 0xb4, 0x00, 0x00, 0xf4, 0x00
98};
99#endif
100
101/* use 0 for production, 1 for verification, >2 for debug */
102#ifndef NET_DEBUG
103#define NET_DEBUG 1
104#endif
105static unsigned int net_debug = NET_DEBUG;
106
107typedef unsigned char uchar;
108
109/* Information that need to be kept for each board. */
110struct net_local {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 spinlock_t lock;
112 unsigned char mc_filter[8];
113 uint jumpered:1; /* Set iff the board has jumper config. */
114 uint tx_started:1; /* Packets are on the Tx queue. */
115 uint tx_queue_ready:1; /* Tx queue is ready to be sent. */
116 uint rx_started:1; /* Packets are Rxing. */
117 uchar tx_queue; /* Number of packet on the Tx queue. */
118 char mca_slot; /* -1 means ISA */
119 ushort tx_queue_len; /* Current length of the Tx queue. */
120};
121
122
123/* Offsets from the base address. */
124#define STATUS 0
125#define TX_STATUS 0
126#define RX_STATUS 1
127#define TX_INTR 2 /* Bit-mapped interrupt enable registers. */
128#define RX_INTR 3
129#define TX_MODE 4
130#define RX_MODE 5
131#define CONFIG_0 6 /* Misc. configuration settings. */
132#define CONFIG_1 7
133/* Run-time register bank 2 definitions. */
134#define DATAPORT 8 /* Word-wide DMA or programmed-I/O dataport. */
135#define TX_START 10
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300136#define COL16CNTL 11 /* Control Reg for 16 collisions */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137#define MODE13 13
138#define RX_CTRL 14
139/* Configuration registers only on the '865A/B chips. */
140#define EEPROM_Ctrl 16
141#define EEPROM_Data 17
142#define CARDSTATUS 16 /* FMV-18x Card Status */
143#define CARDSTATUS1 17 /* FMV-18x Card Status */
144#define IOCONFIG 18 /* Either read the jumper, or move the I/O. */
145#define IOCONFIG1 19
146#define SAPROM 20 /* The station address PROM, if no EEPROM. */
147#define MODE24 24
148#define RESET 31 /* Write to reset some parts of the chip. */
149#define AT1700_IO_EXTENT 32
150#define PORT_OFFSET(o) (o)
151
152
Eric Dumazetc63fdf42010-11-03 22:49:35 +0000153#define TX_TIMEOUT (HZ/10)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155
156/* Index to functions, as function prototypes. */
157
158static int at1700_probe1(struct net_device *dev, int ioaddr);
159static int read_eeprom(long ioaddr, int location);
160static int net_open(struct net_device *dev);
Stephen Hemminger613573252009-08-31 19:50:58 +0000161static netdev_tx_t net_send_packet(struct sk_buff *skb,
162 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
Stephen Hemmingercb0c7002009-03-26 15:11:36 +0000252static const struct net_device_ops at1700_netdev_ops = {
253 .ndo_open = net_open,
254 .ndo_stop = net_close,
255 .ndo_start_xmit = net_send_packet,
256 .ndo_set_multicast_list = set_rx_mode,
257 .ndo_tx_timeout = net_tx_timeout,
258 .ndo_change_mtu = eth_change_mtu,
259 .ndo_set_mac_address = eth_mac_addr,
260 .ndo_validate_addr = eth_validate_addr,
261};
262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263/* The Fujitsu datasheet suggests that the NIC be probed for by checking its
264 "signature", the default bit pattern after a reset. This *doesn't* work --
265 there is no way to reset the bus interface without a complete power-cycle!
266
267 It turns out that ATI came to the same conclusion I did: the only thing
268 that can be done is checking a few bits and then diving right into an
269 EEPROM read. */
270
271static int __init at1700_probe1(struct net_device *dev, int ioaddr)
272{
Joe Perchesb6bc7652010-12-21 02:16:08 -0800273 static const char fmv_irqmap[4] = {3, 7, 10, 15};
274 static const char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
275 static const char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
277 int slot, ret = -ENODEV;
278 struct net_local *lp = netdev_priv(dev);
279
280 if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
281 return -EBUSY;
282
283 /* Resetting the chip doesn't reset the ISA interface, so don't bother.
284 That means we have to be careful with the register values we probe
285 for.
286 */
287#ifdef notdef
288 printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
289 ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
290 read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
291#endif
292
293#ifdef CONFIG_MCA_LEGACY
294 /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
295
296 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
297 modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
298 to support standard MCA probing. */
299
300 /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
301 /* now works as a module */
302
303 if (MCA_bus) {
304 int j;
305 int l_i;
306 u_char pos3, pos4;
307
308 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
309 slot = 0;
310 while (slot != MCA_NOTFOUND) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
313 if (slot == MCA_NOTFOUND) break;
314
315 /* if we get this far, an adapter has been detected and is
316 enabled */
317
318 pos3 = mca_read_stored_pos( slot, 3 );
319 pos4 = mca_read_stored_pos( slot, 4 );
320
roel kluin3b73e792009-07-25 12:01:50 +0000321 for (l_i = 0; l_i < 8; l_i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
323 break;
324 ioaddr = at1700_mca_probe_list[l_i];
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400325
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 for (irq = 0; irq < 0x10; irq++)
327 if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
328 break;
329
330 /* probing for a card at a particular IO/IRQ */
331 if ((dev->irq && dev->irq != irq) ||
332 (dev->base_addr && dev->base_addr != ioaddr)) {
333 slot++; /* probing next slot */
334 continue;
335 }
336
337 dev->irq = irq;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 /* claim the slot */
340 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
341 mca_mark_as_used(slot);
342
343 goto found;
344 }
345 }
346 /* if we get here, we didn't find an MCA adapter - try ISA */
347 }
348#endif
349 slot = -1;
350 /* We must check for the EEPROM-config boards first, else accessing
351 IOCONFIG0 will move the board! */
Joe Perches8e95a202009-12-03 07:58:21 +0000352 if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr &&
353 read_eeprom(ioaddr, 4) == 0x0000 &&
354 (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 is_at1700 = 1;
Joe Perches8e95a202009-12-03 07:58:21 +0000356 else if (inb(ioaddr + SAPROM ) == 0x00 &&
357 inb(ioaddr + SAPROM + 1) == 0x00 &&
358 inb(ioaddr + SAPROM + 2) == 0x0e)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 is_fmv18x = 1;
360 else {
361 goto err_out;
362 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364#ifdef CONFIG_MCA_LEGACY
365found:
366#endif
367
368 /* Reset the internal state machines. */
369 outb(0, ioaddr + RESET);
370
371 if (is_at1700) {
372 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
373 | (read_eeprom(ioaddr, 0)>>14)];
374 } else {
375 /* Check PnP mode for FMV-183/184/183A/184A. */
376 /* This PnP routine is very poor. IO and IRQ should be known. */
377 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
378 irq = dev->irq;
379 for (i = 0; i < 8; i++) {
380 if (irq == fmv_irqmap_pnp[i])
381 break;
382 }
383 if (i == 8) {
384 goto err_mca;
385 }
386 } else {
387 if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
388 goto err_mca;
389 irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
390 }
391 }
392
393 printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
394 is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
395
396 dev->base_addr = ioaddr;
397 dev->irq = irq;
398
399 if (is_at1700) {
400 for(i = 0; i < 3; i++) {
401 unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
403 }
404 } else {
405 for(i = 0; i < 6; i++) {
406 unsigned char val = inb(ioaddr + SAPROM + i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 dev->dev_addr[i] = val;
408 }
409 }
Johannes Berge1749612008-10-27 15:59:26 -0700410 printk("%pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
412 /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
413 rather than 150 ohm shielded twisted pair compensation.
414 0x0000 == auto-sense the interface
415 0x0800 == use TP interface
416 0x1800 == use coax interface
417 */
418 {
419 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
420 if (is_at1700) {
421 ushort setup_value = read_eeprom(ioaddr, 12);
422 dev->if_port = setup_value >> 8;
423 } else {
424 ushort setup_value = inb(ioaddr + CARDSTATUS);
425 switch (setup_value & 0x07) {
426 case 0x01: /* 10base5 */
427 case 0x02: /* 10base2 */
428 dev->if_port = 0x18; break;
429 case 0x04: /* 10baseT */
430 dev->if_port = 0x08; break;
431 default: /* auto-sense */
432 dev->if_port = 0x00; break;
433 }
434 }
435 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
436 }
437
438 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
439 bus access, two 4K Tx queues, and disabled Tx and Rx. */
440 outb(0xda, ioaddr + CONFIG_0);
441
442 /* Set the station address in bank zero. */
443 outb(0x00, ioaddr + CONFIG_1);
444 for (i = 0; i < 6; i++)
445 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
446
447 /* Switch to bank 1 and set the multicast table to accept none. */
448 outb(0x04, ioaddr + CONFIG_1);
449 for (i = 0; i < 8; i++)
450 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
451
452
453 /* Switch to bank 2 */
454 /* Lock our I/O address, and set manual processing mode for 16 collisions. */
455 outb(0x08, ioaddr + CONFIG_1);
456 outb(dev->if_port, ioaddr + MODE13);
457 outb(0x00, ioaddr + COL16CNTL);
458
459 if (net_debug)
460 printk(version);
461
Stephen Hemmingercb0c7002009-03-26 15:11:36 +0000462 dev->netdev_ops = &at1700_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 dev->watchdog_timeo = TX_TIMEOUT;
464
465 spin_lock_init(&lp->lock);
466
467 lp->jumpered = is_fmv18x;
468 lp->mca_slot = slot;
469 /* Snarf the interrupt vector now. */
Joe Perchesa0607fd2009-11-18 23:29:17 -0800470 ret = request_irq(irq, net_interrupt, 0, DRV_NAME, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 if (ret) {
Jeff Garzikcba05162007-11-23 21:50:34 -0500472 printk(KERN_ERR "AT1700 at %#3x is unusable due to a "
473 "conflict on IRQ %d.\n",
474 ioaddr, irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 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));
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700576 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 /* 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
Eric Dumazet1ae5dc32010-05-10 05:01:31 -0700586 dev->trans_start = jiffies; /* prevent tx timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
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
Stephen Hemminger613573252009-08-31 19:50:58 +0000598static netdev_tx_t net_send_packet (struct sk_buff *skb,
599 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600{
601 struct net_local *lp = netdev_priv(dev);
602 int ioaddr = dev->base_addr;
603 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
604 short len = skb->len;
605 unsigned char *buf = skb->data;
606 static u8 pad[ETH_ZLEN];
607
608 netif_stop_queue (dev);
609
610 /* We may not start transmitting unless we finish transferring
611 a packet into the Tx queue. During executing the following
612 codes we possibly catch a Tx interrupt. Thus we flag off
613 tx_queue_ready, so that we prevent the interrupt routine
614 (net_interrupt) to start transmitting. */
615 lp->tx_queue_ready = 0;
616 {
617 outw (length, ioaddr + DATAPORT);
618 /* Packet data */
619 outsw (ioaddr + DATAPORT, buf, len >> 1);
620 /* Check for dribble byte */
621 if (len & 1) {
622 outw(skb->data[skb->len-1], ioaddr + DATAPORT);
623 len++;
624 }
625 /* Check for packet padding */
626 if (length != skb->len)
627 outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
628
629 lp->tx_queue++;
630 lp->tx_queue_len += length + 2;
631 }
632 lp->tx_queue_ready = 1;
633
634 if (lp->tx_started == 0) {
635 /* If the Tx is idle, always trigger a transmit. */
636 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
637 lp->tx_queue = 0;
638 lp->tx_queue_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 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
Patrick McHardy6ed10652009-06-23 06:03:08 +0000646 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647}
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);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700696 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 }
698 if (status & 0x82) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700699 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 /* 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{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 int ioaddr = dev->base_addr;
725 int boguscount = 5;
726
727 while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
728 ushort status = inw(ioaddr + DATAPORT);
729 ushort pkt_len = inw(ioaddr + DATAPORT);
730
731 if (net_debug > 4)
732 printk("%s: Rxing packet mode %02x status %04x.\n",
733 dev->name, inb(ioaddr + RX_MODE), status);
734#ifndef final_version
735 if (status == 0) {
736 outb(0x05, ioaddr + RX_CTRL);
737 break;
738 }
739#endif
740
741 if ((status & 0xF0) != 0x20) { /* There was an error. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700742 dev->stats.rx_errors++;
743 if (status & 0x08) dev->stats.rx_length_errors++;
744 if (status & 0x04) dev->stats.rx_frame_errors++;
745 if (status & 0x02) dev->stats.rx_crc_errors++;
746 if (status & 0x01) dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 } else {
748 /* Malloc up new buffer. */
749 struct sk_buff *skb;
750
751 if (pkt_len > 1550) {
752 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
753 dev->name, pkt_len);
754 /* Prime the FIFO and then flush the packet. */
755 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
756 outb(0x05, ioaddr + RX_CTRL);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700757 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 break;
759 }
760 skb = dev_alloc_skb(pkt_len+3);
761 if (skb == NULL) {
762 printk("%s: Memory squeeze, dropping packet (len %d).\n",
763 dev->name, pkt_len);
764 /* Prime the FIFO and then flush the packet. */
765 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
766 outb(0x05, ioaddr + RX_CTRL);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700767 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 break;
769 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 skb_reserve(skb,2);
771
772 insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
773 skb->protocol=eth_type_trans(skb, dev);
774 netif_rx(skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700775 dev->stats.rx_packets++;
776 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 }
778 if (--boguscount <= 0)
779 break;
780 }
781
782 /* If any worth-while packets have been received, dev_rint()
783 has done a mark_bh(NET_BH) for us and will work on them
784 when we get to the bottom-half routine. */
785 {
786 int i;
787 for (i = 0; i < 20; i++) {
788 if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
789 break;
790 inw(ioaddr + DATAPORT); /* dummy status read */
791 outb(0x05, ioaddr + RX_CTRL);
792 }
793
794 if (net_debug > 5)
795 printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
796 dev->name, inb(ioaddr + RX_MODE), i);
797 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798}
799
800/* The inverse routine to net_open(). */
801static int net_close(struct net_device *dev)
802{
803 struct net_local *lp = netdev_priv(dev);
804 int ioaddr = dev->base_addr;
805
806 netif_stop_queue(dev);
807
808 /* Set configuration register 0 to disable Tx and Rx. */
809 outb(0xda, ioaddr + CONFIG_0);
810
811 /* No statistic counters on the chip to update. */
812
813 /* Disable the IRQ on boards of fmv18x where it is feasible. */
Kulikov Vasiliy451d33dd2010-07-09 02:31:26 +0000814 if (lp->jumpered)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 outb(0x00, ioaddr + IOCONFIG1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
817 /* Power-down the chip. Green, green, green! */
818 outb(0x00, ioaddr + CONFIG_1);
819 return 0;
820}
821
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822/*
823 Set the multicast/promiscuous mode for this adaptor.
824*/
825
826static void
827set_rx_mode(struct net_device *dev)
828{
829 int ioaddr = dev->base_addr;
830 struct net_local *lp = netdev_priv(dev);
831 unsigned char mc_filter[8]; /* Multicast hash filter */
832 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 if (dev->flags & IFF_PROMISC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 memset(mc_filter, 0xff, sizeof(mc_filter));
836 outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */
Jiri Pirko4cd24ea2010-02-08 04:30:35 +0000837 } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
Joe Perches8e95a202009-12-03 07:58:21 +0000838 (dev->flags & IFF_ALLMULTI)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 /* Too many to filter perfectly -- accept all multicasts. */
840 memset(mc_filter, 0xff, sizeof(mc_filter));
841 outb(2, ioaddr + RX_MODE); /* Use normal mode. */
Jiri Pirko4cd24ea2010-02-08 04:30:35 +0000842 } else if (netdev_mc_empty(dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 memset(mc_filter, 0x00, sizeof(mc_filter));
844 outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */
845 } else {
Jiri Pirko22bedad2010-04-01 21:22:57 +0000846 struct netdev_hw_addr *ha;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847
848 memset(mc_filter, 0, sizeof(mc_filter));
Jiri Pirko22bedad2010-04-01 21:22:57 +0000849 netdev_for_each_mc_addr(ha, dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 unsigned int bit =
Jiri Pirko22bedad2010-04-01 21:22:57 +0000851 ether_crc_le(ETH_ALEN, ha->addr) >> 26;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 mc_filter[bit >> 3] |= (1 << bit);
853 }
854 outb(0x02, ioaddr + RX_MODE); /* Use normal mode. */
855 }
856
857 spin_lock_irqsave (&lp->lock, flags);
858 if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
Hannes Eder1256f732009-02-14 11:11:55 +0000859 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}
870
871#ifdef MODULE
872static struct net_device *dev_at1700;
873
874module_param(io, int, 0);
875module_param(irq, int, 0);
876module_param(net_debug, int, 0);
877MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
878MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
879MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
880
Jon Schindler5250f332008-02-28 01:31:12 -0600881static int __init at1700_module_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882{
883 if (io == 0)
884 printk("at1700: You should not use auto-probing with insmod!\n");
885 dev_at1700 = at1700_probe(-1);
886 if (IS_ERR(dev_at1700))
887 return PTR_ERR(dev_at1700);
888 return 0;
889}
890
Jon Schindler5250f332008-02-28 01:31:12 -0600891static void __exit at1700_module_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892{
893 unregister_netdev(dev_at1700);
894 cleanup_card(dev_at1700);
895 free_netdev(dev_at1700);
896}
Jon Schindler5250f332008-02-28 01:31:12 -0600897module_init(at1700_module_init);
898module_exit(at1700_module_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899#endif /* MODULE */
900MODULE_LICENSE("GPL");