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 29 static char *version = 30 DRV_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. */ 37 static int rx_copybreak = 200; 38 39 /* Allow setting MTU to a larger size, bypassing the normal ethernet setup. */ 40 static const int mtu = 1500; 41 42 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */ 43 static 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 84 MODULE_AUTHOR("Donald Becker <becker@scyld.com>"); 85 MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver"); 86 MODULE_LICENSE("GPL"); 87 MODULE_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. */ 94 static 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 109 static int corkscrew_debug = DRIVER_DEBUG; 110 #else 111 static int corkscrew_debug = 1; 112 #endif 113 114 #define CORKSCREW_ID 10 115 116 /* 117 Theory of Operation 118 119 I. Board Compatibility 120 121 This device driver is designed for the 3Com 3c515 ISA Fast EtherLink XL, 122 3Com's ISA bus adapter for Fast Ethernet. Due to the unique I/O port layout, 123 it's not practical to integrate this driver with the other EtherLink drivers. 124 125 II. Board-specific settings 126 127 The Corkscrew has an EEPROM for configuration, but no special settings are 128 needed for Linux. 129 130 III. Driver operation 131 132 The 3c515 series use an interface that's very similar to the 3c900 "Boomerang" 133 PCI cards, with the bus master interface extensively modified to work with 134 the ISA bus. 135 136 The card is capable of full-bus-master transfers with separate 137 lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet, 138 DEC Tulip and Intel Speedo3. 139 140 This driver uses a "RX_COPYBREAK" scheme rather than a fixed intermediate 141 receive buffer. This scheme allocates full-sized skbuffs as receive 142 buffers. The value RX_COPYBREAK is used as the copying breakpoint: it is 143 chosen to trade-off the memory wasted by passing the full-sized skbuff to 144 the queue layer for all frames vs. the copying cost of copying a frame to a 145 correctly-sized skbuff. 146 147 148 IIIC. Synchronization 149 The driver runs as two independent, single-threaded flows of control. One 150 is the send-packet routine, which enforces single-threaded use by the netif 151 layer. The other thread is the interrupt handler, which is single 152 threaded by the hardware and other software. 153 154 IV. Notes 155 156 Thanks to Terry Murphy of 3Com for providing documentation and a development 157 board. 158 159 The names "Vortex", "Boomerang" and "Corkscrew" are the internal 3Com 160 project names. I use these names to eliminate confusion -- 3Com product 161 numbers and names are very similar and often confused. 162 163 The new chips support both ethernet (1.5K) and FDDI (4.5K) frame sizes! 164 This driver only supports ethernet frames because of the recent MTU limit 165 of 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 185 enum 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: */ 199 enum RxFilter { 200 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 201 }; 202 203 /* Bits in the general status register. */ 204 enum 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. */ 215 enum 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 }; 220 enum 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 }; 230 enum 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. */ 237 enum eeprom_offset { 238 PhysAddr01 = 0, PhysAddr23 = 1, PhysAddr45 = 2, ModelID = 3, 239 EtherLink3ID = 7, 240 }; 241 242 enum Window3 { /* Window 3: MAC/config bits. */ 243 Wn3_Config = 0, Wn3_MAC_Ctrl = 6, Wn3_Options = 8, 244 }; 245 enum 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 257 enum Window4 { 258 Wn4_NetDiag = 6, Wn4_Media = 10, /* Window 4: Xcvr/media bits. */ 259 }; 260 enum 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 }; 266 enum 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! */ 271 enum 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[]. */ 280 struct boom_rx_desc { 281 u32 next; 282 s32 status; 283 u32 addr; 284 s32 length; 285 }; 286 287 /* Values for the Rx status entry. */ 288 enum rx_desc_status { 289 RxDComplete = 0x00008000, RxDError = 0x4000, 290 /* See boomerang_rx() for actual error bits */ 291 }; 292 293 struct boom_tx_desc { 294 u32 next; 295 s32 status; 296 u32 addr; 297 s32 length; 298 }; 299 300 struct 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 */ 330 enum 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 335 static 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__ 354 static 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 361 MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters); 362 363 static int nopnp; 364 #endif /* __ISAPNP__ */ 365 366 static struct net_device *corkscrew_scan(int unit); 367 static int corkscrew_setup(struct net_device *dev, int ioaddr, 368 struct pnp_dev *idev, int card_number); 369 static int corkscrew_open(struct net_device *dev); 370 static void corkscrew_timer(unsigned long arg); 371 static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb, 372 struct net_device *dev); 373 static int corkscrew_rx(struct net_device *dev); 374 static void corkscrew_timeout(struct net_device *dev); 375 static int boomerang_rx(struct net_device *dev); 376 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id); 377 static int corkscrew_close(struct net_device *dev); 378 static void update_stats(int addr, struct net_device *dev); 379 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev); 380 static void set_rx_mode(struct net_device *dev); 381 static 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!! */ 398 static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, }; 399 400 #ifdef MODULE 401 static int debug = -1; 402 403 module_param(debug, int, 0); 404 module_param_array(options, int, NULL, 0); 405 module_param(rx_copybreak, int, 0); 406 module_param(max_interrupt_work, int, 0); 407 MODULE_PARM_DESC(debug, "3c515 debug level (0-6)"); 408 MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering"); 409 MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames"); 410 MODULE_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 */ 414 static LIST_HEAD(root_corkscrew_dev); 415 416 int 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 429 struct 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 446 static 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 472 static 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 484 static 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 } 546 no_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 566 static 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 579 static 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 707 static 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 = dev_alloc_skb(PKT_BUF_SZ); 830 vp->rx_skbuff[i] = skb; 831 if (skb == NULL) 832 break; /* Bad news! */ 833 skb->dev = dev; /* Mark as being used by this device. */ 834 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */ 835 vp->rx_ring[i].addr = isa_virt_to_bus(skb->data); 836 } 837 if (i != 0) 838 vp->rx_ring[i - 1].next = 839 isa_virt_to_bus(&vp->rx_ring[0]); /* Wrap the ring. */ 840 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr); 841 } 842 if (vp->full_bus_master_tx) { /* Boomerang bus master Tx. */ 843 vp->cur_tx = vp->dirty_tx = 0; 844 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold); /* Room for a packet. */ 845 /* Clear the Tx ring. */ 846 for (i = 0; i < TX_RING_SIZE; i++) 847 vp->tx_skbuff[i] = NULL; 848 outl(0, ioaddr + DownListPtr); 849 } 850 /* Set receiver mode: presumably accept b-case and phys addr only. */ 851 set_rx_mode(dev); 852 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */ 853 854 netif_start_queue(dev); 855 856 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */ 857 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */ 858 /* Allow status bits to be seen. */ 859 outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull | 860 (vp->full_bus_master_tx ? DownComplete : TxAvailable) | 861 (vp->full_bus_master_rx ? UpComplete : RxComplete) | 862 (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD); 863 /* Ack all pending events, and set active indicator mask. */ 864 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq, 865 ioaddr + EL3_CMD); 866 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull 867 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete, 868 ioaddr + EL3_CMD); 869 870 return 0; 871 } 872 873 static void corkscrew_timer(unsigned long data) 874 { 875 #ifdef AUTOMEDIA 876 struct net_device *dev = (struct net_device *) data; 877 struct corkscrew_private *vp = netdev_priv(dev); 878 int ioaddr = dev->base_addr; 879 unsigned long flags; 880 int ok = 0; 881 882 if (corkscrew_debug > 1) 883 pr_debug("%s: Media selection timer tick happened, %s.\n", 884 dev->name, media_tbl[dev->if_port].name); 885 886 spin_lock_irqsave(&vp->lock, flags); 887 888 { 889 int old_window = inw(ioaddr + EL3_CMD) >> 13; 890 int media_status; 891 EL3WINDOW(4); 892 media_status = inw(ioaddr + Wn4_Media); 893 switch (dev->if_port) { 894 case 0: 895 case 4: 896 case 5: /* 10baseT, 100baseTX, 100baseFX */ 897 if (media_status & Media_LnkBeat) { 898 ok = 1; 899 if (corkscrew_debug > 1) 900 pr_debug("%s: Media %s has link beat, %x.\n", 901 dev->name, 902 media_tbl[dev->if_port].name, 903 media_status); 904 } else if (corkscrew_debug > 1) 905 pr_debug("%s: Media %s is has no link beat, %x.\n", 906 dev->name, 907 media_tbl[dev->if_port].name, 908 media_status); 909 910 break; 911 default: /* Other media types handled by Tx timeouts. */ 912 if (corkscrew_debug > 1) 913 pr_debug("%s: Media %s is has no indication, %x.\n", 914 dev->name, 915 media_tbl[dev->if_port].name, 916 media_status); 917 ok = 1; 918 } 919 if (!ok) { 920 __u32 config; 921 922 do { 923 dev->if_port = 924 media_tbl[dev->if_port].next; 925 } 926 while (!(vp->available_media & media_tbl[dev->if_port].mask)); 927 928 if (dev->if_port == 8) { /* Go back to default. */ 929 dev->if_port = vp->default_media; 930 if (corkscrew_debug > 1) 931 pr_debug("%s: Media selection failing, using default %s port.\n", 932 dev->name, 933 media_tbl[dev->if_port].name); 934 } else { 935 if (corkscrew_debug > 1) 936 pr_debug("%s: Media selection failed, now trying %s port.\n", 937 dev->name, 938 media_tbl[dev->if_port].name); 939 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait; 940 add_timer(&vp->timer); 941 } 942 outw((media_status & ~(Media_10TP | Media_SQE)) | 943 media_tbl[dev->if_port].media_bits, 944 ioaddr + Wn4_Media); 945 946 EL3WINDOW(3); 947 config = inl(ioaddr + Wn3_Config); 948 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift); 949 outl(config, ioaddr + Wn3_Config); 950 951 outw(dev->if_port == 3 ? StartCoax : StopCoax, 952 ioaddr + EL3_CMD); 953 } 954 EL3WINDOW(old_window); 955 } 956 957 spin_unlock_irqrestore(&vp->lock, flags); 958 if (corkscrew_debug > 1) 959 pr_debug("%s: Media selection timer finished, %s.\n", 960 dev->name, media_tbl[dev->if_port].name); 961 962 #endif /* AUTOMEDIA */ 963 } 964 965 static void corkscrew_timeout(struct net_device *dev) 966 { 967 int i; 968 struct corkscrew_private *vp = netdev_priv(dev); 969 int ioaddr = dev->base_addr; 970 971 pr_warning("%s: transmit timed out, tx_status %2.2x status %4.4x.\n", 972 dev->name, inb(ioaddr + TxStatus), 973 inw(ioaddr + EL3_STATUS)); 974 /* Slight code bloat to be user friendly. */ 975 if ((inb(ioaddr + TxStatus) & 0x88) == 0x88) 976 pr_warning("%s: Transmitter encountered 16 collisions --" 977 " network cable problem?\n", dev->name); 978 #ifndef final_version 979 pr_debug(" Flags; bus-master %d, full %d; dirty %d current %d.\n", 980 vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx, 981 vp->cur_tx); 982 pr_debug(" Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr), 983 &vp->tx_ring[0]); 984 for (i = 0; i < TX_RING_SIZE; i++) { 985 pr_debug(" %d: %p length %8.8x status %8.8x\n", i, 986 &vp->tx_ring[i], 987 vp->tx_ring[i].length, vp->tx_ring[i].status); 988 } 989 #endif 990 /* Issue TX_RESET and TX_START commands. */ 991 outw(TxReset, ioaddr + EL3_CMD); 992 for (i = 20; i >= 0; i--) 993 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress)) 994 break; 995 outw(TxEnable, ioaddr + EL3_CMD); 996 dev->trans_start = jiffies; /* prevent tx timeout */ 997 dev->stats.tx_errors++; 998 dev->stats.tx_dropped++; 999 netif_wake_queue(dev); 1000 } 1001 1002 static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb, 1003 struct net_device *dev) 1004 { 1005 struct corkscrew_private *vp = netdev_priv(dev); 1006 int ioaddr = dev->base_addr; 1007 1008 /* Block a timer-based transmit from overlapping. */ 1009 1010 netif_stop_queue(dev); 1011 1012 if (vp->full_bus_master_tx) { /* BOOMERANG bus-master */ 1013 /* Calculate the next Tx descriptor entry. */ 1014 int entry = vp->cur_tx % TX_RING_SIZE; 1015 struct boom_tx_desc *prev_entry; 1016 unsigned long flags; 1017 int i; 1018 1019 if (vp->tx_full) /* No room to transmit with */ 1020 return NETDEV_TX_BUSY; 1021 if (vp->cur_tx != 0) 1022 prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE]; 1023 else 1024 prev_entry = NULL; 1025 if (corkscrew_debug > 3) 1026 pr_debug("%s: Trying to send a packet, Tx index %d.\n", 1027 dev->name, vp->cur_tx); 1028 /* vp->tx_full = 1; */ 1029 vp->tx_skbuff[entry] = skb; 1030 vp->tx_ring[entry].next = 0; 1031 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data); 1032 vp->tx_ring[entry].length = skb->len | 0x80000000; 1033 vp->tx_ring[entry].status = skb->len | 0x80000000; 1034 1035 spin_lock_irqsave(&vp->lock, flags); 1036 outw(DownStall, ioaddr + EL3_CMD); 1037 /* Wait for the stall to complete. */ 1038 for (i = 20; i >= 0; i--) 1039 if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0) 1040 break; 1041 if (prev_entry) 1042 prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]); 1043 if (inl(ioaddr + DownListPtr) == 0) { 1044 outl(isa_virt_to_bus(&vp->tx_ring[entry]), 1045 ioaddr + DownListPtr); 1046 queued_packet++; 1047 } 1048 outw(DownUnstall, ioaddr + EL3_CMD); 1049 spin_unlock_irqrestore(&vp->lock, flags); 1050 1051 vp->cur_tx++; 1052 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1) 1053 vp->tx_full = 1; 1054 else { /* Clear previous interrupt enable. */ 1055 if (prev_entry) 1056 prev_entry->status &= ~0x80000000; 1057 netif_wake_queue(dev); 1058 } 1059 return NETDEV_TX_OK; 1060 } 1061 /* Put out the doubleword header... */ 1062 outl(skb->len, ioaddr + TX_FIFO); 1063 dev->stats.tx_bytes += skb->len; 1064 #ifdef VORTEX_BUS_MASTER 1065 if (vp->bus_master) { 1066 /* Set the bus-master controller to transfer the packet. */ 1067 outl((int) (skb->data), ioaddr + Wn7_MasterAddr); 1068 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen); 1069 vp->tx_skb = skb; 1070 outw(StartDMADown, ioaddr + EL3_CMD); 1071 /* queue will be woken at the DMADone interrupt. */ 1072 } else { 1073 /* ... and the packet rounded to a doubleword. */ 1074 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2); 1075 dev_kfree_skb(skb); 1076 if (inw(ioaddr + TxFree) > 1536) { 1077 netif_wake_queue(dev); 1078 } else 1079 /* Interrupt us when the FIFO has room for max-sized packet. */ 1080 outw(SetTxThreshold + (1536 >> 2), 1081 ioaddr + EL3_CMD); 1082 } 1083 #else 1084 /* ... and the packet rounded to a doubleword. */ 1085 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2); 1086 dev_kfree_skb(skb); 1087 if (inw(ioaddr + TxFree) > 1536) { 1088 netif_wake_queue(dev); 1089 } else 1090 /* Interrupt us when the FIFO has room for max-sized packet. */ 1091 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD); 1092 #endif /* bus master */ 1093 1094 1095 /* Clear the Tx status stack. */ 1096 { 1097 short tx_status; 1098 int i = 4; 1099 1100 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) { 1101 if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */ 1102 if (corkscrew_debug > 2) 1103 pr_debug("%s: Tx error, status %2.2x.\n", 1104 dev->name, tx_status); 1105 if (tx_status & 0x04) 1106 dev->stats.tx_fifo_errors++; 1107 if (tx_status & 0x38) 1108 dev->stats.tx_aborted_errors++; 1109 if (tx_status & 0x30) { 1110 int j; 1111 outw(TxReset, ioaddr + EL3_CMD); 1112 for (j = 20; j >= 0; j--) 1113 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress)) 1114 break; 1115 } 1116 outw(TxEnable, ioaddr + EL3_CMD); 1117 } 1118 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */ 1119 } 1120 } 1121 return NETDEV_TX_OK; 1122 } 1123 1124 /* The interrupt handler does all of the Rx thread work and cleans up 1125 after the Tx thread. */ 1126 1127 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id) 1128 { 1129 /* Use the now-standard shared IRQ implementation. */ 1130 struct net_device *dev = dev_id; 1131 struct corkscrew_private *lp = netdev_priv(dev); 1132 int ioaddr, status; 1133 int latency; 1134 int i = max_interrupt_work; 1135 1136 ioaddr = dev->base_addr; 1137 latency = inb(ioaddr + Timer); 1138 1139 spin_lock(&lp->lock); 1140 1141 status = inw(ioaddr + EL3_STATUS); 1142 1143 if (corkscrew_debug > 4) 1144 pr_debug("%s: interrupt, status %4.4x, timer %d.\n", 1145 dev->name, status, latency); 1146 if ((status & 0xE000) != 0xE000) { 1147 static int donedidthis; 1148 /* Some interrupt controllers store a bogus interrupt from boot-time. 1149 Ignore a single early interrupt, but don't hang the machine for 1150 other interrupt problems. */ 1151 if (donedidthis++ > 100) { 1152 pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n", 1153 dev->name, status, netif_running(dev)); 1154 free_irq(dev->irq, dev); 1155 dev->irq = -1; 1156 } 1157 } 1158 1159 do { 1160 if (corkscrew_debug > 5) 1161 pr_debug("%s: In interrupt loop, status %4.4x.\n", 1162 dev->name, status); 1163 if (status & RxComplete) 1164 corkscrew_rx(dev); 1165 1166 if (status & TxAvailable) { 1167 if (corkscrew_debug > 5) 1168 pr_debug(" TX room bit was handled.\n"); 1169 /* There's room in the FIFO for a full-sized packet. */ 1170 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD); 1171 netif_wake_queue(dev); 1172 } 1173 if (status & DownComplete) { 1174 unsigned int dirty_tx = lp->dirty_tx; 1175 1176 while (lp->cur_tx - dirty_tx > 0) { 1177 int entry = dirty_tx % TX_RING_SIZE; 1178 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry])) 1179 break; /* It still hasn't been processed. */ 1180 if (lp->tx_skbuff[entry]) { 1181 dev_kfree_skb_irq(lp->tx_skbuff[entry]); 1182 lp->tx_skbuff[entry] = NULL; 1183 } 1184 dirty_tx++; 1185 } 1186 lp->dirty_tx = dirty_tx; 1187 outw(AckIntr | DownComplete, ioaddr + EL3_CMD); 1188 if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) { 1189 lp->tx_full = 0; 1190 netif_wake_queue(dev); 1191 } 1192 } 1193 #ifdef VORTEX_BUS_MASTER 1194 if (status & DMADone) { 1195 outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */ 1196 dev_kfree_skb_irq(lp->tx_skb); /* Release the transferred buffer */ 1197 netif_wake_queue(dev); 1198 } 1199 #endif 1200 if (status & UpComplete) { 1201 boomerang_rx(dev); 1202 outw(AckIntr | UpComplete, ioaddr + EL3_CMD); 1203 } 1204 if (status & (AdapterFailure | RxEarly | StatsFull)) { 1205 /* Handle all uncommon interrupts at once. */ 1206 if (status & RxEarly) { /* Rx early is unused. */ 1207 corkscrew_rx(dev); 1208 outw(AckIntr | RxEarly, ioaddr + EL3_CMD); 1209 } 1210 if (status & StatsFull) { /* Empty statistics. */ 1211 static int DoneDidThat; 1212 if (corkscrew_debug > 4) 1213 pr_debug("%s: Updating stats.\n", dev->name); 1214 update_stats(ioaddr, dev); 1215 /* DEBUG HACK: Disable statistics as an interrupt source. */ 1216 /* This occurs when we have the wrong media type! */ 1217 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) { 1218 int win, reg; 1219 pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n", 1220 dev->name); 1221 for (win = 0; win < 8; win++) { 1222 EL3WINDOW(win); 1223 pr_notice("Vortex window %d:", win); 1224 for (reg = 0; reg < 16; reg++) 1225 pr_cont(" %2.2x", inb(ioaddr + reg)); 1226 pr_cont("\n"); 1227 } 1228 EL3WINDOW(7); 1229 outw(SetIntrEnb | TxAvailable | 1230 RxComplete | AdapterFailure | 1231 UpComplete | DownComplete | 1232 TxComplete, ioaddr + EL3_CMD); 1233 DoneDidThat++; 1234 } 1235 } 1236 if (status & AdapterFailure) { 1237 /* Adapter failure requires Rx reset and reinit. */ 1238 outw(RxReset, ioaddr + EL3_CMD); 1239 /* Set the Rx filter to the current state. */ 1240 set_rx_mode(dev); 1241 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */ 1242 outw(AckIntr | AdapterFailure, 1243 ioaddr + EL3_CMD); 1244 } 1245 } 1246 1247 if (--i < 0) { 1248 pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n", 1249 dev->name, status, SetStatusEnb | ((~status) & 0x7FE)); 1250 /* Disable all pending interrupts. */ 1251 outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD); 1252 outw(AckIntr | 0x7FF, ioaddr + EL3_CMD); 1253 break; 1254 } 1255 /* Acknowledge the IRQ. */ 1256 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); 1257 1258 } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete)); 1259 1260 spin_unlock(&lp->lock); 1261 1262 if (corkscrew_debug > 4) 1263 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status); 1264 return IRQ_HANDLED; 1265 } 1266 1267 static int corkscrew_rx(struct net_device *dev) 1268 { 1269 int ioaddr = dev->base_addr; 1270 int i; 1271 short rx_status; 1272 1273 if (corkscrew_debug > 5) 1274 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n", 1275 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus)); 1276 while ((rx_status = inw(ioaddr + RxStatus)) > 0) { 1277 if (rx_status & 0x4000) { /* Error, update stats. */ 1278 unsigned char rx_error = inb(ioaddr + RxErrors); 1279 if (corkscrew_debug > 2) 1280 pr_debug(" Rx error: status %2.2x.\n", 1281 rx_error); 1282 dev->stats.rx_errors++; 1283 if (rx_error & 0x01) 1284 dev->stats.rx_over_errors++; 1285 if (rx_error & 0x02) 1286 dev->stats.rx_length_errors++; 1287 if (rx_error & 0x04) 1288 dev->stats.rx_frame_errors++; 1289 if (rx_error & 0x08) 1290 dev->stats.rx_crc_errors++; 1291 if (rx_error & 0x10) 1292 dev->stats.rx_length_errors++; 1293 } else { 1294 /* The packet length: up to 4.5K!. */ 1295 short pkt_len = rx_status & 0x1fff; 1296 struct sk_buff *skb; 1297 1298 skb = dev_alloc_skb(pkt_len + 5 + 2); 1299 if (corkscrew_debug > 4) 1300 pr_debug("Receiving packet size %d status %4.4x.\n", 1301 pkt_len, rx_status); 1302 if (skb != NULL) { 1303 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */ 1304 /* 'skb_put()' points to the start of sk_buff data area. */ 1305 insl(ioaddr + RX_FIFO, 1306 skb_put(skb, pkt_len), 1307 (pkt_len + 3) >> 2); 1308 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */ 1309 skb->protocol = eth_type_trans(skb, dev); 1310 netif_rx(skb); 1311 dev->stats.rx_packets++; 1312 dev->stats.rx_bytes += pkt_len; 1313 /* Wait a limited time to go to next packet. */ 1314 for (i = 200; i >= 0; i--) 1315 if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress)) 1316 break; 1317 continue; 1318 } else if (corkscrew_debug) 1319 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len); 1320 } 1321 outw(RxDiscard, ioaddr + EL3_CMD); 1322 dev->stats.rx_dropped++; 1323 /* Wait a limited time to skip this packet. */ 1324 for (i = 200; i >= 0; i--) 1325 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress)) 1326 break; 1327 } 1328 return 0; 1329 } 1330 1331 static int boomerang_rx(struct net_device *dev) 1332 { 1333 struct corkscrew_private *vp = netdev_priv(dev); 1334 int entry = vp->cur_rx % RX_RING_SIZE; 1335 int ioaddr = dev->base_addr; 1336 int rx_status; 1337 1338 if (corkscrew_debug > 5) 1339 pr_debug(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n", 1340 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus)); 1341 while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) { 1342 if (rx_status & RxDError) { /* Error, update stats. */ 1343 unsigned char rx_error = rx_status >> 16; 1344 if (corkscrew_debug > 2) 1345 pr_debug(" Rx error: status %2.2x.\n", 1346 rx_error); 1347 dev->stats.rx_errors++; 1348 if (rx_error & 0x01) 1349 dev->stats.rx_over_errors++; 1350 if (rx_error & 0x02) 1351 dev->stats.rx_length_errors++; 1352 if (rx_error & 0x04) 1353 dev->stats.rx_frame_errors++; 1354 if (rx_error & 0x08) 1355 dev->stats.rx_crc_errors++; 1356 if (rx_error & 0x10) 1357 dev->stats.rx_length_errors++; 1358 } else { 1359 /* The packet length: up to 4.5K!. */ 1360 short pkt_len = rx_status & 0x1fff; 1361 struct sk_buff *skb; 1362 1363 dev->stats.rx_bytes += pkt_len; 1364 if (corkscrew_debug > 4) 1365 pr_debug("Receiving packet size %d status %4.4x.\n", 1366 pkt_len, rx_status); 1367 1368 /* Check if the packet is long enough to just accept without 1369 copying to a properly sized skbuff. */ 1370 if (pkt_len < rx_copybreak && 1371 (skb = dev_alloc_skb(pkt_len + 4)) != NULL) { 1372 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */ 1373 /* 'skb_put()' points to the start of sk_buff data area. */ 1374 memcpy(skb_put(skb, pkt_len), 1375 isa_bus_to_virt(vp->rx_ring[entry]. 1376 addr), pkt_len); 1377 rx_copy++; 1378 } else { 1379 void *temp; 1380 /* Pass up the skbuff already on the Rx ring. */ 1381 skb = vp->rx_skbuff[entry]; 1382 vp->rx_skbuff[entry] = NULL; 1383 temp = skb_put(skb, pkt_len); 1384 /* Remove this checking code for final release. */ 1385 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp) 1386 pr_warning("%s: Warning -- the skbuff addresses do not match" 1387 " in boomerang_rx: %p vs. %p / %p.\n", 1388 dev->name, 1389 isa_bus_to_virt(vp-> 1390 rx_ring[entry]. 1391 addr), skb->head, 1392 temp); 1393 rx_nocopy++; 1394 } 1395 skb->protocol = eth_type_trans(skb, dev); 1396 netif_rx(skb); 1397 dev->stats.rx_packets++; 1398 } 1399 entry = (++vp->cur_rx) % RX_RING_SIZE; 1400 } 1401 /* Refill the Rx ring buffers. */ 1402 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) { 1403 struct sk_buff *skb; 1404 entry = vp->dirty_rx % RX_RING_SIZE; 1405 if (vp->rx_skbuff[entry] == NULL) { 1406 skb = dev_alloc_skb(PKT_BUF_SZ); 1407 if (skb == NULL) 1408 break; /* Bad news! */ 1409 skb->dev = dev; /* Mark as being used by this device. */ 1410 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */ 1411 vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data); 1412 vp->rx_skbuff[entry] = skb; 1413 } 1414 vp->rx_ring[entry].status = 0; /* Clear complete bit. */ 1415 } 1416 return 0; 1417 } 1418 1419 static int corkscrew_close(struct net_device *dev) 1420 { 1421 struct corkscrew_private *vp = netdev_priv(dev); 1422 int ioaddr = dev->base_addr; 1423 int i; 1424 1425 netif_stop_queue(dev); 1426 1427 if (corkscrew_debug > 1) { 1428 pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n", 1429 dev->name, inw(ioaddr + EL3_STATUS), 1430 inb(ioaddr + TxStatus)); 1431 pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n", 1432 dev->name, rx_nocopy, rx_copy, queued_packet); 1433 } 1434 1435 del_timer(&vp->timer); 1436 1437 /* Turn off statistics ASAP. We update lp->stats below. */ 1438 outw(StatsDisable, ioaddr + EL3_CMD); 1439 1440 /* Disable the receiver and transmitter. */ 1441 outw(RxDisable, ioaddr + EL3_CMD); 1442 outw(TxDisable, ioaddr + EL3_CMD); 1443 1444 if (dev->if_port == XCVR_10base2) 1445 /* Turn off thinnet power. Green! */ 1446 outw(StopCoax, ioaddr + EL3_CMD); 1447 1448 free_irq(dev->irq, dev); 1449 1450 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD); 1451 1452 update_stats(ioaddr, dev); 1453 if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */ 1454 outl(0, ioaddr + UpListPtr); 1455 for (i = 0; i < RX_RING_SIZE; i++) 1456 if (vp->rx_skbuff[i]) { 1457 dev_kfree_skb(vp->rx_skbuff[i]); 1458 vp->rx_skbuff[i] = NULL; 1459 } 1460 } 1461 if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */ 1462 outl(0, ioaddr + DownListPtr); 1463 for (i = 0; i < TX_RING_SIZE; i++) 1464 if (vp->tx_skbuff[i]) { 1465 dev_kfree_skb(vp->tx_skbuff[i]); 1466 vp->tx_skbuff[i] = NULL; 1467 } 1468 } 1469 1470 return 0; 1471 } 1472 1473 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev) 1474 { 1475 struct corkscrew_private *vp = netdev_priv(dev); 1476 unsigned long flags; 1477 1478 if (netif_running(dev)) { 1479 spin_lock_irqsave(&vp->lock, flags); 1480 update_stats(dev->base_addr, dev); 1481 spin_unlock_irqrestore(&vp->lock, flags); 1482 } 1483 return &dev->stats; 1484 } 1485 1486 /* Update statistics. 1487 Unlike with the EL3 we need not worry about interrupts changing 1488 the window setting from underneath us, but we must still guard 1489 against a race condition with a StatsUpdate interrupt updating the 1490 table. This is done by checking that the ASM (!) code generated uses 1491 atomic updates with '+='. 1492 */ 1493 static void update_stats(int ioaddr, struct net_device *dev) 1494 { 1495 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */ 1496 /* Switch to the stats window, and read everything. */ 1497 EL3WINDOW(6); 1498 dev->stats.tx_carrier_errors += inb(ioaddr + 0); 1499 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1); 1500 /* Multiple collisions. */ inb(ioaddr + 2); 1501 dev->stats.collisions += inb(ioaddr + 3); 1502 dev->stats.tx_window_errors += inb(ioaddr + 4); 1503 dev->stats.rx_fifo_errors += inb(ioaddr + 5); 1504 dev->stats.tx_packets += inb(ioaddr + 6); 1505 dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4; 1506 /* Rx packets */ inb(ioaddr + 7); 1507 /* Must read to clear */ 1508 /* Tx deferrals */ inb(ioaddr + 8); 1509 /* Don't bother with register 9, an extension of registers 6&7. 1510 If we do use the 6&7 values the atomic update assumption above 1511 is invalid. */ 1512 inw(ioaddr + 10); /* Total Rx and Tx octets. */ 1513 inw(ioaddr + 12); 1514 /* New: On the Vortex we must also clear the BadSSD counter. */ 1515 EL3WINDOW(4); 1516 inb(ioaddr + 12); 1517 1518 /* We change back to window 7 (not 1) with the Vortex. */ 1519 EL3WINDOW(7); 1520 } 1521 1522 /* This new version of set_rx_mode() supports v1.4 kernels. 1523 The Vortex chip has no documented multicast filter, so the only 1524 multicast setting is to receive all multicast frames. At least 1525 the chip has a very clean way to set the mode, unlike many others. */ 1526 static void set_rx_mode(struct net_device *dev) 1527 { 1528 int ioaddr = dev->base_addr; 1529 short new_mode; 1530 1531 if (dev->flags & IFF_PROMISC) { 1532 if (corkscrew_debug > 3) 1533 pr_debug("%s: Setting promiscuous mode.\n", 1534 dev->name); 1535 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm; 1536 } else if (!netdev_mc_empty(dev) || dev->flags & IFF_ALLMULTI) { 1537 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast; 1538 } else 1539 new_mode = SetRxFilter | RxStation | RxBroadcast; 1540 1541 outw(new_mode, ioaddr + EL3_CMD); 1542 } 1543 1544 static void netdev_get_drvinfo(struct net_device *dev, 1545 struct ethtool_drvinfo *info) 1546 { 1547 strcpy(info->driver, DRV_NAME); 1548 strcpy(info->version, DRV_VERSION); 1549 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr); 1550 } 1551 1552 static u32 netdev_get_msglevel(struct net_device *dev) 1553 { 1554 return corkscrew_debug; 1555 } 1556 1557 static void netdev_set_msglevel(struct net_device *dev, u32 level) 1558 { 1559 corkscrew_debug = level; 1560 } 1561 1562 static const struct ethtool_ops netdev_ethtool_ops = { 1563 .get_drvinfo = netdev_get_drvinfo, 1564 .get_msglevel = netdev_get_msglevel, 1565 .set_msglevel = netdev_set_msglevel, 1566 }; 1567 1568 1569 #ifdef MODULE 1570 void cleanup_module(void) 1571 { 1572 while (!list_empty(&root_corkscrew_dev)) { 1573 struct net_device *dev; 1574 struct corkscrew_private *vp; 1575 1576 vp = list_entry(root_corkscrew_dev.next, 1577 struct corkscrew_private, list); 1578 dev = vp->our_dev; 1579 unregister_netdev(dev); 1580 cleanup_card(dev); 1581 free_netdev(dev); 1582 } 1583 } 1584 #endif /* MODULE */ 1585