8ce14dac603f659c00f7d7a6fb300e65ea351034
[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         Rbalign = 16,   /* rx buffer alignment */
454         Npool = 10,
455 };
456
457 enum {
458         i82563,
459         i82566,
460         i82567,
461         i82567m,
462         i82571,
463         i82572,
464         i82573,
465         i82574,
466         i82575,
467         i82576,
468         i82577,
469         i82577m,
470         i82578,
471         i82578m,
472         i82579,
473         i82580,
474         i82583,
475         i210,
476         i217,
477         i350,
478         Nctlrtype,
479 };
480
481 enum {
482         Fload = 1 << 0,
483         Fert = 1 << 1,
484         F75 = 1 << 2,
485         Fpba = 1 << 3,
486         Fflashea = 1 << 4,
487         F79phy = 1 << 5,
488         Fnofct = 1 << 6,
489 };
490
491 typedef struct Ctlrtype Ctlrtype;
492 struct Ctlrtype {
493         int type;
494         int mtu;
495         int phyno;
496         char *name;
497         int flag;
498 };
499
500 static Ctlrtype cttab[Nctlrtype] = {
501         {i82563, 9014, 1, "i82563", Fpba},
502         {i82566, 1514, 1, "i82566", Fload},
503         {i82567, 9234, 1, "i82567", Fload},
504         {i82567m, 1514, 1, "i82567m", 0},
505         {i82571, 9234, 1, "i82571", Fpba},
506         {i82572, 9234, 1, "i82572", Fpba},
507         {i82573, 8192, 1, "i82573", Fert},      /* terrible perf above 8k */
508         {i82574, 9018, 1, "i82574", 0},
509         {i82575, 9728, 1, "i82575", F75 | Fflashea},
510         {i82576, 9728, 1, "i82576", F75},
511         {i82577, 4096, 2, "i82577", Fload | Fert},
512         {i82577m, 1514, 2, "i82577", Fload | Fert},
513         {i82578, 4096, 2, "i82578", Fload | Fert},
514         {i82578m, 1514, 2, "i82578", Fload | Fert},
515         {i82579, 9018, 2, "i82579", Fload | Fert | F79phy | Fnofct},
516         {i82580, 9728, 1, "i82580", F75 | F79phy},
517         {i82583, 1514, 1, "i82583", 0},
518         {i210, 9728, 1, "i210", F75 | Fnofct | Fert},
519         {i217, 9728, 1, "i217", F79phy | Fnofct | Fload | Fert},
520         {i350, 9728, 1, "i350", F75 | F79phy | Fnofct},
521 };
522
523 typedef void (*Freefn) (struct block *);
524
525 typedef struct ctlr Ctlr;
526 struct ctlr {
527         uintptr_t mmio_paddr;
528         struct pci_device *pcidev;
529         struct ctlr *next;
530         int active;
531         int type;
532         uint16_t eeprom[0x40];
533
534         qlock_t alock;                          /* attach */
535         void *alloc;                            /* receive/transmit descriptors */
536         int nrd;
537         int ntd;
538         unsigned int rbsz;
539
540         uint32_t *nic;
541         spinlock_t imlock;
542         int im;                                         /* interrupt mask */
543
544         struct rendez lrendez;
545         int lim;
546
547         qlock_t slock;
548         uint32_t statistics[Nstatistics];
549         unsigned int lsleep;
550         unsigned int lintr;
551         unsigned int rsleep;
552         unsigned int rintr;
553         unsigned int txdw;
554         unsigned int tintr;
555         unsigned int ixsm;
556         unsigned int ipcs;
557         unsigned int tcpcs;
558         unsigned int speeds[4];
559         unsigned int phyerrata;
560
561         uint8_t ra[Eaddrlen];           /* receive address */
562         uint32_t mta[128];                      /* multicast table array */
563
564         struct rendez rrendez;
565         int rim;
566         int rdfree;
567         Rd *rdba;                                       /* receive descriptor base address */
568         struct block **rb;                      /* receive buffers */
569         unsigned int rdh;                       /* receive descriptor head */
570         unsigned int rdt;                       /* receive descriptor tail */
571         int rdtr;                                       /* receive delay timer ring value */
572         int radv;                                       /* receive interrupt absolute delay timer */
573
574         struct rendez trendez;
575         qlock_t tlock;
576         int tbusy;
577         Td *tdba;                                       /* transmit descriptor base address */
578         struct block **tb;                      /* transmit buffers */
579         int tdh;                                        /* transmit descriptor head */
580         int tdt;                                        /* transmit descriptor tail */
581
582         int fcrtl;
583         int fcrth;
584
585         uint32_t pba;                           /* packet buffer allocation */
586 };
587
588 static inline uint32_t csr32r(struct ctlr *c, uintptr_t reg)
589 {
590         return read_mmreg32((uintptr_t)(c->nic + (reg / 4)));
591 }
592
593 static inline void csr32w(struct ctlr *c, uintptr_t reg, uint32_t val)
594 {
595         write_mmreg32((uintptr_t)(c->nic + (reg / 4)), val);
596 }
597
598 static struct ctlr *i82563ctlr;
599
600 static char *statistics[Nstatistics] = {
601         "CRC Error",
602         "Alignment Error",
603         "Symbol Error",
604         "RX Error",
605         "Missed Packets",
606         "Single Collision",
607         "Excessive Collisions",
608         "Multiple Collision",
609         "Late Collisions",
610         NULL,
611         "Collision",
612         "Transmit Underrun",
613         "Defer",
614         "Transmit - No CRS",
615         "Sequence Error",
616         "Carrier Extension Error",
617         "Receive Error Length",
618         NULL,
619         "XON Received",
620         "XON Transmitted",
621         "XOFF Received",
622         "XOFF Transmitted",
623         "FC Received Unsupported",
624         "Packets Received (64 Bytes)",
625         "Packets Received (65-127 Bytes)",
626         "Packets Received (128-255 Bytes)",
627         "Packets Received (256-511 Bytes)",
628         "Packets Received (512-1023 Bytes)",
629         "Packets Received (1024-mtu Bytes)",
630         "Good Packets Received",
631         "Broadcast Packets Received",
632         "Multicast Packets Received",
633         "Good Packets Transmitted",
634         NULL,
635         "Good Octets Received",
636         NULL,
637         "Good Octets Transmitted",
638         NULL,
639         NULL,
640         NULL,
641         "Receive No Buffers",
642         "Receive Undersize",
643         "Receive Fragment",
644         "Receive Oversize",
645         "Receive Jabber",
646         "Management Packets Rx",
647         "Management Packets Drop",
648         "Management Packets Tx",
649         "Total Octets Received",
650         NULL,
651         "Total Octets Transmitted",
652         NULL,
653         "Total Packets Received",
654         "Total Packets Transmitted",
655         "Packets Transmitted (64 Bytes)",
656         "Packets Transmitted (65-127 Bytes)",
657         "Packets Transmitted (128-255 Bytes)",
658         "Packets Transmitted (256-511 Bytes)",
659         "Packets Transmitted (512-1023 Bytes)",
660         "Packets Transmitted (1024-mtu Bytes)",
661         "Multicast Packets Transmitted",
662         "Broadcast Packets Transmitted",
663         "TCP Segmentation Context Transmitted",
664         "TCP Segmentation Context Fail",
665         "Interrupt Assertion",
666         "Interrupt Rx Pkt Timer",
667         "Interrupt Rx Abs Timer",
668         "Interrupt Tx Pkt Timer",
669         "Interrupt Tx Abs Timer",
670         "Interrupt Tx Queue Empty",
671         "Interrupt Tx Desc Low",
672         "Interrupt Rx Min",
673         "Interrupt Rx Overrun",
674 };
675
676 static char *cname(struct ctlr *c)
677 {
678         return cttab[c->type].name;
679 }
680
681 static long i82563ifstat(struct ether* edev, void* a, long n, uint32_t offset)
682 {
683         char *s, *p, *e, *stat;
684         int i, r;
685         uint64_t tuvl, ruvl;
686         struct ctlr *ctlr;
687
688         ctlr = edev->ctlr;
689         qlock(&ctlr->slock);
690         p = s = kzmalloc(READSTR, 0);
691         e = p + READSTR;
692
693         for (i = 0; i < Nstatistics; i++) {
694                 r = csr32r(ctlr, Statistics + i * 4);
695                 if ((stat = statistics[i]) == NULL)
696                         continue;
697                 switch (i) {
698                         case Gorcl:
699                         case Gotcl:
700                         case Torl:
701                         case Totl:
702                                 ruvl = r;
703                                 ruvl += (uint64_t) csr32r(ctlr, Statistics + (i + 1) * 4) << 32;
704                                 tuvl = ruvl;
705                                 tuvl += ctlr->statistics[i];
706                                 tuvl += (uint64_t) ctlr->statistics[i + 1] << 32;
707                                 if (tuvl == 0)
708                                         continue;
709                                 ctlr->statistics[i] = tuvl;
710                                 ctlr->statistics[i + 1] = tuvl >> 32;
711                                 p = seprintf(p, e, "%s: %llud %llud\n", stat, tuvl, ruvl);
712                                 i++;
713                                 break;
714
715                         default:
716                                 ctlr->statistics[i] += r;
717                                 if (ctlr->statistics[i] == 0)
718                                         continue;
719                                 p = seprintf(p, e, "%s: %ud %ud\n", stat,
720                                                          ctlr->statistics[i], r);
721                                 break;
722                 }
723         }
724
725         p = seprintf(p, e, "lintr: %ud %ud\n", ctlr->lintr, ctlr->lsleep);
726         p = seprintf(p, e, "rintr: %ud %ud\n", ctlr->rintr, ctlr->rsleep);
727         p = seprintf(p, e, "tintr: %ud %ud\n", ctlr->tintr, ctlr->txdw);
728         p = seprintf(p, e, "ixcs: %ud %ud %ud\n", ctlr->ixsm, ctlr->ipcs,
729                                  ctlr->tcpcs);
730         p = seprintf(p, e, "rdtr: %ud\n", ctlr->rdtr);
731         p = seprintf(p, e, "radv: %ud\n", ctlr->radv);
732         p = seprintf(p, e, "ctrl: %.8ux\n", csr32r(ctlr, Ctrl));
733         p = seprintf(p, e, "ctrlext: %.8ux\n", csr32r(ctlr, Ctrlext));
734         p = seprintf(p, e, "status: %.8ux\n", csr32r(ctlr, Status));
735         p = seprintf(p, e, "txcw: %.8ux\n", csr32r(ctlr, Txcw));
736         p = seprintf(p, e, "txdctl: %.8ux\n", csr32r(ctlr, Txdctl));
737         p = seprintf(p, e, "pba: %.8ux\n", ctlr->pba);
738
739         p = seprintf(p, e, "speeds: 10:%ud 100:%ud 1000:%ud ?:%ud\n",
740                                  ctlr->speeds[0], ctlr->speeds[1], ctlr->speeds[2],
741                                  ctlr->speeds[3]);
742         p = seprintf(p, e, "type: %s\n", cname(ctlr));
743
744         n = readstr(offset, a, n, s);
745         kfree(s);
746         qunlock(&ctlr->slock);
747
748         return n;
749 }
750
751 static void i82563promiscuous(void *arg, int on)
752 {
753         int rctl;
754         struct ctlr *ctlr;
755         struct ether *edev;
756
757         edev = arg;
758         ctlr = edev->ctlr;
759
760         rctl = csr32r(ctlr, Rctl);
761         rctl &= ~MoMASK;
762         if (on)
763                 rctl |= Upe | Mpe;
764         else
765                 rctl &= ~(Upe | Mpe);
766         csr32w(ctlr, Rctl, rctl);
767 }
768
769 static void i82563multicast(void *arg, uint8_t * addr, int on)
770 {
771         int bit, x;
772         struct ctlr *ctlr;
773         struct ether *edev;
774
775         edev = arg;
776         ctlr = edev->ctlr;
777
778         x = addr[5] >> 1;
779         if (ctlr->type == i82566)
780                 x &= 31;
781         if (ctlr->type == i210 || ctlr->type == i217)
782                 x &= 15;
783         bit = ((addr[5] & 1) << 4) | (addr[4] >> 4);
784         /*
785          * multiple ether addresses can hash to the same filter bit,
786          * so it's never safe to clear a filter bit.
787          * if we want to clear filter bits, we need to keep track of
788          * all the multicast addresses in use, clear all the filter bits,
789          * then set the ones corresponding to in-use addresses.
790          */
791         if (on)
792                 ctlr->mta[x] |= 1 << bit;
793 //  else
794 //      ctlr->mta[x] &= ~(1<<bit);
795
796         csr32w(ctlr, Mta + x * 4, ctlr->mta[x]);
797 }
798
799 static void i82563im(struct ctlr *ctlr, int im)
800 {
801         spin_lock_irqsave(&ctlr->imlock);
802         ctlr->im |= im;
803         csr32w(ctlr, Ims, ctlr->im);
804         spin_unlock_irqsave(&ctlr->imlock);
805 }
806
807 static void i82563txinit(struct ctlr *ctlr)
808 {
809         int i;
810         uint32_t r;
811         struct block *b;
812
813         if (cttab[ctlr->type].flag & F75)
814                 csr32w(ctlr, Tctl, 0x0F << CtSHIFT | Psp);
815         else
816                 csr32w(ctlr, Tctl, 0x0F << CtSHIFT | Psp | 66 << ColdSHIFT | Mulr);
817         csr32w(ctlr, Tipg, 6 << 20 | 8 << 10 | 8);      /* yb sez: 0x702008 */
818         csr32w(ctlr, Tdbal, paddr_low32(ctlr->tdba));
819         csr32w(ctlr, Tdbah, paddr_high32(ctlr->tdba));
820         csr32w(ctlr, Tdlen, ctlr->ntd * sizeof(Td));
821         ctlr->tdh = PREV_RING(0, ctlr->ntd);
822         csr32w(ctlr, Tdh, 0);
823         ctlr->tdt = 0;
824         csr32w(ctlr, Tdt, 0);
825         for (i = 0; i < ctlr->ntd; i++) {
826                 if ((b = ctlr->tb[i]) != NULL) {
827                         ctlr->tb[i] = NULL;
828                         freeb(b);
829                 }
830                 memset(&ctlr->tdba[i], 0, sizeof(Td));
831         }
832         csr32w(ctlr, Tidv, 128);
833         csr32w(ctlr, Tadv, 64);
834         csr32w(ctlr, Tctl, csr32r(ctlr, Tctl) | Ten);
835         r = csr32r(ctlr, Txdctl) & ~WthreshMASK;
836         r |= 4 << WthreshSHIFT | 4 << PthreshSHIFT;
837         if (cttab[ctlr->type].flag & F75)
838                 r |= Enable;
839         csr32w(ctlr, Txdctl, r);
840 }
841
842 static int i82563cleanup(struct ether *e)
843 {
844         struct block *b;
845         struct ctlr *c;
846         int tdh, m, n;
847
848         c = e->ctlr;
849         tdh = c->tdh;
850         m = c->ntd;
851         while (c->tdba[n = NEXT_RING(tdh, m)].status & Tdd) {
852                 tdh = n;
853                 if ((b = c->tb[tdh]) != NULL) {
854                         c->tb[tdh] = NULL;
855                         freeb(b);
856                 } else
857                         printk("#l%d: %s tx underrun! %d\n", e->ctlrno, cname(c), n);
858                 c->tdba[tdh].status = 0;
859         }
860
861         return c->tdh = tdh;
862 }
863
864 static int notrim(void *v)
865 {
866         struct ctlr *c;
867
868         c = v;
869         return (c->im & Txdw) == 0;
870 }
871
872 static void i82563tproc(void *v)
873 {
874         Td *td;
875         struct block *bp;
876         struct ether *edev;
877         struct ctlr *ctlr;
878         int tdh, tdt, m;
879
880         edev = v;
881         ctlr = edev->ctlr;
882         tdt = ctlr->tdt;
883         m = ctlr->ntd;
884
885         i82563txinit(ctlr);
886
887         for (;;) {
888                 tdh = i82563cleanup(edev);
889
890                 if (NEXT_RING(tdt, m) == tdh) {
891                         ctlr->txdw++;
892                         i82563im(ctlr, Txdw);
893                         rendez_sleep(&ctlr->trendez, notrim, ctlr);
894                         continue;
895                 }
896                 bp = qbread(edev->oq, 100000);
897                 if (!bp) {
898                         /* this only happens if the q is closed.  qbread can also throw,
899                          * btw, which we don't handle. */
900                         warn("i350 tproc failed to get a block, aborting!");
901                         return;
902                 }
903                 td = &ctlr->tdba[tdt];
904                 td->addr[0] = paddr_low32(bp->rp);
905                 td->addr[1] = paddr_high32(bp->rp);
906                 td->control = Ide | Rs | Ifcs | Teop | BLEN(bp);
907                 ctlr->tb[tdt] = bp;
908                 tdt = NEXT_RING(tdt, m);
909                 wmb_f();
910                 csr32w(ctlr, Tdt, tdt);
911         }
912 }
913
914 static int i82563replenish(struct ctlr *ctlr, int maysleep)
915 {
916         unsigned int rdt, m;
917         struct block *bp;
918         Rd *rd;
919         int retval = 0;
920
921         rdt = ctlr->rdt;
922         m = ctlr->nrd;
923         for (; NEXT_RING(rdt, m) != ctlr->rdh; rdt = NEXT_RING(rdt, m)) {
924                 rd = &ctlr->rdba[rdt];
925                 if (ctlr->rb[rdt] != NULL) {
926                         printk("%s: tx overrun\n", cname(ctlr));
927                         break;
928                 }
929                 bp = iallocb(ctlr->rbsz + Rbalign);
930                 if (bp == NULL) {
931                         /* could do a sleeping allocb btw, we're a ktask */
932                         warn_once("OOM, trying to survive");
933                         break;
934                 }
935                 ctlr->rb[rdt] = bp;
936                 rd->addr[0] = paddr_low32(bp->rp);
937                 rd->addr[1] = paddr_high32(bp->rp);
938                 rd->status = 0;
939                 ctlr->rdfree++;
940         }
941         if (ctlr->rdt != rdt) {
942                 ctlr->rdt = rdt;
943                 wmb_f();
944                 csr32w(ctlr, Rdt, rdt);
945         }
946         return retval;
947 }
948
949 static void i82563rxinit(struct ctlr *ctlr)
950 {
951         int i;
952         struct block *bp;
953
954         if (ctlr->rbsz <= 2048)
955                 csr32w(ctlr, Rctl, Dpf | Bsize2048 | Bam | RdtmsHALF);
956         else {
957                 i = ctlr->rbsz / 1024;
958                 if (ctlr->rbsz % 1024)
959                         i++;
960                 if (cttab[ctlr->type].flag & F75) {
961                         csr32w(ctlr, Rctl, Lpe | Dpf | Bsize2048 | Bam | RdtmsHALF | Secrc);
962                         if (ctlr->type != i82575)
963                                 i |= (ctlr->nrd / 2 >> 4) << 20;        /* RdmsHalf */
964                         csr32w(ctlr, Srrctl, i | Dropen);
965                         csr32w(ctlr, Rmpl, ctlr->rbsz);
966 //          csr32w(ctlr, Drxmxod, 0x7ff);
967                 } else
968                         csr32w(ctlr, Rctl,
969                                    Lpe | Dpf | BsizeFlex * i | Bam | RdtmsHALF | Secrc);
970         }
971
972         if (cttab[ctlr->type].flag & Fert)
973                 csr32w(ctlr, Ert, 1024 / 8);
974
975         if (ctlr->type == i82566)
976                 csr32w(ctlr, Pbs, 16);
977
978         csr32w(ctlr, Rdbal, paddr_low32(ctlr->rdba));
979         csr32w(ctlr, Rdbah, paddr_high32(ctlr->rdba));
980         csr32w(ctlr, Rdlen, ctlr->nrd * sizeof(Rd));
981         ctlr->rdh = 0;
982         csr32w(ctlr, Rdh, 0);
983         ctlr->rdt = 0;
984         csr32w(ctlr, Rdt, 0);
985         ctlr->rdtr = 0; //25;
986         ctlr->radv = 0; //500;
987         csr32w(ctlr, Rdtr, ctlr->rdtr);
988         csr32w(ctlr, Radv, ctlr->radv);
989
990         for (i = 0; i < ctlr->nrd; i++)
991                 if ((bp = ctlr->rb[i]) != NULL) {
992                         ctlr->rb[i] = NULL;
993                         freeb(bp);
994                 }
995         if (cttab[ctlr->type].flag & F75)
996                 csr32w(ctlr, Rxdctl,
997                            1 << WthreshSHIFT | 8 << PthreshSHIFT | 1 << HthreshSHIFT |
998                            Enable);
999         else
1000                 csr32w(ctlr, Rxdctl, 2 << WthreshSHIFT | 2 << PthreshSHIFT);
1001
1002         /*
1003          * Enable checksum offload.
1004          */
1005         csr32w(ctlr, Rxcsum, Tuofl | Ipofl | ETHERHDRSIZE);
1006 }
1007
1008 static int i82563rim(void *v)
1009 {
1010         return ((struct ctlr *)v)->rim != 0;
1011 }
1012
1013 static void i82563rproc(void *arg)
1014 {
1015         unsigned int m, rdh, rim, im;
1016         struct block *bp;
1017         struct ctlr *ctlr;
1018         struct ether *edev;
1019         Rd *rd;
1020
1021         edev = arg;
1022         ctlr = edev->ctlr;
1023
1024         i82563rxinit(ctlr);
1025         csr32w(ctlr, Rctl, csr32r(ctlr, Rctl) | Ren);
1026         if (cttab[ctlr->type].flag & F75) {
1027                 csr32w(ctlr, Rxdctl, csr32r(ctlr, Rxdctl) | Enable);
1028                 im = Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack;
1029         } else
1030                 im = Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack;
1031         m = ctlr->nrd;
1032
1033         for (;;) {
1034                 i82563im(ctlr, im);
1035                 ctlr->rsleep++;
1036                 i82563replenish(ctlr, 1);
1037                 rendez_sleep(&ctlr->rrendez, i82563rim, ctlr);
1038
1039                 rdh = ctlr->rdh;
1040                 for (;;) {
1041                         rd = &ctlr->rdba[rdh];
1042                         rim = ctlr->rim;
1043                         ctlr->rim = 0;
1044                         if (!(rd->status & Rdd))
1045                                 break;
1046
1047                         /*
1048                          * Accept eop packets with no errors.
1049                          * With no errors and the Ixsm bit set,
1050                          * the descriptor status Tpcs and Ipcs bits give
1051                          * an indication of whether the checksums were
1052                          * calculated and valid.
1053                          */
1054                         bp = ctlr->rb[rdh];
1055                         if ((rd->status & Reop) && rd->errors == 0) {
1056                                 bp->wp += rd->length;
1057                                 bp->lim = bp->wp;       /* lie like a dog.  avoid packblock. */
1058                                 if (!(rd->status & Ixsm)) {
1059                                         ctlr->ixsm++;
1060                                         if (rd->status & Ipcs) {
1061                                                 /*
1062                                                  * IP checksum calculated
1063                                                  * (and valid as errors == 0).
1064                                                  */
1065                                                 ctlr->ipcs++;
1066                                                 bp->flag |= Bipck;
1067                                         }
1068                                         if (rd->status & Tcpcs) {
1069                                                 /*
1070                                                  * TCP/UDP checksum calculated
1071                                                  * (and valid as errors == 0).
1072                                                  */
1073                                                 ctlr->tcpcs++;
1074                                                 bp->flag |= Btcpck | Budpck;
1075                                         }
1076                                         bp->checksum = rd->checksum;
1077                                         bp->flag |= Bpktck;
1078                                 }
1079                                 etheriq(edev, bp, 1);
1080                         } else
1081                                 freeb(bp);
1082                         ctlr->rb[rdh] = NULL;
1083                         rd->status = 0;
1084                         ctlr->rdfree--;
1085                         ctlr->rdh = rdh = NEXT_RING(rdh, m);
1086                         if (ctlr->nrd - ctlr->rdfree >= 32 || (rim & Rxdmt0))
1087                                 if (i82563replenish(ctlr, 0) == -1)
1088                                         break;
1089                 }
1090         }
1091 }
1092
1093 static int i82563lim(void *v)
1094 {
1095         return ((struct ctlr *)v)->lim != 0;
1096 }
1097
1098 static int speedtab[] = {
1099         10, 100, 1000, 0
1100 };
1101
1102 static unsigned int phywrite0(struct ctlr *, int unused_int, int, uint16_t);
1103
1104 static unsigned int
1105 setpage(struct ctlr *c, unsigned int phyno, unsigned int p, unsigned int r)
1106 {
1107         unsigned int pr;
1108
1109         switch (c->type) {
1110                 case i82563:
1111                         if (r >= 16 && r <= 28 && r != 22)
1112                                 pr = Phypage;
1113                         else if (r == 30 || r == 31)
1114                                 pr = Phyapage;
1115                         else
1116                                 return 0;
1117                         return phywrite0(c, phyno, pr, p);
1118                 case i82576:
1119                 case i82577:
1120                 case i82578:
1121                         return phywrite0(c, phyno, Phy79page, p);       /* unverified */
1122                 case i82579:
1123                         return phywrite0(c, phyno, Phy79page, p << 5);
1124                 default:
1125                         if (p == 0)
1126                                 return 0;
1127                         return ~0;
1128         }
1129 }
1130
1131 static unsigned int phyread0(struct ctlr *c, int phyno, int reg)
1132 {
1133         unsigned int phy, i;
1134
1135         csr32w(c, Mdic, MDIrop | phyno << MDIpSHIFT | reg << MDIrSHIFT);
1136         phy = 0;
1137         for (i = 0; i < 64; i++) {
1138                 phy = csr32r(c, Mdic);
1139                 if (phy & (MDIe | MDIready))
1140                         break;
1141                 udelay(1);
1142         }
1143         if ((phy & (MDIe | MDIready)) != MDIready) {
1144                 printd("%s: phy %d wedged %.8ux\n", cttab[c->type].name, phyno, phy);
1145                 return ~0;
1146         }
1147         return phy & 0xffff;
1148 }
1149
1150 static unsigned int
1151 phyread(struct ctlr *c, unsigned int phyno, unsigned int reg)
1152 {
1153         if (setpage(c, phyno, reg >> 8, reg & 0xff) == ~0) {
1154                 printd("%s: phyread: bad phy page %d\n", cname(c), reg >> 8);
1155                 return ~0;
1156         }
1157         return phyread0(c, phyno, reg & 0xff);
1158 }
1159
1160 static unsigned int phywrite0(struct ctlr *c, int phyno, int reg, uint16_t val)
1161 {
1162         unsigned int phy, i;
1163
1164         csr32w(c, Mdic, MDIwop | phyno << MDIpSHIFT | reg << MDIrSHIFT | val);
1165         phy = 0;
1166         for (i = 0; i < 64; i++) {
1167                 phy = csr32r(c, Mdic);
1168                 if (phy & (MDIe | MDIready))
1169                         break;
1170                 udelay(1);
1171         }
1172         if ((phy & (MDIe | MDIready)) != MDIready)
1173                 return ~0;
1174         return 0;
1175 }
1176
1177 static unsigned int
1178 phywrite(struct ctlr *c, unsigned int phyno, unsigned int reg, uint16_t v)
1179 {
1180         if (setpage(c, phyno, reg >> 8, reg & 0xff) == ~0)
1181                 panic("%s: bad phy reg %.4ux", cname(c), reg);
1182         return phywrite0(c, phyno, reg & 0xff, v);
1183 }
1184
1185 static void phyerrata(struct ether *e, struct ctlr *c, unsigned int phyno)
1186 {
1187         if (e->mbps == 0) {
1188                 if (c->phyerrata == 0) {
1189                         c->phyerrata++;
1190                         phywrite(c, phyno, Phyprst, Prst);      /* try a port reset */
1191                         printd("ether%d: %s: phy port reset\n", e->ctlrno, cname(c));
1192                 }
1193         } else {
1194                 c->phyerrata = 0;
1195         }
1196 }
1197
1198 static void phyl79proc(void *v)
1199 {
1200         unsigned int a, i, r, phy, phyno;
1201         struct ctlr *c;
1202         struct ether *e;
1203
1204         e = v;
1205         c = e->ctlr;
1206
1207         phyno = cttab[c->type].phyno;
1208         for (;;) {
1209                 phy = phyread(c, phyno, Phystat);
1210                 if (phy == ~0) {
1211                         phy = 0;
1212                         i = 3;
1213                         goto next;
1214                 }
1215                 i = (phy >> 8) & 3;
1216                 a = phy & Ans;
1217                 if (a) {
1218                         r = phyread(c, phyno, Phyctl);
1219                         phywrite(c, phyno, Phyctl, r | Ran | Ean);
1220                 }
1221 next:
1222                 e->link = i != 3 && (phy & Link) != 0;
1223                 if (e->link == 0)
1224                         i = 3;
1225                 c->speeds[i]++;
1226                 e->mbps = speedtab[i];
1227                 c->lim = 0;
1228                 i82563im(c, Lsc);
1229                 c->lsleep++;
1230                 rendez_sleep(&c->lrendez, i82563lim, c);
1231         }
1232 }
1233
1234 static void phylproc(void *v)
1235 {
1236         unsigned int a, i, phy, phyno;
1237         struct ctlr *c;
1238         struct ether *e;
1239
1240         e = v;
1241         c = e->ctlr;
1242         phyno = cttab[c->type].phyno;
1243
1244         if (c->type == i82573 && (phy = phyread(c, 1, Phyier)) != ~0)
1245                 phywrite(c, phyno, Phyier, phy | Lscie | Ancie | Spdie | Panie);
1246         for (;;) {
1247                 phy = phyread(c, phyno, Physsr);
1248                 if (phy == ~0) {
1249                         phy = 0;
1250                         i = 3;
1251                         goto next;
1252                 }
1253                 i = (phy >> 14) & 3;
1254                 switch (c->type) {
1255                         default:
1256                                 a = 0;
1257                                 break;
1258                         case i82563:
1259                         case i82578:
1260                         case i82578m:
1261                         case i82583:
1262                         case i210:
1263                                 a = phyread(c, phyno, Phyisr) & Ane;
1264                                 break;
1265                         case i82571:
1266                         case i82572:
1267                         case i82575:
1268                         case i82576:
1269                                 a = phyread(c, phyno, Phylhr) & Anf;
1270                                 i = (i - 1) & 3;
1271                                 break;
1272                 }
1273                 if (a)
1274                         phywrite(c, phyno, Phyctl, phyread(c, phyno, Phyctl) | Ran | Ean);
1275 next:
1276                 e->link = (phy & Rtlink) != 0;
1277                 if (e->link == 0)
1278                         i = 3;
1279                 c->speeds[i]++;
1280                 e->mbps = speedtab[i];
1281                 if (c->type == i82563)
1282                         phyerrata(e, c, phyno);
1283                 c->lim = 0;
1284                 i82563im(c, Lsc);
1285                 c->lsleep++;
1286                 rendez_sleep(&c->lrendez, i82563lim, c);
1287         }
1288 }
1289
1290 static void pcslproc(void *v)
1291 {
1292         unsigned int i, phy;
1293         struct ctlr *c;
1294         struct ether *e;
1295
1296         e = v;
1297         c = e->ctlr;
1298
1299         if (c->type == i82575 || c->type == i82576)
1300                 csr32w(c, Connsw, Enrgirq);
1301         for (;;) {
1302                 phy = csr32r(c, Pcsstat);
1303                 e->link = phy & Linkok;
1304                 i = 3;
1305                 if (e->link)
1306                         i = (phy & 6) >> 1;
1307                 else if (phy & Anbad)
1308                         csr32w(c, Pcsctl, csr32r(c, Pcsctl) | Pan | Prestart);
1309                 c->speeds[i]++;
1310                 e->mbps = speedtab[i];
1311                 c->lim = 0;
1312                 i82563im(c, Lsc | Omed);
1313                 c->lsleep++;
1314                 rendez_sleep(&c->lrendez, i82563lim, c);
1315         }
1316 }
1317
1318 static void serdeslproc(void *v)
1319 {
1320         unsigned int i, tx, rx;
1321         struct ctlr *c;
1322         struct ether *e;
1323
1324         e = v;
1325         c = e->ctlr;
1326
1327         for (;;) {
1328                 rx = csr32r(c, Rxcw);
1329                 tx = csr32r(c, Txcw);
1330                 e->link = (rx & 1 << 31) != 0;
1331 //      e->netif.link = (csr32r(c, Status) & Lu) != 0;
1332                 i = 3;
1333                 if (e->link)
1334                         i = 2;
1335                 c->speeds[i]++;
1336                 e->mbps = speedtab[i];
1337                 c->lim = 0;
1338                 i82563im(c, Lsc);
1339                 c->lsleep++;
1340                 rendez_sleep(&c->lrendez, i82563lim, c);
1341         }
1342 }
1343
1344 static void i82563attach(struct ether *edev)
1345 {
1346         ERRSTACK(1);
1347         char *lname, *rname, *tname;
1348         int i;
1349         struct block *bp;
1350         struct ctlr *ctlr;
1351
1352         ctlr = edev->ctlr;
1353         qlock(&ctlr->alock);
1354         if (ctlr->alloc != NULL) {
1355                 qunlock(&ctlr->alock);
1356                 return;
1357         }
1358
1359         ctlr->nrd = Nrd;
1360         ctlr->ntd = Ntd;
1361         ctlr->alloc =
1362                 kzmalloc(ctlr->nrd * sizeof(Rd) + ctlr->ntd * sizeof(Td) + 255, 0);
1363         if (ctlr->alloc == NULL) {
1364                 qunlock(&ctlr->alock);
1365                 error(Enomem);
1366         }
1367         ctlr->rdba = (Rd *) ROUNDUP((uintptr_t) ctlr->alloc, 256);
1368         ctlr->tdba = (Td *) (ctlr->rdba + ctlr->nrd);
1369
1370         ctlr->rb = kzmalloc(ctlr->nrd * sizeof(struct block *), 0);
1371         ctlr->tb = kzmalloc(ctlr->ntd * sizeof(struct block *), 0);
1372
1373         if (waserror()) {
1374                 kfree(ctlr->tb);
1375                 ctlr->tb = NULL;
1376                 kfree(ctlr->rb);
1377                 ctlr->rb = NULL;
1378                 kfree(ctlr->alloc);
1379                 ctlr->alloc = NULL;
1380                 qunlock(&ctlr->alock);
1381                 nexterror();
1382         }
1383
1384         /* the ktasks should free these names, if they ever exit */
1385         lname = kmalloc(KNAMELEN, KMALLOC_WAIT);
1386         rname = kmalloc(KNAMELEN, KMALLOC_WAIT);
1387         tname = kmalloc(KNAMELEN, KMALLOC_WAIT);
1388
1389         snprintf(lname, KNAMELEN, "#l%dlproc", edev->ctlrno);
1390
1391         if (csr32r(ctlr, Status) & Tbimode)
1392                 ktask(lname, serdeslproc, edev);        /* mac based serdes */
1393         else if ((csr32r(ctlr, Ctrlext) & Linkmode) == Serdes)
1394                 ktask(lname, pcslproc, edev);   /* phy based serdes */
1395         else if (cttab[ctlr->type].flag & F79phy)
1396                 ktask(lname, phyl79proc, edev);
1397         else
1398                 ktask(lname, phylproc, edev);
1399
1400         snprintf(rname, KNAMELEN, "#l%drproc", edev->ctlrno);
1401         ktask(rname, i82563rproc, edev);
1402
1403         snprintf(tname, KNAMELEN, "#l%dtproc", edev->ctlrno);
1404         ktask(tname, i82563tproc, edev);
1405
1406         qunlock(&ctlr->alock);
1407         poperror();
1408 }
1409
1410 static void i82563interrupt(struct hw_trapframe *hw_tf, void *arg)
1411 {
1412         struct ctlr *ctlr;
1413         struct ether *edev;
1414         uint32_t icr, im;
1415
1416         edev = arg;
1417         ctlr = edev->ctlr;
1418
1419         spin_lock_irqsave(&ctlr->imlock);
1420         csr32w(ctlr, Imc, ~0);
1421         im = ctlr->im;
1422
1423         while ((icr = csr32r(ctlr, Icr)) & ctlr->im) {
1424                 if (icr & (Lsc | Omed)) {
1425                         im &= ~(Lsc | Omed);
1426                         ctlr->lim = icr & (Lsc | Omed);
1427                         rendez_wakeup(&ctlr->lrendez);
1428                         ctlr->lintr++;
1429                 }
1430                 if (icr & (Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack)) {
1431                         ctlr->rim = icr & (Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack);
1432                         im &= ~(Rxt0 | Rxo | Rxdmt0 | Rxseq | Ack);
1433                         rendez_wakeup(&ctlr->rrendez);
1434                         ctlr->rintr++;
1435                 }
1436                 if (icr & Txdw) {
1437                         im &= ~Txdw;
1438                         ctlr->tintr++;
1439                         rendez_wakeup(&ctlr->trendez);
1440                 }
1441         }
1442
1443         ctlr->im = im;
1444         csr32w(ctlr, Ims, im);
1445         spin_unlock_irqsave(&ctlr->imlock);
1446 }
1447
1448 static int i82563detach(struct ctlr *ctlr)
1449 {
1450         int r, timeo;
1451
1452         /* balance rx/tx packet buffer; survives reset */
1453         if (ctlr->rbsz > 8192 && cttab[ctlr->type].flag & Fpba) {
1454                 ctlr->pba = csr32r(ctlr, Pba);
1455                 r = ctlr->pba >> 16;
1456                 r += ctlr->pba & 0xffff;
1457                 r >>= 1;
1458                 csr32w(ctlr, Pba, r);
1459         } else if (ctlr->type == i82573 && ctlr->rbsz > 1514)
1460                 csr32w(ctlr, Pba, 14);
1461         ctlr->pba = csr32r(ctlr, Pba);
1462
1463         /*
1464          * Perform a device reset to get the chip back to the
1465          * power-on state, followed by an EEPROM reset to read
1466          * the defaults for some internal registers.
1467          */
1468         csr32w(ctlr, Imc, ~0);
1469         csr32w(ctlr, Rctl, 0);
1470         csr32w(ctlr, Tctl, csr32r(ctlr, Tctl) & ~Ten);
1471
1472         udelay(1000 * 1000);
1473
1474         r = csr32r(ctlr, Ctrl);
1475         if (ctlr->type == i82566 || ctlr->type == i82579)
1476                 r |= Phyrst;
1477         csr32w(ctlr, Ctrl, Devrst | r);
1478         udelay(1000 * 1000);
1479         for (timeo = 0;; timeo++) {
1480                 if ((csr32r(ctlr, Ctrl) & (Devrst | Phyrst)) == 0)
1481                         break;
1482                 if (timeo >= 1000)
1483                         return -1;
1484                 udelay(1000);
1485         }
1486
1487         r = csr32r(ctlr, Ctrl);
1488         csr32w(ctlr, Ctrl, Slu | r);
1489
1490         r = csr32r(ctlr, Ctrlext);
1491         csr32w(ctlr, Ctrlext, r | Eerst);
1492         udelay(1000);
1493         for (timeo = 0; timeo < 1000; timeo++) {
1494                 if (!(csr32r(ctlr, Ctrlext) & Eerst))
1495                         break;
1496                 udelay(1000);
1497         }
1498         if (csr32r(ctlr, Ctrlext) & Eerst)
1499                 return -1;
1500
1501         csr32w(ctlr, Imc, ~0);
1502         udelay(1000);
1503         for (timeo = 0; timeo < 1000; timeo++) {
1504                 if ((csr32r(ctlr, Icr) & ~Rxcfg) == 0)
1505                         break;
1506                 udelay(1000);
1507         }
1508         if (csr32r(ctlr, Icr) & ~Rxcfg)
1509                 return -1;
1510
1511         return 0;
1512 }
1513
1514 static void i82563shutdown(struct ether *edev)
1515 {
1516         i82563detach(edev->ctlr);
1517 }
1518
1519 static uint16_t eeread(struct ctlr *ctlr, int adr)
1520 {
1521         csr32w(ctlr, Eerd, EEstart | adr << 2);
1522         while ((csr32r(ctlr, Eerd) & EEdone) == 0)
1523                 cpu_relax();
1524         return csr32r(ctlr, Eerd) >> 16;
1525 }
1526
1527 static int eeload(struct ctlr *ctlr)
1528 {
1529         uint16_t sum;
1530         int data, adr;
1531
1532         sum = 0;
1533         for (adr = 0; adr < 0x40; adr++) {
1534                 data = eeread(ctlr, adr);
1535                 ctlr->eeprom[adr] = data;
1536                 sum += data;
1537         }
1538         return sum;
1539 }
1540
1541 static int fcycle(struct ctlr *unused, Flash * f)
1542 {
1543         uint16_t s, i;
1544
1545         s = f->reg[Fsts];
1546         if ((s & Fvalid) == 0)
1547                 return -1;
1548         f->reg[Fsts] |= Fcerr | Ael;
1549         for (i = 0; i < 10; i++) {
1550                 if ((s & Scip) == 0)
1551                         return 0;
1552                 udelay(1000);
1553                 s = f->reg[Fsts];
1554         }
1555         return -1;
1556 }
1557
1558 static int fread(struct ctlr *c, Flash * f, int ladr)
1559 {
1560         uint16_t s;
1561
1562         udelay(1000);
1563         if (fcycle(c, f) == -1)
1564                 return -1;
1565         f->reg[Fsts] |= Fdone;
1566         f->reg32[Faddr] = ladr;
1567
1568         /* setup flash control register */
1569         s = f->reg[Fctl] & ~0x3ff;
1570         f->reg[Fctl] = s | 1 << 8 | Fgo;        /* 2 byte read */
1571
1572         while ((f->reg[Fsts] & Fdone) == 0) ;
1573         if (f->reg[Fsts] & (Fcerr | Ael))
1574                 return -1;
1575         return f->reg32[Fdata] & 0xffff;
1576 }
1577
1578 static int fload(struct ctlr *c)
1579 {
1580         unsigned int data, r, adr;
1581         uint16_t sum;
1582         uintptr_t mmio_paddr;
1583         struct pci_device *pcidev = c->pcidev;
1584         Flash f;
1585         mmio_paddr = pcidev->bar[1].mmio_base32 ? pcidev->bar[1].mmio_base32 : 
1586                                                   pcidev->bar[1].mmio_base64;
1587         f.reg = (void*)vmap_pmem(mmio_paddr, pcidev->bar[1].mmio_sz);
1588         if (f.reg == NULL)
1589                 return -1;
1590         f.reg32 = (uint32_t *) f.reg;
1591         f.base = f.reg32[Bfpr] & 0x1fff;
1592         f.lim = f.reg32[Bfpr] >> 16 & 0x1fff;
1593         if (csr32r(c, Eec) & Sec1val)
1594                 f.base += (f.lim + 1) - (f.base >> 1);
1595         r = f.base << 12;
1596         sum = 0;
1597         for (adr = 0; adr < 0x40; adr++) {
1598                 data = fread(c, &f, r + adr * 2);
1599                 if (data == -1)
1600                         return -1;
1601                 c->eeprom[adr] = data;
1602                 sum += data;
1603         }
1604         vunmap_vmem((uintptr_t)f.reg, c->pcidev->bar[1].mmio_sz);
1605         return sum;
1606 }
1607
1608 static void defaultea(struct ctlr *ctlr, uint8_t * ra)
1609 {
1610         unsigned int i, r;
1611         uint64_t u;
1612         static uint8_t NULLea[Eaddrlen];
1613
1614         if (memcmp(ra, NULLea, Eaddrlen) != 0)
1615                 return;
1616         if (cttab[ctlr->type].flag & Fflashea) {
1617                 /* intel mb bug */
1618                 u = (uint64_t) csr32r(ctlr, Rah) << 32u | (unsigned int)csr32r(ctlr,
1619                                                                                                                                            Ral);
1620                 for (i = 0; i < Eaddrlen; i++)
1621                         ra[i] = u >> 8 * i;
1622         }
1623         if (memcmp(ra, NULLea, Eaddrlen) != 0)
1624                 return;
1625         for (i = 0; i < Eaddrlen / 2; i++) {
1626                 ra[2 * i] = ctlr->eeprom[Ea + i];
1627                 ra[2 * i + 1] = ctlr->eeprom[Ea + i] >> 8;
1628         }
1629         r = (csr32r(ctlr, Status) & Lanid) >> 2;
1630         ra[5] += r;     /* ea ctlr[n] = ea ctlr[0]+n */
1631 }
1632
1633 static int i82563reset(struct ctlr *ctlr)
1634 {
1635         uint8_t *ra;
1636         int i, r;
1637
1638         if (i82563detach(ctlr))
1639                 return -1;
1640         if (cttab[ctlr->type].flag & Fload)
1641                 r = fload(ctlr);
1642         else
1643                 r = eeload(ctlr);
1644         if (r != 0 && r != 0xbaba) {
1645                 printd("%s: bad eeprom checksum - %#.4ux\n", cname(ctlr), r);
1646                 return -1;
1647         }
1648
1649         ra = ctlr->ra;
1650         defaultea(ctlr, ra);
1651         csr32w(ctlr, Ral, ra[3] << 24 | ra[2] << 16 | ra[1] << 8 | ra[0]);
1652         csr32w(ctlr, Rah, 1 << 31 | ra[5] << 8 | ra[4]);
1653         for (i = 1; i < 16; i++) {
1654                 csr32w(ctlr, Ral + i * 8, 0);
1655                 csr32w(ctlr, Rah + i * 8, 0);
1656         }
1657         memset(ctlr->mta, 0, sizeof(ctlr->mta));
1658         for (i = 0; i < 128; i++)
1659                 csr32w(ctlr, Mta + i * 4, 0);
1660         csr32w(ctlr, Fcal, 0x00C28001);
1661         csr32w(ctlr, Fcah, 0x0100);
1662         if ((cttab[ctlr->type].flag & Fnofct) == 0)
1663                 csr32w(ctlr, Fct, 0x8808);
1664         csr32w(ctlr, Fcttv, 0x0100);
1665         csr32w(ctlr, Fcrtl, ctlr->fcrtl);
1666         csr32w(ctlr, Fcrth, ctlr->fcrth);
1667         if (cttab[ctlr->type].flag & F75)
1668                 csr32w(ctlr, Eitr, 128 << 2);   /* 128 ¼ microsecond intervals */
1669         return 0;
1670 }
1671
1672 enum {
1673         CMrdtr,
1674         CMradv,
1675         CMpause,
1676         CMan,
1677 };
1678
1679 static struct cmdtab i82563ctlmsg[] = {
1680         {CMrdtr, "rdtr", 2},
1681         {CMradv, "radv", 2},
1682         {CMpause, "pause", 1},
1683         {CMan, "an", 1},
1684 };
1685
1686 static long i82563ctl(struct ether *edev, void *buf, long n)
1687 {
1688         ERRSTACK(1);
1689         char *p;
1690         uint32_t v;
1691         struct ctlr *ctlr;
1692         struct cmdbuf *cb;
1693         struct cmdtab *ct;
1694
1695         if ((ctlr = edev->ctlr) == NULL)
1696                 error(Enonexist);
1697
1698         cb = parsecmd(buf, n);
1699         if (waserror()) {
1700                 kfree(cb);
1701                 nexterror();
1702         }
1703
1704         ct = lookupcmd(cb, i82563ctlmsg, ARRAY_SIZE(i82563ctlmsg));
1705         switch (ct->index) {
1706                 case CMrdtr:
1707                         v = strtoul(cb->f[1], &p, 0);
1708                         if (*p || v > 0xffff)
1709                                 error(Ebadarg);
1710                         ctlr->rdtr = v;
1711                         csr32w(ctlr, Rdtr, v);
1712                         break;
1713                 case CMradv:
1714                         v = strtoul(cb->f[1], &p, 0);
1715                         if (*p || v > 0xffff)
1716                                 error(Ebadarg);
1717                         ctlr->radv = v;
1718                         csr32w(ctlr, Radv, v);
1719                         break;
1720                 case CMpause:
1721                         csr32w(ctlr, Ctrl, csr32r(ctlr, Ctrl) ^ (Rfce | Tfce));
1722                         break;
1723                 case CMan:
1724                         csr32w(ctlr, Ctrl, csr32r(ctlr, Ctrl) | Lrst | Phyrst);
1725                         break;
1726         }
1727         kfree(cb);
1728         poperror();
1729
1730         return n;
1731 }
1732
1733 static int didtype(int d)
1734 {
1735         switch (d) {
1736                 case 0x1096:
1737                 case 0x10ba:    /* “gilgal” */
1738                 case 0x1098:    /* serdes; not seen */
1739                 case 0x10bb:    /* serdes */
1740                         return i82563;
1741                 case 0x1049:    /* mm */
1742                 case 0x104a:    /* dm */
1743                 case 0x104b:    /* dc */
1744                 case 0x104d:    /* v “ninevah” */
1745                 case 0x10bd:    /* dm-2 */
1746                 case 0x294c:    /* ich 9 */
1747                         return i82566;
1748                 case 0x10de:    /* lm ich10d */
1749                 case 0x10df:    /* lf ich10 */
1750                 case 0x10e5:    /* lm ich9 */
1751                 case 0x10f5:    /* lm ich9m; “boazman” */
1752                         return i82567;
1753                 case 0x10bf:    /* lf ich9m */
1754                 case 0x10cb:    /* v ich9m */
1755                 case 0x10cd:    /* lf ich10 */
1756                 case 0x10ce:    /* v ich10 */
1757                 case 0x10cc:    /* lm ich10 */
1758                         return i82567m;
1759                 case 0x105e:    /* eb */
1760                 case 0x105f:    /* eb */
1761                 case 0x1060:    /* eb */
1762                 case 0x10a4:    /* eb */
1763                 case 0x10a5:    /* eb  fiber */
1764                 case 0x10bc:    /* eb */
1765                 case 0x10d9:    /* eb serdes */
1766                 case 0x10da:    /* eb serdes “ophir” */
1767                         return i82571;
1768                 case 0x107d:    /* eb copper */
1769                 case 0x107e:    /* ei fiber */
1770                 case 0x107f:    /* ei */
1771                 case 0x10b9:    /* ei “rimon” */
1772                         return i82572;
1773                 case 0x108b:    /*  e “vidalia” */
1774                 case 0x108c:    /*  e (iamt) */
1775                 case 0x109a:    /*  l “tekoa” */
1776                         return i82573;
1777                 case 0x10d3:    /* l or it; “hartwell” */
1778                         return i82574;
1779                 case 0x10a7:
1780                 case 0x10a9:    /* fiber/serdes */
1781                         return i82575;
1782                 case 0x10c9:    /* copper */
1783                 case 0x10e6:    /* fiber */
1784                 case 0x10e7:    /* serdes; “kawela” */
1785                 case 0x150d:    /* backplane */
1786                         return i82576;
1787                 case 0x10ea:    /* lc “calpella”; aka pch lan */
1788                         return i82577;
1789                 case 0x10eb:    /* lm “calpella” */
1790                         return i82577m;
1791                 case 0x10ef:    /* dc “piketon” */
1792                         return i82578;
1793                 case 0x1502:    /* lm */
1794                 case 0x1503:    /* v “lewisville” */
1795                         return i82579;
1796                 case 0x10f0:    /* dm “king's creek” */
1797                         return i82578m;
1798                 case 0x150e:    /* “barton hills” */
1799                 case 0x150f:    /* fiber */
1800                 case 0x1510:    /* backplane */
1801                 case 0x1511:    /* sfp */
1802                 case 0x1516:
1803                         return i82580;
1804                 case 0x1506:    /* v */
1805                         return i82583;
1806                 case 0x1533:    /* i210-t1 */
1807                 case 0x1534:
1808                 case 0x1536:    /* fiber */
1809                 case 0x1537:    /* backplane */
1810                 case 0x1538:
1811                 case 0x1539:    /* i211 */
1812                         return i210;
1813                 case 0x153a:    /* i217-lm */
1814                 case 0x153b:    /* i217-v */
1815                 case 0x15a0:    /* i218-lm */
1816                 case 0x15a1:    /* i218-v */
1817                 case 0x15a2:    /* i218-lm */
1818                 case 0x15a3:    /* i218-v */
1819                         return i217;
1820                 case 0x151f:    /* “powerville” eeprom-less */
1821                 case 0x1521:    /* copper */
1822                 case 0x1522:    /* fiber */
1823                 case 0x1523:    /* serdes */
1824                 case 0x1524:    /* sgmii */
1825                         return i350;
1826         }
1827         return -1;
1828 }
1829
1830 static void hbafixup(struct pci_device *p)
1831 {
1832         unsigned int i;
1833
1834         i = pcidev_read32(p, PciSVID);
1835         if ((i & 0xffff) == 0x1b52 && p->dev_id == 1)
1836                 p->dev_id = i >> 16;
1837 }
1838
1839 static void i82563pci(void)
1840 {
1841         int type;
1842         struct ctlr *c, **cc;
1843         struct pci_device *p;
1844
1845         cc = &i82563ctlr;
1846         STAILQ_FOREACH(p, &pci_devices, all_dev) {
1847                 if (p->ven_id != 0x8086)
1848                         continue;
1849                 hbafixup(p);
1850                 if ((type = didtype(p->dev_id)) == -1)
1851                         continue;
1852                 c = kzmalloc(sizeof *c, KMALLOC_WAIT);
1853
1854                 qlock_init(&c->alock);
1855                 spinlock_init_irqsave(&c->imlock);
1856                 rendez_init(&c->lrendez);
1857                 qlock_init(&c->slock);
1858                 rendez_init(&c->rrendez);
1859                 rendez_init(&c->trendez);
1860                 qlock_init(&c->tlock);
1861
1862                 c->type = type;
1863                 c->pcidev = p;
1864                 c->rbsz = cttab[type].mtu;
1865                 /* plan9 called this c->port, and just used the top of the raw bar,
1866                  * regardless of the type. */
1867                 c->mmio_paddr = p->bar[0].mmio_base32 ? p->bar[0].mmio_base32 : 
1868                                                         p->bar[0].mmio_base64;
1869                 *cc = c;
1870                 cc = &c->next;
1871         }
1872 }
1873
1874 static int setup(struct ctlr *ctlr)
1875 {
1876         struct pci_device *p;
1877
1878         p = ctlr->pcidev;
1879         ctlr->nic = (void*)vmap_pmem(ctlr->mmio_paddr, p->bar[0].mmio_sz);
1880         if (ctlr->nic == NULL) {
1881                 printd("%s: can't map %p\n", cname(ctlr), ctlr->mmio_paddr);
1882                 return -1;
1883         }
1884         pci_set_bus_master(p);
1885         if (i82563reset(ctlr)) {
1886                 vunmap_vmem((uintptr_t)ctlr->nic, p->bar[0].mmio_sz);
1887                 return -1;
1888         }
1889         return 0;
1890 }
1891
1892 static void i82563_init(void)
1893 {
1894         i82563pci();
1895 }
1896
1897 static int pnp(struct ether *edev, int type)
1898 {
1899         struct ctlr *ctlr;
1900
1901         run_once(i82563_init());
1902
1903         /*
1904          * Any adapter matches if no edev->port is supplied,
1905          * otherwise the ports must match.
1906          */
1907         for (ctlr = i82563ctlr;; ctlr = ctlr->next) {
1908                 if (ctlr == NULL)
1909                         return -1;
1910                 if (ctlr->active)
1911                         continue;
1912                 if (type != -1 && ctlr->type != type)
1913                         continue;
1914                 if (edev->port == 0 || edev->port == ctlr->mmio_paddr) {
1915                         ctlr->active = 1;
1916                         memmove(ctlr->ra, edev->ea, Eaddrlen);
1917                         if (setup(ctlr) == 0)
1918                                 break;
1919                 }
1920         }
1921
1922         edev->ctlr = ctlr;
1923         edev->port = ctlr->mmio_paddr;
1924         edev->irq = ctlr->pcidev->irqline;
1925         edev->tbdf = pci_to_tbdf(ctlr->pcidev);
1926         edev->mbps = 1000;
1927         edev->maxmtu = ctlr->rbsz - ETHERHDRSIZE;       /* MTU doesn't include header */
1928         memmove(edev->ea, ctlr->ra, Eaddrlen);
1929
1930         /*
1931          * Linkage to the generic ethernet driver.
1932          */
1933         edev->attach = i82563attach;
1934         edev->ifstat = i82563ifstat;
1935         edev->ctl = i82563ctl;
1936
1937         edev->arg = edev;
1938         edev->promiscuous = i82563promiscuous;
1939         edev->shutdown = i82563shutdown;
1940         edev->multicast = i82563multicast;
1941
1942         register_irq(edev->irq, i82563interrupt, edev, edev->tbdf);
1943         return 0;
1944 }
1945
1946 static int anypnp(struct ether *e)
1947 {
1948         return pnp(e, -1);
1949 }
1950
1951 linker_func_3(ether82563link)
1952 {
1953         addethercard("i82563", anypnp);
1954 }