5.4.1 updates, driver patch updates
[etherboot.git] / src / drivers / net / r8169.c
1 /**************************************************************************
2 *    r8169.c: Etherboot device driver for the RealTek RTL-8169 Gigabit
3 *    Written 2003 by Timothy Legge <tlegge@rogers.com>
4 *
5 *    This program is free software; you can redistribute it and/or modify
6 *    it under the terms of the GNU General Public License as published by
7 *    the Free Software Foundation; either version 2 of the License, or
8 *    (at your option) any later version.
9 *
10 *    This program is distributed in the hope that it will be useful,
11 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
12 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 *    GNU General Public License for more details.
14 *
15 *    You should have received a copy of the GNU General Public License
16 *    along with this program; if not, write to the Free Software
17 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 *
19 *    Portions of this code based on:
20 *       r8169.c: A RealTek RTL-8169 Gigabit Ethernet driver 
21 *               for Linux kernel 2.4.x.
22 *
23 *    Written 2002 ShuChen <shuchen@realtek.com.tw>
24 *         See Linux Driver for full information
25 *       
26 *    Linux Driver Version 1.27a, 10.02.2002
27
28 *    Thanks to:
29 *       Jean Chen of RealTek Semiconductor Corp. for
30 *       providing the evaluation NIC used to develop 
31 *       this driver.  RealTek's support for Etherboot 
32 *       is appreciated.
33 *       
34 *    REVISION HISTORY:
35 *    ================
36 *
37 *    v1.0       11-26-2003      timlegge        Initial port of Linux driver
38 *    v1.5       01-17-2004      timlegge        Initial driver output cleanup
39 *    v1.6       03-27-2004      timlegge        Additional Cleanup
40 *    
41 *    Indent Options: indent -kr -i8
42 ***************************************************************************/
43
44 /* to get some global routines like printf */
45 #include "etherboot.h"
46 /* to get the interface to the body of the program */
47 #include "nic.h"
48 /* to get the PCI support functions, if this is a PCI NIC */
49 #include "pci.h"
50 #include "timer.h"
51
52 #define drv_version "v1.6"
53 #define drv_date "03-27-2004"
54
55 #define HZ 1000
56
57 static u32 ioaddr;
58
59 #ifdef EDEBUG
60 #define dprintf(x) printf x
61 #else
62 #define dprintf(x)
63 #endif
64
65 /* Condensed operations for readability. */
66 #define virt_to_le32desc(addr)  cpu_to_le32(virt_to_bus(addr))
67 #define le32desc_to_virt(addr)  bus_to_virt(le32_to_cpu(addr))
68
69 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
70
71 /* media options 
72         _10_Half = 0x01,
73         _10_Full = 0x02,
74         _100_Half = 0x04,
75         _100_Full = 0x08,
76         _1000_Full = 0x10,
77 */
78 static int media = -1;
79
80 #if 0
81 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
82 static int max_interrupt_work = 20;
83 #endif
84
85 #if 0
86 /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
87    The RTL chips use a 64 element hash table based on the Ethernet CRC.  */
88 static int multicast_filter_limit = 32;
89 #endif
90
91 /* MAC address length*/
92 #define MAC_ADDR_LEN    6
93
94 /* max supported gigabit ethernet frame size -- must be at least (dev->mtu+14+4).*/
95 #define MAX_ETH_FRAME_SIZE      1536
96
97 #define TX_FIFO_THRESH 256      /* In bytes */
98
99 #define RX_FIFO_THRESH  7       /* 7 means NO threshold, Rx buffer level before first PCI xfer.  */
100 #define RX_DMA_BURST    6       /* Maximum PCI burst, '6' is 1024 */
101 #define TX_DMA_BURST    6       /* Maximum PCI burst, '6' is 1024 */
102 #define EarlyTxThld     0x3F    /* 0x3F means NO early transmit */
103 #define RxPacketMaxSize 0x0800  /* Maximum size supported is 16K-1 */
104 #define InterFrameGap   0x03    /* 3 means InterFrameGap = the shortest one */
105
106 #define NUM_TX_DESC     1       /* Number of Tx descriptor registers */
107 #define NUM_RX_DESC     4       /* Number of Rx descriptor registers */
108 #define RX_BUF_SIZE     1536    /* Rx Buffer size */
109
110 #define RTL_MIN_IO_SIZE 0x80
111 #define TX_TIMEOUT  (6*HZ)
112
113 /* write/read MMIO register */
114 #define RTL_W8(reg, val8)       writeb ((val8), ioaddr + (reg))
115 #define RTL_W16(reg, val16)     writew ((val16), ioaddr + (reg))
116 #define RTL_W32(reg, val32)     writel ((val32), ioaddr + (reg))
117 #define RTL_R8(reg)             readb (ioaddr + (reg))
118 #define RTL_R16(reg)            readw (ioaddr + (reg))
119 #define RTL_R32(reg)            ((unsigned long) readl (ioaddr + (reg)))
120
121 enum RTL8169_registers {
122         MAC0 = 0,               /* Ethernet hardware address. */
123         MAR0 = 8,               /* Multicast filter. */
124         TxDescStartAddr = 0x20,
125         TxHDescStartAddr = 0x28,
126         FLASH = 0x30,
127         ERSR = 0x36,
128         ChipCmd = 0x37,
129         TxPoll = 0x38,
130         IntrMask = 0x3C,
131         IntrStatus = 0x3E,
132         TxConfig = 0x40,
133         RxConfig = 0x44,
134         RxMissed = 0x4C,
135         Cfg9346 = 0x50,
136         Config0 = 0x51,
137         Config1 = 0x52,
138         Config2 = 0x53,
139         Config3 = 0x54,
140         Config4 = 0x55,
141         Config5 = 0x56,
142         MultiIntr = 0x5C,
143         PHYAR = 0x60,
144         TBICSR = 0x64,
145         TBI_ANAR = 0x68,
146         TBI_LPAR = 0x6A,
147         PHYstatus = 0x6C,
148         RxMaxSize = 0xDA,
149         CPlusCmd = 0xE0,
150         RxDescStartAddr = 0xE4,
151         EarlyTxThres = 0xEC,
152         FuncEvent = 0xF0,
153         FuncEventMask = 0xF4,
154         FuncPresetState = 0xF8,
155         FuncForceEvent = 0xFC,
156 };
157
158 enum RTL8169_register_content {
159         /*InterruptStatusBits */
160         SYSErr = 0x8000,
161         PCSTimeout = 0x4000,
162         SWInt = 0x0100,
163         TxDescUnavail = 0x80,
164         RxFIFOOver = 0x40,
165         RxUnderrun = 0x20,
166         RxOverflow = 0x10,
167         TxErr = 0x08,
168         TxOK = 0x04,
169         RxErr = 0x02,
170         RxOK = 0x01,
171
172         /*RxStatusDesc */
173         RxRES = 0x00200000,
174         RxCRC = 0x00080000,
175         RxRUNT = 0x00100000,
176         RxRWT = 0x00400000,
177
178         /*ChipCmdBits */
179         CmdReset = 0x10,
180         CmdRxEnb = 0x08,
181         CmdTxEnb = 0x04,
182         RxBufEmpty = 0x01,
183
184         /*Cfg9346Bits */
185         Cfg9346_Lock = 0x00,
186         Cfg9346_Unlock = 0xC0,
187
188         /*rx_mode_bits */
189         AcceptErr = 0x20,
190         AcceptRunt = 0x10,
191         AcceptBroadcast = 0x08,
192         AcceptMulticast = 0x04,
193         AcceptMyPhys = 0x02,
194         AcceptAllPhys = 0x01,
195
196         /*RxConfigBits */
197         RxCfgFIFOShift = 13,
198         RxCfgDMAShift = 8,
199
200         /*TxConfigBits */
201         TxInterFrameGapShift = 24,
202         TxDMAShift = 8,         /* DMA burst value (0-7) is shift this many bits */
203
204         /*rtl8169_PHYstatus */
205         TBI_Enable = 0x80,
206         TxFlowCtrl = 0x40,
207         RxFlowCtrl = 0x20,
208         _1000bpsF = 0x10,
209         _100bps = 0x08,
210         _10bps = 0x04,
211         LinkStatus = 0x02,
212         FullDup = 0x01,
213
214         /*GIGABIT_PHY_registers */
215         PHY_CTRL_REG = 0,
216         PHY_STAT_REG = 1,
217         PHY_AUTO_NEGO_REG = 4,
218         PHY_1000_CTRL_REG = 9,
219
220         /*GIGABIT_PHY_REG_BIT */
221         PHY_Restart_Auto_Nego = 0x0200,
222         PHY_Enable_Auto_Nego = 0x1000,
223
224         /* PHY_STAT_REG = 1; */
225         PHY_Auto_Neco_Comp = 0x0020,
226
227         /* PHY_AUTO_NEGO_REG = 4; */
228         PHY_Cap_10_Half = 0x0020,
229         PHY_Cap_10_Full = 0x0040,
230         PHY_Cap_100_Half = 0x0080,
231         PHY_Cap_100_Full = 0x0100,
232
233         /* PHY_1000_CTRL_REG = 9; */
234         PHY_Cap_1000_Full = 0x0200,
235
236         PHY_Cap_Null = 0x0,
237
238         /*_MediaType*/
239         _10_Half = 0x01,
240         _10_Full = 0x02,
241         _100_Half = 0x04,
242         _100_Full = 0x08,
243         _1000_Full = 0x10,
244
245         /*_TBICSRBit*/
246         TBILinkOK = 0x02000000,
247 };
248
249 static struct {
250         const char *name;
251         u8 version;             /* depend on RTL8169 docs */
252         u32 RxConfigMask;       /* should clear the bits supported by this chip */
253 } rtl_chip_info[] = {
254         {
255 "RTL-8169", 0x00, 0xff7e1880,},};
256
257 enum _DescStatusBit {
258         OWNbit = 0x80000000,
259         EORbit = 0x40000000,
260         FSbit = 0x20000000,
261         LSbit = 0x10000000,
262 };
263
264 struct TxDesc {
265         u32 status;
266         u32 vlan_tag;
267         u32 buf_addr;
268         u32 buf_Haddr;
269 };
270
271 struct RxDesc {
272         u32 status;
273         u32 vlan_tag;
274         u32 buf_addr;
275         u32 buf_Haddr;
276 };
277
278 /* The descriptors for this card are required to be aligned on
279 256 byte boundaries.  As the align attribute does not do more than
280 16 bytes of alignment it requires some extra steps.  Add 256 to the 
281 size of the array and the init_ring adjusts the alignment */
282
283 /* Define the TX Descriptor */
284 static u8 tx_ring[NUM_TX_DESC * sizeof(struct TxDesc) + 256];
285
286 /* Create a static buffer of size RX_BUF_SZ for each
287 TX Descriptor.  All descriptors point to a
288 part of this buffer */
289 static unsigned char txb[NUM_TX_DESC * RX_BUF_SIZE];
290
291 /* Define the RX Descriptor */
292 static u8 rx_ring[NUM_RX_DESC * sizeof(struct TxDesc) + 256];
293
294 /* Create a static buffer of size RX_BUF_SZ for each
295 RX Descriptor   All descriptors point to a
296 part of this buffer */
297 static unsigned char rxb[NUM_RX_DESC * RX_BUF_SIZE];
298
299 struct rtl8169_private {
300         void *mmio_addr;        /* memory map physical address */
301         int chipset;
302         unsigned long cur_rx;   /* Index into the Rx descriptor buffer of next Rx pkt. */
303         unsigned long cur_tx;   /* Index into the Tx descriptor buffer of next Rx pkt. */
304         unsigned char *TxDescArrays;    /* Index of Tx Descriptor buffer */
305         unsigned char *RxDescArrays;    /* Index of Rx Descriptor buffer */
306         struct TxDesc *TxDescArray;     /* Index of 256-alignment Tx Descriptor buffer */
307         struct RxDesc *RxDescArray;     /* Index of 256-alignment Rx Descriptor buffer */
308         unsigned char *RxBufferRing[NUM_RX_DESC];       /* Index of Rx Buffer array */
309         unsigned char *Tx_skbuff[NUM_TX_DESC];
310 } tpx;
311
312 static struct rtl8169_private *tpc;
313
314 static const u16 rtl8169_intr_mask =
315     SYSErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver | TxErr |
316     TxOK | RxErr | RxOK;
317 static const unsigned int rtl8169_rx_config =
318     (RX_FIFO_THRESH << RxCfgFIFOShift) | (RX_DMA_BURST << RxCfgDMAShift);
319
320 void mdio_write(int RegAddr, int value)
321 {
322         int i;
323
324         RTL_W32(PHYAR, 0x80000000 | (RegAddr & 0xFF) << 16 | value);
325         udelay(1000);
326
327         for (i = 2000; i > 0; i--) {
328                 /* Check if the RTL8169 has completed writing to the specified MII register */
329                 if (!(RTL_R32(PHYAR) & 0x80000000)) {
330                         break;
331                 } else {
332                         udelay(100);
333                 }
334         }
335 }
336
337 int mdio_read(int RegAddr)
338 {
339         int i, value = -1;
340
341         RTL_W32(PHYAR, 0x0 | (RegAddr & 0xFF) << 16);
342         udelay(1000);
343
344         for (i = 2000; i > 0; i--) {
345                 /* Check if the RTL8169 has completed retrieving data from the specified MII register */
346                 if (RTL_R32(PHYAR) & 0x80000000) {
347                         value = (int) (RTL_R32(PHYAR) & 0xFFFF);
348                         break;
349                 } else {
350                         udelay(100);
351                 }
352         }
353         return value;
354 }
355
356 static int rtl8169_init_board(struct pci_device *pdev)
357 {
358         int i;
359         unsigned long rtreg_base, rtreg_len;
360         u32 tmp;
361
362         rtreg_base = pci_bar_start(pdev, PCI_BASE_ADDRESS_1);
363         rtreg_len = pci_bar_size(pdev, PCI_BASE_ADDRESS_1);
364
365         /* check for weird/broken PCI region reporting */
366         if (rtreg_len < RTL_MIN_IO_SIZE) {
367                 printf("Invalid PCI region size(s), aborting\n");
368         }
369
370         adjust_pci_device(pdev);
371 /*      pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM); */
372
373         /* ioremap MMIO region */
374         ioaddr = (unsigned long) ioremap(rtreg_base, rtreg_len);
375         if (ioaddr == 0)
376                 return 0;
377
378         tpc->mmio_addr = &ioaddr;
379         /* Soft reset the chip. */
380         RTL_W8(ChipCmd, CmdReset);
381
382         /* Check that the chip has finished the reset. */
383         for (i = 1000; i > 0; i--)
384                 if ((RTL_R8(ChipCmd) & CmdReset) == 0)
385                         break;
386                 else
387                         udelay(10);
388
389         /* identify chip attached to board */
390         tmp = RTL_R32(TxConfig);
391         tmp = ((tmp & 0x7c000000) + ((tmp & 0x00800000) << 2)) >> 24;
392
393         for (i = ARRAY_SIZE(rtl_chip_info) - 1; i >= 0; i--)
394                 if (tmp == rtl_chip_info[i].version) {
395                         tpc->chipset = i;
396                         goto match;
397                 }
398         /* if unknown chip, assume array element #0, original RTL-8169 in this case */
399         dprintf(("PCI device: unknown chip version, assuming RTL-8169\n"));
400         dprintf(("PCI device: TxConfig = 0x%hX\n",
401                  (unsigned long) RTL_R32(TxConfig)));
402         tpc->chipset = 0;
403         return 1;
404       match:
405         return 0;
406
407 }
408
409 /**************************************************************************
410 IRQ - Wait for a frame
411 ***************************************************************************/
412 void r8169_irq ( struct nic *nic __unused, irq_action_t action ) {
413         int intr_status = 0;
414         int interested = RxUnderrun | RxOverflow | RxFIFOOver | RxErr | RxOK;
415  
416         switch ( action ) {
417                 case DISABLE:
418                 case ENABLE:
419                         intr_status = RTL_R16(IntrStatus);
420                         /* h/w no longer present (hotplug?) or major error, 
421                                 bail */
422                         if (intr_status == 0xFFFF)
423                                 break;
424
425                         intr_status = intr_status & ~interested;
426                         if ( action == ENABLE )
427                                 intr_status = intr_status | interested;
428                         RTL_W16(IntrMask, intr_status);
429                         break;
430                 case FORCE :
431                         RTL_W8(TxPoll, (RTL_R8(TxPoll) | 0x01));
432                         break;
433         }
434 }
435
436 /**************************************************************************
437 POLL - Wait for a frame
438 ***************************************************************************/
439 static int r8169_poll(struct nic *nic, int retreive)
440 {
441         /* return true if there's an ethernet packet ready to read */
442         /* nic->packet should contain data on return */
443         /* nic->packetlen should contain length of data */
444         int cur_rx;
445         unsigned int intr_status = 0;
446         cur_rx = tpc->cur_rx;
447         if ((tpc->RxDescArray[cur_rx].status & OWNbit) == 0) {
448                  /* There is a packet ready */
449                  if(!retreive)
450                          return 1;
451                 intr_status = RTL_R16(IntrStatus);
452                 /* h/w no longer present (hotplug?) or major error,
453                         bail */
454                 if (intr_status == 0xFFFF)
455                         return 0;
456                 RTL_W16(IntrStatus, intr_status & 
457                         ~(RxFIFOOver | RxOverflow | RxOK));
458
459                 if (!(tpc->RxDescArray[cur_rx].status & RxRES)) {
460                         nic->packetlen = (int) (tpc->RxDescArray[cur_rx].
461                                                 status & 0x00001FFF) - 4;
462                         memcpy(nic->packet, tpc->RxBufferRing[cur_rx],
463                                nic->packetlen);
464                         if (cur_rx == NUM_RX_DESC - 1)
465                                 tpc->RxDescArray[cur_rx].status =
466                                     (OWNbit | EORbit) + RX_BUF_SIZE;
467                         else
468                                 tpc->RxDescArray[cur_rx].status =
469                                     OWNbit + RX_BUF_SIZE;
470                         tpc->RxDescArray[cur_rx].buf_addr =
471                             virt_to_bus(tpc->RxBufferRing[cur_rx]);
472                 } else
473                         printf("Error Rx");
474                 /* FIXME: shouldn't I reset the status on an error */
475                 cur_rx = (cur_rx + 1) % NUM_RX_DESC;
476                 tpc->cur_rx = cur_rx;
477                 RTL_W16(IntrStatus, intr_status & 
478                         (RxFIFOOver | RxOverflow | RxOK));
479
480                 return 1;
481
482         }
483         tpc->cur_rx = cur_rx;
484         /* FIXME: There is no reason to do this as cur_rx did not change */
485
486         return (0);             /* initially as this is called to flush the input */
487
488 }
489
490 /**************************************************************************
491 TRANSMIT - Transmit a frame
492 ***************************************************************************/
493 static void r8169_transmit(struct nic *nic, const char *d,      /* Destination */
494                            unsigned int t,      /* Type */
495                            unsigned int s,      /* size */
496                            const char *p)
497 {                               /* Packet */
498         /* send the packet to destination */
499
500         u16 nstype;
501         u32 to;
502         u8 *ptxb;
503         int entry = tpc->cur_tx % NUM_TX_DESC;
504
505         /* point to the current txb incase multiple tx_rings are used */
506         ptxb = tpc->Tx_skbuff[entry * MAX_ETH_FRAME_SIZE];
507         memcpy(ptxb, d, ETH_ALEN);
508         memcpy(ptxb + ETH_ALEN, nic->node_addr, ETH_ALEN);
509         nstype = htons((u16) t);
510         memcpy(ptxb + 2 * ETH_ALEN, (u8 *) & nstype, 2);
511         memcpy(ptxb + ETH_HLEN, p, s);
512         s += ETH_HLEN;
513         s &= 0x0FFF;
514         while (s < ETH_ZLEN)
515                 ptxb[s++] = '\0';
516
517         tpc->TxDescArray[entry].buf_addr = virt_to_bus(ptxb);
518         if (entry != (NUM_TX_DESC - 1))
519                 tpc->TxDescArray[entry].status =
520                     (OWNbit | FSbit | LSbit) | ((s > ETH_ZLEN) ? s :
521                                                 ETH_ZLEN);
522         else
523                 tpc->TxDescArray[entry].status =
524                     (OWNbit | EORbit | FSbit | LSbit) | ((s > ETH_ZLEN) ? s
525                                                          : ETH_ZLEN);
526         RTL_W8(TxPoll, 0x40);   /* set polling bit */
527
528         tpc->cur_tx++;
529         to = currticks() + TX_TIMEOUT;
530         while ((tpc->TxDescArray[entry].status & OWNbit) && (currticks() < to));        /* wait */
531
532         if (currticks() >= to) {
533                 printf("TX Time Out");
534         }
535 }
536
537 static void rtl8169_set_rx_mode(struct nic *nic __unused)
538 {
539         u32 mc_filter[2];       /* Multicast hash filter */
540         int rx_mode;
541         u32 tmp = 0;
542
543         /* IFF_ALLMULTI */
544         /* Too many to filter perfectly -- accept all multicasts. */
545         rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
546         mc_filter[1] = mc_filter[0] = 0xffffffff;
547
548         tmp =
549             rtl8169_rx_config | rx_mode | (RTL_R32(RxConfig) &
550                                            rtl_chip_info[tpc->chipset].
551                                            RxConfigMask);
552
553         RTL_W32(RxConfig, tmp);
554         RTL_W32(MAR0 + 0, mc_filter[0]);
555         RTL_W32(MAR0 + 4, mc_filter[1]);
556 }
557 static void rtl8169_hw_start(struct nic *nic)
558 {
559         u32 i;
560
561         /* Soft reset the chip. */
562         RTL_W8(ChipCmd, CmdReset);
563
564         /* Check that the chip has finished the reset. */
565         for (i = 1000; i > 0; i--) {
566                 if ((RTL_R8(ChipCmd) & CmdReset) == 0)
567                         break;
568                 else
569                         udelay(10);
570         }
571
572         RTL_W8(Cfg9346, Cfg9346_Unlock);
573         RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
574         RTL_W8(EarlyTxThres, EarlyTxThld);
575
576         /* For gigabit rtl8169 */
577         RTL_W16(RxMaxSize, RxPacketMaxSize);
578
579         /* Set Rx Config register */
580         i = rtl8169_rx_config | (RTL_R32(RxConfig) &
581                                  rtl_chip_info[tpc->chipset].RxConfigMask);
582         RTL_W32(RxConfig, i);
583
584         /* Set DMA burst size and Interframe Gap Time */
585         RTL_W32(TxConfig,
586                 (TX_DMA_BURST << TxDMAShift) | (InterFrameGap <<
587                                                 TxInterFrameGapShift));
588
589
590         tpc->cur_rx = 0;
591
592         RTL_W32(TxDescStartAddr, virt_to_le32desc(tpc->TxDescArray));
593         RTL_W32(RxDescStartAddr, virt_to_le32desc(tpc->RxDescArray));
594         RTL_W8(Cfg9346, Cfg9346_Lock);
595         udelay(10);
596
597         RTL_W32(RxMissed, 0);
598
599         rtl8169_set_rx_mode(nic);
600
601         /* no early-rx interrupts */
602         RTL_W16(MultiIntr, RTL_R16(MultiIntr) & 0xF000);
603 }
604
605 static void rtl8169_init_ring(struct nic *nic __unused)
606 {
607         int i;
608
609         tpc->cur_rx = 0;
610         tpc->cur_tx = 0;
611         memset(tpc->TxDescArray, 0x0, NUM_TX_DESC * sizeof(struct TxDesc));
612         memset(tpc->RxDescArray, 0x0, NUM_RX_DESC * sizeof(struct RxDesc));
613
614         for (i = 0; i < NUM_TX_DESC; i++) {
615                 tpc->Tx_skbuff[i] = &txb[i];
616         }
617
618         for (i = 0; i < NUM_RX_DESC; i++) {
619                 if (i == (NUM_RX_DESC - 1))
620                         tpc->RxDescArray[i].status =
621                             (OWNbit | EORbit) + RX_BUF_SIZE;
622                 else
623                         tpc->RxDescArray[i].status = OWNbit + RX_BUF_SIZE;
624
625                 tpc->RxBufferRing[i] = &rxb[i * RX_BUF_SIZE];
626                 tpc->RxDescArray[i].buf_addr =
627                     virt_to_bus(tpc->RxBufferRing[i]);
628         }
629 }
630
631 /**************************************************************************
632 RESET - Finish setting up the ethernet interface
633 ***************************************************************************/
634 static void r8169_reset(struct nic *nic)
635 {
636         int i;
637         u8 diff;
638         u32 TxPhyAddr, RxPhyAddr;
639
640         tpc->TxDescArrays = tx_ring;
641         if (tpc->TxDescArrays == 0)
642                 printf("Allot Error");
643         /* Tx Desscriptor needs 256 bytes alignment; */
644         TxPhyAddr = virt_to_bus(tpc->TxDescArrays);
645         diff = 256 - (TxPhyAddr - ((TxPhyAddr >> 8) << 8));
646         TxPhyAddr += diff;
647         tpc->TxDescArray = (struct TxDesc *) (tpc->TxDescArrays + diff);
648
649         tpc->RxDescArrays = rx_ring;
650         /* Rx Desscriptor needs 256 bytes alignment; */
651         RxPhyAddr = virt_to_bus(tpc->RxDescArrays);
652         diff = 256 - (RxPhyAddr - ((RxPhyAddr >> 8) << 8));
653         RxPhyAddr += diff;
654         tpc->RxDescArray = (struct RxDesc *) (tpc->RxDescArrays + diff);
655
656         if (tpc->TxDescArrays == NULL || tpc->RxDescArrays == NULL) {
657                 printf("Allocate RxDescArray or TxDescArray failed\n");
658                 return;
659         }
660
661         rtl8169_init_ring(nic);
662         rtl8169_hw_start(nic);
663         /* Construct a perfect filter frame with the mac address as first match
664          * and broadcast for all others */
665         for (i = 0; i < 192; i++)
666                 txb[i] = 0xFF;
667
668         txb[0] = nic->node_addr[0];
669         txb[1] = nic->node_addr[1];
670         txb[2] = nic->node_addr[2];
671         txb[3] = nic->node_addr[3];
672         txb[4] = nic->node_addr[4];
673         txb[5] = nic->node_addr[5];
674 }
675
676 /**************************************************************************
677 DISABLE - Turn off ethernet interface
678 ***************************************************************************/
679 static void r8169_disable(struct dev *dev __unused)
680 {
681         int i;
682         /* Stop the chip's Tx and Rx DMA processes. */
683         RTL_W8(ChipCmd, 0x00);
684
685         /* Disable interrupts by clearing the interrupt mask. */
686         RTL_W16(IntrMask, 0x0000);
687
688         RTL_W32(RxMissed, 0);
689
690         tpc->TxDescArrays = NULL;
691         tpc->RxDescArrays = NULL;
692         tpc->TxDescArray = NULL;
693         tpc->RxDescArray = NULL;
694         for (i = 0; i < NUM_RX_DESC; i++) {
695                 tpc->RxBufferRing[i] = NULL;
696         }
697 }
698
699 /**************************************************************************
700 PROBE - Look for an adapter, this routine's visible to the outside
701 ***************************************************************************/
702
703 #define board_found 1
704 #define valid_link 0
705 static int r8169_probe(struct dev *dev, struct pci_device *pci)
706 {
707         struct nic *nic = (struct nic *) dev;
708         static int board_idx = -1;
709         static int printed_version = 0;
710         int i, rc;
711         int option = -1, Cap10_100 = 0, Cap1000 = 0;
712
713         printf("r8169.c: Found %s, Vendor=%hX Device=%hX\n",
714                pci->name, pci->vendor, pci->dev_id);
715
716         board_idx++;
717
718         printed_version = 1;
719
720         /* point to private storage */
721         tpc = &tpx;
722
723         rc = rtl8169_init_board(pci);   /* Return code is meaningless */
724
725         /* Get MAC address.  FIXME: read EEPROM */
726         for (i = 0; i < MAC_ADDR_LEN; i++)
727                 nic->node_addr[i] = RTL_R8(MAC0 + i);
728
729         dprintf(("%s: Identified chip type is '%s'.\n", pci->name,
730                  rtl_chip_info[tpc->chipset].name));
731         /* Print out some hardware info */
732         printf("%s: %! at ioaddr %hX, ", pci->name, nic->node_addr,
733                ioaddr);
734
735         /* if TBI is not endbled */
736         if (!(RTL_R8(PHYstatus) & TBI_Enable)) {
737                 int val = mdio_read(PHY_AUTO_NEGO_REG);
738
739                 option = media;
740                 /* Force RTL8169 in 10/100/1000 Full/Half mode. */
741                 if (option > 0) {
742                         printf(" Force-mode Enabled.\n");
743                         Cap10_100 = 0, Cap1000 = 0;
744                         switch (option) {
745                         case _10_Half:
746                                 Cap10_100 = PHY_Cap_10_Half;
747                                 Cap1000 = PHY_Cap_Null;
748                                 break;
749                         case _10_Full:
750                                 Cap10_100 = PHY_Cap_10_Full;
751                                 Cap1000 = PHY_Cap_Null;
752                                 break;
753                         case _100_Half:
754                                 Cap10_100 = PHY_Cap_100_Half;
755                                 Cap1000 = PHY_Cap_Null;
756                                 break;
757                         case _100_Full:
758                                 Cap10_100 = PHY_Cap_100_Full;
759                                 Cap1000 = PHY_Cap_Null;
760                                 break;
761                         case _1000_Full:
762                                 Cap10_100 = PHY_Cap_Null;
763                                 Cap1000 = PHY_Cap_1000_Full;
764                                 break;
765                         default:
766                                 break;
767                         }
768                         /* leave PHY_AUTO_NEGO_REG bit4:0 unchanged */
769                         mdio_write(PHY_AUTO_NEGO_REG,
770                                    Cap10_100 | (val & 0x1F));
771                         mdio_write(PHY_1000_CTRL_REG, Cap1000);
772                 } else {
773                         dprintf(("Auto-negotiation Enabled.\n",
774                                  pci->name));
775
776                         /* enable 10/100 Full/Half Mode, leave PHY_AUTO_NEGO_REG bit4:0 unchanged */
777                         mdio_write(PHY_AUTO_NEGO_REG,
778                                    PHY_Cap_10_Half | PHY_Cap_10_Full |
779                                    PHY_Cap_100_Half | PHY_Cap_100_Full |
780                                    (val & 0x1F));
781
782                         /* enable 1000 Full Mode */
783                         mdio_write(PHY_1000_CTRL_REG, PHY_Cap_1000_Full);
784
785                 }
786
787                 /* Enable auto-negotiation and restart auto-nigotiation */
788                 mdio_write(PHY_CTRL_REG,
789                            PHY_Enable_Auto_Nego | PHY_Restart_Auto_Nego);
790                 udelay(100);
791
792                 /* wait for auto-negotiation process */
793                 for (i = 10000; i > 0; i--) {
794                         /* Check if auto-negotiation complete */
795                         if (mdio_read(PHY_STAT_REG) & PHY_Auto_Neco_Comp) {
796                                 udelay(100);
797                                 option = RTL_R8(PHYstatus);
798                                 if (option & _1000bpsF) {
799                                         printf
800                                             ("1000Mbps Full-duplex operation.\n");
801                                 } else {
802                                         printf
803                                             ("%sMbps %s-duplex operation.\n",
804                                              (option & _100bps) ? "100" :
805                                              "10",
806                                              (option & FullDup) ? "Full" :
807                                              "Half");
808                                 }
809                                 break;
810                         } else {
811                                 udelay(100);
812                         }
813                 }               /* end for-loop to wait for auto-negotiation process */
814
815         } else {
816                 udelay(100);
817                 printf
818                     ("%s: 1000Mbps Full-duplex operation, TBI Link %s!\n",
819                      pci->name,
820                      (RTL_R32(TBICSR) & TBILinkOK) ? "OK" : "Failed");
821
822         }
823
824         r8169_reset(nic);
825         /* point to NIC specific routines */
826         dev->disable = r8169_disable;
827         nic->poll = r8169_poll;
828         nic->transmit = r8169_transmit;
829         nic->irqno = pci->irq;
830         nic->irq = r8169_irq;
831         nic->ioaddr = ioaddr;
832         return 1;
833
834 }
835
836 static struct pci_id r8169_nics[] = {
837         PCI_ROM(0x10ec, 0x8169, "r8169", "RealTek RTL8169 Gigabit Ethernet"),
838         PCI_ROM(0x16ec, 0x0116, "usr-r8169", "US Robotics RTL8169 Gigabit Ethernet"),
839         PCI_ROM(0x1186, 0x4300, "dlink-r8169", "D-Link RTL8169 Gigabit Ethernet"),
840 };
841
842 static struct pci_driver r8169_driver __pci_driver = {
843         .type = NIC_DRIVER,
844         .name = "r8169/PCI",
845         .probe = r8169_probe,
846         .ids = r8169_nics,
847         .id_count = sizeof(r8169_nics) / sizeof(r8169_nics[0]),
848         .class = 0,
849 };