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