sys/src/9/pc/ether8169.c

   1 /*
   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
   5  * to be necessary.
   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.
   9  */
  10 #include "u.h"
  11 #include "../port/lib.h"
  12 #include "mem.h"
  13 #include "dat.h"
  14 #include "fns.h"
  15 #include "io.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"
  21
  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 */
  55
  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 */
  61 };
  62
  63 enum {                                  /* Dtccr */
  64         Cmd             = 0x00000008,   /* Command */
  65 };
  66
  67 enum {                                  /* Cr */
  68         Te              = 0x04,         /* Transmitter Enable */
  69         Re              = 0x08,         /* Receiver Enable */
  70         Rst             = 0x10,         /* Software Reset */
  71 };
  72
  73 enum {                                  /* Tppoll */
  74         Fswint          = 0x01,         /* Forced Software Interrupt */
  75         Npq             = 0x40,         /* Normal Priority Queue polling */
  76         Hpq             = 0x80,         /* High Priority Queue polling */
  77 };
  78
  79 enum {                                  /* Imr/Isr */
  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 */
  91 };
  92
  93 enum {                                  /* Tcr */
  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         Macv39          = 0x44800000,   /* RTL8106E */
 124         Macv40          = 0x4c000000,   /* RTL8168G */
 125         Macv42          = 0x50800000,   /* RTL8168GU */
 126         Macv44          = 0x5c800000,   /* RTL8411B */
 127         Macv45          = 0x54000000,   /* RTL8111HN */
 128
 129         Ifg0            = 0x01000000,   /* Interframe Gap 0 */
 130         Ifg1            = 0x02000000,   /* Interframe Gap 1 */
 131 };
 132
 133 enum {                                  /* Rcr */
 134         Aap             = 0x00000001,   /* Accept All Packets */
 135         Apm             = 0x00000002,   /* Accept Physical Match */
 136         Am              = 0x00000004,   /* Accept Multicast */
 137         Ab              = 0x00000008,   /* Accept Broadcast */
 138         Ar              = 0x00000010,   /* Accept Runt */
 139         Aer             = 0x00000020,   /* Accept Error */
 140         Sel9356         = 0x00000040,   /* 9356 EEPROM used */
 141         MrxdmaSHIFT     = 8,            /* Max. DMA Burst Size */
 142         MrxdmaMASK      = 0x00000700,
 143         Mrxdmaunlimited = 0x00000700,
 144         RxfthSHIFT      = 13,           /* Receive Buffer Length */
 145         RxfthMASK       = 0x0000E000,
 146         Rxfth256        = 0x00008000,
 147         Rxfthnone       = 0x0000E000,
 148         Rer8            = 0x00010000,   /* Accept Error Packets > 8 bytes */
 149         MulERINT        = 0x01000000,   /* Multiple Early Interrupt Select */
 150 };
 151
 152 enum {                                  /* Cr9346 */
 153         Eedo            = 0x01,         /* */
 154         Eedi            = 0x02,         /* */
 155         Eesk            = 0x04,         /* */
 156         Eecs            = 0x08,         /* */
 157         Eem0            = 0x40,         /* Operating Mode */
 158         Eem1            = 0x80,
 159 };
 160
 161 enum {                                  /* Phyar */
 162         DataMASK        = 0x0000FFFF,   /* 16-bit GMII/MII Register Data */
 163         DataSHIFT       = 0,
 164         RegaddrMASK     = 0x001F0000,   /* 5-bit GMII/MII Register Address */
 165         RegaddrSHIFT    = 16,
 166         Flag            = 0x80000000,   /* */
 167 };
 168
 169 enum {                                  /* Phystatus */
 170         Fd              = 0x01,         /* Full Duplex */
 171         Linksts         = 0x02,         /* Link Status */
 172         Speed10         = 0x04,         /* */
 173         Speed100        = 0x08,         /* */
 174         Speed1000       = 0x10,         /* */
 175         Rxflow          = 0x20,         /* */
 176         Txflow          = 0x40,         /* */
 177         Entbi           = 0x80,         /* */
 178 };
 179
 180 enum {                                  /* Cplusc */
 181         Txenb           = 0x0001,       /* enable C+ transmit mode */
 182         Rxenb           = 0x0002,       /* enable C+ receive mode */
 183         Mulrw           = 0x0008,       /* PCI Multiple R/W Enable */
 184         Dac             = 0x0010,       /* PCI Dual Address Cycle Enable */
 185         Rxchksum        = 0x0020,       /* Receive Checksum Offload Enable */
 186         Rxvlan          = 0x0040,       /* Receive VLAN De-tagging Enable */
 187         Macstatdis      = 0x0080,       /* Disable Mac Statistics */
 188         Endian          = 0x0200,       /* Endian Mode */
 189 };
 190
 191 typedef struct D D;                     /* Transmit/Receive Descriptor */
 192 struct D {
 193         u32int  control;
 194         u32int  vlan;
 195         u32int  addrlo;
 196         u32int  addrhi;
 197 };
 198
 199 enum {                                  /* Transmit Descriptor control */
 200         TxflMASK        = 0x0000FFFF,   /* Transmit Frame Length */
 201         TxflSHIFT       = 0,
 202         Tcps            = 0x00010000,   /* TCP Checksum Offload */
 203         Udpcs           = 0x00020000,   /* UDP Checksum Offload */
 204         Ipcs            = 0x00040000,   /* IP Checksum Offload */
 205         Lgsen           = 0x08000000,   /* TSO; WARNING: contains lark's vomit */
 206 };
 207
 208 enum {                                  /* Receive Descriptor control */
 209         RxflMASK        = 0x00001FFF,   /* Receive Frame Length */
 210         Tcpf            = 0x00004000,   /* TCP Checksum Failure */
 211         Udpf            = 0x00008000,   /* UDP Checksum Failure */
 212         Ipf             = 0x00010000,   /* IP Checksum Failure */
 213         Pid0            = 0x00020000,   /* Protocol ID0 */
 214         Pid1            = 0x00040000,   /* Protocol ID1 */
 215         Crce            = 0x00080000,   /* CRC Error */
 216         Runt            = 0x00100000,   /* Runt Packet */
 217         Res             = 0x00200000,   /* Receive Error Summary */
 218         Rwt             = 0x00400000,   /* Receive Watchdog Timer Expired */
 219         Fovf            = 0x00800000,   /* FIFO Overflow */
 220         Bovf            = 0x01000000,   /* Buffer Overflow */
 221         Bar             = 0x02000000,   /* Broadcast Address Received */
 222         Pam             = 0x04000000,   /* Physical Address Matched */
 223         Mar             = 0x08000000,   /* Multicast Address Received */
 224 };
 225
 226 enum {                                  /* General Descriptor control */
 227         Ls              = 0x10000000,   /* Last Segment Descriptor */
 228         Fs              = 0x20000000,   /* First Segment Descriptor */
 229         Eor             = 0x40000000,   /* End of Descriptor Ring */
 230         Own             = 0x80000000,   /* Ownership */
 231 };
 232
 233 /*
 234  */
 235 enum {                                  /* Ring sizes  (<= 1024) */
 236         Ntd             = 64,           /* Transmit Ring */
 237         Nrd             = 256,          /* Receive Ring */
 238
 239         Mtu             = ETHERMAXTU,
 240         Mps             = ROUNDUP(ETHERMAXTU+4, 128),
 241 };
 242
 243 typedef struct Dtcc Dtcc;
 244 struct Dtcc {
 245         u64int  txok;
 246         u64int  rxok;
 247         u64int  txer;
 248         u32int  rxer;
 249         u16int  misspkt;
 250         u16int  fae;
 251         u32int  tx1col;
 252         u32int  txmcol;
 253         u64int  rxokph;
 254         u64int  rxokbrd;
 255         u32int  rxokmu;
 256         u16int  txabt;
 257         u16int  txundrn;
 258 };
 259
 260 enum {                                          /* Variants */
 261         Rtl8100e        = (0x8136<<16)|0x10EC,  /* RTL810[01]E: pci -e */
 262         Rtl8169c        = (0x0116<<16)|0x16EC,  /* RTL8169C+ (USR997902) */
 263         Rtl8169sc       = (0x8167<<16)|0x10EC,  /* RTL8169SC */
 264         Rtl8168b        = (0x8168<<16)|0x10EC,  /* RTL8168B: pci-e */
 265         Rtl8169         = (0x8169<<16)|0x10EC,  /* RTL8169 */
 266 };
 267
 268 typedef struct Ctlr Ctlr;
 269 typedef struct Ctlr {
 270         Lock;
 271
 272         int     port;
 273         Pcidev* pcidev;
 274         Ctlr*   next;
 275         int     active;
 276
 277         QLock   alock;                  /* attach */
 278         int     init;                   /*  */
 279         Rendez  reset;
 280
 281         int     pciv;                   /*  */
 282         int     macv;                   /* MAC version */
 283         int     phyv;                   /* PHY version */
 284         int     pcie;                   /* flag: pci-express device? */
 285
 286         uvlong  mchash;                 /* multicast hash */
 287
 288         Mii*    mii;
 289
 290         D*      td;                     /* descriptor ring */
 291         Block** tb;                     /* transmit buffers */
 292         int     ntd;
 293
 294         int     tdh;                    /* head - producer index (host) */
 295         int     tdt;                    /* tail - consumer index (NIC) */
 296         int     ntq;
 297
 298         D*      rd;                     /* descriptor ring */
 299         Block** rb;                     /* receive buffers */
 300         int     nrd;
 301
 302         int     rdh;                    /* head - producer index (NIC) */
 303         int     rdt;                    /* tail - consumer index (host) */
 304         int     nrq;
 305
 306         int     tcr;                    /* transmit configuration register */
 307         int     rcr;                    /* receive configuration register */
 308         int     imr;
 309
 310         QLock   slock;                  /* statistics */
 311         Dtcc*   dtcc;
 312         uint    txdu;
 313         uint    tcpf;
 314         uint    udpf;
 315         uint    ipf;
 316         uint    fovf;
 317         uint    rer;
 318         uint    rdu;
 319         uint    punlc;
 320         uint    serr;
 321         uint    fovw;
 322         uint    mcast;
 323         uint    frag;                   /* partial packets; rb was too small */
 324 } Ctlr;
 325
 326 static Ctlr* rtl8169ctlrhead;
 327 static Ctlr* rtl8169ctlrtail;
 328
 329 #define csr8r(c, r)     (inb((c)->port+(r)))
 330 #define csr16r(c, r)    (ins((c)->port+(r)))
 331 #define csr32r(c, r)    (inl((c)->port+(r)))
 332 #define csr8w(c, r, b)  (outb((c)->port+(r), (u8int)(b)))
 333 #define csr16w(c, r, w) (outs((c)->port+(r), (u16int)(w)))
 334 #define csr32w(c, r, l) (outl((c)->port+(r), (u32int)(l)))
 335
 336 static int
 337 rtl8169miimir(Mii* mii, int pa, int ra)
 338 {
 339         uint r;
 340         int timeo;
 341         Ctlr *ctlr;
 342
 343         if(pa != 1)
 344                 return -1;
 345         ctlr = mii->ctlr;
 346
 347         r = (ra<<16) & RegaddrMASK;
 348         csr32w(ctlr, Phyar, r);
 349         delay(1);
 350         for(timeo = 0; timeo < 2000; timeo++){
 351                 if((r = csr32r(ctlr, Phyar)) & Flag)
 352                         break;
 353                 microdelay(100);
 354         }
 355         if(!(r & Flag))
 356                 return -1;
 357
 358         return (r & DataMASK)>>DataSHIFT;
 359 }
 360
 361 static int
 362 rtl8169miimiw(Mii* mii, int pa, int ra, int data)
 363 {
 364         uint r;
 365         int timeo;
 366         Ctlr *ctlr;
 367
 368         if(pa != 1)
 369                 return -1;
 370         ctlr = mii->ctlr;
 371
 372         r = Flag|((ra<<16) & RegaddrMASK)|((data<<DataSHIFT) & DataMASK);
 373         csr32w(ctlr, Phyar, r);
 374         delay(1);
 375         for(timeo = 0; timeo < 2000; timeo++){
 376                 if(!((r = csr32r(ctlr, Phyar)) & Flag))
 377                         break;
 378                 microdelay(100);
 379         }
 380         if(r & Flag)
 381                 return -1;
 382
 383         return 0;
 384 }
 385
 386 static void
 387 rtl8169mii(Ether *edev)
 388 {
 389         Ctlr *ctlr = edev->ctlr;
 390         MiiPhy *phy;
 391
 392         /*
 393          * Link management.
 394          */
 395         ctlr->mii = smalloc(sizeof(Mii));
 396         ctlr->mii->mir = rtl8169miimir;
 397         ctlr->mii->miw = rtl8169miimiw;
 398         ctlr->mii->ctlr = ctlr;
 399
 400         /*
 401          * PHY wakeup
 402          */
 403         switch(ctlr->macv){
 404         case Macv25:
 405         case Macv28:
 406         case Macv29:
 407         case Macv30:
 408                 csr8w(ctlr, Pmch, csr8r(ctlr, Pmch) | 0x80);
 409                 break;
 410         }
 411         rtl8169miimiw(ctlr->mii, 1, 0x1f, 0);
 412         rtl8169miimiw(ctlr->mii, 1, 0x0e, 0);
 413
 414         /*
 415          * Get rev number out of Phyidr2 so can config properly.
 416          * There's probably more special stuff for Macv0[234] needed here.
 417          */
 418         ctlr->phyv = rtl8169miimir(ctlr->mii, 1, Phyidr2) & 0x0F;
 419         if(ctlr->macv == Macv02){
 420                 csr8w(ctlr, Ldps, 1);                           /* magic */
 421                 rtl8169miimiw(ctlr->mii, 1, 0x0B, 0x0000);      /* magic */
 422         }
 423
 424         if(mii(ctlr->mii, (1<<1)) == 0 || (phy = ctlr->mii->curphy) == nil){
 425                 error("no phy");
 426                 return;
 427         }
 428
 429         print("#l%d: rtl8169: oui %#ux phyno %d, macv = %#8.8ux phyv = %#4.4ux\n",
 430                 edev->ctlrno, phy->oui, phy->phyno, ctlr->macv, ctlr->phyv);
 431
 432         miireset(ctlr->mii);
 433
 434         microdelay(100);
 435
 436         miiane(ctlr->mii, ~0, ~0, ~0);
 437 }
 438
 439 static void
 440 rtl8169promiscuous(void* arg, int on)
 441 {
 442         Ether *edev;
 443         Ctlr * ctlr;
 444
 445         edev = arg;
 446         ctlr = edev->ctlr;
 447         ilock(ctlr);
 448         if(on)
 449                 ctlr->rcr |= Aap;
 450         else
 451                 ctlr->rcr &= ~Aap;
 452         csr32w(ctlr, Rcr, ctlr->rcr);
 453         iunlock(ctlr);
 454 }
 455
 456 enum {
 457         /* everyone else uses 0x04c11db7, but they both produce the same crc */
 458         Etherpolybe = 0x04c11db6,
 459         Bytemask = (1<<8) - 1,
 460 };
 461
 462 static ulong
 463 ethercrcbe(uchar *addr, long len)
 464 {
 465         int i, j;
 466         ulong c, crc, carry;
 467
 468         crc = ~0UL;
 469         for (i = 0; i < len; i++) {
 470                 c = addr[i];
 471                 for (j = 0; j < 8; j++) {
 472                         carry = ((crc & (1UL << 31))? 1: 0) ^ (c & 1);
 473                         crc <<= 1;
 474                         c >>= 1;
 475                         if (carry)
 476                                 crc = (crc ^ Etherpolybe) | carry;
 477                 }
 478         }
 479         return crc;
 480 }
 481
 482 static ulong
 483 swabl(ulong l)
 484 {
 485         return l>>24 | (l>>8) & (Bytemask<<8) |
 486                 (l<<8) & (Bytemask<<16) | l<<24;
 487 }
 488
 489 static void
 490 rtl8169multicast(void* ether, uchar *eaddr, int add)
 491 {
 492         Ether *edev;
 493         Ctlr *ctlr;
 494
 495         if (!add)
 496                 return; /* ok to keep receiving on old mcast addrs */
 497
 498         edev = ether;
 499         ctlr = edev->ctlr;
 500         ilock(ctlr);
 501
 502         ctlr->mchash |= 1ULL << (ethercrcbe(eaddr, Eaddrlen) >> 26);
 503
 504         ctlr->rcr |= Am;
 505         csr32w(ctlr, Rcr, ctlr->rcr);
 506
 507         /* pci-e variants reverse the order of the hash byte registers */
 508         if (ctlr->pcie) {
 509                 csr32w(ctlr, Mar0,   swabl(ctlr->mchash>>32));
 510                 csr32w(ctlr, Mar0+4, swabl(ctlr->mchash));
 511         } else {
 512                 csr32w(ctlr, Mar0,   ctlr->mchash);
 513                 csr32w(ctlr, Mar0+4, ctlr->mchash>>32);
 514         }
 515
 516         iunlock(ctlr);
 517 }
 518
 519 static long
 520 rtl8169ifstat(Ether* edev, void* a, long n, ulong offset)
 521 {
 522         char *p;
 523         Ctlr *ctlr;
 524         Dtcc *dtcc;
 525         int i, l, r, timeo;
 526
 527         p = smalloc(READSTR);
 528
 529         ctlr = edev->ctlr;
 530         qlock(&ctlr->slock);
 531
 532         if(waserror()){
 533                 qunlock(&ctlr->slock);
 534                 free(p);
 535                 nexterror();
 536         }
 537
 538         csr32w(ctlr, Dtccr+4, 0);
 539         csr32w(ctlr, Dtccr, PCIWADDR(ctlr->dtcc)|Cmd);
 540         for(timeo = 0; timeo < 1000; timeo++){
 541                 if(!(csr32r(ctlr, Dtccr) & Cmd))
 542                         break;
 543                 delay(1);
 544         }
 545         if(csr32r(ctlr, Dtccr) & Cmd)
 546                 error(Eio);
 547         dtcc = ctlr->dtcc;
 548
 549         edev->oerrs = dtcc->txer;
 550         edev->crcs = dtcc->rxer;
 551         edev->frames = dtcc->fae;
 552         edev->buffs = dtcc->misspkt;
 553         edev->overflows = ctlr->txdu+ctlr->rdu;
 554
 555         if(n == 0){
 556                 qunlock(&ctlr->slock);
 557                 poperror();
 558                 free(p);
 559                 return 0;
 560         }
 561
 562         l = snprint(p, READSTR, "TxOk: %llud\n", dtcc->txok);
 563         l += snprint(p+l, READSTR-l, "RxOk: %llud\n", dtcc->rxok);
 564         l += snprint(p+l, READSTR-l, "TxEr: %llud\n", dtcc->txer);
 565         l += snprint(p+l, READSTR-l, "RxEr: %ud\n", dtcc->rxer);
 566         l += snprint(p+l, READSTR-l, "MissPkt: %ud\n", dtcc->misspkt);
 567         l += snprint(p+l, READSTR-l, "FAE: %ud\n", dtcc->fae);
 568         l += snprint(p+l, READSTR-l, "Tx1Col: %ud\n", dtcc->tx1col);
 569         l += snprint(p+l, READSTR-l, "TxMCol: %ud\n", dtcc->txmcol);
 570         l += snprint(p+l, READSTR-l, "RxOkPh: %llud\n", dtcc->rxokph);
 571         l += snprint(p+l, READSTR-l, "RxOkBrd: %llud\n", dtcc->rxokbrd);
 572         l += snprint(p+l, READSTR-l, "RxOkMu: %ud\n", dtcc->rxokmu);
 573         l += snprint(p+l, READSTR-l, "TxAbt: %ud\n", dtcc->txabt);
 574         l += snprint(p+l, READSTR-l, "TxUndrn: %ud\n", dtcc->txundrn);
 575
 576         l += snprint(p+l, READSTR-l, "serr: %ud\n", ctlr->serr);
 577         l += snprint(p+l, READSTR-l, "fovw: %ud\n", ctlr->fovw);
 578
 579         l += snprint(p+l, READSTR-l, "txdu: %ud\n", ctlr->txdu);
 580         l += snprint(p+l, READSTR-l, "tcpf: %ud\n", ctlr->tcpf);
 581         l += snprint(p+l, READSTR-l, "udpf: %ud\n", ctlr->udpf);
 582         l += snprint(p+l, READSTR-l, "ipf: %ud\n", ctlr->ipf);
 583         l += snprint(p+l, READSTR-l, "fovf: %ud\n", ctlr->fovf);
 584         l += snprint(p+l, READSTR-l, "rer: %ud\n", ctlr->rer);
 585         l += snprint(p+l, READSTR-l, "rdu: %ud\n", ctlr->rdu);
 586         l += snprint(p+l, READSTR-l, "punlc: %ud\n", ctlr->punlc);
 587
 588         l += snprint(p+l, READSTR-l, "tcr: %#8.8ux\n", ctlr->tcr);
 589         l += snprint(p+l, READSTR-l, "rcr: %#8.8ux\n", ctlr->rcr);
 590         l += snprint(p+l, READSTR-l, "multicast: %ud\n", ctlr->mcast);
 591
 592         if(ctlr->mii != nil && ctlr->mii->curphy != nil){
 593                 l += snprint(p+l, READSTR-l, "phy:   ");
 594                 for(i = 0; i < NMiiPhyr; i++){
 595                         if(i && ((i & 0x07) == 0))
 596                                 l += snprint(p+l, READSTR-l, "\n       ");
 597                         r = miimir(ctlr->mii, i);
 598                         l += snprint(p+l, READSTR-l, " %4.4ux", r);
 599                 }
 600                 snprint(p+l, READSTR-l, "\n");
 601         }
 602
 603         n = readstr(offset, a, n, p);
 604
 605         qunlock(&ctlr->slock);
 606         poperror();
 607         free(p);
 608
 609         return n;
 610 }
 611
 612 static void
 613 rtl8169halt(Ctlr* ctlr)
 614 {
 615         csr8w(ctlr, Cr, 0);
 616
 617         ctlr->imr = 0;
 618         csr16w(ctlr, Imr, 0);
 619         csr16w(ctlr, Isr, ~0);
 620 }
 621
 622 static int
 623 rtl8169reset(Ctlr* ctlr)
 624 {
 625         u32int r;
 626         int timeo;
 627
 628         /*
 629          * Soft reset the controller.
 630          */
 631         csr8w(ctlr, Cr, Rst);
 632         for(r = timeo = 0; timeo < 1000; timeo++){
 633                 r = csr8r(ctlr, Cr);
 634                 if(!(r & Rst))
 635                         break;
 636                 delay(1);
 637         }
 638         rtl8169halt(ctlr);
 639
 640         if(r & Rst)
 641                 return -1;
 642         return 0;
 643 }
 644
 645 static void
 646 rtl8169replenish(Ctlr* ctlr)
 647 {
 648         D *d;
 649         int x;
 650         Block *bp;
 651         u64int pa;
 652
 653         x = ctlr->rdt;
 654         while(NEXT(x, ctlr->nrd) != ctlr->rdh){
 655                 bp = iallocb(Mps);
 656                 if(bp == nil){
 657                         iprint("rtl8169: no available buffers\n");
 658                         break;
 659                 }
 660                 ctlr->rb[x] = bp;
 661                 ctlr->nrq++;
 662                 pa = PCIWADDR(bp->rp);
 663                 d = &ctlr->rd[x];
 664                 d->addrlo = pa;
 665                 d->addrhi = pa >> 32;
 666                 coherence();
 667                 d->control = (d->control & Eor) | Own | BALLOC(bp);
 668                 x = NEXT(x, ctlr->nrd);
 669                 ctlr->rdt = x;
 670         }
 671 }
 672
 673 static void
 674 rtl8169init(Ether* edev)
 675 {
 676         int i;
 677         u32int r;
 678         Block *bp;
 679         Ctlr *ctlr;
 680         u64int pa;
 681         u16int cplusc;
 682
 683         ctlr = edev->ctlr;
 684         ilock(ctlr);
 685         if(rtl8169reset(ctlr) < 0){
 686                 iunlock(ctlr);
 687                 error("reset failed");
 688         }
 689
 690         memset(ctlr->td, 0, sizeof(D)*ctlr->ntd);
 691         ctlr->tdh = ctlr->tdt = ctlr->ntq = 0;
 692         ctlr->td[ctlr->ntd-1].control = Eor;
 693         for(i = 0; i < ctlr->ntd; i++)
 694                 if(bp = ctlr->tb[i]){
 695                         ctlr->tb[i] = nil;
 696                         freeb(bp);
 697                 }
 698
 699         memset(ctlr->rd, 0, sizeof(D)*ctlr->nrd);
 700         ctlr->rdh = ctlr->rdt = ctlr->nrq = 0;
 701         ctlr->rd[ctlr->nrd-1].control = Eor;
 702         for(i = 0; i < ctlr->nrd; i++)
 703                 if(bp = ctlr->rb[i]){
 704                         ctlr->rb[i] = nil;
 705                         freeb(bp);
 706                 }
 707
 708         rtl8169replenish(ctlr);
 709
 710         cplusc = csr16r(ctlr, Cplusc);
 711         cplusc &= ~(Endian|Rxchksum);
 712         cplusc |= Txenb|Mulrw;
 713         switch(ctlr->macv){
 714         case Macv40:
 715         case Macv44:
 716                 cplusc |= Macstatdis;
 717                 break;
 718         default:
 719                 cplusc |= Rxenb;
 720                 break;
 721         }
 722         csr16w(ctlr, Cplusc, cplusc);
 723
 724         pa = PCIWADDR(ctlr->td);
 725         csr32w(ctlr, Tnpds+4, pa>>32);
 726         csr32w(ctlr, Tnpds, pa);
 727
 728         pa = PCIWADDR(ctlr->rd);
 729         csr32w(ctlr, Rdsar+4, pa>>32);
 730         csr32w(ctlr, Rdsar, pa);
 731
 732         csr8w(ctlr, Cr, Te|Re);
 733
 734         csr32w(ctlr, Tcr, Ifg1|Ifg0|Mtxdmaunlimited);
 735         ctlr->tcr = csr32r(ctlr, Tcr);
 736         switch(ctlr->macv){
 737         case Macv42:
 738         case Macv45:
 739                 ctlr->rcr = Rxfth256|Mrxdmaunlimited|Ab|Am|Apm;
 740                 break;
 741         default:
 742                 ctlr->rcr = Rxfthnone|Mrxdmaunlimited|Ab|Am|Apm;
 743                 break;
 744         }
 745         ctlr->mchash = 0;
 746         csr32w(ctlr, Mar0,   0);
 747         csr32w(ctlr, Mar0+4, 0);
 748         csr32w(ctlr, Rcr, ctlr->rcr);
 749
 750         /* maximum packet sizes, unlimited */
 751         csr8w(ctlr, Etx, 0x3f);
 752         csr16w(ctlr, Rms, 0x3fff);
 753
 754         csr16w(ctlr, Coal, 0);
 755
 756         /* no early rx interrupts */
 757         r = csr16r(ctlr, Mulint) & 0xF000;
 758         csr16w(ctlr, Mulint, r);
 759
 760         ctlr->imr = Serr|Fovw|Punlc|Rdu|Ter|Rer|Rok|Tdu;
 761         csr16w(ctlr, Imr, ctlr->imr);
 762
 763         csr32w(ctlr, Mpc, 0);
 764
 765         iunlock(ctlr);
 766 }
 767
 768 static void
 769 rtl8169reseter(void *arg)
 770 {
 771         Ether *edev;
 772         Ctlr *ctlr;
 773
 774         edev = arg;
 775         while(waserror())
 776                 ;
 777         for(;;){
 778                 ctlr = edev->ctlr;
 779                 sleep(&ctlr->reset, return0, nil);
 780                 rtl8169init(edev);
 781         }
 782 }
 783
 784 static void rtl8169interrupt(Ureg*, void* arg);
 785
 786 static void
 787 rtl8169attach(Ether* edev)
 788 {
 789         Ctlr *ctlr;
 790
 791         ctlr = edev->ctlr;
 792         qlock(&ctlr->alock);
 793         if(ctlr->init){
 794                 qunlock(&ctlr->alock);
 795                 return;
 796         }
 797         if(waserror()){
 798                 print("#l%d: rtl8169: %s\n", edev->ctlrno, up->errstr);
 799                 qunlock(&ctlr->alock);
 800                 nexterror();
 801         }
 802         ctlr->ntd = Ntd;
 803         ctlr->nrd = Nrd;
 804
 805         ctlr->tb = malloc(ctlr->ntd*sizeof(Block*));
 806         ctlr->rb = malloc(ctlr->nrd*sizeof(Block*));
 807         ctlr->td = mallocalign(sizeof(D)*ctlr->ntd, 256, 0, 0);
 808         ctlr->rd = mallocalign(sizeof(D)*ctlr->nrd, 256, 0, 0);
 809         ctlr->dtcc = mallocalign(sizeof(Dtcc), 64, 0, 0);
 810         if(waserror()){
 811                 free(ctlr->tb);
 812                 ctlr->tb = nil;
 813                 free(ctlr->rb);
 814                 ctlr->rb = nil;
 815                 free(ctlr->td);
 816                 ctlr->td = nil;
 817                 free(ctlr->rd);
 818                 ctlr->rd = nil;
 819                 free(ctlr->dtcc);
 820                 ctlr->dtcc = nil;
 821                 nexterror();
 822         }
 823
 824         if(ctlr->tb == nil || ctlr->rb == nil
 825         || ctlr->td == nil || ctlr->rd == nil
 826         || ctlr->dtcc == nil)
 827                 error(Enomem);
 828
 829         pcisetbme(ctlr->pcidev);
 830         intrenable(edev->irq, rtl8169interrupt, edev, edev->tbdf, edev->name);
 831         if(waserror()){
 832                 rtl8169halt(ctlr);
 833                 pciclrbme(ctlr->pcidev);
 834                 intrdisable(edev->irq, rtl8169interrupt, edev, edev->tbdf, edev->name);
 835                 nexterror();
 836         }
 837
 838         rtl8169init(edev);
 839         rtl8169mii(edev);
 840         ctlr->init = 1;
 841
 842         poperror();
 843         poperror();
 844
 845         kproc("rtl8169", rtl8169reseter, edev);
 846
 847         qunlock(&ctlr->alock);
 848         poperror();
 849 }
 850
 851 static void
 852 rtl8169link(Ether* edev)
 853 {
 854         uint r;
 855         int limit;
 856         Ctlr *ctlr;
 857
 858         ctlr = edev->ctlr;
 859
 860         r = csr8r(ctlr, Phystatus);
 861         /*
 862          * Maybe the link changed - do we care very much?
 863          * Could stall transmits if no link, maybe?
 864          */
 865         edev->link = (r & Linksts) != 0;
 866
 867         limit = 256*1024;
 868         if(r & Speed10){
 869                 edev->mbps = 10;
 870                 limit = 65*1024;
 871         } else if(r & Speed100)
 872                 edev->mbps = 100;
 873         else if(r & Speed1000)
 874                 edev->mbps = 1000;
 875
 876         if(edev->oq != nil)
 877                 qsetlimit(edev->oq, limit);
 878 }
 879
 880 static void
 881 rtl8169transmit(Ether* edev)
 882 {
 883         D *d;
 884         Block *bp;
 885         Ctlr *ctlr;
 886         u64int pa;
 887         int x;
 888
 889         ctlr = edev->ctlr;
 890
 891         if(!canlock(ctlr))
 892                 return;
 893         for(x = ctlr->tdh; ctlr->ntq > 0; x = NEXT(x, ctlr->ntd)){
 894                 d = &ctlr->td[x];
 895                 if(d->control & Own)
 896                         break;
 897
 898                 /*
 899                  * Free it up.
 900                  * Need to clean the descriptor here? Not really.
 901                  * Simple freeb for now (no chain and freeblist).
 902                  * Use ntq count for now.
 903                  */
 904                 freeb(ctlr->tb[x]);
 905                 ctlr->tb[x] = nil;
 906                 ctlr->ntq--;
 907         }
 908         ctlr->tdh = x;
 909
 910         x = ctlr->tdt;
 911         while(ctlr->ntq < (ctlr->ntd-1)){
 912                 if((bp = qget(edev->oq)) == nil)
 913                         break;
 914
 915                 pa = PCIWADDR(bp->rp);
 916                 d = &ctlr->td[x];
 917                 d->addrlo = pa;
 918                 d->addrhi = pa >> 32;
 919                 coherence();
 920                 d->control = (d->control & Eor) | Own | Fs | Ls | BLEN(bp);
 921
 922                 ctlr->tb[x] = bp;
 923                 ctlr->ntq++;
 924
 925                 x = NEXT(x, ctlr->ntd);
 926         }
 927         if(x != ctlr->tdt)
 928                 ctlr->tdt = x;
 929         else if(ctlr->ntq >= (ctlr->ntd-1))
 930                 ctlr->txdu++;
 931
 932         if(ctlr->ntq > 0){
 933                 coherence();
 934                 csr8w(ctlr, Tppoll, Npq);
 935         }
 936         unlock(ctlr);
 937 }
 938
 939 static void
 940 rtl8169receive(Ether* edev)
 941 {
 942         D *d;
 943         Block *bp;
 944         Ctlr *ctlr;
 945         u32int control;
 946         int x;
 947
 948         ctlr = edev->ctlr;
 949         if(ctlr->nrq < ctlr->nrd/2)
 950                 rtl8169replenish(ctlr);
 951
 952         for(x = ctlr->rdh; x != ctlr->rdt;){
 953                 d = &ctlr->rd[x];
 954                 if((control = d->control) & Own)
 955                         break;
 956
 957                 bp = ctlr->rb[x];
 958                 ctlr->rb[x] = nil;
 959                 ctlr->nrq--;
 960
 961                 x = NEXT(x, ctlr->nrd);
 962                 ctlr->rdh = x;
 963
 964                 if(ctlr->nrq < ctlr->nrd/2)
 965                         rtl8169replenish(ctlr);
 966
 967                 if((control & (Fs|Ls|Res)) == (Fs|Ls)){
 968                         bp->wp = bp->rp + (control & RxflMASK) - 4;
 969
 970                         if(control & Fovf)
 971                                 ctlr->fovf++;
 972                         if(control & Mar)
 973                                 ctlr->mcast++;
 974
 975                         switch(control & (Pid1|Pid0)){
 976                         default:
 977                                 break;
 978                         case Pid0:
 979                                 if(control & Tcpf){
 980                                         ctlr->tcpf++;
 981                                         break;
 982                                 }
 983                                 bp->flag |= Btcpck;
 984                                 break;
 985                         case Pid1:
 986                                 if(control & Udpf){
 987                                         ctlr->udpf++;
 988                                         break;
 989                                 }
 990                                 bp->flag |= Budpck;
 991                                 break;
 992                         case Pid1|Pid0:
 993                                 if(control & Ipf){
 994                                         ctlr->ipf++;
 995                                         break;
 996                                 }
 997                                 bp->flag |= Bipck;
 998                                 break;
 999                         }
1000                         etheriq(edev, bp);
1001                 }else{
1002                         if(!(control & Res))
1003                                 ctlr->frag++;
1004                         freeb(bp);
1005                 }
1006         }
1007 }
1008
1009 static void
1010 rtl8169restart(Ctlr *ctlr)
1011 {
1012         rtl8169halt(ctlr);
1013         wakeup(&ctlr->reset);
1014 }
1015
1016 static void
1017 rtl8169interrupt(Ureg*, void* arg)
1018 {
1019         Ctlr *ctlr;
1020         Ether *edev;
1021         u32int isr;
1022
1023         edev = arg;
1024         ctlr = edev->ctlr;
1025
1026         while((isr = csr16r(ctlr, Isr)) != 0 && isr != 0xFFFF){
1027                 csr16w(ctlr, Isr, isr);
1028                 if((isr & ctlr->imr) == 0)
1029                         break;
1030
1031                 if(isr & Serr)
1032                         ctlr->serr++;
1033                 if(isr & Fovw)
1034                         ctlr->fovw++;
1035                 if(isr & Rer)
1036                         ctlr->rer++;
1037                 if(isr & Rdu)
1038                         ctlr->rdu++;
1039                 if(isr & Punlc)
1040                         ctlr->punlc++;
1041
1042                 if(isr & (Serr|Fovw)){
1043                         rtl8169restart(ctlr);
1044                         break;
1045                 }
1046
1047                 if(isr & (Punlc|Rdu|Rer|Rok))
1048                         rtl8169receive(edev);
1049
1050                 if(isr & (Tdu|Ter|Tok))
1051                         rtl8169transmit(edev);
1052
1053                 if(isr & Punlc)
1054                         rtl8169link(edev);
1055         }
1056 }
1057
1058 static void
1059 rtl8169shutdown(Ether *edev)
1060 {
1061         Ctlr *ctlr = edev->ctlr;
1062
1063         rtl8169halt(ctlr);
1064 }
1065
1066 int
1067 vetmacv(Ctlr *ctlr, uint *macv)
1068 {
1069         *macv = csr32r(ctlr, Tcr) & HwveridMASK;
1070         switch(*macv){
1071         default:
1072                 return -1;
1073         case Macv01:
1074         case Macv02:
1075         case Macv03:
1076         case Macv04:
1077         case Macv05:
1078         case Macv07:
1079         case Macv07a:
1080         case Macv11:
1081         case Macv12:
1082         case Macv12a:
1083         case Macv13:
1084         case Macv14:
1085         case Macv15:
1086         case Macv25:
1087         case Macv26:
1088         case Macv27:
1089         case Macv28:
1090         case Macv29:
1091         case Macv30:
1092         case Macv39:
1093         case Macv40:
1094         case Macv42:
1095         case Macv44:
1096         case Macv45:
1097                 break;
1098         }
1099         return 0;
1100 }
1101
1102 static void
1103 rtl8169pci(void)
1104 {
1105         Pcidev *p;
1106         Ctlr *ctlr;
1107         int i, port, pcie;
1108         uint macv;
1109
1110         p = nil;
1111         while(p = pcimatch(p, 0, 0)){
1112                 if(p->ccrb != 0x02 || p->ccru != 0)
1113                         continue;
1114
1115                 pcie = 0;
1116                 switch(i = ((p->did<<16)|p->vid)){
1117                 default:
1118                         continue;
1119                 case Rtl8100e:                  /* RTL810[01]E ? */
1120                 case Rtl8168b:                  /* RTL8168B */
1121                         pcie = 1;
1122                         break;
1123                 case Rtl8169c:                  /* RTL8169C */
1124                 case Rtl8169sc:                 /* RTL8169SC */
1125                 case Rtl8169:                   /* RTL8169 */
1126                         break;
1127                 case (0xC107<<16)|0x1259:       /* Corega CG-LAPCIGT */
1128                         i = Rtl8169;
1129                         break;
1130                 }
1131
1132                 if(p->mem[0].size == 0 || (p->mem[0].bar & 1) == 0)
1133                         continue;
1134                 port = p->mem[0].bar & ~3;
1135                 if(ioalloc(port, p->mem[0].size, 0, "rtl8169") < 0){
1136                         print("rtl8169: port %#ux in use\n", port);
1137                         continue;
1138                 }
1139
1140                 ctlr = malloc(sizeof(Ctlr));
1141                 if(ctlr == nil){
1142                         print("rtl8169: can't allocate memory\n");
1143                         iofree(port);
1144                         continue;
1145                 }
1146                 ctlr->port = port;
1147                 ctlr->pcidev = p;
1148                 ctlr->pciv = i;
1149                 ctlr->pcie = pcie;
1150
1151                 pcienable(p);
1152                 if(vetmacv(ctlr, &macv) == -1){
1153                         print("rtl8169: %T: unknown mac %.4ux %.8ux\n", p->tbdf, p->did, macv);
1154                         pcidisable(p);
1155                         iofree(port);
1156                         free(ctlr);
1157                         continue;
1158                 }
1159                 rtl8169halt(ctlr);
1160
1161                 /*
1162                  * Extract the chip hardware version,
1163                  * needed to configure each properly.
1164                  */
1165                 ctlr->macv = macv;
1166                 if(rtl8169ctlrhead != nil)
1167                         rtl8169ctlrtail->next = ctlr;
1168                 else
1169                         rtl8169ctlrhead = ctlr;
1170                 rtl8169ctlrtail = ctlr;
1171         }
1172 }
1173
1174 static int
1175 rtl8169pnp(Ether* edev)
1176 {
1177         u32int r;
1178         Ctlr *ctlr;
1179         uchar ea[Eaddrlen];
1180         static int once;
1181
1182         if(once == 0){
1183                 once = 1;
1184                 rtl8169pci();
1185         }
1186
1187         /*
1188          * Any adapter matches if no edev->port is supplied,
1189          * otherwise the ports must match.
1190          */
1191         for(ctlr = rtl8169ctlrhead; ctlr != nil; ctlr = ctlr->next){
1192                 if(ctlr->active)
1193                         continue;
1194                 if(edev->port == 0 || edev->port == ctlr->port){
1195                         ctlr->active = 1;
1196                         break;
1197                 }
1198         }
1199         if(ctlr == nil)
1200                 return -1;
1201
1202         edev->ctlr = ctlr;
1203         edev->port = ctlr->port;
1204         edev->irq = ctlr->pcidev->intl;
1205         edev->tbdf = ctlr->pcidev->tbdf;
1206         edev->mbps = 100;
1207         edev->maxmtu = Mtu;
1208
1209         /*
1210          * Check if the adapter's station address is to be overridden.
1211          * If not, read it from the device and set in edev->ea.
1212          */
1213         memset(ea, 0, Eaddrlen);
1214         if(memcmp(ea, edev->ea, Eaddrlen) == 0){
1215                 r = csr32r(ctlr, Idr0);
1216                 edev->ea[0] = r;
1217                 edev->ea[1] = r>>8;
1218                 edev->ea[2] = r>>16;
1219                 edev->ea[3] = r>>24;
1220                 r = csr32r(ctlr, Idr0+4);
1221                 edev->ea[4] = r;
1222                 edev->ea[5] = r>>8;
1223         }
1224
1225         edev->attach = rtl8169attach;
1226         edev->transmit = rtl8169transmit;
1227         edev->ifstat = rtl8169ifstat;
1228         edev->shutdown = rtl8169shutdown;
1229
1230         edev->arg = edev;
1231         edev->promiscuous = rtl8169promiscuous;
1232         edev->multicast = rtl8169multicast;
1233
1234         rtl8169link(edev);
1235
1236         return 0;
1237 }
1238
1239 void
1240 ether8169link(void)
1241 {
1242         addethercard("rtl8169", rtl8169pnp);
1243 }