Correct the date in the copyright line of ether82563.c
[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 - 1;
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 - 1;
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, i;
1075         struct block *bp;
1076         Rbpool *p;
1077         Rd *rd;
1078
1079         rdt = ctlr->rdt;
1080         m = ctlr->nrd - 1;
1081         p = rbtab + ctlr->pool;
1082         i = 0;
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                                 return -1;
1097                         spin_lock_irqsave(&p->lock);
1098                         p->starve = 1;
1099                         spin_unlock_irqsave(&p->lock);
1100                         rendez_sleep(&p->r, icansleep, p);
1101                         goto redux;
1102                 }
1103                 i++;
1104                 ctlr->rb[rdt] = bp;
1105                 rd->addr[0] = paddr_low32(bp->rp);
1106                 rd->addr[1] = paddr_high32(bp->rp);
1107                 rd->status = 0;
1108                 ctlr->rdfree++;
1109         }
1110         if (i != 0) {
1111                 ctlr->rdt = rdt;
1112                 wmb_f();
1113                 csr32w(ctlr, Rdt, rdt);
1114         }
1115         return 0;
1116 }
1117
1118 static void i82563rxinit(struct ctlr *ctlr)
1119 {
1120         int i;
1121         struct block *bp;
1122
1123         if (ctlr->rbsz <= 2048)
1124                 csr32w(ctlr, Rctl, Dpf | Bsize2048 | Bam | RdtmsHALF);
1125         else {
1126                 i = ctlr->rbsz / 1024;
1127                 if (ctlr->rbsz % 1024)
1128                         i++;
1129                 if (cttab[ctlr->type].flag & F75) {
1130                         csr32w(ctlr, Rctl, Lpe | Dpf | Bsize2048 | Bam | RdtmsHALF | Secrc);
1131                         if (ctlr->type != i82575)
1132                                 i |= (ctlr->nrd / 2 >> 4) << 20;        /* RdmsHalf */
1133                         csr32w(ctlr, Srrctl, i | Dropen);
1134                         csr32w(ctlr, Rmpl, ctlr->rbsz);
1135 //          csr32w(ctlr, Drxmxod, 0x7ff);
1136                 } else
1137                         csr32w(ctlr, Rctl,
1138                                    Lpe | Dpf | BsizeFlex * i | Bam | RdtmsHALF | Secrc);
1139         }
1140
1141         if (cttab[ctlr->type].flag & Fert)
1142                 csr32w(ctlr, Ert, 1024 / 8);
1143
1144         if (ctlr->type == i82566)
1145                 csr32w(ctlr, Pbs, 16);
1146
1147         csr32w(ctlr, Rdbal, paddr_low32(ctlr->rdba));
1148         csr32w(ctlr, Rdbah, paddr_high32(ctlr->rdba));
1149         csr32w(ctlr, Rdlen, ctlr->nrd * sizeof(Rd));
1150         ctlr->rdh = 0;
1151         csr32w(ctlr, Rdh, 0);
1152         ctlr->rdt = 0;
1153         csr32w(ctlr, Rdt, 0);
1154         ctlr->rdtr = 0; //25;
1155         ctlr->radv = 0; //500;
1156         csr32w(ctlr, Rdtr, ctlr->rdtr);
1157         csr32w(ctlr, Radv, ctlr->radv);
1158
1159         for (i = 0; i < ctlr->nrd; i++)
1160                 if ((bp = ctlr->rb[i]) != NULL) {
1161                         ctlr->rb[i] = NULL;
1162                         freeb(bp);
1163                 }
1164         if (cttab[ctlr->type].flag & F75)
1165                 csr32w(ctlr, Rxdctl,
1166                            1 << WthreshSHIFT | 8 << PthreshSHIFT | 1 << HthreshSHIFT |
1167                            Enable);
1168         else
1169                 csr32w(ctlr, Rxdctl, 2 << WthreshSHIFT | 2 << PthreshSHIFT);
1170
1171         /*
1172          * Enable checksum offload.
1173          */
1174         csr32w(ctlr, Rxcsum, Tuofl | Ipofl | ETHERHDRSIZE);
1175 }
1176
1177 static int i82563rim(void *v)
1178 {
1179         return ((struct ctlr *)v)->rim != 0;
1180 }
1181
1182 static void i82563rproc(void *arg)
1183 {
1184         unsigned int m, rdh, rim, im;
1185         struct block *bp;
1186         struct ctlr *ctlr;
1187         struct ether *edev;
1188         Rd *rd;
1189
1190         edev = arg;
1191         ctlr = edev->ctlr;
1192
1193         i82563rxinit(ctlr);
1194         csr32w(ctlr, Rctl, csr32r(ctlr, Rctl) | Ren);
1195         if (cttab[ctlr->type].flag & F75) {
1196                 csr32w(ctlr, Rxdctl, csr32r(ctlr, Rxdctl) | Enable);
1197                 im = Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack;
1198         } else
1199                 im = Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack;
1200         m = ctlr->nrd - 1;
1201
1202         for (;;) {
1203                 i82563im(ctlr, im);
1204                 ctlr->rsleep++;
1205                 i82563replenish(ctlr, 1);
1206                 rendez_sleep(&ctlr->rrendez, i82563rim, ctlr);
1207
1208                 rdh = ctlr->rdh;
1209                 for (;;) {
1210                         rd = &ctlr->rdba[rdh];
1211                         rim = ctlr->rim;
1212                         ctlr->rim = 0;
1213                         if (!(rd->status & Rdd))
1214                                 break;
1215
1216                         /*
1217                          * Accept eop packets with no errors.
1218                          * With no errors and the Ixsm bit set,
1219                          * the descriptor status Tpcs and Ipcs bits give
1220                          * an indication of whether the checksums were
1221                          * calculated and valid.
1222                          */
1223                         bp = ctlr->rb[rdh];
1224                         if ((rd->status & Reop) && rd->errors == 0) {
1225                                 bp->wp += rd->length;
1226                                 bp->lim = bp->wp;       /* lie like a dog.  avoid packblock. */
1227                                 if (!(rd->status & Ixsm)) {
1228                                         ctlr->ixsm++;
1229                                         if (rd->status & Ipcs) {
1230                                                 /*
1231                                                  * IP checksum calculated
1232                                                  * (and valid as errors == 0).
1233                                                  */
1234                                                 ctlr->ipcs++;
1235                                                 bp->flag |= Bipck;
1236                                         }
1237                                         if (rd->status & Tcpcs) {
1238                                                 /*
1239                                                  * TCP/UDP checksum calculated
1240                                                  * (and valid as errors == 0).
1241                                                  */
1242                                                 ctlr->tcpcs++;
1243                                                 bp->flag |= Btcpck | Budpck;
1244                                         }
1245                                         bp->checksum = rd->checksum;
1246                                         bp->flag |= Bpktck;
1247                                 }
1248                                 etheriq(edev, bp, 1);
1249                         } else
1250                                 freeb(bp);
1251                         ctlr->rb[rdh] = NULL;
1252                         rd->status = 0;
1253                         ctlr->rdfree--;
1254                         ctlr->rdh = rdh = NEXT_RING(rdh, m);
1255                         if (ctlr->nrd - ctlr->rdfree >= 32 || (rim & Rxdmt0))
1256                                 if (i82563replenish(ctlr, 0) == -1)
1257                                         break;
1258                 }
1259         }
1260 }
1261
1262 static int i82563lim(void *v)
1263 {
1264         return ((struct ctlr *)v)->lim != 0;
1265 }
1266
1267 static int speedtab[] = {
1268         10, 100, 1000, 0
1269 };
1270
1271 static unsigned int phywrite0(struct ctlr *, int unused_int, int, uint16_t);
1272
1273 static unsigned int
1274 setpage(struct ctlr *c, unsigned int phyno, unsigned int p, unsigned int r)
1275 {
1276         unsigned int pr;
1277
1278         switch (c->type) {
1279                 case i82563:
1280                         if (r >= 16 && r <= 28 && r != 22)
1281                                 pr = Phypage;
1282                         else if (r == 30 || r == 31)
1283                                 pr = Phyapage;
1284                         else
1285                                 return 0;
1286                         return phywrite0(c, phyno, pr, p);
1287                 case i82576:
1288                 case i82577:
1289                 case i82578:
1290                         return phywrite0(c, phyno, Phy79page, p);       /* unverified */
1291                 case i82579:
1292                         return phywrite0(c, phyno, Phy79page, p << 5);
1293                 default:
1294                         if (p == 0)
1295                                 return 0;
1296                         return ~0;
1297         }
1298 }
1299
1300 static unsigned int phyread0(struct ctlr *c, int phyno, int reg)
1301 {
1302         unsigned int phy, i;
1303
1304         csr32w(c, Mdic, MDIrop | phyno << MDIpSHIFT | reg << MDIrSHIFT);
1305         phy = 0;
1306         for (i = 0; i < 64; i++) {
1307                 phy = csr32r(c, Mdic);
1308                 if (phy & (MDIe | MDIready))
1309                         break;
1310                 udelay(1);
1311         }
1312         if ((phy & (MDIe | MDIready)) != MDIready) {
1313                 printd("%s: phy %d wedged %.8ux\n", cttab[c->type].name, phyno, phy);
1314                 return ~0;
1315         }
1316         return phy & 0xffff;
1317 }
1318
1319 static unsigned int
1320 phyread(struct ctlr *c, unsigned int phyno, unsigned int reg)
1321 {
1322         if (setpage(c, phyno, reg >> 8, reg & 0xff) == ~0) {
1323                 printd("%s: phyread: bad phy page %d\n", cname(c), reg >> 8);
1324                 return ~0;
1325         }
1326         return phyread0(c, phyno, reg & 0xff);
1327 }
1328
1329 static unsigned int phywrite0(struct ctlr *c, int phyno, int reg, uint16_t val)
1330 {
1331         unsigned int phy, i;
1332
1333         csr32w(c, Mdic, MDIwop | phyno << MDIpSHIFT | reg << MDIrSHIFT | val);
1334         phy = 0;
1335         for (i = 0; i < 64; i++) {
1336                 phy = csr32r(c, Mdic);
1337                 if (phy & (MDIe | MDIready))
1338                         break;
1339                 udelay(1);
1340         }
1341         if ((phy & (MDIe | MDIready)) != MDIready)
1342                 return ~0;
1343         return 0;
1344 }
1345
1346 static unsigned int
1347 phywrite(struct ctlr *c, unsigned int phyno, unsigned int reg, uint16_t v)
1348 {
1349         if (setpage(c, phyno, reg >> 8, reg & 0xff) == ~0)
1350                 panic("%s: bad phy reg %.4ux", cname(c), reg);
1351         return phywrite0(c, phyno, reg & 0xff, v);
1352 }
1353
1354 static void phyerrata(struct ether *e, struct ctlr *c, unsigned int phyno)
1355 {
1356         if (e->netif.mbps == 0) {
1357                 if (c->phyerrata == 0) {
1358                         c->phyerrata++;
1359                         phywrite(c, phyno, Phyprst, Prst);      /* try a port reset */
1360                         printd("ether%d: %s: phy port reset\n", e->ctlrno, cname(c));
1361                 }
1362         } else {
1363                 c->phyerrata = 0;
1364         }
1365 }
1366
1367 static void phyl79proc(void *v)
1368 {
1369         unsigned int a, i, r, phy, phyno;
1370         struct ctlr *c;
1371         struct ether *e;
1372
1373         e = v;
1374         c = e->ctlr;
1375
1376         phyno = cttab[c->type].phyno;
1377         for (;;) {
1378                 phy = phyread(c, phyno, Phystat);
1379                 if (phy == ~0) {
1380                         phy = 0;
1381                         i = 3;
1382                         goto next;
1383                 }
1384                 i = (phy >> 8) & 3;
1385                 a = phy & Ans;
1386                 if (a) {
1387                         r = phyread(c, phyno, Phyctl);
1388                         phywrite(c, phyno, Phyctl, r | Ran | Ean);
1389                 }
1390 next:
1391                 e->netif.link = i != 3 && (phy & Link) != 0;
1392                 if (e->netif.link == 0)
1393                         i = 3;
1394                 c->speeds[i]++;
1395                 e->netif.mbps = speedtab[i];
1396                 c->lim = 0;
1397                 i82563im(c, Lsc);
1398                 c->lsleep++;
1399                 rendez_sleep(&c->lrendez, i82563lim, c);
1400         }
1401 }
1402
1403 static void phylproc(void *v)
1404 {
1405         unsigned int a, i, phy, phyno;
1406         struct ctlr *c;
1407         struct ether *e;
1408
1409         e = v;
1410         c = e->ctlr;
1411         phyno = cttab[c->type].phyno;
1412
1413         if (c->type == i82573 && (phy = phyread(c, 1, Phyier)) != ~0)
1414                 phywrite(c, phyno, Phyier, phy | Lscie | Ancie | Spdie | Panie);
1415         for (;;) {
1416                 phy = phyread(c, phyno, Physsr);
1417                 if (phy == ~0) {
1418                         phy = 0;
1419                         i = 3;
1420                         goto next;
1421                 }
1422                 i = (phy >> 14) & 3;
1423                 switch (c->type) {
1424                         default:
1425                                 a = 0;
1426                                 break;
1427                         case i82563:
1428                         case i82578:
1429                         case i82578m:
1430                         case i82583:
1431                         case i210:
1432                                 a = phyread(c, phyno, Phyisr) & Ane;
1433                                 break;
1434                         case i82571:
1435                         case i82572:
1436                         case i82575:
1437                         case i82576:
1438                                 a = phyread(c, phyno, Phylhr) & Anf;
1439                                 i = (i - 1) & 3;
1440                                 break;
1441                 }
1442                 if (a)
1443                         phywrite(c, phyno, Phyctl, phyread(c, phyno, Phyctl) | Ran | Ean);
1444 next:
1445                 e->netif.link = (phy & Rtlink) != 0;
1446                 if (e->netif.link == 0)
1447                         i = 3;
1448                 c->speeds[i]++;
1449                 e->netif.mbps = speedtab[i];
1450                 if (c->type == i82563)
1451                         phyerrata(e, c, phyno);
1452                 c->lim = 0;
1453                 i82563im(c, Lsc);
1454                 c->lsleep++;
1455                 rendez_sleep(&c->lrendez, i82563lim, c);
1456         }
1457 }
1458
1459 static void pcslproc(void *v)
1460 {
1461         unsigned int i, phy;
1462         struct ctlr *c;
1463         struct ether *e;
1464
1465         e = v;
1466         c = e->ctlr;
1467
1468         if (c->type == i82575 || c->type == i82576)
1469                 csr32w(c, Connsw, Enrgirq);
1470         for (;;) {
1471                 phy = csr32r(c, Pcsstat);
1472                 e->netif.link = phy & Linkok;
1473                 i = 3;
1474                 if (e->netif.link)
1475                         i = (phy & 6) >> 1;
1476                 else if (phy & Anbad)
1477                         csr32w(c, Pcsctl, csr32r(c, Pcsctl) | Pan | Prestart);
1478                 c->speeds[i]++;
1479                 e->netif.mbps = speedtab[i];
1480                 c->lim = 0;
1481                 i82563im(c, Lsc | Omed);
1482                 c->lsleep++;
1483                 rendez_sleep(&c->lrendez, i82563lim, c);
1484         }
1485 }
1486
1487 static void serdeslproc(void *v)
1488 {
1489         unsigned int i, tx, rx;
1490         struct ctlr *c;
1491         struct ether *e;
1492
1493         e = v;
1494         c = e->ctlr;
1495
1496         for (;;) {
1497                 rx = csr32r(c, Rxcw);
1498                 tx = csr32r(c, Txcw);
1499                 e->netif.link = (rx & 1 << 31) != 0;
1500 //      e->netif.link = (csr32r(c, Status) & Lu) != 0;
1501                 i = 3;
1502                 if (e->netif.link)
1503                         i = 2;
1504                 c->speeds[i]++;
1505                 e->netif.mbps = speedtab[i];
1506                 c->lim = 0;
1507                 i82563im(c, Lsc);
1508                 c->lsleep++;
1509                 rendez_sleep(&c->lrendez, i82563lim, c);
1510         }
1511 }
1512
1513 static void i82563attach(struct ether *edev)
1514 {
1515         ERRSTACK(1);
1516         char *name;
1517         int i;
1518         struct block *bp;
1519         struct ctlr *ctlr;
1520
1521         ctlr = edev->ctlr;
1522         qlock(&ctlr->alock);
1523         if (ctlr->alloc != NULL) {
1524                 qunlock(&ctlr->alock);
1525                 return;
1526         }
1527
1528         ctlr->nrd = Nrd;
1529         ctlr->ntd = Ntd;
1530         ctlr->alloc =
1531                 kzmalloc(ctlr->nrd * sizeof(Rd) + ctlr->ntd * sizeof(Td) + 255, 0);
1532         if (ctlr->alloc == NULL) {
1533                 qunlock(&ctlr->alock);
1534                 error(Enomem);
1535         }
1536         ctlr->rdba = (Rd *) ROUNDUP((uintptr_t) ctlr->alloc, 256);
1537         ctlr->tdba = (Td *) (ctlr->rdba + ctlr->nrd);
1538
1539         ctlr->rb = kzmalloc(ctlr->nrd * sizeof(struct block *), 0);
1540         ctlr->tb = kzmalloc(ctlr->ntd * sizeof(struct block *), 0);
1541
1542         if (waserror()) {
1543                 while ((bp = i82563rballoc(rbtab + ctlr->pool))) {
1544                         bp->free = NULL;
1545                         freeb(bp);
1546                 }
1547                 kfree(ctlr->tb);
1548                 ctlr->tb = NULL;
1549                 kfree(ctlr->rb);
1550                 ctlr->rb = NULL;
1551                 kfree(ctlr->alloc);
1552                 ctlr->alloc = NULL;
1553                 qunlock(&ctlr->alock);
1554                 nexterror();
1555         }
1556
1557         for (i = 0; i < Nrb; i++) {
1558                 bp = allocb(ctlr->rbsz + Rbalign);
1559                 bp->free = freetab[ctlr->pool];
1560                 freeb(bp);
1561         }
1562
1563         /* the ktasks should free these names, if they ever exit */
1564         name = kmalloc(KNAMELEN, KMALLOC_WAIT);
1565         snprintf(name, KNAMELEN, "#l%dlproc", edev->ctlrno);
1566
1567         if (csr32r(ctlr, Status) & Tbimode)
1568                 ktask(name, serdeslproc, edev); /* mac based serdes */
1569         else if ((csr32r(ctlr, Ctrlext) & Linkmode) == Serdes)
1570                 ktask(name, pcslproc, edev);    /* phy based serdes */
1571         else if (cttab[ctlr->type].flag & F79phy)
1572                 ktask(name, phyl79proc, edev);
1573         else
1574                 ktask(name, phylproc, edev);
1575
1576         snprintf(name, KNAMELEN, "#l%drproc", edev->ctlrno);
1577         ktask(name, i82563rproc, edev);
1578
1579         snprintf(name, KNAMELEN, "#l%dtproc", edev->ctlrno);
1580         ktask(name, i82563tproc, edev);
1581
1582         qunlock(&ctlr->alock);
1583         poperror();
1584 }
1585
1586 static void i82563interrupt(struct hw_trapframe *hw_tf, void *arg)
1587 {
1588         struct ctlr *ctlr;
1589         struct ether *edev;
1590         uint32_t icr, im;
1591
1592         edev = arg;
1593         ctlr = edev->ctlr;
1594
1595         spin_lock_irqsave(&ctlr->imlock);
1596         csr32w(ctlr, Imc, ~0);
1597         im = ctlr->im;
1598
1599         while ((icr = csr32r(ctlr, Icr)) & ctlr->im) {
1600                 if (icr & (Lsc | Omed)) {
1601                         im &= ~(Lsc | Omed);
1602                         ctlr->lim = icr & (Lsc | Omed);
1603                         rendez_wakeup(&ctlr->lrendez);
1604                         ctlr->lintr++;
1605                 }
1606                 if (icr & (Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack)) {
1607                         ctlr->rim = icr & (Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack);
1608                         im &= ~(Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack);
1609                         rendez_wakeup(&ctlr->rrendez);
1610                         ctlr->rintr++;
1611                 }
1612                 if (icr & Txdw) {
1613                         im &= ~Txdw;
1614                         ctlr->tintr++;
1615                         rendez_wakeup(&ctlr->trendez);
1616                 }
1617         }
1618
1619         ctlr->im = im;
1620         csr32w(ctlr, Ims, im);
1621         spin_unlock_irqsave(&ctlr->imlock);
1622 }
1623
1624 static int i82563detach(struct ctlr *ctlr)
1625 {
1626         int r, timeo;
1627
1628         /* balance rx/tx packet buffer; survives reset */
1629         if (ctlr->rbsz > 8192 && cttab[ctlr->type].flag & Fpba) {
1630                 ctlr->pba = csr32r(ctlr, Pba);
1631                 r = ctlr->pba >> 16;
1632                 r += ctlr->pba & 0xffff;
1633                 r >>= 1;
1634                 csr32w(ctlr, Pba, r);
1635         } else if (ctlr->type == i82573 && ctlr->rbsz > 1514)
1636                 csr32w(ctlr, Pba, 14);
1637         ctlr->pba = csr32r(ctlr, Pba);
1638
1639         /*
1640          * Perform a device reset to get the chip back to the
1641          * power-on state, followed by an EEPROM reset to read
1642          * the defaults for some internal registers.
1643          */
1644         csr32w(ctlr, Imc, ~0);
1645         csr32w(ctlr, Rctl, 0);
1646         csr32w(ctlr, Tctl, csr32r(ctlr, Tctl) & ~Ten);
1647
1648         udelay(10 * 1000 * 1000);
1649
1650         r = csr32r(ctlr, Ctrl);
1651         if (ctlr->type == i82566 || ctlr->type == i82579)
1652                 r |= Phyrst;
1653         csr32w(ctlr, Ctrl, Devrst | r);
1654         udelay(1000 * 1000);
1655         for (timeo = 0;; timeo++) {
1656                 if ((csr32r(ctlr, Ctrl) & (Devrst | Phyrst)) == 0)
1657                         break;
1658                 if (timeo >= 1000)
1659                         return -1;
1660                 udelay(1000);
1661         }
1662
1663         r = csr32r(ctlr, Ctrl);
1664         csr32w(ctlr, Ctrl, Slu | r);
1665
1666         r = csr32r(ctlr, Ctrlext);
1667         csr32w(ctlr, Ctrlext, r | Eerst);
1668         udelay(1000);
1669         for (timeo = 0; timeo < 1000; timeo++) {
1670                 if (!(csr32r(ctlr, Ctrlext) & Eerst))
1671                         break;
1672                 udelay(1000);
1673         }
1674         if (csr32r(ctlr, Ctrlext) & Eerst)
1675                 return -1;
1676
1677         csr32w(ctlr, Imc, ~0);
1678         udelay(1000);
1679         for (timeo = 0; timeo < 1000; timeo++) {
1680                 if ((csr32r(ctlr, Icr) & ~Rxcfg) == 0)
1681                         break;
1682                 udelay(1000);
1683         }
1684         if (csr32r(ctlr, Icr) & ~Rxcfg)
1685                 return -1;
1686
1687         return 0;
1688 }
1689
1690 static void i82563shutdown(struct ether *edev)
1691 {
1692         i82563detach(edev->ctlr);
1693 }
1694
1695 static uint16_t eeread(struct ctlr *ctlr, int adr)
1696 {
1697         csr32w(ctlr, Eerd, EEstart | adr << 2);
1698         while ((csr32r(ctlr, Eerd) & EEdone) == 0)
1699                 cpu_relax();
1700         return csr32r(ctlr, Eerd) >> 16;
1701 }
1702
1703 static int eeload(struct ctlr *ctlr)
1704 {
1705         uint16_t sum;
1706         int data, adr;
1707
1708         sum = 0;
1709         for (adr = 0; adr < 0x40; adr++) {
1710                 data = eeread(ctlr, adr);
1711                 ctlr->eeprom[adr] = data;
1712                 sum += data;
1713         }
1714         return sum;
1715 }
1716
1717 static int fcycle(struct ctlr *unused, Flash * f)
1718 {
1719         uint16_t s, i;
1720
1721         s = f->reg[Fsts];
1722         if ((s & Fvalid) == 0)
1723                 return -1;
1724         f->reg[Fsts] |= Fcerr | Ael;
1725         for (i = 0; i < 10; i++) {
1726                 if ((s & Scip) == 0)
1727                         return 0;
1728                 udelay(1000);
1729                 s = f->reg[Fsts];
1730         }
1731         return -1;
1732 }
1733
1734 static int fread(struct ctlr *c, Flash * f, int ladr)
1735 {
1736         uint16_t s;
1737
1738         udelay(1000);
1739         if (fcycle(c, f) == -1)
1740                 return -1;
1741         f->reg[Fsts] |= Fdone;
1742         f->reg32[Faddr] = ladr;
1743
1744         /* setup flash control register */
1745         s = f->reg[Fctl] & ~0x3ff;
1746         f->reg[Fctl] = s | 1 << 8 | Fgo;        /* 2 byte read */
1747
1748         while ((f->reg[Fsts] & Fdone) == 0) ;
1749         if (f->reg[Fsts] & (Fcerr | Ael))
1750                 return -1;
1751         return f->reg32[Fdata] & 0xffff;
1752 }
1753
1754 static int fload(struct ctlr *c)
1755 {
1756         unsigned int data, r, adr;
1757         uint16_t sum;
1758         uintptr_t mmio_paddr;
1759         struct pci_device *pcidev = c->pcidev;
1760         Flash f;
1761         mmio_paddr = pcidev->bar[1].mmio_base32 ? pcidev->bar[1].mmio_base32 : 
1762                                                   pcidev->bar[1].mmio_base64;
1763         f.reg = (void*)vmap_pmem(mmio_paddr, pcidev->bar[1].mmio_sz);
1764         if (f.reg == NULL)
1765                 return -1;
1766         f.reg32 = (uint32_t *) f.reg;
1767         f.base = f.reg32[Bfpr] & 0x1fff;
1768         f.lim = f.reg32[Bfpr] >> 16 & 0x1fff;
1769         if (csr32r(c, Eec) & Sec1val)
1770                 f.base += (f.lim + 1) - (f.base >> 1);
1771         r = f.base << 12;
1772         sum = 0;
1773         for (adr = 0; adr < 0x40; adr++) {
1774                 data = fread(c, &f, r + adr * 2);
1775                 if (data == -1)
1776                         return -1;
1777                 c->eeprom[adr] = data;
1778                 sum += data;
1779         }
1780         vunmap_vmem((uintptr_t)f.reg, c->pcidev->bar[1].mmio_sz);
1781         return sum;
1782 }
1783
1784 static void defaultea(struct ctlr *ctlr, uint8_t * ra)
1785 {
1786         unsigned int i, r;
1787         uint64_t u;
1788         static uint8_t NULLea[Eaddrlen];
1789
1790         if (memcmp(ra, NULLea, Eaddrlen) != 0)
1791                 return;
1792         if (cttab[ctlr->type].flag & Fflashea) {
1793                 /* intel mb bug */
1794                 u = (uint64_t) csr32r(ctlr, Rah) << 32u | (unsigned int)csr32r(ctlr,
1795                                                                                                                                            Ral);
1796                 for (i = 0; i < Eaddrlen; i++)
1797                         ra[i] = u >> 8 * i;
1798         }
1799         if (memcmp(ra, NULLea, Eaddrlen) != 0)
1800                 return;
1801         for (i = 0; i < Eaddrlen / 2; i++) {
1802                 ra[2 * i] = ctlr->eeprom[Ea + i];
1803                 ra[2 * i + 1] = ctlr->eeprom[Ea + i] >> 8;
1804         }
1805         r = (csr32r(ctlr, Status) & Lanid) >> 2;
1806         ra[5] += r;     /* ea ctlr[n] = ea ctlr[0]+n */
1807 }
1808
1809 static int i82563reset(struct ctlr *ctlr)
1810 {
1811         uint8_t *ra;
1812         int i, r;
1813
1814         if (i82563detach(ctlr))
1815                 return -1;
1816         if (cttab[ctlr->type].flag & Fload)
1817                 r = fload(ctlr);
1818         else
1819                 r = eeload(ctlr);
1820         if (r != 0 && r != 0xbaba) {
1821                 printd("%s: bad eeprom checksum - %#.4ux\n", cname(ctlr), r);
1822                 return -1;
1823         }
1824
1825         ra = ctlr->ra;
1826         defaultea(ctlr, ra);
1827         csr32w(ctlr, Ral, ra[3] << 24 | ra[2] << 16 | ra[1] << 8 | ra[0]);
1828         csr32w(ctlr, Rah, 1 << 31 | ra[5] << 8 | ra[4]);
1829         for (i = 1; i < 16; i++) {
1830                 csr32w(ctlr, Ral + i * 8, 0);
1831                 csr32w(ctlr, Rah + i * 8, 0);
1832         }
1833         memset(ctlr->mta, 0, sizeof(ctlr->mta));
1834         for (i = 0; i < 128; i++)
1835                 csr32w(ctlr, Mta + i * 4, 0);
1836         csr32w(ctlr, Fcal, 0x00C28001);
1837         csr32w(ctlr, Fcah, 0x0100);
1838         if ((cttab[ctlr->type].flag & Fnofct) == 0)
1839                 csr32w(ctlr, Fct, 0x8808);
1840         csr32w(ctlr, Fcttv, 0x0100);
1841         csr32w(ctlr, Fcrtl, ctlr->fcrtl);
1842         csr32w(ctlr, Fcrth, ctlr->fcrth);
1843         if (cttab[ctlr->type].flag & F75)
1844                 csr32w(ctlr, Eitr, 128 << 2);   /* 128 ¼ microsecond intervals */
1845         return 0;
1846 }
1847
1848 enum {
1849         CMrdtr,
1850         CMradv,
1851         CMpause,
1852         CMan,
1853 };
1854
1855 static struct cmdtab i82563ctlmsg[] = {
1856         {CMrdtr, "rdtr", 2},
1857         {CMradv, "radv", 2},
1858         {CMpause, "pause", 1},
1859         {CMan, "an", 1},
1860 };
1861
1862 static long i82563ctl(struct ether *edev, void *buf, long n)
1863 {
1864         ERRSTACK(1);
1865         char *p;
1866         uint32_t v;
1867         struct ctlr *ctlr;
1868         struct cmdbuf *cb;
1869         struct cmdtab *ct;
1870
1871         if ((ctlr = edev->ctlr) == NULL)
1872                 error(Enonexist);
1873
1874         cb = parsecmd(buf, n);
1875         if (waserror()) {
1876                 kfree(cb);
1877                 nexterror();
1878         }
1879
1880         ct = lookupcmd(cb, i82563ctlmsg, ARRAY_SIZE(i82563ctlmsg));
1881         switch (ct->index) {
1882                 case CMrdtr:
1883                         v = strtoul(cb->f[1], &p, 0);
1884                         if (*p || v > 0xffff)
1885                                 error(Ebadarg);
1886                         ctlr->rdtr = v;
1887                         csr32w(ctlr, Rdtr, v);
1888                         break;
1889                 case CMradv:
1890                         v = strtoul(cb->f[1], &p, 0);
1891                         if (*p || v > 0xffff)
1892                                 error(Ebadarg);
1893                         ctlr->radv = v;
1894                         csr32w(ctlr, Radv, v);
1895                         break;
1896                 case CMpause:
1897                         csr32w(ctlr, Ctrl, csr32r(ctlr, Ctrl) ^ (Rfce | Tfce));
1898                         break;
1899                 case CMan:
1900                         csr32w(ctlr, Ctrl, csr32r(ctlr, Ctrl) | Lrst | Phyrst);
1901                         break;
1902         }
1903         kfree(cb);
1904         poperror();
1905
1906         return n;
1907 }
1908
1909 static int didtype(int d)
1910 {
1911         switch (d) {
1912                 case 0x1096:
1913                 case 0x10ba:    /* “gilgal” */
1914                 case 0x1098:    /* serdes; not seen */
1915                 case 0x10bb:    /* serdes */
1916                         return i82563;
1917                 case 0x1049:    /* mm */
1918                 case 0x104a:    /* dm */
1919                 case 0x104b:    /* dc */
1920                 case 0x104d:    /* v “ninevah” */
1921                 case 0x10bd:    /* dm-2 */
1922                 case 0x294c:    /* ich 9 */
1923                         return i82566;
1924                 case 0x10de:    /* lm ich10d */
1925                 case 0x10df:    /* lf ich10 */
1926                 case 0x10e5:    /* lm ich9 */
1927                 case 0x10f5:    /* lm ich9m; “boazman” */
1928                         return i82567;
1929                 case 0x10bf:    /* lf ich9m */
1930                 case 0x10cb:    /* v ich9m */
1931                 case 0x10cd:    /* lf ich10 */
1932                 case 0x10ce:    /* v ich10 */
1933                 case 0x10cc:    /* lm ich10 */
1934                         return i82567m;
1935                 case 0x105e:    /* eb */
1936                 case 0x105f:    /* eb */
1937                 case 0x1060:    /* eb */
1938                 case 0x10a4:    /* eb */
1939                 case 0x10a5:    /* eb  fiber */
1940                 case 0x10bc:    /* eb */
1941                 case 0x10d9:    /* eb serdes */
1942                 case 0x10da:    /* eb serdes “ophir” */
1943                         return i82571;
1944                 case 0x107d:    /* eb copper */
1945                 case 0x107e:    /* ei fiber */
1946                 case 0x107f:    /* ei */
1947                 case 0x10b9:    /* ei “rimon” */
1948                         return i82572;
1949                 case 0x108b:    /*  e “vidalia” */
1950                 case 0x108c:    /*  e (iamt) */
1951                 case 0x109a:    /*  l “tekoa” */
1952                         return i82573;
1953                 case 0x10d3:    /* l or it; “hartwell” */
1954                         return i82574;
1955                 case 0x10a7:
1956                 case 0x10a9:    /* fiber/serdes */
1957                         return i82575;
1958                 case 0x10c9:    /* copper */
1959                 case 0x10e6:    /* fiber */
1960                 case 0x10e7:    /* serdes; “kawela” */
1961                 case 0x150d:    /* backplane */
1962                         return i82576;
1963                 case 0x10ea:    /* lc “calpella”; aka pch lan */
1964                         return i82577;
1965                 case 0x10eb:    /* lm “calpella” */
1966                         return i82577m;
1967                 case 0x10ef:    /* dc “piketon” */
1968                         return i82578;
1969                 case 0x1502:    /* lm */
1970                 case 0x1503:    /* v “lewisville” */
1971                         return i82579;
1972                 case 0x10f0:    /* dm “king's creek” */
1973                         return i82578m;
1974                 case 0x150e:    /* “barton hills” */
1975                 case 0x150f:    /* fiber */
1976                 case 0x1510:    /* backplane */
1977                 case 0x1511:    /* sfp */
1978                 case 0x1516:
1979                         return i82580;
1980                 case 0x1506:    /* v */
1981                         return i82583;
1982                 case 0x1533:    /* i210-t1 */
1983                 case 0x1534:
1984                 case 0x1536:    /* fiber */
1985                 case 0x1537:    /* backplane */
1986                 case 0x1538:
1987                 case 0x1539:    /* i211 */
1988                         return i210;
1989                 case 0x153a:    /* i217-lm */
1990                 case 0x153b:    /* i217-v */
1991                 case 0x15a0:    /* i218-lm */
1992                 case 0x15a1:    /* i218-v */
1993                 case 0x15a2:    /* i218-lm */
1994                 case 0x15a3:    /* i218-v */
1995                         return i217;
1996                 case 0x151f:    /* “powerville” eeprom-less */
1997                 case 0x1521:    /* copper */
1998                 case 0x1522:    /* fiber */
1999                 case 0x1523:    /* serdes */
2000                 case 0x1524:    /* sgmii */
2001                         return i350;
2002         }
2003         return -1;
2004 }
2005
2006 static void hbafixup(struct pci_device *p)
2007 {
2008         unsigned int i;
2009
2010         i = pcidev_read32(p, PciSVID);
2011         if ((i & 0xffff) == 0x1b52 && p->dev_id == 1)
2012                 p->dev_id = i >> 16;
2013 }
2014
2015 static void i82563pci(void)
2016 {
2017         int type;
2018         struct ctlr *c, **cc;
2019         struct pci_device *p;
2020
2021         cc = &i82563ctlr;
2022         STAILQ_FOREACH(p, &pci_devices, all_dev) {
2023                 if (p->ven_id != 0x8086)
2024                         continue;
2025                 hbafixup(p);
2026                 if ((type = didtype(p->dev_id)) == -1)
2027                         continue;
2028                 c = kzmalloc(sizeof *c, KMALLOC_WAIT);
2029
2030                 qlock_init(&c->alock);
2031                 spinlock_init_irqsave(&c->imlock);
2032                 rendez_init(&c->lrendez);
2033                 qlock_init(&c->slock);
2034                 rendez_init(&c->rrendez);
2035                 rendez_init(&c->trendez);
2036                 qlock_init(&c->tlock);
2037
2038                 c->type = type;
2039                 c->pcidev = p;
2040                 c->rbsz = cttab[type].mtu;
2041                 /* plan9 called this c->port, and just used the top of the raw bar,
2042                  * regardless of the type. */
2043                 c->mmio_paddr = p->bar[0].mmio_base32 ? p->bar[0].mmio_base32 : 
2044                                                         p->bar[0].mmio_base64;
2045                 *cc = c;
2046                 cc = &c->next;
2047         }
2048 }
2049
2050 static int setup(struct ctlr *ctlr)
2051 {
2052         struct pci_device *p;
2053
2054         if ((ctlr->pool = newpool()) == -1) {
2055                 printd("%s: no pool\n", cname(ctlr));
2056                 return -1;
2057         }
2058         p = ctlr->pcidev;
2059         ctlr->nic = (void*)vmap_pmem(ctlr->mmio_paddr, p->bar[0].mmio_sz);
2060         if (ctlr->nic == NULL) {
2061                 printd("%s: can't map %p\n", cname(ctlr), ctlr->mmio_paddr);
2062                 return -1;
2063         }
2064         pci_set_bus_master(p);
2065         if (i82563reset(ctlr)) {
2066                 vunmap_vmem((uintptr_t)ctlr->nic, p->bar[0].mmio_sz);
2067                 return -1;
2068         }
2069         return 0;
2070 }
2071
2072 static void i82563_init(void)
2073 {
2074         for (struct Rbpool *rb = rbtab; rb < rbtab + Npool; rb++) {
2075                 spinlock_init_irqsave(&rb->lock);
2076                 rendez_init(&rb->r);
2077         }
2078         i82563pci();
2079 }
2080
2081 static int pnp(struct ether *edev, int type)
2082 {
2083         struct ctlr *ctlr;
2084
2085         run_once(i82563_init());
2086
2087         /*
2088          * Any adapter matches if no edev->port is supplied,
2089          * otherwise the ports must match.
2090          */
2091         for (ctlr = i82563ctlr;; ctlr = ctlr->next) {
2092                 if (ctlr == NULL)
2093                         return -1;
2094                 if (ctlr->active)
2095                         continue;
2096                 if (type != -1 && ctlr->type != type)
2097                         continue;
2098                 if (edev->port == 0 || edev->port == ctlr->mmio_paddr) {
2099                         ctlr->active = 1;
2100                         memmove(ctlr->ra, edev->ea, Eaddrlen);
2101                         if (setup(ctlr) == 0)
2102                                 break;
2103                 }
2104         }
2105
2106         edev->ctlr = ctlr;
2107         edev->port = ctlr->mmio_paddr;
2108         edev->irq = ctlr->pcidev->irqline;
2109         edev->tbdf = MKBUS(BusPCI, ctlr->pcidev->bus, ctlr->pcidev->dev,
2110                            ctlr->pcidev->func);
2111         edev->netif.mbps = 1000;
2112         edev->maxmtu = ctlr->rbsz;
2113         memmove(edev->ea, ctlr->ra, Eaddrlen);
2114
2115         /*
2116          * Linkage to the generic ethernet driver.
2117          */
2118         edev->attach = i82563attach;
2119         edev->ifstat = i82563ifstat;
2120         edev->ctl = i82563ctl;
2121
2122         edev->netif.arg = edev;
2123         edev->netif.promiscuous = i82563promiscuous;
2124         edev->shutdown = i82563shutdown;
2125         edev->netif.multicast = i82563multicast;
2126
2127         register_irq(edev->irq, i82563interrupt, edev, edev->tbdf);
2128         return 0;
2129 }
2130
2131 static int anypnp(struct ether *e)
2132 {
2133         return pnp(e, -1);
2134 }
2135
2136 linker_func_3(ether82563link)
2137 {
2138         addethercard("i82563", anypnp);
2139 }