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