82563: faster booting
[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 to work in Akaros. */
25 /*
26  * Intel 8256[367], 8257[1-9], 8258[03], i21[01], i350
27  *      Gigabit Ethernet PCI-Express Controllers
28  * Coraid EtherDrive® hba
29  */
30 #include <vfs.h>
31 #include <kfs.h>
32 #include <slab.h>
33 #include <kmalloc.h>
34 #include <kref.h>
35 #include <string.h>
36 #include <stdio.h>
37 #include <assert.h>
38 #include <error.h>
39 #include <cpio.h>
40 #include <pmap.h>
41 #include <smp.h>
42 #include <ip.h>
43
44 /*
45  * note: the 82575, 82576 and 82580 are operated using registers aliased
46  * to the 82563-style architecture.  many features seen in the 82598
47  * are also seen in the 82575 part.
48  */
49
50 enum {
51         /* General */
52
53         Ctrl = 0x0000,                          /* Device Control */
54         Status = 0x0008,        /* Device Status */
55         Eec = 0x0010,   /* EEPROM/Flash Control/Data */
56         Eerd = 0x0014,  /* EEPROM Read */
57         Ctrlext = 0x0018,       /* Extended Device Control */
58         Fla = 0x001c,   /* Flash Access */
59         Mdic = 0x0020,  /* MDI Control */
60         Fcal = 0x0028,  /* Flow Control Address Low */
61         Fcah = 0x002c,  /* Flow Control Address High */
62         Fct = 0x0030,   /* Flow Control Type */
63         Kumctrlsta = 0x0034,    /* Kumeran Control and Status Register */
64         Connsw = 0x0034,        /* copper / fiber switch control; 82575/82576 */
65         Vet = 0x0038,   /* VLAN EtherType */
66         Fcttv = 0x0170, /* Flow Control Transmit Timer Value */
67         Txcw = 0x0178,  /* Transmit Configuration Word */
68         Rxcw = 0x0180,  /* Receive Configuration Word */
69         Ledctl = 0x0e00,        /* LED control */
70         Pba = 0x1000,   /* Packet Buffer Allocation */
71         Pbs = 0x1008,   /* Packet Buffer Size */
72
73         /* Interrupt */
74
75         Icr = 0x00c0,   /* Interrupt Cause Read */
76         Itr = 0x00c4,   /* Interrupt Throttling Rate */
77         Ics = 0x00c8,   /* Interrupt Cause Set */
78         Ims = 0x00d0,   /* Interrupt Mask Set/Read */
79         Imc = 0x00d8,   /* Interrupt mask Clear */
80         Iam = 0x00e0,   /* Interrupt acknowledge Auto Mask */
81         Ivar = 0x00e4,  /* Ivar: interrupt allocation */
82         Eitr = 0x1680,  /* Extended itr; 82575/6 80 only */
83         P3gio = 0x5b00, /*  */
84         Pbaclr = 0x5b68,        /* clear msi-x pba */
85
86         /* Receive */
87
88         Rctl = 0x0100,  /* Control */
89         Ert = 0x2008,   /* Early Receive Threshold (573[EVL], 82578 only) */
90         Fcrtl = 0x2160, /* Flow Control RX Threshold Low */
91         Fcrth = 0x2168, /* Flow Control Rx Threshold High */
92         Psrctl = 0x2170,        /* Packet Split Receive Control */
93         Drxmxod = 0x2540,       /* dma max outstanding bytes (82575) */
94         Rdbal = 0x2800, /* Rdesc Base Address Low Queue 0 */
95         Rdbah = 0x2804, /* Rdesc Base Address High Queue 0 */
96         Rdlen = 0x2808, /* Descriptor Length Queue 0 */
97         Srrctl = 0x280c,        /* split and replication rx control (82575) */
98         Rdh = 0x2810,   /* Descriptor Head Queue 0 */
99         Rdt = 0x2818,   /* Descriptor Tail Queue 0 */
100         Rdtr = 0x2820,  /* Descriptor Timer Ring */
101         Rxdctl = 0x2828,        /* Descriptor Control */
102         Radv = 0x282C,  /* Interrupt Absolute Delay Timer */
103         Rsrpd = 0x2c00, /* Small Packet Detect */
104         Raid = 0x2c08,  /* ACK interrupt delay */
105         Cpuvec = 0x2c10,        /* CPU Vector */
106         Rxcsum = 0x5000,        /* Checksum Control */
107         Rmpl = 0x5004,  /* rx maximum packet length (82575) */
108         Rfctl = 0x5008, /* Filter Control */
109         Mta = 0x5200,   /* Multicast Table Array */
110         Ral = 0x5400,   /* Receive Address Low */
111         Rah = 0x5404,   /* Receive Address High */
112         Vfta = 0x5600,  /* VLAN Filter Table Array */
113         Mrqc = 0x5818,  /* Multiple Receive Queues Command */
114
115         /* Transmit */
116
117         Tctl = 0x0400,  /* Transmit Control */
118         Tipg = 0x0410,  /* Transmit IPG */
119         Tkabgtxd = 0x3004,      /* glci afe band gap transmit ref data, or something */
120         Tdbal = 0x3800, /* Tdesc Base Address Low */
121         Tdbah = 0x3804, /* Tdesc Base Address High */
122         Tdlen = 0x3808, /* Descriptor Length */
123         Tdh = 0x3810,   /* Descriptor Head */
124         Tdt = 0x3818,   /* Descriptor Tail */
125         Tidv = 0x3820,  /* Interrupt Delay Value */
126         Txdctl = 0x3828,        /* Descriptor Control */
127         Tadv = 0x382C,  /* Interrupt Absolute Delay Timer */
128         Tarc0 = 0x3840, /* Arbitration Counter Queue 0 */
129
130         /* Statistics */
131
132         Statistics = 0x4000,    /* Start of Statistics Area */
133         Gorcl = 0x88 / 4,       /* Good Octets Received Count */
134         Gotcl = 0x90 / 4,       /* Good Octets Transmitted Count */
135         Torl = 0xC0 / 4,        /* Total Octets Received */
136         Totl = 0xC8 / 4,        /* Total Octets Transmitted */
137         Nstatistics = 0x124 / 4,
138 };
139
140 enum {                                                  /* Ctrl */
141         Lrst = 1 << 3,                          /* link reset */
142         Slu = 1 << 6,   /* Set Link Up */
143         Devrst = 1 << 26,       /* Device Reset */
144         Rfce = 1 << 27, /* Receive Flow Control Enable */
145         Tfce = 1 << 28, /* Transmit Flow Control Enable */
146         Phyrst = 1 << 31,       /* Phy Reset */
147 };
148
149 enum {                                                  /* Status */
150         Lu = 1 << 1,                            /* Link Up */
151         Lanid = 3 << 2, /* mask for Lan ID. */
152         Txoff = 1 << 4, /* Transmission Paused */
153         Tbimode = 1 << 5,       /* TBI Mode Indication */
154         Phyra = 1 << 10,        /* PHY Reset Asserted */
155         GIOme = 1 << 19,        /* GIO Master Enable Status */
156 };
157
158 enum {
159         /* Eec */
160         Nvpres = 1 << 8,                        /* nvram present */
161         Autord = 1 << 9,        /* autoread complete */
162         Sec1val = 1 << 22,      /* sector 1 valid (!sec0) */
163 };
164
165 enum {                                                  /* Eerd */
166         EEstart = 1 << 0,                       /* Start Read */
167         EEdone = 1 << 1,        /* Read done */
168 };
169
170 enum {                                                  /* Ctrlext */
171         Eerst = 1 << 13,                        /* EEPROM Reset */
172         Linkmode = 3 << 22,     /* linkmode */
173         Internalphy = 0 << 22,  /* " internal phy (copper) */
174         Sgmii = 2 << 22,        /* " sgmii */
175         Serdes = 3 << 22,       /* " serdes */
176         Eiame = 1 << 24,        /* extended auto mask enable */
177         Iame = 1 << 27, /* auto mask enable */
178         Pbasup = 1 << 31,       /* msi-x pba support */
179 };
180
181 enum {
182         /* Connsw */
183         Enrgirq = 1 << 2,                       /* interrupt on power detect (enrgsrc) */
184 };
185
186 enum {                                                  /* EEPROM content offsets */
187         Ea = 0x00,                                      /* Ethernet Address */
188 };
189
190 enum {                                                  /* Mdic */
191         MDIdMASK = 0x0000FFFF,          /* Data */
192         MDIdSHIFT = 0,
193         MDIrMASK = 0x001F0000,  /* PHY Register Address */
194         MDIrSHIFT = 16,
195         MDIpMASK = 0x03E00000,  /* PHY Address */
196         MDIpSHIFT = 21,
197         MDIwop = 0x04000000,    /* Write Operation */
198         MDIrop = 0x08000000,    /* Read Operation */
199         MDIready = 0x10000000,  /* End of Transaction */
200         MDIie = 0x20000000,     /* Interrupt Enable */
201         MDIe = 0x40000000,      /* Error */
202 };
203
204 enum {                                                  /* phy interface */
205         Phyctl = 0,                                     /* phy ctl register */
206         Phyisr = 19,    /* 82563 phy interrupt status register */
207         Phylhr = 19,    /* 8257[12] link health register */
208         Physsr = 17,    /* phy secondary status register */
209         Phyprst = 193 << 8 | 17,        /* 8256[34] phy port reset */
210         Phyier = 18,    /* 82573 phy interrupt enable register */
211         Phypage = 22,   /* 8256[34] page register */
212         Phystat = 26,   /* 82580 phy status */
213         Phyapage = 29,
214         Phy79page = 31, /* 82579 phy page register (all pages) */
215
216         Rtlink = 1 << 10,       /* realtime link status */
217         Phyan = 1 << 11,        /* phy has autonegotiated */
218
219         /* Phyctl bits */
220         Ran = 1 << 9,   /* restart auto negotiation */
221         Ean = 1 << 12,  /* enable auto negotiation */
222
223         /* Phyprst bits */
224         Prst = 1 << 0,  /* reset the port */
225
226         /* 82573 Phyier bits */
227         Lscie = 1 << 10,        /* link status changed ie */
228         Ancie = 1 << 11,        /* auto negotiation complete ie */
229         Spdie = 1 << 14,        /* speed changed ie */
230         Panie = 1 << 15,        /* phy auto negotiation error ie */
231
232         /* Phylhr/Phyisr bits */
233         Anf = 1 << 6,   /* lhr: auto negotiation fault */
234         Ane = 1 << 15,  /* isr: auto negotiation error */
235
236         /* 82580 Phystat bits */
237         Ans = 1 << 14 | 1 << 15,        /* 82580 autoneg. status */
238         Link = 1 << 6,  /* 82580 Link */
239
240         /* Rxcw builtin serdes */
241         Anc = 1 << 31,
242         Rxsynch = 1 << 30,
243         Rxcfg = 1 << 29,
244         Rxcfgch = 1 << 28,
245         Rxcfgbad = 1 << 27,
246         Rxnc = 1 << 26,
247
248         /* Txcw */
249         Txane = 1 << 31,
250         Txcfg = 1 << 30,
251 };
252
253 enum {                                                  /* fiber (pcs) interface */
254         Pcsctl = 0x4208,                        /* pcs control */
255         Pcsstat = 0x420c,       /* pcs status */
256
257         /* Pcsctl bits */
258         Pan = 1 << 16,  /* autonegotiate */
259         Prestart = 1 << 17,     /* restart an (self clearing) */
260
261         /* Pcsstat bits */
262         Linkok = 1 << 0,        /* link is okay */
263         Andone = 1 << 16,       /* an phase is done see below for success */
264         Anbad = 1 << 19 | 1 << 20,      /* Anerror | Anremfault */
265 };
266
267 enum {                                                  /* Icr, Ics, Ims, Imc */
268         Txdw = 0x00000001,                      /* Transmit Descriptor Written Back */
269         Txqe = 0x00000002,      /* Transmit Queue Empty */
270         Lsc = 0x00000004,       /* Link Status Change */
271         Rxseq = 0x00000008,     /* Receive Sequence Error */
272         Rxdmt0 = 0x00000010,    /* Rdesc Minimum Threshold Reached */
273         Rxo = 0x00000040,       /* Receiver Overrun */
274         Rxt0 = 0x00000080,      /* Receiver Timer Interrupt; !82575/6/80 only */
275         Rxdw = 0x00000080,      /* Rdesc write back; 82575/6/80 only */
276         Mdac = 0x00000200,      /* MDIO Access Completed */
277         Rxcfgset = 0x00000400,  /* Receiving /C/ ordered sets */
278         Ack = 0x00020000,       /* Receive ACK frame */
279         Omed = 1 << 20, /* media change; pcs interface */
280 };
281
282 enum {                                                  /* Txcw */
283         TxcwFd = 0x00000020,            /* Full Duplex */
284         TxcwHd = 0x00000040,    /* Half Duplex */
285         TxcwPauseMASK = 0x00000180,     /* Pause */
286         TxcwPauseSHIFT = 7,
287         TxcwPs = 1 << TxcwPauseSHIFT,   /* Pause Supported */
288         TxcwAs = 2 << TxcwPauseSHIFT,   /* Asymmetric FC desired */
289         TxcwRfiMASK = 0x00003000,       /* Remote Fault Indication */
290         TxcwRfiSHIFT = 12,
291         TxcwNpr = 0x00008000,   /* Next Page Request */
292         TxcwConfig = 0x40000000,        /* Transmit COnfig Control */
293         TxcwAne = 0x80000000,   /* Auto-Negotiation Enable */
294 };
295
296 enum {                                                  /* Rctl */
297         Rrst = 0x00000001,                      /* Receiver Software Reset */
298         Ren = 0x00000002,       /* Receiver Enable */
299         Sbp = 0x00000004,       /* Store Bad Packets */
300         Upe = 0x00000008,       /* Unicast Promiscuous Enable */
301         Mpe = 0x00000010,       /* Multicast Promiscuous Enable */
302         Lpe = 0x00000020,       /* Long Packet Reception Enable */
303         RdtmsMASK = 0x00000300, /* Rdesc Minimum Threshold Size */
304         RdtmsHALF = 0x00000000, /* Threshold is 1/2 Rdlen */
305         RdtmsQUARTER = 0x00000100,      /* Threshold is 1/4 Rdlen */
306         RdtmsEIGHTH = 0x00000200,       /* Threshold is 1/8 Rdlen */
307         MoMASK = 0x00003000,    /* Multicast Offset */
308         Bam = 0x00008000,       /* Broadcast Accept Mode */
309         BsizeMASK = 0x00030000, /* Receive Buffer Size */
310         Bsize16384 = 0x00010000,        /* Bsex = 1 */
311         Bsize8192 = 0x00020000, /* Bsex = 1 */
312         Bsize2048 = 0x00000000,
313         Bsize1024 = 0x00010000,
314         Bsize512 = 0x00020000,
315         Bsize256 = 0x00030000,
316         BsizeFlex = 0x08000000, /* Flexable Bsize in 1kb increments */
317         Vfe = 0x00040000,       /* VLAN Filter Enable */
318         Cfien = 0x00080000,     /* Canonical Form Indicator Enable */
319         Cfi = 0x00100000,       /* Canonical Form Indicator value */
320         Dpf = 0x00400000,       /* Discard Pause Frames */
321         Pmcf = 0x00800000,      /* Pass MAC Control Frames */
322         Bsex = 0x02000000,      /* Buffer Size Extension */
323         Secrc = 0x04000000,     /* Strip CRC from incoming packet */
324 };
325
326 enum {                                                  /* Srrctl */
327         Dropen = 1 << 31,
328 };
329
330 enum {                                                  /* Tctl */
331         Trst = 0x00000001,                      /* Transmitter Software Reset */
332         Ten = 0x00000002,       /* Transmit Enable */
333         Psp = 0x00000008,       /* Pad Short Packets */
334         Mulr = 0x10000000,      /* Allow multiple concurrent requests */
335         CtMASK = 0x00000FF0,    /* Collision Threshold */
336         CtSHIFT = 4,
337         ColdMASK = 0x003FF000,  /* Collision Distance */
338         ColdSHIFT = 12,
339         Swxoff = 0x00400000,    /* Sofware XOFF Transmission */
340         Pbe = 0x00800000,       /* Packet Burst Enable */
341         Rtlc = 0x01000000,      /* Re-transmit on Late Collision */
342         Nrtu = 0x02000000,      /* No Re-transmit on Underrrun */
343 };
344
345 enum {                                                  /* [RT]xdctl */
346         PthreshMASK = 0x0000003F,       /* Prefetch Threshold */
347         PthreshSHIFT = 0,
348         HthreshMASK = 0x00003F00,       /* Host Threshold */
349         HthreshSHIFT = 8,
350         WthreshMASK = 0x003F0000,       /* Writeback Threshold */
351         WthreshSHIFT = 16,
352         Gran = 0x01000000,      /* Granularity; not 82575 */
353         Enable = 0x02000000,
354 };
355
356 enum {                                                  /* Rxcsum */
357         Ipofl = 0x0100,                         /* IP Checksum Off-load Enable */
358         Tuofl = 0x0200, /* TCP/UDP Checksum Off-load Enable */
359 };
360
361 typedef struct Rd {                             /* Receive Descriptor */
362         uint32_t addr[2];
363         uint16_t length;
364         uint16_t checksum;
365         uint8_t status;
366         uint8_t errors;
367         uint16_t special;
368 } Rd;
369
370 enum {                                                  /* Rd status */
371         Rdd = 0x01,                                     /* Descriptor Done */
372         Reop = 0x02,    /* End of Packet */
373         Ixsm = 0x04,    /* Ignore Checksum Indication */
374         Vp = 0x08,      /* Packet is 802.1Q (matched VET) */
375         Tcpcs = 0x20,   /* TCP Checksum Calculated on Packet */
376         Ipcs = 0x40,    /* IP Checksum Calculated on Packet */
377         Pif = 0x80,     /* Passed in-exact filter */
378 };
379
380 enum {                                                  /* Rd errors */
381         Ce = 0x01,                                      /* CRC Error or Alignment Error */
382         Se = 0x02,      /* Symbol Error */
383         Seq = 0x04,     /* Sequence Error */
384         Cxe = 0x10,     /* Carrier Extension Error */
385         Tcpe = 0x20,    /* TCP/UDP Checksum Error */
386         Ipe = 0x40,     /* IP Checksum Error */
387         Rxe = 0x80,     /* RX Data Error */
388 };
389
390 typedef struct {                                /* Transmit Descriptor */
391         uint32_t addr[2];                       /* Data */
392         uint32_t control;
393         uint32_t status;
394 } Td;
395
396 enum {                                                  /* Tdesc control */
397         LenMASK = 0x000FFFFF,           /* Data/Packet Length Field */
398         LenSHIFT = 0,
399         DtypeCD = 0x00000000,   /* Data Type 'Context Descriptor' */
400         DtypeDD = 0x00100000,   /* Data Type 'Data Descriptor' */
401         PtypeTCP = 0x01000000,  /* TCP/UDP Packet Type (CD) */
402         Teop = 0x01000000,      /* End of Packet (DD) */
403         PtypeIP = 0x02000000,   /* IP Packet Type (CD) */
404         Ifcs = 0x02000000,      /* Insert FCS (DD) */
405         Tse = 0x04000000,       /* TCP Segmentation Enable */
406         Rs = 0x08000000,        /* Report Status */
407         Rps = 0x10000000,       /* Report Status Sent */
408         Dext = 0x20000000,      /* Descriptor Extension */
409         Vle = 0x40000000,       /* VLAN Packet Enable */
410         Ide = 0x80000000,       /* Interrupt Delay Enable */
411 };
412
413 enum {                                                  /* Tdesc status */
414         Tdd = 0x0001,                           /* Descriptor Done */
415         Ec = 0x0002,    /* Excess Collisions */
416         Lc = 0x0004,    /* Late Collision */
417         Tu = 0x0008,    /* Transmit Underrun */
418         CssMASK = 0xFF00,       /* Checksum Start Field */
419         CssSHIFT = 8,
420 };
421
422 typedef struct {
423         uint16_t *reg;
424         uint32_t *reg32;
425         unsigned int base;
426         unsigned int lim;
427 } Flash;
428
429 enum {
430         /* 16 and 32-bit flash registers for ich flash parts */
431         Bfpr = 0x00 / 4,                        /* flash base 0:12; lim 16:28 */
432         Fsts = 0x04 / 2,        /* flash status; Hsfsts */
433         Fctl = 0x06 / 2,        /* flash control; Hsfctl */
434         Faddr = 0x08 / 4,       /* flash address to r/w */
435         Fdata = 0x10 / 4,       /* data @ address */
436
437         /* status register */
438         Fdone = 1 << 0, /* flash cycle done */
439         Fcerr = 1 << 1, /* cycle error; write 1 to clear */
440         Ael = 1 << 2,   /* direct access error log; 1 to clear */
441         Scip = 1 << 5,  /* spi cycle in progress */
442         Fvalid = 1 << 14,       /* flash descriptor valid */
443
444         /* control register */
445         Fgo = 1 << 0,   /* start cycle */
446         Flcycle = 1 << 1,       /* two bits: r=0; w=2 */
447         Fdbc = 1 << 8,  /* bytes to read; 5 bits */
448 };
449
450 enum {
451         Nrd = 256,                                      /* power of two */
452         Ntd = 256,      /* power of two */
453         Nrb = 3 * 512,  /* private receive buffers per Ctlr */
454         Rbalign = 16,   /* rx buffer alignment */
455         Npool = 10,
456 };
457
458 enum {
459         i82563,
460         i82566,
461         i82567,
462         i82567m,
463         i82571,
464         i82572,
465         i82573,
466         i82574,
467         i82575,
468         i82576,
469         i82577,
470         i82577m,
471         i82578,
472         i82578m,
473         i82579,
474         i82580,
475         i82583,
476         i210,
477         i217,
478         i350,
479         Nctlrtype,
480 };
481
482 enum {
483         Fload = 1 << 0,
484         Fert = 1 << 1,
485         F75 = 1 << 2,
486         Fpba = 1 << 3,
487         Fflashea = 1 << 4,
488         F79phy = 1 << 5,
489         Fnofct = 1 << 6,
490 };
491
492 typedef struct Ctlrtype Ctlrtype;
493 struct Ctlrtype {
494         int type;
495         int mtu;
496         int phyno;
497         char *name;
498         int flag;
499 };
500
501 static Ctlrtype cttab[Nctlrtype] = {
502         {i82563, 9014, 1, "i82563", Fpba},
503         {i82566, 1514, 1, "i82566", Fload},
504         {i82567, 9234, 1, "i82567", Fload},
505         {i82567m, 1514, 1, "i82567m", 0},
506         {i82571, 9234, 1, "i82571", Fpba},
507         {i82572, 9234, 1, "i82572", Fpba},
508         {i82573, 8192, 1, "i82573", Fert},      /* terrible perf above 8k */
509         {i82574, 9018, 1, "i82574", 0},
510         {i82575, 9728, 1, "i82575", F75 | Fflashea},
511         {i82576, 9728, 1, "i82576", F75},
512         {i82577, 4096, 2, "i82577", Fload | Fert},
513         {i82577m, 1514, 2, "i82577", Fload | Fert},
514         {i82578, 4096, 2, "i82578", Fload | Fert},
515         {i82578m, 1514, 2, "i82578", Fload | Fert},
516         {i82579, 9018, 2, "i82579", Fload | Fert | F79phy | Fnofct},
517         {i82580, 9728, 1, "i82580", F75 | F79phy},
518         {i82583, 1514, 1, "i82583", 0},
519         {i210, 9728, 1, "i210", F75 | Fnofct | Fert},
520         {i217, 9728, 1, "i217", F79phy | Fnofct | Fload | Fert},
521         {i350, 9728, 1, "i350", F75 | F79phy | Fnofct},
522 };
523
524 typedef void (*Freefn) (struct block *);
525
526 typedef struct ctlr Ctlr;
527 struct ctlr {
528         uintptr_t mmio_paddr;
529         struct pci_device *pcidev;
530         struct ctlr *next;
531         int active;
532         int type;
533         int pool;
534         uint16_t eeprom[0x40];
535
536         qlock_t alock;                          /* attach */
537         void *alloc;                            /* receive/transmit descriptors */
538         int nrd;
539         int ntd;
540         unsigned int rbsz;
541
542         uint32_t *nic;
543         spinlock_t imlock;
544         int im;                                         /* interrupt mask */
545
546         struct rendez lrendez;
547         int lim;
548
549         qlock_t slock;
550         uint32_t statistics[Nstatistics];
551         unsigned int lsleep;
552         unsigned int lintr;
553         unsigned int rsleep;
554         unsigned int rintr;
555         unsigned int txdw;
556         unsigned int tintr;
557         unsigned int ixsm;
558         unsigned int ipcs;
559         unsigned int tcpcs;
560         unsigned int speeds[4];
561         unsigned int phyerrata;
562
563         uint8_t ra[Eaddrlen];           /* receive address */
564         uint32_t mta[128];                      /* multicast table array */
565
566         struct rendez rrendez;
567         int rim;
568         int rdfree;
569         Rd *rdba;                                       /* receive descriptor base address */
570         struct block **rb;                      /* receive buffers */
571         unsigned int rdh;                       /* receive descriptor head */
572         unsigned int rdt;                       /* receive descriptor tail */
573         int rdtr;                                       /* receive delay timer ring value */
574         int radv;                                       /* receive interrupt absolute delay timer */
575
576         struct rendez trendez;
577         qlock_t tlock;
578         int tbusy;
579         Td *tdba;                                       /* transmit descriptor base address */
580         struct block **tb;                      /* transmit buffers */
581         int tdh;                                        /* transmit descriptor head */
582         int tdt;                                        /* transmit descriptor tail */
583
584         int fcrtl;
585         int fcrth;
586
587         uint32_t pba;                           /* packet buffer allocation */
588 };
589
590 typedef struct Rbpool Rbpool;
591 struct Rbpool {
592         union {
593                 struct {
594                         spinlock_t lock;
595                         struct block *b;
596                         unsigned int nstarve;
597                         unsigned int nwakey;
598                         unsigned int starve;
599                         struct rendez r;
600                 };
601                 uint8_t pad[64];                /* cacheline */
602         };
603
604         struct block *x;
605         unsigned int nfast;
606         unsigned int nslow;
607 };
608
609 static inline uint32_t csr32r(struct ctlr *c, uintptr_t reg)
610 {
611         return read_mmreg32((uintptr_t)(c->nic + (reg / 4)));
612 }
613
614 static inline void csr32w(struct ctlr *c, uintptr_t reg, uint32_t val)
615 {
616         write_mmreg32((uintptr_t)(c->nic + (reg / 4)), val);
617 }
618
619 static struct ctlr *i82563ctlr;
620 static Rbpool rbtab[Npool];
621
622 static char *statistics[Nstatistics] = {
623         "CRC Error",
624         "Alignment Error",
625         "Symbol Error",
626         "RX Error",
627         "Missed Packets",
628         "Single Collision",
629         "Excessive Collisions",
630         "Multiple Collision",
631         "Late Collisions",
632         NULL,
633         "Collision",
634         "Transmit Underrun",
635         "Defer",
636         "Transmit - No CRS",
637         "Sequence Error",
638         "Carrier Extension Error",
639         "Receive Error Length",
640         NULL,
641         "XON Received",
642         "XON Transmitted",
643         "XOFF Received",
644         "XOFF Transmitted",
645         "FC Received Unsupported",
646         "Packets Received (64 Bytes)",
647         "Packets Received (65-127 Bytes)",
648         "Packets Received (128-255 Bytes)",
649         "Packets Received (256-511 Bytes)",
650         "Packets Received (512-1023 Bytes)",
651         "Packets Received (1024-mtu Bytes)",
652         "Good Packets Received",
653         "Broadcast Packets Received",
654         "Multicast Packets Received",
655         "Good Packets Transmitted",
656         NULL,
657         "Good Octets Received",
658         NULL,
659         "Good Octets Transmitted",
660         NULL,
661         NULL,
662         NULL,
663         "Receive No Buffers",
664         "Receive Undersize",
665         "Receive Fragment",
666         "Receive Oversize",
667         "Receive Jabber",
668         "Management Packets Rx",
669         "Management Packets Drop",
670         "Management Packets Tx",
671         "Total Octets Received",
672         NULL,
673         "Total Octets Transmitted",
674         NULL,
675         "Total Packets Received",
676         "Total Packets Transmitted",
677         "Packets Transmitted (64 Bytes)",
678         "Packets Transmitted (65-127 Bytes)",
679         "Packets Transmitted (128-255 Bytes)",
680         "Packets Transmitted (256-511 Bytes)",
681         "Packets Transmitted (512-1023 Bytes)",
682         "Packets Transmitted (1024-mtu Bytes)",
683         "Multicast Packets Transmitted",
684         "Broadcast Packets Transmitted",
685         "TCP Segmentation Context Transmitted",
686         "TCP Segmentation Context Fail",
687         "Interrupt Assertion",
688         "Interrupt Rx Pkt Timer",
689         "Interrupt Rx Abs Timer",
690         "Interrupt Tx Pkt Timer",
691         "Interrupt Tx Abs Timer",
692         "Interrupt Tx Queue Empty",
693         "Interrupt Tx Desc Low",
694         "Interrupt Rx Min",
695         "Interrupt Rx Overrun",
696 };
697
698 static char *cname(struct ctlr *c)
699 {
700         return cttab[c->type].name;
701 }
702
703 static long i82563ifstat(struct ether* edev, void* a, long n, uint32_t offset)
704 {
705         char *s, *p, *e, *stat;
706         int i, r;
707         uint64_t tuvl, ruvl;
708         struct ctlr *ctlr;
709         Rbpool *b;
710
711         ctlr = edev->ctlr;
712         qlock(&ctlr->slock);
713         p = s = kzmalloc(READSTR, 0);
714         e = p + READSTR;
715
716         for (i = 0; i < Nstatistics; i++) {
717                 r = csr32r(ctlr, Statistics + i * 4);
718                 if ((stat = statistics[i]) == NULL)
719                         continue;
720                 switch (i) {
721                         case Gorcl:
722                         case Gotcl:
723                         case Torl:
724                         case Totl:
725                                 ruvl = r;
726                                 ruvl += (uint64_t) csr32r(ctlr, Statistics + (i + 1) * 4) << 32;
727                                 tuvl = ruvl;
728                                 tuvl += ctlr->statistics[i];
729                                 tuvl += (uint64_t) ctlr->statistics[i + 1] << 32;
730                                 if (tuvl == 0)
731                                         continue;
732                                 ctlr->statistics[i] = tuvl;
733                                 ctlr->statistics[i + 1] = tuvl >> 32;
734                                 p = seprintf(p, e, "%s: %llud %llud\n", stat, tuvl, ruvl);
735                                 i++;
736                                 break;
737
738                         default:
739                                 ctlr->statistics[i] += r;
740                                 if (ctlr->statistics[i] == 0)
741                                         continue;
742                                 p = seprintf(p, e, "%s: %ud %ud\n", stat,
743                                                          ctlr->statistics[i], r);
744                                 break;
745                 }
746         }
747
748         p = seprintf(p, e, "lintr: %ud %ud\n", ctlr->lintr, ctlr->lsleep);
749         p = seprintf(p, e, "rintr: %ud %ud\n", ctlr->rintr, ctlr->rsleep);
750         p = seprintf(p, e, "tintr: %ud %ud\n", ctlr->tintr, ctlr->txdw);
751         p = seprintf(p, e, "ixcs: %ud %ud %ud\n", ctlr->ixsm, ctlr->ipcs,
752                                  ctlr->tcpcs);
753         p = seprintf(p, e, "rdtr: %ud\n", ctlr->rdtr);
754         p = seprintf(p, e, "radv: %ud\n", ctlr->radv);
755         p = seprintf(p, e, "ctrl: %.8ux\n", csr32r(ctlr, Ctrl));
756         p = seprintf(p, e, "ctrlext: %.8ux\n", csr32r(ctlr, Ctrlext));
757         p = seprintf(p, e, "status: %.8ux\n", csr32r(ctlr, Status));
758         p = seprintf(p, e, "txcw: %.8ux\n", csr32r(ctlr, Txcw));
759         p = seprintf(p, e, "txdctl: %.8ux\n", csr32r(ctlr, Txdctl));
760         p = seprintf(p, e, "pba: %.8ux\n", ctlr->pba);
761
762         b = rbtab + ctlr->pool;
763         p = seprintf(p, e,
764                                  "pool: fast %ud slow %ud nstarve %ud nwakey %ud starve %ud\n",
765                                  b->nfast, b->nslow, b->nstarve, b->nwakey, b->starve);
766         p = seprintf(p, e, "speeds: 10:%ud 100:%ud 1000:%ud ?:%ud\n",
767                                  ctlr->speeds[0], ctlr->speeds[1], ctlr->speeds[2],
768                                  ctlr->speeds[3]);
769         p = seprintf(p, e, "type: %s\n", cname(ctlr));
770
771         n = readstr(offset, a, n, s);
772         kfree(s);
773         qunlock(&ctlr->slock);
774
775         return n;
776 }
777
778 static void i82563promiscuous(void *arg, int on)
779 {
780         int rctl;
781         struct ctlr *ctlr;
782         struct ether *edev;
783
784         edev = arg;
785         ctlr = edev->ctlr;
786
787         rctl = csr32r(ctlr, Rctl);
788         rctl &= ~MoMASK;
789         if (on)
790                 rctl |= Upe | Mpe;
791         else
792                 rctl &= ~(Upe | Mpe);
793         csr32w(ctlr, Rctl, rctl);
794 }
795
796 static void i82563multicast(void *arg, uint8_t * addr, int on)
797 {
798         int bit, x;
799         struct ctlr *ctlr;
800         struct ether *edev;
801
802         edev = arg;
803         ctlr = edev->ctlr;
804
805         x = addr[5] >> 1;
806         if (ctlr->type == i82566)
807                 x &= 31;
808         if (ctlr->type == i210 || ctlr->type == i217)
809                 x &= 15;
810         bit = ((addr[5] & 1) << 4) | (addr[4] >> 4);
811         /*
812          * multiple ether addresses can hash to the same filter bit,
813          * so it's never safe to clear a filter bit.
814          * if we want to clear filter bits, we need to keep track of
815          * all the multicast addresses in use, clear all the filter bits,
816          * then set the ones corresponding to in-use addresses.
817          */
818         if (on)
819                 ctlr->mta[x] |= 1 << bit;
820 //  else
821 //      ctlr->mta[x] &= ~(1<<bit);
822
823         csr32w(ctlr, Mta + x * 4, ctlr->mta[x]);
824 }
825
826 static int icansleep(void *v)
827 {
828         Rbpool *p;
829         int r;
830
831         p = v;
832         spin_lock_irqsave(&p->lock);
833         r = p->starve == 0;
834         spin_unlock_irqsave(&p->lock);
835
836         return r;
837 }
838
839 static struct block *i82563rballoc(Rbpool * p)
840 {
841         struct block *b;
842
843         for (;;) {
844                 if ((b = p->x) != NULL) {
845                         p->nfast++;
846                         p->x = b->next;
847                         b->next = NULL;
848                         return b;
849                 }
850
851                 spin_lock_irqsave(&p->lock);
852                 b = p->b;
853                 p->b = NULL;
854                 if (b == NULL) {
855                         p->nstarve++;
856                         spin_unlock_irqsave(&p->lock);
857                         return NULL;
858                 }
859                 p->nslow++;
860                 spin_unlock_irqsave(&p->lock);
861                 p->x = b;
862         }
863 }
864
865 static void rbfree(struct block *b, int t)
866 {
867         Rbpool *p;
868
869         p = rbtab + t;
870         b->rp = b->wp = (uint8_t *) ROUNDUP((uintptr_t) b->base, Rbalign);
871         b->flag &= ~(Bipck | Budpck | Btcpck | Bpktck);
872
873         spin_lock_irqsave(&p->lock);
874         b->next = p->b;
875         p->b = b;
876         if (p->starve) {
877                 if (0)
878                         printk("wakey %d; %d %d\n", t, p->nstarve, p->nwakey);
879                 p->nwakey++;
880                 p->starve = 0;
881                 spin_unlock_irqsave(&p->lock);
882                 rendez_wakeup(&p->r);
883         } else
884                 spin_unlock_irqsave(&p->lock);
885 }
886
887 static void rbfree0(struct block *b)
888 {
889         rbfree(b, 0);
890 }
891
892 static void rbfree1(struct block *b)
893 {
894         rbfree(b, 1);
895 }
896
897 static void rbfree2(struct block *b)
898 {
899         rbfree(b, 2);
900 }
901
902 static void rbfree3(struct block *b)
903 {
904         rbfree(b, 3);
905 }
906
907 static void rbfree4(struct block *b)
908 {
909         rbfree(b, 4);
910 }
911
912 static void rbfree5(struct block *b)
913 {
914         rbfree(b, 5);
915 }
916
917 static void rbfree6(struct block *b)
918 {
919         rbfree(b, 6);
920 }
921
922 static void rbfree7(struct block *b)
923 {
924         rbfree(b, 7);
925 }
926
927 static void rbfree8(struct block *b)
928 {
929         rbfree(b, 8);
930 }
931
932 static void rbfree9(struct block *b)
933 {
934         rbfree(b, 9);
935 }
936
937 static Freefn freetab[Npool] = {
938         rbfree0,
939         rbfree1,
940         rbfree2,
941         rbfree3,
942         rbfree4,
943         rbfree5,
944         rbfree6,
945         rbfree7,
946         rbfree8,
947         rbfree9,
948 };
949
950 static int newpool(void)
951 {
952         static int seq;
953
954         if (seq == ARRAY_SIZE(freetab))
955                 return -1;
956         if (freetab[seq] == NULL) {
957                 printd("82563: bad freetab\n");
958                 return -1;
959         }
960         return seq++;
961 }
962
963 static void i82563im(struct ctlr *ctlr, int im)
964 {
965         spin_lock_irqsave(&ctlr->imlock);
966         ctlr->im |= im;
967         csr32w(ctlr, Ims, ctlr->im);
968         spin_unlock_irqsave(&ctlr->imlock);
969 }
970
971 static void i82563txinit(struct ctlr *ctlr)
972 {
973         int i;
974         uint32_t r;
975         struct block *b;
976
977         if (cttab[ctlr->type].flag & F75)
978                 csr32w(ctlr, Tctl, 0x0F << CtSHIFT | Psp);
979         else
980                 csr32w(ctlr, Tctl, 0x0F << CtSHIFT | Psp | 66 << ColdSHIFT | Mulr);
981         csr32w(ctlr, Tipg, 6 << 20 | 8 << 10 | 8);      /* yb sez: 0x702008 */
982         csr32w(ctlr, Tdbal, paddr_low32(ctlr->tdba));
983         csr32w(ctlr, Tdbah, paddr_high32(ctlr->tdba));
984         csr32w(ctlr, Tdlen, ctlr->ntd * sizeof(Td));
985         ctlr->tdh = PREV_RING(0, ctlr->ntd);
986         csr32w(ctlr, Tdh, 0);
987         ctlr->tdt = 0;
988         csr32w(ctlr, Tdt, 0);
989         for (i = 0; i < ctlr->ntd; i++) {
990                 if ((b = ctlr->tb[i]) != NULL) {
991                         ctlr->tb[i] = NULL;
992                         freeb(b);
993                 }
994                 memset(&ctlr->tdba[i], 0, sizeof(Td));
995         }
996         csr32w(ctlr, Tidv, 128);
997         csr32w(ctlr, Tadv, 64);
998         csr32w(ctlr, Tctl, csr32r(ctlr, Tctl) | Ten);
999         r = csr32r(ctlr, Txdctl) & ~WthreshMASK;
1000         r |= 4 << WthreshSHIFT | 4 << PthreshSHIFT;
1001         if (cttab[ctlr->type].flag & F75)
1002                 r |= Enable;
1003         csr32w(ctlr, Txdctl, r);
1004 }
1005
1006 static int i82563cleanup(struct ether *e)
1007 {
1008         struct block *b;
1009         struct ctlr *c;
1010         int tdh, m, n;
1011
1012         c = e->ctlr;
1013         tdh = c->tdh;
1014         m = c->ntd;
1015         while (c->tdba[n = NEXT_RING(tdh, m)].status & Tdd) {
1016                 tdh = n;
1017                 if ((b = c->tb[tdh]) != NULL) {
1018                         c->tb[tdh] = NULL;
1019                         freeb(b);
1020                 } else
1021                         printk("#l%d: %s tx underrun! %d\n", e->ctlrno, cname(c), n);
1022                 c->tdba[tdh].status = 0;
1023         }
1024
1025         return c->tdh = tdh;
1026 }
1027
1028 static int notrim(void *v)
1029 {
1030         struct ctlr *c;
1031
1032         c = v;
1033         return (c->im & Txdw) == 0;
1034 }
1035
1036 static void i82563tproc(void *v)
1037 {
1038         Td *td;
1039         struct block *bp;
1040         struct ether *edev;
1041         struct ctlr *ctlr;
1042         int tdh, tdt, m;
1043
1044         edev = v;
1045         ctlr = edev->ctlr;
1046         tdt = ctlr->tdt;
1047         m = ctlr->ntd;
1048
1049         i82563txinit(ctlr);
1050
1051         for (;;) {
1052                 tdh = i82563cleanup(edev);
1053
1054                 if (NEXT_RING(tdt, m) == tdh) {
1055                         ctlr->txdw++;
1056                         i82563im(ctlr, Txdw);
1057                         rendez_sleep(&ctlr->trendez, notrim, ctlr);
1058                         continue;
1059                 }
1060                 bp = qbread(edev->oq, 100000);
1061                 td = &ctlr->tdba[tdt];
1062                 td->addr[0] = paddr_low32(bp->rp);
1063                 td->addr[1] = paddr_high32(bp->rp);
1064                 td->control = Ide | Rs | Ifcs | Teop | BLEN(bp);
1065                 ctlr->tb[tdt] = bp;
1066                 tdt = NEXT_RING(tdt, m);
1067                 wmb_f();
1068                 csr32w(ctlr, Tdt, tdt);
1069         }
1070 }
1071
1072 static int i82563replenish(struct ctlr *ctlr, int maysleep)
1073 {
1074         unsigned int rdt, m;
1075         struct block *bp;
1076         Rbpool *p;
1077         Rd *rd;
1078         int retval = 0;
1079
1080         rdt = ctlr->rdt;
1081         m = ctlr->nrd;
1082         p = rbtab + ctlr->pool;
1083         for (; NEXT_RING(rdt, m) != ctlr->rdh; rdt = NEXT_RING(rdt, m)) {
1084                 rd = &ctlr->rdba[rdt];
1085                 if (ctlr->rb[rdt] != NULL) {
1086                         printk("%s: tx overrun\n", cname(ctlr));
1087                         break;
1088                 }
1089 redux:
1090                 bp = i82563rballoc(p);
1091                 if (bp == NULL) {
1092                         if (rdt - ctlr->rdh >= 16)
1093                                 break;
1094                         printd("%s: pool %d: no rx buffers\n", cname(ctlr), ctlr->pool);
1095                         if (maysleep == 0) {
1096                                 retval = -1;
1097                                 goto out;
1098                         }
1099                         spin_lock_irqsave(&p->lock);
1100                         p->starve = 1;
1101                         spin_unlock_irqsave(&p->lock);
1102                         rendez_sleep(&p->r, icansleep, p);
1103                         goto redux;
1104                 }
1105                 ctlr->rb[rdt] = bp;
1106                 rd->addr[0] = paddr_low32(bp->rp);
1107                 rd->addr[1] = paddr_high32(bp->rp);
1108                 rd->status = 0;
1109                 ctlr->rdfree++;
1110         }
1111 out:
1112         if (ctlr->rdt != rdt) {
1113                 ctlr->rdt = rdt;
1114                 wmb_f();
1115                 csr32w(ctlr, Rdt, rdt);
1116         }
1117         return retval;
1118 }
1119
1120 static void i82563rxinit(struct ctlr *ctlr)
1121 {
1122         int i;
1123         struct block *bp;
1124
1125         if (ctlr->rbsz <= 2048)
1126                 csr32w(ctlr, Rctl, Dpf | Bsize2048 | Bam | RdtmsHALF);
1127         else {
1128                 i = ctlr->rbsz / 1024;
1129                 if (ctlr->rbsz % 1024)
1130                         i++;
1131                 if (cttab[ctlr->type].flag & F75) {
1132                         csr32w(ctlr, Rctl, Lpe | Dpf | Bsize2048 | Bam | RdtmsHALF | Secrc);
1133                         if (ctlr->type != i82575)
1134                                 i |= (ctlr->nrd / 2 >> 4) << 20;        /* RdmsHalf */
1135                         csr32w(ctlr, Srrctl, i | Dropen);
1136                         csr32w(ctlr, Rmpl, ctlr->rbsz);
1137 //          csr32w(ctlr, Drxmxod, 0x7ff);
1138                 } else
1139                         csr32w(ctlr, Rctl,
1140                                    Lpe | Dpf | BsizeFlex * i | Bam | RdtmsHALF | Secrc);
1141         }
1142
1143         if (cttab[ctlr->type].flag & Fert)
1144                 csr32w(ctlr, Ert, 1024 / 8);
1145
1146         if (ctlr->type == i82566)
1147                 csr32w(ctlr, Pbs, 16);
1148
1149         csr32w(ctlr, Rdbal, paddr_low32(ctlr->rdba));
1150         csr32w(ctlr, Rdbah, paddr_high32(ctlr->rdba));
1151         csr32w(ctlr, Rdlen, ctlr->nrd * sizeof(Rd));
1152         ctlr->rdh = 0;
1153         csr32w(ctlr, Rdh, 0);
1154         ctlr->rdt = 0;
1155         csr32w(ctlr, Rdt, 0);
1156         ctlr->rdtr = 0; //25;
1157         ctlr->radv = 0; //500;
1158         csr32w(ctlr, Rdtr, ctlr->rdtr);
1159         csr32w(ctlr, Radv, ctlr->radv);
1160
1161         for (i = 0; i < ctlr->nrd; i++)
1162                 if ((bp = ctlr->rb[i]) != NULL) {
1163                         ctlr->rb[i] = NULL;
1164                         freeb(bp);
1165                 }
1166         if (cttab[ctlr->type].flag & F75)
1167                 csr32w(ctlr, Rxdctl,
1168                            1 << WthreshSHIFT | 8 << PthreshSHIFT | 1 << HthreshSHIFT |
1169                            Enable);
1170         else
1171                 csr32w(ctlr, Rxdctl, 2 << WthreshSHIFT | 2 << PthreshSHIFT);
1172
1173         /*
1174          * Enable checksum offload.
1175          */
1176         csr32w(ctlr, Rxcsum, Tuofl | Ipofl | ETHERHDRSIZE);
1177 }
1178
1179 static int i82563rim(void *v)
1180 {
1181         return ((struct ctlr *)v)->rim != 0;
1182 }
1183
1184 static void i82563rproc(void *arg)
1185 {
1186         unsigned int m, rdh, rim, im;
1187         struct block *bp;
1188         struct ctlr *ctlr;
1189         struct ether *edev;
1190         Rd *rd;
1191
1192         edev = arg;
1193         ctlr = edev->ctlr;
1194
1195         i82563rxinit(ctlr);
1196         csr32w(ctlr, Rctl, csr32r(ctlr, Rctl) | Ren);
1197         if (cttab[ctlr->type].flag & F75) {
1198                 csr32w(ctlr, Rxdctl, csr32r(ctlr, Rxdctl) | Enable);
1199                 im = Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack;
1200         } else
1201                 im = Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack;
1202         m = ctlr->nrd;
1203
1204         for (;;) {
1205                 i82563im(ctlr, im);
1206                 ctlr->rsleep++;
1207                 i82563replenish(ctlr, 1);
1208                 rendez_sleep(&ctlr->rrendez, i82563rim, ctlr);
1209
1210                 rdh = ctlr->rdh;
1211                 for (;;) {
1212                         rd = &ctlr->rdba[rdh];
1213                         rim = ctlr->rim;
1214                         ctlr->rim = 0;
1215                         if (!(rd->status & Rdd))
1216                                 break;
1217
1218                         /*
1219                          * Accept eop packets with no errors.
1220                          * With no errors and the Ixsm bit set,
1221                          * the descriptor status Tpcs and Ipcs bits give
1222                          * an indication of whether the checksums were
1223                          * calculated and valid.
1224                          */
1225                         bp = ctlr->rb[rdh];
1226                         if ((rd->status & Reop) && rd->errors == 0) {
1227                                 bp->wp += rd->length;
1228                                 bp->lim = bp->wp;       /* lie like a dog.  avoid packblock. */
1229                                 if (!(rd->status & Ixsm)) {
1230                                         ctlr->ixsm++;
1231                                         if (rd->status & Ipcs) {
1232                                                 /*
1233                                                  * IP checksum calculated
1234                                                  * (and valid as errors == 0).
1235                                                  */
1236                                                 ctlr->ipcs++;
1237                                                 bp->flag |= Bipck;
1238                                         }
1239                                         if (rd->status & Tcpcs) {
1240                                                 /*
1241                                                  * TCP/UDP checksum calculated
1242                                                  * (and valid as errors == 0).
1243                                                  */
1244                                                 ctlr->tcpcs++;
1245                                                 bp->flag |= Btcpck | Budpck;
1246                                         }
1247                                         bp->checksum = rd->checksum;
1248                                         bp->flag |= Bpktck;
1249                                 }
1250                                 etheriq(edev, bp, 1);
1251                         } else
1252                                 freeb(bp);
1253                         ctlr->rb[rdh] = NULL;
1254                         rd->status = 0;
1255                         ctlr->rdfree--;
1256                         ctlr->rdh = rdh = NEXT_RING(rdh, m);
1257                         if (ctlr->nrd - ctlr->rdfree >= 32 || (rim & Rxdmt0))
1258                                 if (i82563replenish(ctlr, 0) == -1)
1259                                         break;
1260                 }
1261         }
1262 }
1263
1264 static int i82563lim(void *v)
1265 {
1266         return ((struct ctlr *)v)->lim != 0;
1267 }
1268
1269 static int speedtab[] = {
1270         10, 100, 1000, 0
1271 };
1272
1273 static unsigned int phywrite0(struct ctlr *, int unused_int, int, uint16_t);
1274
1275 static unsigned int
1276 setpage(struct ctlr *c, unsigned int phyno, unsigned int p, unsigned int r)
1277 {
1278         unsigned int pr;
1279
1280         switch (c->type) {
1281                 case i82563:
1282                         if (r >= 16 && r <= 28 && r != 22)
1283                                 pr = Phypage;
1284                         else if (r == 30 || r == 31)
1285                                 pr = Phyapage;
1286                         else
1287                                 return 0;
1288                         return phywrite0(c, phyno, pr, p);
1289                 case i82576:
1290                 case i82577:
1291                 case i82578:
1292                         return phywrite0(c, phyno, Phy79page, p);       /* unverified */
1293                 case i82579:
1294                         return phywrite0(c, phyno, Phy79page, p << 5);
1295                 default:
1296                         if (p == 0)
1297                                 return 0;
1298                         return ~0;
1299         }
1300 }
1301
1302 static unsigned int phyread0(struct ctlr *c, int phyno, int reg)
1303 {
1304         unsigned int phy, i;
1305
1306         csr32w(c, Mdic, MDIrop | phyno << MDIpSHIFT | reg << MDIrSHIFT);
1307         phy = 0;
1308         for (i = 0; i < 64; i++) {
1309                 phy = csr32r(c, Mdic);
1310                 if (phy & (MDIe | MDIready))
1311                         break;
1312                 udelay(1);
1313         }
1314         if ((phy & (MDIe | MDIready)) != MDIready) {
1315                 printd("%s: phy %d wedged %.8ux\n", cttab[c->type].name, phyno, phy);
1316                 return ~0;
1317         }
1318         return phy & 0xffff;
1319 }
1320
1321 static unsigned int
1322 phyread(struct ctlr *c, unsigned int phyno, unsigned int reg)
1323 {
1324         if (setpage(c, phyno, reg >> 8, reg & 0xff) == ~0) {
1325                 printd("%s: phyread: bad phy page %d\n", cname(c), reg >> 8);
1326                 return ~0;
1327         }
1328         return phyread0(c, phyno, reg & 0xff);
1329 }
1330
1331 static unsigned int phywrite0(struct ctlr *c, int phyno, int reg, uint16_t val)
1332 {
1333         unsigned int phy, i;
1334
1335         csr32w(c, Mdic, MDIwop | phyno << MDIpSHIFT | reg << MDIrSHIFT | val);
1336         phy = 0;
1337         for (i = 0; i < 64; i++) {
1338                 phy = csr32r(c, Mdic);
1339                 if (phy & (MDIe | MDIready))
1340                         break;
1341                 udelay(1);
1342         }
1343         if ((phy & (MDIe | MDIready)) != MDIready)
1344                 return ~0;
1345         return 0;
1346 }
1347
1348 static unsigned int
1349 phywrite(struct ctlr *c, unsigned int phyno, unsigned int reg, uint16_t v)
1350 {
1351         if (setpage(c, phyno, reg >> 8, reg & 0xff) == ~0)
1352                 panic("%s: bad phy reg %.4ux", cname(c), reg);
1353         return phywrite0(c, phyno, reg & 0xff, v);
1354 }
1355
1356 static void phyerrata(struct ether *e, struct ctlr *c, unsigned int phyno)
1357 {
1358         if (e->netif.mbps == 0) {
1359                 if (c->phyerrata == 0) {
1360                         c->phyerrata++;
1361                         phywrite(c, phyno, Phyprst, Prst);      /* try a port reset */
1362                         printd("ether%d: %s: phy port reset\n", e->ctlrno, cname(c));
1363                 }
1364         } else {
1365                 c->phyerrata = 0;
1366         }
1367 }
1368
1369 static void phyl79proc(void *v)
1370 {
1371         unsigned int a, i, r, phy, phyno;
1372         struct ctlr *c;
1373         struct ether *e;
1374
1375         e = v;
1376         c = e->ctlr;
1377
1378         phyno = cttab[c->type].phyno;
1379         for (;;) {
1380                 phy = phyread(c, phyno, Phystat);
1381                 if (phy == ~0) {
1382                         phy = 0;
1383                         i = 3;
1384                         goto next;
1385                 }
1386                 i = (phy >> 8) & 3;
1387                 a = phy & Ans;
1388                 if (a) {
1389                         r = phyread(c, phyno, Phyctl);
1390                         phywrite(c, phyno, Phyctl, r | Ran | Ean);
1391                 }
1392 next:
1393                 e->netif.link = i != 3 && (phy & Link) != 0;
1394                 if (e->netif.link == 0)
1395                         i = 3;
1396                 c->speeds[i]++;
1397                 e->netif.mbps = speedtab[i];
1398                 c->lim = 0;
1399                 i82563im(c, Lsc);
1400                 c->lsleep++;
1401                 rendez_sleep(&c->lrendez, i82563lim, c);
1402         }
1403 }
1404
1405 static void phylproc(void *v)
1406 {
1407         unsigned int a, i, phy, phyno;
1408         struct ctlr *c;
1409         struct ether *e;
1410
1411         e = v;
1412         c = e->ctlr;
1413         phyno = cttab[c->type].phyno;
1414
1415         if (c->type == i82573 && (phy = phyread(c, 1, Phyier)) != ~0)
1416                 phywrite(c, phyno, Phyier, phy | Lscie | Ancie | Spdie | Panie);
1417         for (;;) {
1418                 phy = phyread(c, phyno, Physsr);
1419                 if (phy == ~0) {
1420                         phy = 0;
1421                         i = 3;
1422                         goto next;
1423                 }
1424                 i = (phy >> 14) & 3;
1425                 switch (c->type) {
1426                         default:
1427                                 a = 0;
1428                                 break;
1429                         case i82563:
1430                         case i82578:
1431                         case i82578m:
1432                         case i82583:
1433                         case i210:
1434                                 a = phyread(c, phyno, Phyisr) & Ane;
1435                                 break;
1436                         case i82571:
1437                         case i82572:
1438                         case i82575:
1439                         case i82576:
1440                                 a = phyread(c, phyno, Phylhr) & Anf;
1441                                 i = (i - 1) & 3;
1442                                 break;
1443                 }
1444                 if (a)
1445                         phywrite(c, phyno, Phyctl, phyread(c, phyno, Phyctl) | Ran | Ean);
1446 next:
1447                 e->netif.link = (phy & Rtlink) != 0;
1448                 if (e->netif.link == 0)
1449                         i = 3;
1450                 c->speeds[i]++;
1451                 e->netif.mbps = speedtab[i];
1452                 if (c->type == i82563)
1453                         phyerrata(e, c, phyno);
1454                 c->lim = 0;
1455                 i82563im(c, Lsc);
1456                 c->lsleep++;
1457                 rendez_sleep(&c->lrendez, i82563lim, c);
1458         }
1459 }
1460
1461 static void pcslproc(void *v)
1462 {
1463         unsigned int i, phy;
1464         struct ctlr *c;
1465         struct ether *e;
1466
1467         e = v;
1468         c = e->ctlr;
1469
1470         if (c->type == i82575 || c->type == i82576)
1471                 csr32w(c, Connsw, Enrgirq);
1472         for (;;) {
1473                 phy = csr32r(c, Pcsstat);
1474                 e->netif.link = phy & Linkok;
1475                 i = 3;
1476                 if (e->netif.link)
1477                         i = (phy & 6) >> 1;
1478                 else if (phy & Anbad)
1479                         csr32w(c, Pcsctl, csr32r(c, Pcsctl) | Pan | Prestart);
1480                 c->speeds[i]++;
1481                 e->netif.mbps = speedtab[i];
1482                 c->lim = 0;
1483                 i82563im(c, Lsc | Omed);
1484                 c->lsleep++;
1485                 rendez_sleep(&c->lrendez, i82563lim, c);
1486         }
1487 }
1488
1489 static void serdeslproc(void *v)
1490 {
1491         unsigned int i, tx, rx;
1492         struct ctlr *c;
1493         struct ether *e;
1494
1495         e = v;
1496         c = e->ctlr;
1497
1498         for (;;) {
1499                 rx = csr32r(c, Rxcw);
1500                 tx = csr32r(c, Txcw);
1501                 e->netif.link = (rx & 1 << 31) != 0;
1502 //      e->netif.link = (csr32r(c, Status) & Lu) != 0;
1503                 i = 3;
1504                 if (e->netif.link)
1505                         i = 2;
1506                 c->speeds[i]++;
1507                 e->netif.mbps = speedtab[i];
1508                 c->lim = 0;
1509                 i82563im(c, Lsc);
1510                 c->lsleep++;
1511                 rendez_sleep(&c->lrendez, i82563lim, c);
1512         }
1513 }
1514
1515 static void i82563attach(struct ether *edev)
1516 {
1517         ERRSTACK(1);
1518         char *name;
1519         int i;
1520         struct block *bp;
1521         struct ctlr *ctlr;
1522
1523         ctlr = edev->ctlr;
1524         qlock(&ctlr->alock);
1525         if (ctlr->alloc != NULL) {
1526                 qunlock(&ctlr->alock);
1527                 return;
1528         }
1529
1530         ctlr->nrd = Nrd;
1531         ctlr->ntd = Ntd;
1532         ctlr->alloc =
1533                 kzmalloc(ctlr->nrd * sizeof(Rd) + ctlr->ntd * sizeof(Td) + 255, 0);
1534         if (ctlr->alloc == NULL) {
1535                 qunlock(&ctlr->alock);
1536                 error(Enomem);
1537         }
1538         ctlr->rdba = (Rd *) ROUNDUP((uintptr_t) ctlr->alloc, 256);
1539         ctlr->tdba = (Td *) (ctlr->rdba + ctlr->nrd);
1540
1541         ctlr->rb = kzmalloc(ctlr->nrd * sizeof(struct block *), 0);
1542         ctlr->tb = kzmalloc(ctlr->ntd * sizeof(struct block *), 0);
1543
1544         if (waserror()) {
1545                 while ((bp = i82563rballoc(rbtab + ctlr->pool))) {
1546                         bp->free = NULL;
1547                         freeb(bp);
1548                 }
1549                 kfree(ctlr->tb);
1550                 ctlr->tb = NULL;
1551                 kfree(ctlr->rb);
1552                 ctlr->rb = NULL;
1553                 kfree(ctlr->alloc);
1554                 ctlr->alloc = NULL;
1555                 qunlock(&ctlr->alock);
1556                 nexterror();
1557         }
1558
1559         for (i = 0; i < Nrb; i++) {
1560                 bp = allocb(ctlr->rbsz + Rbalign);
1561                 bp->free = freetab[ctlr->pool];
1562                 freeb(bp);
1563         }
1564
1565         /* the ktasks should free these names, if they ever exit */
1566         name = kmalloc(KNAMELEN, KMALLOC_WAIT);
1567         snprintf(name, KNAMELEN, "#l%dlproc", edev->ctlrno);
1568
1569         if (csr32r(ctlr, Status) & Tbimode)
1570                 ktask(name, serdeslproc, edev); /* mac based serdes */
1571         else if ((csr32r(ctlr, Ctrlext) & Linkmode) == Serdes)
1572                 ktask(name, pcslproc, edev);    /* phy based serdes */
1573         else if (cttab[ctlr->type].flag & F79phy)
1574                 ktask(name, phyl79proc, edev);
1575         else
1576                 ktask(name, phylproc, edev);
1577
1578         snprintf(name, KNAMELEN, "#l%drproc", edev->ctlrno);
1579         ktask(name, i82563rproc, edev);
1580
1581         snprintf(name, KNAMELEN, "#l%dtproc", edev->ctlrno);
1582         ktask(name, i82563tproc, edev);
1583
1584         qunlock(&ctlr->alock);
1585         poperror();
1586 }
1587
1588 static void i82563interrupt(struct hw_trapframe *hw_tf, void *arg)
1589 {
1590         struct ctlr *ctlr;
1591         struct ether *edev;
1592         uint32_t icr, im;
1593
1594         edev = arg;
1595         ctlr = edev->ctlr;
1596
1597         spin_lock_irqsave(&ctlr->imlock);
1598         csr32w(ctlr, Imc, ~0);
1599         im = ctlr->im;
1600
1601         while ((icr = csr32r(ctlr, Icr)) & ctlr->im) {
1602                 if (icr & (Lsc | Omed)) {
1603                         im &= ~(Lsc | Omed);
1604                         ctlr->lim = icr & (Lsc | Omed);
1605                         rendez_wakeup(&ctlr->lrendez);
1606                         ctlr->lintr++;
1607                 }
1608                 if (icr & (Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack)) {
1609                         ctlr->rim = icr & (Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack);
1610                         im &= ~(Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack);
1611                         rendez_wakeup(&ctlr->rrendez);
1612                         ctlr->rintr++;
1613                 }
1614                 if (icr & Txdw) {
1615                         im &= ~Txdw;
1616                         ctlr->tintr++;
1617                         rendez_wakeup(&ctlr->trendez);
1618                 }
1619         }
1620
1621         ctlr->im = im;
1622         csr32w(ctlr, Ims, im);
1623         spin_unlock_irqsave(&ctlr->imlock);
1624 }
1625
1626 static int i82563detach(struct ctlr *ctlr)
1627 {
1628         int r, timeo;
1629
1630         /* balance rx/tx packet buffer; survives reset */
1631         if (ctlr->rbsz > 8192 && cttab[ctlr->type].flag & Fpba) {
1632                 ctlr->pba = csr32r(ctlr, Pba);
1633                 r = ctlr->pba >> 16;
1634                 r += ctlr->pba & 0xffff;
1635                 r >>= 1;
1636                 csr32w(ctlr, Pba, r);
1637         } else if (ctlr->type == i82573 && ctlr->rbsz > 1514)
1638                 csr32w(ctlr, Pba, 14);
1639         ctlr->pba = csr32r(ctlr, Pba);
1640
1641         /*
1642          * Perform a device reset to get the chip back to the
1643          * power-on state, followed by an EEPROM reset to read
1644          * the defaults for some internal registers.
1645          */
1646         csr32w(ctlr, Imc, ~0);
1647         csr32w(ctlr, Rctl, 0);
1648         csr32w(ctlr, Tctl, csr32r(ctlr, Tctl) & ~Ten);
1649
1650         udelay(1000 * 1000);
1651
1652         r = csr32r(ctlr, Ctrl);
1653         if (ctlr->type == i82566 || ctlr->type == i82579)
1654                 r |= Phyrst;
1655         csr32w(ctlr, Ctrl, Devrst | r);
1656         udelay(1000 * 1000);
1657         for (timeo = 0;; timeo++) {
1658                 if ((csr32r(ctlr, Ctrl) & (Devrst | Phyrst)) == 0)
1659                         break;
1660                 if (timeo >= 1000)
1661                         return -1;
1662                 udelay(1000);
1663         }
1664
1665         r = csr32r(ctlr, Ctrl);
1666         csr32w(ctlr, Ctrl, Slu | r);
1667
1668         r = csr32r(ctlr, Ctrlext);
1669         csr32w(ctlr, Ctrlext, r | Eerst);
1670         udelay(1000);
1671         for (timeo = 0; timeo < 1000; timeo++) {
1672                 if (!(csr32r(ctlr, Ctrlext) & Eerst))
1673                         break;
1674                 udelay(1000);
1675         }
1676         if (csr32r(ctlr, Ctrlext) & Eerst)
1677                 return -1;
1678
1679         csr32w(ctlr, Imc, ~0);
1680         udelay(1000);
1681         for (timeo = 0; timeo < 1000; timeo++) {
1682                 if ((csr32r(ctlr, Icr) & ~Rxcfg) == 0)
1683                         break;
1684                 udelay(1000);
1685         }
1686         if (csr32r(ctlr, Icr) & ~Rxcfg)
1687                 return -1;
1688
1689         return 0;
1690 }
1691
1692 static void i82563shutdown(struct ether *edev)
1693 {
1694         i82563detach(edev->ctlr);
1695 }
1696
1697 static uint16_t eeread(struct ctlr *ctlr, int adr)
1698 {
1699         csr32w(ctlr, Eerd, EEstart | adr << 2);
1700         while ((csr32r(ctlr, Eerd) & EEdone) == 0)
1701                 cpu_relax();
1702         return csr32r(ctlr, Eerd) >> 16;
1703 }
1704
1705 static int eeload(struct ctlr *ctlr)
1706 {
1707         uint16_t sum;
1708         int data, adr;
1709
1710         sum = 0;
1711         for (adr = 0; adr < 0x40; adr++) {
1712                 data = eeread(ctlr, adr);
1713                 ctlr->eeprom[adr] = data;
1714                 sum += data;
1715         }
1716         return sum;
1717 }
1718
1719 static int fcycle(struct ctlr *unused, Flash * f)
1720 {
1721         uint16_t s, i;
1722
1723         s = f->reg[Fsts];
1724         if ((s & Fvalid) == 0)
1725                 return -1;
1726         f->reg[Fsts] |= Fcerr | Ael;
1727         for (i = 0; i < 10; i++) {
1728                 if ((s & Scip) == 0)
1729                         return 0;
1730                 udelay(1000);
1731                 s = f->reg[Fsts];
1732         }
1733         return -1;
1734 }
1735
1736 static int fread(struct ctlr *c, Flash * f, int ladr)
1737 {
1738         uint16_t s;
1739
1740         udelay(1000);
1741         if (fcycle(c, f) == -1)
1742                 return -1;
1743         f->reg[Fsts] |= Fdone;
1744         f->reg32[Faddr] = ladr;
1745
1746         /* setup flash control register */
1747         s = f->reg[Fctl] & ~0x3ff;
1748         f->reg[Fctl] = s | 1 << 8 | Fgo;        /* 2 byte read */
1749
1750         while ((f->reg[Fsts] & Fdone) == 0) ;
1751         if (f->reg[Fsts] & (Fcerr | Ael))
1752                 return -1;
1753         return f->reg32[Fdata] & 0xffff;
1754 }
1755
1756 static int fload(struct ctlr *c)
1757 {
1758         unsigned int data, r, adr;
1759         uint16_t sum;
1760         uintptr_t mmio_paddr;
1761         struct pci_device *pcidev = c->pcidev;
1762         Flash f;
1763         mmio_paddr = pcidev->bar[1].mmio_base32 ? pcidev->bar[1].mmio_base32 : 
1764                                                   pcidev->bar[1].mmio_base64;
1765         f.reg = (void*)vmap_pmem(mmio_paddr, pcidev->bar[1].mmio_sz);
1766         if (f.reg == NULL)
1767                 return -1;
1768         f.reg32 = (uint32_t *) f.reg;
1769         f.base = f.reg32[Bfpr] & 0x1fff;
1770         f.lim = f.reg32[Bfpr] >> 16 & 0x1fff;
1771         if (csr32r(c, Eec) & Sec1val)
1772                 f.base += (f.lim + 1) - (f.base >> 1);
1773         r = f.base << 12;
1774         sum = 0;
1775         for (adr = 0; adr < 0x40; adr++) {
1776                 data = fread(c, &f, r + adr * 2);
1777                 if (data == -1)
1778                         return -1;
1779                 c->eeprom[adr] = data;
1780                 sum += data;
1781         }
1782         vunmap_vmem((uintptr_t)f.reg, c->pcidev->bar[1].mmio_sz);
1783         return sum;
1784 }
1785
1786 static void defaultea(struct ctlr *ctlr, uint8_t * ra)
1787 {
1788         unsigned int i, r;
1789         uint64_t u;
1790         static uint8_t NULLea[Eaddrlen];
1791
1792         if (memcmp(ra, NULLea, Eaddrlen) != 0)
1793                 return;
1794         if (cttab[ctlr->type].flag & Fflashea) {
1795                 /* intel mb bug */
1796                 u = (uint64_t) csr32r(ctlr, Rah) << 32u | (unsigned int)csr32r(ctlr,
1797                                                                                                                                            Ral);
1798                 for (i = 0; i < Eaddrlen; i++)
1799                         ra[i] = u >> 8 * i;
1800         }
1801         if (memcmp(ra, NULLea, Eaddrlen) != 0)
1802                 return;
1803         for (i = 0; i < Eaddrlen / 2; i++) {
1804                 ra[2 * i] = ctlr->eeprom[Ea + i];
1805                 ra[2 * i + 1] = ctlr->eeprom[Ea + i] >> 8;
1806         }
1807         r = (csr32r(ctlr, Status) & Lanid) >> 2;
1808         ra[5] += r;     /* ea ctlr[n] = ea ctlr[0]+n */
1809 }
1810
1811 static int i82563reset(struct ctlr *ctlr)
1812 {
1813         uint8_t *ra;
1814         int i, r;
1815
1816         if (i82563detach(ctlr))
1817                 return -1;
1818         if (cttab[ctlr->type].flag & Fload)
1819                 r = fload(ctlr);
1820         else
1821                 r = eeload(ctlr);
1822         if (r != 0 && r != 0xbaba) {
1823                 printd("%s: bad eeprom checksum - %#.4ux\n", cname(ctlr), r);
1824                 return -1;
1825         }
1826
1827         ra = ctlr->ra;
1828         defaultea(ctlr, ra);
1829         csr32w(ctlr, Ral, ra[3] << 24 | ra[2] << 16 | ra[1] << 8 | ra[0]);
1830         csr32w(ctlr, Rah, 1 << 31 | ra[5] << 8 | ra[4]);
1831         for (i = 1; i < 16; i++) {
1832                 csr32w(ctlr, Ral + i * 8, 0);
1833                 csr32w(ctlr, Rah + i * 8, 0);
1834         }
1835         memset(ctlr->mta, 0, sizeof(ctlr->mta));
1836         for (i = 0; i < 128; i++)
1837                 csr32w(ctlr, Mta + i * 4, 0);
1838         csr32w(ctlr, Fcal, 0x00C28001);
1839         csr32w(ctlr, Fcah, 0x0100);
1840         if ((cttab[ctlr->type].flag & Fnofct) == 0)
1841                 csr32w(ctlr, Fct, 0x8808);
1842         csr32w(ctlr, Fcttv, 0x0100);
1843         csr32w(ctlr, Fcrtl, ctlr->fcrtl);
1844         csr32w(ctlr, Fcrth, ctlr->fcrth);
1845         if (cttab[ctlr->type].flag & F75)
1846                 csr32w(ctlr, Eitr, 128 << 2);   /* 128 ¼ microsecond intervals */
1847         return 0;
1848 }
1849
1850 enum {
1851         CMrdtr,
1852         CMradv,
1853         CMpause,
1854         CMan,
1855 };
1856
1857 static struct cmdtab i82563ctlmsg[] = {
1858         {CMrdtr, "rdtr", 2},
1859         {CMradv, "radv", 2},
1860         {CMpause, "pause", 1},
1861         {CMan, "an", 1},
1862 };
1863
1864 static long i82563ctl(struct ether *edev, void *buf, long n)
1865 {
1866         ERRSTACK(1);
1867         char *p;
1868         uint32_t v;
1869         struct ctlr *ctlr;
1870         struct cmdbuf *cb;
1871         struct cmdtab *ct;
1872
1873         if ((ctlr = edev->ctlr) == NULL)
1874                 error(Enonexist);
1875
1876         cb = parsecmd(buf, n);
1877         if (waserror()) {
1878                 kfree(cb);
1879                 nexterror();
1880         }
1881
1882         ct = lookupcmd(cb, i82563ctlmsg, ARRAY_SIZE(i82563ctlmsg));
1883         switch (ct->index) {
1884                 case CMrdtr:
1885                         v = strtoul(cb->f[1], &p, 0);
1886                         if (*p || v > 0xffff)
1887                                 error(Ebadarg);
1888                         ctlr->rdtr = v;
1889                         csr32w(ctlr, Rdtr, v);
1890                         break;
1891                 case CMradv:
1892                         v = strtoul(cb->f[1], &p, 0);
1893                         if (*p || v > 0xffff)
1894                                 error(Ebadarg);
1895                         ctlr->radv = v;
1896                         csr32w(ctlr, Radv, v);
1897                         break;
1898                 case CMpause:
1899                         csr32w(ctlr, Ctrl, csr32r(ctlr, Ctrl) ^ (Rfce | Tfce));
1900                         break;
1901                 case CMan:
1902                         csr32w(ctlr, Ctrl, csr32r(ctlr, Ctrl) | Lrst | Phyrst);
1903                         break;
1904         }
1905         kfree(cb);
1906         poperror();
1907
1908         return n;
1909 }
1910
1911 static int didtype(int d)
1912 {
1913         switch (d) {
1914                 case 0x1096:
1915                 case 0x10ba:    /* “gilgal” */
1916                 case 0x1098:    /* serdes; not seen */
1917                 case 0x10bb:    /* serdes */
1918                         return i82563;
1919                 case 0x1049:    /* mm */
1920                 case 0x104a:    /* dm */
1921                 case 0x104b:    /* dc */
1922                 case 0x104d:    /* v “ninevah” */
1923                 case 0x10bd:    /* dm-2 */
1924                 case 0x294c:    /* ich 9 */
1925                         return i82566;
1926                 case 0x10de:    /* lm ich10d */
1927                 case 0x10df:    /* lf ich10 */
1928                 case 0x10e5:    /* lm ich9 */
1929                 case 0x10f5:    /* lm ich9m; “boazman” */
1930                         return i82567;
1931                 case 0x10bf:    /* lf ich9m */
1932                 case 0x10cb:    /* v ich9m */
1933                 case 0x10cd:    /* lf ich10 */
1934                 case 0x10ce:    /* v ich10 */
1935                 case 0x10cc:    /* lm ich10 */
1936                         return i82567m;
1937                 case 0x105e:    /* eb */
1938                 case 0x105f:    /* eb */
1939                 case 0x1060:    /* eb */
1940                 case 0x10a4:    /* eb */
1941                 case 0x10a5:    /* eb  fiber */
1942                 case 0x10bc:    /* eb */
1943                 case 0x10d9:    /* eb serdes */
1944                 case 0x10da:    /* eb serdes “ophir” */
1945                         return i82571;
1946                 case 0x107d:    /* eb copper */
1947                 case 0x107e:    /* ei fiber */
1948                 case 0x107f:    /* ei */
1949                 case 0x10b9:    /* ei “rimon” */
1950                         return i82572;
1951                 case 0x108b:    /*  e “vidalia” */
1952                 case 0x108c:    /*  e (iamt) */
1953                 case 0x109a:    /*  l “tekoa” */
1954                         return i82573;
1955                 case 0x10d3:    /* l or it; “hartwell” */
1956                         return i82574;
1957                 case 0x10a7:
1958                 case 0x10a9:    /* fiber/serdes */
1959                         return i82575;
1960                 case 0x10c9:    /* copper */
1961                 case 0x10e6:    /* fiber */
1962                 case 0x10e7:    /* serdes; “kawela” */
1963                 case 0x150d:    /* backplane */
1964                         return i82576;
1965                 case 0x10ea:    /* lc “calpella”; aka pch lan */
1966                         return i82577;
1967                 case 0x10eb:    /* lm “calpella” */
1968                         return i82577m;
1969                 case 0x10ef:    /* dc “piketon” */
1970                         return i82578;
1971                 case 0x1502:    /* lm */
1972                 case 0x1503:    /* v “lewisville” */
1973                         return i82579;
1974                 case 0x10f0:    /* dm “king's creek” */
1975                         return i82578m;
1976                 case 0x150e:    /* “barton hills” */
1977                 case 0x150f:    /* fiber */
1978                 case 0x1510:    /* backplane */
1979                 case 0x1511:    /* sfp */
1980                 case 0x1516:
1981                         return i82580;
1982                 case 0x1506:    /* v */
1983                         return i82583;
1984                 case 0x1533:    /* i210-t1 */
1985                 case 0x1534:
1986                 case 0x1536:    /* fiber */
1987                 case 0x1537:    /* backplane */
1988                 case 0x1538:
1989                 case 0x1539:    /* i211 */
1990                         return i210;
1991                 case 0x153a:    /* i217-lm */
1992                 case 0x153b:    /* i217-v */
1993                 case 0x15a0:    /* i218-lm */
1994                 case 0x15a1:    /* i218-v */
1995                 case 0x15a2:    /* i218-lm */
1996                 case 0x15a3:    /* i218-v */
1997                         return i217;
1998                 case 0x151f:    /* “powerville” eeprom-less */
1999                 case 0x1521:    /* copper */
2000                 case 0x1522:    /* fiber */
2001                 case 0x1523:    /* serdes */
2002                 case 0x1524:    /* sgmii */
2003                         return i350;
2004         }
2005         return -1;
2006 }
2007
2008 static void hbafixup(struct pci_device *p)
2009 {
2010         unsigned int i;
2011
2012         i = pcidev_read32(p, PciSVID);
2013         if ((i & 0xffff) == 0x1b52 && p->dev_id == 1)
2014                 p->dev_id = i >> 16;
2015 }
2016
2017 static void i82563pci(void)
2018 {
2019         int type;
2020         struct ctlr *c, **cc;
2021         struct pci_device *p;
2022
2023         cc = &i82563ctlr;
2024         STAILQ_FOREACH(p, &pci_devices, all_dev) {
2025                 if (p->ven_id != 0x8086)
2026                         continue;
2027                 hbafixup(p);
2028                 if ((type = didtype(p->dev_id)) == -1)
2029                         continue;
2030                 c = kzmalloc(sizeof *c, KMALLOC_WAIT);
2031
2032                 qlock_init(&c->alock);
2033                 spinlock_init_irqsave(&c->imlock);
2034                 rendez_init(&c->lrendez);
2035                 qlock_init(&c->slock);
2036                 rendez_init(&c->rrendez);
2037                 rendez_init(&c->trendez);
2038                 qlock_init(&c->tlock);
2039
2040                 c->type = type;
2041                 c->pcidev = p;
2042                 c->rbsz = cttab[type].mtu;
2043                 /* plan9 called this c->port, and just used the top of the raw bar,
2044                  * regardless of the type. */
2045                 c->mmio_paddr = p->bar[0].mmio_base32 ? p->bar[0].mmio_base32 : 
2046                                                         p->bar[0].mmio_base64;
2047                 *cc = c;
2048                 cc = &c->next;
2049         }
2050 }
2051
2052 static int setup(struct ctlr *ctlr)
2053 {
2054         struct pci_device *p;
2055
2056         if ((ctlr->pool = newpool()) == -1) {
2057                 printd("%s: no pool\n", cname(ctlr));
2058                 return -1;
2059         }
2060         p = ctlr->pcidev;
2061         ctlr->nic = (void*)vmap_pmem(ctlr->mmio_paddr, p->bar[0].mmio_sz);
2062         if (ctlr->nic == NULL) {
2063                 printd("%s: can't map %p\n", cname(ctlr), ctlr->mmio_paddr);
2064                 return -1;
2065         }
2066         pci_set_bus_master(p);
2067         if (i82563reset(ctlr)) {
2068                 vunmap_vmem((uintptr_t)ctlr->nic, p->bar[0].mmio_sz);
2069                 return -1;
2070         }
2071         return 0;
2072 }
2073
2074 static void i82563_init(void)
2075 {
2076         for (struct Rbpool *rb = rbtab; rb < rbtab + Npool; rb++) {
2077                 spinlock_init_irqsave(&rb->lock);
2078                 rendez_init(&rb->r);
2079         }
2080         i82563pci();
2081 }
2082
2083 static int pnp(struct ether *edev, int type)
2084 {
2085         struct ctlr *ctlr;
2086
2087         run_once(i82563_init());
2088
2089         /*
2090          * Any adapter matches if no edev->port is supplied,
2091          * otherwise the ports must match.
2092          */
2093         for (ctlr = i82563ctlr;; ctlr = ctlr->next) {
2094                 if (ctlr == NULL)
2095                         return -1;
2096                 if (ctlr->active)
2097                         continue;
2098                 if (type != -1 && ctlr->type != type)
2099                         continue;
2100                 if (edev->port == 0 || edev->port == ctlr->mmio_paddr) {
2101                         ctlr->active = 1;
2102                         memmove(ctlr->ra, edev->ea, Eaddrlen);
2103                         if (setup(ctlr) == 0)
2104                                 break;
2105                 }
2106         }
2107
2108         edev->ctlr = ctlr;
2109         edev->port = ctlr->mmio_paddr;
2110         edev->irq = ctlr->pcidev->irqline;
2111         edev->tbdf = MKBUS(BusPCI, ctlr->pcidev->bus, ctlr->pcidev->dev,
2112                            ctlr->pcidev->func);
2113         edev->netif.mbps = 1000;
2114         edev->maxmtu = ctlr->rbsz;
2115         memmove(edev->ea, ctlr->ra, Eaddrlen);
2116
2117         /*
2118          * Linkage to the generic ethernet driver.
2119          */
2120         edev->attach = i82563attach;
2121         edev->ifstat = i82563ifstat;
2122         edev->ctl = i82563ctl;
2123
2124         edev->netif.arg = edev;
2125         edev->netif.promiscuous = i82563promiscuous;
2126         edev->shutdown = i82563shutdown;
2127         edev->netif.multicast = i82563multicast;
2128
2129         register_irq(edev->irq, i82563interrupt, edev, edev->tbdf);
2130         return 0;
2131 }
2132
2133 static int anypnp(struct ether *e)
2134 {
2135         return pnp(e, -1);
2136 }
2137
2138 linker_func_3(ether82563link)
2139 {
2140         addethercard("i82563", anypnp);
2141 }