1/* 2 Written 1997-1998 by Donald Becker. 3 4 This software may be used and distributed according to the terms 5 of the GNU General Public License, incorporated herein by reference. 6 7 This driver is for the 3Com ISA EtherLink XL "Corkscrew" 3c515 ethercard. 8 9 The author may be reached as becker@scyld.com, or C/O 10 Scyld Computing Corporation 11 410 Severn Ave., Suite 210 12 Annapolis MD 21403 13 14 15 2000/2/2- Added support for kernel-level ISAPnP 16 by Stephen Frost <sfrost@snowman.net> and Alessandro Zummo 17 Cleaned up for 2.3.x/softnet by Jeff Garzik and Alan Cox. 18 19 2001/11/17 - Added ethtool support (jgarzik) 20 21 2002/10/28 - Locking updates for 2.5 (alan@lxorguk.ukuu.org.uk) 22 23*/ 24 25#define DRV_NAME "3c515" 26#define DRV_VERSION "0.99t-ac" 27#define DRV_RELDATE "28-Oct-2002" 28 29static char *version = 30DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " becker@scyld.com and others\n"; 31 32#define CORKSCREW 1 33 34/* "Knobs" that adjust features and parameters. */ 35/* Set the copy breakpoint for the copy-only-tiny-frames scheme. 36 Setting to > 1512 effectively disables this feature. */ 37static int rx_copybreak = 200; 38 39/* Allow setting MTU to a larger size, bypassing the normal ethernet setup. */ 40static const int mtu = 1500; 41 42/* Maximum events (Rx packets, etc.) to handle at each interrupt. */ 43static int max_interrupt_work = 20; 44 45/* Enable the automatic media selection code -- usually set. */ 46#define AUTOMEDIA 1 47 48/* Allow the use of fragment bus master transfers instead of only 49 programmed-I/O for Vortex cards. Full-bus-master transfers are always 50 enabled by default on Boomerang cards. If VORTEX_BUS_MASTER is defined, 51 the feature may be turned on using 'options'. */ 52#define VORTEX_BUS_MASTER 53 54/* A few values that may be tweaked. */ 55/* Keep the ring sizes a power of two for efficiency. */ 56#define TX_RING_SIZE 16 57#define RX_RING_SIZE 16 58#define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer. */ 59 60#include <linux/module.h> 61#include <linux/isapnp.h> 62#include <linux/kernel.h> 63#include <linux/netdevice.h> 64#include <linux/string.h> 65#include <linux/errno.h> 66#include <linux/in.h> 67#include <linux/ioport.h> 68#include <linux/skbuff.h> 69#include <linux/etherdevice.h> 70#include <linux/interrupt.h> 71#include <linux/timer.h> 72#include <linux/ethtool.h> 73#include <linux/bitops.h> 74 75#include <asm/uaccess.h> 76#include <asm/io.h> 77#include <asm/dma.h> 78 79#define NEW_MULTICAST 80#include <linux/delay.h> 81 82#define MAX_UNITS 8 83 84MODULE_AUTHOR("Donald Becker <becker@scyld.com>"); 85MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver"); 86MODULE_LICENSE("GPL"); 87MODULE_VERSION(DRV_VERSION); 88 89/* "Knobs" for adjusting internal parameters. */ 90/* Put out somewhat more debugging messages. (0 - no msg, 1 minimal msgs). */ 91#define DRIVER_DEBUG 1 92/* Some values here only for performance evaluation and path-coverage 93 debugging. */ 94static int rx_nocopy, rx_copy, queued_packet; 95 96/* Number of times to check to see if the Tx FIFO has space, used in some 97 limited cases. */ 98#define WAIT_TX_AVAIL 200 99 100/* Operational parameter that usually are not changed. */ 101#define TX_TIMEOUT ((4*HZ)/10) /* Time in jiffies before concluding Tx hung */ 102 103/* The size here is somewhat misleading: the Corkscrew also uses the ISA 104 aliased registers at <base>+0x400. 105 */ 106#define CORKSCREW_TOTAL_SIZE 0x20 107 108#ifdef DRIVER_DEBUG 109static int corkscrew_debug = DRIVER_DEBUG; 110#else 111static int corkscrew_debug = 1; 112#endif 113 114#define CORKSCREW_ID 10 115 116/* 117 Theory of Operation 118 119I. Board Compatibility 120 121This device driver is designed for the 3Com 3c515 ISA Fast EtherLink XL, 1223Com's ISA bus adapter for Fast Ethernet. Due to the unique I/O port layout, 123it's not practical to integrate this driver with the other EtherLink drivers. 124 125II. Board-specific settings 126 127The Corkscrew has an EEPROM for configuration, but no special settings are 128needed for Linux. 129 130III. Driver operation 131 132The 3c515 series use an interface that's very similar to the 3c900 "Boomerang" 133PCI cards, with the bus master interface extensively modified to work with 134the ISA bus. 135 136The card is capable of full-bus-master transfers with separate 137lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet, 138DEC Tulip and Intel Speedo3. 139 140This driver uses a "RX_COPYBREAK" scheme rather than a fixed intermediate 141receive buffer. This scheme allocates full-sized skbuffs as receive 142buffers. The value RX_COPYBREAK is used as the copying breakpoint: it is 143chosen to trade-off the memory wasted by passing the full-sized skbuff to 144the queue layer for all frames vs. the copying cost of copying a frame to a 145correctly-sized skbuff. 146 147 148IIIC. Synchronization 149The driver runs as two independent, single-threaded flows of control. One 150is the send-packet routine, which enforces single-threaded use by the netif 151layer. The other thread is the interrupt handler, which is single 152threaded by the hardware and other software. 153 154IV. Notes 155 156Thanks to Terry Murphy of 3Com for providing documentation and a development 157board. 158 159The names "Vortex", "Boomerang" and "Corkscrew" are the internal 3Com 160project names. I use these names to eliminate confusion -- 3Com product 161numbers and names are very similar and often confused. 162 163The new chips support both ethernet (1.5K) and FDDI (4.5K) frame sizes! 164This driver only supports ethernet frames because of the recent MTU limit 165of 1.5K, but the changes to support 4.5K are minimal. 166*/ 167 168/* Operational definitions. 169 These are not used by other compilation units and thus are not 170 exported in a ".h" file. 171 172 First the windows. There are eight register windows, with the command 173 and status registers available in each. 174 */ 175#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD) 176#define EL3_CMD 0x0e 177#define EL3_STATUS 0x0e 178 179/* The top five bits written to EL3_CMD are a command, the lower 180 11 bits are the parameter, if applicable. 181 Note that 11 parameters bits was fine for ethernet, but the new chips 182 can handle FDDI length frames (~4500 octets) and now parameters count 183 32-bit 'Dwords' rather than octets. */ 184 185enum corkscrew_cmd { 186 TotalReset = 0 << 11, SelectWindow = 1 << 11, StartCoax = 2 << 11, 187 RxDisable = 3 << 11, RxEnable = 4 << 11, RxReset = 5 << 11, 188 UpStall = 6 << 11, UpUnstall = (6 << 11) + 1, DownStall = (6 << 11) + 2, 189 DownUnstall = (6 << 11) + 3, RxDiscard = 8 << 11, TxEnable = 9 << 11, 190 TxDisable = 10 << 11, TxReset = 11 << 11, FakeIntr = 12 << 11, 191 AckIntr = 13 << 11, SetIntrEnb = 14 << 11, SetStatusEnb = 15 << 11, 192 SetRxFilter = 16 << 11, SetRxThreshold = 17 << 11, 193 SetTxThreshold = 18 << 11, SetTxStart = 19 << 11, StartDMAUp = 20 << 11, 194 StartDMADown = (20 << 11) + 1, StatsEnable = 21 << 11, 195 StatsDisable = 22 << 11, StopCoax = 23 << 11, 196}; 197 198/* The SetRxFilter command accepts the following classes: */ 199enum RxFilter { 200 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 201}; 202 203/* Bits in the general status register. */ 204enum corkscrew_status { 205 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004, 206 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020, 207 IntReq = 0x0040, StatsFull = 0x0080, 208 DMADone = 1 << 8, DownComplete = 1 << 9, UpComplete = 1 << 10, 209 DMAInProgress = 1 << 11, /* DMA controller is still busy. */ 210 CmdInProgress = 1 << 12, /* EL3_CMD is still busy. */ 211}; 212 213/* Register window 1 offsets, the window used in normal operation. 214 On the Corkscrew this window is always mapped at offsets 0x10-0x1f. */ 215enum Window1 { 216 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14, 217 RxStatus = 0x18, Timer = 0x1A, TxStatus = 0x1B, 218 TxFree = 0x1C, /* Remaining free bytes in Tx buffer. */ 219}; 220enum Window0 { 221 Wn0IRQ = 0x08, 222#if defined(CORKSCREW) 223 Wn0EepromCmd = 0x200A, /* Corkscrew EEPROM command register. */ 224 Wn0EepromData = 0x200C, /* Corkscrew EEPROM results register. */ 225#else 226 Wn0EepromCmd = 10, /* Window 0: EEPROM command register. */ 227 Wn0EepromData = 12, /* Window 0: EEPROM results register. */ 228#endif 229}; 230enum Win0_EEPROM_bits { 231 EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0, 232 EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */ 233 EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */ 234}; 235 236/* EEPROM locations. */ 237enum eeprom_offset { 238 PhysAddr01 = 0, PhysAddr23 = 1, PhysAddr45 = 2, ModelID = 3, 239 EtherLink3ID = 7, 240}; 241 242enum Window3 { /* Window 3: MAC/config bits. */ 243 Wn3_Config = 0, Wn3_MAC_Ctrl = 6, Wn3_Options = 8, 244}; 245enum wn3_config { 246 Ram_size = 7, 247 Ram_width = 8, 248 Ram_speed = 0x30, 249 Rom_size = 0xc0, 250 Ram_split_shift = 16, 251 Ram_split = 3 << Ram_split_shift, 252 Xcvr_shift = 20, 253 Xcvr = 7 << Xcvr_shift, 254 Autoselect = 0x1000000, 255}; 256 257enum Window4 { 258 Wn4_NetDiag = 6, Wn4_Media = 10, /* Window 4: Xcvr/media bits. */ 259}; 260enum Win4_Media_bits { 261 Media_SQE = 0x0008, /* Enable SQE error counting for AUI. */ 262 Media_10TP = 0x00C0, /* Enable link beat and jabber for 10baseT. */ 263 Media_Lnk = 0x0080, /* Enable just link beat for 100TX/100FX. */ 264 Media_LnkBeat = 0x0800, 265}; 266enum Window7 { /* Window 7: Bus Master control. */ 267 Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12, 268}; 269 270/* Boomerang-style bus master control registers. Note ISA aliases! */ 271enum MasterCtrl { 272 PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen = 273 0x40c, 274 TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418, 275}; 276 277/* The Rx and Tx descriptor lists. 278 Caution Alpha hackers: these types are 32 bits! Note also the 8 byte 279 alignment contraint on tx_ring[] and rx_ring[]. */ 280struct boom_rx_desc { 281 u32 next; 282 s32 status; 283 u32 addr; 284 s32 length; 285}; 286 287/* Values for the Rx status entry. */ 288enum rx_desc_status { 289 RxDComplete = 0x00008000, RxDError = 0x4000, 290 /* See boomerang_rx() for actual error bits */ 291}; 292 293struct boom_tx_desc { 294 u32 next; 295 s32 status; 296 u32 addr; 297 s32 length; 298}; 299 300struct corkscrew_private { 301 const char *product_name; 302 struct list_head list; 303 struct net_device *our_dev; 304 /* The Rx and Tx rings are here to keep them quad-word-aligned. */ 305 struct boom_rx_desc rx_ring[RX_RING_SIZE]; 306 struct boom_tx_desc tx_ring[TX_RING_SIZE]; 307 /* The addresses of transmit- and receive-in-place skbuffs. */ 308 struct sk_buff *rx_skbuff[RX_RING_SIZE]; 309 struct sk_buff *tx_skbuff[TX_RING_SIZE]; 310 unsigned int cur_rx, cur_tx; /* The next free ring entry */ 311 unsigned int dirty_rx, dirty_tx;/* The ring entries to be free()ed. */ 312 struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl. */ 313 struct timer_list timer; /* Media selection timer. */ 314 int capabilities ; /* Adapter capabilities word. */ 315 int options; /* User-settable misc. driver options. */ 316 int last_rx_packets; /* For media autoselection. */ 317 unsigned int available_media:8, /* From Wn3_Options */ 318 media_override:3, /* Passed-in media type. */ 319 default_media:3, /* Read from the EEPROM. */ 320 full_duplex:1, autoselect:1, bus_master:1, /* Vortex can only do a fragment bus-m. */ 321 full_bus_master_tx:1, full_bus_master_rx:1, /* Boomerang */ 322 tx_full:1; 323 spinlock_t lock; 324 struct device *dev; 325}; 326 327/* The action to take with a media selection timer tick. 328 Note that we deviate from the 3Com order by checking 10base2 before AUI. 329 */ 330enum xcvr_types { 331 XCVR_10baseT = 0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx, 332 XCVR_100baseFx, XCVR_MII = 6, XCVR_Default = 8, 333}; 334 335static struct media_table { 336 char *name; 337 unsigned int media_bits:16, /* Bits to set in Wn4_Media register. */ 338 mask:8, /* The transceiver-present bit in Wn3_Config. */ 339 next:8; /* The media type to try next. */ 340 short wait; /* Time before we check media status. */ 341} media_tbl[] = { 342 { "10baseT", Media_10TP, 0x08, XCVR_10base2, (14 * HZ) / 10 }, 343 { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1 * HZ) / 10}, 344 { "undefined", 0, 0x80, XCVR_10baseT, 10000}, 345 { "10base2", 0, 0x10, XCVR_AUI, (1 * HZ) / 10}, 346 { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14 * HZ) / 10}, 347 { "100baseFX", Media_Lnk, 0x04, XCVR_MII, (14 * HZ) / 10}, 348 { "MII", 0, 0x40, XCVR_10baseT, 3 * HZ}, 349 { "undefined", 0, 0x01, XCVR_10baseT, 10000}, 350 { "Default", 0, 0xFF, XCVR_10baseT, 10000}, 351}; 352 353#ifdef __ISAPNP__ 354static struct isapnp_device_id corkscrew_isapnp_adapters[] = { 355 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, 356 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5051), 357 (long) "3Com Fast EtherLink ISA" }, 358 { } /* terminate list */ 359}; 360 361MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters); 362 363static int nopnp; 364#endif /* __ISAPNP__ */ 365 366static struct net_device *corkscrew_scan(int unit); 367static int corkscrew_setup(struct net_device *dev, int ioaddr, 368 struct pnp_dev *idev, int card_number); 369static int corkscrew_open(struct net_device *dev); 370static void corkscrew_timer(unsigned long arg); 371static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb, 372 struct net_device *dev); 373static int corkscrew_rx(struct net_device *dev); 374static void corkscrew_timeout(struct net_device *dev); 375static int boomerang_rx(struct net_device *dev); 376static irqreturn_t corkscrew_interrupt(int irq, void *dev_id); 377static int corkscrew_close(struct net_device *dev); 378static void update_stats(int addr, struct net_device *dev); 379static struct net_device_stats *corkscrew_get_stats(struct net_device *dev); 380static void set_rx_mode(struct net_device *dev); 381static const struct ethtool_ops netdev_ethtool_ops; 382 383 384/* 385 Unfortunately maximizing the shared code between the integrated and 386 module version of the driver results in a complicated set of initialization 387 procedures. 388 init_module() -- modules / tc59x_init() -- built-in 389 The wrappers for corkscrew_scan() 390 corkscrew_scan() The common routine that scans for PCI and EISA cards 391 corkscrew_found_device() Allocate a device structure when we find a card. 392 Different versions exist for modules and built-in. 393 corkscrew_probe1() Fill in the device structure -- this is separated 394 so that the modules code can put it in dev->init. 395*/ 396/* This driver uses 'options' to pass the media type, full-duplex flag, etc. */ 397/* Note: this is the only limit on the number of cards supported!! */ 398static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, }; 399 400#ifdef MODULE 401static int debug = -1; 402 403module_param(debug, int, 0); 404module_param_array(options, int, NULL, 0); 405module_param(rx_copybreak, int, 0); 406module_param(max_interrupt_work, int, 0); 407MODULE_PARM_DESC(debug, "3c515 debug level (0-6)"); 408MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering"); 409MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames"); 410MODULE_PARM_DESC(max_interrupt_work, "3c515 maximum events handled per interrupt"); 411 412/* A list of all installed Vortex devices, for removing the driver module. */ 413/* we will need locking (and refcounting) if we ever use it for more */ 414static LIST_HEAD(root_corkscrew_dev); 415 416int init_module(void) 417{ 418 int found = 0; 419 if (debug >= 0) 420 corkscrew_debug = debug; 421 if (corkscrew_debug) 422 pr_debug("%s", version); 423 while (corkscrew_scan(-1)) 424 found++; 425 return found ? 0 : -ENODEV; 426} 427 428#else 429struct net_device *tc515_probe(int unit) 430{ 431 struct net_device *dev = corkscrew_scan(unit); 432 static int printed; 433 434 if (!dev) 435 return ERR_PTR(-ENODEV); 436 437 if (corkscrew_debug > 0 && !printed) { 438 printed = 1; 439 pr_debug("%s", version); 440 } 441 442 return dev; 443} 444#endif /* not MODULE */ 445 446static int check_device(unsigned ioaddr) 447{ 448 int timer; 449 450 if (!request_region(ioaddr, CORKSCREW_TOTAL_SIZE, "3c515")) 451 return 0; 452 /* Check the resource configuration for a matching ioaddr. */ 453 if ((inw(ioaddr + 0x2002) & 0x1f0) != (ioaddr & 0x1f0)) { 454 release_region(ioaddr, CORKSCREW_TOTAL_SIZE); 455 return 0; 456 } 457 /* Verify by reading the device ID from the EEPROM. */ 458 outw(EEPROM_Read + 7, ioaddr + Wn0EepromCmd); 459 /* Pause for at least 162 us. for the read to take place. */ 460 for (timer = 4; timer >= 0; timer--) { 461 udelay(162); 462 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0) 463 break; 464 } 465 if (inw(ioaddr + Wn0EepromData) != 0x6d50) { 466 release_region(ioaddr, CORKSCREW_TOTAL_SIZE); 467 return 0; 468 } 469 return 1; 470} 471 472static void cleanup_card(struct net_device *dev) 473{ 474 struct corkscrew_private *vp = netdev_priv(dev); 475 list_del_init(&vp->list); 476 if (dev->dma) 477 free_dma(dev->dma); 478 outw(TotalReset, dev->base_addr + EL3_CMD); 479 release_region(dev->base_addr, CORKSCREW_TOTAL_SIZE); 480 if (vp->dev) 481 pnp_device_detach(to_pnp_dev(vp->dev)); 482} 483 484static struct net_device *corkscrew_scan(int unit) 485{ 486 struct net_device *dev; 487 static int cards_found = 0; 488 static int ioaddr; 489 int err; 490#ifdef __ISAPNP__ 491 short i; 492 static int pnp_cards; 493#endif 494 495 dev = alloc_etherdev(sizeof(struct corkscrew_private)); 496 if (!dev) 497 return ERR_PTR(-ENOMEM); 498 499 if (unit >= 0) { 500 sprintf(dev->name, "eth%d", unit); 501 netdev_boot_setup_check(dev); 502 } 503 504#ifdef __ISAPNP__ 505 if(nopnp == 1) 506 goto no_pnp; 507 for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) { 508 struct pnp_dev *idev = NULL; 509 int irq; 510 while((idev = pnp_find_dev(NULL, 511 corkscrew_isapnp_adapters[i].vendor, 512 corkscrew_isapnp_adapters[i].function, 513 idev))) { 514 515 if (pnp_device_attach(idev) < 0) 516 continue; 517 if (pnp_activate_dev(idev) < 0) { 518 pr_warning("pnp activate failed (out of resources?)\n"); 519 pnp_device_detach(idev); 520 continue; 521 } 522 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) { 523 pnp_device_detach(idev); 524 continue; 525 } 526 ioaddr = pnp_port_start(idev, 0); 527 irq = pnp_irq(idev, 0); 528 if (!check_device(ioaddr)) { 529 pnp_device_detach(idev); 530 continue; 531 } 532 if(corkscrew_debug) 533 pr_debug("ISAPNP reports %s at i/o 0x%x, irq %d\n", 534 (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq); 535 pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n", 536 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000)); 537 /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */ 538 SET_NETDEV_DEV(dev, &idev->dev); 539 pnp_cards++; 540 err = corkscrew_setup(dev, ioaddr, idev, cards_found++); 541 if (!err) 542 return dev; 543 cleanup_card(dev); 544 } 545 } 546no_pnp: 547#endif /* __ISAPNP__ */ 548 549 /* Check all locations on the ISA bus -- evil! */ 550 for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) { 551 if (!check_device(ioaddr)) 552 continue; 553 554 pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n", 555 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000)); 556 err = corkscrew_setup(dev, ioaddr, NULL, cards_found++); 557 if (!err) 558 return dev; 559 cleanup_card(dev); 560 } 561 free_netdev(dev); 562 return NULL; 563} 564 565 566static const struct net_device_ops netdev_ops = { 567 .ndo_open = corkscrew_open, 568 .ndo_stop = corkscrew_close, 569 .ndo_start_xmit = corkscrew_start_xmit, 570 .ndo_tx_timeout = corkscrew_timeout, 571 .ndo_get_stats = corkscrew_get_stats, 572 .ndo_set_rx_mode = set_rx_mode, 573 .ndo_change_mtu = eth_change_mtu, 574 .ndo_set_mac_address = eth_mac_addr, 575 .ndo_validate_addr = eth_validate_addr, 576}; 577 578 579static int corkscrew_setup(struct net_device *dev, int ioaddr, 580 struct pnp_dev *idev, int card_number) 581{ 582 struct corkscrew_private *vp = netdev_priv(dev); 583 unsigned int eeprom[0x40], checksum = 0; /* EEPROM contents */ 584 int i; 585 int irq; 586 587#ifdef __ISAPNP__ 588 if (idev) { 589 irq = pnp_irq(idev, 0); 590 vp->dev = &idev->dev; 591 } else { 592 irq = inw(ioaddr + 0x2002) & 15; 593 } 594#else 595 irq = inw(ioaddr + 0x2002) & 15; 596#endif 597 598 dev->base_addr = ioaddr; 599 dev->irq = irq; 600 dev->dma = inw(ioaddr + 0x2000) & 7; 601 vp->product_name = "3c515"; 602 vp->options = dev->mem_start; 603 vp->our_dev = dev; 604 605 if (!vp->options) { 606 if (card_number >= MAX_UNITS) 607 vp->options = -1; 608 else 609 vp->options = options[card_number]; 610 } 611 612 if (vp->options >= 0) { 613 vp->media_override = vp->options & 7; 614 if (vp->media_override == 2) 615 vp->media_override = 0; 616 vp->full_duplex = (vp->options & 8) ? 1 : 0; 617 vp->bus_master = (vp->options & 16) ? 1 : 0; 618 } else { 619 vp->media_override = 7; 620 vp->full_duplex = 0; 621 vp->bus_master = 0; 622 } 623#ifdef MODULE 624 list_add(&vp->list, &root_corkscrew_dev); 625#endif 626 627 pr_info("%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr); 628 629 spin_lock_init(&vp->lock); 630 631 /* Read the station address from the EEPROM. */ 632 EL3WINDOW(0); 633 for (i = 0; i < 0x18; i++) { 634 __be16 *phys_addr = (__be16 *) dev->dev_addr; 635 int timer; 636 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd); 637 /* Pause for at least 162 us. for the read to take place. */ 638 for (timer = 4; timer >= 0; timer--) { 639 udelay(162); 640 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0) 641 break; 642 } 643 eeprom[i] = inw(ioaddr + Wn0EepromData); 644 checksum ^= eeprom[i]; 645 if (i < 3) 646 phys_addr[i] = htons(eeprom[i]); 647 } 648 checksum = (checksum ^ (checksum >> 8)) & 0xff; 649 if (checksum != 0x00) 650 pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum); 651 pr_cont(" %pM", dev->dev_addr); 652 if (eeprom[16] == 0x11c7) { /* Corkscrew */ 653 if (request_dma(dev->dma, "3c515")) { 654 pr_cont(", DMA %d allocation failed", dev->dma); 655 dev->dma = 0; 656 } else 657 pr_cont(", DMA %d", dev->dma); 658 } 659 pr_cont(", IRQ %d\n", dev->irq); 660 /* Tell them about an invalid IRQ. */ 661 if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15)) 662 pr_warning(" *** Warning: this IRQ is unlikely to work! ***\n"); 663 664 { 665 static const char * const ram_split[] = { 666 "5:3", "3:1", "1:1", "3:5" 667 }; 668 __u32 config; 669 EL3WINDOW(3); 670 vp->available_media = inw(ioaddr + Wn3_Options); 671 config = inl(ioaddr + Wn3_Config); 672 if (corkscrew_debug > 1) 673 pr_info(" Internal config register is %4.4x, transceivers %#x.\n", 674 config, inw(ioaddr + Wn3_Options)); 675 pr_info(" %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n", 676 8 << config & Ram_size, 677 config & Ram_width ? "word" : "byte", 678 ram_split[(config & Ram_split) >> Ram_split_shift], 679 config & Autoselect ? "autoselect/" : "", 680 media_tbl[(config & Xcvr) >> Xcvr_shift].name); 681 vp->default_media = (config & Xcvr) >> Xcvr_shift; 682 vp->autoselect = config & Autoselect ? 1 : 0; 683 dev->if_port = vp->default_media; 684 } 685 if (vp->media_override != 7) { 686 pr_info(" Media override to transceiver type %d (%s).\n", 687 vp->media_override, 688 media_tbl[vp->media_override].name); 689 dev->if_port = vp->media_override; 690 } 691 692 vp->capabilities = eeprom[16]; 693 vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0; 694 /* Rx is broken at 10mbps, so we always disable it. */ 695 /* vp->full_bus_master_rx = 0; */ 696 vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0; 697 698 /* The 3c51x-specific entries in the device structure. */ 699 dev->netdev_ops = &netdev_ops; 700 dev->watchdog_timeo = (400 * HZ) / 1000; 701 dev->ethtool_ops = &netdev_ethtool_ops; 702 703 return register_netdev(dev); 704} 705 706 707static int corkscrew_open(struct net_device *dev) 708{ 709 int ioaddr = dev->base_addr; 710 struct corkscrew_private *vp = netdev_priv(dev); 711 __u32 config; 712 int i; 713 714 /* Before initializing select the active media port. */ 715 EL3WINDOW(3); 716 if (vp->full_duplex) 717 outb(0x20, ioaddr + Wn3_MAC_Ctrl); /* Set the full-duplex bit. */ 718 config = inl(ioaddr + Wn3_Config); 719 720 if (vp->media_override != 7) { 721 if (corkscrew_debug > 1) 722 pr_info("%s: Media override to transceiver %d (%s).\n", 723 dev->name, vp->media_override, 724 media_tbl[vp->media_override].name); 725 dev->if_port = vp->media_override; 726 } else if (vp->autoselect) { 727 /* Find first available media type, starting with 100baseTx. */ 728 dev->if_port = 4; 729 while (!(vp->available_media & media_tbl[dev->if_port].mask)) 730 dev->if_port = media_tbl[dev->if_port].next; 731 732 if (corkscrew_debug > 1) 733 pr_debug("%s: Initial media type %s.\n", 734 dev->name, media_tbl[dev->if_port].name); 735 736 init_timer(&vp->timer); 737 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait; 738 vp->timer.data = (unsigned long) dev; 739 vp->timer.function = corkscrew_timer; /* timer handler */ 740 add_timer(&vp->timer); 741 } else 742 dev->if_port = vp->default_media; 743 744 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift); 745 outl(config, ioaddr + Wn3_Config); 746 747 if (corkscrew_debug > 1) { 748 pr_debug("%s: corkscrew_open() InternalConfig %8.8x.\n", 749 dev->name, config); 750 } 751 752 outw(TxReset, ioaddr + EL3_CMD); 753 for (i = 20; i >= 0; i--) 754 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress)) 755 break; 756 757 outw(RxReset, ioaddr + EL3_CMD); 758 /* Wait a few ticks for the RxReset command to complete. */ 759 for (i = 20; i >= 0; i--) 760 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress)) 761 break; 762 763 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD); 764 765 /* Use the now-standard shared IRQ implementation. */ 766 if (vp->capabilities == 0x11c7) { 767 /* Corkscrew: Cannot share ISA resources. */ 768 if (dev->irq == 0 || 769 dev->dma == 0 || 770 request_irq(dev->irq, corkscrew_interrupt, 0, 771 vp->product_name, dev)) 772 return -EAGAIN; 773 enable_dma(dev->dma); 774 set_dma_mode(dev->dma, DMA_MODE_CASCADE); 775 } else if (request_irq(dev->irq, corkscrew_interrupt, IRQF_SHARED, 776 vp->product_name, dev)) { 777 return -EAGAIN; 778 } 779 780 if (corkscrew_debug > 1) { 781 EL3WINDOW(4); 782 pr_debug("%s: corkscrew_open() irq %d media status %4.4x.\n", 783 dev->name, dev->irq, inw(ioaddr + Wn4_Media)); 784 } 785 786 /* Set the station address and mask in window 2 each time opened. */ 787 EL3WINDOW(2); 788 for (i = 0; i < 6; i++) 789 outb(dev->dev_addr[i], ioaddr + i); 790 for (; i < 12; i += 2) 791 outw(0, ioaddr + i); 792 793 if (dev->if_port == 3) 794 /* Start the thinnet transceiver. We should really wait 50ms... */ 795 outw(StartCoax, ioaddr + EL3_CMD); 796 EL3WINDOW(4); 797 outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) | 798 media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media); 799 800 /* Switch to the stats window, and clear all stats by reading. */ 801 outw(StatsDisable, ioaddr + EL3_CMD); 802 EL3WINDOW(6); 803 for (i = 0; i < 10; i++) 804 inb(ioaddr + i); 805 inw(ioaddr + 10); 806 inw(ioaddr + 12); 807 /* New: On the Vortex we must also clear the BadSSD counter. */ 808 EL3WINDOW(4); 809 inb(ioaddr + 12); 810 /* ..and on the Boomerang we enable the extra statistics bits. */ 811 outw(0x0040, ioaddr + Wn4_NetDiag); 812 813 /* Switch to register set 7 for normal use. */ 814 EL3WINDOW(7); 815 816 if (vp->full_bus_master_rx) { /* Boomerang bus master. */ 817 vp->cur_rx = vp->dirty_rx = 0; 818 if (corkscrew_debug > 2) 819 pr_debug("%s: Filling in the Rx ring.\n", dev->name); 820 for (i = 0; i < RX_RING_SIZE; i++) { 821 struct sk_buff *skb; 822 if (i < (RX_RING_SIZE - 1)) 823 vp->rx_ring[i].next = 824 isa_virt_to_bus(&vp->rx_ring[i + 1]); 825 else 826 vp->rx_ring[i].next = 0; 827 vp->rx_ring[i].status = 0; /* Clear complete bit. */ 828 vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000; 829 skb = netdev_alloc_skb(dev, PKT_BUF_SZ); 830 vp->rx_skbuff[i] = skb; 831 if (skb == NULL) 832 break; /* Bad news! */ 833 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */ 834 vp->rx_ring[i].addr = isa_virt_to_bus(skb->data); 835 } 836 if (i != 0) 837 vp->rx_ring[i - 1].next = 838 isa_virt_to_bus(&vp->rx_ring[0]); /* Wrap the ring. */ 839 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr); 840 } 841 if (vp->full_bus_master_tx) { /* Boomerang bus master Tx. */ 842 vp->cur_tx = vp->dirty_tx = 0; 843 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold); /* Room for a packet. */ 844 /* Clear the Tx ring. */ 845 for (i = 0; i < TX_RING_SIZE; i++) 846 vp->tx_skbuff[i] = NULL; 847 outl(0, ioaddr + DownListPtr); 848 } 849 /* Set receiver mode: presumably accept b-case and phys addr only. */ 850 set_rx_mode(dev); 851 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */ 852 853 netif_start_queue(dev); 854 855 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */ 856 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */ 857 /* Allow status bits to be seen. */ 858 outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull | 859 (vp->full_bus_master_tx ? DownComplete : TxAvailable) | 860 (vp->full_bus_master_rx ? UpComplete : RxComplete) | 861 (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD); 862 /* Ack all pending events, and set active indicator mask. */ 863 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq, 864 ioaddr + EL3_CMD); 865 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull 866 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete, 867 ioaddr + EL3_CMD); 868 869 return 0; 870} 871 872static void corkscrew_timer(unsigned long data) 873{ 874#ifdef AUTOMEDIA 875 struct net_device *dev = (struct net_device *) data; 876 struct corkscrew_private *vp = netdev_priv(dev); 877 int ioaddr = dev->base_addr; 878 unsigned long flags; 879 int ok = 0; 880 881 if (corkscrew_debug > 1) 882 pr_debug("%s: Media selection timer tick happened, %s.\n", 883 dev->name, media_tbl[dev->if_port].name); 884 885 spin_lock_irqsave(&vp->lock, flags); 886 887 { 888 int old_window = inw(ioaddr + EL3_CMD) >> 13; 889 int media_status; 890 EL3WINDOW(4); 891 media_status = inw(ioaddr + Wn4_Media); 892 switch (dev->if_port) { 893 case 0: 894 case 4: 895 case 5: /* 10baseT, 100baseTX, 100baseFX */ 896 if (media_status & Media_LnkBeat) { 897 ok = 1; 898 if (corkscrew_debug > 1) 899 pr_debug("%s: Media %s has link beat, %x.\n", 900 dev->name, 901 media_tbl[dev->if_port].name, 902 media_status); 903 } else if (corkscrew_debug > 1) 904 pr_debug("%s: Media %s is has no link beat, %x.\n", 905 dev->name, 906 media_tbl[dev->if_port].name, 907 media_status); 908 909 break; 910 default: /* Other media types handled by Tx timeouts. */ 911 if (corkscrew_debug > 1) 912 pr_debug("%s: Media %s is has no indication, %x.\n", 913 dev->name, 914 media_tbl[dev->if_port].name, 915 media_status); 916 ok = 1; 917 } 918 if (!ok) { 919 __u32 config; 920 921 do { 922 dev->if_port = 923 media_tbl[dev->if_port].next; 924 } 925 while (!(vp->available_media & media_tbl[dev->if_port].mask)); 926 927 if (dev->if_port == 8) { /* Go back to default. */ 928 dev->if_port = vp->default_media; 929 if (corkscrew_debug > 1) 930 pr_debug("%s: Media selection failing, using default %s port.\n", 931 dev->name, 932 media_tbl[dev->if_port].name); 933 } else { 934 if (corkscrew_debug > 1) 935 pr_debug("%s: Media selection failed, now trying %s port.\n", 936 dev->name, 937 media_tbl[dev->if_port].name); 938 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait; 939 add_timer(&vp->timer); 940 } 941 outw((media_status & ~(Media_10TP | Media_SQE)) | 942 media_tbl[dev->if_port].media_bits, 943 ioaddr + Wn4_Media); 944 945 EL3WINDOW(3); 946 config = inl(ioaddr + Wn3_Config); 947 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift); 948 outl(config, ioaddr + Wn3_Config); 949 950 outw(dev->if_port == 3 ? StartCoax : StopCoax, 951 ioaddr + EL3_CMD); 952 } 953 EL3WINDOW(old_window); 954 } 955 956 spin_unlock_irqrestore(&vp->lock, flags); 957 if (corkscrew_debug > 1) 958 pr_debug("%s: Media selection timer finished, %s.\n", 959 dev->name, media_tbl[dev->if_port].name); 960 961#endif /* AUTOMEDIA */ 962} 963 964static void corkscrew_timeout(struct net_device *dev) 965{ 966 int i; 967 struct corkscrew_private *vp = netdev_priv(dev); 968 int ioaddr = dev->base_addr; 969 970 pr_warning("%s: transmit timed out, tx_status %2.2x status %4.4x.\n", 971 dev->name, inb(ioaddr + TxStatus), 972 inw(ioaddr + EL3_STATUS)); 973 /* Slight code bloat to be user friendly. */ 974 if ((inb(ioaddr + TxStatus) & 0x88) == 0x88) 975 pr_warning("%s: Transmitter encountered 16 collisions --" 976 " network cable problem?\n", dev->name); 977#ifndef final_version 978 pr_debug(" Flags; bus-master %d, full %d; dirty %d current %d.\n", 979 vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx, 980 vp->cur_tx); 981 pr_debug(" Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr), 982 &vp->tx_ring[0]); 983 for (i = 0; i < TX_RING_SIZE; i++) { 984 pr_debug(" %d: %p length %8.8x status %8.8x\n", i, 985 &vp->tx_ring[i], 986 vp->tx_ring[i].length, vp->tx_ring[i].status); 987 } 988#endif 989 /* Issue TX_RESET and TX_START commands. */ 990 outw(TxReset, ioaddr + EL3_CMD); 991 for (i = 20; i >= 0; i--) 992 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress)) 993 break; 994 outw(TxEnable, ioaddr + EL3_CMD); 995 dev->trans_start = jiffies; /* prevent tx timeout */ 996 dev->stats.tx_errors++; 997 dev->stats.tx_dropped++; 998 netif_wake_queue(dev); 999} 1000 1001static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb, 1002 struct net_device *dev) 1003{ 1004 struct corkscrew_private *vp = netdev_priv(dev); 1005 int ioaddr = dev->base_addr; 1006 1007 /* Block a timer-based transmit from overlapping. */ 1008 1009 netif_stop_queue(dev); 1010 1011 if (vp->full_bus_master_tx) { /* BOOMERANG bus-master */ 1012 /* Calculate the next Tx descriptor entry. */ 1013 int entry = vp->cur_tx % TX_RING_SIZE; 1014 struct boom_tx_desc *prev_entry; 1015 unsigned long flags; 1016 int i; 1017 1018 if (vp->tx_full) /* No room to transmit with */ 1019 return NETDEV_TX_BUSY; 1020 if (vp->cur_tx != 0) 1021 prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE]; 1022 else 1023 prev_entry = NULL; 1024 if (corkscrew_debug > 3) 1025 pr_debug("%s: Trying to send a packet, Tx index %d.\n", 1026 dev->name, vp->cur_tx); 1027 /* vp->tx_full = 1; */ 1028 vp->tx_skbuff[entry] = skb; 1029 vp->tx_ring[entry].next = 0; 1030 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data); 1031 vp->tx_ring[entry].length = skb->len | 0x80000000; 1032 vp->tx_ring[entry].status = skb->len | 0x80000000; 1033 1034 spin_lock_irqsave(&vp->lock, flags); 1035 outw(DownStall, ioaddr + EL3_CMD); 1036 /* Wait for the stall to complete. */ 1037 for (i = 20; i >= 0; i--) 1038 if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0) 1039 break; 1040 if (prev_entry) 1041 prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]); 1042 if (inl(ioaddr + DownListPtr) == 0) { 1043 outl(isa_virt_to_bus(&vp->tx_ring[entry]), 1044 ioaddr + DownListPtr); 1045 queued_packet++; 1046 } 1047 outw(DownUnstall, ioaddr + EL3_CMD); 1048 spin_unlock_irqrestore(&vp->lock, flags); 1049 1050 vp->cur_tx++; 1051 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1) 1052 vp->tx_full = 1; 1053 else { /* Clear previous interrupt enable. */ 1054 if (prev_entry) 1055 prev_entry->status &= ~0x80000000; 1056 netif_wake_queue(dev); 1057 } 1058 return NETDEV_TX_OK; 1059 } 1060 /* Put out the doubleword header... */ 1061 outl(skb->len, ioaddr + TX_FIFO); 1062 dev->stats.tx_bytes += skb->len; 1063#ifdef VORTEX_BUS_MASTER 1064 if (vp->bus_master) { 1065 /* Set the bus-master controller to transfer the packet. */ 1066 outl((int) (skb->data), ioaddr + Wn7_MasterAddr); 1067 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen); 1068 vp->tx_skb = skb; 1069 outw(StartDMADown, ioaddr + EL3_CMD); 1070 /* queue will be woken at the DMADone interrupt. */ 1071 } else { 1072 /* ... and the packet rounded to a doubleword. */ 1073 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2); 1074 dev_kfree_skb(skb); 1075 if (inw(ioaddr + TxFree) > 1536) { 1076 netif_wake_queue(dev); 1077 } else 1078 /* Interrupt us when the FIFO has room for max-sized packet. */ 1079 outw(SetTxThreshold + (1536 >> 2), 1080 ioaddr + EL3_CMD); 1081 } 1082#else 1083 /* ... and the packet rounded to a doubleword. */ 1084 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2); 1085 dev_kfree_skb(skb); 1086 if (inw(ioaddr + TxFree) > 1536) { 1087 netif_wake_queue(dev); 1088 } else 1089 /* Interrupt us when the FIFO has room for max-sized packet. */ 1090 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD); 1091#endif /* bus master */ 1092 1093 1094 /* Clear the Tx status stack. */ 1095 { 1096 short tx_status; 1097 int i = 4; 1098 1099 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) { 1100 if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */ 1101 if (corkscrew_debug > 2) 1102 pr_debug("%s: Tx error, status %2.2x.\n", 1103 dev->name, tx_status); 1104 if (tx_status & 0x04) 1105 dev->stats.tx_fifo_errors++; 1106 if (tx_status & 0x38) 1107 dev->stats.tx_aborted_errors++; 1108 if (tx_status & 0x30) { 1109 int j; 1110 outw(TxReset, ioaddr + EL3_CMD); 1111 for (j = 20; j >= 0; j--) 1112 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress)) 1113 break; 1114 } 1115 outw(TxEnable, ioaddr + EL3_CMD); 1116 } 1117 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */ 1118 } 1119 } 1120 return NETDEV_TX_OK; 1121} 1122 1123/* The interrupt handler does all of the Rx thread work and cleans up 1124 after the Tx thread. */ 1125 1126static irqreturn_t corkscrew_interrupt(int irq, void *dev_id) 1127{ 1128 /* Use the now-standard shared IRQ implementation. */ 1129 struct net_device *dev = dev_id; 1130 struct corkscrew_private *lp = netdev_priv(dev); 1131 int ioaddr, status; 1132 int latency; 1133 int i = max_interrupt_work; 1134 1135 ioaddr = dev->base_addr; 1136 latency = inb(ioaddr + Timer); 1137 1138 spin_lock(&lp->lock); 1139 1140 status = inw(ioaddr + EL3_STATUS); 1141 1142 if (corkscrew_debug > 4) 1143 pr_debug("%s: interrupt, status %4.4x, timer %d.\n", 1144 dev->name, status, latency); 1145 if ((status & 0xE000) != 0xE000) { 1146 static int donedidthis; 1147 /* Some interrupt controllers store a bogus interrupt from boot-time. 1148 Ignore a single early interrupt, but don't hang the machine for 1149 other interrupt problems. */ 1150 if (donedidthis++ > 100) { 1151 pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n", 1152 dev->name, status, netif_running(dev)); 1153 free_irq(dev->irq, dev); 1154 dev->irq = -1; 1155 } 1156 } 1157 1158 do { 1159 if (corkscrew_debug > 5) 1160 pr_debug("%s: In interrupt loop, status %4.4x.\n", 1161 dev->name, status); 1162 if (status & RxComplete) 1163 corkscrew_rx(dev); 1164 1165 if (status & TxAvailable) { 1166 if (corkscrew_debug > 5) 1167 pr_debug(" TX room bit was handled.\n"); 1168 /* There's room in the FIFO for a full-sized packet. */ 1169 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD); 1170 netif_wake_queue(dev); 1171 } 1172 if (status & DownComplete) { 1173 unsigned int dirty_tx = lp->dirty_tx; 1174 1175 while (lp->cur_tx - dirty_tx > 0) { 1176 int entry = dirty_tx % TX_RING_SIZE; 1177 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry])) 1178 break; /* It still hasn't been processed. */ 1179 if (lp->tx_skbuff[entry]) { 1180 dev_kfree_skb_irq(lp->tx_skbuff[entry]); 1181 lp->tx_skbuff[entry] = NULL; 1182 } 1183 dirty_tx++; 1184 } 1185 lp->dirty_tx = dirty_tx; 1186 outw(AckIntr | DownComplete, ioaddr + EL3_CMD); 1187 if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) { 1188 lp->tx_full = 0; 1189 netif_wake_queue(dev); 1190 } 1191 } 1192#ifdef VORTEX_BUS_MASTER 1193 if (status & DMADone) { 1194 outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */ 1195 dev_kfree_skb_irq(lp->tx_skb); /* Release the transferred buffer */ 1196 netif_wake_queue(dev); 1197 } 1198#endif 1199 if (status & UpComplete) { 1200 boomerang_rx(dev); 1201 outw(AckIntr | UpComplete, ioaddr + EL3_CMD); 1202 } 1203 if (status & (AdapterFailure | RxEarly | StatsFull)) { 1204 /* Handle all uncommon interrupts at once. */ 1205 if (status & RxEarly) { /* Rx early is unused. */ 1206 corkscrew_rx(dev); 1207 outw(AckIntr | RxEarly, ioaddr + EL3_CMD); 1208 } 1209 if (status & StatsFull) { /* Empty statistics. */ 1210 static int DoneDidThat; 1211 if (corkscrew_debug > 4) 1212 pr_debug("%s: Updating stats.\n", dev->name); 1213 update_stats(ioaddr, dev); 1214 /* DEBUG HACK: Disable statistics as an interrupt source. */ 1215 /* This occurs when we have the wrong media type! */ 1216 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) { 1217 int win, reg; 1218 pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n", 1219 dev->name); 1220 for (win = 0; win < 8; win++) { 1221 EL3WINDOW(win); 1222 pr_notice("Vortex window %d:", win); 1223 for (reg = 0; reg < 16; reg++) 1224 pr_cont(" %2.2x", inb(ioaddr + reg)); 1225 pr_cont("\n"); 1226 } 1227 EL3WINDOW(7); 1228 outw(SetIntrEnb | TxAvailable | 1229 RxComplete | AdapterFailure | 1230 UpComplete | DownComplete | 1231 TxComplete, ioaddr + EL3_CMD); 1232 DoneDidThat++; 1233 } 1234 } 1235 if (status & AdapterFailure) { 1236 /* Adapter failure requires Rx reset and reinit. */ 1237 outw(RxReset, ioaddr + EL3_CMD); 1238 /* Set the Rx filter to the current state. */ 1239 set_rx_mode(dev); 1240 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */ 1241 outw(AckIntr | AdapterFailure, 1242 ioaddr + EL3_CMD); 1243 } 1244 } 1245 1246 if (--i < 0) { 1247 pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n", 1248 dev->name, status, SetStatusEnb | ((~status) & 0x7FE)); 1249 /* Disable all pending interrupts. */ 1250 outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD); 1251 outw(AckIntr | 0x7FF, ioaddr + EL3_CMD); 1252 break; 1253 } 1254 /* Acknowledge the IRQ. */ 1255 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); 1256 1257 } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete)); 1258 1259 spin_unlock(&lp->lock); 1260 1261 if (corkscrew_debug > 4) 1262 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status); 1263 return IRQ_HANDLED; 1264} 1265 1266static int corkscrew_rx(struct net_device *dev) 1267{ 1268 int ioaddr = dev->base_addr; 1269 int i; 1270 short rx_status; 1271 1272 if (corkscrew_debug > 5) 1273 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n", 1274 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus)); 1275 while ((rx_status = inw(ioaddr + RxStatus)) > 0) { 1276 if (rx_status & 0x4000) { /* Error, update stats. */ 1277 unsigned char rx_error = inb(ioaddr + RxErrors); 1278 if (corkscrew_debug > 2) 1279 pr_debug(" Rx error: status %2.2x.\n", 1280 rx_error); 1281 dev->stats.rx_errors++; 1282 if (rx_error & 0x01) 1283 dev->stats.rx_over_errors++; 1284 if (rx_error & 0x02) 1285 dev->stats.rx_length_errors++; 1286 if (rx_error & 0x04) 1287 dev->stats.rx_frame_errors++; 1288 if (rx_error & 0x08) 1289 dev->stats.rx_crc_errors++; 1290 if (rx_error & 0x10) 1291 dev->stats.rx_length_errors++; 1292 } else { 1293 /* The packet length: up to 4.5K!. */ 1294 short pkt_len = rx_status & 0x1fff; 1295 struct sk_buff *skb; 1296 1297 skb = netdev_alloc_skb(dev, pkt_len + 5 + 2); 1298 if (corkscrew_debug > 4) 1299 pr_debug("Receiving packet size %d status %4.4x.\n", 1300 pkt_len, rx_status); 1301 if (skb != NULL) { 1302 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */ 1303 /* 'skb_put()' points to the start of sk_buff data area. */ 1304 insl(ioaddr + RX_FIFO, 1305 skb_put(skb, pkt_len), 1306 (pkt_len + 3) >> 2); 1307 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */ 1308 skb->protocol = eth_type_trans(skb, dev); 1309 netif_rx(skb); 1310 dev->stats.rx_packets++; 1311 dev->stats.rx_bytes += pkt_len; 1312 /* Wait a limited time to go to next packet. */ 1313 for (i = 200; i >= 0; i--) 1314 if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress)) 1315 break; 1316 continue; 1317 } else if (corkscrew_debug) 1318 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len); 1319 } 1320 outw(RxDiscard, ioaddr + EL3_CMD); 1321 dev->stats.rx_dropped++; 1322 /* Wait a limited time to skip this packet. */ 1323 for (i = 200; i >= 0; i--) 1324 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress)) 1325 break; 1326 } 1327 return 0; 1328} 1329 1330static int boomerang_rx(struct net_device *dev) 1331{ 1332 struct corkscrew_private *vp = netdev_priv(dev); 1333 int entry = vp->cur_rx % RX_RING_SIZE; 1334 int ioaddr = dev->base_addr; 1335 int rx_status; 1336 1337 if (corkscrew_debug > 5) 1338 pr_debug(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n", 1339 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus)); 1340 while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) { 1341 if (rx_status & RxDError) { /* Error, update stats. */ 1342 unsigned char rx_error = rx_status >> 16; 1343 if (corkscrew_debug > 2) 1344 pr_debug(" Rx error: status %2.2x.\n", 1345 rx_error); 1346 dev->stats.rx_errors++; 1347 if (rx_error & 0x01) 1348 dev->stats.rx_over_errors++; 1349 if (rx_error & 0x02) 1350 dev->stats.rx_length_errors++; 1351 if (rx_error & 0x04) 1352 dev->stats.rx_frame_errors++; 1353 if (rx_error & 0x08) 1354 dev->stats.rx_crc_errors++; 1355 if (rx_error & 0x10) 1356 dev->stats.rx_length_errors++; 1357 } else { 1358 /* The packet length: up to 4.5K!. */ 1359 short pkt_len = rx_status & 0x1fff; 1360 struct sk_buff *skb; 1361 1362 dev->stats.rx_bytes += pkt_len; 1363 if (corkscrew_debug > 4) 1364 pr_debug("Receiving packet size %d status %4.4x.\n", 1365 pkt_len, rx_status); 1366 1367 /* Check if the packet is long enough to just accept without 1368 copying to a properly sized skbuff. */ 1369 if (pkt_len < rx_copybreak && 1370 (skb = netdev_alloc_skb(dev, pkt_len + 4)) != NULL) { 1371 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */ 1372 /* 'skb_put()' points to the start of sk_buff data area. */ 1373 memcpy(skb_put(skb, pkt_len), 1374 isa_bus_to_virt(vp->rx_ring[entry]. 1375 addr), pkt_len); 1376 rx_copy++; 1377 } else { 1378 void *temp; 1379 /* Pass up the skbuff already on the Rx ring. */ 1380 skb = vp->rx_skbuff[entry]; 1381 vp->rx_skbuff[entry] = NULL; 1382 temp = skb_put(skb, pkt_len); 1383 /* Remove this checking code for final release. */ 1384 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp) 1385 pr_warning("%s: Warning -- the skbuff addresses do not match" 1386 " in boomerang_rx: %p vs. %p / %p.\n", 1387 dev->name, 1388 isa_bus_to_virt(vp-> 1389 rx_ring[entry]. 1390 addr), skb->head, 1391 temp); 1392 rx_nocopy++; 1393 } 1394 skb->protocol = eth_type_trans(skb, dev); 1395 netif_rx(skb); 1396 dev->stats.rx_packets++; 1397 } 1398 entry = (++vp->cur_rx) % RX_RING_SIZE; 1399 } 1400 /* Refill the Rx ring buffers. */ 1401 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) { 1402 struct sk_buff *skb; 1403 entry = vp->dirty_rx % RX_RING_SIZE; 1404 if (vp->rx_skbuff[entry] == NULL) { 1405 skb = netdev_alloc_skb(dev, PKT_BUF_SZ); 1406 if (skb == NULL) 1407 break; /* Bad news! */ 1408 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */ 1409 vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data); 1410 vp->rx_skbuff[entry] = skb; 1411 } 1412 vp->rx_ring[entry].status = 0; /* Clear complete bit. */ 1413 } 1414 return 0; 1415} 1416 1417static int corkscrew_close(struct net_device *dev) 1418{ 1419 struct corkscrew_private *vp = netdev_priv(dev); 1420 int ioaddr = dev->base_addr; 1421 int i; 1422 1423 netif_stop_queue(dev); 1424 1425 if (corkscrew_debug > 1) { 1426 pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n", 1427 dev->name, inw(ioaddr + EL3_STATUS), 1428 inb(ioaddr + TxStatus)); 1429 pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n", 1430 dev->name, rx_nocopy, rx_copy, queued_packet); 1431 } 1432 1433 del_timer(&vp->timer); 1434 1435 /* Turn off statistics ASAP. We update lp->stats below. */ 1436 outw(StatsDisable, ioaddr + EL3_CMD); 1437 1438 /* Disable the receiver and transmitter. */ 1439 outw(RxDisable, ioaddr + EL3_CMD); 1440 outw(TxDisable, ioaddr + EL3_CMD); 1441 1442 if (dev->if_port == XCVR_10base2) 1443 /* Turn off thinnet power. Green! */ 1444 outw(StopCoax, ioaddr + EL3_CMD); 1445 1446 free_irq(dev->irq, dev); 1447 1448 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD); 1449 1450 update_stats(ioaddr, dev); 1451 if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */ 1452 outl(0, ioaddr + UpListPtr); 1453 for (i = 0; i < RX_RING_SIZE; i++) 1454 if (vp->rx_skbuff[i]) { 1455 dev_kfree_skb(vp->rx_skbuff[i]); 1456 vp->rx_skbuff[i] = NULL; 1457 } 1458 } 1459 if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */ 1460 outl(0, ioaddr + DownListPtr); 1461 for (i = 0; i < TX_RING_SIZE; i++) 1462 if (vp->tx_skbuff[i]) { 1463 dev_kfree_skb(vp->tx_skbuff[i]); 1464 vp->tx_skbuff[i] = NULL; 1465 } 1466 } 1467 1468 return 0; 1469} 1470 1471static struct net_device_stats *corkscrew_get_stats(struct net_device *dev) 1472{ 1473 struct corkscrew_private *vp = netdev_priv(dev); 1474 unsigned long flags; 1475 1476 if (netif_running(dev)) { 1477 spin_lock_irqsave(&vp->lock, flags); 1478 update_stats(dev->base_addr, dev); 1479 spin_unlock_irqrestore(&vp->lock, flags); 1480 } 1481 return &dev->stats; 1482} 1483 1484/* Update statistics. 1485 Unlike with the EL3 we need not worry about interrupts changing 1486 the window setting from underneath us, but we must still guard 1487 against a race condition with a StatsUpdate interrupt updating the 1488 table. This is done by checking that the ASM (!) code generated uses 1489 atomic updates with '+='. 1490 */ 1491static void update_stats(int ioaddr, struct net_device *dev) 1492{ 1493 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */ 1494 /* Switch to the stats window, and read everything. */ 1495 EL3WINDOW(6); 1496 dev->stats.tx_carrier_errors += inb(ioaddr + 0); 1497 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1); 1498 /* Multiple collisions. */ inb(ioaddr + 2); 1499 dev->stats.collisions += inb(ioaddr + 3); 1500 dev->stats.tx_window_errors += inb(ioaddr + 4); 1501 dev->stats.rx_fifo_errors += inb(ioaddr + 5); 1502 dev->stats.tx_packets += inb(ioaddr + 6); 1503 dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4; 1504 /* Rx packets */ inb(ioaddr + 7); 1505 /* Must read to clear */ 1506 /* Tx deferrals */ inb(ioaddr + 8); 1507 /* Don't bother with register 9, an extension of registers 6&7. 1508 If we do use the 6&7 values the atomic update assumption above 1509 is invalid. */ 1510 inw(ioaddr + 10); /* Total Rx and Tx octets. */ 1511 inw(ioaddr + 12); 1512 /* New: On the Vortex we must also clear the BadSSD counter. */ 1513 EL3WINDOW(4); 1514 inb(ioaddr + 12); 1515 1516 /* We change back to window 7 (not 1) with the Vortex. */ 1517 EL3WINDOW(7); 1518} 1519 1520/* This new version of set_rx_mode() supports v1.4 kernels. 1521 The Vortex chip has no documented multicast filter, so the only 1522 multicast setting is to receive all multicast frames. At least 1523 the chip has a very clean way to set the mode, unlike many others. */ 1524static void set_rx_mode(struct net_device *dev) 1525{ 1526 int ioaddr = dev->base_addr; 1527 short new_mode; 1528 1529 if (dev->flags & IFF_PROMISC) { 1530 if (corkscrew_debug > 3) 1531 pr_debug("%s: Setting promiscuous mode.\n", 1532 dev->name); 1533 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm; 1534 } else if (!netdev_mc_empty(dev) || dev->flags & IFF_ALLMULTI) { 1535 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast; 1536 } else 1537 new_mode = SetRxFilter | RxStation | RxBroadcast; 1538 1539 outw(new_mode, ioaddr + EL3_CMD); 1540} 1541 1542static void netdev_get_drvinfo(struct net_device *dev, 1543 struct ethtool_drvinfo *info) 1544{ 1545 strcpy(info->driver, DRV_NAME); 1546 strcpy(info->version, DRV_VERSION); 1547 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr); 1548} 1549 1550static u32 netdev_get_msglevel(struct net_device *dev) 1551{ 1552 return corkscrew_debug; 1553} 1554 1555static void netdev_set_msglevel(struct net_device *dev, u32 level) 1556{ 1557 corkscrew_debug = level; 1558} 1559 1560static const struct ethtool_ops netdev_ethtool_ops = { 1561 .get_drvinfo = netdev_get_drvinfo, 1562 .get_msglevel = netdev_get_msglevel, 1563 .set_msglevel = netdev_set_msglevel, 1564}; 1565 1566 1567#ifdef MODULE 1568void cleanup_module(void) 1569{ 1570 while (!list_empty(&root_corkscrew_dev)) { 1571 struct net_device *dev; 1572 struct corkscrew_private *vp; 1573 1574 vp = list_entry(root_corkscrew_dev.next, 1575 struct corkscrew_private, list); 1576 dev = vp->our_dev; 1577 unregister_netdev(dev); 1578 cleanup_card(dev); 1579 free_netdev(dev); 1580 } 1581} 1582#endif /* MODULE */ 1583