Loading...
Note: File does not exist in v3.1.
1/* yellowfin.c: A Packet Engines G-NIC ethernet driver for linux. */
2/*
3 Written 1997-2001 by Donald Becker.
4
5 This software may be used and distributed according to the terms of
6 the GNU General Public License (GPL), incorporated herein by reference.
7 Drivers based on or derived from this code fall under the GPL and must
8 retain the authorship, copyright and license notice. This file is not
9 a complete program and may only be used when the entire operating
10 system is licensed under the GPL.
11
12 This driver is for the Packet Engines G-NIC PCI Gigabit Ethernet adapter.
13 It also supports the Symbios Logic version of the same chip core.
14
15 The author may be reached as becker@scyld.com, or C/O
16 Scyld Computing Corporation
17 410 Severn Ave., Suite 210
18 Annapolis MD 21403
19
20 Support and updates available at
21 http://www.scyld.com/network/yellowfin.html
22 [link no longer provides useful info -jgarzik]
23
24*/
25
26#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27
28#define DRV_NAME "yellowfin"
29#define DRV_VERSION "2.1"
30#define DRV_RELDATE "Sep 11, 2006"
31
32/* The user-configurable values.
33 These may be modified when a driver module is loaded.*/
34
35static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
36/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
37static int max_interrupt_work = 20;
38static int mtu;
39#ifdef YF_PROTOTYPE /* Support for prototype hardware errata. */
40/* System-wide count of bogus-rx frames. */
41static int bogus_rx;
42static int dma_ctrl = 0x004A0263; /* Constrained by errata */
43static int fifo_cfg = 0x0020; /* Bypass external Tx FIFO. */
44#elif defined(YF_NEW) /* A future perfect board :->. */
45static int dma_ctrl = 0x00CAC277; /* Override when loading module! */
46static int fifo_cfg = 0x0028;
47#else
48static const int dma_ctrl = 0x004A0263; /* Constrained by errata */
49static const int fifo_cfg = 0x0020; /* Bypass external Tx FIFO. */
50#endif
51
52/* Set the copy breakpoint for the copy-only-tiny-frames scheme.
53 Setting to > 1514 effectively disables this feature. */
54static int rx_copybreak;
55
56/* Used to pass the media type, etc.
57 No media types are currently defined. These exist for driver
58 interoperability.
59*/
60#define MAX_UNITS 8 /* More are supported, limit only on options */
61static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
62static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
63
64/* Do ugly workaround for GX server chipset errata. */
65static int gx_fix;
66
67/* Operational parameters that are set at compile time. */
68
69/* Keep the ring sizes a power of two for efficiency.
70 Making the Tx ring too long decreases the effectiveness of channel
71 bonding and packet priority.
72 There are no ill effects from too-large receive rings. */
73#define TX_RING_SIZE 16
74#define TX_QUEUE_SIZE 12 /* Must be > 4 && <= TX_RING_SIZE */
75#define RX_RING_SIZE 64
76#define STATUS_TOTAL_SIZE TX_RING_SIZE*sizeof(struct tx_status_words)
77#define TX_TOTAL_SIZE 2*TX_RING_SIZE*sizeof(struct yellowfin_desc)
78#define RX_TOTAL_SIZE RX_RING_SIZE*sizeof(struct yellowfin_desc)
79
80/* Operational parameters that usually are not changed. */
81/* Time in jiffies before concluding the transmitter is hung. */
82#define TX_TIMEOUT (2*HZ)
83#define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
84
85#define yellowfin_debug debug
86
87#include <linux/module.h>
88#include <linux/kernel.h>
89#include <linux/string.h>
90#include <linux/timer.h>
91#include <linux/errno.h>
92#include <linux/ioport.h>
93#include <linux/interrupt.h>
94#include <linux/pci.h>
95#include <linux/init.h>
96#include <linux/mii.h>
97#include <linux/netdevice.h>
98#include <linux/etherdevice.h>
99#include <linux/skbuff.h>
100#include <linux/ethtool.h>
101#include <linux/crc32.h>
102#include <linux/bitops.h>
103#include <linux/uaccess.h>
104#include <asm/processor.h> /* Processor type for cache alignment. */
105#include <asm/unaligned.h>
106#include <asm/io.h>
107
108/* These identify the driver base version and may not be removed. */
109static const char version[] =
110 KERN_INFO DRV_NAME ".c:v1.05 1/09/2001 Written by Donald Becker <becker@scyld.com>\n"
111 " (unofficial 2.4.x port, " DRV_VERSION ", " DRV_RELDATE ")\n";
112
113MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
114MODULE_DESCRIPTION("Packet Engines Yellowfin G-NIC Gigabit Ethernet driver");
115MODULE_LICENSE("GPL");
116
117module_param(max_interrupt_work, int, 0);
118module_param(mtu, int, 0);
119module_param(debug, int, 0);
120module_param(rx_copybreak, int, 0);
121module_param_array(options, int, NULL, 0);
122module_param_array(full_duplex, int, NULL, 0);
123module_param(gx_fix, int, 0);
124MODULE_PARM_DESC(max_interrupt_work, "G-NIC maximum events handled per interrupt");
125MODULE_PARM_DESC(mtu, "G-NIC MTU (all boards)");
126MODULE_PARM_DESC(debug, "G-NIC debug level (0-7)");
127MODULE_PARM_DESC(rx_copybreak, "G-NIC copy breakpoint for copy-only-tiny-frames");
128MODULE_PARM_DESC(options, "G-NIC: Bits 0-3: media type, bit 17: full duplex");
129MODULE_PARM_DESC(full_duplex, "G-NIC full duplex setting(s) (1)");
130MODULE_PARM_DESC(gx_fix, "G-NIC: enable GX server chipset bug workaround (0-1)");
131
132/*
133 Theory of Operation
134
135I. Board Compatibility
136
137This device driver is designed for the Packet Engines "Yellowfin" Gigabit
138Ethernet adapter. The G-NIC 64-bit PCI card is supported, as well as the
139Symbios 53C885E dual function chip.
140
141II. Board-specific settings
142
143PCI bus devices are configured by the system at boot time, so no jumpers
144need to be set on the board. The system BIOS preferably should assign the
145PCI INTA signal to an otherwise unused system IRQ line.
146Note: Kernel versions earlier than 1.3.73 do not support shared PCI
147interrupt lines.
148
149III. Driver operation
150
151IIIa. Ring buffers
152
153The Yellowfin uses the Descriptor Based DMA Architecture specified by Apple.
154This is a descriptor list scheme similar to that used by the EEPro100 and
155Tulip. This driver uses two statically allocated fixed-size descriptor lists
156formed into rings by a branch from the final descriptor to the beginning of
157the list. The ring sizes are set at compile time by RX/TX_RING_SIZE.
158
159The driver allocates full frame size skbuffs for the Rx ring buffers at
160open() time and passes the skb->data field to the Yellowfin as receive data
161buffers. When an incoming frame is less than RX_COPYBREAK bytes long,
162a fresh skbuff is allocated and the frame is copied to the new skbuff.
163When the incoming frame is larger, the skbuff is passed directly up the
164protocol stack and replaced by a newly allocated skbuff.
165
166The RX_COPYBREAK value is chosen to trade-off the memory wasted by
167using a full-sized skbuff for small frames vs. the copying costs of larger
168frames. For small frames the copying cost is negligible (esp. considering
169that we are pre-loading the cache with immediately useful header
170information). For large frames the copying cost is non-trivial, and the
171larger copy might flush the cache of useful data.
172
173IIIC. Synchronization
174
175The driver runs as two independent, single-threaded flows of control. One
176is the send-packet routine, which enforces single-threaded use by the
177dev->tbusy flag. The other thread is the interrupt handler, which is single
178threaded by the hardware and other software.
179
180The send packet thread has partial control over the Tx ring and 'dev->tbusy'
181flag. It sets the tbusy flag whenever it's queuing a Tx packet. If the next
182queue slot is empty, it clears the tbusy flag when finished otherwise it sets
183the 'yp->tx_full' flag.
184
185The interrupt handler has exclusive control over the Rx ring and records stats
186from the Tx ring. After reaping the stats, it marks the Tx queue entry as
187empty by incrementing the dirty_tx mark. Iff the 'yp->tx_full' flag is set, it
188clears both the tx_full and tbusy flags.
189
190IV. Notes
191
192Thanks to Kim Stearns of Packet Engines for providing a pair of G-NIC boards.
193Thanks to Bruce Faust of Digitalscape for providing both their SYM53C885 board
194and an AlphaStation to verifty the Alpha port!
195
196IVb. References
197
198Yellowfin Engineering Design Specification, 4/23/97 Preliminary/Confidential
199Symbios SYM53C885 PCI-SCSI/Fast Ethernet Multifunction Controller Preliminary
200 Data Manual v3.0
201http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html
202http://cesdis.gsfc.nasa.gov/linux/misc/100mbps.html
203
204IVc. Errata
205
206See Packet Engines confidential appendix (prototype chips only).
207*/
208
209
210
211enum capability_flags {
212 HasMII=1, FullTxStatus=2, IsGigabit=4, HasMulticastBug=8, FullRxStatus=16,
213 HasMACAddrBug=32, /* Only on early revs. */
214 DontUseEeprom=64, /* Don't read the MAC from the EEPROm. */
215};
216
217/* The PCI I/O space extent. */
218enum {
219 YELLOWFIN_SIZE = 0x100,
220};
221
222struct pci_id_info {
223 const char *name;
224 struct match_info {
225 int pci, pci_mask, subsystem, subsystem_mask;
226 int revision, revision_mask; /* Only 8 bits. */
227 } id;
228 int drv_flags; /* Driver use, intended as capability flags. */
229};
230
231static const struct pci_id_info pci_id_tbl[] = {
232 {"Yellowfin G-NIC Gigabit Ethernet", { 0x07021000, 0xffffffff},
233 FullTxStatus | IsGigabit | HasMulticastBug | HasMACAddrBug | DontUseEeprom},
234 {"Symbios SYM83C885", { 0x07011000, 0xffffffff},
235 HasMII | DontUseEeprom },
236 { }
237};
238
239static const struct pci_device_id yellowfin_pci_tbl[] = {
240 { 0x1000, 0x0702, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
241 { 0x1000, 0x0701, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
242 { }
243};
244MODULE_DEVICE_TABLE (pci, yellowfin_pci_tbl);
245
246
247/* Offsets to the Yellowfin registers. Various sizes and alignments. */
248enum yellowfin_offsets {
249 TxCtrl=0x00, TxStatus=0x04, TxPtr=0x0C,
250 TxIntrSel=0x10, TxBranchSel=0x14, TxWaitSel=0x18,
251 RxCtrl=0x40, RxStatus=0x44, RxPtr=0x4C,
252 RxIntrSel=0x50, RxBranchSel=0x54, RxWaitSel=0x58,
253 EventStatus=0x80, IntrEnb=0x82, IntrClear=0x84, IntrStatus=0x86,
254 ChipRev=0x8C, DMACtrl=0x90, TxThreshold=0x94,
255 Cnfg=0xA0, FrameGap0=0xA2, FrameGap1=0xA4,
256 MII_Cmd=0xA6, MII_Addr=0xA8, MII_Wr_Data=0xAA, MII_Rd_Data=0xAC,
257 MII_Status=0xAE,
258 RxDepth=0xB8, FlowCtrl=0xBC,
259 AddrMode=0xD0, StnAddr=0xD2, HashTbl=0xD8, FIFOcfg=0xF8,
260 EEStatus=0xF0, EECtrl=0xF1, EEAddr=0xF2, EERead=0xF3, EEWrite=0xF4,
261 EEFeature=0xF5,
262};
263
264/* The Yellowfin Rx and Tx buffer descriptors.
265 Elements are written as 32 bit for endian portability. */
266struct yellowfin_desc {
267 __le32 dbdma_cmd;
268 __le32 addr;
269 __le32 branch_addr;
270 __le32 result_status;
271};
272
273struct tx_status_words {
274#ifdef __BIG_ENDIAN
275 u16 tx_errs;
276 u16 tx_cnt;
277 u16 paused;
278 u16 total_tx_cnt;
279#else /* Little endian chips. */
280 u16 tx_cnt;
281 u16 tx_errs;
282 u16 total_tx_cnt;
283 u16 paused;
284#endif /* __BIG_ENDIAN */
285};
286
287/* Bits in yellowfin_desc.cmd */
288enum desc_cmd_bits {
289 CMD_TX_PKT=0x10000000, CMD_RX_BUF=0x20000000, CMD_TXSTATUS=0x30000000,
290 CMD_NOP=0x60000000, CMD_STOP=0x70000000,
291 BRANCH_ALWAYS=0x0C0000, INTR_ALWAYS=0x300000, WAIT_ALWAYS=0x030000,
292 BRANCH_IFTRUE=0x040000,
293};
294
295/* Bits in yellowfin_desc.status */
296enum desc_status_bits { RX_EOP=0x0040, };
297
298/* Bits in the interrupt status/mask registers. */
299enum intr_status_bits {
300 IntrRxDone=0x01, IntrRxInvalid=0x02, IntrRxPCIFault=0x04,IntrRxPCIErr=0x08,
301 IntrTxDone=0x10, IntrTxInvalid=0x20, IntrTxPCIFault=0x40,IntrTxPCIErr=0x80,
302 IntrEarlyRx=0x100, IntrWakeup=0x200, };
303
304#define PRIV_ALIGN 31 /* Required alignment mask */
305#define MII_CNT 4
306struct yellowfin_private {
307 /* Descriptor rings first for alignment.
308 Tx requires a second descriptor for status. */
309 struct yellowfin_desc *rx_ring;
310 struct yellowfin_desc *tx_ring;
311 struct sk_buff* rx_skbuff[RX_RING_SIZE];
312 struct sk_buff* tx_skbuff[TX_RING_SIZE];
313 dma_addr_t rx_ring_dma;
314 dma_addr_t tx_ring_dma;
315
316 struct tx_status_words *tx_status;
317 dma_addr_t tx_status_dma;
318
319 struct timer_list timer; /* Media selection timer. */
320 /* Frequently used and paired value: keep adjacent for cache effect. */
321 int chip_id, drv_flags;
322 struct pci_dev *pci_dev;
323 unsigned int cur_rx, dirty_rx; /* Producer/consumer ring indices */
324 unsigned int rx_buf_sz; /* Based on MTU+slack. */
325 struct tx_status_words *tx_tail_desc;
326 unsigned int cur_tx, dirty_tx;
327 int tx_threshold;
328 unsigned int tx_full:1; /* The Tx queue is full. */
329 unsigned int full_duplex:1; /* Full-duplex operation requested. */
330 unsigned int duplex_lock:1;
331 unsigned int medialock:1; /* Do not sense media. */
332 unsigned int default_port:4; /* Last dev->if_port value. */
333 /* MII transceiver section. */
334 int mii_cnt; /* MII device addresses. */
335 u16 advertising; /* NWay media advertisement */
336 unsigned char phys[MII_CNT]; /* MII device addresses, only first one used */
337 spinlock_t lock;
338 void __iomem *base;
339};
340
341static int read_eeprom(void __iomem *ioaddr, int location);
342static int mdio_read(void __iomem *ioaddr, int phy_id, int location);
343static void mdio_write(void __iomem *ioaddr, int phy_id, int location, int value);
344static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
345static int yellowfin_open(struct net_device *dev);
346static void yellowfin_timer(struct timer_list *t);
347static void yellowfin_tx_timeout(struct net_device *dev);
348static int yellowfin_init_ring(struct net_device *dev);
349static netdev_tx_t yellowfin_start_xmit(struct sk_buff *skb,
350 struct net_device *dev);
351static irqreturn_t yellowfin_interrupt(int irq, void *dev_instance);
352static int yellowfin_rx(struct net_device *dev);
353static void yellowfin_error(struct net_device *dev, int intr_status);
354static int yellowfin_close(struct net_device *dev);
355static void set_rx_mode(struct net_device *dev);
356static const struct ethtool_ops ethtool_ops;
357
358static const struct net_device_ops netdev_ops = {
359 .ndo_open = yellowfin_open,
360 .ndo_stop = yellowfin_close,
361 .ndo_start_xmit = yellowfin_start_xmit,
362 .ndo_set_rx_mode = set_rx_mode,
363 .ndo_validate_addr = eth_validate_addr,
364 .ndo_set_mac_address = eth_mac_addr,
365 .ndo_do_ioctl = netdev_ioctl,
366 .ndo_tx_timeout = yellowfin_tx_timeout,
367};
368
369static int yellowfin_init_one(struct pci_dev *pdev,
370 const struct pci_device_id *ent)
371{
372 struct net_device *dev;
373 struct yellowfin_private *np;
374 int irq;
375 int chip_idx = ent->driver_data;
376 static int find_cnt;
377 void __iomem *ioaddr;
378 int i, option = find_cnt < MAX_UNITS ? options[find_cnt] : 0;
379 int drv_flags = pci_id_tbl[chip_idx].drv_flags;
380 void *ring_space;
381 dma_addr_t ring_dma;
382#ifdef USE_IO_OPS
383 int bar = 0;
384#else
385 int bar = 1;
386#endif
387
388/* when built into the kernel, we only print version if device is found */
389#ifndef MODULE
390 static int printed_version;
391 if (!printed_version++)
392 printk(version);
393#endif
394
395 i = pci_enable_device(pdev);
396 if (i) return i;
397
398 dev = alloc_etherdev(sizeof(*np));
399 if (!dev)
400 return -ENOMEM;
401
402 SET_NETDEV_DEV(dev, &pdev->dev);
403
404 np = netdev_priv(dev);
405
406 if (pci_request_regions(pdev, DRV_NAME))
407 goto err_out_free_netdev;
408
409 pci_set_master (pdev);
410
411 ioaddr = pci_iomap(pdev, bar, YELLOWFIN_SIZE);
412 if (!ioaddr)
413 goto err_out_free_res;
414
415 irq = pdev->irq;
416
417 if (drv_flags & DontUseEeprom)
418 for (i = 0; i < 6; i++)
419 dev->dev_addr[i] = ioread8(ioaddr + StnAddr + i);
420 else {
421 int ee_offset = (read_eeprom(ioaddr, 6) == 0xff ? 0x100 : 0);
422 for (i = 0; i < 6; i++)
423 dev->dev_addr[i] = read_eeprom(ioaddr, ee_offset + i);
424 }
425
426 /* Reset the chip. */
427 iowrite32(0x80000000, ioaddr + DMACtrl);
428
429 pci_set_drvdata(pdev, dev);
430 spin_lock_init(&np->lock);
431
432 np->pci_dev = pdev;
433 np->chip_id = chip_idx;
434 np->drv_flags = drv_flags;
435 np->base = ioaddr;
436
437 ring_space = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);
438 if (!ring_space)
439 goto err_out_cleardev;
440 np->tx_ring = ring_space;
441 np->tx_ring_dma = ring_dma;
442
443 ring_space = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);
444 if (!ring_space)
445 goto err_out_unmap_tx;
446 np->rx_ring = ring_space;
447 np->rx_ring_dma = ring_dma;
448
449 ring_space = pci_alloc_consistent(pdev, STATUS_TOTAL_SIZE, &ring_dma);
450 if (!ring_space)
451 goto err_out_unmap_rx;
452 np->tx_status = ring_space;
453 np->tx_status_dma = ring_dma;
454
455 if (dev->mem_start)
456 option = dev->mem_start;
457
458 /* The lower four bits are the media type. */
459 if (option > 0) {
460 if (option & 0x200)
461 np->full_duplex = 1;
462 np->default_port = option & 15;
463 if (np->default_port)
464 np->medialock = 1;
465 }
466 if (find_cnt < MAX_UNITS && full_duplex[find_cnt] > 0)
467 np->full_duplex = 1;
468
469 if (np->full_duplex)
470 np->duplex_lock = 1;
471
472 /* The Yellowfin-specific entries in the device structure. */
473 dev->netdev_ops = &netdev_ops;
474 dev->ethtool_ops = ðtool_ops;
475 dev->watchdog_timeo = TX_TIMEOUT;
476
477 if (mtu)
478 dev->mtu = mtu;
479
480 i = register_netdev(dev);
481 if (i)
482 goto err_out_unmap_status;
483
484 netdev_info(dev, "%s type %8x at %p, %pM, IRQ %d\n",
485 pci_id_tbl[chip_idx].name,
486 ioread32(ioaddr + ChipRev), ioaddr,
487 dev->dev_addr, irq);
488
489 if (np->drv_flags & HasMII) {
490 int phy, phy_idx = 0;
491 for (phy = 0; phy < 32 && phy_idx < MII_CNT; phy++) {
492 int mii_status = mdio_read(ioaddr, phy, 1);
493 if (mii_status != 0xffff && mii_status != 0x0000) {
494 np->phys[phy_idx++] = phy;
495 np->advertising = mdio_read(ioaddr, phy, 4);
496 netdev_info(dev, "MII PHY found at address %d, status 0x%04x advertising %04x\n",
497 phy, mii_status, np->advertising);
498 }
499 }
500 np->mii_cnt = phy_idx;
501 }
502
503 find_cnt++;
504
505 return 0;
506
507err_out_unmap_status:
508 pci_free_consistent(pdev, STATUS_TOTAL_SIZE, np->tx_status,
509 np->tx_status_dma);
510err_out_unmap_rx:
511 pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma);
512err_out_unmap_tx:
513 pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma);
514err_out_cleardev:
515 pci_iounmap(pdev, ioaddr);
516err_out_free_res:
517 pci_release_regions(pdev);
518err_out_free_netdev:
519 free_netdev (dev);
520 return -ENODEV;
521}
522
523static int read_eeprom(void __iomem *ioaddr, int location)
524{
525 int bogus_cnt = 10000; /* Typical 33Mhz: 1050 ticks */
526
527 iowrite8(location, ioaddr + EEAddr);
528 iowrite8(0x30 | ((location >> 8) & 7), ioaddr + EECtrl);
529 while ((ioread8(ioaddr + EEStatus) & 0x80) && --bogus_cnt > 0)
530 ;
531 return ioread8(ioaddr + EERead);
532}
533
534/* MII Managemen Data I/O accesses.
535 These routines assume the MDIO controller is idle, and do not exit until
536 the command is finished. */
537
538static int mdio_read(void __iomem *ioaddr, int phy_id, int location)
539{
540 int i;
541
542 iowrite16((phy_id<<8) + location, ioaddr + MII_Addr);
543 iowrite16(1, ioaddr + MII_Cmd);
544 for (i = 10000; i >= 0; i--)
545 if ((ioread16(ioaddr + MII_Status) & 1) == 0)
546 break;
547 return ioread16(ioaddr + MII_Rd_Data);
548}
549
550static void mdio_write(void __iomem *ioaddr, int phy_id, int location, int value)
551{
552 int i;
553
554 iowrite16((phy_id<<8) + location, ioaddr + MII_Addr);
555 iowrite16(value, ioaddr + MII_Wr_Data);
556
557 /* Wait for the command to finish. */
558 for (i = 10000; i >= 0; i--)
559 if ((ioread16(ioaddr + MII_Status) & 1) == 0)
560 break;
561}
562
563
564static int yellowfin_open(struct net_device *dev)
565{
566 struct yellowfin_private *yp = netdev_priv(dev);
567 const int irq = yp->pci_dev->irq;
568 void __iomem *ioaddr = yp->base;
569 int i, rc;
570
571 /* Reset the chip. */
572 iowrite32(0x80000000, ioaddr + DMACtrl);
573
574 rc = request_irq(irq, yellowfin_interrupt, IRQF_SHARED, dev->name, dev);
575 if (rc)
576 return rc;
577
578 rc = yellowfin_init_ring(dev);
579 if (rc < 0)
580 goto err_free_irq;
581
582 iowrite32(yp->rx_ring_dma, ioaddr + RxPtr);
583 iowrite32(yp->tx_ring_dma, ioaddr + TxPtr);
584
585 for (i = 0; i < 6; i++)
586 iowrite8(dev->dev_addr[i], ioaddr + StnAddr + i);
587
588 /* Set up various condition 'select' registers.
589 There are no options here. */
590 iowrite32(0x00800080, ioaddr + TxIntrSel); /* Interrupt on Tx abort */
591 iowrite32(0x00800080, ioaddr + TxBranchSel); /* Branch on Tx abort */
592 iowrite32(0x00400040, ioaddr + TxWaitSel); /* Wait on Tx status */
593 iowrite32(0x00400040, ioaddr + RxIntrSel); /* Interrupt on Rx done */
594 iowrite32(0x00400040, ioaddr + RxBranchSel); /* Branch on Rx error */
595 iowrite32(0x00400040, ioaddr + RxWaitSel); /* Wait on Rx done */
596
597 /* Initialize other registers: with so many this eventually this will
598 converted to an offset/value list. */
599 iowrite32(dma_ctrl, ioaddr + DMACtrl);
600 iowrite16(fifo_cfg, ioaddr + FIFOcfg);
601 /* Enable automatic generation of flow control frames, period 0xffff. */
602 iowrite32(0x0030FFFF, ioaddr + FlowCtrl);
603
604 yp->tx_threshold = 32;
605 iowrite32(yp->tx_threshold, ioaddr + TxThreshold);
606
607 if (dev->if_port == 0)
608 dev->if_port = yp->default_port;
609
610 netif_start_queue(dev);
611
612 /* Setting the Rx mode will start the Rx process. */
613 if (yp->drv_flags & IsGigabit) {
614 /* We are always in full-duplex mode with gigabit! */
615 yp->full_duplex = 1;
616 iowrite16(0x01CF, ioaddr + Cnfg);
617 } else {
618 iowrite16(0x0018, ioaddr + FrameGap0); /* 0060/4060 for non-MII 10baseT */
619 iowrite16(0x1018, ioaddr + FrameGap1);
620 iowrite16(0x101C | (yp->full_duplex ? 2 : 0), ioaddr + Cnfg);
621 }
622 set_rx_mode(dev);
623
624 /* Enable interrupts by setting the interrupt mask. */
625 iowrite16(0x81ff, ioaddr + IntrEnb); /* See enum intr_status_bits */
626 iowrite16(0x0000, ioaddr + EventStatus); /* Clear non-interrupting events */
627 iowrite32(0x80008000, ioaddr + RxCtrl); /* Start Rx and Tx channels. */
628 iowrite32(0x80008000, ioaddr + TxCtrl);
629
630 if (yellowfin_debug > 2) {
631 netdev_printk(KERN_DEBUG, dev, "Done %s()\n", __func__);
632 }
633
634 /* Set the timer to check for link beat. */
635 timer_setup(&yp->timer, yellowfin_timer, 0);
636 yp->timer.expires = jiffies + 3*HZ;
637 add_timer(&yp->timer);
638out:
639 return rc;
640
641err_free_irq:
642 free_irq(irq, dev);
643 goto out;
644}
645
646static void yellowfin_timer(struct timer_list *t)
647{
648 struct yellowfin_private *yp = from_timer(yp, t, timer);
649 struct net_device *dev = pci_get_drvdata(yp->pci_dev);
650 void __iomem *ioaddr = yp->base;
651 int next_tick = 60*HZ;
652
653 if (yellowfin_debug > 3) {
654 netdev_printk(KERN_DEBUG, dev, "Yellowfin timer tick, status %08x\n",
655 ioread16(ioaddr + IntrStatus));
656 }
657
658 if (yp->mii_cnt) {
659 int bmsr = mdio_read(ioaddr, yp->phys[0], MII_BMSR);
660 int lpa = mdio_read(ioaddr, yp->phys[0], MII_LPA);
661 int negotiated = lpa & yp->advertising;
662 if (yellowfin_debug > 1)
663 netdev_printk(KERN_DEBUG, dev, "MII #%d status register is %04x, link partner capability %04x\n",
664 yp->phys[0], bmsr, lpa);
665
666 yp->full_duplex = mii_duplex(yp->duplex_lock, negotiated);
667
668 iowrite16(0x101C | (yp->full_duplex ? 2 : 0), ioaddr + Cnfg);
669
670 if (bmsr & BMSR_LSTATUS)
671 next_tick = 60*HZ;
672 else
673 next_tick = 3*HZ;
674 }
675
676 yp->timer.expires = jiffies + next_tick;
677 add_timer(&yp->timer);
678}
679
680static void yellowfin_tx_timeout(struct net_device *dev)
681{
682 struct yellowfin_private *yp = netdev_priv(dev);
683 void __iomem *ioaddr = yp->base;
684
685 netdev_warn(dev, "Yellowfin transmit timed out at %d/%d Tx status %04x, Rx status %04x, resetting...\n",
686 yp->cur_tx, yp->dirty_tx,
687 ioread32(ioaddr + TxStatus),
688 ioread32(ioaddr + RxStatus));
689
690 /* Note: these should be KERN_DEBUG. */
691 if (yellowfin_debug) {
692 int i;
693 pr_warn(" Rx ring %p: ", yp->rx_ring);
694 for (i = 0; i < RX_RING_SIZE; i++)
695 pr_cont(" %08x", yp->rx_ring[i].result_status);
696 pr_cont("\n");
697 pr_warn(" Tx ring %p: ", yp->tx_ring);
698 for (i = 0; i < TX_RING_SIZE; i++)
699 pr_cont(" %04x /%08x",
700 yp->tx_status[i].tx_errs,
701 yp->tx_ring[i].result_status);
702 pr_cont("\n");
703 }
704
705 /* If the hardware is found to hang regularly, we will update the code
706 to reinitialize the chip here. */
707 dev->if_port = 0;
708
709 /* Wake the potentially-idle transmit channel. */
710 iowrite32(0x10001000, yp->base + TxCtrl);
711 if (yp->cur_tx - yp->dirty_tx < TX_QUEUE_SIZE)
712 netif_wake_queue (dev); /* Typical path */
713
714 netif_trans_update(dev); /* prevent tx timeout */
715 dev->stats.tx_errors++;
716}
717
718/* Initialize the Rx and Tx rings, along with various 'dev' bits. */
719static int yellowfin_init_ring(struct net_device *dev)
720{
721 struct yellowfin_private *yp = netdev_priv(dev);
722 int i, j;
723
724 yp->tx_full = 0;
725 yp->cur_rx = yp->cur_tx = 0;
726 yp->dirty_tx = 0;
727
728 yp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
729
730 for (i = 0; i < RX_RING_SIZE; i++) {
731 yp->rx_ring[i].dbdma_cmd =
732 cpu_to_le32(CMD_RX_BUF | INTR_ALWAYS | yp->rx_buf_sz);
733 yp->rx_ring[i].branch_addr = cpu_to_le32(yp->rx_ring_dma +
734 ((i+1)%RX_RING_SIZE)*sizeof(struct yellowfin_desc));
735 }
736
737 for (i = 0; i < RX_RING_SIZE; i++) {
738 struct sk_buff *skb = netdev_alloc_skb(dev, yp->rx_buf_sz + 2);
739 yp->rx_skbuff[i] = skb;
740 if (skb == NULL)
741 break;
742 skb_reserve(skb, 2); /* 16 byte align the IP header. */
743 yp->rx_ring[i].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
744 skb->data, yp->rx_buf_sz, PCI_DMA_FROMDEVICE));
745 }
746 if (i != RX_RING_SIZE) {
747 for (j = 0; j < i; j++)
748 dev_kfree_skb(yp->rx_skbuff[j]);
749 return -ENOMEM;
750 }
751 yp->rx_ring[i-1].dbdma_cmd = cpu_to_le32(CMD_STOP);
752 yp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
753
754#define NO_TXSTATS
755#ifdef NO_TXSTATS
756 /* In this mode the Tx ring needs only a single descriptor. */
757 for (i = 0; i < TX_RING_SIZE; i++) {
758 yp->tx_skbuff[i] = NULL;
759 yp->tx_ring[i].dbdma_cmd = cpu_to_le32(CMD_STOP);
760 yp->tx_ring[i].branch_addr = cpu_to_le32(yp->tx_ring_dma +
761 ((i+1)%TX_RING_SIZE)*sizeof(struct yellowfin_desc));
762 }
763 /* Wrap ring */
764 yp->tx_ring[--i].dbdma_cmd = cpu_to_le32(CMD_STOP | BRANCH_ALWAYS);
765#else
766{
767 /* Tx ring needs a pair of descriptors, the second for the status. */
768 for (i = 0; i < TX_RING_SIZE; i++) {
769 j = 2*i;
770 yp->tx_skbuff[i] = 0;
771 /* Branch on Tx error. */
772 yp->tx_ring[j].dbdma_cmd = cpu_to_le32(CMD_STOP);
773 yp->tx_ring[j].branch_addr = cpu_to_le32(yp->tx_ring_dma +
774 (j+1)*sizeof(struct yellowfin_desc));
775 j++;
776 if (yp->flags & FullTxStatus) {
777 yp->tx_ring[j].dbdma_cmd =
778 cpu_to_le32(CMD_TXSTATUS | sizeof(*yp->tx_status));
779 yp->tx_ring[j].request_cnt = sizeof(*yp->tx_status);
780 yp->tx_ring[j].addr = cpu_to_le32(yp->tx_status_dma +
781 i*sizeof(struct tx_status_words));
782 } else {
783 /* Symbios chips write only tx_errs word. */
784 yp->tx_ring[j].dbdma_cmd =
785 cpu_to_le32(CMD_TXSTATUS | INTR_ALWAYS | 2);
786 yp->tx_ring[j].request_cnt = 2;
787 /* Om pade ummmmm... */
788 yp->tx_ring[j].addr = cpu_to_le32(yp->tx_status_dma +
789 i*sizeof(struct tx_status_words) +
790 &(yp->tx_status[0].tx_errs) -
791 &(yp->tx_status[0]));
792 }
793 yp->tx_ring[j].branch_addr = cpu_to_le32(yp->tx_ring_dma +
794 ((j+1)%(2*TX_RING_SIZE))*sizeof(struct yellowfin_desc));
795 }
796 /* Wrap ring */
797 yp->tx_ring[++j].dbdma_cmd |= cpu_to_le32(BRANCH_ALWAYS | INTR_ALWAYS);
798}
799#endif
800 yp->tx_tail_desc = &yp->tx_status[0];
801 return 0;
802}
803
804static netdev_tx_t yellowfin_start_xmit(struct sk_buff *skb,
805 struct net_device *dev)
806{
807 struct yellowfin_private *yp = netdev_priv(dev);
808 unsigned entry;
809 int len = skb->len;
810
811 netif_stop_queue (dev);
812
813 /* Note: Ordering is important here, set the field with the
814 "ownership" bit last, and only then increment cur_tx. */
815
816 /* Calculate the next Tx descriptor entry. */
817 entry = yp->cur_tx % TX_RING_SIZE;
818
819 if (gx_fix) { /* Note: only works for paddable protocols e.g. IP. */
820 int cacheline_end = ((unsigned long)skb->data + skb->len) % 32;
821 /* Fix GX chipset errata. */
822 if (cacheline_end > 24 || cacheline_end == 0) {
823 len = skb->len + 32 - cacheline_end + 1;
824 if (skb_padto(skb, len)) {
825 yp->tx_skbuff[entry] = NULL;
826 netif_wake_queue(dev);
827 return NETDEV_TX_OK;
828 }
829 }
830 }
831 yp->tx_skbuff[entry] = skb;
832
833#ifdef NO_TXSTATS
834 yp->tx_ring[entry].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
835 skb->data, len, PCI_DMA_TODEVICE));
836 yp->tx_ring[entry].result_status = 0;
837 if (entry >= TX_RING_SIZE-1) {
838 /* New stop command. */
839 yp->tx_ring[0].dbdma_cmd = cpu_to_le32(CMD_STOP);
840 yp->tx_ring[TX_RING_SIZE-1].dbdma_cmd =
841 cpu_to_le32(CMD_TX_PKT|BRANCH_ALWAYS | len);
842 } else {
843 yp->tx_ring[entry+1].dbdma_cmd = cpu_to_le32(CMD_STOP);
844 yp->tx_ring[entry].dbdma_cmd =
845 cpu_to_le32(CMD_TX_PKT | BRANCH_IFTRUE | len);
846 }
847 yp->cur_tx++;
848#else
849 yp->tx_ring[entry<<1].request_cnt = len;
850 yp->tx_ring[entry<<1].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
851 skb->data, len, PCI_DMA_TODEVICE));
852 /* The input_last (status-write) command is constant, but we must
853 rewrite the subsequent 'stop' command. */
854
855 yp->cur_tx++;
856 {
857 unsigned next_entry = yp->cur_tx % TX_RING_SIZE;
858 yp->tx_ring[next_entry<<1].dbdma_cmd = cpu_to_le32(CMD_STOP);
859 }
860 /* Final step -- overwrite the old 'stop' command. */
861
862 yp->tx_ring[entry<<1].dbdma_cmd =
863 cpu_to_le32( ((entry % 6) == 0 ? CMD_TX_PKT|INTR_ALWAYS|BRANCH_IFTRUE :
864 CMD_TX_PKT | BRANCH_IFTRUE) | len);
865#endif
866
867 /* Non-x86 Todo: explicitly flush cache lines here. */
868
869 /* Wake the potentially-idle transmit channel. */
870 iowrite32(0x10001000, yp->base + TxCtrl);
871
872 if (yp->cur_tx - yp->dirty_tx < TX_QUEUE_SIZE)
873 netif_start_queue (dev); /* Typical path */
874 else
875 yp->tx_full = 1;
876
877 if (yellowfin_debug > 4) {
878 netdev_printk(KERN_DEBUG, dev, "Yellowfin transmit frame #%d queued in slot %d\n",
879 yp->cur_tx, entry);
880 }
881 return NETDEV_TX_OK;
882}
883
884/* The interrupt handler does all of the Rx thread work and cleans up
885 after the Tx thread. */
886static irqreturn_t yellowfin_interrupt(int irq, void *dev_instance)
887{
888 struct net_device *dev = dev_instance;
889 struct yellowfin_private *yp;
890 void __iomem *ioaddr;
891 int boguscnt = max_interrupt_work;
892 unsigned int handled = 0;
893
894 yp = netdev_priv(dev);
895 ioaddr = yp->base;
896
897 spin_lock (&yp->lock);
898
899 do {
900 u16 intr_status = ioread16(ioaddr + IntrClear);
901
902 if (yellowfin_debug > 4)
903 netdev_printk(KERN_DEBUG, dev, "Yellowfin interrupt, status %04x\n",
904 intr_status);
905
906 if (intr_status == 0)
907 break;
908 handled = 1;
909
910 if (intr_status & (IntrRxDone | IntrEarlyRx)) {
911 yellowfin_rx(dev);
912 iowrite32(0x10001000, ioaddr + RxCtrl); /* Wake Rx engine. */
913 }
914
915#ifdef NO_TXSTATS
916 for (; yp->cur_tx - yp->dirty_tx > 0; yp->dirty_tx++) {
917 int entry = yp->dirty_tx % TX_RING_SIZE;
918 struct sk_buff *skb;
919
920 if (yp->tx_ring[entry].result_status == 0)
921 break;
922 skb = yp->tx_skbuff[entry];
923 dev->stats.tx_packets++;
924 dev->stats.tx_bytes += skb->len;
925 /* Free the original skb. */
926 pci_unmap_single(yp->pci_dev, le32_to_cpu(yp->tx_ring[entry].addr),
927 skb->len, PCI_DMA_TODEVICE);
928 dev_kfree_skb_irq(skb);
929 yp->tx_skbuff[entry] = NULL;
930 }
931 if (yp->tx_full &&
932 yp->cur_tx - yp->dirty_tx < TX_QUEUE_SIZE - 4) {
933 /* The ring is no longer full, clear tbusy. */
934 yp->tx_full = 0;
935 netif_wake_queue(dev);
936 }
937#else
938 if ((intr_status & IntrTxDone) || (yp->tx_tail_desc->tx_errs)) {
939 unsigned dirty_tx = yp->dirty_tx;
940
941 for (dirty_tx = yp->dirty_tx; yp->cur_tx - dirty_tx > 0;
942 dirty_tx++) {
943 /* Todo: optimize this. */
944 int entry = dirty_tx % TX_RING_SIZE;
945 u16 tx_errs = yp->tx_status[entry].tx_errs;
946 struct sk_buff *skb;
947
948#ifndef final_version
949 if (yellowfin_debug > 5)
950 netdev_printk(KERN_DEBUG, dev, "Tx queue %d check, Tx status %04x %04x %04x %04x\n",
951 entry,
952 yp->tx_status[entry].tx_cnt,
953 yp->tx_status[entry].tx_errs,
954 yp->tx_status[entry].total_tx_cnt,
955 yp->tx_status[entry].paused);
956#endif
957 if (tx_errs == 0)
958 break; /* It still hasn't been Txed */
959 skb = yp->tx_skbuff[entry];
960 if (tx_errs & 0xF810) {
961 /* There was an major error, log it. */
962#ifndef final_version
963 if (yellowfin_debug > 1)
964 netdev_printk(KERN_DEBUG, dev, "Transmit error, Tx status %04x\n",
965 tx_errs);
966#endif
967 dev->stats.tx_errors++;
968 if (tx_errs & 0xF800) dev->stats.tx_aborted_errors++;
969 if (tx_errs & 0x0800) dev->stats.tx_carrier_errors++;
970 if (tx_errs & 0x2000) dev->stats.tx_window_errors++;
971 if (tx_errs & 0x8000) dev->stats.tx_fifo_errors++;
972 } else {
973#ifndef final_version
974 if (yellowfin_debug > 4)
975 netdev_printk(KERN_DEBUG, dev, "Normal transmit, Tx status %04x\n",
976 tx_errs);
977#endif
978 dev->stats.tx_bytes += skb->len;
979 dev->stats.collisions += tx_errs & 15;
980 dev->stats.tx_packets++;
981 }
982 /* Free the original skb. */
983 pci_unmap_single(yp->pci_dev,
984 yp->tx_ring[entry<<1].addr, skb->len,
985 PCI_DMA_TODEVICE);
986 dev_kfree_skb_irq(skb);
987 yp->tx_skbuff[entry] = 0;
988 /* Mark status as empty. */
989 yp->tx_status[entry].tx_errs = 0;
990 }
991
992#ifndef final_version
993 if (yp->cur_tx - dirty_tx > TX_RING_SIZE) {
994 netdev_err(dev, "Out-of-sync dirty pointer, %d vs. %d, full=%d\n",
995 dirty_tx, yp->cur_tx, yp->tx_full);
996 dirty_tx += TX_RING_SIZE;
997 }
998#endif
999
1000 if (yp->tx_full &&
1001 yp->cur_tx - dirty_tx < TX_QUEUE_SIZE - 2) {
1002 /* The ring is no longer full, clear tbusy. */
1003 yp->tx_full = 0;
1004 netif_wake_queue(dev);
1005 }
1006
1007 yp->dirty_tx = dirty_tx;
1008 yp->tx_tail_desc = &yp->tx_status[dirty_tx % TX_RING_SIZE];
1009 }
1010#endif
1011
1012 /* Log errors and other uncommon events. */
1013 if (intr_status & 0x2ee) /* Abnormal error summary. */
1014 yellowfin_error(dev, intr_status);
1015
1016 if (--boguscnt < 0) {
1017 netdev_warn(dev, "Too much work at interrupt, status=%#04x\n",
1018 intr_status);
1019 break;
1020 }
1021 } while (1);
1022
1023 if (yellowfin_debug > 3)
1024 netdev_printk(KERN_DEBUG, dev, "exiting interrupt, status=%#04x\n",
1025 ioread16(ioaddr + IntrStatus));
1026
1027 spin_unlock (&yp->lock);
1028 return IRQ_RETVAL(handled);
1029}
1030
1031/* This routine is logically part of the interrupt handler, but separated
1032 for clarity and better register allocation. */
1033static int yellowfin_rx(struct net_device *dev)
1034{
1035 struct yellowfin_private *yp = netdev_priv(dev);
1036 int entry = yp->cur_rx % RX_RING_SIZE;
1037 int boguscnt = yp->dirty_rx + RX_RING_SIZE - yp->cur_rx;
1038
1039 if (yellowfin_debug > 4) {
1040 printk(KERN_DEBUG " In yellowfin_rx(), entry %d status %08x\n",
1041 entry, yp->rx_ring[entry].result_status);
1042 printk(KERN_DEBUG " #%d desc. %08x %08x %08x\n",
1043 entry, yp->rx_ring[entry].dbdma_cmd, yp->rx_ring[entry].addr,
1044 yp->rx_ring[entry].result_status);
1045 }
1046
1047 /* If EOP is set on the next entry, it's a new packet. Send it up. */
1048 while (1) {
1049 struct yellowfin_desc *desc = &yp->rx_ring[entry];
1050 struct sk_buff *rx_skb = yp->rx_skbuff[entry];
1051 s16 frame_status;
1052 u16 desc_status;
1053 int data_size, yf_size;
1054 u8 *buf_addr;
1055
1056 if(!desc->result_status)
1057 break;
1058 pci_dma_sync_single_for_cpu(yp->pci_dev, le32_to_cpu(desc->addr),
1059 yp->rx_buf_sz, PCI_DMA_FROMDEVICE);
1060 desc_status = le32_to_cpu(desc->result_status) >> 16;
1061 buf_addr = rx_skb->data;
1062 data_size = (le32_to_cpu(desc->dbdma_cmd) -
1063 le32_to_cpu(desc->result_status)) & 0xffff;
1064 frame_status = get_unaligned_le16(&(buf_addr[data_size - 2]));
1065 if (yellowfin_debug > 4)
1066 printk(KERN_DEBUG " %s() status was %04x\n",
1067 __func__, frame_status);
1068 if (--boguscnt < 0)
1069 break;
1070
1071 yf_size = sizeof(struct yellowfin_desc);
1072
1073 if ( ! (desc_status & RX_EOP)) {
1074 if (data_size != 0)
1075 netdev_warn(dev, "Oversized Ethernet frame spanned multiple buffers, status %04x, data_size %d!\n",
1076 desc_status, data_size);
1077 dev->stats.rx_length_errors++;
1078 } else if ((yp->drv_flags & IsGigabit) && (frame_status & 0x0038)) {
1079 /* There was a error. */
1080 if (yellowfin_debug > 3)
1081 printk(KERN_DEBUG " %s() Rx error was %04x\n",
1082 __func__, frame_status);
1083 dev->stats.rx_errors++;
1084 if (frame_status & 0x0060) dev->stats.rx_length_errors++;
1085 if (frame_status & 0x0008) dev->stats.rx_frame_errors++;
1086 if (frame_status & 0x0010) dev->stats.rx_crc_errors++;
1087 if (frame_status < 0) dev->stats.rx_dropped++;
1088 } else if ( !(yp->drv_flags & IsGigabit) &&
1089 ((buf_addr[data_size-1] & 0x85) || buf_addr[data_size-2] & 0xC0)) {
1090 u8 status1 = buf_addr[data_size-2];
1091 u8 status2 = buf_addr[data_size-1];
1092 dev->stats.rx_errors++;
1093 if (status1 & 0xC0) dev->stats.rx_length_errors++;
1094 if (status2 & 0x03) dev->stats.rx_frame_errors++;
1095 if (status2 & 0x04) dev->stats.rx_crc_errors++;
1096 if (status2 & 0x80) dev->stats.rx_dropped++;
1097#ifdef YF_PROTOTYPE /* Support for prototype hardware errata. */
1098 } else if ((yp->flags & HasMACAddrBug) &&
1099 !ether_addr_equal(le32_to_cpu(yp->rx_ring_dma +
1100 entry * yf_size),
1101 dev->dev_addr) &&
1102 !ether_addr_equal(le32_to_cpu(yp->rx_ring_dma +
1103 entry * yf_size),
1104 "\377\377\377\377\377\377")) {
1105 if (bogus_rx++ == 0)
1106 netdev_warn(dev, "Bad frame to %pM\n",
1107 buf_addr);
1108#endif
1109 } else {
1110 struct sk_buff *skb;
1111 int pkt_len = data_size -
1112 (yp->chip_id ? 7 : 8 + buf_addr[data_size - 8]);
1113 /* To verify: Yellowfin Length should omit the CRC! */
1114
1115#ifndef final_version
1116 if (yellowfin_debug > 4)
1117 printk(KERN_DEBUG " %s() normal Rx pkt length %d of %d, bogus_cnt %d\n",
1118 __func__, pkt_len, data_size, boguscnt);
1119#endif
1120 /* Check if the packet is long enough to just pass up the skbuff
1121 without copying to a properly sized skbuff. */
1122 if (pkt_len > rx_copybreak) {
1123 skb_put(skb = rx_skb, pkt_len);
1124 pci_unmap_single(yp->pci_dev,
1125 le32_to_cpu(yp->rx_ring[entry].addr),
1126 yp->rx_buf_sz,
1127 PCI_DMA_FROMDEVICE);
1128 yp->rx_skbuff[entry] = NULL;
1129 } else {
1130 skb = netdev_alloc_skb(dev, pkt_len + 2);
1131 if (skb == NULL)
1132 break;
1133 skb_reserve(skb, 2); /* 16 byte align the IP header */
1134 skb_copy_to_linear_data(skb, rx_skb->data, pkt_len);
1135 skb_put(skb, pkt_len);
1136 pci_dma_sync_single_for_device(yp->pci_dev,
1137 le32_to_cpu(desc->addr),
1138 yp->rx_buf_sz,
1139 PCI_DMA_FROMDEVICE);
1140 }
1141 skb->protocol = eth_type_trans(skb, dev);
1142 netif_rx(skb);
1143 dev->stats.rx_packets++;
1144 dev->stats.rx_bytes += pkt_len;
1145 }
1146 entry = (++yp->cur_rx) % RX_RING_SIZE;
1147 }
1148
1149 /* Refill the Rx ring buffers. */
1150 for (; yp->cur_rx - yp->dirty_rx > 0; yp->dirty_rx++) {
1151 entry = yp->dirty_rx % RX_RING_SIZE;
1152 if (yp->rx_skbuff[entry] == NULL) {
1153 struct sk_buff *skb = netdev_alloc_skb(dev, yp->rx_buf_sz + 2);
1154 if (skb == NULL)
1155 break; /* Better luck next round. */
1156 yp->rx_skbuff[entry] = skb;
1157 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1158 yp->rx_ring[entry].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
1159 skb->data, yp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1160 }
1161 yp->rx_ring[entry].dbdma_cmd = cpu_to_le32(CMD_STOP);
1162 yp->rx_ring[entry].result_status = 0; /* Clear complete bit. */
1163 if (entry != 0)
1164 yp->rx_ring[entry - 1].dbdma_cmd =
1165 cpu_to_le32(CMD_RX_BUF | INTR_ALWAYS | yp->rx_buf_sz);
1166 else
1167 yp->rx_ring[RX_RING_SIZE - 1].dbdma_cmd =
1168 cpu_to_le32(CMD_RX_BUF | INTR_ALWAYS | BRANCH_ALWAYS
1169 | yp->rx_buf_sz);
1170 }
1171
1172 return 0;
1173}
1174
1175static void yellowfin_error(struct net_device *dev, int intr_status)
1176{
1177 netdev_err(dev, "Something Wicked happened! %04x\n", intr_status);
1178 /* Hmmmmm, it's not clear what to do here. */
1179 if (intr_status & (IntrTxPCIErr | IntrTxPCIFault))
1180 dev->stats.tx_errors++;
1181 if (intr_status & (IntrRxPCIErr | IntrRxPCIFault))
1182 dev->stats.rx_errors++;
1183}
1184
1185static int yellowfin_close(struct net_device *dev)
1186{
1187 struct yellowfin_private *yp = netdev_priv(dev);
1188 void __iomem *ioaddr = yp->base;
1189 int i;
1190
1191 netif_stop_queue (dev);
1192
1193 if (yellowfin_debug > 1) {
1194 netdev_printk(KERN_DEBUG, dev, "Shutting down ethercard, status was Tx %04x Rx %04x Int %02x\n",
1195 ioread16(ioaddr + TxStatus),
1196 ioread16(ioaddr + RxStatus),
1197 ioread16(ioaddr + IntrStatus));
1198 netdev_printk(KERN_DEBUG, dev, "Queue pointers were Tx %d / %d, Rx %d / %d\n",
1199 yp->cur_tx, yp->dirty_tx,
1200 yp->cur_rx, yp->dirty_rx);
1201 }
1202
1203 /* Disable interrupts by clearing the interrupt mask. */
1204 iowrite16(0x0000, ioaddr + IntrEnb);
1205
1206 /* Stop the chip's Tx and Rx processes. */
1207 iowrite32(0x80000000, ioaddr + RxCtrl);
1208 iowrite32(0x80000000, ioaddr + TxCtrl);
1209
1210 del_timer(&yp->timer);
1211
1212#if defined(__i386__)
1213 if (yellowfin_debug > 2) {
1214 printk(KERN_DEBUG " Tx ring at %08llx:\n",
1215 (unsigned long long)yp->tx_ring_dma);
1216 for (i = 0; i < TX_RING_SIZE*2; i++)
1217 printk(KERN_DEBUG " %c #%d desc. %08x %08x %08x %08x\n",
1218 ioread32(ioaddr + TxPtr) == (long)&yp->tx_ring[i] ? '>' : ' ',
1219 i, yp->tx_ring[i].dbdma_cmd, yp->tx_ring[i].addr,
1220 yp->tx_ring[i].branch_addr, yp->tx_ring[i].result_status);
1221 printk(KERN_DEBUG " Tx status %p:\n", yp->tx_status);
1222 for (i = 0; i < TX_RING_SIZE; i++)
1223 printk(KERN_DEBUG " #%d status %04x %04x %04x %04x\n",
1224 i, yp->tx_status[i].tx_cnt, yp->tx_status[i].tx_errs,
1225 yp->tx_status[i].total_tx_cnt, yp->tx_status[i].paused);
1226
1227 printk(KERN_DEBUG " Rx ring %08llx:\n",
1228 (unsigned long long)yp->rx_ring_dma);
1229 for (i = 0; i < RX_RING_SIZE; i++) {
1230 printk(KERN_DEBUG " %c #%d desc. %08x %08x %08x\n",
1231 ioread32(ioaddr + RxPtr) == (long)&yp->rx_ring[i] ? '>' : ' ',
1232 i, yp->rx_ring[i].dbdma_cmd, yp->rx_ring[i].addr,
1233 yp->rx_ring[i].result_status);
1234 if (yellowfin_debug > 6) {
1235 if (get_unaligned((u8*)yp->rx_ring[i].addr) != 0x69) {
1236 int j;
1237
1238 printk(KERN_DEBUG);
1239 for (j = 0; j < 0x50; j++)
1240 pr_cont(" %04x",
1241 get_unaligned(((u16*)yp->rx_ring[i].addr) + j));
1242 pr_cont("\n");
1243 }
1244 }
1245 }
1246 }
1247#endif /* __i386__ debugging only */
1248
1249 free_irq(yp->pci_dev->irq, dev);
1250
1251 /* Free all the skbuffs in the Rx queue. */
1252 for (i = 0; i < RX_RING_SIZE; i++) {
1253 yp->rx_ring[i].dbdma_cmd = cpu_to_le32(CMD_STOP);
1254 yp->rx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
1255 if (yp->rx_skbuff[i]) {
1256 dev_kfree_skb(yp->rx_skbuff[i]);
1257 }
1258 yp->rx_skbuff[i] = NULL;
1259 }
1260 for (i = 0; i < TX_RING_SIZE; i++) {
1261 if (yp->tx_skbuff[i])
1262 dev_kfree_skb(yp->tx_skbuff[i]);
1263 yp->tx_skbuff[i] = NULL;
1264 }
1265
1266#ifdef YF_PROTOTYPE /* Support for prototype hardware errata. */
1267 if (yellowfin_debug > 0) {
1268 netdev_printk(KERN_DEBUG, dev, "Received %d frames that we should not have\n",
1269 bogus_rx);
1270 }
1271#endif
1272
1273 return 0;
1274}
1275
1276/* Set or clear the multicast filter for this adaptor. */
1277
1278static void set_rx_mode(struct net_device *dev)
1279{
1280 struct yellowfin_private *yp = netdev_priv(dev);
1281 void __iomem *ioaddr = yp->base;
1282 u16 cfg_value = ioread16(ioaddr + Cnfg);
1283
1284 /* Stop the Rx process to change any value. */
1285 iowrite16(cfg_value & ~0x1000, ioaddr + Cnfg);
1286 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
1287 iowrite16(0x000F, ioaddr + AddrMode);
1288 } else if ((netdev_mc_count(dev) > 64) ||
1289 (dev->flags & IFF_ALLMULTI)) {
1290 /* Too many to filter well, or accept all multicasts. */
1291 iowrite16(0x000B, ioaddr + AddrMode);
1292 } else if (!netdev_mc_empty(dev)) { /* Must use the multicast hash table. */
1293 struct netdev_hw_addr *ha;
1294 u16 hash_table[4];
1295 int i;
1296
1297 memset(hash_table, 0, sizeof(hash_table));
1298 netdev_for_each_mc_addr(ha, dev) {
1299 unsigned int bit;
1300
1301 /* Due to a bug in the early chip versions, multiple filter
1302 slots must be set for each address. */
1303 if (yp->drv_flags & HasMulticastBug) {
1304 bit = (ether_crc_le(3, ha->addr) >> 3) & 0x3f;
1305 hash_table[bit >> 4] |= (1 << bit);
1306 bit = (ether_crc_le(4, ha->addr) >> 3) & 0x3f;
1307 hash_table[bit >> 4] |= (1 << bit);
1308 bit = (ether_crc_le(5, ha->addr) >> 3) & 0x3f;
1309 hash_table[bit >> 4] |= (1 << bit);
1310 }
1311 bit = (ether_crc_le(6, ha->addr) >> 3) & 0x3f;
1312 hash_table[bit >> 4] |= (1 << bit);
1313 }
1314 /* Copy the hash table to the chip. */
1315 for (i = 0; i < 4; i++)
1316 iowrite16(hash_table[i], ioaddr + HashTbl + i*2);
1317 iowrite16(0x0003, ioaddr + AddrMode);
1318 } else { /* Normal, unicast/broadcast-only mode. */
1319 iowrite16(0x0001, ioaddr + AddrMode);
1320 }
1321 /* Restart the Rx process. */
1322 iowrite16(cfg_value | 0x1000, ioaddr + Cnfg);
1323}
1324
1325static void yellowfin_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1326{
1327 struct yellowfin_private *np = netdev_priv(dev);
1328
1329 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1330 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1331 strlcpy(info->bus_info, pci_name(np->pci_dev), sizeof(info->bus_info));
1332}
1333
1334static const struct ethtool_ops ethtool_ops = {
1335 .get_drvinfo = yellowfin_get_drvinfo
1336};
1337
1338static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1339{
1340 struct yellowfin_private *np = netdev_priv(dev);
1341 void __iomem *ioaddr = np->base;
1342 struct mii_ioctl_data *data = if_mii(rq);
1343
1344 switch(cmd) {
1345 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
1346 data->phy_id = np->phys[0] & 0x1f;
1347 /* Fall Through */
1348
1349 case SIOCGMIIREG: /* Read MII PHY register. */
1350 data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f, data->reg_num & 0x1f);
1351 return 0;
1352
1353 case SIOCSMIIREG: /* Write MII PHY register. */
1354 if (data->phy_id == np->phys[0]) {
1355 u16 value = data->val_in;
1356 switch (data->reg_num) {
1357 case 0:
1358 /* Check for autonegotiation on or reset. */
1359 np->medialock = (value & 0x9000) ? 0 : 1;
1360 if (np->medialock)
1361 np->full_duplex = (value & 0x0100) ? 1 : 0;
1362 break;
1363 case 4: np->advertising = value; break;
1364 }
1365 /* Perhaps check_duplex(dev), depending on chip semantics. */
1366 }
1367 mdio_write(ioaddr, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1368 return 0;
1369 default:
1370 return -EOPNOTSUPP;
1371 }
1372}
1373
1374
1375static void yellowfin_remove_one(struct pci_dev *pdev)
1376{
1377 struct net_device *dev = pci_get_drvdata(pdev);
1378 struct yellowfin_private *np;
1379
1380 BUG_ON(!dev);
1381 np = netdev_priv(dev);
1382
1383 pci_free_consistent(pdev, STATUS_TOTAL_SIZE, np->tx_status,
1384 np->tx_status_dma);
1385 pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma);
1386 pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma);
1387 unregister_netdev (dev);
1388
1389 pci_iounmap(pdev, np->base);
1390
1391 pci_release_regions (pdev);
1392
1393 free_netdev (dev);
1394}
1395
1396
1397static struct pci_driver yellowfin_driver = {
1398 .name = DRV_NAME,
1399 .id_table = yellowfin_pci_tbl,
1400 .probe = yellowfin_init_one,
1401 .remove = yellowfin_remove_one,
1402};
1403
1404
1405static int __init yellowfin_init (void)
1406{
1407/* when a module, this is printed whether or not devices are found in probe */
1408#ifdef MODULE
1409 printk(version);
1410#endif
1411 return pci_register_driver(&yellowfin_driver);
1412}
1413
1414
1415static void __exit yellowfin_cleanup (void)
1416{
1417 pci_unregister_driver (&yellowfin_driver);
1418}
1419
1420
1421module_init(yellowfin_init);
1422module_exit(yellowfin_cleanup);