82536: fixes ktask names
[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 *lname, *rname, *tname;
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         lname = kmalloc(KNAMELEN, KMALLOC_WAIT);
1567         rname = kmalloc(KNAMELEN, KMALLOC_WAIT);
1568         tname = kmalloc(KNAMELEN, KMALLOC_WAIT);
1569
1570         snprintf(lname, KNAMELEN, "#l%dlproc", edev->ctlrno);
1571
1572         if (csr32r(ctlr, Status) & Tbimode)
1573                 ktask(lname, serdeslproc, edev);        /* mac based serdes */
1574         else if ((csr32r(ctlr, Ctrlext) & Linkmode) == Serdes)
1575                 ktask(lname, pcslproc, edev);   /* phy based serdes */
1576         else if (cttab[ctlr->type].flag & F79phy)
1577                 ktask(lname, phyl79proc, edev);
1578         else
1579                 ktask(lname, phylproc, edev);
1580
1581         snprintf(rname, KNAMELEN, "#l%drproc", edev->ctlrno);
1582         ktask(rname, i82563rproc, edev);
1583
1584         snprintf(tname, KNAMELEN, "#l%dtproc", edev->ctlrno);
1585         ktask(tname, i82563tproc, edev);
1586
1587         qunlock(&ctlr->alock);
1588         poperror();
1589 }
1590
1591 static void i82563interrupt(struct hw_trapframe *hw_tf, void *arg)
1592 {
1593         struct ctlr *ctlr;
1594         struct ether *edev;
1595         uint32_t icr, im;
1596
1597         edev = arg;
1598         ctlr = edev->ctlr;
1599
1600         spin_lock_irqsave(&ctlr->imlock);
1601         csr32w(ctlr, Imc, ~0);
1602         im = ctlr->im;
1603
1604         while ((icr = csr32r(ctlr, Icr)) & ctlr->im) {
1605                 if (icr & (Lsc | Omed)) {
1606                         im &= ~(Lsc | Omed);
1607                         ctlr->lim = icr & (Lsc | Omed);
1608                         rendez_wakeup(&ctlr->lrendez);
1609                         ctlr->lintr++;
1610                 }
1611                 if (icr & (Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack)) {
1612                         ctlr->rim = icr & (Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack);
1613                         im &= ~(Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack);
1614                         rendez_wakeup(&ctlr->rrendez);
1615                         ctlr->rintr++;
1616                 }
1617                 if (icr & Txdw) {
1618                         im &= ~Txdw;
1619                         ctlr->tintr++;
1620                         rendez_wakeup(&ctlr->trendez);
1621                 }
1622         }
1623
1624         ctlr->im = im;
1625         csr32w(ctlr, Ims, im);
1626         spin_unlock_irqsave(&ctlr->imlock);
1627 }
1628
1629 static int i82563detach(struct ctlr *ctlr)
1630 {
1631         int r, timeo;
1632
1633         /* balance rx/tx packet buffer; survives reset */
1634         if (ctlr->rbsz > 8192 && cttab[ctlr->type].flag & Fpba) {
1635                 ctlr->pba = csr32r(ctlr, Pba);
1636                 r = ctlr->pba >> 16;
1637                 r += ctlr->pba & 0xffff;
1638                 r >>= 1;
1639                 csr32w(ctlr, Pba, r);
1640         } else if (ctlr->type == i82573 && ctlr->rbsz > 1514)
1641                 csr32w(ctlr, Pba, 14);
1642         ctlr->pba = csr32r(ctlr, Pba);
1643
1644         /*
1645          * Perform a device reset to get the chip back to the
1646          * power-on state, followed by an EEPROM reset to read
1647          * the defaults for some internal registers.
1648          */
1649         csr32w(ctlr, Imc, ~0);
1650         csr32w(ctlr, Rctl, 0);
1651         csr32w(ctlr, Tctl, csr32r(ctlr, Tctl) & ~Ten);
1652
1653         udelay(1000 * 1000);
1654
1655         r = csr32r(ctlr, Ctrl);
1656         if (ctlr->type == i82566 || ctlr->type == i82579)
1657                 r |= Phyrst;
1658         csr32w(ctlr, Ctrl, Devrst | r);
1659         udelay(1000 * 1000);
1660         for (timeo = 0;; timeo++) {
1661                 if ((csr32r(ctlr, Ctrl) & (Devrst | Phyrst)) == 0)
1662                         break;
1663                 if (timeo >= 1000)
1664                         return -1;
1665                 udelay(1000);
1666         }
1667
1668         r = csr32r(ctlr, Ctrl);
1669         csr32w(ctlr, Ctrl, Slu | r);
1670
1671         r = csr32r(ctlr, Ctrlext);
1672         csr32w(ctlr, Ctrlext, r | Eerst);
1673         udelay(1000);
1674         for (timeo = 0; timeo < 1000; timeo++) {
1675                 if (!(csr32r(ctlr, Ctrlext) & Eerst))
1676                         break;
1677                 udelay(1000);
1678         }
1679         if (csr32r(ctlr, Ctrlext) & Eerst)
1680                 return -1;
1681
1682         csr32w(ctlr, Imc, ~0);
1683         udelay(1000);
1684         for (timeo = 0; timeo < 1000; timeo++) {
1685                 if ((csr32r(ctlr, Icr) & ~Rxcfg) == 0)
1686                         break;
1687                 udelay(1000);
1688         }
1689         if (csr32r(ctlr, Icr) & ~Rxcfg)
1690                 return -1;
1691
1692         return 0;
1693 }
1694
1695 static void i82563shutdown(struct ether *edev)
1696 {
1697         i82563detach(edev->ctlr);
1698 }
1699
1700 static uint16_t eeread(struct ctlr *ctlr, int adr)
1701 {
1702         csr32w(ctlr, Eerd, EEstart | adr << 2);
1703         while ((csr32r(ctlr, Eerd) & EEdone) == 0)
1704                 cpu_relax();
1705         return csr32r(ctlr, Eerd) >> 16;
1706 }
1707
1708 static int eeload(struct ctlr *ctlr)
1709 {
1710         uint16_t sum;
1711         int data, adr;
1712
1713         sum = 0;
1714         for (adr = 0; adr < 0x40; adr++) {
1715                 data = eeread(ctlr, adr);
1716                 ctlr->eeprom[adr] = data;
1717                 sum += data;
1718         }
1719         return sum;
1720 }
1721
1722 static int fcycle(struct ctlr *unused, Flash * f)
1723 {
1724         uint16_t s, i;
1725
1726         s = f->reg[Fsts];
1727         if ((s & Fvalid) == 0)
1728                 return -1;
1729         f->reg[Fsts] |= Fcerr | Ael;
1730         for (i = 0; i < 10; i++) {
1731                 if ((s & Scip) == 0)
1732                         return 0;
1733                 udelay(1000);
1734                 s = f->reg[Fsts];
1735         }
1736         return -1;
1737 }
1738
1739 static int fread(struct ctlr *c, Flash * f, int ladr)
1740 {
1741         uint16_t s;
1742
1743         udelay(1000);
1744         if (fcycle(c, f) == -1)
1745                 return -1;
1746         f->reg[Fsts] |= Fdone;
1747         f->reg32[Faddr] = ladr;
1748
1749         /* setup flash control register */
1750         s = f->reg[Fctl] & ~0x3ff;
1751         f->reg[Fctl] = s | 1 << 8 | Fgo;        /* 2 byte read */
1752
1753         while ((f->reg[Fsts] & Fdone) == 0) ;
1754         if (f->reg[Fsts] & (Fcerr | Ael))
1755                 return -1;
1756         return f->reg32[Fdata] & 0xffff;
1757 }
1758
1759 static int fload(struct ctlr *c)
1760 {
1761         unsigned int data, r, adr;
1762         uint16_t sum;
1763         uintptr_t mmio_paddr;
1764         struct pci_device *pcidev = c->pcidev;
1765         Flash f;
1766         mmio_paddr = pcidev->bar[1].mmio_base32 ? pcidev->bar[1].mmio_base32 : 
1767                                                   pcidev->bar[1].mmio_base64;
1768         f.reg = (void*)vmap_pmem(mmio_paddr, pcidev->bar[1].mmio_sz);
1769         if (f.reg == NULL)
1770                 return -1;
1771         f.reg32 = (uint32_t *) f.reg;
1772         f.base = f.reg32[Bfpr] & 0x1fff;
1773         f.lim = f.reg32[Bfpr] >> 16 & 0x1fff;
1774         if (csr32r(c, Eec) & Sec1val)
1775                 f.base += (f.lim + 1) - (f.base >> 1);
1776         r = f.base << 12;
1777         sum = 0;
1778         for (adr = 0; adr < 0x40; adr++) {
1779                 data = fread(c, &f, r + adr * 2);
1780                 if (data == -1)
1781                         return -1;
1782                 c->eeprom[adr] = data;
1783                 sum += data;
1784         }
1785         vunmap_vmem((uintptr_t)f.reg, c->pcidev->bar[1].mmio_sz);
1786         return sum;
1787 }
1788
1789 static void defaultea(struct ctlr *ctlr, uint8_t * ra)
1790 {
1791         unsigned int i, r;
1792         uint64_t u;
1793         static uint8_t NULLea[Eaddrlen];
1794
1795         if (memcmp(ra, NULLea, Eaddrlen) != 0)
1796                 return;
1797         if (cttab[ctlr->type].flag & Fflashea) {
1798                 /* intel mb bug */
1799                 u = (uint64_t) csr32r(ctlr, Rah) << 32u | (unsigned int)csr32r(ctlr,
1800                                                                                                                                            Ral);
1801                 for (i = 0; i < Eaddrlen; i++)
1802                         ra[i] = u >> 8 * i;
1803         }
1804         if (memcmp(ra, NULLea, Eaddrlen) != 0)
1805                 return;
1806         for (i = 0; i < Eaddrlen / 2; i++) {
1807                 ra[2 * i] = ctlr->eeprom[Ea + i];
1808                 ra[2 * i + 1] = ctlr->eeprom[Ea + i] >> 8;
1809         }
1810         r = (csr32r(ctlr, Status) & Lanid) >> 2;
1811         ra[5] += r;     /* ea ctlr[n] = ea ctlr[0]+n */
1812 }
1813
1814 static int i82563reset(struct ctlr *ctlr)
1815 {
1816         uint8_t *ra;
1817         int i, r;
1818
1819         if (i82563detach(ctlr))
1820                 return -1;
1821         if (cttab[ctlr->type].flag & Fload)
1822                 r = fload(ctlr);
1823         else
1824                 r = eeload(ctlr);
1825         if (r != 0 && r != 0xbaba) {
1826                 printd("%s: bad eeprom checksum - %#.4ux\n", cname(ctlr), r);
1827                 return -1;
1828         }
1829
1830         ra = ctlr->ra;
1831         defaultea(ctlr, ra);
1832         csr32w(ctlr, Ral, ra[3] << 24 | ra[2] << 16 | ra[1] << 8 | ra[0]);
1833         csr32w(ctlr, Rah, 1 << 31 | ra[5] << 8 | ra[4]);
1834         for (i = 1; i < 16; i++) {
1835                 csr32w(ctlr, Ral + i * 8, 0);
1836                 csr32w(ctlr, Rah + i * 8, 0);
1837         }
1838         memset(ctlr->mta, 0, sizeof(ctlr->mta));
1839         for (i = 0; i < 128; i++)
1840                 csr32w(ctlr, Mta + i * 4, 0);
1841         csr32w(ctlr, Fcal, 0x00C28001);
1842         csr32w(ctlr, Fcah, 0x0100);
1843         if ((cttab[ctlr->type].flag & Fnofct) == 0)
1844                 csr32w(ctlr, Fct, 0x8808);
1845         csr32w(ctlr, Fcttv, 0x0100);
1846         csr32w(ctlr, Fcrtl, ctlr->fcrtl);
1847         csr32w(ctlr, Fcrth, ctlr->fcrth);
1848         if (cttab[ctlr->type].flag & F75)
1849                 csr32w(ctlr, Eitr, 128 << 2);   /* 128 ¼ microsecond intervals */
1850         return 0;
1851 }
1852
1853 enum {
1854         CMrdtr,
1855         CMradv,
1856         CMpause,
1857         CMan,
1858 };
1859
1860 static struct cmdtab i82563ctlmsg[] = {
1861         {CMrdtr, "rdtr", 2},
1862         {CMradv, "radv", 2},
1863         {CMpause, "pause", 1},
1864         {CMan, "an", 1},
1865 };
1866
1867 static long i82563ctl(struct ether *edev, void *buf, long n)
1868 {
1869         ERRSTACK(1);
1870         char *p;
1871         uint32_t v;
1872         struct ctlr *ctlr;
1873         struct cmdbuf *cb;
1874         struct cmdtab *ct;
1875
1876         if ((ctlr = edev->ctlr) == NULL)
1877                 error(Enonexist);
1878
1879         cb = parsecmd(buf, n);
1880         if (waserror()) {
1881                 kfree(cb);
1882                 nexterror();
1883         }
1884
1885         ct = lookupcmd(cb, i82563ctlmsg, ARRAY_SIZE(i82563ctlmsg));
1886         switch (ct->index) {
1887                 case CMrdtr:
1888                         v = strtoul(cb->f[1], &p, 0);
1889                         if (*p || v > 0xffff)
1890                                 error(Ebadarg);
1891                         ctlr->rdtr = v;
1892                         csr32w(ctlr, Rdtr, v);
1893                         break;
1894                 case CMradv:
1895                         v = strtoul(cb->f[1], &p, 0);
1896                         if (*p || v > 0xffff)
1897                                 error(Ebadarg);
1898                         ctlr->radv = v;
1899                         csr32w(ctlr, Radv, v);
1900                         break;
1901                 case CMpause:
1902                         csr32w(ctlr, Ctrl, csr32r(ctlr, Ctrl) ^ (Rfce | Tfce));
1903                         break;
1904                 case CMan:
1905                         csr32w(ctlr, Ctrl, csr32r(ctlr, Ctrl) | Lrst | Phyrst);
1906                         break;
1907         }
1908         kfree(cb);
1909         poperror();
1910
1911         return n;
1912 }
1913
1914 static int didtype(int d)
1915 {
1916         switch (d) {
1917                 case 0x1096:
1918                 case 0x10ba:    /* “gilgal” */
1919                 case 0x1098:    /* serdes; not seen */
1920                 case 0x10bb:    /* serdes */
1921                         return i82563;
1922                 case 0x1049:    /* mm */
1923                 case 0x104a:    /* dm */
1924                 case 0x104b:    /* dc */
1925                 case 0x104d:    /* v “ninevah” */
1926                 case 0x10bd:    /* dm-2 */
1927                 case 0x294c:    /* ich 9 */
1928                         return i82566;
1929                 case 0x10de:    /* lm ich10d */
1930                 case 0x10df:    /* lf ich10 */
1931                 case 0x10e5:    /* lm ich9 */
1932                 case 0x10f5:    /* lm ich9m; “boazman” */
1933                         return i82567;
1934                 case 0x10bf:    /* lf ich9m */
1935                 case 0x10cb:    /* v ich9m */
1936                 case 0x10cd:    /* lf ich10 */
1937                 case 0x10ce:    /* v ich10 */
1938                 case 0x10cc:    /* lm ich10 */
1939                         return i82567m;
1940                 case 0x105e:    /* eb */
1941                 case 0x105f:    /* eb */
1942                 case 0x1060:    /* eb */
1943                 case 0x10a4:    /* eb */
1944                 case 0x10a5:    /* eb  fiber */
1945                 case 0x10bc:    /* eb */
1946                 case 0x10d9:    /* eb serdes */
1947                 case 0x10da:    /* eb serdes “ophir” */
1948                         return i82571;
1949                 case 0x107d:    /* eb copper */
1950                 case 0x107e:    /* ei fiber */
1951                 case 0x107f:    /* ei */
1952                 case 0x10b9:    /* ei “rimon” */
1953                         return i82572;
1954                 case 0x108b:    /*  e “vidalia” */
1955                 case 0x108c:    /*  e (iamt) */
1956                 case 0x109a:    /*  l “tekoa” */
1957                         return i82573;
1958                 case 0x10d3:    /* l or it; “hartwell” */
1959                         return i82574;
1960                 case 0x10a7:
1961                 case 0x10a9:    /* fiber/serdes */
1962                         return i82575;
1963                 case 0x10c9:    /* copper */
1964                 case 0x10e6:    /* fiber */
1965                 case 0x10e7:    /* serdes; “kawela” */
1966                 case 0x150d:    /* backplane */
1967                         return i82576;
1968                 case 0x10ea:    /* lc “calpella”; aka pch lan */
1969                         return i82577;
1970                 case 0x10eb:    /* lm “calpella” */
1971                         return i82577m;
1972                 case 0x10ef:    /* dc “piketon” */
1973                         return i82578;
1974                 case 0x1502:    /* lm */
1975                 case 0x1503:    /* v “lewisville” */
1976                         return i82579;
1977                 case 0x10f0:    /* dm “king's creek” */
1978                         return i82578m;
1979                 case 0x150e:    /* “barton hills” */
1980                 case 0x150f:    /* fiber */
1981                 case 0x1510:    /* backplane */
1982                 case 0x1511:    /* sfp */
1983                 case 0x1516:
1984                         return i82580;
1985                 case 0x1506:    /* v */
1986                         return i82583;
1987                 case 0x1533:    /* i210-t1 */
1988                 case 0x1534:
1989                 case 0x1536:    /* fiber */
1990                 case 0x1537:    /* backplane */
1991                 case 0x1538:
1992                 case 0x1539:    /* i211 */
1993                         return i210;
1994                 case 0x153a:    /* i217-lm */
1995                 case 0x153b:    /* i217-v */
1996                 case 0x15a0:    /* i218-lm */
1997                 case 0x15a1:    /* i218-v */
1998                 case 0x15a2:    /* i218-lm */
1999                 case 0x15a3:    /* i218-v */
2000                         return i217;
2001                 case 0x151f:    /* “powerville” eeprom-less */
2002                 case 0x1521:    /* copper */
2003                 case 0x1522:    /* fiber */
2004                 case 0x1523:    /* serdes */
2005                 case 0x1524:    /* sgmii */
2006                         return i350;
2007         }
2008         return -1;
2009 }
2010
2011 static void hbafixup(struct pci_device *p)
2012 {
2013         unsigned int i;
2014
2015         i = pcidev_read32(p, PciSVID);
2016         if ((i & 0xffff) == 0x1b52 && p->dev_id == 1)
2017                 p->dev_id = i >> 16;
2018 }
2019
2020 static void i82563pci(void)
2021 {
2022         int type;
2023         struct ctlr *c, **cc;
2024         struct pci_device *p;
2025
2026         cc = &i82563ctlr;
2027         STAILQ_FOREACH(p, &pci_devices, all_dev) {
2028                 if (p->ven_id != 0x8086)
2029                         continue;
2030                 hbafixup(p);
2031                 if ((type = didtype(p->dev_id)) == -1)
2032                         continue;
2033                 c = kzmalloc(sizeof *c, KMALLOC_WAIT);
2034
2035                 qlock_init(&c->alock);
2036                 spinlock_init_irqsave(&c->imlock);
2037                 rendez_init(&c->lrendez);
2038                 qlock_init(&c->slock);
2039                 rendez_init(&c->rrendez);
2040                 rendez_init(&c->trendez);
2041                 qlock_init(&c->tlock);
2042
2043                 c->type = type;
2044                 c->pcidev = p;
2045                 c->rbsz = cttab[type].mtu;
2046                 /* plan9 called this c->port, and just used the top of the raw bar,
2047                  * regardless of the type. */
2048                 c->mmio_paddr = p->bar[0].mmio_base32 ? p->bar[0].mmio_base32 : 
2049                                                         p->bar[0].mmio_base64;
2050                 *cc = c;
2051                 cc = &c->next;
2052         }
2053 }
2054
2055 static int setup(struct ctlr *ctlr)
2056 {
2057         struct pci_device *p;
2058
2059         if ((ctlr->pool = newpool()) == -1) {
2060                 printd("%s: no pool\n", cname(ctlr));
2061                 return -1;
2062         }
2063         p = ctlr->pcidev;
2064         ctlr->nic = (void*)vmap_pmem(ctlr->mmio_paddr, p->bar[0].mmio_sz);
2065         if (ctlr->nic == NULL) {
2066                 printd("%s: can't map %p\n", cname(ctlr), ctlr->mmio_paddr);
2067                 return -1;
2068         }
2069         pci_set_bus_master(p);
2070         if (i82563reset(ctlr)) {
2071                 vunmap_vmem((uintptr_t)ctlr->nic, p->bar[0].mmio_sz);
2072                 return -1;
2073         }
2074         return 0;
2075 }
2076
2077 static void i82563_init(void)
2078 {
2079         for (struct Rbpool *rb = rbtab; rb < rbtab + Npool; rb++) {
2080                 spinlock_init_irqsave(&rb->lock);
2081                 rendez_init(&rb->r);
2082         }
2083         i82563pci();
2084 }
2085
2086 static int pnp(struct ether *edev, int type)
2087 {
2088         struct ctlr *ctlr;
2089
2090         run_once(i82563_init());
2091
2092         /*
2093          * Any adapter matches if no edev->port is supplied,
2094          * otherwise the ports must match.
2095          */
2096         for (ctlr = i82563ctlr;; ctlr = ctlr->next) {
2097                 if (ctlr == NULL)
2098                         return -1;
2099                 if (ctlr->active)
2100                         continue;
2101                 if (type != -1 && ctlr->type != type)
2102                         continue;
2103                 if (edev->port == 0 || edev->port == ctlr->mmio_paddr) {
2104                         ctlr->active = 1;
2105                         memmove(ctlr->ra, edev->ea, Eaddrlen);
2106                         if (setup(ctlr) == 0)
2107                                 break;
2108                 }
2109         }
2110
2111         edev->ctlr = ctlr;
2112         edev->port = ctlr->mmio_paddr;
2113         edev->irq = ctlr->pcidev->irqline;
2114         edev->tbdf = MKBUS(BusPCI, ctlr->pcidev->bus, ctlr->pcidev->dev,
2115                            ctlr->pcidev->func);
2116         edev->netif.mbps = 1000;
2117         edev->maxmtu = ctlr->rbsz;
2118         memmove(edev->ea, ctlr->ra, Eaddrlen);
2119
2120         /*
2121          * Linkage to the generic ethernet driver.
2122          */
2123         edev->attach = i82563attach;
2124         edev->ifstat = i82563ifstat;
2125         edev->ctl = i82563ctl;
2126
2127         edev->netif.arg = edev;
2128         edev->netif.promiscuous = i82563promiscuous;
2129         edev->shutdown = i82563shutdown;
2130         edev->netif.multicast = i82563multicast;
2131
2132         register_irq(edev->irq, i82563interrupt, edev, edev->tbdf);
2133         return 0;
2134 }
2135
2136 static int anypnp(struct ether *e)
2137 {
2138         return pnp(e, -1);
2139 }
2140
2141 linker_func_3(ether82563link)
2142 {
2143         addethercard("i82563", anypnp);
2144 }