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.1" 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_stats { 421 u64 packets; 422 u64 bytes; 423 struct u64_stats_sync syncp; 424 }; 425 426 struct rhine_private { 427 /* Bit mask for configured VLAN ids */ 428 unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)]; 429 430 /* Descriptor rings */ 431 struct rx_desc *rx_ring; 432 struct tx_desc *tx_ring; 433 dma_addr_t rx_ring_dma; 434 dma_addr_t tx_ring_dma; 435 436 /* The addresses of receive-in-place skbuffs. */ 437 struct sk_buff *rx_skbuff[RX_RING_SIZE]; 438 dma_addr_t rx_skbuff_dma[RX_RING_SIZE]; 439 440 /* The saved address of a sent-in-place packet/buffer, for later free(). */ 441 struct sk_buff *tx_skbuff[TX_RING_SIZE]; 442 dma_addr_t tx_skbuff_dma[TX_RING_SIZE]; 443 444 /* Tx bounce buffers (Rhine-I only) */ 445 unsigned char *tx_buf[TX_RING_SIZE]; 446 unsigned char *tx_bufs; 447 dma_addr_t tx_bufs_dma; 448 449 struct pci_dev *pdev; 450 long pioaddr; 451 struct net_device *dev; 452 struct napi_struct napi; 453 spinlock_t lock; 454 struct mutex task_lock; 455 bool task_enable; 456 struct work_struct slow_event_task; 457 struct work_struct reset_task; 458 459 u32 msg_enable; 460 461 /* Frequently used values: keep some adjacent for cache effect. */ 462 u32 quirks; 463 struct rx_desc *rx_head_desc; 464 unsigned int cur_rx, dirty_rx; /* Producer/consumer ring indices */ 465 unsigned int cur_tx, dirty_tx; 466 unsigned int rx_buf_sz; /* Based on MTU+slack. */ 467 struct rhine_stats rx_stats; 468 struct rhine_stats tx_stats; 469 u8 wolopts; 470 471 u8 tx_thresh, rx_thresh; 472 473 struct mii_if_info mii_if; 474 void __iomem *base; 475 }; 476 477 #define BYTE_REG_BITS_ON(x, p) do { iowrite8((ioread8((p))|(x)), (p)); } while (0) 478 #define WORD_REG_BITS_ON(x, p) do { iowrite16((ioread16((p))|(x)), (p)); } while (0) 479 #define DWORD_REG_BITS_ON(x, p) do { iowrite32((ioread32((p))|(x)), (p)); } while (0) 480 481 #define BYTE_REG_BITS_IS_ON(x, p) (ioread8((p)) & (x)) 482 #define WORD_REG_BITS_IS_ON(x, p) (ioread16((p)) & (x)) 483 #define DWORD_REG_BITS_IS_ON(x, p) (ioread32((p)) & (x)) 484 485 #define BYTE_REG_BITS_OFF(x, p) do { iowrite8(ioread8((p)) & (~(x)), (p)); } while (0) 486 #define WORD_REG_BITS_OFF(x, p) do { iowrite16(ioread16((p)) & (~(x)), (p)); } while (0) 487 #define DWORD_REG_BITS_OFF(x, p) do { iowrite32(ioread32((p)) & (~(x)), (p)); } while (0) 488 489 #define BYTE_REG_BITS_SET(x, m, p) do { iowrite8((ioread8((p)) & (~(m)))|(x), (p)); } while (0) 490 #define WORD_REG_BITS_SET(x, m, p) do { iowrite16((ioread16((p)) & (~(m)))|(x), (p)); } while (0) 491 #define DWORD_REG_BITS_SET(x, m, p) do { iowrite32((ioread32((p)) & (~(m)))|(x), (p)); } while (0) 492 493 494 static int mdio_read(struct net_device *dev, int phy_id, int location); 495 static void mdio_write(struct net_device *dev, int phy_id, int location, int value); 496 static int rhine_open(struct net_device *dev); 497 static void rhine_reset_task(struct work_struct *work); 498 static void rhine_slow_event_task(struct work_struct *work); 499 static void rhine_tx_timeout(struct net_device *dev); 500 static netdev_tx_t rhine_start_tx(struct sk_buff *skb, 501 struct net_device *dev); 502 static irqreturn_t rhine_interrupt(int irq, void *dev_instance); 503 static void rhine_tx(struct net_device *dev); 504 static int rhine_rx(struct net_device *dev, int limit); 505 static void rhine_set_rx_mode(struct net_device *dev); 506 static struct rtnl_link_stats64 *rhine_get_stats64(struct net_device *dev, 507 struct rtnl_link_stats64 *stats); 508 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); 509 static const struct ethtool_ops netdev_ethtool_ops; 510 static int rhine_close(struct net_device *dev); 511 static int rhine_vlan_rx_add_vid(struct net_device *dev, 512 __be16 proto, u16 vid); 513 static int rhine_vlan_rx_kill_vid(struct net_device *dev, 514 __be16 proto, u16 vid); 515 static void rhine_restart_tx(struct net_device *dev); 516 517 static void rhine_wait_bit(struct rhine_private *rp, u8 reg, u8 mask, bool low) 518 { 519 void __iomem *ioaddr = rp->base; 520 int i; 521 522 for (i = 0; i < 1024; i++) { 523 bool has_mask_bits = !!(ioread8(ioaddr + reg) & mask); 524 525 if (low ^ has_mask_bits) 526 break; 527 udelay(10); 528 } 529 if (i > 64) { 530 netif_dbg(rp, hw, rp->dev, "%s bit wait (%02x/%02x) cycle " 531 "count: %04d\n", low ? "low" : "high", reg, mask, i); 532 } 533 } 534 535 static void rhine_wait_bit_high(struct rhine_private *rp, u8 reg, u8 mask) 536 { 537 rhine_wait_bit(rp, reg, mask, false); 538 } 539 540 static void rhine_wait_bit_low(struct rhine_private *rp, u8 reg, u8 mask) 541 { 542 rhine_wait_bit(rp, reg, mask, true); 543 } 544 545 static u32 rhine_get_events(struct rhine_private *rp) 546 { 547 void __iomem *ioaddr = rp->base; 548 u32 intr_status; 549 550 intr_status = ioread16(ioaddr + IntrStatus); 551 /* On Rhine-II, Bit 3 indicates Tx descriptor write-back race. */ 552 if (rp->quirks & rqStatusWBRace) 553 intr_status |= ioread8(ioaddr + IntrStatus2) << 16; 554 return intr_status; 555 } 556 557 static void rhine_ack_events(struct rhine_private *rp, u32 mask) 558 { 559 void __iomem *ioaddr = rp->base; 560 561 if (rp->quirks & rqStatusWBRace) 562 iowrite8(mask >> 16, ioaddr + IntrStatus2); 563 iowrite16(mask, ioaddr + IntrStatus); 564 mmiowb(); 565 } 566 567 /* 568 * Get power related registers into sane state. 569 * Notify user about past WOL event. 570 */ 571 static void rhine_power_init(struct net_device *dev) 572 { 573 struct rhine_private *rp = netdev_priv(dev); 574 void __iomem *ioaddr = rp->base; 575 u16 wolstat; 576 577 if (rp->quirks & rqWOL) { 578 /* Make sure chip is in power state D0 */ 579 iowrite8(ioread8(ioaddr + StickyHW) & 0xFC, ioaddr + StickyHW); 580 581 /* Disable "force PME-enable" */ 582 iowrite8(0x80, ioaddr + WOLcgClr); 583 584 /* Clear power-event config bits (WOL) */ 585 iowrite8(0xFF, ioaddr + WOLcrClr); 586 /* More recent cards can manage two additional patterns */ 587 if (rp->quirks & rq6patterns) 588 iowrite8(0x03, ioaddr + WOLcrClr1); 589 590 /* Save power-event status bits */ 591 wolstat = ioread8(ioaddr + PwrcsrSet); 592 if (rp->quirks & rq6patterns) 593 wolstat |= (ioread8(ioaddr + PwrcsrSet1) & 0x03) << 8; 594 595 /* Clear power-event status bits */ 596 iowrite8(0xFF, ioaddr + PwrcsrClr); 597 if (rp->quirks & rq6patterns) 598 iowrite8(0x03, ioaddr + PwrcsrClr1); 599 600 if (wolstat) { 601 char *reason; 602 switch (wolstat) { 603 case WOLmagic: 604 reason = "Magic packet"; 605 break; 606 case WOLlnkon: 607 reason = "Link went up"; 608 break; 609 case WOLlnkoff: 610 reason = "Link went down"; 611 break; 612 case WOLucast: 613 reason = "Unicast packet"; 614 break; 615 case WOLbmcast: 616 reason = "Multicast/broadcast packet"; 617 break; 618 default: 619 reason = "Unknown"; 620 } 621 netdev_info(dev, "Woke system up. Reason: %s\n", 622 reason); 623 } 624 } 625 } 626 627 static void rhine_chip_reset(struct net_device *dev) 628 { 629 struct rhine_private *rp = netdev_priv(dev); 630 void __iomem *ioaddr = rp->base; 631 u8 cmd1; 632 633 iowrite8(Cmd1Reset, ioaddr + ChipCmd1); 634 IOSYNC; 635 636 if (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) { 637 netdev_info(dev, "Reset not complete yet. Trying harder.\n"); 638 639 /* Force reset */ 640 if (rp->quirks & rqForceReset) 641 iowrite8(0x40, ioaddr + MiscCmd); 642 643 /* Reset can take somewhat longer (rare) */ 644 rhine_wait_bit_low(rp, ChipCmd1, Cmd1Reset); 645 } 646 647 cmd1 = ioread8(ioaddr + ChipCmd1); 648 netif_info(rp, hw, dev, "Reset %s\n", (cmd1 & Cmd1Reset) ? 649 "failed" : "succeeded"); 650 } 651 652 #ifdef USE_MMIO 653 static void enable_mmio(long pioaddr, u32 quirks) 654 { 655 int n; 656 if (quirks & rqRhineI) { 657 /* More recent docs say that this bit is reserved ... */ 658 n = inb(pioaddr + ConfigA) | 0x20; 659 outb(n, pioaddr + ConfigA); 660 } else { 661 n = inb(pioaddr + ConfigD) | 0x80; 662 outb(n, pioaddr + ConfigD); 663 } 664 } 665 #endif 666 667 /* 668 * Loads bytes 0x00-0x05, 0x6E-0x6F, 0x78-0x7B from EEPROM 669 * (plus 0x6C for Rhine-I/II) 670 */ 671 static void rhine_reload_eeprom(long pioaddr, struct net_device *dev) 672 { 673 struct rhine_private *rp = netdev_priv(dev); 674 void __iomem *ioaddr = rp->base; 675 int i; 676 677 outb(0x20, pioaddr + MACRegEEcsr); 678 for (i = 0; i < 1024; i++) { 679 if (!(inb(pioaddr + MACRegEEcsr) & 0x20)) 680 break; 681 } 682 if (i > 512) 683 pr_info("%4d cycles used @ %s:%d\n", i, __func__, __LINE__); 684 685 #ifdef USE_MMIO 686 /* 687 * Reloading from EEPROM overwrites ConfigA-D, so we must re-enable 688 * MMIO. If reloading EEPROM was done first this could be avoided, but 689 * it is not known if that still works with the "win98-reboot" problem. 690 */ 691 enable_mmio(pioaddr, rp->quirks); 692 #endif 693 694 /* Turn off EEPROM-controlled wake-up (magic packet) */ 695 if (rp->quirks & rqWOL) 696 iowrite8(ioread8(ioaddr + ConfigA) & 0xFC, ioaddr + ConfigA); 697 698 } 699 700 #ifdef CONFIG_NET_POLL_CONTROLLER 701 static void rhine_poll(struct net_device *dev) 702 { 703 struct rhine_private *rp = netdev_priv(dev); 704 const int irq = rp->pdev->irq; 705 706 disable_irq(irq); 707 rhine_interrupt(irq, dev); 708 enable_irq(irq); 709 } 710 #endif 711 712 static void rhine_kick_tx_threshold(struct rhine_private *rp) 713 { 714 if (rp->tx_thresh < 0xe0) { 715 void __iomem *ioaddr = rp->base; 716 717 rp->tx_thresh += 0x20; 718 BYTE_REG_BITS_SET(rp->tx_thresh, 0x80, ioaddr + TxConfig); 719 } 720 } 721 722 static void rhine_tx_err(struct rhine_private *rp, u32 status) 723 { 724 struct net_device *dev = rp->dev; 725 726 if (status & IntrTxAborted) { 727 netif_info(rp, tx_err, dev, 728 "Abort %08x, frame dropped\n", status); 729 } 730 731 if (status & IntrTxUnderrun) { 732 rhine_kick_tx_threshold(rp); 733 netif_info(rp, tx_err ,dev, "Transmitter underrun, " 734 "Tx threshold now %02x\n", rp->tx_thresh); 735 } 736 737 if (status & IntrTxDescRace) 738 netif_info(rp, tx_err, dev, "Tx descriptor write-back race\n"); 739 740 if ((status & IntrTxError) && 741 (status & (IntrTxAborted | IntrTxUnderrun | IntrTxDescRace)) == 0) { 742 rhine_kick_tx_threshold(rp); 743 netif_info(rp, tx_err, dev, "Unspecified error. " 744 "Tx threshold now %02x\n", rp->tx_thresh); 745 } 746 747 rhine_restart_tx(dev); 748 } 749 750 static void rhine_update_rx_crc_and_missed_errord(struct rhine_private *rp) 751 { 752 void __iomem *ioaddr = rp->base; 753 struct net_device_stats *stats = &rp->dev->stats; 754 755 stats->rx_crc_errors += ioread16(ioaddr + RxCRCErrs); 756 stats->rx_missed_errors += ioread16(ioaddr + RxMissed); 757 758 /* 759 * Clears the "tally counters" for CRC errors and missed frames(?). 760 * It has been reported that some chips need a write of 0 to clear 761 * these, for others the counters are set to 1 when written to and 762 * instead cleared when read. So we clear them both ways ... 763 */ 764 iowrite32(0, ioaddr + RxMissed); 765 ioread16(ioaddr + RxCRCErrs); 766 ioread16(ioaddr + RxMissed); 767 } 768 769 #define RHINE_EVENT_NAPI_RX (IntrRxDone | \ 770 IntrRxErr | \ 771 IntrRxEmpty | \ 772 IntrRxOverflow | \ 773 IntrRxDropped | \ 774 IntrRxNoBuf | \ 775 IntrRxWakeUp) 776 777 #define RHINE_EVENT_NAPI_TX_ERR (IntrTxError | \ 778 IntrTxAborted | \ 779 IntrTxUnderrun | \ 780 IntrTxDescRace) 781 #define RHINE_EVENT_NAPI_TX (IntrTxDone | RHINE_EVENT_NAPI_TX_ERR) 782 783 #define RHINE_EVENT_NAPI (RHINE_EVENT_NAPI_RX | \ 784 RHINE_EVENT_NAPI_TX | \ 785 IntrStatsMax) 786 #define RHINE_EVENT_SLOW (IntrPCIErr | IntrLinkChange) 787 #define RHINE_EVENT (RHINE_EVENT_NAPI | RHINE_EVENT_SLOW) 788 789 static int rhine_napipoll(struct napi_struct *napi, int budget) 790 { 791 struct rhine_private *rp = container_of(napi, struct rhine_private, napi); 792 struct net_device *dev = rp->dev; 793 void __iomem *ioaddr = rp->base; 794 u16 enable_mask = RHINE_EVENT & 0xffff; 795 int work_done = 0; 796 u32 status; 797 798 status = rhine_get_events(rp); 799 rhine_ack_events(rp, status & ~RHINE_EVENT_SLOW); 800 801 if (status & RHINE_EVENT_NAPI_RX) 802 work_done += rhine_rx(dev, budget); 803 804 if (status & RHINE_EVENT_NAPI_TX) { 805 if (status & RHINE_EVENT_NAPI_TX_ERR) { 806 /* Avoid scavenging before Tx engine turned off */ 807 rhine_wait_bit_low(rp, ChipCmd, CmdTxOn); 808 if (ioread8(ioaddr + ChipCmd) & CmdTxOn) 809 netif_warn(rp, tx_err, dev, "Tx still on\n"); 810 } 811 812 rhine_tx(dev); 813 814 if (status & RHINE_EVENT_NAPI_TX_ERR) 815 rhine_tx_err(rp, status); 816 } 817 818 if (status & IntrStatsMax) { 819 spin_lock(&rp->lock); 820 rhine_update_rx_crc_and_missed_errord(rp); 821 spin_unlock(&rp->lock); 822 } 823 824 if (status & RHINE_EVENT_SLOW) { 825 enable_mask &= ~RHINE_EVENT_SLOW; 826 schedule_work(&rp->slow_event_task); 827 } 828 829 if (work_done < budget) { 830 napi_complete(napi); 831 iowrite16(enable_mask, ioaddr + IntrEnable); 832 mmiowb(); 833 } 834 return work_done; 835 } 836 837 static void rhine_hw_init(struct net_device *dev, long pioaddr) 838 { 839 struct rhine_private *rp = netdev_priv(dev); 840 841 /* Reset the chip to erase previous misconfiguration. */ 842 rhine_chip_reset(dev); 843 844 /* Rhine-I needs extra time to recuperate before EEPROM reload */ 845 if (rp->quirks & rqRhineI) 846 msleep(5); 847 848 /* Reload EEPROM controlled bytes cleared by soft reset */ 849 rhine_reload_eeprom(pioaddr, dev); 850 } 851 852 static const struct net_device_ops rhine_netdev_ops = { 853 .ndo_open = rhine_open, 854 .ndo_stop = rhine_close, 855 .ndo_start_xmit = rhine_start_tx, 856 .ndo_get_stats64 = rhine_get_stats64, 857 .ndo_set_rx_mode = rhine_set_rx_mode, 858 .ndo_change_mtu = eth_change_mtu, 859 .ndo_validate_addr = eth_validate_addr, 860 .ndo_set_mac_address = eth_mac_addr, 861 .ndo_do_ioctl = netdev_ioctl, 862 .ndo_tx_timeout = rhine_tx_timeout, 863 .ndo_vlan_rx_add_vid = rhine_vlan_rx_add_vid, 864 .ndo_vlan_rx_kill_vid = rhine_vlan_rx_kill_vid, 865 #ifdef CONFIG_NET_POLL_CONTROLLER 866 .ndo_poll_controller = rhine_poll, 867 #endif 868 }; 869 870 static int rhine_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 871 { 872 struct net_device *dev; 873 struct rhine_private *rp; 874 int i, rc; 875 u32 quirks; 876 long pioaddr; 877 long memaddr; 878 void __iomem *ioaddr; 879 int io_size, phy_id; 880 const char *name; 881 #ifdef USE_MMIO 882 int bar = 1; 883 #else 884 int bar = 0; 885 #endif 886 887 /* when built into the kernel, we only print version if device is found */ 888 #ifndef MODULE 889 pr_info_once("%s\n", version); 890 #endif 891 892 io_size = 256; 893 phy_id = 0; 894 quirks = 0; 895 name = "Rhine"; 896 if (pdev->revision < VTunknown0) { 897 quirks = rqRhineI; 898 io_size = 128; 899 } 900 else if (pdev->revision >= VT6102) { 901 quirks = rqWOL | rqForceReset; 902 if (pdev->revision < VT6105) { 903 name = "Rhine II"; 904 quirks |= rqStatusWBRace; /* Rhine-II exclusive */ 905 } 906 else { 907 phy_id = 1; /* Integrated PHY, phy_id fixed to 1 */ 908 if (pdev->revision >= VT6105_B0) 909 quirks |= rq6patterns; 910 if (pdev->revision < VT6105M) 911 name = "Rhine III"; 912 else 913 name = "Rhine III (Management Adapter)"; 914 } 915 } 916 917 rc = pci_enable_device(pdev); 918 if (rc) 919 goto err_out; 920 921 /* this should always be supported */ 922 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 923 if (rc) { 924 dev_err(&pdev->dev, 925 "32-bit PCI DMA addresses not supported by the card!?\n"); 926 goto err_out; 927 } 928 929 /* sanity check */ 930 if ((pci_resource_len(pdev, 0) < io_size) || 931 (pci_resource_len(pdev, 1) < io_size)) { 932 rc = -EIO; 933 dev_err(&pdev->dev, "Insufficient PCI resources, aborting\n"); 934 goto err_out; 935 } 936 937 pioaddr = pci_resource_start(pdev, 0); 938 memaddr = pci_resource_start(pdev, 1); 939 940 pci_set_master(pdev); 941 942 dev = alloc_etherdev(sizeof(struct rhine_private)); 943 if (!dev) { 944 rc = -ENOMEM; 945 goto err_out; 946 } 947 SET_NETDEV_DEV(dev, &pdev->dev); 948 949 rp = netdev_priv(dev); 950 rp->dev = dev; 951 rp->quirks = quirks; 952 rp->pioaddr = pioaddr; 953 rp->pdev = pdev; 954 rp->msg_enable = netif_msg_init(debug, RHINE_MSG_DEFAULT); 955 956 rc = pci_request_regions(pdev, DRV_NAME); 957 if (rc) 958 goto err_out_free_netdev; 959 960 ioaddr = pci_iomap(pdev, bar, io_size); 961 if (!ioaddr) { 962 rc = -EIO; 963 dev_err(&pdev->dev, 964 "ioremap failed for device %s, region 0x%X @ 0x%lX\n", 965 pci_name(pdev), io_size, memaddr); 966 goto err_out_free_res; 967 } 968 969 #ifdef USE_MMIO 970 enable_mmio(pioaddr, quirks); 971 972 /* Check that selected MMIO registers match the PIO ones */ 973 i = 0; 974 while (mmio_verify_registers[i]) { 975 int reg = mmio_verify_registers[i++]; 976 unsigned char a = inb(pioaddr+reg); 977 unsigned char b = readb(ioaddr+reg); 978 if (a != b) { 979 rc = -EIO; 980 dev_err(&pdev->dev, 981 "MMIO do not match PIO [%02x] (%02x != %02x)\n", 982 reg, a, b); 983 goto err_out_unmap; 984 } 985 } 986 #endif /* USE_MMIO */ 987 988 rp->base = ioaddr; 989 990 u64_stats_init(&rp->tx_stats.syncp); 991 u64_stats_init(&rp->rx_stats.syncp); 992 993 /* Get chip registers into a sane state */ 994 rhine_power_init(dev); 995 rhine_hw_init(dev, pioaddr); 996 997 for (i = 0; i < 6; i++) 998 dev->dev_addr[i] = ioread8(ioaddr + StationAddr + i); 999 1000 if (!is_valid_ether_addr(dev->dev_addr)) { 1001 /* Report it and use a random ethernet address instead */ 1002 netdev_err(dev, "Invalid MAC address: %pM\n", dev->dev_addr); 1003 eth_hw_addr_random(dev); 1004 netdev_info(dev, "Using random MAC address: %pM\n", 1005 dev->dev_addr); 1006 } 1007 1008 /* For Rhine-I/II, phy_id is loaded from EEPROM */ 1009 if (!phy_id) 1010 phy_id = ioread8(ioaddr + 0x6C); 1011 1012 spin_lock_init(&rp->lock); 1013 mutex_init(&rp->task_lock); 1014 INIT_WORK(&rp->reset_task, rhine_reset_task); 1015 INIT_WORK(&rp->slow_event_task, rhine_slow_event_task); 1016 1017 rp->mii_if.dev = dev; 1018 rp->mii_if.mdio_read = mdio_read; 1019 rp->mii_if.mdio_write = mdio_write; 1020 rp->mii_if.phy_id_mask = 0x1f; 1021 rp->mii_if.reg_num_mask = 0x1f; 1022 1023 /* The chip-specific entries in the device structure. */ 1024 dev->netdev_ops = &rhine_netdev_ops; 1025 dev->ethtool_ops = &netdev_ethtool_ops, 1026 dev->watchdog_timeo = TX_TIMEOUT; 1027 1028 netif_napi_add(dev, &rp->napi, rhine_napipoll, 64); 1029 1030 if (rp->quirks & rqRhineI) 1031 dev->features |= NETIF_F_SG|NETIF_F_HW_CSUM; 1032 1033 if (pdev->revision >= VT6105M) 1034 dev->features |= NETIF_F_HW_VLAN_CTAG_TX | 1035 NETIF_F_HW_VLAN_CTAG_RX | 1036 NETIF_F_HW_VLAN_CTAG_FILTER; 1037 1038 /* dev->name not defined before register_netdev()! */ 1039 rc = register_netdev(dev); 1040 if (rc) 1041 goto err_out_unmap; 1042 1043 netdev_info(dev, "VIA %s at 0x%lx, %pM, IRQ %d\n", 1044 name, 1045 #ifdef USE_MMIO 1046 memaddr, 1047 #else 1048 (long)ioaddr, 1049 #endif 1050 dev->dev_addr, pdev->irq); 1051 1052 pci_set_drvdata(pdev, dev); 1053 1054 { 1055 u16 mii_cmd; 1056 int mii_status = mdio_read(dev, phy_id, 1); 1057 mii_cmd = mdio_read(dev, phy_id, MII_BMCR) & ~BMCR_ISOLATE; 1058 mdio_write(dev, phy_id, MII_BMCR, mii_cmd); 1059 if (mii_status != 0xffff && mii_status != 0x0000) { 1060 rp->mii_if.advertising = mdio_read(dev, phy_id, 4); 1061 netdev_info(dev, 1062 "MII PHY found at address %d, status 0x%04x advertising %04x Link %04x\n", 1063 phy_id, 1064 mii_status, rp->mii_if.advertising, 1065 mdio_read(dev, phy_id, 5)); 1066 1067 /* set IFF_RUNNING */ 1068 if (mii_status & BMSR_LSTATUS) 1069 netif_carrier_on(dev); 1070 else 1071 netif_carrier_off(dev); 1072 1073 } 1074 } 1075 rp->mii_if.phy_id = phy_id; 1076 if (avoid_D3) 1077 netif_info(rp, probe, dev, "No D3 power state at shutdown\n"); 1078 1079 return 0; 1080 1081 err_out_unmap: 1082 pci_iounmap(pdev, ioaddr); 1083 err_out_free_res: 1084 pci_release_regions(pdev); 1085 err_out_free_netdev: 1086 free_netdev(dev); 1087 err_out: 1088 return rc; 1089 } 1090 1091 static int alloc_ring(struct net_device* dev) 1092 { 1093 struct rhine_private *rp = netdev_priv(dev); 1094 void *ring; 1095 dma_addr_t ring_dma; 1096 1097 ring = pci_alloc_consistent(rp->pdev, 1098 RX_RING_SIZE * sizeof(struct rx_desc) + 1099 TX_RING_SIZE * sizeof(struct tx_desc), 1100 &ring_dma); 1101 if (!ring) { 1102 netdev_err(dev, "Could not allocate DMA memory\n"); 1103 return -ENOMEM; 1104 } 1105 if (rp->quirks & rqRhineI) { 1106 rp->tx_bufs = pci_alloc_consistent(rp->pdev, 1107 PKT_BUF_SZ * TX_RING_SIZE, 1108 &rp->tx_bufs_dma); 1109 if (rp->tx_bufs == NULL) { 1110 pci_free_consistent(rp->pdev, 1111 RX_RING_SIZE * sizeof(struct rx_desc) + 1112 TX_RING_SIZE * sizeof(struct tx_desc), 1113 ring, ring_dma); 1114 return -ENOMEM; 1115 } 1116 } 1117 1118 rp->rx_ring = ring; 1119 rp->tx_ring = ring + RX_RING_SIZE * sizeof(struct rx_desc); 1120 rp->rx_ring_dma = ring_dma; 1121 rp->tx_ring_dma = ring_dma + RX_RING_SIZE * sizeof(struct rx_desc); 1122 1123 return 0; 1124 } 1125 1126 static void free_ring(struct net_device* dev) 1127 { 1128 struct rhine_private *rp = netdev_priv(dev); 1129 1130 pci_free_consistent(rp->pdev, 1131 RX_RING_SIZE * sizeof(struct rx_desc) + 1132 TX_RING_SIZE * sizeof(struct tx_desc), 1133 rp->rx_ring, rp->rx_ring_dma); 1134 rp->tx_ring = NULL; 1135 1136 if (rp->tx_bufs) 1137 pci_free_consistent(rp->pdev, PKT_BUF_SZ * TX_RING_SIZE, 1138 rp->tx_bufs, rp->tx_bufs_dma); 1139 1140 rp->tx_bufs = NULL; 1141 1142 } 1143 1144 static void alloc_rbufs(struct net_device *dev) 1145 { 1146 struct rhine_private *rp = netdev_priv(dev); 1147 dma_addr_t next; 1148 int i; 1149 1150 rp->dirty_rx = rp->cur_rx = 0; 1151 1152 rp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32); 1153 rp->rx_head_desc = &rp->rx_ring[0]; 1154 next = rp->rx_ring_dma; 1155 1156 /* Init the ring entries */ 1157 for (i = 0; i < RX_RING_SIZE; i++) { 1158 rp->rx_ring[i].rx_status = 0; 1159 rp->rx_ring[i].desc_length = cpu_to_le32(rp->rx_buf_sz); 1160 next += sizeof(struct rx_desc); 1161 rp->rx_ring[i].next_desc = cpu_to_le32(next); 1162 rp->rx_skbuff[i] = NULL; 1163 } 1164 /* Mark the last entry as wrapping the ring. */ 1165 rp->rx_ring[i-1].next_desc = cpu_to_le32(rp->rx_ring_dma); 1166 1167 /* Fill in the Rx buffers. Handle allocation failure gracefully. */ 1168 for (i = 0; i < RX_RING_SIZE; i++) { 1169 struct sk_buff *skb = netdev_alloc_skb(dev, rp->rx_buf_sz); 1170 rp->rx_skbuff[i] = skb; 1171 if (skb == NULL) 1172 break; 1173 1174 rp->rx_skbuff_dma[i] = 1175 pci_map_single(rp->pdev, skb->data, rp->rx_buf_sz, 1176 PCI_DMA_FROMDEVICE); 1177 if (dma_mapping_error(&rp->pdev->dev, rp->rx_skbuff_dma[i])) { 1178 rp->rx_skbuff_dma[i] = 0; 1179 dev_kfree_skb(skb); 1180 break; 1181 } 1182 rp->rx_ring[i].addr = cpu_to_le32(rp->rx_skbuff_dma[i]); 1183 rp->rx_ring[i].rx_status = cpu_to_le32(DescOwn); 1184 } 1185 rp->dirty_rx = (unsigned int)(i - RX_RING_SIZE); 1186 } 1187 1188 static void free_rbufs(struct net_device* dev) 1189 { 1190 struct rhine_private *rp = netdev_priv(dev); 1191 int i; 1192 1193 /* Free all the skbuffs in the Rx queue. */ 1194 for (i = 0; i < RX_RING_SIZE; i++) { 1195 rp->rx_ring[i].rx_status = 0; 1196 rp->rx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */ 1197 if (rp->rx_skbuff[i]) { 1198 pci_unmap_single(rp->pdev, 1199 rp->rx_skbuff_dma[i], 1200 rp->rx_buf_sz, PCI_DMA_FROMDEVICE); 1201 dev_kfree_skb(rp->rx_skbuff[i]); 1202 } 1203 rp->rx_skbuff[i] = NULL; 1204 } 1205 } 1206 1207 static void alloc_tbufs(struct net_device* dev) 1208 { 1209 struct rhine_private *rp = netdev_priv(dev); 1210 dma_addr_t next; 1211 int i; 1212 1213 rp->dirty_tx = rp->cur_tx = 0; 1214 next = rp->tx_ring_dma; 1215 for (i = 0; i < TX_RING_SIZE; i++) { 1216 rp->tx_skbuff[i] = NULL; 1217 rp->tx_ring[i].tx_status = 0; 1218 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC); 1219 next += sizeof(struct tx_desc); 1220 rp->tx_ring[i].next_desc = cpu_to_le32(next); 1221 if (rp->quirks & rqRhineI) 1222 rp->tx_buf[i] = &rp->tx_bufs[i * PKT_BUF_SZ]; 1223 } 1224 rp->tx_ring[i-1].next_desc = cpu_to_le32(rp->tx_ring_dma); 1225 1226 } 1227 1228 static void free_tbufs(struct net_device* dev) 1229 { 1230 struct rhine_private *rp = netdev_priv(dev); 1231 int i; 1232 1233 for (i = 0; i < TX_RING_SIZE; i++) { 1234 rp->tx_ring[i].tx_status = 0; 1235 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC); 1236 rp->tx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */ 1237 if (rp->tx_skbuff[i]) { 1238 if (rp->tx_skbuff_dma[i]) { 1239 pci_unmap_single(rp->pdev, 1240 rp->tx_skbuff_dma[i], 1241 rp->tx_skbuff[i]->len, 1242 PCI_DMA_TODEVICE); 1243 } 1244 dev_kfree_skb(rp->tx_skbuff[i]); 1245 } 1246 rp->tx_skbuff[i] = NULL; 1247 rp->tx_buf[i] = NULL; 1248 } 1249 } 1250 1251 static void rhine_check_media(struct net_device *dev, unsigned int init_media) 1252 { 1253 struct rhine_private *rp = netdev_priv(dev); 1254 void __iomem *ioaddr = rp->base; 1255 1256 mii_check_media(&rp->mii_if, netif_msg_link(rp), init_media); 1257 1258 if (rp->mii_if.full_duplex) 1259 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1FDuplex, 1260 ioaddr + ChipCmd1); 1261 else 1262 iowrite8(ioread8(ioaddr + ChipCmd1) & ~Cmd1FDuplex, 1263 ioaddr + ChipCmd1); 1264 1265 netif_info(rp, link, dev, "force_media %d, carrier %d\n", 1266 rp->mii_if.force_media, netif_carrier_ok(dev)); 1267 } 1268 1269 /* Called after status of force_media possibly changed */ 1270 static void rhine_set_carrier(struct mii_if_info *mii) 1271 { 1272 struct net_device *dev = mii->dev; 1273 struct rhine_private *rp = netdev_priv(dev); 1274 1275 if (mii->force_media) { 1276 /* autoneg is off: Link is always assumed to be up */ 1277 if (!netif_carrier_ok(dev)) 1278 netif_carrier_on(dev); 1279 } else /* Let MMI library update carrier status */ 1280 rhine_check_media(dev, 0); 1281 1282 netif_info(rp, link, dev, "force_media %d, carrier %d\n", 1283 mii->force_media, netif_carrier_ok(dev)); 1284 } 1285 1286 /** 1287 * rhine_set_cam - set CAM multicast filters 1288 * @ioaddr: register block of this Rhine 1289 * @idx: multicast CAM index [0..MCAM_SIZE-1] 1290 * @addr: multicast address (6 bytes) 1291 * 1292 * Load addresses into multicast filters. 1293 */ 1294 static void rhine_set_cam(void __iomem *ioaddr, int idx, u8 *addr) 1295 { 1296 int i; 1297 1298 iowrite8(CAMC_CAMEN, ioaddr + CamCon); 1299 wmb(); 1300 1301 /* Paranoid -- idx out of range should never happen */ 1302 idx &= (MCAM_SIZE - 1); 1303 1304 iowrite8((u8) idx, ioaddr + CamAddr); 1305 1306 for (i = 0; i < 6; i++, addr++) 1307 iowrite8(*addr, ioaddr + MulticastFilter0 + i); 1308 udelay(10); 1309 wmb(); 1310 1311 iowrite8(CAMC_CAMWR | CAMC_CAMEN, ioaddr + CamCon); 1312 udelay(10); 1313 1314 iowrite8(0, ioaddr + CamCon); 1315 } 1316 1317 /** 1318 * rhine_set_vlan_cam - set CAM VLAN filters 1319 * @ioaddr: register block of this Rhine 1320 * @idx: VLAN CAM index [0..VCAM_SIZE-1] 1321 * @addr: VLAN ID (2 bytes) 1322 * 1323 * Load addresses into VLAN filters. 1324 */ 1325 static void rhine_set_vlan_cam(void __iomem *ioaddr, int idx, u8 *addr) 1326 { 1327 iowrite8(CAMC_CAMEN | CAMC_VCAMSL, ioaddr + CamCon); 1328 wmb(); 1329 1330 /* Paranoid -- idx out of range should never happen */ 1331 idx &= (VCAM_SIZE - 1); 1332 1333 iowrite8((u8) idx, ioaddr + CamAddr); 1334 1335 iowrite16(*((u16 *) addr), ioaddr + MulticastFilter0 + 6); 1336 udelay(10); 1337 wmb(); 1338 1339 iowrite8(CAMC_CAMWR | CAMC_CAMEN, ioaddr + CamCon); 1340 udelay(10); 1341 1342 iowrite8(0, ioaddr + CamCon); 1343 } 1344 1345 /** 1346 * rhine_set_cam_mask - set multicast CAM mask 1347 * @ioaddr: register block of this Rhine 1348 * @mask: multicast CAM mask 1349 * 1350 * Mask sets multicast filters active/inactive. 1351 */ 1352 static void rhine_set_cam_mask(void __iomem *ioaddr, u32 mask) 1353 { 1354 iowrite8(CAMC_CAMEN, ioaddr + CamCon); 1355 wmb(); 1356 1357 /* write mask */ 1358 iowrite32(mask, ioaddr + CamMask); 1359 1360 /* disable CAMEN */ 1361 iowrite8(0, ioaddr + CamCon); 1362 } 1363 1364 /** 1365 * rhine_set_vlan_cam_mask - set VLAN CAM mask 1366 * @ioaddr: register block of this Rhine 1367 * @mask: VLAN CAM mask 1368 * 1369 * Mask sets VLAN filters active/inactive. 1370 */ 1371 static void rhine_set_vlan_cam_mask(void __iomem *ioaddr, u32 mask) 1372 { 1373 iowrite8(CAMC_CAMEN | CAMC_VCAMSL, ioaddr + CamCon); 1374 wmb(); 1375 1376 /* write mask */ 1377 iowrite32(mask, ioaddr + CamMask); 1378 1379 /* disable CAMEN */ 1380 iowrite8(0, ioaddr + CamCon); 1381 } 1382 1383 /** 1384 * rhine_init_cam_filter - initialize CAM filters 1385 * @dev: network device 1386 * 1387 * Initialize (disable) hardware VLAN and multicast support on this 1388 * Rhine. 1389 */ 1390 static void rhine_init_cam_filter(struct net_device *dev) 1391 { 1392 struct rhine_private *rp = netdev_priv(dev); 1393 void __iomem *ioaddr = rp->base; 1394 1395 /* Disable all CAMs */ 1396 rhine_set_vlan_cam_mask(ioaddr, 0); 1397 rhine_set_cam_mask(ioaddr, 0); 1398 1399 /* disable hardware VLAN support */ 1400 BYTE_REG_BITS_ON(TCR_PQEN, ioaddr + TxConfig); 1401 BYTE_REG_BITS_OFF(BCR1_VIDFR, ioaddr + PCIBusConfig1); 1402 } 1403 1404 /** 1405 * rhine_update_vcam - update VLAN CAM filters 1406 * @rp: rhine_private data of this Rhine 1407 * 1408 * Update VLAN CAM filters to match configuration change. 1409 */ 1410 static void rhine_update_vcam(struct net_device *dev) 1411 { 1412 struct rhine_private *rp = netdev_priv(dev); 1413 void __iomem *ioaddr = rp->base; 1414 u16 vid; 1415 u32 vCAMmask = 0; /* 32 vCAMs (6105M and better) */ 1416 unsigned int i = 0; 1417 1418 for_each_set_bit(vid, rp->active_vlans, VLAN_N_VID) { 1419 rhine_set_vlan_cam(ioaddr, i, (u8 *)&vid); 1420 vCAMmask |= 1 << i; 1421 if (++i >= VCAM_SIZE) 1422 break; 1423 } 1424 rhine_set_vlan_cam_mask(ioaddr, vCAMmask); 1425 } 1426 1427 static int rhine_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid) 1428 { 1429 struct rhine_private *rp = netdev_priv(dev); 1430 1431 spin_lock_bh(&rp->lock); 1432 set_bit(vid, rp->active_vlans); 1433 rhine_update_vcam(dev); 1434 spin_unlock_bh(&rp->lock); 1435 return 0; 1436 } 1437 1438 static int rhine_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, u16 vid) 1439 { 1440 struct rhine_private *rp = netdev_priv(dev); 1441 1442 spin_lock_bh(&rp->lock); 1443 clear_bit(vid, rp->active_vlans); 1444 rhine_update_vcam(dev); 1445 spin_unlock_bh(&rp->lock); 1446 return 0; 1447 } 1448 1449 static void init_registers(struct net_device *dev) 1450 { 1451 struct rhine_private *rp = netdev_priv(dev); 1452 void __iomem *ioaddr = rp->base; 1453 int i; 1454 1455 for (i = 0; i < 6; i++) 1456 iowrite8(dev->dev_addr[i], ioaddr + StationAddr + i); 1457 1458 /* Initialize other registers. */ 1459 iowrite16(0x0006, ioaddr + PCIBusConfig); /* Tune configuration??? */ 1460 /* Configure initial FIFO thresholds. */ 1461 iowrite8(0x20, ioaddr + TxConfig); 1462 rp->tx_thresh = 0x20; 1463 rp->rx_thresh = 0x60; /* Written in rhine_set_rx_mode(). */ 1464 1465 iowrite32(rp->rx_ring_dma, ioaddr + RxRingPtr); 1466 iowrite32(rp->tx_ring_dma, ioaddr + TxRingPtr); 1467 1468 rhine_set_rx_mode(dev); 1469 1470 if (rp->pdev->revision >= VT6105M) 1471 rhine_init_cam_filter(dev); 1472 1473 napi_enable(&rp->napi); 1474 1475 iowrite16(RHINE_EVENT & 0xffff, ioaddr + IntrEnable); 1476 1477 iowrite16(CmdStart | CmdTxOn | CmdRxOn | (Cmd1NoTxPoll << 8), 1478 ioaddr + ChipCmd); 1479 rhine_check_media(dev, 1); 1480 } 1481 1482 /* Enable MII link status auto-polling (required for IntrLinkChange) */ 1483 static void rhine_enable_linkmon(struct rhine_private *rp) 1484 { 1485 void __iomem *ioaddr = rp->base; 1486 1487 iowrite8(0, ioaddr + MIICmd); 1488 iowrite8(MII_BMSR, ioaddr + MIIRegAddr); 1489 iowrite8(0x80, ioaddr + MIICmd); 1490 1491 rhine_wait_bit_high(rp, MIIRegAddr, 0x20); 1492 1493 iowrite8(MII_BMSR | 0x40, ioaddr + MIIRegAddr); 1494 } 1495 1496 /* Disable MII link status auto-polling (required for MDIO access) */ 1497 static void rhine_disable_linkmon(struct rhine_private *rp) 1498 { 1499 void __iomem *ioaddr = rp->base; 1500 1501 iowrite8(0, ioaddr + MIICmd); 1502 1503 if (rp->quirks & rqRhineI) { 1504 iowrite8(0x01, ioaddr + MIIRegAddr); // MII_BMSR 1505 1506 /* Can be called from ISR. Evil. */ 1507 mdelay(1); 1508 1509 /* 0x80 must be set immediately before turning it off */ 1510 iowrite8(0x80, ioaddr + MIICmd); 1511 1512 rhine_wait_bit_high(rp, MIIRegAddr, 0x20); 1513 1514 /* Heh. Now clear 0x80 again. */ 1515 iowrite8(0, ioaddr + MIICmd); 1516 } 1517 else 1518 rhine_wait_bit_high(rp, MIIRegAddr, 0x80); 1519 } 1520 1521 /* Read and write over the MII Management Data I/O (MDIO) interface. */ 1522 1523 static int mdio_read(struct net_device *dev, int phy_id, int regnum) 1524 { 1525 struct rhine_private *rp = netdev_priv(dev); 1526 void __iomem *ioaddr = rp->base; 1527 int result; 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 iowrite8(0x40, ioaddr + MIICmd); /* Trigger read */ 1535 rhine_wait_bit_low(rp, MIICmd, 0x40); 1536 result = ioread16(ioaddr + MIIData); 1537 1538 rhine_enable_linkmon(rp); 1539 return result; 1540 } 1541 1542 static void mdio_write(struct net_device *dev, int phy_id, int regnum, int value) 1543 { 1544 struct rhine_private *rp = netdev_priv(dev); 1545 void __iomem *ioaddr = rp->base; 1546 1547 rhine_disable_linkmon(rp); 1548 1549 /* rhine_disable_linkmon already cleared MIICmd */ 1550 iowrite8(phy_id, ioaddr + MIIPhyAddr); 1551 iowrite8(regnum, ioaddr + MIIRegAddr); 1552 iowrite16(value, ioaddr + MIIData); 1553 iowrite8(0x20, ioaddr + MIICmd); /* Trigger write */ 1554 rhine_wait_bit_low(rp, MIICmd, 0x20); 1555 1556 rhine_enable_linkmon(rp); 1557 } 1558 1559 static void rhine_task_disable(struct rhine_private *rp) 1560 { 1561 mutex_lock(&rp->task_lock); 1562 rp->task_enable = false; 1563 mutex_unlock(&rp->task_lock); 1564 1565 cancel_work_sync(&rp->slow_event_task); 1566 cancel_work_sync(&rp->reset_task); 1567 } 1568 1569 static void rhine_task_enable(struct rhine_private *rp) 1570 { 1571 mutex_lock(&rp->task_lock); 1572 rp->task_enable = true; 1573 mutex_unlock(&rp->task_lock); 1574 } 1575 1576 static int rhine_open(struct net_device *dev) 1577 { 1578 struct rhine_private *rp = netdev_priv(dev); 1579 void __iomem *ioaddr = rp->base; 1580 int rc; 1581 1582 rc = request_irq(rp->pdev->irq, rhine_interrupt, IRQF_SHARED, dev->name, 1583 dev); 1584 if (rc) 1585 return rc; 1586 1587 netif_dbg(rp, ifup, dev, "%s() irq %d\n", __func__, rp->pdev->irq); 1588 1589 rc = alloc_ring(dev); 1590 if (rc) { 1591 free_irq(rp->pdev->irq, dev); 1592 return rc; 1593 } 1594 alloc_rbufs(dev); 1595 alloc_tbufs(dev); 1596 rhine_chip_reset(dev); 1597 rhine_task_enable(rp); 1598 init_registers(dev); 1599 1600 netif_dbg(rp, ifup, dev, "%s() Done - status %04x MII status: %04x\n", 1601 __func__, ioread16(ioaddr + ChipCmd), 1602 mdio_read(dev, rp->mii_if.phy_id, MII_BMSR)); 1603 1604 netif_start_queue(dev); 1605 1606 return 0; 1607 } 1608 1609 static void rhine_reset_task(struct work_struct *work) 1610 { 1611 struct rhine_private *rp = container_of(work, struct rhine_private, 1612 reset_task); 1613 struct net_device *dev = rp->dev; 1614 1615 mutex_lock(&rp->task_lock); 1616 1617 if (!rp->task_enable) 1618 goto out_unlock; 1619 1620 napi_disable(&rp->napi); 1621 netif_tx_disable(dev); 1622 spin_lock_bh(&rp->lock); 1623 1624 /* clear all descriptors */ 1625 free_tbufs(dev); 1626 free_rbufs(dev); 1627 alloc_tbufs(dev); 1628 alloc_rbufs(dev); 1629 1630 /* Reinitialize the hardware. */ 1631 rhine_chip_reset(dev); 1632 init_registers(dev); 1633 1634 spin_unlock_bh(&rp->lock); 1635 1636 dev->trans_start = jiffies; /* prevent tx timeout */ 1637 dev->stats.tx_errors++; 1638 netif_wake_queue(dev); 1639 1640 out_unlock: 1641 mutex_unlock(&rp->task_lock); 1642 } 1643 1644 static void rhine_tx_timeout(struct net_device *dev) 1645 { 1646 struct rhine_private *rp = netdev_priv(dev); 1647 void __iomem *ioaddr = rp->base; 1648 1649 netdev_warn(dev, "Transmit timed out, status %04x, PHY status %04x, resetting...\n", 1650 ioread16(ioaddr + IntrStatus), 1651 mdio_read(dev, rp->mii_if.phy_id, MII_BMSR)); 1652 1653 schedule_work(&rp->reset_task); 1654 } 1655 1656 static netdev_tx_t rhine_start_tx(struct sk_buff *skb, 1657 struct net_device *dev) 1658 { 1659 struct rhine_private *rp = netdev_priv(dev); 1660 void __iomem *ioaddr = rp->base; 1661 unsigned entry; 1662 1663 /* Caution: the write order is important here, set the field 1664 with the "ownership" bits last. */ 1665 1666 /* Calculate the next Tx descriptor entry. */ 1667 entry = rp->cur_tx % TX_RING_SIZE; 1668 1669 if (skb_padto(skb, ETH_ZLEN)) 1670 return NETDEV_TX_OK; 1671 1672 rp->tx_skbuff[entry] = skb; 1673 1674 if ((rp->quirks & rqRhineI) && 1675 (((unsigned long)skb->data & 3) || skb_shinfo(skb)->nr_frags != 0 || skb->ip_summed == CHECKSUM_PARTIAL)) { 1676 /* Must use alignment buffer. */ 1677 if (skb->len > PKT_BUF_SZ) { 1678 /* packet too long, drop it */ 1679 dev_kfree_skb(skb); 1680 rp->tx_skbuff[entry] = NULL; 1681 dev->stats.tx_dropped++; 1682 return NETDEV_TX_OK; 1683 } 1684 1685 /* Padding is not copied and so must be redone. */ 1686 skb_copy_and_csum_dev(skb, rp->tx_buf[entry]); 1687 if (skb->len < ETH_ZLEN) 1688 memset(rp->tx_buf[entry] + skb->len, 0, 1689 ETH_ZLEN - skb->len); 1690 rp->tx_skbuff_dma[entry] = 0; 1691 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_bufs_dma + 1692 (rp->tx_buf[entry] - 1693 rp->tx_bufs)); 1694 } else { 1695 rp->tx_skbuff_dma[entry] = 1696 pci_map_single(rp->pdev, skb->data, skb->len, 1697 PCI_DMA_TODEVICE); 1698 if (dma_mapping_error(&rp->pdev->dev, rp->tx_skbuff_dma[entry])) { 1699 dev_kfree_skb(skb); 1700 rp->tx_skbuff_dma[entry] = 0; 1701 dev->stats.tx_dropped++; 1702 return NETDEV_TX_OK; 1703 } 1704 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_skbuff_dma[entry]); 1705 } 1706 1707 rp->tx_ring[entry].desc_length = 1708 cpu_to_le32(TXDESC | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN)); 1709 1710 if (unlikely(vlan_tx_tag_present(skb))) { 1711 u16 vid_pcp = vlan_tx_tag_get(skb); 1712 1713 /* drop CFI/DEI bit, register needs VID and PCP */ 1714 vid_pcp = (vid_pcp & VLAN_VID_MASK) | 1715 ((vid_pcp & VLAN_PRIO_MASK) >> 1); 1716 rp->tx_ring[entry].tx_status = cpu_to_le32((vid_pcp) << 16); 1717 /* request tagging */ 1718 rp->tx_ring[entry].desc_length |= cpu_to_le32(0x020000); 1719 } 1720 else 1721 rp->tx_ring[entry].tx_status = 0; 1722 1723 /* lock eth irq */ 1724 wmb(); 1725 rp->tx_ring[entry].tx_status |= cpu_to_le32(DescOwn); 1726 wmb(); 1727 1728 rp->cur_tx++; 1729 1730 /* Non-x86 Todo: explicitly flush cache lines here. */ 1731 1732 if (vlan_tx_tag_present(skb)) 1733 /* Tx queues are bits 7-0 (first Tx queue: bit 7) */ 1734 BYTE_REG_BITS_ON(1 << 7, ioaddr + TQWake); 1735 1736 /* Wake the potentially-idle transmit channel */ 1737 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand, 1738 ioaddr + ChipCmd1); 1739 IOSYNC; 1740 1741 if (rp->cur_tx == rp->dirty_tx + TX_QUEUE_LEN) 1742 netif_stop_queue(dev); 1743 1744 netif_dbg(rp, tx_queued, dev, "Transmit frame #%d queued in slot %d\n", 1745 rp->cur_tx - 1, entry); 1746 1747 return NETDEV_TX_OK; 1748 } 1749 1750 static void rhine_irq_disable(struct rhine_private *rp) 1751 { 1752 iowrite16(0x0000, rp->base + IntrEnable); 1753 mmiowb(); 1754 } 1755 1756 /* The interrupt handler does all of the Rx thread work and cleans up 1757 after the Tx thread. */ 1758 static irqreturn_t rhine_interrupt(int irq, void *dev_instance) 1759 { 1760 struct net_device *dev = dev_instance; 1761 struct rhine_private *rp = netdev_priv(dev); 1762 u32 status; 1763 int handled = 0; 1764 1765 status = rhine_get_events(rp); 1766 1767 netif_dbg(rp, intr, dev, "Interrupt, status %08x\n", status); 1768 1769 if (status & RHINE_EVENT) { 1770 handled = 1; 1771 1772 rhine_irq_disable(rp); 1773 napi_schedule(&rp->napi); 1774 } 1775 1776 if (status & ~(IntrLinkChange | IntrStatsMax | RHINE_EVENT_NAPI)) { 1777 netif_err(rp, intr, dev, "Something Wicked happened! %08x\n", 1778 status); 1779 } 1780 1781 return IRQ_RETVAL(handled); 1782 } 1783 1784 /* This routine is logically part of the interrupt handler, but isolated 1785 for clarity. */ 1786 static void rhine_tx(struct net_device *dev) 1787 { 1788 struct rhine_private *rp = netdev_priv(dev); 1789 int txstatus = 0, entry = rp->dirty_tx % TX_RING_SIZE; 1790 1791 /* find and cleanup dirty tx descriptors */ 1792 while (rp->dirty_tx != rp->cur_tx) { 1793 txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status); 1794 netif_dbg(rp, tx_done, dev, "Tx scavenge %d status %08x\n", 1795 entry, txstatus); 1796 if (txstatus & DescOwn) 1797 break; 1798 if (txstatus & 0x8000) { 1799 netif_dbg(rp, tx_done, dev, 1800 "Transmit error, Tx status %08x\n", txstatus); 1801 dev->stats.tx_errors++; 1802 if (txstatus & 0x0400) 1803 dev->stats.tx_carrier_errors++; 1804 if (txstatus & 0x0200) 1805 dev->stats.tx_window_errors++; 1806 if (txstatus & 0x0100) 1807 dev->stats.tx_aborted_errors++; 1808 if (txstatus & 0x0080) 1809 dev->stats.tx_heartbeat_errors++; 1810 if (((rp->quirks & rqRhineI) && txstatus & 0x0002) || 1811 (txstatus & 0x0800) || (txstatus & 0x1000)) { 1812 dev->stats.tx_fifo_errors++; 1813 rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn); 1814 break; /* Keep the skb - we try again */ 1815 } 1816 /* Transmitter restarted in 'abnormal' handler. */ 1817 } else { 1818 if (rp->quirks & rqRhineI) 1819 dev->stats.collisions += (txstatus >> 3) & 0x0F; 1820 else 1821 dev->stats.collisions += txstatus & 0x0F; 1822 netif_dbg(rp, tx_done, dev, "collisions: %1.1x:%1.1x\n", 1823 (txstatus >> 3) & 0xF, txstatus & 0xF); 1824 1825 u64_stats_update_begin(&rp->tx_stats.syncp); 1826 rp->tx_stats.bytes += rp->tx_skbuff[entry]->len; 1827 rp->tx_stats.packets++; 1828 u64_stats_update_end(&rp->tx_stats.syncp); 1829 } 1830 /* Free the original skb. */ 1831 if (rp->tx_skbuff_dma[entry]) { 1832 pci_unmap_single(rp->pdev, 1833 rp->tx_skbuff_dma[entry], 1834 rp->tx_skbuff[entry]->len, 1835 PCI_DMA_TODEVICE); 1836 } 1837 dev_kfree_skb(rp->tx_skbuff[entry]); 1838 rp->tx_skbuff[entry] = NULL; 1839 entry = (++rp->dirty_tx) % TX_RING_SIZE; 1840 } 1841 if ((rp->cur_tx - rp->dirty_tx) < TX_QUEUE_LEN - 4) 1842 netif_wake_queue(dev); 1843 } 1844 1845 /** 1846 * rhine_get_vlan_tci - extract TCI from Rx data buffer 1847 * @skb: pointer to sk_buff 1848 * @data_size: used data area of the buffer including CRC 1849 * 1850 * If hardware VLAN tag extraction is enabled and the chip indicates a 802.1Q 1851 * packet, the extracted 802.1Q header (2 bytes TPID + 2 bytes TCI) is 4-byte 1852 * aligned following the CRC. 1853 */ 1854 static inline u16 rhine_get_vlan_tci(struct sk_buff *skb, int data_size) 1855 { 1856 u8 *trailer = (u8 *)skb->data + ((data_size + 3) & ~3) + 2; 1857 return be16_to_cpup((__be16 *)trailer); 1858 } 1859 1860 /* Process up to limit frames from receive ring */ 1861 static int rhine_rx(struct net_device *dev, int limit) 1862 { 1863 struct rhine_private *rp = netdev_priv(dev); 1864 int count; 1865 int entry = rp->cur_rx % RX_RING_SIZE; 1866 1867 netif_dbg(rp, rx_status, dev, "%s(), entry %d status %08x\n", __func__, 1868 entry, le32_to_cpu(rp->rx_head_desc->rx_status)); 1869 1870 /* If EOP is set on the next entry, it's a new packet. Send it up. */ 1871 for (count = 0; count < limit; ++count) { 1872 struct rx_desc *desc = rp->rx_head_desc; 1873 u32 desc_status = le32_to_cpu(desc->rx_status); 1874 u32 desc_length = le32_to_cpu(desc->desc_length); 1875 int data_size = desc_status >> 16; 1876 1877 if (desc_status & DescOwn) 1878 break; 1879 1880 netif_dbg(rp, rx_status, dev, "%s() status %08x\n", __func__, 1881 desc_status); 1882 1883 if ((desc_status & (RxWholePkt | RxErr)) != RxWholePkt) { 1884 if ((desc_status & RxWholePkt) != RxWholePkt) { 1885 netdev_warn(dev, 1886 "Oversized Ethernet frame spanned multiple buffers, " 1887 "entry %#x length %d status %08x!\n", 1888 entry, data_size, 1889 desc_status); 1890 netdev_warn(dev, 1891 "Oversized Ethernet frame %p vs %p\n", 1892 rp->rx_head_desc, 1893 &rp->rx_ring[entry]); 1894 dev->stats.rx_length_errors++; 1895 } else if (desc_status & RxErr) { 1896 /* There was a error. */ 1897 netif_dbg(rp, rx_err, dev, 1898 "%s() Rx error %08x\n", __func__, 1899 desc_status); 1900 dev->stats.rx_errors++; 1901 if (desc_status & 0x0030) 1902 dev->stats.rx_length_errors++; 1903 if (desc_status & 0x0048) 1904 dev->stats.rx_fifo_errors++; 1905 if (desc_status & 0x0004) 1906 dev->stats.rx_frame_errors++; 1907 if (desc_status & 0x0002) { 1908 /* this can also be updated outside the interrupt handler */ 1909 spin_lock(&rp->lock); 1910 dev->stats.rx_crc_errors++; 1911 spin_unlock(&rp->lock); 1912 } 1913 } 1914 } else { 1915 struct sk_buff *skb = NULL; 1916 /* Length should omit the CRC */ 1917 int pkt_len = data_size - 4; 1918 u16 vlan_tci = 0; 1919 1920 /* Check if the packet is long enough to accept without 1921 copying to a minimally-sized skbuff. */ 1922 if (pkt_len < rx_copybreak) 1923 skb = netdev_alloc_skb_ip_align(dev, pkt_len); 1924 if (skb) { 1925 pci_dma_sync_single_for_cpu(rp->pdev, 1926 rp->rx_skbuff_dma[entry], 1927 rp->rx_buf_sz, 1928 PCI_DMA_FROMDEVICE); 1929 1930 skb_copy_to_linear_data(skb, 1931 rp->rx_skbuff[entry]->data, 1932 pkt_len); 1933 skb_put(skb, pkt_len); 1934 pci_dma_sync_single_for_device(rp->pdev, 1935 rp->rx_skbuff_dma[entry], 1936 rp->rx_buf_sz, 1937 PCI_DMA_FROMDEVICE); 1938 } else { 1939 skb = rp->rx_skbuff[entry]; 1940 if (skb == NULL) { 1941 netdev_err(dev, "Inconsistent Rx descriptor chain\n"); 1942 break; 1943 } 1944 rp->rx_skbuff[entry] = NULL; 1945 skb_put(skb, pkt_len); 1946 pci_unmap_single(rp->pdev, 1947 rp->rx_skbuff_dma[entry], 1948 rp->rx_buf_sz, 1949 PCI_DMA_FROMDEVICE); 1950 } 1951 1952 if (unlikely(desc_length & DescTag)) 1953 vlan_tci = rhine_get_vlan_tci(skb, data_size); 1954 1955 skb->protocol = eth_type_trans(skb, dev); 1956 1957 if (unlikely(desc_length & DescTag)) 1958 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tci); 1959 netif_receive_skb(skb); 1960 1961 u64_stats_update_begin(&rp->rx_stats.syncp); 1962 rp->rx_stats.bytes += pkt_len; 1963 rp->rx_stats.packets++; 1964 u64_stats_update_end(&rp->rx_stats.syncp); 1965 } 1966 entry = (++rp->cur_rx) % RX_RING_SIZE; 1967 rp->rx_head_desc = &rp->rx_ring[entry]; 1968 } 1969 1970 /* Refill the Rx ring buffers. */ 1971 for (; rp->cur_rx - rp->dirty_rx > 0; rp->dirty_rx++) { 1972 struct sk_buff *skb; 1973 entry = rp->dirty_rx % RX_RING_SIZE; 1974 if (rp->rx_skbuff[entry] == NULL) { 1975 skb = netdev_alloc_skb(dev, rp->rx_buf_sz); 1976 rp->rx_skbuff[entry] = skb; 1977 if (skb == NULL) 1978 break; /* Better luck next round. */ 1979 rp->rx_skbuff_dma[entry] = 1980 pci_map_single(rp->pdev, skb->data, 1981 rp->rx_buf_sz, 1982 PCI_DMA_FROMDEVICE); 1983 if (dma_mapping_error(&rp->pdev->dev, rp->rx_skbuff_dma[entry])) { 1984 dev_kfree_skb(skb); 1985 rp->rx_skbuff_dma[entry] = 0; 1986 break; 1987 } 1988 rp->rx_ring[entry].addr = cpu_to_le32(rp->rx_skbuff_dma[entry]); 1989 } 1990 rp->rx_ring[entry].rx_status = cpu_to_le32(DescOwn); 1991 } 1992 1993 return count; 1994 } 1995 1996 static void rhine_restart_tx(struct net_device *dev) { 1997 struct rhine_private *rp = netdev_priv(dev); 1998 void __iomem *ioaddr = rp->base; 1999 int entry = rp->dirty_tx % TX_RING_SIZE; 2000 u32 intr_status; 2001 2002 /* 2003 * If new errors occurred, we need to sort them out before doing Tx. 2004 * In that case the ISR will be back here RSN anyway. 2005 */ 2006 intr_status = rhine_get_events(rp); 2007 2008 if ((intr_status & IntrTxErrSummary) == 0) { 2009 2010 /* We know better than the chip where it should continue. */ 2011 iowrite32(rp->tx_ring_dma + entry * sizeof(struct tx_desc), 2012 ioaddr + TxRingPtr); 2013 2014 iowrite8(ioread8(ioaddr + ChipCmd) | CmdTxOn, 2015 ioaddr + ChipCmd); 2016 2017 if (rp->tx_ring[entry].desc_length & cpu_to_le32(0x020000)) 2018 /* Tx queues are bits 7-0 (first Tx queue: bit 7) */ 2019 BYTE_REG_BITS_ON(1 << 7, ioaddr + TQWake); 2020 2021 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand, 2022 ioaddr + ChipCmd1); 2023 IOSYNC; 2024 } 2025 else { 2026 /* This should never happen */ 2027 netif_warn(rp, tx_err, dev, "another error occurred %08x\n", 2028 intr_status); 2029 } 2030 2031 } 2032 2033 static void rhine_slow_event_task(struct work_struct *work) 2034 { 2035 struct rhine_private *rp = 2036 container_of(work, struct rhine_private, slow_event_task); 2037 struct net_device *dev = rp->dev; 2038 u32 intr_status; 2039 2040 mutex_lock(&rp->task_lock); 2041 2042 if (!rp->task_enable) 2043 goto out_unlock; 2044 2045 intr_status = rhine_get_events(rp); 2046 rhine_ack_events(rp, intr_status & RHINE_EVENT_SLOW); 2047 2048 if (intr_status & IntrLinkChange) 2049 rhine_check_media(dev, 0); 2050 2051 if (intr_status & IntrPCIErr) 2052 netif_warn(rp, hw, dev, "PCI error\n"); 2053 2054 iowrite16(RHINE_EVENT & 0xffff, rp->base + IntrEnable); 2055 2056 out_unlock: 2057 mutex_unlock(&rp->task_lock); 2058 } 2059 2060 static struct rtnl_link_stats64 * 2061 rhine_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats) 2062 { 2063 struct rhine_private *rp = netdev_priv(dev); 2064 unsigned int start; 2065 2066 spin_lock_bh(&rp->lock); 2067 rhine_update_rx_crc_and_missed_errord(rp); 2068 spin_unlock_bh(&rp->lock); 2069 2070 netdev_stats_to_stats64(stats, &dev->stats); 2071 2072 do { 2073 start = u64_stats_fetch_begin_bh(&rp->rx_stats.syncp); 2074 stats->rx_packets = rp->rx_stats.packets; 2075 stats->rx_bytes = rp->rx_stats.bytes; 2076 } while (u64_stats_fetch_retry_bh(&rp->rx_stats.syncp, start)); 2077 2078 do { 2079 start = u64_stats_fetch_begin_bh(&rp->tx_stats.syncp); 2080 stats->tx_packets = rp->tx_stats.packets; 2081 stats->tx_bytes = rp->tx_stats.bytes; 2082 } while (u64_stats_fetch_retry_bh(&rp->tx_stats.syncp, start)); 2083 2084 return stats; 2085 } 2086 2087 static void rhine_set_rx_mode(struct net_device *dev) 2088 { 2089 struct rhine_private *rp = netdev_priv(dev); 2090 void __iomem *ioaddr = rp->base; 2091 u32 mc_filter[2]; /* Multicast hash filter */ 2092 u8 rx_mode = 0x0C; /* Note: 0x02=accept runt, 0x01=accept errs */ 2093 struct netdev_hw_addr *ha; 2094 2095 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ 2096 rx_mode = 0x1C; 2097 iowrite32(0xffffffff, ioaddr + MulticastFilter0); 2098 iowrite32(0xffffffff, ioaddr + MulticastFilter1); 2099 } else if ((netdev_mc_count(dev) > multicast_filter_limit) || 2100 (dev->flags & IFF_ALLMULTI)) { 2101 /* Too many to match, or accept all multicasts. */ 2102 iowrite32(0xffffffff, ioaddr + MulticastFilter0); 2103 iowrite32(0xffffffff, ioaddr + MulticastFilter1); 2104 } else if (rp->pdev->revision >= VT6105M) { 2105 int i = 0; 2106 u32 mCAMmask = 0; /* 32 mCAMs (6105M and better) */ 2107 netdev_for_each_mc_addr(ha, dev) { 2108 if (i == MCAM_SIZE) 2109 break; 2110 rhine_set_cam(ioaddr, i, ha->addr); 2111 mCAMmask |= 1 << i; 2112 i++; 2113 } 2114 rhine_set_cam_mask(ioaddr, mCAMmask); 2115 } else { 2116 memset(mc_filter, 0, sizeof(mc_filter)); 2117 netdev_for_each_mc_addr(ha, dev) { 2118 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26; 2119 2120 mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31); 2121 } 2122 iowrite32(mc_filter[0], ioaddr + MulticastFilter0); 2123 iowrite32(mc_filter[1], ioaddr + MulticastFilter1); 2124 } 2125 /* enable/disable VLAN receive filtering */ 2126 if (rp->pdev->revision >= VT6105M) { 2127 if (dev->flags & IFF_PROMISC) 2128 BYTE_REG_BITS_OFF(BCR1_VIDFR, ioaddr + PCIBusConfig1); 2129 else 2130 BYTE_REG_BITS_ON(BCR1_VIDFR, ioaddr + PCIBusConfig1); 2131 } 2132 BYTE_REG_BITS_ON(rx_mode, ioaddr + RxConfig); 2133 } 2134 2135 static void netdev_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 2136 { 2137 struct rhine_private *rp = netdev_priv(dev); 2138 2139 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 2140 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 2141 strlcpy(info->bus_info, pci_name(rp->pdev), sizeof(info->bus_info)); 2142 } 2143 2144 static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 2145 { 2146 struct rhine_private *rp = netdev_priv(dev); 2147 int rc; 2148 2149 mutex_lock(&rp->task_lock); 2150 rc = mii_ethtool_gset(&rp->mii_if, cmd); 2151 mutex_unlock(&rp->task_lock); 2152 2153 return rc; 2154 } 2155 2156 static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 2157 { 2158 struct rhine_private *rp = netdev_priv(dev); 2159 int rc; 2160 2161 mutex_lock(&rp->task_lock); 2162 rc = mii_ethtool_sset(&rp->mii_if, cmd); 2163 rhine_set_carrier(&rp->mii_if); 2164 mutex_unlock(&rp->task_lock); 2165 2166 return rc; 2167 } 2168 2169 static int netdev_nway_reset(struct net_device *dev) 2170 { 2171 struct rhine_private *rp = netdev_priv(dev); 2172 2173 return mii_nway_restart(&rp->mii_if); 2174 } 2175 2176 static u32 netdev_get_link(struct net_device *dev) 2177 { 2178 struct rhine_private *rp = netdev_priv(dev); 2179 2180 return mii_link_ok(&rp->mii_if); 2181 } 2182 2183 static u32 netdev_get_msglevel(struct net_device *dev) 2184 { 2185 struct rhine_private *rp = netdev_priv(dev); 2186 2187 return rp->msg_enable; 2188 } 2189 2190 static void netdev_set_msglevel(struct net_device *dev, u32 value) 2191 { 2192 struct rhine_private *rp = netdev_priv(dev); 2193 2194 rp->msg_enable = value; 2195 } 2196 2197 static void rhine_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 2198 { 2199 struct rhine_private *rp = netdev_priv(dev); 2200 2201 if (!(rp->quirks & rqWOL)) 2202 return; 2203 2204 spin_lock_irq(&rp->lock); 2205 wol->supported = WAKE_PHY | WAKE_MAGIC | 2206 WAKE_UCAST | WAKE_MCAST | WAKE_BCAST; /* Untested */ 2207 wol->wolopts = rp->wolopts; 2208 spin_unlock_irq(&rp->lock); 2209 } 2210 2211 static int rhine_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 2212 { 2213 struct rhine_private *rp = netdev_priv(dev); 2214 u32 support = WAKE_PHY | WAKE_MAGIC | 2215 WAKE_UCAST | WAKE_MCAST | WAKE_BCAST; /* Untested */ 2216 2217 if (!(rp->quirks & rqWOL)) 2218 return -EINVAL; 2219 2220 if (wol->wolopts & ~support) 2221 return -EINVAL; 2222 2223 spin_lock_irq(&rp->lock); 2224 rp->wolopts = wol->wolopts; 2225 spin_unlock_irq(&rp->lock); 2226 2227 return 0; 2228 } 2229 2230 static const struct ethtool_ops netdev_ethtool_ops = { 2231 .get_drvinfo = netdev_get_drvinfo, 2232 .get_settings = netdev_get_settings, 2233 .set_settings = netdev_set_settings, 2234 .nway_reset = netdev_nway_reset, 2235 .get_link = netdev_get_link, 2236 .get_msglevel = netdev_get_msglevel, 2237 .set_msglevel = netdev_set_msglevel, 2238 .get_wol = rhine_get_wol, 2239 .set_wol = rhine_set_wol, 2240 }; 2241 2242 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 2243 { 2244 struct rhine_private *rp = netdev_priv(dev); 2245 int rc; 2246 2247 if (!netif_running(dev)) 2248 return -EINVAL; 2249 2250 mutex_lock(&rp->task_lock); 2251 rc = generic_mii_ioctl(&rp->mii_if, if_mii(rq), cmd, NULL); 2252 rhine_set_carrier(&rp->mii_if); 2253 mutex_unlock(&rp->task_lock); 2254 2255 return rc; 2256 } 2257 2258 static int rhine_close(struct net_device *dev) 2259 { 2260 struct rhine_private *rp = netdev_priv(dev); 2261 void __iomem *ioaddr = rp->base; 2262 2263 rhine_task_disable(rp); 2264 napi_disable(&rp->napi); 2265 netif_stop_queue(dev); 2266 2267 netif_dbg(rp, ifdown, dev, "Shutting down ethercard, status was %04x\n", 2268 ioread16(ioaddr + ChipCmd)); 2269 2270 /* Switch to loopback mode to avoid hardware races. */ 2271 iowrite8(rp->tx_thresh | 0x02, ioaddr + TxConfig); 2272 2273 rhine_irq_disable(rp); 2274 2275 /* Stop the chip's Tx and Rx processes. */ 2276 iowrite16(CmdStop, ioaddr + ChipCmd); 2277 2278 free_irq(rp->pdev->irq, dev); 2279 free_rbufs(dev); 2280 free_tbufs(dev); 2281 free_ring(dev); 2282 2283 return 0; 2284 } 2285 2286 2287 static void rhine_remove_one(struct pci_dev *pdev) 2288 { 2289 struct net_device *dev = pci_get_drvdata(pdev); 2290 struct rhine_private *rp = netdev_priv(dev); 2291 2292 unregister_netdev(dev); 2293 2294 pci_iounmap(pdev, rp->base); 2295 pci_release_regions(pdev); 2296 2297 free_netdev(dev); 2298 pci_disable_device(pdev); 2299 } 2300 2301 static void rhine_shutdown (struct pci_dev *pdev) 2302 { 2303 struct net_device *dev = pci_get_drvdata(pdev); 2304 struct rhine_private *rp = netdev_priv(dev); 2305 void __iomem *ioaddr = rp->base; 2306 2307 if (!(rp->quirks & rqWOL)) 2308 return; /* Nothing to do for non-WOL adapters */ 2309 2310 rhine_power_init(dev); 2311 2312 /* Make sure we use pattern 0, 1 and not 4, 5 */ 2313 if (rp->quirks & rq6patterns) 2314 iowrite8(0x04, ioaddr + WOLcgClr); 2315 2316 spin_lock(&rp->lock); 2317 2318 if (rp->wolopts & WAKE_MAGIC) { 2319 iowrite8(WOLmagic, ioaddr + WOLcrSet); 2320 /* 2321 * Turn EEPROM-controlled wake-up back on -- some hardware may 2322 * not cooperate otherwise. 2323 */ 2324 iowrite8(ioread8(ioaddr + ConfigA) | 0x03, ioaddr + ConfigA); 2325 } 2326 2327 if (rp->wolopts & (WAKE_BCAST|WAKE_MCAST)) 2328 iowrite8(WOLbmcast, ioaddr + WOLcgSet); 2329 2330 if (rp->wolopts & WAKE_PHY) 2331 iowrite8(WOLlnkon | WOLlnkoff, ioaddr + WOLcrSet); 2332 2333 if (rp->wolopts & WAKE_UCAST) 2334 iowrite8(WOLucast, ioaddr + WOLcrSet); 2335 2336 if (rp->wolopts) { 2337 /* Enable legacy WOL (for old motherboards) */ 2338 iowrite8(0x01, ioaddr + PwcfgSet); 2339 iowrite8(ioread8(ioaddr + StickyHW) | 0x04, ioaddr + StickyHW); 2340 } 2341 2342 spin_unlock(&rp->lock); 2343 2344 if (system_state == SYSTEM_POWER_OFF && !avoid_D3) { 2345 iowrite8(ioread8(ioaddr + StickyHW) | 0x03, ioaddr + StickyHW); 2346 2347 pci_wake_from_d3(pdev, true); 2348 pci_set_power_state(pdev, PCI_D3hot); 2349 } 2350 } 2351 2352 #ifdef CONFIG_PM_SLEEP 2353 static int rhine_suspend(struct device *device) 2354 { 2355 struct pci_dev *pdev = to_pci_dev(device); 2356 struct net_device *dev = pci_get_drvdata(pdev); 2357 struct rhine_private *rp = netdev_priv(dev); 2358 2359 if (!netif_running(dev)) 2360 return 0; 2361 2362 rhine_task_disable(rp); 2363 rhine_irq_disable(rp); 2364 napi_disable(&rp->napi); 2365 2366 netif_device_detach(dev); 2367 2368 rhine_shutdown(pdev); 2369 2370 return 0; 2371 } 2372 2373 static int rhine_resume(struct device *device) 2374 { 2375 struct pci_dev *pdev = to_pci_dev(device); 2376 struct net_device *dev = pci_get_drvdata(pdev); 2377 struct rhine_private *rp = netdev_priv(dev); 2378 2379 if (!netif_running(dev)) 2380 return 0; 2381 2382 #ifdef USE_MMIO 2383 enable_mmio(rp->pioaddr, rp->quirks); 2384 #endif 2385 rhine_power_init(dev); 2386 free_tbufs(dev); 2387 free_rbufs(dev); 2388 alloc_tbufs(dev); 2389 alloc_rbufs(dev); 2390 rhine_task_enable(rp); 2391 spin_lock_bh(&rp->lock); 2392 init_registers(dev); 2393 spin_unlock_bh(&rp->lock); 2394 2395 netif_device_attach(dev); 2396 2397 return 0; 2398 } 2399 2400 static SIMPLE_DEV_PM_OPS(rhine_pm_ops, rhine_suspend, rhine_resume); 2401 #define RHINE_PM_OPS (&rhine_pm_ops) 2402 2403 #else 2404 2405 #define RHINE_PM_OPS NULL 2406 2407 #endif /* !CONFIG_PM_SLEEP */ 2408 2409 static struct pci_driver rhine_driver = { 2410 .name = DRV_NAME, 2411 .id_table = rhine_pci_tbl, 2412 .probe = rhine_init_one, 2413 .remove = rhine_remove_one, 2414 .shutdown = rhine_shutdown, 2415 .driver.pm = RHINE_PM_OPS, 2416 }; 2417 2418 static struct dmi_system_id rhine_dmi_table[] __initdata = { 2419 { 2420 .ident = "EPIA-M", 2421 .matches = { 2422 DMI_MATCH(DMI_BIOS_VENDOR, "Award Software International, Inc."), 2423 DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"), 2424 }, 2425 }, 2426 { 2427 .ident = "KV7", 2428 .matches = { 2429 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"), 2430 DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"), 2431 }, 2432 }, 2433 { NULL } 2434 }; 2435 2436 static int __init rhine_init(void) 2437 { 2438 /* when a module, this is printed whether or not devices are found in probe */ 2439 #ifdef MODULE 2440 pr_info("%s\n", version); 2441 #endif 2442 if (dmi_check_system(rhine_dmi_table)) { 2443 /* these BIOSes fail at PXE boot if chip is in D3 */ 2444 avoid_D3 = true; 2445 pr_warn("Broken BIOS detected, avoid_D3 enabled\n"); 2446 } 2447 else if (avoid_D3) 2448 pr_info("avoid_D3 set\n"); 2449 2450 return pci_register_driver(&rhine_driver); 2451 } 2452 2453 2454 static void __exit rhine_cleanup(void) 2455 { 2456 pci_unregister_driver(&rhine_driver); 2457 } 2458 2459 2460 module_init(rhine_init); 2461 module_exit(rhine_cleanup); 2462