1/* eth16i.c An ICL EtherTeam 16i and 32 EISA ethernet driver for Linux 2 3 Written 1994-1999 by Mika Kuoppala 4 5 Copyright (C) 1994-1999 by Mika Kuoppala 6 Based on skeleton.c and heavily on at1700.c by Donald Becker 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 miku@iki.fi 12 13 This driver supports following cards : 14 - ICL EtherTeam 16i 15 - ICL EtherTeam 32 EISA 16 (Uses true 32 bit transfers rather than 16i compability mode) 17 18 Example Module usage: 19 insmod eth16i.o io=0x2a0 mediatype=bnc 20 21 mediatype can be one of the following: bnc,tp,dix,auto,eprom 22 23 'auto' will try to autoprobe mediatype. 24 'eprom' will use whatever type defined in eprom. 25 26 I have benchmarked driver with PII/300Mhz as a ftp client 27 and 486/33Mhz as a ftp server. Top speed was 1128.37 kilobytes/sec. 28 29 Sources: 30 - skeleton.c a sample network driver core for linux, 31 written by Donald Becker <becker@scyld.com> 32 - at1700.c a driver for Allied Telesis AT1700, written 33 by Donald Becker. 34 - e16iSRV.asm a Netware 3.X Server Driver for ICL EtherTeam16i 35 written by Markku Viima 36 - The Fujitsu MB86965 databook. 37 38 Author thanks following persons due to their valueble assistance: 39 Markku Viima (ICL) 40 Ari Valve (ICL) 41 Donald Becker 42 Kurt Huwig <kurt@huwig.de> 43 44 Revision history: 45 46 Version Date Description 47 48 0.01 15.12-94 Initial version (card detection) 49 0.02 23.01-95 Interrupt is now hooked correctly 50 0.03 01.02-95 Rewrote initialization part 51 0.04 07.02-95 Base skeleton done... 52 Made a few changes to signature checking 53 to make it a bit reliable. 54 - fixed bug in tx_buf mapping 55 - fixed bug in initialization (DLC_EN 56 wasn't enabled when initialization 57 was done.) 58 0.05 08.02-95 If there were more than one packet to send, 59 transmit was jammed due to invalid 60 register write...now fixed 61 0.06 19.02-95 Rewrote interrupt handling 62 0.07 13.04-95 Wrote EEPROM read routines 63 Card configuration now set according to 64 data read from EEPROM 65 0.08 23.06-95 Wrote part that tries to probe used interface 66 port if AUTO is selected 67 68 0.09 01.09-95 Added module support 69 70 0.10 04.09-95 Fixed receive packet allocation to work 71 with kernels > 1.3.x 72 73 0.20 20.09-95 Added support for EtherTeam32 EISA 74 75 0.21 17.10-95 Removed the unnecessary extern 76 init_etherdev() declaration. Some 77 other cleanups. 78 79 0.22 22.02-96 Receive buffer was not flushed 80 correctly when faulty packet was 81 received. Now fixed. 82 83 0.23 26.02-96 Made resetting the adapter 84 more reliable. 85 86 0.24 27.02-96 Rewrote faulty packet handling in eth16i_rx 87 88 0.25 22.05-96 kfree() was missing from cleanup_module. 89 90 0.26 11.06-96 Sometimes card was not found by 91 check_signature(). Now made more reliable. 92 93 0.27 23.06-96 Oops. 16 consecutive collisions halted 94 adapter. Now will try to retransmit 95 MAX_COL_16 times before finally giving up. 96 97 0.28 28.10-97 Added dev_id parameter (NULL) for free_irq 98 99 0.29 29.10-97 Multiple card support for module users 100 101 0.30 30.10-97 Fixed irq allocation bug. 102 (request_irq moved from probe to open) 103 104 0.30a 21.08-98 Card detection made more relaxed. Driver 105 had problems with some TCP/IP-PROM boots 106 to find the card. Suggested by 107 Kurt Huwig <kurt@huwig.de> 108 109 0.31 28.08-98 Media interface port can now be selected 110 with module parameters or kernel 111 boot parameters. 112 113 0.32 31.08-98 IRQ was never freed if open/close 114 pair wasn't called. Now fixed. 115 116 0.33 10.09-98 When eth16i_open() was called after 117 eth16i_close() chip never recovered. 118 Now more shallow reset is made on 119 close. 120 121 0.34 29.06-99 Fixed one bad #ifdef. 122 Changed ioaddr -> io for consistency 123 124 0.35 01.07-99 transmit,-receive bytes were never 125 updated in stats. 126 127 Bugs: 128 In some cases the media interface autoprobing code doesn't find 129 the correct interface type. In this case you can 130 manually choose the interface type in DOS with E16IC.EXE which is 131 configuration software for EtherTeam16i and EtherTeam32 cards. 132 This is also true for IRQ setting. You cannot use module 133 parameter to configure IRQ of the card (yet). 134 135 To do: 136 - Real multicast support 137 - Rewrite the media interface autoprobing code. Its _horrible_ ! 138 - Possibly merge all the MB86965 specific code to external 139 module for use by eth16.c and Donald's at1700.c 140 - IRQ configuration with module parameter. I will do 141 this when i will get enough info about setting 142 irq without configuration utility. 143*/ 144 145static char *version = 146 "eth16i.c: v0.35 01-Jul-1999 Mika Kuoppala (miku@iki.fi)\n"; 147 148#include <linux/module.h> 149#include <linux/kernel.h> 150#include <linux/types.h> 151#include <linux/fcntl.h> 152#include <linux/interrupt.h> 153#include <linux/ioport.h> 154#include <linux/in.h> 155#include <linux/slab.h> 156#include <linux/string.h> 157#include <linux/errno.h> 158#include <linux/init.h> 159#include <linux/spinlock.h> 160#include <linux/netdevice.h> 161#include <linux/etherdevice.h> 162#include <linux/skbuff.h> 163#include <linux/bitops.h> 164#include <linux/jiffies.h> 165#include <linux/io.h> 166 167#include <asm/system.h> 168#include <asm/dma.h> 169 170 171 172/* Few macros */ 173#define BIT(a) ( (1 << (a)) ) 174#define BITSET(ioaddr, bnum) ((outb(((inb(ioaddr)) | (bnum)), ioaddr))) 175#define BITCLR(ioaddr, bnum) ((outb(((inb(ioaddr)) & (~(bnum))), ioaddr))) 176 177/* This is the I/O address space for Etherteam 16i adapter. */ 178#define ETH16I_IO_EXTENT 32 179 180/* Ticks before deciding that transmit has timed out */ 181#define TX_TIMEOUT (400*HZ/1000) 182 183/* Maximum loop count when receiving packets */ 184#define MAX_RX_LOOP 20 185 186/* Some interrupt masks */ 187#define ETH16I_INTR_ON 0xef8a /* Higher is receive mask */ 188#define ETH16I_INTR_OFF 0x0000 189 190/* Buffers header status byte meanings */ 191#define PKT_GOOD BIT(5) 192#define PKT_GOOD_RMT BIT(4) 193#define PKT_SHORT BIT(3) 194#define PKT_ALIGN_ERR BIT(2) 195#define PKT_CRC_ERR BIT(1) 196#define PKT_RX_BUF_OVERFLOW BIT(0) 197 198/* Transmit status register (DLCR0) */ 199#define TX_STATUS_REG 0 200#define TX_DONE BIT(7) 201#define NET_BUSY BIT(6) 202#define TX_PKT_RCD BIT(5) 203#define CR_LOST BIT(4) 204#define TX_JABBER_ERR BIT(3) 205#define COLLISION BIT(2) 206#define COLLISIONS_16 BIT(1) 207 208/* Receive status register (DLCR1) */ 209#define RX_STATUS_REG 1 210#define RX_PKT BIT(7) /* Packet received */ 211#define BUS_RD_ERR BIT(6) 212#define SHORT_PKT_ERR BIT(3) 213#define ALIGN_ERR BIT(2) 214#define CRC_ERR BIT(1) 215#define RX_BUF_OVERFLOW BIT(0) 216 217/* Transmit Interrupt Enable Register (DLCR2) */ 218#define TX_INTR_REG 2 219#define TX_INTR_DONE BIT(7) 220#define TX_INTR_COL BIT(2) 221#define TX_INTR_16_COL BIT(1) 222 223/* Receive Interrupt Enable Register (DLCR3) */ 224#define RX_INTR_REG 3 225#define RX_INTR_RECEIVE BIT(7) 226#define RX_INTR_SHORT_PKT BIT(3) 227#define RX_INTR_CRC_ERR BIT(1) 228#define RX_INTR_BUF_OVERFLOW BIT(0) 229 230/* Transmit Mode Register (DLCR4) */ 231#define TRANSMIT_MODE_REG 4 232#define LOOPBACK_CONTROL BIT(1) 233#define CONTROL_OUTPUT BIT(2) 234 235/* Receive Mode Register (DLCR5) */ 236#define RECEIVE_MODE_REG 5 237#define RX_BUFFER_EMPTY BIT(6) 238#define ACCEPT_BAD_PACKETS BIT(5) 239#define RECEIVE_SHORT_ADDR BIT(4) 240#define ACCEPT_SHORT_PACKETS BIT(3) 241#define REMOTE_RESET BIT(2) 242 243#define ADDRESS_FILTER_MODE BIT(1) | BIT(0) 244#define REJECT_ALL 0 245#define ACCEPT_ALL 3 246#define MODE_1 1 /* NODE ID, BC, MC, 2-24th bit */ 247#define MODE_2 2 /* NODE ID, BC, MC, Hash Table */ 248 249/* Configuration Register 0 (DLCR6) */ 250#define CONFIG_REG_0 6 251#define DLC_EN BIT(7) 252#define SRAM_CYCLE_TIME_100NS BIT(6) 253#define SYSTEM_BUS_WIDTH_8 BIT(5) /* 1 = 8bit, 0 = 16bit */ 254#define BUFFER_WIDTH_8 BIT(4) /* 1 = 8bit, 0 = 16bit */ 255#define TBS1 BIT(3) 256#define TBS0 BIT(2) 257#define SRAM_BS1 BIT(1) /* 00=8kb, 01=16kb */ 258#define SRAM_BS0 BIT(0) /* 10=32kb, 11=64kb */ 259 260#ifndef ETH16I_TX_BUF_SIZE /* 0 = 2kb, 1 = 4kb */ 261#define ETH16I_TX_BUF_SIZE 3 /* 2 = 8kb, 3 = 16kb */ 262#endif 263#define TX_BUF_1x2048 0 264#define TX_BUF_2x2048 1 265#define TX_BUF_2x4098 2 266#define TX_BUF_2x8192 3 267 268/* Configuration Register 1 (DLCR7) */ 269#define CONFIG_REG_1 7 270#define POWERUP BIT(5) 271 272/* Transmit start register */ 273#define TRANSMIT_START_REG 10 274#define TRANSMIT_START_RB 2 275#define TX_START BIT(7) /* Rest of register bit indicate*/ 276 /* number of packets in tx buffer*/ 277/* Node ID registers (DLCR8-13) */ 278#define NODE_ID_0 8 279#define NODE_ID_RB 0 280 281/* Hash Table registers (HT8-15) */ 282#define HASH_TABLE_0 8 283#define HASH_TABLE_RB 1 284 285/* Buffer memory ports */ 286#define BUFFER_MEM_PORT_LB 8 287#define DATAPORT BUFFER_MEM_PORT_LB 288#define BUFFER_MEM_PORT_HB 9 289 290/* 16 Collision control register (BMPR11) */ 291#define COL_16_REG 11 292#define HALT_ON_16 0x00 293#define RETRANS_AND_HALT_ON_16 0x02 294 295/* Maximum number of attempts to send after 16 concecutive collisions */ 296#define MAX_COL_16 10 297 298/* DMA Burst and Transceiver Mode Register (BMPR13) */ 299#define TRANSCEIVER_MODE_REG 13 300#define TRANSCEIVER_MODE_RB 2 301#define IO_BASE_UNLOCK BIT(7) 302#define LOWER_SQUELCH_TRESH BIT(6) 303#define LINK_TEST_DISABLE BIT(5) 304#define AUI_SELECT BIT(4) 305#define DIS_AUTO_PORT_SEL BIT(3) 306 307/* Filter Self Receive Register (BMPR14) */ 308#define FILTER_SELF_RX_REG 14 309#define SKIP_RX_PACKET BIT(2) 310#define FILTER_SELF_RECEIVE BIT(0) 311 312/* EEPROM Control Register (BMPR 16) */ 313#define EEPROM_CTRL_REG 16 314 315/* EEPROM Data Register (BMPR 17) */ 316#define EEPROM_DATA_REG 17 317 318/* NMC93CSx6 EEPROM Control Bits */ 319#define CS_0 0x00 320#define CS_1 0x20 321#define SK_0 0x00 322#define SK_1 0x40 323#define DI_0 0x00 324#define DI_1 0x80 325 326/* NMC93CSx6 EEPROM Instructions */ 327#define EEPROM_READ 0x80 328 329/* NMC93CSx6 EEPROM Addresses */ 330#define E_NODEID_0 0x02 331#define E_NODEID_1 0x03 332#define E_NODEID_2 0x04 333#define E_PORT_SELECT 0x14 334 #define E_PORT_BNC 0x00 335 #define E_PORT_DIX 0x01 336 #define E_PORT_TP 0x02 337 #define E_PORT_AUTO 0x03 338 #define E_PORT_FROM_EPROM 0x04 339#define E_PRODUCT_CFG 0x30 340 341 342/* Macro to slow down io between EEPROM clock transitions */ 343#define eeprom_slow_io() do { int _i = 40; while(--_i > 0) { inb(0x80); }}while(0) 344 345/* Jumperless Configuration Register (BMPR19) */ 346#define JUMPERLESS_CONFIG 19 347 348/* ID ROM registers, writing to them also resets some parts of chip */ 349#define ID_ROM_0 24 350#define ID_ROM_7 31 351#define RESET ID_ROM_0 352 353/* This is the I/O address list to be probed when seeking the card */ 354static unsigned int eth16i_portlist[] __initdata = { 355 0x260, 0x280, 0x2A0, 0x240, 0x340, 0x320, 0x380, 0x300, 0 356}; 357 358static unsigned int eth32i_portlist[] __initdata = { 359 0x1000, 0x2000, 0x3000, 0x4000, 0x5000, 0x6000, 0x7000, 0x8000, 360 0x9000, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000, 0 361}; 362 363/* This is the Interrupt lookup table for Eth16i card */ 364static unsigned int eth16i_irqmap[] __initdata = { 9, 10, 5, 15, 0 }; 365#define NUM_OF_ISA_IRQS 4 366 367/* This is the Interrupt lookup table for Eth32i card */ 368static unsigned int eth32i_irqmap[] __initdata = { 3, 5, 7, 9, 10, 11, 12, 15, 0 }; 369#define EISA_IRQ_REG 0xc89 370#define NUM_OF_EISA_IRQS 8 371 372static unsigned int eth16i_tx_buf_map[] = { 2048, 2048, 4096, 8192 }; 373 374/* Use 0 for production, 1 for verification, >2 for debug */ 375#ifndef ETH16I_DEBUG 376#define ETH16I_DEBUG 0 377#endif 378static unsigned int eth16i_debug = ETH16I_DEBUG; 379 380/* Information for each board */ 381 382struct eth16i_local { 383 struct net_device_stats stats; 384 unsigned char tx_started; 385 unsigned char tx_buf_busy; 386 unsigned short tx_queue; /* Number of packets in transmit buffer */ 387 unsigned short tx_queue_len; 388 unsigned int tx_buf_size; 389 unsigned long open_time; 390 unsigned long tx_buffered_packets; 391 unsigned long tx_buffered_bytes; 392 unsigned long col_16; 393 spinlock_t lock; 394}; 395 396/* Function prototypes */ 397 398static int eth16i_probe1(struct net_device *dev, int ioaddr); 399static int eth16i_check_signature(int ioaddr); 400static int eth16i_probe_port(int ioaddr); 401static void eth16i_set_port(int ioaddr, int porttype); 402static int eth16i_send_probe_packet(int ioaddr, unsigned char *b, int l); 403static int eth16i_receive_probe_packet(int ioaddr); 404static int eth16i_get_irq(int ioaddr); 405static int eth16i_read_eeprom(int ioaddr, int offset); 406static int eth16i_read_eeprom_word(int ioaddr); 407static void eth16i_eeprom_cmd(int ioaddr, unsigned char command); 408static int eth16i_open(struct net_device *dev); 409static int eth16i_close(struct net_device *dev); 410static int eth16i_tx(struct sk_buff *skb, struct net_device *dev); 411static void eth16i_rx(struct net_device *dev); 412static void eth16i_timeout(struct net_device *dev); 413static irqreturn_t eth16i_interrupt(int irq, void *dev_id); 414static void eth16i_reset(struct net_device *dev); 415static void eth16i_timeout(struct net_device *dev); 416static void eth16i_skip_packet(struct net_device *dev); 417static void eth16i_multicast(struct net_device *dev); 418static void eth16i_select_regbank(unsigned char regbank, int ioaddr); 419static void eth16i_initialize(struct net_device *dev, int boot); 420 421 422#ifdef MODULE 423static ushort eth16i_parse_mediatype(const char* s); 424#endif 425 426static struct net_device_stats *eth16i_get_stats(struct net_device *dev); 427 428static char cardname[] __initdata = "ICL EtherTeam 16i/32"; 429 430static int __init do_eth16i_probe(struct net_device *dev) 431{ 432 int i; 433 int ioaddr; 434 int base_addr = dev->base_addr; 435 436 SET_MODULE_OWNER(dev); 437 438 if(eth16i_debug > 4) 439 printk(KERN_DEBUG "Probing started for %s\n", cardname); 440 441 if(base_addr > 0x1ff) /* Check only single location */ 442 return eth16i_probe1(dev, base_addr); 443 else if(base_addr != 0) /* Don't probe at all */ 444 return -ENXIO; 445 446 /* Seek card from the ISA io address space */ 447 for(i = 0; (ioaddr = eth16i_portlist[i]) ; i++) 448 if(eth16i_probe1(dev, ioaddr) == 0) 449 return 0; 450 451 /* Seek card from the EISA io address space */ 452 for(i = 0; (ioaddr = eth32i_portlist[i]) ; i++) 453 if(eth16i_probe1(dev, ioaddr) == 0) 454 return 0; 455 456 return -ENODEV; 457} 458 459#ifndef MODULE 460struct net_device * __init eth16i_probe(int unit) 461{ 462 struct net_device *dev = alloc_etherdev(sizeof(struct eth16i_local)); 463 int err; 464 465 if (!dev) 466 return ERR_PTR(-ENOMEM); 467 468 sprintf(dev->name, "eth%d", unit); 469 netdev_boot_setup_check(dev); 470 471 err = do_eth16i_probe(dev); 472 if (err) 473 goto out; 474 return dev; 475out: 476 free_netdev(dev); 477 return ERR_PTR(err); 478} 479#endif 480 481static int __init eth16i_probe1(struct net_device *dev, int ioaddr) 482{ 483 struct eth16i_local *lp = netdev_priv(dev); 484 static unsigned version_printed; 485 int retval; 486 487 /* Let's grab the region */ 488 if (!request_region(ioaddr, ETH16I_IO_EXTENT, cardname)) 489 return -EBUSY; 490 491 /* 492 The MB86985 chip has on register which holds information in which 493 io address the chip lies. First read this register and compare 494 it to our current io address and if match then this could 495 be our chip. 496 */ 497 498 if(ioaddr < 0x1000) { 499 if(eth16i_portlist[(inb(ioaddr + JUMPERLESS_CONFIG) & 0x07)] 500 != ioaddr) { 501 retval = -ENODEV; 502 goto out; 503 } 504 } 505 506 /* Now we will go a bit deeper and try to find the chip's signature */ 507 508 if(eth16i_check_signature(ioaddr) != 0) { 509 retval = -ENODEV; 510 goto out; 511 } 512 513 /* 514 Now it seems that we have found a ethernet chip in this particular 515 ioaddr. The MB86985 chip has this feature, that when you read a 516 certain register it will increase it's io base address to next 517 configurable slot. Now when we have found the chip, first thing is 518 to make sure that the chip's ioaddr will hold still here. 519 */ 520 521 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr); 522 outb(0x00, ioaddr + TRANSCEIVER_MODE_REG); 523 524 outb(0x00, ioaddr + RESET); /* Reset some parts of chip */ 525 BITSET(ioaddr + CONFIG_REG_0, BIT(7)); /* Disable the data link */ 526 527 if( (eth16i_debug & version_printed++) == 0) 528 printk(KERN_INFO "%s", version); 529 530 dev->base_addr = ioaddr; 531 dev->irq = eth16i_get_irq(ioaddr); 532 533 /* Try to obtain interrupt vector */ 534 535 if ((retval = request_irq(dev->irq, (void *)ð16i_interrupt, 0, cardname, dev))) { 536 printk(KERN_WARNING "%s at %#3x, but is unusable due to conflicting IRQ %d.\n", 537 cardname, ioaddr, dev->irq); 538 goto out; 539 } 540 541 printk(KERN_INFO "%s: %s at %#3x, IRQ %d, ", 542 dev->name, cardname, ioaddr, dev->irq); 543 544 545 /* Now we will have to lock the chip's io address */ 546 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr); 547 outb(0x38, ioaddr + TRANSCEIVER_MODE_REG); 548 549 eth16i_initialize(dev, 1); /* Initialize rest of the chip's registers */ 550 551 /* Now let's same some energy by shutting down the chip ;) */ 552 BITCLR(ioaddr + CONFIG_REG_1, POWERUP); 553 554 /* Initialize the device structure */ 555 memset(lp, 0, sizeof(struct eth16i_local)); 556 dev->open = eth16i_open; 557 dev->stop = eth16i_close; 558 dev->hard_start_xmit = eth16i_tx; 559 dev->get_stats = eth16i_get_stats; 560 dev->set_multicast_list = eth16i_multicast; 561 dev->tx_timeout = eth16i_timeout; 562 dev->watchdog_timeo = TX_TIMEOUT; 563 spin_lock_init(&lp->lock); 564 565 retval = register_netdev(dev); 566 if (retval) 567 goto out1; 568 return 0; 569out1: 570 free_irq(dev->irq, dev); 571out: 572 release_region(ioaddr, ETH16I_IO_EXTENT); 573 return retval; 574} 575 576 577static void eth16i_initialize(struct net_device *dev, int boot) 578{ 579 int ioaddr = dev->base_addr; 580 int i, node_w = 0; 581 unsigned char node_byte = 0; 582 583 /* Setup station address */ 584 eth16i_select_regbank(NODE_ID_RB, ioaddr); 585 for(i = 0 ; i < 3 ; i++) { 586 unsigned short node_val = eth16i_read_eeprom(ioaddr, E_NODEID_0 + i); 587 ((unsigned short *)dev->dev_addr)[i] = ntohs(node_val); 588 } 589 590 for(i = 0; i < 6; i++) { 591 outb( ((unsigned char *)dev->dev_addr)[i], ioaddr + NODE_ID_0 + i); 592 if(boot) { 593 printk("%02x", inb(ioaddr + NODE_ID_0 + i)); 594 if(i != 5) 595 printk(":"); 596 } 597 } 598 599 /* Now we will set multicast addresses to accept none */ 600 eth16i_select_regbank(HASH_TABLE_RB, ioaddr); 601 for(i = 0; i < 8; i++) 602 outb(0x00, ioaddr + HASH_TABLE_0 + i); 603 604 /* 605 Now let's disable the transmitter and receiver, set the buffer ram 606 cycle time, bus width and buffer data path width. Also we shall 607 set transmit buffer size and total buffer size. 608 */ 609 610 eth16i_select_regbank(2, ioaddr); 611 612 node_byte = 0; 613 node_w = eth16i_read_eeprom(ioaddr, E_PRODUCT_CFG); 614 615 if( (node_w & 0xFF00) == 0x0800) 616 node_byte |= BUFFER_WIDTH_8; 617 618 node_byte |= SRAM_BS1; 619 620 if( (node_w & 0x00FF) == 64) 621 node_byte |= SRAM_BS0; 622 623 node_byte |= DLC_EN | SRAM_CYCLE_TIME_100NS | (ETH16I_TX_BUF_SIZE << 2); 624 625 outb(node_byte, ioaddr + CONFIG_REG_0); 626 627 /* We shall halt the transmitting, if 16 collisions are detected */ 628 outb(HALT_ON_16, ioaddr + COL_16_REG); 629 630#ifdef MODULE 631 /* if_port already set by init_module() */ 632#else 633 dev->if_port = (dev->mem_start < E_PORT_FROM_EPROM) ? 634 dev->mem_start : E_PORT_FROM_EPROM; 635#endif 636 637 /* Set interface port type */ 638 if(boot) { 639 char *porttype[] = {"BNC", "DIX", "TP", "AUTO", "FROM_EPROM" }; 640 641 switch(dev->if_port) 642 { 643 644 case E_PORT_FROM_EPROM: 645 dev->if_port = eth16i_read_eeprom(ioaddr, E_PORT_SELECT); 646 break; 647 648 case E_PORT_AUTO: 649 dev->if_port = eth16i_probe_port(ioaddr); 650 break; 651 652 case E_PORT_BNC: 653 case E_PORT_TP: 654 case E_PORT_DIX: 655 break; 656 } 657 658 printk(" %s interface.\n", porttype[dev->if_port]); 659 660 eth16i_set_port(ioaddr, dev->if_port); 661 } 662 663 /* Set Receive Mode to normal operation */ 664 outb(MODE_2, ioaddr + RECEIVE_MODE_REG); 665} 666 667static int eth16i_probe_port(int ioaddr) 668{ 669 int i; 670 int retcode; 671 unsigned char dummy_packet[64]; 672 673 /* Powerup the chip */ 674 outb(0xc0 | POWERUP, ioaddr + CONFIG_REG_1); 675 676 BITSET(ioaddr + CONFIG_REG_0, DLC_EN); 677 678 eth16i_select_regbank(NODE_ID_RB, ioaddr); 679 680 for(i = 0; i < 6; i++) { 681 dummy_packet[i] = inb(ioaddr + NODE_ID_0 + i); 682 dummy_packet[i+6] = inb(ioaddr + NODE_ID_0 + i); 683 } 684 685 dummy_packet[12] = 0x00; 686 dummy_packet[13] = 0x04; 687 memset(dummy_packet + 14, 0, sizeof(dummy_packet) - 14); 688 689 eth16i_select_regbank(2, ioaddr); 690 691 for(i = 0; i < 3; i++) { 692 BITSET(ioaddr + CONFIG_REG_0, DLC_EN); 693 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN); 694 eth16i_set_port(ioaddr, i); 695 696 if(eth16i_debug > 1) 697 printk(KERN_DEBUG "Set port number %d\n", i); 698 699 retcode = eth16i_send_probe_packet(ioaddr, dummy_packet, 64); 700 if(retcode == 0) { 701 retcode = eth16i_receive_probe_packet(ioaddr); 702 if(retcode != -1) { 703 if(eth16i_debug > 1) 704 printk(KERN_DEBUG "Eth16i interface port found at %d\n", i); 705 return i; 706 } 707 } 708 else { 709 if(eth16i_debug > 1) 710 printk(KERN_DEBUG "TRANSMIT_DONE timeout when probing interface port\n"); 711 } 712 } 713 714 if( eth16i_debug > 1) 715 printk(KERN_DEBUG "Using default port\n"); 716 717 return E_PORT_BNC; 718} 719 720static void eth16i_set_port(int ioaddr, int porttype) 721{ 722 unsigned short temp = 0; 723 724 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr); 725 outb(LOOPBACK_CONTROL, ioaddr + TRANSMIT_MODE_REG); 726 727 temp |= DIS_AUTO_PORT_SEL; 728 729 switch(porttype) { 730 731 case E_PORT_BNC : 732 temp |= AUI_SELECT; 733 break; 734 735 case E_PORT_TP : 736 break; 737 738 case E_PORT_DIX : 739 temp |= AUI_SELECT; 740 BITSET(ioaddr + TRANSMIT_MODE_REG, CONTROL_OUTPUT); 741 break; 742 } 743 744 outb(temp, ioaddr + TRANSCEIVER_MODE_REG); 745 746 if(eth16i_debug > 1) { 747 printk(KERN_DEBUG "TRANSMIT_MODE_REG = %x\n", inb(ioaddr + TRANSMIT_MODE_REG)); 748 printk(KERN_DEBUG "TRANSCEIVER_MODE_REG = %x\n", 749 inb(ioaddr+TRANSCEIVER_MODE_REG)); 750 } 751} 752 753static int eth16i_send_probe_packet(int ioaddr, unsigned char *b, int l) 754{ 755 unsigned long starttime; 756 757 outb(0xff, ioaddr + TX_STATUS_REG); 758 759 outw(l, ioaddr + DATAPORT); 760 outsw(ioaddr + DATAPORT, (unsigned short *)b, (l + 1) >> 1); 761 762 starttime = jiffies; 763 outb(TX_START | 1, ioaddr + TRANSMIT_START_REG); 764 765 while( (inb(ioaddr + TX_STATUS_REG) & 0x80) == 0) { 766 if( time_after(jiffies, starttime + TX_TIMEOUT)) { 767 return -1; 768 } 769 } 770 771 return 0; 772} 773 774static int eth16i_receive_probe_packet(int ioaddr) 775{ 776 unsigned long starttime; 777 778 starttime = jiffies; 779 780 while((inb(ioaddr + TX_STATUS_REG) & 0x20) == 0) { 781 if( time_after(jiffies, starttime + TX_TIMEOUT)) { 782 783 if(eth16i_debug > 1) 784 printk(KERN_DEBUG "Timeout occurred waiting transmit packet received\n"); 785 starttime = jiffies; 786 while((inb(ioaddr + RX_STATUS_REG) & 0x80) == 0) { 787 if( time_after(jiffies, starttime + TX_TIMEOUT)) { 788 if(eth16i_debug > 1) 789 printk(KERN_DEBUG "Timeout occurred waiting receive packet\n"); 790 return -1; 791 } 792 } 793 794 if(eth16i_debug > 1) 795 printk(KERN_DEBUG "RECEIVE_PACKET\n"); 796 return(0); /* Found receive packet */ 797 } 798 } 799 800 if(eth16i_debug > 1) { 801 printk(KERN_DEBUG "TRANSMIT_PACKET_RECEIVED %x\n", inb(ioaddr + TX_STATUS_REG)); 802 printk(KERN_DEBUG "RX_STATUS_REG = %x\n", inb(ioaddr + RX_STATUS_REG)); 803 } 804 805 return(0); /* Return success */ 806} 807 808 809static int __init eth16i_get_irq(int ioaddr) 810{ 811 unsigned char cbyte; 812 813 if( ioaddr < 0x1000) { 814 cbyte = inb(ioaddr + JUMPERLESS_CONFIG); 815 return( eth16i_irqmap[ ((cbyte & 0xC0) >> 6) ] ); 816 } else { /* Oh..the card is EISA so method getting IRQ different */ 817 unsigned short index = 0; 818 cbyte = inb(ioaddr + EISA_IRQ_REG); 819 while( (cbyte & 0x01) == 0) { 820 cbyte = cbyte >> 1; 821 index++; 822 } 823 return( eth32i_irqmap[ index ] ); 824 } 825} 826 827static int __init eth16i_check_signature(int ioaddr) 828{ 829 int i; 830 unsigned char creg[4] = { 0 }; 831 832 for(i = 0; i < 4 ; i++) { 833 834 creg[i] = inb(ioaddr + TRANSMIT_MODE_REG + i); 835 836 if(eth16i_debug > 1) 837 printk("eth16i: read signature byte %x at %x\n", 838 creg[i], 839 ioaddr + TRANSMIT_MODE_REG + i); 840 } 841 842 creg[0] &= 0x0F; /* Mask collision cnr */ 843 creg[2] &= 0x7F; /* Mask DCLEN bit */ 844 845 846 if( !((creg[2] == 0x36) && (creg[3] == 0xE0)) ) { 847 creg[2] &= 0x40; 848 creg[3] &= 0x03; 849 850 if( !((creg[2] == 0x40) && (creg[3] == 0x00)) ) 851 return -1; 852 } 853 854 if(eth16i_read_eeprom(ioaddr, E_NODEID_0) != 0) 855 return -1; 856 857 if((eth16i_read_eeprom(ioaddr, E_NODEID_1) & 0xFF00) != 0x4B00) 858 return -1; 859 860 return 0; 861} 862 863static int eth16i_read_eeprom(int ioaddr, int offset) 864{ 865 int data = 0; 866 867 eth16i_eeprom_cmd(ioaddr, EEPROM_READ | offset); 868 outb(CS_1, ioaddr + EEPROM_CTRL_REG); 869 data = eth16i_read_eeprom_word(ioaddr); 870 outb(CS_0 | SK_0, ioaddr + EEPROM_CTRL_REG); 871 872 return(data); 873} 874 875static int eth16i_read_eeprom_word(int ioaddr) 876{ 877 int i; 878 int data = 0; 879 880 for(i = 16; i > 0; i--) { 881 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG); 882 eeprom_slow_io(); 883 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG); 884 eeprom_slow_io(); 885 data = (data << 1) | 886 ((inb(ioaddr + EEPROM_DATA_REG) & DI_1) ? 1 : 0); 887 888 eeprom_slow_io(); 889 } 890 891 return(data); 892} 893 894static void eth16i_eeprom_cmd(int ioaddr, unsigned char command) 895{ 896 int i; 897 898 outb(CS_0 | SK_0, ioaddr + EEPROM_CTRL_REG); 899 outb(DI_0, ioaddr + EEPROM_DATA_REG); 900 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG); 901 outb(DI_1, ioaddr + EEPROM_DATA_REG); 902 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG); 903 904 for(i = 7; i >= 0; i--) { 905 short cmd = ( (command & (1 << i)) ? DI_1 : DI_0 ); 906 outb(cmd, ioaddr + EEPROM_DATA_REG); 907 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG); 908 eeprom_slow_io(); 909 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG); 910 eeprom_slow_io(); 911 } 912} 913 914static int eth16i_open(struct net_device *dev) 915{ 916 struct eth16i_local *lp = netdev_priv(dev); 917 int ioaddr = dev->base_addr; 918 919 /* Powerup the chip */ 920 outb(0xc0 | POWERUP, ioaddr + CONFIG_REG_1); 921 922 /* Initialize the chip */ 923 eth16i_initialize(dev, 0); 924 925 /* Set the transmit buffer size */ 926 lp->tx_buf_size = eth16i_tx_buf_map[ETH16I_TX_BUF_SIZE & 0x03]; 927 928 if(eth16i_debug > 0) 929 printk(KERN_DEBUG "%s: transmit buffer size %d\n", 930 dev->name, lp->tx_buf_size); 931 932 /* Now enable Transmitter and Receiver sections */ 933 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN); 934 935 /* Now switch to register bank 2, for run time operation */ 936 eth16i_select_regbank(2, ioaddr); 937 938 lp->open_time = jiffies; 939 lp->tx_started = 0; 940 lp->tx_queue = 0; 941 lp->tx_queue_len = 0; 942 943 /* Turn on interrupts*/ 944 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG); 945 946 netif_start_queue(dev); 947 return 0; 948} 949 950static int eth16i_close(struct net_device *dev) 951{ 952 struct eth16i_local *lp = netdev_priv(dev); 953 int ioaddr = dev->base_addr; 954 955 eth16i_reset(dev); 956 957 /* Turn off interrupts*/ 958 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG); 959 960 netif_stop_queue(dev); 961 962 lp->open_time = 0; 963 964 /* Disable transmit and receive */ 965 BITSET(ioaddr + CONFIG_REG_0, DLC_EN); 966 967 /* Reset the chip */ 968 /* outb(0xff, ioaddr + RESET); */ 969 /* outw(0xffff, ioaddr + TX_STATUS_REG); */ 970 971 outb(0x00, ioaddr + CONFIG_REG_1); 972 973 return 0; 974} 975 976static void eth16i_timeout(struct net_device *dev) 977{ 978 struct eth16i_local *lp = netdev_priv(dev); 979 int ioaddr = dev->base_addr; 980 /* 981 If we get here, some higher level has decided that 982 we are broken. There should really be a "kick me" 983 function call instead. 984 */ 985 986 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG); 987 printk(KERN_WARNING "%s: transmit timed out with status %04x, %s ?\n", 988 dev->name, 989 inw(ioaddr + TX_STATUS_REG), (inb(ioaddr + TX_STATUS_REG) & TX_DONE) ? 990 "IRQ conflict" : "network cable problem"); 991 992 dev->trans_start = jiffies; 993 994 /* Let's dump all registers */ 995 if(eth16i_debug > 0) { 996 printk(KERN_DEBUG "%s: timeout: %02x %02x %02x %02x %02x %02x %02x %02x.\n", 997 dev->name, inb(ioaddr + 0), 998 inb(ioaddr + 1), inb(ioaddr + 2), 999 inb(ioaddr + 3), inb(ioaddr + 4), 1000 inb(ioaddr + 5), 1001 inb(ioaddr + 6), inb(ioaddr + 7)); 1002 1003 printk(KERN_DEBUG "%s: transmit start reg: %02x. collision reg %02x\n", 1004 dev->name, inb(ioaddr + TRANSMIT_START_REG), 1005 inb(ioaddr + COL_16_REG)); 1006 printk(KERN_DEBUG "lp->tx_queue = %d\n", lp->tx_queue); 1007 printk(KERN_DEBUG "lp->tx_queue_len = %d\n", lp->tx_queue_len); 1008 printk(KERN_DEBUG "lp->tx_started = %d\n", lp->tx_started); 1009 } 1010 lp->stats.tx_errors++; 1011 eth16i_reset(dev); 1012 dev->trans_start = jiffies; 1013 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG); 1014 netif_wake_queue(dev); 1015} 1016 1017static int eth16i_tx(struct sk_buff *skb, struct net_device *dev) 1018{ 1019 struct eth16i_local *lp = netdev_priv(dev); 1020 int ioaddr = dev->base_addr; 1021 int status = 0; 1022 ushort length = skb->len; 1023 unsigned char *buf; 1024 unsigned long flags; 1025 1026 if (length < ETH_ZLEN) { 1027 if (skb_padto(skb, ETH_ZLEN)) 1028 return 0; 1029 length = ETH_ZLEN; 1030 } 1031 buf = skb->data; 1032 1033 netif_stop_queue(dev); 1034 1035 /* Turn off TX interrupts */ 1036 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG); 1037 1038 /* We would be better doing the disable_irq tricks the 3c509 does, 1039 that would make this suck a lot less */ 1040 1041 spin_lock_irqsave(&lp->lock, flags); 1042 1043 if( (length + 2) > (lp->tx_buf_size - lp->tx_queue_len)) { 1044 if(eth16i_debug > 0) 1045 printk(KERN_WARNING "%s: Transmit buffer full.\n", dev->name); 1046 } 1047 else { 1048 outw(length, ioaddr + DATAPORT); 1049 1050 if( ioaddr < 0x1000 ) 1051 outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1); 1052 else { 1053 unsigned char frag = length % 4; 1054 outsl(ioaddr + DATAPORT, buf, length >> 2); 1055 if( frag != 0 ) { 1056 outsw(ioaddr + DATAPORT, (buf + (length & 0xFFFC)), 1); 1057 if( frag == 3 ) 1058 outsw(ioaddr + DATAPORT, 1059 (buf + (length & 0xFFFC) + 2), 1); 1060 } 1061 } 1062 lp->tx_buffered_packets++; 1063 lp->tx_buffered_bytes = length; 1064 lp->tx_queue++; 1065 lp->tx_queue_len += length + 2; 1066 } 1067 lp->tx_buf_busy = 0; 1068 1069 if(lp->tx_started == 0) { 1070 /* If the transmitter is idle..always trigger a transmit */ 1071 outb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG); 1072 lp->tx_queue = 0; 1073 lp->tx_queue_len = 0; 1074 dev->trans_start = jiffies; 1075 lp->tx_started = 1; 1076 netif_wake_queue(dev); 1077 } 1078 else if(lp->tx_queue_len < lp->tx_buf_size - (ETH_FRAME_LEN + 2)) { 1079 /* There is still more room for one more packet in tx buffer */ 1080 netif_wake_queue(dev); 1081 } 1082 1083 spin_unlock_irqrestore(&lp->lock, flags); 1084 1085 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG); 1086 /* Turn TX interrupts back on */ 1087 /* outb(TX_INTR_DONE | TX_INTR_16_COL, ioaddr + TX_INTR_REG); */ 1088 status = 0; 1089 dev_kfree_skb(skb); 1090 return 0; 1091} 1092 1093static void eth16i_rx(struct net_device *dev) 1094{ 1095 struct eth16i_local *lp = netdev_priv(dev); 1096 int ioaddr = dev->base_addr; 1097 int boguscount = MAX_RX_LOOP; 1098 1099 /* Loop until all packets have been read */ 1100 while( (inb(ioaddr + RECEIVE_MODE_REG) & RX_BUFFER_EMPTY) == 0) { 1101 1102 /* Read status byte from receive buffer */ 1103 ushort status = inw(ioaddr + DATAPORT); 1104 1105 /* Get the size of the packet from receive buffer */ 1106 ushort pkt_len = inw(ioaddr + DATAPORT); 1107 1108 if(eth16i_debug > 4) 1109 printk(KERN_DEBUG "%s: Receiving packet mode %02x status %04x.\n", 1110 dev->name, 1111 inb(ioaddr + RECEIVE_MODE_REG), status); 1112 1113 if( !(status & PKT_GOOD) ) { 1114 lp->stats.rx_errors++; 1115 1116 if( (pkt_len < ETH_ZLEN) || (pkt_len > ETH_FRAME_LEN) ) { 1117 lp->stats.rx_length_errors++; 1118 eth16i_reset(dev); 1119 return; 1120 } 1121 else { 1122 eth16i_skip_packet(dev); 1123 lp->stats.rx_dropped++; 1124 } 1125 } 1126 else { /* Ok so now we should have a good packet */ 1127 struct sk_buff *skb; 1128 1129 skb = dev_alloc_skb(pkt_len + 3); 1130 if( skb == NULL ) { 1131 printk(KERN_WARNING "%s: Could'n allocate memory for packet (len %d)\n", 1132 dev->name, pkt_len); 1133 eth16i_skip_packet(dev); 1134 lp->stats.rx_dropped++; 1135 break; 1136 } 1137 1138 skb_reserve(skb,2); 1139 1140 /* 1141 Now let's get the packet out of buffer. 1142 size is (pkt_len + 1) >> 1, cause we are now reading words 1143 and it have to be even aligned. 1144 */ 1145 1146 if(ioaddr < 0x1000) 1147 insw(ioaddr + DATAPORT, skb_put(skb, pkt_len), 1148 (pkt_len + 1) >> 1); 1149 else { 1150 unsigned char *buf = skb_put(skb, pkt_len); 1151 unsigned char frag = pkt_len % 4; 1152 1153 insl(ioaddr + DATAPORT, buf, pkt_len >> 2); 1154 1155 if(frag != 0) { 1156 unsigned short rest[2]; 1157 rest[0] = inw( ioaddr + DATAPORT ); 1158 if(frag == 3) 1159 rest[1] = inw( ioaddr + DATAPORT ); 1160 1161 memcpy(buf + (pkt_len & 0xfffc), (char *)rest, frag); 1162 } 1163 } 1164 1165 skb->protocol=eth_type_trans(skb, dev); 1166 1167 if( eth16i_debug > 5 ) { 1168 int i; 1169 printk(KERN_DEBUG "%s: Received packet of length %d.\n", 1170 dev->name, pkt_len); 1171 for(i = 0; i < 14; i++) 1172 printk(KERN_DEBUG " %02x", skb->data[i]); 1173 printk(KERN_DEBUG ".\n"); 1174 } 1175 netif_rx(skb); 1176 dev->last_rx = jiffies; 1177 lp->stats.rx_packets++; 1178 lp->stats.rx_bytes += pkt_len; 1179 1180 } /* else */ 1181 1182 if(--boguscount <= 0) 1183 break; 1184 1185 } /* while */ 1186} 1187 1188static irqreturn_t eth16i_interrupt(int irq, void *dev_id) 1189{ 1190 struct net_device *dev = dev_id; 1191 struct eth16i_local *lp; 1192 int ioaddr = 0, status; 1193 int handled = 0; 1194 1195 ioaddr = dev->base_addr; 1196 lp = netdev_priv(dev); 1197 1198 /* Turn off all interrupts from adapter */ 1199 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG); 1200 1201 /* eth16i_tx won't be called */ 1202 spin_lock(&lp->lock); 1203 1204 status = inw(ioaddr + TX_STATUS_REG); /* Get the status */ 1205 outw(status, ioaddr + TX_STATUS_REG); /* Clear status bits */ 1206 1207 if (status) 1208 handled = 1; 1209 1210 if(eth16i_debug > 3) 1211 printk(KERN_DEBUG "%s: Interrupt with status %04x.\n", dev->name, status); 1212 1213 if( status & 0x7f00 ) { 1214 1215 lp->stats.rx_errors++; 1216 1217 if(status & (BUS_RD_ERR << 8) ) 1218 printk(KERN_WARNING "%s: Bus read error.\n",dev->name); 1219 if(status & (SHORT_PKT_ERR << 8) ) lp->stats.rx_length_errors++; 1220 if(status & (ALIGN_ERR << 8) ) lp->stats.rx_frame_errors++; 1221 if(status & (CRC_ERR << 8) ) lp->stats.rx_crc_errors++; 1222 if(status & (RX_BUF_OVERFLOW << 8) ) lp->stats.rx_over_errors++; 1223 } 1224 if( status & 0x001a) { 1225 1226 lp->stats.tx_errors++; 1227 1228 if(status & CR_LOST) lp->stats.tx_carrier_errors++; 1229 if(status & TX_JABBER_ERR) lp->stats.tx_window_errors++; 1230 1231 if(status & COLLISIONS_16) { 1232 if(lp->col_16 < MAX_COL_16) { 1233 lp->col_16++; 1234 lp->stats.collisions++; 1235 /* Resume transmitting, skip failed packet */ 1236 outb(0x02, ioaddr + COL_16_REG); 1237 } 1238 else { 1239 printk(KERN_WARNING "%s: bailing out due to many consecutive 16-in-a-row collisions. Network cable problem?\n", dev->name); 1240 } 1241 } 1242 } 1243 1244 if( status & 0x00ff ) { /* Let's check the transmit status reg */ 1245 1246 if(status & TX_DONE) { /* The transmit has been done */ 1247 lp->stats.tx_packets = lp->tx_buffered_packets; 1248 lp->stats.tx_bytes += lp->tx_buffered_bytes; 1249 lp->col_16 = 0; 1250 1251 if(lp->tx_queue) { /* Is there still packets ? */ 1252 /* There was packet(s) so start transmitting and write also 1253 how many packets there is to be sended */ 1254 outb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG); 1255 lp->tx_queue = 0; 1256 lp->tx_queue_len = 0; 1257 lp->tx_started = 1; 1258 } 1259 else { 1260 lp->tx_started = 0; 1261 } 1262 netif_wake_queue(dev); 1263 } 1264 } 1265 1266 if( ( status & 0x8000 ) || 1267 ( (inb(ioaddr + RECEIVE_MODE_REG) & RX_BUFFER_EMPTY) == 0) ) { 1268 eth16i_rx(dev); /* We have packet in receive buffer */ 1269 } 1270 1271 /* Turn interrupts back on */ 1272 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG); 1273 1274 if(lp->tx_queue_len < lp->tx_buf_size - (ETH_FRAME_LEN + 2)) { 1275 /* There is still more room for one more packet in tx buffer */ 1276 netif_wake_queue(dev); 1277 } 1278 1279 spin_unlock(&lp->lock); 1280 1281 return IRQ_RETVAL(handled); 1282} 1283 1284static void eth16i_skip_packet(struct net_device *dev) 1285{ 1286 int ioaddr = dev->base_addr; 1287 1288 inw(ioaddr + DATAPORT); 1289 inw(ioaddr + DATAPORT); 1290 inw(ioaddr + DATAPORT); 1291 1292 outb(SKIP_RX_PACKET, ioaddr + FILTER_SELF_RX_REG); 1293 while( inb( ioaddr + FILTER_SELF_RX_REG ) != 0); 1294} 1295 1296static void eth16i_reset(struct net_device *dev) 1297{ 1298 struct eth16i_local *lp = netdev_priv(dev); 1299 int ioaddr = dev->base_addr; 1300 1301 if(eth16i_debug > 1) 1302 printk(KERN_DEBUG "%s: Resetting device.\n", dev->name); 1303 1304 BITSET(ioaddr + CONFIG_REG_0, DLC_EN); 1305 outw(0xffff, ioaddr + TX_STATUS_REG); 1306 eth16i_select_regbank(2, ioaddr); 1307 1308 lp->tx_started = 0; 1309 lp->tx_buf_busy = 0; 1310 lp->tx_queue = 0; 1311 lp->tx_queue_len = 0; 1312 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN); 1313} 1314 1315static void eth16i_multicast(struct net_device *dev) 1316{ 1317 int ioaddr = dev->base_addr; 1318 1319 if(dev->mc_count || dev->flags&(IFF_ALLMULTI|IFF_PROMISC)) 1320 { 1321 dev->flags|=IFF_PROMISC; /* Must do this */ 1322 outb(3, ioaddr + RECEIVE_MODE_REG); 1323 } else { 1324 outb(2, ioaddr + RECEIVE_MODE_REG); 1325 } 1326} 1327 1328static struct net_device_stats *eth16i_get_stats(struct net_device *dev) 1329{ 1330 struct eth16i_local *lp = netdev_priv(dev); 1331 return &lp->stats; 1332} 1333 1334static void eth16i_select_regbank(unsigned char banknbr, int ioaddr) 1335{ 1336 unsigned char data; 1337 1338 data = inb(ioaddr + CONFIG_REG_1); 1339 outb( ((data & 0xF3) | ( (banknbr & 0x03) << 2)), ioaddr + CONFIG_REG_1); 1340} 1341 1342#ifdef MODULE 1343 1344static ushort eth16i_parse_mediatype(const char* s) 1345{ 1346 if(!s) 1347 return E_PORT_FROM_EPROM; 1348 1349 if (!strncmp(s, "bnc", 3)) 1350 return E_PORT_BNC; 1351 else if (!strncmp(s, "tp", 2)) 1352 return E_PORT_TP; 1353 else if (!strncmp(s, "dix", 3)) 1354 return E_PORT_DIX; 1355 else if (!strncmp(s, "auto", 4)) 1356 return E_PORT_AUTO; 1357 else 1358 return E_PORT_FROM_EPROM; 1359} 1360 1361#define MAX_ETH16I_CARDS 4 /* Max number of Eth16i cards per module */ 1362 1363static struct net_device *dev_eth16i[MAX_ETH16I_CARDS]; 1364static int io[MAX_ETH16I_CARDS]; 1365static char* mediatype[MAX_ETH16I_CARDS]; 1366static int debug = -1; 1367 1368MODULE_AUTHOR("Mika Kuoppala <miku@iki.fi>"); 1369MODULE_DESCRIPTION("ICL EtherTeam 16i/32 driver"); 1370MODULE_LICENSE("GPL"); 1371 1372 1373module_param_array(io, int, NULL, 0); 1374MODULE_PARM_DESC(io, "eth16i I/O base address(es)"); 1375 1376 1377module_param_array(mediatype, charp, NULL, 0); 1378MODULE_PARM_DESC(mediatype, "eth16i media type of interface(s) (bnc,tp,dix,auto,eprom)"); 1379 1380module_param(debug, int, 0); 1381MODULE_PARM_DESC(debug, "eth16i debug level (0-6)"); 1382 1383int __init init_module(void) 1384{ 1385 int this_dev, found = 0; 1386 struct net_device *dev; 1387 1388 for (this_dev = 0; this_dev < MAX_ETH16I_CARDS; this_dev++) { 1389 dev = alloc_etherdev(sizeof(struct eth16i_local)); 1390 if (!dev) 1391 break; 1392 1393 dev->base_addr = io[this_dev]; 1394 1395 if(debug != -1) 1396 eth16i_debug = debug; 1397 1398 if(eth16i_debug > 1) 1399 printk(KERN_NOTICE "eth16i(%d): interface type %s\n", this_dev, mediatype[this_dev] ? mediatype[this_dev] : "none" ); 1400 1401 dev->if_port = eth16i_parse_mediatype(mediatype[this_dev]); 1402 1403 if(io[this_dev] == 0) { 1404 if(this_dev != 0) /* Only autoprobe 1st one */ 1405 break; 1406 1407 printk(KERN_NOTICE "eth16i.c: Presently autoprobing (not recommended) for a single card.\n"); 1408 } 1409 1410 if (do_eth16i_probe(dev) == 0) { 1411 dev_eth16i[found++] = dev; 1412 continue; 1413 } 1414 printk(KERN_WARNING "eth16i.c No Eth16i card found (i/o = 0x%x).\n", 1415 io[this_dev]); 1416 free_netdev(dev); 1417 break; 1418 } 1419 if (found) 1420 return 0; 1421 return -ENXIO; 1422} 1423 1424void __exit cleanup_module(void) 1425{ 1426 int this_dev; 1427 1428 for(this_dev = 0; this_dev < MAX_ETH16I_CARDS; this_dev++) { 1429 struct net_device *dev = dev_eth16i[this_dev]; 1430 1431 if(dev->priv) { 1432 unregister_netdev(dev); 1433 free_irq(dev->irq, dev); 1434 release_region(dev->base_addr, ETH16I_IO_EXTENT); 1435 free_netdev(dev); 1436 } 1437 } 1438} 1439#endif /* MODULE */ 1440 1441/* 1442 * Local variables: 1443 * compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c eth16i.c" 1444 * alt-compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict -prototypes -O6 -c eth16i.c" 1445 * tab-width: 8 1446 * c-basic-offset: 8 1447 * c-indent-level: 8 1448 * End: 1449 */ 1450 1451/* End of file eth16i.c */ 1452