projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] bcm43xx: Fix array overrun in bcm43xx_geo_init
[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
21 (tamy@flab.fujitsu.co.jp).
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
LT		 37
38#include <linux/config.h>
39#include <linux/errno.h>
40#include <linux/netdevice.h>
41#include <linux/etherdevice.h>
42#include <linux/mca-legacy.h>
43#include <linux/module.h>
44#include <linux/kernel.h>
45#include <linux/types.h>
46#include <linux/fcntl.h>
47#include <linux/interrupt.h>
48#include <linux/ioport.h>
49#include <linux/in.h>
50#include <linux/skbuff.h>
51#include <linux/slab.h>
52#include <linux/string.h>
53#include <linux/init.h>
54#include <linux/crc32.h>
55#include <linux/bitops.h>
56
57#include <asm/system.h>
58#include <asm/io.h>
59#include <asm/dma.h>
60
61static char version[] __initdata =
62 "at1700.c:v1.15 4/7/98 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
63
64#define DRV_NAME "at1700"
65
66/* Tunable parameters. */
67
68/* When to switch from the 64-entry multicast filter to Rx-all-multicast. */
69#define MC_FILTERBREAK 64
70
71/* These unusual address orders are used to verify the CONFIG register. */
72
73static int fmv18x_probe_list[] __initdata = {
74 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
75};
76
77/*
78 * ISA
79 */
80
81static unsigned at1700_probe_list[] __initdata = {
82 0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
83};
84
85/*
86 * MCA
87 */
88#ifdef CONFIG_MCA_LEGACY
89static int at1700_ioaddr_pattern[] __initdata = {
90 0x00, 0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07
91};
92
93static int at1700_mca_probe_list[] __initdata = {
94 0x400, 0x1400, 0x2400, 0x3400, 0x4400, 0x5400, 0x6400, 0x7400, 0
95};
96
97static int at1700_irq_pattern[] __initdata = {
98 0x00, 0x00, 0x00, 0x30, 0x70, 0xb0, 0x00, 0x00,
99 0x00, 0xf0, 0x34, 0x74, 0xb4, 0x00, 0x00, 0xf4, 0x00
100};
101#endif
102
103/* use 0 for production, 1 for verification, >2 for debug */
104#ifndef NET_DEBUG
105#define NET_DEBUG 1
106#endif
107static unsigned int net_debug = NET_DEBUG;
108
109typedef unsigned char uchar;
110
111/* Information that need to be kept for each board. */
112struct net_local {
113 struct net_device_stats stats;
114 spinlock_t lock;
115 unsigned char mc_filter[8];
116 uint jumpered:1; /* Set iff the board has jumper config. */
117 uint tx_started:1; /* Packets are on the Tx queue. */
118 uint tx_queue_ready:1; /* Tx queue is ready to be sent. */
119 uint rx_started:1; /* Packets are Rxing. */
120 uchar tx_queue; /* Number of packet on the Tx queue. */
121 char mca_slot; /* -1 means ISA */
122 ushort tx_queue_len; /* Current length of the Tx queue. */
123};
124
125
126/* Offsets from the base address. */
127#define STATUS 0
128#define TX_STATUS 0
129#define RX_STATUS 1
130#define TX_INTR 2 /* Bit-mapped interrupt enable registers. */
131#define RX_INTR 3
132#define TX_MODE 4
133#define RX_MODE 5
134#define CONFIG_0 6 /* Misc. configuration settings. */
135#define CONFIG_1 7
136/* Run-time register bank 2 definitions. */
137#define DATAPORT 8 /* Word-wide DMA or programmed-I/O dataport. */
138#define TX_START 10
139#define COL16CNTL 11 /* Controll Reg for 16 collisions */
140#define MODE13 13
141#define RX_CTRL 14
142/* Configuration registers only on the '865A/B chips. */
143#define EEPROM_Ctrl 16
144#define EEPROM_Data 17
145#define CARDSTATUS 16 /* FMV-18x Card Status */
146#define CARDSTATUS1 17 /* FMV-18x Card Status */
147#define IOCONFIG 18 /* Either read the jumper, or move the I/O. */
148#define IOCONFIG1 19
149#define SAPROM 20 /* The station address PROM, if no EEPROM. */
150#define MODE24 24
151#define RESET 31 /* Write to reset some parts of the chip. */
152#define AT1700_IO_EXTENT 32
153#define PORT_OFFSET(o) (o)
154
155
156#define TX_TIMEOUT 10
157
158
159/* Index to functions, as function prototypes. */
160
161static int at1700_probe1(struct net_device *dev, int ioaddr);
162static int read_eeprom(long ioaddr, int location);
163static int net_open(struct net_device *dev);
164static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
165static irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs *regs);
166static void net_rx(struct net_device *dev);
167static int net_close(struct net_device *dev);
168static struct net_device_stats *net_get_stats(struct net_device *dev);
169static void set_rx_mode(struct net_device *dev);
170static void net_tx_timeout (struct net_device *dev);
171
172\f
173#ifdef CONFIG_MCA_LEGACY
174struct at1720_mca_adapters_struct {
175 char* name;
176 int id;
177};
178/* rEnE : maybe there are others I don't know off... */
179
180static struct at1720_mca_adapters_struct at1720_mca_adapters[] __initdata = {
181 { "Allied Telesys AT1720AT", 0x6410 },
182 { "Allied Telesys AT1720BT", 0x6413 },
183 { "Allied Telesys AT1720T", 0x6416 },
184 { NULL, 0 },
185};
186#endif
187
188/* Check for a network adaptor of this type, and return '0' iff one exists.
189 If dev->base_addr == 0, probe all likely locations.
190 If dev->base_addr == 1, always return failure.
191 If dev->base_addr == 2, allocate space for the device and return success
192 (detachable devices only).
193 */
194
195static int io = 0x260;
196
197static int irq;
198
199static void cleanup_card(struct net_device *dev)
200{
201#ifdef CONFIG_MCA_LEGACY
202 struct net_local *lp = netdev_priv(dev);
203 if (lp->mca_slot >= 0)
204 mca_mark_as_unused(lp->mca_slot);
205#endif
206 free_irq(dev->irq, NULL);
207 release_region(dev->base_addr, AT1700_IO_EXTENT);
208}
209
210struct net_device * __init at1700_probe(int unit)
211{
212 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
213 unsigned *port;
214 int err = 0;
215
216 if (!dev)
217 return ERR_PTR(-ENODEV);
218
219 if (unit >= 0) {
220 sprintf(dev->name, "eth%d", unit);
221 netdev_boot_setup_check(dev);
222 io = dev->base_addr;
223 irq = dev->irq;
224 } else {
225 dev->base_addr = io;
226 dev->irq = irq;
227 }
228
229 SET_MODULE_OWNER(dev);
230
231 if (io > 0x1ff) { /* Check a single specified location. */
232 err = at1700_probe1(dev, io);
233 } else if (io != 0) { /* Don't probe at all. */
234 err = -ENXIO;
235 } else {
236 for (port = at1700_probe_list; *port; port++) {
237 if (at1700_probe1(dev, *port) == 0)
238 break;
239 dev->irq = irq;
240 }
241 if (!*port)
242 err = -ENODEV;
243 }
244 if (err)
245 goto out;
246 err = register_netdev(dev);
247 if (err)
248 goto out1;
249 return dev;
250out1:
251 cleanup_card(dev);
252out:
253 free_netdev(dev);
254 return ERR_PTR(err);
255}
256
257/* The Fujitsu datasheet suggests that the NIC be probed for by checking its
258 "signature", the default bit pattern after a reset. This *doesn't* work --
259 there is no way to reset the bus interface without a complete power-cycle!
260
261 It turns out that ATI came to the same conclusion I did: the only thing
262 that can be done is checking a few bits and then diving right into an
263 EEPROM read. */
264
265static int __init at1700_probe1(struct net_device *dev, int ioaddr)
266{
267 char fmv_irqmap[4] = {3, 7, 10, 15};
268 char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
269 char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
270 unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
271 int slot, ret = -ENODEV;
272 struct net_local *lp = netdev_priv(dev);
273
274 if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
275 return -EBUSY;
276
277 /* Resetting the chip doesn't reset the ISA interface, so don't bother.
278 That means we have to be careful with the register values we probe
279 for.
280 */
281#ifdef notdef
282 printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
283 ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
284 read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
285#endif
286
287#ifdef CONFIG_MCA_LEGACY
288 /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
289
290 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
291 modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
292 to support standard MCA probing. */
293
294 /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
295 /* now works as a module */
296
297 if (MCA_bus) {
298 int j;
299 int l_i;
300 u_char pos3, pos4;
301
302 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
303 slot = 0;
304 while (slot != MCA_NOTFOUND) {
305
306 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
307 if (slot == MCA_NOTFOUND) break;
308
309 /* if we get this far, an adapter has been detected and is
310 enabled */
311
312 pos3 = mca_read_stored_pos( slot, 3 );
313 pos4 = mca_read_stored_pos( slot, 4 );
314
315 for (l_i = 0; l_i < 0x09; l_i++)
316 if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
317 break;
318 ioaddr = at1700_mca_probe_list[l_i];
319
320 for (irq = 0; irq < 0x10; irq++)
321 if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
322 break;
323
324 /* probing for a card at a particular IO/IRQ */
325 if ((dev->irq && dev->irq != irq) ||
326 (dev->base_addr && dev->base_addr != ioaddr)) {
327 slot++; /* probing next slot */
328 continue;
329 }
330
331 dev->irq = irq;
332
333 /* claim the slot */
334 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
335 mca_mark_as_used(slot);
336
337 goto found;
338 }
339 }
340 /* if we get here, we didn't find an MCA adapter - try ISA */
341 }
342#endif
343 slot = -1;
344 /* We must check for the EEPROM-config boards first, else accessing
345 IOCONFIG0 will move the board! */
346 if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr
347 && read_eeprom(ioaddr, 4) == 0x0000
348 && (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
349 is_at1700 = 1;
350 else if (inb(ioaddr + SAPROM ) == 0x00
351 && inb(ioaddr + SAPROM + 1) == 0x00
352 && inb(ioaddr + SAPROM + 2) == 0x0e)
353 is_fmv18x = 1;
354 else {
355 goto err_out;
356 }
357
358#ifdef CONFIG_MCA_LEGACY
359found:
360#endif
361
362 /* Reset the internal state machines. */
363 outb(0, ioaddr + RESET);
364
365 if (is_at1700) {
366 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
367 | (read_eeprom(ioaddr, 0)>>14)];
368 } else {
369 /* Check PnP mode for FMV-183/184/183A/184A. */
370 /* This PnP routine is very poor. IO and IRQ should be known. */
371 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
372 irq = dev->irq;
373 for (i = 0; i < 8; i++) {
374 if (irq == fmv_irqmap_pnp[i])
375 break;
376 }
377 if (i == 8) {
378 goto err_mca;
379 }
380 } else {
381 if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
382 goto err_mca;
383 irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
384 }
385 }
386
387 printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
388 is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
389
390 dev->base_addr = ioaddr;
391 dev->irq = irq;
392
393 if (is_at1700) {
394 for(i = 0; i < 3; i++) {
395 unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
396 printk("%04x", eeprom_val);
397 ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
398 }
399 } else {
400 for(i = 0; i < 6; i++) {
401 unsigned char val = inb(ioaddr + SAPROM + i);
402 printk("%02x", val);
403 dev->dev_addr[i] = val;
404 }
405 }
406
407 /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
408 rather than 150 ohm shielded twisted pair compensation.
409 0x0000 == auto-sense the interface
410 0x0800 == use TP interface
411 0x1800 == use coax interface
412 */
413 {
414 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
415 if (is_at1700) {
416 ushort setup_value = read_eeprom(ioaddr, 12);
417 dev->if_port = setup_value >> 8;
418 } else {
419 ushort setup_value = inb(ioaddr + CARDSTATUS);
420 switch (setup_value & 0x07) {
421 case 0x01: /* 10base5 */
422 case 0x02: /* 10base2 */
423 dev->if_port = 0x18; break;
424 case 0x04: /* 10baseT */
425 dev->if_port = 0x08; break;
426 default: /* auto-sense */
427 dev->if_port = 0x00; break;
428 }
429 }
430 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
431 }
432
433 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
434 bus access, two 4K Tx queues, and disabled Tx and Rx. */
435 outb(0xda, ioaddr + CONFIG_0);
436
437 /* Set the station address in bank zero. */
438 outb(0x00, ioaddr + CONFIG_1);
439 for (i = 0; i < 6; i++)
440 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
441
442 /* Switch to bank 1 and set the multicast table to accept none. */
443 outb(0x04, ioaddr + CONFIG_1);
444 for (i = 0; i < 8; i++)
445 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
446
447
448 /* Switch to bank 2 */
449 /* Lock our I/O address, and set manual processing mode for 16 collisions. */
450 outb(0x08, ioaddr + CONFIG_1);
451 outb(dev->if_port, ioaddr + MODE13);
452 outb(0x00, ioaddr + COL16CNTL);
453
454 if (net_debug)
455 printk(version);
456
457 memset(lp, 0, sizeof(struct net_local));
458
459 dev->open = net_open;
460 dev->stop = net_close;
461 dev->hard_start_xmit = net_send_packet;
462 dev->get_stats = net_get_stats;
463 dev->set_multicast_list = &set_rx_mode;
464 dev->tx_timeout = net_tx_timeout;
465 dev->watchdog_timeo = TX_TIMEOUT;
466
467 spin_lock_init(&lp->lock);
468
469 lp->jumpered = is_fmv18x;
470 lp->mca_slot = slot;
471 /* Snarf the interrupt vector now. */
472 ret = request_irq(irq, &net_interrupt, 0, DRV_NAME, dev);
473 if (ret) {
474 printk (" AT1700 at %#3x is unusable due to a conflict on"
475 "IRQ %d.\n", ioaddr, irq);
476 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
491\f
492/* 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
532\f
533
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));
577 lp->stats.tx_errors++;
578 /* 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
599static int net_send_packet (struct sk_buff *skb, struct net_device *dev)
600{
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;
639 dev->trans_start = jiffies;
640 lp->tx_started = 1;
641 netif_start_queue (dev);
642 } else if (lp->tx_queue_len < 4096 - 1502)
643 /* Yes, there is room for one more packet. */
644 netif_start_queue (dev);
645 dev_kfree_skb (skb);
646
647 return 0;
648}
649\f
650/* The typical workload of the driver:
651 Handle the network interface interrupts. */
652static irqreturn_t
653net_interrupt(int irq, void *dev_id, struct pt_regs *regs)
654{
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);
667
668 spin_lock (&lp->lock);
669
670 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);
698 lp->stats.collisions++;
699 }
700 if (status & 0x82) {
701 lp->stats.tx_packets++;
702 /* 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{
726 struct net_local *lp = netdev_priv(dev);
727 int ioaddr = dev->base_addr;
728 int boguscount = 5;
729
730 while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
731 ushort status = inw(ioaddr + DATAPORT);
732 ushort pkt_len = inw(ioaddr + DATAPORT);
733
734 if (net_debug > 4)
735 printk("%s: Rxing packet mode %02x status %04x.\n",
736 dev->name, inb(ioaddr + RX_MODE), status);
737#ifndef final_version
738 if (status == 0) {
739 outb(0x05, ioaddr + RX_CTRL);
740 break;
741 }
742#endif
743
744 if ((status & 0xF0) != 0x20) { /* There was an error. */
745 lp->stats.rx_errors++;
746 if (status & 0x08) lp->stats.rx_length_errors++;
747 if (status & 0x04) lp->stats.rx_frame_errors++;
748 if (status & 0x02) lp->stats.rx_crc_errors++;
749 if (status & 0x01) lp->stats.rx_over_errors++;
750 } else {
751 /* Malloc up new buffer. */
752 struct sk_buff *skb;
753
754 if (pkt_len > 1550) {
755 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
756 dev->name, pkt_len);
757 /* Prime the FIFO and then flush the packet. */
758 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
759 outb(0x05, ioaddr + RX_CTRL);
760 lp->stats.rx_errors++;
761 break;
762 }
763 skb = dev_alloc_skb(pkt_len+3);
764 if (skb == NULL) {
765 printk("%s: Memory squeeze, dropping packet (len %d).\n",
766 dev->name, pkt_len);
767 /* Prime the FIFO and then flush the packet. */
768 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
769 outb(0x05, ioaddr + RX_CTRL);
770 lp->stats.rx_dropped++;
771 break;
772 }
773 skb->dev = dev;
774 skb_reserve(skb,2);
775
776 insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
777 skb->protocol=eth_type_trans(skb, dev);
778 netif_rx(skb);
779 dev->last_rx = jiffies;
780 lp->stats.rx_packets++;
781 lp->stats.rx_bytes += pkt_len;
782 }
783 if (--boguscount <= 0)
784 break;
785 }
786
787 /* If any worth-while packets have been received, dev_rint()
788 has done a mark_bh(NET_BH) for us and will work on them
789 when we get to the bottom-half routine. */
790 {
791 int i;
792 for (i = 0; i < 20; i++) {
793 if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
794 break;
795 inw(ioaddr + DATAPORT); /* dummy status read */
796 outb(0x05, ioaddr + RX_CTRL);
797 }
798
799 if (net_debug > 5)
800 printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
801 dev->name, inb(ioaddr + RX_MODE), i);
802 }
803 return;
804}
805
806/* The inverse routine to net_open(). */
807static int net_close(struct net_device *dev)
808{
809 struct net_local *lp = netdev_priv(dev);
810 int ioaddr = dev->base_addr;
811
812 netif_stop_queue(dev);
813
814 /* Set configuration register 0 to disable Tx and Rx. */
815 outb(0xda, ioaddr + CONFIG_0);
816
817 /* No statistic counters on the chip to update. */
818
819 /* Disable the IRQ on boards of fmv18x where it is feasible. */
820 if (lp->jumpered) {
821 outb(0x00, ioaddr + IOCONFIG1);
822 free_irq(dev->irq, dev);
823 }
824
825 /* Power-down the chip. Green, green, green! */
826 outb(0x00, ioaddr + CONFIG_1);
827 return 0;
828}
829
830/* Get the current statistics.
831 This may be called with the card open or closed.
832 There are no on-chip counters, so this function is trivial.
833*/
834static struct net_device_stats *
835net_get_stats(struct net_device *dev)
836{
837 struct net_local *lp = netdev_priv(dev);
838 return &lp->stats;
839}
840
841/*
842 Set the multicast/promiscuous mode for this adaptor.
843*/
844
845static void
846set_rx_mode(struct net_device *dev)
847{
848 int ioaddr = dev->base_addr;
849 struct net_local *lp = netdev_priv(dev);
850 unsigned char mc_filter[8]; /* Multicast hash filter */
851 unsigned long flags;
852 int i;
853
854 if (dev->flags & IFF_PROMISC) {
855 /* Unconditionally log net taps. */
856 printk("%s: Promiscuous mode enabled.\n", dev->name);
857 memset(mc_filter, 0xff, sizeof(mc_filter));
858 outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */
859 } else if (dev->mc_count > MC_FILTERBREAK
860 || (dev->flags & IFF_ALLMULTI)) {
861 /* Too many to filter perfectly -- accept all multicasts. */
862 memset(mc_filter, 0xff, sizeof(mc_filter));
863 outb(2, ioaddr + RX_MODE); /* Use normal mode. */
864 } else if (dev->mc_count == 0) {
865 memset(mc_filter, 0x00, sizeof(mc_filter));
866 outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */
867 } else {
868 struct dev_mc_list *mclist;
869 int i;
870
871 memset(mc_filter, 0, sizeof(mc_filter));
872 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
873 i++, mclist = mclist->next) {
874 unsigned int bit =
875 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
876 mc_filter[bit >> 3] |= (1 << bit);
877 }
878 outb(0x02, ioaddr + RX_MODE); /* Use normal mode. */
879 }
880
881 spin_lock_irqsave (&lp->lock, flags);
882 if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
883 int saved_bank = inw(ioaddr + CONFIG_0);
884 /* Switch to bank 1 and set the multicast table. */
885 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
886 for (i = 0; i < 8; i++)
887 outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
888 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
889 outw(saved_bank, ioaddr + CONFIG_0);
890 }
891 spin_unlock_irqrestore (&lp->lock, flags);
892 return;
893}
894
895#ifdef MODULE
896static struct net_device *dev_at1700;
897
898module_param(io, int, 0);
899module_param(irq, int, 0);
900module_param(net_debug, int, 0);
901MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
902MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
903MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
904
905int init_module(void)
906{
907 if (io == 0)
908 printk("at1700: You should not use auto-probing with insmod!\n");
909 dev_at1700 = at1700_probe(-1);
910 if (IS_ERR(dev_at1700))
911 return PTR_ERR(dev_at1700);
912 return 0;
913}
914
915void
916cleanup_module(void)
917{
918 unregister_netdev(dev_at1700);
919 cleanup_card(dev_at1700);
920 free_netdev(dev_at1700);
921}
922#endif /* MODULE */
923MODULE_LICENSE("GPL");
924
925\f
926/*
927 * Local variables:
928 * compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
929 * alt-compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
930 * tab-width: 4
931 * c-basic-offset: 4
932 * c-indent-level: 4
933 * End:
934 */
935
Linux kernel - Deliverables
This page took 0.171639 seconds and 5 git commands to generate.