projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'drbd-8.4_ed6' into for-3.8-drivers-drbd-8.4_ed6
[deliverable/linux.git] / drivers / net / ethernet / fujitsu / at1700.c
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 (now deleted) 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 */
37
38 #include <linux/errno.h>
39 #include <linux/netdevice.h>
40 #include <linux/etherdevice.h>
41 #include <linux/module.h>
42 #include <linux/kernel.h>
43 #include <linux/types.h>
44 #include <linux/fcntl.h>
45 #include <linux/interrupt.h>
46 #include <linux/ioport.h>
47 #include <linux/in.h>
48 #include <linux/skbuff.h>
49 #include <linux/string.h>
50 #include <linux/init.h>
51 #include <linux/crc32.h>
52 #include <linux/bitops.h>
53
54 #include <asm/io.h>
55 #include <asm/dma.h>
56
57 static char version[] __initdata =
58 "at1700.c:v1.16 9/11/06 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
59
60 #define DRV_NAME "at1700"
61
62 /* Tunable parameters. */
63
64 /* When to switch from the 64-entry multicast filter to Rx-all-multicast. */
65 #define MC_FILTERBREAK 64
66
67 /* These unusual address orders are used to verify the CONFIG register. */
68
69 static int fmv18x_probe_list[] __initdata = {
70 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
71 };
72
73 /*
74 * ISA
75 */
76
77 static unsigned at1700_probe_list[] __initdata = {
78 0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
79 };
80
81 /* use 0 for production, 1 for verification, >2 for debug */
82 #ifndef NET_DEBUG
83 #define NET_DEBUG 1
84 #endif
85 static unsigned int net_debug = NET_DEBUG;
86
87 typedef unsigned char uchar;
88
89 /* Information that need to be kept for each board. */
90 struct net_local {
91 spinlock_t lock;
92 unsigned char mc_filter[8];
93 uint jumpered:1; /* Set iff the board has jumper config. */
94 uint tx_started:1; /* Packets are on the Tx queue. */
95 uint tx_queue_ready:1; /* Tx queue is ready to be sent. */
96 uint rx_started:1; /* Packets are Rxing. */
97 uchar tx_queue; /* Number of packet on the Tx queue. */
98 ushort tx_queue_len; /* Current length of the Tx queue. */
99 };
100
101
102 /* Offsets from the base address. */
103 #define STATUS 0
104 #define TX_STATUS 0
105 #define RX_STATUS 1
106 #define TX_INTR 2 /* Bit-mapped interrupt enable registers. */
107 #define RX_INTR 3
108 #define TX_MODE 4
109 #define RX_MODE 5
110 #define CONFIG_0 6 /* Misc. configuration settings. */
111 #define CONFIG_1 7
112 /* Run-time register bank 2 definitions. */
113 #define DATAPORT 8 /* Word-wide DMA or programmed-I/O dataport. */
114 #define TX_START 10
115 #define COL16CNTL 11 /* Control Reg for 16 collisions */
116 #define MODE13 13
117 #define RX_CTRL 14
118 /* Configuration registers only on the '865A/B chips. */
119 #define EEPROM_Ctrl 16
120 #define EEPROM_Data 17
121 #define CARDSTATUS 16 /* FMV-18x Card Status */
122 #define CARDSTATUS1 17 /* FMV-18x Card Status */
123 #define IOCONFIG 18 /* Either read the jumper, or move the I/O. */
124 #define IOCONFIG1 19
125 #define SAPROM 20 /* The station address PROM, if no EEPROM. */
126 #define MODE24 24
127 #define RESET 31 /* Write to reset some parts of the chip. */
128 #define AT1700_IO_EXTENT 32
129 #define PORT_OFFSET(o) (o)
130
131
132 #define TX_TIMEOUT (HZ/10)
133
134
135 /* Index to functions, as function prototypes. */
136
137 static int at1700_probe1(struct net_device *dev, int ioaddr);
138 static int read_eeprom(long ioaddr, int location);
139 static int net_open(struct net_device *dev);
140 static netdev_tx_t net_send_packet(struct sk_buff *skb,
141 struct net_device *dev);
142 static irqreturn_t net_interrupt(int irq, void *dev_id);
143 static void net_rx(struct net_device *dev);
144 static int net_close(struct net_device *dev);
145 static void set_rx_mode(struct net_device *dev);
146 static void net_tx_timeout (struct net_device *dev);
147
148
149 /* Check for a network adaptor of this type, and return '0' iff one exists.
150 If dev->base_addr == 0, probe all likely locations.
151 If dev->base_addr == 1, always return failure.
152 If dev->base_addr == 2, allocate space for the device and return success
153 (detachable devices only).
154 */
155
156 static int io = 0x260;
157
158 static int irq;
159
160 static void cleanup_card(struct net_device *dev)
161 {
162 free_irq(dev->irq, NULL);
163 release_region(dev->base_addr, AT1700_IO_EXTENT);
164 }
165
166 struct net_device * __init at1700_probe(int unit)
167 {
168 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
169 unsigned *port;
170 int err = 0;
171
172 if (!dev)
173 return ERR_PTR(-ENODEV);
174
175 if (unit >= 0) {
176 sprintf(dev->name, "eth%d", unit);
177 netdev_boot_setup_check(dev);
178 io = dev->base_addr;
179 irq = dev->irq;
180 } else {
181 dev->base_addr = io;
182 dev->irq = irq;
183 }
184
185 if (io > 0x1ff) { /* Check a single specified location. */
186 err = at1700_probe1(dev, io);
187 } else if (io != 0) { /* Don't probe at all. */
188 err = -ENXIO;
189 } else {
190 for (port = at1700_probe_list; *port; port++) {
191 if (at1700_probe1(dev, *port) == 0)
192 break;
193 dev->irq = irq;
194 }
195 if (!*port)
196 err = -ENODEV;
197 }
198 if (err)
199 goto out;
200 err = register_netdev(dev);
201 if (err)
202 goto out1;
203 return dev;
204 out1:
205 cleanup_card(dev);
206 out:
207 free_netdev(dev);
208 return ERR_PTR(err);
209 }
210
211 static const struct net_device_ops at1700_netdev_ops = {
212 .ndo_open = net_open,
213 .ndo_stop = net_close,
214 .ndo_start_xmit = net_send_packet,
215 .ndo_set_rx_mode = set_rx_mode,
216 .ndo_tx_timeout = net_tx_timeout,
217 .ndo_change_mtu = eth_change_mtu,
218 .ndo_set_mac_address = eth_mac_addr,
219 .ndo_validate_addr = eth_validate_addr,
220 };
221
222 /* The Fujitsu datasheet suggests that the NIC be probed for by checking its
223 "signature", the default bit pattern after a reset. This *doesn't* work --
224 there is no way to reset the bus interface without a complete power-cycle!
225
226 It turns out that ATI came to the same conclusion I did: the only thing
227 that can be done is checking a few bits and then diving right into an
228 EEPROM read. */
229
230 static int __init at1700_probe1(struct net_device *dev, int ioaddr)
231 {
232 static const char fmv_irqmap[4] = {3, 7, 10, 15};
233 static const char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
234 static const char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
235 unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
236 int ret = -ENODEV;
237 struct net_local *lp = netdev_priv(dev);
238
239 if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
240 return -EBUSY;
241
242 /* Resetting the chip doesn't reset the ISA interface, so don't bother.
243 That means we have to be careful with the register values we probe
244 for.
245 */
246 #ifdef notdef
247 printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
248 ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
249 read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
250 #endif
251 /* We must check for the EEPROM-config boards first, else accessing
252 IOCONFIG0 will move the board! */
253 if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr &&
254 read_eeprom(ioaddr, 4) == 0x0000 &&
255 (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
256 is_at1700 = 1;
257 else if (inb(ioaddr + SAPROM ) == 0x00 &&
258 inb(ioaddr + SAPROM + 1) == 0x00 &&
259 inb(ioaddr + SAPROM + 2) == 0x0e)
260 is_fmv18x = 1;
261 else {
262 goto err_out;
263 }
264
265 /* Reset the internal state machines. */
266 outb(0, ioaddr + RESET);
267
268 if (is_at1700) {
269 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
270 | (read_eeprom(ioaddr, 0)>>14)];
271 } else {
272 /* Check PnP mode for FMV-183/184/183A/184A. */
273 /* This PnP routine is very poor. IO and IRQ should be known. */
274 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
275 irq = dev->irq;
276 for (i = 0; i < 8; i++) {
277 if (irq == fmv_irqmap_pnp[i])
278 break;
279 }
280 if (i == 8) {
281 goto err_out;
282 }
283 } else {
284 if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
285 goto err_out;
286 irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
287 }
288 }
289
290 printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
291 is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
292
293 dev->base_addr = ioaddr;
294 dev->irq = irq;
295
296 if (is_at1700) {
297 for(i = 0; i < 3; i++) {
298 unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
299 ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
300 }
301 } else {
302 for(i = 0; i < 6; i++) {
303 unsigned char val = inb(ioaddr + SAPROM + i);
304 dev->dev_addr[i] = val;
305 }
306 }
307 printk("%pM", dev->dev_addr);
308
309 /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
310 rather than 150 ohm shielded twisted pair compensation.
311 0x0000 == auto-sense the interface
312 0x0800 == use TP interface
313 0x1800 == use coax interface
314 */
315 {
316 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
317 if (is_at1700) {
318 ushort setup_value = read_eeprom(ioaddr, 12);
319 dev->if_port = setup_value >> 8;
320 } else {
321 ushort setup_value = inb(ioaddr + CARDSTATUS);
322 switch (setup_value & 0x07) {
323 case 0x01: /* 10base5 */
324 case 0x02: /* 10base2 */
325 dev->if_port = 0x18; break;
326 case 0x04: /* 10baseT */
327 dev->if_port = 0x08; break;
328 default: /* auto-sense */
329 dev->if_port = 0x00; break;
330 }
331 }
332 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
333 }
334
335 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
336 bus access, two 4K Tx queues, and disabled Tx and Rx. */
337 outb(0xda, ioaddr + CONFIG_0);
338
339 /* Set the station address in bank zero. */
340 outb(0x00, ioaddr + CONFIG_1);
341 for (i = 0; i < 6; i++)
342 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
343
344 /* Switch to bank 1 and set the multicast table to accept none. */
345 outb(0x04, ioaddr + CONFIG_1);
346 for (i = 0; i < 8; i++)
347 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
348
349
350 /* Switch to bank 2 */
351 /* Lock our I/O address, and set manual processing mode for 16 collisions. */
352 outb(0x08, ioaddr + CONFIG_1);
353 outb(dev->if_port, ioaddr + MODE13);
354 outb(0x00, ioaddr + COL16CNTL);
355
356 if (net_debug)
357 printk(version);
358
359 dev->netdev_ops = &at1700_netdev_ops;
360 dev->watchdog_timeo = TX_TIMEOUT;
361
362 spin_lock_init(&lp->lock);
363
364 lp->jumpered = is_fmv18x;
365 /* Snarf the interrupt vector now. */
366 ret = request_irq(irq, net_interrupt, 0, DRV_NAME, dev);
367 if (ret) {
368 printk(KERN_ERR "AT1700 at %#3x is unusable due to a "
369 "conflict on IRQ %d.\n",
370 ioaddr, irq);
371 goto err_out;
372 }
373
374 return 0;
375
376 err_out:
377 release_region(ioaddr, AT1700_IO_EXTENT);
378 return ret;
379 }
380
381
382 /* EEPROM_Ctrl bits. */
383 #define EE_SHIFT_CLK 0x40 /* EEPROM shift clock, in reg. 16. */
384 #define EE_CS 0x20 /* EEPROM chip select, in reg. 16. */
385 #define EE_DATA_WRITE 0x80 /* EEPROM chip data in, in reg. 17. */
386 #define EE_DATA_READ 0x80 /* EEPROM chip data out, in reg. 17. */
387
388 /* The EEPROM commands include the alway-set leading bit. */
389 #define EE_WRITE_CMD (5 << 6)
390 #define EE_READ_CMD (6 << 6)
391 #define EE_ERASE_CMD (7 << 6)
392
393 static int __init read_eeprom(long ioaddr, int location)
394 {
395 int i;
396 unsigned short retval = 0;
397 long ee_addr = ioaddr + EEPROM_Ctrl;
398 long ee_daddr = ioaddr + EEPROM_Data;
399 int read_cmd = location | EE_READ_CMD;
400
401 /* Shift the read command bits out. */
402 for (i = 9; i >= 0; i--) {
403 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
404 outb(EE_CS, ee_addr);
405 outb(dataval, ee_daddr);
406 outb(EE_CS | EE_SHIFT_CLK, ee_addr); /* EEPROM clock tick. */
407 }
408 outb(EE_DATA_WRITE, ee_daddr);
409 for (i = 16; i > 0; i--) {
410 outb(EE_CS, ee_addr);
411 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
412 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
413 }
414
415 /* Terminate the EEPROM access. */
416 outb(EE_CS, ee_addr);
417 outb(EE_SHIFT_CLK, ee_addr);
418 outb(0, ee_addr);
419 return retval;
420 }
421
422
423
424 static int net_open(struct net_device *dev)
425 {
426 struct net_local *lp = netdev_priv(dev);
427 int ioaddr = dev->base_addr;
428
429 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
430 bus access, and two 4K Tx queues. */
431 outb(0x5a, ioaddr + CONFIG_0);
432
433 /* Powerup, switch to register bank 2, and enable the Rx and Tx. */
434 outb(0xe8, ioaddr + CONFIG_1);
435
436 lp->tx_started = 0;
437 lp->tx_queue_ready = 1;
438 lp->rx_started = 0;
439 lp->tx_queue = 0;
440 lp->tx_queue_len = 0;
441
442 /* Turn on hardware Tx and Rx interrupts. */
443 outb(0x82, ioaddr + TX_INTR);
444 outb(0x81, ioaddr + RX_INTR);
445
446 /* Enable the IRQ on boards of fmv18x it is feasible. */
447 if (lp->jumpered) {
448 outb(0x80, ioaddr + IOCONFIG1);
449 }
450
451 netif_start_queue(dev);
452 return 0;
453 }
454
455 static void net_tx_timeout (struct net_device *dev)
456 {
457 struct net_local *lp = netdev_priv(dev);
458 int ioaddr = dev->base_addr;
459
460 printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
461 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
462 ? "IRQ conflict" : "network cable problem");
463 printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
464 dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
465 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
466 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
467 dev->stats.tx_errors++;
468 /* ToDo: We should try to restart the adaptor... */
469 outw(0xffff, ioaddr + MODE24);
470 outw (0xffff, ioaddr + TX_STATUS);
471 outb (0x5a, ioaddr + CONFIG_0);
472 outb (0xe8, ioaddr + CONFIG_1);
473 outw (0x8182, ioaddr + TX_INTR);
474 outb (0x00, ioaddr + TX_START);
475 outb (0x03, ioaddr + COL16CNTL);
476
477 dev->trans_start = jiffies; /* prevent tx timeout */
478
479 lp->tx_started = 0;
480 lp->tx_queue_ready = 1;
481 lp->rx_started = 0;
482 lp->tx_queue = 0;
483 lp->tx_queue_len = 0;
484
485 netif_wake_queue(dev);
486 }
487
488
489 static netdev_tx_t net_send_packet (struct sk_buff *skb,
490 struct net_device *dev)
491 {
492 struct net_local *lp = netdev_priv(dev);
493 int ioaddr = dev->base_addr;
494 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
495 short len = skb->len;
496 unsigned char *buf = skb->data;
497 static u8 pad[ETH_ZLEN];
498
499 netif_stop_queue (dev);
500
501 /* We may not start transmitting unless we finish transferring
502 a packet into the Tx queue. During executing the following
503 codes we possibly catch a Tx interrupt. Thus we flag off
504 tx_queue_ready, so that we prevent the interrupt routine
505 (net_interrupt) to start transmitting. */
506 lp->tx_queue_ready = 0;
507 {
508 outw (length, ioaddr + DATAPORT);
509 /* Packet data */
510 outsw (ioaddr + DATAPORT, buf, len >> 1);
511 /* Check for dribble byte */
512 if (len & 1) {
513 outw(skb->data[skb->len-1], ioaddr + DATAPORT);
514 len++;
515 }
516 /* Check for packet padding */
517 if (length != skb->len)
518 outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
519
520 lp->tx_queue++;
521 lp->tx_queue_len += length + 2;
522 }
523 lp->tx_queue_ready = 1;
524
525 if (lp->tx_started == 0) {
526 /* If the Tx is idle, always trigger a transmit. */
527 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
528 lp->tx_queue = 0;
529 lp->tx_queue_len = 0;
530 lp->tx_started = 1;
531 netif_start_queue (dev);
532 } else if (lp->tx_queue_len < 4096 - 1502)
533 /* Yes, there is room for one more packet. */
534 netif_start_queue (dev);
535 dev_kfree_skb (skb);
536
537 return NETDEV_TX_OK;
538 }
539
540 /* The typical workload of the driver:
541 Handle the network interface interrupts. */
542 static irqreturn_t net_interrupt(int irq, void *dev_id)
543 {
544 struct net_device *dev = dev_id;
545 struct net_local *lp;
546 int ioaddr, status;
547 int handled = 0;
548
549 if (dev == NULL) {
550 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
551 return IRQ_NONE;
552 }
553
554 ioaddr = dev->base_addr;
555 lp = netdev_priv(dev);
556
557 spin_lock (&lp->lock);
558
559 status = inw(ioaddr + TX_STATUS);
560 outw(status, ioaddr + TX_STATUS);
561
562 if (net_debug > 4)
563 printk("%s: Interrupt with status %04x.\n", dev->name, status);
564 if (lp->rx_started == 0 &&
565 (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
566 /* Got a packet(s).
567 We cannot execute net_rx more than once at the same time for
568 the same device. During executing net_rx, we possibly catch a
569 Tx interrupt. Thus we flag on rx_started, so that we prevent
570 the interrupt routine (net_interrupt) to dive into net_rx
571 again. */
572 handled = 1;
573 lp->rx_started = 1;
574 outb(0x00, ioaddr + RX_INTR); /* Disable RX intr. */
575 net_rx(dev);
576 outb(0x81, ioaddr + RX_INTR); /* Enable RX intr. */
577 lp->rx_started = 0;
578 }
579 if (status & 0x00ff) {
580 handled = 1;
581 if (status & 0x02) {
582 /* More than 16 collisions occurred */
583 if (net_debug > 4)
584 printk("%s: 16 Collision occur during Txing.\n", dev->name);
585 /* Cancel sending a packet. */
586 outb(0x03, ioaddr + COL16CNTL);
587 dev->stats.collisions++;
588 }
589 if (status & 0x82) {
590 dev->stats.tx_packets++;
591 /* The Tx queue has any packets and is not being
592 transferred a packet from the host, start
593 transmitting. */
594 if (lp->tx_queue && lp->tx_queue_ready) {
595 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
596 lp->tx_queue = 0;
597 lp->tx_queue_len = 0;
598 dev->trans_start = jiffies;
599 netif_wake_queue (dev);
600 } else {
601 lp->tx_started = 0;
602 netif_wake_queue (dev);
603 }
604 }
605 }
606
607 spin_unlock (&lp->lock);
608 return IRQ_RETVAL(handled);
609 }
610
611 /* We have a good packet(s), get it/them out of the buffers. */
612 static void
613 net_rx(struct net_device *dev)
614 {
615 int ioaddr = dev->base_addr;
616 int boguscount = 5;
617
618 while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
619 ushort status = inw(ioaddr + DATAPORT);
620 ushort pkt_len = inw(ioaddr + DATAPORT);
621
622 if (net_debug > 4)
623 printk("%s: Rxing packet mode %02x status %04x.\n",
624 dev->name, inb(ioaddr + RX_MODE), status);
625 #ifndef final_version
626 if (status == 0) {
627 outb(0x05, ioaddr + RX_CTRL);
628 break;
629 }
630 #endif
631
632 if ((status & 0xF0) != 0x20) { /* There was an error. */
633 dev->stats.rx_errors++;
634 if (status & 0x08) dev->stats.rx_length_errors++;
635 if (status & 0x04) dev->stats.rx_frame_errors++;
636 if (status & 0x02) dev->stats.rx_crc_errors++;
637 if (status & 0x01) dev->stats.rx_over_errors++;
638 } else {
639 /* Malloc up new buffer. */
640 struct sk_buff *skb;
641
642 if (pkt_len > 1550) {
643 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
644 dev->name, pkt_len);
645 /* Prime the FIFO and then flush the packet. */
646 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
647 outb(0x05, ioaddr + RX_CTRL);
648 dev->stats.rx_errors++;
649 break;
650 }
651 skb = netdev_alloc_skb(dev, pkt_len + 3);
652 if (skb == NULL) {
653 printk("%s: Memory squeeze, dropping packet (len %d).\n",
654 dev->name, pkt_len);
655 /* Prime the FIFO and then flush the packet. */
656 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
657 outb(0x05, ioaddr + RX_CTRL);
658 dev->stats.rx_dropped++;
659 break;
660 }
661 skb_reserve(skb,2);
662
663 insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
664 skb->protocol=eth_type_trans(skb, dev);
665 netif_rx(skb);
666 dev->stats.rx_packets++;
667 dev->stats.rx_bytes += pkt_len;
668 }
669 if (--boguscount <= 0)
670 break;
671 }
672
673 /* If any worth-while packets have been received, dev_rint()
674 has done a mark_bh(NET_BH) for us and will work on them
675 when we get to the bottom-half routine. */
676 {
677 int i;
678 for (i = 0; i < 20; i++) {
679 if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
680 break;
681 inw(ioaddr + DATAPORT); /* dummy status read */
682 outb(0x05, ioaddr + RX_CTRL);
683 }
684
685 if (net_debug > 5)
686 printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
687 dev->name, inb(ioaddr + RX_MODE), i);
688 }
689 }
690
691 /* The inverse routine to net_open(). */
692 static int net_close(struct net_device *dev)
693 {
694 struct net_local *lp = netdev_priv(dev);
695 int ioaddr = dev->base_addr;
696
697 netif_stop_queue(dev);
698
699 /* Set configuration register 0 to disable Tx and Rx. */
700 outb(0xda, ioaddr + CONFIG_0);
701
702 /* No statistic counters on the chip to update. */
703
704 /* Disable the IRQ on boards of fmv18x where it is feasible. */
705 if (lp->jumpered)
706 outb(0x00, ioaddr + IOCONFIG1);
707
708 /* Power-down the chip. Green, green, green! */
709 outb(0x00, ioaddr + CONFIG_1);
710 return 0;
711 }
712
713 /*
714 Set the multicast/promiscuous mode for this adaptor.
715 */
716
717 static void
718 set_rx_mode(struct net_device *dev)
719 {
720 int ioaddr = dev->base_addr;
721 struct net_local *lp = netdev_priv(dev);
722 unsigned char mc_filter[8]; /* Multicast hash filter */
723 unsigned long flags;
724
725 if (dev->flags & IFF_PROMISC) {
726 memset(mc_filter, 0xff, sizeof(mc_filter));
727 outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */
728 } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
729 (dev->flags & IFF_ALLMULTI)) {
730 /* Too many to filter perfectly -- accept all multicasts. */
731 memset(mc_filter, 0xff, sizeof(mc_filter));
732 outb(2, ioaddr + RX_MODE); /* Use normal mode. */
733 } else if (netdev_mc_empty(dev)) {
734 memset(mc_filter, 0x00, sizeof(mc_filter));
735 outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */
736 } else {
737 struct netdev_hw_addr *ha;
738
739 memset(mc_filter, 0, sizeof(mc_filter));
740 netdev_for_each_mc_addr(ha, dev) {
741 unsigned int bit =
742 ether_crc_le(ETH_ALEN, ha->addr) >> 26;
743 mc_filter[bit >> 3] |= (1 << bit);
744 }
745 outb(0x02, ioaddr + RX_MODE); /* Use normal mode. */
746 }
747
748 spin_lock_irqsave (&lp->lock, flags);
749 if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
750 int i;
751 int saved_bank = inw(ioaddr + CONFIG_0);
752 /* Switch to bank 1 and set the multicast table. */
753 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
754 for (i = 0; i < 8; i++)
755 outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
756 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
757 outw(saved_bank, ioaddr + CONFIG_0);
758 }
759 spin_unlock_irqrestore (&lp->lock, flags);
760 }
761
762 #ifdef MODULE
763 static struct net_device *dev_at1700;
764
765 module_param(io, int, 0);
766 module_param(irq, int, 0);
767 module_param(net_debug, int, 0);
768 MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
769 MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
770 MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
771
772 static int __init at1700_module_init(void)
773 {
774 if (io == 0)
775 printk("at1700: You should not use auto-probing with insmod!\n");
776 dev_at1700 = at1700_probe(-1);
777 if (IS_ERR(dev_at1700))
778 return PTR_ERR(dev_at1700);
779 return 0;
780 }
781
782 static void __exit at1700_module_exit(void)
783 {
784 unregister_netdev(dev_at1700);
785 cleanup_card(dev_at1700);
786 free_netdev(dev_at1700);
787 }
788 module_init(at1700_module_init);
789 module_exit(at1700_module_exit);
790 #endif /* MODULE */
791 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.087141 seconds and 6 git commands to generate.