2 * Realtek RTL8110S/8169S Gigabit Ethernet Controllers.
3 * Mostly there. There are some magic register values used
4 * which are not described in any datasheet or driver but seem
6 * No tuning has been done. Only tested on an RTL8110S, there
7 * are slight differences between the chips in the series so some
8 * tweaks may be needed.
11 #include "../port/lib.h"
16 #include "../port/pci.h"
17 #include "../port/error.h"
18 #include "../port/netif.h"
19 #include "../port/etherif.h"
20 #include "../port/ethermii.h"
22 enum { /* registers */
23 Idr0 = 0x00, /* MAC address */
24 Mar0 = 0x08, /* Multicast address */
25 Dtccr = 0x10, /* Dump Tally Counter Command */
26 Tnpds = 0x20, /* Transmit Normal Priority Descriptors */
27 Thpds = 0x28, /* Transmit High Priority Descriptors */
28 Flash = 0x30, /* Flash Memory Read/Write */
29 Erbcr = 0x34, /* Early Receive Byte Count */
30 Ersr = 0x36, /* Early Receive Status */
31 Cr = 0x37, /* Command Register */
32 Tppoll = 0x38, /* Transmit Priority Polling */
33 Imr = 0x3C, /* Interrupt Mask */
34 Isr = 0x3E, /* Interrupt Status */
35 Tcr = 0x40, /* Transmit Configuration */
36 Rcr = 0x44, /* Receive Configuration */
37 Tctr = 0x48, /* Timer Count */
38 Mpc = 0x4C, /* Missed Packet Counter */
39 Cr9346 = 0x50, /* 9346 Command Register */
40 Config0 = 0x51, /* Configuration Register 0 */
41 Config1 = 0x52, /* Configuration Register 1 */
42 Config2 = 0x53, /* Configuration Register 2 */
43 Config3 = 0x54, /* Configuration Register 3 */
44 Config4 = 0x55, /* Configuration Register 4 */
45 Config5 = 0x56, /* Configuration Register 5 */
46 Timerint = 0x58, /* Timer Interrupt */
47 Mulint = 0x5C, /* Multiple Interrupt Select */
48 Phyar = 0x60, /* PHY Access */
49 Tbicsr0 = 0x64, /* TBI Control and Status */
50 Tbianar = 0x68, /* TBI Auto-Negotiation Advertisment */
51 Tbilpar = 0x6A, /* TBI Auto-Negotiation Link Partner */
52 Phystatus = 0x6C, /* PHY Status */
53 Pmch = 0x6F, /* power management */
54 Ldps = 0x82, /* link down power saving */
56 Rms = 0xDA, /* Receive Packet Maximum Size */
57 Cplusc = 0xE0, /* C+ Command */
58 Coal = 0xE2, /* Interrupt Mitigation (Coalesce) */
59 Rdsar = 0xE4, /* Receive Descriptor Start Address */
60 Etx = 0xEC, /* Early Transmit Threshold */
64 Cmd = 0x00000008, /* Command */
68 Te = 0x04, /* Transmitter Enable */
69 Re = 0x08, /* Receiver Enable */
70 Rst = 0x10, /* Software Reset */
74 Fswint = 0x01, /* Forced Software Interrupt */
75 Npq = 0x40, /* Normal Priority Queue polling */
76 Hpq = 0x80, /* High Priority Queue polling */
80 Rok = 0x0001, /* Receive OK */
81 Rer = 0x0002, /* Receive Error */
82 Tok = 0x0004, /* Transmit OK */
83 Ter = 0x0008, /* Transmit Error */
84 Rdu = 0x0010, /* Receive Descriptor Unavailable */
85 Punlc = 0x0020, /* Packet Underrun or Link Change */
86 Fovw = 0x0040, /* Receive FIFO Overflow */
87 Tdu = 0x0080, /* Transmit Descriptor Unavailable */
88 Swint = 0x0100, /* Software Interrupt */
89 Timeout = 0x4000, /* Timer */
90 Serr = 0x8000, /* System Error */
94 MtxdmaSHIFT = 8, /* Max. DMA Burst Size */
95 MtxdmaMASK = 0x00000700,
96 Mtxdmaunlimited = 0x00000700,
97 Acrc = 0x00010000, /* Append CRC (not) */
98 Lbk0 = 0x00020000, /* Loopback Test 0 */
99 Lbk1 = 0x00040000, /* Loopback Test 1 */
100 Ifg2 = 0x00080000, /* Interframe Gap 2 */
101 HwveridSHIFT = 23, /* Hardware Version ID */
102 HwveridMASK = 0x7C800000,
103 Macv01 = 0x00000000, /* RTL8169 */
104 Macv02 = 0x00800000, /* RTL8169S/8110S */
105 Macv03 = 0x04000000, /* RTL8169S/8110S */
106 Macv04 = 0x10000000, /* RTL8169SB/8110SB */
107 Macv05 = 0x18000000, /* RTL8169SC/8110SC */
108 Macv07 = 0x24800000, /* RTL8102e */
109 Macv07a = 0x34800000, /* RTL8102e */
110 Macv11 = 0x30000000, /* RTL8168B/8111B */
111 Macv12 = 0x38000000, /* RTL8169B/8111B */
112 Macv12a = 0x3c000000, /* RTL8169C/8111C */
113 Macv13 = 0x34000000, /* RTL8101E */
114 Macv14 = 0x30800000, /* RTL8100E */
115 Macv15 = 0x38800000, /* RTL8100E */
116 // Macv19 = 0x3c000000, /* dup Macv12a: RTL8111c-gr */
117 Macv25 = 0x28000000, /* RTL8168D */
118 Macv26 = 0x48000000, /* RTL8111/8168B */
119 Macv27 = 0x2c800000, /* RTL8111e */
120 Macv28 = 0x2c000000, /* RTL8111/8168B */
121 Macv29 = 0x40800000, /* RTL8101/8102E */
122 Macv30 = 0x24000000, /* RTL8101E? (untested) */
123 Macv38 = 0x44000000, /* RTL8402 */
124 Macv39 = 0x44800000, /* RTL8106E */
125 Macv40 = 0x4c000000, /* RTL8168G */
126 Macv42 = 0x50800000, /* RTL8168GU */
127 Macv44 = 0x5c800000, /* RTL8411B */
128 Macv45 = 0x54000000, /* RTL8111HN */
130 Ifg0 = 0x01000000, /* Interframe Gap 0 */
131 Ifg1 = 0x02000000, /* Interframe Gap 1 */
135 Aap = 0x00000001, /* Accept All Packets */
136 Apm = 0x00000002, /* Accept Physical Match */
137 Am = 0x00000004, /* Accept Multicast */
138 Ab = 0x00000008, /* Accept Broadcast */
139 Ar = 0x00000010, /* Accept Runt */
140 Aer = 0x00000020, /* Accept Error */
141 Sel9356 = 0x00000040, /* 9356 EEPROM used */
142 MrxdmaSHIFT = 8, /* Max. DMA Burst Size */
143 MrxdmaMASK = 0x00000700,
144 Mrxdmaunlimited = 0x00000700,
145 RxfthSHIFT = 13, /* Receive Buffer Length */
146 RxfthMASK = 0x0000E000,
147 Rxfth256 = 0x00008000,
148 Rxfthnone = 0x0000E000,
149 Rer8 = 0x00010000, /* Accept Error Packets > 8 bytes */
150 MulERINT = 0x01000000, /* Multiple Early Interrupt Select */
158 Eem0 = 0x40, /* Operating Mode */
163 DataMASK = 0x0000FFFF, /* 16-bit GMII/MII Register Data */
165 RegaddrMASK = 0x001F0000, /* 5-bit GMII/MII Register Address */
167 Flag = 0x80000000, /* */
170 enum { /* Phystatus */
171 Fd = 0x01, /* Full Duplex */
172 Linksts = 0x02, /* Link Status */
173 Speed10 = 0x04, /* */
174 Speed100 = 0x08, /* */
175 Speed1000 = 0x10, /* */
182 Txenb = 0x0001, /* enable C+ transmit mode */
183 Rxenb = 0x0002, /* enable C+ receive mode */
184 Mulrw = 0x0008, /* PCI Multiple R/W Enable */
185 Dac = 0x0010, /* PCI Dual Address Cycle Enable */
186 Rxchksum = 0x0020, /* Receive Checksum Offload Enable */
187 Rxvlan = 0x0040, /* Receive VLAN De-tagging Enable */
188 Macstatdis = 0x0080, /* Disable Mac Statistics */
189 Endian = 0x0200, /* Endian Mode */
192 typedef struct D D; /* Transmit/Receive Descriptor */
200 enum { /* Transmit Descriptor control */
201 TxflMASK = 0x0000FFFF, /* Transmit Frame Length */
203 Tcps = 0x00010000, /* TCP Checksum Offload */
204 Udpcs = 0x00020000, /* UDP Checksum Offload */
205 Ipcs = 0x00040000, /* IP Checksum Offload */
206 Lgsen = 0x08000000, /* TSO; WARNING: contains lark's vomit */
209 enum { /* Receive Descriptor control */
210 RxflMASK = 0x00001FFF, /* Receive Frame Length */
211 Tcpf = 0x00004000, /* TCP Checksum Failure */
212 Udpf = 0x00008000, /* UDP Checksum Failure */
213 Ipf = 0x00010000, /* IP Checksum Failure */
214 Pid0 = 0x00020000, /* Protocol ID0 */
215 Pid1 = 0x00040000, /* Protocol ID1 */
216 Crce = 0x00080000, /* CRC Error */
217 Runt = 0x00100000, /* Runt Packet */
218 Res = 0x00200000, /* Receive Error Summary */
219 Rwt = 0x00400000, /* Receive Watchdog Timer Expired */
220 Fovf = 0x00800000, /* FIFO Overflow */
221 Bovf = 0x01000000, /* Buffer Overflow */
222 Bar = 0x02000000, /* Broadcast Address Received */
223 Pam = 0x04000000, /* Physical Address Matched */
224 Mar = 0x08000000, /* Multicast Address Received */
227 enum { /* General Descriptor control */
228 Ls = 0x10000000, /* Last Segment Descriptor */
229 Fs = 0x20000000, /* First Segment Descriptor */
230 Eor = 0x40000000, /* End of Descriptor Ring */
231 Own = 0x80000000, /* Ownership */
236 enum { /* Ring sizes (<= 1024) */
237 Ntd = 64, /* Transmit Ring */
238 Nrd = 256, /* Receive Ring */
241 Mps = ROUNDUP(ETHERMAXTU+4, 128),
244 typedef struct Dtcc Dtcc;
261 enum { /* Variants */
262 Rtl8100e = (0x8136<<16)|0x10EC, /* RTL810[01]E: pci -e */
263 Rtl8169c = (0x0116<<16)|0x16EC, /* RTL8169C+ (USR997902) */
264 Rtl8169sc = (0x8167<<16)|0x10EC, /* RTL8169SC */
265 Rtl8168b = (0x8168<<16)|0x10EC, /* RTL8168B: pci-e */
266 Rtl8169 = (0x8169<<16)|0x10EC, /* RTL8169 */
269 typedef struct Ctlr Ctlr;
270 typedef struct Ctlr {
278 QLock alock; /* attach */
283 int macv; /* MAC version */
284 int phyv; /* PHY version */
285 int pcie; /* flag: pci-express device? */
287 uvlong mchash; /* multicast hash */
291 D* td; /* descriptor ring */
292 Block** tb; /* transmit buffers */
295 int tdh; /* head - producer index (host) */
296 int tdt; /* tail - consumer index (NIC) */
299 D* rd; /* descriptor ring */
300 Block** rb; /* receive buffers */
303 int rdh; /* head - producer index (NIC) */
304 int rdt; /* tail - consumer index (host) */
307 int tcr; /* transmit configuration register */
308 int rcr; /* receive configuration register */
311 QLock slock; /* statistics */
324 uint frag; /* partial packets; rb was too small */
327 static Ctlr* rtl8169ctlrhead;
328 static Ctlr* rtl8169ctlrtail;
330 #define csr8r(c, r) (inb((c)->port+(r)))
331 #define csr16r(c, r) (ins((c)->port+(r)))
332 #define csr32r(c, r) (inl((c)->port+(r)))
333 #define csr8w(c, r, b) (outb((c)->port+(r), (u8int)(b)))
334 #define csr16w(c, r, w) (outs((c)->port+(r), (u16int)(w)))
335 #define csr32w(c, r, l) (outl((c)->port+(r), (u32int)(l)))
338 rtl8169miimir(Mii* mii, int pa, int ra)
348 r = (ra<<16) & RegaddrMASK;
349 csr32w(ctlr, Phyar, r);
351 for(timeo = 0; timeo < 2000; timeo++){
352 if((r = csr32r(ctlr, Phyar)) & Flag)
359 return (r & DataMASK)>>DataSHIFT;
363 rtl8169miimiw(Mii* mii, int pa, int ra, int data)
373 r = Flag|((ra<<16) & RegaddrMASK)|((data<<DataSHIFT) & DataMASK);
374 csr32w(ctlr, Phyar, r);
376 for(timeo = 0; timeo < 2000; timeo++){
377 if(!((r = csr32r(ctlr, Phyar)) & Flag))
388 rtl8169mii(Ether *edev)
390 Ctlr *ctlr = edev->ctlr;
396 ctlr->mii = smalloc(sizeof(Mii));
397 ctlr->mii->mir = rtl8169miimir;
398 ctlr->mii->miw = rtl8169miimiw;
399 ctlr->mii->ctlr = ctlr;
409 csr8w(ctlr, Pmch, csr8r(ctlr, Pmch) | 0x80);
412 rtl8169miimiw(ctlr->mii, 1, 0x1f, 0);
413 rtl8169miimiw(ctlr->mii, 1, 0x0e, 0);
416 * Get rev number out of Phyidr2 so can config properly.
417 * There's probably more special stuff for Macv0[234] needed here.
419 ctlr->phyv = rtl8169miimir(ctlr->mii, 1, Phyidr2) & 0x0F;
420 if(ctlr->macv == Macv02){
421 csr8w(ctlr, Ldps, 1); /* magic */
422 rtl8169miimiw(ctlr->mii, 1, 0x0B, 0x0000); /* magic */
425 if(mii(ctlr->mii, (1<<1)) == 0 || (phy = ctlr->mii->curphy) == nil){
430 print("#l%d: rtl8169: oui %#ux phyno %d, macv = %#8.8ux phyv = %#4.4ux\n",
431 edev->ctlrno, phy->oui, phy->phyno, ctlr->macv, ctlr->phyv);
437 miiane(ctlr->mii, ~0, ~0, ~0);
441 rtl8169promiscuous(void* arg, int on)
453 csr32w(ctlr, Rcr, ctlr->rcr);
458 /* everyone else uses 0x04c11db7, but they both produce the same crc */
459 Etherpolybe = 0x04c11db6,
460 Bytemask = (1<<8) - 1,
464 ethercrcbe(uchar *addr, long len)
470 for (i = 0; i < len; i++) {
472 for (j = 0; j < 8; j++) {
473 carry = ((crc & (1UL << 31))? 1: 0) ^ (c & 1);
477 crc = (crc ^ Etherpolybe) | carry;
486 return l>>24 | (l>>8) & (Bytemask<<8) |
487 (l<<8) & (Bytemask<<16) | l<<24;
491 rtl8169multicast(void* ether, uchar *eaddr, int add)
497 return; /* ok to keep receiving on old mcast addrs */
503 ctlr->mchash |= 1ULL << (ethercrcbe(eaddr, Eaddrlen) >> 26);
506 csr32w(ctlr, Rcr, ctlr->rcr);
508 /* pci-e variants reverse the order of the hash byte registers */
510 csr32w(ctlr, Mar0, swabl(ctlr->mchash>>32));
511 csr32w(ctlr, Mar0+4, swabl(ctlr->mchash));
513 csr32w(ctlr, Mar0, ctlr->mchash);
514 csr32w(ctlr, Mar0+4, ctlr->mchash>>32);
521 rtl8169ifstat(Ether* edev, void* a, long n, ulong offset)
528 p = smalloc(READSTR);
534 qunlock(&ctlr->slock);
539 csr32w(ctlr, Dtccr+4, 0);
540 csr32w(ctlr, Dtccr, PCIWADDR(ctlr->dtcc)|Cmd);
541 for(timeo = 0; timeo < 1000; timeo++){
542 if(!(csr32r(ctlr, Dtccr) & Cmd))
546 if(csr32r(ctlr, Dtccr) & Cmd)
550 edev->oerrs = dtcc->txer;
551 edev->crcs = dtcc->rxer;
552 edev->frames = dtcc->fae;
553 edev->buffs = dtcc->misspkt;
554 edev->overflows = ctlr->txdu+ctlr->rdu;
557 qunlock(&ctlr->slock);
563 l = snprint(p, READSTR, "TxOk: %llud\n", dtcc->txok);
564 l += snprint(p+l, READSTR-l, "RxOk: %llud\n", dtcc->rxok);
565 l += snprint(p+l, READSTR-l, "TxEr: %llud\n", dtcc->txer);
566 l += snprint(p+l, READSTR-l, "RxEr: %ud\n", dtcc->rxer);
567 l += snprint(p+l, READSTR-l, "MissPkt: %ud\n", dtcc->misspkt);
568 l += snprint(p+l, READSTR-l, "FAE: %ud\n", dtcc->fae);
569 l += snprint(p+l, READSTR-l, "Tx1Col: %ud\n", dtcc->tx1col);
570 l += snprint(p+l, READSTR-l, "TxMCol: %ud\n", dtcc->txmcol);
571 l += snprint(p+l, READSTR-l, "RxOkPh: %llud\n", dtcc->rxokph);
572 l += snprint(p+l, READSTR-l, "RxOkBrd: %llud\n", dtcc->rxokbrd);
573 l += snprint(p+l, READSTR-l, "RxOkMu: %ud\n", dtcc->rxokmu);
574 l += snprint(p+l, READSTR-l, "TxAbt: %ud\n", dtcc->txabt);
575 l += snprint(p+l, READSTR-l, "TxUndrn: %ud\n", dtcc->txundrn);
577 l += snprint(p+l, READSTR-l, "serr: %ud\n", ctlr->serr);
578 l += snprint(p+l, READSTR-l, "fovw: %ud\n", ctlr->fovw);
580 l += snprint(p+l, READSTR-l, "txdu: %ud\n", ctlr->txdu);
581 l += snprint(p+l, READSTR-l, "tcpf: %ud\n", ctlr->tcpf);
582 l += snprint(p+l, READSTR-l, "udpf: %ud\n", ctlr->udpf);
583 l += snprint(p+l, READSTR-l, "ipf: %ud\n", ctlr->ipf);
584 l += snprint(p+l, READSTR-l, "fovf: %ud\n", ctlr->fovf);
585 l += snprint(p+l, READSTR-l, "rer: %ud\n", ctlr->rer);
586 l += snprint(p+l, READSTR-l, "rdu: %ud\n", ctlr->rdu);
587 l += snprint(p+l, READSTR-l, "punlc: %ud\n", ctlr->punlc);
589 l += snprint(p+l, READSTR-l, "tcr: %#8.8ux\n", ctlr->tcr);
590 l += snprint(p+l, READSTR-l, "rcr: %#8.8ux\n", ctlr->rcr);
591 l += snprint(p+l, READSTR-l, "multicast: %ud\n", ctlr->mcast);
593 if(ctlr->mii != nil && ctlr->mii->curphy != nil){
594 l += snprint(p+l, READSTR-l, "phy: ");
595 for(i = 0; i < NMiiPhyr; i++){
596 if(i && ((i & 0x07) == 0))
597 l += snprint(p+l, READSTR-l, "\n ");
598 r = miimir(ctlr->mii, i);
599 l += snprint(p+l, READSTR-l, " %4.4ux", r);
601 snprint(p+l, READSTR-l, "\n");
604 n = readstr(offset, a, n, p);
606 qunlock(&ctlr->slock);
614 rtl8169halt(Ctlr* ctlr)
619 csr16w(ctlr, Imr, 0);
620 csr16w(ctlr, Isr, ~0);
624 rtl8169reset(Ctlr* ctlr)
630 * Soft reset the controller.
632 csr8w(ctlr, Cr, Rst);
633 for(r = timeo = 0; timeo < 1000; timeo++){
647 rtl8169replenish(Ctlr* ctlr)
655 while(NEXT(x, ctlr->nrd) != ctlr->rdh){
658 iprint("rtl8169: no available buffers\n");
663 pa = PCIWADDR(bp->rp);
666 d->addrhi = pa >> 32;
668 d->control = (d->control & Eor) | Own | BALLOC(bp);
669 x = NEXT(x, ctlr->nrd);
675 rtl8169init(Ether* edev)
686 if(rtl8169reset(ctlr) < 0){
688 error("reset failed");
691 memset(ctlr->td, 0, sizeof(D)*ctlr->ntd);
692 ctlr->tdh = ctlr->tdt = ctlr->ntq = 0;
693 ctlr->td[ctlr->ntd-1].control = Eor;
694 for(i = 0; i < ctlr->ntd; i++)
695 if(bp = ctlr->tb[i]){
700 memset(ctlr->rd, 0, sizeof(D)*ctlr->nrd);
701 ctlr->rdh = ctlr->rdt = ctlr->nrq = 0;
702 ctlr->rd[ctlr->nrd-1].control = Eor;
703 for(i = 0; i < ctlr->nrd; i++)
704 if(bp = ctlr->rb[i]){
709 rtl8169replenish(ctlr);
711 cplusc = csr16r(ctlr, Cplusc);
712 cplusc &= ~(Endian|Rxchksum);
713 cplusc |= Txenb|Mulrw;
717 cplusc |= Macstatdis;
723 csr16w(ctlr, Cplusc, cplusc);
725 pa = PCIWADDR(ctlr->td);
726 csr32w(ctlr, Tnpds+4, pa>>32);
727 csr32w(ctlr, Tnpds, pa);
729 pa = PCIWADDR(ctlr->rd);
730 csr32w(ctlr, Rdsar+4, pa>>32);
731 csr32w(ctlr, Rdsar, pa);
733 csr8w(ctlr, Cr, Te|Re);
735 csr32w(ctlr, Tcr, Ifg1|Ifg0|Mtxdmaunlimited);
736 ctlr->tcr = csr32r(ctlr, Tcr);
740 ctlr->rcr = Rxfth256|Mrxdmaunlimited|Ab|Am|Apm;
743 ctlr->rcr = Rxfthnone|Mrxdmaunlimited|Ab|Am|Apm;
747 csr32w(ctlr, Mar0, 0);
748 csr32w(ctlr, Mar0+4, 0);
749 csr32w(ctlr, Rcr, ctlr->rcr);
751 /* maximum packet sizes, unlimited */
752 csr8w(ctlr, Etx, 0x3f);
753 csr16w(ctlr, Rms, 0x3fff);
755 csr16w(ctlr, Coal, 0);
757 /* no early rx interrupts */
758 r = csr16r(ctlr, Mulint) & 0xF000;
759 csr16w(ctlr, Mulint, r);
761 ctlr->imr = Serr|Fovw|Punlc|Rdu|Ter|Rer|Rok|Tdu;
762 csr16w(ctlr, Imr, ctlr->imr);
764 csr32w(ctlr, Mpc, 0);
770 rtl8169reseter(void *arg)
780 sleep(&ctlr->reset, return0, nil);
785 static void rtl8169interrupt(Ureg*, void* arg);
788 rtl8169attach(Ether* edev)
795 qunlock(&ctlr->alock);
799 print("#l%d: rtl8169: %s\n", edev->ctlrno, up->errstr);
800 qunlock(&ctlr->alock);
806 ctlr->tb = malloc(ctlr->ntd*sizeof(Block*));
807 ctlr->rb = malloc(ctlr->nrd*sizeof(Block*));
808 ctlr->td = mallocalign(sizeof(D)*ctlr->ntd, 256, 0, 0);
809 ctlr->rd = mallocalign(sizeof(D)*ctlr->nrd, 256, 0, 0);
810 ctlr->dtcc = mallocalign(sizeof(Dtcc), 64, 0, 0);
825 if(ctlr->tb == nil || ctlr->rb == nil
826 || ctlr->td == nil || ctlr->rd == nil
827 || ctlr->dtcc == nil)
830 pcisetbme(ctlr->pcidev);
831 intrenable(edev->irq, rtl8169interrupt, edev, edev->tbdf, edev->name);
834 pciclrbme(ctlr->pcidev);
835 intrdisable(edev->irq, rtl8169interrupt, edev, edev->tbdf, edev->name);
846 kproc("rtl8169", rtl8169reseter, edev);
848 qunlock(&ctlr->alock);
853 rtl8169link(Ether* edev)
861 r = csr8r(ctlr, Phystatus);
863 * Maybe the link changed - do we care very much?
864 * Could stall transmits if no link, maybe?
866 edev->link = (r & Linksts) != 0;
872 } else if(r & Speed100)
874 else if(r & Speed1000)
878 qsetlimit(edev->oq, limit);
882 rtl8169transmit(Ether* edev)
894 for(x = ctlr->tdh; ctlr->ntq > 0; x = NEXT(x, ctlr->ntd)){
901 * Need to clean the descriptor here? Not really.
902 * Simple freeb for now (no chain and freeblist).
903 * Use ntq count for now.
912 while(ctlr->ntq < (ctlr->ntd-1)){
913 if((bp = qget(edev->oq)) == nil)
916 pa = PCIWADDR(bp->rp);
919 d->addrhi = pa >> 32;
921 d->control = (d->control & Eor) | Own | Fs | Ls | BLEN(bp);
926 x = NEXT(x, ctlr->ntd);
930 else if(ctlr->ntq >= (ctlr->ntd-1))
935 csr8w(ctlr, Tppoll, Npq);
941 rtl8169receive(Ether* edev)
950 if(ctlr->nrq < ctlr->nrd/2)
951 rtl8169replenish(ctlr);
953 for(x = ctlr->rdh; x != ctlr->rdt;){
955 if((control = d->control) & Own)
962 x = NEXT(x, ctlr->nrd);
965 if(ctlr->nrq < ctlr->nrd/2)
966 rtl8169replenish(ctlr);
968 if((control & (Fs|Ls|Res)) == (Fs|Ls)){
969 bp->wp = bp->rp + (control & RxflMASK) - 4;
976 switch(control & (Pid1|Pid0)){
1003 if(!(control & Res))
1011 rtl8169restart(Ctlr *ctlr)
1014 wakeup(&ctlr->reset);
1018 rtl8169interrupt(Ureg*, void* arg)
1027 while((isr = csr16r(ctlr, Isr)) != 0 && isr != 0xFFFF){
1028 csr16w(ctlr, Isr, isr);
1029 if((isr & ctlr->imr) == 0)
1043 if(isr & (Serr|Fovw)){
1044 rtl8169restart(ctlr);
1048 if(isr & (Punlc|Rdu|Rer|Rok))
1049 rtl8169receive(edev);
1051 if(isr & (Tdu|Ter|Tok))
1052 rtl8169transmit(edev);
1060 rtl8169shutdown(Ether *edev)
1062 Ctlr *ctlr = edev->ctlr;
1068 vetmacv(Ctlr *ctlr, uint *macv)
1070 *macv = csr32r(ctlr, Tcr) & HwveridMASK;
1113 while(p = pcimatch(p, 0, 0)){
1114 if(p->ccrb != 0x02 || p->ccru != 0)
1118 switch(i = ((p->did<<16)|p->vid)){
1121 case Rtl8100e: /* RTL810[01]E ? */
1122 case Rtl8168b: /* RTL8168B */
1125 case Rtl8169c: /* RTL8169C */
1126 case Rtl8169sc: /* RTL8169SC */
1127 case Rtl8169: /* RTL8169 */
1129 case (0xC107<<16)|0x1259: /* Corega CG-LAPCIGT */
1134 if(p->mem[0].size == 0 || (p->mem[0].bar & 1) == 0)
1136 port = p->mem[0].bar & ~3;
1137 if(ioalloc(port, p->mem[0].size, 0, "rtl8169") < 0){
1138 print("rtl8169: port %#ux in use\n", port);
1142 ctlr = malloc(sizeof(Ctlr));
1144 print("rtl8169: can't allocate memory\n");
1154 if(vetmacv(ctlr, &macv) == -1){
1155 print("rtl8169: %T: unknown mac %.4ux %.8ux\n", p->tbdf, p->did, macv);
1164 * Extract the chip hardware version,
1165 * needed to configure each properly.
1168 if(rtl8169ctlrhead != nil)
1169 rtl8169ctlrtail->next = ctlr;
1171 rtl8169ctlrhead = ctlr;
1172 rtl8169ctlrtail = ctlr;
1177 rtl8169pnp(Ether* edev)
1190 * Any adapter matches if no edev->port is supplied,
1191 * otherwise the ports must match.
1193 for(ctlr = rtl8169ctlrhead; ctlr != nil; ctlr = ctlr->next){
1196 if(edev->port == 0 || edev->port == ctlr->port){
1205 edev->port = ctlr->port;
1206 edev->irq = ctlr->pcidev->intl;
1207 edev->tbdf = ctlr->pcidev->tbdf;
1212 * Check if the adapter's station address is to be overridden.
1213 * If not, read it from the device and set in edev->ea.
1215 memset(ea, 0, Eaddrlen);
1216 if(memcmp(ea, edev->ea, Eaddrlen) == 0){
1217 r = csr32r(ctlr, Idr0);
1220 edev->ea[2] = r>>16;
1221 edev->ea[3] = r>>24;
1222 r = csr32r(ctlr, Idr0+4);
1227 edev->attach = rtl8169attach;
1228 edev->transmit = rtl8169transmit;
1229 edev->ifstat = rtl8169ifstat;
1230 edev->shutdown = rtl8169shutdown;
1233 edev->promiscuous = rtl8169promiscuous;
1234 edev->multicast = rtl8169multicast;
1244 addethercard("rtl8169", rtl8169pnp);