blob: 544d5af6950ec8fd577d3999d5f8b61e8ff4e96e [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);
Stephen Hemminger613573252009-08-31 19:50:58 +0000162static netdev_tx_t net_send_packet(struct sk_buff *skb,
163 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167static void set_rx_mode(struct net_device *dev);
168static void net_tx_timeout (struct net_device *dev);
169
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171#ifdef CONFIG_MCA_LEGACY
172struct at1720_mca_adapters_struct {
173 char* name;
174 int id;
175};
176/* rEnE : maybe there are others I don't know off... */
177
178static struct at1720_mca_adapters_struct at1720_mca_adapters[] __initdata = {
179 { "Allied Telesys AT1720AT", 0x6410 },
180 { "Allied Telesys AT1720BT", 0x6413 },
181 { "Allied Telesys AT1720T", 0x6416 },
182 { NULL, 0 },
183};
184#endif
185
186/* Check for a network adaptor of this type, and return '0' iff one exists.
187 If dev->base_addr == 0, probe all likely locations.
188 If dev->base_addr == 1, always return failure.
189 If dev->base_addr == 2, allocate space for the device and return success
190 (detachable devices only).
191 */
192
193static int io = 0x260;
194
195static int irq;
196
197static void cleanup_card(struct net_device *dev)
198{
199#ifdef CONFIG_MCA_LEGACY
200 struct net_local *lp = netdev_priv(dev);
201 if (lp->mca_slot >= 0)
202 mca_mark_as_unused(lp->mca_slot);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400203#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 free_irq(dev->irq, NULL);
205 release_region(dev->base_addr, AT1700_IO_EXTENT);
206}
207
208struct net_device * __init at1700_probe(int unit)
209{
210 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
211 unsigned *port;
212 int err = 0;
213
214 if (!dev)
215 return ERR_PTR(-ENODEV);
216
217 if (unit >= 0) {
218 sprintf(dev->name, "eth%d", unit);
219 netdev_boot_setup_check(dev);
220 io = dev->base_addr;
221 irq = dev->irq;
222 } else {
223 dev->base_addr = io;
224 dev->irq = irq;
225 }
226
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 if (io > 0x1ff) { /* Check a single specified location. */
228 err = at1700_probe1(dev, io);
229 } else if (io != 0) { /* Don't probe at all. */
230 err = -ENXIO;
231 } else {
232 for (port = at1700_probe_list; *port; port++) {
233 if (at1700_probe1(dev, *port) == 0)
234 break;
235 dev->irq = irq;
236 }
237 if (!*port)
238 err = -ENODEV;
239 }
240 if (err)
241 goto out;
242 err = register_netdev(dev);
243 if (err)
244 goto out1;
245 return dev;
246out1:
247 cleanup_card(dev);
248out:
249 free_netdev(dev);
250 return ERR_PTR(err);
251}
252
Stephen Hemmingercb0c7002009-03-26 15:11:36 +0000253static const struct net_device_ops at1700_netdev_ops = {
254 .ndo_open = net_open,
255 .ndo_stop = net_close,
256 .ndo_start_xmit = net_send_packet,
257 .ndo_set_multicast_list = set_rx_mode,
258 .ndo_tx_timeout = net_tx_timeout,
259 .ndo_change_mtu = eth_change_mtu,
260 .ndo_set_mac_address = eth_mac_addr,
261 .ndo_validate_addr = eth_validate_addr,
262};
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264/* The Fujitsu datasheet suggests that the NIC be probed for by checking its
265 "signature", the default bit pattern after a reset. This *doesn't* work --
266 there is no way to reset the bus interface without a complete power-cycle!
267
268 It turns out that ATI came to the same conclusion I did: the only thing
269 that can be done is checking a few bits and then diving right into an
270 EEPROM read. */
271
272static int __init at1700_probe1(struct net_device *dev, int ioaddr)
273{
274 char fmv_irqmap[4] = {3, 7, 10, 15};
275 char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
276 char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
277 unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
278 int slot, ret = -ENODEV;
279 struct net_local *lp = netdev_priv(dev);
280
281 if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
282 return -EBUSY;
283
284 /* Resetting the chip doesn't reset the ISA interface, so don't bother.
285 That means we have to be careful with the register values we probe
286 for.
287 */
288#ifdef notdef
289 printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
290 ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
291 read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
292#endif
293
294#ifdef CONFIG_MCA_LEGACY
295 /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
296
297 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
298 modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
299 to support standard MCA probing. */
300
301 /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
302 /* now works as a module */
303
304 if (MCA_bus) {
305 int j;
306 int l_i;
307 u_char pos3, pos4;
308
309 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
310 slot = 0;
311 while (slot != MCA_NOTFOUND) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
314 if (slot == MCA_NOTFOUND) break;
315
316 /* if we get this far, an adapter has been detected and is
317 enabled */
318
319 pos3 = mca_read_stored_pos( slot, 3 );
320 pos4 = mca_read_stored_pos( slot, 4 );
321
roel kluin3b73e792009-07-25 12:01:50 +0000322 for (l_i = 0; l_i < 8; l_i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
324 break;
325 ioaddr = at1700_mca_probe_list[l_i];
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 for (irq = 0; irq < 0x10; irq++)
328 if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
329 break;
330
331 /* probing for a card at a particular IO/IRQ */
332 if ((dev->irq && dev->irq != irq) ||
333 (dev->base_addr && dev->base_addr != ioaddr)) {
334 slot++; /* probing next slot */
335 continue;
336 }
337
338 dev->irq = irq;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 /* claim the slot */
341 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
342 mca_mark_as_used(slot);
343
344 goto found;
345 }
346 }
347 /* if we get here, we didn't find an MCA adapter - try ISA */
348 }
349#endif
350 slot = -1;
351 /* We must check for the EEPROM-config boards first, else accessing
352 IOCONFIG0 will move the board! */
353 if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr
354 && read_eeprom(ioaddr, 4) == 0x0000
355 && (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
356 is_at1700 = 1;
357 else if (inb(ioaddr + SAPROM ) == 0x00
358 && inb(ioaddr + SAPROM + 1) == 0x00
359 && inb(ioaddr + SAPROM + 2) == 0x0e)
360 is_fmv18x = 1;
361 else {
362 goto err_out;
363 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365#ifdef CONFIG_MCA_LEGACY
366found:
367#endif
368
369 /* Reset the internal state machines. */
370 outb(0, ioaddr + RESET);
371
372 if (is_at1700) {
373 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
374 | (read_eeprom(ioaddr, 0)>>14)];
375 } else {
376 /* Check PnP mode for FMV-183/184/183A/184A. */
377 /* This PnP routine is very poor. IO and IRQ should be known. */
378 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
379 irq = dev->irq;
380 for (i = 0; i < 8; i++) {
381 if (irq == fmv_irqmap_pnp[i])
382 break;
383 }
384 if (i == 8) {
385 goto err_mca;
386 }
387 } else {
388 if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
389 goto err_mca;
390 irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
391 }
392 }
393
394 printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
395 is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
396
397 dev->base_addr = ioaddr;
398 dev->irq = irq;
399
400 if (is_at1700) {
401 for(i = 0; i < 3; i++) {
402 unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
404 }
405 } else {
406 for(i = 0; i < 6; i++) {
407 unsigned char val = inb(ioaddr + SAPROM + i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 dev->dev_addr[i] = val;
409 }
410 }
Johannes Berge1749612008-10-27 15:59:26 -0700411 printk("%pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
413 /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
414 rather than 150 ohm shielded twisted pair compensation.
415 0x0000 == auto-sense the interface
416 0x0800 == use TP interface
417 0x1800 == use coax interface
418 */
419 {
420 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
421 if (is_at1700) {
422 ushort setup_value = read_eeprom(ioaddr, 12);
423 dev->if_port = setup_value >> 8;
424 } else {
425 ushort setup_value = inb(ioaddr + CARDSTATUS);
426 switch (setup_value & 0x07) {
427 case 0x01: /* 10base5 */
428 case 0x02: /* 10base2 */
429 dev->if_port = 0x18; break;
430 case 0x04: /* 10baseT */
431 dev->if_port = 0x08; break;
432 default: /* auto-sense */
433 dev->if_port = 0x00; break;
434 }
435 }
436 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
437 }
438
439 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
440 bus access, two 4K Tx queues, and disabled Tx and Rx. */
441 outb(0xda, ioaddr + CONFIG_0);
442
443 /* Set the station address in bank zero. */
444 outb(0x00, ioaddr + CONFIG_1);
445 for (i = 0; i < 6; i++)
446 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
447
448 /* Switch to bank 1 and set the multicast table to accept none. */
449 outb(0x04, ioaddr + CONFIG_1);
450 for (i = 0; i < 8; i++)
451 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
452
453
454 /* Switch to bank 2 */
455 /* Lock our I/O address, and set manual processing mode for 16 collisions. */
456 outb(0x08, ioaddr + CONFIG_1);
457 outb(dev->if_port, ioaddr + MODE13);
458 outb(0x00, ioaddr + COL16CNTL);
459
460 if (net_debug)
461 printk(version);
462
Stephen Hemmingercb0c7002009-03-26 15:11:36 +0000463 dev->netdev_ops = &at1700_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 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) {
Jeff Garzikcba05162007-11-23 21:50:34 -0500473 printk(KERN_ERR "AT1700 at %#3x is unusable due to a "
474 "conflict on IRQ %d.\n",
475 ioaddr, irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 goto err_mca;
477 }
478
479 return 0;
480
481err_mca:
482#ifdef CONFIG_MCA_LEGACY
483 if (slot >= 0)
484 mca_mark_as_unused(slot);
485#endif
486err_out:
487 release_region(ioaddr, AT1700_IO_EXTENT);
488 return ret;
489}
490
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400491
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492/* EEPROM_Ctrl bits. */
493#define EE_SHIFT_CLK 0x40 /* EEPROM shift clock, in reg. 16. */
494#define EE_CS 0x20 /* EEPROM chip select, in reg. 16. */
495#define EE_DATA_WRITE 0x80 /* EEPROM chip data in, in reg. 17. */
496#define EE_DATA_READ 0x80 /* EEPROM chip data out, in reg. 17. */
497
498/* The EEPROM commands include the alway-set leading bit. */
499#define EE_WRITE_CMD (5 << 6)
500#define EE_READ_CMD (6 << 6)
501#define EE_ERASE_CMD (7 << 6)
502
503static int __init read_eeprom(long ioaddr, int location)
504{
505 int i;
506 unsigned short retval = 0;
507 long ee_addr = ioaddr + EEPROM_Ctrl;
508 long ee_daddr = ioaddr + EEPROM_Data;
509 int read_cmd = location | EE_READ_CMD;
510
511 /* Shift the read command bits out. */
512 for (i = 9; i >= 0; i--) {
513 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
514 outb(EE_CS, ee_addr);
515 outb(dataval, ee_daddr);
516 outb(EE_CS | EE_SHIFT_CLK, ee_addr); /* EEPROM clock tick. */
517 }
518 outb(EE_DATA_WRITE, ee_daddr);
519 for (i = 16; i > 0; i--) {
520 outb(EE_CS, ee_addr);
521 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
522 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
523 }
524
525 /* Terminate the EEPROM access. */
526 outb(EE_CS, ee_addr);
527 outb(EE_SHIFT_CLK, ee_addr);
528 outb(0, ee_addr);
529 return retval;
530}
531
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400532
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
534static int net_open(struct net_device *dev)
535{
536 struct net_local *lp = netdev_priv(dev);
537 int ioaddr = dev->base_addr;
538
539 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
540 bus access, and two 4K Tx queues. */
541 outb(0x5a, ioaddr + CONFIG_0);
542
543 /* Powerup, switch to register bank 2, and enable the Rx and Tx. */
544 outb(0xe8, ioaddr + CONFIG_1);
545
546 lp->tx_started = 0;
547 lp->tx_queue_ready = 1;
548 lp->rx_started = 0;
549 lp->tx_queue = 0;
550 lp->tx_queue_len = 0;
551
552 /* Turn on hardware Tx and Rx interrupts. */
553 outb(0x82, ioaddr + TX_INTR);
554 outb(0x81, ioaddr + RX_INTR);
555
556 /* Enable the IRQ on boards of fmv18x it is feasible. */
557 if (lp->jumpered) {
558 outb(0x80, ioaddr + IOCONFIG1);
559 }
560
561 netif_start_queue(dev);
562 return 0;
563}
564
565static void net_tx_timeout (struct net_device *dev)
566{
567 struct net_local *lp = netdev_priv(dev);
568 int ioaddr = dev->base_addr;
569
570 printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
571 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
572 ? "IRQ conflict" : "network cable problem");
573 printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
574 dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
575 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
576 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700577 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 /* ToDo: We should try to restart the adaptor... */
579 outw(0xffff, ioaddr + MODE24);
580 outw (0xffff, ioaddr + TX_STATUS);
581 outb (0x5a, ioaddr + CONFIG_0);
582 outb (0xe8, ioaddr + CONFIG_1);
583 outw (0x8182, ioaddr + TX_INTR);
584 outb (0x00, ioaddr + TX_START);
585 outb (0x03, ioaddr + COL16CNTL);
586
587 dev->trans_start = jiffies;
588
589 lp->tx_started = 0;
590 lp->tx_queue_ready = 1;
591 lp->rx_started = 0;
592 lp->tx_queue = 0;
593 lp->tx_queue_len = 0;
594
595 netif_wake_queue(dev);
596}
597
598
Stephen Hemminger613573252009-08-31 19:50:58 +0000599static netdev_tx_t net_send_packet (struct sk_buff *skb,
600 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{
602 struct net_local *lp = netdev_priv(dev);
603 int ioaddr = dev->base_addr;
604 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
605 short len = skb->len;
606 unsigned char *buf = skb->data;
607 static u8 pad[ETH_ZLEN];
608
609 netif_stop_queue (dev);
610
611 /* We may not start transmitting unless we finish transferring
612 a packet into the Tx queue. During executing the following
613 codes we possibly catch a Tx interrupt. Thus we flag off
614 tx_queue_ready, so that we prevent the interrupt routine
615 (net_interrupt) to start transmitting. */
616 lp->tx_queue_ready = 0;
617 {
618 outw (length, ioaddr + DATAPORT);
619 /* Packet data */
620 outsw (ioaddr + DATAPORT, buf, len >> 1);
621 /* Check for dribble byte */
622 if (len & 1) {
623 outw(skb->data[skb->len-1], ioaddr + DATAPORT);
624 len++;
625 }
626 /* Check for packet padding */
627 if (length != skb->len)
628 outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
629
630 lp->tx_queue++;
631 lp->tx_queue_len += length + 2;
632 }
633 lp->tx_queue_ready = 1;
634
635 if (lp->tx_started == 0) {
636 /* If the Tx is idle, always trigger a transmit. */
637 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
638 lp->tx_queue = 0;
639 lp->tx_queue_len = 0;
640 dev->trans_start = jiffies;
641 lp->tx_started = 1;
642 netif_start_queue (dev);
643 } else if (lp->tx_queue_len < 4096 - 1502)
644 /* Yes, there is room for one more packet. */
645 netif_start_queue (dev);
646 dev_kfree_skb (skb);
647
Patrick McHardy6ed10652009-06-23 06:03:08 +0000648 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651/* The typical workload of the driver:
652 Handle the network interface interrupts. */
David Howells7d12e782006-10-05 14:55:46 +0100653static irqreturn_t net_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654{
655 struct net_device *dev = dev_id;
656 struct net_local *lp;
657 int ioaddr, status;
658 int handled = 0;
659
660 if (dev == NULL) {
661 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
662 return IRQ_NONE;
663 }
664
665 ioaddr = dev->base_addr;
666 lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400667
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 spin_lock (&lp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400669
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 status = inw(ioaddr + TX_STATUS);
671 outw(status, ioaddr + TX_STATUS);
672
673 if (net_debug > 4)
674 printk("%s: Interrupt with status %04x.\n", dev->name, status);
675 if (lp->rx_started == 0 &&
676 (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
677 /* Got a packet(s).
678 We cannot execute net_rx more than once at the same time for
679 the same device. During executing net_rx, we possibly catch a
680 Tx interrupt. Thus we flag on rx_started, so that we prevent
681 the interrupt routine (net_interrupt) to dive into net_rx
682 again. */
683 handled = 1;
684 lp->rx_started = 1;
685 outb(0x00, ioaddr + RX_INTR); /* Disable RX intr. */
686 net_rx(dev);
687 outb(0x81, ioaddr + RX_INTR); /* Enable RX intr. */
688 lp->rx_started = 0;
689 }
690 if (status & 0x00ff) {
691 handled = 1;
692 if (status & 0x02) {
693 /* More than 16 collisions occurred */
694 if (net_debug > 4)
695 printk("%s: 16 Collision occur during Txing.\n", dev->name);
696 /* Cancel sending a packet. */
697 outb(0x03, ioaddr + COL16CNTL);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700698 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 }
700 if (status & 0x82) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700701 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 /* The Tx queue has any packets and is not being
703 transferred a packet from the host, start
704 transmitting. */
705 if (lp->tx_queue && lp->tx_queue_ready) {
706 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
707 lp->tx_queue = 0;
708 lp->tx_queue_len = 0;
709 dev->trans_start = jiffies;
710 netif_wake_queue (dev);
711 } else {
712 lp->tx_started = 0;
713 netif_wake_queue (dev);
714 }
715 }
716 }
717
718 spin_unlock (&lp->lock);
719 return IRQ_RETVAL(handled);
720}
721
722/* We have a good packet(s), get it/them out of the buffers. */
723static void
724net_rx(struct net_device *dev)
725{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 int ioaddr = dev->base_addr;
727 int boguscount = 5;
728
729 while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
730 ushort status = inw(ioaddr + DATAPORT);
731 ushort pkt_len = inw(ioaddr + DATAPORT);
732
733 if (net_debug > 4)
734 printk("%s: Rxing packet mode %02x status %04x.\n",
735 dev->name, inb(ioaddr + RX_MODE), status);
736#ifndef final_version
737 if (status == 0) {
738 outb(0x05, ioaddr + RX_CTRL);
739 break;
740 }
741#endif
742
743 if ((status & 0xF0) != 0x20) { /* There was an error. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700744 dev->stats.rx_errors++;
745 if (status & 0x08) dev->stats.rx_length_errors++;
746 if (status & 0x04) dev->stats.rx_frame_errors++;
747 if (status & 0x02) dev->stats.rx_crc_errors++;
748 if (status & 0x01) dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 } else {
750 /* Malloc up new buffer. */
751 struct sk_buff *skb;
752
753 if (pkt_len > 1550) {
754 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
755 dev->name, pkt_len);
756 /* Prime the FIFO and then flush the packet. */
757 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
758 outb(0x05, ioaddr + RX_CTRL);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700759 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 break;
761 }
762 skb = dev_alloc_skb(pkt_len+3);
763 if (skb == NULL) {
764 printk("%s: Memory squeeze, dropping packet (len %d).\n",
765 dev->name, pkt_len);
766 /* Prime the FIFO and then flush the packet. */
767 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
768 outb(0x05, ioaddr + RX_CTRL);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700769 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 break;
771 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 skb_reserve(skb,2);
773
774 insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
775 skb->protocol=eth_type_trans(skb, dev);
776 netif_rx(skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700777 dev->stats.rx_packets++;
778 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 }
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827/*
828 Set the multicast/promiscuous mode for this adaptor.
829*/
830
831static void
832set_rx_mode(struct net_device *dev)
833{
834 int ioaddr = dev->base_addr;
835 struct net_local *lp = netdev_priv(dev);
836 unsigned char mc_filter[8]; /* Multicast hash filter */
837 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
839 if (dev->flags & IFF_PROMISC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 memset(mc_filter, 0xff, sizeof(mc_filter));
841 outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */
842 } else if (dev->mc_count > MC_FILTERBREAK
843 || (dev->flags & IFF_ALLMULTI)) {
844 /* Too many to filter perfectly -- accept all multicasts. */
845 memset(mc_filter, 0xff, sizeof(mc_filter));
846 outb(2, ioaddr + RX_MODE); /* Use normal mode. */
847 } else if (dev->mc_count == 0) {
848 memset(mc_filter, 0x00, sizeof(mc_filter));
849 outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */
850 } else {
851 struct dev_mc_list *mclist;
852 int i;
853
854 memset(mc_filter, 0, sizeof(mc_filter));
855 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
856 i++, mclist = mclist->next) {
857 unsigned int bit =
858 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
859 mc_filter[bit >> 3] |= (1 << bit);
860 }
861 outb(0x02, ioaddr + RX_MODE); /* Use normal mode. */
862 }
863
864 spin_lock_irqsave (&lp->lock, flags);
865 if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
Hannes Eder1256f732009-02-14 11:11:55 +0000866 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 int saved_bank = inw(ioaddr + CONFIG_0);
868 /* Switch to bank 1 and set the multicast table. */
869 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
870 for (i = 0; i < 8; i++)
871 outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
872 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
873 outw(saved_bank, ioaddr + CONFIG_0);
874 }
875 spin_unlock_irqrestore (&lp->lock, flags);
876 return;
877}
878
879#ifdef MODULE
880static struct net_device *dev_at1700;
881
882module_param(io, int, 0);
883module_param(irq, int, 0);
884module_param(net_debug, int, 0);
885MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
886MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
887MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
888
Jon Schindler5250f332008-02-28 01:31:12 -0600889static int __init at1700_module_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890{
891 if (io == 0)
892 printk("at1700: You should not use auto-probing with insmod!\n");
893 dev_at1700 = at1700_probe(-1);
894 if (IS_ERR(dev_at1700))
895 return PTR_ERR(dev_at1700);
896 return 0;
897}
898
Jon Schindler5250f332008-02-28 01:31:12 -0600899static void __exit at1700_module_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900{
901 unregister_netdev(dev_at1700);
902 cleanup_card(dev_at1700);
903 free_netdev(dev_at1700);
904}
Jon Schindler5250f332008-02-28 01:31:12 -0600905module_init(at1700_module_init);
906module_exit(at1700_module_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907#endif /* MODULE */
908MODULE_LICENSE("GPL");