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