sys/src/9/pc/etherdp83820.c

   1 /*
   2  * National Semiconductor DP83820
   3  * 10/100/1000 Mb/s Ethernet Network Interface Controller
   4  * (Gig-NIC).
   5  * Driver assumes little-endian and 32-bit host throughout.
   6  */
   7 #include "u.h"
   8 #include "../port/lib.h"
   9 #include "mem.h"
  10 #include "dat.h"
  11 #include "fns.h"
  12 #include "io.h"
  13 #include "../port/error.h"
  14 #include "../port/netif.h"
  15
  16 #include "etherif.h"
  17 #include "ethermii.h"
  18
  19 enum {                                  /* Registers */
  20         Cr              = 0x00,         /* Command */
  21         Cfg             = 0x04,         /* Configuration and Media Status */
  22         Mear            = 0x08,         /* MII/EEPROM Access */
  23         Ptscr           = 0x0C,         /* PCI Test Control */
  24         Isr             = 0x10,         /* Interrupt Status */
  25         Imr             = 0x14,         /* Interrupt Mask */
  26         Ier             = 0x18,         /* Interrupt Enable */
  27         Ihr             = 0x1C,         /* Interrupt Holdoff */
  28         Txdp            = 0x20,         /* Transmit Descriptor Pointer */
  29         Txdphi          = 0x24,         /* Transmit Descriptor Pointer Hi */
  30         Txcfg           = 0x28,         /* Transmit Configuration */
  31         Gpior           = 0x2C,         /* General Purpose I/O Control */
  32         Rxdp            = 0x30,         /* Receive Descriptor Pointer */
  33         Rxdphi          = 0x34,         /* Receive Descriptor Pointer Hi */
  34         Rxcfg           = 0x38,         /* Receive Configuration */
  35         Pqcr            = 0x3C,         /* Priority Queueing Control */
  36         Wcsr            = 0x40,         /* Wake on LAN Control/Status */
  37         Pcr             = 0x44,         /* Pause Control/Status */
  38         Rfcr            = 0x48,         /* Receive Filter/Match Control */
  39         Rfdr            = 0x4C,         /* Receive Filter/Match Data */
  40         Brar            = 0x50,         /* Boot ROM Address */
  41         Brdr            = 0x54,         /* Boot ROM Data */
  42         Srr             = 0x58,         /* Silicon Revision */
  43         Mibc            = 0x5C,         /* MIB Control */
  44         Mibd            = 0x60,         /* MIB Data */
  45         Txdp1           = 0xA0,         /* Txdp Priority 1 */
  46         Txdp2           = 0xA4,         /* Txdp Priority 2 */
  47         Txdp3           = 0xA8,         /* Txdp Priority 3 */
  48         Rxdp1           = 0xB0,         /* Rxdp Priority 1 */
  49         Rxdp2           = 0xB4,         /* Rxdp Priority 2 */
  50         Rxdp3           = 0xB8,         /* Rxdp Priority 3 */
  51         Vrcr            = 0xBC,         /* VLAN/IP Receive Control */
  52         Vtcr            = 0xC0,         /* VLAN/IP Transmit Control */
  53         Vdr             = 0xC4,         /* VLAN Data */
  54         Ccsr            = 0xCC,         /* Clockrun Control/Status */
  55         Tbicr           = 0xE0,         /* TBI Control */
  56         Tbisr           = 0xE4,         /* TBI Status */
  57         Tanar           = 0xE8,         /* TBI ANAR */
  58         Tanlpar         = 0xEC,         /* TBI ANLPAR */
  59         Taner           = 0xF0,         /* TBI ANER */
  60         Tesr            = 0xF4,         /* TBI ESR */
  61 };
  62
  63 enum {                                  /* Cr */
  64         Txe             = 0x00000001,   /* Transmit Enable */
  65         Txd             = 0x00000002,   /* Transmit Disable */
  66         Rxe             = 0x00000004,   /* Receiver Enable */
  67         Rxd             = 0x00000008,   /* Receiver Disable */
  68         Txr             = 0x00000010,   /* Transmitter Reset */
  69         Rxr             = 0x00000020,   /* Receiver Reset */
  70         Swien           = 0x00000080,   /* Software Interrupt Enable */
  71         Rst             = 0x00000100,   /* Reset */
  72         TxpriSHFT       = 9,            /* Tx Priority Queue Select */
  73         TxpriMASK       = 0x00001E00,
  74         RxpriSHFT       = 13,           /* Rx Priority Queue Select */
  75         RxpriMASK       = 0x0001E000,
  76 };
  77
  78 enum {                                  /* Configuration and Media Status */
  79         Bem             = 0x00000001,   /* Big Endian Mode */
  80         Ext125          = 0x00000002,   /* External 125MHz reference Select */
  81         Bromdis         = 0x00000004,   /* Disable Boot ROM interface */
  82         Pesel           = 0x00000008,   /* Parity Error Detection Action */
  83         Exd             = 0x00000010,   /* Excessive Deferral Abort */
  84         Pow             = 0x00000020,   /* Program Out of Window Timer */
  85         Sb              = 0x00000040,   /* Single Back-off */
  86         Reqalg          = 0x00000080,   /* PCI Bus Request Algorithm */
  87         Extstsen        = 0x00000100,   /* Extended Status Enable */
  88         Phydis          = 0x00000200,   /* Disable PHY */
  89         Phyrst          = 0x00000400,   /* Reset PHY */
  90         M64addren       = 0x00000800,   /* Master 64-bit Addressing Enable */
  91         Data64en        = 0x00001000,   /* 64-bit Data Enable */
  92         Pci64det        = 0x00002000,   /* PCI 64-bit Bus Detected */
  93         T64addren       = 0x00004000,   /* Target 64-bit Addressing Enable */
  94         Mwidis          = 0x00008000,   /* MWI Disable */
  95         Mrmdis          = 0x00010000,   /* MRM Disable */
  96         Tmrtest         = 0x00020000,   /* Timer Test Mode */
  97         Spdstsien       = 0x00040000,   /* PHY Spdsts Interrupt Enable */
  98         Lnkstsien       = 0x00080000,   /* PHY Lnksts Interrupt Enable */
  99         Dupstsien       = 0x00100000,   /* PHY Dupsts Interrupt Enable */
 100         Mode1000        = 0x00400000,   /* 1000Mb/s Mode Control */
 101         Tbien           = 0x01000000,   /* Ten-Bit Interface Enable */
 102         Dupsts          = 0x10000000,   /* Full Duplex Status */
 103         Spdsts100       = 0x20000000,   /* SPEED100 Input Pin Status */
 104         Spdsts1000      = 0x40000000,   /* SPEED1000 Input Pin Status */
 105         Lnksts          = 0x80000000,   /* Link Status */
 106 };
 107
 108 enum {                                  /* MII/EEPROM Access */
 109         Eedi            = 0x00000001,   /* EEPROM Data In */
 110         Eedo            = 0x00000002,   /* EEPROM Data Out */
 111         Eeclk           = 0x00000004,   /* EEPROM Serial Clock */
 112         Eesel           = 0x00000008,   /* EEPROM Chip Select */
 113         Mdio            = 0x00000010,   /* MII Management Data */
 114         Mddir           = 0x00000020,   /* MII Management Direction */
 115         Mdc             = 0x00000040,   /* MII Management Clock */
 116 };
 117
 118 enum {                                  /* Interrupts */
 119         Rxok            = 0x00000001,   /* Rx OK */
 120         Rxdesc          = 0x00000002,   /* Rx Descriptor */
 121         Rxerr           = 0x00000004,   /* Rx Packet Error */
 122         Rxearly         = 0x00000008,   /* Rx Early Threshold */
 123         Rxidle          = 0x00000010,   /* Rx Idle */
 124         Rxorn           = 0x00000020,   /* Rx Overrun */
 125         Txok            = 0x00000040,   /* Tx Packet OK */
 126         Txdesc          = 0x00000080,   /* Tx Descriptor */
 127         Txerr           = 0x00000100,   /* Tx Packet Error */
 128         Txidle          = 0x00000200,   /* Tx Idle */
 129         Txurn           = 0x00000400,   /* Tx Underrun */
 130         Mib             = 0x00000800,   /* MIB Service */
 131         Swi             = 0x00001000,   /* Software Interrupt */
 132         Pme             = 0x00002000,   /* Power Management Event */
 133         Phy             = 0x00004000,   /* PHY Interrupt */
 134         Hibint          = 0x00008000,   /* High Bits Interrupt Set */
 135         Rxsovr          = 0x00010000,   /* Rx Status FIFO Overrun */
 136         Rtabt           = 0x00020000,   /* Received Target Abort */
 137         Rmabt           = 0x00040000,   /* Received Master Abort */
 138         Sserr           = 0x00080000,   /* Signalled System Error */
 139         Dperr           = 0x00100000,   /* Detected Parity Error */
 140         Rxrcmp          = 0x00200000,   /* Receive Reset Complete */
 141         Txrcmp          = 0x00400000,   /* Transmit Reset Complete */
 142         Rxdesc0         = 0x00800000,   /* Rx Descriptor for Priority Queue 0 */
 143         Rxdesc1         = 0x01000000,   /* Rx Descriptor for Priority Queue 1 */
 144         Rxdesc2         = 0x02000000,   /* Rx Descriptor for Priority Queue 2 */
 145         Rxdesc3         = 0x04000000,   /* Rx Descriptor for Priority Queue 3 */
 146         Txdesc0         = 0x08000000,   /* Tx Descriptor for Priority Queue 0 */
 147         Txdesc1         = 0x10000000,   /* Tx Descriptor for Priority Queue 1 */
 148         Txdesc2         = 0x20000000,   /* Tx Descriptor for Priority Queue 2 */
 149         Txdesc3         = 0x40000000,   /* Tx Descriptor for Priority Queue 3 */
 150 };
 151
 152 enum {                                  /* Interrupt Enable */
 153         Ien             = 0x00000001,   /* Interrupt Enable */
 154 };
 155
 156 enum {                                  /* Interrupt Holdoff */
 157         IhSHFT          = 0,            /* Interrupt Holdoff */
 158         IhMASK          = 0x000000FF,
 159         Ihctl           = 0x00000100,   /* Interrupt Holdoff Control */
 160 };
 161
 162 enum {                                  /* Transmit Configuration */
 163         TxdrthSHFT      = 0,            /* Tx Drain Threshold */
 164         TxdrthMASK      = 0x000000FF,
 165         FlthSHFT        = 16,           /* Tx Fill Threshold */
 166         FlthMASK        = 0x0000FF00,
 167         Brstdis         = 0x00080000,   /* 1000Mb/s Burst Disable */
 168         MxdmaSHFT       = 20,           /* Max Size per Tx DMA Burst */
 169         MxdmaMASK       = 0x00700000,
 170         Ecretryen       = 0x00800000,   /* Excessive Collision Retry Enable */
 171         Atp             = 0x10000000,   /* Automatic Transmit Padding */
 172         Mlb             = 0x20000000,   /* MAC Loopback */
 173         Hbi             = 0x40000000,   /* Heartbeat Ignore */
 174         Csi             = 0x80000000,   /* Carrier Sense Ignore */
 175 };
 176
 177 enum {                                  /* Receive Configuration */
 178         RxdrthSHFT      = 1,            /* Rx Drain Threshold */
 179         RxdrthMASK      = 0x0000003E,
 180         Airl            = 0x04000000,   /* Accept In-Range Length Errored */
 181         Alp             = 0x08000000,   /* Accept Long Packets */
 182         Rxfd            = 0x10000000,   /* Receive Full Duplex */
 183         Stripcrc        = 0x20000000,   /* Strip CRC */
 184         Arp             = 0x40000000,   /* Accept Runt Packets */
 185         Aep             = 0x80000000,   /* Accept Errored Packets */
 186 };
 187
 188 enum {                                  /* Priority Queueing Control */
 189         Txpqen          = 0x00000001,   /* Transmit Priority Queuing Enable */
 190         Txfairen        = 0x00000002,   /* Transmit Fairness Enable */
 191         RxpqenSHFT      = 2,            /* Receive Priority Queue Enable */
 192         RxpqenMASK      = 0x0000000C,
 193 };
 194
 195 enum {                                  /* Pause Control/Status */
 196         PscntSHFT       = 0,            /* Pause Counter Value */
 197         PscntMASK       = 0x0000FFFF,
 198         Pstx            = 0x00020000,   /* Transmit Pause Frame */
 199         PsffloSHFT      = 18,           /* Rx Data FIFO Lo Threshold */
 200         PsffloMASK      = 0x000C0000,
 201         PsffhiSHFT      = 20,           /* Rx Data FIFO Hi Threshold */
 202         PsffhiMASK      = 0x00300000,
 203         PsstloSHFT      = 22,           /* Rx Stat FIFO Hi Threshold */
 204         PsstloMASK      = 0x00C00000,
 205         PssthiSHFT      = 24,           /* Rx Stat FIFO Hi Threshold */
 206         PssthiMASK      = 0x03000000,
 207         Psrcvd          = 0x08000000,   /* Pause Frame Received */
 208         Psact           = 0x10000000,   /* Pause Active */
 209         Psda            = 0x20000000,   /* Pause on Destination Address */
 210         Psmcast         = 0x40000000,   /* Pause on Multicast */
 211         Psen            = 0x80000000,   /* Pause Enable */
 212 };
 213
 214 enum {                                  /* Receive Filter/Match Control */
 215         RfaddrSHFT      = 0,            /* Extended Register Address */
 216         RfaddrMASK      = 0x000003FF,
 217         Ulm             = 0x00080000,   /* U/L bit mask */
 218         Uhen            = 0x00100000,   /* Unicast Hash Enable */
 219         Mhen            = 0x00200000,   /* Multicast Hash Enable */
 220         Aarp            = 0x00400000,   /* Accept ARP Packets */
 221         ApatSHFT        = 23,           /* Accept on Pattern Match */
 222         ApatMASK        = 0x07800000,
 223         Apm             = 0x08000000,   /* Accept on Perfect Match */
 224         Aau             = 0x10000000,   /* Accept All Unicast */
 225         Aam             = 0x20000000,   /* Accept All Multicast */
 226         Aab             = 0x40000000,   /* Accept All Broadcast */
 227         Rfen            = 0x80000000,   /* Rx Filter Enable */
 228 };
 229
 230 enum {                                  /* Receive Filter/Match Data */
 231         RfdataSHFT      = 0,            /* Receive Filter Data */
 232         RfdataMASK      = 0x0000FFFF,
 233         BmaskSHFT       = 16,           /* Byte Mask */
 234         BmaskMASK       = 0x00030000,
 235 };
 236
 237 enum {                                  /* MIB Control */
 238         Wrn             = 0x00000001,   /* Warning Test Indicator */
 239         Frz             = 0x00000002,   /* Freeze All Counters */
 240         Aclr            = 0x00000004,   /* Clear All Counters */
 241         Mibs            = 0x00000008,   /* MIB Counter Strobe */
 242 };
 243
 244 enum {                                  /* MIB Data */
 245         Nmibd           = 11,           /* Number of MIB Data Registers */
 246 };
 247
 248 enum {                                  /* VLAN/IP Receive Control */
 249         Vtden           = 0x00000001,   /* VLAN Tag Detection Enable */
 250         Vtren           = 0x00000002,   /* VLAN Tag Removal Enable */
 251         Dvtf            = 0x00000004,   /* Discard VLAN Tagged Frames */
 252         Dutf            = 0x00000008,   /* Discard Untagged Frames */
 253         Ipen            = 0x00000010,   /* IP Checksum Enable */
 254         Ripe            = 0x00000020,   /* Reject IP Checksum Errors */
 255         Rtcpe           = 0x00000040,   /* Reject TCP Checksum Errors */
 256         Rudpe           = 0x00000080,   /* Reject UDP Checksum Errors */
 257 };
 258
 259 enum {                                  /* VLAN/IP Transmit Control */
 260         Vgti            = 0x00000001,   /* VLAN Global Tag Insertion */
 261         Vppti           = 0x00000002,   /* VLAN Per-Packet Tag Insertion */
 262         Gchk            = 0x00000004,   /* Global Checksum Generation */
 263         Ppchk           = 0x00000008,   /* Per-Packet Checksum Generation */
 264 };
 265
 266 enum {                                  /* VLAN Data */
 267         VtypeSHFT       = 0,            /* VLAN Type Field */
 268         VtypeMASK       = 0x0000FFFF,
 269         VtciSHFT        = 16,           /* VLAN Tag Control Information */
 270         VtciMASK        = 0xFFFF0000,
 271 };
 272
 273 enum {                                  /* Clockrun Control/Status */
 274         Clkrunen        = 0x00000001,   /* CLKRUN Enable */
 275         Pmeen           = 0x00000100,   /* PME Enable */
 276         Pmests          = 0x00008000,   /* PME Status */
 277 };
 278
 279 typedef struct {
 280         u32int  link;                   /* Link to the next descriptor */
 281         u32int  bufptr;                 /* pointer to data Buffer */
 282         int     cmdsts;                 /* Command/Status */
 283         int     extsts;                 /* optional Extended Status */
 284
 285         Block*  bp;                     /* Block containing bufptr */
 286         u32int  unused;                 /* pad to 64-bit */
 287 } Desc;
 288
 289 enum {                                  /* Common cmdsts bits */
 290         SizeMASK        = 0x0000FFFF,   /* Descriptor Byte Count */
 291         SizeSHFT        = 0,
 292         Ok              = 0x08000000,   /* Packet OK */
 293         Crc             = 0x10000000,   /* Suppress/Include CRC */
 294         Intr            = 0x20000000,   /* Interrupt on ownership transfer */
 295         More            = 0x40000000,   /* not last descriptor in a packet */
 296         Own             = 0x80000000,   /* Descriptor Ownership */
 297 };
 298
 299 enum {                                  /* Transmit cmdsts bits */
 300         CcntMASK        = 0x000F0000,   /* Collision Count */
 301         CcntSHFT        = 16,
 302         Ec              = 0x00100000,   /* Excessive Collisions */
 303         Owc             = 0x00200000,   /* Out of Window Collision */
 304         Ed              = 0x00400000,   /* Excessive Deferral */
 305         Td              = 0x00800000,   /* Transmit Deferred */
 306         Crs             = 0x01000000,   /* Carrier Sense Lost */
 307         Tfu             = 0x02000000,   /* Transmit FIFO Underrun */
 308         Txa             = 0x04000000,   /* Transmit Abort */
 309 };
 310
 311 enum {                                  /* Receive cmdsts bits */
 312         Irl             = 0x00010000,   /* In-Range Length Error */
 313         Lbp             = 0x00020000,   /* Loopback Packet */
 314         Fae             = 0x00040000,   /* Frame Alignment Error */
 315         Crce            = 0x00080000,   /* CRC Error */
 316         Ise             = 0x00100000,   /* Invalid Symbol Error */
 317         Runt            = 0x00200000,   /* Runt Packet Received */
 318         Long            = 0x00400000,   /* Too Long Packet Received */
 319         DestMASK        = 0x01800000,   /* Destination Class */
 320         DestSHFT        = 23,
 321         Rxo             = 0x02000000,   /* Receive Overrun */
 322         Rxa             = 0x04000000,   /* Receive Aborted */
 323 };
 324
 325 enum {                                  /* extsts bits */
 326         EvtciMASK       = 0x0000FFFF,   /* VLAN Tag Control Information */
 327         EvtciSHFT       = 0,
 328         Vpkt            = 0x00010000,   /* VLAN Packet */
 329         Ippkt           = 0x00020000,   /* IP Packet */
 330         Iperr           = 0x00040000,   /* IP Checksum Error */
 331         Tcppkt          = 0x00080000,   /* TCP Packet */
 332         Tcperr          = 0x00100000,   /* TCP Checksum Error */
 333         Udppkt          = 0x00200000,   /* UDP Packet */
 334         Udperr          = 0x00400000,   /* UDP Checksum Error */
 335 };
 336
 337 enum {
 338         Nrd             = 256,
 339         Nrb             = 4*Nrd,
 340         Rbsz            = ROUNDUP(sizeof(Etherpkt)+8, 8),
 341         Ntd             = 128,
 342 };
 343
 344 typedef struct Ctlr Ctlr;
 345 typedef struct Ctlr {
 346         int     port;
 347         Pcidev* pcidev;
 348         Ctlr*   next;
 349         int     active;
 350         int     id;
 351
 352         int     eepromsz;               /* address size in bits */
 353         ushort* eeprom;
 354
 355         int*    nic;
 356         int     cfg;
 357         int     imr;
 358
 359         QLock   alock;                  /* attach */
 360         Lock    ilock;                  /* init */
 361         void*   alloc;                  /* base of per-Ctlr allocated data */
 362
 363         Mii*    mii;
 364
 365         Lock    rdlock;                 /* receive */
 366         Desc*   rd;
 367         int     nrd;
 368         int     nrb;
 369         int     rdx;
 370         int     rxcfg;
 371
 372         Lock    tlock;                  /* transmit */
 373         Desc*   td;
 374         int     ntd;
 375         int     tdh;
 376         int     tdt;
 377         int     ntq;
 378         int     txcfg;
 379
 380         int     rxidle;
 381
 382         uint    mibd[Nmibd];
 383
 384         int     ec;
 385         int     owc;
 386         int     ed;
 387         int     crs;
 388         int     tfu;
 389         int     txa;
 390 } Ctlr;
 391
 392 #define csr32r(c, r)    (*((c)->nic+((r)/4)))
 393 #define csr32w(c, r, v) (*((c)->nic+((r)/4)) = (v))
 394
 395 static Ctlr* dp83820ctlrhead;
 396 static Ctlr* dp83820ctlrtail;
 397
 398 static Lock dp83820rblock;              /* free receive Blocks */
 399 static Block* dp83820rbpool;
 400
 401 static char* dp83820mibs[Nmibd] = {
 402         "RXErroredPkts",
 403         "RXFCSErrors",
 404         "RXMsdPktErrors",
 405         "RXFAErrors",
 406         "RXSymbolErrors",
 407         "RXFrameToLong",
 408         "RXIRLErrors",
 409         "RXBadOpcodes",
 410         "RXPauseFrames",
 411         "TXPauseFrames",
 412         "TXSQEErrors",
 413 };
 414
 415 static int
 416 mdior(Ctlr* ctlr, int n)
 417 {
 418         int data, i, mear, r;
 419
 420         mear = csr32r(ctlr, Mear);
 421         r = ~(Mdc|Mddir) & mear;
 422         data = 0;
 423         for(i = n-1; i >= 0; i--){
 424                 if(csr32r(ctlr, Mear) & Mdio)
 425                         data |= (1<<i);
 426                 csr32w(ctlr, Mear, Mdc|r);
 427                 csr32w(ctlr, Mear, r);
 428         }
 429         csr32w(ctlr, Mear, mear);
 430
 431         return data;
 432 }
 433
 434 static void
 435 mdiow(Ctlr* ctlr, int bits, int n)
 436 {
 437         int i, mear, r;
 438
 439         mear = csr32r(ctlr, Mear);
 440         r = Mddir|(~Mdc & mear);
 441         for(i = n-1; i >= 0; i--){
 442                 if(bits & (1<<i))
 443                         r |= Mdio;
 444                 else
 445                         r &= ~Mdio;
 446                 csr32w(ctlr, Mear, r);
 447                 csr32w(ctlr, Mear, Mdc|r);
 448         }
 449         csr32w(ctlr, Mear, mear);
 450 }
 451
 452 static int
 453 dp83820miimir(Mii* mii, int pa, int ra)
 454 {
 455         int data;
 456         Ctlr *ctlr;
 457
 458         ctlr = mii->ctlr;
 459
 460         /*
 461          * MII Management Interface Read.
 462          *
 463          * Preamble;
 464          * ST+OP+PA+RA;
 465          * LT + 16 data bits.
 466          */
 467         mdiow(ctlr, 0xFFFFFFFF, 32);
 468         mdiow(ctlr, 0x1800|(pa<<5)|ra, 14);
 469         data = mdior(ctlr, 18);
 470
 471         if(data & 0x10000)
 472                 return -1;
 473
 474         return data & 0xFFFF;
 475 }
 476
 477 static int
 478 dp83820miimiw(Mii* mii, int pa, int ra, int data)
 479 {
 480         Ctlr *ctlr;
 481
 482         ctlr = mii->ctlr;
 483
 484         /*
 485          * MII Management Interface Write.
 486          *
 487          * Preamble;
 488          * ST+OP+PA+RA+LT + 16 data bits;
 489          * Z.
 490          */
 491         mdiow(ctlr, 0xFFFFFFFF, 32);
 492         data &= 0xFFFF;
 493         data |= (0x05<<(5+5+2+16))|(pa<<(5+2+16))|(ra<<(2+16))|(0x02<<16);
 494         mdiow(ctlr, data, 32);
 495
 496         return 0;
 497 }
 498
 499 static Block *
 500 dp83820rballoc(Desc* desc)
 501 {
 502         Block *bp;
 503
 504         if(desc->bp == nil){
 505                 ilock(&dp83820rblock);
 506                 if((bp = dp83820rbpool) == nil){
 507                         iunlock(&dp83820rblock);
 508                         desc->bp = nil;
 509                         desc->cmdsts = Own;
 510                         return nil;
 511                 }
 512                 dp83820rbpool = bp->next;
 513                 bp->next = nil;
 514                 iunlock(&dp83820rblock);
 515
 516                 desc->bufptr = PCIWADDR(bp->rp);
 517                 desc->bp = bp;
 518         }
 519         else{
 520                 bp = desc->bp;
 521                 bp->rp = bp->lim - Rbsz;
 522                 bp->wp = bp->rp;
 523         }
 524
 525         coherence();
 526         desc->cmdsts = Intr|Rbsz;
 527
 528         return bp;
 529 }
 530
 531 static void
 532 dp83820rbfree(Block *bp)
 533 {
 534         bp->rp = bp->lim - Rbsz;
 535         bp->wp = bp->rp;
 536
 537         ilock(&dp83820rblock);
 538         bp->next = dp83820rbpool;
 539         dp83820rbpool = bp;
 540         iunlock(&dp83820rblock);
 541 }
 542
 543 static void
 544 dp83820halt(Ctlr* ctlr)
 545 {
 546         int i, timeo;
 547
 548         ilock(&ctlr->ilock);
 549         csr32w(ctlr, Imr, 0);
 550         csr32w(ctlr, Ier, 0);
 551         csr32w(ctlr, Cr, Rxd|Txd);
 552         for(timeo = 0; timeo < 1000; timeo++){
 553                 if(!(csr32r(ctlr, Cr) & (Rxe|Txe)))
 554                         break;
 555                 microdelay(1);
 556         }
 557         csr32w(ctlr, Mibc, Frz);
 558         iunlock(&ctlr->ilock);
 559
 560         if(ctlr->rd != nil){
 561                 for(i = 0; i < ctlr->nrd; i++){
 562                         if(ctlr->rd[i].bp == nil)
 563                                 continue;
 564                         freeb(ctlr->rd[i].bp);
 565                         ctlr->rd[i].bp = nil;
 566                 }
 567         }
 568         if(ctlr->td != nil){
 569                 for(i = 0; i < ctlr->ntd; i++){
 570                         if(ctlr->td[i].bp == nil)
 571                                 continue;
 572                         freeb(ctlr->td[i].bp);
 573                         ctlr->td[i].bp = nil;
 574                 }
 575         }
 576 }
 577
 578 static void
 579 dp83820cfg(Ctlr* ctlr)
 580 {
 581         int cfg;
 582
 583         /*
 584          * Don't know how to deal with a TBI yet.
 585          */
 586         if(ctlr->mii == nil)
 587                 return;
 588
 589         /*
 590          * The polarity of these bits is at the mercy
 591          * of the board designer.
 592          * The correct answer for all speed and duplex questions
 593          * should be to query the phy.
 594          */
 595         cfg = csr32r(ctlr, Cfg);
 596         if(!(cfg & Dupsts)){
 597                 ctlr->rxcfg |= Rxfd;
 598                 ctlr->txcfg |= Csi|Hbi;
 599                 iprint("83820: full duplex, ");
 600         }
 601         else{
 602                 ctlr->rxcfg &= ~Rxfd;
 603                 ctlr->txcfg &= ~(Csi|Hbi);
 604                 iprint("83820: half duplex, ");
 605         }
 606         csr32w(ctlr, Rxcfg, ctlr->rxcfg);
 607         csr32w(ctlr, Txcfg, ctlr->txcfg);
 608
 609         switch(cfg & (Spdsts1000|Spdsts100)){
 610         case Spdsts1000:                /* 100Mbps */
 611         default:                        /* 10Mbps */
 612                 ctlr->cfg &= ~Mode1000;
 613                 if((cfg & (Spdsts1000|Spdsts100)) == Spdsts1000)
 614                         iprint("100Mb/s\n");
 615                 else
 616                         iprint("10Mb/s\n");
 617                 break;
 618         case Spdsts100:                 /* 1Gbps */
 619                 ctlr->cfg |= Mode1000;
 620                 iprint("1Gb/s\n");
 621                 break;
 622         }
 623         csr32w(ctlr, Cfg, ctlr->cfg);
 624 }
 625
 626 static void
 627 dp83820init(Ether* edev)
 628 {
 629         int i;
 630         Ctlr *ctlr;
 631         Desc *desc;
 632         uchar *alloc;
 633
 634         ctlr = edev->ctlr;
 635
 636         dp83820halt(ctlr);
 637
 638         /*
 639          * Receiver
 640          */
 641         alloc = (uchar*)ROUNDUP((ulong)ctlr->alloc, 8);
 642         ctlr->rd = (Desc*)alloc;
 643         alloc += ctlr->nrd*sizeof(Desc);
 644         memset(ctlr->rd, 0, ctlr->nrd*sizeof(Desc));
 645         ctlr->rdx = 0;
 646         for(i = 0; i < ctlr->nrd; i++){
 647                 desc = &ctlr->rd[i];
 648                 desc->link = PCIWADDR(&ctlr->rd[NEXT(i, ctlr->nrd)]);
 649                 if(dp83820rballoc(desc) == nil)
 650                         continue;
 651         }
 652         csr32w(ctlr, Rxdphi, 0);
 653         csr32w(ctlr, Rxdp, PCIWADDR(ctlr->rd));
 654
 655         for(i = 0; i < Eaddrlen; i += 2){
 656                 csr32w(ctlr, Rfcr, i);
 657                 csr32w(ctlr, Rfdr, (edev->ea[i+1]<<8)|edev->ea[i]);
 658         }
 659         csr32w(ctlr, Rfcr, Rfen|Aab|Aam|Apm);
 660
 661         ctlr->rxcfg = Stripcrc|(((2*(ETHERMINTU+4))/8)<<RxdrthSHFT);
 662         ctlr->imr |= Rxorn|Rxidle|Rxearly|Rxdesc|Rxok;
 663
 664         /*
 665          * Transmitter.
 666          */
 667         ctlr->td = (Desc*)alloc;
 668         memset(ctlr->td, 0, ctlr->ntd*sizeof(Desc));
 669         ctlr->tdh = ctlr->tdt = ctlr->ntq = 0;
 670         for(i = 0; i < ctlr->ntd; i++){
 671                 desc = &ctlr->td[i];
 672                 desc->link = PCIWADDR(&ctlr->td[NEXT(i, ctlr->ntd)]);
 673         }
 674         csr32w(ctlr, Txdphi, 0);
 675         csr32w(ctlr, Txdp, PCIWADDR(ctlr->td));
 676
 677         ctlr->txcfg = Atp|(((2*(ETHERMINTU+4))/32)<<FlthSHFT)|((4096/32)<<TxdrthSHFT);
 678         ctlr->imr |= Txurn|Txidle|Txdesc|Txok;
 679
 680         ilock(&ctlr->ilock);
 681
 682         dp83820cfg(ctlr);
 683
 684         csr32w(ctlr, Mibc, Aclr);
 685         ctlr->imr |= Mib;
 686
 687         csr32w(ctlr, Imr, ctlr->imr);
 688
 689         /* try coalescing adjacent interrupts; use hold-off interval of 100µs */
 690         csr32w(ctlr, Ihr, Ihctl|(1<<IhSHFT));
 691
 692         csr32w(ctlr, Ier, Ien);
 693         csr32w(ctlr, Cr, Rxe|Txe);
 694
 695         iunlock(&ctlr->ilock);
 696 }
 697
 698 static void
 699 dp83820attach(Ether* edev)
 700 {
 701         Block *bp;
 702         Ctlr *ctlr;
 703
 704         ctlr = edev->ctlr;
 705         qlock(&ctlr->alock);
 706         if(ctlr->alloc != nil){
 707                 qunlock(&ctlr->alock);
 708                 return;
 709         }
 710
 711         if(waserror()){
 712                 if(ctlr->mii != nil){
 713                         free(ctlr->mii);
 714                         ctlr->mii = nil;
 715                 }
 716                 if(ctlr->alloc != nil){
 717                         free(ctlr->alloc);
 718                         ctlr->alloc = nil;
 719                 }
 720                 qunlock(&ctlr->alock);
 721                 nexterror();
 722         }
 723
 724         if(!(ctlr->cfg & Tbien)){
 725                 if((ctlr->mii = malloc(sizeof(Mii))) == nil)
 726                         error(Enomem);
 727                 ctlr->mii->ctlr = ctlr;
 728                 ctlr->mii->mir = dp83820miimir;
 729                 ctlr->mii->miw = dp83820miimiw;
 730                 if(mii(ctlr->mii, ~0) == 0)
 731                         error("no PHY");
 732                 ctlr->cfg |= Dupstsien|Lnkstsien|Spdstsien;
 733                 ctlr->imr |= Phy;
 734         }
 735
 736         ctlr->nrd = Nrd;
 737         ctlr->nrb = Nrb;
 738         ctlr->ntd = Ntd;
 739         ctlr->alloc = mallocz((ctlr->nrd+ctlr->ntd)*sizeof(Desc) + 7, 0);
 740         if(ctlr->alloc == nil)
 741                 error(Enomem);
 742
 743         for(ctlr->nrb = 0; ctlr->nrb < Nrb; ctlr->nrb++){
 744                 if((bp = allocb(Rbsz)) == nil)
 745                         break;
 746                 bp->free = dp83820rbfree;
 747                 dp83820rbfree(bp);
 748         }
 749
 750         dp83820init(edev);
 751
 752         qunlock(&ctlr->alock);
 753         poperror();
 754 }
 755
 756 static void
 757 dp83820transmit(Ether* edev)
 758 {
 759         Block *bp;
 760         Ctlr *ctlr;
 761         Desc *desc;
 762         int cmdsts, r, x;
 763
 764         ctlr = edev->ctlr;
 765
 766         ilock(&ctlr->tlock);
 767
 768         bp = nil;
 769         for(x = ctlr->tdh; ctlr->ntq; x = NEXT(x, ctlr->ntd)){
 770                 desc = &ctlr->td[x];
 771                 if((cmdsts = desc->cmdsts) & Own)
 772                         break;
 773                 if(!(cmdsts & Ok)){
 774                         if(cmdsts & Ec)
 775                                 ctlr->ec++;
 776                         if(cmdsts & Owc)
 777                                 ctlr->owc++;
 778                         if(cmdsts & Ed)
 779                                 ctlr->ed++;
 780                         if(cmdsts & Crs)
 781                                 ctlr->crs++;
 782                         if(cmdsts & Tfu)
 783                                 ctlr->tfu++;
 784                         if(cmdsts & Txa)
 785                                 ctlr->txa++;
 786                         edev->oerrs++;
 787                 }
 788                 desc->bp->next = bp;
 789                 bp = desc->bp;
 790                 desc->bp = nil;
 791
 792                 ctlr->ntq--;
 793         }
 794         ctlr->tdh = x;
 795         if(bp != nil)
 796                 freeblist(bp);
 797
 798         x = ctlr->tdt;
 799         while(ctlr->ntq < (ctlr->ntd-1)){
 800                 if((bp = qget(edev->oq)) == nil)
 801                         break;
 802
 803                 desc = &ctlr->td[x];
 804                 desc->bufptr = PCIWADDR(bp->rp);
 805                 desc->bp = bp;
 806                 ctlr->ntq++;
 807                 coherence();
 808                 desc->cmdsts = Own|Intr|BLEN(bp);
 809
 810                 x = NEXT(x, ctlr->ntd);
 811         }
 812         if(x != ctlr->tdt){
 813                 ctlr->tdt = x;
 814                 r = csr32r(ctlr, Cr);
 815                 csr32w(ctlr, Cr, Txe|r);
 816         }
 817
 818         iunlock(&ctlr->tlock);
 819 }
 820
 821 static void
 822 dp83820interrupt(Ureg*, void* arg)
 823 {
 824         Block *bp;
 825         Ctlr *ctlr;
 826         Desc *desc;
 827         Ether *edev;
 828         int cmdsts, i, isr, r, x;
 829
 830         edev = arg;
 831         ctlr = edev->ctlr;
 832
 833         for(isr = csr32r(ctlr, Isr); isr & ctlr->imr; isr = csr32r(ctlr, Isr)){
 834                 if(isr & (Rxorn|Rxidle|Rxearly|Rxerr|Rxdesc|Rxok)){
 835                         x = ctlr->rdx;
 836                         desc = &ctlr->rd[x];
 837                         while((cmdsts = desc->cmdsts) & Own){
 838                                 if((cmdsts & Ok) && desc->bp != nil){
 839                                         bp = desc->bp;
 840                                         desc->bp = nil;
 841                                         bp->wp += cmdsts & SizeMASK;
 842                                         etheriq(edev, bp, 1);
 843                                 }
 844                                 else if(0 && !(cmdsts & Ok)){
 845                                         iprint("dp83820: rx %8.8uX:", cmdsts);
 846                                         bp = desc->bp;
 847                                         for(i = 0; i < 20; i++)
 848                                                 iprint(" %2.2uX", bp->rp[i]);
 849                                         iprint("\n");
 850                                 }
 851                                 dp83820rballoc(desc);
 852
 853                                 x = NEXT(x, ctlr->nrd);
 854                                 desc = &ctlr->rd[x];
 855                         }
 856                         ctlr->rdx = x;
 857
 858                         if(isr & Rxidle){
 859                                 r = csr32r(ctlr, Cr);
 860                                 csr32w(ctlr, Cr, Rxe|r);
 861                                 ctlr->rxidle++;
 862                         }
 863
 864                         isr &= ~(Rxorn|Rxidle|Rxearly|Rxerr|Rxdesc|Rxok);
 865                 }
 866
 867                 if(isr & Txurn){
 868                         x = (ctlr->txcfg & TxdrthMASK)>>TxdrthSHFT;
 869                         r = (ctlr->txcfg & FlthMASK)>>FlthSHFT;
 870                         if(x < ((TxdrthMASK)>>TxdrthSHFT)
 871                         && x < (2048/32 - r)){
 872                                 ctlr->txcfg &= ~TxdrthMASK;
 873                                 x++;
 874                                 ctlr->txcfg |= x<<TxdrthSHFT;
 875                                 csr32w(ctlr, Txcfg, ctlr->txcfg);
 876                         }
 877                 }
 878
 879                 if(isr & (Txurn|Txidle|Txdesc|Txok)){
 880                         dp83820transmit(edev);
 881                         isr &= ~(Txurn|Txidle|Txdesc|Txok);
 882                 }
 883
 884                 if(isr & Mib){
 885                         for(i = 0; i < Nmibd; i++){
 886                                 r = csr32r(ctlr, Mibd+(i*sizeof(int)));
 887                                 ctlr->mibd[i] += r & 0xFFFF;
 888                         }
 889                         isr &= ~Mib;
 890                 }
 891
 892                 if((isr & Phy) && ctlr->mii != nil){
 893                         ctlr->mii->mir(ctlr->mii, 1, Bmsr);
 894                         print("phy: cfg %8.8uX bmsr %4.4uX\n",
 895                                 csr32r(ctlr, Cfg),
 896                                 ctlr->mii->mir(ctlr->mii, 1, Bmsr));
 897                         dp83820cfg(ctlr);
 898                         isr &= ~Phy;
 899                 }
 900                 if(isr)
 901                         iprint("dp83820: isr %8.8uX\n", isr);
 902         }
 903 }
 904
 905 static long
 906 dp83820ifstat(Ether* edev, void* a, long n, ulong offset)
 907 {
 908         char *p;
 909         Ctlr *ctlr;
 910         int i, l, r;
 911
 912         ctlr = edev->ctlr;
 913
 914         edev->crcs = ctlr->mibd[Mibd+(1*sizeof(int))];
 915         edev->frames = ctlr->mibd[Mibd+(3*sizeof(int))];
 916         edev->buffs = ctlr->mibd[Mibd+(5*sizeof(int))];
 917         edev->overflows = ctlr->mibd[Mibd+(2*sizeof(int))];
 918
 919         if(n == 0)
 920                 return 0;
 921
 922         p = smalloc(READSTR);
 923         l = 0;
 924         for(i = 0; i < Nmibd; i++){
 925                 r = csr32r(ctlr, Mibd+(i*sizeof(int)));
 926                 ctlr->mibd[i] += r & 0xFFFF;
 927                 if(ctlr->mibd[i] != 0 && dp83820mibs[i] != nil)
 928                         l += snprint(p+l, READSTR-l, "%s: %ud %ud\n",
 929                                 dp83820mibs[i], ctlr->mibd[i], r);
 930         }
 931         l += snprint(p+l, READSTR-l, "rxidle %d\n", ctlr->rxidle);
 932         l += snprint(p+l, READSTR-l, "ec %d\n", ctlr->ec);
 933         l += snprint(p+l, READSTR-l, "owc %d\n", ctlr->owc);
 934         l += snprint(p+l, READSTR-l, "ed %d\n", ctlr->ed);
 935         l += snprint(p+l, READSTR-l, "crs %d\n", ctlr->crs);
 936         l += snprint(p+l, READSTR-l, "tfu %d\n", ctlr->tfu);
 937         l += snprint(p+l, READSTR-l, "txa %d\n", ctlr->txa);
 938
 939         l += snprint(p+l, READSTR-l, "rom:");
 940         for(i = 0; i < 0x10; i++){
 941                 if(i && ((i & 0x07) == 0))
 942                         l += snprint(p+l, READSTR-l, "\n    ");
 943                 l += snprint(p+l, READSTR-l, " %4.4uX", ctlr->eeprom[i]);
 944         }
 945         l += snprint(p+l, READSTR-l, "\n");
 946
 947         if(ctlr->mii != nil && ctlr->mii->curphy != nil){
 948                 l += snprint(p+l, READSTR-l, "phy:");
 949                 for(i = 0; i < NMiiPhyr; i++){
 950                         if(i && ((i & 0x07) == 0))
 951                                 l += snprint(p+l, READSTR-l, "\n    ");
 952                         r = miimir(ctlr->mii, i);
 953                         l += snprint(p+l, READSTR-l, " %4.4uX", r);
 954                 }
 955                 snprint(p+l, READSTR-l, "\n");
 956         }
 957
 958         n = readstr(offset, a, n, p);
 959         free(p);
 960
 961         return n;
 962 }
 963
 964 static void
 965 dp83820promiscuous(void* arg, int on)
 966 {
 967         USED(arg, on);
 968 }
 969
 970 /* multicast already on, don't need to do anything */
 971 static void
 972 dp83820multicast(void*, uchar*, int)
 973 {
 974 }
 975
 976 static int
 977 dp83820detach(Ctlr* ctlr)
 978 {
 979         /*
 980          * Soft reset the controller.
 981          */
 982         csr32w(ctlr, Cr, Rst);
 983         delay(1);
 984         while(csr32r(ctlr, Cr) & Rst)
 985                 delay(1);
 986         return 0;
 987 }
 988
 989 static void
 990 dp83820shutdown(Ether* ether)
 991 {
 992 print("dp83820shutdown\n");
 993         dp83820detach(ether->ctlr);
 994 }
 995
 996 static int
 997 atc93c46r(Ctlr* ctlr, int address)
 998 {
 999         int data, i, mear, r, size;
1000
1001         /*
1002          * Analog Technology, Inc. ATC93C46
1003          * or equivalent serial EEPROM.
1004          */
1005         mear = csr32r(ctlr, Mear);
1006         mear &= ~(Eesel|Eeclk|Eedo|Eedi);
1007         r = Eesel|mear;
1008
1009 reread:
1010         csr32w(ctlr, Mear, r);
1011         data = 0x06;
1012         for(i = 3-1; i >= 0; i--){
1013                 if(data & (1<<i))
1014                         r |= Eedi;
1015                 else
1016                         r &= ~Eedi;
1017                 csr32w(ctlr, Mear, r);
1018                 csr32w(ctlr, Mear, Eeclk|r);
1019                 microdelay(1);
1020                 csr32w(ctlr, Mear, r);
1021                 microdelay(1);
1022         }
1023
1024         /*
1025          * First time through must work out the EEPROM size.
1026          */
1027         if((size = ctlr->eepromsz) == 0)
1028                 size = 8;
1029
1030         for(size = size-1; size >= 0; size--){
1031                 if(address & (1<<size))
1032                         r |= Eedi;
1033                 else
1034                         r &= ~Eedi;
1035                 csr32w(ctlr, Mear, r);
1036                 microdelay(1);
1037                 csr32w(ctlr, Mear, Eeclk|r);
1038                 microdelay(1);
1039                 csr32w(ctlr, Mear, r);
1040                 microdelay(1);
1041                 if(!(csr32r(ctlr, Mear) & Eedo))
1042                         break;
1043         }
1044         r &= ~Eedi;
1045
1046         data = 0;
1047         for(i = 16-1; i >= 0; i--){
1048                 csr32w(ctlr, Mear, Eeclk|r);
1049                 microdelay(1);
1050                 if(csr32r(ctlr, Mear) & Eedo)
1051                         data |= (1<<i);
1052                 csr32w(ctlr, Mear, r);
1053                 microdelay(1);
1054         }
1055
1056         csr32w(ctlr, Mear, mear);
1057
1058         if(ctlr->eepromsz == 0){
1059                 ctlr->eepromsz = 8-size;
1060                 ctlr->eeprom = malloc((1<<ctlr->eepromsz)*sizeof(ushort));
1061                 goto reread;
1062         }
1063
1064         return data;
1065 }
1066
1067 static int
1068 dp83820reset(Ctlr* ctlr)
1069 {
1070         int i, r;
1071         unsigned char sum;
1072
1073         /*
1074          * Soft reset the controller;
1075          * read the EEPROM to get the initial settings
1076          * of the Cfg and Gpior bits which should be cleared by
1077          * the reset.
1078          */
1079         dp83820detach(ctlr);
1080
1081         atc93c46r(ctlr, 0);
1082         if(ctlr->eeprom == nil) {
1083                 print("dp83820reset: no eeprom\n");
1084                 return -1;
1085         }
1086         sum = 0;
1087         for(i = 0; i < 0x0E; i++){
1088                 r = atc93c46r(ctlr, i);
1089                 ctlr->eeprom[i] = r;
1090                 sum += r;
1091                 sum += r>>8;
1092         }
1093
1094         if(sum != 0){
1095                 print("dp83820reset: bad EEPROM checksum\n");
1096                 return -1;
1097         }
1098
1099 #ifdef notdef
1100         csr32w(ctlr, Gpior, ctlr->eeprom[4]);
1101
1102         cfg = Extstsen|Exd;
1103         r = csr32r(ctlr, Cfg);
1104         if(ctlr->eeprom[5] & 0x0001)
1105                 cfg |= Ext125;
1106         if(ctlr->eeprom[5] & 0x0002)
1107                 cfg |= M64addren;
1108         if((ctlr->eeprom[5] & 0x0004) && (r & Pci64det))
1109                 cfg |= Data64en;
1110         if(ctlr->eeprom[5] & 0x0008)
1111                 cfg |= T64addren;
1112         if(!(pcicfgr16(ctlr->pcidev, PciPCR) & 0x10))
1113                 cfg |= Mwidis;
1114         if(ctlr->eeprom[5] & 0x0020)
1115                 cfg |= Mrmdis;
1116         if(ctlr->eeprom[5] & 0x0080)
1117                 cfg |= Mode1000;
1118         if(ctlr->eeprom[5] & 0x0200)
1119                 cfg |= Tbien|Mode1000;
1120         /*
1121          * What about RO bits we might have destroyed with Rst?
1122          * What about Exd, Tmrtest, Extstsen, Pintctl?
1123          * Why does it think it has detected a 64-bit bus when
1124          * it hasn't?
1125          */
1126 #else
1127         // r = csr32r(ctlr, Cfg);
1128         // r &= ~(Mode1000|T64addren|Data64en|M64addren);
1129         // csr32w(ctlr, Cfg, r);
1130         // csr32w(ctlr, Cfg, 0x2000);
1131 #endif                                          /* notdef */
1132         ctlr->cfg = csr32r(ctlr, Cfg);
1133 print("cfg %8.8uX pcicfg %8.8uX\n", ctlr->cfg, pcicfgr32(ctlr->pcidev, PciPCR));
1134         ctlr->cfg &= ~(T64addren|Data64en|M64addren);
1135         csr32w(ctlr, Cfg, ctlr->cfg);
1136         csr32w(ctlr, Mibc, Aclr|Frz);
1137
1138         return 0;
1139 }
1140
1141 static void
1142 dp83820pci(void)
1143 {
1144         void *mem;
1145         Pcidev *p;
1146         Ctlr *ctlr;
1147
1148         p = nil;
1149         while(p = pcimatch(p, 0, 0)){
1150                 if(p->ccrb != Pcibcnet || p->ccru != Pciscether)
1151                         continue;
1152
1153                 switch((p->did<<16)|p->vid){
1154                 default:
1155                         continue;
1156                 case (0x0022<<16)|0x100B:       /* DP83820 (Gig-NIC) */
1157                         break;
1158                 }
1159
1160                 mem = vmap(p->mem[1].bar & ~0x0F, p->mem[1].size);
1161                 if(mem == 0){
1162                         print("DP83820: can't map %8.8luX\n", p->mem[1].bar);
1163                         continue;
1164                 }
1165
1166                 ctlr = malloc(sizeof(Ctlr));
1167                 if(ctlr == nil){
1168                         print("DP83820: can't allocate memory\n");
1169                         continue;
1170                 }
1171                 ctlr->port = p->mem[1].bar & ~0x0F;
1172                 ctlr->pcidev = p;
1173                 ctlr->id = (p->did<<16)|p->vid;
1174
1175                 ctlr->nic = mem;
1176                 if(dp83820reset(ctlr)){
1177                         free(ctlr);
1178                         continue;
1179                 }
1180                 pcisetbme(p);
1181
1182                 if(dp83820ctlrhead != nil)
1183                         dp83820ctlrtail->next = ctlr;
1184                 else
1185                         dp83820ctlrhead = ctlr;
1186                 dp83820ctlrtail = ctlr;
1187         }
1188 }
1189
1190 static int
1191 dp83820pnp(Ether* edev)
1192 {
1193         int i;
1194         Ctlr *ctlr;
1195         uchar ea[Eaddrlen];
1196
1197         if(dp83820ctlrhead == nil)
1198                 dp83820pci();
1199
1200         /*
1201          * Any adapter matches if no edev->port is supplied,
1202          * otherwise the ports must match.
1203          */
1204         for(ctlr = dp83820ctlrhead; ctlr != nil; ctlr = ctlr->next){
1205                 if(ctlr->active)
1206                         continue;
1207                 if(edev->port == 0 || edev->port == ctlr->port){
1208                         ctlr->active = 1;
1209                         break;
1210                 }
1211         }
1212         if(ctlr == nil)
1213                 return -1;
1214
1215         edev->ctlr = ctlr;
1216         edev->port = ctlr->port;
1217         edev->irq = ctlr->pcidev->intl;
1218         edev->tbdf = ctlr->pcidev->tbdf;
1219         edev->mbps = 1000;
1220
1221         /*
1222          * Check if the adapter's station address is to be overridden.
1223          * If not, read it from the EEPROM and set in ether->ea prior to
1224          * loading the station address in the hardware.
1225          */
1226         memset(ea, 0, Eaddrlen);
1227         if(memcmp(ea, edev->ea, Eaddrlen) == 0)
1228                 for(i = 0; i < Eaddrlen/2; i++){
1229                         edev->ea[2*i] = ctlr->eeprom[0x0C-i];
1230                         edev->ea[2*i+1] = ctlr->eeprom[0x0C-i]>>8;
1231                 }
1232
1233         edev->attach = dp83820attach;
1234         edev->transmit = dp83820transmit;
1235         edev->interrupt = dp83820interrupt;
1236         edev->ifstat = dp83820ifstat;
1237
1238         edev->arg = edev;
1239         edev->promiscuous = dp83820promiscuous;
1240         edev->multicast = dp83820multicast;
1241         edev->shutdown = dp83820shutdown;
1242
1243         return 0;
1244 }
1245
1246 void
1247 etherdp83820link(void)
1248 {
1249         addethercard("DP83820", dp83820pnp);
1250 }