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