sys/src/9/pc/etherbcm.c

   1 /*
   2  * Broadcom BCM57xx
   3  * Not implemented:
   4  *  proper fatal error handling
   5  *  multiple rings
   6  *  QoS
   7  *  checksum offloading
   8  */
   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/error.h"
  17 #include "../port/netif.h"
  18
  19 #include "etherif.h"
  20
  21 #define Rbsz            ROUNDUP(sizeof(Etherpkt)+4, 4)
  22
  23 typedef struct Ctlr Ctlr;
  24 struct Ctlr {
  25         Lock txlock, imlock;
  26         Ctlr *link;
  27         Pcidev *pdev;
  28         ulong *nic, *status;
  29         /* One Ring to find them, One Ring to bring them all and in the darkness bind them */
  30         ulong *recvret, *recvprod, *sendr;
  31         ulong port;
  32         ulong recvreti, recvprodi, sendri, sendcleani;
  33         Block **sends;
  34         int active, duplex;
  35 };
  36
  37 enum {
  38         RecvRetRingLen = 0x200,
  39         RecvProdRingLen = 0x200,
  40         SendRingLen = 0x200,
  41 };
  42
  43 enum {
  44         Reset = 1<<0,
  45         Enable = 1<<1,
  46         Attn = 1<<2,
  47
  48         PowerControlStatus = 0x4C,
  49
  50         MiscHostCtl = 0x68,
  51         ClearIntA = 1<<0,
  52         MaskPCIInt = 1<<1,
  53         ByteSwap = 1<<2,
  54         WordSwap = 1<<3,
  55         EnablePCIStateRegister = 1<<4,
  56         EnableClockControlRegister = 1<<5,
  57         IndirectAccessEnable = 1<<7,
  58         TaggedStatus = 1<<9,
  59
  60         DMARWControl = 0x6C,
  61         DMAWatermarkMask = ~(7<<19),
  62         DMAWatermarkValue = 3<<19,
  63
  64         MemoryWindow = 0x7C,
  65         MemoryWindowData = 0x84,
  66
  67         SendRCB = 0x100,
  68         RecvRetRCB = 0x200,
  69
  70         InterruptMailbox = 0x204,
  71
  72         RecvProdBDRingIndex = 0x26c,
  73         RecvBDRetRingIndex = 0x284,
  74         SendBDRingHostIndex = 0x304,
  75
  76         MACMode = 0x400,
  77         MACPortMask = ~((1<<3)|(1<<2)),
  78         MACPortGMII = 1<<3,
  79         MACPortMII = 1<<2,
  80         MACEnable = (1<<23) | (1<<22) | (1<<21) | (1 << 15) | (1 << 14) | (1<<12) | (1<<11),
  81         MACHalfDuplex = 1<<1,
  82
  83         MACEventStatus = 0x404,
  84         MACEventEnable = 0x408,
  85         MACAddress = 0x410,
  86         EthernetRandomBackoff = 0x438,
  87         ReceiveMTU = 0x43C,
  88         MIComm = 0x44C,
  89         MIStatus = 0x450,
  90         MIMode = 0x454,
  91         ReceiveMACMode = 0x468,
  92         TransmitMACMode = 0x45C,
  93         TransmitMACLengths = 0x464,
  94         MACHash = 0x470,
  95         ReceiveRules = 0x480,
  96
  97         ReceiveRulesConfiguration = 0x500,
  98         LowWatermarkMaximum = 0x504,
  99         LowWatermarkMaxMask = ~0xFFFF,
 100         LowWatermarkMaxValue = 2,
 101
 102         SendDataInitiatorMode = 0xC00,
 103         SendInitiatorConfiguration = 0x0C08,
 104         SendStats = 1<<0,
 105         SendInitiatorMask = 0x0C0C,
 106
 107         SendDataCompletionMode = 0x1000,
 108         SendBDSelectorMode = 0x1400,
 109         SendBDInitiatorMode = 0x1800,
 110         SendBDCompletionMode = 0x1C00,
 111
 112         ReceiveListPlacementMode = 0x2000,
 113         ReceiveListPlacement = 0x2010,
 114         ReceiveListPlacementConfiguration = 0x2014,
 115         ReceiveStats = 1<<0,
 116         ReceiveListPlacementMask = 0x2018,
 117
 118         ReceiveDataBDInitiatorMode = 0x2400,
 119         ReceiveBDHostAddr = 0x2450,
 120         ReceiveBDFlags = 0x2458,
 121         ReceiveBDNIC = 0x245C,
 122         ReceiveDataCompletionMode = 0x2800,
 123         ReceiveBDInitiatorMode = 0x2C00,
 124         ReceiveBDRepl = 0x2C18,
 125
 126         ReceiveBDCompletionMode = 0x3000,
 127         HostCoalescingMode = 0x3C00,
 128         HostCoalescingRecvTicks = 0x3C08,
 129         HostCoalescingSendTicks = 0x3C0C,
 130         RecvMaxCoalescedFrames = 0x3C10,
 131         SendMaxCoalescedFrames = 0x3C14,
 132         RecvMaxCoalescedFramesInt = 0x3C20,
 133         SendMaxCoalescedFramesInt = 0x3C24,
 134         StatusBlockHostAddr = 0x3C38,
 135         FlowAttention = 0x3C48,
 136
 137         MemArbiterMode = 0x4000,
 138
 139         BufferManMode = 0x4400,
 140
 141         MBUFLowWatermark = 0x4414,
 142         MBUFHighWatermark = 0x4418,
 143
 144         ReadDMAMode = 0x4800,
 145         ReadDMAStatus = 0x4804,
 146         WriteDMAMode = 0x4C00,
 147         WriteDMAStatus = 0x4C04,
 148
 149         RISCState = 0x5004,
 150         FTQReset = 0x5C00,
 151         MSIMode = 0x6000,
 152
 153         ModeControl = 0x6800,
 154         ByteWordSwap = (1<<4)|(1<<5)|(1<<2),//|(1<<1),
 155         HostStackUp = 1<<16,
 156         HostSendBDs = 1<<17,
 157         InterruptOnMAC = 1<<26,
 158
 159         MiscConfiguration = 0x6804,
 160         CoreClockBlocksReset = 1<<0,
 161         GPHYPowerDownOverride = 1<<26,
 162         DisableGRCResetOnPCIE = 1<<29,
 163         TimerMask = ~0xFF,
 164         TimerValue = 65<<1,
 165         MiscLocalControl = 0x6808,
 166         InterruptOnAttn = 1<<3,
 167         AutoSEEPROM = 1<<24,
 168
 169         SwArbitration = 0x7020,
 170         SwArbitSet1 = 1<<1,
 171         SwArbitWon1 = 1<<9,
 172         TLPControl = 0x7C00,
 173
 174         PhyControl = 0x00,
 175         PhyStatus = 0x01,
 176         PhyLinkStatus = 1<<2,
 177         PhyAutoNegComplete = 1<<5,
 178         PhyPartnerStatus = 0x05,
 179         Phy100FD = 1<<8,
 180         Phy100HD = 1<<7,
 181         Phy10FD = 1<<6,
 182         Phy10HD = 1<<5,
 183         PhyGbitStatus = 0x0A,
 184         Phy1000FD = 1<<12,
 185         Phy1000HD = 1<<11,
 186         PhyAuxControl = 0x18,
 187         PhyIntStatus = 0x1A,
 188         PhyIntMask = 0x1B,
 189
 190         Updated = 1<<0,
 191         LinkStateChange = 1<<1,
 192         Error = 1<<2,
 193
 194         PacketEnd = 1<<2,
 195         FrameError = 1<<10,
 196 };
 197
 198 enum {
 199         BCM5752 = 0x1600,
 200         BCM5752M = 0x1601,
 201         BCM5709 = 0x1639,
 202         BCM5709S = 0x163a,
 203         BCM5716 = 0x163b,
 204         BCM5716S = 0x163c,
 205         BCM5700 = 0x1644,
 206         BCM5701 = 0x1645,
 207         BCM5702 = 0x1646,
 208         BCM5703 = 0x1647,
 209         BCM5704 = 0x1648,
 210         BCM5704S_2 = 0x1649,
 211         BCM5706 = 0x164a,
 212         BCM5708 = 0x164c,
 213         BCM5702FE = 0x164d,
 214         BCM57710 = 0x164e,
 215         BCM57711 = 0x164f,
 216         BCM57711E = 0x1650,
 217         BCM5705 = 0x1653,
 218         BCM5705_2 = 0x1654,
 219         BCM5717 = 0x1655,
 220         BCM5718 = 0x1656,
 221         BCM5720 = 0x1658,
 222         BCM5721 = 0x1659,
 223         BCM5722 = 0x165a,
 224         BCM5723 = 0x165b,
 225         BCM5724 = 0x165c,
 226         BCM5705M = 0x165d,
 227         BCM5705M_2 = 0x165e,
 228         BCM5714 = 0x1668,
 229         BCM5780 = 0x166a,
 230         BCM5780S = 0x166b,
 231         BCM5754M = 0x1672,
 232         BCM5755M = 0x1673,
 233         BCM5756ME = 0x1674,
 234         BCM5750 = 0x1676,
 235         BCM5751 = 0x1677,
 236         BCM5715 = 0x1678,
 237         BCM5715S = 0x1679,
 238         BCM5754 = 0x167a,
 239         BCM5755 = 0x167b,
 240         BCM5750M = 0x167c,
 241         BCM5751M = 0x167d,
 242         BCM5751F = 0x167e,
 243         BCM5787F = 0x167f,
 244         BCM5761e = 0x1680,
 245         BCM5761 = 0x1681,
 246         BCM5764M = 0x1684,
 247         BCM57760 = 0x1690,
 248         BCM57788 = 0x1691,
 249         BCM57780 = 0x1692,
 250         BCM5787M = 0x1693,
 251         BCM57790 = 0x1694,
 252         BCM5782 = 0x1696,
 253         BCM5784M = 0x1698,
 254         BCM5785 = 0x1699,
 255         BCM5786 = 0x169a,
 256         BCM5787 = 0x169b,
 257         BCM5788 = 0x169c,
 258         BCM5789 = 0x169d,
 259         BCM5785 = 0x16a0,
 260         BCM5702X = 0x16a6,
 261         BCM5703X = 0x16a7,
 262         BCM5704S = 0x16a8,
 263         BCM5706S = 0x16aa,
 264         BCM5708S = 0x16ac,
 265         BCM57761 = 0x16b0,
 266         BCM57781 = 0x16b1,
 267         BCM57791 = 0x16b2,
 268         BCM57765 = 0x16b4,
 269         BCM57785 = 0x16b5,
 270         BCM57795 = 0x16b6,
 271         BCM5702A3 = 0x16c6,
 272         BCM5703 = 0x16c7,
 273         BCM5781 = 0x16dd,
 274         BCM5753 = 0x16f7,
 275         BCM5753M = 0x16fd,
 276         BCM5753F = 0x16fe,
 277         BCM5906 = 0x1712,
 278         BCM5906M = 0x1713,
 279 };
 280
 281 #define csr32(c, r)     ((c)->nic[(r)/4])
 282 #define mem32(c, r) csr32(c, (r)+0x8000)
 283
 284 static Ctlr *bcmhead, *bcmtail;
 285
 286 static ulong
 287 dummyread(ulong x)
 288 {
 289         return x;
 290 }
 291
 292 static int
 293 miir(Ctlr *ctlr, int ra)
 294 {
 295         while(csr32(ctlr, MIComm) & (1<<29));
 296         csr32(ctlr, MIComm) = (ra << 16) | (1 << 21) | (1 << 27) | (1 << 29);
 297         while(csr32(ctlr, MIComm) & (1<<29));
 298         if(csr32(ctlr, MIComm) & (1<<28)) return -1;
 299         return csr32(ctlr, MIComm) & 0xFFFF;
 300 }
 301
 302 static int
 303 miiw(Ctlr *ctlr, int ra, int value)
 304 {
 305         while(csr32(ctlr, MIComm) & (1<<29));
 306         csr32(ctlr, MIComm) = (value & 0xFFFF) | (ra << 16) | (1 << 21) | (1 << 27) | (1 << 29);
 307         while(csr32(ctlr, MIComm) & (1<<29));
 308         return 0;
 309 }
 310
 311 static void
 312 checklink(Ether *edev)
 313 {
 314         Ctlr *ctlr;
 315         ulong i;
 316
 317         ctlr = edev->ctlr;
 318         miir(ctlr, PhyStatus); /* dummy read necessary */
 319         if(!(miir(ctlr, PhyStatus) & PhyLinkStatus)) {
 320                 edev->link = 0;
 321                 edev->mbps = 1000;
 322                 ctlr->duplex = 1;
 323                 print("bcm: no link\n");
 324                 goto out;
 325         }
 326         edev->link = 1;
 327         while((miir(ctlr, PhyStatus) & PhyAutoNegComplete) == 0);
 328         i = miir(ctlr, PhyGbitStatus);
 329         if(i & (Phy1000FD | Phy1000HD)) {
 330                 edev->mbps = 1000;
 331                 ctlr->duplex = (i & Phy1000FD) != 0;
 332         } else if(i = miir(ctlr, PhyPartnerStatus), i & (Phy100FD | Phy100HD)) {
 333                 edev->mbps = 100;
 334                 ctlr->duplex = (i & Phy100FD) != 0;
 335         } else if(i & (Phy10FD | Phy10HD)) {
 336                 edev->mbps = 10;
 337                 ctlr->duplex = (i & Phy10FD) != 0;
 338         } else {
 339                 edev->link = 0;
 340                 edev->mbps = 1000;
 341                 ctlr->duplex = 1;
 342                 print("bcm: link partner supports neither 10/100/1000 Mbps\n");
 343                 goto out;
 344         }
 345         print("bcm: %d Mbps link, %s duplex\n", edev->mbps, ctlr->duplex ? "full" : "half");
 346 out:
 347         if(ctlr->duplex) csr32(ctlr, MACMode) &= ~MACHalfDuplex;
 348         else csr32(ctlr, MACMode) |= MACHalfDuplex;
 349         if(edev->mbps >= 1000)
 350                 csr32(ctlr, MACMode) = (csr32(ctlr, MACMode) & MACPortMask) | MACPortGMII;
 351         else
 352                 csr32(ctlr, MACMode) = (csr32(ctlr, MACMode) & MACPortMask) | MACPortMII;
 353         csr32(ctlr, MACEventStatus) |= (1<<4) | (1<<3); /* undocumented bits (sync and config changed) */
 354 }
 355
 356 static ulong*
 357 currentrecvret(Ctlr *ctlr)
 358 {
 359         if(ctlr->recvreti == (ctlr->status[4] & 0xFFFF)) return 0;
 360         return ctlr->recvret + ctlr->recvreti * 8;
 361 }
 362
 363 static void
 364 consumerecvret(Ctlr *ctlr)
 365 {
 366         csr32(ctlr, RecvBDRetRingIndex) = ctlr->recvreti = (ctlr->recvreti + 1) & (RecvRetRingLen - 1);
 367 }
 368
 369 static int
 370 replenish(Ctlr *ctlr)
 371 {
 372         ulong *next;
 373         ulong incr;
 374         Block *bp;
 375
 376         incr = (ctlr->recvprodi + 1) & (RecvProdRingLen - 1);
 377         if(incr == (ctlr->status[2] >> 16)) return -1;
 378         bp = iallocb(Rbsz);
 379         if(bp == nil) {
 380                 print("bcm: out of memory for receive buffers\n");
 381                 return -1;
 382         }
 383         next = ctlr->recvprod + ctlr->recvprodi * 8;
 384         memset(next, 0, 32);
 385         next[1] = PADDR(bp->rp);
 386         next[2] = Rbsz;
 387         next[7] = (ulong) bp;
 388         coherence();
 389         csr32(ctlr, RecvProdBDRingIndex) = ctlr->recvprodi = incr;
 390         return 0;
 391 }
 392
 393 static void
 394 bcmreceive(Ether *edev)
 395 {
 396         Ctlr *ctlr;
 397         Block *bp;
 398         ulong *pkt, len;
 399
 400         ctlr = edev->ctlr;
 401         for(; pkt = currentrecvret(ctlr); replenish(ctlr), consumerecvret(ctlr)) {
 402                 bp = (Block*) pkt[7];
 403                 len = pkt[2] & 0xFFFF;
 404                 bp->wp = bp->rp + len;
 405                 if((pkt[3] & PacketEnd) == 0) print("bcm: partial frame received -- shouldn't happen\n");
 406                 if(pkt[3] & FrameError) {
 407                         freeb(bp); /* dump erroneous packets */
 408                 } else {
 409                         etheriq(edev, bp, 1);
 410                 }
 411         }
 412 }
 413
 414 static void
 415 bcmtransclean(Ether *edev, int dolock)
 416 {
 417         Ctlr *ctlr;
 418
 419         ctlr = edev->ctlr;
 420         if(dolock)
 421                 ilock(&ctlr->txlock);
 422         while(ctlr->sendcleani != (ctlr->status[4] >> 16)) {
 423                 freeb(ctlr->sends[ctlr->sendcleani]);
 424                 ctlr->sends[ctlr->sendcleani] = 0;
 425                 ctlr->sendcleani = (ctlr->sendcleani + 1) & (SendRingLen - 1);
 426         }
 427         if(dolock)
 428                 iunlock(&ctlr->txlock);
 429 }
 430
 431 static void
 432 bcmtransmit(Ether *edev)
 433 {
 434         Ctlr *ctlr;
 435         Block *bp;
 436         ulong *next;
 437         ulong incr;
 438
 439         ctlr = edev->ctlr;
 440         ilock(&ctlr->txlock);
 441         while(1) {
 442                 incr = (ctlr->sendri + 1) & (SendRingLen - 1);
 443                 if(incr == (ctlr->status[4] >> 16)) {
 444                         print("bcm: send queue full\n");
 445                         break;
 446                 }
 447                 bp = qget(edev->oq);
 448                 if(bp == nil) break;
 449                 setmalloctag(bp, (ulong)(void*)bcmtransmit);
 450                 next = ctlr->sendr + ctlr->sendri * 4;
 451                 next[0] = 0;
 452                 next[1] = PADDR(bp->rp);
 453                 next[2] = (BLEN(bp) << 16) | PacketEnd;
 454                 next[3] = 0;
 455                 if(ctlr->sends[ctlr->sendri] != 0)
 456                         freeb(ctlr->sends[ctlr->sendri]);
 457                 ctlr->sends[ctlr->sendri] = bp;
 458                 coherence();
 459                 csr32(ctlr, SendBDRingHostIndex) = ctlr->sendri = incr;
 460         }
 461         iunlock(&ctlr->txlock);
 462 }
 463
 464 static void
 465 bcmerror(Ether *edev)
 466 {
 467         Ctlr *ctlr;
 468
 469         ctlr = edev->ctlr;
 470         if(csr32(ctlr, FlowAttention)) {
 471                 if(csr32(ctlr, FlowAttention) & 0xF8FF8080UL) {
 472                         panic("bcm: fatal error %#.8ulx", csr32(ctlr, FlowAttention));
 473                 }
 474                 csr32(ctlr, FlowAttention) = 0;
 475         }
 476         csr32(ctlr, MACEventStatus) = 0; /* worth ignoring */
 477         if(csr32(ctlr, ReadDMAStatus) || csr32(ctlr, WriteDMAStatus)) {
 478                 print("bcm: DMA error\n");
 479                 csr32(ctlr, ReadDMAStatus) = 0;
 480                 csr32(ctlr, WriteDMAStatus) = 0;
 481         }
 482         if(csr32(ctlr, RISCState)) {
 483                 if(csr32(ctlr, RISCState) & 0x78000403) {
 484                         panic("bcm: RISC halted %#.8ulx", csr32(ctlr, RISCState));
 485                 }
 486                 csr32(ctlr, RISCState) = 0;
 487         }
 488 }
 489
 490 static void
 491 bcminterrupt(Ureg*, void *arg)
 492 {
 493         Ether *edev;
 494         Ctlr *ctlr;
 495         ulong status, tag;
 496
 497         edev = arg;
 498         ctlr = edev->ctlr;
 499         ilock(&ctlr->imlock);
 500         dummyread(csr32(ctlr, InterruptMailbox));
 501         csr32(ctlr, InterruptMailbox) = 1;
 502         status = ctlr->status[0];
 503         tag = ctlr->status[1];
 504         ctlr->status[0] = 0;
 505         if(status & Error) bcmerror(edev);
 506         if(status & LinkStateChange) checklink(edev);
 507 //      print("bcm: interrupt %8ulx %8ulx\n", ctlr->status[2], ctlr->status[4]);
 508         bcmreceive(edev);
 509         bcmtransclean(edev, 1);
 510         bcmtransmit(edev);
 511         csr32(ctlr, InterruptMailbox) = tag << 24;
 512         iunlock(&ctlr->imlock);
 513 }
 514
 515 static int
 516 bcminit(Ether *edev)
 517 {
 518         ulong i, j;
 519         Ctlr *ctlr;
 520
 521         ctlr = edev->ctlr;
 522         print("bcm: reset\n");
 523         /* initialization procedure according to the datasheet */
 524         csr32(ctlr, MiscHostCtl) |= MaskPCIInt | ClearIntA;
 525         csr32(ctlr, SwArbitration) |= SwArbitSet1;
 526         for(i = 0; i < 10000 && (csr32(ctlr, SwArbitration) & SwArbitWon1) == 0; i++)
 527                 microdelay(100);
 528         if(i == 10000){
 529                 iprint("bcm: arbiter failed to respond\n");
 530                 return -1;
 531         }
 532         csr32(ctlr, MemArbiterMode) |= Enable;
 533         csr32(ctlr, MiscHostCtl) |= IndirectAccessEnable | EnablePCIStateRegister | EnableClockControlRegister;
 534         csr32(ctlr, MiscHostCtl) = (csr32(ctlr, MiscHostCtl) & ~(ByteSwap|WordSwap)) | WordSwap;
 535         csr32(ctlr, ModeControl) |= ByteWordSwap;
 536         csr32(ctlr, MemoryWindow) = 0;
 537         mem32(ctlr, 0xB50) = 0x4B657654; /* magic number bullshit */
 538         csr32(ctlr, MiscConfiguration) |= GPHYPowerDownOverride | DisableGRCResetOnPCIE;
 539         csr32(ctlr, MiscConfiguration) |= CoreClockBlocksReset;
 540         microdelay(100000);
 541         ctlr->pdev->pcr |= 1<<1; /* pci memory access enable */
 542         pcisetbme(ctlr->pdev);
 543         csr32(ctlr, MiscHostCtl) |= MaskPCIInt;
 544         csr32(ctlr, MemArbiterMode) |= Enable;
 545         csr32(ctlr, MiscHostCtl) = (csr32(ctlr, MiscHostCtl) & ~(ByteSwap|WordSwap)) | WordSwap;
 546         csr32(ctlr, MiscHostCtl) |= IndirectAccessEnable | EnablePCIStateRegister | EnableClockControlRegister | TaggedStatus;
 547         csr32(ctlr, ModeControl) |= ByteWordSwap;
 548         csr32(ctlr, MACMode) = (csr32(ctlr, MACMode) & MACPortMask) | MACPortGMII;
 549         microdelay(40000);
 550         for(i = 0; i < 100000 && mem32(ctlr, 0xB50) != 0xB49A89AB; i++)
 551                 microdelay(100);
 552         if(i == 100000){
 553                 iprint("bcm: chip failed to reset\n");
 554                 return -1;
 555         }
 556         switch(ctlr->pdev->did){
 557         case BCM5721:
 558         case BCM5751:
 559         case BCM5752:
 560                 csr32(ctlr, TLPControl) |= (1<<25) | (1<<29);
 561                 break;
 562         }
 563         memset(ctlr->status, 0, 20);
 564         csr32(ctlr, DMARWControl) = (csr32(ctlr, DMARWControl) & DMAWatermarkMask) | DMAWatermarkValue;
 565         csr32(ctlr, ModeControl) |= HostSendBDs | HostStackUp | InterruptOnMAC;
 566         csr32(ctlr, MiscConfiguration) = (csr32(ctlr, MiscConfiguration) & TimerMask) | TimerValue;
 567         csr32(ctlr, MBUFLowWatermark) = 0x20;
 568         csr32(ctlr, MBUFHighWatermark) = 0x60;
 569         csr32(ctlr, LowWatermarkMaximum) = (csr32(ctlr, LowWatermarkMaximum) & LowWatermarkMaxMask) | LowWatermarkMaxValue;
 570         csr32(ctlr, BufferManMode) |= Enable | Attn;
 571         for(i = 0; i < 100 && (csr32(ctlr, BufferManMode) & Enable) == 0; i++)
 572                 microdelay(100);
 573         if(i == 100){
 574                 iprint("bcm: buffer manager failed to start\n");
 575                 return -1;
 576         }
 577         csr32(ctlr, FTQReset) = -1;
 578         csr32(ctlr, FTQReset) = 0;
 579         for(i = 0; i < 1000 && csr32(ctlr, FTQReset) != 0; i++)
 580                 microdelay(100);
 581         if(i == 1000){
 582                 iprint("bcm: ftq failed to reset\n");
 583                 return -1;
 584         }
 585         csr32(ctlr, ReceiveBDHostAddr) = 0;
 586         csr32(ctlr, ReceiveBDHostAddr + 4) = PADDR(ctlr->recvprod);
 587         csr32(ctlr, ReceiveBDFlags) = RecvProdRingLen << 16;
 588         csr32(ctlr, ReceiveBDNIC) = 0x6000;
 589         csr32(ctlr, ReceiveBDRepl) = 25;
 590         csr32(ctlr, SendBDRingHostIndex) = 0;
 591         csr32(ctlr, SendBDRingHostIndex+4) = 0;
 592         mem32(ctlr, SendRCB) = 0;
 593         mem32(ctlr, SendRCB + 4) = PADDR(ctlr->sendr);
 594         mem32(ctlr, SendRCB + 8) = SendRingLen << 16;
 595         mem32(ctlr, SendRCB + 12) = 0x4000;
 596         for(i=1;i<4;i++)
 597                 mem32(ctlr, RecvRetRCB + i * 0x10 + 8) = 2;
 598         mem32(ctlr, RecvRetRCB) = 0;
 599         mem32(ctlr, RecvRetRCB + 4) = PADDR(ctlr->recvret);
 600         mem32(ctlr, RecvRetRCB + 8) = RecvRetRingLen << 16;
 601         csr32(ctlr, RecvProdBDRingIndex) = 0;
 602         csr32(ctlr, RecvProdBDRingIndex+4) = 0;
 603         /* this delay is not in the datasheet, but necessary; Broadcom is fucking with us */
 604         microdelay(1000);
 605         i = csr32(ctlr, 0x410);
 606         j = edev->ea[0] = i >> 8;
 607         j += edev->ea[1] = i;
 608         i = csr32(ctlr, MACAddress + 4);
 609         j += edev->ea[2] = i >> 24;
 610         j += edev->ea[3] = i >> 16;
 611         j += edev->ea[4] = i >> 8;
 612         j += edev->ea[5] = i;
 613         csr32(ctlr, EthernetRandomBackoff) = j & 0x3FF;
 614         csr32(ctlr, ReceiveMTU) = Rbsz;
 615         csr32(ctlr, TransmitMACLengths) = 0x2620;
 616         csr32(ctlr, ReceiveListPlacement) = 1<<3; /* one list */
 617         csr32(ctlr, ReceiveListPlacementMask) = 0xFFFFFF;
 618         csr32(ctlr, ReceiveListPlacementConfiguration) |= ReceiveStats;
 619         csr32(ctlr, SendInitiatorMask) = 0xFFFFFF;
 620         csr32(ctlr, SendInitiatorConfiguration) |= SendStats;
 621         csr32(ctlr, HostCoalescingMode) = 0;
 622         for(i = 0; i < 200 && csr32(ctlr, HostCoalescingMode) != 0; i++)
 623                 microdelay(100);
 624         if(i == 200){
 625                 iprint("bcm: host coalescing engine failed to stop\n");
 626                 return -1;
 627         }
 628         csr32(ctlr, HostCoalescingRecvTicks) = 150;
 629         csr32(ctlr, HostCoalescingSendTicks) = 150;
 630         csr32(ctlr, RecvMaxCoalescedFrames) = 10;
 631         csr32(ctlr, SendMaxCoalescedFrames) = 10;
 632         csr32(ctlr, RecvMaxCoalescedFramesInt) = 0;
 633         csr32(ctlr, SendMaxCoalescedFramesInt) = 0;
 634         csr32(ctlr, StatusBlockHostAddr) = 0;
 635         csr32(ctlr, StatusBlockHostAddr + 4) = PADDR(ctlr->status);
 636         csr32(ctlr, HostCoalescingMode) |= Enable;
 637         csr32(ctlr, ReceiveBDCompletionMode) |= Enable | Attn;
 638         csr32(ctlr, ReceiveListPlacementMode) |= Enable;
 639         csr32(ctlr, MACMode) |= MACEnable;
 640         csr32(ctlr, MiscLocalControl) |= InterruptOnAttn | AutoSEEPROM;
 641         csr32(ctlr, InterruptMailbox) = 0;
 642         csr32(ctlr, WriteDMAMode) |= 0x200003fe; /* pulled out of my nose */
 643         csr32(ctlr, ReadDMAMode) |= 0x3fe;
 644         csr32(ctlr, ReceiveDataCompletionMode) |= Enable | Attn;
 645         csr32(ctlr, SendDataCompletionMode) |= Enable;
 646         csr32(ctlr, SendBDCompletionMode) |= Enable | Attn;
 647         csr32(ctlr, ReceiveBDInitiatorMode) |= Enable | Attn;
 648         csr32(ctlr, ReceiveDataBDInitiatorMode) |= Enable | (1<<4);
 649         csr32(ctlr, SendDataInitiatorMode) |= Enable;
 650         csr32(ctlr, SendBDInitiatorMode) |= Enable | Attn;
 651         csr32(ctlr, SendBDSelectorMode) |= Enable | Attn;
 652         ctlr->recvprodi = 0;
 653         while(replenish(ctlr) >= 0);
 654         csr32(ctlr, TransmitMACMode) |= Enable;
 655         csr32(ctlr, ReceiveMACMode) |= Enable;
 656         csr32(ctlr, PowerControlStatus) &= ~3;
 657         csr32(ctlr, MIStatus) |= 1<<0;
 658         csr32(ctlr, MACEventEnable) = 0;
 659         csr32(ctlr, MACEventStatus) |= (1<<12);
 660         csr32(ctlr, MIMode) = 0xC0000;
 661         microdelay(40);
 662         miiw(ctlr, PhyControl, 1<<15);
 663         for(i = 0; i < 1000 && miir(ctlr, PhyControl) & (1<<15); i++)
 664                 microdelay(100);
 665         if(i == 1000){
 666                 iprint("bcm: PHY failed to reset\n");
 667                 return -1;
 668         }
 669         miiw(ctlr, PhyAuxControl, 2);
 670         miir(ctlr, PhyIntStatus);
 671         miir(ctlr, PhyIntStatus);
 672         miiw(ctlr, PhyIntMask, ~(1<<1));
 673         checklink(edev);
 674         csr32(ctlr, MACEventEnable) |= 1<<12;
 675         csr32(ctlr, MACHash) = -1;
 676         csr32(ctlr, MACHash+4) = -1;
 677         csr32(ctlr, MACHash+8) = -1;
 678         csr32(ctlr, MACHash+12) = -1;
 679         for(i = 0; i < 8; i++) csr32(ctlr, ReceiveRules + 8 * i) = 0;
 680         csr32(ctlr, ReceiveRulesConfiguration) = 1 << 3;
 681         csr32(ctlr, MSIMode) |= Enable;
 682         csr32(ctlr, MiscHostCtl) &= ~(MaskPCIInt | ClearIntA);
 683         return 0;
 684 }
 685
 686 static void
 687 bcmpci(void)
 688 {
 689         Pcidev *pdev;
 690
 691         pdev = nil;
 692         while(pdev = pcimatch(pdev, 0, 0)) {
 693                 Ctlr *ctlr;
 694                 void *mem;
 695
 696                 if(pdev->ccrb != 2 || pdev->ccru != 0)
 697                         continue;
 698                 if(pdev->vid != 0x14e4)
 699                         continue;
 700                 switch(pdev->did){
 701                 default:
 702                         continue;
 703                 case BCM5752:
 704                 case BCM5752M:
 705                 case BCM5709:
 706                 case BCM5709S:
 707                 case BCM5716:
 708                 case BCM5716S:
 709                 case BCM5700:
 710                 case BCM5701:
 711                 case BCM5702:
 712                 case BCM5703:
 713                 case BCM5704:
 714                 case BCM5704S_2:
 715                 case BCM5706:
 716                 case BCM5708:
 717                 case BCM5702FE:
 718                 case BCM57710:
 719                 case BCM57711:
 720                 case BCM57711E:
 721                 case BCM5705:
 722                 case BCM5705_2:
 723                 case BCM5717:
 724                 case BCM5718:
 725                 case BCM5720:
 726                 case BCM5721:
 727                 case BCM5722:
 728                 case BCM5723:
 729                 case BCM5724:
 730                 case BCM5705M:
 731                 case BCM5705M_2:
 732                 case BCM5714:
 733                 case BCM5780:
 734                 case BCM5780S:
 735                 case BCM5754M:
 736                 case BCM5755M:
 737                 case BCM5756ME:
 738                 case BCM5750:
 739                 case BCM5751:
 740                 case BCM5715:
 741                 case BCM5715S:
 742                 case BCM5754:
 743                 case BCM5755:
 744                 case BCM5750M:
 745                 case BCM5751M:
 746                 case BCM5751F:
 747                 case BCM5787F:
 748                 case BCM5761e:
 749                 case BCM5761:
 750                 case BCM5764M:
 751                 case BCM57760:
 752                 case BCM57788:
 753                 case BCM57780:
 754                 case BCM5787M:
 755                 case BCM57790:
 756                 case BCM5782:
 757                 case BCM5784M:
 758                 case BCM5785:
 759                 case BCM5786:
 760                 case BCM5787:
 761                 case BCM5788:
 762                 case BCM5789:
 763                 case BCM5785:
 764                 case BCM5702X:
 765                 case BCM5703X:
 766                 case BCM5704S:
 767                 case BCM5706S:
 768                 case BCM5708S:
 769                 case BCM57761:
 770                 case BCM57781:
 771                 case BCM57791:
 772                 case BCM57765:
 773                 case BCM57785:
 774                 case BCM57795:
 775                 case BCM5702A3:
 776                 case BCM5703:
 777                 case BCM5781:
 778                 case BCM5753:
 779                 case BCM5753M:
 780                 case BCM5753F:
 781                 case BCM5906:   /* ??? */
 782                 case BCM5906M:  /* ??? */
 783                 case 0x1670:    /* ??? */
 784                         break;
 785                 }
 786
 787                 pcisetbme(pdev);
 788                 pcisetpms(pdev, 0);
 789                 ctlr = malloc(sizeof(Ctlr));
 790                 if(ctlr == nil) {
 791                         print("bcm: unable to alloc Ctlr\n");
 792                         continue;
 793                 }
 794                 mem = vmap(pdev->mem[0].bar & ~0x0F, pdev->mem[0].size);
 795                 if(mem == nil) {
 796                         print("bcm: can't map %8.8luX\n", pdev->mem[0].bar);
 797                         free(ctlr);
 798                         continue;
 799                 }
 800                 ctlr->pdev = pdev;
 801                 ctlr->nic = mem;
 802                 ctlr->port = pdev->mem[0].bar & ~0x0F;
 803                 ctlr->status = xspanalloc(20, 16, 0);
 804                 ctlr->recvprod = xspanalloc(32 * RecvProdRingLen, 16, 0);
 805                 ctlr->recvret = xspanalloc(32 * RecvRetRingLen, 16, 0);
 806                 ctlr->sendr = xspanalloc(16 * SendRingLen, 16, 0);
 807                 ctlr->sends = malloc(sizeof(Block) * SendRingLen);
 808                 if(bcmhead != nil)
 809                         bcmtail->link = ctlr;
 810                 else
 811                         bcmhead = ctlr;
 812                 bcmtail = ctlr;
 813         }
 814 }
 815
 816 static void
 817 bcmpromiscuous(void* arg, int on)
 818 {
 819         Ctlr *ctlr;
 820
 821         ctlr = ((Ether*)arg)->ctlr;
 822         if(on)
 823                 csr32(ctlr, ReceiveMACMode) |= 1<<8;
 824         else
 825                 csr32(ctlr, ReceiveMACMode) &= ~(1<<8);
 826 }
 827
 828 static void
 829 bcmmulticast(void*, uchar*, int)
 830 {
 831 }
 832
 833 static int
 834 bcmpnp(Ether* edev)
 835 {
 836         Ctlr *ctlr;
 837
 838 again:
 839         if(bcmhead == nil)
 840                 bcmpci();
 841
 842         for(ctlr = bcmhead; ctlr != nil; ctlr = ctlr->link) {
 843                 if(ctlr->active)
 844                         continue;
 845
 846                 if(edev->port == 0 || edev->port == ctlr->port) {
 847                         ctlr->active = 1;
 848                         break;
 849                 }
 850         }
 851
 852         if(ctlr == nil)
 853                 return -1;
 854
 855         edev->ctlr = ctlr;
 856         edev->port = ctlr->port;
 857         edev->irq = ctlr->pdev->intl;
 858         edev->tbdf = ctlr->pdev->tbdf;
 859         edev->interrupt = bcminterrupt;
 860         edev->transmit = bcmtransmit;
 861         edev->multicast = bcmmulticast;
 862         edev->promiscuous = bcmpromiscuous;
 863         edev->arg = edev;
 864         edev->mbps = 1000;
 865
 866         if(bcminit(edev) < 0){
 867                 edev->ctlr = nil;
 868                 goto again;
 869         }
 870         return 0;
 871 }
 872
 873 void
 874 etherbcmlink(void)
 875 {
 876         addethercard("bcm", bcmpnp);
 877 }