1/* 3c574.c: A PCMCIA ethernet driver for the 3com 3c574 "RoadRunner". 2 3 Written 1993-1998 by 4 Donald Becker, becker@scyld.com, (driver core) and 5 David Hinds, dahinds@users.sourceforge.net (from his PC card code). 6 Locking fixes (C) Copyright 2003 Red Hat Inc 7 8 This software may be used and distributed according to the terms of 9 the GNU General Public License, incorporated herein by reference. 10 11 This driver derives from Donald Becker's 3c509 core, which has the 12 following copyright: 13 Copyright 1993 United States Government as represented by the 14 Director, National Security Agency. 15 16 17*/ 18 19/* 20 Theory of Operation 21 22I. Board Compatibility 23 24This device driver is designed for the 3Com 3c574 PC card Fast Ethernet 25Adapter. 26 27II. Board-specific settings 28 29None -- PC cards are autoconfigured. 30 31III. Driver operation 32 33The 3c574 uses a Boomerang-style interface, without the bus-master capability. 34See the Boomerang driver and documentation for most details. 35 36IV. Notes and chip documentation. 37 38Two added registers are used to enhance PIO performance, RunnerRdCtrl and 39RunnerWrCtrl. These are 11 bit down-counters that are preloaded with the 40count of word (16 bits) reads or writes the driver is about to do to the Rx 41or Tx FIFO. The chip is then able to hide the internal-PCI-bus to PC-card 42translation latency by buffering the I/O operations with an 8 word FIFO. 43Note: No other chip accesses are permitted when this buffer is used. 44 45A second enhancement is that both attribute and common memory space 460x0800-0x0fff can translated to the PIO FIFO. Thus memory operations (faster 47with *some* PCcard bridges) may be used instead of I/O operations. 48This is enabled by setting the 0x10 bit in the PCMCIA LAN COR. 49 50Some slow PC card bridges work better if they never see a WAIT signal. 51This is configured by setting the 0x20 bit in the PCMCIA LAN COR. 52Only do this after testing that it is reliable and improves performance. 53 54The upper five bits of RunnerRdCtrl are used to window into PCcard 55configuration space registers. Window 0 is the regular Boomerang/Odie 56register set, 1-5 are various PC card control registers, and 16-31 are 57the (reversed!) CIS table. 58 59A final note: writing the InternalConfig register in window 3 with an 60invalid ramWidth is Very Bad. 61 62V. References 63 64http://www.scyld.com/expert/NWay.html 65http://www.national.com/pf/DP/DP83840.html 66 67Thanks to Terry Murphy of 3Com for providing development information for 68earlier 3Com products. 69 70*/ 71 72#include <linux/module.h> 73#include <linux/kernel.h> 74#include <linux/init.h> 75#include <linux/slab.h> 76#include <linux/string.h> 77#include <linux/timer.h> 78#include <linux/interrupt.h> 79#include <linux/in.h> 80#include <linux/delay.h> 81#include <linux/netdevice.h> 82#include <linux/etherdevice.h> 83#include <linux/skbuff.h> 84#include <linux/if_arp.h> 85#include <linux/ioport.h> 86#include <linux/ethtool.h> 87#include <linux/bitops.h> 88#include <linux/mii.h> 89 90#include <pcmcia/cs.h> 91#include <pcmcia/cistpl.h> 92#include <pcmcia/cisreg.h> 93#include <pcmcia/ciscode.h> 94#include <pcmcia/ds.h> 95 96#include <asm/uaccess.h> 97#include <asm/io.h> 98#include <asm/system.h> 99 100/*====================================================================*/ 101 102/* Module parameters */ 103 104MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>"); 105MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver"); 106MODULE_LICENSE("GPL"); 107 108#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0) 109 110/* Maximum events (Rx packets, etc.) to handle at each interrupt. */ 111INT_MODULE_PARM(max_interrupt_work, 32); 112 113/* Force full duplex modes? */ 114INT_MODULE_PARM(full_duplex, 0); 115 116/* Autodetect link polarity reversal? */ 117INT_MODULE_PARM(auto_polarity, 1); 118 119 120/*====================================================================*/ 121 122/* Time in jiffies before concluding the transmitter is hung. */ 123#define TX_TIMEOUT ((800*HZ)/1000) 124 125/* To minimize the size of the driver source and make the driver more 126 readable not all constants are symbolically defined. 127 You'll need the manual if you want to understand driver details anyway. */ 128/* Offsets from base I/O address. */ 129#define EL3_DATA 0x00 130#define EL3_CMD 0x0e 131#define EL3_STATUS 0x0e 132 133#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD) 134 135/* The top five bits written to EL3_CMD are a command, the lower 136 11 bits are the parameter, if applicable. */ 137enum el3_cmds { 138 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11, 139 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11, 140 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11, 141 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11, 142 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11, 143 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11, 144 StatsDisable = 22<<11, StopCoax = 23<<11, 145}; 146 147enum elxl_status { 148 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004, 149 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020, 150 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000 }; 151 152/* The SetRxFilter command accepts the following classes: */ 153enum RxFilter { 154 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 155}; 156 157enum Window0 { 158 Wn0EepromCmd = 10, Wn0EepromData = 12, /* EEPROM command/address, data. */ 159 IntrStatus=0x0E, /* Valid in all windows. */ 160}; 161/* These assumes the larger EEPROM. */ 162enum Win0_EEPROM_cmds { 163 EEPROM_Read = 0x200, EEPROM_WRITE = 0x100, EEPROM_ERASE = 0x300, 164 EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */ 165 EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */ 166}; 167 168/* Register window 1 offsets, the window used in normal operation. 169 On the "Odie" this window is always mapped at offsets 0x10-0x1f. 170 Except for TxFree, which is overlapped by RunnerWrCtrl. */ 171enum Window1 { 172 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14, 173 RxStatus = 0x18, Timer=0x1A, TxStatus = 0x1B, 174 TxFree = 0x0C, /* Remaining free bytes in Tx buffer. */ 175 RunnerRdCtrl = 0x16, RunnerWrCtrl = 0x1c, 176}; 177 178enum Window3 { /* Window 3: MAC/config bits. */ 179 Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8, 180}; 181enum wn3_config { 182 Ram_size = 7, 183 Ram_width = 8, 184 Ram_speed = 0x30, 185 Rom_size = 0xc0, 186 Ram_split_shift = 16, 187 Ram_split = 3 << Ram_split_shift, 188 Xcvr_shift = 20, 189 Xcvr = 7 << Xcvr_shift, 190 Autoselect = 0x1000000, 191}; 192 193enum Window4 { /* Window 4: Xcvr/media bits. */ 194 Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10, 195}; 196 197#define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */ 198 199struct el3_private { 200 struct pcmcia_device *p_dev; 201 u16 advertising, partner; /* NWay media advertisement */ 202 unsigned char phys; /* MII device address */ 203 unsigned int autoselect:1, default_media:3; /* Read from the EEPROM/Wn3_Config. */ 204 /* for transceiver monitoring */ 205 struct timer_list media; 206 unsigned short media_status; 207 unsigned short fast_poll; 208 unsigned long last_irq; 209 spinlock_t window_lock; /* Guards the Window selection */ 210}; 211 212/* Set iff a MII transceiver on any interface requires mdio preamble. 213 This only set with the original DP83840 on older 3c905 boards, so the extra 214 code size of a per-interface flag is not worthwhile. */ 215static char mii_preamble_required = 0; 216 217/* Index of functions. */ 218 219static int tc574_config(struct pcmcia_device *link); 220static void tc574_release(struct pcmcia_device *link); 221 222static void mdio_sync(unsigned int ioaddr, int bits); 223static int mdio_read(unsigned int ioaddr, int phy_id, int location); 224static void mdio_write(unsigned int ioaddr, int phy_id, int location, 225 int value); 226static unsigned short read_eeprom(unsigned int ioaddr, int index); 227static void tc574_wait_for_completion(struct net_device *dev, int cmd); 228 229static void tc574_reset(struct net_device *dev); 230static void media_check(unsigned long arg); 231static int el3_open(struct net_device *dev); 232static netdev_tx_t el3_start_xmit(struct sk_buff *skb, 233 struct net_device *dev); 234static irqreturn_t el3_interrupt(int irq, void *dev_id); 235static void update_stats(struct net_device *dev); 236static struct net_device_stats *el3_get_stats(struct net_device *dev); 237static int el3_rx(struct net_device *dev, int worklimit); 238static int el3_close(struct net_device *dev); 239static void el3_tx_timeout(struct net_device *dev); 240static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); 241static const struct ethtool_ops netdev_ethtool_ops; 242static void set_rx_mode(struct net_device *dev); 243static void set_multicast_list(struct net_device *dev); 244 245static void tc574_detach(struct pcmcia_device *p_dev); 246 247/* 248 tc574_attach() creates an "instance" of the driver, allocating 249 local data structures for one device. The device is registered 250 with Card Services. 251*/ 252static const struct net_device_ops el3_netdev_ops = { 253 .ndo_open = el3_open, 254 .ndo_stop = el3_close, 255 .ndo_start_xmit = el3_start_xmit, 256 .ndo_tx_timeout = el3_tx_timeout, 257 .ndo_get_stats = el3_get_stats, 258 .ndo_do_ioctl = el3_ioctl, 259 .ndo_set_multicast_list = set_multicast_list, 260 .ndo_change_mtu = eth_change_mtu, 261 .ndo_set_mac_address = eth_mac_addr, 262 .ndo_validate_addr = eth_validate_addr, 263}; 264 265static int tc574_probe(struct pcmcia_device *link) 266{ 267 struct el3_private *lp; 268 struct net_device *dev; 269 270 dev_dbg(&link->dev, "3c574_attach()\n"); 271 272 /* Create the PC card device object. */ 273 dev = alloc_etherdev(sizeof(struct el3_private)); 274 if (!dev) 275 return -ENOMEM; 276 lp = netdev_priv(dev); 277 link->priv = dev; 278 lp->p_dev = link; 279 280 spin_lock_init(&lp->window_lock); 281 link->resource[0]->end = 32; 282 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16; 283 link->conf.Attributes = CONF_ENABLE_IRQ; 284 link->conf.IntType = INT_MEMORY_AND_IO; 285 link->conf.ConfigIndex = 1; 286 287 dev->netdev_ops = &el3_netdev_ops; 288 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops); 289 dev->watchdog_timeo = TX_TIMEOUT; 290 291 return tc574_config(link); 292} /* tc574_attach */ 293 294/* 295 296 This deletes a driver "instance". The device is de-registered 297 with Card Services. If it has been released, all local data 298 structures are freed. Otherwise, the structures will be freed 299 when the device is released. 300 301*/ 302 303static void tc574_detach(struct pcmcia_device *link) 304{ 305 struct net_device *dev = link->priv; 306 307 dev_dbg(&link->dev, "3c574_detach()\n"); 308 309 unregister_netdev(dev); 310 311 tc574_release(link); 312 313 free_netdev(dev); 314} /* tc574_detach */ 315 316/* 317 tc574_config() is scheduled to run after a CARD_INSERTION event 318 is received, to configure the PCMCIA socket, and to make the 319 ethernet device available to the system. 320*/ 321 322static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"}; 323 324static int tc574_config(struct pcmcia_device *link) 325{ 326 struct net_device *dev = link->priv; 327 struct el3_private *lp = netdev_priv(dev); 328 int ret, i, j; 329 unsigned int ioaddr; 330 __be16 *phys_addr; 331 char *cardname; 332 __u32 config; 333 u8 *buf; 334 size_t len; 335 336 phys_addr = (__be16 *)dev->dev_addr; 337 338 dev_dbg(&link->dev, "3c574_config()\n"); 339 340 link->io_lines = 16; 341 342 for (i = j = 0; j < 0x400; j += 0x20) { 343 link->resource[0]->start = j ^ 0x300; 344 i = pcmcia_request_io(link); 345 if (i == 0) 346 break; 347 } 348 if (i != 0) 349 goto failed; 350 351 ret = pcmcia_request_irq(link, el3_interrupt); 352 if (ret) 353 goto failed; 354 355 ret = pcmcia_request_configuration(link, &link->conf); 356 if (ret) 357 goto failed; 358 359 dev->irq = link->irq; 360 dev->base_addr = link->resource[0]->start; 361 362 ioaddr = dev->base_addr; 363 364 /* The 3c574 normally uses an EEPROM for configuration info, including 365 the hardware address. The future products may include a modem chip 366 and put the address in the CIS. */ 367 368 len = pcmcia_get_tuple(link, 0x88, &buf); 369 if (buf && len >= 6) { 370 for (i = 0; i < 3; i++) 371 phys_addr[i] = htons(le16_to_cpu(buf[i * 2])); 372 kfree(buf); 373 } else { 374 kfree(buf); /* 0 < len < 6 */ 375 EL3WINDOW(0); 376 for (i = 0; i < 3; i++) 377 phys_addr[i] = htons(read_eeprom(ioaddr, i + 10)); 378 if (phys_addr[0] == htons(0x6060)) { 379 printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx" 380 "-0x%03lx\n", dev->base_addr, dev->base_addr+15); 381 goto failed; 382 } 383 } 384 if (link->prod_id[1]) 385 cardname = link->prod_id[1]; 386 else 387 cardname = "3Com 3c574"; 388 389 { 390 u_char mcr; 391 outw(2<<11, ioaddr + RunnerRdCtrl); 392 mcr = inb(ioaddr + 2); 393 outw(0<<11, ioaddr + RunnerRdCtrl); 394 printk(KERN_INFO " ASIC rev %d,", mcr>>3); 395 EL3WINDOW(3); 396 config = inl(ioaddr + Wn3_Config); 397 lp->default_media = (config & Xcvr) >> Xcvr_shift; 398 lp->autoselect = config & Autoselect ? 1 : 0; 399 } 400 401 init_timer(&lp->media); 402 403 { 404 int phy; 405 406 /* Roadrunner only: Turn on the MII transceiver */ 407 outw(0x8040, ioaddr + Wn3_Options); 408 mdelay(1); 409 outw(0xc040, ioaddr + Wn3_Options); 410 tc574_wait_for_completion(dev, TxReset); 411 tc574_wait_for_completion(dev, RxReset); 412 mdelay(1); 413 outw(0x8040, ioaddr + Wn3_Options); 414 415 EL3WINDOW(4); 416 for (phy = 1; phy <= 32; phy++) { 417 int mii_status; 418 mdio_sync(ioaddr, 32); 419 mii_status = mdio_read(ioaddr, phy & 0x1f, 1); 420 if (mii_status != 0xffff) { 421 lp->phys = phy & 0x1f; 422 dev_dbg(&link->dev, " MII transceiver at " 423 "index %d, status %x.\n", 424 phy, mii_status); 425 if ((mii_status & 0x0040) == 0) 426 mii_preamble_required = 1; 427 break; 428 } 429 } 430 if (phy > 32) { 431 printk(KERN_NOTICE " No MII transceivers found!\n"); 432 goto failed; 433 } 434 i = mdio_read(ioaddr, lp->phys, 16) | 0x40; 435 mdio_write(ioaddr, lp->phys, 16, i); 436 lp->advertising = mdio_read(ioaddr, lp->phys, 4); 437 if (full_duplex) { 438 /* Only advertise the FD media types. */ 439 lp->advertising &= ~0x02a0; 440 mdio_write(ioaddr, lp->phys, 4, lp->advertising); 441 } 442 } 443 444 SET_NETDEV_DEV(dev, &link->dev); 445 446 if (register_netdev(dev) != 0) { 447 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n"); 448 goto failed; 449 } 450 451 printk(KERN_INFO "%s: %s at io %#3lx, irq %d, " 452 "hw_addr %pM.\n", 453 dev->name, cardname, dev->base_addr, dev->irq, 454 dev->dev_addr); 455 printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n", 456 8 << config & Ram_size, 457 ram_split[(config & Ram_split) >> Ram_split_shift], 458 config & Autoselect ? "autoselect " : ""); 459 460 return 0; 461 462failed: 463 tc574_release(link); 464 return -ENODEV; 465 466} /* tc574_config */ 467 468/* 469 After a card is removed, tc574_release() will unregister the net 470 device, and release the PCMCIA configuration. If the device is 471 still open, this will be postponed until it is closed. 472*/ 473 474static void tc574_release(struct pcmcia_device *link) 475{ 476 pcmcia_disable_device(link); 477} 478 479static int tc574_suspend(struct pcmcia_device *link) 480{ 481 struct net_device *dev = link->priv; 482 483 if (link->open) 484 netif_device_detach(dev); 485 486 return 0; 487} 488 489static int tc574_resume(struct pcmcia_device *link) 490{ 491 struct net_device *dev = link->priv; 492 493 if (link->open) { 494 tc574_reset(dev); 495 netif_device_attach(dev); 496 } 497 498 return 0; 499} 500 501static void dump_status(struct net_device *dev) 502{ 503 unsigned int ioaddr = dev->base_addr; 504 EL3WINDOW(1); 505 printk(KERN_INFO " irq status %04x, rx status %04x, tx status " 506 "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS), 507 inw(ioaddr+RxStatus), inb(ioaddr+TxStatus), 508 inw(ioaddr+TxFree)); 509 EL3WINDOW(4); 510 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x" 511 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06), 512 inw(ioaddr+0x08), inw(ioaddr+0x0a)); 513 EL3WINDOW(1); 514} 515 516/* 517 Use this for commands that may take time to finish 518*/ 519static void tc574_wait_for_completion(struct net_device *dev, int cmd) 520{ 521 int i = 1500; 522 outw(cmd, dev->base_addr + EL3_CMD); 523 while (--i > 0) 524 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break; 525 if (i == 0) 526 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd); 527} 528 529/* Read a word from the EEPROM using the regular EEPROM access register. 530 Assume that we are in register window zero. 531 */ 532static unsigned short read_eeprom(unsigned int ioaddr, int index) 533{ 534 int timer; 535 outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd); 536 /* Pause for at least 162 usec for the read to take place. */ 537 for (timer = 1620; timer >= 0; timer--) { 538 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0) 539 break; 540 } 541 return inw(ioaddr + Wn0EepromData); 542} 543 544/* MII transceiver control section. 545 Read and write the MII registers using software-generated serial 546 MDIO protocol. See the MII specifications or DP83840A data sheet 547 for details. 548 The maxium data clock rate is 2.5 Mhz. The timing is easily met by the 549 slow PC card interface. */ 550 551#define MDIO_SHIFT_CLK 0x01 552#define MDIO_DIR_WRITE 0x04 553#define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE) 554#define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE) 555#define MDIO_DATA_READ 0x02 556#define MDIO_ENB_IN 0x00 557 558/* Generate the preamble required for initial synchronization and 559 a few older transceivers. */ 560static void mdio_sync(unsigned int ioaddr, int bits) 561{ 562 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt; 563 564 /* Establish sync by sending at least 32 logic ones. */ 565 while (-- bits >= 0) { 566 outw(MDIO_DATA_WRITE1, mdio_addr); 567 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr); 568 } 569} 570 571static int mdio_read(unsigned int ioaddr, int phy_id, int location) 572{ 573 int i; 574 int read_cmd = (0xf6 << 10) | (phy_id << 5) | location; 575 unsigned int retval = 0; 576 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt; 577 578 if (mii_preamble_required) 579 mdio_sync(ioaddr, 32); 580 581 /* Shift the read command bits out. */ 582 for (i = 14; i >= 0; i--) { 583 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0; 584 outw(dataval, mdio_addr); 585 outw(dataval | MDIO_SHIFT_CLK, mdio_addr); 586 } 587 /* Read the two transition, 16 data, and wire-idle bits. */ 588 for (i = 19; i > 0; i--) { 589 outw(MDIO_ENB_IN, mdio_addr); 590 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0); 591 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr); 592 } 593 return (retval>>1) & 0xffff; 594} 595 596static void mdio_write(unsigned int ioaddr, int phy_id, int location, int value) 597{ 598 int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value; 599 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt; 600 int i; 601 602 if (mii_preamble_required) 603 mdio_sync(ioaddr, 32); 604 605 /* Shift the command bits out. */ 606 for (i = 31; i >= 0; i--) { 607 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0; 608 outw(dataval, mdio_addr); 609 outw(dataval | MDIO_SHIFT_CLK, mdio_addr); 610 } 611 /* Leave the interface idle. */ 612 for (i = 1; i >= 0; i--) { 613 outw(MDIO_ENB_IN, mdio_addr); 614 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr); 615 } 616} 617 618/* Reset and restore all of the 3c574 registers. */ 619static void tc574_reset(struct net_device *dev) 620{ 621 struct el3_private *lp = netdev_priv(dev); 622 int i; 623 unsigned int ioaddr = dev->base_addr; 624 unsigned long flags; 625 626 tc574_wait_for_completion(dev, TotalReset|0x10); 627 628 spin_lock_irqsave(&lp->window_lock, flags); 629 /* Clear any transactions in progress. */ 630 outw(0, ioaddr + RunnerWrCtrl); 631 outw(0, ioaddr + RunnerRdCtrl); 632 633 /* Set the station address and mask. */ 634 EL3WINDOW(2); 635 for (i = 0; i < 6; i++) 636 outb(dev->dev_addr[i], ioaddr + i); 637 for (; i < 12; i+=2) 638 outw(0, ioaddr + i); 639 640 /* Reset config options */ 641 EL3WINDOW(3); 642 outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl); 643 outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b, 644 ioaddr + Wn3_Config); 645 /* Roadrunner only: Turn on the MII transceiver. */ 646 outw(0x8040, ioaddr + Wn3_Options); 647 mdelay(1); 648 outw(0xc040, ioaddr + Wn3_Options); 649 EL3WINDOW(1); 650 spin_unlock_irqrestore(&lp->window_lock, flags); 651 652 tc574_wait_for_completion(dev, TxReset); 653 tc574_wait_for_completion(dev, RxReset); 654 mdelay(1); 655 spin_lock_irqsave(&lp->window_lock, flags); 656 EL3WINDOW(3); 657 outw(0x8040, ioaddr + Wn3_Options); 658 659 /* Switch to the stats window, and clear all stats by reading. */ 660 outw(StatsDisable, ioaddr + EL3_CMD); 661 EL3WINDOW(6); 662 for (i = 0; i < 10; i++) 663 inb(ioaddr + i); 664 inw(ioaddr + 10); 665 inw(ioaddr + 12); 666 EL3WINDOW(4); 667 inb(ioaddr + 12); 668 inb(ioaddr + 13); 669 670 /* .. enable any extra statistics bits.. */ 671 outw(0x0040, ioaddr + Wn4_NetDiag); 672 673 EL3WINDOW(1); 674 spin_unlock_irqrestore(&lp->window_lock, flags); 675 676 /* .. re-sync MII and re-fill what NWay is advertising. */ 677 mdio_sync(ioaddr, 32); 678 mdio_write(ioaddr, lp->phys, 4, lp->advertising); 679 if (!auto_polarity) { 680 /* works for TDK 78Q2120 series MII's */ 681 i = mdio_read(ioaddr, lp->phys, 16) | 0x20; 682 mdio_write(ioaddr, lp->phys, 16, i); 683 } 684 685 spin_lock_irqsave(&lp->window_lock, flags); 686 /* Switch to register set 1 for normal use, just for TxFree. */ 687 set_rx_mode(dev); 688 spin_unlock_irqrestore(&lp->window_lock, flags); 689 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */ 690 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */ 691 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */ 692 /* Allow status bits to be seen. */ 693 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD); 694 /* Ack all pending events, and set active indicator mask. */ 695 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq, 696 ioaddr + EL3_CMD); 697 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull 698 | AdapterFailure | RxEarly, ioaddr + EL3_CMD); 699} 700 701static int el3_open(struct net_device *dev) 702{ 703 struct el3_private *lp = netdev_priv(dev); 704 struct pcmcia_device *link = lp->p_dev; 705 706 if (!pcmcia_dev_present(link)) 707 return -ENODEV; 708 709 link->open++; 710 netif_start_queue(dev); 711 712 tc574_reset(dev); 713 lp->media.function = &media_check; 714 lp->media.data = (unsigned long) dev; 715 lp->media.expires = jiffies + HZ; 716 add_timer(&lp->media); 717 718 dev_dbg(&link->dev, "%s: opened, status %4.4x.\n", 719 dev->name, inw(dev->base_addr + EL3_STATUS)); 720 721 return 0; 722} 723 724static void el3_tx_timeout(struct net_device *dev) 725{ 726 unsigned int ioaddr = dev->base_addr; 727 728 printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name); 729 dump_status(dev); 730 dev->stats.tx_errors++; 731 dev->trans_start = jiffies; /* prevent tx timeout */ 732 /* Issue TX_RESET and TX_START commands. */ 733 tc574_wait_for_completion(dev, TxReset); 734 outw(TxEnable, ioaddr + EL3_CMD); 735 netif_wake_queue(dev); 736} 737 738static void pop_tx_status(struct net_device *dev) 739{ 740 unsigned int ioaddr = dev->base_addr; 741 int i; 742 743 /* Clear the Tx status stack. */ 744 for (i = 32; i > 0; i--) { 745 u_char tx_status = inb(ioaddr + TxStatus); 746 if (!(tx_status & 0x84)) 747 break; 748 /* reset transmitter on jabber error or underrun */ 749 if (tx_status & 0x30) 750 tc574_wait_for_completion(dev, TxReset); 751 if (tx_status & 0x38) { 752 pr_debug("%s: transmit error: status 0x%02x\n", 753 dev->name, tx_status); 754 outw(TxEnable, ioaddr + EL3_CMD); 755 dev->stats.tx_aborted_errors++; 756 } 757 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */ 758 } 759} 760 761static netdev_tx_t el3_start_xmit(struct sk_buff *skb, 762 struct net_device *dev) 763{ 764 unsigned int ioaddr = dev->base_addr; 765 struct el3_private *lp = netdev_priv(dev); 766 unsigned long flags; 767 768 pr_debug("%s: el3_start_xmit(length = %ld) called, " 769 "status %4.4x.\n", dev->name, (long)skb->len, 770 inw(ioaddr + EL3_STATUS)); 771 772 spin_lock_irqsave(&lp->window_lock, flags); 773 774 dev->stats.tx_bytes += skb->len; 775 776 /* Put out the doubleword header... */ 777 outw(skb->len, ioaddr + TX_FIFO); 778 outw(0, ioaddr + TX_FIFO); 779 /* ... and the packet rounded to a doubleword. */ 780 outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2); 781 782 /* TxFree appears only in Window 1, not offset 0x1c. */ 783 if (inw(ioaddr + TxFree) <= 1536) { 784 netif_stop_queue(dev); 785 /* Interrupt us when the FIFO has room for max-sized packet. 786 The threshold is in units of dwords. */ 787 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD); 788 } 789 790 pop_tx_status(dev); 791 spin_unlock_irqrestore(&lp->window_lock, flags); 792 dev_kfree_skb(skb); 793 return NETDEV_TX_OK; 794} 795 796/* The EL3 interrupt handler. */ 797static irqreturn_t el3_interrupt(int irq, void *dev_id) 798{ 799 struct net_device *dev = (struct net_device *) dev_id; 800 struct el3_private *lp = netdev_priv(dev); 801 unsigned int ioaddr; 802 unsigned status; 803 int work_budget = max_interrupt_work; 804 int handled = 0; 805 806 if (!netif_device_present(dev)) 807 return IRQ_NONE; 808 ioaddr = dev->base_addr; 809 810 pr_debug("%s: interrupt, status %4.4x.\n", 811 dev->name, inw(ioaddr + EL3_STATUS)); 812 813 spin_lock(&lp->window_lock); 814 815 while ((status = inw(ioaddr + EL3_STATUS)) & 816 (IntLatch | RxComplete | RxEarly | StatsFull)) { 817 if (!netif_device_present(dev) || 818 ((status & 0xe000) != 0x2000)) { 819 pr_debug("%s: Interrupt from dead card\n", dev->name); 820 break; 821 } 822 823 handled = 1; 824 825 if (status & RxComplete) 826 work_budget = el3_rx(dev, work_budget); 827 828 if (status & TxAvailable) { 829 pr_debug(" TX room bit was handled.\n"); 830 /* There's room in the FIFO for a full-sized packet. */ 831 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD); 832 netif_wake_queue(dev); 833 } 834 835 if (status & TxComplete) 836 pop_tx_status(dev); 837 838 if (status & (AdapterFailure | RxEarly | StatsFull)) { 839 /* Handle all uncommon interrupts. */ 840 if (status & StatsFull) 841 update_stats(dev); 842 if (status & RxEarly) { 843 work_budget = el3_rx(dev, work_budget); 844 outw(AckIntr | RxEarly, ioaddr + EL3_CMD); 845 } 846 if (status & AdapterFailure) { 847 u16 fifo_diag; 848 EL3WINDOW(4); 849 fifo_diag = inw(ioaddr + Wn4_FIFODiag); 850 EL3WINDOW(1); 851 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic" 852 " register %04x.\n", dev->name, fifo_diag); 853 if (fifo_diag & 0x0400) { 854 /* Tx overrun */ 855 tc574_wait_for_completion(dev, TxReset); 856 outw(TxEnable, ioaddr + EL3_CMD); 857 } 858 if (fifo_diag & 0x2000) { 859 /* Rx underrun */ 860 tc574_wait_for_completion(dev, RxReset); 861 set_rx_mode(dev); 862 outw(RxEnable, ioaddr + EL3_CMD); 863 } 864 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD); 865 } 866 } 867 868 if (--work_budget < 0) { 869 pr_debug("%s: Too much work in interrupt, " 870 "status %4.4x.\n", dev->name, status); 871 /* Clear all interrupts */ 872 outw(AckIntr | 0xFF, ioaddr + EL3_CMD); 873 break; 874 } 875 /* Acknowledge the IRQ. */ 876 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); 877 } 878 879 pr_debug("%s: exiting interrupt, status %4.4x.\n", 880 dev->name, inw(ioaddr + EL3_STATUS)); 881 882 spin_unlock(&lp->window_lock); 883 return IRQ_RETVAL(handled); 884} 885 886/* 887 This timer serves two purposes: to check for missed interrupts 888 (and as a last resort, poll the NIC for events), and to monitor 889 the MII, reporting changes in cable status. 890*/ 891static void media_check(unsigned long arg) 892{ 893 struct net_device *dev = (struct net_device *) arg; 894 struct el3_private *lp = netdev_priv(dev); 895 unsigned int ioaddr = dev->base_addr; 896 unsigned long flags; 897 unsigned short /* cable, */ media, partner; 898 899 if (!netif_device_present(dev)) 900 goto reschedule; 901 902 /* Check for pending interrupt with expired latency timer: with 903 this, we can limp along even if the interrupt is blocked */ 904 if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) { 905 if (!lp->fast_poll) 906 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name); 907 908 local_irq_save(flags); 909 el3_interrupt(dev->irq, dev); 910 local_irq_restore(flags); 911 912 lp->fast_poll = HZ; 913 } 914 if (lp->fast_poll) { 915 lp->fast_poll--; 916 lp->media.expires = jiffies + 2*HZ/100; 917 add_timer(&lp->media); 918 return; 919 } 920 921 spin_lock_irqsave(&lp->window_lock, flags); 922 EL3WINDOW(4); 923 media = mdio_read(ioaddr, lp->phys, 1); 924 partner = mdio_read(ioaddr, lp->phys, 5); 925 EL3WINDOW(1); 926 927 if (media != lp->media_status) { 928 if ((media ^ lp->media_status) & 0x0004) 929 printk(KERN_INFO "%s: %s link beat\n", dev->name, 930 (lp->media_status & 0x0004) ? "lost" : "found"); 931 if ((media ^ lp->media_status) & 0x0020) { 932 lp->partner = 0; 933 if (lp->media_status & 0x0020) { 934 printk(KERN_INFO "%s: autonegotiation restarted\n", 935 dev->name); 936 } else if (partner) { 937 partner &= lp->advertising; 938 lp->partner = partner; 939 printk(KERN_INFO "%s: autonegotiation complete: " 940 "%sbaseT-%cD selected\n", dev->name, 941 ((partner & 0x0180) ? "100" : "10"), 942 ((partner & 0x0140) ? 'F' : 'H')); 943 } else { 944 printk(KERN_INFO "%s: link partner did not autonegotiate\n", 945 dev->name); 946 } 947 948 EL3WINDOW(3); 949 outb((partner & 0x0140 ? 0x20 : 0) | 950 (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl); 951 EL3WINDOW(1); 952 953 } 954 if (media & 0x0010) 955 printk(KERN_INFO "%s: remote fault detected\n", 956 dev->name); 957 if (media & 0x0002) 958 printk(KERN_INFO "%s: jabber detected\n", dev->name); 959 lp->media_status = media; 960 } 961 spin_unlock_irqrestore(&lp->window_lock, flags); 962 963reschedule: 964 lp->media.expires = jiffies + HZ; 965 add_timer(&lp->media); 966} 967 968static struct net_device_stats *el3_get_stats(struct net_device *dev) 969{ 970 struct el3_private *lp = netdev_priv(dev); 971 972 if (netif_device_present(dev)) { 973 unsigned long flags; 974 spin_lock_irqsave(&lp->window_lock, flags); 975 update_stats(dev); 976 spin_unlock_irqrestore(&lp->window_lock, flags); 977 } 978 return &dev->stats; 979} 980 981/* Update statistics. 982 Suprisingly this need not be run single-threaded, but it effectively is. 983 The counters clear when read, so the adds must merely be atomic. 984 */ 985static void update_stats(struct net_device *dev) 986{ 987 unsigned int ioaddr = dev->base_addr; 988 u8 rx, tx, up; 989 990 pr_debug("%s: updating the statistics.\n", dev->name); 991 992 if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */ 993 return; 994 995 /* Unlike the 3c509 we need not turn off stats updates while reading. */ 996 /* Switch to the stats window, and read everything. */ 997 EL3WINDOW(6); 998 dev->stats.tx_carrier_errors += inb(ioaddr + 0); 999 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1); 1000 /* Multiple collisions. */ inb(ioaddr + 2); 1001 dev->stats.collisions += inb(ioaddr + 3); 1002 dev->stats.tx_window_errors += inb(ioaddr + 4); 1003 dev->stats.rx_fifo_errors += inb(ioaddr + 5); 1004 dev->stats.tx_packets += inb(ioaddr + 6); 1005 up = inb(ioaddr + 9); 1006 dev->stats.tx_packets += (up&0x30) << 4; 1007 /* Rx packets */ inb(ioaddr + 7); 1008 /* Tx deferrals */ inb(ioaddr + 8); 1009 rx = inw(ioaddr + 10); 1010 tx = inw(ioaddr + 12); 1011 1012 EL3WINDOW(4); 1013 /* BadSSD */ inb(ioaddr + 12); 1014 up = inb(ioaddr + 13); 1015 1016 EL3WINDOW(1); 1017} 1018 1019static int el3_rx(struct net_device *dev, int worklimit) 1020{ 1021 unsigned int ioaddr = dev->base_addr; 1022 short rx_status; 1023 1024 pr_debug("%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n", 1025 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus)); 1026 while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) && 1027 worklimit > 0) { 1028 worklimit--; 1029 if (rx_status & 0x4000) { /* Error, update stats. */ 1030 short error = rx_status & 0x3800; 1031 dev->stats.rx_errors++; 1032 switch (error) { 1033 case 0x0000: dev->stats.rx_over_errors++; break; 1034 case 0x0800: dev->stats.rx_length_errors++; break; 1035 case 0x1000: dev->stats.rx_frame_errors++; break; 1036 case 0x1800: dev->stats.rx_length_errors++; break; 1037 case 0x2000: dev->stats.rx_frame_errors++; break; 1038 case 0x2800: dev->stats.rx_crc_errors++; break; 1039 } 1040 } else { 1041 short pkt_len = rx_status & 0x7ff; 1042 struct sk_buff *skb; 1043 1044 skb = dev_alloc_skb(pkt_len+5); 1045 1046 pr_debug(" Receiving packet size %d status %4.4x.\n", 1047 pkt_len, rx_status); 1048 if (skb != NULL) { 1049 skb_reserve(skb, 2); 1050 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len), 1051 ((pkt_len+3)>>2)); 1052 skb->protocol = eth_type_trans(skb, dev); 1053 netif_rx(skb); 1054 dev->stats.rx_packets++; 1055 dev->stats.rx_bytes += pkt_len; 1056 } else { 1057 pr_debug("%s: couldn't allocate a sk_buff of" 1058 " size %d.\n", dev->name, pkt_len); 1059 dev->stats.rx_dropped++; 1060 } 1061 } 1062 tc574_wait_for_completion(dev, RxDiscard); 1063 } 1064 1065 return worklimit; 1066} 1067 1068static void netdev_get_drvinfo(struct net_device *dev, 1069 struct ethtool_drvinfo *info) 1070{ 1071 strcpy(info->driver, "3c574_cs"); 1072} 1073 1074static const struct ethtool_ops netdev_ethtool_ops = { 1075 .get_drvinfo = netdev_get_drvinfo, 1076}; 1077 1078/* Provide ioctl() calls to examine the MII xcvr state. */ 1079static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 1080{ 1081 struct el3_private *lp = netdev_priv(dev); 1082 unsigned int ioaddr = dev->base_addr; 1083 struct mii_ioctl_data *data = if_mii(rq); 1084 int phy = lp->phys & 0x1f; 1085 1086 pr_debug("%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n", 1087 dev->name, rq->ifr_ifrn.ifrn_name, cmd, 1088 data->phy_id, data->reg_num, data->val_in, data->val_out); 1089 1090 switch(cmd) { 1091 case SIOCGMIIPHY: /* Get the address of the PHY in use. */ 1092 data->phy_id = phy; 1093 case SIOCGMIIREG: /* Read the specified MII register. */ 1094 { 1095 int saved_window; 1096 unsigned long flags; 1097 1098 spin_lock_irqsave(&lp->window_lock, flags); 1099 saved_window = inw(ioaddr + EL3_CMD) >> 13; 1100 EL3WINDOW(4); 1101 data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f, 1102 data->reg_num & 0x1f); 1103 EL3WINDOW(saved_window); 1104 spin_unlock_irqrestore(&lp->window_lock, flags); 1105 return 0; 1106 } 1107 case SIOCSMIIREG: /* Write the specified MII register */ 1108 { 1109 int saved_window; 1110 unsigned long flags; 1111 1112 spin_lock_irqsave(&lp->window_lock, flags); 1113 saved_window = inw(ioaddr + EL3_CMD) >> 13; 1114 EL3WINDOW(4); 1115 mdio_write(ioaddr, data->phy_id & 0x1f, 1116 data->reg_num & 0x1f, data->val_in); 1117 EL3WINDOW(saved_window); 1118 spin_unlock_irqrestore(&lp->window_lock, flags); 1119 return 0; 1120 } 1121 default: 1122 return -EOPNOTSUPP; 1123 } 1124} 1125 1126/* The Odie chip has a 64 bin multicast filter, but the bit layout is not 1127 documented. Until it is we revert to receiving all multicast frames when 1128 any multicast reception is desired. 1129 Note: My other drivers emit a log message whenever promiscuous mode is 1130 entered to help detect password sniffers. This is less desirable on 1131 typical PC card machines, so we omit the message. 1132 */ 1133 1134static void set_rx_mode(struct net_device *dev) 1135{ 1136 unsigned int ioaddr = dev->base_addr; 1137 1138 if (dev->flags & IFF_PROMISC) 1139 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm, 1140 ioaddr + EL3_CMD); 1141 else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI)) 1142 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD); 1143 else 1144 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD); 1145} 1146 1147static void set_multicast_list(struct net_device *dev) 1148{ 1149 struct el3_private *lp = netdev_priv(dev); 1150 unsigned long flags; 1151 1152 spin_lock_irqsave(&lp->window_lock, flags); 1153 set_rx_mode(dev); 1154 spin_unlock_irqrestore(&lp->window_lock, flags); 1155} 1156 1157static int el3_close(struct net_device *dev) 1158{ 1159 unsigned int ioaddr = dev->base_addr; 1160 struct el3_private *lp = netdev_priv(dev); 1161 struct pcmcia_device *link = lp->p_dev; 1162 1163 dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name); 1164 1165 if (pcmcia_dev_present(link)) { 1166 unsigned long flags; 1167 1168 /* Turn off statistics ASAP. We update lp->stats below. */ 1169 outw(StatsDisable, ioaddr + EL3_CMD); 1170 1171 /* Disable the receiver and transmitter. */ 1172 outw(RxDisable, ioaddr + EL3_CMD); 1173 outw(TxDisable, ioaddr + EL3_CMD); 1174 1175 /* Note: Switching to window 0 may disable the IRQ. */ 1176 EL3WINDOW(0); 1177 spin_lock_irqsave(&lp->window_lock, flags); 1178 update_stats(dev); 1179 spin_unlock_irqrestore(&lp->window_lock, flags); 1180 1181 /* force interrupts off */ 1182 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD); 1183 } 1184 1185 link->open--; 1186 netif_stop_queue(dev); 1187 del_timer_sync(&lp->media); 1188 1189 return 0; 1190} 1191 1192static struct pcmcia_device_id tc574_ids[] = { 1193 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574), 1194 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "cis/3CCFEM556.cis"), 1195 PCMCIA_DEVICE_NULL, 1196}; 1197MODULE_DEVICE_TABLE(pcmcia, tc574_ids); 1198 1199static struct pcmcia_driver tc574_driver = { 1200 .owner = THIS_MODULE, 1201 .drv = { 1202 .name = "3c574_cs", 1203 }, 1204 .probe = tc574_probe, 1205 .remove = tc574_detach, 1206 .id_table = tc574_ids, 1207 .suspend = tc574_suspend, 1208 .resume = tc574_resume, 1209}; 1210 1211static int __init init_tc574(void) 1212{ 1213 return pcmcia_register_driver(&tc574_driver); 1214} 1215 1216static void __exit exit_tc574(void) 1217{ 1218 pcmcia_unregister_driver(&tc574_driver); 1219} 1220 1221module_init(init_tc574); 1222module_exit(exit_tc574); 1223