1 /* via-rhine.c: A Linux Ethernet device driver for VIA Rhine family chips. */ 2 /* 3 Written 1998-2001 by Donald Becker. 4 5 Current Maintainer: Roger Luethi <rl@hellgate.ch> 6 7 This software may be used and distributed according to the terms of 8 the GNU General Public License (GPL), incorporated herein by reference. 9 Drivers based on or derived from this code fall under the GPL and must 10 retain the authorship, copyright and license notice. This file is not 11 a complete program and may only be used when the entire operating 12 system is licensed under the GPL. 13 14 This driver is designed for the VIA VT86C100A Rhine-I. 15 It also works with the Rhine-II (6102) and Rhine-III (6105/6105L/6105LOM 16 and management NIC 6105M). 17 18 The author may be reached as becker@scyld.com, or C/O 19 Scyld Computing Corporation 20 410 Severn Ave., Suite 210 21 Annapolis MD 21403 22 23 24 This driver contains some changes from the original Donald Becker 25 version. He may or may not be interested in bug reports on this 26 code. You can find his versions at: 27 http://www.scyld.com/network/via-rhine.html 28 [link no longer provides useful info -jgarzik] 29 30 */ 31 32 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 33 34 #define DRV_NAME "via-rhine" 35 #define DRV_VERSION "1.5.0" 36 #define DRV_RELDATE "2010-10-09" 37 38 #include <linux/types.h> 39 40 /* A few user-configurable values. 41 These may be modified when a driver module is loaded. */ 42 static int debug = 0; 43 #define RHINE_MSG_DEFAULT \ 44 (0x0000) 45 46 /* Set the copy breakpoint for the copy-only-tiny-frames scheme. 47 Setting to > 1518 effectively disables this feature. */ 48 #if defined(__alpha__) || defined(__arm__) || defined(__hppa__) || \ 49 defined(CONFIG_SPARC) || defined(__ia64__) || \ 50 defined(__sh__) || defined(__mips__) 51 static int rx_copybreak = 1518; 52 #else 53 static int rx_copybreak; 54 #endif 55 56 /* Work-around for broken BIOSes: they are unable to get the chip back out of 57 power state D3 so PXE booting fails. bootparam(7): via-rhine.avoid_D3=1 */ 58 static bool avoid_D3; 59 60 /* 61 * In case you are looking for 'options[]' or 'full_duplex[]', they 62 * are gone. Use ethtool(8) instead. 63 */ 64 65 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast). 66 The Rhine has a 64 element 8390-like hash table. */ 67 static const int multicast_filter_limit = 32; 68 69 70 /* Operational parameters that are set at compile time. */ 71 72 /* Keep the ring sizes a power of two for compile efficiency. 73 The compiler will convert <unsigned>'%'<2^N> into a bit mask. 74 Making the Tx ring too large decreases the effectiveness of channel 75 bonding and packet priority. 76 There are no ill effects from too-large receive rings. */ 77 #define TX_RING_SIZE 16 78 #define TX_QUEUE_LEN 10 /* Limit ring entries actually used. */ 79 #define RX_RING_SIZE 64 80 81 /* Operational parameters that usually are not changed. */ 82 83 /* Time in jiffies before concluding the transmitter is hung. */ 84 #define TX_TIMEOUT (2*HZ) 85 86 #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/ 87 88 #include <linux/module.h> 89 #include <linux/moduleparam.h> 90 #include <linux/kernel.h> 91 #include <linux/string.h> 92 #include <linux/timer.h> 93 #include <linux/errno.h> 94 #include <linux/ioport.h> 95 #include <linux/interrupt.h> 96 #include <linux/pci.h> 97 #include <linux/dma-mapping.h> 98 #include <linux/netdevice.h> 99 #include <linux/etherdevice.h> 100 #include <linux/skbuff.h> 101 #include <linux/init.h> 102 #include <linux/delay.h> 103 #include <linux/mii.h> 104 #include <linux/ethtool.h> 105 #include <linux/crc32.h> 106 #include <linux/if_vlan.h> 107 #include <linux/bitops.h> 108 #include <linux/workqueue.h> 109 #include <asm/processor.h> /* Processor type for cache alignment. */ 110 #include <asm/io.h> 111 #include <asm/irq.h> 112 #include <asm/uaccess.h> 113 #include <linux/dmi.h> 114 115 /* These identify the driver base version and may not be removed. */ 116 static const char version[] = 117 "v1.10-LK" DRV_VERSION " " DRV_RELDATE " Written by Donald Becker"; 118 119 /* This driver was written to use PCI memory space. Some early versions 120 of the Rhine may only work correctly with I/O space accesses. */ 121 #ifdef CONFIG_VIA_RHINE_MMIO 122 #define USE_MMIO 123 #else 124 #endif 125 126 MODULE_AUTHOR("Donald Becker <becker@scyld.com>"); 127 MODULE_DESCRIPTION("VIA Rhine PCI Fast Ethernet driver"); 128 MODULE_LICENSE("GPL"); 129 130 module_param(debug, int, 0); 131 module_param(rx_copybreak, int, 0); 132 module_param(avoid_D3, bool, 0); 133 MODULE_PARM_DESC(debug, "VIA Rhine debug message flags"); 134 MODULE_PARM_DESC(rx_copybreak, "VIA Rhine copy breakpoint for copy-only-tiny-frames"); 135 MODULE_PARM_DESC(avoid_D3, "Avoid power state D3 (work-around for broken BIOSes)"); 136 137 #define MCAM_SIZE 32 138 #define VCAM_SIZE 32 139 140 /* 141 Theory of Operation 142 143 I. Board Compatibility 144 145 This driver is designed for the VIA 86c100A Rhine-II PCI Fast Ethernet 146 controller. 147 148 II. Board-specific settings 149 150 Boards with this chip are functional only in a bus-master PCI slot. 151 152 Many operational settings are loaded from the EEPROM to the Config word at 153 offset 0x78. For most of these settings, this driver assumes that they are 154 correct. 155 If this driver is compiled to use PCI memory space operations the EEPROM 156 must be configured to enable memory ops. 157 158 III. Driver operation 159 160 IIIa. Ring buffers 161 162 This driver uses two statically allocated fixed-size descriptor lists 163 formed into rings by a branch from the final descriptor to the beginning of 164 the list. The ring sizes are set at compile time by RX/TX_RING_SIZE. 165 166 IIIb/c. Transmit/Receive Structure 167 168 This driver attempts to use a zero-copy receive and transmit scheme. 169 170 Alas, all data buffers are required to start on a 32 bit boundary, so 171 the driver must often copy transmit packets into bounce buffers. 172 173 The driver allocates full frame size skbuffs for the Rx ring buffers at 174 open() time and passes the skb->data field to the chip as receive data 175 buffers. When an incoming frame is less than RX_COPYBREAK bytes long, 176 a fresh skbuff is allocated and the frame is copied to the new skbuff. 177 When the incoming frame is larger, the skbuff is passed directly up the 178 protocol stack. Buffers consumed this way are replaced by newly allocated 179 skbuffs in the last phase of rhine_rx(). 180 181 The RX_COPYBREAK value is chosen to trade-off the memory wasted by 182 using a full-sized skbuff for small frames vs. the copying costs of larger 183 frames. New boards are typically used in generously configured machines 184 and the underfilled buffers have negligible impact compared to the benefit of 185 a single allocation size, so the default value of zero results in never 186 copying packets. When copying is done, the cost is usually mitigated by using 187 a combined copy/checksum routine. Copying also preloads the cache, which is 188 most useful with small frames. 189 190 Since the VIA chips are only able to transfer data to buffers on 32 bit 191 boundaries, the IP header at offset 14 in an ethernet frame isn't 192 longword aligned for further processing. Copying these unaligned buffers 193 has the beneficial effect of 16-byte aligning the IP header. 194 195 IIId. Synchronization 196 197 The driver runs as two independent, single-threaded flows of control. One 198 is the send-packet routine, which enforces single-threaded use by the 199 netdev_priv(dev)->lock spinlock. The other thread is the interrupt handler, 200 which is single threaded by the hardware and interrupt handling software. 201 202 The send packet thread has partial control over the Tx ring. It locks the 203 netdev_priv(dev)->lock whenever it's queuing a Tx packet. If the next slot in 204 the ring is not available it stops the transmit queue by 205 calling netif_stop_queue. 206 207 The interrupt handler has exclusive control over the Rx ring and records stats 208 from the Tx ring. After reaping the stats, it marks the Tx queue entry as 209 empty by incrementing the dirty_tx mark. If at least half of the entries in 210 the Rx ring are available the transmit queue is woken up if it was stopped. 211 212 IV. Notes 213 214 IVb. References 215 216 Preliminary VT86C100A manual from http://www.via.com.tw/ 217 http://www.scyld.com/expert/100mbps.html 218 http://www.scyld.com/expert/NWay.html 219 ftp://ftp.via.com.tw/public/lan/Products/NIC/VT86C100A/Datasheet/VT86C100A03.pdf 220 ftp://ftp.via.com.tw/public/lan/Products/NIC/VT6102/Datasheet/VT6102_021.PDF 221 222 223 IVc. Errata 224 225 The VT86C100A manual is not reliable information. 226 The 3043 chip does not handle unaligned transmit or receive buffers, resulting 227 in significant performance degradation for bounce buffer copies on transmit 228 and unaligned IP headers on receive. 229 The chip does not pad to minimum transmit length. 230 231 */ 232 233 234 /* This table drives the PCI probe routines. It's mostly boilerplate in all 235 of the drivers, and will likely be provided by some future kernel. 236 Note the matching code -- the first table entry matchs all 56** cards but 237 second only the 1234 card. 238 */ 239 240 enum rhine_revs { 241 VT86C100A = 0x00, 242 VTunknown0 = 0x20, 243 VT6102 = 0x40, 244 VT8231 = 0x50, /* Integrated MAC */ 245 VT8233 = 0x60, /* Integrated MAC */ 246 VT8235 = 0x74, /* Integrated MAC */ 247 VT8237 = 0x78, /* Integrated MAC */ 248 VTunknown1 = 0x7C, 249 VT6105 = 0x80, 250 VT6105_B0 = 0x83, 251 VT6105L = 0x8A, 252 VT6107 = 0x8C, 253 VTunknown2 = 0x8E, 254 VT6105M = 0x90, /* Management adapter */ 255 }; 256 257 enum rhine_quirks { 258 rqWOL = 0x0001, /* Wake-On-LAN support */ 259 rqForceReset = 0x0002, 260 rq6patterns = 0x0040, /* 6 instead of 4 patterns for WOL */ 261 rqStatusWBRace = 0x0080, /* Tx Status Writeback Error possible */ 262 rqRhineI = 0x0100, /* See comment below */ 263 }; 264 /* 265 * rqRhineI: VT86C100A (aka Rhine-I) uses different bits to enable 266 * MMIO as well as for the collision counter and the Tx FIFO underflow 267 * indicator. In addition, Tx and Rx buffers need to 4 byte aligned. 268 */ 269 270 /* Beware of PCI posted writes */ 271 #define IOSYNC do { ioread8(ioaddr + StationAddr); } while (0) 272 273 static DEFINE_PCI_DEVICE_TABLE(rhine_pci_tbl) = { 274 { 0x1106, 0x3043, PCI_ANY_ID, PCI_ANY_ID, }, /* VT86C100A */ 275 { 0x1106, 0x3065, PCI_ANY_ID, PCI_ANY_ID, }, /* VT6102 */ 276 { 0x1106, 0x3106, PCI_ANY_ID, PCI_ANY_ID, }, /* 6105{,L,LOM} */ 277 { 0x1106, 0x3053, PCI_ANY_ID, PCI_ANY_ID, }, /* VT6105M */ 278 { } /* terminate list */ 279 }; 280 MODULE_DEVICE_TABLE(pci, rhine_pci_tbl); 281 282 283 /* Offsets to the device registers. */ 284 enum register_offsets { 285 StationAddr=0x00, RxConfig=0x06, TxConfig=0x07, ChipCmd=0x08, 286 ChipCmd1=0x09, TQWake=0x0A, 287 IntrStatus=0x0C, IntrEnable=0x0E, 288 MulticastFilter0=0x10, MulticastFilter1=0x14, 289 RxRingPtr=0x18, TxRingPtr=0x1C, GFIFOTest=0x54, 290 MIIPhyAddr=0x6C, MIIStatus=0x6D, PCIBusConfig=0x6E, PCIBusConfig1=0x6F, 291 MIICmd=0x70, MIIRegAddr=0x71, MIIData=0x72, MACRegEEcsr=0x74, 292 ConfigA=0x78, ConfigB=0x79, ConfigC=0x7A, ConfigD=0x7B, 293 RxMissed=0x7C, RxCRCErrs=0x7E, MiscCmd=0x81, 294 StickyHW=0x83, IntrStatus2=0x84, 295 CamMask=0x88, CamCon=0x92, CamAddr=0x93, 296 WOLcrSet=0xA0, PwcfgSet=0xA1, WOLcgSet=0xA3, WOLcrClr=0xA4, 297 WOLcrClr1=0xA6, WOLcgClr=0xA7, 298 PwrcsrSet=0xA8, PwrcsrSet1=0xA9, PwrcsrClr=0xAC, PwrcsrClr1=0xAD, 299 }; 300 301 /* Bits in ConfigD */ 302 enum backoff_bits { 303 BackOptional=0x01, BackModify=0x02, 304 BackCaptureEffect=0x04, BackRandom=0x08 305 }; 306 307 /* Bits in the TxConfig (TCR) register */ 308 enum tcr_bits { 309 TCR_PQEN=0x01, 310 TCR_LB0=0x02, /* loopback[0] */ 311 TCR_LB1=0x04, /* loopback[1] */ 312 TCR_OFSET=0x08, 313 TCR_RTGOPT=0x10, 314 TCR_RTFT0=0x20, 315 TCR_RTFT1=0x40, 316 TCR_RTSF=0x80, 317 }; 318 319 /* Bits in the CamCon (CAMC) register */ 320 enum camcon_bits { 321 CAMC_CAMEN=0x01, 322 CAMC_VCAMSL=0x02, 323 CAMC_CAMWR=0x04, 324 CAMC_CAMRD=0x08, 325 }; 326 327 /* Bits in the PCIBusConfig1 (BCR1) register */ 328 enum bcr1_bits { 329 BCR1_POT0=0x01, 330 BCR1_POT1=0x02, 331 BCR1_POT2=0x04, 332 BCR1_CTFT0=0x08, 333 BCR1_CTFT1=0x10, 334 BCR1_CTSF=0x20, 335 BCR1_TXQNOBK=0x40, /* for VT6105 */ 336 BCR1_VIDFR=0x80, /* for VT6105 */ 337 BCR1_MED0=0x40, /* for VT6102 */ 338 BCR1_MED1=0x80, /* for VT6102 */ 339 }; 340 341 #ifdef USE_MMIO 342 /* Registers we check that mmio and reg are the same. */ 343 static const int mmio_verify_registers[] = { 344 RxConfig, TxConfig, IntrEnable, ConfigA, ConfigB, ConfigC, ConfigD, 345 0 346 }; 347 #endif 348 349 /* Bits in the interrupt status/mask registers. */ 350 enum intr_status_bits { 351 IntrRxDone = 0x0001, 352 IntrTxDone = 0x0002, 353 IntrRxErr = 0x0004, 354 IntrTxError = 0x0008, 355 IntrRxEmpty = 0x0020, 356 IntrPCIErr = 0x0040, 357 IntrStatsMax = 0x0080, 358 IntrRxEarly = 0x0100, 359 IntrTxUnderrun = 0x0210, 360 IntrRxOverflow = 0x0400, 361 IntrRxDropped = 0x0800, 362 IntrRxNoBuf = 0x1000, 363 IntrTxAborted = 0x2000, 364 IntrLinkChange = 0x4000, 365 IntrRxWakeUp = 0x8000, 366 IntrTxDescRace = 0x080000, /* mapped from IntrStatus2 */ 367 IntrNormalSummary = IntrRxDone | IntrTxDone, 368 IntrTxErrSummary = IntrTxDescRace | IntrTxAborted | IntrTxError | 369 IntrTxUnderrun, 370 }; 371 372 /* Bits in WOLcrSet/WOLcrClr and PwrcsrSet/PwrcsrClr */ 373 enum wol_bits { 374 WOLucast = 0x10, 375 WOLmagic = 0x20, 376 WOLbmcast = 0x30, 377 WOLlnkon = 0x40, 378 WOLlnkoff = 0x80, 379 }; 380 381 /* The Rx and Tx buffer descriptors. */ 382 struct rx_desc { 383 __le32 rx_status; 384 __le32 desc_length; /* Chain flag, Buffer/frame length */ 385 __le32 addr; 386 __le32 next_desc; 387 }; 388 struct tx_desc { 389 __le32 tx_status; 390 __le32 desc_length; /* Chain flag, Tx Config, Frame length */ 391 __le32 addr; 392 __le32 next_desc; 393 }; 394 395 /* Initial value for tx_desc.desc_length, Buffer size goes to bits 0-10 */ 396 #define TXDESC 0x00e08000 397 398 enum rx_status_bits { 399 RxOK=0x8000, RxWholePkt=0x0300, RxErr=0x008F 400 }; 401 402 /* Bits in *_desc.*_status */ 403 enum desc_status_bits { 404 DescOwn=0x80000000 405 }; 406 407 /* Bits in *_desc.*_length */ 408 enum desc_length_bits { 409 DescTag=0x00010000 410 }; 411 412 /* Bits in ChipCmd. */ 413 enum chip_cmd_bits { 414 CmdInit=0x01, CmdStart=0x02, CmdStop=0x04, CmdRxOn=0x08, 415 CmdTxOn=0x10, Cmd1TxDemand=0x20, CmdRxDemand=0x40, 416 Cmd1EarlyRx=0x01, Cmd1EarlyTx=0x02, Cmd1FDuplex=0x04, 417 Cmd1NoTxPoll=0x08, Cmd1Reset=0x80, 418 }; 419 420 struct rhine_private { 421 /* Bit mask for configured VLAN ids */ 422 unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)]; 423 424 /* Descriptor rings */ 425 struct rx_desc *rx_ring; 426 struct tx_desc *tx_ring; 427 dma_addr_t rx_ring_dma; 428 dma_addr_t tx_ring_dma; 429 430 /* The addresses of receive-in-place skbuffs. */ 431 struct sk_buff *rx_skbuff[RX_RING_SIZE]; 432 dma_addr_t rx_skbuff_dma[RX_RING_SIZE]; 433 434 /* The saved address of a sent-in-place packet/buffer, for later free(). */ 435 struct sk_buff *tx_skbuff[TX_RING_SIZE]; 436 dma_addr_t tx_skbuff_dma[TX_RING_SIZE]; 437 438 /* Tx bounce buffers (Rhine-I only) */ 439 unsigned char *tx_buf[TX_RING_SIZE]; 440 unsigned char *tx_bufs; 441 dma_addr_t tx_bufs_dma; 442 443 struct pci_dev *pdev; 444 long pioaddr; 445 struct net_device *dev; 446 struct napi_struct napi; 447 spinlock_t lock; 448 struct mutex task_lock; 449 bool task_enable; 450 struct work_struct slow_event_task; 451 struct work_struct reset_task; 452 453 u32 msg_enable; 454 455 /* Frequently used values: keep some adjacent for cache effect. */ 456 u32 quirks; 457 struct rx_desc *rx_head_desc; 458 unsigned int cur_rx, dirty_rx; /* Producer/consumer ring indices */ 459 unsigned int cur_tx, dirty_tx; 460 unsigned int rx_buf_sz; /* Based on MTU+slack. */ 461 u8 wolopts; 462 463 u8 tx_thresh, rx_thresh; 464 465 struct mii_if_info mii_if; 466 void __iomem *base; 467 }; 468 469 #define BYTE_REG_BITS_ON(x, p) do { iowrite8((ioread8((p))|(x)), (p)); } while (0) 470 #define WORD_REG_BITS_ON(x, p) do { iowrite16((ioread16((p))|(x)), (p)); } while (0) 471 #define DWORD_REG_BITS_ON(x, p) do { iowrite32((ioread32((p))|(x)), (p)); } while (0) 472 473 #define BYTE_REG_BITS_IS_ON(x, p) (ioread8((p)) & (x)) 474 #define WORD_REG_BITS_IS_ON(x, p) (ioread16((p)) & (x)) 475 #define DWORD_REG_BITS_IS_ON(x, p) (ioread32((p)) & (x)) 476 477 #define BYTE_REG_BITS_OFF(x, p) do { iowrite8(ioread8((p)) & (~(x)), (p)); } while (0) 478 #define WORD_REG_BITS_OFF(x, p) do { iowrite16(ioread16((p)) & (~(x)), (p)); } while (0) 479 #define DWORD_REG_BITS_OFF(x, p) do { iowrite32(ioread32((p)) & (~(x)), (p)); } while (0) 480 481 #define BYTE_REG_BITS_SET(x, m, p) do { iowrite8((ioread8((p)) & (~(m)))|(x), (p)); } while (0) 482 #define WORD_REG_BITS_SET(x, m, p) do { iowrite16((ioread16((p)) & (~(m)))|(x), (p)); } while (0) 483 #define DWORD_REG_BITS_SET(x, m, p) do { iowrite32((ioread32((p)) & (~(m)))|(x), (p)); } while (0) 484 485 486 static int mdio_read(struct net_device *dev, int phy_id, int location); 487 static void mdio_write(struct net_device *dev, int phy_id, int location, int value); 488 static int rhine_open(struct net_device *dev); 489 static void rhine_reset_task(struct work_struct *work); 490 static void rhine_slow_event_task(struct work_struct *work); 491 static void rhine_tx_timeout(struct net_device *dev); 492 static netdev_tx_t rhine_start_tx(struct sk_buff *skb, 493 struct net_device *dev); 494 static irqreturn_t rhine_interrupt(int irq, void *dev_instance); 495 static void rhine_tx(struct net_device *dev); 496 static int rhine_rx(struct net_device *dev, int limit); 497 static void rhine_set_rx_mode(struct net_device *dev); 498 static struct net_device_stats *rhine_get_stats(struct net_device *dev); 499 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); 500 static const struct ethtool_ops netdev_ethtool_ops; 501 static int rhine_close(struct net_device *dev); 502 static int rhine_vlan_rx_add_vid(struct net_device *dev, unsigned short vid); 503 static int rhine_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid); 504 static void rhine_restart_tx(struct net_device *dev); 505 506 static void rhine_wait_bit(struct rhine_private *rp, u8 reg, u8 mask, bool low) 507 { 508 void __iomem *ioaddr = rp->base; 509 int i; 510 511 for (i = 0; i < 1024; i++) { 512 bool has_mask_bits = !!(ioread8(ioaddr + reg) & mask); 513 514 if (low ^ has_mask_bits) 515 break; 516 udelay(10); 517 } 518 if (i > 64) { 519 netif_dbg(rp, hw, rp->dev, "%s bit wait (%02x/%02x) cycle " 520 "count: %04d\n", low ? "low" : "high", reg, mask, i); 521 } 522 } 523 524 static void rhine_wait_bit_high(struct rhine_private *rp, u8 reg, u8 mask) 525 { 526 rhine_wait_bit(rp, reg, mask, false); 527 } 528 529 static void rhine_wait_bit_low(struct rhine_private *rp, u8 reg, u8 mask) 530 { 531 rhine_wait_bit(rp, reg, mask, true); 532 } 533 534 static u32 rhine_get_events(struct rhine_private *rp) 535 { 536 void __iomem *ioaddr = rp->base; 537 u32 intr_status; 538 539 intr_status = ioread16(ioaddr + IntrStatus); 540 /* On Rhine-II, Bit 3 indicates Tx descriptor write-back race. */ 541 if (rp->quirks & rqStatusWBRace) 542 intr_status |= ioread8(ioaddr + IntrStatus2) << 16; 543 return intr_status; 544 } 545 546 static void rhine_ack_events(struct rhine_private *rp, u32 mask) 547 { 548 void __iomem *ioaddr = rp->base; 549 550 if (rp->quirks & rqStatusWBRace) 551 iowrite8(mask >> 16, ioaddr + IntrStatus2); 552 iowrite16(mask, ioaddr + IntrStatus); 553 mmiowb(); 554 } 555 556 /* 557 * Get power related registers into sane state. 558 * Notify user about past WOL event. 559 */ 560 static void rhine_power_init(struct net_device *dev) 561 { 562 struct rhine_private *rp = netdev_priv(dev); 563 void __iomem *ioaddr = rp->base; 564 u16 wolstat; 565 566 if (rp->quirks & rqWOL) { 567 /* Make sure chip is in power state D0 */ 568 iowrite8(ioread8(ioaddr + StickyHW) & 0xFC, ioaddr + StickyHW); 569 570 /* Disable "force PME-enable" */ 571 iowrite8(0x80, ioaddr + WOLcgClr); 572 573 /* Clear power-event config bits (WOL) */ 574 iowrite8(0xFF, ioaddr + WOLcrClr); 575 /* More recent cards can manage two additional patterns */ 576 if (rp->quirks & rq6patterns) 577 iowrite8(0x03, ioaddr + WOLcrClr1); 578 579 /* Save power-event status bits */ 580 wolstat = ioread8(ioaddr + PwrcsrSet); 581 if (rp->quirks & rq6patterns) 582 wolstat |= (ioread8(ioaddr + PwrcsrSet1) & 0x03) << 8; 583 584 /* Clear power-event status bits */ 585 iowrite8(0xFF, ioaddr + PwrcsrClr); 586 if (rp->quirks & rq6patterns) 587 iowrite8(0x03, ioaddr + PwrcsrClr1); 588 589 if (wolstat) { 590 char *reason; 591 switch (wolstat) { 592 case WOLmagic: 593 reason = "Magic packet"; 594 break; 595 case WOLlnkon: 596 reason = "Link went up"; 597 break; 598 case WOLlnkoff: 599 reason = "Link went down"; 600 break; 601 case WOLucast: 602 reason = "Unicast packet"; 603 break; 604 case WOLbmcast: 605 reason = "Multicast/broadcast packet"; 606 break; 607 default: 608 reason = "Unknown"; 609 } 610 netdev_info(dev, "Woke system up. Reason: %s\n", 611 reason); 612 } 613 } 614 } 615 616 static void rhine_chip_reset(struct net_device *dev) 617 { 618 struct rhine_private *rp = netdev_priv(dev); 619 void __iomem *ioaddr = rp->base; 620 u8 cmd1; 621 622 iowrite8(Cmd1Reset, ioaddr + ChipCmd1); 623 IOSYNC; 624 625 if (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) { 626 netdev_info(dev, "Reset not complete yet. Trying harder.\n"); 627 628 /* Force reset */ 629 if (rp->quirks & rqForceReset) 630 iowrite8(0x40, ioaddr + MiscCmd); 631 632 /* Reset can take somewhat longer (rare) */ 633 rhine_wait_bit_low(rp, ChipCmd1, Cmd1Reset); 634 } 635 636 cmd1 = ioread8(ioaddr + ChipCmd1); 637 netif_info(rp, hw, dev, "Reset %s\n", (cmd1 & Cmd1Reset) ? 638 "failed" : "succeeded"); 639 } 640 641 #ifdef USE_MMIO 642 static void enable_mmio(long pioaddr, u32 quirks) 643 { 644 int n; 645 if (quirks & rqRhineI) { 646 /* More recent docs say that this bit is reserved ... */ 647 n = inb(pioaddr + ConfigA) | 0x20; 648 outb(n, pioaddr + ConfigA); 649 } else { 650 n = inb(pioaddr + ConfigD) | 0x80; 651 outb(n, pioaddr + ConfigD); 652 } 653 } 654 #endif 655 656 /* 657 * Loads bytes 0x00-0x05, 0x6E-0x6F, 0x78-0x7B from EEPROM 658 * (plus 0x6C for Rhine-I/II) 659 */ 660 static void rhine_reload_eeprom(long pioaddr, struct net_device *dev) 661 { 662 struct rhine_private *rp = netdev_priv(dev); 663 void __iomem *ioaddr = rp->base; 664 int i; 665 666 outb(0x20, pioaddr + MACRegEEcsr); 667 for (i = 0; i < 1024; i++) { 668 if (!(inb(pioaddr + MACRegEEcsr) & 0x20)) 669 break; 670 } 671 if (i > 512) 672 pr_info("%4d cycles used @ %s:%d\n", i, __func__, __LINE__); 673 674 #ifdef USE_MMIO 675 /* 676 * Reloading from EEPROM overwrites ConfigA-D, so we must re-enable 677 * MMIO. If reloading EEPROM was done first this could be avoided, but 678 * it is not known if that still works with the "win98-reboot" problem. 679 */ 680 enable_mmio(pioaddr, rp->quirks); 681 #endif 682 683 /* Turn off EEPROM-controlled wake-up (magic packet) */ 684 if (rp->quirks & rqWOL) 685 iowrite8(ioread8(ioaddr + ConfigA) & 0xFC, ioaddr + ConfigA); 686 687 } 688 689 #ifdef CONFIG_NET_POLL_CONTROLLER 690 static void rhine_poll(struct net_device *dev) 691 { 692 struct rhine_private *rp = netdev_priv(dev); 693 const int irq = rp->pdev->irq; 694 695 disable_irq(irq); 696 rhine_interrupt(irq, dev); 697 enable_irq(irq); 698 } 699 #endif 700 701 static void rhine_kick_tx_threshold(struct rhine_private *rp) 702 { 703 if (rp->tx_thresh < 0xe0) { 704 void __iomem *ioaddr = rp->base; 705 706 rp->tx_thresh += 0x20; 707 BYTE_REG_BITS_SET(rp->tx_thresh, 0x80, ioaddr + TxConfig); 708 } 709 } 710 711 static void rhine_tx_err(struct rhine_private *rp, u32 status) 712 { 713 struct net_device *dev = rp->dev; 714 715 if (status & IntrTxAborted) { 716 netif_info(rp, tx_err, dev, 717 "Abort %08x, frame dropped\n", status); 718 } 719 720 if (status & IntrTxUnderrun) { 721 rhine_kick_tx_threshold(rp); 722 netif_info(rp, tx_err ,dev, "Transmitter underrun, " 723 "Tx threshold now %02x\n", rp->tx_thresh); 724 } 725 726 if (status & IntrTxDescRace) 727 netif_info(rp, tx_err, dev, "Tx descriptor write-back race\n"); 728 729 if ((status & IntrTxError) && 730 (status & (IntrTxAborted | IntrTxUnderrun | IntrTxDescRace)) == 0) { 731 rhine_kick_tx_threshold(rp); 732 netif_info(rp, tx_err, dev, "Unspecified error. " 733 "Tx threshold now %02x\n", rp->tx_thresh); 734 } 735 736 rhine_restart_tx(dev); 737 } 738 739 static void rhine_update_rx_crc_and_missed_errord(struct rhine_private *rp) 740 { 741 void __iomem *ioaddr = rp->base; 742 struct net_device_stats *stats = &rp->dev->stats; 743 744 stats->rx_crc_errors += ioread16(ioaddr + RxCRCErrs); 745 stats->rx_missed_errors += ioread16(ioaddr + RxMissed); 746 747 /* 748 * Clears the "tally counters" for CRC errors and missed frames(?). 749 * It has been reported that some chips need a write of 0 to clear 750 * these, for others the counters are set to 1 when written to and 751 * instead cleared when read. So we clear them both ways ... 752 */ 753 iowrite32(0, ioaddr + RxMissed); 754 ioread16(ioaddr + RxCRCErrs); 755 ioread16(ioaddr + RxMissed); 756 } 757 758 #define RHINE_EVENT_NAPI_RX (IntrRxDone | \ 759 IntrRxErr | \ 760 IntrRxEmpty | \ 761 IntrRxOverflow | \ 762 IntrRxDropped | \ 763 IntrRxNoBuf | \ 764 IntrRxWakeUp) 765 766 #define RHINE_EVENT_NAPI_TX_ERR (IntrTxError | \ 767 IntrTxAborted | \ 768 IntrTxUnderrun | \ 769 IntrTxDescRace) 770 #define RHINE_EVENT_NAPI_TX (IntrTxDone | RHINE_EVENT_NAPI_TX_ERR) 771 772 #define RHINE_EVENT_NAPI (RHINE_EVENT_NAPI_RX | \ 773 RHINE_EVENT_NAPI_TX | \ 774 IntrStatsMax) 775 #define RHINE_EVENT_SLOW (IntrPCIErr | IntrLinkChange) 776 #define RHINE_EVENT (RHINE_EVENT_NAPI | RHINE_EVENT_SLOW) 777 778 static int rhine_napipoll(struct napi_struct *napi, int budget) 779 { 780 struct rhine_private *rp = container_of(napi, struct rhine_private, napi); 781 struct net_device *dev = rp->dev; 782 void __iomem *ioaddr = rp->base; 783 u16 enable_mask = RHINE_EVENT & 0xffff; 784 int work_done = 0; 785 u32 status; 786 787 status = rhine_get_events(rp); 788 rhine_ack_events(rp, status & ~RHINE_EVENT_SLOW); 789 790 if (status & RHINE_EVENT_NAPI_RX) 791 work_done += rhine_rx(dev, budget); 792 793 if (status & RHINE_EVENT_NAPI_TX) { 794 if (status & RHINE_EVENT_NAPI_TX_ERR) { 795 /* Avoid scavenging before Tx engine turned off */ 796 rhine_wait_bit_low(rp, ChipCmd, CmdTxOn); 797 if (ioread8(ioaddr + ChipCmd) & CmdTxOn) 798 netif_warn(rp, tx_err, dev, "Tx still on\n"); 799 } 800 801 rhine_tx(dev); 802 803 if (status & RHINE_EVENT_NAPI_TX_ERR) 804 rhine_tx_err(rp, status); 805 } 806 807 if (status & IntrStatsMax) { 808 spin_lock(&rp->lock); 809 rhine_update_rx_crc_and_missed_errord(rp); 810 spin_unlock(&rp->lock); 811 } 812 813 if (status & RHINE_EVENT_SLOW) { 814 enable_mask &= ~RHINE_EVENT_SLOW; 815 schedule_work(&rp->slow_event_task); 816 } 817 818 if (work_done < budget) { 819 napi_complete(napi); 820 iowrite16(enable_mask, ioaddr + IntrEnable); 821 mmiowb(); 822 } 823 return work_done; 824 } 825 826 static void rhine_hw_init(struct net_device *dev, long pioaddr) 827 { 828 struct rhine_private *rp = netdev_priv(dev); 829 830 /* Reset the chip to erase previous misconfiguration. */ 831 rhine_chip_reset(dev); 832 833 /* Rhine-I needs extra time to recuperate before EEPROM reload */ 834 if (rp->quirks & rqRhineI) 835 msleep(5); 836 837 /* Reload EEPROM controlled bytes cleared by soft reset */ 838 rhine_reload_eeprom(pioaddr, dev); 839 } 840 841 static const struct net_device_ops rhine_netdev_ops = { 842 .ndo_open = rhine_open, 843 .ndo_stop = rhine_close, 844 .ndo_start_xmit = rhine_start_tx, 845 .ndo_get_stats = rhine_get_stats, 846 .ndo_set_rx_mode = rhine_set_rx_mode, 847 .ndo_change_mtu = eth_change_mtu, 848 .ndo_validate_addr = eth_validate_addr, 849 .ndo_set_mac_address = eth_mac_addr, 850 .ndo_do_ioctl = netdev_ioctl, 851 .ndo_tx_timeout = rhine_tx_timeout, 852 .ndo_vlan_rx_add_vid = rhine_vlan_rx_add_vid, 853 .ndo_vlan_rx_kill_vid = rhine_vlan_rx_kill_vid, 854 #ifdef CONFIG_NET_POLL_CONTROLLER 855 .ndo_poll_controller = rhine_poll, 856 #endif 857 }; 858 859 static int rhine_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 860 { 861 struct net_device *dev; 862 struct rhine_private *rp; 863 int i, rc; 864 u32 quirks; 865 long pioaddr; 866 long memaddr; 867 void __iomem *ioaddr; 868 int io_size, phy_id; 869 const char *name; 870 #ifdef USE_MMIO 871 int bar = 1; 872 #else 873 int bar = 0; 874 #endif 875 876 /* when built into the kernel, we only print version if device is found */ 877 #ifndef MODULE 878 pr_info_once("%s\n", version); 879 #endif 880 881 io_size = 256; 882 phy_id = 0; 883 quirks = 0; 884 name = "Rhine"; 885 if (pdev->revision < VTunknown0) { 886 quirks = rqRhineI; 887 io_size = 128; 888 } 889 else if (pdev->revision >= VT6102) { 890 quirks = rqWOL | rqForceReset; 891 if (pdev->revision < VT6105) { 892 name = "Rhine II"; 893 quirks |= rqStatusWBRace; /* Rhine-II exclusive */ 894 } 895 else { 896 phy_id = 1; /* Integrated PHY, phy_id fixed to 1 */ 897 if (pdev->revision >= VT6105_B0) 898 quirks |= rq6patterns; 899 if (pdev->revision < VT6105M) 900 name = "Rhine III"; 901 else 902 name = "Rhine III (Management Adapter)"; 903 } 904 } 905 906 rc = pci_enable_device(pdev); 907 if (rc) 908 goto err_out; 909 910 /* this should always be supported */ 911 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 912 if (rc) { 913 dev_err(&pdev->dev, 914 "32-bit PCI DMA addresses not supported by the card!?\n"); 915 goto err_out; 916 } 917 918 /* sanity check */ 919 if ((pci_resource_len(pdev, 0) < io_size) || 920 (pci_resource_len(pdev, 1) < io_size)) { 921 rc = -EIO; 922 dev_err(&pdev->dev, "Insufficient PCI resources, aborting\n"); 923 goto err_out; 924 } 925 926 pioaddr = pci_resource_start(pdev, 0); 927 memaddr = pci_resource_start(pdev, 1); 928 929 pci_set_master(pdev); 930 931 dev = alloc_etherdev(sizeof(struct rhine_private)); 932 if (!dev) { 933 rc = -ENOMEM; 934 goto err_out; 935 } 936 SET_NETDEV_DEV(dev, &pdev->dev); 937 938 rp = netdev_priv(dev); 939 rp->dev = dev; 940 rp->quirks = quirks; 941 rp->pioaddr = pioaddr; 942 rp->pdev = pdev; 943 rp->msg_enable = netif_msg_init(debug, RHINE_MSG_DEFAULT); 944 945 rc = pci_request_regions(pdev, DRV_NAME); 946 if (rc) 947 goto err_out_free_netdev; 948 949 ioaddr = pci_iomap(pdev, bar, io_size); 950 if (!ioaddr) { 951 rc = -EIO; 952 dev_err(&pdev->dev, 953 "ioremap failed for device %s, region 0x%X @ 0x%lX\n", 954 pci_name(pdev), io_size, memaddr); 955 goto err_out_free_res; 956 } 957 958 #ifdef USE_MMIO 959 enable_mmio(pioaddr, quirks); 960 961 /* Check that selected MMIO registers match the PIO ones */ 962 i = 0; 963 while (mmio_verify_registers[i]) { 964 int reg = mmio_verify_registers[i++]; 965 unsigned char a = inb(pioaddr+reg); 966 unsigned char b = readb(ioaddr+reg); 967 if (a != b) { 968 rc = -EIO; 969 dev_err(&pdev->dev, 970 "MMIO do not match PIO [%02x] (%02x != %02x)\n", 971 reg, a, b); 972 goto err_out_unmap; 973 } 974 } 975 #endif /* USE_MMIO */ 976 977 rp->base = ioaddr; 978 979 /* Get chip registers into a sane state */ 980 rhine_power_init(dev); 981 rhine_hw_init(dev, pioaddr); 982 983 for (i = 0; i < 6; i++) 984 dev->dev_addr[i] = ioread8(ioaddr + StationAddr + i); 985 986 if (!is_valid_ether_addr(dev->dev_addr)) { 987 /* Report it and use a random ethernet address instead */ 988 netdev_err(dev, "Invalid MAC address: %pM\n", dev->dev_addr); 989 eth_hw_addr_random(dev); 990 netdev_info(dev, "Using random MAC address: %pM\n", 991 dev->dev_addr); 992 } 993 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len); 994 995 /* For Rhine-I/II, phy_id is loaded from EEPROM */ 996 if (!phy_id) 997 phy_id = ioread8(ioaddr + 0x6C); 998 999 spin_lock_init(&rp->lock); 1000 mutex_init(&rp->task_lock); 1001 INIT_WORK(&rp->reset_task, rhine_reset_task); 1002 INIT_WORK(&rp->slow_event_task, rhine_slow_event_task); 1003 1004 rp->mii_if.dev = dev; 1005 rp->mii_if.mdio_read = mdio_read; 1006 rp->mii_if.mdio_write = mdio_write; 1007 rp->mii_if.phy_id_mask = 0x1f; 1008 rp->mii_if.reg_num_mask = 0x1f; 1009 1010 /* The chip-specific entries in the device structure. */ 1011 dev->netdev_ops = &rhine_netdev_ops; 1012 dev->ethtool_ops = &netdev_ethtool_ops, 1013 dev->watchdog_timeo = TX_TIMEOUT; 1014 1015 netif_napi_add(dev, &rp->napi, rhine_napipoll, 64); 1016 1017 if (rp->quirks & rqRhineI) 1018 dev->features |= NETIF_F_SG|NETIF_F_HW_CSUM; 1019 1020 if (pdev->revision >= VT6105M) 1021 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX | 1022 NETIF_F_HW_VLAN_FILTER; 1023 1024 /* dev->name not defined before register_netdev()! */ 1025 rc = register_netdev(dev); 1026 if (rc) 1027 goto err_out_unmap; 1028 1029 netdev_info(dev, "VIA %s at 0x%lx, %pM, IRQ %d\n", 1030 name, 1031 #ifdef USE_MMIO 1032 memaddr, 1033 #else 1034 (long)ioaddr, 1035 #endif 1036 dev->dev_addr, pdev->irq); 1037 1038 pci_set_drvdata(pdev, dev); 1039 1040 { 1041 u16 mii_cmd; 1042 int mii_status = mdio_read(dev, phy_id, 1); 1043 mii_cmd = mdio_read(dev, phy_id, MII_BMCR) & ~BMCR_ISOLATE; 1044 mdio_write(dev, phy_id, MII_BMCR, mii_cmd); 1045 if (mii_status != 0xffff && mii_status != 0x0000) { 1046 rp->mii_if.advertising = mdio_read(dev, phy_id, 4); 1047 netdev_info(dev, 1048 "MII PHY found at address %d, status 0x%04x advertising %04x Link %04x\n", 1049 phy_id, 1050 mii_status, rp->mii_if.advertising, 1051 mdio_read(dev, phy_id, 5)); 1052 1053 /* set IFF_RUNNING */ 1054 if (mii_status & BMSR_LSTATUS) 1055 netif_carrier_on(dev); 1056 else 1057 netif_carrier_off(dev); 1058 1059 } 1060 } 1061 rp->mii_if.phy_id = phy_id; 1062 if (avoid_D3) 1063 netif_info(rp, probe, dev, "No D3 power state at shutdown\n"); 1064 1065 return 0; 1066 1067 err_out_unmap: 1068 pci_iounmap(pdev, ioaddr); 1069 err_out_free_res: 1070 pci_release_regions(pdev); 1071 err_out_free_netdev: 1072 free_netdev(dev); 1073 err_out: 1074 return rc; 1075 } 1076 1077 static int alloc_ring(struct net_device* dev) 1078 { 1079 struct rhine_private *rp = netdev_priv(dev); 1080 void *ring; 1081 dma_addr_t ring_dma; 1082 1083 ring = pci_alloc_consistent(rp->pdev, 1084 RX_RING_SIZE * sizeof(struct rx_desc) + 1085 TX_RING_SIZE * sizeof(struct tx_desc), 1086 &ring_dma); 1087 if (!ring) { 1088 netdev_err(dev, "Could not allocate DMA memory\n"); 1089 return -ENOMEM; 1090 } 1091 if (rp->quirks & rqRhineI) { 1092 rp->tx_bufs = pci_alloc_consistent(rp->pdev, 1093 PKT_BUF_SZ * TX_RING_SIZE, 1094 &rp->tx_bufs_dma); 1095 if (rp->tx_bufs == NULL) { 1096 pci_free_consistent(rp->pdev, 1097 RX_RING_SIZE * sizeof(struct rx_desc) + 1098 TX_RING_SIZE * sizeof(struct tx_desc), 1099 ring, ring_dma); 1100 return -ENOMEM; 1101 } 1102 } 1103 1104 rp->rx_ring = ring; 1105 rp->tx_ring = ring + RX_RING_SIZE * sizeof(struct rx_desc); 1106 rp->rx_ring_dma = ring_dma; 1107 rp->tx_ring_dma = ring_dma + RX_RING_SIZE * sizeof(struct rx_desc); 1108 1109 return 0; 1110 } 1111 1112 static void free_ring(struct net_device* dev) 1113 { 1114 struct rhine_private *rp = netdev_priv(dev); 1115 1116 pci_free_consistent(rp->pdev, 1117 RX_RING_SIZE * sizeof(struct rx_desc) + 1118 TX_RING_SIZE * sizeof(struct tx_desc), 1119 rp->rx_ring, rp->rx_ring_dma); 1120 rp->tx_ring = NULL; 1121 1122 if (rp->tx_bufs) 1123 pci_free_consistent(rp->pdev, PKT_BUF_SZ * TX_RING_SIZE, 1124 rp->tx_bufs, rp->tx_bufs_dma); 1125 1126 rp->tx_bufs = NULL; 1127 1128 } 1129 1130 static void alloc_rbufs(struct net_device *dev) 1131 { 1132 struct rhine_private *rp = netdev_priv(dev); 1133 dma_addr_t next; 1134 int i; 1135 1136 rp->dirty_rx = rp->cur_rx = 0; 1137 1138 rp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32); 1139 rp->rx_head_desc = &rp->rx_ring[0]; 1140 next = rp->rx_ring_dma; 1141 1142 /* Init the ring entries */ 1143 for (i = 0; i < RX_RING_SIZE; i++) { 1144 rp->rx_ring[i].rx_status = 0; 1145 rp->rx_ring[i].desc_length = cpu_to_le32(rp->rx_buf_sz); 1146 next += sizeof(struct rx_desc); 1147 rp->rx_ring[i].next_desc = cpu_to_le32(next); 1148 rp->rx_skbuff[i] = NULL; 1149 } 1150 /* Mark the last entry as wrapping the ring. */ 1151 rp->rx_ring[i-1].next_desc = cpu_to_le32(rp->rx_ring_dma); 1152 1153 /* Fill in the Rx buffers. Handle allocation failure gracefully. */ 1154 for (i = 0; i < RX_RING_SIZE; i++) { 1155 struct sk_buff *skb = netdev_alloc_skb(dev, rp->rx_buf_sz); 1156 rp->rx_skbuff[i] = skb; 1157 if (skb == NULL) 1158 break; 1159 1160 rp->rx_skbuff_dma[i] = 1161 pci_map_single(rp->pdev, skb->data, rp->rx_buf_sz, 1162 PCI_DMA_FROMDEVICE); 1163 1164 rp->rx_ring[i].addr = cpu_to_le32(rp->rx_skbuff_dma[i]); 1165 rp->rx_ring[i].rx_status = cpu_to_le32(DescOwn); 1166 } 1167 rp->dirty_rx = (unsigned int)(i - RX_RING_SIZE); 1168 } 1169 1170 static void free_rbufs(struct net_device* dev) 1171 { 1172 struct rhine_private *rp = netdev_priv(dev); 1173 int i; 1174 1175 /* Free all the skbuffs in the Rx queue. */ 1176 for (i = 0; i < RX_RING_SIZE; i++) { 1177 rp->rx_ring[i].rx_status = 0; 1178 rp->rx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */ 1179 if (rp->rx_skbuff[i]) { 1180 pci_unmap_single(rp->pdev, 1181 rp->rx_skbuff_dma[i], 1182 rp->rx_buf_sz, PCI_DMA_FROMDEVICE); 1183 dev_kfree_skb(rp->rx_skbuff[i]); 1184 } 1185 rp->rx_skbuff[i] = NULL; 1186 } 1187 } 1188 1189 static void alloc_tbufs(struct net_device* dev) 1190 { 1191 struct rhine_private *rp = netdev_priv(dev); 1192 dma_addr_t next; 1193 int i; 1194 1195 rp->dirty_tx = rp->cur_tx = 0; 1196 next = rp->tx_ring_dma; 1197 for (i = 0; i < TX_RING_SIZE; i++) { 1198 rp->tx_skbuff[i] = NULL; 1199 rp->tx_ring[i].tx_status = 0; 1200 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC); 1201 next += sizeof(struct tx_desc); 1202 rp->tx_ring[i].next_desc = cpu_to_le32(next); 1203 if (rp->quirks & rqRhineI) 1204 rp->tx_buf[i] = &rp->tx_bufs[i * PKT_BUF_SZ]; 1205 } 1206 rp->tx_ring[i-1].next_desc = cpu_to_le32(rp->tx_ring_dma); 1207 1208 } 1209 1210 static void free_tbufs(struct net_device* dev) 1211 { 1212 struct rhine_private *rp = netdev_priv(dev); 1213 int i; 1214 1215 for (i = 0; i < TX_RING_SIZE; i++) { 1216 rp->tx_ring[i].tx_status = 0; 1217 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC); 1218 rp->tx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */ 1219 if (rp->tx_skbuff[i]) { 1220 if (rp->tx_skbuff_dma[i]) { 1221 pci_unmap_single(rp->pdev, 1222 rp->tx_skbuff_dma[i], 1223 rp->tx_skbuff[i]->len, 1224 PCI_DMA_TODEVICE); 1225 } 1226 dev_kfree_skb(rp->tx_skbuff[i]); 1227 } 1228 rp->tx_skbuff[i] = NULL; 1229 rp->tx_buf[i] = NULL; 1230 } 1231 } 1232 1233 static void rhine_check_media(struct net_device *dev, unsigned int init_media) 1234 { 1235 struct rhine_private *rp = netdev_priv(dev); 1236 void __iomem *ioaddr = rp->base; 1237 1238 mii_check_media(&rp->mii_if, netif_msg_link(rp), init_media); 1239 1240 if (rp->mii_if.full_duplex) 1241 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1FDuplex, 1242 ioaddr + ChipCmd1); 1243 else 1244 iowrite8(ioread8(ioaddr + ChipCmd1) & ~Cmd1FDuplex, 1245 ioaddr + ChipCmd1); 1246 1247 netif_info(rp, link, dev, "force_media %d, carrier %d\n", 1248 rp->mii_if.force_media, netif_carrier_ok(dev)); 1249 } 1250 1251 /* Called after status of force_media possibly changed */ 1252 static void rhine_set_carrier(struct mii_if_info *mii) 1253 { 1254 struct net_device *dev = mii->dev; 1255 struct rhine_private *rp = netdev_priv(dev); 1256 1257 if (mii->force_media) { 1258 /* autoneg is off: Link is always assumed to be up */ 1259 if (!netif_carrier_ok(dev)) 1260 netif_carrier_on(dev); 1261 } else /* Let MMI library update carrier status */ 1262 rhine_check_media(dev, 0); 1263 1264 netif_info(rp, link, dev, "force_media %d, carrier %d\n", 1265 mii->force_media, netif_carrier_ok(dev)); 1266 } 1267 1268 /** 1269 * rhine_set_cam - set CAM multicast filters 1270 * @ioaddr: register block of this Rhine 1271 * @idx: multicast CAM index [0..MCAM_SIZE-1] 1272 * @addr: multicast address (6 bytes) 1273 * 1274 * Load addresses into multicast filters. 1275 */ 1276 static void rhine_set_cam(void __iomem *ioaddr, int idx, u8 *addr) 1277 { 1278 int i; 1279 1280 iowrite8(CAMC_CAMEN, ioaddr + CamCon); 1281 wmb(); 1282 1283 /* Paranoid -- idx out of range should never happen */ 1284 idx &= (MCAM_SIZE - 1); 1285 1286 iowrite8((u8) idx, ioaddr + CamAddr); 1287 1288 for (i = 0; i < 6; i++, addr++) 1289 iowrite8(*addr, ioaddr + MulticastFilter0 + i); 1290 udelay(10); 1291 wmb(); 1292 1293 iowrite8(CAMC_CAMWR | CAMC_CAMEN, ioaddr + CamCon); 1294 udelay(10); 1295 1296 iowrite8(0, ioaddr + CamCon); 1297 } 1298 1299 /** 1300 * rhine_set_vlan_cam - set CAM VLAN filters 1301 * @ioaddr: register block of this Rhine 1302 * @idx: VLAN CAM index [0..VCAM_SIZE-1] 1303 * @addr: VLAN ID (2 bytes) 1304 * 1305 * Load addresses into VLAN filters. 1306 */ 1307 static void rhine_set_vlan_cam(void __iomem *ioaddr, int idx, u8 *addr) 1308 { 1309 iowrite8(CAMC_CAMEN | CAMC_VCAMSL, ioaddr + CamCon); 1310 wmb(); 1311 1312 /* Paranoid -- idx out of range should never happen */ 1313 idx &= (VCAM_SIZE - 1); 1314 1315 iowrite8((u8) idx, ioaddr + CamAddr); 1316 1317 iowrite16(*((u16 *) addr), ioaddr + MulticastFilter0 + 6); 1318 udelay(10); 1319 wmb(); 1320 1321 iowrite8(CAMC_CAMWR | CAMC_CAMEN, ioaddr + CamCon); 1322 udelay(10); 1323 1324 iowrite8(0, ioaddr + CamCon); 1325 } 1326 1327 /** 1328 * rhine_set_cam_mask - set multicast CAM mask 1329 * @ioaddr: register block of this Rhine 1330 * @mask: multicast CAM mask 1331 * 1332 * Mask sets multicast filters active/inactive. 1333 */ 1334 static void rhine_set_cam_mask(void __iomem *ioaddr, u32 mask) 1335 { 1336 iowrite8(CAMC_CAMEN, ioaddr + CamCon); 1337 wmb(); 1338 1339 /* write mask */ 1340 iowrite32(mask, ioaddr + CamMask); 1341 1342 /* disable CAMEN */ 1343 iowrite8(0, ioaddr + CamCon); 1344 } 1345 1346 /** 1347 * rhine_set_vlan_cam_mask - set VLAN CAM mask 1348 * @ioaddr: register block of this Rhine 1349 * @mask: VLAN CAM mask 1350 * 1351 * Mask sets VLAN filters active/inactive. 1352 */ 1353 static void rhine_set_vlan_cam_mask(void __iomem *ioaddr, u32 mask) 1354 { 1355 iowrite8(CAMC_CAMEN | CAMC_VCAMSL, ioaddr + CamCon); 1356 wmb(); 1357 1358 /* write mask */ 1359 iowrite32(mask, ioaddr + CamMask); 1360 1361 /* disable CAMEN */ 1362 iowrite8(0, ioaddr + CamCon); 1363 } 1364 1365 /** 1366 * rhine_init_cam_filter - initialize CAM filters 1367 * @dev: network device 1368 * 1369 * Initialize (disable) hardware VLAN and multicast support on this 1370 * Rhine. 1371 */ 1372 static void rhine_init_cam_filter(struct net_device *dev) 1373 { 1374 struct rhine_private *rp = netdev_priv(dev); 1375 void __iomem *ioaddr = rp->base; 1376 1377 /* Disable all CAMs */ 1378 rhine_set_vlan_cam_mask(ioaddr, 0); 1379 rhine_set_cam_mask(ioaddr, 0); 1380 1381 /* disable hardware VLAN support */ 1382 BYTE_REG_BITS_ON(TCR_PQEN, ioaddr + TxConfig); 1383 BYTE_REG_BITS_OFF(BCR1_VIDFR, ioaddr + PCIBusConfig1); 1384 } 1385 1386 /** 1387 * rhine_update_vcam - update VLAN CAM filters 1388 * @rp: rhine_private data of this Rhine 1389 * 1390 * Update VLAN CAM filters to match configuration change. 1391 */ 1392 static void rhine_update_vcam(struct net_device *dev) 1393 { 1394 struct rhine_private *rp = netdev_priv(dev); 1395 void __iomem *ioaddr = rp->base; 1396 u16 vid; 1397 u32 vCAMmask = 0; /* 32 vCAMs (6105M and better) */ 1398 unsigned int i = 0; 1399 1400 for_each_set_bit(vid, rp->active_vlans, VLAN_N_VID) { 1401 rhine_set_vlan_cam(ioaddr, i, (u8 *)&vid); 1402 vCAMmask |= 1 << i; 1403 if (++i >= VCAM_SIZE) 1404 break; 1405 } 1406 rhine_set_vlan_cam_mask(ioaddr, vCAMmask); 1407 } 1408 1409 static int rhine_vlan_rx_add_vid(struct net_device *dev, unsigned short vid) 1410 { 1411 struct rhine_private *rp = netdev_priv(dev); 1412 1413 spin_lock_bh(&rp->lock); 1414 set_bit(vid, rp->active_vlans); 1415 rhine_update_vcam(dev); 1416 spin_unlock_bh(&rp->lock); 1417 return 0; 1418 } 1419 1420 static int rhine_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid) 1421 { 1422 struct rhine_private *rp = netdev_priv(dev); 1423 1424 spin_lock_bh(&rp->lock); 1425 clear_bit(vid, rp->active_vlans); 1426 rhine_update_vcam(dev); 1427 spin_unlock_bh(&rp->lock); 1428 return 0; 1429 } 1430 1431 static void init_registers(struct net_device *dev) 1432 { 1433 struct rhine_private *rp = netdev_priv(dev); 1434 void __iomem *ioaddr = rp->base; 1435 int i; 1436 1437 for (i = 0; i < 6; i++) 1438 iowrite8(dev->dev_addr[i], ioaddr + StationAddr + i); 1439 1440 /* Initialize other registers. */ 1441 iowrite16(0x0006, ioaddr + PCIBusConfig); /* Tune configuration??? */ 1442 /* Configure initial FIFO thresholds. */ 1443 iowrite8(0x20, ioaddr + TxConfig); 1444 rp->tx_thresh = 0x20; 1445 rp->rx_thresh = 0x60; /* Written in rhine_set_rx_mode(). */ 1446 1447 iowrite32(rp->rx_ring_dma, ioaddr + RxRingPtr); 1448 iowrite32(rp->tx_ring_dma, ioaddr + TxRingPtr); 1449 1450 rhine_set_rx_mode(dev); 1451 1452 if (rp->pdev->revision >= VT6105M) 1453 rhine_init_cam_filter(dev); 1454 1455 napi_enable(&rp->napi); 1456 1457 iowrite16(RHINE_EVENT & 0xffff, ioaddr + IntrEnable); 1458 1459 iowrite16(CmdStart | CmdTxOn | CmdRxOn | (Cmd1NoTxPoll << 8), 1460 ioaddr + ChipCmd); 1461 rhine_check_media(dev, 1); 1462 } 1463 1464 /* Enable MII link status auto-polling (required for IntrLinkChange) */ 1465 static void rhine_enable_linkmon(struct rhine_private *rp) 1466 { 1467 void __iomem *ioaddr = rp->base; 1468 1469 iowrite8(0, ioaddr + MIICmd); 1470 iowrite8(MII_BMSR, ioaddr + MIIRegAddr); 1471 iowrite8(0x80, ioaddr + MIICmd); 1472 1473 rhine_wait_bit_high(rp, MIIRegAddr, 0x20); 1474 1475 iowrite8(MII_BMSR | 0x40, ioaddr + MIIRegAddr); 1476 } 1477 1478 /* Disable MII link status auto-polling (required for MDIO access) */ 1479 static void rhine_disable_linkmon(struct rhine_private *rp) 1480 { 1481 void __iomem *ioaddr = rp->base; 1482 1483 iowrite8(0, ioaddr + MIICmd); 1484 1485 if (rp->quirks & rqRhineI) { 1486 iowrite8(0x01, ioaddr + MIIRegAddr); // MII_BMSR 1487 1488 /* Can be called from ISR. Evil. */ 1489 mdelay(1); 1490 1491 /* 0x80 must be set immediately before turning it off */ 1492 iowrite8(0x80, ioaddr + MIICmd); 1493 1494 rhine_wait_bit_high(rp, MIIRegAddr, 0x20); 1495 1496 /* Heh. Now clear 0x80 again. */ 1497 iowrite8(0, ioaddr + MIICmd); 1498 } 1499 else 1500 rhine_wait_bit_high(rp, MIIRegAddr, 0x80); 1501 } 1502 1503 /* Read and write over the MII Management Data I/O (MDIO) interface. */ 1504 1505 static int mdio_read(struct net_device *dev, int phy_id, int regnum) 1506 { 1507 struct rhine_private *rp = netdev_priv(dev); 1508 void __iomem *ioaddr = rp->base; 1509 int result; 1510 1511 rhine_disable_linkmon(rp); 1512 1513 /* rhine_disable_linkmon already cleared MIICmd */ 1514 iowrite8(phy_id, ioaddr + MIIPhyAddr); 1515 iowrite8(regnum, ioaddr + MIIRegAddr); 1516 iowrite8(0x40, ioaddr + MIICmd); /* Trigger read */ 1517 rhine_wait_bit_low(rp, MIICmd, 0x40); 1518 result = ioread16(ioaddr + MIIData); 1519 1520 rhine_enable_linkmon(rp); 1521 return result; 1522 } 1523 1524 static void mdio_write(struct net_device *dev, int phy_id, int regnum, int value) 1525 { 1526 struct rhine_private *rp = netdev_priv(dev); 1527 void __iomem *ioaddr = rp->base; 1528 1529 rhine_disable_linkmon(rp); 1530 1531 /* rhine_disable_linkmon already cleared MIICmd */ 1532 iowrite8(phy_id, ioaddr + MIIPhyAddr); 1533 iowrite8(regnum, ioaddr + MIIRegAddr); 1534 iowrite16(value, ioaddr + MIIData); 1535 iowrite8(0x20, ioaddr + MIICmd); /* Trigger write */ 1536 rhine_wait_bit_low(rp, MIICmd, 0x20); 1537 1538 rhine_enable_linkmon(rp); 1539 } 1540 1541 static void rhine_task_disable(struct rhine_private *rp) 1542 { 1543 mutex_lock(&rp->task_lock); 1544 rp->task_enable = false; 1545 mutex_unlock(&rp->task_lock); 1546 1547 cancel_work_sync(&rp->slow_event_task); 1548 cancel_work_sync(&rp->reset_task); 1549 } 1550 1551 static void rhine_task_enable(struct rhine_private *rp) 1552 { 1553 mutex_lock(&rp->task_lock); 1554 rp->task_enable = true; 1555 mutex_unlock(&rp->task_lock); 1556 } 1557 1558 static int rhine_open(struct net_device *dev) 1559 { 1560 struct rhine_private *rp = netdev_priv(dev); 1561 void __iomem *ioaddr = rp->base; 1562 int rc; 1563 1564 rc = request_irq(rp->pdev->irq, rhine_interrupt, IRQF_SHARED, dev->name, 1565 dev); 1566 if (rc) 1567 return rc; 1568 1569 netif_dbg(rp, ifup, dev, "%s() irq %d\n", __func__, rp->pdev->irq); 1570 1571 rc = alloc_ring(dev); 1572 if (rc) { 1573 free_irq(rp->pdev->irq, dev); 1574 return rc; 1575 } 1576 alloc_rbufs(dev); 1577 alloc_tbufs(dev); 1578 rhine_chip_reset(dev); 1579 rhine_task_enable(rp); 1580 init_registers(dev); 1581 1582 netif_dbg(rp, ifup, dev, "%s() Done - status %04x MII status: %04x\n", 1583 __func__, ioread16(ioaddr + ChipCmd), 1584 mdio_read(dev, rp->mii_if.phy_id, MII_BMSR)); 1585 1586 netif_start_queue(dev); 1587 1588 return 0; 1589 } 1590 1591 static void rhine_reset_task(struct work_struct *work) 1592 { 1593 struct rhine_private *rp = container_of(work, struct rhine_private, 1594 reset_task); 1595 struct net_device *dev = rp->dev; 1596 1597 mutex_lock(&rp->task_lock); 1598 1599 if (!rp->task_enable) 1600 goto out_unlock; 1601 1602 napi_disable(&rp->napi); 1603 spin_lock_bh(&rp->lock); 1604 1605 /* clear all descriptors */ 1606 free_tbufs(dev); 1607 free_rbufs(dev); 1608 alloc_tbufs(dev); 1609 alloc_rbufs(dev); 1610 1611 /* Reinitialize the hardware. */ 1612 rhine_chip_reset(dev); 1613 init_registers(dev); 1614 1615 spin_unlock_bh(&rp->lock); 1616 1617 dev->trans_start = jiffies; /* prevent tx timeout */ 1618 dev->stats.tx_errors++; 1619 netif_wake_queue(dev); 1620 1621 out_unlock: 1622 mutex_unlock(&rp->task_lock); 1623 } 1624 1625 static void rhine_tx_timeout(struct net_device *dev) 1626 { 1627 struct rhine_private *rp = netdev_priv(dev); 1628 void __iomem *ioaddr = rp->base; 1629 1630 netdev_warn(dev, "Transmit timed out, status %04x, PHY status %04x, resetting...\n", 1631 ioread16(ioaddr + IntrStatus), 1632 mdio_read(dev, rp->mii_if.phy_id, MII_BMSR)); 1633 1634 schedule_work(&rp->reset_task); 1635 } 1636 1637 static netdev_tx_t rhine_start_tx(struct sk_buff *skb, 1638 struct net_device *dev) 1639 { 1640 struct rhine_private *rp = netdev_priv(dev); 1641 void __iomem *ioaddr = rp->base; 1642 unsigned entry; 1643 1644 /* Caution: the write order is important here, set the field 1645 with the "ownership" bits last. */ 1646 1647 /* Calculate the next Tx descriptor entry. */ 1648 entry = rp->cur_tx % TX_RING_SIZE; 1649 1650 if (skb_padto(skb, ETH_ZLEN)) 1651 return NETDEV_TX_OK; 1652 1653 rp->tx_skbuff[entry] = skb; 1654 1655 if ((rp->quirks & rqRhineI) && 1656 (((unsigned long)skb->data & 3) || skb_shinfo(skb)->nr_frags != 0 || skb->ip_summed == CHECKSUM_PARTIAL)) { 1657 /* Must use alignment buffer. */ 1658 if (skb->len > PKT_BUF_SZ) { 1659 /* packet too long, drop it */ 1660 dev_kfree_skb(skb); 1661 rp->tx_skbuff[entry] = NULL; 1662 dev->stats.tx_dropped++; 1663 return NETDEV_TX_OK; 1664 } 1665 1666 /* Padding is not copied and so must be redone. */ 1667 skb_copy_and_csum_dev(skb, rp->tx_buf[entry]); 1668 if (skb->len < ETH_ZLEN) 1669 memset(rp->tx_buf[entry] + skb->len, 0, 1670 ETH_ZLEN - skb->len); 1671 rp->tx_skbuff_dma[entry] = 0; 1672 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_bufs_dma + 1673 (rp->tx_buf[entry] - 1674 rp->tx_bufs)); 1675 } else { 1676 rp->tx_skbuff_dma[entry] = 1677 pci_map_single(rp->pdev, skb->data, skb->len, 1678 PCI_DMA_TODEVICE); 1679 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_skbuff_dma[entry]); 1680 } 1681 1682 rp->tx_ring[entry].desc_length = 1683 cpu_to_le32(TXDESC | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN)); 1684 1685 if (unlikely(vlan_tx_tag_present(skb))) { 1686 rp->tx_ring[entry].tx_status = cpu_to_le32((vlan_tx_tag_get(skb)) << 16); 1687 /* request tagging */ 1688 rp->tx_ring[entry].desc_length |= cpu_to_le32(0x020000); 1689 } 1690 else 1691 rp->tx_ring[entry].tx_status = 0; 1692 1693 /* lock eth irq */ 1694 wmb(); 1695 rp->tx_ring[entry].tx_status |= cpu_to_le32(DescOwn); 1696 wmb(); 1697 1698 rp->cur_tx++; 1699 1700 /* Non-x86 Todo: explicitly flush cache lines here. */ 1701 1702 if (vlan_tx_tag_present(skb)) 1703 /* Tx queues are bits 7-0 (first Tx queue: bit 7) */ 1704 BYTE_REG_BITS_ON(1 << 7, ioaddr + TQWake); 1705 1706 /* Wake the potentially-idle transmit channel */ 1707 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand, 1708 ioaddr + ChipCmd1); 1709 IOSYNC; 1710 1711 if (rp->cur_tx == rp->dirty_tx + TX_QUEUE_LEN) 1712 netif_stop_queue(dev); 1713 1714 netif_dbg(rp, tx_queued, dev, "Transmit frame #%d queued in slot %d\n", 1715 rp->cur_tx - 1, entry); 1716 1717 return NETDEV_TX_OK; 1718 } 1719 1720 static void rhine_irq_disable(struct rhine_private *rp) 1721 { 1722 iowrite16(0x0000, rp->base + IntrEnable); 1723 mmiowb(); 1724 } 1725 1726 /* The interrupt handler does all of the Rx thread work and cleans up 1727 after the Tx thread. */ 1728 static irqreturn_t rhine_interrupt(int irq, void *dev_instance) 1729 { 1730 struct net_device *dev = dev_instance; 1731 struct rhine_private *rp = netdev_priv(dev); 1732 u32 status; 1733 int handled = 0; 1734 1735 status = rhine_get_events(rp); 1736 1737 netif_dbg(rp, intr, dev, "Interrupt, status %08x\n", status); 1738 1739 if (status & RHINE_EVENT) { 1740 handled = 1; 1741 1742 rhine_irq_disable(rp); 1743 napi_schedule(&rp->napi); 1744 } 1745 1746 if (status & ~(IntrLinkChange | IntrStatsMax | RHINE_EVENT_NAPI)) { 1747 netif_err(rp, intr, dev, "Something Wicked happened! %08x\n", 1748 status); 1749 } 1750 1751 return IRQ_RETVAL(handled); 1752 } 1753 1754 /* This routine is logically part of the interrupt handler, but isolated 1755 for clarity. */ 1756 static void rhine_tx(struct net_device *dev) 1757 { 1758 struct rhine_private *rp = netdev_priv(dev); 1759 int txstatus = 0, entry = rp->dirty_tx % TX_RING_SIZE; 1760 1761 /* find and cleanup dirty tx descriptors */ 1762 while (rp->dirty_tx != rp->cur_tx) { 1763 txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status); 1764 netif_dbg(rp, tx_done, dev, "Tx scavenge %d status %08x\n", 1765 entry, txstatus); 1766 if (txstatus & DescOwn) 1767 break; 1768 if (txstatus & 0x8000) { 1769 netif_dbg(rp, tx_done, dev, 1770 "Transmit error, Tx status %08x\n", txstatus); 1771 dev->stats.tx_errors++; 1772 if (txstatus & 0x0400) 1773 dev->stats.tx_carrier_errors++; 1774 if (txstatus & 0x0200) 1775 dev->stats.tx_window_errors++; 1776 if (txstatus & 0x0100) 1777 dev->stats.tx_aborted_errors++; 1778 if (txstatus & 0x0080) 1779 dev->stats.tx_heartbeat_errors++; 1780 if (((rp->quirks & rqRhineI) && txstatus & 0x0002) || 1781 (txstatus & 0x0800) || (txstatus & 0x1000)) { 1782 dev->stats.tx_fifo_errors++; 1783 rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn); 1784 break; /* Keep the skb - we try again */ 1785 } 1786 /* Transmitter restarted in 'abnormal' handler. */ 1787 } else { 1788 if (rp->quirks & rqRhineI) 1789 dev->stats.collisions += (txstatus >> 3) & 0x0F; 1790 else 1791 dev->stats.collisions += txstatus & 0x0F; 1792 netif_dbg(rp, tx_done, dev, "collisions: %1.1x:%1.1x\n", 1793 (txstatus >> 3) & 0xF, txstatus & 0xF); 1794 dev->stats.tx_bytes += rp->tx_skbuff[entry]->len; 1795 dev->stats.tx_packets++; 1796 } 1797 /* Free the original skb. */ 1798 if (rp->tx_skbuff_dma[entry]) { 1799 pci_unmap_single(rp->pdev, 1800 rp->tx_skbuff_dma[entry], 1801 rp->tx_skbuff[entry]->len, 1802 PCI_DMA_TODEVICE); 1803 } 1804 dev_kfree_skb_irq(rp->tx_skbuff[entry]); 1805 rp->tx_skbuff[entry] = NULL; 1806 entry = (++rp->dirty_tx) % TX_RING_SIZE; 1807 } 1808 if ((rp->cur_tx - rp->dirty_tx) < TX_QUEUE_LEN - 4) 1809 netif_wake_queue(dev); 1810 } 1811 1812 /** 1813 * rhine_get_vlan_tci - extract TCI from Rx data buffer 1814 * @skb: pointer to sk_buff 1815 * @data_size: used data area of the buffer including CRC 1816 * 1817 * If hardware VLAN tag extraction is enabled and the chip indicates a 802.1Q 1818 * packet, the extracted 802.1Q header (2 bytes TPID + 2 bytes TCI) is 4-byte 1819 * aligned following the CRC. 1820 */ 1821 static inline u16 rhine_get_vlan_tci(struct sk_buff *skb, int data_size) 1822 { 1823 u8 *trailer = (u8 *)skb->data + ((data_size + 3) & ~3) + 2; 1824 return be16_to_cpup((__be16 *)trailer); 1825 } 1826 1827 /* Process up to limit frames from receive ring */ 1828 static int rhine_rx(struct net_device *dev, int limit) 1829 { 1830 struct rhine_private *rp = netdev_priv(dev); 1831 int count; 1832 int entry = rp->cur_rx % RX_RING_SIZE; 1833 1834 netif_dbg(rp, rx_status, dev, "%s(), entry %d status %08x\n", __func__, 1835 entry, le32_to_cpu(rp->rx_head_desc->rx_status)); 1836 1837 /* If EOP is set on the next entry, it's a new packet. Send it up. */ 1838 for (count = 0; count < limit; ++count) { 1839 struct rx_desc *desc = rp->rx_head_desc; 1840 u32 desc_status = le32_to_cpu(desc->rx_status); 1841 u32 desc_length = le32_to_cpu(desc->desc_length); 1842 int data_size = desc_status >> 16; 1843 1844 if (desc_status & DescOwn) 1845 break; 1846 1847 netif_dbg(rp, rx_status, dev, "%s() status %08x\n", __func__, 1848 desc_status); 1849 1850 if ((desc_status & (RxWholePkt | RxErr)) != RxWholePkt) { 1851 if ((desc_status & RxWholePkt) != RxWholePkt) { 1852 netdev_warn(dev, 1853 "Oversized Ethernet frame spanned multiple buffers, " 1854 "entry %#x length %d status %08x!\n", 1855 entry, data_size, 1856 desc_status); 1857 netdev_warn(dev, 1858 "Oversized Ethernet frame %p vs %p\n", 1859 rp->rx_head_desc, 1860 &rp->rx_ring[entry]); 1861 dev->stats.rx_length_errors++; 1862 } else if (desc_status & RxErr) { 1863 /* There was a error. */ 1864 netif_dbg(rp, rx_err, dev, 1865 "%s() Rx error %08x\n", __func__, 1866 desc_status); 1867 dev->stats.rx_errors++; 1868 if (desc_status & 0x0030) 1869 dev->stats.rx_length_errors++; 1870 if (desc_status & 0x0048) 1871 dev->stats.rx_fifo_errors++; 1872 if (desc_status & 0x0004) 1873 dev->stats.rx_frame_errors++; 1874 if (desc_status & 0x0002) { 1875 /* this can also be updated outside the interrupt handler */ 1876 spin_lock(&rp->lock); 1877 dev->stats.rx_crc_errors++; 1878 spin_unlock(&rp->lock); 1879 } 1880 } 1881 } else { 1882 struct sk_buff *skb = NULL; 1883 /* Length should omit the CRC */ 1884 int pkt_len = data_size - 4; 1885 u16 vlan_tci = 0; 1886 1887 /* Check if the packet is long enough to accept without 1888 copying to a minimally-sized skbuff. */ 1889 if (pkt_len < rx_copybreak) 1890 skb = netdev_alloc_skb_ip_align(dev, pkt_len); 1891 if (skb) { 1892 pci_dma_sync_single_for_cpu(rp->pdev, 1893 rp->rx_skbuff_dma[entry], 1894 rp->rx_buf_sz, 1895 PCI_DMA_FROMDEVICE); 1896 1897 skb_copy_to_linear_data(skb, 1898 rp->rx_skbuff[entry]->data, 1899 pkt_len); 1900 skb_put(skb, pkt_len); 1901 pci_dma_sync_single_for_device(rp->pdev, 1902 rp->rx_skbuff_dma[entry], 1903 rp->rx_buf_sz, 1904 PCI_DMA_FROMDEVICE); 1905 } else { 1906 skb = rp->rx_skbuff[entry]; 1907 if (skb == NULL) { 1908 netdev_err(dev, "Inconsistent Rx descriptor chain\n"); 1909 break; 1910 } 1911 rp->rx_skbuff[entry] = NULL; 1912 skb_put(skb, pkt_len); 1913 pci_unmap_single(rp->pdev, 1914 rp->rx_skbuff_dma[entry], 1915 rp->rx_buf_sz, 1916 PCI_DMA_FROMDEVICE); 1917 } 1918 1919 if (unlikely(desc_length & DescTag)) 1920 vlan_tci = rhine_get_vlan_tci(skb, data_size); 1921 1922 skb->protocol = eth_type_trans(skb, dev); 1923 1924 if (unlikely(desc_length & DescTag)) 1925 __vlan_hwaccel_put_tag(skb, vlan_tci); 1926 netif_receive_skb(skb); 1927 dev->stats.rx_bytes += pkt_len; 1928 dev->stats.rx_packets++; 1929 } 1930 entry = (++rp->cur_rx) % RX_RING_SIZE; 1931 rp->rx_head_desc = &rp->rx_ring[entry]; 1932 } 1933 1934 /* Refill the Rx ring buffers. */ 1935 for (; rp->cur_rx - rp->dirty_rx > 0; rp->dirty_rx++) { 1936 struct sk_buff *skb; 1937 entry = rp->dirty_rx % RX_RING_SIZE; 1938 if (rp->rx_skbuff[entry] == NULL) { 1939 skb = netdev_alloc_skb(dev, rp->rx_buf_sz); 1940 rp->rx_skbuff[entry] = skb; 1941 if (skb == NULL) 1942 break; /* Better luck next round. */ 1943 rp->rx_skbuff_dma[entry] = 1944 pci_map_single(rp->pdev, skb->data, 1945 rp->rx_buf_sz, 1946 PCI_DMA_FROMDEVICE); 1947 rp->rx_ring[entry].addr = cpu_to_le32(rp->rx_skbuff_dma[entry]); 1948 } 1949 rp->rx_ring[entry].rx_status = cpu_to_le32(DescOwn); 1950 } 1951 1952 return count; 1953 } 1954 1955 static void rhine_restart_tx(struct net_device *dev) { 1956 struct rhine_private *rp = netdev_priv(dev); 1957 void __iomem *ioaddr = rp->base; 1958 int entry = rp->dirty_tx % TX_RING_SIZE; 1959 u32 intr_status; 1960 1961 /* 1962 * If new errors occurred, we need to sort them out before doing Tx. 1963 * In that case the ISR will be back here RSN anyway. 1964 */ 1965 intr_status = rhine_get_events(rp); 1966 1967 if ((intr_status & IntrTxErrSummary) == 0) { 1968 1969 /* We know better than the chip where it should continue. */ 1970 iowrite32(rp->tx_ring_dma + entry * sizeof(struct tx_desc), 1971 ioaddr + TxRingPtr); 1972 1973 iowrite8(ioread8(ioaddr + ChipCmd) | CmdTxOn, 1974 ioaddr + ChipCmd); 1975 1976 if (rp->tx_ring[entry].desc_length & cpu_to_le32(0x020000)) 1977 /* Tx queues are bits 7-0 (first Tx queue: bit 7) */ 1978 BYTE_REG_BITS_ON(1 << 7, ioaddr + TQWake); 1979 1980 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand, 1981 ioaddr + ChipCmd1); 1982 IOSYNC; 1983 } 1984 else { 1985 /* This should never happen */ 1986 netif_warn(rp, tx_err, dev, "another error occurred %08x\n", 1987 intr_status); 1988 } 1989 1990 } 1991 1992 static void rhine_slow_event_task(struct work_struct *work) 1993 { 1994 struct rhine_private *rp = 1995 container_of(work, struct rhine_private, slow_event_task); 1996 struct net_device *dev = rp->dev; 1997 u32 intr_status; 1998 1999 mutex_lock(&rp->task_lock); 2000 2001 if (!rp->task_enable) 2002 goto out_unlock; 2003 2004 intr_status = rhine_get_events(rp); 2005 rhine_ack_events(rp, intr_status & RHINE_EVENT_SLOW); 2006 2007 if (intr_status & IntrLinkChange) 2008 rhine_check_media(dev, 0); 2009 2010 if (intr_status & IntrPCIErr) 2011 netif_warn(rp, hw, dev, "PCI error\n"); 2012 2013 napi_disable(&rp->napi); 2014 rhine_irq_disable(rp); 2015 /* Slow and safe. Consider __napi_schedule as a replacement ? */ 2016 napi_enable(&rp->napi); 2017 napi_schedule(&rp->napi); 2018 2019 out_unlock: 2020 mutex_unlock(&rp->task_lock); 2021 } 2022 2023 static struct net_device_stats *rhine_get_stats(struct net_device *dev) 2024 { 2025 struct rhine_private *rp = netdev_priv(dev); 2026 2027 spin_lock_bh(&rp->lock); 2028 rhine_update_rx_crc_and_missed_errord(rp); 2029 spin_unlock_bh(&rp->lock); 2030 2031 return &dev->stats; 2032 } 2033 2034 static void rhine_set_rx_mode(struct net_device *dev) 2035 { 2036 struct rhine_private *rp = netdev_priv(dev); 2037 void __iomem *ioaddr = rp->base; 2038 u32 mc_filter[2]; /* Multicast hash filter */ 2039 u8 rx_mode = 0x0C; /* Note: 0x02=accept runt, 0x01=accept errs */ 2040 struct netdev_hw_addr *ha; 2041 2042 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ 2043 rx_mode = 0x1C; 2044 iowrite32(0xffffffff, ioaddr + MulticastFilter0); 2045 iowrite32(0xffffffff, ioaddr + MulticastFilter1); 2046 } else if ((netdev_mc_count(dev) > multicast_filter_limit) || 2047 (dev->flags & IFF_ALLMULTI)) { 2048 /* Too many to match, or accept all multicasts. */ 2049 iowrite32(0xffffffff, ioaddr + MulticastFilter0); 2050 iowrite32(0xffffffff, ioaddr + MulticastFilter1); 2051 } else if (rp->pdev->revision >= VT6105M) { 2052 int i = 0; 2053 u32 mCAMmask = 0; /* 32 mCAMs (6105M and better) */ 2054 netdev_for_each_mc_addr(ha, dev) { 2055 if (i == MCAM_SIZE) 2056 break; 2057 rhine_set_cam(ioaddr, i, ha->addr); 2058 mCAMmask |= 1 << i; 2059 i++; 2060 } 2061 rhine_set_cam_mask(ioaddr, mCAMmask); 2062 } else { 2063 memset(mc_filter, 0, sizeof(mc_filter)); 2064 netdev_for_each_mc_addr(ha, dev) { 2065 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26; 2066 2067 mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31); 2068 } 2069 iowrite32(mc_filter[0], ioaddr + MulticastFilter0); 2070 iowrite32(mc_filter[1], ioaddr + MulticastFilter1); 2071 } 2072 /* enable/disable VLAN receive filtering */ 2073 if (rp->pdev->revision >= VT6105M) { 2074 if (dev->flags & IFF_PROMISC) 2075 BYTE_REG_BITS_OFF(BCR1_VIDFR, ioaddr + PCIBusConfig1); 2076 else 2077 BYTE_REG_BITS_ON(BCR1_VIDFR, ioaddr + PCIBusConfig1); 2078 } 2079 BYTE_REG_BITS_ON(rx_mode, ioaddr + RxConfig); 2080 } 2081 2082 static void netdev_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 2083 { 2084 struct rhine_private *rp = netdev_priv(dev); 2085 2086 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 2087 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 2088 strlcpy(info->bus_info, pci_name(rp->pdev), sizeof(info->bus_info)); 2089 } 2090 2091 static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 2092 { 2093 struct rhine_private *rp = netdev_priv(dev); 2094 int rc; 2095 2096 mutex_lock(&rp->task_lock); 2097 rc = mii_ethtool_gset(&rp->mii_if, cmd); 2098 mutex_unlock(&rp->task_lock); 2099 2100 return rc; 2101 } 2102 2103 static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 2104 { 2105 struct rhine_private *rp = netdev_priv(dev); 2106 int rc; 2107 2108 mutex_lock(&rp->task_lock); 2109 rc = mii_ethtool_sset(&rp->mii_if, cmd); 2110 rhine_set_carrier(&rp->mii_if); 2111 mutex_unlock(&rp->task_lock); 2112 2113 return rc; 2114 } 2115 2116 static int netdev_nway_reset(struct net_device *dev) 2117 { 2118 struct rhine_private *rp = netdev_priv(dev); 2119 2120 return mii_nway_restart(&rp->mii_if); 2121 } 2122 2123 static u32 netdev_get_link(struct net_device *dev) 2124 { 2125 struct rhine_private *rp = netdev_priv(dev); 2126 2127 return mii_link_ok(&rp->mii_if); 2128 } 2129 2130 static u32 netdev_get_msglevel(struct net_device *dev) 2131 { 2132 struct rhine_private *rp = netdev_priv(dev); 2133 2134 return rp->msg_enable; 2135 } 2136 2137 static void netdev_set_msglevel(struct net_device *dev, u32 value) 2138 { 2139 struct rhine_private *rp = netdev_priv(dev); 2140 2141 rp->msg_enable = value; 2142 } 2143 2144 static void rhine_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 2145 { 2146 struct rhine_private *rp = netdev_priv(dev); 2147 2148 if (!(rp->quirks & rqWOL)) 2149 return; 2150 2151 spin_lock_irq(&rp->lock); 2152 wol->supported = WAKE_PHY | WAKE_MAGIC | 2153 WAKE_UCAST | WAKE_MCAST | WAKE_BCAST; /* Untested */ 2154 wol->wolopts = rp->wolopts; 2155 spin_unlock_irq(&rp->lock); 2156 } 2157 2158 static int rhine_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 2159 { 2160 struct rhine_private *rp = netdev_priv(dev); 2161 u32 support = WAKE_PHY | WAKE_MAGIC | 2162 WAKE_UCAST | WAKE_MCAST | WAKE_BCAST; /* Untested */ 2163 2164 if (!(rp->quirks & rqWOL)) 2165 return -EINVAL; 2166 2167 if (wol->wolopts & ~support) 2168 return -EINVAL; 2169 2170 spin_lock_irq(&rp->lock); 2171 rp->wolopts = wol->wolopts; 2172 spin_unlock_irq(&rp->lock); 2173 2174 return 0; 2175 } 2176 2177 static const struct ethtool_ops netdev_ethtool_ops = { 2178 .get_drvinfo = netdev_get_drvinfo, 2179 .get_settings = netdev_get_settings, 2180 .set_settings = netdev_set_settings, 2181 .nway_reset = netdev_nway_reset, 2182 .get_link = netdev_get_link, 2183 .get_msglevel = netdev_get_msglevel, 2184 .set_msglevel = netdev_set_msglevel, 2185 .get_wol = rhine_get_wol, 2186 .set_wol = rhine_set_wol, 2187 }; 2188 2189 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 2190 { 2191 struct rhine_private *rp = netdev_priv(dev); 2192 int rc; 2193 2194 if (!netif_running(dev)) 2195 return -EINVAL; 2196 2197 mutex_lock(&rp->task_lock); 2198 rc = generic_mii_ioctl(&rp->mii_if, if_mii(rq), cmd, NULL); 2199 rhine_set_carrier(&rp->mii_if); 2200 mutex_unlock(&rp->task_lock); 2201 2202 return rc; 2203 } 2204 2205 static int rhine_close(struct net_device *dev) 2206 { 2207 struct rhine_private *rp = netdev_priv(dev); 2208 void __iomem *ioaddr = rp->base; 2209 2210 rhine_task_disable(rp); 2211 napi_disable(&rp->napi); 2212 netif_stop_queue(dev); 2213 2214 netif_dbg(rp, ifdown, dev, "Shutting down ethercard, status was %04x\n", 2215 ioread16(ioaddr + ChipCmd)); 2216 2217 /* Switch to loopback mode to avoid hardware races. */ 2218 iowrite8(rp->tx_thresh | 0x02, ioaddr + TxConfig); 2219 2220 rhine_irq_disable(rp); 2221 2222 /* Stop the chip's Tx and Rx processes. */ 2223 iowrite16(CmdStop, ioaddr + ChipCmd); 2224 2225 free_irq(rp->pdev->irq, dev); 2226 free_rbufs(dev); 2227 free_tbufs(dev); 2228 free_ring(dev); 2229 2230 return 0; 2231 } 2232 2233 2234 static void rhine_remove_one(struct pci_dev *pdev) 2235 { 2236 struct net_device *dev = pci_get_drvdata(pdev); 2237 struct rhine_private *rp = netdev_priv(dev); 2238 2239 unregister_netdev(dev); 2240 2241 pci_iounmap(pdev, rp->base); 2242 pci_release_regions(pdev); 2243 2244 free_netdev(dev); 2245 pci_disable_device(pdev); 2246 pci_set_drvdata(pdev, NULL); 2247 } 2248 2249 static void rhine_shutdown (struct pci_dev *pdev) 2250 { 2251 struct net_device *dev = pci_get_drvdata(pdev); 2252 struct rhine_private *rp = netdev_priv(dev); 2253 void __iomem *ioaddr = rp->base; 2254 2255 if (!(rp->quirks & rqWOL)) 2256 return; /* Nothing to do for non-WOL adapters */ 2257 2258 rhine_power_init(dev); 2259 2260 /* Make sure we use pattern 0, 1 and not 4, 5 */ 2261 if (rp->quirks & rq6patterns) 2262 iowrite8(0x04, ioaddr + WOLcgClr); 2263 2264 spin_lock(&rp->lock); 2265 2266 if (rp->wolopts & WAKE_MAGIC) { 2267 iowrite8(WOLmagic, ioaddr + WOLcrSet); 2268 /* 2269 * Turn EEPROM-controlled wake-up back on -- some hardware may 2270 * not cooperate otherwise. 2271 */ 2272 iowrite8(ioread8(ioaddr + ConfigA) | 0x03, ioaddr + ConfigA); 2273 } 2274 2275 if (rp->wolopts & (WAKE_BCAST|WAKE_MCAST)) 2276 iowrite8(WOLbmcast, ioaddr + WOLcgSet); 2277 2278 if (rp->wolopts & WAKE_PHY) 2279 iowrite8(WOLlnkon | WOLlnkoff, ioaddr + WOLcrSet); 2280 2281 if (rp->wolopts & WAKE_UCAST) 2282 iowrite8(WOLucast, ioaddr + WOLcrSet); 2283 2284 if (rp->wolopts) { 2285 /* Enable legacy WOL (for old motherboards) */ 2286 iowrite8(0x01, ioaddr + PwcfgSet); 2287 iowrite8(ioread8(ioaddr + StickyHW) | 0x04, ioaddr + StickyHW); 2288 } 2289 2290 spin_unlock(&rp->lock); 2291 2292 if (system_state == SYSTEM_POWER_OFF && !avoid_D3) { 2293 iowrite8(ioread8(ioaddr + StickyHW) | 0x03, ioaddr + StickyHW); 2294 2295 pci_wake_from_d3(pdev, true); 2296 pci_set_power_state(pdev, PCI_D3hot); 2297 } 2298 } 2299 2300 #ifdef CONFIG_PM_SLEEP 2301 static int rhine_suspend(struct device *device) 2302 { 2303 struct pci_dev *pdev = to_pci_dev(device); 2304 struct net_device *dev = pci_get_drvdata(pdev); 2305 struct rhine_private *rp = netdev_priv(dev); 2306 2307 if (!netif_running(dev)) 2308 return 0; 2309 2310 rhine_task_disable(rp); 2311 rhine_irq_disable(rp); 2312 napi_disable(&rp->napi); 2313 2314 netif_device_detach(dev); 2315 2316 rhine_shutdown(pdev); 2317 2318 return 0; 2319 } 2320 2321 static int rhine_resume(struct device *device) 2322 { 2323 struct pci_dev *pdev = to_pci_dev(device); 2324 struct net_device *dev = pci_get_drvdata(pdev); 2325 struct rhine_private *rp = netdev_priv(dev); 2326 2327 if (!netif_running(dev)) 2328 return 0; 2329 2330 #ifdef USE_MMIO 2331 enable_mmio(rp->pioaddr, rp->quirks); 2332 #endif 2333 rhine_power_init(dev); 2334 free_tbufs(dev); 2335 free_rbufs(dev); 2336 alloc_tbufs(dev); 2337 alloc_rbufs(dev); 2338 rhine_task_enable(rp); 2339 spin_lock_bh(&rp->lock); 2340 init_registers(dev); 2341 spin_unlock_bh(&rp->lock); 2342 2343 netif_device_attach(dev); 2344 2345 return 0; 2346 } 2347 2348 static SIMPLE_DEV_PM_OPS(rhine_pm_ops, rhine_suspend, rhine_resume); 2349 #define RHINE_PM_OPS (&rhine_pm_ops) 2350 2351 #else 2352 2353 #define RHINE_PM_OPS NULL 2354 2355 #endif /* !CONFIG_PM_SLEEP */ 2356 2357 static struct pci_driver rhine_driver = { 2358 .name = DRV_NAME, 2359 .id_table = rhine_pci_tbl, 2360 .probe = rhine_init_one, 2361 .remove = rhine_remove_one, 2362 .shutdown = rhine_shutdown, 2363 .driver.pm = RHINE_PM_OPS, 2364 }; 2365 2366 static struct dmi_system_id __initdata rhine_dmi_table[] = { 2367 { 2368 .ident = "EPIA-M", 2369 .matches = { 2370 DMI_MATCH(DMI_BIOS_VENDOR, "Award Software International, Inc."), 2371 DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"), 2372 }, 2373 }, 2374 { 2375 .ident = "KV7", 2376 .matches = { 2377 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"), 2378 DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"), 2379 }, 2380 }, 2381 { NULL } 2382 }; 2383 2384 static int __init rhine_init(void) 2385 { 2386 /* when a module, this is printed whether or not devices are found in probe */ 2387 #ifdef MODULE 2388 pr_info("%s\n", version); 2389 #endif 2390 if (dmi_check_system(rhine_dmi_table)) { 2391 /* these BIOSes fail at PXE boot if chip is in D3 */ 2392 avoid_D3 = true; 2393 pr_warn("Broken BIOS detected, avoid_D3 enabled\n"); 2394 } 2395 else if (avoid_D3) 2396 pr_info("avoid_D3 set\n"); 2397 2398 return pci_register_driver(&rhine_driver); 2399 } 2400 2401 2402 static void __exit rhine_cleanup(void) 2403 { 2404 pci_unregister_driver(&rhine_driver); 2405 } 2406 2407 2408 module_init(rhine_init); 2409 module_exit(rhine_cleanup); 2410