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