9ns: Support rename
[akaros.git] / kern / drivers / net / ether82563.c
1 /*
2  * Copyright 2008-2014
3  * erik quanstrom
4  *
5  * This software is provided `as-is,' without any express or implied
6  * warranty.  In no event will the author be held liable for any damages
7  * arising from the use of this software.
8  *
9  * Permission is granted to anyone to use this software for any purpose,
10  * including commercial applications, and to alter it and redistribute it
11  * freely, subject to the following restrictions:
12  *
13  * 1.  The origin of this software must not be misrepresented; you must
14  * not claim that you wrote the original software.  If you use this
15  * software in a product, an acknowledgment in the product documentation
16  * would be appreciated but is not required.
17  *
18  * 2.  Altered source versions must be plainly marked as such, and must
19  * not be misrepresented as being the original software.
20  *
21  * 3.  This notice may not be removed or altered from any source
22  * distribution.
23  */
24 /* This code has been modified by UC Berkeley and Google to work in Akaros. */
25 /*
26  * Intel Gigabit Ethernet PCI-Express Controllers.
27  *      8256[367], 8257[1-79], 21[078]
28  * Pretty basic, does not use many of the chip smarts.
29  * The interrupt mitigation tuning for each chip variant
30  * is probably different. The reset/initialisation
31  * sequence needs straightened out. Doubt the PHY code
32  * for the 82575eb is right.
33  *
34  * on the assumption that allowing jumbo packets makes the controller
35  * much slower (as is true of the 82579), never allow jumbos.
36  */
37 #include <slab.h>
38 #include <kmalloc.h>
39 #include <kref.h>
40 #include <string.h>
41 #include <stdio.h>
42 #include <assert.h>
43 #include <error.h>
44 #include <cpio.h>
45 #include <pmap.h>
46 #include <smp.h>
47 #include <net/ip.h>
48
49 #define now() TK2MS(MACHP(0)->ticks)
50
51 /*
52  * these are in the order they appear in the manual, not numeric order.
53  * It was too hard to find them in the book. Ref 21489, rev 2.6
54  */
55
56 enum {
57         /* General */
58         Ctrl = 0x0000,                          /* Device Control */
59         Status = 0x0008,        /* Device Status */
60         Eec = 0x0010,   /* EEPROM/Flash Control/Data */
61         Fextnvm6 = 0x0010,      /* Future Extended NVM 6 */
62         Eerd = 0x0014,  /* EEPROM Read */
63         Ctrlext = 0x0018,       /* Extended Device Control */
64         Fla = 0x001c,   /* Flash Access */
65         Mdic = 0x0020,  /* MDI Control */
66         Seresctl = 0x0024,      /* Serdes ana */
67         Fcal = 0x0028,  /* Flow Control Address Low */
68         Fcah = 0x002C,  /* Flow Control Address High */
69         Fct = 0x0030,   /* Flow Control Type */
70         Kumctrlsta = 0x0034,    /* MAC-PHY Interface */
71         Vet = 0x0038,   /* VLAN EtherType */
72         Fcttv = 0x0170, /* Flow Control Transmit Timer Value */
73         Txcw = 0x0178,  /* Transmit Configuration Word */
74         Rxcw = 0x0180,  /* Receive Configuration Word */
75         Ledctl = 0x0E00,        /* LED control */
76         Pba = 0x1000,   /* Packet Buffer Allocation */
77         Pbs = 0x1008,   /* Packet Buffer Size */
78
79         /* Interrupt */
80         Icr = 0x00C0,   /* Interrupt Cause Read */
81         Itr = 0x00c4,   /* Interrupt Throttling Rate */
82         Ics = 0x00C8,   /* Interrupt Cause Set */
83         Ims = 0x00D0,   /* Interrupt Mask Set/Read */
84         Imc = 0x00D8,   /* Interrupt mask Clear */
85         Iam = 0x00E0,   /* Interrupt acknowledge Auto Mask */
86
87         /* Receive */
88         Rctl = 0x0100,  /* Control */
89         Ert = 0x2008,   /* Early Receive Threshold (573[EVL], 579 only) */
90         Fcrtl = 0x2160, /* Flow Control RX Threshold Low */
91         Fcrth = 0x2168, /* Flow Control Rx Threshold High */
92         Psrctl = 0x2170,        /* Packet Split Receive Control */
93         Rdbal = 0x2800, /* Rdesc Base Address Low Queue 0 */
94         Rdbah = 0x2804, /* Rdesc Base Address High Queue 0 */
95         Rdlen = 0x2808, /* Descriptor Length Queue 0 */
96         Srrctl = 0x280c,        /* split and replication rx control (82575) */
97         Rdh = 0x2810,   /* Descriptor Head Queue 0 */
98         Rdt = 0x2818,   /* Descriptor Tail Queue 0 */
99         Rdtr = 0x2820,  /* Descriptor Timer Ring */
100         Rxdctl = 0x2828,        /* Descriptor Control */
101         Radv = 0x282C,  /* Interrupt Absolute Delay Timer */
102         Rdbal1 = 0x2900,        /* Rdesc Base Address Low Queue 1 */
103         Rdbah1 = 0x2804,        /* Rdesc Base Address High Queue 1 */
104         Rdlen1 = 0x2908,        /* Descriptor Length Queue 1 */
105         Rdh1 = 0x2910,  /* Descriptor Head Queue 1 */
106         Rdt1 = 0x2918,  /* Descriptor Tail Queue 1 */
107         Rxdctl1 = 0x2928,       /* Descriptor Control Queue 1 */
108         Rsrpd = 0x2c00, /* Small Packet Detect */
109         Raid = 0x2c08,  /* ACK interrupt delay */
110         Cpuvec = 0x2c10,        /* CPU Vector */
111         Rxcsum = 0x5000,        /* Checksum Control */
112         Rmpl = 0x5004,  /* rx maximum packet length (82575) */
113         Rfctl = 0x5008, /* Filter Control */
114         Mta = 0x5200,   /* Multicast Table Array */
115         Ral = 0x5400,   /* Receive Address Low */
116         Rah = 0x5404,   /* Receive Address High */
117         Vfta = 0x5600,  /* VLAN Filter Table Array */
118         Mrqc = 0x5818,  /* Multiple Receive Queues Command */
119         Rssim = 0x5864, /* RSS Interrupt Mask */
120         Rssir = 0x5868, /* RSS Interrupt Request */
121         Reta = 0x5c00,  /* Redirection Table */
122         Rssrk = 0x5c80, /* RSS Random Key */
123
124         /* Transmit */
125         Tctl = 0x0400,  /* Transmit Control */
126         Tipg = 0x0410,  /* Transmit IPG */
127         Tkabgtxd = 0x3004,      /* glci afe band gap transmit ref data, or something */
128         Tdbal = 0x3800, /* Tdesc Base Address Low */
129         Tdbah = 0x3804, /* Tdesc Base Address High */
130         Tdlen = 0x3808, /* Descriptor Length */
131         Tdh = 0x3810,   /* Descriptor Head */
132         Tdt = 0x3818,   /* Descriptor Tail */
133         Tidv = 0x3820,  /* Interrupt Delay Value */
134         Txdctl = 0x3828,        /* Descriptor Control */
135         Tadv = 0x382C,  /* Interrupt Absolute Delay Timer */
136         Tarc0 = 0x3840, /* Arbitration Counter Queue 0 */
137         Tdbal1 = 0x3900,        /* Descriptor Base Low Queue 1 */
138         Tdbah1 = 0x3904,        /* Descriptor Base High Queue 1 */
139         Tdlen1 = 0x3908,        /* Descriptor Length Queue 1 */
140         Tdh1 = 0x3910,  /* Descriptor Head Queue 1 */
141         Tdt1 = 0x3918,  /* Descriptor Tail Queue 1 */
142         Txdctl1 = 0x3928,       /* Descriptor Control 1 */
143         Tarc1 = 0x3940, /* Arbitration Counter Queue 1 */
144
145         /* Statistics */
146         Statistics = 0x4000,    /* Start of Statistics Area */
147         Gorcl = 0x88 / 4,       /* Good Octets Received Count */
148         Gotcl = 0x90 / 4,       /* Good Octets Transmitted Count */
149         Torl = 0xC0 / 4,        /* Total Octets Received */
150         Totl = 0xC8 / 4,        /* Total Octets Transmitted */
151         Nstatistics = 0x124 / 4,
152 };
153
154 enum {                                                  /* Ctrl */
155         GIOmd = 1 << 2,                         /* BIO master disable */
156         Lrst = 1 << 3,  /* link reset */
157         Slu = 1 << 6,   /* Set Link Up */
158         SspeedMASK = 3 << 8,    /* Speed Selection */
159         SspeedSHIFT = 8,
160         Sspeed10 = 0x00000000,  /* 10Mb/s */
161         Sspeed100 = 0x00000100, /* 100Mb/s */
162         Sspeed1000 = 0x00000200,        /* 1000Mb/s */
163         Frcspd = 1 << 11,       /* Force Speed */
164         Frcdplx = 1 << 12,      /* Force Duplex */
165         SwdpinsloMASK = 0x003C0000,     /* Software Defined Pins - lo nibble */
166         SwdpinsloSHIFT = 18,
167         SwdpioloMASK = 0x03C00000,      /* Software Defined Pins - I or O */
168         SwdpioloSHIFT = 22,
169         Devrst = 1 << 26,       /* Device Reset */
170         Rfce = 1 << 27, /* Receive Flow Control Enable */
171         Tfce = 1 << 28, /* Transmit Flow Control Enable */
172         Vme = 1 << 30,  /* VLAN Mode Enable */
173         Phyrst = 1 << 31,       /* Phy Reset */
174 };
175
176 enum {                                                  /* Status */
177         Lu = 1 << 1,                            /* Link Up */
178         Lanid = 3 << 2, /* mask for Lan ID. */
179         Txoff = 1 << 4, /* Transmission Paused */
180         Tbimode = 1 << 5,       /* TBI Mode Indication */
181         Phyra = 1 << 10,        /* PHY Reset Asserted */
182         GIOme = 1 << 19,        /* GIO Master Enable Status */
183 };
184
185 enum {
186         /* Eec */
187         Nvpres = 1 << 8,                        /* nvram present */
188         Autord = 1 << 9,        /* autoread complete */
189         Sec1val = 1 << 22,      /* sector 1 valid (!sec0) */
190 };
191
192 enum {                                                  /* Eerd */
193         EEstart = 1 << 0,                       /* Start Read */
194         EEdone = 1 << 1,        /* Read done */
195 };
196
197 enum {                                                  /* Ctrlext */
198         Asdchk = 1 << 12,                       /* ASD Check */
199         Eerst = 1 << 13,        /* EEPROM Reset */
200         Spdbyps = 1 << 15,      /* Speed Select Bypass */
201 };
202
203 /*
204  * TODO(dcross): 'Ea' is 0 elsewhere. Investigate and possibly correct.
205  */
206 enum {                                                  /* EEPROM content offsets */
207         OldEa = 0x00,                           /* Old Ethernet address */
208         Ea = 0x01,                                      /* Ethernet Address */
209         Cf = 0x03,      /* Compatibility Field */
210         Icw1 = 0x0A,    /* Initialization Control Word 1 */
211         Sid = 0x0B,     /* Subsystem ID */
212         Svid = 0x0C,    /* Subsystem Vendor ID */
213         Did = 0x0D,     /* Device ID */
214         Vid = 0x0E,     /* Vendor ID */
215         Icw2 = 0x0F,    /* Initialization Control Word 2 */
216 };
217
218 enum {                                                  /* Mdic */
219         MDIdMASK = 0x0000FFFF,          /* Data */
220         MDIdSHIFT = 0,
221         MDIrMASK = 0x001F0000,  /* PHY Register Address */
222         MDIrSHIFT = 16,
223         MDIpMASK = 0x03E00000,  /* PHY Address */
224         MDIpSHIFT = 21,
225         MDIwop = 0x04000000,    /* Write Operation */
226         MDIrop = 0x08000000,    /* Read Operation */
227         MDIready = 0x10000000,  /* End of Transaction */
228         MDIie = 0x20000000,     /* Interrupt Enable */
229         MDIe = 0x40000000,      /* Error */
230 };
231
232 enum {                                                  /* phy interface registers */
233         Phyctl = 0,                                     /* phy ctl */
234         Physsr = 17,    /* phy secondary status */
235         Phyier = 18,    /* 82573 phy interrupt enable */
236         Phyisr = 19,    /* 82563 phy interrupt status */
237         Phylhr = 19,    /* 8257[12] link health */
238         Phyier218 = 24, /* 218 (phy79?) phy interrupt enable */
239         Phyisr218 = 25, /* 218 (phy79?) phy interrupt status */
240         Phystat = 26,   /* 82580 (phy79?) phy status */
241         Phypage = 31,   /* page number */
242
243         Rtlink = 1 << 10,       /* realtime link status */
244         Phyan = 1 << 11,        /* phy has auto-negotiated */
245
246         /* Phyctl bits */
247         Ran = 1 << 9,   /* restart auto-negotiation */
248         Ean = 1 << 12,  /* enable auto-negotiation */
249
250         /* 82573 Phyier interrupt enable bits */
251         Lscie = 1 << 10,        /* link status changed */
252         Ancie = 1 << 11,        /* auto-negotiation complete */
253         Spdie = 1 << 14,        /* speed changed */
254         Panie = 1 << 15,        /* phy auto-negotiation error */
255
256         /* Phylhr/Phyisr bits */
257         Anf = 1 << 6,   /* lhr: auto-negotiation fault */
258         Ane = 1 << 15,  /* isr: auto-negotiation error */
259
260         /* 82580 Phystat bits */
261         Ans = 3 << 14,  /* 82580 autoneg. status */
262         Link = 1 << 6,  /* 82580 link */
263
264         /* 218 Phystat bits */
265         Anfs = 3 << 13, /* fault status */
266         Ans218 = 1 << 12,       /* autoneg complete */
267
268         /* 218 Phyier218 interrupt enable bits */
269         Spdie218 = 1 << 1,      /* speed changed */
270         Lscie218 = 1 << 2,      /* link status changed */
271         Ancie218 = 1 << 8,      /* auto-negotiation changed */
272 };
273
274 enum {                                                  /* Icr, Ics, Ims, Imc */
275         Txdw = 0x00000001,                      /* Transmit Descriptor Written Back */
276         Txqe = 0x00000002,      /* Transmit Queue Empty */
277         Lsc = 0x00000004,       /* Link Status Change */
278         Rxseq = 0x00000008,     /* Receive Sequence Error */
279         Rxdmt0 = 0x00000010,    /* Rdesc Minimum Threshold Reached */
280         Rxo = 0x00000040,       /* Receiver Overrun */
281         Rxt0 = 0x00000080,      /* Receiver Timer Interrupt */
282         Mdac = 0x00000200,      /* MDIO Access Completed */
283         Rxcfg = 0x00000400,     /* Receiving /C/ ordered sets */
284         Gpi0 = 0x00000800,      /* General Purpose Interrupts */
285         Gpi1 = 0x00001000,
286         Gpi2 = 0x00002000,
287         Gpi3 = 0x00004000,
288         Ack = 0x00020000,       /* Receive ACK frame */
289 };
290
291 enum {                                                  /* Txcw */
292         TxcwFd = 0x00000020,            /* Full Duplex */
293         TxcwHd = 0x00000040,    /* Half Duplex */
294         TxcwPauseMASK = 0x00000180,     /* Pause */
295         TxcwPauseSHIFT = 7,
296         TxcwPs = 1 << TxcwPauseSHIFT,   /* Pause Supported */
297         TxcwAs = 2 << TxcwPauseSHIFT,   /* Asymmetric FC desired */
298         TxcwRfiMASK = 0x00003000,       /* Remote Fault Indication */
299         TxcwRfiSHIFT = 12,
300         TxcwNpr = 0x00008000,   /* Next Page Request */
301         TxcwConfig = 0x40000000,        /* Transmit Config Control */
302         TxcwAne = 0x80000000,   /* Auto-Negotiation Enable */
303 };
304
305 enum {                                                  /* Rctl */
306         Rrst = 0x00000001,                      /* Receiver Software Reset */
307         Ren = 0x00000002,       /* Receiver Enable */
308         Sbp = 0x00000004,       /* Store Bad Packets */
309         Upe = 0x00000008,       /* Unicast Promiscuous Enable */
310         Mpe = 0x00000010,       /* Multicast Promiscuous Enable */
311         Lpe = 0x00000020,       /* Long Packet Reception Enable */
312         LbmMASK = 0x000000C0,   /* Loopback Mode */
313         LbmOFF = 0x00000000,    /* No Loopback */
314         LbmTBI = 0x00000040,    /* TBI Loopback */
315         LbmMII = 0x00000080,    /* GMII/MII Loopback */
316         LbmXCVR = 0x000000C0,   /* Transceiver Loopback */
317         RdtmsMASK = 0x00000300, /* Rdesc Minimum Threshold Size */
318         RdtmsHALF = 0x00000000, /* Threshold is 1/2 Rdlen */
319         RdtmsQUARTER = 0x00000100,      /* Threshold is 1/4 Rdlen */
320         RdtmsEIGHTH = 0x00000200,       /* Threshold is 1/8 Rdlen */
321         MoMASK = 0x00003000,    /* Multicast Offset */
322         Bam = 0x00008000,       /* Broadcast Accept Mode */
323         BsizeMASK = 0x00030000, /* Receive Buffer Size */
324         Bsize16384 = 0x00010000,        /* Bsex = 1 */
325         Bsize8192 = 0x00020000, /* Bsex = 1 */
326         Bsize2048 = 0x00000000,
327         Bsize1024 = 0x00010000,
328         Bsize512 = 0x00020000,
329         Bsize256 = 0x00030000,
330         BsizeFlex = 0x08000000, /* Flexible Bsize in 1KB increments */
331         Vfe = 0x00040000,       /* VLAN Filter Enable */
332         Cfien = 0x00080000,     /* Canonical Form Indicator Enable */
333         Cfi = 0x00100000,       /* Canonical Form Indicator value */
334         Dpf = 0x00400000,       /* Discard Pause Frames */
335         Pmcf = 0x00800000,      /* Pass MAC Control Frames */
336         Bsex = 0x02000000,      /* Buffer Size Extension */
337         Secrc = 0x04000000,     /* Strip CRC from incoming packet */
338 };
339
340 enum {                                                  /* Srrctl */
341         Dropen = 1 << 31,
342 };
343
344 enum {                                                  /* Tctl */
345         Trst = 0x00000001,                      /* Transmitter Software Reset */
346         Ten = 0x00000002,       /* Transmit Enable */
347         Psp = 0x00000008,       /* Pad Short Packets */
348         Mulr = 0x10000000,      /* Allow multiple concurrent requests */
349         Ctmask = 0x00000FF0,    /* Collision Threshold */
350         Ctshift = 4,
351         ColdMASK = 0x003FF000,  /* Collision Distance */
352         ColdSHIFT = 12,
353         Swxoff = 0x00400000,    /* Sofware XOFF Transmission */
354         Pbe = 0x00800000,       /* Packet Burst Enable */
355         Rtlc = 0x01000000,      /* Re-transmit on Late Collision */
356         Nrtu = 0x02000000,      /* No Re-transmit on Underrrun */
357 };
358
359 enum {                                                  /* [RT]xdctl */
360         PthreshMASK = 0x0000003F,       /* Prefetch Threshold */
361         PthreshSHIFT = 0,
362         HthreshMASK = 0x00003F00,       /* Host Threshold */
363         HthreshSHIFT = 8,
364         WthreshMASK = 0x003F0000,       /* Writeback Threshold */
365         WthreshSHIFT = 16,
366         Gran = 0x01000000,      /* Granularity (descriptors, not cls) */
367         Qenable = 0x02000000,   /* Queue Enable (82575) */
368 };
369
370 enum {                                                  /* Rxcsum */
371         PcssMASK = 0x00FF,                      /* Packet Checksum Start */
372         PcssSHIFT = 0,
373         Ipofl = 0x0100, /* IP Checksum Off-load Enable */
374         Tuofl = 0x0200, /* TCP/UDP Checksum Off-load Enable */
375 };
376
377 enum {                                                  /* Receive Delay Timer Ring */
378         DelayMASK = 0xFFFF,                     /* delay timer in 1.024nS increments */
379         DelaySHIFT = 0,
380         Fpd = 0x80000000,       /* Flush partial Descriptor Block */
381 };
382
383 struct rd {                                             /* Receive Descriptor */
384         uint32_t addr[2];
385         uint16_t length;
386         uint16_t checksum;
387         uint8_t status;
388         uint8_t errors;
389         uint16_t special;
390 };
391
392 enum {                                                  /* Rd status */
393         Rdd = 0x01,                                     /* Descriptor Done */
394         Reop = 0x02,    /* End of Packet */
395         Ixsm = 0x04,    /* Ignore Checksum Indication */
396         Vp = 0x08,      /* Packet is 802.1Q (matched VET) */
397         Tcpcs = 0x20,   /* TCP Checksum Calculated on Packet */
398         Ipcs = 0x40,    /* IP Checksum Calculated on Packet */
399         Pif = 0x80,     /* Passed in-exact filter */
400 };
401
402 enum {                                                  /* Rd errors */
403         Ce = 0x01,                                      /* CRC Error or Alignment Error */
404         Se = 0x02,      /* Symbol Error */
405         Seq = 0x04,     /* Sequence Error */
406         Cxe = 0x10,     /* Carrier Extension Error */
407         Tcpe = 0x20,    /* TCP/UDP Checksum Error */
408         Ipe = 0x40,     /* IP Checksum Error */
409         Rxe = 0x80,     /* RX Data Error */
410 };
411
412 struct td {                                             /* Transmit Descriptor */
413         uint32_t addr[2];                       /* Data */
414         uint32_t control;
415         uint32_t status;
416 };
417
418 enum {                                                  /* Tdesc control */
419         LenMASK = 0x000FFFFF,           /* Data/Packet Length Field */
420         LenSHIFT = 0,
421         DtypeCD = 0x00000000,   /* Data Type 'Context Descriptor' */
422         DtypeDD = 0x00100000,   /* Data Type 'Data Descriptor' */
423         PtypeTCP = 0x01000000,  /* TCP/UDP Packet Type (CD) */
424         Teop = 0x01000000,      /* End of Packet (DD) */
425         PtypeIP = 0x02000000,   /* IP Packet Type (CD) */
426         Ifcs = 0x02000000,      /* Insert FCS (DD) */
427         Tse = 0x04000000,       /* TCP Segmentation Enable */
428         Rs = 0x08000000,        /* Report Status */
429         Rps = 0x10000000,       /* Report Status Sent */
430         Dext = 0x20000000,      /* Descriptor Extension */
431         Vle = 0x40000000,       /* VLAN Packet Enable */
432         Ide = 0x80000000,       /* Interrupt Delay Enable */
433 };
434
435 enum {                                                  /* Tdesc status */
436         Tdd = 0x0001,                           /* Descriptor Done */
437         Ec = 0x0002,    /* Excess Collisions */
438         Lc = 0x0004,    /* Late Collision */
439         Tu = 0x0008,    /* Transmit Underrun */
440         CssMASK = 0xFF00,       /* Checksum Start Field */
441         CssSHIFT = 8,
442 };
443
444 struct flash {
445         uint16_t *reg;
446         uint32_t *reg32;
447         uint16_t base;
448         uint16_t lim;
449 };
450
451 enum {
452         /* 16 and 32-bit flash registers for ich flash parts */
453         Bfpr = 0x00 / 4,                        /* flash base 0:12; lim 16:28 */
454         Fsts = 0x04 / 2,        /* flash status;  Hsfsts */
455         Fctl = 0x06 / 2,        /* flash control; Hsfctl */
456         Faddr = 0x08 / 4,       /* flash address to r/w */
457         Fdata = 0x10 / 4,       /* data @ address */
458
459         /* status register */
460         Fdone = 1 << 0, /* flash cycle done */
461         Fcerr = 1 << 1, /* cycle error; write 1 to clear */
462         Ael = 1 << 2,   /* direct access error log; 1 to clear */
463         Scip = 1 << 5,  /* spi cycle in progress */
464         Fvalid = 1 << 14,       /* flash descriptor valid */
465
466         /* control register */
467         Fgo = 1 << 0,   /* start cycle */
468         Flcycle = 1 << 1,       /* two bits: r=0; w=2 */
469         Fdbc = 1 << 8,  /* bytes to read; 5 bits */
470 };
471
472 /*
473  * the kumeran interface is mac-to-phy for external gigabit ethernet on
474  * intel's esb2 ich8 (io controller hub), it carries mii bits.  can be used
475  * to reset the phy.  intel proprietary, see "kumeran specification".
476  */
477 enum {
478         I217inbandctlpage = 770,        /* phy page */
479         I217inbandctlreg = 18,  /* phy register */
480         I217inbandctllnkststxtmoutmask = 0x3F00,
481         I217inbandctllnkststxtmoutshift = 8,
482
483         Fextnvm6reqpllclk = 0x100,
484         Fextnvm6enak1entrycond = 0x200, /* extend K1 entry latency */
485
486         Nvmk1cfg = 0x1B,        /* NVM K1 Config Word */
487         Nvmk1enable = 0x1,      /* NVM Enable K1 bit */
488
489         Kumctrlstaoff = 0x1F0000,
490         Kumctrlstaoffshift = 16,
491         Kumctrlstaren = 0x200000,
492         Kumctrlstak1cfg = 0x7,
493         Kumctrlstak1enable = 0x2,
494 };
495
496 enum {
497         /*
498          * these were 512, 1024 & 64, but 52, 253 & 9 are usually ample;
499          * however cpu servers and terminals can need more receive buffers
500          * due to bursts of traffic.
501          *
502          * Tdlen and Rdlen have to be multiples of 128.  Rd and Td are both
503          * 16 bytes long, so Nrd and Ntd must be multiples of 8.
504          */
505         Ntd = 32,                                       /* power of two >= 8 */
506         Nrd = 128,      /* power of two >= 8 */
507         Rbalign = 16,
508         Slop = 32,      /* for vlan headers, crcs, etc. */
509 };
510
511 enum {
512         Iany = -1,
513         i82563,
514         i82566,
515         i82567,
516         i82567m,
517         i82571,
518         i82572,
519         i82573,
520         i82574,
521         i82575,
522         i82576,
523         i82577,
524         i82577m,
525         i82578,
526         i82578m,
527         i82579,
528         i82580,
529         i82583,
530         i210,
531         i217,
532         i218,
533         i350,
534         Nctlrtype,
535 };
536
537 enum {
538         Fload = 1 << 0,
539         Fert = 1 << 1,
540         F75 = 1 << 2,
541         Fpba = 1 << 3,
542         Fflashea = 1 << 4,
543         F79phy = 1 << 5,
544         Fnofct = 1 << 6,
545 };
546
547 struct ctlrtype {
548         int type;
549         int mtu;
550         int phyno;
551         char *name;
552         int flag;
553 };
554
555 static struct ctlrtype ctlrtab[Nctlrtype] = {
556         {i82563, 9014, 1, "i82563", Fpba},
557         {i82566, 1514, 1, "i82566", Fload},
558         {i82567, 9234, 1, "i82567", Fload},
559         {i82567m, 1514, 1, "i82567m", 0},
560         {i82571, 9234, 1, "i82571", Fpba},
561         {i82572, 9234, 1, "i82572", Fpba},
562         {i82573, 8192, 1, "i82573", Fert},      /* terrible perf above 8k */
563         {i82574, 9018, 1, "i82574", 0},
564         {i82575, 9728, 1, "i82575", F75 | Fflashea},
565         {i82576, 9728, 1, "i82576", F75},
566         {i82577, 4096, 2, "i82577", Fload | Fert},
567         {i82577m, 1514, 2, "i82577", Fload | Fert},
568         {i82578, 4096, 2, "i82578", Fload | Fert},
569         {i82578m, 1514, 2, "i82578", Fload | Fert},
570         {i82579, 9018, 2, "i82579", Fload | Fert | F79phy | Fnofct},
571         {i82580, 9728, 1, "i82580", F75 | F79phy},
572         {i82583, 1514, 1, "i82583", 0},
573         {i210, 9728, 1, "i210", F75 | Fnofct | Fert},
574         {i217, 9728, 1, "i217", F79phy | Fnofct | Fload | Fert},
575         {i350, 9728, 1, "i350", F75 | F79phy | Fnofct},
576 };
577
578 struct ctlr {
579         uintptr_t mmio_paddr;
580         struct pci_device *pcidev;
581         struct ctlr *next;
582         struct ether *edev;
583         int active;
584         int type;
585         uint16_t eeprom[0x40];
586
587         qlock_t alock;                          /* attach */
588         void *alloc;
589         unsigned int rbsz;
590         int attached;
591
592         int *nic;
593         spinlock_t imlock;
594         int im;                                         /* interrupt mask */
595
596         struct rendez lrendez;
597         int lim;
598         int phynum;
599         int didk1fix;
600
601         qlock_t slock;
602         unsigned int statistics[Nstatistics];
603         unsigned int lsleep;
604         unsigned int lintr;
605         unsigned int rsleep;
606         unsigned int rintr;
607         unsigned int txdw;
608         unsigned int tintr;
609         unsigned int ixsm;
610         unsigned int ipcs;
611         unsigned int tcpcs;
612         unsigned int speeds[4];
613
614         uint8_t ra[Eaddrlen];           /* receive address */
615         uint32_t mta[128];                      /* multicast table array */
616
617         struct rendez rrendez;
618         int rim;
619         int rdfree;                                     /* rx descriptors awaiting packets */
620         struct rd *rdba;                        /* receive descriptor base address */
621         struct block **rb;                      /* receive buffers */
622         unsigned int rdh;                       /* receive descriptor head */
623         unsigned int rdt;                       /* receive descriptor tail */
624         int rdtr;                                       /* receive delay timer ring value */
625         int radv;                                       /* receive interrupt absolute delay timer */
626
627         struct rendez trendez;
628         qlock_t tlock;
629         struct td *tdba;                        /* transmit descriptor base address */
630         struct block **tb;                      /* transmit buffers */
631         int tdh;                                        /* transmit descriptor head */
632         int tdt;                                        /* transmit descriptor tail */
633
634         int fcrtl;
635         int fcrth;
636
637         unsigned int pbs;                       /* packet buffer size */
638         unsigned int pba;                       /* packet buffer allocation */
639 };
640
641 static inline uint32_t csr32r(struct ctlr *c, uintptr_t reg)
642 {
643         return read_mmreg32((uintptr_t)(c->nic + (reg / 4)));
644 }
645
646 static inline void csr32w(struct ctlr *c, uintptr_t reg, uint32_t val)
647 {
648         write_mmreg32((uintptr_t)(c->nic + (reg / 4)), val);
649 }
650
651 static struct ctlr *i82563ctlrhead;
652 static struct ctlr *i82563ctlrtail;
653
654 static int speedtab[] = {
655         10, 100, 1000, 0
656 };
657
658 static char *statistics[] = {
659         "CRC Error",
660         "Alignment Error",
661         "Symbol Error",
662         "RX Error",
663         "Missed Packets",
664         "Single Collision",
665         "Excessive Collisions",
666         "Multiple Collision",
667         "Late Collisions",
668         NULL,
669         "Collision",
670         "Transmit Underrun",
671         "Defer",
672         "Transmit - No CRS",
673         "Sequence Error",
674         "Carrier Extension Error",
675         "Receive Error Length",
676         NULL,
677         "XON Received",
678         "XON Transmitted",
679         "XOFF Received",
680         "XOFF Transmitted",
681         "FC Received Unsupported",
682         "Packets Received (64 Bytes)",
683         "Packets Received (65-127 Bytes)",
684         "Packets Received (128-255 Bytes)",
685         "Packets Received (256-511 Bytes)",
686         "Packets Received (512-1023 Bytes)",
687         "Packets Received (1024-mtu Bytes)",
688         "Good Packets Received",
689         "Broadcast Packets Received",
690         "Multicast Packets Received",
691         "Good Packets Transmitted",
692         NULL,
693         "Good Octets Received",
694         NULL,
695         "Good Octets Transmitted",
696         NULL,
697         NULL,
698         NULL,
699         "Receive No Buffers",
700         "Receive Undersize",
701         "Receive Fragment",
702         "Receive Oversize",
703         "Receive Jabber",
704         "Management Packets Rx",
705         "Management Packets Drop",
706         "Management Packets Tx",
707         "Total Octets Received",
708         NULL,
709         "Total Octets Transmitted",
710         NULL,
711         "Total Packets Received",
712         "Total Packets Transmitted",
713         "Packets Transmitted (64 Bytes)",
714         "Packets Transmitted (65-127 Bytes)",
715         "Packets Transmitted (128-255 Bytes)",
716         "Packets Transmitted (256-511 Bytes)",
717         "Packets Transmitted (512-1023 Bytes)",
718         "Packets Transmitted (1024-mtu Bytes)",
719         "Multicast Packets Transmitted",
720         "Broadcast Packets Transmitted",
721         "TCP Segmentation Context Transmitted",
722         "TCP Segmentation Context Fail",
723         "Interrupt Assertion",
724         "Interrupt Rx Pkt Timer",
725         "Interrupt Rx Abs Timer",
726         "Interrupt Tx Pkt Timer",
727         "Interrupt Tx Abs Timer",
728         "Interrupt Tx Queue Empty",
729         "Interrupt Tx Desc Low",
730         "Interrupt Rx Min",
731         "Interrupt Rx Overrun",
732 };
733
734 static char *cname(struct ctlr *c)
735 {
736         return ctlrtab[c->type].name;
737 }
738
739 static int i82563reset(struct ctlr *);
740
741 static long i82563ifstat(struct ether *edev, void *a, long n, uint32_t offset)
742 {
743         struct ctlr *ctlr;
744         char *s, *p, *e, *stat;
745         int i, r;
746         uint64_t tuvl, ruvl;
747
748         ctlr = edev->ctlr;
749         qlock(&ctlr->slock);
750         p = s = kzmalloc(READSTR, 0);
751         if (p == NULL) {
752                 qunlock(&ctlr->slock);
753                 error(ENOMEM, "kzmalloc did not panic");
754         }
755         e = p + READSTR;
756
757         for (i = 0; i < Nstatistics; i++) {
758                 r = csr32r(ctlr, Statistics + i * 4);
759                 stat = statistics[i];
760                 if (stat == NULL)
761                         continue;
762                 switch (i) {
763                         case Gorcl:
764                         case Gotcl:
765                         case Torl:
766                         case Totl:
767                                 ruvl = r;
768                                 ruvl += (uint64_t) csr32r(ctlr, Statistics + (i + 1) * 4) << 32;
769                                 tuvl = ruvl;
770                                 tuvl += ctlr->statistics[i];
771                                 tuvl += (uint64_t) ctlr->statistics[i + 1] << 32;
772                                 if (tuvl == 0)
773                                         continue;
774                                 ctlr->statistics[i] = tuvl;
775                                 ctlr->statistics[i + 1] = tuvl >> 32;
776                                 p = seprintf(p, e, "%s: %llud %llud\n", stat, tuvl, ruvl);
777                                 i++;
778                                 break;
779
780                         default:
781                                 ctlr->statistics[i] += r;
782                                 if (ctlr->statistics[i] == 0)
783                                         continue;
784                                 p = seprintf(p, e, "%s: %ud %ud\n", stat,
785                                                          ctlr->statistics[i], r);
786                                 break;
787                 }
788         }
789
790         p = seprintf(p, e, "lintr: %ud %ud\n", ctlr->lintr, ctlr->lsleep);
791         p = seprintf(p, e, "rintr: %ud %ud\n", ctlr->rintr, ctlr->rsleep);
792         p = seprintf(p, e, "tintr: %ud %ud\n", ctlr->tintr, ctlr->txdw);
793         p = seprintf(p, e, "ixcs: %ud %ud %ud\n", ctlr->ixsm, ctlr->ipcs,
794                                  ctlr->tcpcs);
795         p = seprintf(p, e, "ctrl: %.8ux\n", csr32r(ctlr, Ctrl));
796         p = seprintf(p, e, "ctrlext: %.8ux\n", csr32r(ctlr, Ctrlext));
797         p = seprintf(p, e, "status: %.8ux\n", csr32r(ctlr, Status));
798         p = seprintf(p, e, "txcw: %.8ux\n", csr32r(ctlr, Txcw));
799         p = seprintf(p, e, "txdctl: %.8ux\n", csr32r(ctlr, Txdctl));
800         p = seprintf(p, e, "pbs: %dKB\n", ctlr->pbs);
801         p = seprintf(p, e, "pba: %#.8ux\n", ctlr->pba);
802
803         p = seprintf(p, e, "speeds: 10:%ud 100:%ud 1000:%ud ?:%ud\n",
804                                  ctlr->speeds[0], ctlr->speeds[1], ctlr->speeds[2],
805                                  ctlr->speeds[3]);
806         p = seprintf(p, e, "type: %s\n", cname(ctlr));
807
808 //  p = seprintf(p, e, "eeprom:");
809 //  for(i = 0; i < 0x40; i++){
810 //      if(i && ((i & 7) == 0))
811 //          p = seprintf(p, e, "\n       ");
812 //      p = seprintf(p, e, " %4.4ux", ctlr->eeprom[i]);
813 //  }
814 //  p = seprintf(p, e, "\n");
815
816         n = readstr(offset, a, n, s);
817         kfree(s);
818         qunlock(&ctlr->slock);
819
820         return n;
821 }
822
823 enum {
824         CMrdtr,
825         CMradv,
826         CMpause,
827         CMan,
828 };
829
830 static struct cmdtab i82563ctlmsg[] = {
831         {CMrdtr, "rdtr", 2},
832         {CMradv, "radv", 2},
833         {CMpause, "pause", 1},
834         {CMan, "an", 1},
835 };
836
837 static long i82563ctl(struct ether *edev, void *buf, long n)
838 {
839         ERRSTACK(1);
840         char *p;
841         uint32_t v;
842         struct ctlr *ctlr;
843         struct cmdbuf *cb;
844         struct cmdtab *ct;
845
846         ctlr = edev->ctlr;
847         if (ctlr == NULL)
848                 error(ENODEV, "i82563ctl: NULL controller");
849
850         cb = parsecmd(buf, n);
851         if (waserror()) {
852                 kfree(cb);
853                 nexterror();
854         }
855
856         ct = lookupcmd(cb, i82563ctlmsg, ARRAY_SIZE(i82563ctlmsg));
857         switch (ct->index) {
858                 case CMrdtr:
859                         v = strtoul(cb->f[1], &p, 0);
860                         if (*p || v > 0xffff)
861                                 error(EINVAL, ERROR_FIXME);
862                         ctlr->rdtr = v;
863                         csr32w(ctlr, Rdtr, v);
864                         break;
865                 case CMradv:
866                         v = strtoul(cb->f[1], &p, 0);
867                         if (*p || v > 0xffff)
868                                 error(EINVAL, ERROR_FIXME);
869                         ctlr->radv = v;
870                         csr32w(ctlr, Radv, v);
871                         break;
872                 case CMpause:
873                         csr32w(ctlr, Ctrl, csr32r(ctlr, Ctrl) ^ (Rfce | Tfce));
874                         break;
875                 case CMan:
876                         csr32w(ctlr, Ctrl, csr32r(ctlr, Ctrl) | Lrst | Phyrst);
877                         break;
878         }
879         kfree(cb);
880         poperror();
881
882         return n;
883 }
884
885 static void i82563promiscuous(void *arg, int on)
886 {
887         int rctl;
888         struct ctlr *ctlr;
889         struct ether *edev;
890
891         edev = arg;
892         ctlr = edev->ctlr;
893
894         rctl = csr32r(ctlr, Rctl) & ~MoMASK;
895         if (on)
896                 rctl |= Upe | Mpe;
897         else
898                 rctl &= ~(Upe | Mpe);
899         csr32w(ctlr, Rctl, rctl);
900 }
901
902 /*
903  * Returns the number of bits of mac address used in multicast hash,
904  * thus the number of longs of ctlr->mta (2^(bits-5)).
905  * This must be right for multicast (thus ipv6) to work reliably.
906  *
907  * The default multicast hash for mta is based on 12 bits of MAC address;
908  * the rightmost bit is a function of Rctl's Multicast Offset: 0=>36,
909  * 1=>35, 2=>34, 3=>32.  Exceptions include the 578, 579, 217, 218, 219;
910  * they use only 10 bits, ignoring the rightmost 2 of the 12.
911  */
912 static int mcastbits(struct ctlr *ctlr)
913 {
914         switch (ctlr->type) {
915                 /*
916                  * openbsd says all `ich8' versions (ich8, ich9, ich10, pch,
917                  * pch2 and pch_lpt) have 32 longs (use 10 bits of mac address
918                  * for hash).
919                  */
920                 case i82566:
921                 case i82567:
922         //      case i82578:
923                 case i82579:
924                 case i217:
925                 case i218:
926         //      case i219:
927                         return 10;              /* 32 longs */
928                 case i82563:
929                 case i82571:
930                 case i82572:
931                 case i82573:
932                 case i82574:
933         //      case i82575:
934         //      case i82583:
935                 case i210:                      /* includes i211 */
936                         return 12;              /* 128 longs */
937                 default:
938                         printk("82563: unsure of multicast bits in mac addresses; enabling promiscuous multicast reception\n");
939                         csr32w(ctlr, Rctl, csr32r(ctlr, Rctl) | Mpe);
940                         return 10;      /* be conservative (for mta size) */
941                 }
942 }
943
944 static int mcbitstolongs(int nmcbits)
945 {
946         return 1 << (nmcbits - 5);      /* 2^5 = 32 */
947 }
948
949 static void i82563multicast(void *arg, uint8_t *addr, int on)
950 {
951         uint32_t nbits, tblsz, hash, word, bit;
952         struct ctlr *ctlr;
953         struct ether *edev;
954
955         edev = arg;
956         ctlr = edev->ctlr;
957
958         nbits = mcastbits(ctlr);
959         tblsz = mcbitstolongs(nbits);
960         /* assume multicast offset in Rctl is 0 (we clear it above) */
961         hash = addr[5] << 4 | addr[4] >> 4;     /* bits 47:36 of mac */
962         if (nbits == 10)
963                 hash >>= 2;                     /* discard 37:36 of mac */
964         word = (hash / 32) & (tblsz - 1);
965         bit = 1UL << (hash % 32);
966         /*
967          * multiple ether addresses can hash to the same filter bit,
968          * so it's never safe to clear a filter bit.
969          * if we want to clear filter bits, we need to keep track of
970          * all the multicast addresses in use, clear all the filter bits,
971          * then set the ones corresponding to in-use addresses.
972          */
973         if (on)
974                 ctlr->mta[word] |= bit;
975 //      else
976 //              ctlr->mta[word] &= ~bit;
977         csr32w(ctlr, Mta+word*4, ctlr->mta[word]);
978 }
979
980 static void i82563im(struct ctlr *ctlr, int im)
981 {
982         spin_lock_irqsave(&ctlr->imlock);
983         ctlr->im |= im;
984         csr32w(ctlr, Ims, ctlr->im);
985         spin_unlock_irqsave(&ctlr->imlock);
986 }
987
988 static void i82563txinit(struct ctlr *ctlr)
989 {
990         int i, r, tctl;
991         struct block *bp;
992
993         /*
994          * TODO(dcross): Figure out how to integrate this table driven
995          * code into the stanza below.
996          */
997         tctl = 0x0F << Ctshift | Psp;
998         if (0) {
999                 if ((ctlrtab[ctlr->type].flag & F75) == 0)
1000                         tctl |= (66 << ColdSHIFT | Mulr);
1001         }
1002         switch (ctlr->type) {
1003                 case i210:
1004                         break;
1005                 default:
1006                         tctl |= Mulr;
1007                         /* fall through */
1008                 case i217:
1009                 case i218:
1010                         tctl |= 66 << ColdSHIFT;
1011                         break;
1012         }
1013         csr32w(ctlr, Tctl, tctl);
1014         csr32w(ctlr, Tipg, 6 << 20 | 8 << 10 | 8);      /* yb sez: 0x702008 */
1015         for (i = 0; i < Ntd; i++) {
1016                 bp = ctlr->tb[i];
1017                 if (bp != NULL) {
1018                         ctlr->tb[i] = NULL;
1019                         freeb(bp);
1020                 }
1021         }
1022         memset(ctlr->tdba, 0, Ntd * sizeof(struct td));
1023         csr32w(ctlr, Tdbal, paddr_low32(ctlr->tdba));
1024         csr32w(ctlr, Tdbah, paddr_high32(ctlr->tdba));
1025         csr32w(ctlr, Tdlen, Ntd * sizeof(struct td));
1026         ctlr->tdh = PREV_RING(0, Ntd);
1027         csr32w(ctlr, Tdh, 0);
1028         ctlr->tdt = 0;
1029         csr32w(ctlr, Tdt, 0);
1030         csr32w(ctlr, Tidv, 0);  /* don't coalesce interrupts */
1031         csr32w(ctlr, Tadv, 0);
1032         r = csr32r(ctlr, Txdctl) & ~(WthreshMASK | PthreshMASK);
1033         r |= 4 << WthreshSHIFT | 4 << PthreshSHIFT;
1034         if (ctlrtab[ctlr->type].flag & F75)
1035                 r |= Qenable;
1036         csr32w(ctlr, Txdctl, r);
1037         csr32w(ctlr, Tctl, csr32r(ctlr, Tctl) | Ten);
1038 }
1039
1040 static int i82563cleanup(struct ctlr *ctlr)
1041 {
1042         struct block *bp;
1043         int tdh, n;
1044
1045         tdh = ctlr->tdh;
1046         while (ctlr->tdba[n = NEXT_RING(tdh, Ntd)].status & Tdd) {
1047                 tdh = n;
1048                 bp = ctlr->tb[tdh];
1049                 if (bp != NULL) {
1050                         ctlr->tb[tdh] = NULL;
1051                         freeb(bp);
1052                 } else
1053                         iprint("82563 tx underrun!\n");
1054                 ctlr->tdba[tdh].status = 0;
1055         }
1056         return ctlr->tdh = tdh;
1057 }
1058
1059 static void i82563transmit(struct ether *edev)
1060 {
1061         struct td *td;
1062         struct block *bp;
1063         struct ctlr *ctlr;
1064         int tdh, tdt;
1065
1066         ctlr = edev->ctlr;
1067         qlock(&ctlr->tlock);
1068
1069         /*
1070          * Free any completed packets
1071          */
1072         tdh = i82563cleanup(ctlr);
1073
1074         /* if link down on 218, don't try since we need k1fix to run first */
1075         if (!edev->link && ctlr->type == i218 && !ctlr->didk1fix) {
1076                 qunlock(&ctlr->tlock);
1077                 return;
1078         }
1079
1080         /*
1081          * Try to fill the ring back up.
1082          */
1083         tdt = ctlr->tdt;
1084         for (;;) {
1085                 if (NEXT_RING(tdt, Ntd) == tdh) {       /* ring full? */
1086                         ctlr->txdw++;
1087                         i82563im(ctlr, Txdw);
1088                         break;
1089                 }
1090                 bp = qget(edev->oq);
1091                 if (bp == NULL)
1092                         break;
1093                 td = &ctlr->tdba[tdt];
1094                 td->addr[0] = paddr_low32(bp->rp);
1095                 td->addr[1] = paddr_high32(bp->rp);
1096                 td->control = Ide | Rs | Ifcs | Teop | BLEN(bp);
1097                 ctlr->tb[tdt] = bp;
1098                 tdt = NEXT_RING(tdt, Ntd);
1099         }
1100         if (ctlr->tdt != tdt) {
1101                 ctlr->tdt = tdt;
1102                 wmb_f();
1103                 csr32w(ctlr, Tdt, tdt);
1104         }
1105         /* else may not be any new ones, but could be some still in flight */
1106         qunlock(&ctlr->tlock);
1107 }
1108
1109 static void i82563replenish(struct ctlr *ctlr)
1110 {
1111         struct rd *rd;
1112         int rdt;
1113         struct block *bp;
1114
1115         rdt = ctlr->rdt;
1116         while (NEXT_RING(rdt, Nrd) != ctlr->rdh) {
1117                 rd = &ctlr->rdba[rdt];
1118                 if (ctlr->rb[rdt] != NULL) {
1119                         printd("#l%d: 82563: rx overrun\n", ctlr->edev->ctlrno);
1120                         break;
1121                 }
1122                 bp = block_alloc(ctlr->rbsz + Slop + Rbalign, MEM_ATOMIC);
1123                 if (bp == NULL) {
1124                         warn_once("OOM, trying to survive");
1125                         break;
1126                 }
1127                 ctlr->rb[rdt] = bp;
1128                 rd->addr[0] = paddr_low32(bp->rp);
1129                 rd->addr[1] = paddr_high32(bp->rp);
1130                 rd->status = 0;
1131                 ctlr->rdfree++;
1132                 rdt = NEXT_RING(rdt, Nrd);
1133         }
1134         if (ctlr->rdt != rdt) {
1135                 ctlr->rdt = rdt;
1136                 wmb_f();
1137                 csr32w(ctlr, Rdt, rdt);
1138         }
1139 }
1140
1141 static void i82563rxinit(struct ctlr *ctlr)
1142 {
1143         struct block *bp;
1144         int i, r, rctl, type;
1145
1146         type = ctlr->type;
1147
1148         if (ctlr->rbsz <= 2048)
1149                 csr32w(ctlr, Rctl, Dpf | Bsize2048 | Bam | RdtmsHALF);
1150         else {
1151                 i = ctlr->rbsz / 1024;
1152                 if (ctlr->rbsz % 1024)
1153                         i++;
1154                 if (ctlrtab[ctlr->type].flag & F75) {
1155                         csr32w(ctlr, Rctl, Lpe | Dpf | Bsize2048 | Bam | RdtmsHALF | Secrc);
1156                         if (ctlr->type != i82575)
1157                                 i |= (Nrd / 2 >> 4) << 20;      /* RdmsHalf */
1158                         csr32w(ctlr, Srrctl, i | Dropen);
1159                         csr32w(ctlr, Rmpl, ctlr->rbsz);
1160                         // csr32w(ctlr, Drxmxod, 0x7ff);
1161                 } else
1162                         csr32w(ctlr, Rctl,
1163                                    Lpe | Dpf | BsizeFlex * i | Bam | RdtmsHALF | Secrc);
1164         }
1165
1166         /*
1167          * TODO(dcross): Reconcile this with latest above code block.
1168          */
1169         if (0) {
1170                 rctl = Dpf | Bsize2048 | Bam | RdtmsHALF;
1171                 if (type == i82575 || type == i82576 || type == i210) {
1172                         /*
1173                          * Setting Qenable in Rxdctl does not
1174                          * appear to stick unless Ren is on.
1175                          */
1176                         csr32w(ctlr, Rctl, Ren | rctl);
1177                         csr32w(ctlr, Rxdctl, csr32r(ctlr, Rxdctl) | Qenable);
1178                 }
1179                 csr32w(ctlr, Rctl, rctl);
1180         }
1181
1182         if (ctlrtab[ctlr->type].flag & Fert)
1183                 csr32w(ctlr, Ert, 1024 / 8);    /* early rx threshold */
1184
1185         csr32w(ctlr, Rdbal, paddr_low32(ctlr->rdba));
1186         csr32w(ctlr, Rdbah, paddr_high32(ctlr->rdba));
1187         csr32w(ctlr, Rdlen, Nrd * sizeof(struct rd));
1188         ctlr->rdh = ctlr->rdt = 0;
1189         csr32w(ctlr, Rdh, 0);
1190         csr32w(ctlr, Rdt, 0);
1191
1192         /* to hell with interrupt moderation, we want low latency */
1193         csr32w(ctlr, Rdtr, 0);
1194         csr32w(ctlr, Radv, 0);
1195
1196         for (i = 0; i < Nrd; i++) {
1197                 bp = ctlr->rb[i];
1198                 if (bp != NULL) {
1199                         ctlr->rb[i] = NULL;
1200                         freeb(bp);
1201                 }
1202         }
1203         i82563replenish(ctlr);
1204
1205         if (type == i82575 || type == i82576 || type == i210) {
1206                 /*
1207                  * See comment above for Qenable.
1208                  * Could shuffle the code?
1209                  */
1210                 r = csr32r(ctlr, Rxdctl) & ~(WthreshMASK | PthreshMASK);
1211                 csr32w(ctlr, Rxdctl, r | 2 << WthreshSHIFT | 2 << PthreshSHIFT);
1212         }
1213
1214         /*
1215          * Don't enable checksum offload.  In practice, it interferes with
1216          * tftp booting on at least the 82575.
1217          */
1218         csr32w(ctlr, Rxcsum, 0);
1219 }
1220
1221 static int i82563rim(void *ctlr)
1222 {
1223         return ((struct ctlr *)ctlr)->rim != 0;
1224 }
1225
1226 /*
1227  * With no errors and the Ixsm bit set,
1228  * the descriptor status Tpcs and Ipcs bits give
1229  * an indication of whether the checksums were
1230  * calculated and valid.
1231  *
1232  * Must be called with rd->errors == 0.
1233  */
1234 static void ckcksums(struct ctlr *ctlr, struct rd *rd, struct block *bp)
1235 {
1236         if (0) {
1237                 if (rd->status & Ixsm)
1238                         return;
1239                 ctlr->ixsm++;
1240                 if (rd->status & Ipcs) {
1241                         /*
1242                          * IP checksum calculated (and valid as errors == 0).
1243                          */
1244                         ctlr->ipcs++;
1245                         bp->flag |= Bipck;
1246                 }
1247                 if (rd->status & Tcpcs) {
1248                         /*
1249                          * TCP/UDP checksum calculated (and valid as errors == 0).
1250                          */
1251                         ctlr->tcpcs++;
1252                         bp->flag |= Btcpck | Budpck;
1253                 }
1254                 bp->flag |= Bpktck;
1255         }
1256 }
1257
1258 static void i82563rproc(void *arg)
1259 {
1260         struct rd *rd;
1261         struct block *bp;
1262         struct ctlr *ctlr;
1263         int rdh, rim, passed;
1264         struct ether *edev;
1265
1266         edev = arg;
1267         ctlr = edev->ctlr;
1268         i82563rxinit(ctlr);
1269         csr32w(ctlr, Rctl, csr32r(ctlr, Rctl) | Ren);
1270
1271         /*
1272          * TODO(dcross): Work references to ctlrtab into this code.
1273          */
1274         if (ctlr->type == i210)
1275                 csr32w(ctlr, Rxdctl, csr32r(ctlr, Rxdctl) | Qenable);
1276
1277         for (;;) {
1278                 i82563replenish(ctlr);
1279                 i82563im(ctlr, Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack);
1280                 ctlr->rsleep++;
1281                 rendez_sleep(&ctlr->rrendez, i82563rim, ctlr);
1282
1283                 rdh = ctlr->rdh;
1284                 passed = 0;
1285                 for (;;) {
1286                         rim = ctlr->rim;
1287                         ctlr->rim = 0;
1288                         rd = &ctlr->rdba[rdh];
1289                         if (!(rd->status & Rdd))
1290                                 break;
1291
1292                         /*
1293                          * Accept eop packets with no errors.
1294                          */
1295                         bp = ctlr->rb[rdh];
1296                         if ((rd->status & Reop) && rd->errors == 0) {
1297                                 bp->wp += rd->length;
1298                                 bp->lim = bp->wp;       /* lie like a dog. */
1299                                 if (0)
1300                                         ckcksums(ctlr, rd, bp);
1301                                 etheriq(edev, bp, 1);   /* pass pkt upstream */
1302                                 passed++;
1303                         } else {
1304                                 if (rd->status & Reop && rd->errors)
1305                                         printd("%s: input packet error %#ux\n",
1306                                                    tname[ctlr->type], rd->errors);
1307                                 freeb(bp);
1308                         }
1309                         ctlr->rb[rdh] = NULL;
1310
1311                         /* rd needs to be replenished to accept another pkt */
1312                         rd->status = 0;
1313                         ctlr->rdfree--;
1314                         ctlr->rdh = rdh = NEXT_RING(rdh, Nrd);
1315                         /*
1316                          * if number of rds ready for packets is too low,
1317                          * set up the unready ones.
1318                          */
1319                         if (ctlr->rdfree <= Nrd - 32 || (rim & Rxdmt0))
1320                                 i82563replenish(ctlr);
1321                 }
1322         }
1323 }
1324
1325 static int i82563lim(void *ctlr)
1326 {
1327         return ((struct ctlr *)ctlr)->lim != 0;
1328 }
1329
1330 static int phynum(struct ctlr *ctlr)
1331 {
1332         if (ctlr->phynum < 0)
1333                 switch (ctlr->type) {
1334                         case i82577:
1335 //      case i82578:            /* not yet implemented */
1336                         case i82579:
1337                         case i217:
1338                         case i218:
1339                                 ctlr->phynum = 2;       /* pcie phy */
1340                                 break;
1341                         default:
1342                                 ctlr->phynum = 1;       /* gbe phy */
1343                                 break;
1344                 }
1345         return ctlr->phynum;
1346 }
1347
1348 static unsigned int phyread(struct ctlr *ctlr, int reg)
1349 {
1350         unsigned int phy, i;
1351
1352         if (reg >= 32)
1353                 iprint("phyread: reg %d >= 32\n", reg);
1354         csr32w(ctlr, Mdic, MDIrop | phynum(ctlr) << MDIpSHIFT | reg << MDIrSHIFT);
1355         phy = 0;
1356         for (i = 0; i < 64; i++) {
1357                 phy = csr32r(ctlr, Mdic);
1358                 if (phy & (MDIe | MDIready))
1359                         break;
1360                 udelay(1);
1361         }
1362         if ((phy & (MDIe | MDIready)) != MDIready)
1363                 return ~0;
1364         return phy & 0xffff;
1365 }
1366
1367 static unsigned int phywrite(struct ctlr *ctlr, int reg, uint16_t val)
1368 {
1369         unsigned int phy, i;
1370
1371         if (reg >= 32)
1372                 iprint("phyread: reg %d >= 32\n", reg);
1373         csr32w(ctlr, Mdic, MDIwop | phynum(ctlr) << MDIpSHIFT | reg << MDIrSHIFT |
1374                    val);
1375         phy = 0;
1376         for (i = 0; i < 64; i++) {
1377                 phy = csr32r(ctlr, Mdic);
1378                 if (phy & (MDIe | MDIready))
1379                         break;
1380                 udelay(1);
1381         }
1382         if ((phy & (MDIe | MDIready)) != MDIready)
1383                 return ~0;
1384         return 0;
1385 }
1386
1387 static uint32_t kmrnread(struct ctlr *ctlr, uint32_t reg_addr)
1388 {
1389         /* write register address */
1390         csr32w(ctlr, Kumctrlsta,
1391                ((reg_addr << Kumctrlstaoffshift) & Kumctrlstaoff) | Kumctrlstaren);
1392         udelay(2);
1393         /* read data */
1394         return csr32r(ctlr, Kumctrlsta);
1395 }
1396
1397 static void kmrnwrite(struct ctlr *ctlr, uint32_t reg_addr, uint16_t data)
1398 {
1399         csr32w(ctlr, Kumctrlsta, ((reg_addr << Kumctrlstaoffshift) &
1400                                                           Kumctrlstaoff) | data);
1401         udelay(2);
1402 }
1403
1404 /*
1405  * this is essentially black magic.  we blindly follow the incantations
1406  * prescribed by the god Intel:
1407  *
1408  * On ESB2, the MAC-to-PHY (Kumeran) interface must be configured after
1409  * link is up before any traffic is sent.
1410  *
1411  * workaround DMA unit hang on I218
1412  *
1413  * At 1Gbps link speed, one of the MAC's internal clocks can be stopped
1414  * for up to 4us when entering K1 (a power mode of the MAC-PHY
1415  * interconnect).  If the MAC is waiting for completion indications for 2
1416  * DMA write requests into Host memory (e.g.  descriptor writeback or Rx
1417  * packet writing) and the indications occur while the clock is stopped,
1418  * both indications will be missed by the MAC, causing the MAC to wait
1419  * for the completion indications and be unable to generate further DMA
1420  * write requests.  This results in an apparent hardware hang.
1421  *
1422  * Work-around the bug by disabling the de-assertion of the clock request
1423  * when 1Gbps link is acquired (K1 must be disabled while doing this).
1424  * Also, set appropriate Tx re-transmission timeouts for 10 and 100-half
1425  * link speeds to avoid Tx hangs.
1426  */
1427 static void k1fix(struct ctlr *ctlr)
1428 {
1429         int txtmout;                            /* units of 10µs */
1430         uint32_t fextnvm6, status;
1431         uint16_t reg;
1432         struct ether *edev;
1433
1434         edev = ctlr->edev;
1435         fextnvm6 = csr32r(ctlr, Fextnvm6);
1436         status = csr32r(ctlr, Status);
1437         /* status speed bits are different on 217/8 than earlier ctlrs */
1438         if (edev->link && status & (Sspeed1000 >> 2)) {
1439                 reg = kmrnread(ctlr, Kumctrlstak1cfg);
1440                 kmrnwrite(ctlr, Kumctrlstak1cfg, reg & ~Kumctrlstak1enable);
1441                 udelay(10);
1442                 csr32w(ctlr, Fextnvm6, fextnvm6 | Fextnvm6reqpllclk);
1443                 kmrnwrite(ctlr, Kumctrlstak1cfg, reg);
1444                 ctlr->didk1fix = 1;
1445                 return;
1446         }
1447         /* else uncommon cases */
1448
1449         fextnvm6 &= ~Fextnvm6reqpllclk;
1450         /*
1451          * 217 manual claims not to have Frcdplx bit in status;
1452          * 218 manual just omits the non-phy registers.
1453          */
1454         if (!edev->link ||
1455                 (status & (Sspeed100 >> 2 | Frcdplx)) == (Sspeed100 >> 2 | Frcdplx)) {
1456                 csr32w(ctlr, Fextnvm6, fextnvm6);
1457                 ctlr->didk1fix = 1;
1458                 return;
1459         }
1460
1461         /* access other page via phy addr 1 reg 31, then access reg 16-30 */
1462         phywrite(ctlr, Phypage, I217inbandctlpage << 5);
1463         reg = phyread(ctlr, I217inbandctlreg) & ~I217inbandctllnkststxtmoutmask;
1464         if (status & (Sspeed100 >> 2)) {        /* 100Mb/s half-duplex? */
1465                 txtmout = 5;
1466                 fextnvm6 &= ~Fextnvm6enak1entrycond;
1467         } else {        /* 10Mb/s */
1468                 txtmout = 50;
1469                 fextnvm6 |= Fextnvm6enak1entrycond;
1470         }
1471         phywrite(ctlr, I217inbandctlreg, reg |
1472                          txtmout << I217inbandctllnkststxtmoutshift);
1473         csr32w(ctlr, Fextnvm6, fextnvm6);
1474         phywrite(ctlr, Phypage, 0 << 5);        /* reset page to usual 0 */
1475         ctlr->didk1fix = 1;
1476 }
1477
1478 /*
1479  * watch for changes of link state
1480  */
1481 static void i82563lproc(void *v)
1482 {
1483         unsigned int phy, sp, a, phy79, prevlink;
1484         struct ctlr *ctlr;
1485         struct ether *edev;
1486
1487         edev = v;
1488         ctlr = edev->ctlr;
1489         phy79 = 0;
1490         switch (ctlr->type) {
1491                 case i82579:
1492                 case i82580:
1493                 case i217:
1494                 case i218:
1495                 case i350:
1496                         phy79 = 1;
1497                         break;
1498         }
1499         /*
1500          * TODO(dcross): Extract PHY number from ctlrtab.
1501          */
1502         if (ctlr->type == i82573 && phyread(ctlr, Phyier) != ~0) {
1503                 phy = phyread(ctlr, Phyier);
1504                 phywrite(ctlr, Phyier, phy | Lscie | Ancie | Spdie | Panie);
1505         } else if (phy79 && phyread(ctlr, Phyier218) != ~0) {
1506                 phy = phyread(ctlr, Phyier218);
1507                 phywrite(ctlr, Phyier218, phy | Lscie218 | Ancie218 | Spdie218);
1508         }
1509         prevlink = 0;
1510         for (;;) {
1511                 a = 0;
1512                 phy = phyread(ctlr, phy79 ? Phystat : Physsr);
1513                 if (phy == ~0)
1514                         goto next;
1515                 if (phy79) {
1516                         sp = (phy >> 8) & 3;
1517                         // a = phy & (ctlr->type == i218? Anfs: Ans);
1518                         a = phy & Anfs;
1519                 } else {
1520                         sp = (phy >> 14) & 3;
1521                         switch (ctlr->type) {
1522                                 case i82563:
1523                                 case i210:
1524                                         a = phyread(ctlr, Phyisr) & Ane;        /* a-n error */
1525                                         break;
1526                                 case i82571:
1527                                 case i82572:
1528                                 case i82575:
1529                                 case i82576:
1530                                         a = phyread(ctlr, Phylhr) & Anf;        /* a-n fault */
1531                                         sp = (sp - 1) & 3;
1532                                         break;
1533                         }
1534                 }
1535                 if (a)  /* enable & restart autoneg */  /* enable & restart autoneg */
1536                         phywrite(ctlr, Phyctl, phyread(ctlr, Phyctl) | Ran | Ean);
1537                 edev->link = (phy & (phy79 ? Link : Rtlink)) != 0;
1538                 if (edev->link) {
1539                         ctlr->speeds[sp]++;
1540                         if (speedtab[sp])
1541                                 edev->mbps = speedtab[sp];
1542                         if (prevlink == 0 && ctlr->type == i218)
1543                                 k1fix(ctlr);    /* link newly up: kludge away */
1544                         netif_carrier_on(edev);
1545                 } else
1546                         ctlr->didk1fix = 0;     /* force fix at next link up */
1547                 prevlink = edev->link;
1548 next:
1549                 ctlr->lim = 0;
1550                 i82563im(ctlr, Lsc);
1551                 ctlr->lsleep++;
1552                 rendez_sleep(&ctlr->lrendez, i82563lim, ctlr);
1553         }
1554 }
1555
1556 static int return0(void *unused_void_p)
1557 {
1558         return 0;
1559 }
1560
1561 static void i82563tproc(void *v)
1562 {
1563         struct ether *edev;
1564         struct ctlr *ctlr;
1565
1566         edev = v;
1567         ctlr = edev->ctlr;
1568         for (;;) {
1569                 rendez_sleep(&ctlr->trendez, return0, 0);
1570                 i82563transmit(edev);
1571         }
1572 }
1573
1574 /*
1575  * controller is buggered; shock it back to life.
1576  */
1577 static void restart(struct ctlr *ctlr)
1578 {
1579         if (0) {
1580                 static spinlock_t rstlock;
1581
1582                 qlock(&ctlr->tlock);
1583                 spin_lock_irqsave(&rstlock);
1584                 iprint("#l%d: resetting...", ctlr->edev->ctlrno);
1585                 i82563reset(ctlr);
1586                 /* [rt]xinit reset the ring indices */
1587                 i82563txinit(ctlr);
1588                 i82563rxinit(ctlr);
1589                 csr32w(ctlr, Rctl, csr32r(ctlr, Rctl) | Ren);
1590                 spin_unlock_irqsave(&rstlock);
1591                 qunlock(&ctlr->tlock);
1592                 iprint("reset\n");
1593         }
1594 }
1595
1596 static void freemem(struct ctlr *ctlr)
1597 {
1598         kfree(ctlr->tb);
1599         ctlr->tb = NULL;
1600         kfree(ctlr->rb);
1601         ctlr->rb = NULL;
1602         kfree(ctlr->tdba);
1603         ctlr->tdba = NULL;
1604         kfree(ctlr->rdba);
1605         ctlr->rdba = NULL;
1606 }
1607
1608 static void i82563attach(struct ether *edev)
1609 {
1610         ERRSTACK(2);
1611         int i;
1612         struct block *bp;
1613         struct ctlr *ctlr;
1614         char *lname, *rname, *tname;
1615
1616         ctlr = edev->ctlr;
1617         qlock(&ctlr->alock);
1618
1619         if (ctlr->attached) {
1620                 qunlock(&ctlr->alock);
1621                 return;
1622         }
1623
1624         if (waserror()) {
1625                 freemem(ctlr);
1626                 qunlock(&ctlr->alock);
1627                 nexterror();
1628         }
1629
1630         ctlr->alloc = kzmalloc(Nrd * sizeof(struct rd) +
1631                                    Ntd * sizeof(struct td) + 255,
1632                                MEM_WAIT);
1633         if (ctlr->alloc == NULL) {
1634                 qunlock(&ctlr->alock);
1635                 error(ENOMEM, "i82563attach: error allocating rx/tx rings");
1636         }
1637         ctlr->rdba = (struct rd *)ROUNDUP((uintptr_t)ctlr->alloc, 256);
1638         ctlr->tdba = (struct td *)(ctlr->rdba + Nrd);
1639         ctlr->rb = kzmalloc(Nrd * sizeof(struct block *), 0);
1640         ctlr->tb = kzmalloc(Ntd * sizeof(struct block *), 0);
1641         if (ctlr->rb == NULL || ctlr->tb == NULL) {
1642                 qunlock(&ctlr->alock);
1643                 error(ENOMEM, "i82563attach: error allocating rx/tx buffers");
1644         }
1645
1646         ctlr->edev = edev;      /* point back to Ether* */
1647         ctlr->attached = 1;
1648
1649         lname = kzmalloc(KNAMELEN, MEM_WAIT);
1650         snprintf(lname, KNAMELEN, "#l%dl", edev->ctlrno);
1651         ktask(lname, i82563lproc, edev);
1652
1653         rname = kzmalloc(KNAMELEN, MEM_WAIT);
1654         snprintf(rname, KNAMELEN, "#l%dr", edev->ctlrno);
1655         ktask(rname, i82563rproc, edev);
1656
1657         tname = kzmalloc(KNAMELEN, MEM_WAIT);
1658         snprintf(tname, KNAMELEN, "#l%dt", edev->ctlrno);
1659         ktask(tname, i82563tproc, edev);
1660
1661         i82563txinit(ctlr);
1662
1663         qunlock(&ctlr->alock);
1664         poperror();
1665 }
1666
1667 static void i82563interrupt(struct hw_trapframe *unused_hw_trapframe, void *arg)
1668 {
1669         struct ctlr *ctlr;
1670         struct ether *edev;
1671         int icr, im, i, loops;
1672
1673         edev = arg;
1674         ctlr = edev->ctlr;
1675         spin_lock_irqsave(&ctlr->imlock);
1676         csr32w(ctlr, Imc, ~0);
1677         im = ctlr->im;
1678         loops = 0;
1679         i = Nrd;        /* don't livelock */
1680         for (icr = csr32r(ctlr, Icr); icr & ctlr->im && i-- > 0;
1681                  icr = csr32r(ctlr, Icr)) {
1682                 loops++;
1683                 if (icr & Lsc) {
1684                         im &= ~Lsc;
1685                         ctlr->lim = icr & Lsc;
1686                         rendez_wakeup(&ctlr->lrendez);
1687                         ctlr->lintr++;
1688                 }
1689                 if (icr & (Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack)) {
1690                         ctlr->rim = icr & (Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack);
1691                         im &= ~(Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack);
1692                         rendez_wakeup(&ctlr->rrendez);
1693                         ctlr->rintr++;
1694                 }
1695                 if (icr & Txdw) {
1696                         im &= ~Txdw;
1697                         ctlr->tintr++;
1698                         rendez_wakeup(&ctlr->trendez);
1699                 }
1700         }
1701         ctlr->im = im;
1702         csr32w(ctlr, Ims, im);
1703         spin_unlock_irqsave(&ctlr->imlock);
1704 }
1705
1706 /* assume misrouted interrupts and check all controllers */
1707 static void i82575interrupt(struct hw_trapframe *unused_hw_trapframe,
1708                             void *unused_arg)
1709 {
1710         struct ctlr *ctlr;
1711
1712         for (ctlr = i82563ctlrhead; ctlr != NULL && ctlr->edev != NULL;
1713                  ctlr = ctlr->next)
1714                 i82563interrupt(NULL, ctlr->edev);
1715 }
1716
1717 static int i82563detach0(struct ctlr *ctlr)
1718 {
1719         int r, timeo;
1720
1721         /*
1722          * Perform a device reset to get the chip back to the
1723          * power-on state, followed by an EEPROM reset to read
1724          * the defaults for some internal registers.
1725          */
1726         csr32w(ctlr, Imc, ~0);
1727         csr32w(ctlr, Rctl, 0);
1728         csr32w(ctlr, Tctl, 0);
1729
1730         udelay(1000 * 1000);
1731
1732         /*
1733          * Balance Rx/Tx packet buffer.
1734          * No need to set PBA register unless using jumbo, defaults to 32KB
1735          * for receive. If it is changed, then have to do a MAC reset,
1736          * and need to do that at the the right time as it will wipe stuff.
1737          *
1738          * TODO(dcross): reconcile the following code with the above commentary.
1739          */
1740         if (0) {
1741                 if (ctlr->rbsz > 8192 && ctlrtab[ctlr->type].flag & Fpba) {
1742                         ctlr->pba = csr32r(ctlr, Pba);
1743                         r = ctlr->pba >> 16;
1744                         r += ctlr->pba & 0xffff;
1745                         r >>= 1;
1746                         csr32w(ctlr, Pba, r);
1747                 } else if (ctlr->type == i82573 && ctlr->rbsz > 1514)
1748                         csr32w(ctlr, Pba, 14);
1749         }
1750         ctlr->pba = csr32r(ctlr, Pba);
1751
1752         /* set packet buffer size if present.  no effect until soft reset. */
1753         switch (ctlr->type) {
1754                 case i82566:
1755                 case i82567:
1756                 case i217:
1757                         ctlr->pbs = 16; /* in KB */
1758                         csr32w(ctlr, Pbs, ctlr->pbs);
1759                         break;
1760                 case i218:
1761                         // after pxe or 9fat boot, pba is always 0xe0012 on i218 => 32K
1762                         ctlr->pbs = (ctlr->pba >> 16) + (uint16_t) ctlr->pba;
1763                         csr32w(ctlr, Pbs, ctlr->pbs);
1764                         break;
1765         }
1766
1767         r = csr32r(ctlr, Ctrl);
1768         if (ctlr->type == i82566 || ctlr->type == i82567 || ctlr->type == i82579)
1769                 r |= Phyrst;
1770         csr32w(ctlr, Ctrl, Devrst | r);
1771         udelay(1000);
1772         for (timeo = 0; timeo < 1000; timeo++) {
1773                 if (!(csr32r(ctlr, Ctrl) & Devrst))
1774                         break;
1775                 udelay(1000);
1776         }
1777         if (csr32r(ctlr, Ctrl) & Devrst)
1778                 return -1;
1779
1780         r = csr32r(ctlr, Ctrlext);
1781         csr32w(ctlr, Ctrlext, r | Eerst);
1782         udelay(1000);
1783         for (timeo = 0; timeo < 1000; timeo++) {
1784                 if (!(csr32r(ctlr, Ctrlext) & Eerst))
1785                         break;
1786                 udelay(1000);
1787         }
1788         if (csr32r(ctlr, Ctrlext) & Eerst)
1789                 return -1;
1790
1791         csr32w(ctlr, Imc, ~0);
1792         udelay(1000);
1793         for (timeo = 0; timeo < 1000; timeo++) {
1794                 if (!csr32r(ctlr, Icr))
1795                         break;
1796                 udelay(1000);
1797         }
1798         if (csr32r(ctlr, Icr))
1799                 return -1;
1800
1801         csr32w(ctlr, Ctrl, Slu | csr32r(ctlr, Ctrl));
1802         return 0;
1803 }
1804
1805 static int i82563detach(struct ctlr *ctlr)
1806 {
1807         int r;
1808         static spinlock_t detlck;
1809
1810         spin_lock_irqsave(&detlck);
1811         r = i82563detach0(ctlr);
1812         spin_unlock_irqsave(&detlck);
1813         return r;
1814 }
1815
1816 static void i82563shutdown(struct ether *ether)
1817 {
1818         i82563detach(ether->ctlr);
1819 }
1820
1821 static uint16_t eeread(struct ctlr *ctlr, int adr)
1822 {
1823         uint32_t n;
1824
1825         csr32w(ctlr, Eerd, EEstart | adr << 2);
1826         n = 1000000;
1827         while (n > 0 && (csr32r(ctlr, Eerd) & EEdone) == 0)
1828                 n--;
1829         if (n == 0)
1830                 panic("i82563: eeread stuck");
1831         return csr32r(ctlr, Eerd) >> 16;
1832 }
1833
1834 /* load eeprom into ctlr */
1835 static int eeload(struct ctlr *ctlr)
1836 {
1837         uint16_t sum;
1838         int data, adr;
1839
1840         sum = 0;
1841         for (adr = 0; adr < 0x40; adr++) {
1842                 data = eeread(ctlr, adr);
1843                 ctlr->eeprom[adr] = data;
1844                 sum += data;
1845         }
1846         return sum;
1847 }
1848
1849 static int fcycle(struct ctlr *unused_ctlr_p, struct flash *f)
1850 {
1851         uint16_t s, i;
1852
1853         s = f->reg[Fsts];
1854         if ((s & Fvalid) == 0)
1855                 return -1;
1856         f->reg[Fsts] |= Fcerr | Ael;
1857         for (i = 0; i < 10; i++) {
1858                 if ((s & Scip) == 0)    /* spi cycle done? */
1859                         return 0;
1860                 udelay(1000);
1861                 s = f->reg[Fsts];
1862         }
1863         return -1;
1864 }
1865
1866 static int fread(struct ctlr *ctlr, struct flash *f, int ladr)
1867 {
1868         uint16_t s;
1869         uint32_t n;
1870
1871         udelay(1000);
1872         if (fcycle(ctlr, f) == -1)
1873                 return -1;
1874         f->reg[Fsts] |= Fdone;
1875         f->reg32[Faddr] = ladr;
1876
1877         /* setup flash control register */
1878         s = f->reg[Fctl] & ~(0x1f << 8);
1879         s |= (2 - 1) << 8;      /* 2 bytes */
1880         s &= ~(2 * Flcycle);    /* read */
1881         f->reg[Fctl] = s | Fgo;
1882
1883         n = 1000000;
1884         while (n > 0 && (f->reg[Fsts] & Fdone) == 0)
1885                 n--;
1886         if (n == 0)
1887                 panic("i82563: fread stuck");
1888         if (f->reg[Fsts] & (Fcerr | Ael))
1889                 return -1;
1890         return f->reg32[Fdata] & 0xffff;
1891 }
1892
1893 /* load flash into ctlr */
1894 static int fload(struct ctlr *ctlr)
1895 {
1896         uint32_t data, r, adr;
1897         uint16_t sum;
1898         uintptr_t mmio_paddr;
1899         struct pci_device *pcidev = ctlr->pcidev;
1900         struct flash f;
1901
1902         mmio_paddr = pcidev->bar[1].mmio_base32 ? pcidev->bar[1].mmio_base32 :
1903                                                   pcidev->bar[1].mmio_base64;
1904         f.reg = (void *)vmap_pmem(mmio_paddr, pcidev->bar[1].mmio_sz);
1905         if (f.reg == NULL)
1906                 return -1;
1907         f.reg32 = (void *)f.reg;
1908         f.base = f.reg32[Bfpr] & 0x1fff;
1909         f.lim = (f.reg32[Bfpr] >> 16) & 0x1fff;
1910         if (csr32r(ctlr, Eec) & Sec1val)
1911                 f.base += (f.lim + 1 - f.base) >> 1;
1912         r = f.base << 12;
1913
1914         sum = 0;
1915         for (adr = 0; adr < 0x40; adr++) {
1916                 data = fread(ctlr, &f, r + adr * 2);
1917                 if (data == -1)
1918                         break;
1919                 ctlr->eeprom[adr] = data;
1920                 sum += data;
1921         }
1922         vunmap_vmem((uintptr_t)f.reg, pcidev->bar[1].mmio_sz);
1923         return sum;
1924 }
1925
1926 static int i82563reset(struct ctlr *ctlr)
1927 {
1928         int i, r, type;
1929
1930         /*
1931          * TODO(dcross): Integrate ctlrtab references into this code.
1932          */
1933         if (i82563detach(ctlr)) {
1934                 iprint("82563 reset: detach failed\n");
1935                 return -1;
1936         }
1937         type = ctlr->type;
1938         if (ctlr->ra[Eaddrlen - 1] != 0)
1939                 goto macset;
1940         switch (type) {
1941                 case i82566:
1942                 case i82567:
1943                 case i82577:
1944         //  case i82578:            /* not yet implemented */
1945                 case i82579:
1946                 case i217:
1947                 case i218:
1948                         r = fload(ctlr);
1949                         break;
1950                 default:
1951                         r = eeload(ctlr);
1952                         break;
1953         }
1954         if (r != 0 && r != 0xBABA) {
1955                 printd("%s: bad EEPROM checksum - %#.4ux\n", tname[type], r);
1956                 //return -1;
1957         }
1958
1959         /* set mac addr */
1960         for (i = 0; i < Eaddrlen / 2; i++) {
1961                 ctlr->ra[2 * i] = ctlr->eeprom[Ea + i];
1962                 ctlr->ra[2 * i + 1] = ctlr->eeprom[Ea + i] >> 8;
1963         }
1964         /* ea ctlr[1] = ea ctlr[0]+1 */
1965         ctlr->ra[5] += (csr32r(ctlr, Status) & Lanid) >> 2;
1966         /*
1967          * zero other mac addresses.`
1968          * AV bits should be zeroed by master reset & there may only be 11
1969          * other registers on e.g., the i217.
1970          */
1971         for (i = 1; i < 12; i++) {      /* `12' used to be `16' here */
1972                 csr32w(ctlr, Ral + i * 8, 0);
1973                 csr32w(ctlr, Rah + i * 8, 0);
1974         }
1975         memset(ctlr->mta, 0, sizeof(ctlr->mta));
1976 macset:
1977         /* low mac addr */
1978         csr32w(ctlr, Ral,
1979                ctlr->ra[3] << 24 | ctlr->ra[2] << 16 |
1980                ctlr->ra[1] << 8 | ctlr->ra[0]);
1981         /* address valid | high mac addr */
1982         csr32w(ctlr, Rah, 0x80000000 | ctlr->ra[5] << 8 | ctlr->ra[4]);
1983
1984         /* populate multicast table */
1985         for (i = 0; i < mcbitstolongs(mcastbits(ctlr)); i++)
1986                 csr32w(ctlr, Mta + i * 4, ctlr->mta[i]);
1987
1988         /*
1989          * Does autonegotiation affect this manual setting?
1990          * The correct values here should depend on the PBA value
1991          * and maximum frame length, no?
1992          */
1993         /* fixed flow control ethernet address 0x0180c2000001 */
1994         csr32w(ctlr, Fcal, 0x00C28001);
1995         csr32w(ctlr, Fcah, 0x0100);
1996         if (type != i82579 && type != i210 && type != i217 && type != i218)
1997                 /* flow control type, dictated by Intel */
1998                 csr32w(ctlr, Fct, 0x8808);
1999         csr32w(ctlr, Fcttv, 0x0100);    /* for XOFF frame */
2000         // ctlr->fcrtl = 0x00002000;        /* rcv low water mark: 8KB */
2001         /* rcv high water mark: 16KB, < rcv buffer in PBA & RXA */
2002         // ctlr->fcrth = 0x00004000;
2003         ctlr->fcrtl = ctlr->fcrth = 0;
2004         csr32w(ctlr, Fcrtl, ctlr->fcrtl);
2005         csr32w(ctlr, Fcrth, ctlr->fcrth);
2006         return 0;
2007 }
2008
2009 static void i82563pci(void)
2010 {
2011         int type;
2012         uintptr_t io;
2013         void *mem;
2014         struct pci_device *p;
2015         struct ctlr *ctlr;
2016
2017         p = NULL;
2018         STAILQ_FOREACH(p, &pci_devices, all_dev) {
2019                 if (p->ven_id != 0x8086)
2020                         continue;
2021                 switch (p->dev_id) {
2022                         default:
2023                                 continue;
2024                         case 0x1096:
2025                         case 0x10ba:
2026                         case 0x1098:    /* serdes; not seen */
2027                         case 0x10bb:    /* serdes */
2028                                 type = i82563;
2029                                 break;
2030                         case 0x1049:    /* mm */
2031                         case 0x104a:    /* dm */
2032                         case 0x104b:    /* dc */
2033                         case 0x104d:    /* mc */
2034                         case 0x10bd:    /* dm */
2035                         case 0x294c:    /* dc-2 */
2036                                 type = i82566;
2037                                 break;
2038                         case 0x10de:    /* lm-3 */
2039                         case 0x10df:    /* lf ich10 */
2040                         case 0x10e5:    /* lm ich9 */
2041                         case 0x10f5:    /* lm-2 */
2042                                 type = i82567;
2043                                 break;
2044                         case 0x10bf:    /* lf ich9m */
2045                         case 0x10cb:    /* v ich9m */
2046                         case 0x10cd:    /* lf ich10 */
2047                         case 0x10ce:    /* v ich10 */
2048                         case 0x10cc:    /* lm ich10 */
2049                                 type = i82567m;
2050                                 break;
2051                         case 0x105e:    /* eb */
2052                         case 0x105f:    /* eb */
2053                         case 0x1060:    /* eb */
2054                         case 0x10a4:    /* eb */
2055                         case 0x10a5:    /* eb  fiber */
2056                         case 0x10bc:    /* eb */
2057                         case 0x10d9:    /* eb serdes */
2058                         case 0x10da:    /* eb serdes “ophir” */
2059                                 type = i82571;
2060                                 break;
2061                         case 0x107d:    /* eb copper */
2062                         case 0x107e:    /* ei fiber */
2063                         case 0x107f:    /* ei */
2064                         case 0x10b9:    /* sic, 82572gi */
2065                                 type = i82572;
2066                                 break;
2067                         case 0x108b:    /*  v */
2068                         case 0x108c:    /*  e (iamt) */
2069                         case 0x109a:    /*  l */
2070                                 type = i82573;
2071                                 break;
2072                         case 0x10d3:    /* l */
2073                                 type = i82574;
2074                                 break;
2075                         case 0x10a7:    /* 82575eb: one of a pair of controllers */
2076                         case 0x10a9:    /* fiber/serdes */
2077                                 type = i82575;
2078                                 break;
2079                         case 0x10c9:    /* 82576 copper */
2080                         case 0x10e6:    /* 82576 fiber */
2081                         case 0x10e7:    /* 82576 serdes */
2082                         case 0x150d:    /* backplane */
2083                                 type = i82576;
2084                                 break;
2085                         case 0x10ea:    /* 82577lm */
2086                                 type = i82577;
2087                                 break;
2088                         case 0x10eb:    /* lm “calpella” */
2089                                 type = i82577m;
2090                                 break;
2091                         case 0x1502:    /* 82579lm */
2092                         case 0x1503:    /* 82579v */
2093                                 type = i82579;
2094                                 break;
2095                         case 0x10f0:    /* dm “king's creek” */
2096                                 type = i82578m;
2097                                 break;
2098                         case 0x150e:    /* “barton hills” */
2099                         case 0x150f:    /* fiber */
2100                         case 0x1510:    /* backplane */
2101                         case 0x1511:    /* sfp */
2102                         case 0x1516:
2103                                 type = i82580;
2104                                 break;
2105                         case 0x1506:    /* v */
2106                                 type = i82583;
2107                                 break;
2108                         case 0x1533:    /* i210-t1 */
2109                         case 0x1534:    /* i210 */
2110                         case 0x1536:    /* i210-fiber */
2111                         case 0x1537:    /* i210-backplane */
2112                         case 0x1538:
2113                         case 0x1539:    /* i211 */
2114                         case 0x157b:    /* i210 */
2115                         case 0x157c:    /* i210 */
2116                                 type = i210;
2117                                 break;
2118                         case 0x153a:    /* i217-lm */
2119                         case 0x153b:    /* i217-v */
2120                                 type = i217;
2121                                 break;
2122                         case 0x15a0:    /* i218-lm */
2123                         case 0x15a1:    /* i218-v */
2124                         case 0x15a2:    /* i218-lm */
2125                         case 0x15a3:    /* i218-v */
2126                                 type = i218;
2127                                 break;
2128                         case 0x151f:    /* “powerville” eeprom-less */
2129                         case 0x1521:    /* copper */
2130                         case 0x1522:    /* fiber */
2131                         case 0x1523:    /* serdes */
2132                         case 0x1524:    /* sgmii */
2133                                 type = i350;
2134                                 break;
2135                 }
2136
2137                 io = p->bar[0].mmio_base32 ? p->bar[0].mmio_base32 :
2138                                                                          p->bar[0].mmio_base64;
2139                 mem = (void *)vmap_pmem(io, p->bar[0].mmio_sz);
2140                 if (mem == NULL) {
2141                         printd("%s: can't map %.8lux\n", tname[type], io);
2142                         continue;
2143                 }
2144                 ctlr = kzmalloc(sizeof(struct ctlr), 0);
2145                 if (ctlr == NULL) {
2146                         vunmap_vmem((uintptr_t)mem, p->bar[0].mmio_sz);
2147                         error(ENOMEM, "i82563pci: alloc for ctlr failed");
2148                 }
2149                 ctlr->mmio_paddr = io;
2150                 ctlr->rbsz = ctlrtab[type].mtu;
2151                 ctlr->pcidev = p;
2152                 ctlr->type = type;
2153                 ctlr->nic = mem;
2154                 ctlr->phynum = -1;      /* not yet known */
2155
2156                 qlock_init(&ctlr->alock);
2157                 spinlock_init_irqsave(&ctlr->imlock);
2158                 rendez_init(&ctlr->lrendez);
2159                 qlock_init(&ctlr->slock);
2160                 rendez_init(&ctlr->rrendez);
2161                 rendez_init(&ctlr->trendez);
2162                 qlock_init(&ctlr->tlock);
2163
2164                 pci_set_bus_master(p);
2165                 if (i82563reset(ctlr)) {
2166                         vunmap_vmem((uintptr_t)mem, p->bar[0].mmio_sz);
2167                         kfree(ctlr);
2168                         continue;
2169                 }
2170
2171                 if (i82563ctlrhead != NULL)
2172                         i82563ctlrtail->next = ctlr;
2173                 else
2174                         i82563ctlrhead = ctlr;
2175                 i82563ctlrtail = ctlr;
2176         }
2177 }
2178
2179 static int pnp(struct ether *edev, int type)
2180 {
2181         struct ctlr *ctlr;
2182         static int done;
2183
2184         if (!done) {
2185                 i82563pci();
2186                 done = 1;
2187         }
2188
2189         /*
2190          * Any adapter matches if no edev->port is supplied,
2191          * otherwise the ports must match.
2192          */
2193         for (ctlr = i82563ctlrhead; ctlr != NULL; ctlr = ctlr->next) {
2194                 if (ctlr->active)
2195                         continue;
2196                 if (type != Iany && ctlr->type != type)
2197                         continue;
2198                 if (edev->port == 0 || edev->port == ctlr->mmio_paddr) {
2199                         ctlr->active = 1;
2200                         break;
2201                 }
2202         }
2203         if (ctlr == NULL)
2204                 return -1;
2205
2206         edev->ctlr = ctlr;
2207         strlcpy(edev->drv_name, "i82563", KNAMELEN);
2208         ctlr->edev = edev;      /* point back to Ether* */
2209         edev->port = ctlr->mmio_paddr;
2210         edev->irq = ctlr->pcidev->irqline;
2211         edev->tbdf = pci_to_tbdf(ctlr->pcidev);
2212         edev->mbps = 1000;
2213         edev->max_mtu = ctlr->rbsz - ETHERHDRSIZE;
2214         edev->mtu = edev->mtu;
2215         memmove(edev->ea, ctlr->ra, Eaddrlen);
2216         /* Jim or whoever have this turned on already.  We might be capable of other
2217          * features. */
2218         edev->feat = NETF_RXCSUM;
2219
2220         /*
2221          * Linkage to the generic ethernet driver.
2222          */
2223         edev->attach = i82563attach;
2224         edev->transmit = i82563transmit;
2225         edev->ifstat = i82563ifstat;
2226         edev->ctl = i82563ctl;
2227
2228         edev->arg = edev;
2229         edev->promiscuous = i82563promiscuous;
2230         edev->shutdown = i82563shutdown;
2231         edev->multicast = i82563multicast;
2232
2233         register_irq(edev->irq,
2234                      ctlr->type == i82575 ? i82575interrupt : i82563interrupt,
2235                      edev, edev->tbdf);
2236         return 0;
2237 }
2238
2239 static int anypnp(struct ether *e)
2240 {
2241         return pnp(e, Iany);
2242 }
2243
2244 static int i82563pnp(struct ether *e)
2245 {
2246         return pnp(e, i82563);
2247 }
2248
2249 static int i82566pnp(struct ether *e)
2250 {
2251         return pnp(e, i82566);
2252 }
2253
2254 static int i82571pnp(struct ether *e)
2255 {
2256         return pnp(e, i82571);
2257 }
2258
2259 static int i82572pnp(struct ether *e)
2260 {
2261         return pnp(e, i82572);
2262 }
2263
2264 static int i82573pnp(struct ether *e)
2265 {
2266         return pnp(e, i82573);
2267 }
2268
2269 static int i82575pnp(struct ether *e)
2270 {
2271         return pnp(e, i82575);
2272 }
2273
2274 static int i82579pnp(struct ether *e)
2275 {
2276         return pnp(e, i82579);
2277 }
2278
2279 static int i210pnp(struct ether *e)
2280 {
2281         return pnp(e, i210);
2282 }
2283
2284 static int i217pnp(struct ether *e)
2285 {
2286         return pnp(e, i217);
2287 }
2288
2289 static int i218pnp(struct ether *e)
2290 {
2291         return pnp(e, i218);
2292 }
2293
2294 linker_func_3(ether82563link)
2295 {
2296         /* recognise lots of model numbers for debugging assistance */
2297         addethercard("i82563", i82563pnp);
2298         addethercard("i82566", i82566pnp);
2299         addethercard("i82571", i82571pnp);
2300         addethercard("i82572", i82572pnp);
2301         addethercard("i82573", i82573pnp);
2302         addethercard("i82575", i82575pnp);
2303         addethercard("i82579", i82579pnp);
2304         addethercard("i210", i210pnp);
2305         addethercard("i217", i217pnp);
2306         addethercard("i218", i218pnp);
2307         addethercard("igbepcie", anypnp);
2308 }