1/* eepro.c: Intel EtherExpress Pro/10 device driver for Linux. */ 2/* 3 Written 1994, 1995,1996 by Bao C. Ha. 4 5 Copyright (C) 1994, 1995,1996 by Bao C. Ha. 6 7 This software may be used and distributed 8 according to the terms of the GNU General Public License, 9 incorporated herein by reference. 10 11 The author may be reached at bao.ha@srs.gov 12 or 418 Hastings Place, Martinez, GA 30907. 13 14 Things remaining to do: 15 Better record keeping of errors. 16 Eliminate transmit interrupt to reduce overhead. 17 Implement "concurrent processing". I won't be doing it! 18 19 Bugs: 20 21 If you have a problem of not detecting the 82595 during a 22 reboot (warm reset), disable the FLASH memory should fix it. 23 This is a compatibility hardware problem. 24 25 Versions: 26 0.13b basic ethtool support (aris, 09/13/2004) 27 0.13a in memory shortage, drop packets also in board 28 (Michael Westermann <mw@microdata-pos.de>, 07/30/2002) 29 0.13 irq sharing, rewrote probe function, fixed a nasty bug in 30 hardware_send_packet and a major cleanup (aris, 11/08/2001) 31 0.12d fixing a problem with single card detected as eight eth devices 32 fixing a problem with sudden drop in card performance 33 (chris (asdn@go2.pl), 10/29/2001) 34 0.12c fixing some problems with old cards (aris, 01/08/2001) 35 0.12b misc fixes (aris, 06/26/2000) 36 0.12a port of version 0.12a of 2.2.x kernels to 2.3.x 37 (aris (aris@conectiva.com.br), 05/19/2000) 38 0.11e some tweaks about multiple cards support (PdP, jul/aug 1999) 39 0.11d added __initdata, __init stuff; call spin_lock_init 40 in eepro_probe1. Replaced "eepro" by dev->name. Augmented 41 the code protected by spin_lock in interrupt routine 42 (PdP, 12/12/1998) 43 0.11c minor cleanup (PdP, RMC, 09/12/1998) 44 0.11b Pascal Dupuis (dupuis@lei.ucl.ac.be): works as a module 45 under 2.1.xx. Debug messages are flagged as KERN_DEBUG to 46 avoid console flooding. Added locking at critical parts. Now 47 the dawn thing is SMP safe. 48 0.11a Attempt to get 2.1.xx support up (RMC) 49 0.11 Brian Candler added support for multiple cards. Tested as 50 a module, no idea if it works when compiled into kernel. 51 52 0.10e Rick Bressler notified me that ifconfig up;ifconfig down fails 53 because the irq is lost somewhere. Fixed that by moving 54 request_irq and free_irq to eepro_open and eepro_close respectively. 55 0.10d Ugh! Now Wakeup works. Was seriously broken in my first attempt. 56 I'll need to find a way to specify an ioport other than 57 the default one in the PnP case. PnP definitively sucks. 58 And, yes, this is not the only reason. 59 0.10c PnP Wakeup Test for 595FX. uncomment #define PnPWakeup; 60 to use. 61 0.10b Should work now with (some) Pro/10+. At least for 62 me (and my two cards) it does. _No_ guarantee for 63 function with non-Pro/10+ cards! (don't have any) 64 (RMC, 9/11/96) 65 66 0.10 Added support for the Etherexpress Pro/10+. The 67 IRQ map was changed significantly from the old 68 pro/10. The new interrupt map was provided by 69 Rainer M. Canavan (Canavan@Zeus.cs.bonn.edu). 70 (BCH, 9/3/96) 71 72 0.09 Fixed a race condition in the transmit algorithm, 73 which causes crashes under heavy load with fast 74 pentium computers. The performance should also 75 improve a bit. The size of RX buffer, and hence 76 TX buffer, can also be changed via lilo or insmod. 77 (BCH, 7/31/96) 78 79 0.08 Implement 32-bit I/O for the 82595TX and 82595FX 80 based lan cards. Disable full-duplex mode if TPE 81 is not used. (BCH, 4/8/96) 82 83 0.07a Fix a stat report which counts every packet as a 84 heart-beat failure. (BCH, 6/3/95) 85 86 0.07 Modified to support all other 82595-based lan cards. 87 The IRQ vector of the EtherExpress Pro will be set 88 according to the value saved in the EEPROM. For other 89 cards, I will do autoirq_request() to grab the next 90 available interrupt vector. (BCH, 3/17/95) 91 92 0.06a,b Interim released. Minor changes in the comments and 93 print out format. (BCH, 3/9/95 and 3/14/95) 94 95 0.06 First stable release that I am comfortable with. (BCH, 96 3/2/95) 97 98 0.05 Complete testing of multicast. (BCH, 2/23/95) 99 100 0.04 Adding multicast support. (BCH, 2/14/95) 101 102 0.03 First widely alpha release for public testing. 103 (BCH, 2/14/95) 104 105*/ 106 107static const char version[] = 108 "eepro.c: v0.13b 09/13/2004 aris@cathedrallabs.org\n"; 109 110#include <linux/module.h> 111 112/* 113 Sources: 114 115 This driver wouldn't have been written without the availability 116 of the Crynwr's Lan595 driver source code. It helps me to 117 familiarize with the 82595 chipset while waiting for the Intel 118 documentation. I also learned how to detect the 82595 using 119 the packet driver's technique. 120 121 This driver is written by cutting and pasting the skeleton.c driver 122 provided by Donald Becker. I also borrowed the EEPROM routine from 123 Donald Becker's 82586 driver. 124 125 Datasheet for the Intel 82595 (including the TX and FX version). It 126 provides just enough info that the casual reader might think that it 127 documents the i82595. 128 129 The User Manual for the 82595. It provides a lot of the missing 130 information. 131 132*/ 133 134#include <linux/kernel.h> 135#include <linux/types.h> 136#include <linux/fcntl.h> 137#include <linux/interrupt.h> 138#include <linux/ioport.h> 139#include <linux/in.h> 140#include <linux/string.h> 141#include <linux/errno.h> 142#include <linux/netdevice.h> 143#include <linux/etherdevice.h> 144#include <linux/skbuff.h> 145#include <linux/spinlock.h> 146#include <linux/init.h> 147#include <linux/delay.h> 148#include <linux/bitops.h> 149#include <linux/ethtool.h> 150 151#include <asm/system.h> 152#include <asm/io.h> 153#include <asm/dma.h> 154 155#define DRV_NAME "eepro" 156#define DRV_VERSION "0.13c" 157 158#define compat_dev_kfree_skb( skb, mode ) dev_kfree_skb( (skb) ) 159/* I had reports of looong delays with SLOW_DOWN defined as udelay(2) */ 160#define SLOW_DOWN inb(0x80) 161/* udelay(2) */ 162#define compat_init_data __initdata 163enum iftype { AUI=0, BNC=1, TPE=2 }; 164 165/* First, a few definitions that the brave might change. */ 166/* A zero-terminated list of I/O addresses to be probed. */ 167static unsigned int eepro_portlist[] compat_init_data = 168 { 0x300, 0x210, 0x240, 0x280, 0x2C0, 0x200, 0x320, 0x340, 0x360, 0}; 169/* note: 0x300 is default, the 595FX supports ALL IO Ports 170 from 0x000 to 0x3F0, some of which are reserved in PCs */ 171 172/* To try the (not-really PnP Wakeup: */ 173/* 174#define PnPWakeup 175*/ 176 177/* use 0 for production, 1 for verification, >2 for debug */ 178#ifndef NET_DEBUG 179#define NET_DEBUG 0 180#endif 181static unsigned int net_debug = NET_DEBUG; 182 183/* The number of low I/O ports used by the ethercard. */ 184#define EEPRO_IO_EXTENT 16 185 186/* Different 82595 chips */ 187#define LAN595 0 188#define LAN595TX 1 189#define LAN595FX 2 190#define LAN595FX_10ISA 3 191 192/* Information that need to be kept for each board. */ 193struct eepro_local { 194 unsigned rx_start; 195 unsigned tx_start; /* start of the transmit chain */ 196 int tx_last; /* pointer to last packet in the transmit chain */ 197 unsigned tx_end; /* end of the transmit chain (plus 1) */ 198 int eepro; /* 1 for the EtherExpress Pro/10, 199 2 for the EtherExpress Pro/10+, 200 3 for the EtherExpress 10 (blue cards), 201 0 for other 82595-based lan cards. */ 202 int version; /* a flag to indicate if this is a TX or FX 203 version of the 82595 chip. */ 204 int stepping; 205 206 spinlock_t lock; /* Serializing lock */ 207 208 unsigned rcv_ram; /* pre-calculated space for rx */ 209 unsigned xmt_ram; /* pre-calculated space for tx */ 210 unsigned char xmt_bar; 211 unsigned char xmt_lower_limit_reg; 212 unsigned char xmt_upper_limit_reg; 213 short xmt_lower_limit; 214 short xmt_upper_limit; 215 short rcv_lower_limit; 216 short rcv_upper_limit; 217 unsigned char eeprom_reg; 218 unsigned short word[8]; 219}; 220 221/* The station (ethernet) address prefix, used for IDing the board. */ 222#define SA_ADDR0 0x00 /* Etherexpress Pro/10 */ 223#define SA_ADDR1 0xaa 224#define SA_ADDR2 0x00 225 226#define GetBit(x,y) ((x & (1<<y))>>y) 227 228/* EEPROM Word 0: */ 229#define ee_PnP 0 /* Plug 'n Play enable bit */ 230#define ee_Word1 1 /* Word 1? */ 231#define ee_BusWidth 2 /* 8/16 bit */ 232#define ee_FlashAddr 3 /* Flash Address */ 233#define ee_FlashMask 0x7 /* Mask */ 234#define ee_AutoIO 6 /* */ 235#define ee_reserved0 7 /* =0! */ 236#define ee_Flash 8 /* Flash there? */ 237#define ee_AutoNeg 9 /* Auto Negotiation enabled? */ 238#define ee_IO0 10 /* IO Address LSB */ 239#define ee_IO0Mask 0x /*...*/ 240#define ee_IO1 15 /* IO MSB */ 241 242/* EEPROM Word 1: */ 243#define ee_IntSel 0 /* Interrupt */ 244#define ee_IntMask 0x7 245#define ee_LI 3 /* Link Integrity 0= enabled */ 246#define ee_PC 4 /* Polarity Correction 0= enabled */ 247#define ee_TPE_AUI 5 /* PortSelection 1=TPE */ 248#define ee_Jabber 6 /* Jabber prevention 0= enabled */ 249#define ee_AutoPort 7 /* Auto Port Selection 1= Disabled */ 250#define ee_SMOUT 8 /* SMout Pin Control 0= Input */ 251#define ee_PROM 9 /* Flash EPROM / PROM 0=Flash */ 252#define ee_reserved1 10 /* .. 12 =0! */ 253#define ee_AltReady 13 /* Alternate Ready, 0=normal */ 254#define ee_reserved2 14 /* =0! */ 255#define ee_Duplex 15 256 257/* Word2,3,4: */ 258#define ee_IA5 0 /*bit start for individual Addr Byte 5 */ 259#define ee_IA4 8 /*bit start for individual Addr Byte 5 */ 260#define ee_IA3 0 /*bit start for individual Addr Byte 5 */ 261#define ee_IA2 8 /*bit start for individual Addr Byte 5 */ 262#define ee_IA1 0 /*bit start for individual Addr Byte 5 */ 263#define ee_IA0 8 /*bit start for individual Addr Byte 5 */ 264 265/* Word 5: */ 266#define ee_BNC_TPE 0 /* 0=TPE */ 267#define ee_BootType 1 /* 00=None, 01=IPX, 10=ODI, 11=NDIS */ 268#define ee_BootTypeMask 0x3 269#define ee_NumConn 3 /* Number of Connections 0= One or Two */ 270#define ee_FlashSock 4 /* Presence of Flash Socket 0= Present */ 271#define ee_PortTPE 5 272#define ee_PortBNC 6 273#define ee_PortAUI 7 274#define ee_PowerMgt 10 /* 0= disabled */ 275#define ee_CP 13 /* Concurrent Processing */ 276#define ee_CPMask 0x7 277 278/* Word 6: */ 279#define ee_Stepping 0 /* Stepping info */ 280#define ee_StepMask 0x0F 281#define ee_BoardID 4 /* Manucaturer Board ID, reserved */ 282#define ee_BoardMask 0x0FFF 283 284/* Word 7: */ 285#define ee_INT_TO_IRQ 0 /* int to IRQ Mapping = 0x1EB8 for Pro/10+ */ 286#define ee_FX_INT2IRQ 0x1EB8 /* the _only_ mapping allowed for FX chips */ 287 288/*..*/ 289#define ee_SIZE 0x40 /* total EEprom Size */ 290#define ee_Checksum 0xBABA /* initial and final value for adding checksum */ 291 292 293/* Card identification via EEprom: */ 294#define ee_addr_vendor 0x10 /* Word offset for EISA Vendor ID */ 295#define ee_addr_id 0x11 /* Word offset for Card ID */ 296#define ee_addr_SN 0x12 /* Serial Number */ 297#define ee_addr_CRC_8 0x14 /* CRC over last thee Bytes */ 298 299 300#define ee_vendor_intel0 0x25 /* Vendor ID Intel */ 301#define ee_vendor_intel1 0xD4 302#define ee_id_eepro10p0 0x10 /* ID for eepro/10+ */ 303#define ee_id_eepro10p1 0x31 304 305#define TX_TIMEOUT 40 306 307/* Index to functions, as function prototypes. */ 308 309static int eepro_probe1(struct net_device *dev, int autoprobe); 310static int eepro_open(struct net_device *dev); 311static netdev_tx_t eepro_send_packet(struct sk_buff *skb, 312 struct net_device *dev); 313static irqreturn_t eepro_interrupt(int irq, void *dev_id); 314static void eepro_rx(struct net_device *dev); 315static void eepro_transmit_interrupt(struct net_device *dev); 316static int eepro_close(struct net_device *dev); 317static void set_multicast_list(struct net_device *dev); 318static void eepro_tx_timeout (struct net_device *dev); 319 320static int read_eeprom(int ioaddr, int location, struct net_device *dev); 321static int hardware_send_packet(struct net_device *dev, void *buf, short length); 322static int eepro_grab_irq(struct net_device *dev); 323 324/* 325 Details of the i82595. 326 327You will need either the datasheet or the user manual to understand what 328is going on here. The 82595 is very different from the 82586, 82593. 329 330The receive algorithm in eepro_rx() is just an implementation of the 331RCV ring structure that the Intel 82595 imposes at the hardware level. 332The receive buffer is set at 24K, and the transmit buffer is 8K. I 333am assuming that the total buffer memory is 32K, which is true for the 334Intel EtherExpress Pro/10. If it is less than that on a generic card, 335the driver will be broken. 336 337The transmit algorithm in the hardware_send_packet() is similar to the 338one in the eepro_rx(). The transmit buffer is a ring linked list. 339I just queue the next available packet to the end of the list. In my 340system, the 82595 is so fast that the list seems to always contain a 341single packet. In other systems with faster computers and more congested 342network traffics, the ring linked list should improve performance by 343allowing up to 8K worth of packets to be queued. 344 345The sizes of the receive and transmit buffers can now be changed via lilo 346or insmod. Lilo uses the appended line "ether=io,irq,debug,rx-buffer,eth0" 347where rx-buffer is in KB unit. Modules uses the parameter mem which is 348also in KB unit, for example "insmod io=io-address irq=0 mem=rx-buffer." 349The receive buffer has to be more than 3K or less than 29K. Otherwise, 350it is reset to the default of 24K, and, hence, 8K for the trasnmit 351buffer (transmit-buffer = 32K - receive-buffer). 352 353*/ 354#define RAM_SIZE 0x8000 355 356#define RCV_HEADER 8 357#define RCV_DEFAULT_RAM 0x6000 358 359#define XMT_HEADER 8 360#define XMT_DEFAULT_RAM (RAM_SIZE - RCV_DEFAULT_RAM) 361 362#define XMT_START_PRO RCV_DEFAULT_RAM 363#define XMT_START_10 0x0000 364#define RCV_START_PRO 0x0000 365#define RCV_START_10 XMT_DEFAULT_RAM 366 367#define RCV_DONE 0x0008 368#define RX_OK 0x2000 369#define RX_ERROR 0x0d81 370 371#define TX_DONE_BIT 0x0080 372#define TX_OK 0x2000 373#define CHAIN_BIT 0x8000 374#define XMT_STATUS 0x02 375#define XMT_CHAIN 0x04 376#define XMT_COUNT 0x06 377 378#define BANK0_SELECT 0x00 379#define BANK1_SELECT 0x40 380#define BANK2_SELECT 0x80 381 382/* Bank 0 registers */ 383#define COMMAND_REG 0x00 /* Register 0 */ 384#define MC_SETUP 0x03 385#define XMT_CMD 0x04 386#define DIAGNOSE_CMD 0x07 387#define RCV_ENABLE_CMD 0x08 388#define RCV_DISABLE_CMD 0x0a 389#define STOP_RCV_CMD 0x0b 390#define RESET_CMD 0x0e 391#define POWER_DOWN_CMD 0x18 392#define RESUME_XMT_CMD 0x1c 393#define SEL_RESET_CMD 0x1e 394#define STATUS_REG 0x01 /* Register 1 */ 395#define RX_INT 0x02 396#define TX_INT 0x04 397#define EXEC_STATUS 0x30 398#define ID_REG 0x02 /* Register 2 */ 399#define R_ROBIN_BITS 0xc0 /* round robin counter */ 400#define ID_REG_MASK 0x2c 401#define ID_REG_SIG 0x24 402#define AUTO_ENABLE 0x10 403#define INT_MASK_REG 0x03 /* Register 3 */ 404#define RX_STOP_MASK 0x01 405#define RX_MASK 0x02 406#define TX_MASK 0x04 407#define EXEC_MASK 0x08 408#define ALL_MASK 0x0f 409#define IO_32_BIT 0x10 410#define RCV_BAR 0x04 /* The following are word (16-bit) registers */ 411#define RCV_STOP 0x06 412 413#define XMT_BAR_PRO 0x0a 414#define XMT_BAR_10 0x0b 415 416#define HOST_ADDRESS_REG 0x0c 417#define IO_PORT 0x0e 418#define IO_PORT_32_BIT 0x0c 419 420/* Bank 1 registers */ 421#define REG1 0x01 422#define WORD_WIDTH 0x02 423#define INT_ENABLE 0x80 424#define INT_NO_REG 0x02 425#define RCV_LOWER_LIMIT_REG 0x08 426#define RCV_UPPER_LIMIT_REG 0x09 427 428#define XMT_LOWER_LIMIT_REG_PRO 0x0a 429#define XMT_UPPER_LIMIT_REG_PRO 0x0b 430#define XMT_LOWER_LIMIT_REG_10 0x0b 431#define XMT_UPPER_LIMIT_REG_10 0x0a 432 433/* Bank 2 registers */ 434#define XMT_Chain_Int 0x20 /* Interrupt at the end of the transmit chain */ 435#define XMT_Chain_ErrStop 0x40 /* Interrupt at the end of the chain even if there are errors */ 436#define RCV_Discard_BadFrame 0x80 /* Throw bad frames away, and continue to receive others */ 437#define REG2 0x02 438#define PRMSC_Mode 0x01 439#define Multi_IA 0x20 440#define REG3 0x03 441#define TPE_BIT 0x04 442#define BNC_BIT 0x20 443#define REG13 0x0d 444#define FDX 0x00 445#define A_N_ENABLE 0x02 446 447#define I_ADD_REG0 0x04 448#define I_ADD_REG1 0x05 449#define I_ADD_REG2 0x06 450#define I_ADD_REG3 0x07 451#define I_ADD_REG4 0x08 452#define I_ADD_REG5 0x09 453 454#define EEPROM_REG_PRO 0x0a 455#define EEPROM_REG_10 0x0b 456 457#define EESK 0x01 458#define EECS 0x02 459#define EEDI 0x04 460#define EEDO 0x08 461 462/* do a full reset */ 463#define eepro_reset(ioaddr) outb(RESET_CMD, ioaddr) 464 465/* do a nice reset */ 466#define eepro_sel_reset(ioaddr) { \ 467 outb(SEL_RESET_CMD, ioaddr); \ 468 SLOW_DOWN; \ 469 SLOW_DOWN; \ 470 } 471 472/* disable all interrupts */ 473#define eepro_dis_int(ioaddr) outb(ALL_MASK, ioaddr + INT_MASK_REG) 474 475/* clear all interrupts */ 476#define eepro_clear_int(ioaddr) outb(ALL_MASK, ioaddr + STATUS_REG) 477 478/* enable tx/rx */ 479#define eepro_en_int(ioaddr) outb(ALL_MASK & ~(RX_MASK | TX_MASK), \ 480 ioaddr + INT_MASK_REG) 481 482/* enable exec event interrupt */ 483#define eepro_en_intexec(ioaddr) outb(ALL_MASK & ~(EXEC_MASK), ioaddr + INT_MASK_REG) 484 485/* enable rx */ 486#define eepro_en_rx(ioaddr) outb(RCV_ENABLE_CMD, ioaddr) 487 488/* disable rx */ 489#define eepro_dis_rx(ioaddr) outb(RCV_DISABLE_CMD, ioaddr) 490 491/* switch bank */ 492#define eepro_sw2bank0(ioaddr) outb(BANK0_SELECT, ioaddr) 493#define eepro_sw2bank1(ioaddr) outb(BANK1_SELECT, ioaddr) 494#define eepro_sw2bank2(ioaddr) outb(BANK2_SELECT, ioaddr) 495 496/* enable interrupt line */ 497#define eepro_en_intline(ioaddr) outb(inb(ioaddr + REG1) | INT_ENABLE,\ 498 ioaddr + REG1) 499 500/* disable interrupt line */ 501#define eepro_dis_intline(ioaddr) outb(inb(ioaddr + REG1) & 0x7f, \ 502 ioaddr + REG1); 503 504/* set diagnose flag */ 505#define eepro_diag(ioaddr) outb(DIAGNOSE_CMD, ioaddr) 506 507/* ack for rx int */ 508#define eepro_ack_rx(ioaddr) outb (RX_INT, ioaddr + STATUS_REG) 509 510/* ack for tx int */ 511#define eepro_ack_tx(ioaddr) outb (TX_INT, ioaddr + STATUS_REG) 512 513/* a complete sel reset */ 514#define eepro_complete_selreset(ioaddr) { \ 515 dev->stats.tx_errors++;\ 516 eepro_sel_reset(ioaddr);\ 517 lp->tx_end = \ 518 lp->xmt_lower_limit;\ 519 lp->tx_start = lp->tx_end;\ 520 lp->tx_last = 0;\ 521 dev->trans_start = jiffies;\ 522 netif_wake_queue(dev);\ 523 eepro_en_rx(ioaddr);\ 524 } 525 526/* Check for a network adaptor of this type, and return '0' if one exists. 527 If dev->base_addr == 0, probe all likely locations. 528 If dev->base_addr == 1, always return failure. 529 If dev->base_addr == 2, allocate space for the device and return success 530 (detachable devices only). 531 */ 532static int __init do_eepro_probe(struct net_device *dev) 533{ 534 int i; 535 int base_addr = dev->base_addr; 536 int irq = dev->irq; 537 538#ifdef PnPWakeup 539 540 /* Wakeup: */ 541 #define WakeupPort 0x279 542 #define WakeupSeq {0x6A, 0xB5, 0xDA, 0xED, 0xF6, 0xFB, 0x7D, 0xBE,\ 543 0xDF, 0x6F, 0x37, 0x1B, 0x0D, 0x86, 0xC3, 0x61,\ 544 0xB0, 0x58, 0x2C, 0x16, 0x8B, 0x45, 0xA2, 0xD1,\ 545 0xE8, 0x74, 0x3A, 0x9D, 0xCE, 0xE7, 0x73, 0x43} 546 547 { 548 unsigned short int WS[32]=WakeupSeq; 549 550 if (request_region(WakeupPort, 2, "eepro wakeup")) { 551 if (net_debug>5) 552 printk(KERN_DEBUG "Waking UP\n"); 553 554 outb_p(0,WakeupPort); 555 outb_p(0,WakeupPort); 556 for (i=0; i<32; i++) { 557 outb_p(WS[i],WakeupPort); 558 if (net_debug>5) printk(KERN_DEBUG ": %#x ",WS[i]); 559 } 560 561 release_region(WakeupPort, 2); 562 } else 563 printk(KERN_WARNING "PnP wakeup region busy!\n"); 564 } 565#endif 566 567 if (base_addr > 0x1ff) /* Check a single specified location. */ 568 return eepro_probe1(dev, 0); 569 570 else if (base_addr != 0) /* Don't probe at all. */ 571 return -ENXIO; 572 573 for (i = 0; eepro_portlist[i]; i++) { 574 dev->base_addr = eepro_portlist[i]; 575 dev->irq = irq; 576 if (eepro_probe1(dev, 1) == 0) 577 return 0; 578 } 579 580 return -ENODEV; 581} 582 583#ifndef MODULE 584struct net_device * __init eepro_probe(int unit) 585{ 586 struct net_device *dev = alloc_etherdev(sizeof(struct eepro_local)); 587 int err; 588 589 if (!dev) 590 return ERR_PTR(-ENODEV); 591 592 sprintf(dev->name, "eth%d", unit); 593 netdev_boot_setup_check(dev); 594 595 err = do_eepro_probe(dev); 596 if (err) 597 goto out; 598 return dev; 599out: 600 free_netdev(dev); 601 return ERR_PTR(err); 602} 603#endif 604 605static void __init printEEPROMInfo(struct net_device *dev) 606{ 607 struct eepro_local *lp = netdev_priv(dev); 608 int ioaddr = dev->base_addr; 609 unsigned short Word; 610 int i,j; 611 612 j = ee_Checksum; 613 for (i = 0; i < 8; i++) 614 j += lp->word[i]; 615 for ( ; i < ee_SIZE; i++) 616 j += read_eeprom(ioaddr, i, dev); 617 618 printk(KERN_DEBUG "Checksum: %#x\n",j&0xffff); 619 620 Word = lp->word[0]; 621 printk(KERN_DEBUG "Word0:\n"); 622 printk(KERN_DEBUG " Plug 'n Pray: %d\n",GetBit(Word,ee_PnP)); 623 printk(KERN_DEBUG " Buswidth: %d\n",(GetBit(Word,ee_BusWidth)+1)*8 ); 624 printk(KERN_DEBUG " AutoNegotiation: %d\n",GetBit(Word,ee_AutoNeg)); 625 printk(KERN_DEBUG " IO Address: %#x\n", (Word>>ee_IO0)<<4); 626 627 if (net_debug>4) { 628 Word = lp->word[1]; 629 printk(KERN_DEBUG "Word1:\n"); 630 printk(KERN_DEBUG " INT: %d\n", Word & ee_IntMask); 631 printk(KERN_DEBUG " LI: %d\n", GetBit(Word,ee_LI)); 632 printk(KERN_DEBUG " PC: %d\n", GetBit(Word,ee_PC)); 633 printk(KERN_DEBUG " TPE/AUI: %d\n", GetBit(Word,ee_TPE_AUI)); 634 printk(KERN_DEBUG " Jabber: %d\n", GetBit(Word,ee_Jabber)); 635 printk(KERN_DEBUG " AutoPort: %d\n", !GetBit(Word,ee_AutoPort)); 636 printk(KERN_DEBUG " Duplex: %d\n", GetBit(Word,ee_Duplex)); 637 } 638 639 Word = lp->word[5]; 640 printk(KERN_DEBUG "Word5:\n"); 641 printk(KERN_DEBUG " BNC: %d\n",GetBit(Word,ee_BNC_TPE)); 642 printk(KERN_DEBUG " NumConnectors: %d\n",GetBit(Word,ee_NumConn)); 643 printk(KERN_DEBUG " Has "); 644 if (GetBit(Word,ee_PortTPE)) printk(KERN_DEBUG "TPE "); 645 if (GetBit(Word,ee_PortBNC)) printk(KERN_DEBUG "BNC "); 646 if (GetBit(Word,ee_PortAUI)) printk(KERN_DEBUG "AUI "); 647 printk(KERN_DEBUG "port(s)\n"); 648 649 Word = lp->word[6]; 650 printk(KERN_DEBUG "Word6:\n"); 651 printk(KERN_DEBUG " Stepping: %d\n",Word & ee_StepMask); 652 printk(KERN_DEBUG " BoardID: %d\n",Word>>ee_BoardID); 653 654 Word = lp->word[7]; 655 printk(KERN_DEBUG "Word7:\n"); 656 printk(KERN_DEBUG " INT to IRQ:\n"); 657 658 for (i=0, j=0; i<15; i++) 659 if (GetBit(Word,i)) printk(KERN_DEBUG " INT%d -> IRQ %d;",j++,i); 660 661 printk(KERN_DEBUG "\n"); 662} 663 664/* function to recalculate the limits of buffer based on rcv_ram */ 665static void eepro_recalc (struct net_device *dev) 666{ 667 struct eepro_local * lp; 668 669 lp = netdev_priv(dev); 670 lp->xmt_ram = RAM_SIZE - lp->rcv_ram; 671 672 if (lp->eepro == LAN595FX_10ISA) { 673 lp->xmt_lower_limit = XMT_START_10; 674 lp->xmt_upper_limit = (lp->xmt_ram - 2); 675 lp->rcv_lower_limit = lp->xmt_ram; 676 lp->rcv_upper_limit = (RAM_SIZE - 2); 677 } 678 else { 679 lp->rcv_lower_limit = RCV_START_PRO; 680 lp->rcv_upper_limit = (lp->rcv_ram - 2); 681 lp->xmt_lower_limit = lp->rcv_ram; 682 lp->xmt_upper_limit = (RAM_SIZE - 2); 683 } 684} 685 686/* prints boot-time info */ 687static void __init eepro_print_info (struct net_device *dev) 688{ 689 struct eepro_local * lp = netdev_priv(dev); 690 int i; 691 const char * ifmap[] = {"AUI", "10Base2", "10BaseT"}; 692 693 i = inb(dev->base_addr + ID_REG); 694 printk(KERN_DEBUG " id: %#x ",i); 695 printk(" io: %#x ", (unsigned)dev->base_addr); 696 697 switch (lp->eepro) { 698 case LAN595FX_10ISA: 699 printk("%s: Intel EtherExpress 10 ISA\n at %#x,", 700 dev->name, (unsigned)dev->base_addr); 701 break; 702 case LAN595FX: 703 printk("%s: Intel EtherExpress Pro/10+ ISA\n at %#x,", 704 dev->name, (unsigned)dev->base_addr); 705 break; 706 case LAN595TX: 707 printk("%s: Intel EtherExpress Pro/10 ISA at %#x,", 708 dev->name, (unsigned)dev->base_addr); 709 break; 710 case LAN595: 711 printk("%s: Intel 82595-based lan card at %#x,", 712 dev->name, (unsigned)dev->base_addr); 713 break; 714 } 715 716 printk(" %pM", dev->dev_addr); 717 718 if (net_debug > 3) 719 printk(KERN_DEBUG ", %dK RCV buffer", 720 (int)(lp->rcv_ram)/1024); 721 722 if (dev->irq > 2) 723 printk(", IRQ %d, %s.\n", dev->irq, ifmap[dev->if_port]); 724 else 725 printk(", %s.\n", ifmap[dev->if_port]); 726 727 if (net_debug > 3) { 728 i = lp->word[5]; 729 if (i & 0x2000) /* bit 13 of EEPROM word 5 */ 730 printk(KERN_DEBUG "%s: Concurrent Processing is " 731 "enabled but not used!\n", dev->name); 732 } 733 734 /* Check the station address for the manufacturer's code */ 735 if (net_debug>3) 736 printEEPROMInfo(dev); 737} 738 739static const struct ethtool_ops eepro_ethtool_ops; 740 741static const struct net_device_ops eepro_netdev_ops = { 742 .ndo_open = eepro_open, 743 .ndo_stop = eepro_close, 744 .ndo_start_xmit = eepro_send_packet, 745 .ndo_set_multicast_list = set_multicast_list, 746 .ndo_tx_timeout = eepro_tx_timeout, 747 .ndo_change_mtu = eth_change_mtu, 748 .ndo_set_mac_address = eth_mac_addr, 749 .ndo_validate_addr = eth_validate_addr, 750}; 751 752/* This is the real probe routine. Linux has a history of friendly device 753 probes on the ISA bus. A good device probe avoids doing writes, and 754 verifies that the correct device exists and functions. */ 755 756static int __init eepro_probe1(struct net_device *dev, int autoprobe) 757{ 758 unsigned short station_addr[3], id, counter; 759 int i; 760 struct eepro_local *lp; 761 int ioaddr = dev->base_addr; 762 int err; 763 764 /* Grab the region so we can find another board if autoIRQ fails. */ 765 if (!request_region(ioaddr, EEPRO_IO_EXTENT, DRV_NAME)) { 766 if (!autoprobe) 767 printk(KERN_WARNING "EEPRO: io-port 0x%04x in use\n", 768 ioaddr); 769 return -EBUSY; 770 } 771 772 /* Now, we are going to check for the signature of the 773 ID_REG (register 2 of bank 0) */ 774 775 id = inb(ioaddr + ID_REG); 776 777 if ((id & ID_REG_MASK) != ID_REG_SIG) 778 goto exit; 779 780 /* We seem to have the 82595 signature, let's 781 play with its counter (last 2 bits of 782 register 2 of bank 0) to be sure. */ 783 784 counter = id & R_ROBIN_BITS; 785 786 if ((inb(ioaddr + ID_REG) & R_ROBIN_BITS) != (counter + 0x40)) 787 goto exit; 788 789 lp = netdev_priv(dev); 790 memset(lp, 0, sizeof(struct eepro_local)); 791 lp->xmt_bar = XMT_BAR_PRO; 792 lp->xmt_lower_limit_reg = XMT_LOWER_LIMIT_REG_PRO; 793 lp->xmt_upper_limit_reg = XMT_UPPER_LIMIT_REG_PRO; 794 lp->eeprom_reg = EEPROM_REG_PRO; 795 spin_lock_init(&lp->lock); 796 797 /* Now, get the ethernet hardware address from 798 the EEPROM */ 799 station_addr[0] = read_eeprom(ioaddr, 2, dev); 800 801 if (station_addr[0] == 0x0000 || station_addr[0] == 0xffff) { 802 lp->eepro = LAN595FX_10ISA; 803 lp->eeprom_reg = EEPROM_REG_10; 804 lp->xmt_lower_limit_reg = XMT_LOWER_LIMIT_REG_10; 805 lp->xmt_upper_limit_reg = XMT_UPPER_LIMIT_REG_10; 806 lp->xmt_bar = XMT_BAR_10; 807 station_addr[0] = read_eeprom(ioaddr, 2, dev); 808 } 809 810 /* get all words at once. will be used here and for ethtool */ 811 for (i = 0; i < 8; i++) { 812 lp->word[i] = read_eeprom(ioaddr, i, dev); 813 } 814 station_addr[1] = lp->word[3]; 815 station_addr[2] = lp->word[4]; 816 817 if (!lp->eepro) { 818 if (lp->word[7] == ee_FX_INT2IRQ) 819 lp->eepro = 2; 820 else if (station_addr[2] == SA_ADDR1) 821 lp->eepro = 1; 822 } 823 824 /* Fill in the 'dev' fields. */ 825 for (i=0; i < 6; i++) 826 dev->dev_addr[i] = ((unsigned char *) station_addr)[5-i]; 827 828 /* RX buffer must be more than 3K and less than 29K */ 829 if (dev->mem_end < 3072 || dev->mem_end > 29696) 830 lp->rcv_ram = RCV_DEFAULT_RAM; 831 832 /* calculate {xmt,rcv}_{lower,upper}_limit */ 833 eepro_recalc(dev); 834 835 if (GetBit(lp->word[5], ee_BNC_TPE)) 836 dev->if_port = BNC; 837 else 838 dev->if_port = TPE; 839 840 if (dev->irq < 2 && lp->eepro != 0) { 841 /* Mask off INT number */ 842 int count = lp->word[1] & 7; 843 unsigned irqMask = lp->word[7]; 844 845 while (count--) 846 irqMask &= irqMask - 1; 847 848 count = ffs(irqMask); 849 850 if (count) 851 dev->irq = count - 1; 852 853 if (dev->irq < 2) { 854 printk(KERN_ERR " Duh! illegal interrupt vector stored in EEPROM.\n"); 855 goto exit; 856 } else if (dev->irq == 2) { 857 dev->irq = 9; 858 } 859 } 860 861 dev->netdev_ops = &eepro_netdev_ops; 862 dev->watchdog_timeo = TX_TIMEOUT; 863 dev->ethtool_ops = &eepro_ethtool_ops; 864 865 /* print boot time info */ 866 eepro_print_info(dev); 867 868 /* reset 82595 */ 869 eepro_reset(ioaddr); 870 871 err = register_netdev(dev); 872 if (err) 873 goto err; 874 return 0; 875exit: 876 err = -ENODEV; 877err: 878 release_region(dev->base_addr, EEPRO_IO_EXTENT); 879 return err; 880} 881 882/* Open/initialize the board. This is called (in the current kernel) 883 sometime after booting when the 'ifconfig' program is run. 884 885 This routine should set everything up anew at each open, even 886 registers that "should" only need to be set once at boot, so that 887 there is non-reboot way to recover if something goes wrong. 888 */ 889 890static char irqrmap[] = {-1,-1,0,1,-1,2,-1,-1,-1,0,3,4,-1,-1,-1,-1}; 891static char irqrmap2[] = {-1,-1,4,0,1,2,-1,3,-1,4,5,6,7,-1,-1,-1}; 892static int eepro_grab_irq(struct net_device *dev) 893{ 894 int irqlist[] = { 3, 4, 5, 7, 9, 10, 11, 12, 0 }; 895 int *irqp = irqlist, temp_reg, ioaddr = dev->base_addr; 896 897 eepro_sw2bank1(ioaddr); /* be CAREFUL, BANK 1 now */ 898 899 /* Enable the interrupt line. */ 900 eepro_en_intline(ioaddr); 901 902 /* be CAREFUL, BANK 0 now */ 903 eepro_sw2bank0(ioaddr); 904 905 /* clear all interrupts */ 906 eepro_clear_int(ioaddr); 907 908 /* Let EXEC event to interrupt */ 909 eepro_en_intexec(ioaddr); 910 911 do { 912 eepro_sw2bank1(ioaddr); /* be CAREFUL, BANK 1 now */ 913 914 temp_reg = inb(ioaddr + INT_NO_REG); 915 outb((temp_reg & 0xf8) | irqrmap[*irqp], ioaddr + INT_NO_REG); 916 917 eepro_sw2bank0(ioaddr); /* Switch back to Bank 0 */ 918 919 if (request_irq (*irqp, NULL, IRQF_SHARED, "bogus", dev) != EBUSY) { 920 unsigned long irq_mask; 921 /* Twinkle the interrupt, and check if it's seen */ 922 irq_mask = probe_irq_on(); 923 924 eepro_diag(ioaddr); /* RESET the 82595 */ 925 mdelay(20); 926 927 if (*irqp == probe_irq_off(irq_mask)) /* It's a good IRQ line */ 928 break; 929 930 /* clear all interrupts */ 931 eepro_clear_int(ioaddr); 932 } 933 } while (*++irqp); 934 935 eepro_sw2bank1(ioaddr); /* Switch back to Bank 1 */ 936 937 /* Disable the physical interrupt line. */ 938 eepro_dis_intline(ioaddr); 939 940 eepro_sw2bank0(ioaddr); /* Switch back to Bank 0 */ 941 942 /* Mask all the interrupts. */ 943 eepro_dis_int(ioaddr); 944 945 /* clear all interrupts */ 946 eepro_clear_int(ioaddr); 947 948 return dev->irq; 949} 950 951static int eepro_open(struct net_device *dev) 952{ 953 unsigned short temp_reg, old8, old9; 954 int irqMask; 955 int i, ioaddr = dev->base_addr; 956 struct eepro_local *lp = netdev_priv(dev); 957 958 if (net_debug > 3) 959 printk(KERN_DEBUG "%s: entering eepro_open routine.\n", dev->name); 960 961 irqMask = lp->word[7]; 962 963 if (lp->eepro == LAN595FX_10ISA) { 964 if (net_debug > 3) printk(KERN_DEBUG "p->eepro = 3;\n"); 965 } 966 else if (irqMask == ee_FX_INT2IRQ) /* INT to IRQ Mask */ 967 { 968 lp->eepro = 2; /* Yes, an Intel EtherExpress Pro/10+ */ 969 if (net_debug > 3) printk(KERN_DEBUG "p->eepro = 2;\n"); 970 } 971 972 else if ((dev->dev_addr[0] == SA_ADDR0 && 973 dev->dev_addr[1] == SA_ADDR1 && 974 dev->dev_addr[2] == SA_ADDR2)) 975 { 976 lp->eepro = 1; 977 if (net_debug > 3) printk(KERN_DEBUG "p->eepro = 1;\n"); 978 } /* Yes, an Intel EtherExpress Pro/10 */ 979 980 else lp->eepro = 0; /* No, it is a generic 82585 lan card */ 981 982 /* Get the interrupt vector for the 82595 */ 983 if (dev->irq < 2 && eepro_grab_irq(dev) == 0) { 984 printk(KERN_ERR "%s: unable to get IRQ %d.\n", dev->name, dev->irq); 985 return -EAGAIN; 986 } 987 988 if (request_irq(dev->irq , eepro_interrupt, 0, dev->name, dev)) { 989 printk(KERN_ERR "%s: unable to get IRQ %d.\n", dev->name, dev->irq); 990 return -EAGAIN; 991 } 992 993 /* Initialize the 82595. */ 994 995 eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */ 996 temp_reg = inb(ioaddr + lp->eeprom_reg); 997 998 lp->stepping = temp_reg >> 5; /* Get the stepping number of the 595 */ 999 1000 if (net_debug > 3) 1001 printk(KERN_DEBUG "The stepping of the 82595 is %d\n", lp->stepping); 1002 1003 if (temp_reg & 0x10) /* Check the TurnOff Enable bit */ 1004 outb(temp_reg & 0xef, ioaddr + lp->eeprom_reg); 1005 for (i=0; i < 6; i++) 1006 outb(dev->dev_addr[i] , ioaddr + I_ADD_REG0 + i); 1007 1008 temp_reg = inb(ioaddr + REG1); /* Setup Transmit Chaining */ 1009 outb(temp_reg | XMT_Chain_Int | XMT_Chain_ErrStop /* and discard bad RCV frames */ 1010 | RCV_Discard_BadFrame, ioaddr + REG1); 1011 1012 temp_reg = inb(ioaddr + REG2); /* Match broadcast */ 1013 outb(temp_reg | 0x14, ioaddr + REG2); 1014 1015 temp_reg = inb(ioaddr + REG3); 1016 outb(temp_reg & 0x3f, ioaddr + REG3); /* clear test mode */ 1017 1018 /* Set the receiving mode */ 1019 eepro_sw2bank1(ioaddr); /* be CAREFUL, BANK 1 now */ 1020 1021 /* Set the interrupt vector */ 1022 temp_reg = inb(ioaddr + INT_NO_REG); 1023 if (lp->eepro == LAN595FX || lp->eepro == LAN595FX_10ISA) 1024 outb((temp_reg & 0xf8) | irqrmap2[dev->irq], ioaddr + INT_NO_REG); 1025 else outb((temp_reg & 0xf8) | irqrmap[dev->irq], ioaddr + INT_NO_REG); 1026 1027 1028 temp_reg = inb(ioaddr + INT_NO_REG); 1029 if (lp->eepro == LAN595FX || lp->eepro == LAN595FX_10ISA) 1030 outb((temp_reg & 0xf0) | irqrmap2[dev->irq] | 0x08,ioaddr+INT_NO_REG); 1031 else outb((temp_reg & 0xf8) | irqrmap[dev->irq], ioaddr + INT_NO_REG); 1032 1033 if (net_debug > 3) 1034 printk(KERN_DEBUG "eepro_open: content of INT Reg is %x\n", temp_reg); 1035 1036 1037 /* Initialize the RCV and XMT upper and lower limits */ 1038 outb(lp->rcv_lower_limit >> 8, ioaddr + RCV_LOWER_LIMIT_REG); 1039 outb(lp->rcv_upper_limit >> 8, ioaddr + RCV_UPPER_LIMIT_REG); 1040 outb(lp->xmt_lower_limit >> 8, ioaddr + lp->xmt_lower_limit_reg); 1041 outb(lp->xmt_upper_limit >> 8, ioaddr + lp->xmt_upper_limit_reg); 1042 1043 /* Enable the interrupt line. */ 1044 eepro_en_intline(ioaddr); 1045 1046 /* Switch back to Bank 0 */ 1047 eepro_sw2bank0(ioaddr); 1048 1049 /* Let RX and TX events to interrupt */ 1050 eepro_en_int(ioaddr); 1051 1052 /* clear all interrupts */ 1053 eepro_clear_int(ioaddr); 1054 1055 /* Initialize RCV */ 1056 outw(lp->rcv_lower_limit, ioaddr + RCV_BAR); 1057 lp->rx_start = lp->rcv_lower_limit; 1058 outw(lp->rcv_upper_limit | 0xfe, ioaddr + RCV_STOP); 1059 1060 /* Initialize XMT */ 1061 outw(lp->xmt_lower_limit, ioaddr + lp->xmt_bar); 1062 lp->tx_start = lp->tx_end = lp->xmt_lower_limit; 1063 lp->tx_last = 0; 1064 1065 /* Check for the i82595TX and i82595FX */ 1066 old8 = inb(ioaddr + 8); 1067 outb(~old8, ioaddr + 8); 1068 1069 if ((temp_reg = inb(ioaddr + 8)) == old8) { 1070 if (net_debug > 3) 1071 printk(KERN_DEBUG "i82595 detected!\n"); 1072 lp->version = LAN595; 1073 } 1074 else { 1075 lp->version = LAN595TX; 1076 outb(old8, ioaddr + 8); 1077 old9 = inb(ioaddr + 9); 1078 1079 if (irqMask==ee_FX_INT2IRQ) { 1080 if (net_debug > 3) { 1081 printk(KERN_DEBUG "IrqMask: %#x\n",irqMask); 1082 printk(KERN_DEBUG "i82595FX detected!\n"); 1083 } 1084 lp->version = LAN595FX; 1085 outb(old9, ioaddr + 9); 1086 if (dev->if_port != TPE) { /* Hopefully, this will fix the 1087 problem of using Pentiums and 1088 pro/10 w/ BNC. */ 1089 eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */ 1090 temp_reg = inb(ioaddr + REG13); 1091 /* disable the full duplex mode since it is not 1092 applicable with the 10Base2 cable. */ 1093 outb(temp_reg & ~(FDX | A_N_ENABLE), REG13); 1094 eepro_sw2bank0(ioaddr); /* be CAREFUL, BANK 0 now */ 1095 } 1096 } 1097 else if (net_debug > 3) { 1098 printk(KERN_DEBUG "temp_reg: %#x ~old9: %#x\n",temp_reg,((~old9)&0xff)); 1099 printk(KERN_DEBUG "i82595TX detected!\n"); 1100 } 1101 } 1102 1103 eepro_sel_reset(ioaddr); 1104 1105 netif_start_queue(dev); 1106 1107 if (net_debug > 3) 1108 printk(KERN_DEBUG "%s: exiting eepro_open routine.\n", dev->name); 1109 1110 /* enabling rx */ 1111 eepro_en_rx(ioaddr); 1112 1113 return 0; 1114} 1115 1116static void eepro_tx_timeout (struct net_device *dev) 1117{ 1118 struct eepro_local *lp = netdev_priv(dev); 1119 int ioaddr = dev->base_addr; 1120 1121 /* if (net_debug > 1) */ 1122 printk (KERN_ERR "%s: transmit timed out, %s?\n", dev->name, 1123 "network cable problem"); 1124 /* This is not a duplicate. One message for the console, 1125 one for the log file */ 1126 printk (KERN_DEBUG "%s: transmit timed out, %s?\n", dev->name, 1127 "network cable problem"); 1128 eepro_complete_selreset(ioaddr); 1129} 1130 1131 1132static netdev_tx_t eepro_send_packet(struct sk_buff *skb, 1133 struct net_device *dev) 1134{ 1135 struct eepro_local *lp = netdev_priv(dev); 1136 unsigned long flags; 1137 int ioaddr = dev->base_addr; 1138 short length = skb->len; 1139 1140 if (net_debug > 5) 1141 printk(KERN_DEBUG "%s: entering eepro_send_packet routine.\n", dev->name); 1142 1143 if (length < ETH_ZLEN) { 1144 if (skb_padto(skb, ETH_ZLEN)) 1145 return NETDEV_TX_OK; 1146 length = ETH_ZLEN; 1147 } 1148 netif_stop_queue (dev); 1149 1150 eepro_dis_int(ioaddr); 1151 spin_lock_irqsave(&lp->lock, flags); 1152 1153 { 1154 unsigned char *buf = skb->data; 1155 1156 if (hardware_send_packet(dev, buf, length)) 1157 /* we won't wake queue here because we're out of space */ 1158 dev->stats.tx_dropped++; 1159 else { 1160 dev->stats.tx_bytes+=skb->len; 1161 netif_wake_queue(dev); 1162 } 1163 1164 } 1165 1166 dev_kfree_skb (skb); 1167 1168 /* You might need to clean up and record Tx statistics here. */ 1169 /* dev->stats.tx_aborted_errors++; */ 1170 1171 if (net_debug > 5) 1172 printk(KERN_DEBUG "%s: exiting eepro_send_packet routine.\n", dev->name); 1173 1174 eepro_en_int(ioaddr); 1175 spin_unlock_irqrestore(&lp->lock, flags); 1176 1177 return NETDEV_TX_OK; 1178} 1179 1180 1181/* The typical workload of the driver: 1182 Handle the network interface interrupts. */ 1183 1184static irqreturn_t 1185eepro_interrupt(int irq, void *dev_id) 1186{ 1187 struct net_device *dev = dev_id; 1188 struct eepro_local *lp; 1189 int ioaddr, status, boguscount = 20; 1190 int handled = 0; 1191 1192 lp = netdev_priv(dev); 1193 1194 spin_lock(&lp->lock); 1195 1196 if (net_debug > 5) 1197 printk(KERN_DEBUG "%s: entering eepro_interrupt routine.\n", dev->name); 1198 1199 ioaddr = dev->base_addr; 1200 1201 while (((status = inb(ioaddr + STATUS_REG)) & (RX_INT|TX_INT)) && (boguscount--)) 1202 { 1203 handled = 1; 1204 if (status & RX_INT) { 1205 if (net_debug > 4) 1206 printk(KERN_DEBUG "%s: packet received interrupt.\n", dev->name); 1207 1208 eepro_dis_int(ioaddr); 1209 1210 /* Get the received packets */ 1211 eepro_ack_rx(ioaddr); 1212 eepro_rx(dev); 1213 1214 eepro_en_int(ioaddr); 1215 } 1216 if (status & TX_INT) { 1217 if (net_debug > 4) 1218 printk(KERN_DEBUG "%s: packet transmit interrupt.\n", dev->name); 1219 1220 1221 eepro_dis_int(ioaddr); 1222 1223 /* Process the status of transmitted packets */ 1224 eepro_ack_tx(ioaddr); 1225 eepro_transmit_interrupt(dev); 1226 1227 eepro_en_int(ioaddr); 1228 } 1229 } 1230 1231 if (net_debug > 5) 1232 printk(KERN_DEBUG "%s: exiting eepro_interrupt routine.\n", dev->name); 1233 1234 spin_unlock(&lp->lock); 1235 return IRQ_RETVAL(handled); 1236} 1237 1238static int eepro_close(struct net_device *dev) 1239{ 1240 struct eepro_local *lp = netdev_priv(dev); 1241 int ioaddr = dev->base_addr; 1242 short temp_reg; 1243 1244 netif_stop_queue(dev); 1245 1246 eepro_sw2bank1(ioaddr); /* Switch back to Bank 1 */ 1247 1248 /* Disable the physical interrupt line. */ 1249 temp_reg = inb(ioaddr + REG1); 1250 outb(temp_reg & 0x7f, ioaddr + REG1); 1251 1252 eepro_sw2bank0(ioaddr); /* Switch back to Bank 0 */ 1253 1254 /* Flush the Tx and disable Rx. */ 1255 outb(STOP_RCV_CMD, ioaddr); 1256 lp->tx_start = lp->tx_end = lp->xmt_lower_limit; 1257 lp->tx_last = 0; 1258 1259 /* Mask all the interrupts. */ 1260 eepro_dis_int(ioaddr); 1261 1262 /* clear all interrupts */ 1263 eepro_clear_int(ioaddr); 1264 1265 /* Reset the 82595 */ 1266 eepro_reset(ioaddr); 1267 1268 /* release the interrupt */ 1269 free_irq(dev->irq, dev); 1270 1271 /* Update the statistics here. What statistics? */ 1272 1273 return 0; 1274} 1275 1276/* Set or clear the multicast filter for this adaptor. 1277 */ 1278static void 1279set_multicast_list(struct net_device *dev) 1280{ 1281 struct eepro_local *lp = netdev_priv(dev); 1282 short ioaddr = dev->base_addr; 1283 unsigned short mode; 1284 struct netdev_hw_addr *ha; 1285 int mc_count = netdev_mc_count(dev); 1286 1287 if (dev->flags&(IFF_ALLMULTI|IFF_PROMISC) || mc_count > 63) 1288 { 1289 eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */ 1290 mode = inb(ioaddr + REG2); 1291 outb(mode | PRMSC_Mode, ioaddr + REG2); 1292 mode = inb(ioaddr + REG3); 1293 outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */ 1294 eepro_sw2bank0(ioaddr); /* Return to BANK 0 now */ 1295 } 1296 1297 else if (mc_count == 0) 1298 { 1299 eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */ 1300 mode = inb(ioaddr + REG2); 1301 outb(mode & 0xd6, ioaddr + REG2); /* Turn off Multi-IA and PRMSC_Mode bits */ 1302 mode = inb(ioaddr + REG3); 1303 outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */ 1304 eepro_sw2bank0(ioaddr); /* Return to BANK 0 now */ 1305 } 1306 1307 else 1308 { 1309 unsigned short status, *eaddrs; 1310 int i, boguscount = 0; 1311 1312 /* Disable RX and TX interrupts. Necessary to avoid 1313 corruption of the HOST_ADDRESS_REG by interrupt 1314 service routines. */ 1315 eepro_dis_int(ioaddr); 1316 1317 eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */ 1318 mode = inb(ioaddr + REG2); 1319 outb(mode | Multi_IA, ioaddr + REG2); 1320 mode = inb(ioaddr + REG3); 1321 outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */ 1322 eepro_sw2bank0(ioaddr); /* Return to BANK 0 now */ 1323 outw(lp->tx_end, ioaddr + HOST_ADDRESS_REG); 1324 outw(MC_SETUP, ioaddr + IO_PORT); 1325 outw(0, ioaddr + IO_PORT); 1326 outw(0, ioaddr + IO_PORT); 1327 outw(6 * (mc_count + 1), ioaddr + IO_PORT); 1328 1329 netdev_for_each_mc_addr(ha, dev) { 1330 eaddrs = (unsigned short *) ha->addr; 1331 outw(*eaddrs++, ioaddr + IO_PORT); 1332 outw(*eaddrs++, ioaddr + IO_PORT); 1333 outw(*eaddrs++, ioaddr + IO_PORT); 1334 } 1335 1336 eaddrs = (unsigned short *) dev->dev_addr; 1337 outw(eaddrs[0], ioaddr + IO_PORT); 1338 outw(eaddrs[1], ioaddr + IO_PORT); 1339 outw(eaddrs[2], ioaddr + IO_PORT); 1340 outw(lp->tx_end, ioaddr + lp->xmt_bar); 1341 outb(MC_SETUP, ioaddr); 1342 1343 /* Update the transmit queue */ 1344 i = lp->tx_end + XMT_HEADER + 6 * (mc_count + 1); 1345 1346 if (lp->tx_start != lp->tx_end) 1347 { 1348 /* update the next address and the chain bit in the 1349 last packet */ 1350 outw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG); 1351 outw(i, ioaddr + IO_PORT); 1352 outw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG); 1353 status = inw(ioaddr + IO_PORT); 1354 outw(status | CHAIN_BIT, ioaddr + IO_PORT); 1355 lp->tx_end = i ; 1356 } 1357 else { 1358 lp->tx_start = lp->tx_end = i ; 1359 } 1360 1361 /* Acknowledge that the MC setup is done */ 1362 do { /* We should be doing this in the eepro_interrupt()! */ 1363 SLOW_DOWN; 1364 SLOW_DOWN; 1365 if (inb(ioaddr + STATUS_REG) & 0x08) 1366 { 1367 i = inb(ioaddr); 1368 outb(0x08, ioaddr + STATUS_REG); 1369 1370 if (i & 0x20) { /* command ABORTed */ 1371 printk(KERN_NOTICE "%s: multicast setup failed.\n", 1372 dev->name); 1373 break; 1374 } else if ((i & 0x0f) == 0x03) { /* MC-Done */ 1375 printk(KERN_DEBUG "%s: set Rx mode to %d address%s.\n", 1376 dev->name, mc_count, 1377 mc_count > 1 ? "es":""); 1378 break; 1379 } 1380 } 1381 } while (++boguscount < 100); 1382 1383 /* Re-enable RX and TX interrupts */ 1384 eepro_en_int(ioaddr); 1385 } 1386 if (lp->eepro == LAN595FX_10ISA) { 1387 eepro_complete_selreset(ioaddr); 1388 } 1389 else 1390 eepro_en_rx(ioaddr); 1391} 1392 1393/* The horrible routine to read a word from the serial EEPROM. */ 1394/* IMPORTANT - the 82595 will be set to Bank 0 after the eeprom is read */ 1395 1396/* The delay between EEPROM clock transitions. */ 1397#define eeprom_delay() { udelay(40); } 1398#define EE_READ_CMD (6 << 6) 1399 1400static int 1401read_eeprom(int ioaddr, int location, struct net_device *dev) 1402{ 1403 int i; 1404 unsigned short retval = 0; 1405 struct eepro_local *lp = netdev_priv(dev); 1406 short ee_addr = ioaddr + lp->eeprom_reg; 1407 int read_cmd = location | EE_READ_CMD; 1408 short ctrl_val = EECS ; 1409 1410 eepro_sw2bank1(ioaddr); 1411 outb(0x00, ioaddr + STATUS_REG); 1412 1413 eepro_sw2bank2(ioaddr); 1414 outb(ctrl_val, ee_addr); 1415 1416 /* Shift the read command bits out. */ 1417 for (i = 8; i >= 0; i--) { 1418 short outval = (read_cmd & (1 << i)) ? ctrl_val | EEDI 1419 : ctrl_val; 1420 outb(outval, ee_addr); 1421 outb(outval | EESK, ee_addr); /* EEPROM clock tick. */ 1422 eeprom_delay(); 1423 outb(outval, ee_addr); /* Finish EEPROM a clock tick. */ 1424 eeprom_delay(); 1425 } 1426 outb(ctrl_val, ee_addr); 1427 1428 for (i = 16; i > 0; i--) { 1429 outb(ctrl_val | EESK, ee_addr); eeprom_delay(); 1430 retval = (retval << 1) | ((inb(ee_addr) & EEDO) ? 1 : 0); 1431 outb(ctrl_val, ee_addr); eeprom_delay(); 1432 } 1433 1434 /* Terminate the EEPROM access. */ 1435 ctrl_val &= ~EECS; 1436 outb(ctrl_val | EESK, ee_addr); 1437 eeprom_delay(); 1438 outb(ctrl_val, ee_addr); 1439 eeprom_delay(); 1440 eepro_sw2bank0(ioaddr); 1441 return retval; 1442} 1443 1444static int 1445hardware_send_packet(struct net_device *dev, void *buf, short length) 1446{ 1447 struct eepro_local *lp = netdev_priv(dev); 1448 short ioaddr = dev->base_addr; 1449 unsigned status, tx_available, last, end; 1450 1451 if (net_debug > 5) 1452 printk(KERN_DEBUG "%s: entering hardware_send_packet routine.\n", dev->name); 1453 1454 /* determine how much of the transmit buffer space is available */ 1455 if (lp->tx_end > lp->tx_start) 1456 tx_available = lp->xmt_ram - (lp->tx_end - lp->tx_start); 1457 else if (lp->tx_end < lp->tx_start) 1458 tx_available = lp->tx_start - lp->tx_end; 1459 else tx_available = lp->xmt_ram; 1460 1461 if (((((length + 3) >> 1) << 1) + 2*XMT_HEADER) >= tx_available) { 1462 /* No space available ??? */ 1463 return 1; 1464 } 1465 1466 last = lp->tx_end; 1467 end = last + (((length + 3) >> 1) << 1) + XMT_HEADER; 1468 1469 if (end >= lp->xmt_upper_limit + 2) { /* the transmit buffer is wrapped around */ 1470 if ((lp->xmt_upper_limit + 2 - last) <= XMT_HEADER) { 1471 /* Arrrr!!!, must keep the xmt header together, 1472 several days were lost to chase this one down. */ 1473 last = lp->xmt_lower_limit; 1474 end = last + (((length + 3) >> 1) << 1) + XMT_HEADER; 1475 } 1476 else end = lp->xmt_lower_limit + (end - 1477 lp->xmt_upper_limit + 2); 1478 } 1479 1480 outw(last, ioaddr + HOST_ADDRESS_REG); 1481 outw(XMT_CMD, ioaddr + IO_PORT); 1482 outw(0, ioaddr + IO_PORT); 1483 outw(end, ioaddr + IO_PORT); 1484 outw(length, ioaddr + IO_PORT); 1485 1486 if (lp->version == LAN595) 1487 outsw(ioaddr + IO_PORT, buf, (length + 3) >> 1); 1488 else { /* LAN595TX or LAN595FX, capable of 32-bit I/O processing */ 1489 unsigned short temp = inb(ioaddr + INT_MASK_REG); 1490 outb(temp | IO_32_BIT, ioaddr + INT_MASK_REG); 1491 outsl(ioaddr + IO_PORT_32_BIT, buf, (length + 3) >> 2); 1492 outb(temp & ~(IO_32_BIT), ioaddr + INT_MASK_REG); 1493 } 1494 1495 /* A dummy read to flush the DRAM write pipeline */ 1496 status = inw(ioaddr + IO_PORT); 1497 1498 if (lp->tx_start == lp->tx_end) { 1499 outw(last, ioaddr + lp->xmt_bar); 1500 outb(XMT_CMD, ioaddr); 1501 lp->tx_start = last; /* I don't like to change tx_start here */ 1502 } 1503 else { 1504 /* update the next address and the chain bit in the 1505 last packet */ 1506 1507 if (lp->tx_end != last) { 1508 outw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG); 1509 outw(last, ioaddr + IO_PORT); 1510 } 1511 1512 outw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG); 1513 status = inw(ioaddr + IO_PORT); 1514 outw(status | CHAIN_BIT, ioaddr + IO_PORT); 1515 1516 /* Continue the transmit command */ 1517 outb(RESUME_XMT_CMD, ioaddr); 1518 } 1519 1520 lp->tx_last = last; 1521 lp->tx_end = end; 1522 1523 if (net_debug > 5) 1524 printk(KERN_DEBUG "%s: exiting hardware_send_packet routine.\n", dev->name); 1525 1526 return 0; 1527} 1528 1529static void 1530eepro_rx(struct net_device *dev) 1531{ 1532 struct eepro_local *lp = netdev_priv(dev); 1533 short ioaddr = dev->base_addr; 1534 short boguscount = 20; 1535 short rcv_car = lp->rx_start; 1536 unsigned rcv_event, rcv_status, rcv_next_frame, rcv_size; 1537 1538 if (net_debug > 5) 1539 printk(KERN_DEBUG "%s: entering eepro_rx routine.\n", dev->name); 1540 1541 /* Set the read pointer to the start of the RCV */ 1542 outw(rcv_car, ioaddr + HOST_ADDRESS_REG); 1543 1544 rcv_event = inw(ioaddr + IO_PORT); 1545 1546 while (rcv_event == RCV_DONE) { 1547 1548 rcv_status = inw(ioaddr + IO_PORT); 1549 rcv_next_frame = inw(ioaddr + IO_PORT); 1550 rcv_size = inw(ioaddr + IO_PORT); 1551 1552 if ((rcv_status & (RX_OK | RX_ERROR)) == RX_OK) { 1553 1554 /* Malloc up new buffer. */ 1555 struct sk_buff *skb; 1556 1557 dev->stats.rx_bytes+=rcv_size; 1558 rcv_size &= 0x3fff; 1559 skb = dev_alloc_skb(rcv_size+5); 1560 if (skb == NULL) { 1561 printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name); 1562 dev->stats.rx_dropped++; 1563 rcv_car = lp->rx_start + RCV_HEADER + rcv_size; 1564 lp->rx_start = rcv_next_frame; 1565 outw(rcv_next_frame, ioaddr + HOST_ADDRESS_REG); 1566 1567 break; 1568 } 1569 skb_reserve(skb,2); 1570 1571 if (lp->version == LAN595) 1572 insw(ioaddr+IO_PORT, skb_put(skb,rcv_size), (rcv_size + 3) >> 1); 1573 else { /* LAN595TX or LAN595FX, capable of 32-bit I/O processing */ 1574 unsigned short temp = inb(ioaddr + INT_MASK_REG); 1575 outb(temp | IO_32_BIT, ioaddr + INT_MASK_REG); 1576 insl(ioaddr+IO_PORT_32_BIT, skb_put(skb,rcv_size), 1577 (rcv_size + 3) >> 2); 1578 outb(temp & ~(IO_32_BIT), ioaddr + INT_MASK_REG); 1579 } 1580 1581 skb->protocol = eth_type_trans(skb,dev); 1582 netif_rx(skb); 1583 dev->stats.rx_packets++; 1584 } 1585 1586 else { /* Not sure will ever reach here, 1587 I set the 595 to discard bad received frames */ 1588 dev->stats.rx_errors++; 1589 1590 if (rcv_status & 0x0100) 1591 dev->stats.rx_over_errors++; 1592 1593 else if (rcv_status & 0x0400) 1594 dev->stats.rx_frame_errors++; 1595 1596 else if (rcv_status & 0x0800) 1597 dev->stats.rx_crc_errors++; 1598 1599 printk(KERN_DEBUG "%s: event = %#x, status = %#x, next = %#x, size = %#x\n", 1600 dev->name, rcv_event, rcv_status, rcv_next_frame, rcv_size); 1601 } 1602 1603 if (rcv_status & 0x1000) 1604 dev->stats.rx_length_errors++; 1605 1606 rcv_car = lp->rx_start + RCV_HEADER + rcv_size; 1607 lp->rx_start = rcv_next_frame; 1608 1609 if (--boguscount == 0) 1610 break; 1611 1612 outw(rcv_next_frame, ioaddr + HOST_ADDRESS_REG); 1613 rcv_event = inw(ioaddr + IO_PORT); 1614 1615 } 1616 if (rcv_car == 0) 1617 rcv_car = lp->rcv_upper_limit | 0xff; 1618 1619 outw(rcv_car - 1, ioaddr + RCV_STOP); 1620 1621 if (net_debug > 5) 1622 printk(KERN_DEBUG "%s: exiting eepro_rx routine.\n", dev->name); 1623} 1624 1625static void 1626eepro_transmit_interrupt(struct net_device *dev) 1627{ 1628 struct eepro_local *lp = netdev_priv(dev); 1629 short ioaddr = dev->base_addr; 1630 short boguscount = 25; 1631 short xmt_status; 1632 1633 while ((lp->tx_start != lp->tx_end) && boguscount--) { 1634 1635 outw(lp->tx_start, ioaddr + HOST_ADDRESS_REG); 1636 xmt_status = inw(ioaddr+IO_PORT); 1637 1638 if (!(xmt_status & TX_DONE_BIT)) 1639 break; 1640 1641 xmt_status = inw(ioaddr+IO_PORT); 1642 lp->tx_start = inw(ioaddr+IO_PORT); 1643 1644 netif_wake_queue (dev); 1645 1646 if (xmt_status & TX_OK) 1647 dev->stats.tx_packets++; 1648 else { 1649 dev->stats.tx_errors++; 1650 if (xmt_status & 0x0400) { 1651 dev->stats.tx_carrier_errors++; 1652 printk(KERN_DEBUG "%s: carrier error\n", 1653 dev->name); 1654 printk(KERN_DEBUG "%s: XMT status = %#x\n", 1655 dev->name, xmt_status); 1656 } 1657 else { 1658 printk(KERN_DEBUG "%s: XMT status = %#x\n", 1659 dev->name, xmt_status); 1660 printk(KERN_DEBUG "%s: XMT status = %#x\n", 1661 dev->name, xmt_status); 1662 } 1663 } 1664 if (xmt_status & 0x000f) { 1665 dev->stats.collisions += (xmt_status & 0x000f); 1666 } 1667 1668 if ((xmt_status & 0x0040) == 0x0) { 1669 dev->stats.tx_heartbeat_errors++; 1670 } 1671 } 1672} 1673 1674static int eepro_ethtool_get_settings(struct net_device *dev, 1675 struct ethtool_cmd *cmd) 1676{ 1677 struct eepro_local *lp = netdev_priv(dev); 1678 1679 cmd->supported = SUPPORTED_10baseT_Half | 1680 SUPPORTED_10baseT_Full | 1681 SUPPORTED_Autoneg; 1682 cmd->advertising = ADVERTISED_10baseT_Half | 1683 ADVERTISED_10baseT_Full | 1684 ADVERTISED_Autoneg; 1685 1686 if (GetBit(lp->word[5], ee_PortTPE)) { 1687 cmd->supported |= SUPPORTED_TP; 1688 cmd->advertising |= ADVERTISED_TP; 1689 } 1690 if (GetBit(lp->word[5], ee_PortBNC)) { 1691 cmd->supported |= SUPPORTED_BNC; 1692 cmd->advertising |= ADVERTISED_BNC; 1693 } 1694 if (GetBit(lp->word[5], ee_PortAUI)) { 1695 cmd->supported |= SUPPORTED_AUI; 1696 cmd->advertising |= ADVERTISED_AUI; 1697 } 1698 1699 cmd->speed = SPEED_10; 1700 1701 if (dev->if_port == TPE && lp->word[1] & ee_Duplex) { 1702 cmd->duplex = DUPLEX_FULL; 1703 } 1704 else { 1705 cmd->duplex = DUPLEX_HALF; 1706 } 1707 1708 cmd->port = dev->if_port; 1709 cmd->phy_address = dev->base_addr; 1710 cmd->transceiver = XCVR_INTERNAL; 1711 1712 if (lp->word[0] & ee_AutoNeg) { 1713 cmd->autoneg = 1; 1714 } 1715 1716 return 0; 1717} 1718 1719static void eepro_ethtool_get_drvinfo(struct net_device *dev, 1720 struct ethtool_drvinfo *drvinfo) 1721{ 1722 strcpy(drvinfo->driver, DRV_NAME); 1723 strcpy(drvinfo->version, DRV_VERSION); 1724 sprintf(drvinfo->bus_info, "ISA 0x%lx", dev->base_addr); 1725} 1726 1727static const struct ethtool_ops eepro_ethtool_ops = { 1728 .get_settings = eepro_ethtool_get_settings, 1729 .get_drvinfo = eepro_ethtool_get_drvinfo, 1730}; 1731 1732#ifdef MODULE 1733 1734#define MAX_EEPRO 8 1735static struct net_device *dev_eepro[MAX_EEPRO]; 1736 1737static int io[MAX_EEPRO] = { 1738 [0 ... MAX_EEPRO-1] = -1 1739}; 1740static int irq[MAX_EEPRO]; 1741static int mem[MAX_EEPRO] = { /* Size of the rx buffer in KB */ 1742 [0 ... MAX_EEPRO-1] = RCV_DEFAULT_RAM/1024 1743}; 1744static int autodetect; 1745 1746static int n_eepro; 1747/* For linux 2.1.xx */ 1748 1749MODULE_AUTHOR("Pascal Dupuis and others"); 1750MODULE_DESCRIPTION("Intel i82595 ISA EtherExpressPro10/10+ driver"); 1751MODULE_LICENSE("GPL"); 1752 1753module_param_array(io, int, NULL, 0); 1754module_param_array(irq, int, NULL, 0); 1755module_param_array(mem, int, NULL, 0); 1756module_param(autodetect, int, 0); 1757MODULE_PARM_DESC(io, "EtherExpress Pro/10 I/O base addres(es)"); 1758MODULE_PARM_DESC(irq, "EtherExpress Pro/10 IRQ number(s)"); 1759MODULE_PARM_DESC(mem, "EtherExpress Pro/10 Rx buffer size(es) in kB (3-29)"); 1760MODULE_PARM_DESC(autodetect, "EtherExpress Pro/10 force board(s) detection (0-1)"); 1761 1762int __init init_module(void) 1763{ 1764 struct net_device *dev; 1765 int i; 1766 if (io[0] == -1 && autodetect == 0) { 1767 printk(KERN_WARNING "eepro_init_module: Probe is very dangerous in ISA boards!\n"); 1768 printk(KERN_WARNING "eepro_init_module: Please add \"autodetect=1\" to force probe\n"); 1769 return -ENODEV; 1770 } 1771 else if (autodetect) { 1772 /* if autodetect is set then we must force detection */ 1773 for (i = 0; i < MAX_EEPRO; i++) { 1774 io[i] = 0; 1775 } 1776 1777 printk(KERN_INFO "eepro_init_module: Auto-detecting boards (May God protect us...)\n"); 1778 } 1779 1780 for (i = 0; i < MAX_EEPRO && io[i] != -1; i++) { 1781 dev = alloc_etherdev(sizeof(struct eepro_local)); 1782 if (!dev) 1783 break; 1784 1785 dev->mem_end = mem[i]; 1786 dev->base_addr = io[i]; 1787 dev->irq = irq[i]; 1788 1789 if (do_eepro_probe(dev) == 0) { 1790 dev_eepro[n_eepro++] = dev; 1791 continue; 1792 } 1793 free_netdev(dev); 1794 break; 1795 } 1796 1797 if (n_eepro) 1798 printk(KERN_INFO "%s", version); 1799 1800 return n_eepro ? 0 : -ENODEV; 1801} 1802 1803void __exit 1804cleanup_module(void) 1805{ 1806 int i; 1807 1808 for (i=0; i<n_eepro; i++) { 1809 struct net_device *dev = dev_eepro[i]; 1810 unregister_netdev(dev); 1811 release_region(dev->base_addr, EEPRO_IO_EXTENT); 1812 free_netdev(dev); 1813 } 1814} 1815#endif /* MODULE */ 1816