if_wm.c revision 1.434 1 /* $NetBSD: if_wm.c,v 1.434 2016/10/28 06:59:08 msaitoh Exp $ */
2
3 /*
4 * Copyright (c) 2001, 2002, 2003, 2004 Wasabi Systems, Inc.
5 * All rights reserved.
6 *
7 * Written by Jason R. Thorpe for Wasabi Systems, Inc.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed for the NetBSD Project by
20 * Wasabi Systems, Inc.
21 * 4. The name of Wasabi Systems, Inc. may not be used to endorse
22 * or promote products derived from this software without specific prior
23 * written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC
29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35 * POSSIBILITY OF SUCH DAMAGE.
36 */
37
38 /*******************************************************************************
39
40 Copyright (c) 2001-2005, Intel Corporation
41 All rights reserved.
42
43 Redistribution and use in source and binary forms, with or without
44 modification, are permitted provided that the following conditions are met:
45
46 1. Redistributions of source code must retain the above copyright notice,
47 this list of conditions and the following disclaimer.
48
49 2. Redistributions in binary form must reproduce the above copyright
50 notice, this list of conditions and the following disclaimer in the
51 documentation and/or other materials provided with the distribution.
52
53 3. Neither the name of the Intel Corporation nor the names of its
54 contributors may be used to endorse or promote products derived from
55 this software without specific prior written permission.
56
57 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
58 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
59 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
60 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
61 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
62 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
63 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
64 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
65 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
66 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
67 POSSIBILITY OF SUCH DAMAGE.
68
69 *******************************************************************************/
70 /*
71 * Device driver for the Intel i8254x family of Gigabit Ethernet chips.
72 *
73 * TODO (in order of importance):
74 *
75 * - Check XXX'ed comments
76 * - Disable D0 LPLU on 8257[12356], 82580 and I350.
77 * - TX Multi queue improvement (refine queue selection logic)
78 * - Advanced Receive Descriptor
79 * - EEE (Energy Efficiency Ethernet)
80 * - Virtual Function
81 * - Set LED correctly (based on contents in EEPROM)
82 * - Rework how parameters are loaded from the EEPROM.
83 * - Image Unique ID
84 */
85
86 #include <sys/cdefs.h>
87 __KERNEL_RCSID(0, "$NetBSD: if_wm.c,v 1.434 2016/10/28 06:59:08 msaitoh Exp $");
88
89 #ifdef _KERNEL_OPT
90 #include "opt_net_mpsafe.h"
91 #endif
92
93 #include <sys/param.h>
94 #include <sys/systm.h>
95 #include <sys/callout.h>
96 #include <sys/mbuf.h>
97 #include <sys/malloc.h>
98 #include <sys/kmem.h>
99 #include <sys/kernel.h>
100 #include <sys/socket.h>
101 #include <sys/ioctl.h>
102 #include <sys/errno.h>
103 #include <sys/device.h>
104 #include <sys/queue.h>
105 #include <sys/syslog.h>
106 #include <sys/interrupt.h>
107 #include <sys/cpu.h>
108 #include <sys/pcq.h>
109
110 #include <sys/rndsource.h>
111
112 #include <net/if.h>
113 #include <net/if_dl.h>
114 #include <net/if_media.h>
115 #include <net/if_ether.h>
116
117 #include <net/bpf.h>
118
119 #include <netinet/in.h> /* XXX for struct ip */
120 #include <netinet/in_systm.h> /* XXX for struct ip */
121 #include <netinet/ip.h> /* XXX for struct ip */
122 #include <netinet/ip6.h> /* XXX for struct ip6_hdr */
123 #include <netinet/tcp.h> /* XXX for struct tcphdr */
124
125 #include <sys/bus.h>
126 #include <sys/intr.h>
127 #include <machine/endian.h>
128
129 #include <dev/mii/mii.h>
130 #include <dev/mii/miivar.h>
131 #include <dev/mii/miidevs.h>
132 #include <dev/mii/mii_bitbang.h>
133 #include <dev/mii/ikphyreg.h>
134 #include <dev/mii/igphyreg.h>
135 #include <dev/mii/igphyvar.h>
136 #include <dev/mii/inbmphyreg.h>
137
138 #include <dev/pci/pcireg.h>
139 #include <dev/pci/pcivar.h>
140 #include <dev/pci/pcidevs.h>
141
142 #include <dev/pci/if_wmreg.h>
143 #include <dev/pci/if_wmvar.h>
144
145 #ifdef WM_DEBUG
146 #define WM_DEBUG_LINK __BIT(0)
147 #define WM_DEBUG_TX __BIT(1)
148 #define WM_DEBUG_RX __BIT(2)
149 #define WM_DEBUG_GMII __BIT(3)
150 #define WM_DEBUG_MANAGE __BIT(4)
151 #define WM_DEBUG_NVM __BIT(5)
152 #define WM_DEBUG_INIT __BIT(6)
153 #define WM_DEBUG_LOCK __BIT(7)
154 int wm_debug = WM_DEBUG_TX | WM_DEBUG_RX | WM_DEBUG_LINK | WM_DEBUG_GMII
155 | WM_DEBUG_MANAGE | WM_DEBUG_NVM | WM_DEBUG_INIT | WM_DEBUG_LOCK;
156
157 #define DPRINTF(x, y) if (wm_debug & (x)) printf y
158 #else
159 #define DPRINTF(x, y) /* nothing */
160 #endif /* WM_DEBUG */
161
162 #ifdef NET_MPSAFE
163 #define WM_MPSAFE 1
164 #endif
165
166 /*
167 * This device driver's max interrupt numbers.
168 */
169 #define WM_MAX_NQUEUEINTR 16
170 #define WM_MAX_NINTR (WM_MAX_NQUEUEINTR + 1)
171
172 /*
173 * Transmit descriptor list size. Due to errata, we can only have
174 * 256 hardware descriptors in the ring on < 82544, but we use 4096
175 * on >= 82544. We tell the upper layers that they can queue a lot
176 * of packets, and we go ahead and manage up to 64 (16 for the i82547)
177 * of them at a time.
178 *
179 * We allow up to 256 (!) DMA segments per packet. Pathological packet
180 * chains containing many small mbufs have been observed in zero-copy
181 * situations with jumbo frames.
182 */
183 #define WM_NTXSEGS 256
184 #define WM_IFQUEUELEN 256
185 #define WM_TXQUEUELEN_MAX 64
186 #define WM_TXQUEUELEN_MAX_82547 16
187 #define WM_TXQUEUELEN(txq) ((txq)->txq_num)
188 #define WM_TXQUEUELEN_MASK(txq) (WM_TXQUEUELEN(txq) - 1)
189 #define WM_TXQUEUE_GC(txq) (WM_TXQUEUELEN(txq) / 8)
190 #define WM_NTXDESC_82542 256
191 #define WM_NTXDESC_82544 4096
192 #define WM_NTXDESC(txq) ((txq)->txq_ndesc)
193 #define WM_NTXDESC_MASK(txq) (WM_NTXDESC(txq) - 1)
194 #define WM_TXDESCS_SIZE(txq) (WM_NTXDESC(txq) * (txq)->txq_descsize)
195 #define WM_NEXTTX(txq, x) (((x) + 1) & WM_NTXDESC_MASK(txq))
196 #define WM_NEXTTXS(txq, x) (((x) + 1) & WM_TXQUEUELEN_MASK(txq))
197
198 #define WM_MAXTXDMA (2 * round_page(IP_MAXPACKET)) /* for TSO */
199
200 #define WM_TXINTERQSIZE 256
201
202 /*
203 * Receive descriptor list size. We have one Rx buffer for normal
204 * sized packets. Jumbo packets consume 5 Rx buffers for a full-sized
205 * packet. We allocate 256 receive descriptors, each with a 2k
206 * buffer (MCLBYTES), which gives us room for 50 jumbo packets.
207 */
208 #define WM_NRXDESC 256
209 #define WM_NRXDESC_MASK (WM_NRXDESC - 1)
210 #define WM_NEXTRX(x) (((x) + 1) & WM_NRXDESC_MASK)
211 #define WM_PREVRX(x) (((x) - 1) & WM_NRXDESC_MASK)
212
213 typedef union txdescs {
214 wiseman_txdesc_t sctxu_txdescs[WM_NTXDESC_82544];
215 nq_txdesc_t sctxu_nq_txdescs[WM_NTXDESC_82544];
216 } txdescs_t;
217
218 #define WM_CDTXOFF(txq, x) ((txq)->txq_descsize * (x))
219 #define WM_CDRXOFF(x) (sizeof(wiseman_rxdesc_t) * x)
220
221 /*
222 * Software state for transmit jobs.
223 */
224 struct wm_txsoft {
225 struct mbuf *txs_mbuf; /* head of our mbuf chain */
226 bus_dmamap_t txs_dmamap; /* our DMA map */
227 int txs_firstdesc; /* first descriptor in packet */
228 int txs_lastdesc; /* last descriptor in packet */
229 int txs_ndesc; /* # of descriptors used */
230 };
231
232 /*
233 * Software state for receive buffers. Each descriptor gets a
234 * 2k (MCLBYTES) buffer and a DMA map. For packets which fill
235 * more than one buffer, we chain them together.
236 */
237 struct wm_rxsoft {
238 struct mbuf *rxs_mbuf; /* head of our mbuf chain */
239 bus_dmamap_t rxs_dmamap; /* our DMA map */
240 };
241
242 #define WM_LINKUP_TIMEOUT 50
243
244 static uint16_t swfwphysem[] = {
245 SWFW_PHY0_SM,
246 SWFW_PHY1_SM,
247 SWFW_PHY2_SM,
248 SWFW_PHY3_SM
249 };
250
251 static const uint32_t wm_82580_rxpbs_table[] = {
252 36, 72, 144, 1, 2, 4, 8, 16, 35, 70, 140
253 };
254
255 struct wm_softc;
256
257 #ifdef WM_EVENT_COUNTERS
258 #define WM_Q_EVCNT_DEFINE(qname, evname) \
259 char qname##_##evname##_evcnt_name[sizeof("qname##XX##evname")]; \
260 struct evcnt qname##_ev_##evname;
261
262 #define WM_Q_EVCNT_ATTACH(qname, evname, q, qnum, xname, evtype) \
263 do{ \
264 snprintf((q)->qname##_##evname##_evcnt_name, \
265 sizeof((q)->qname##_##evname##_evcnt_name), \
266 "%s%02d%s", #qname, (qnum), #evname); \
267 evcnt_attach_dynamic(&(q)->qname##_ev_##evname, \
268 (evtype), NULL, (xname), \
269 (q)->qname##_##evname##_evcnt_name); \
270 }while(0)
271
272 #define WM_Q_MISC_EVCNT_ATTACH(qname, evname, q, qnum, xname) \
273 WM_Q_EVCNT_ATTACH(qname, evname, q, qnum, xname, EVCNT_TYPE_MISC)
274
275 #define WM_Q_INTR_EVCNT_ATTACH(qname, evname, q, qnum, xname) \
276 WM_Q_EVCNT_ATTACH(qname, evname, q, qnum, xname, EVCNT_TYPE_INTR)
277 #endif /* WM_EVENT_COUNTERS */
278
279 struct wm_txqueue {
280 kmutex_t *txq_lock; /* lock for tx operations */
281
282 struct wm_softc *txq_sc; /* shortcut (skip struct wm_queue) */
283
284 /* Software state for the transmit descriptors. */
285 int txq_num; /* must be a power of two */
286 struct wm_txsoft txq_soft[WM_TXQUEUELEN_MAX];
287
288 /* TX control data structures. */
289 int txq_ndesc; /* must be a power of two */
290 size_t txq_descsize; /* a tx descriptor size */
291 txdescs_t *txq_descs_u;
292 bus_dmamap_t txq_desc_dmamap; /* control data DMA map */
293 bus_dma_segment_t txq_desc_seg; /* control data segment */
294 int txq_desc_rseg; /* real number of control segment */
295 #define txq_desc_dma txq_desc_dmamap->dm_segs[0].ds_addr
296 #define txq_descs txq_descs_u->sctxu_txdescs
297 #define txq_nq_descs txq_descs_u->sctxu_nq_txdescs
298
299 bus_addr_t txq_tdt_reg; /* offset of TDT register */
300
301 int txq_free; /* number of free Tx descriptors */
302 int txq_next; /* next ready Tx descriptor */
303
304 int txq_sfree; /* number of free Tx jobs */
305 int txq_snext; /* next free Tx job */
306 int txq_sdirty; /* dirty Tx jobs */
307
308 /* These 4 variables are used only on the 82547. */
309 int txq_fifo_size; /* Tx FIFO size */
310 int txq_fifo_head; /* current head of FIFO */
311 uint32_t txq_fifo_addr; /* internal address of start of FIFO */
312 int txq_fifo_stall; /* Tx FIFO is stalled */
313
314 /*
315 * When ncpu > number of Tx queues, a Tx queue is shared by multiple
316 * CPUs. This queue intermediate them without block.
317 */
318 pcq_t *txq_interq;
319
320 /*
321 * NEWQUEUE devices must use not ifp->if_flags but txq->txq_flags
322 * to manage Tx H/W queue's busy flag.
323 */
324 int txq_flags; /* flags for H/W queue, see below */
325 #define WM_TXQ_NO_SPACE 0x1
326
327 bool txq_stopping;
328
329 #ifdef WM_EVENT_COUNTERS
330 WM_Q_EVCNT_DEFINE(txq, txsstall) /* Tx stalled due to no txs */
331 WM_Q_EVCNT_DEFINE(txq, txdstall) /* Tx stalled due to no txd */
332 WM_Q_EVCNT_DEFINE(txq, txfifo_stall) /* Tx FIFO stalls (82547) */
333 WM_Q_EVCNT_DEFINE(txq, txdw) /* Tx descriptor interrupts */
334 WM_Q_EVCNT_DEFINE(txq, txqe) /* Tx queue empty interrupts */
335 /* XXX not used? */
336
337 WM_Q_EVCNT_DEFINE(txq, txipsum) /* IP checksums comp. out-bound */
338 WM_Q_EVCNT_DEFINE(txq,txtusum) /* TCP/UDP cksums comp. out-bound */
339 WM_Q_EVCNT_DEFINE(txq, txtusum6) /* TCP/UDP v6 cksums comp. out-bound */
340 WM_Q_EVCNT_DEFINE(txq, txtso) /* TCP seg offload out-bound (IPv4) */
341 WM_Q_EVCNT_DEFINE(txq, txtso6) /* TCP seg offload out-bound (IPv6) */
342 WM_Q_EVCNT_DEFINE(txq, txtsopain) /* painful header manip. for TSO */
343
344 WM_Q_EVCNT_DEFINE(txq, txdrop) /* Tx packets dropped(too many segs) */
345
346 WM_Q_EVCNT_DEFINE(txq, tu) /* Tx underrun */
347
348 char txq_txseg_evcnt_names[WM_NTXSEGS][sizeof("txqXXtxsegXXX")];
349 struct evcnt txq_ev_txseg[WM_NTXSEGS]; /* Tx packets w/ N segments */
350 #endif /* WM_EVENT_COUNTERS */
351 };
352
353 struct wm_rxqueue {
354 kmutex_t *rxq_lock; /* lock for rx operations */
355
356 struct wm_softc *rxq_sc; /* shortcut (skip struct wm_queue) */
357
358 /* Software state for the receive descriptors. */
359 wiseman_rxdesc_t *rxq_descs;
360
361 /* RX control data structures. */
362 struct wm_rxsoft rxq_soft[WM_NRXDESC];
363 bus_dmamap_t rxq_desc_dmamap; /* control data DMA map */
364 bus_dma_segment_t rxq_desc_seg; /* control data segment */
365 int rxq_desc_rseg; /* real number of control segment */
366 size_t rxq_desc_size; /* control data size */
367 #define rxq_desc_dma rxq_desc_dmamap->dm_segs[0].ds_addr
368
369 bus_addr_t rxq_rdt_reg; /* offset of RDT register */
370
371 int rxq_ptr; /* next ready Rx desc/queue ent */
372 int rxq_discard;
373 int rxq_len;
374 struct mbuf *rxq_head;
375 struct mbuf *rxq_tail;
376 struct mbuf **rxq_tailp;
377
378 bool rxq_stopping;
379
380 #ifdef WM_EVENT_COUNTERS
381 WM_Q_EVCNT_DEFINE(rxq, rxintr); /* Rx interrupts */
382
383 WM_Q_EVCNT_DEFINE(rxq, rxipsum); /* IP checksums checked in-bound */
384 WM_Q_EVCNT_DEFINE(rxq, rxtusum); /* TCP/UDP cksums checked in-bound */
385 #endif
386 };
387
388 struct wm_queue {
389 int wmq_id; /* index of transmit and receive queues */
390 int wmq_intr_idx; /* index of MSI-X tables */
391
392 struct wm_txqueue wmq_txq;
393 struct wm_rxqueue wmq_rxq;
394 };
395
396 struct wm_phyop {
397 int (*acquire)(struct wm_softc *);
398 void (*release)(struct wm_softc *);
399 };
400
401 /*
402 * Software state per device.
403 */
404 struct wm_softc {
405 device_t sc_dev; /* generic device information */
406 bus_space_tag_t sc_st; /* bus space tag */
407 bus_space_handle_t sc_sh; /* bus space handle */
408 bus_size_t sc_ss; /* bus space size */
409 bus_space_tag_t sc_iot; /* I/O space tag */
410 bus_space_handle_t sc_ioh; /* I/O space handle */
411 bus_size_t sc_ios; /* I/O space size */
412 bus_space_tag_t sc_flasht; /* flash registers space tag */
413 bus_space_handle_t sc_flashh; /* flash registers space handle */
414 bus_size_t sc_flashs; /* flash registers space size */
415 off_t sc_flashreg_offset; /*
416 * offset to flash registers from
417 * start of BAR
418 */
419 bus_dma_tag_t sc_dmat; /* bus DMA tag */
420
421 struct ethercom sc_ethercom; /* ethernet common data */
422 struct mii_data sc_mii; /* MII/media information */
423
424 pci_chipset_tag_t sc_pc;
425 pcitag_t sc_pcitag;
426 int sc_bus_speed; /* PCI/PCIX bus speed */
427 int sc_pcixe_capoff; /* PCI[Xe] capability reg offset */
428
429 uint16_t sc_pcidevid; /* PCI device ID */
430 wm_chip_type sc_type; /* MAC type */
431 int sc_rev; /* MAC revision */
432 wm_phy_type sc_phytype; /* PHY type */
433 uint32_t sc_mediatype; /* Media type (Copper, Fiber, SERDES)*/
434 #define WM_MEDIATYPE_UNKNOWN 0x00
435 #define WM_MEDIATYPE_FIBER 0x01
436 #define WM_MEDIATYPE_COPPER 0x02
437 #define WM_MEDIATYPE_SERDES 0x03 /* Internal SERDES */
438 int sc_funcid; /* unit number of the chip (0 to 3) */
439 int sc_flags; /* flags; see below */
440 int sc_if_flags; /* last if_flags */
441 int sc_flowflags; /* 802.3x flow control flags */
442 int sc_align_tweak;
443
444 void *sc_ihs[WM_MAX_NINTR]; /*
445 * interrupt cookie.
446 * legacy and msi use sc_ihs[0].
447 */
448 pci_intr_handle_t *sc_intrs; /* legacy and msi use sc_intrs[0] */
449 int sc_nintrs; /* number of interrupts */
450
451 int sc_link_intr_idx; /* index of MSI-X tables */
452
453 callout_t sc_tick_ch; /* tick callout */
454 bool sc_core_stopping;
455
456 int sc_nvm_ver_major;
457 int sc_nvm_ver_minor;
458 int sc_nvm_ver_build;
459 int sc_nvm_addrbits; /* NVM address bits */
460 unsigned int sc_nvm_wordsize; /* NVM word size */
461 int sc_ich8_flash_base;
462 int sc_ich8_flash_bank_size;
463 int sc_nvm_k1_enabled;
464
465 int sc_nqueues;
466 struct wm_queue *sc_queue;
467
468 int sc_affinity_offset;
469
470 #ifdef WM_EVENT_COUNTERS
471 /* Event counters. */
472 struct evcnt sc_ev_linkintr; /* Link interrupts */
473
474 /* WM_T_82542_2_1 only */
475 struct evcnt sc_ev_tx_xoff; /* Tx PAUSE(!0) frames */
476 struct evcnt sc_ev_tx_xon; /* Tx PAUSE(0) frames */
477 struct evcnt sc_ev_rx_xoff; /* Rx PAUSE(!0) frames */
478 struct evcnt sc_ev_rx_xon; /* Rx PAUSE(0) frames */
479 struct evcnt sc_ev_rx_macctl; /* Rx Unsupported */
480 #endif /* WM_EVENT_COUNTERS */
481
482 /* This variable are used only on the 82547. */
483 callout_t sc_txfifo_ch; /* Tx FIFO stall work-around timer */
484
485 uint32_t sc_ctrl; /* prototype CTRL register */
486 #if 0
487 uint32_t sc_ctrl_ext; /* prototype CTRL_EXT register */
488 #endif
489 uint32_t sc_icr; /* prototype interrupt bits */
490 uint32_t sc_itr; /* prototype intr throttling reg */
491 uint32_t sc_tctl; /* prototype TCTL register */
492 uint32_t sc_rctl; /* prototype RCTL register */
493 uint32_t sc_txcw; /* prototype TXCW register */
494 uint32_t sc_tipg; /* prototype TIPG register */
495 uint32_t sc_fcrtl; /* prototype FCRTL register */
496 uint32_t sc_pba; /* prototype PBA register */
497
498 int sc_tbi_linkup; /* TBI link status */
499 int sc_tbi_serdes_anegticks; /* autonegotiation ticks */
500 int sc_tbi_serdes_ticks; /* tbi ticks */
501
502 int sc_mchash_type; /* multicast filter offset */
503
504 krndsource_t rnd_source; /* random source */
505
506 struct if_percpuq *sc_ipq; /* softint-based input queues */
507
508 kmutex_t *sc_core_lock; /* lock for softc operations */
509 kmutex_t *sc_ich_phymtx; /*
510 * 82574/82583/ICH/PCH specific PHY
511 * mutex. For 82574/82583, the mutex
512 * is used for both PHY and NVM.
513 */
514 kmutex_t *sc_ich_nvmmtx; /* ICH/PCH specific NVM mutex */
515
516 struct wm_phyop phy;
517 };
518
519 #define WM_CORE_LOCK(_sc) if ((_sc)->sc_core_lock) mutex_enter((_sc)->sc_core_lock)
520 #define WM_CORE_UNLOCK(_sc) if ((_sc)->sc_core_lock) mutex_exit((_sc)->sc_core_lock)
521 #define WM_CORE_LOCKED(_sc) (!(_sc)->sc_core_lock || mutex_owned((_sc)->sc_core_lock))
522
523 #ifdef WM_MPSAFE
524 #define CALLOUT_FLAGS CALLOUT_MPSAFE
525 #else
526 #define CALLOUT_FLAGS 0
527 #endif
528
529 #define WM_RXCHAIN_RESET(rxq) \
530 do { \
531 (rxq)->rxq_tailp = &(rxq)->rxq_head; \
532 *(rxq)->rxq_tailp = NULL; \
533 (rxq)->rxq_len = 0; \
534 } while (/*CONSTCOND*/0)
535
536 #define WM_RXCHAIN_LINK(rxq, m) \
537 do { \
538 *(rxq)->rxq_tailp = (rxq)->rxq_tail = (m); \
539 (rxq)->rxq_tailp = &(m)->m_next; \
540 } while (/*CONSTCOND*/0)
541
542 #ifdef WM_EVENT_COUNTERS
543 #define WM_EVCNT_INCR(ev) (ev)->ev_count++
544 #define WM_EVCNT_ADD(ev, val) (ev)->ev_count += (val)
545
546 #define WM_Q_EVCNT_INCR(qname, evname) \
547 WM_EVCNT_INCR(&(qname)->qname##_ev_##evname)
548 #define WM_Q_EVCNT_ADD(qname, evname, val) \
549 WM_EVCNT_ADD(&(qname)->qname##_ev_##evname, (val))
550 #else /* !WM_EVENT_COUNTERS */
551 #define WM_EVCNT_INCR(ev) /* nothing */
552 #define WM_EVCNT_ADD(ev, val) /* nothing */
553
554 #define WM_Q_EVCNT_INCR(qname, evname) /* nothing */
555 #define WM_Q_EVCNT_ADD(qname, evname, val) /* nothing */
556 #endif /* !WM_EVENT_COUNTERS */
557
558 #define CSR_READ(sc, reg) \
559 bus_space_read_4((sc)->sc_st, (sc)->sc_sh, (reg))
560 #define CSR_WRITE(sc, reg, val) \
561 bus_space_write_4((sc)->sc_st, (sc)->sc_sh, (reg), (val))
562 #define CSR_WRITE_FLUSH(sc) \
563 (void) CSR_READ((sc), WMREG_STATUS)
564
565 #define ICH8_FLASH_READ32(sc, reg) \
566 bus_space_read_4((sc)->sc_flasht, (sc)->sc_flashh, \
567 (reg) + sc->sc_flashreg_offset)
568 #define ICH8_FLASH_WRITE32(sc, reg, data) \
569 bus_space_write_4((sc)->sc_flasht, (sc)->sc_flashh, \
570 (reg) + sc->sc_flashreg_offset, (data))
571
572 #define ICH8_FLASH_READ16(sc, reg) \
573 bus_space_read_2((sc)->sc_flasht, (sc)->sc_flashh, \
574 (reg) + sc->sc_flashreg_offset)
575 #define ICH8_FLASH_WRITE16(sc, reg, data) \
576 bus_space_write_2((sc)->sc_flasht, (sc)->sc_flashh, \
577 (reg) + sc->sc_flashreg_offset, (data))
578
579 #define WM_CDTXADDR(txq, x) ((txq)->txq_desc_dma + WM_CDTXOFF((txq), (x)))
580 #define WM_CDRXADDR(rxq, x) ((rxq)->rxq_desc_dma + WM_CDRXOFF((x)))
581
582 #define WM_CDTXADDR_LO(txq, x) (WM_CDTXADDR((txq), (x)) & 0xffffffffU)
583 #define WM_CDTXADDR_HI(txq, x) \
584 (sizeof(bus_addr_t) == 8 ? \
585 (uint64_t)WM_CDTXADDR((txq), (x)) >> 32 : 0)
586
587 #define WM_CDRXADDR_LO(rxq, x) (WM_CDRXADDR((rxq), (x)) & 0xffffffffU)
588 #define WM_CDRXADDR_HI(rxq, x) \
589 (sizeof(bus_addr_t) == 8 ? \
590 (uint64_t)WM_CDRXADDR((rxq), (x)) >> 32 : 0)
591
592 /*
593 * Register read/write functions.
594 * Other than CSR_{READ|WRITE}().
595 */
596 #if 0
597 static inline uint32_t wm_io_read(struct wm_softc *, int);
598 #endif
599 static inline void wm_io_write(struct wm_softc *, int, uint32_t);
600 static inline void wm_82575_write_8bit_ctlr_reg(struct wm_softc *, uint32_t,
601 uint32_t, uint32_t);
602 static inline void wm_set_dma_addr(volatile wiseman_addr_t *, bus_addr_t);
603
604 /*
605 * Descriptor sync/init functions.
606 */
607 static inline void wm_cdtxsync(struct wm_txqueue *, int, int, int);
608 static inline void wm_cdrxsync(struct wm_rxqueue *, int, int);
609 static inline void wm_init_rxdesc(struct wm_rxqueue *, int);
610
611 /*
612 * Device driver interface functions and commonly used functions.
613 * match, attach, detach, init, start, stop, ioctl, watchdog and so on.
614 */
615 static const struct wm_product *wm_lookup(const struct pci_attach_args *);
616 static int wm_match(device_t, cfdata_t, void *);
617 static void wm_attach(device_t, device_t, void *);
618 static int wm_detach(device_t, int);
619 static bool wm_suspend(device_t, const pmf_qual_t *);
620 static bool wm_resume(device_t, const pmf_qual_t *);
621 static void wm_watchdog(struct ifnet *);
622 static void wm_watchdog_txq(struct ifnet *, struct wm_txqueue *);
623 static void wm_tick(void *);
624 static int wm_ifflags_cb(struct ethercom *);
625 static int wm_ioctl(struct ifnet *, u_long, void *);
626 /* MAC address related */
627 static uint16_t wm_check_alt_mac_addr(struct wm_softc *);
628 static int wm_read_mac_addr(struct wm_softc *, uint8_t *);
629 static void wm_set_ral(struct wm_softc *, const uint8_t *, int);
630 static uint32_t wm_mchash(struct wm_softc *, const uint8_t *);
631 static void wm_set_filter(struct wm_softc *);
632 /* Reset and init related */
633 static void wm_set_vlan(struct wm_softc *);
634 static void wm_set_pcie_completion_timeout(struct wm_softc *);
635 static void wm_get_auto_rd_done(struct wm_softc *);
636 static void wm_lan_init_done(struct wm_softc *);
637 static void wm_get_cfg_done(struct wm_softc *);
638 static void wm_initialize_hardware_bits(struct wm_softc *);
639 static uint32_t wm_rxpbs_adjust_82580(uint32_t);
640 static void wm_reset(struct wm_softc *);
641 static int wm_add_rxbuf(struct wm_rxqueue *, int);
642 static void wm_rxdrain(struct wm_rxqueue *);
643 static void wm_rss_getkey(uint8_t *);
644 static void wm_init_rss(struct wm_softc *);
645 static void wm_adjust_qnum(struct wm_softc *, int);
646 static int wm_setup_legacy(struct wm_softc *);
647 static int wm_setup_msix(struct wm_softc *);
648 static int wm_init(struct ifnet *);
649 static int wm_init_locked(struct ifnet *);
650 static void wm_turnon(struct wm_softc *);
651 static void wm_turnoff(struct wm_softc *);
652 static void wm_stop(struct ifnet *, int);
653 static void wm_stop_locked(struct ifnet *, int);
654 static void wm_dump_mbuf_chain(struct wm_softc *, struct mbuf *);
655 static void wm_82547_txfifo_stall(void *);
656 static int wm_82547_txfifo_bugchk(struct wm_softc *, struct mbuf *);
657 /* DMA related */
658 static int wm_alloc_tx_descs(struct wm_softc *, struct wm_txqueue *);
659 static void wm_free_tx_descs(struct wm_softc *, struct wm_txqueue *);
660 static void wm_init_tx_descs(struct wm_softc *, struct wm_txqueue *);
661 static void wm_init_tx_regs(struct wm_softc *, struct wm_queue *,
662 struct wm_txqueue *);
663 static int wm_alloc_rx_descs(struct wm_softc *, struct wm_rxqueue *);
664 static void wm_free_rx_descs(struct wm_softc *, struct wm_rxqueue *);
665 static void wm_init_rx_regs(struct wm_softc *, struct wm_queue *,
666 struct wm_rxqueue *);
667 static int wm_alloc_tx_buffer(struct wm_softc *, struct wm_txqueue *);
668 static void wm_free_tx_buffer(struct wm_softc *, struct wm_txqueue *);
669 static void wm_init_tx_buffer(struct wm_softc *, struct wm_txqueue *);
670 static int wm_alloc_rx_buffer(struct wm_softc *, struct wm_rxqueue *);
671 static void wm_free_rx_buffer(struct wm_softc *, struct wm_rxqueue *);
672 static int wm_init_rx_buffer(struct wm_softc *, struct wm_rxqueue *);
673 static void wm_init_tx_queue(struct wm_softc *, struct wm_queue *,
674 struct wm_txqueue *);
675 static int wm_init_rx_queue(struct wm_softc *, struct wm_queue *,
676 struct wm_rxqueue *);
677 static int wm_alloc_txrx_queues(struct wm_softc *);
678 static void wm_free_txrx_queues(struct wm_softc *);
679 static int wm_init_txrx_queues(struct wm_softc *);
680 /* Start */
681 static int wm_tx_offload(struct wm_softc *, struct wm_txsoft *,
682 uint32_t *, uint8_t *);
683 static void wm_start(struct ifnet *);
684 static void wm_start_locked(struct ifnet *);
685 static int wm_nq_tx_offload(struct wm_softc *, struct wm_txqueue *,
686 struct wm_txsoft *, uint32_t *, uint32_t *, bool *);
687 static void wm_nq_start(struct ifnet *);
688 static void wm_nq_start_locked(struct ifnet *);
689 static int wm_nq_transmit(struct ifnet *, struct mbuf *);
690 static inline int wm_nq_select_txqueue(struct ifnet *, struct mbuf *);
691 static void wm_nq_transmit_locked(struct ifnet *, struct wm_txqueue *);
692 static void wm_nq_send_common_locked(struct ifnet *, struct wm_txqueue *, bool);
693 /* Interrupt */
694 static int wm_txeof(struct wm_softc *, struct wm_txqueue *);
695 static void wm_rxeof(struct wm_rxqueue *);
696 static void wm_linkintr_gmii(struct wm_softc *, uint32_t);
697 static void wm_linkintr_tbi(struct wm_softc *, uint32_t);
698 static void wm_linkintr_serdes(struct wm_softc *, uint32_t);
699 static void wm_linkintr(struct wm_softc *, uint32_t);
700 static int wm_intr_legacy(void *);
701 static int wm_txrxintr_msix(void *);
702 static int wm_linkintr_msix(void *);
703
704 /*
705 * Media related.
706 * GMII, SGMII, TBI, SERDES and SFP.
707 */
708 /* Common */
709 static void wm_tbi_serdes_set_linkled(struct wm_softc *);
710 /* GMII related */
711 static void wm_gmii_reset(struct wm_softc *);
712 static int wm_get_phy_id_82575(struct wm_softc *);
713 static void wm_gmii_mediainit(struct wm_softc *, pci_product_id_t);
714 static int wm_gmii_mediachange(struct ifnet *);
715 static void wm_gmii_mediastatus(struct ifnet *, struct ifmediareq *);
716 static void wm_i82543_mii_sendbits(struct wm_softc *, uint32_t, int);
717 static uint32_t wm_i82543_mii_recvbits(struct wm_softc *);
718 static int wm_gmii_i82543_readreg(device_t, int, int);
719 static void wm_gmii_i82543_writereg(device_t, int, int, int);
720 static int wm_gmii_mdic_readreg(device_t, int, int);
721 static void wm_gmii_mdic_writereg(device_t, int, int, int);
722 static int wm_gmii_i82544_readreg(device_t, int, int);
723 static void wm_gmii_i82544_writereg(device_t, int, int, int);
724 static int wm_gmii_i80003_readreg(device_t, int, int);
725 static void wm_gmii_i80003_writereg(device_t, int, int, int);
726 static int wm_gmii_bm_readreg(device_t, int, int);
727 static void wm_gmii_bm_writereg(device_t, int, int, int);
728 static void wm_access_phy_wakeup_reg_bm(device_t, int, int16_t *, int);
729 static int wm_gmii_hv_readreg(device_t, int, int);
730 static int wm_gmii_hv_readreg_locked(device_t, int, int);
731 static void wm_gmii_hv_writereg(device_t, int, int, int);
732 static void wm_gmii_hv_writereg_locked(device_t, int, int, int);
733 static int wm_gmii_82580_readreg(device_t, int, int);
734 static void wm_gmii_82580_writereg(device_t, int, int, int);
735 static int wm_gmii_gs40g_readreg(device_t, int, int);
736 static void wm_gmii_gs40g_writereg(device_t, int, int, int);
737 static void wm_gmii_statchg(struct ifnet *);
738 static int wm_kmrn_readreg(struct wm_softc *, int);
739 static int wm_kmrn_readreg_locked(struct wm_softc *, int);
740 static void wm_kmrn_writereg(struct wm_softc *, int, int);
741 static void wm_kmrn_writereg_locked(struct wm_softc *, int, int);
742 /* SGMII */
743 static bool wm_sgmii_uses_mdio(struct wm_softc *);
744 static int wm_sgmii_readreg(device_t, int, int);
745 static void wm_sgmii_writereg(device_t, int, int, int);
746 /* TBI related */
747 static void wm_tbi_mediainit(struct wm_softc *);
748 static int wm_tbi_mediachange(struct ifnet *);
749 static void wm_tbi_mediastatus(struct ifnet *, struct ifmediareq *);
750 static int wm_check_for_link(struct wm_softc *);
751 static void wm_tbi_tick(struct wm_softc *);
752 /* SERDES related */
753 static void wm_serdes_power_up_link_82575(struct wm_softc *);
754 static int wm_serdes_mediachange(struct ifnet *);
755 static void wm_serdes_mediastatus(struct ifnet *, struct ifmediareq *);
756 static void wm_serdes_tick(struct wm_softc *);
757 /* SFP related */
758 static int wm_sfp_read_data_byte(struct wm_softc *, uint16_t, uint8_t *);
759 static uint32_t wm_sfp_get_media_type(struct wm_softc *);
760
761 /*
762 * NVM related.
763 * Microwire, SPI (w/wo EERD) and Flash.
764 */
765 /* Misc functions */
766 static void wm_eeprom_sendbits(struct wm_softc *, uint32_t, int);
767 static void wm_eeprom_recvbits(struct wm_softc *, uint32_t *, int);
768 static int wm_nvm_set_addrbits_size_eecd(struct wm_softc *);
769 /* Microwire */
770 static int wm_nvm_read_uwire(struct wm_softc *, int, int, uint16_t *);
771 /* SPI */
772 static int wm_nvm_ready_spi(struct wm_softc *);
773 static int wm_nvm_read_spi(struct wm_softc *, int, int, uint16_t *);
774 /* Using with EERD */
775 static int wm_poll_eerd_eewr_done(struct wm_softc *, int);
776 static int wm_nvm_read_eerd(struct wm_softc *, int, int, uint16_t *);
777 /* Flash */
778 static int wm_nvm_valid_bank_detect_ich8lan(struct wm_softc *,
779 unsigned int *);
780 static int32_t wm_ich8_cycle_init(struct wm_softc *);
781 static int32_t wm_ich8_flash_cycle(struct wm_softc *, uint32_t);
782 static int32_t wm_read_ich8_data(struct wm_softc *, uint32_t, uint32_t,
783 uint32_t *);
784 static int32_t wm_read_ich8_byte(struct wm_softc *, uint32_t, uint8_t *);
785 static int32_t wm_read_ich8_word(struct wm_softc *, uint32_t, uint16_t *);
786 static int32_t wm_read_ich8_dword(struct wm_softc *, uint32_t, uint32_t *);
787 static int wm_nvm_read_ich8(struct wm_softc *, int, int, uint16_t *);
788 static int wm_nvm_read_spt(struct wm_softc *, int, int, uint16_t *);
789 /* iNVM */
790 static int wm_nvm_read_word_invm(struct wm_softc *, uint16_t, uint16_t *);
791 static int wm_nvm_read_invm(struct wm_softc *, int, int, uint16_t *);
792 /* Lock, detecting NVM type, validate checksum and read */
793 static int wm_nvm_acquire(struct wm_softc *);
794 static void wm_nvm_release(struct wm_softc *);
795 static int wm_nvm_is_onboard_eeprom(struct wm_softc *);
796 static int wm_nvm_get_flash_presence_i210(struct wm_softc *);
797 static int wm_nvm_validate_checksum(struct wm_softc *);
798 static void wm_nvm_version_invm(struct wm_softc *);
799 static void wm_nvm_version(struct wm_softc *);
800 static int wm_nvm_read(struct wm_softc *, int, int, uint16_t *);
801
802 /*
803 * Hardware semaphores.
804 * Very complexed...
805 */
806 static int wm_get_null(struct wm_softc *);
807 static void wm_put_null(struct wm_softc *);
808 static int wm_get_swsm_semaphore(struct wm_softc *); /* 8257[123] */
809 static void wm_put_swsm_semaphore(struct wm_softc *);
810 static int wm_get_swfw_semaphore(struct wm_softc *, uint16_t);
811 static void wm_put_swfw_semaphore(struct wm_softc *, uint16_t);
812 static int wm_get_phy_82575(struct wm_softc *);
813 static void wm_put_phy_82575(struct wm_softc *);
814 static int wm_get_swfwhw_semaphore(struct wm_softc *); /* For 574/583 */
815 static void wm_put_swfwhw_semaphore(struct wm_softc *);
816 static int wm_get_swflag_ich8lan(struct wm_softc *); /* For PHY */
817 static void wm_put_swflag_ich8lan(struct wm_softc *);
818 static int wm_get_nvm_ich8lan(struct wm_softc *); /* For NVM */
819 static void wm_put_nvm_ich8lan(struct wm_softc *);
820 static int wm_get_hw_semaphore_82573(struct wm_softc *);
821 static void wm_put_hw_semaphore_82573(struct wm_softc *);
822
823 /*
824 * Management mode and power management related subroutines.
825 * BMC, AMT, suspend/resume and EEE.
826 */
827 #ifdef WM_WOL
828 static int wm_check_mng_mode(struct wm_softc *);
829 static int wm_check_mng_mode_ich8lan(struct wm_softc *);
830 static int wm_check_mng_mode_82574(struct wm_softc *);
831 static int wm_check_mng_mode_generic(struct wm_softc *);
832 #endif
833 static int wm_enable_mng_pass_thru(struct wm_softc *);
834 static bool wm_phy_resetisblocked(struct wm_softc *);
835 static void wm_get_hw_control(struct wm_softc *);
836 static void wm_release_hw_control(struct wm_softc *);
837 static void wm_gate_hw_phy_config_ich8lan(struct wm_softc *, bool);
838 static void wm_smbustopci(struct wm_softc *);
839 static void wm_init_manageability(struct wm_softc *);
840 static void wm_release_manageability(struct wm_softc *);
841 static void wm_get_wakeup(struct wm_softc *);
842 #ifdef WM_WOL
843 static void wm_enable_phy_wakeup(struct wm_softc *);
844 static void wm_igp3_phy_powerdown_workaround_ich8lan(struct wm_softc *);
845 static void wm_enable_wakeup(struct wm_softc *);
846 #endif
847 /* LPLU (Low Power Link Up) */
848 static void wm_lplu_d0_disable(struct wm_softc *);
849 static void wm_lplu_d0_disable_pch(struct wm_softc *);
850 /* EEE */
851 static void wm_set_eee_i350(struct wm_softc *);
852
853 /*
854 * Workarounds (mainly PHY related).
855 * Basically, PHY's workarounds are in the PHY drivers.
856 */
857 static void wm_kmrn_lock_loss_workaround_ich8lan(struct wm_softc *);
858 static void wm_gig_downshift_workaround_ich8lan(struct wm_softc *);
859 static void wm_hv_phy_workaround_ich8lan(struct wm_softc *);
860 static void wm_lv_phy_workaround_ich8lan(struct wm_softc *);
861 static int wm_k1_gig_workaround_hv(struct wm_softc *, int);
862 static void wm_set_mdio_slow_mode_hv(struct wm_softc *);
863 static void wm_configure_k1_ich8lan(struct wm_softc *, int);
864 static void wm_reset_init_script_82575(struct wm_softc *);
865 static void wm_reset_mdicnfg_82580(struct wm_softc *);
866 static void wm_pll_workaround_i210(struct wm_softc *);
867
868 CFATTACH_DECL3_NEW(wm, sizeof(struct wm_softc),
869 wm_match, wm_attach, wm_detach, NULL, NULL, NULL, DVF_DETACH_SHUTDOWN);
870
871 /*
872 * Devices supported by this driver.
873 */
874 static const struct wm_product {
875 pci_vendor_id_t wmp_vendor;
876 pci_product_id_t wmp_product;
877 const char *wmp_name;
878 wm_chip_type wmp_type;
879 uint32_t wmp_flags;
880 #define WMP_F_UNKNOWN WM_MEDIATYPE_UNKNOWN
881 #define WMP_F_FIBER WM_MEDIATYPE_FIBER
882 #define WMP_F_COPPER WM_MEDIATYPE_COPPER
883 #define WMP_F_SERDES WM_MEDIATYPE_SERDES
884 #define WMP_MEDIATYPE(x) ((x) & 0x03)
885 } wm_products[] = {
886 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82542,
887 "Intel i82542 1000BASE-X Ethernet",
888 WM_T_82542_2_1, WMP_F_FIBER },
889
890 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82543GC_FIBER,
891 "Intel i82543GC 1000BASE-X Ethernet",
892 WM_T_82543, WMP_F_FIBER },
893
894 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82543GC_COPPER,
895 "Intel i82543GC 1000BASE-T Ethernet",
896 WM_T_82543, WMP_F_COPPER },
897
898 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82544EI_COPPER,
899 "Intel i82544EI 1000BASE-T Ethernet",
900 WM_T_82544, WMP_F_COPPER },
901
902 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82544EI_FIBER,
903 "Intel i82544EI 1000BASE-X Ethernet",
904 WM_T_82544, WMP_F_FIBER },
905
906 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82544GC_COPPER,
907 "Intel i82544GC 1000BASE-T Ethernet",
908 WM_T_82544, WMP_F_COPPER },
909
910 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82544GC_LOM,
911 "Intel i82544GC (LOM) 1000BASE-T Ethernet",
912 WM_T_82544, WMP_F_COPPER },
913
914 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82540EM,
915 "Intel i82540EM 1000BASE-T Ethernet",
916 WM_T_82540, WMP_F_COPPER },
917
918 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82540EM_LOM,
919 "Intel i82540EM (LOM) 1000BASE-T Ethernet",
920 WM_T_82540, WMP_F_COPPER },
921
922 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82540EP_LOM,
923 "Intel i82540EP 1000BASE-T Ethernet",
924 WM_T_82540, WMP_F_COPPER },
925
926 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82540EP,
927 "Intel i82540EP 1000BASE-T Ethernet",
928 WM_T_82540, WMP_F_COPPER },
929
930 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82540EP_LP,
931 "Intel i82540EP 1000BASE-T Ethernet",
932 WM_T_82540, WMP_F_COPPER },
933
934 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82545EM_COPPER,
935 "Intel i82545EM 1000BASE-T Ethernet",
936 WM_T_82545, WMP_F_COPPER },
937
938 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82545GM_COPPER,
939 "Intel i82545GM 1000BASE-T Ethernet",
940 WM_T_82545_3, WMP_F_COPPER },
941
942 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82545GM_FIBER,
943 "Intel i82545GM 1000BASE-X Ethernet",
944 WM_T_82545_3, WMP_F_FIBER },
945
946 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82545GM_SERDES,
947 "Intel i82545GM Gigabit Ethernet (SERDES)",
948 WM_T_82545_3, WMP_F_SERDES },
949
950 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82546EB_COPPER,
951 "Intel i82546EB 1000BASE-T Ethernet",
952 WM_T_82546, WMP_F_COPPER },
953
954 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82546EB_QUAD,
955 "Intel i82546EB 1000BASE-T Ethernet",
956 WM_T_82546, WMP_F_COPPER },
957
958 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82545EM_FIBER,
959 "Intel i82545EM 1000BASE-X Ethernet",
960 WM_T_82545, WMP_F_FIBER },
961
962 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82546EB_FIBER,
963 "Intel i82546EB 1000BASE-X Ethernet",
964 WM_T_82546, WMP_F_FIBER },
965
966 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82546GB_COPPER,
967 "Intel i82546GB 1000BASE-T Ethernet",
968 WM_T_82546_3, WMP_F_COPPER },
969
970 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82546GB_FIBER,
971 "Intel i82546GB 1000BASE-X Ethernet",
972 WM_T_82546_3, WMP_F_FIBER },
973
974 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82546GB_SERDES,
975 "Intel i82546GB Gigabit Ethernet (SERDES)",
976 WM_T_82546_3, WMP_F_SERDES },
977
978 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82546GB_QUAD_COPPER,
979 "i82546GB quad-port Gigabit Ethernet",
980 WM_T_82546_3, WMP_F_COPPER },
981
982 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82546GB_QUAD_COPPER_KSP3,
983 "i82546GB quad-port Gigabit Ethernet (KSP3)",
984 WM_T_82546_3, WMP_F_COPPER },
985
986 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82546GB_PCIE,
987 "Intel PRO/1000MT (82546GB)",
988 WM_T_82546_3, WMP_F_COPPER },
989
990 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82541EI,
991 "Intel i82541EI 1000BASE-T Ethernet",
992 WM_T_82541, WMP_F_COPPER },
993
994 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82541ER_LOM,
995 "Intel i82541ER (LOM) 1000BASE-T Ethernet",
996 WM_T_82541, WMP_F_COPPER },
997
998 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82541EI_MOBILE,
999 "Intel i82541EI Mobile 1000BASE-T Ethernet",
1000 WM_T_82541, WMP_F_COPPER },
1001
1002 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82541ER,
1003 "Intel i82541ER 1000BASE-T Ethernet",
1004 WM_T_82541_2, WMP_F_COPPER },
1005
1006 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82541GI,
1007 "Intel i82541GI 1000BASE-T Ethernet",
1008 WM_T_82541_2, WMP_F_COPPER },
1009
1010 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82541GI_MOBILE,
1011 "Intel i82541GI Mobile 1000BASE-T Ethernet",
1012 WM_T_82541_2, WMP_F_COPPER },
1013
1014 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82541PI,
1015 "Intel i82541PI 1000BASE-T Ethernet",
1016 WM_T_82541_2, WMP_F_COPPER },
1017
1018 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82547EI,
1019 "Intel i82547EI 1000BASE-T Ethernet",
1020 WM_T_82547, WMP_F_COPPER },
1021
1022 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82547EI_MOBILE,
1023 "Intel i82547EI Mobile 1000BASE-T Ethernet",
1024 WM_T_82547, WMP_F_COPPER },
1025
1026 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82547GI,
1027 "Intel i82547GI 1000BASE-T Ethernet",
1028 WM_T_82547_2, WMP_F_COPPER },
1029
1030 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82571EB_COPPER,
1031 "Intel PRO/1000 PT (82571EB)",
1032 WM_T_82571, WMP_F_COPPER },
1033
1034 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82571EB_FIBER,
1035 "Intel PRO/1000 PF (82571EB)",
1036 WM_T_82571, WMP_F_FIBER },
1037
1038 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82571EB_SERDES,
1039 "Intel PRO/1000 PB (82571EB)",
1040 WM_T_82571, WMP_F_SERDES },
1041
1042 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82571EB_QUAD_COPPER,
1043 "Intel PRO/1000 QT (82571EB)",
1044 WM_T_82571, WMP_F_COPPER },
1045
1046 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82571GB_QUAD_COPPER,
1047 "Intel PRO/1000 PT Quad Port Server Adapter",
1048 WM_T_82571, WMP_F_COPPER, },
1049
1050 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82571PT_QUAD_COPPER,
1051 "Intel Gigabit PT Quad Port Server ExpressModule",
1052 WM_T_82571, WMP_F_COPPER, },
1053
1054 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82571EB_DUAL_SERDES,
1055 "Intel 82571EB Dual Gigabit Ethernet (SERDES)",
1056 WM_T_82571, WMP_F_SERDES, },
1057
1058 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82571EB_QUAD_SERDES,
1059 "Intel 82571EB Quad Gigabit Ethernet (SERDES)",
1060 WM_T_82571, WMP_F_SERDES, },
1061
1062 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82571EB_QUAD_FIBER,
1063 "Intel 82571EB Quad 1000baseX Ethernet",
1064 WM_T_82571, WMP_F_FIBER, },
1065
1066 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82572EI_COPPER,
1067 "Intel i82572EI 1000baseT Ethernet",
1068 WM_T_82572, WMP_F_COPPER },
1069
1070 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82572EI_FIBER,
1071 "Intel i82572EI 1000baseX Ethernet",
1072 WM_T_82572, WMP_F_FIBER },
1073
1074 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82572EI_SERDES,
1075 "Intel i82572EI Gigabit Ethernet (SERDES)",
1076 WM_T_82572, WMP_F_SERDES },
1077
1078 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82572EI,
1079 "Intel i82572EI 1000baseT Ethernet",
1080 WM_T_82572, WMP_F_COPPER },
1081
1082 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82573E,
1083 "Intel i82573E",
1084 WM_T_82573, WMP_F_COPPER },
1085
1086 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82573E_IAMT,
1087 "Intel i82573E IAMT",
1088 WM_T_82573, WMP_F_COPPER },
1089
1090 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82573L,
1091 "Intel i82573L Gigabit Ethernet",
1092 WM_T_82573, WMP_F_COPPER },
1093
1094 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82574L,
1095 "Intel i82574L",
1096 WM_T_82574, WMP_F_COPPER },
1097
1098 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82574LA,
1099 "Intel i82574L",
1100 WM_T_82574, WMP_F_COPPER },
1101
1102 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82583V,
1103 "Intel i82583V",
1104 WM_T_82583, WMP_F_COPPER },
1105
1106 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_80K3LAN_CPR_DPT,
1107 "i80003 dual 1000baseT Ethernet",
1108 WM_T_80003, WMP_F_COPPER },
1109
1110 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_80K3LAN_FIB_DPT,
1111 "i80003 dual 1000baseX Ethernet",
1112 WM_T_80003, WMP_F_COPPER },
1113
1114 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_80K3LAN_SDS_DPT,
1115 "Intel i80003ES2 dual Gigabit Ethernet (SERDES)",
1116 WM_T_80003, WMP_F_SERDES },
1117
1118 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_80K3LAN_CPR_SPT,
1119 "Intel i80003 1000baseT Ethernet",
1120 WM_T_80003, WMP_F_COPPER },
1121
1122 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_80K3LAN_SDS_SPT,
1123 "Intel i80003 Gigabit Ethernet (SERDES)",
1124 WM_T_80003, WMP_F_SERDES },
1125
1126 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801H_M_AMT,
1127 "Intel i82801H (M_AMT) LAN Controller",
1128 WM_T_ICH8, WMP_F_COPPER },
1129 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801H_AMT,
1130 "Intel i82801H (AMT) LAN Controller",
1131 WM_T_ICH8, WMP_F_COPPER },
1132 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801H_LAN,
1133 "Intel i82801H LAN Controller",
1134 WM_T_ICH8, WMP_F_COPPER },
1135 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801H_IFE_LAN,
1136 "Intel i82801H (IFE) LAN Controller",
1137 WM_T_ICH8, WMP_F_COPPER },
1138 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801H_M_LAN,
1139 "Intel i82801H (M) LAN Controller",
1140 WM_T_ICH8, WMP_F_COPPER },
1141 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801H_IFE_GT,
1142 "Intel i82801H IFE (GT) LAN Controller",
1143 WM_T_ICH8, WMP_F_COPPER },
1144 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801H_IFE_G,
1145 "Intel i82801H IFE (G) LAN Controller",
1146 WM_T_ICH8, WMP_F_COPPER },
1147 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801H_82567V_3,
1148 "82567V-3 LAN Controller",
1149 WM_T_ICH8, WMP_F_COPPER },
1150 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801I_IGP_AMT,
1151 "82801I (AMT) LAN Controller",
1152 WM_T_ICH9, WMP_F_COPPER },
1153 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801I_IFE,
1154 "82801I LAN Controller",
1155 WM_T_ICH9, WMP_F_COPPER },
1156 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801I_IFE_G,
1157 "82801I (G) LAN Controller",
1158 WM_T_ICH9, WMP_F_COPPER },
1159 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801I_IFE_GT,
1160 "82801I (GT) LAN Controller",
1161 WM_T_ICH9, WMP_F_COPPER },
1162 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801I_IGP_C,
1163 "82801I (C) LAN Controller",
1164 WM_T_ICH9, WMP_F_COPPER },
1165 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801I_IGP_M,
1166 "82801I mobile LAN Controller",
1167 WM_T_ICH9, WMP_F_COPPER },
1168 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801H_IGP_M_V,
1169 "82801I mobile (V) LAN Controller",
1170 WM_T_ICH9, WMP_F_COPPER },
1171 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801I_IGP_M_AMT,
1172 "82801I mobile (AMT) LAN Controller",
1173 WM_T_ICH9, WMP_F_COPPER },
1174 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801I_BM,
1175 "82567LM-4 LAN Controller",
1176 WM_T_ICH9, WMP_F_COPPER },
1177 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801J_R_BM_LM,
1178 "82567LM-2 LAN Controller",
1179 WM_T_ICH10, WMP_F_COPPER },
1180 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801J_R_BM_LF,
1181 "82567LF-2 LAN Controller",
1182 WM_T_ICH10, WMP_F_COPPER },
1183 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801J_D_BM_LM,
1184 "82567LM-3 LAN Controller",
1185 WM_T_ICH10, WMP_F_COPPER },
1186 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801J_D_BM_LF,
1187 "82567LF-3 LAN Controller",
1188 WM_T_ICH10, WMP_F_COPPER },
1189 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801J_R_BM_V,
1190 "82567V-2 LAN Controller",
1191 WM_T_ICH10, WMP_F_COPPER },
1192 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82801J_D_BM_V,
1193 "82567V-3? LAN Controller",
1194 WM_T_ICH10, WMP_F_COPPER },
1195 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_HANKSVILLE,
1196 "HANKSVILLE LAN Controller",
1197 WM_T_ICH10, WMP_F_COPPER },
1198 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PCH_M_LM,
1199 "PCH LAN (82577LM) Controller",
1200 WM_T_PCH, WMP_F_COPPER },
1201 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PCH_M_LC,
1202 "PCH LAN (82577LC) Controller",
1203 WM_T_PCH, WMP_F_COPPER },
1204 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PCH_D_DM,
1205 "PCH LAN (82578DM) Controller",
1206 WM_T_PCH, WMP_F_COPPER },
1207 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PCH_D_DC,
1208 "PCH LAN (82578DC) Controller",
1209 WM_T_PCH, WMP_F_COPPER },
1210 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PCH2_LV_LM,
1211 "PCH2 LAN (82579LM) Controller",
1212 WM_T_PCH2, WMP_F_COPPER },
1213 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PCH2_LV_V,
1214 "PCH2 LAN (82579V) Controller",
1215 WM_T_PCH2, WMP_F_COPPER },
1216 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82575EB_COPPER,
1217 "82575EB dual-1000baseT Ethernet",
1218 WM_T_82575, WMP_F_COPPER },
1219 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82575EB_FIBER_SERDES,
1220 "82575EB dual-1000baseX Ethernet (SERDES)",
1221 WM_T_82575, WMP_F_SERDES },
1222 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82575GB_QUAD_COPPER,
1223 "82575GB quad-1000baseT Ethernet",
1224 WM_T_82575, WMP_F_COPPER },
1225 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82575GB_QUAD_COPPER_PM,
1226 "82575GB quad-1000baseT Ethernet (PM)",
1227 WM_T_82575, WMP_F_COPPER },
1228 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82576_COPPER,
1229 "82576 1000BaseT Ethernet",
1230 WM_T_82576, WMP_F_COPPER },
1231 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82576_FIBER,
1232 "82576 1000BaseX Ethernet",
1233 WM_T_82576, WMP_F_FIBER },
1234
1235 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82576_SERDES,
1236 "82576 gigabit Ethernet (SERDES)",
1237 WM_T_82576, WMP_F_SERDES },
1238
1239 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82576_QUAD_COPPER,
1240 "82576 quad-1000BaseT Ethernet",
1241 WM_T_82576, WMP_F_COPPER },
1242
1243 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82576_QUAD_COPPER_ET2,
1244 "82576 Gigabit ET2 Quad Port Server Adapter",
1245 WM_T_82576, WMP_F_COPPER },
1246
1247 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82576_NS,
1248 "82576 gigabit Ethernet",
1249 WM_T_82576, WMP_F_COPPER },
1250
1251 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82576_NS_SERDES,
1252 "82576 gigabit Ethernet (SERDES)",
1253 WM_T_82576, WMP_F_SERDES },
1254 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82576_SERDES_QUAD,
1255 "82576 quad-gigabit Ethernet (SERDES)",
1256 WM_T_82576, WMP_F_SERDES },
1257
1258 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82580_COPPER,
1259 "82580 1000BaseT Ethernet",
1260 WM_T_82580, WMP_F_COPPER },
1261 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82580_FIBER,
1262 "82580 1000BaseX Ethernet",
1263 WM_T_82580, WMP_F_FIBER },
1264
1265 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82580_SERDES,
1266 "82580 1000BaseT Ethernet (SERDES)",
1267 WM_T_82580, WMP_F_SERDES },
1268
1269 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82580_SGMII,
1270 "82580 gigabit Ethernet (SGMII)",
1271 WM_T_82580, WMP_F_COPPER },
1272 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82580_COPPER_DUAL,
1273 "82580 dual-1000BaseT Ethernet",
1274 WM_T_82580, WMP_F_COPPER },
1275
1276 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82580_QUAD_FIBER,
1277 "82580 quad-1000BaseX Ethernet",
1278 WM_T_82580, WMP_F_FIBER },
1279
1280 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_DH89XXCC_SGMII,
1281 "DH89XXCC Gigabit Ethernet (SGMII)",
1282 WM_T_82580, WMP_F_COPPER },
1283
1284 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_DH89XXCC_SERDES,
1285 "DH89XXCC Gigabit Ethernet (SERDES)",
1286 WM_T_82580, WMP_F_SERDES },
1287
1288 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_DH89XXCC_BPLANE,
1289 "DH89XXCC 1000BASE-KX Ethernet",
1290 WM_T_82580, WMP_F_SERDES },
1291
1292 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_DH89XXCC_SFP,
1293 "DH89XXCC Gigabit Ethernet (SFP)",
1294 WM_T_82580, WMP_F_SERDES },
1295
1296 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I350_COPPER,
1297 "I350 Gigabit Network Connection",
1298 WM_T_I350, WMP_F_COPPER },
1299
1300 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I350_FIBER,
1301 "I350 Gigabit Fiber Network Connection",
1302 WM_T_I350, WMP_F_FIBER },
1303
1304 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I350_SERDES,
1305 "I350 Gigabit Backplane Connection",
1306 WM_T_I350, WMP_F_SERDES },
1307
1308 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I350_DA4,
1309 "I350 Quad Port Gigabit Ethernet",
1310 WM_T_I350, WMP_F_SERDES },
1311
1312 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I350_SGMII,
1313 "I350 Gigabit Connection",
1314 WM_T_I350, WMP_F_COPPER },
1315
1316 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_C2000_1000KX,
1317 "I354 Gigabit Ethernet (KX)",
1318 WM_T_I354, WMP_F_SERDES },
1319
1320 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_C2000_SGMII,
1321 "I354 Gigabit Ethernet (SGMII)",
1322 WM_T_I354, WMP_F_COPPER },
1323
1324 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_C2000_25GBE,
1325 "I354 Gigabit Ethernet (2.5G)",
1326 WM_T_I354, WMP_F_COPPER },
1327
1328 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I210_T1,
1329 "I210-T1 Ethernet Server Adapter",
1330 WM_T_I210, WMP_F_COPPER },
1331
1332 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I210_COPPER_OEM1,
1333 "I210 Ethernet (Copper OEM)",
1334 WM_T_I210, WMP_F_COPPER },
1335
1336 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I210_COPPER_IT,
1337 "I210 Ethernet (Copper IT)",
1338 WM_T_I210, WMP_F_COPPER },
1339
1340 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I210_COPPER_WOF,
1341 "I210 Ethernet (FLASH less)",
1342 WM_T_I210, WMP_F_COPPER },
1343
1344 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I210_FIBER,
1345 "I210 Gigabit Ethernet (Fiber)",
1346 WM_T_I210, WMP_F_FIBER },
1347
1348 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I210_SERDES,
1349 "I210 Gigabit Ethernet (SERDES)",
1350 WM_T_I210, WMP_F_SERDES },
1351
1352 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I210_SERDES_WOF,
1353 "I210 Gigabit Ethernet (FLASH less)",
1354 WM_T_I210, WMP_F_SERDES },
1355
1356 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I210_SGMII,
1357 "I210 Gigabit Ethernet (SGMII)",
1358 WM_T_I210, WMP_F_COPPER },
1359
1360 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I211_COPPER,
1361 "I211 Ethernet (COPPER)",
1362 WM_T_I211, WMP_F_COPPER },
1363 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I217_V,
1364 "I217 V Ethernet Connection",
1365 WM_T_PCH_LPT, WMP_F_COPPER },
1366 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I217_LM,
1367 "I217 LM Ethernet Connection",
1368 WM_T_PCH_LPT, WMP_F_COPPER },
1369 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I218_V,
1370 "I218 V Ethernet Connection",
1371 WM_T_PCH_LPT, WMP_F_COPPER },
1372 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I218_V2,
1373 "I218 V Ethernet Connection",
1374 WM_T_PCH_LPT, WMP_F_COPPER },
1375 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I218_V3,
1376 "I218 V Ethernet Connection",
1377 WM_T_PCH_LPT, WMP_F_COPPER },
1378 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I218_LM,
1379 "I218 LM Ethernet Connection",
1380 WM_T_PCH_LPT, WMP_F_COPPER },
1381 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I218_LM2,
1382 "I218 LM Ethernet Connection",
1383 WM_T_PCH_LPT, WMP_F_COPPER },
1384 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I218_LM3,
1385 "I218 LM Ethernet Connection",
1386 WM_T_PCH_LPT, WMP_F_COPPER },
1387 #if 0
1388 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I219_V,
1389 "I219 V Ethernet Connection",
1390 WM_T_PCH_SPT, WMP_F_COPPER },
1391 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I219_V2,
1392 "I219 V Ethernet Connection",
1393 WM_T_PCH_SPT, WMP_F_COPPER },
1394 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I219_V4,
1395 "I219 V Ethernet Connection",
1396 WM_T_PCH_SPT, WMP_F_COPPER },
1397 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I219_V5,
1398 "I219 V Ethernet Connection",
1399 WM_T_PCH_SPT, WMP_F_COPPER },
1400 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I219_LM,
1401 "I219 LM Ethernet Connection",
1402 WM_T_PCH_SPT, WMP_F_COPPER },
1403 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I219_LM2,
1404 "I219 LM Ethernet Connection",
1405 WM_T_PCH_SPT, WMP_F_COPPER },
1406 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I219_LM3,
1407 "I219 LM Ethernet Connection",
1408 WM_T_PCH_SPT, WMP_F_COPPER },
1409 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I219_LM4,
1410 "I219 LM Ethernet Connection",
1411 WM_T_PCH_SPT, WMP_F_COPPER },
1412 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_I219_LM5,
1413 "I219 LM Ethernet Connection",
1414 WM_T_PCH_SPT, WMP_F_COPPER },
1415 #endif
1416 { 0, 0,
1417 NULL,
1418 0, 0 },
1419 };
1420
1421 /*
1422 * Register read/write functions.
1423 * Other than CSR_{READ|WRITE}().
1424 */
1425
1426 #if 0 /* Not currently used */
1427 static inline uint32_t
1428 wm_io_read(struct wm_softc *sc, int reg)
1429 {
1430
1431 bus_space_write_4(sc->sc_iot, sc->sc_ioh, 0, reg);
1432 return (bus_space_read_4(sc->sc_iot, sc->sc_ioh, 4));
1433 }
1434 #endif
1435
1436 static inline void
1437 wm_io_write(struct wm_softc *sc, int reg, uint32_t val)
1438 {
1439
1440 bus_space_write_4(sc->sc_iot, sc->sc_ioh, 0, reg);
1441 bus_space_write_4(sc->sc_iot, sc->sc_ioh, 4, val);
1442 }
1443
1444 static inline void
1445 wm_82575_write_8bit_ctlr_reg(struct wm_softc *sc, uint32_t reg, uint32_t off,
1446 uint32_t data)
1447 {
1448 uint32_t regval;
1449 int i;
1450
1451 regval = (data & SCTL_CTL_DATA_MASK) | (off << SCTL_CTL_ADDR_SHIFT);
1452
1453 CSR_WRITE(sc, reg, regval);
1454
1455 for (i = 0; i < SCTL_CTL_POLL_TIMEOUT; i++) {
1456 delay(5);
1457 if (CSR_READ(sc, reg) & SCTL_CTL_READY)
1458 break;
1459 }
1460 if (i == SCTL_CTL_POLL_TIMEOUT) {
1461 aprint_error("%s: WARNING:"
1462 " i82575 reg 0x%08x setup did not indicate ready\n",
1463 device_xname(sc->sc_dev), reg);
1464 }
1465 }
1466
1467 static inline void
1468 wm_set_dma_addr(volatile wiseman_addr_t *wa, bus_addr_t v)
1469 {
1470 wa->wa_low = htole32(v & 0xffffffffU);
1471 if (sizeof(bus_addr_t) == 8)
1472 wa->wa_high = htole32((uint64_t) v >> 32);
1473 else
1474 wa->wa_high = 0;
1475 }
1476
1477 /*
1478 * Descriptor sync/init functions.
1479 */
1480 static inline void
1481 wm_cdtxsync(struct wm_txqueue *txq, int start, int num, int ops)
1482 {
1483 struct wm_softc *sc = txq->txq_sc;
1484
1485 /* If it will wrap around, sync to the end of the ring. */
1486 if ((start + num) > WM_NTXDESC(txq)) {
1487 bus_dmamap_sync(sc->sc_dmat, txq->txq_desc_dmamap,
1488 WM_CDTXOFF(txq, start), txq->txq_descsize *
1489 (WM_NTXDESC(txq) - start), ops);
1490 num -= (WM_NTXDESC(txq) - start);
1491 start = 0;
1492 }
1493
1494 /* Now sync whatever is left. */
1495 bus_dmamap_sync(sc->sc_dmat, txq->txq_desc_dmamap,
1496 WM_CDTXOFF(txq, start), txq->txq_descsize * num, ops);
1497 }
1498
1499 static inline void
1500 wm_cdrxsync(struct wm_rxqueue *rxq, int start, int ops)
1501 {
1502 struct wm_softc *sc = rxq->rxq_sc;
1503
1504 bus_dmamap_sync(sc->sc_dmat, rxq->rxq_desc_dmamap,
1505 WM_CDRXOFF(start), sizeof(wiseman_rxdesc_t), ops);
1506 }
1507
1508 static inline void
1509 wm_init_rxdesc(struct wm_rxqueue *rxq, int start)
1510 {
1511 struct wm_softc *sc = rxq->rxq_sc;
1512 struct wm_rxsoft *rxs = &rxq->rxq_soft[start];
1513 wiseman_rxdesc_t *rxd = &rxq->rxq_descs[start];
1514 struct mbuf *m = rxs->rxs_mbuf;
1515
1516 /*
1517 * Note: We scoot the packet forward 2 bytes in the buffer
1518 * so that the payload after the Ethernet header is aligned
1519 * to a 4-byte boundary.
1520
1521 * XXX BRAINDAMAGE ALERT!
1522 * The stupid chip uses the same size for every buffer, which
1523 * is set in the Receive Control register. We are using the 2K
1524 * size option, but what we REALLY want is (2K - 2)! For this
1525 * reason, we can't "scoot" packets longer than the standard
1526 * Ethernet MTU. On strict-alignment platforms, if the total
1527 * size exceeds (2K - 2) we set align_tweak to 0 and let
1528 * the upper layer copy the headers.
1529 */
1530 m->m_data = m->m_ext.ext_buf + sc->sc_align_tweak;
1531
1532 wm_set_dma_addr(&rxd->wrx_addr,
1533 rxs->rxs_dmamap->dm_segs[0].ds_addr + sc->sc_align_tweak);
1534 rxd->wrx_len = 0;
1535 rxd->wrx_cksum = 0;
1536 rxd->wrx_status = 0;
1537 rxd->wrx_errors = 0;
1538 rxd->wrx_special = 0;
1539 wm_cdrxsync(rxq, start, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1540
1541 CSR_WRITE(sc, rxq->rxq_rdt_reg, start);
1542 }
1543
1544 /*
1545 * Device driver interface functions and commonly used functions.
1546 * match, attach, detach, init, start, stop, ioctl, watchdog and so on.
1547 */
1548
1549 /* Lookup supported device table */
1550 static const struct wm_product *
1551 wm_lookup(const struct pci_attach_args *pa)
1552 {
1553 const struct wm_product *wmp;
1554
1555 for (wmp = wm_products; wmp->wmp_name != NULL; wmp++) {
1556 if (PCI_VENDOR(pa->pa_id) == wmp->wmp_vendor &&
1557 PCI_PRODUCT(pa->pa_id) == wmp->wmp_product)
1558 return wmp;
1559 }
1560 return NULL;
1561 }
1562
1563 /* The match function (ca_match) */
1564 static int
1565 wm_match(device_t parent, cfdata_t cf, void *aux)
1566 {
1567 struct pci_attach_args *pa = aux;
1568
1569 if (wm_lookup(pa) != NULL)
1570 return 1;
1571
1572 return 0;
1573 }
1574
1575 /* The attach function (ca_attach) */
1576 static void
1577 wm_attach(device_t parent, device_t self, void *aux)
1578 {
1579 struct wm_softc *sc = device_private(self);
1580 struct pci_attach_args *pa = aux;
1581 prop_dictionary_t dict;
1582 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
1583 pci_chipset_tag_t pc = pa->pa_pc;
1584 int counts[PCI_INTR_TYPE_SIZE];
1585 pci_intr_type_t max_type;
1586 const char *eetype, *xname;
1587 bus_space_tag_t memt;
1588 bus_space_handle_t memh;
1589 bus_size_t memsize;
1590 int memh_valid;
1591 int i, error;
1592 const struct wm_product *wmp;
1593 prop_data_t ea;
1594 prop_number_t pn;
1595 uint8_t enaddr[ETHER_ADDR_LEN];
1596 uint16_t cfg1, cfg2, swdpin, nvmword;
1597 pcireg_t preg, memtype;
1598 uint16_t eeprom_data, apme_mask;
1599 bool force_clear_smbi;
1600 uint32_t link_mode;
1601 uint32_t reg;
1602
1603 sc->sc_dev = self;
1604 callout_init(&sc->sc_tick_ch, CALLOUT_FLAGS);
1605 sc->sc_core_stopping = false;
1606
1607 wmp = wm_lookup(pa);
1608 #ifdef DIAGNOSTIC
1609 if (wmp == NULL) {
1610 printf("\n");
1611 panic("wm_attach: impossible");
1612 }
1613 #endif
1614 sc->sc_mediatype = WMP_MEDIATYPE(wmp->wmp_flags);
1615
1616 sc->sc_pc = pa->pa_pc;
1617 sc->sc_pcitag = pa->pa_tag;
1618
1619 if (pci_dma64_available(pa))
1620 sc->sc_dmat = pa->pa_dmat64;
1621 else
1622 sc->sc_dmat = pa->pa_dmat;
1623
1624 sc->sc_pcidevid = PCI_PRODUCT(pa->pa_id);
1625 sc->sc_rev = PCI_REVISION(pci_conf_read(pc, pa->pa_tag,PCI_CLASS_REG));
1626 pci_aprint_devinfo_fancy(pa, "Ethernet controller", wmp->wmp_name, 1);
1627
1628 sc->sc_type = wmp->wmp_type;
1629
1630 /* Set default function pointers */
1631 sc->phy.acquire = wm_get_null;
1632 sc->phy.release = wm_put_null;
1633
1634 if (sc->sc_type < WM_T_82543) {
1635 if (sc->sc_rev < 2) {
1636 aprint_error_dev(sc->sc_dev,
1637 "i82542 must be at least rev. 2\n");
1638 return;
1639 }
1640 if (sc->sc_rev < 3)
1641 sc->sc_type = WM_T_82542_2_0;
1642 }
1643
1644 /*
1645 * Disable MSI for Errata:
1646 * "Message Signaled Interrupt Feature May Corrupt Write Transactions"
1647 *
1648 * 82544: Errata 25
1649 * 82540: Errata 6 (easy to reproduce device timeout)
1650 * 82545: Errata 4 (easy to reproduce device timeout)
1651 * 82546: Errata 26 (easy to reproduce device timeout)
1652 * 82541: Errata 7 (easy to reproduce device timeout)
1653 *
1654 * "Byte Enables 2 and 3 are not set on MSI writes"
1655 *
1656 * 82571 & 82572: Errata 63
1657 */
1658 if ((sc->sc_type <= WM_T_82541_2) || (sc->sc_type == WM_T_82571)
1659 || (sc->sc_type == WM_T_82572))
1660 pa->pa_flags &= ~PCI_FLAGS_MSI_OKAY;
1661
1662 if ((sc->sc_type == WM_T_82575) || (sc->sc_type == WM_T_82576)
1663 || (sc->sc_type == WM_T_82580)
1664 || (sc->sc_type == WM_T_I350) || (sc->sc_type == WM_T_I354)
1665 || (sc->sc_type == WM_T_I210) || (sc->sc_type == WM_T_I211))
1666 sc->sc_flags |= WM_F_NEWQUEUE;
1667
1668 /* Set device properties (mactype) */
1669 dict = device_properties(sc->sc_dev);
1670 prop_dictionary_set_uint32(dict, "mactype", sc->sc_type);
1671
1672 /*
1673 * Map the device. All devices support memory-mapped acccess,
1674 * and it is really required for normal operation.
1675 */
1676 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, WM_PCI_MMBA);
1677 switch (memtype) {
1678 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT:
1679 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT:
1680 memh_valid = (pci_mapreg_map(pa, WM_PCI_MMBA,
1681 memtype, 0, &memt, &memh, NULL, &memsize) == 0);
1682 break;
1683 default:
1684 memh_valid = 0;
1685 break;
1686 }
1687
1688 if (memh_valid) {
1689 sc->sc_st = memt;
1690 sc->sc_sh = memh;
1691 sc->sc_ss = memsize;
1692 } else {
1693 aprint_error_dev(sc->sc_dev,
1694 "unable to map device registers\n");
1695 return;
1696 }
1697
1698 /*
1699 * In addition, i82544 and later support I/O mapped indirect
1700 * register access. It is not desirable (nor supported in
1701 * this driver) to use it for normal operation, though it is
1702 * required to work around bugs in some chip versions.
1703 */
1704 if (sc->sc_type >= WM_T_82544) {
1705 /* First we have to find the I/O BAR. */
1706 for (i = PCI_MAPREG_START; i < PCI_MAPREG_END; i += 4) {
1707 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, i);
1708 if (memtype == PCI_MAPREG_TYPE_IO)
1709 break;
1710 if (PCI_MAPREG_MEM_TYPE(memtype) ==
1711 PCI_MAPREG_MEM_TYPE_64BIT)
1712 i += 4; /* skip high bits, too */
1713 }
1714 if (i < PCI_MAPREG_END) {
1715 /*
1716 * We found PCI_MAPREG_TYPE_IO. Note that 82580
1717 * (and newer?) chip has no PCI_MAPREG_TYPE_IO.
1718 * It's no problem because newer chips has no this
1719 * bug.
1720 *
1721 * The i8254x doesn't apparently respond when the
1722 * I/O BAR is 0, which looks somewhat like it's not
1723 * been configured.
1724 */
1725 preg = pci_conf_read(pc, pa->pa_tag, i);
1726 if (PCI_MAPREG_MEM_ADDR(preg) == 0) {
1727 aprint_error_dev(sc->sc_dev,
1728 "WARNING: I/O BAR at zero.\n");
1729 } else if (pci_mapreg_map(pa, i, PCI_MAPREG_TYPE_IO,
1730 0, &sc->sc_iot, &sc->sc_ioh,
1731 NULL, &sc->sc_ios) == 0) {
1732 sc->sc_flags |= WM_F_IOH_VALID;
1733 } else {
1734 aprint_error_dev(sc->sc_dev,
1735 "WARNING: unable to map I/O space\n");
1736 }
1737 }
1738
1739 }
1740
1741 /* Enable bus mastering. Disable MWI on the i82542 2.0. */
1742 preg = pci_conf_read(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
1743 preg |= PCI_COMMAND_MASTER_ENABLE;
1744 if (sc->sc_type < WM_T_82542_2_1)
1745 preg &= ~PCI_COMMAND_INVALIDATE_ENABLE;
1746 pci_conf_write(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, preg);
1747
1748 /* power up chip */
1749 if ((error = pci_activate(pa->pa_pc, pa->pa_tag, self,
1750 NULL)) && error != EOPNOTSUPP) {
1751 aprint_error_dev(sc->sc_dev, "cannot activate %d\n", error);
1752 return;
1753 }
1754
1755 wm_adjust_qnum(sc, pci_msix_count(pa->pa_pc, pa->pa_tag));
1756
1757 /* Allocation settings */
1758 max_type = PCI_INTR_TYPE_MSIX;
1759 counts[PCI_INTR_TYPE_MSIX] = sc->sc_nqueues + 1;
1760 counts[PCI_INTR_TYPE_MSI] = 1;
1761 counts[PCI_INTR_TYPE_INTX] = 1;
1762
1763 alloc_retry:
1764 if (pci_intr_alloc(pa, &sc->sc_intrs, counts, max_type) != 0) {
1765 aprint_error_dev(sc->sc_dev, "failed to allocate interrupt\n");
1766 return;
1767 }
1768
1769 if (pci_intr_type(pc, sc->sc_intrs[0]) == PCI_INTR_TYPE_MSIX) {
1770 error = wm_setup_msix(sc);
1771 if (error) {
1772 pci_intr_release(pc, sc->sc_intrs,
1773 counts[PCI_INTR_TYPE_MSIX]);
1774
1775 /* Setup for MSI: Disable MSI-X */
1776 max_type = PCI_INTR_TYPE_MSI;
1777 counts[PCI_INTR_TYPE_MSI] = 1;
1778 counts[PCI_INTR_TYPE_INTX] = 1;
1779 goto alloc_retry;
1780 }
1781 } else if (pci_intr_type(pc, sc->sc_intrs[0]) == PCI_INTR_TYPE_MSI) {
1782 wm_adjust_qnum(sc, 0); /* must not use multiqueue */
1783 error = wm_setup_legacy(sc);
1784 if (error) {
1785 pci_intr_release(sc->sc_pc, sc->sc_intrs,
1786 counts[PCI_INTR_TYPE_MSI]);
1787
1788 /* The next try is for INTx: Disable MSI */
1789 max_type = PCI_INTR_TYPE_INTX;
1790 counts[PCI_INTR_TYPE_INTX] = 1;
1791 goto alloc_retry;
1792 }
1793 } else {
1794 wm_adjust_qnum(sc, 0); /* must not use multiqueue */
1795 error = wm_setup_legacy(sc);
1796 if (error) {
1797 pci_intr_release(sc->sc_pc, sc->sc_intrs,
1798 counts[PCI_INTR_TYPE_INTX]);
1799 return;
1800 }
1801 }
1802
1803 /*
1804 * Check the function ID (unit number of the chip).
1805 */
1806 if ((sc->sc_type == WM_T_82546) || (sc->sc_type == WM_T_82546_3)
1807 || (sc->sc_type == WM_T_82571) || (sc->sc_type == WM_T_80003)
1808 || (sc->sc_type == WM_T_82575) || (sc->sc_type == WM_T_82576)
1809 || (sc->sc_type == WM_T_82580)
1810 || (sc->sc_type == WM_T_I350) || (sc->sc_type == WM_T_I354))
1811 sc->sc_funcid = (CSR_READ(sc, WMREG_STATUS)
1812 >> STATUS_FUNCID_SHIFT) & STATUS_FUNCID_MASK;
1813 else
1814 sc->sc_funcid = 0;
1815
1816 /*
1817 * Determine a few things about the bus we're connected to.
1818 */
1819 if (sc->sc_type < WM_T_82543) {
1820 /* We don't really know the bus characteristics here. */
1821 sc->sc_bus_speed = 33;
1822 } else if (sc->sc_type == WM_T_82547 || sc->sc_type == WM_T_82547_2) {
1823 /*
1824 * CSA (Communication Streaming Architecture) is about as fast
1825 * a 32-bit 66MHz PCI Bus.
1826 */
1827 sc->sc_flags |= WM_F_CSA;
1828 sc->sc_bus_speed = 66;
1829 aprint_verbose_dev(sc->sc_dev,
1830 "Communication Streaming Architecture\n");
1831 if (sc->sc_type == WM_T_82547) {
1832 callout_init(&sc->sc_txfifo_ch, CALLOUT_FLAGS);
1833 callout_setfunc(&sc->sc_txfifo_ch,
1834 wm_82547_txfifo_stall, sc);
1835 aprint_verbose_dev(sc->sc_dev,
1836 "using 82547 Tx FIFO stall work-around\n");
1837 }
1838 } else if (sc->sc_type >= WM_T_82571) {
1839 sc->sc_flags |= WM_F_PCIE;
1840 if ((sc->sc_type != WM_T_ICH8) && (sc->sc_type != WM_T_ICH9)
1841 && (sc->sc_type != WM_T_ICH10)
1842 && (sc->sc_type != WM_T_PCH)
1843 && (sc->sc_type != WM_T_PCH2)
1844 && (sc->sc_type != WM_T_PCH_LPT)
1845 && (sc->sc_type != WM_T_PCH_SPT)) {
1846 /* ICH* and PCH* have no PCIe capability registers */
1847 if (pci_get_capability(pa->pa_pc, pa->pa_tag,
1848 PCI_CAP_PCIEXPRESS, &sc->sc_pcixe_capoff,
1849 NULL) == 0)
1850 aprint_error_dev(sc->sc_dev,
1851 "unable to find PCIe capability\n");
1852 }
1853 aprint_verbose_dev(sc->sc_dev, "PCI-Express bus\n");
1854 } else {
1855 reg = CSR_READ(sc, WMREG_STATUS);
1856 if (reg & STATUS_BUS64)
1857 sc->sc_flags |= WM_F_BUS64;
1858 if ((reg & STATUS_PCIX_MODE) != 0) {
1859 pcireg_t pcix_cmd, pcix_sts, bytecnt, maxb;
1860
1861 sc->sc_flags |= WM_F_PCIX;
1862 if (pci_get_capability(pa->pa_pc, pa->pa_tag,
1863 PCI_CAP_PCIX, &sc->sc_pcixe_capoff, NULL) == 0)
1864 aprint_error_dev(sc->sc_dev,
1865 "unable to find PCIX capability\n");
1866 else if (sc->sc_type != WM_T_82545_3 &&
1867 sc->sc_type != WM_T_82546_3) {
1868 /*
1869 * Work around a problem caused by the BIOS
1870 * setting the max memory read byte count
1871 * incorrectly.
1872 */
1873 pcix_cmd = pci_conf_read(pa->pa_pc, pa->pa_tag,
1874 sc->sc_pcixe_capoff + PCIX_CMD);
1875 pcix_sts = pci_conf_read(pa->pa_pc, pa->pa_tag,
1876 sc->sc_pcixe_capoff + PCIX_STATUS);
1877
1878 bytecnt = (pcix_cmd & PCIX_CMD_BYTECNT_MASK) >>
1879 PCIX_CMD_BYTECNT_SHIFT;
1880 maxb = (pcix_sts & PCIX_STATUS_MAXB_MASK) >>
1881 PCIX_STATUS_MAXB_SHIFT;
1882 if (bytecnt > maxb) {
1883 aprint_verbose_dev(sc->sc_dev,
1884 "resetting PCI-X MMRBC: %d -> %d\n",
1885 512 << bytecnt, 512 << maxb);
1886 pcix_cmd = (pcix_cmd &
1887 ~PCIX_CMD_BYTECNT_MASK) |
1888 (maxb << PCIX_CMD_BYTECNT_SHIFT);
1889 pci_conf_write(pa->pa_pc, pa->pa_tag,
1890 sc->sc_pcixe_capoff + PCIX_CMD,
1891 pcix_cmd);
1892 }
1893 }
1894 }
1895 /*
1896 * The quad port adapter is special; it has a PCIX-PCIX
1897 * bridge on the board, and can run the secondary bus at
1898 * a higher speed.
1899 */
1900 if (wmp->wmp_product == PCI_PRODUCT_INTEL_82546EB_QUAD) {
1901 sc->sc_bus_speed = (sc->sc_flags & WM_F_PCIX) ? 120
1902 : 66;
1903 } else if (sc->sc_flags & WM_F_PCIX) {
1904 switch (reg & STATUS_PCIXSPD_MASK) {
1905 case STATUS_PCIXSPD_50_66:
1906 sc->sc_bus_speed = 66;
1907 break;
1908 case STATUS_PCIXSPD_66_100:
1909 sc->sc_bus_speed = 100;
1910 break;
1911 case STATUS_PCIXSPD_100_133:
1912 sc->sc_bus_speed = 133;
1913 break;
1914 default:
1915 aprint_error_dev(sc->sc_dev,
1916 "unknown PCIXSPD %d; assuming 66MHz\n",
1917 reg & STATUS_PCIXSPD_MASK);
1918 sc->sc_bus_speed = 66;
1919 break;
1920 }
1921 } else
1922 sc->sc_bus_speed = (reg & STATUS_PCI66) ? 66 : 33;
1923 aprint_verbose_dev(sc->sc_dev, "%d-bit %dMHz %s bus\n",
1924 (sc->sc_flags & WM_F_BUS64) ? 64 : 32, sc->sc_bus_speed,
1925 (sc->sc_flags & WM_F_PCIX) ? "PCIX" : "PCI");
1926 }
1927
1928 /* clear interesting stat counters */
1929 CSR_READ(sc, WMREG_COLC);
1930 CSR_READ(sc, WMREG_RXERRC);
1931
1932 /* get PHY control from SMBus to PCIe */
1933 if ((sc->sc_type == WM_T_PCH) || (sc->sc_type == WM_T_PCH2)
1934 || (sc->sc_type == WM_T_PCH_LPT) || (sc->sc_type == WM_T_PCH_SPT))
1935 wm_smbustopci(sc);
1936
1937 if ((sc->sc_type == WM_T_82574) || (sc->sc_type == WM_T_82583)
1938 || (sc->sc_type >= WM_T_ICH8))
1939 sc->sc_ich_phymtx = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NET);
1940 if (sc->sc_type >= WM_T_ICH8)
1941 sc->sc_ich_nvmmtx = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NET);
1942
1943 /* Set PHY, NVM mutex related stuff */
1944 switch (sc->sc_type) {
1945 case WM_T_82542_2_0:
1946 case WM_T_82542_2_1:
1947 case WM_T_82543:
1948 case WM_T_82544:
1949 /* Microwire */
1950 sc->sc_nvm_wordsize = 64;
1951 sc->sc_nvm_addrbits = 6;
1952 break;
1953 case WM_T_82540:
1954 case WM_T_82545:
1955 case WM_T_82545_3:
1956 case WM_T_82546:
1957 case WM_T_82546_3:
1958 /* Microwire */
1959 reg = CSR_READ(sc, WMREG_EECD);
1960 if (reg & EECD_EE_SIZE) {
1961 sc->sc_nvm_wordsize = 256;
1962 sc->sc_nvm_addrbits = 8;
1963 } else {
1964 sc->sc_nvm_wordsize = 64;
1965 sc->sc_nvm_addrbits = 6;
1966 }
1967 sc->sc_flags |= WM_F_LOCK_EECD;
1968 break;
1969 case WM_T_82541:
1970 case WM_T_82541_2:
1971 case WM_T_82547:
1972 case WM_T_82547_2:
1973 sc->sc_flags |= WM_F_LOCK_EECD;
1974 reg = CSR_READ(sc, WMREG_EECD);
1975 if (reg & EECD_EE_TYPE) {
1976 /* SPI */
1977 sc->sc_flags |= WM_F_EEPROM_SPI;
1978 wm_nvm_set_addrbits_size_eecd(sc);
1979 } else {
1980 /* Microwire */
1981 if ((reg & EECD_EE_ABITS) != 0) {
1982 sc->sc_nvm_wordsize = 256;
1983 sc->sc_nvm_addrbits = 8;
1984 } else {
1985 sc->sc_nvm_wordsize = 64;
1986 sc->sc_nvm_addrbits = 6;
1987 }
1988 }
1989 break;
1990 case WM_T_82571:
1991 case WM_T_82572:
1992 /* SPI */
1993 sc->sc_flags |= WM_F_EEPROM_SPI;
1994 wm_nvm_set_addrbits_size_eecd(sc);
1995 sc->sc_flags |= WM_F_LOCK_EECD | WM_F_LOCK_SWSM;
1996 sc->phy.acquire = wm_get_swsm_semaphore;
1997 sc->phy.release = wm_put_swsm_semaphore;
1998 break;
1999 case WM_T_82573:
2000 case WM_T_82574:
2001 case WM_T_82583:
2002 if (sc->sc_type == WM_T_82573) {
2003 sc->sc_flags |= WM_F_LOCK_SWSM;
2004 sc->phy.acquire = wm_get_swsm_semaphore;
2005 sc->phy.release = wm_put_swsm_semaphore;
2006 } else {
2007 sc->sc_flags |= WM_F_LOCK_EXTCNF;
2008 /* Both PHY and NVM use the same semaphore. */
2009 sc->phy.acquire
2010 = wm_get_swfwhw_semaphore;
2011 sc->phy.release
2012 = wm_put_swfwhw_semaphore;
2013 }
2014 if (wm_nvm_is_onboard_eeprom(sc) == 0) {
2015 sc->sc_flags |= WM_F_EEPROM_FLASH;
2016 sc->sc_nvm_wordsize = 2048;
2017 } else {
2018 /* SPI */
2019 sc->sc_flags |= WM_F_EEPROM_SPI;
2020 wm_nvm_set_addrbits_size_eecd(sc);
2021 }
2022 sc->sc_flags |= WM_F_EEPROM_EERDEEWR;
2023 break;
2024 case WM_T_82575:
2025 case WM_T_82576:
2026 case WM_T_82580:
2027 case WM_T_I350:
2028 case WM_T_I354:
2029 case WM_T_80003:
2030 /* SPI */
2031 sc->sc_flags |= WM_F_EEPROM_SPI;
2032 wm_nvm_set_addrbits_size_eecd(sc);
2033 sc->sc_flags |= WM_F_EEPROM_EERDEEWR | WM_F_LOCK_SWFW
2034 | WM_F_LOCK_SWSM;
2035 sc->phy.acquire = wm_get_phy_82575;
2036 sc->phy.release = wm_put_phy_82575;
2037 break;
2038 case WM_T_ICH8:
2039 case WM_T_ICH9:
2040 case WM_T_ICH10:
2041 case WM_T_PCH:
2042 case WM_T_PCH2:
2043 case WM_T_PCH_LPT:
2044 /* FLASH */
2045 sc->sc_flags |= WM_F_EEPROM_FLASH | WM_F_LOCK_EXTCNF;
2046 sc->sc_nvm_wordsize = 2048;
2047 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag,WM_ICH8_FLASH);
2048 if (pci_mapreg_map(pa, WM_ICH8_FLASH, memtype, 0,
2049 &sc->sc_flasht, &sc->sc_flashh, NULL, &sc->sc_flashs)) {
2050 aprint_error_dev(sc->sc_dev,
2051 "can't map FLASH registers\n");
2052 goto out;
2053 }
2054 reg = ICH8_FLASH_READ32(sc, ICH_FLASH_GFPREG);
2055 sc->sc_ich8_flash_base = (reg & ICH_GFPREG_BASE_MASK) *
2056 ICH_FLASH_SECTOR_SIZE;
2057 sc->sc_ich8_flash_bank_size =
2058 ((reg >> 16) & ICH_GFPREG_BASE_MASK) + 1;
2059 sc->sc_ich8_flash_bank_size -= (reg & ICH_GFPREG_BASE_MASK);
2060 sc->sc_ich8_flash_bank_size *= ICH_FLASH_SECTOR_SIZE;
2061 sc->sc_ich8_flash_bank_size /= 2 * sizeof(uint16_t);
2062 sc->sc_flashreg_offset = 0;
2063 sc->phy.acquire = wm_get_swflag_ich8lan;
2064 sc->phy.release = wm_put_swflag_ich8lan;
2065 break;
2066 case WM_T_PCH_SPT:
2067 /* SPT has no GFPREG; flash registers mapped through BAR0 */
2068 sc->sc_flags |= WM_F_EEPROM_FLASH | WM_F_LOCK_EXTCNF;
2069 sc->sc_flasht = sc->sc_st;
2070 sc->sc_flashh = sc->sc_sh;
2071 sc->sc_ich8_flash_base = 0;
2072 sc->sc_nvm_wordsize =
2073 (((CSR_READ(sc, WMREG_STRAP) >> 1) & 0x1F) + 1)
2074 * NVM_SIZE_MULTIPLIER;
2075 /* It is size in bytes, we want words */
2076 sc->sc_nvm_wordsize /= 2;
2077 /* assume 2 banks */
2078 sc->sc_ich8_flash_bank_size = sc->sc_nvm_wordsize / 2;
2079 sc->sc_flashreg_offset = WM_PCH_SPT_FLASHOFFSET;
2080 sc->phy.acquire = wm_get_swflag_ich8lan;
2081 sc->phy.release = wm_put_swflag_ich8lan;
2082 break;
2083 case WM_T_I210:
2084 case WM_T_I211:
2085 if (wm_nvm_get_flash_presence_i210(sc)) {
2086 wm_nvm_set_addrbits_size_eecd(sc);
2087 sc->sc_flags |= WM_F_EEPROM_FLASH_HW;
2088 sc->sc_flags |= WM_F_EEPROM_EERDEEWR;
2089 } else {
2090 sc->sc_nvm_wordsize = INVM_SIZE;
2091 sc->sc_flags |= WM_F_EEPROM_INVM;
2092 }
2093 sc->sc_flags |= WM_F_LOCK_SWFW | WM_F_LOCK_SWSM;
2094 sc->phy.acquire = wm_get_phy_82575;
2095 sc->phy.release = wm_put_phy_82575;
2096 break;
2097 default:
2098 break;
2099 }
2100
2101 /* Reset the chip to a known state. */
2102 wm_reset(sc);
2103
2104 /* Ensure the SMBI bit is clear before first NVM or PHY access */
2105 switch (sc->sc_type) {
2106 case WM_T_82571:
2107 case WM_T_82572:
2108 reg = CSR_READ(sc, WMREG_SWSM2);
2109 if ((reg & SWSM2_LOCK) == 0) {
2110 CSR_WRITE(sc, WMREG_SWSM2, reg | SWSM2_LOCK);
2111 force_clear_smbi = true;
2112 } else
2113 force_clear_smbi = false;
2114 break;
2115 case WM_T_82573:
2116 case WM_T_82574:
2117 case WM_T_82583:
2118 force_clear_smbi = true;
2119 break;
2120 default:
2121 force_clear_smbi = false;
2122 break;
2123 }
2124 if (force_clear_smbi) {
2125 reg = CSR_READ(sc, WMREG_SWSM);
2126 if ((reg & SWSM_SMBI) != 0)
2127 aprint_error_dev(sc->sc_dev,
2128 "Please update the Bootagent\n");
2129 CSR_WRITE(sc, WMREG_SWSM, reg & ~SWSM_SMBI);
2130 }
2131
2132 /*
2133 * Defer printing the EEPROM type until after verifying the checksum
2134 * This allows the EEPROM type to be printed correctly in the case
2135 * that no EEPROM is attached.
2136 */
2137 /*
2138 * Validate the EEPROM checksum. If the checksum fails, flag
2139 * this for later, so we can fail future reads from the EEPROM.
2140 */
2141 if (wm_nvm_validate_checksum(sc)) {
2142 /*
2143 * Read twice again because some PCI-e parts fail the
2144 * first check due to the link being in sleep state.
2145 */
2146 if (wm_nvm_validate_checksum(sc))
2147 sc->sc_flags |= WM_F_EEPROM_INVALID;
2148 }
2149
2150 /* Set device properties (macflags) */
2151 prop_dictionary_set_uint32(dict, "macflags", sc->sc_flags);
2152
2153 if (sc->sc_flags & WM_F_EEPROM_INVALID)
2154 aprint_verbose_dev(sc->sc_dev, "No EEPROM");
2155 else {
2156 aprint_verbose_dev(sc->sc_dev, "%u words ",
2157 sc->sc_nvm_wordsize);
2158 if (sc->sc_flags & WM_F_EEPROM_INVM)
2159 aprint_verbose("iNVM");
2160 else if (sc->sc_flags & WM_F_EEPROM_FLASH_HW)
2161 aprint_verbose("FLASH(HW)");
2162 else if (sc->sc_flags & WM_F_EEPROM_FLASH)
2163 aprint_verbose("FLASH");
2164 else {
2165 if (sc->sc_flags & WM_F_EEPROM_SPI)
2166 eetype = "SPI";
2167 else
2168 eetype = "MicroWire";
2169 aprint_verbose("(%d address bits) %s EEPROM",
2170 sc->sc_nvm_addrbits, eetype);
2171 }
2172 }
2173 wm_nvm_version(sc);
2174 aprint_verbose("\n");
2175
2176 /* Check for I21[01] PLL workaround */
2177 if (sc->sc_type == WM_T_I210)
2178 sc->sc_flags |= WM_F_PLL_WA_I210;
2179 if ((sc->sc_type == WM_T_I210) && wm_nvm_get_flash_presence_i210(sc)) {
2180 /* NVM image release 3.25 has a workaround */
2181 if ((sc->sc_nvm_ver_major < 3)
2182 || ((sc->sc_nvm_ver_major == 3)
2183 && (sc->sc_nvm_ver_minor < 25))) {
2184 aprint_verbose_dev(sc->sc_dev,
2185 "ROM image version %d.%d is older than 3.25\n",
2186 sc->sc_nvm_ver_major, sc->sc_nvm_ver_minor);
2187 sc->sc_flags |= WM_F_PLL_WA_I210;
2188 }
2189 }
2190 if ((sc->sc_flags & WM_F_PLL_WA_I210) != 0)
2191 wm_pll_workaround_i210(sc);
2192
2193 wm_get_wakeup(sc);
2194 switch (sc->sc_type) {
2195 case WM_T_82571:
2196 case WM_T_82572:
2197 case WM_T_82573:
2198 case WM_T_82574:
2199 case WM_T_82583:
2200 case WM_T_80003:
2201 case WM_T_ICH8:
2202 case WM_T_ICH9:
2203 case WM_T_ICH10:
2204 case WM_T_PCH:
2205 case WM_T_PCH2:
2206 case WM_T_PCH_LPT:
2207 case WM_T_PCH_SPT:
2208 /* Non-AMT based hardware can now take control from firmware */
2209 if ((sc->sc_flags & WM_F_HAS_AMT) == 0)
2210 wm_get_hw_control(sc);
2211 break;
2212 default:
2213 break;
2214 }
2215
2216 /*
2217 * Read the Ethernet address from the EEPROM, if not first found
2218 * in device properties.
2219 */
2220 ea = prop_dictionary_get(dict, "mac-address");
2221 if (ea != NULL) {
2222 KASSERT(prop_object_type(ea) == PROP_TYPE_DATA);
2223 KASSERT(prop_data_size(ea) == ETHER_ADDR_LEN);
2224 memcpy(enaddr, prop_data_data_nocopy(ea), ETHER_ADDR_LEN);
2225 } else {
2226 if (wm_read_mac_addr(sc, enaddr) != 0) {
2227 aprint_error_dev(sc->sc_dev,
2228 "unable to read Ethernet address\n");
2229 goto out;
2230 }
2231 }
2232
2233 aprint_normal_dev(sc->sc_dev, "Ethernet address %s\n",
2234 ether_sprintf(enaddr));
2235
2236 /*
2237 * Read the config info from the EEPROM, and set up various
2238 * bits in the control registers based on their contents.
2239 */
2240 pn = prop_dictionary_get(dict, "i82543-cfg1");
2241 if (pn != NULL) {
2242 KASSERT(prop_object_type(pn) == PROP_TYPE_NUMBER);
2243 cfg1 = (uint16_t) prop_number_integer_value(pn);
2244 } else {
2245 if (wm_nvm_read(sc, NVM_OFF_CFG1, 1, &cfg1)) {
2246 aprint_error_dev(sc->sc_dev, "unable to read CFG1\n");
2247 goto out;
2248 }
2249 }
2250
2251 pn = prop_dictionary_get(dict, "i82543-cfg2");
2252 if (pn != NULL) {
2253 KASSERT(prop_object_type(pn) == PROP_TYPE_NUMBER);
2254 cfg2 = (uint16_t) prop_number_integer_value(pn);
2255 } else {
2256 if (wm_nvm_read(sc, NVM_OFF_CFG2, 1, &cfg2)) {
2257 aprint_error_dev(sc->sc_dev, "unable to read CFG2\n");
2258 goto out;
2259 }
2260 }
2261
2262 /* check for WM_F_WOL */
2263 switch (sc->sc_type) {
2264 case WM_T_82542_2_0:
2265 case WM_T_82542_2_1:
2266 case WM_T_82543:
2267 /* dummy? */
2268 eeprom_data = 0;
2269 apme_mask = NVM_CFG3_APME;
2270 break;
2271 case WM_T_82544:
2272 apme_mask = NVM_CFG2_82544_APM_EN;
2273 eeprom_data = cfg2;
2274 break;
2275 case WM_T_82546:
2276 case WM_T_82546_3:
2277 case WM_T_82571:
2278 case WM_T_82572:
2279 case WM_T_82573:
2280 case WM_T_82574:
2281 case WM_T_82583:
2282 case WM_T_80003:
2283 default:
2284 apme_mask = NVM_CFG3_APME;
2285 wm_nvm_read(sc, (sc->sc_funcid == 1) ? NVM_OFF_CFG3_PORTB
2286 : NVM_OFF_CFG3_PORTA, 1, &eeprom_data);
2287 break;
2288 case WM_T_82575:
2289 case WM_T_82576:
2290 case WM_T_82580:
2291 case WM_T_I350:
2292 case WM_T_I354: /* XXX ok? */
2293 case WM_T_ICH8:
2294 case WM_T_ICH9:
2295 case WM_T_ICH10:
2296 case WM_T_PCH:
2297 case WM_T_PCH2:
2298 case WM_T_PCH_LPT:
2299 case WM_T_PCH_SPT:
2300 /* XXX The funcid should be checked on some devices */
2301 apme_mask = WUC_APME;
2302 eeprom_data = CSR_READ(sc, WMREG_WUC);
2303 break;
2304 }
2305
2306 /* Check for WM_F_WOL flag after the setting of the EEPROM stuff */
2307 if ((eeprom_data & apme_mask) != 0)
2308 sc->sc_flags |= WM_F_WOL;
2309 #ifdef WM_DEBUG
2310 if ((sc->sc_flags & WM_F_WOL) != 0)
2311 printf("WOL\n");
2312 #endif
2313
2314 if ((sc->sc_type == WM_T_82575) || (sc->sc_type == WM_T_82576)) {
2315 /* Check NVM for autonegotiation */
2316 if (wm_nvm_read(sc, NVM_OFF_COMPAT, 1, &nvmword) == 0) {
2317 if ((nvmword & NVM_COMPAT_SERDES_FORCE_MODE) != 0)
2318 sc->sc_flags |= WM_F_PCS_DIS_AUTONEGO;
2319 }
2320 }
2321
2322 /*
2323 * XXX need special handling for some multiple port cards
2324 * to disable a paticular port.
2325 */
2326
2327 if (sc->sc_type >= WM_T_82544) {
2328 pn = prop_dictionary_get(dict, "i82543-swdpin");
2329 if (pn != NULL) {
2330 KASSERT(prop_object_type(pn) == PROP_TYPE_NUMBER);
2331 swdpin = (uint16_t) prop_number_integer_value(pn);
2332 } else {
2333 if (wm_nvm_read(sc, NVM_OFF_SWDPIN, 1, &swdpin)) {
2334 aprint_error_dev(sc->sc_dev,
2335 "unable to read SWDPIN\n");
2336 goto out;
2337 }
2338 }
2339 }
2340
2341 if (cfg1 & NVM_CFG1_ILOS)
2342 sc->sc_ctrl |= CTRL_ILOS;
2343
2344 /*
2345 * XXX
2346 * This code isn't correct because pin 2 and 3 are located
2347 * in different position on newer chips. Check all datasheet.
2348 *
2349 * Until resolve this problem, check if a chip < 82580
2350 */
2351 if (sc->sc_type <= WM_T_82580) {
2352 if (sc->sc_type >= WM_T_82544) {
2353 sc->sc_ctrl |=
2354 ((swdpin >> NVM_SWDPIN_SWDPIO_SHIFT) & 0xf) <<
2355 CTRL_SWDPIO_SHIFT;
2356 sc->sc_ctrl |=
2357 ((swdpin >> NVM_SWDPIN_SWDPIN_SHIFT) & 0xf) <<
2358 CTRL_SWDPINS_SHIFT;
2359 } else {
2360 sc->sc_ctrl |=
2361 ((cfg1 >> NVM_CFG1_SWDPIO_SHIFT) & 0xf) <<
2362 CTRL_SWDPIO_SHIFT;
2363 }
2364 }
2365
2366 /* XXX For other than 82580? */
2367 if (sc->sc_type == WM_T_82580) {
2368 wm_nvm_read(sc, NVM_OFF_CFG3_PORTA, 1, &nvmword);
2369 if (nvmword & __BIT(13))
2370 sc->sc_ctrl |= CTRL_ILOS;
2371 }
2372
2373 #if 0
2374 if (sc->sc_type >= WM_T_82544) {
2375 if (cfg1 & NVM_CFG1_IPS0)
2376 sc->sc_ctrl_ext |= CTRL_EXT_IPS;
2377 if (cfg1 & NVM_CFG1_IPS1)
2378 sc->sc_ctrl_ext |= CTRL_EXT_IPS1;
2379 sc->sc_ctrl_ext |=
2380 ((swdpin >> (NVM_SWDPIN_SWDPIO_SHIFT + 4)) & 0xd) <<
2381 CTRL_EXT_SWDPIO_SHIFT;
2382 sc->sc_ctrl_ext |=
2383 ((swdpin >> (NVM_SWDPIN_SWDPIN_SHIFT + 4)) & 0xd) <<
2384 CTRL_EXT_SWDPINS_SHIFT;
2385 } else {
2386 sc->sc_ctrl_ext |=
2387 ((cfg2 >> NVM_CFG2_SWDPIO_SHIFT) & 0xf) <<
2388 CTRL_EXT_SWDPIO_SHIFT;
2389 }
2390 #endif
2391
2392 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
2393 #if 0
2394 CSR_WRITE(sc, WMREG_CTRL_EXT, sc->sc_ctrl_ext);
2395 #endif
2396
2397 if (sc->sc_type == WM_T_PCH) {
2398 uint16_t val;
2399
2400 /* Save the NVM K1 bit setting */
2401 wm_nvm_read(sc, NVM_OFF_K1_CONFIG, 1, &val);
2402
2403 if ((val & NVM_K1_CONFIG_ENABLE) != 0)
2404 sc->sc_nvm_k1_enabled = 1;
2405 else
2406 sc->sc_nvm_k1_enabled = 0;
2407 }
2408
2409 /*
2410 * Determine if we're TBI,GMII or SGMII mode, and initialize the
2411 * media structures accordingly.
2412 */
2413 if (sc->sc_type == WM_T_ICH8 || sc->sc_type == WM_T_ICH9
2414 || sc->sc_type == WM_T_ICH10 || sc->sc_type == WM_T_PCH
2415 || sc->sc_type == WM_T_PCH2 || sc->sc_type == WM_T_PCH_LPT
2416 || sc->sc_type == WM_T_PCH_SPT || sc->sc_type == WM_T_82573
2417 || sc->sc_type == WM_T_82574 || sc->sc_type == WM_T_82583) {
2418 /* STATUS_TBIMODE reserved/reused, can't rely on it */
2419 wm_gmii_mediainit(sc, wmp->wmp_product);
2420 } else if (sc->sc_type < WM_T_82543 ||
2421 (CSR_READ(sc, WMREG_STATUS) & STATUS_TBIMODE) != 0) {
2422 if (sc->sc_mediatype == WM_MEDIATYPE_COPPER) {
2423 aprint_error_dev(sc->sc_dev,
2424 "WARNING: TBIMODE set on 1000BASE-T product!\n");
2425 sc->sc_mediatype = WM_MEDIATYPE_FIBER;
2426 }
2427 wm_tbi_mediainit(sc);
2428 } else {
2429 switch (sc->sc_type) {
2430 case WM_T_82575:
2431 case WM_T_82576:
2432 case WM_T_82580:
2433 case WM_T_I350:
2434 case WM_T_I354:
2435 case WM_T_I210:
2436 case WM_T_I211:
2437 reg = CSR_READ(sc, WMREG_CTRL_EXT);
2438 link_mode = reg & CTRL_EXT_LINK_MODE_MASK;
2439 switch (link_mode) {
2440 case CTRL_EXT_LINK_MODE_1000KX:
2441 aprint_verbose_dev(sc->sc_dev, "1000KX\n");
2442 sc->sc_mediatype = WM_MEDIATYPE_SERDES;
2443 break;
2444 case CTRL_EXT_LINK_MODE_SGMII:
2445 if (wm_sgmii_uses_mdio(sc)) {
2446 aprint_verbose_dev(sc->sc_dev,
2447 "SGMII(MDIO)\n");
2448 sc->sc_flags |= WM_F_SGMII;
2449 sc->sc_mediatype = WM_MEDIATYPE_COPPER;
2450 break;
2451 }
2452 aprint_verbose_dev(sc->sc_dev, "SGMII(I2C)\n");
2453 /*FALLTHROUGH*/
2454 case CTRL_EXT_LINK_MODE_PCIE_SERDES:
2455 sc->sc_mediatype = wm_sfp_get_media_type(sc);
2456 if (sc->sc_mediatype == WM_MEDIATYPE_UNKNOWN) {
2457 if (link_mode
2458 == CTRL_EXT_LINK_MODE_SGMII) {
2459 sc->sc_mediatype
2460 = WM_MEDIATYPE_COPPER;
2461 sc->sc_flags |= WM_F_SGMII;
2462 } else {
2463 sc->sc_mediatype
2464 = WM_MEDIATYPE_SERDES;
2465 aprint_verbose_dev(sc->sc_dev,
2466 "SERDES\n");
2467 }
2468 break;
2469 }
2470 if (sc->sc_mediatype == WM_MEDIATYPE_SERDES)
2471 aprint_verbose_dev(sc->sc_dev,
2472 "SERDES\n");
2473
2474 /* Change current link mode setting */
2475 reg &= ~CTRL_EXT_LINK_MODE_MASK;
2476 switch (sc->sc_mediatype) {
2477 case WM_MEDIATYPE_COPPER:
2478 reg |= CTRL_EXT_LINK_MODE_SGMII;
2479 break;
2480 case WM_MEDIATYPE_SERDES:
2481 reg |= CTRL_EXT_LINK_MODE_PCIE_SERDES;
2482 break;
2483 default:
2484 break;
2485 }
2486 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
2487 break;
2488 case CTRL_EXT_LINK_MODE_GMII:
2489 default:
2490 aprint_verbose_dev(sc->sc_dev, "Copper\n");
2491 sc->sc_mediatype = WM_MEDIATYPE_COPPER;
2492 break;
2493 }
2494
2495 reg &= ~CTRL_EXT_I2C_ENA;
2496 if ((sc->sc_flags & WM_F_SGMII) != 0)
2497 reg |= CTRL_EXT_I2C_ENA;
2498 else
2499 reg &= ~CTRL_EXT_I2C_ENA;
2500 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
2501
2502 if (sc->sc_mediatype == WM_MEDIATYPE_COPPER)
2503 wm_gmii_mediainit(sc, wmp->wmp_product);
2504 else
2505 wm_tbi_mediainit(sc);
2506 break;
2507 default:
2508 if (sc->sc_mediatype == WM_MEDIATYPE_FIBER)
2509 aprint_error_dev(sc->sc_dev,
2510 "WARNING: TBIMODE clear on 1000BASE-X product!\n");
2511 sc->sc_mediatype = WM_MEDIATYPE_COPPER;
2512 wm_gmii_mediainit(sc, wmp->wmp_product);
2513 }
2514 }
2515
2516 ifp = &sc->sc_ethercom.ec_if;
2517 xname = device_xname(sc->sc_dev);
2518 strlcpy(ifp->if_xname, xname, IFNAMSIZ);
2519 ifp->if_softc = sc;
2520 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
2521 ifp->if_extflags = IFEF_START_MPSAFE;
2522 ifp->if_ioctl = wm_ioctl;
2523 if ((sc->sc_flags & WM_F_NEWQUEUE) != 0) {
2524 ifp->if_start = wm_nq_start;
2525 if (sc->sc_nqueues > 1)
2526 ifp->if_transmit = wm_nq_transmit;
2527 } else
2528 ifp->if_start = wm_start;
2529 ifp->if_watchdog = wm_watchdog;
2530 ifp->if_init = wm_init;
2531 ifp->if_stop = wm_stop;
2532 IFQ_SET_MAXLEN(&ifp->if_snd, max(WM_IFQUEUELEN, IFQ_MAXLEN));
2533 IFQ_SET_READY(&ifp->if_snd);
2534
2535 /* Check for jumbo frame */
2536 switch (sc->sc_type) {
2537 case WM_T_82573:
2538 /* XXX limited to 9234 if ASPM is disabled */
2539 wm_nvm_read(sc, NVM_OFF_INIT_3GIO_3, 1, &nvmword);
2540 if ((nvmword & NVM_3GIO_3_ASPM_MASK) != 0)
2541 sc->sc_ethercom.ec_capabilities |= ETHERCAP_JUMBO_MTU;
2542 break;
2543 case WM_T_82571:
2544 case WM_T_82572:
2545 case WM_T_82574:
2546 case WM_T_82575:
2547 case WM_T_82576:
2548 case WM_T_82580:
2549 case WM_T_I350:
2550 case WM_T_I354: /* XXXX ok? */
2551 case WM_T_I210:
2552 case WM_T_I211:
2553 case WM_T_80003:
2554 case WM_T_ICH9:
2555 case WM_T_ICH10:
2556 case WM_T_PCH2: /* PCH2 supports 9K frame size */
2557 case WM_T_PCH_LPT:
2558 case WM_T_PCH_SPT:
2559 /* XXX limited to 9234 */
2560 sc->sc_ethercom.ec_capabilities |= ETHERCAP_JUMBO_MTU;
2561 break;
2562 case WM_T_PCH:
2563 /* XXX limited to 4096 */
2564 sc->sc_ethercom.ec_capabilities |= ETHERCAP_JUMBO_MTU;
2565 break;
2566 case WM_T_82542_2_0:
2567 case WM_T_82542_2_1:
2568 case WM_T_82583:
2569 case WM_T_ICH8:
2570 /* No support for jumbo frame */
2571 break;
2572 default:
2573 /* ETHER_MAX_LEN_JUMBO */
2574 sc->sc_ethercom.ec_capabilities |= ETHERCAP_JUMBO_MTU;
2575 break;
2576 }
2577
2578 /* If we're a i82543 or greater, we can support VLANs. */
2579 if (sc->sc_type >= WM_T_82543)
2580 sc->sc_ethercom.ec_capabilities |=
2581 ETHERCAP_VLAN_MTU | ETHERCAP_VLAN_HWTAGGING;
2582
2583 /*
2584 * We can perform TCPv4 and UDPv4 checkums in-bound. Only
2585 * on i82543 and later.
2586 */
2587 if (sc->sc_type >= WM_T_82543) {
2588 ifp->if_capabilities |=
2589 IFCAP_CSUM_IPv4_Tx | IFCAP_CSUM_IPv4_Rx |
2590 IFCAP_CSUM_TCPv4_Tx | IFCAP_CSUM_TCPv4_Rx |
2591 IFCAP_CSUM_UDPv4_Tx | IFCAP_CSUM_UDPv4_Rx |
2592 IFCAP_CSUM_TCPv6_Tx |
2593 IFCAP_CSUM_UDPv6_Tx;
2594 }
2595
2596 /*
2597 * XXXyamt: i'm not sure which chips support RXCSUM_IPV6OFL.
2598 *
2599 * 82541GI (8086:1076) ... no
2600 * 82572EI (8086:10b9) ... yes
2601 */
2602 if (sc->sc_type >= WM_T_82571) {
2603 ifp->if_capabilities |=
2604 IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_UDPv6_Rx;
2605 }
2606
2607 /*
2608 * If we're a i82544 or greater (except i82547), we can do
2609 * TCP segmentation offload.
2610 */
2611 if (sc->sc_type >= WM_T_82544 && sc->sc_type != WM_T_82547) {
2612 ifp->if_capabilities |= IFCAP_TSOv4;
2613 }
2614
2615 if (sc->sc_type >= WM_T_82571) {
2616 ifp->if_capabilities |= IFCAP_TSOv6;
2617 }
2618
2619 #ifdef WM_MPSAFE
2620 sc->sc_core_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NET);
2621 #else
2622 sc->sc_core_lock = NULL;
2623 #endif
2624
2625 /* Attach the interface. */
2626 if_initialize(ifp);
2627 sc->sc_ipq = if_percpuq_create(&sc->sc_ethercom.ec_if);
2628 ether_ifattach(ifp, enaddr);
2629 if_register(ifp);
2630 ether_set_ifflags_cb(&sc->sc_ethercom, wm_ifflags_cb);
2631 rnd_attach_source(&sc->rnd_source, xname, RND_TYPE_NET,
2632 RND_FLAG_DEFAULT);
2633
2634 #ifdef WM_EVENT_COUNTERS
2635 /* Attach event counters. */
2636 evcnt_attach_dynamic(&sc->sc_ev_linkintr, EVCNT_TYPE_INTR,
2637 NULL, xname, "linkintr");
2638
2639 evcnt_attach_dynamic(&sc->sc_ev_tx_xoff, EVCNT_TYPE_MISC,
2640 NULL, xname, "tx_xoff");
2641 evcnt_attach_dynamic(&sc->sc_ev_tx_xon, EVCNT_TYPE_MISC,
2642 NULL, xname, "tx_xon");
2643 evcnt_attach_dynamic(&sc->sc_ev_rx_xoff, EVCNT_TYPE_MISC,
2644 NULL, xname, "rx_xoff");
2645 evcnt_attach_dynamic(&sc->sc_ev_rx_xon, EVCNT_TYPE_MISC,
2646 NULL, xname, "rx_xon");
2647 evcnt_attach_dynamic(&sc->sc_ev_rx_macctl, EVCNT_TYPE_MISC,
2648 NULL, xname, "rx_macctl");
2649 #endif /* WM_EVENT_COUNTERS */
2650
2651 if (pmf_device_register(self, wm_suspend, wm_resume))
2652 pmf_class_network_register(self, ifp);
2653 else
2654 aprint_error_dev(self, "couldn't establish power handler\n");
2655
2656 sc->sc_flags |= WM_F_ATTACHED;
2657 out:
2658 return;
2659 }
2660
2661 /* The detach function (ca_detach) */
2662 static int
2663 wm_detach(device_t self, int flags __unused)
2664 {
2665 struct wm_softc *sc = device_private(self);
2666 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
2667 int i;
2668
2669 if ((sc->sc_flags & WM_F_ATTACHED) == 0)
2670 return 0;
2671
2672 /* Stop the interface. Callouts are stopped in it. */
2673 wm_stop(ifp, 1);
2674
2675 pmf_device_deregister(self);
2676
2677 /* Tell the firmware about the release */
2678 WM_CORE_LOCK(sc);
2679 wm_release_manageability(sc);
2680 wm_release_hw_control(sc);
2681 WM_CORE_UNLOCK(sc);
2682
2683 mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);
2684
2685 /* Delete all remaining media. */
2686 ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);
2687
2688 ether_ifdetach(ifp);
2689 if_detach(ifp);
2690 if_percpuq_destroy(sc->sc_ipq);
2691
2692 /* Unload RX dmamaps and free mbufs */
2693 for (i = 0; i < sc->sc_nqueues; i++) {
2694 struct wm_rxqueue *rxq = &sc->sc_queue[i].wmq_rxq;
2695 mutex_enter(rxq->rxq_lock);
2696 wm_rxdrain(rxq);
2697 mutex_exit(rxq->rxq_lock);
2698 }
2699 /* Must unlock here */
2700
2701 /* Disestablish the interrupt handler */
2702 for (i = 0; i < sc->sc_nintrs; i++) {
2703 if (sc->sc_ihs[i] != NULL) {
2704 pci_intr_disestablish(sc->sc_pc, sc->sc_ihs[i]);
2705 sc->sc_ihs[i] = NULL;
2706 }
2707 }
2708 pci_intr_release(sc->sc_pc, sc->sc_intrs, sc->sc_nintrs);
2709
2710 wm_free_txrx_queues(sc);
2711
2712 /* Unmap the registers */
2713 if (sc->sc_ss) {
2714 bus_space_unmap(sc->sc_st, sc->sc_sh, sc->sc_ss);
2715 sc->sc_ss = 0;
2716 }
2717 if (sc->sc_ios) {
2718 bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
2719 sc->sc_ios = 0;
2720 }
2721 if (sc->sc_flashs) {
2722 bus_space_unmap(sc->sc_flasht, sc->sc_flashh, sc->sc_flashs);
2723 sc->sc_flashs = 0;
2724 }
2725
2726 if (sc->sc_core_lock)
2727 mutex_obj_free(sc->sc_core_lock);
2728 if (sc->sc_ich_phymtx)
2729 mutex_obj_free(sc->sc_ich_phymtx);
2730 if (sc->sc_ich_nvmmtx)
2731 mutex_obj_free(sc->sc_ich_nvmmtx);
2732
2733 return 0;
2734 }
2735
2736 static bool
2737 wm_suspend(device_t self, const pmf_qual_t *qual)
2738 {
2739 struct wm_softc *sc = device_private(self);
2740
2741 wm_release_manageability(sc);
2742 wm_release_hw_control(sc);
2743 #ifdef WM_WOL
2744 wm_enable_wakeup(sc);
2745 #endif
2746
2747 return true;
2748 }
2749
2750 static bool
2751 wm_resume(device_t self, const pmf_qual_t *qual)
2752 {
2753 struct wm_softc *sc = device_private(self);
2754
2755 wm_init_manageability(sc);
2756
2757 return true;
2758 }
2759
2760 /*
2761 * wm_watchdog: [ifnet interface function]
2762 *
2763 * Watchdog timer handler.
2764 */
2765 static void
2766 wm_watchdog(struct ifnet *ifp)
2767 {
2768 int qid;
2769 struct wm_softc *sc = ifp->if_softc;
2770
2771 for (qid = 0; qid < sc->sc_nqueues; qid++) {
2772 struct wm_txqueue *txq = &sc->sc_queue[qid].wmq_txq;
2773
2774 wm_watchdog_txq(ifp, txq);
2775 }
2776
2777 /* Reset the interface. */
2778 (void) wm_init(ifp);
2779
2780 /*
2781 * There are still some upper layer processing which call
2782 * ifp->if_start(). e.g. ALTQ
2783 */
2784 /* Try to get more packets going. */
2785 ifp->if_start(ifp);
2786 }
2787
2788 static void
2789 wm_watchdog_txq(struct ifnet *ifp, struct wm_txqueue *txq)
2790 {
2791 struct wm_softc *sc = ifp->if_softc;
2792
2793 /*
2794 * Since we're using delayed interrupts, sweep up
2795 * before we report an error.
2796 */
2797 mutex_enter(txq->txq_lock);
2798 wm_txeof(sc, txq);
2799 mutex_exit(txq->txq_lock);
2800
2801 if (txq->txq_free != WM_NTXDESC(txq)) {
2802 #ifdef WM_DEBUG
2803 int i, j;
2804 struct wm_txsoft *txs;
2805 #endif
2806 log(LOG_ERR,
2807 "%s: device timeout (txfree %d txsfree %d txnext %d)\n",
2808 device_xname(sc->sc_dev), txq->txq_free, txq->txq_sfree,
2809 txq->txq_next);
2810 ifp->if_oerrors++;
2811 #ifdef WM_DEBUG
2812 for (i = txq->txq_sdirty; i != txq->txq_snext ;
2813 i = WM_NEXTTXS(txq, i)) {
2814 txs = &txq->txq_soft[i];
2815 printf("txs %d tx %d -> %d\n",
2816 i, txs->txs_firstdesc, txs->txs_lastdesc);
2817 for (j = txs->txs_firstdesc; ;
2818 j = WM_NEXTTX(txq, j)) {
2819 printf("\tdesc %d: 0x%" PRIx64 "\n", j,
2820 txq->txq_nq_descs[j].nqtx_data.nqtxd_addr);
2821 printf("\t %#08x%08x\n",
2822 txq->txq_nq_descs[j].nqtx_data.nqtxd_fields,
2823 txq->txq_nq_descs[j].nqtx_data.nqtxd_cmdlen);
2824 if (j == txs->txs_lastdesc)
2825 break;
2826 }
2827 }
2828 #endif
2829 }
2830 }
2831
2832 /*
2833 * wm_tick:
2834 *
2835 * One second timer, used to check link status, sweep up
2836 * completed transmit jobs, etc.
2837 */
2838 static void
2839 wm_tick(void *arg)
2840 {
2841 struct wm_softc *sc = arg;
2842 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
2843 #ifndef WM_MPSAFE
2844 int s = splnet();
2845 #endif
2846
2847 WM_CORE_LOCK(sc);
2848
2849 if (sc->sc_core_stopping)
2850 goto out;
2851
2852 if (sc->sc_type >= WM_T_82542_2_1) {
2853 WM_EVCNT_ADD(&sc->sc_ev_rx_xon, CSR_READ(sc, WMREG_XONRXC));
2854 WM_EVCNT_ADD(&sc->sc_ev_tx_xon, CSR_READ(sc, WMREG_XONTXC));
2855 WM_EVCNT_ADD(&sc->sc_ev_rx_xoff, CSR_READ(sc, WMREG_XOFFRXC));
2856 WM_EVCNT_ADD(&sc->sc_ev_tx_xoff, CSR_READ(sc, WMREG_XOFFTXC));
2857 WM_EVCNT_ADD(&sc->sc_ev_rx_macctl, CSR_READ(sc, WMREG_FCRUC));
2858 }
2859
2860 ifp->if_collisions += CSR_READ(sc, WMREG_COLC);
2861 ifp->if_ierrors += 0ULL + /* ensure quad_t */
2862 + CSR_READ(sc, WMREG_CRCERRS)
2863 + CSR_READ(sc, WMREG_ALGNERRC)
2864 + CSR_READ(sc, WMREG_SYMERRC)
2865 + CSR_READ(sc, WMREG_RXERRC)
2866 + CSR_READ(sc, WMREG_SEC)
2867 + CSR_READ(sc, WMREG_CEXTERR)
2868 + CSR_READ(sc, WMREG_RLEC);
2869 /*
2870 * WMREG_RNBC is incremented when there is no available buffers in host
2871 * memory. It does not mean the number of dropped packet. Because
2872 * ethernet controller can receive packets in such case if there is
2873 * space in phy's FIFO.
2874 *
2875 * If you want to know the nubmer of WMREG_RMBC, you should use such as
2876 * own EVCNT instead of if_iqdrops.
2877 */
2878 ifp->if_iqdrops += CSR_READ(sc, WMREG_MPC);
2879
2880 if (sc->sc_flags & WM_F_HAS_MII)
2881 mii_tick(&sc->sc_mii);
2882 else if ((sc->sc_type >= WM_T_82575)
2883 && (sc->sc_mediatype == WM_MEDIATYPE_SERDES))
2884 wm_serdes_tick(sc);
2885 else
2886 wm_tbi_tick(sc);
2887
2888 out:
2889 WM_CORE_UNLOCK(sc);
2890 #ifndef WM_MPSAFE
2891 splx(s);
2892 #endif
2893
2894 if (!sc->sc_core_stopping)
2895 callout_reset(&sc->sc_tick_ch, hz, wm_tick, sc);
2896 }
2897
2898 static int
2899 wm_ifflags_cb(struct ethercom *ec)
2900 {
2901 struct ifnet *ifp = &ec->ec_if;
2902 struct wm_softc *sc = ifp->if_softc;
2903 int rc = 0;
2904
2905 WM_CORE_LOCK(sc);
2906
2907 int change = ifp->if_flags ^ sc->sc_if_flags;
2908 sc->sc_if_flags = ifp->if_flags;
2909
2910 if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0) {
2911 rc = ENETRESET;
2912 goto out;
2913 }
2914
2915 if ((change & (IFF_PROMISC | IFF_ALLMULTI)) != 0)
2916 wm_set_filter(sc);
2917
2918 wm_set_vlan(sc);
2919
2920 out:
2921 WM_CORE_UNLOCK(sc);
2922
2923 return rc;
2924 }
2925
2926 /*
2927 * wm_ioctl: [ifnet interface function]
2928 *
2929 * Handle control requests from the operator.
2930 */
2931 static int
2932 wm_ioctl(struct ifnet *ifp, u_long cmd, void *data)
2933 {
2934 struct wm_softc *sc = ifp->if_softc;
2935 struct ifreq *ifr = (struct ifreq *) data;
2936 struct ifaddr *ifa = (struct ifaddr *)data;
2937 struct sockaddr_dl *sdl;
2938 int s, error;
2939
2940 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
2941 device_xname(sc->sc_dev), __func__));
2942
2943 #ifndef WM_MPSAFE
2944 s = splnet();
2945 #endif
2946 switch (cmd) {
2947 case SIOCSIFMEDIA:
2948 case SIOCGIFMEDIA:
2949 WM_CORE_LOCK(sc);
2950 /* Flow control requires full-duplex mode. */
2951 if (IFM_SUBTYPE(ifr->ifr_media) == IFM_AUTO ||
2952 (ifr->ifr_media & IFM_FDX) == 0)
2953 ifr->ifr_media &= ~IFM_ETH_FMASK;
2954 if (IFM_SUBTYPE(ifr->ifr_media) != IFM_AUTO) {
2955 if ((ifr->ifr_media & IFM_ETH_FMASK) == IFM_FLOW) {
2956 /* We can do both TXPAUSE and RXPAUSE. */
2957 ifr->ifr_media |=
2958 IFM_ETH_TXPAUSE | IFM_ETH_RXPAUSE;
2959 }
2960 sc->sc_flowflags = ifr->ifr_media & IFM_ETH_FMASK;
2961 }
2962 WM_CORE_UNLOCK(sc);
2963 #ifdef WM_MPSAFE
2964 s = splnet();
2965 #endif
2966 error = ifmedia_ioctl(ifp, ifr, &sc->sc_mii.mii_media, cmd);
2967 #ifdef WM_MPSAFE
2968 splx(s);
2969 #endif
2970 break;
2971 case SIOCINITIFADDR:
2972 WM_CORE_LOCK(sc);
2973 if (ifa->ifa_addr->sa_family == AF_LINK) {
2974 sdl = satosdl(ifp->if_dl->ifa_addr);
2975 (void)sockaddr_dl_setaddr(sdl, sdl->sdl_len,
2976 LLADDR(satosdl(ifa->ifa_addr)), ifp->if_addrlen);
2977 /* unicast address is first multicast entry */
2978 wm_set_filter(sc);
2979 error = 0;
2980 WM_CORE_UNLOCK(sc);
2981 break;
2982 }
2983 WM_CORE_UNLOCK(sc);
2984 /*FALLTHROUGH*/
2985 default:
2986 #ifdef WM_MPSAFE
2987 s = splnet();
2988 #endif
2989 /* It may call wm_start, so unlock here */
2990 error = ether_ioctl(ifp, cmd, data);
2991 #ifdef WM_MPSAFE
2992 splx(s);
2993 #endif
2994 if (error != ENETRESET)
2995 break;
2996
2997 error = 0;
2998
2999 if (cmd == SIOCSIFCAP) {
3000 error = (*ifp->if_init)(ifp);
3001 } else if (cmd != SIOCADDMULTI && cmd != SIOCDELMULTI)
3002 ;
3003 else if (ifp->if_flags & IFF_RUNNING) {
3004 /*
3005 * Multicast list has changed; set the hardware filter
3006 * accordingly.
3007 */
3008 WM_CORE_LOCK(sc);
3009 wm_set_filter(sc);
3010 WM_CORE_UNLOCK(sc);
3011 }
3012 break;
3013 }
3014
3015 #ifndef WM_MPSAFE
3016 splx(s);
3017 #endif
3018 return error;
3019 }
3020
3021 /* MAC address related */
3022
3023 /*
3024 * Get the offset of MAC address and return it.
3025 * If error occured, use offset 0.
3026 */
3027 static uint16_t
3028 wm_check_alt_mac_addr(struct wm_softc *sc)
3029 {
3030 uint16_t myea[ETHER_ADDR_LEN / 2];
3031 uint16_t offset = NVM_OFF_MACADDR;
3032
3033 /* Try to read alternative MAC address pointer */
3034 if (wm_nvm_read(sc, NVM_OFF_ALT_MAC_ADDR_PTR, 1, &offset) != 0)
3035 return 0;
3036
3037 /* Check pointer if it's valid or not. */
3038 if ((offset == 0x0000) || (offset == 0xffff))
3039 return 0;
3040
3041 offset += NVM_OFF_MACADDR_82571(sc->sc_funcid);
3042 /*
3043 * Check whether alternative MAC address is valid or not.
3044 * Some cards have non 0xffff pointer but those don't use
3045 * alternative MAC address in reality.
3046 *
3047 * Check whether the broadcast bit is set or not.
3048 */
3049 if (wm_nvm_read(sc, offset, 1, myea) == 0)
3050 if (((myea[0] & 0xff) & 0x01) == 0)
3051 return offset; /* Found */
3052
3053 /* Not found */
3054 return 0;
3055 }
3056
3057 static int
3058 wm_read_mac_addr(struct wm_softc *sc, uint8_t *enaddr)
3059 {
3060 uint16_t myea[ETHER_ADDR_LEN / 2];
3061 uint16_t offset = NVM_OFF_MACADDR;
3062 int do_invert = 0;
3063
3064 switch (sc->sc_type) {
3065 case WM_T_82580:
3066 case WM_T_I350:
3067 case WM_T_I354:
3068 /* EEPROM Top Level Partitioning */
3069 offset = NVM_OFF_LAN_FUNC_82580(sc->sc_funcid) + 0;
3070 break;
3071 case WM_T_82571:
3072 case WM_T_82575:
3073 case WM_T_82576:
3074 case WM_T_80003:
3075 case WM_T_I210:
3076 case WM_T_I211:
3077 offset = wm_check_alt_mac_addr(sc);
3078 if (offset == 0)
3079 if ((sc->sc_funcid & 0x01) == 1)
3080 do_invert = 1;
3081 break;
3082 default:
3083 if ((sc->sc_funcid & 0x01) == 1)
3084 do_invert = 1;
3085 break;
3086 }
3087
3088 if (wm_nvm_read(sc, offset, sizeof(myea) / sizeof(myea[0]), myea) != 0)
3089 goto bad;
3090
3091 enaddr[0] = myea[0] & 0xff;
3092 enaddr[1] = myea[0] >> 8;
3093 enaddr[2] = myea[1] & 0xff;
3094 enaddr[3] = myea[1] >> 8;
3095 enaddr[4] = myea[2] & 0xff;
3096 enaddr[5] = myea[2] >> 8;
3097
3098 /*
3099 * Toggle the LSB of the MAC address on the second port
3100 * of some dual port cards.
3101 */
3102 if (do_invert != 0)
3103 enaddr[5] ^= 1;
3104
3105 return 0;
3106
3107 bad:
3108 return -1;
3109 }
3110
3111 /*
3112 * wm_set_ral:
3113 *
3114 * Set an entery in the receive address list.
3115 */
3116 static void
3117 wm_set_ral(struct wm_softc *sc, const uint8_t *enaddr, int idx)
3118 {
3119 uint32_t ral_lo, ral_hi;
3120
3121 if (enaddr != NULL) {
3122 ral_lo = enaddr[0] | (enaddr[1] << 8) | (enaddr[2] << 16) |
3123 (enaddr[3] << 24);
3124 ral_hi = enaddr[4] | (enaddr[5] << 8);
3125 ral_hi |= RAL_AV;
3126 } else {
3127 ral_lo = 0;
3128 ral_hi = 0;
3129 }
3130
3131 if (sc->sc_type >= WM_T_82544) {
3132 CSR_WRITE(sc, WMREG_RAL_LO(WMREG_CORDOVA_RAL_BASE, idx),
3133 ral_lo);
3134 CSR_WRITE(sc, WMREG_RAL_HI(WMREG_CORDOVA_RAL_BASE, idx),
3135 ral_hi);
3136 } else {
3137 CSR_WRITE(sc, WMREG_RAL_LO(WMREG_RAL_BASE, idx), ral_lo);
3138 CSR_WRITE(sc, WMREG_RAL_HI(WMREG_RAL_BASE, idx), ral_hi);
3139 }
3140 }
3141
3142 /*
3143 * wm_mchash:
3144 *
3145 * Compute the hash of the multicast address for the 4096-bit
3146 * multicast filter.
3147 */
3148 static uint32_t
3149 wm_mchash(struct wm_softc *sc, const uint8_t *enaddr)
3150 {
3151 static const int lo_shift[4] = { 4, 3, 2, 0 };
3152 static const int hi_shift[4] = { 4, 5, 6, 8 };
3153 static const int ich8_lo_shift[4] = { 6, 5, 4, 2 };
3154 static const int ich8_hi_shift[4] = { 2, 3, 4, 6 };
3155 uint32_t hash;
3156
3157 if ((sc->sc_type == WM_T_ICH8) || (sc->sc_type == WM_T_ICH9)
3158 || (sc->sc_type == WM_T_ICH10) || (sc->sc_type == WM_T_PCH)
3159 || (sc->sc_type == WM_T_PCH2) || (sc->sc_type == WM_T_PCH_LPT)
3160 || (sc->sc_type == WM_T_PCH_SPT)) {
3161 hash = (enaddr[4] >> ich8_lo_shift[sc->sc_mchash_type]) |
3162 (((uint16_t) enaddr[5]) << ich8_hi_shift[sc->sc_mchash_type]);
3163 return (hash & 0x3ff);
3164 }
3165 hash = (enaddr[4] >> lo_shift[sc->sc_mchash_type]) |
3166 (((uint16_t) enaddr[5]) << hi_shift[sc->sc_mchash_type]);
3167
3168 return (hash & 0xfff);
3169 }
3170
3171 /*
3172 * wm_set_filter:
3173 *
3174 * Set up the receive filter.
3175 */
3176 static void
3177 wm_set_filter(struct wm_softc *sc)
3178 {
3179 struct ethercom *ec = &sc->sc_ethercom;
3180 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
3181 struct ether_multi *enm;
3182 struct ether_multistep step;
3183 bus_addr_t mta_reg;
3184 uint32_t hash, reg, bit;
3185 int i, size, ralmax;
3186
3187 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
3188 device_xname(sc->sc_dev), __func__));
3189
3190 if (sc->sc_type >= WM_T_82544)
3191 mta_reg = WMREG_CORDOVA_MTA;
3192 else
3193 mta_reg = WMREG_MTA;
3194
3195 sc->sc_rctl &= ~(RCTL_BAM | RCTL_UPE | RCTL_MPE);
3196
3197 if (ifp->if_flags & IFF_BROADCAST)
3198 sc->sc_rctl |= RCTL_BAM;
3199 if (ifp->if_flags & IFF_PROMISC) {
3200 sc->sc_rctl |= RCTL_UPE;
3201 goto allmulti;
3202 }
3203
3204 /*
3205 * Set the station address in the first RAL slot, and
3206 * clear the remaining slots.
3207 */
3208 if (sc->sc_type == WM_T_ICH8)
3209 size = WM_RAL_TABSIZE_ICH8 -1;
3210 else if ((sc->sc_type == WM_T_ICH9) || (sc->sc_type == WM_T_ICH10)
3211 || (sc->sc_type == WM_T_PCH))
3212 size = WM_RAL_TABSIZE_ICH8;
3213 else if (sc->sc_type == WM_T_PCH2)
3214 size = WM_RAL_TABSIZE_PCH2;
3215 else if ((sc->sc_type == WM_T_PCH_LPT) ||(sc->sc_type == WM_T_PCH_SPT))
3216 size = WM_RAL_TABSIZE_PCH_LPT;
3217 else if (sc->sc_type == WM_T_82575)
3218 size = WM_RAL_TABSIZE_82575;
3219 else if ((sc->sc_type == WM_T_82576) || (sc->sc_type == WM_T_82580))
3220 size = WM_RAL_TABSIZE_82576;
3221 else if ((sc->sc_type == WM_T_I350) || (sc->sc_type == WM_T_I354))
3222 size = WM_RAL_TABSIZE_I350;
3223 else
3224 size = WM_RAL_TABSIZE;
3225 wm_set_ral(sc, CLLADDR(ifp->if_sadl), 0);
3226
3227 if ((sc->sc_type == WM_T_PCH_LPT) || (sc->sc_type == WM_T_PCH_SPT)) {
3228 i = __SHIFTOUT(CSR_READ(sc, WMREG_FWSM), FWSM_WLOCK_MAC);
3229 switch (i) {
3230 case 0:
3231 /* We can use all entries */
3232 ralmax = size;
3233 break;
3234 case 1:
3235 /* Only RAR[0] */
3236 ralmax = 1;
3237 break;
3238 default:
3239 /* available SHRA + RAR[0] */
3240 ralmax = i + 1;
3241 }
3242 } else
3243 ralmax = size;
3244 for (i = 1; i < size; i++) {
3245 if (i < ralmax)
3246 wm_set_ral(sc, NULL, i);
3247 }
3248
3249 if ((sc->sc_type == WM_T_ICH8) || (sc->sc_type == WM_T_ICH9)
3250 || (sc->sc_type == WM_T_ICH10) || (sc->sc_type == WM_T_PCH)
3251 || (sc->sc_type == WM_T_PCH2) || (sc->sc_type == WM_T_PCH_LPT)
3252 || (sc->sc_type == WM_T_PCH_SPT))
3253 size = WM_ICH8_MC_TABSIZE;
3254 else
3255 size = WM_MC_TABSIZE;
3256 /* Clear out the multicast table. */
3257 for (i = 0; i < size; i++)
3258 CSR_WRITE(sc, mta_reg + (i << 2), 0);
3259
3260 ETHER_FIRST_MULTI(step, ec, enm);
3261 while (enm != NULL) {
3262 if (memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) {
3263 /*
3264 * We must listen to a range of multicast addresses.
3265 * For now, just accept all multicasts, rather than
3266 * trying to set only those filter bits needed to match
3267 * the range. (At this time, the only use of address
3268 * ranges is for IP multicast routing, for which the
3269 * range is big enough to require all bits set.)
3270 */
3271 goto allmulti;
3272 }
3273
3274 hash = wm_mchash(sc, enm->enm_addrlo);
3275
3276 reg = (hash >> 5);
3277 if ((sc->sc_type == WM_T_ICH8) || (sc->sc_type == WM_T_ICH9)
3278 || (sc->sc_type == WM_T_ICH10) || (sc->sc_type == WM_T_PCH)
3279 || (sc->sc_type == WM_T_PCH2)
3280 || (sc->sc_type == WM_T_PCH_LPT)
3281 || (sc->sc_type == WM_T_PCH_SPT))
3282 reg &= 0x1f;
3283 else
3284 reg &= 0x7f;
3285 bit = hash & 0x1f;
3286
3287 hash = CSR_READ(sc, mta_reg + (reg << 2));
3288 hash |= 1U << bit;
3289
3290 if (sc->sc_type == WM_T_82544 && (reg & 1) != 0) {
3291 /*
3292 * 82544 Errata 9: Certain register cannot be written
3293 * with particular alignments in PCI-X bus operation
3294 * (FCAH, MTA and VFTA).
3295 */
3296 bit = CSR_READ(sc, mta_reg + ((reg - 1) << 2));
3297 CSR_WRITE(sc, mta_reg + (reg << 2), hash);
3298 CSR_WRITE(sc, mta_reg + ((reg - 1) << 2), bit);
3299 } else
3300 CSR_WRITE(sc, mta_reg + (reg << 2), hash);
3301
3302 ETHER_NEXT_MULTI(step, enm);
3303 }
3304
3305 ifp->if_flags &= ~IFF_ALLMULTI;
3306 goto setit;
3307
3308 allmulti:
3309 ifp->if_flags |= IFF_ALLMULTI;
3310 sc->sc_rctl |= RCTL_MPE;
3311
3312 setit:
3313 CSR_WRITE(sc, WMREG_RCTL, sc->sc_rctl);
3314 }
3315
3316 /* Reset and init related */
3317
3318 static void
3319 wm_set_vlan(struct wm_softc *sc)
3320 {
3321
3322 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
3323 device_xname(sc->sc_dev), __func__));
3324
3325 /* Deal with VLAN enables. */
3326 if (VLAN_ATTACHED(&sc->sc_ethercom))
3327 sc->sc_ctrl |= CTRL_VME;
3328 else
3329 sc->sc_ctrl &= ~CTRL_VME;
3330
3331 /* Write the control registers. */
3332 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
3333 }
3334
3335 static void
3336 wm_set_pcie_completion_timeout(struct wm_softc *sc)
3337 {
3338 uint32_t gcr;
3339 pcireg_t ctrl2;
3340
3341 gcr = CSR_READ(sc, WMREG_GCR);
3342
3343 /* Only take action if timeout value is defaulted to 0 */
3344 if ((gcr & GCR_CMPL_TMOUT_MASK) != 0)
3345 goto out;
3346
3347 if ((gcr & GCR_CAP_VER2) == 0) {
3348 gcr |= GCR_CMPL_TMOUT_10MS;
3349 goto out;
3350 }
3351
3352 ctrl2 = pci_conf_read(sc->sc_pc, sc->sc_pcitag,
3353 sc->sc_pcixe_capoff + PCIE_DCSR2);
3354 ctrl2 |= WM_PCIE_DCSR2_16MS;
3355 pci_conf_write(sc->sc_pc, sc->sc_pcitag,
3356 sc->sc_pcixe_capoff + PCIE_DCSR2, ctrl2);
3357
3358 out:
3359 /* Disable completion timeout resend */
3360 gcr &= ~GCR_CMPL_TMOUT_RESEND;
3361
3362 CSR_WRITE(sc, WMREG_GCR, gcr);
3363 }
3364
3365 void
3366 wm_get_auto_rd_done(struct wm_softc *sc)
3367 {
3368 int i;
3369
3370 /* wait for eeprom to reload */
3371 switch (sc->sc_type) {
3372 case WM_T_82571:
3373 case WM_T_82572:
3374 case WM_T_82573:
3375 case WM_T_82574:
3376 case WM_T_82583:
3377 case WM_T_82575:
3378 case WM_T_82576:
3379 case WM_T_82580:
3380 case WM_T_I350:
3381 case WM_T_I354:
3382 case WM_T_I210:
3383 case WM_T_I211:
3384 case WM_T_80003:
3385 case WM_T_ICH8:
3386 case WM_T_ICH9:
3387 for (i = 0; i < 10; i++) {
3388 if (CSR_READ(sc, WMREG_EECD) & EECD_EE_AUTORD)
3389 break;
3390 delay(1000);
3391 }
3392 if (i == 10) {
3393 log(LOG_ERR, "%s: auto read from eeprom failed to "
3394 "complete\n", device_xname(sc->sc_dev));
3395 }
3396 break;
3397 default:
3398 break;
3399 }
3400 }
3401
3402 void
3403 wm_lan_init_done(struct wm_softc *sc)
3404 {
3405 uint32_t reg = 0;
3406 int i;
3407
3408 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
3409 device_xname(sc->sc_dev), __func__));
3410
3411 /* Wait for eeprom to reload */
3412 switch (sc->sc_type) {
3413 case WM_T_ICH10:
3414 case WM_T_PCH:
3415 case WM_T_PCH2:
3416 case WM_T_PCH_LPT:
3417 case WM_T_PCH_SPT:
3418 for (i = 0; i < WM_ICH8_LAN_INIT_TIMEOUT; i++) {
3419 reg = CSR_READ(sc, WMREG_STATUS);
3420 if ((reg & STATUS_LAN_INIT_DONE) != 0)
3421 break;
3422 delay(100);
3423 }
3424 if (i >= WM_ICH8_LAN_INIT_TIMEOUT) {
3425 log(LOG_ERR, "%s: %s: lan_init_done failed to "
3426 "complete\n", device_xname(sc->sc_dev), __func__);
3427 }
3428 break;
3429 default:
3430 panic("%s: %s: unknown type\n", device_xname(sc->sc_dev),
3431 __func__);
3432 break;
3433 }
3434
3435 reg &= ~STATUS_LAN_INIT_DONE;
3436 CSR_WRITE(sc, WMREG_STATUS, reg);
3437 }
3438
3439 void
3440 wm_get_cfg_done(struct wm_softc *sc)
3441 {
3442 int mask;
3443 uint32_t reg;
3444 int i;
3445
3446 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
3447 device_xname(sc->sc_dev), __func__));
3448
3449 /* Wait for eeprom to reload */
3450 switch (sc->sc_type) {
3451 case WM_T_82542_2_0:
3452 case WM_T_82542_2_1:
3453 /* null */
3454 break;
3455 case WM_T_82543:
3456 case WM_T_82544:
3457 case WM_T_82540:
3458 case WM_T_82545:
3459 case WM_T_82545_3:
3460 case WM_T_82546:
3461 case WM_T_82546_3:
3462 case WM_T_82541:
3463 case WM_T_82541_2:
3464 case WM_T_82547:
3465 case WM_T_82547_2:
3466 case WM_T_82573:
3467 case WM_T_82574:
3468 case WM_T_82583:
3469 /* generic */
3470 delay(10*1000);
3471 break;
3472 case WM_T_80003:
3473 case WM_T_82571:
3474 case WM_T_82572:
3475 case WM_T_82575:
3476 case WM_T_82576:
3477 case WM_T_82580:
3478 case WM_T_I350:
3479 case WM_T_I354:
3480 case WM_T_I210:
3481 case WM_T_I211:
3482 if (sc->sc_type == WM_T_82571) {
3483 /* Only 82571 shares port 0 */
3484 mask = EEMNGCTL_CFGDONE_0;
3485 } else
3486 mask = EEMNGCTL_CFGDONE_0 << sc->sc_funcid;
3487 for (i = 0; i < WM_PHY_CFG_TIMEOUT; i++) {
3488 if (CSR_READ(sc, WMREG_EEMNGCTL) & mask)
3489 break;
3490 delay(1000);
3491 }
3492 if (i >= WM_PHY_CFG_TIMEOUT) {
3493 DPRINTF(WM_DEBUG_GMII, ("%s: %s failed\n",
3494 device_xname(sc->sc_dev), __func__));
3495 }
3496 break;
3497 case WM_T_ICH8:
3498 case WM_T_ICH9:
3499 case WM_T_ICH10:
3500 case WM_T_PCH:
3501 case WM_T_PCH2:
3502 case WM_T_PCH_LPT:
3503 case WM_T_PCH_SPT:
3504 delay(10*1000);
3505 if (sc->sc_type >= WM_T_ICH10)
3506 wm_lan_init_done(sc);
3507 else
3508 wm_get_auto_rd_done(sc);
3509
3510 reg = CSR_READ(sc, WMREG_STATUS);
3511 if ((reg & STATUS_PHYRA) != 0)
3512 CSR_WRITE(sc, WMREG_STATUS, reg & ~STATUS_PHYRA);
3513 break;
3514 default:
3515 panic("%s: %s: unknown type\n", device_xname(sc->sc_dev),
3516 __func__);
3517 break;
3518 }
3519 }
3520
3521 /* Init hardware bits */
3522 void
3523 wm_initialize_hardware_bits(struct wm_softc *sc)
3524 {
3525 uint32_t tarc0, tarc1, reg;
3526
3527 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
3528 device_xname(sc->sc_dev), __func__));
3529
3530 /* For 82571 variant, 80003 and ICHs */
3531 if (((sc->sc_type >= WM_T_82571) && (sc->sc_type <= WM_T_82583))
3532 || (sc->sc_type >= WM_T_80003)) {
3533
3534 /* Transmit Descriptor Control 0 */
3535 reg = CSR_READ(sc, WMREG_TXDCTL(0));
3536 reg |= TXDCTL_COUNT_DESC;
3537 CSR_WRITE(sc, WMREG_TXDCTL(0), reg);
3538
3539 /* Transmit Descriptor Control 1 */
3540 reg = CSR_READ(sc, WMREG_TXDCTL(1));
3541 reg |= TXDCTL_COUNT_DESC;
3542 CSR_WRITE(sc, WMREG_TXDCTL(1), reg);
3543
3544 /* TARC0 */
3545 tarc0 = CSR_READ(sc, WMREG_TARC0);
3546 switch (sc->sc_type) {
3547 case WM_T_82571:
3548 case WM_T_82572:
3549 case WM_T_82573:
3550 case WM_T_82574:
3551 case WM_T_82583:
3552 case WM_T_80003:
3553 /* Clear bits 30..27 */
3554 tarc0 &= ~__BITS(30, 27);
3555 break;
3556 default:
3557 break;
3558 }
3559
3560 switch (sc->sc_type) {
3561 case WM_T_82571:
3562 case WM_T_82572:
3563 tarc0 |= __BITS(26, 23); /* TARC0 bits 23-26 */
3564
3565 tarc1 = CSR_READ(sc, WMREG_TARC1);
3566 tarc1 &= ~__BITS(30, 29); /* Clear bits 30 and 29 */
3567 tarc1 |= __BITS(26, 24); /* TARC1 bits 26-24 */
3568 /* 8257[12] Errata No.7 */
3569 tarc1 |= __BIT(22); /* TARC1 bits 22 */
3570
3571 /* TARC1 bit 28 */
3572 if ((CSR_READ(sc, WMREG_TCTL) & TCTL_MULR) != 0)
3573 tarc1 &= ~__BIT(28);
3574 else
3575 tarc1 |= __BIT(28);
3576 CSR_WRITE(sc, WMREG_TARC1, tarc1);
3577
3578 /*
3579 * 8257[12] Errata No.13
3580 * Disable Dyamic Clock Gating.
3581 */
3582 reg = CSR_READ(sc, WMREG_CTRL_EXT);
3583 reg &= ~CTRL_EXT_DMA_DYN_CLK;
3584 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
3585 break;
3586 case WM_T_82573:
3587 case WM_T_82574:
3588 case WM_T_82583:
3589 if ((sc->sc_type == WM_T_82574)
3590 || (sc->sc_type == WM_T_82583))
3591 tarc0 |= __BIT(26); /* TARC0 bit 26 */
3592
3593 /* Extended Device Control */
3594 reg = CSR_READ(sc, WMREG_CTRL_EXT);
3595 reg &= ~__BIT(23); /* Clear bit 23 */
3596 reg |= __BIT(22); /* Set bit 22 */
3597 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
3598
3599 /* Device Control */
3600 sc->sc_ctrl &= ~__BIT(29); /* Clear bit 29 */
3601 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
3602
3603 /* PCIe Control Register */
3604 /*
3605 * 82573 Errata (unknown).
3606 *
3607 * 82574 Errata 25 and 82583 Errata 12
3608 * "Dropped Rx Packets":
3609 * NVM Image Version 2.1.4 and newer has no this bug.
3610 */
3611 reg = CSR_READ(sc, WMREG_GCR);
3612 reg |= GCR_L1_ACT_WITHOUT_L0S_RX;
3613 CSR_WRITE(sc, WMREG_GCR, reg);
3614
3615 if ((sc->sc_type == WM_T_82574)
3616 || (sc->sc_type == WM_T_82583)) {
3617 /*
3618 * Document says this bit must be set for
3619 * proper operation.
3620 */
3621 reg = CSR_READ(sc, WMREG_GCR);
3622 reg |= __BIT(22);
3623 CSR_WRITE(sc, WMREG_GCR, reg);
3624
3625 /*
3626 * Apply workaround for hardware errata
3627 * documented in errata docs Fixes issue where
3628 * some error prone or unreliable PCIe
3629 * completions are occurring, particularly
3630 * with ASPM enabled. Without fix, issue can
3631 * cause Tx timeouts.
3632 */
3633 reg = CSR_READ(sc, WMREG_GCR2);
3634 reg |= __BIT(0);
3635 CSR_WRITE(sc, WMREG_GCR2, reg);
3636 }
3637 break;
3638 case WM_T_80003:
3639 /* TARC0 */
3640 if ((sc->sc_mediatype == WM_MEDIATYPE_FIBER)
3641 || (sc->sc_mediatype == WM_MEDIATYPE_SERDES))
3642 tarc0 &= ~__BIT(20); /* Clear bits 20 */
3643
3644 /* TARC1 bit 28 */
3645 tarc1 = CSR_READ(sc, WMREG_TARC1);
3646 if ((CSR_READ(sc, WMREG_TCTL) & TCTL_MULR) != 0)
3647 tarc1 &= ~__BIT(28);
3648 else
3649 tarc1 |= __BIT(28);
3650 CSR_WRITE(sc, WMREG_TARC1, tarc1);
3651 break;
3652 case WM_T_ICH8:
3653 case WM_T_ICH9:
3654 case WM_T_ICH10:
3655 case WM_T_PCH:
3656 case WM_T_PCH2:
3657 case WM_T_PCH_LPT:
3658 case WM_T_PCH_SPT:
3659 /* TARC0 */
3660 if ((sc->sc_type == WM_T_ICH8)
3661 || (sc->sc_type == WM_T_PCH_SPT)) {
3662 /* Set TARC0 bits 29 and 28 */
3663 tarc0 |= __BITS(29, 28);
3664 }
3665 /* Set TARC0 bits 23,24,26,27 */
3666 tarc0 |= __BITS(27, 26) | __BITS(24, 23);
3667
3668 /* CTRL_EXT */
3669 reg = CSR_READ(sc, WMREG_CTRL_EXT);
3670 reg |= __BIT(22); /* Set bit 22 */
3671 /*
3672 * Enable PHY low-power state when MAC is at D3
3673 * w/o WoL
3674 */
3675 if (sc->sc_type >= WM_T_PCH)
3676 reg |= CTRL_EXT_PHYPDEN;
3677 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
3678
3679 /* TARC1 */
3680 tarc1 = CSR_READ(sc, WMREG_TARC1);
3681 /* bit 28 */
3682 if ((CSR_READ(sc, WMREG_TCTL) & TCTL_MULR) != 0)
3683 tarc1 &= ~__BIT(28);
3684 else
3685 tarc1 |= __BIT(28);
3686 tarc1 |= __BIT(24) | __BIT(26) | __BIT(30);
3687 CSR_WRITE(sc, WMREG_TARC1, tarc1);
3688
3689 /* Device Status */
3690 if (sc->sc_type == WM_T_ICH8) {
3691 reg = CSR_READ(sc, WMREG_STATUS);
3692 reg &= ~__BIT(31);
3693 CSR_WRITE(sc, WMREG_STATUS, reg);
3694
3695 }
3696
3697 /* IOSFPC */
3698 if (sc->sc_type == WM_T_PCH_SPT) {
3699 reg = CSR_READ(sc, WMREG_IOSFPC);
3700 reg |= RCTL_RDMTS_HEX; /* XXX RTCL bit? */
3701 CSR_WRITE(sc, WMREG_IOSFPC, reg);
3702 }
3703 /*
3704 * Work-around descriptor data corruption issue during
3705 * NFS v2 UDP traffic, just disable the NFS filtering
3706 * capability.
3707 */
3708 reg = CSR_READ(sc, WMREG_RFCTL);
3709 reg |= WMREG_RFCTL_NFSWDIS | WMREG_RFCTL_NFSRDIS;
3710 CSR_WRITE(sc, WMREG_RFCTL, reg);
3711 break;
3712 default:
3713 break;
3714 }
3715 CSR_WRITE(sc, WMREG_TARC0, tarc0);
3716
3717 /*
3718 * 8257[12] Errata No.52 and some others.
3719 * Avoid RSS Hash Value bug.
3720 */
3721 switch (sc->sc_type) {
3722 case WM_T_82571:
3723 case WM_T_82572:
3724 case WM_T_82573:
3725 case WM_T_80003:
3726 case WM_T_ICH8:
3727 reg = CSR_READ(sc, WMREG_RFCTL);
3728 reg |= WMREG_RFCTL_NEWIPV6EXDIS |WMREG_RFCTL_IPV6EXDIS;
3729 CSR_WRITE(sc, WMREG_RFCTL, reg);
3730 break;
3731 default:
3732 break;
3733 }
3734 }
3735 }
3736
3737 static uint32_t
3738 wm_rxpbs_adjust_82580(uint32_t val)
3739 {
3740 uint32_t rv = 0;
3741
3742 if (val < __arraycount(wm_82580_rxpbs_table))
3743 rv = wm_82580_rxpbs_table[val];
3744
3745 return rv;
3746 }
3747
3748 /*
3749 * wm_reset:
3750 *
3751 * Reset the i82542 chip.
3752 */
3753 static void
3754 wm_reset(struct wm_softc *sc)
3755 {
3756 int phy_reset = 0;
3757 int i, error = 0;
3758 uint32_t reg;
3759
3760 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
3761 device_xname(sc->sc_dev), __func__));
3762 KASSERT(sc->sc_type != 0);
3763
3764 /*
3765 * Allocate on-chip memory according to the MTU size.
3766 * The Packet Buffer Allocation register must be written
3767 * before the chip is reset.
3768 */
3769 switch (sc->sc_type) {
3770 case WM_T_82547:
3771 case WM_T_82547_2:
3772 sc->sc_pba = sc->sc_ethercom.ec_if.if_mtu > 8192 ?
3773 PBA_22K : PBA_30K;
3774 for (i = 0; i < sc->sc_nqueues; i++) {
3775 struct wm_txqueue *txq = &sc->sc_queue[i].wmq_txq;
3776 txq->txq_fifo_head = 0;
3777 txq->txq_fifo_addr = sc->sc_pba << PBA_ADDR_SHIFT;
3778 txq->txq_fifo_size =
3779 (PBA_40K - sc->sc_pba) << PBA_BYTE_SHIFT;
3780 txq->txq_fifo_stall = 0;
3781 }
3782 break;
3783 case WM_T_82571:
3784 case WM_T_82572:
3785 case WM_T_82575: /* XXX need special handing for jumbo frames */
3786 case WM_T_80003:
3787 sc->sc_pba = PBA_32K;
3788 break;
3789 case WM_T_82573:
3790 sc->sc_pba = PBA_12K;
3791 break;
3792 case WM_T_82574:
3793 case WM_T_82583:
3794 sc->sc_pba = PBA_20K;
3795 break;
3796 case WM_T_82576:
3797 sc->sc_pba = CSR_READ(sc, WMREG_RXPBS);
3798 sc->sc_pba &= RXPBS_SIZE_MASK_82576;
3799 break;
3800 case WM_T_82580:
3801 case WM_T_I350:
3802 case WM_T_I354:
3803 sc->sc_pba = wm_rxpbs_adjust_82580(CSR_READ(sc, WMREG_RXPBS));
3804 break;
3805 case WM_T_I210:
3806 case WM_T_I211:
3807 sc->sc_pba = PBA_34K;
3808 break;
3809 case WM_T_ICH8:
3810 /* Workaround for a bit corruption issue in FIFO memory */
3811 sc->sc_pba = PBA_8K;
3812 CSR_WRITE(sc, WMREG_PBS, PBA_16K);
3813 break;
3814 case WM_T_ICH9:
3815 case WM_T_ICH10:
3816 sc->sc_pba = sc->sc_ethercom.ec_if.if_mtu > 4096 ?
3817 PBA_14K : PBA_10K;
3818 break;
3819 case WM_T_PCH:
3820 case WM_T_PCH2:
3821 case WM_T_PCH_LPT:
3822 case WM_T_PCH_SPT:
3823 sc->sc_pba = PBA_26K;
3824 break;
3825 default:
3826 sc->sc_pba = sc->sc_ethercom.ec_if.if_mtu > 8192 ?
3827 PBA_40K : PBA_48K;
3828 break;
3829 }
3830 /*
3831 * Only old or non-multiqueue devices have the PBA register
3832 * XXX Need special handling for 82575.
3833 */
3834 if (((sc->sc_flags & WM_F_NEWQUEUE) == 0)
3835 || (sc->sc_type == WM_T_82575))
3836 CSR_WRITE(sc, WMREG_PBA, sc->sc_pba);
3837
3838 /* Prevent the PCI-E bus from sticking */
3839 if (sc->sc_flags & WM_F_PCIE) {
3840 int timeout = 800;
3841
3842 sc->sc_ctrl |= CTRL_GIO_M_DIS;
3843 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
3844
3845 while (timeout--) {
3846 if ((CSR_READ(sc, WMREG_STATUS) & STATUS_GIO_M_ENA)
3847 == 0)
3848 break;
3849 delay(100);
3850 }
3851 }
3852
3853 /* Set the completion timeout for interface */
3854 if ((sc->sc_type == WM_T_82575) || (sc->sc_type == WM_T_82576)
3855 || (sc->sc_type == WM_T_82580)
3856 || (sc->sc_type == WM_T_I350) || (sc->sc_type == WM_T_I354)
3857 || (sc->sc_type == WM_T_I210) || (sc->sc_type == WM_T_I211))
3858 wm_set_pcie_completion_timeout(sc);
3859
3860 /* Clear interrupt */
3861 CSR_WRITE(sc, WMREG_IMC, 0xffffffffU);
3862 if (sc->sc_nintrs > 1) {
3863 if (sc->sc_type != WM_T_82574) {
3864 CSR_WRITE(sc, WMREG_EIMC, 0xffffffffU);
3865 CSR_WRITE(sc, WMREG_EIAC, 0);
3866 } else {
3867 CSR_WRITE(sc, WMREG_EIAC_82574, 0);
3868 }
3869 }
3870
3871 /* Stop the transmit and receive processes. */
3872 CSR_WRITE(sc, WMREG_RCTL, 0);
3873 sc->sc_rctl &= ~RCTL_EN;
3874 CSR_WRITE(sc, WMREG_TCTL, TCTL_PSP);
3875 CSR_WRITE_FLUSH(sc);
3876
3877 /* XXX set_tbi_sbp_82543() */
3878
3879 delay(10*1000);
3880
3881 /* Must acquire the MDIO ownership before MAC reset */
3882 switch (sc->sc_type) {
3883 case WM_T_82573:
3884 case WM_T_82574:
3885 case WM_T_82583:
3886 error = wm_get_hw_semaphore_82573(sc);
3887 break;
3888 default:
3889 break;
3890 }
3891
3892 /*
3893 * 82541 Errata 29? & 82547 Errata 28?
3894 * See also the description about PHY_RST bit in CTRL register
3895 * in 8254x_GBe_SDM.pdf.
3896 */
3897 if ((sc->sc_type == WM_T_82541) || (sc->sc_type == WM_T_82547)) {
3898 CSR_WRITE(sc, WMREG_CTRL,
3899 CSR_READ(sc, WMREG_CTRL) | CTRL_PHY_RESET);
3900 CSR_WRITE_FLUSH(sc);
3901 delay(5000);
3902 }
3903
3904 switch (sc->sc_type) {
3905 case WM_T_82544: /* XXX check whether WM_F_IOH_VALID is set */
3906 case WM_T_82541:
3907 case WM_T_82541_2:
3908 case WM_T_82547:
3909 case WM_T_82547_2:
3910 /*
3911 * On some chipsets, a reset through a memory-mapped write
3912 * cycle can cause the chip to reset before completing the
3913 * write cycle. This causes major headache that can be
3914 * avoided by issuing the reset via indirect register writes
3915 * through I/O space.
3916 *
3917 * So, if we successfully mapped the I/O BAR at attach time,
3918 * use that. Otherwise, try our luck with a memory-mapped
3919 * reset.
3920 */
3921 if (sc->sc_flags & WM_F_IOH_VALID)
3922 wm_io_write(sc, WMREG_CTRL, CTRL_RST);
3923 else
3924 CSR_WRITE(sc, WMREG_CTRL, CTRL_RST);
3925 break;
3926 case WM_T_82545_3:
3927 case WM_T_82546_3:
3928 /* Use the shadow control register on these chips. */
3929 CSR_WRITE(sc, WMREG_CTRL_SHADOW, CTRL_RST);
3930 break;
3931 case WM_T_80003:
3932 reg = CSR_READ(sc, WMREG_CTRL) | CTRL_RST;
3933 sc->phy.acquire(sc);
3934 CSR_WRITE(sc, WMREG_CTRL, reg);
3935 sc->phy.release(sc);
3936 break;
3937 case WM_T_ICH8:
3938 case WM_T_ICH9:
3939 case WM_T_ICH10:
3940 case WM_T_PCH:
3941 case WM_T_PCH2:
3942 case WM_T_PCH_LPT:
3943 case WM_T_PCH_SPT:
3944 reg = CSR_READ(sc, WMREG_CTRL) | CTRL_RST;
3945 if (wm_phy_resetisblocked(sc) == false) {
3946 /*
3947 * Gate automatic PHY configuration by hardware on
3948 * non-managed 82579
3949 */
3950 if ((sc->sc_type == WM_T_PCH2)
3951 && ((CSR_READ(sc, WMREG_FWSM) & FWSM_FW_VALID)
3952 == 0))
3953 wm_gate_hw_phy_config_ich8lan(sc, true);
3954
3955 reg |= CTRL_PHY_RESET;
3956 phy_reset = 1;
3957 } else
3958 printf("XXX reset is blocked!!!\n");
3959 sc->phy.acquire(sc);
3960 CSR_WRITE(sc, WMREG_CTRL, reg);
3961 /* Don't insert a completion barrier when reset */
3962 delay(20*1000);
3963 mutex_exit(sc->sc_ich_phymtx);
3964 break;
3965 case WM_T_82580:
3966 case WM_T_I350:
3967 case WM_T_I354:
3968 case WM_T_I210:
3969 case WM_T_I211:
3970 CSR_WRITE(sc, WMREG_CTRL, CSR_READ(sc, WMREG_CTRL) | CTRL_RST);
3971 if (sc->sc_pcidevid != PCI_PRODUCT_INTEL_DH89XXCC_SGMII)
3972 CSR_WRITE_FLUSH(sc);
3973 delay(5000);
3974 break;
3975 case WM_T_82542_2_0:
3976 case WM_T_82542_2_1:
3977 case WM_T_82543:
3978 case WM_T_82540:
3979 case WM_T_82545:
3980 case WM_T_82546:
3981 case WM_T_82571:
3982 case WM_T_82572:
3983 case WM_T_82573:
3984 case WM_T_82574:
3985 case WM_T_82575:
3986 case WM_T_82576:
3987 case WM_T_82583:
3988 default:
3989 /* Everything else can safely use the documented method. */
3990 CSR_WRITE(sc, WMREG_CTRL, CSR_READ(sc, WMREG_CTRL) | CTRL_RST);
3991 break;
3992 }
3993
3994 /* Must release the MDIO ownership after MAC reset */
3995 switch (sc->sc_type) {
3996 case WM_T_82573:
3997 case WM_T_82574:
3998 case WM_T_82583:
3999 if (error == 0)
4000 wm_put_hw_semaphore_82573(sc);
4001 break;
4002 default:
4003 break;
4004 }
4005
4006 if (phy_reset != 0) {
4007 wm_get_cfg_done(sc);
4008 delay(10 * 1000);
4009 if (sc->sc_type >= WM_T_PCH) {
4010 reg = wm_gmii_hv_readreg(sc->sc_dev, 2,
4011 BM_PORT_GEN_CFG);
4012 reg &= ~BM_WUC_HOST_WU_BIT;
4013 wm_gmii_hv_writereg(sc->sc_dev, 2,
4014 BM_PORT_GEN_CFG, reg);
4015 }
4016 }
4017
4018 /* reload EEPROM */
4019 switch (sc->sc_type) {
4020 case WM_T_82542_2_0:
4021 case WM_T_82542_2_1:
4022 case WM_T_82543:
4023 case WM_T_82544:
4024 delay(10);
4025 reg = CSR_READ(sc, WMREG_CTRL_EXT) | CTRL_EXT_EE_RST;
4026 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
4027 CSR_WRITE_FLUSH(sc);
4028 delay(2000);
4029 break;
4030 case WM_T_82540:
4031 case WM_T_82545:
4032 case WM_T_82545_3:
4033 case WM_T_82546:
4034 case WM_T_82546_3:
4035 delay(5*1000);
4036 /* XXX Disable HW ARPs on ASF enabled adapters */
4037 break;
4038 case WM_T_82541:
4039 case WM_T_82541_2:
4040 case WM_T_82547:
4041 case WM_T_82547_2:
4042 delay(20000);
4043 /* XXX Disable HW ARPs on ASF enabled adapters */
4044 break;
4045 case WM_T_82571:
4046 case WM_T_82572:
4047 case WM_T_82573:
4048 case WM_T_82574:
4049 case WM_T_82583:
4050 if (sc->sc_flags & WM_F_EEPROM_FLASH) {
4051 delay(10);
4052 reg = CSR_READ(sc, WMREG_CTRL_EXT) | CTRL_EXT_EE_RST;
4053 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
4054 CSR_WRITE_FLUSH(sc);
4055 }
4056 /* check EECD_EE_AUTORD */
4057 wm_get_auto_rd_done(sc);
4058 /*
4059 * Phy configuration from NVM just starts after EECD_AUTO_RD
4060 * is set.
4061 */
4062 if ((sc->sc_type == WM_T_82573) || (sc->sc_type == WM_T_82574)
4063 || (sc->sc_type == WM_T_82583))
4064 delay(25*1000);
4065 break;
4066 case WM_T_82575:
4067 case WM_T_82576:
4068 case WM_T_82580:
4069 case WM_T_I350:
4070 case WM_T_I354:
4071 case WM_T_I210:
4072 case WM_T_I211:
4073 case WM_T_80003:
4074 /* check EECD_EE_AUTORD */
4075 wm_get_auto_rd_done(sc);
4076 break;
4077 case WM_T_ICH8:
4078 case WM_T_ICH9:
4079 case WM_T_ICH10:
4080 case WM_T_PCH:
4081 case WM_T_PCH2:
4082 case WM_T_PCH_LPT:
4083 case WM_T_PCH_SPT:
4084 break;
4085 default:
4086 panic("%s: unknown type\n", __func__);
4087 }
4088
4089 /* Check whether EEPROM is present or not */
4090 switch (sc->sc_type) {
4091 case WM_T_82575:
4092 case WM_T_82576:
4093 case WM_T_82580:
4094 case WM_T_I350:
4095 case WM_T_I354:
4096 case WM_T_ICH8:
4097 case WM_T_ICH9:
4098 if ((CSR_READ(sc, WMREG_EECD) & EECD_EE_PRES) == 0) {
4099 /* Not found */
4100 sc->sc_flags |= WM_F_EEPROM_INVALID;
4101 if (sc->sc_type == WM_T_82575)
4102 wm_reset_init_script_82575(sc);
4103 }
4104 break;
4105 default:
4106 break;
4107 }
4108
4109 if ((sc->sc_type == WM_T_82580)
4110 || (sc->sc_type == WM_T_I350) || (sc->sc_type == WM_T_I354)) {
4111 /* clear global device reset status bit */
4112 CSR_WRITE(sc, WMREG_STATUS, STATUS_DEV_RST_SET);
4113 }
4114
4115 /* Clear any pending interrupt events. */
4116 CSR_WRITE(sc, WMREG_IMC, 0xffffffffU);
4117 reg = CSR_READ(sc, WMREG_ICR);
4118 if (sc->sc_nintrs > 1) {
4119 if (sc->sc_type != WM_T_82574) {
4120 CSR_WRITE(sc, WMREG_EIMC, 0xffffffffU);
4121 CSR_WRITE(sc, WMREG_EIAC, 0);
4122 } else
4123 CSR_WRITE(sc, WMREG_EIAC_82574, 0);
4124 }
4125
4126 /* reload sc_ctrl */
4127 sc->sc_ctrl = CSR_READ(sc, WMREG_CTRL);
4128
4129 if ((sc->sc_type >= WM_T_I350) && (sc->sc_type <= WM_T_I211))
4130 wm_set_eee_i350(sc);
4131
4132 /* dummy read from WUC */
4133 if (sc->sc_type == WM_T_PCH)
4134 reg = wm_gmii_hv_readreg(sc->sc_dev, 1, BM_WUC);
4135 /*
4136 * For PCH, this write will make sure that any noise will be detected
4137 * as a CRC error and be dropped rather than show up as a bad packet
4138 * to the DMA engine
4139 */
4140 if (sc->sc_type == WM_T_PCH)
4141 CSR_WRITE(sc, WMREG_CRC_OFFSET, 0x65656565);
4142
4143 if (sc->sc_type >= WM_T_82544)
4144 CSR_WRITE(sc, WMREG_WUC, 0);
4145
4146 wm_reset_mdicnfg_82580(sc);
4147
4148 if ((sc->sc_flags & WM_F_PLL_WA_I210) != 0)
4149 wm_pll_workaround_i210(sc);
4150 }
4151
4152 /*
4153 * wm_add_rxbuf:
4154 *
4155 * Add a receive buffer to the indiciated descriptor.
4156 */
4157 static int
4158 wm_add_rxbuf(struct wm_rxqueue *rxq, int idx)
4159 {
4160 struct wm_softc *sc = rxq->rxq_sc;
4161 struct wm_rxsoft *rxs = &rxq->rxq_soft[idx];
4162 struct mbuf *m;
4163 int error;
4164
4165 KASSERT(mutex_owned(rxq->rxq_lock));
4166
4167 MGETHDR(m, M_DONTWAIT, MT_DATA);
4168 if (m == NULL)
4169 return ENOBUFS;
4170
4171 MCLGET(m, M_DONTWAIT);
4172 if ((m->m_flags & M_EXT) == 0) {
4173 m_freem(m);
4174 return ENOBUFS;
4175 }
4176
4177 if (rxs->rxs_mbuf != NULL)
4178 bus_dmamap_unload(sc->sc_dmat, rxs->rxs_dmamap);
4179
4180 rxs->rxs_mbuf = m;
4181
4182 m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
4183 error = bus_dmamap_load_mbuf(sc->sc_dmat, rxs->rxs_dmamap, m,
4184 BUS_DMA_READ | BUS_DMA_NOWAIT);
4185 if (error) {
4186 /* XXX XXX XXX */
4187 aprint_error_dev(sc->sc_dev,
4188 "unable to load rx DMA map %d, error = %d\n",
4189 idx, error);
4190 panic("wm_add_rxbuf");
4191 }
4192
4193 bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
4194 rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
4195
4196 if ((sc->sc_flags & WM_F_NEWQUEUE) != 0) {
4197 if ((sc->sc_rctl & RCTL_EN) != 0)
4198 wm_init_rxdesc(rxq, idx);
4199 } else
4200 wm_init_rxdesc(rxq, idx);
4201
4202 return 0;
4203 }
4204
4205 /*
4206 * wm_rxdrain:
4207 *
4208 * Drain the receive queue.
4209 */
4210 static void
4211 wm_rxdrain(struct wm_rxqueue *rxq)
4212 {
4213 struct wm_softc *sc = rxq->rxq_sc;
4214 struct wm_rxsoft *rxs;
4215 int i;
4216
4217 KASSERT(mutex_owned(rxq->rxq_lock));
4218
4219 for (i = 0; i < WM_NRXDESC; i++) {
4220 rxs = &rxq->rxq_soft[i];
4221 if (rxs->rxs_mbuf != NULL) {
4222 bus_dmamap_unload(sc->sc_dmat, rxs->rxs_dmamap);
4223 m_freem(rxs->rxs_mbuf);
4224 rxs->rxs_mbuf = NULL;
4225 }
4226 }
4227 }
4228
4229
4230 /*
4231 * XXX copy from FreeBSD's sys/net/rss_config.c
4232 */
4233 /*
4234 * RSS secret key, intended to prevent attacks on load-balancing. Its
4235 * effectiveness may be limited by algorithm choice and available entropy
4236 * during the boot.
4237 *
4238 * XXXRW: And that we don't randomize it yet!
4239 *
4240 * This is the default Microsoft RSS specification key which is also
4241 * the Chelsio T5 firmware default key.
4242 */
4243 #define RSS_KEYSIZE 40
4244 static uint8_t wm_rss_key[RSS_KEYSIZE] = {
4245 0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2,
4246 0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0,
4247 0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4,
4248 0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c,
4249 0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa,
4250 };
4251
4252 /*
4253 * Caller must pass an array of size sizeof(rss_key).
4254 *
4255 * XXX
4256 * As if_ixgbe may use this function, this function should not be
4257 * if_wm specific function.
4258 */
4259 static void
4260 wm_rss_getkey(uint8_t *key)
4261 {
4262
4263 memcpy(key, wm_rss_key, sizeof(wm_rss_key));
4264 }
4265
4266 /*
4267 * Setup registers for RSS.
4268 *
4269 * XXX not yet VMDq support
4270 */
4271 static void
4272 wm_init_rss(struct wm_softc *sc)
4273 {
4274 uint32_t mrqc, reta_reg, rss_key[RSSRK_NUM_REGS];
4275 int i;
4276
4277 CTASSERT(sizeof(rss_key) == sizeof(wm_rss_key));
4278
4279 for (i = 0; i < RETA_NUM_ENTRIES; i++) {
4280 int qid, reta_ent;
4281
4282 qid = i % sc->sc_nqueues;
4283 switch(sc->sc_type) {
4284 case WM_T_82574:
4285 reta_ent = __SHIFTIN(qid,
4286 RETA_ENT_QINDEX_MASK_82574);
4287 break;
4288 case WM_T_82575:
4289 reta_ent = __SHIFTIN(qid,
4290 RETA_ENT_QINDEX1_MASK_82575);
4291 break;
4292 default:
4293 reta_ent = __SHIFTIN(qid, RETA_ENT_QINDEX_MASK);
4294 break;
4295 }
4296
4297 reta_reg = CSR_READ(sc, WMREG_RETA_Q(i));
4298 reta_reg &= ~RETA_ENTRY_MASK_Q(i);
4299 reta_reg |= __SHIFTIN(reta_ent, RETA_ENTRY_MASK_Q(i));
4300 CSR_WRITE(sc, WMREG_RETA_Q(i), reta_reg);
4301 }
4302
4303 wm_rss_getkey((uint8_t *)rss_key);
4304 for (i = 0; i < RSSRK_NUM_REGS; i++)
4305 CSR_WRITE(sc, WMREG_RSSRK(i), rss_key[i]);
4306
4307 if (sc->sc_type == WM_T_82574)
4308 mrqc = MRQC_ENABLE_RSS_MQ_82574;
4309 else
4310 mrqc = MRQC_ENABLE_RSS_MQ;
4311
4312 /* XXXX
4313 * The same as FreeBSD igb.
4314 * Why doesn't use MRQC_RSS_FIELD_IPV6_EX?
4315 */
4316 mrqc |= (MRQC_RSS_FIELD_IPV4 | MRQC_RSS_FIELD_IPV4_TCP);
4317 mrqc |= (MRQC_RSS_FIELD_IPV6 | MRQC_RSS_FIELD_IPV6_TCP);
4318 mrqc |= (MRQC_RSS_FIELD_IPV4_UDP | MRQC_RSS_FIELD_IPV6_UDP);
4319 mrqc |= (MRQC_RSS_FIELD_IPV6_UDP_EX | MRQC_RSS_FIELD_IPV6_TCP_EX);
4320
4321 CSR_WRITE(sc, WMREG_MRQC, mrqc);
4322 }
4323
4324 /*
4325 * Adjust TX and RX queue numbers which the system actulally uses.
4326 *
4327 * The numbers are affected by below parameters.
4328 * - The nubmer of hardware queues
4329 * - The number of MSI-X vectors (= "nvectors" argument)
4330 * - ncpu
4331 */
4332 static void
4333 wm_adjust_qnum(struct wm_softc *sc, int nvectors)
4334 {
4335 int hw_ntxqueues, hw_nrxqueues, hw_nqueues;
4336
4337 if (nvectors < 2) {
4338 sc->sc_nqueues = 1;
4339 return;
4340 }
4341
4342 switch(sc->sc_type) {
4343 case WM_T_82572:
4344 hw_ntxqueues = 2;
4345 hw_nrxqueues = 2;
4346 break;
4347 case WM_T_82574:
4348 hw_ntxqueues = 2;
4349 hw_nrxqueues = 2;
4350 break;
4351 case WM_T_82575:
4352 hw_ntxqueues = 4;
4353 hw_nrxqueues = 4;
4354 break;
4355 case WM_T_82576:
4356 hw_ntxqueues = 16;
4357 hw_nrxqueues = 16;
4358 break;
4359 case WM_T_82580:
4360 case WM_T_I350:
4361 case WM_T_I354:
4362 hw_ntxqueues = 8;
4363 hw_nrxqueues = 8;
4364 break;
4365 case WM_T_I210:
4366 hw_ntxqueues = 4;
4367 hw_nrxqueues = 4;
4368 break;
4369 case WM_T_I211:
4370 hw_ntxqueues = 2;
4371 hw_nrxqueues = 2;
4372 break;
4373 /*
4374 * As below ethernet controllers does not support MSI-X,
4375 * this driver let them not use multiqueue.
4376 * - WM_T_80003
4377 * - WM_T_ICH8
4378 * - WM_T_ICH9
4379 * - WM_T_ICH10
4380 * - WM_T_PCH
4381 * - WM_T_PCH2
4382 * - WM_T_PCH_LPT
4383 */
4384 default:
4385 hw_ntxqueues = 1;
4386 hw_nrxqueues = 1;
4387 break;
4388 }
4389
4390 hw_nqueues = min(hw_ntxqueues, hw_nrxqueues);
4391
4392 /*
4393 * As queues more than MSI-X vectors cannot improve scaling, we limit
4394 * the number of queues used actually.
4395 */
4396 if (nvectors < hw_nqueues + 1) {
4397 sc->sc_nqueues = nvectors - 1;
4398 } else {
4399 sc->sc_nqueues = hw_nqueues;
4400 }
4401
4402 /*
4403 * As queues more then cpus cannot improve scaling, we limit
4404 * the number of queues used actually.
4405 */
4406 if (ncpu < sc->sc_nqueues)
4407 sc->sc_nqueues = ncpu;
4408 }
4409
4410 /*
4411 * Both single interrupt MSI and INTx can use this function.
4412 */
4413 static int
4414 wm_setup_legacy(struct wm_softc *sc)
4415 {
4416 pci_chipset_tag_t pc = sc->sc_pc;
4417 const char *intrstr = NULL;
4418 char intrbuf[PCI_INTRSTR_LEN];
4419 int error;
4420
4421 error = wm_alloc_txrx_queues(sc);
4422 if (error) {
4423 aprint_error_dev(sc->sc_dev, "cannot allocate queues %d\n",
4424 error);
4425 return ENOMEM;
4426 }
4427 intrstr = pci_intr_string(pc, sc->sc_intrs[0], intrbuf,
4428 sizeof(intrbuf));
4429 #ifdef WM_MPSAFE
4430 pci_intr_setattr(pc, &sc->sc_intrs[0], PCI_INTR_MPSAFE, true);
4431 #endif
4432 sc->sc_ihs[0] = pci_intr_establish_xname(pc, sc->sc_intrs[0],
4433 IPL_NET, wm_intr_legacy, sc, device_xname(sc->sc_dev));
4434 if (sc->sc_ihs[0] == NULL) {
4435 aprint_error_dev(sc->sc_dev,"unable to establish %s\n",
4436 (pci_intr_type(pc, sc->sc_intrs[0])
4437 == PCI_INTR_TYPE_MSI) ? "MSI" : "INTx");
4438 return ENOMEM;
4439 }
4440
4441 aprint_normal_dev(sc->sc_dev, "interrupting at %s\n", intrstr);
4442 sc->sc_nintrs = 1;
4443 return 0;
4444 }
4445
4446 static int
4447 wm_setup_msix(struct wm_softc *sc)
4448 {
4449 void *vih;
4450 kcpuset_t *affinity;
4451 int qidx, error, intr_idx, txrx_established;
4452 pci_chipset_tag_t pc = sc->sc_pc;
4453 const char *intrstr = NULL;
4454 char intrbuf[PCI_INTRSTR_LEN];
4455 char intr_xname[INTRDEVNAMEBUF];
4456
4457 if (sc->sc_nqueues < ncpu) {
4458 /*
4459 * To avoid other devices' interrupts, the affinity of Tx/Rx
4460 * interrupts start from CPU#1.
4461 */
4462 sc->sc_affinity_offset = 1;
4463 } else {
4464 /*
4465 * In this case, this device use all CPUs. So, we unify
4466 * affinitied cpu_index to msix vector number for readability.
4467 */
4468 sc->sc_affinity_offset = 0;
4469 }
4470
4471 error = wm_alloc_txrx_queues(sc);
4472 if (error) {
4473 aprint_error_dev(sc->sc_dev, "cannot allocate queues %d\n",
4474 error);
4475 return ENOMEM;
4476 }
4477
4478 kcpuset_create(&affinity, false);
4479 intr_idx = 0;
4480
4481 /*
4482 * TX and RX
4483 */
4484 txrx_established = 0;
4485 for (qidx = 0; qidx < sc->sc_nqueues; qidx++) {
4486 struct wm_queue *wmq = &sc->sc_queue[qidx];
4487 int affinity_to = (sc->sc_affinity_offset + intr_idx) % ncpu;
4488
4489 intrstr = pci_intr_string(pc, sc->sc_intrs[intr_idx], intrbuf,
4490 sizeof(intrbuf));
4491 #ifdef WM_MPSAFE
4492 pci_intr_setattr(pc, &sc->sc_intrs[intr_idx],
4493 PCI_INTR_MPSAFE, true);
4494 #endif
4495 memset(intr_xname, 0, sizeof(intr_xname));
4496 snprintf(intr_xname, sizeof(intr_xname), "%sTXRX%d",
4497 device_xname(sc->sc_dev), qidx);
4498 vih = pci_intr_establish_xname(pc, sc->sc_intrs[intr_idx],
4499 IPL_NET, wm_txrxintr_msix, wmq, intr_xname);
4500 if (vih == NULL) {
4501 aprint_error_dev(sc->sc_dev,
4502 "unable to establish MSI-X(for TX and RX)%s%s\n",
4503 intrstr ? " at " : "",
4504 intrstr ? intrstr : "");
4505
4506 goto fail;
4507 }
4508 kcpuset_zero(affinity);
4509 /* Round-robin affinity */
4510 kcpuset_set(affinity, affinity_to);
4511 error = interrupt_distribute(vih, affinity, NULL);
4512 if (error == 0) {
4513 aprint_normal_dev(sc->sc_dev,
4514 "for TX and RX interrupting at %s affinity to %u\n",
4515 intrstr, affinity_to);
4516 } else {
4517 aprint_normal_dev(sc->sc_dev,
4518 "for TX and RX interrupting at %s\n", intrstr);
4519 }
4520 sc->sc_ihs[intr_idx] = vih;
4521 wmq->wmq_id= qidx;
4522 wmq->wmq_intr_idx = intr_idx;
4523
4524 txrx_established++;
4525 intr_idx++;
4526 }
4527
4528 /*
4529 * LINK
4530 */
4531 intrstr = pci_intr_string(pc, sc->sc_intrs[intr_idx], intrbuf,
4532 sizeof(intrbuf));
4533 #ifdef WM_MPSAFE
4534 pci_intr_setattr(pc, &sc->sc_intrs[intr_idx], PCI_INTR_MPSAFE, true);
4535 #endif
4536 memset(intr_xname, 0, sizeof(intr_xname));
4537 snprintf(intr_xname, sizeof(intr_xname), "%sLINK",
4538 device_xname(sc->sc_dev));
4539 vih = pci_intr_establish_xname(pc, sc->sc_intrs[intr_idx],
4540 IPL_NET, wm_linkintr_msix, sc, intr_xname);
4541 if (vih == NULL) {
4542 aprint_error_dev(sc->sc_dev,
4543 "unable to establish MSI-X(for LINK)%s%s\n",
4544 intrstr ? " at " : "",
4545 intrstr ? intrstr : "");
4546
4547 goto fail;
4548 }
4549 /* keep default affinity to LINK interrupt */
4550 aprint_normal_dev(sc->sc_dev,
4551 "for LINK interrupting at %s\n", intrstr);
4552 sc->sc_ihs[intr_idx] = vih;
4553 sc->sc_link_intr_idx = intr_idx;
4554
4555 sc->sc_nintrs = sc->sc_nqueues + 1;
4556 kcpuset_destroy(affinity);
4557 return 0;
4558
4559 fail:
4560 for (qidx = 0; qidx < txrx_established; qidx++) {
4561 struct wm_queue *wmq = &sc->sc_queue[qidx];
4562 pci_intr_disestablish(sc->sc_pc,sc->sc_ihs[wmq->wmq_intr_idx]);
4563 sc->sc_ihs[wmq->wmq_intr_idx] = NULL;
4564 }
4565
4566 kcpuset_destroy(affinity);
4567 return ENOMEM;
4568 }
4569
4570 static void
4571 wm_turnon(struct wm_softc *sc)
4572 {
4573 int i;
4574
4575 for(i = 0; i < sc->sc_nqueues; i++) {
4576 struct wm_txqueue *txq = &sc->sc_queue[i].wmq_txq;
4577 struct wm_rxqueue *rxq = &sc->sc_queue[i].wmq_rxq;
4578
4579 mutex_enter(txq->txq_lock);
4580 txq->txq_stopping = false;
4581 mutex_exit(txq->txq_lock);
4582
4583 mutex_enter(rxq->rxq_lock);
4584 rxq->rxq_stopping = false;
4585 mutex_exit(rxq->rxq_lock);
4586 }
4587
4588 WM_CORE_LOCK(sc);
4589 sc->sc_core_stopping = false;
4590 WM_CORE_UNLOCK(sc);
4591 }
4592
4593 static void
4594 wm_turnoff(struct wm_softc *sc)
4595 {
4596 int i;
4597
4598 WM_CORE_LOCK(sc);
4599 sc->sc_core_stopping = true;
4600 WM_CORE_UNLOCK(sc);
4601
4602 for(i = 0; i < sc->sc_nqueues; i++) {
4603 struct wm_rxqueue *rxq = &sc->sc_queue[i].wmq_rxq;
4604 struct wm_txqueue *txq = &sc->sc_queue[i].wmq_txq;
4605
4606 mutex_enter(rxq->rxq_lock);
4607 rxq->rxq_stopping = true;
4608 mutex_exit(rxq->rxq_lock);
4609
4610 mutex_enter(txq->txq_lock);
4611 txq->txq_stopping = true;
4612 mutex_exit(txq->txq_lock);
4613 }
4614 }
4615
4616 /*
4617 * wm_init: [ifnet interface function]
4618 *
4619 * Initialize the interface.
4620 */
4621 static int
4622 wm_init(struct ifnet *ifp)
4623 {
4624 struct wm_softc *sc = ifp->if_softc;
4625 int ret;
4626
4627 WM_CORE_LOCK(sc);
4628 ret = wm_init_locked(ifp);
4629 WM_CORE_UNLOCK(sc);
4630
4631 return ret;
4632 }
4633
4634 static int
4635 wm_init_locked(struct ifnet *ifp)
4636 {
4637 struct wm_softc *sc = ifp->if_softc;
4638 int i, j, trynum, error = 0;
4639 uint32_t reg;
4640
4641 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
4642 device_xname(sc->sc_dev), __func__));
4643 KASSERT(WM_CORE_LOCKED(sc));
4644
4645 /*
4646 * *_HDR_ALIGNED_P is constant 1 if __NO_STRICT_ALIGMENT is set.
4647 * There is a small but measurable benefit to avoiding the adjusment
4648 * of the descriptor so that the headers are aligned, for normal mtu,
4649 * on such platforms. One possibility is that the DMA itself is
4650 * slightly more efficient if the front of the entire packet (instead
4651 * of the front of the headers) is aligned.
4652 *
4653 * Note we must always set align_tweak to 0 if we are using
4654 * jumbo frames.
4655 */
4656 #ifdef __NO_STRICT_ALIGNMENT
4657 sc->sc_align_tweak = 0;
4658 #else
4659 if ((ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN) > (MCLBYTES - 2))
4660 sc->sc_align_tweak = 0;
4661 else
4662 sc->sc_align_tweak = 2;
4663 #endif /* __NO_STRICT_ALIGNMENT */
4664
4665 /* Cancel any pending I/O. */
4666 wm_stop_locked(ifp, 0);
4667
4668 /* update statistics before reset */
4669 ifp->if_collisions += CSR_READ(sc, WMREG_COLC);
4670 ifp->if_ierrors += CSR_READ(sc, WMREG_RXERRC);
4671
4672 /* Reset the chip to a known state. */
4673 wm_reset(sc);
4674
4675 switch (sc->sc_type) {
4676 case WM_T_82571:
4677 case WM_T_82572:
4678 case WM_T_82573:
4679 case WM_T_82574:
4680 case WM_T_82583:
4681 case WM_T_80003:
4682 case WM_T_ICH8:
4683 case WM_T_ICH9:
4684 case WM_T_ICH10:
4685 case WM_T_PCH:
4686 case WM_T_PCH2:
4687 case WM_T_PCH_LPT:
4688 case WM_T_PCH_SPT:
4689 /* AMT based hardware can now take control from firmware */
4690 if ((sc->sc_flags & WM_F_HAS_AMT) != 0)
4691 wm_get_hw_control(sc);
4692 break;
4693 default:
4694 break;
4695 }
4696
4697 /* Init hardware bits */
4698 wm_initialize_hardware_bits(sc);
4699
4700 /* Reset the PHY. */
4701 if (sc->sc_flags & WM_F_HAS_MII)
4702 wm_gmii_reset(sc);
4703
4704 /* Calculate (E)ITR value */
4705 if ((sc->sc_flags & WM_F_NEWQUEUE) != 0) {
4706 sc->sc_itr = 450; /* For EITR */
4707 } else if (sc->sc_type >= WM_T_82543) {
4708 /*
4709 * Set up the interrupt throttling register (units of 256ns)
4710 * Note that a footnote in Intel's documentation says this
4711 * ticker runs at 1/4 the rate when the chip is in 100Mbit
4712 * or 10Mbit mode. Empirically, it appears to be the case
4713 * that that is also true for the 1024ns units of the other
4714 * interrupt-related timer registers -- so, really, we ought
4715 * to divide this value by 4 when the link speed is low.
4716 *
4717 * XXX implement this division at link speed change!
4718 */
4719
4720 /*
4721 * For N interrupts/sec, set this value to:
4722 * 1000000000 / (N * 256). Note that we set the
4723 * absolute and packet timer values to this value
4724 * divided by 4 to get "simple timer" behavior.
4725 */
4726
4727 sc->sc_itr = 1500; /* 2604 ints/sec */
4728 }
4729
4730 error = wm_init_txrx_queues(sc);
4731 if (error)
4732 goto out;
4733
4734 /*
4735 * Clear out the VLAN table -- we don't use it (yet).
4736 */
4737 CSR_WRITE(sc, WMREG_VET, 0);
4738 if ((sc->sc_type == WM_T_I350) || (sc->sc_type == WM_T_I354))
4739 trynum = 10; /* Due to hw errata */
4740 else
4741 trynum = 1;
4742 for (i = 0; i < WM_VLAN_TABSIZE; i++)
4743 for (j = 0; j < trynum; j++)
4744 CSR_WRITE(sc, WMREG_VFTA + (i << 2), 0);
4745
4746 /*
4747 * Set up flow-control parameters.
4748 *
4749 * XXX Values could probably stand some tuning.
4750 */
4751 if ((sc->sc_type != WM_T_ICH8) && (sc->sc_type != WM_T_ICH9)
4752 && (sc->sc_type != WM_T_ICH10) && (sc->sc_type != WM_T_PCH)
4753 && (sc->sc_type != WM_T_PCH2) && (sc->sc_type != WM_T_PCH_LPT)
4754 && (sc->sc_type != WM_T_PCH_SPT)) {
4755 CSR_WRITE(sc, WMREG_FCAL, FCAL_CONST);
4756 CSR_WRITE(sc, WMREG_FCAH, FCAH_CONST);
4757 CSR_WRITE(sc, WMREG_FCT, ETHERTYPE_FLOWCONTROL);
4758 }
4759
4760 sc->sc_fcrtl = FCRTL_DFLT;
4761 if (sc->sc_type < WM_T_82543) {
4762 CSR_WRITE(sc, WMREG_OLD_FCRTH, FCRTH_DFLT);
4763 CSR_WRITE(sc, WMREG_OLD_FCRTL, sc->sc_fcrtl);
4764 } else {
4765 CSR_WRITE(sc, WMREG_FCRTH, FCRTH_DFLT);
4766 CSR_WRITE(sc, WMREG_FCRTL, sc->sc_fcrtl);
4767 }
4768
4769 if (sc->sc_type == WM_T_80003)
4770 CSR_WRITE(sc, WMREG_FCTTV, 0xffff);
4771 else
4772 CSR_WRITE(sc, WMREG_FCTTV, FCTTV_DFLT);
4773
4774 /* Writes the control register. */
4775 wm_set_vlan(sc);
4776
4777 if (sc->sc_flags & WM_F_HAS_MII) {
4778 int val;
4779
4780 switch (sc->sc_type) {
4781 case WM_T_80003:
4782 case WM_T_ICH8:
4783 case WM_T_ICH9:
4784 case WM_T_ICH10:
4785 case WM_T_PCH:
4786 case WM_T_PCH2:
4787 case WM_T_PCH_LPT:
4788 case WM_T_PCH_SPT:
4789 /*
4790 * Set the mac to wait the maximum time between each
4791 * iteration and increase the max iterations when
4792 * polling the phy; this fixes erroneous timeouts at
4793 * 10Mbps.
4794 */
4795 wm_kmrn_writereg(sc, KUMCTRLSTA_OFFSET_TIMEOUTS,
4796 0xFFFF);
4797 val = wm_kmrn_readreg(sc, KUMCTRLSTA_OFFSET_INB_PARAM);
4798 val |= 0x3F;
4799 wm_kmrn_writereg(sc,
4800 KUMCTRLSTA_OFFSET_INB_PARAM, val);
4801 break;
4802 default:
4803 break;
4804 }
4805
4806 if (sc->sc_type == WM_T_80003) {
4807 val = CSR_READ(sc, WMREG_CTRL_EXT);
4808 val &= ~CTRL_EXT_LINK_MODE_MASK;
4809 CSR_WRITE(sc, WMREG_CTRL_EXT, val);
4810
4811 /* Bypass RX and TX FIFO's */
4812 wm_kmrn_writereg(sc, KUMCTRLSTA_OFFSET_FIFO_CTRL,
4813 KUMCTRLSTA_FIFO_CTRL_RX_BYPASS
4814 | KUMCTRLSTA_FIFO_CTRL_TX_BYPASS);
4815 wm_kmrn_writereg(sc, KUMCTRLSTA_OFFSET_INB_CTRL,
4816 KUMCTRLSTA_INB_CTRL_DIS_PADDING |
4817 KUMCTRLSTA_INB_CTRL_LINK_TMOUT_DFLT);
4818 }
4819 }
4820 #if 0
4821 CSR_WRITE(sc, WMREG_CTRL_EXT, sc->sc_ctrl_ext);
4822 #endif
4823
4824 /* Set up checksum offload parameters. */
4825 reg = CSR_READ(sc, WMREG_RXCSUM);
4826 reg &= ~(RXCSUM_IPOFL | RXCSUM_IPV6OFL | RXCSUM_TUOFL);
4827 if (ifp->if_capenable & IFCAP_CSUM_IPv4_Rx)
4828 reg |= RXCSUM_IPOFL;
4829 if (ifp->if_capenable & (IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx))
4830 reg |= RXCSUM_IPOFL | RXCSUM_TUOFL;
4831 if (ifp->if_capenable & (IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_UDPv6_Rx))
4832 reg |= RXCSUM_IPV6OFL | RXCSUM_TUOFL;
4833 CSR_WRITE(sc, WMREG_RXCSUM, reg);
4834
4835 /* Set up MSI-X */
4836 if (sc->sc_nintrs > 1) {
4837 uint32_t ivar;
4838 struct wm_queue *wmq;
4839 int qid, qintr_idx;
4840
4841 if (sc->sc_type == WM_T_82575) {
4842 /* Interrupt control */
4843 reg = CSR_READ(sc, WMREG_CTRL_EXT);
4844 reg |= CTRL_EXT_PBA | CTRL_EXT_EIAME | CTRL_EXT_NSICR;
4845 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
4846
4847 /* TX and RX */
4848 for (i = 0; i < sc->sc_nqueues; i++) {
4849 wmq = &sc->sc_queue[i];
4850 CSR_WRITE(sc, WMREG_MSIXBM(wmq->wmq_intr_idx),
4851 EITR_TX_QUEUE(wmq->wmq_id)
4852 | EITR_RX_QUEUE(wmq->wmq_id));
4853 }
4854 /* Link status */
4855 CSR_WRITE(sc, WMREG_MSIXBM(sc->sc_link_intr_idx),
4856 EITR_OTHER);
4857 } else if (sc->sc_type == WM_T_82574) {
4858 /* Interrupt control */
4859 reg = CSR_READ(sc, WMREG_CTRL_EXT);
4860 reg |= CTRL_EXT_PBA | CTRL_EXT_EIAME;
4861 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
4862
4863 ivar = 0;
4864 /* TX and RX */
4865 for (i = 0; i < sc->sc_nqueues; i++) {
4866 wmq = &sc->sc_queue[i];
4867 qid = wmq->wmq_id;
4868 qintr_idx = wmq->wmq_intr_idx;
4869
4870 ivar |= __SHIFTIN((IVAR_VALID_82574|qintr_idx),
4871 IVAR_TX_MASK_Q_82574(qid));
4872 ivar |= __SHIFTIN((IVAR_VALID_82574|qintr_idx),
4873 IVAR_RX_MASK_Q_82574(qid));
4874 }
4875 /* Link status */
4876 ivar |= __SHIFTIN((IVAR_VALID_82574
4877 | sc->sc_link_intr_idx), IVAR_OTHER_MASK);
4878 CSR_WRITE(sc, WMREG_IVAR, ivar | IVAR_INT_ON_ALL_WB);
4879 } else {
4880 /* Interrupt control */
4881 CSR_WRITE(sc, WMREG_GPIE, GPIE_NSICR | GPIE_MULTI_MSIX
4882 | GPIE_EIAME | GPIE_PBA);
4883
4884 switch (sc->sc_type) {
4885 case WM_T_82580:
4886 case WM_T_I350:
4887 case WM_T_I354:
4888 case WM_T_I210:
4889 case WM_T_I211:
4890 /* TX and RX */
4891 for (i = 0; i < sc->sc_nqueues; i++) {
4892 wmq = &sc->sc_queue[i];
4893 qid = wmq->wmq_id;
4894 qintr_idx = wmq->wmq_intr_idx;
4895
4896 ivar = CSR_READ(sc, WMREG_IVAR_Q(qid));
4897 ivar &= ~IVAR_TX_MASK_Q(qid);
4898 ivar |= __SHIFTIN((qintr_idx
4899 | IVAR_VALID),
4900 IVAR_TX_MASK_Q(qid));
4901 ivar &= ~IVAR_RX_MASK_Q(qid);
4902 ivar |= __SHIFTIN((qintr_idx
4903 | IVAR_VALID),
4904 IVAR_RX_MASK_Q(qid));
4905 CSR_WRITE(sc, WMREG_IVAR_Q(qid), ivar);
4906 }
4907 break;
4908 case WM_T_82576:
4909 /* TX and RX */
4910 for (i = 0; i < sc->sc_nqueues; i++) {
4911 wmq = &sc->sc_queue[i];
4912 qid = wmq->wmq_id;
4913 qintr_idx = wmq->wmq_intr_idx;
4914
4915 ivar = CSR_READ(sc,
4916 WMREG_IVAR_Q_82576(qid));
4917 ivar &= ~IVAR_TX_MASK_Q_82576(qid);
4918 ivar |= __SHIFTIN((qintr_idx
4919 | IVAR_VALID),
4920 IVAR_TX_MASK_Q_82576(qid));
4921 ivar &= ~IVAR_RX_MASK_Q_82576(qid);
4922 ivar |= __SHIFTIN((qintr_idx
4923 | IVAR_VALID),
4924 IVAR_RX_MASK_Q_82576(qid));
4925 CSR_WRITE(sc, WMREG_IVAR_Q_82576(qid),
4926 ivar);
4927 }
4928 break;
4929 default:
4930 break;
4931 }
4932
4933 /* Link status */
4934 ivar = __SHIFTIN((sc->sc_link_intr_idx | IVAR_VALID),
4935 IVAR_MISC_OTHER);
4936 CSR_WRITE(sc, WMREG_IVAR_MISC, ivar);
4937 }
4938
4939 if (sc->sc_nqueues > 1) {
4940 wm_init_rss(sc);
4941
4942 /*
4943 ** NOTE: Receive Full-Packet Checksum Offload
4944 ** is mutually exclusive with Multiqueue. However
4945 ** this is not the same as TCP/IP checksums which
4946 ** still work.
4947 */
4948 reg = CSR_READ(sc, WMREG_RXCSUM);
4949 reg |= RXCSUM_PCSD;
4950 CSR_WRITE(sc, WMREG_RXCSUM, reg);
4951 }
4952 }
4953
4954 /* Set up the interrupt registers. */
4955 CSR_WRITE(sc, WMREG_IMC, 0xffffffffU);
4956 sc->sc_icr = ICR_TXDW | ICR_LSC | ICR_RXSEQ | ICR_RXDMT0 |
4957 ICR_RXO | ICR_RXT0;
4958 if (sc->sc_nintrs > 1) {
4959 uint32_t mask;
4960 struct wm_queue *wmq;
4961
4962 switch (sc->sc_type) {
4963 case WM_T_82574:
4964 CSR_WRITE(sc, WMREG_EIAC_82574,
4965 WMREG_EIAC_82574_MSIX_MASK);
4966 sc->sc_icr |= WMREG_EIAC_82574_MSIX_MASK;
4967 CSR_WRITE(sc, WMREG_IMS, sc->sc_icr);
4968 break;
4969 default:
4970 if (sc->sc_type == WM_T_82575) {
4971 mask = 0;
4972 for (i = 0; i < sc->sc_nqueues; i++) {
4973 wmq = &sc->sc_queue[i];
4974 mask |= EITR_TX_QUEUE(wmq->wmq_id);
4975 mask |= EITR_RX_QUEUE(wmq->wmq_id);
4976 }
4977 mask |= EITR_OTHER;
4978 } else {
4979 mask = 0;
4980 for (i = 0; i < sc->sc_nqueues; i++) {
4981 wmq = &sc->sc_queue[i];
4982 mask |= 1 << wmq->wmq_intr_idx;
4983 }
4984 mask |= 1 << sc->sc_link_intr_idx;
4985 }
4986 CSR_WRITE(sc, WMREG_EIAC, mask);
4987 CSR_WRITE(sc, WMREG_EIAM, mask);
4988 CSR_WRITE(sc, WMREG_EIMS, mask);
4989 CSR_WRITE(sc, WMREG_IMS, ICR_LSC);
4990 break;
4991 }
4992 } else
4993 CSR_WRITE(sc, WMREG_IMS, sc->sc_icr);
4994
4995 if ((sc->sc_type == WM_T_ICH8) || (sc->sc_type == WM_T_ICH9)
4996 || (sc->sc_type == WM_T_ICH10) || (sc->sc_type == WM_T_PCH)
4997 || (sc->sc_type == WM_T_PCH2) || (sc->sc_type == WM_T_PCH_LPT)
4998 || (sc->sc_type == WM_T_PCH_SPT)) {
4999 reg = CSR_READ(sc, WMREG_KABGTXD);
5000 reg |= KABGTXD_BGSQLBIAS;
5001 CSR_WRITE(sc, WMREG_KABGTXD, reg);
5002 }
5003
5004 /* Set up the inter-packet gap. */
5005 CSR_WRITE(sc, WMREG_TIPG, sc->sc_tipg);
5006
5007 if (sc->sc_type >= WM_T_82543) {
5008 /*
5009 * XXX 82574 has both ITR and EITR. SET EITR when we use
5010 * the multi queue function with MSI-X.
5011 */
5012 if ((sc->sc_flags & WM_F_NEWQUEUE) != 0) {
5013 int qidx;
5014 for (qidx = 0; qidx < sc->sc_nqueues; qidx++) {
5015 struct wm_queue *wmq = &sc->sc_queue[qidx];
5016 CSR_WRITE(sc, WMREG_EITR(wmq->wmq_intr_idx),
5017 sc->sc_itr);
5018 }
5019 /*
5020 * Link interrupts occur much less than TX
5021 * interrupts and RX interrupts. So, we don't
5022 * tune EINTR(WM_MSIX_LINKINTR_IDX) value like
5023 * FreeBSD's if_igb.
5024 */
5025 } else
5026 CSR_WRITE(sc, WMREG_ITR, sc->sc_itr);
5027 }
5028
5029 /* Set the VLAN ethernetype. */
5030 CSR_WRITE(sc, WMREG_VET, ETHERTYPE_VLAN);
5031
5032 /*
5033 * Set up the transmit control register; we start out with
5034 * a collision distance suitable for FDX, but update it whe
5035 * we resolve the media type.
5036 */
5037 sc->sc_tctl = TCTL_EN | TCTL_PSP | TCTL_RTLC
5038 | TCTL_CT(TX_COLLISION_THRESHOLD)
5039 | TCTL_COLD(TX_COLLISION_DISTANCE_FDX);
5040 if (sc->sc_type >= WM_T_82571)
5041 sc->sc_tctl |= TCTL_MULR;
5042 CSR_WRITE(sc, WMREG_TCTL, sc->sc_tctl);
5043
5044 if ((sc->sc_flags & WM_F_NEWQUEUE) != 0) {
5045 /* Write TDT after TCTL.EN is set. See the document. */
5046 CSR_WRITE(sc, WMREG_TDT(0), 0);
5047 }
5048
5049 if (sc->sc_type == WM_T_80003) {
5050 reg = CSR_READ(sc, WMREG_TCTL_EXT);
5051 reg &= ~TCTL_EXT_GCEX_MASK;
5052 reg |= DEFAULT_80003ES2LAN_TCTL_EXT_GCEX;
5053 CSR_WRITE(sc, WMREG_TCTL_EXT, reg);
5054 }
5055
5056 /* Set the media. */
5057 if ((error = mii_ifmedia_change(&sc->sc_mii)) != 0)
5058 goto out;
5059
5060 /* Configure for OS presence */
5061 wm_init_manageability(sc);
5062
5063 /*
5064 * Set up the receive control register; we actually program
5065 * the register when we set the receive filter. Use multicast
5066 * address offset type 0.
5067 *
5068 * Only the i82544 has the ability to strip the incoming
5069 * CRC, so we don't enable that feature.
5070 */
5071 sc->sc_mchash_type = 0;
5072 sc->sc_rctl = RCTL_EN | RCTL_LBM_NONE | RCTL_RDMTS_1_2 | RCTL_DPF
5073 | RCTL_MO(sc->sc_mchash_type);
5074
5075 /*
5076 * The I350 has a bug where it always strips the CRC whether
5077 * asked to or not. So ask for stripped CRC here and cope in rxeof
5078 */
5079 if ((sc->sc_type == WM_T_I350) || (sc->sc_type == WM_T_I354)
5080 || (sc->sc_type == WM_T_I210))
5081 sc->sc_rctl |= RCTL_SECRC;
5082
5083 if (((sc->sc_ethercom.ec_capabilities & ETHERCAP_JUMBO_MTU) != 0)
5084 && (ifp->if_mtu > ETHERMTU)) {
5085 sc->sc_rctl |= RCTL_LPE;
5086 if ((sc->sc_flags & WM_F_NEWQUEUE) != 0)
5087 CSR_WRITE(sc, WMREG_RLPML, ETHER_MAX_LEN_JUMBO);
5088 }
5089
5090 if (MCLBYTES == 2048) {
5091 sc->sc_rctl |= RCTL_2k;
5092 } else {
5093 if (sc->sc_type >= WM_T_82543) {
5094 switch (MCLBYTES) {
5095 case 4096:
5096 sc->sc_rctl |= RCTL_BSEX | RCTL_BSEX_4k;
5097 break;
5098 case 8192:
5099 sc->sc_rctl |= RCTL_BSEX | RCTL_BSEX_8k;
5100 break;
5101 case 16384:
5102 sc->sc_rctl |= RCTL_BSEX | RCTL_BSEX_16k;
5103 break;
5104 default:
5105 panic("wm_init: MCLBYTES %d unsupported",
5106 MCLBYTES);
5107 break;
5108 }
5109 } else panic("wm_init: i82542 requires MCLBYTES = 2048");
5110 }
5111
5112 /* Set the receive filter. */
5113 wm_set_filter(sc);
5114
5115 /* Enable ECC */
5116 switch (sc->sc_type) {
5117 case WM_T_82571:
5118 reg = CSR_READ(sc, WMREG_PBA_ECC);
5119 reg |= PBA_ECC_CORR_EN;
5120 CSR_WRITE(sc, WMREG_PBA_ECC, reg);
5121 break;
5122 case WM_T_PCH_LPT:
5123 case WM_T_PCH_SPT:
5124 reg = CSR_READ(sc, WMREG_PBECCSTS);
5125 reg |= PBECCSTS_UNCORR_ECC_ENABLE;
5126 CSR_WRITE(sc, WMREG_PBECCSTS, reg);
5127
5128 reg = CSR_READ(sc, WMREG_CTRL);
5129 reg |= CTRL_MEHE;
5130 CSR_WRITE(sc, WMREG_CTRL, reg);
5131 break;
5132 default:
5133 break;
5134 }
5135
5136 /* On 575 and later set RDT only if RX enabled */
5137 if ((sc->sc_flags & WM_F_NEWQUEUE) != 0) {
5138 int qidx;
5139 for (qidx = 0; qidx < sc->sc_nqueues; qidx++) {
5140 struct wm_rxqueue *rxq = &sc->sc_queue[qidx].wmq_rxq;
5141 for (i = 0; i < WM_NRXDESC; i++) {
5142 mutex_enter(rxq->rxq_lock);
5143 wm_init_rxdesc(rxq, i);
5144 mutex_exit(rxq->rxq_lock);
5145
5146 }
5147 }
5148 }
5149
5150 wm_turnon(sc);
5151
5152 /* Start the one second link check clock. */
5153 callout_reset(&sc->sc_tick_ch, hz, wm_tick, sc);
5154
5155 /* ...all done! */
5156 ifp->if_flags |= IFF_RUNNING;
5157 ifp->if_flags &= ~IFF_OACTIVE;
5158
5159 out:
5160 sc->sc_if_flags = ifp->if_flags;
5161 if (error)
5162 log(LOG_ERR, "%s: interface not running\n",
5163 device_xname(sc->sc_dev));
5164 return error;
5165 }
5166
5167 /*
5168 * wm_stop: [ifnet interface function]
5169 *
5170 * Stop transmission on the interface.
5171 */
5172 static void
5173 wm_stop(struct ifnet *ifp, int disable)
5174 {
5175 struct wm_softc *sc = ifp->if_softc;
5176
5177 WM_CORE_LOCK(sc);
5178 wm_stop_locked(ifp, disable);
5179 WM_CORE_UNLOCK(sc);
5180 }
5181
5182 static void
5183 wm_stop_locked(struct ifnet *ifp, int disable)
5184 {
5185 struct wm_softc *sc = ifp->if_softc;
5186 struct wm_txsoft *txs;
5187 int i, qidx;
5188
5189 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
5190 device_xname(sc->sc_dev), __func__));
5191 KASSERT(WM_CORE_LOCKED(sc));
5192
5193 wm_turnoff(sc);
5194
5195 /* Stop the one second clock. */
5196 callout_stop(&sc->sc_tick_ch);
5197
5198 /* Stop the 82547 Tx FIFO stall check timer. */
5199 if (sc->sc_type == WM_T_82547)
5200 callout_stop(&sc->sc_txfifo_ch);
5201
5202 if (sc->sc_flags & WM_F_HAS_MII) {
5203 /* Down the MII. */
5204 mii_down(&sc->sc_mii);
5205 } else {
5206 #if 0
5207 /* Should we clear PHY's status properly? */
5208 wm_reset(sc);
5209 #endif
5210 }
5211
5212 /* Stop the transmit and receive processes. */
5213 CSR_WRITE(sc, WMREG_TCTL, 0);
5214 CSR_WRITE(sc, WMREG_RCTL, 0);
5215 sc->sc_rctl &= ~RCTL_EN;
5216
5217 /*
5218 * Clear the interrupt mask to ensure the device cannot assert its
5219 * interrupt line.
5220 * Clear sc->sc_icr to ensure wm_intr_legacy() makes no attempt to
5221 * service any currently pending or shared interrupt.
5222 */
5223 CSR_WRITE(sc, WMREG_IMC, 0xffffffffU);
5224 sc->sc_icr = 0;
5225 if (sc->sc_nintrs > 1) {
5226 if (sc->sc_type != WM_T_82574) {
5227 CSR_WRITE(sc, WMREG_EIMC, 0xffffffffU);
5228 CSR_WRITE(sc, WMREG_EIAC, 0);
5229 } else
5230 CSR_WRITE(sc, WMREG_EIAC_82574, 0);
5231 }
5232
5233 /* Release any queued transmit buffers. */
5234 for (qidx = 0; qidx < sc->sc_nqueues; qidx++) {
5235 struct wm_queue *wmq = &sc->sc_queue[qidx];
5236 struct wm_txqueue *txq = &wmq->wmq_txq;
5237 mutex_enter(txq->txq_lock);
5238 for (i = 0; i < WM_TXQUEUELEN(txq); i++) {
5239 txs = &txq->txq_soft[i];
5240 if (txs->txs_mbuf != NULL) {
5241 bus_dmamap_unload(sc->sc_dmat,txs->txs_dmamap);
5242 m_freem(txs->txs_mbuf);
5243 txs->txs_mbuf = NULL;
5244 }
5245 }
5246 if (sc->sc_type == WM_T_PCH_SPT) {
5247 pcireg_t preg;
5248 uint32_t reg;
5249 int nexttx;
5250
5251 /* First, disable MULR fix in FEXTNVM11 */
5252 reg = CSR_READ(sc, WMREG_FEXTNVM11);
5253 reg |= FEXTNVM11_DIS_MULRFIX;
5254 CSR_WRITE(sc, WMREG_FEXTNVM11, reg);
5255
5256 preg = pci_conf_read(sc->sc_pc, sc->sc_pcitag,
5257 WM_PCI_DESCRING_STATUS);
5258 reg = CSR_READ(sc, WMREG_TDLEN(0));
5259 printf("XXX RST: FLUSH = %08x, len = %u\n",
5260 (uint32_t)(preg & DESCRING_STATUS_FLUSH_REQ), reg);
5261 if (((preg & DESCRING_STATUS_FLUSH_REQ) != 0)
5262 && (reg != 0)) {
5263 /* TX */
5264 printf("XXX need TX flush (reg = %08x)\n",
5265 preg);
5266 wm_init_tx_descs(sc, txq);
5267 wm_init_tx_regs(sc, wmq, txq);
5268 nexttx = txq->txq_next;
5269 wm_set_dma_addr(
5270 &txq->txq_descs[nexttx].wtx_addr,
5271 WM_CDTXADDR(txq, nexttx));
5272 txq->txq_descs[nexttx].wtx_cmdlen
5273 = htole32(WTX_CMD_IFCS | 512);
5274 wm_cdtxsync(txq, nexttx, 1,
5275 BUS_DMASYNC_PREREAD |BUS_DMASYNC_PREWRITE);
5276 CSR_WRITE(sc, WMREG_TCTL, TCTL_EN);
5277 CSR_WRITE(sc, WMREG_TDT(0), nexttx);
5278 CSR_WRITE_FLUSH(sc);
5279 delay(250);
5280 CSR_WRITE(sc, WMREG_TCTL, 0);
5281 }
5282 preg = pci_conf_read(sc->sc_pc, sc->sc_pcitag,
5283 WM_PCI_DESCRING_STATUS);
5284 if (preg & DESCRING_STATUS_FLUSH_REQ) {
5285 /* RX */
5286 printf("XXX need RX flush\n");
5287 }
5288 }
5289 mutex_exit(txq->txq_lock);
5290 }
5291
5292 /* Mark the interface as down and cancel the watchdog timer. */
5293 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
5294 ifp->if_timer = 0;
5295
5296 if (disable) {
5297 for (i = 0; i < sc->sc_nqueues; i++) {
5298 struct wm_rxqueue *rxq = &sc->sc_queue[i].wmq_rxq;
5299 mutex_enter(rxq->rxq_lock);
5300 wm_rxdrain(rxq);
5301 mutex_exit(rxq->rxq_lock);
5302 }
5303 }
5304
5305 #if 0 /* notyet */
5306 if (sc->sc_type >= WM_T_82544)
5307 CSR_WRITE(sc, WMREG_WUC, 0);
5308 #endif
5309 }
5310
5311 static void
5312 wm_dump_mbuf_chain(struct wm_softc *sc, struct mbuf *m0)
5313 {
5314 struct mbuf *m;
5315 int i;
5316
5317 log(LOG_DEBUG, "%s: mbuf chain:\n", device_xname(sc->sc_dev));
5318 for (m = m0, i = 0; m != NULL; m = m->m_next, i++)
5319 log(LOG_DEBUG, "%s:\tm_data = %p, m_len = %d, "
5320 "m_flags = 0x%08x\n", device_xname(sc->sc_dev),
5321 m->m_data, m->m_len, m->m_flags);
5322 log(LOG_DEBUG, "%s:\t%d mbuf%s in chain\n", device_xname(sc->sc_dev),
5323 i, i == 1 ? "" : "s");
5324 }
5325
5326 /*
5327 * wm_82547_txfifo_stall:
5328 *
5329 * Callout used to wait for the 82547 Tx FIFO to drain,
5330 * reset the FIFO pointers, and restart packet transmission.
5331 */
5332 static void
5333 wm_82547_txfifo_stall(void *arg)
5334 {
5335 struct wm_softc *sc = arg;
5336 struct wm_txqueue *txq = &sc->sc_queue[0].wmq_txq;
5337
5338 mutex_enter(txq->txq_lock);
5339
5340 if (txq->txq_stopping)
5341 goto out;
5342
5343 if (txq->txq_fifo_stall) {
5344 if (CSR_READ(sc, WMREG_TDT(0)) == CSR_READ(sc, WMREG_TDH(0)) &&
5345 CSR_READ(sc, WMREG_TDFT) == CSR_READ(sc, WMREG_TDFH) &&
5346 CSR_READ(sc, WMREG_TDFTS) == CSR_READ(sc, WMREG_TDFHS)) {
5347 /*
5348 * Packets have drained. Stop transmitter, reset
5349 * FIFO pointers, restart transmitter, and kick
5350 * the packet queue.
5351 */
5352 uint32_t tctl = CSR_READ(sc, WMREG_TCTL);
5353 CSR_WRITE(sc, WMREG_TCTL, tctl & ~TCTL_EN);
5354 CSR_WRITE(sc, WMREG_TDFT, txq->txq_fifo_addr);
5355 CSR_WRITE(sc, WMREG_TDFH, txq->txq_fifo_addr);
5356 CSR_WRITE(sc, WMREG_TDFTS, txq->txq_fifo_addr);
5357 CSR_WRITE(sc, WMREG_TDFHS, txq->txq_fifo_addr);
5358 CSR_WRITE(sc, WMREG_TCTL, tctl);
5359 CSR_WRITE_FLUSH(sc);
5360
5361 txq->txq_fifo_head = 0;
5362 txq->txq_fifo_stall = 0;
5363 wm_start_locked(&sc->sc_ethercom.ec_if);
5364 } else {
5365 /*
5366 * Still waiting for packets to drain; try again in
5367 * another tick.
5368 */
5369 callout_schedule(&sc->sc_txfifo_ch, 1);
5370 }
5371 }
5372
5373 out:
5374 mutex_exit(txq->txq_lock);
5375 }
5376
5377 /*
5378 * wm_82547_txfifo_bugchk:
5379 *
5380 * Check for bug condition in the 82547 Tx FIFO. We need to
5381 * prevent enqueueing a packet that would wrap around the end
5382 * if the Tx FIFO ring buffer, otherwise the chip will croak.
5383 *
5384 * We do this by checking the amount of space before the end
5385 * of the Tx FIFO buffer. If the packet will not fit, we "stall"
5386 * the Tx FIFO, wait for all remaining packets to drain, reset
5387 * the internal FIFO pointers to the beginning, and restart
5388 * transmission on the interface.
5389 */
5390 #define WM_FIFO_HDR 0x10
5391 #define WM_82547_PAD_LEN 0x3e0
5392 static int
5393 wm_82547_txfifo_bugchk(struct wm_softc *sc, struct mbuf *m0)
5394 {
5395 struct wm_txqueue *txq = &sc->sc_queue[0].wmq_txq;
5396 int space = txq->txq_fifo_size - txq->txq_fifo_head;
5397 int len = roundup(m0->m_pkthdr.len + WM_FIFO_HDR, WM_FIFO_HDR);
5398
5399 /* Just return if already stalled. */
5400 if (txq->txq_fifo_stall)
5401 return 1;
5402
5403 if (sc->sc_mii.mii_media_active & IFM_FDX) {
5404 /* Stall only occurs in half-duplex mode. */
5405 goto send_packet;
5406 }
5407
5408 if (len >= WM_82547_PAD_LEN + space) {
5409 txq->txq_fifo_stall = 1;
5410 callout_schedule(&sc->sc_txfifo_ch, 1);
5411 return 1;
5412 }
5413
5414 send_packet:
5415 txq->txq_fifo_head += len;
5416 if (txq->txq_fifo_head >= txq->txq_fifo_size)
5417 txq->txq_fifo_head -= txq->txq_fifo_size;
5418
5419 return 0;
5420 }
5421
5422 static int
5423 wm_alloc_tx_descs(struct wm_softc *sc, struct wm_txqueue *txq)
5424 {
5425 int error;
5426
5427 /*
5428 * Allocate the control data structures, and create and load the
5429 * DMA map for it.
5430 *
5431 * NOTE: All Tx descriptors must be in the same 4G segment of
5432 * memory. So must Rx descriptors. We simplify by allocating
5433 * both sets within the same 4G segment.
5434 */
5435 if (sc->sc_type < WM_T_82544)
5436 WM_NTXDESC(txq) = WM_NTXDESC_82542;
5437 else
5438 WM_NTXDESC(txq) = WM_NTXDESC_82544;
5439 if ((sc->sc_flags & WM_F_NEWQUEUE) != 0)
5440 txq->txq_descsize = sizeof(nq_txdesc_t);
5441 else
5442 txq->txq_descsize = sizeof(wiseman_txdesc_t);
5443
5444 if ((error = bus_dmamem_alloc(sc->sc_dmat, WM_TXDESCS_SIZE(txq),
5445 PAGE_SIZE, (bus_size_t) 0x100000000ULL, &txq->txq_desc_seg,
5446 1, &txq->txq_desc_rseg, 0)) != 0) {
5447 aprint_error_dev(sc->sc_dev,
5448 "unable to allocate TX control data, error = %d\n",
5449 error);
5450 goto fail_0;
5451 }
5452
5453 if ((error = bus_dmamem_map(sc->sc_dmat, &txq->txq_desc_seg,
5454 txq->txq_desc_rseg, WM_TXDESCS_SIZE(txq),
5455 (void **)&txq->txq_descs_u, BUS_DMA_COHERENT)) != 0) {
5456 aprint_error_dev(sc->sc_dev,
5457 "unable to map TX control data, error = %d\n", error);
5458 goto fail_1;
5459 }
5460
5461 if ((error = bus_dmamap_create(sc->sc_dmat, WM_TXDESCS_SIZE(txq), 1,
5462 WM_TXDESCS_SIZE(txq), 0, 0, &txq->txq_desc_dmamap)) != 0) {
5463 aprint_error_dev(sc->sc_dev,
5464 "unable to create TX control data DMA map, error = %d\n",
5465 error);
5466 goto fail_2;
5467 }
5468
5469 if ((error = bus_dmamap_load(sc->sc_dmat, txq->txq_desc_dmamap,
5470 txq->txq_descs_u, WM_TXDESCS_SIZE(txq), NULL, 0)) != 0) {
5471 aprint_error_dev(sc->sc_dev,
5472 "unable to load TX control data DMA map, error = %d\n",
5473 error);
5474 goto fail_3;
5475 }
5476
5477 return 0;
5478
5479 fail_3:
5480 bus_dmamap_destroy(sc->sc_dmat, txq->txq_desc_dmamap);
5481 fail_2:
5482 bus_dmamem_unmap(sc->sc_dmat, (void *)txq->txq_descs_u,
5483 WM_TXDESCS_SIZE(txq));
5484 fail_1:
5485 bus_dmamem_free(sc->sc_dmat, &txq->txq_desc_seg, txq->txq_desc_rseg);
5486 fail_0:
5487 return error;
5488 }
5489
5490 static void
5491 wm_free_tx_descs(struct wm_softc *sc, struct wm_txqueue *txq)
5492 {
5493
5494 bus_dmamap_unload(sc->sc_dmat, txq->txq_desc_dmamap);
5495 bus_dmamap_destroy(sc->sc_dmat, txq->txq_desc_dmamap);
5496 bus_dmamem_unmap(sc->sc_dmat, (void *)txq->txq_descs_u,
5497 WM_TXDESCS_SIZE(txq));
5498 bus_dmamem_free(sc->sc_dmat, &txq->txq_desc_seg, txq->txq_desc_rseg);
5499 }
5500
5501 static int
5502 wm_alloc_rx_descs(struct wm_softc *sc, struct wm_rxqueue *rxq)
5503 {
5504 int error;
5505
5506 /*
5507 * Allocate the control data structures, and create and load the
5508 * DMA map for it.
5509 *
5510 * NOTE: All Tx descriptors must be in the same 4G segment of
5511 * memory. So must Rx descriptors. We simplify by allocating
5512 * both sets within the same 4G segment.
5513 */
5514 rxq->rxq_desc_size = sizeof(wiseman_rxdesc_t) * WM_NRXDESC;
5515 if ((error = bus_dmamem_alloc(sc->sc_dmat, rxq->rxq_desc_size,
5516 PAGE_SIZE, (bus_size_t) 0x100000000ULL, &rxq->rxq_desc_seg,
5517 1, &rxq->rxq_desc_rseg, 0)) != 0) {
5518 aprint_error_dev(sc->sc_dev,
5519 "unable to allocate RX control data, error = %d\n",
5520 error);
5521 goto fail_0;
5522 }
5523
5524 if ((error = bus_dmamem_map(sc->sc_dmat, &rxq->rxq_desc_seg,
5525 rxq->rxq_desc_rseg, rxq->rxq_desc_size,
5526 (void **)&rxq->rxq_descs, BUS_DMA_COHERENT)) != 0) {
5527 aprint_error_dev(sc->sc_dev,
5528 "unable to map RX control data, error = %d\n", error);
5529 goto fail_1;
5530 }
5531
5532 if ((error = bus_dmamap_create(sc->sc_dmat, rxq->rxq_desc_size, 1,
5533 rxq->rxq_desc_size, 0, 0, &rxq->rxq_desc_dmamap)) != 0) {
5534 aprint_error_dev(sc->sc_dev,
5535 "unable to create RX control data DMA map, error = %d\n",
5536 error);
5537 goto fail_2;
5538 }
5539
5540 if ((error = bus_dmamap_load(sc->sc_dmat, rxq->rxq_desc_dmamap,
5541 rxq->rxq_descs, rxq->rxq_desc_size, NULL, 0)) != 0) {
5542 aprint_error_dev(sc->sc_dev,
5543 "unable to load RX control data DMA map, error = %d\n",
5544 error);
5545 goto fail_3;
5546 }
5547
5548 return 0;
5549
5550 fail_3:
5551 bus_dmamap_destroy(sc->sc_dmat, rxq->rxq_desc_dmamap);
5552 fail_2:
5553 bus_dmamem_unmap(sc->sc_dmat, (void *)rxq->rxq_descs,
5554 rxq->rxq_desc_size);
5555 fail_1:
5556 bus_dmamem_free(sc->sc_dmat, &rxq->rxq_desc_seg, rxq->rxq_desc_rseg);
5557 fail_0:
5558 return error;
5559 }
5560
5561 static void
5562 wm_free_rx_descs(struct wm_softc *sc, struct wm_rxqueue *rxq)
5563 {
5564
5565 bus_dmamap_unload(sc->sc_dmat, rxq->rxq_desc_dmamap);
5566 bus_dmamap_destroy(sc->sc_dmat, rxq->rxq_desc_dmamap);
5567 bus_dmamem_unmap(sc->sc_dmat, (void *)rxq->rxq_descs,
5568 rxq->rxq_desc_size);
5569 bus_dmamem_free(sc->sc_dmat, &rxq->rxq_desc_seg, rxq->rxq_desc_rseg);
5570 }
5571
5572
5573 static int
5574 wm_alloc_tx_buffer(struct wm_softc *sc, struct wm_txqueue *txq)
5575 {
5576 int i, error;
5577
5578 /* Create the transmit buffer DMA maps. */
5579 WM_TXQUEUELEN(txq) =
5580 (sc->sc_type == WM_T_82547 || sc->sc_type == WM_T_82547_2) ?
5581 WM_TXQUEUELEN_MAX_82547 : WM_TXQUEUELEN_MAX;
5582 for (i = 0; i < WM_TXQUEUELEN(txq); i++) {
5583 if ((error = bus_dmamap_create(sc->sc_dmat, WM_MAXTXDMA,
5584 WM_NTXSEGS, WTX_MAX_LEN, 0, 0,
5585 &txq->txq_soft[i].txs_dmamap)) != 0) {
5586 aprint_error_dev(sc->sc_dev,
5587 "unable to create Tx DMA map %d, error = %d\n",
5588 i, error);
5589 goto fail;
5590 }
5591 }
5592
5593 return 0;
5594
5595 fail:
5596 for (i = 0; i < WM_TXQUEUELEN(txq); i++) {
5597 if (txq->txq_soft[i].txs_dmamap != NULL)
5598 bus_dmamap_destroy(sc->sc_dmat,
5599 txq->txq_soft[i].txs_dmamap);
5600 }
5601 return error;
5602 }
5603
5604 static void
5605 wm_free_tx_buffer(struct wm_softc *sc, struct wm_txqueue *txq)
5606 {
5607 int i;
5608
5609 for (i = 0; i < WM_TXQUEUELEN(txq); i++) {
5610 if (txq->txq_soft[i].txs_dmamap != NULL)
5611 bus_dmamap_destroy(sc->sc_dmat,
5612 txq->txq_soft[i].txs_dmamap);
5613 }
5614 }
5615
5616 static int
5617 wm_alloc_rx_buffer(struct wm_softc *sc, struct wm_rxqueue *rxq)
5618 {
5619 int i, error;
5620
5621 /* Create the receive buffer DMA maps. */
5622 for (i = 0; i < WM_NRXDESC; i++) {
5623 if ((error = bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1,
5624 MCLBYTES, 0, 0,
5625 &rxq->rxq_soft[i].rxs_dmamap)) != 0) {
5626 aprint_error_dev(sc->sc_dev,
5627 "unable to create Rx DMA map %d error = %d\n",
5628 i, error);
5629 goto fail;
5630 }
5631 rxq->rxq_soft[i].rxs_mbuf = NULL;
5632 }
5633
5634 return 0;
5635
5636 fail:
5637 for (i = 0; i < WM_NRXDESC; i++) {
5638 if (rxq->rxq_soft[i].rxs_dmamap != NULL)
5639 bus_dmamap_destroy(sc->sc_dmat,
5640 rxq->rxq_soft[i].rxs_dmamap);
5641 }
5642 return error;
5643 }
5644
5645 static void
5646 wm_free_rx_buffer(struct wm_softc *sc, struct wm_rxqueue *rxq)
5647 {
5648 int i;
5649
5650 for (i = 0; i < WM_NRXDESC; i++) {
5651 if (rxq->rxq_soft[i].rxs_dmamap != NULL)
5652 bus_dmamap_destroy(sc->sc_dmat,
5653 rxq->rxq_soft[i].rxs_dmamap);
5654 }
5655 }
5656
5657 /*
5658 * wm_alloc_quques:
5659 * Allocate {tx,rx}descs and {tx,rx} buffers
5660 */
5661 static int
5662 wm_alloc_txrx_queues(struct wm_softc *sc)
5663 {
5664 int i, error, tx_done, rx_done;
5665
5666 sc->sc_queue = kmem_zalloc(sizeof(struct wm_queue) * sc->sc_nqueues,
5667 KM_SLEEP);
5668 if (sc->sc_queue == NULL) {
5669 aprint_error_dev(sc->sc_dev,"unable to allocate wm_queue\n");
5670 error = ENOMEM;
5671 goto fail_0;
5672 }
5673
5674 /*
5675 * For transmission
5676 */
5677 error = 0;
5678 tx_done = 0;
5679 for (i = 0; i < sc->sc_nqueues; i++) {
5680 #ifdef WM_EVENT_COUNTERS
5681 int j;
5682 const char *xname;
5683 #endif
5684 struct wm_txqueue *txq = &sc->sc_queue[i].wmq_txq;
5685 txq->txq_sc = sc;
5686 txq->txq_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NET);
5687
5688 error = wm_alloc_tx_descs(sc, txq);
5689 if (error)
5690 break;
5691 error = wm_alloc_tx_buffer(sc, txq);
5692 if (error) {
5693 wm_free_tx_descs(sc, txq);
5694 break;
5695 }
5696 txq->txq_interq = pcq_create(WM_TXINTERQSIZE, KM_SLEEP);
5697 if (txq->txq_interq == NULL) {
5698 wm_free_tx_descs(sc, txq);
5699 wm_free_tx_buffer(sc, txq);
5700 error = ENOMEM;
5701 break;
5702 }
5703
5704 #ifdef WM_EVENT_COUNTERS
5705 xname = device_xname(sc->sc_dev);
5706
5707 WM_Q_MISC_EVCNT_ATTACH(txq, txsstall, txq, i, xname);
5708 WM_Q_MISC_EVCNT_ATTACH(txq, txdstall, txq, i, xname);
5709 WM_Q_MISC_EVCNT_ATTACH(txq, txfifo_stall, txq, i, xname);
5710 WM_Q_INTR_EVCNT_ATTACH(txq, txdw, txq, i, xname);
5711 WM_Q_INTR_EVCNT_ATTACH(txq, txqe, txq, i, xname);
5712
5713 WM_Q_MISC_EVCNT_ATTACH(txq, txipsum, txq, i, xname);
5714 WM_Q_MISC_EVCNT_ATTACH(txq, txtusum, txq, i, xname);
5715 WM_Q_MISC_EVCNT_ATTACH(txq, txtusum6, txq, i, xname);
5716 WM_Q_MISC_EVCNT_ATTACH(txq, txtso, txq, i, xname);
5717 WM_Q_MISC_EVCNT_ATTACH(txq, txtso6, txq, i, xname);
5718 WM_Q_MISC_EVCNT_ATTACH(txq, txtsopain, txq, i, xname);
5719
5720 for (j = 0; j < WM_NTXSEGS; j++) {
5721 snprintf(txq->txq_txseg_evcnt_names[j],
5722 sizeof(txq->txq_txseg_evcnt_names[j]), "txq%02dtxseg%d", i, j);
5723 evcnt_attach_dynamic(&txq->txq_ev_txseg[j], EVCNT_TYPE_MISC,
5724 NULL, xname, txq->txq_txseg_evcnt_names[j]);
5725 }
5726
5727 WM_Q_MISC_EVCNT_ATTACH(txq, txdrop, txq, i, xname);
5728
5729 WM_Q_MISC_EVCNT_ATTACH(txq, tu, txq, i, xname);
5730 #endif /* WM_EVENT_COUNTERS */
5731
5732 tx_done++;
5733 }
5734 if (error)
5735 goto fail_1;
5736
5737 /*
5738 * For recieve
5739 */
5740 error = 0;
5741 rx_done = 0;
5742 for (i = 0; i < sc->sc_nqueues; i++) {
5743 #ifdef WM_EVENT_COUNTERS
5744 const char *xname;
5745 #endif
5746 struct wm_rxqueue *rxq = &sc->sc_queue[i].wmq_rxq;
5747 rxq->rxq_sc = sc;
5748 rxq->rxq_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NET);
5749
5750 error = wm_alloc_rx_descs(sc, rxq);
5751 if (error)
5752 break;
5753
5754 error = wm_alloc_rx_buffer(sc, rxq);
5755 if (error) {
5756 wm_free_rx_descs(sc, rxq);
5757 break;
5758 }
5759
5760 #ifdef WM_EVENT_COUNTERS
5761 xname = device_xname(sc->sc_dev);
5762
5763 WM_Q_INTR_EVCNT_ATTACH(rxq, rxintr, rxq, i, xname);
5764
5765 WM_Q_INTR_EVCNT_ATTACH(rxq, rxipsum, rxq, i, xname);
5766 WM_Q_INTR_EVCNT_ATTACH(rxq, rxtusum, rxq, i, xname);
5767 #endif /* WM_EVENT_COUNTERS */
5768
5769 rx_done++;
5770 }
5771 if (error)
5772 goto fail_2;
5773
5774 return 0;
5775
5776 fail_2:
5777 for (i = 0; i < rx_done; i++) {
5778 struct wm_rxqueue *rxq = &sc->sc_queue[i].wmq_rxq;
5779 wm_free_rx_buffer(sc, rxq);
5780 wm_free_rx_descs(sc, rxq);
5781 if (rxq->rxq_lock)
5782 mutex_obj_free(rxq->rxq_lock);
5783 }
5784 fail_1:
5785 for (i = 0; i < tx_done; i++) {
5786 struct wm_txqueue *txq = &sc->sc_queue[i].wmq_txq;
5787 pcq_destroy(txq->txq_interq);
5788 wm_free_tx_buffer(sc, txq);
5789 wm_free_tx_descs(sc, txq);
5790 if (txq->txq_lock)
5791 mutex_obj_free(txq->txq_lock);
5792 }
5793
5794 kmem_free(sc->sc_queue,
5795 sizeof(struct wm_queue) * sc->sc_nqueues);
5796 fail_0:
5797 return error;
5798 }
5799
5800 /*
5801 * wm_free_quques:
5802 * Free {tx,rx}descs and {tx,rx} buffers
5803 */
5804 static void
5805 wm_free_txrx_queues(struct wm_softc *sc)
5806 {
5807 int i;
5808
5809 for (i = 0; i < sc->sc_nqueues; i++) {
5810 struct wm_rxqueue *rxq = &sc->sc_queue[i].wmq_rxq;
5811 wm_free_rx_buffer(sc, rxq);
5812 wm_free_rx_descs(sc, rxq);
5813 if (rxq->rxq_lock)
5814 mutex_obj_free(rxq->rxq_lock);
5815 }
5816
5817 for (i = 0; i < sc->sc_nqueues; i++) {
5818 struct wm_txqueue *txq = &sc->sc_queue[i].wmq_txq;
5819 wm_free_tx_buffer(sc, txq);
5820 wm_free_tx_descs(sc, txq);
5821 if (txq->txq_lock)
5822 mutex_obj_free(txq->txq_lock);
5823 }
5824
5825 kmem_free(sc->sc_queue, sizeof(struct wm_queue) * sc->sc_nqueues);
5826 }
5827
5828 static void
5829 wm_init_tx_descs(struct wm_softc *sc __unused, struct wm_txqueue *txq)
5830 {
5831
5832 KASSERT(mutex_owned(txq->txq_lock));
5833
5834 /* Initialize the transmit descriptor ring. */
5835 memset(txq->txq_descs, 0, WM_TXDESCS_SIZE(txq));
5836 wm_cdtxsync(txq, 0, WM_NTXDESC(txq),
5837 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
5838 txq->txq_free = WM_NTXDESC(txq);
5839 txq->txq_next = 0;
5840 }
5841
5842 static void
5843 wm_init_tx_regs(struct wm_softc *sc, struct wm_queue *wmq,
5844 struct wm_txqueue *txq)
5845 {
5846
5847 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
5848 device_xname(sc->sc_dev), __func__));
5849 KASSERT(mutex_owned(txq->txq_lock));
5850
5851 if (sc->sc_type < WM_T_82543) {
5852 CSR_WRITE(sc, WMREG_OLD_TDBAH, WM_CDTXADDR_HI(txq, 0));
5853 CSR_WRITE(sc, WMREG_OLD_TDBAL, WM_CDTXADDR_LO(txq, 0));
5854 CSR_WRITE(sc, WMREG_OLD_TDLEN, WM_TXDESCS_SIZE(txq));
5855 CSR_WRITE(sc, WMREG_OLD_TDH, 0);
5856 CSR_WRITE(sc, WMREG_OLD_TDT, 0);
5857 CSR_WRITE(sc, WMREG_OLD_TIDV, 128);
5858 } else {
5859 int qid = wmq->wmq_id;
5860
5861 CSR_WRITE(sc, WMREG_TDBAH(qid), WM_CDTXADDR_HI(txq, 0));
5862 CSR_WRITE(sc, WMREG_TDBAL(qid), WM_CDTXADDR_LO(txq, 0));
5863 CSR_WRITE(sc, WMREG_TDLEN(qid), WM_TXDESCS_SIZE(txq));
5864 CSR_WRITE(sc, WMREG_TDH(qid), 0);
5865
5866 if ((sc->sc_flags & WM_F_NEWQUEUE) != 0)
5867 /*
5868 * Don't write TDT before TCTL.EN is set.
5869 * See the document.
5870 */
5871 CSR_WRITE(sc, WMREG_TXDCTL(qid), TXDCTL_QUEUE_ENABLE
5872 | TXDCTL_PTHRESH(0) | TXDCTL_HTHRESH(0)
5873 | TXDCTL_WTHRESH(0));
5874 else {
5875 /* ITR / 4 */
5876 CSR_WRITE(sc, WMREG_TIDV, sc->sc_itr / 4);
5877 if (sc->sc_type >= WM_T_82540) {
5878 /* should be same */
5879 CSR_WRITE(sc, WMREG_TADV, sc->sc_itr / 4);
5880 }
5881
5882 CSR_WRITE(sc, WMREG_TDT(qid), 0);
5883 CSR_WRITE(sc, WMREG_TXDCTL(qid), TXDCTL_PTHRESH(0) |
5884 TXDCTL_HTHRESH(0) | TXDCTL_WTHRESH(0));
5885 }
5886 }
5887 }
5888
5889 static void
5890 wm_init_tx_buffer(struct wm_softc *sc __unused, struct wm_txqueue *txq)
5891 {
5892 int i;
5893
5894 KASSERT(mutex_owned(txq->txq_lock));
5895
5896 /* Initialize the transmit job descriptors. */
5897 for (i = 0; i < WM_TXQUEUELEN(txq); i++)
5898 txq->txq_soft[i].txs_mbuf = NULL;
5899 txq->txq_sfree = WM_TXQUEUELEN(txq);
5900 txq->txq_snext = 0;
5901 txq->txq_sdirty = 0;
5902 }
5903
5904 static void
5905 wm_init_tx_queue(struct wm_softc *sc, struct wm_queue *wmq,
5906 struct wm_txqueue *txq)
5907 {
5908
5909 KASSERT(mutex_owned(txq->txq_lock));
5910
5911 /*
5912 * Set up some register offsets that are different between
5913 * the i82542 and the i82543 and later chips.
5914 */
5915 if (sc->sc_type < WM_T_82543)
5916 txq->txq_tdt_reg = WMREG_OLD_TDT;
5917 else
5918 txq->txq_tdt_reg = WMREG_TDT(wmq->wmq_id);
5919
5920 wm_init_tx_descs(sc, txq);
5921 wm_init_tx_regs(sc, wmq, txq);
5922 wm_init_tx_buffer(sc, txq);
5923 }
5924
5925 static void
5926 wm_init_rx_regs(struct wm_softc *sc, struct wm_queue *wmq,
5927 struct wm_rxqueue *rxq)
5928 {
5929
5930 KASSERT(mutex_owned(rxq->rxq_lock));
5931
5932 /*
5933 * Initialize the receive descriptor and receive job
5934 * descriptor rings.
5935 */
5936 if (sc->sc_type < WM_T_82543) {
5937 CSR_WRITE(sc, WMREG_OLD_RDBAH0, WM_CDRXADDR_HI(rxq, 0));
5938 CSR_WRITE(sc, WMREG_OLD_RDBAL0, WM_CDRXADDR_LO(rxq, 0));
5939 CSR_WRITE(sc, WMREG_OLD_RDLEN0,
5940 sizeof(wiseman_rxdesc_t) * WM_NRXDESC);
5941 CSR_WRITE(sc, WMREG_OLD_RDH0, 0);
5942 CSR_WRITE(sc, WMREG_OLD_RDT0, 0);
5943 CSR_WRITE(sc, WMREG_OLD_RDTR0, 28 | RDTR_FPD);
5944
5945 CSR_WRITE(sc, WMREG_OLD_RDBA1_HI, 0);
5946 CSR_WRITE(sc, WMREG_OLD_RDBA1_LO, 0);
5947 CSR_WRITE(sc, WMREG_OLD_RDLEN1, 0);
5948 CSR_WRITE(sc, WMREG_OLD_RDH1, 0);
5949 CSR_WRITE(sc, WMREG_OLD_RDT1, 0);
5950 CSR_WRITE(sc, WMREG_OLD_RDTR1, 0);
5951 } else {
5952 int qid = wmq->wmq_id;
5953
5954 CSR_WRITE(sc, WMREG_RDBAH(qid), WM_CDRXADDR_HI(rxq, 0));
5955 CSR_WRITE(sc, WMREG_RDBAL(qid), WM_CDRXADDR_LO(rxq, 0));
5956 CSR_WRITE(sc, WMREG_RDLEN(qid), rxq->rxq_desc_size);
5957
5958 if ((sc->sc_flags & WM_F_NEWQUEUE) != 0) {
5959 if (MCLBYTES & ((1 << SRRCTL_BSIZEPKT_SHIFT) - 1))
5960 panic("%s: MCLBYTES %d unsupported for i2575 or higher\n", __func__, MCLBYTES);
5961 CSR_WRITE(sc, WMREG_SRRCTL(qid), SRRCTL_DESCTYPE_LEGACY
5962 | (MCLBYTES >> SRRCTL_BSIZEPKT_SHIFT));
5963 CSR_WRITE(sc, WMREG_RXDCTL(qid), RXDCTL_QUEUE_ENABLE
5964 | RXDCTL_PTHRESH(16) | RXDCTL_HTHRESH(8)
5965 | RXDCTL_WTHRESH(1));
5966 CSR_WRITE(sc, WMREG_RDH(qid), 0);
5967 CSR_WRITE(sc, WMREG_RDT(qid), 0);
5968 } else {
5969 CSR_WRITE(sc, WMREG_RDH(qid), 0);
5970 CSR_WRITE(sc, WMREG_RDT(qid), 0);
5971 /* ITR / 4 */
5972 CSR_WRITE(sc, WMREG_RDTR, (sc->sc_itr / 4) | RDTR_FPD);
5973 /* MUST be same */
5974 CSR_WRITE(sc, WMREG_RADV, sc->sc_itr / 4);
5975 CSR_WRITE(sc, WMREG_RXDCTL(qid), RXDCTL_PTHRESH(0) |
5976 RXDCTL_HTHRESH(0) | RXDCTL_WTHRESH(1));
5977 }
5978 }
5979 }
5980
5981 static int
5982 wm_init_rx_buffer(struct wm_softc *sc, struct wm_rxqueue *rxq)
5983 {
5984 struct wm_rxsoft *rxs;
5985 int error, i;
5986
5987 KASSERT(mutex_owned(rxq->rxq_lock));
5988
5989 for (i = 0; i < WM_NRXDESC; i++) {
5990 rxs = &rxq->rxq_soft[i];
5991 if (rxs->rxs_mbuf == NULL) {
5992 if ((error = wm_add_rxbuf(rxq, i)) != 0) {
5993 log(LOG_ERR, "%s: unable to allocate or map "
5994 "rx buffer %d, error = %d\n",
5995 device_xname(sc->sc_dev), i, error);
5996 /*
5997 * XXX Should attempt to run with fewer receive
5998 * XXX buffers instead of just failing.
5999 */
6000 wm_rxdrain(rxq);
6001 return ENOMEM;
6002 }
6003 } else {
6004 if ((sc->sc_flags & WM_F_NEWQUEUE) == 0)
6005 wm_init_rxdesc(rxq, i);
6006 /*
6007 * For 82575 and newer device, the RX descriptors
6008 * must be initialized after the setting of RCTL.EN in
6009 * wm_set_filter()
6010 */
6011 }
6012 }
6013 rxq->rxq_ptr = 0;
6014 rxq->rxq_discard = 0;
6015 WM_RXCHAIN_RESET(rxq);
6016
6017 return 0;
6018 }
6019
6020 static int
6021 wm_init_rx_queue(struct wm_softc *sc, struct wm_queue *wmq,
6022 struct wm_rxqueue *rxq)
6023 {
6024
6025 KASSERT(mutex_owned(rxq->rxq_lock));
6026
6027 /*
6028 * Set up some register offsets that are different between
6029 * the i82542 and the i82543 and later chips.
6030 */
6031 if (sc->sc_type < WM_T_82543)
6032 rxq->rxq_rdt_reg = WMREG_OLD_RDT0;
6033 else
6034 rxq->rxq_rdt_reg = WMREG_RDT(wmq->wmq_id);
6035
6036 wm_init_rx_regs(sc, wmq, rxq);
6037 return wm_init_rx_buffer(sc, rxq);
6038 }
6039
6040 /*
6041 * wm_init_quques:
6042 * Initialize {tx,rx}descs and {tx,rx} buffers
6043 */
6044 static int
6045 wm_init_txrx_queues(struct wm_softc *sc)
6046 {
6047 int i, error = 0;
6048
6049 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
6050 device_xname(sc->sc_dev), __func__));
6051
6052 for (i = 0; i < sc->sc_nqueues; i++) {
6053 struct wm_queue *wmq = &sc->sc_queue[i];
6054 struct wm_txqueue *txq = &wmq->wmq_txq;
6055 struct wm_rxqueue *rxq = &wmq->wmq_rxq;
6056
6057 mutex_enter(txq->txq_lock);
6058 wm_init_tx_queue(sc, wmq, txq);
6059 mutex_exit(txq->txq_lock);
6060
6061 mutex_enter(rxq->rxq_lock);
6062 error = wm_init_rx_queue(sc, wmq, rxq);
6063 mutex_exit(rxq->rxq_lock);
6064 if (error)
6065 break;
6066 }
6067
6068 return error;
6069 }
6070
6071 /*
6072 * wm_tx_offload:
6073 *
6074 * Set up TCP/IP checksumming parameters for the
6075 * specified packet.
6076 */
6077 static int
6078 wm_tx_offload(struct wm_softc *sc, struct wm_txsoft *txs, uint32_t *cmdp,
6079 uint8_t *fieldsp)
6080 {
6081 struct wm_txqueue *txq = &sc->sc_queue[0].wmq_txq;
6082 struct mbuf *m0 = txs->txs_mbuf;
6083 struct livengood_tcpip_ctxdesc *t;
6084 uint32_t ipcs, tucs, cmd, cmdlen, seg;
6085 uint32_t ipcse;
6086 struct ether_header *eh;
6087 int offset, iphl;
6088 uint8_t fields;
6089
6090 /*
6091 * XXX It would be nice if the mbuf pkthdr had offset
6092 * fields for the protocol headers.
6093 */
6094
6095 eh = mtod(m0, struct ether_header *);
6096 switch (htons(eh->ether_type)) {
6097 case ETHERTYPE_IP:
6098 case ETHERTYPE_IPV6:
6099 offset = ETHER_HDR_LEN;
6100 break;
6101
6102 case ETHERTYPE_VLAN:
6103 offset = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
6104 break;
6105
6106 default:
6107 /*
6108 * Don't support this protocol or encapsulation.
6109 */
6110 *fieldsp = 0;
6111 *cmdp = 0;
6112 return 0;
6113 }
6114
6115 if ((m0->m_pkthdr.csum_flags &
6116 (M_CSUM_TSOv4 | M_CSUM_UDPv4 | M_CSUM_TCPv4)) != 0) {
6117 iphl = M_CSUM_DATA_IPv4_IPHL(m0->m_pkthdr.csum_data);
6118 } else {
6119 iphl = M_CSUM_DATA_IPv6_HL(m0->m_pkthdr.csum_data);
6120 }
6121 ipcse = offset + iphl - 1;
6122
6123 cmd = WTX_CMD_DEXT | WTX_DTYP_D;
6124 cmdlen = WTX_CMD_DEXT | WTX_DTYP_C | WTX_CMD_IDE;
6125 seg = 0;
6126 fields = 0;
6127
6128 if ((m0->m_pkthdr.csum_flags & (M_CSUM_TSOv4 | M_CSUM_TSOv6)) != 0) {
6129 int hlen = offset + iphl;
6130 bool v4 = (m0->m_pkthdr.csum_flags & M_CSUM_TSOv4) != 0;
6131
6132 if (__predict_false(m0->m_len <
6133 (hlen + sizeof(struct tcphdr)))) {
6134 /*
6135 * TCP/IP headers are not in the first mbuf; we need
6136 * to do this the slow and painful way. Let's just
6137 * hope this doesn't happen very often.
6138 */
6139 struct tcphdr th;
6140
6141 WM_Q_EVCNT_INCR(txq, txtsopain);
6142
6143 m_copydata(m0, hlen, sizeof(th), &th);
6144 if (v4) {
6145 struct ip ip;
6146
6147 m_copydata(m0, offset, sizeof(ip), &ip);
6148 ip.ip_len = 0;
6149 m_copyback(m0,
6150 offset + offsetof(struct ip, ip_len),
6151 sizeof(ip.ip_len), &ip.ip_len);
6152 th.th_sum = in_cksum_phdr(ip.ip_src.s_addr,
6153 ip.ip_dst.s_addr, htons(IPPROTO_TCP));
6154 } else {
6155 struct ip6_hdr ip6;
6156
6157 m_copydata(m0, offset, sizeof(ip6), &ip6);
6158 ip6.ip6_plen = 0;
6159 m_copyback(m0,
6160 offset + offsetof(struct ip6_hdr, ip6_plen),
6161 sizeof(ip6.ip6_plen), &ip6.ip6_plen);
6162 th.th_sum = in6_cksum_phdr(&ip6.ip6_src,
6163 &ip6.ip6_dst, 0, htonl(IPPROTO_TCP));
6164 }
6165 m_copyback(m0, hlen + offsetof(struct tcphdr, th_sum),
6166 sizeof(th.th_sum), &th.th_sum);
6167
6168 hlen += th.th_off << 2;
6169 } else {
6170 /*
6171 * TCP/IP headers are in the first mbuf; we can do
6172 * this the easy way.
6173 */
6174 struct tcphdr *th;
6175
6176 if (v4) {
6177 struct ip *ip =
6178 (void *)(mtod(m0, char *) + offset);
6179 th = (void *)(mtod(m0, char *) + hlen);
6180
6181 ip->ip_len = 0;
6182 th->th_sum = in_cksum_phdr(ip->ip_src.s_addr,
6183 ip->ip_dst.s_addr, htons(IPPROTO_TCP));
6184 } else {
6185 struct ip6_hdr *ip6 =
6186 (void *)(mtod(m0, char *) + offset);
6187 th = (void *)(mtod(m0, char *) + hlen);
6188
6189 ip6->ip6_plen = 0;
6190 th->th_sum = in6_cksum_phdr(&ip6->ip6_src,
6191 &ip6->ip6_dst, 0, htonl(IPPROTO_TCP));
6192 }
6193 hlen += th->th_off << 2;
6194 }
6195
6196 if (v4) {
6197 WM_Q_EVCNT_INCR(txq, txtso);
6198 cmdlen |= WTX_TCPIP_CMD_IP;
6199 } else {
6200 WM_Q_EVCNT_INCR(txq, txtso6);
6201 ipcse = 0;
6202 }
6203 cmd |= WTX_TCPIP_CMD_TSE;
6204 cmdlen |= WTX_TCPIP_CMD_TSE |
6205 WTX_TCPIP_CMD_TCP | (m0->m_pkthdr.len - hlen);
6206 seg = WTX_TCPIP_SEG_HDRLEN(hlen) |
6207 WTX_TCPIP_SEG_MSS(m0->m_pkthdr.segsz);
6208 }
6209
6210 /*
6211 * NOTE: Even if we're not using the IP or TCP/UDP checksum
6212 * offload feature, if we load the context descriptor, we
6213 * MUST provide valid values for IPCSS and TUCSS fields.
6214 */
6215
6216 ipcs = WTX_TCPIP_IPCSS(offset) |
6217 WTX_TCPIP_IPCSO(offset + offsetof(struct ip, ip_sum)) |
6218 WTX_TCPIP_IPCSE(ipcse);
6219 if (m0->m_pkthdr.csum_flags & (M_CSUM_IPv4 | M_CSUM_TSOv4)) {
6220 WM_Q_EVCNT_INCR(txq, txipsum);
6221 fields |= WTX_IXSM;
6222 }
6223
6224 offset += iphl;
6225
6226 if (m0->m_pkthdr.csum_flags &
6227 (M_CSUM_TCPv4 | M_CSUM_UDPv4 | M_CSUM_TSOv4)) {
6228 WM_Q_EVCNT_INCR(txq, txtusum);
6229 fields |= WTX_TXSM;
6230 tucs = WTX_TCPIP_TUCSS(offset) |
6231 WTX_TCPIP_TUCSO(offset +
6232 M_CSUM_DATA_IPv4_OFFSET(m0->m_pkthdr.csum_data)) |
6233 WTX_TCPIP_TUCSE(0) /* rest of packet */;
6234 } else if ((m0->m_pkthdr.csum_flags &
6235 (M_CSUM_TCPv6 | M_CSUM_UDPv6 | M_CSUM_TSOv6)) != 0) {
6236 WM_Q_EVCNT_INCR(txq, txtusum6);
6237 fields |= WTX_TXSM;
6238 tucs = WTX_TCPIP_TUCSS(offset) |
6239 WTX_TCPIP_TUCSO(offset +
6240 M_CSUM_DATA_IPv6_OFFSET(m0->m_pkthdr.csum_data)) |
6241 WTX_TCPIP_TUCSE(0) /* rest of packet */;
6242 } else {
6243 /* Just initialize it to a valid TCP context. */
6244 tucs = WTX_TCPIP_TUCSS(offset) |
6245 WTX_TCPIP_TUCSO(offset + offsetof(struct tcphdr, th_sum)) |
6246 WTX_TCPIP_TUCSE(0) /* rest of packet */;
6247 }
6248
6249 /* Fill in the context descriptor. */
6250 t = (struct livengood_tcpip_ctxdesc *)
6251 &txq->txq_descs[txq->txq_next];
6252 t->tcpip_ipcs = htole32(ipcs);
6253 t->tcpip_tucs = htole32(tucs);
6254 t->tcpip_cmdlen = htole32(cmdlen);
6255 t->tcpip_seg = htole32(seg);
6256 wm_cdtxsync(txq, txq->txq_next, 1, BUS_DMASYNC_PREWRITE);
6257
6258 txq->txq_next = WM_NEXTTX(txq, txq->txq_next);
6259 txs->txs_ndesc++;
6260
6261 *cmdp = cmd;
6262 *fieldsp = fields;
6263
6264 return 0;
6265 }
6266
6267 /*
6268 * wm_start: [ifnet interface function]
6269 *
6270 * Start packet transmission on the interface.
6271 */
6272 static void
6273 wm_start(struct ifnet *ifp)
6274 {
6275 struct wm_softc *sc = ifp->if_softc;
6276 struct wm_txqueue *txq = &sc->sc_queue[0].wmq_txq;
6277
6278 KASSERT(ifp->if_extflags & IFEF_START_MPSAFE);
6279
6280 mutex_enter(txq->txq_lock);
6281 if (!txq->txq_stopping)
6282 wm_start_locked(ifp);
6283 mutex_exit(txq->txq_lock);
6284 }
6285
6286 static void
6287 wm_start_locked(struct ifnet *ifp)
6288 {
6289 struct wm_softc *sc = ifp->if_softc;
6290 struct wm_txqueue *txq = &sc->sc_queue[0].wmq_txq;
6291 struct mbuf *m0;
6292 struct m_tag *mtag;
6293 struct wm_txsoft *txs;
6294 bus_dmamap_t dmamap;
6295 int error, nexttx, lasttx = -1, ofree, seg, segs_needed, use_tso;
6296 bus_addr_t curaddr;
6297 bus_size_t seglen, curlen;
6298 uint32_t cksumcmd;
6299 uint8_t cksumfields;
6300
6301 KASSERT(mutex_owned(txq->txq_lock));
6302
6303 if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
6304 return;
6305
6306 /* Remember the previous number of free descriptors. */
6307 ofree = txq->txq_free;
6308
6309 /*
6310 * Loop through the send queue, setting up transmit descriptors
6311 * until we drain the queue, or use up all available transmit
6312 * descriptors.
6313 */
6314 for (;;) {
6315 m0 = NULL;
6316
6317 /* Get a work queue entry. */
6318 if (txq->txq_sfree < WM_TXQUEUE_GC(txq)) {
6319 wm_txeof(sc, txq);
6320 if (txq->txq_sfree == 0) {
6321 DPRINTF(WM_DEBUG_TX,
6322 ("%s: TX: no free job descriptors\n",
6323 device_xname(sc->sc_dev)));
6324 WM_Q_EVCNT_INCR(txq, txsstall);
6325 break;
6326 }
6327 }
6328
6329 /* Grab a packet off the queue. */
6330 IFQ_DEQUEUE(&ifp->if_snd, m0);
6331 if (m0 == NULL)
6332 break;
6333
6334 DPRINTF(WM_DEBUG_TX,
6335 ("%s: TX: have packet to transmit: %p\n",
6336 device_xname(sc->sc_dev), m0));
6337
6338 txs = &txq->txq_soft[txq->txq_snext];
6339 dmamap = txs->txs_dmamap;
6340
6341 use_tso = (m0->m_pkthdr.csum_flags &
6342 (M_CSUM_TSOv4 | M_CSUM_TSOv6)) != 0;
6343
6344 /*
6345 * So says the Linux driver:
6346 * The controller does a simple calculation to make sure
6347 * there is enough room in the FIFO before initiating the
6348 * DMA for each buffer. The calc is:
6349 * 4 = ceil(buffer len / MSS)
6350 * To make sure we don't overrun the FIFO, adjust the max
6351 * buffer len if the MSS drops.
6352 */
6353 dmamap->dm_maxsegsz =
6354 (use_tso && (m0->m_pkthdr.segsz << 2) < WTX_MAX_LEN)
6355 ? m0->m_pkthdr.segsz << 2
6356 : WTX_MAX_LEN;
6357
6358 /*
6359 * Load the DMA map. If this fails, the packet either
6360 * didn't fit in the allotted number of segments, or we
6361 * were short on resources. For the too-many-segments
6362 * case, we simply report an error and drop the packet,
6363 * since we can't sanely copy a jumbo packet to a single
6364 * buffer.
6365 */
6366 error = bus_dmamap_load_mbuf(sc->sc_dmat, dmamap, m0,
6367 BUS_DMA_WRITE | BUS_DMA_NOWAIT);
6368 if (error) {
6369 if (error == EFBIG) {
6370 WM_Q_EVCNT_INCR(txq, txdrop);
6371 log(LOG_ERR, "%s: Tx packet consumes too many "
6372 "DMA segments, dropping...\n",
6373 device_xname(sc->sc_dev));
6374 wm_dump_mbuf_chain(sc, m0);
6375 m_freem(m0);
6376 continue;
6377 }
6378 /* Short on resources, just stop for now. */
6379 DPRINTF(WM_DEBUG_TX,
6380 ("%s: TX: dmamap load failed: %d\n",
6381 device_xname(sc->sc_dev), error));
6382 break;
6383 }
6384
6385 segs_needed = dmamap->dm_nsegs;
6386 if (use_tso) {
6387 /* For sentinel descriptor; see below. */
6388 segs_needed++;
6389 }
6390
6391 /*
6392 * Ensure we have enough descriptors free to describe
6393 * the packet. Note, we always reserve one descriptor
6394 * at the end of the ring due to the semantics of the
6395 * TDT register, plus one more in the event we need
6396 * to load offload context.
6397 */
6398 if (segs_needed > txq->txq_free - 2) {
6399 /*
6400 * Not enough free descriptors to transmit this
6401 * packet. We haven't committed anything yet,
6402 * so just unload the DMA map, put the packet
6403 * pack on the queue, and punt. Notify the upper
6404 * layer that there are no more slots left.
6405 */
6406 DPRINTF(WM_DEBUG_TX,
6407 ("%s: TX: need %d (%d) descriptors, have %d\n",
6408 device_xname(sc->sc_dev), dmamap->dm_nsegs,
6409 segs_needed, txq->txq_free - 1));
6410 ifp->if_flags |= IFF_OACTIVE;
6411 bus_dmamap_unload(sc->sc_dmat, dmamap);
6412 WM_Q_EVCNT_INCR(txq, txdstall);
6413 break;
6414 }
6415
6416 /*
6417 * Check for 82547 Tx FIFO bug. We need to do this
6418 * once we know we can transmit the packet, since we
6419 * do some internal FIFO space accounting here.
6420 */
6421 if (sc->sc_type == WM_T_82547 &&
6422 wm_82547_txfifo_bugchk(sc, m0)) {
6423 DPRINTF(WM_DEBUG_TX,
6424 ("%s: TX: 82547 Tx FIFO bug detected\n",
6425 device_xname(sc->sc_dev)));
6426 ifp->if_flags |= IFF_OACTIVE;
6427 bus_dmamap_unload(sc->sc_dmat, dmamap);
6428 WM_Q_EVCNT_INCR(txq, txfifo_stall);
6429 break;
6430 }
6431
6432 /* WE ARE NOW COMMITTED TO TRANSMITTING THE PACKET. */
6433
6434 DPRINTF(WM_DEBUG_TX,
6435 ("%s: TX: packet has %d (%d) DMA segments\n",
6436 device_xname(sc->sc_dev), dmamap->dm_nsegs, segs_needed));
6437
6438 WM_EVCNT_INCR(&txq->txq_ev_txseg[dmamap->dm_nsegs - 1]);
6439
6440 /*
6441 * Store a pointer to the packet so that we can free it
6442 * later.
6443 *
6444 * Initially, we consider the number of descriptors the
6445 * packet uses the number of DMA segments. This may be
6446 * incremented by 1 if we do checksum offload (a descriptor
6447 * is used to set the checksum context).
6448 */
6449 txs->txs_mbuf = m0;
6450 txs->txs_firstdesc = txq->txq_next;
6451 txs->txs_ndesc = segs_needed;
6452
6453 /* Set up offload parameters for this packet. */
6454 if (m0->m_pkthdr.csum_flags &
6455 (M_CSUM_TSOv4 | M_CSUM_TSOv6 |
6456 M_CSUM_IPv4 | M_CSUM_TCPv4 | M_CSUM_UDPv4 |
6457 M_CSUM_TCPv6 | M_CSUM_UDPv6)) {
6458 if (wm_tx_offload(sc, txs, &cksumcmd,
6459 &cksumfields) != 0) {
6460 /* Error message already displayed. */
6461 bus_dmamap_unload(sc->sc_dmat, dmamap);
6462 continue;
6463 }
6464 } else {
6465 cksumcmd = 0;
6466 cksumfields = 0;
6467 }
6468
6469 cksumcmd |= WTX_CMD_IDE | WTX_CMD_IFCS;
6470
6471 /* Sync the DMA map. */
6472 bus_dmamap_sync(sc->sc_dmat, dmamap, 0, dmamap->dm_mapsize,
6473 BUS_DMASYNC_PREWRITE);
6474
6475 /* Initialize the transmit descriptor. */
6476 for (nexttx = txq->txq_next, seg = 0;
6477 seg < dmamap->dm_nsegs; seg++) {
6478 for (seglen = dmamap->dm_segs[seg].ds_len,
6479 curaddr = dmamap->dm_segs[seg].ds_addr;
6480 seglen != 0;
6481 curaddr += curlen, seglen -= curlen,
6482 nexttx = WM_NEXTTX(txq, nexttx)) {
6483 curlen = seglen;
6484
6485 /*
6486 * So says the Linux driver:
6487 * Work around for premature descriptor
6488 * write-backs in TSO mode. Append a
6489 * 4-byte sentinel descriptor.
6490 */
6491 if (use_tso && seg == dmamap->dm_nsegs - 1 &&
6492 curlen > 8)
6493 curlen -= 4;
6494
6495 wm_set_dma_addr(
6496 &txq->txq_descs[nexttx].wtx_addr, curaddr);
6497 txq->txq_descs[nexttx].wtx_cmdlen
6498 = htole32(cksumcmd | curlen);
6499 txq->txq_descs[nexttx].wtx_fields.wtxu_status
6500 = 0;
6501 txq->txq_descs[nexttx].wtx_fields.wtxu_options
6502 = cksumfields;
6503 txq->txq_descs[nexttx].wtx_fields.wtxu_vlan =0;
6504 lasttx = nexttx;
6505
6506 DPRINTF(WM_DEBUG_TX,
6507 ("%s: TX: desc %d: low %#" PRIx64 ", "
6508 "len %#04zx\n",
6509 device_xname(sc->sc_dev), nexttx,
6510 (uint64_t)curaddr, curlen));
6511 }
6512 }
6513
6514 KASSERT(lasttx != -1);
6515
6516 /*
6517 * Set up the command byte on the last descriptor of
6518 * the packet. If we're in the interrupt delay window,
6519 * delay the interrupt.
6520 */
6521 txq->txq_descs[lasttx].wtx_cmdlen |=
6522 htole32(WTX_CMD_EOP | WTX_CMD_RS);
6523
6524 /*
6525 * If VLANs are enabled and the packet has a VLAN tag, set
6526 * up the descriptor to encapsulate the packet for us.
6527 *
6528 * This is only valid on the last descriptor of the packet.
6529 */
6530 if ((mtag = VLAN_OUTPUT_TAG(&sc->sc_ethercom, m0)) != NULL) {
6531 txq->txq_descs[lasttx].wtx_cmdlen |=
6532 htole32(WTX_CMD_VLE);
6533 txq->txq_descs[lasttx].wtx_fields.wtxu_vlan
6534 = htole16(VLAN_TAG_VALUE(mtag) & 0xffff);
6535 }
6536
6537 txs->txs_lastdesc = lasttx;
6538
6539 DPRINTF(WM_DEBUG_TX,
6540 ("%s: TX: desc %d: cmdlen 0x%08x\n",
6541 device_xname(sc->sc_dev),
6542 lasttx, le32toh(txq->txq_descs[lasttx].wtx_cmdlen)));
6543
6544 /* Sync the descriptors we're using. */
6545 wm_cdtxsync(txq, txq->txq_next, txs->txs_ndesc,
6546 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
6547
6548 /* Give the packet to the chip. */
6549 CSR_WRITE(sc, txq->txq_tdt_reg, nexttx);
6550
6551 DPRINTF(WM_DEBUG_TX,
6552 ("%s: TX: TDT -> %d\n", device_xname(sc->sc_dev), nexttx));
6553
6554 DPRINTF(WM_DEBUG_TX,
6555 ("%s: TX: finished transmitting packet, job %d\n",
6556 device_xname(sc->sc_dev), txq->txq_snext));
6557
6558 /* Advance the tx pointer. */
6559 txq->txq_free -= txs->txs_ndesc;
6560 txq->txq_next = nexttx;
6561
6562 txq->txq_sfree--;
6563 txq->txq_snext = WM_NEXTTXS(txq, txq->txq_snext);
6564
6565 /* Pass the packet to any BPF listeners. */
6566 bpf_mtap(ifp, m0);
6567 }
6568
6569 if (m0 != NULL) {
6570 ifp->if_flags |= IFF_OACTIVE;
6571 WM_Q_EVCNT_INCR(txq, txdrop);
6572 DPRINTF(WM_DEBUG_TX, ("%s: TX: error after IFQ_DEQUEUE\n",
6573 __func__));
6574 m_freem(m0);
6575 }
6576
6577 if (txq->txq_sfree == 0 || txq->txq_free <= 2) {
6578 /* No more slots; notify upper layer. */
6579 ifp->if_flags |= IFF_OACTIVE;
6580 }
6581
6582 if (txq->txq_free != ofree) {
6583 /* Set a watchdog timer in case the chip flakes out. */
6584 ifp->if_timer = 5;
6585 }
6586 }
6587
6588 /*
6589 * wm_nq_tx_offload:
6590 *
6591 * Set up TCP/IP checksumming parameters for the
6592 * specified packet, for NEWQUEUE devices
6593 */
6594 static int
6595 wm_nq_tx_offload(struct wm_softc *sc, struct wm_txqueue *txq,
6596 struct wm_txsoft *txs, uint32_t *cmdlenp, uint32_t *fieldsp, bool *do_csum)
6597 {
6598 struct mbuf *m0 = txs->txs_mbuf;
6599 struct m_tag *mtag;
6600 uint32_t vl_len, mssidx, cmdc;
6601 struct ether_header *eh;
6602 int offset, iphl;
6603
6604 /*
6605 * XXX It would be nice if the mbuf pkthdr had offset
6606 * fields for the protocol headers.
6607 */
6608 *cmdlenp = 0;
6609 *fieldsp = 0;
6610
6611 eh = mtod(m0, struct ether_header *);
6612 switch (htons(eh->ether_type)) {
6613 case ETHERTYPE_IP:
6614 case ETHERTYPE_IPV6:
6615 offset = ETHER_HDR_LEN;
6616 break;
6617
6618 case ETHERTYPE_VLAN:
6619 offset = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
6620 break;
6621
6622 default:
6623 /* Don't support this protocol or encapsulation. */
6624 *do_csum = false;
6625 return 0;
6626 }
6627 *do_csum = true;
6628 *cmdlenp = NQTX_DTYP_D | NQTX_CMD_DEXT | NQTX_CMD_IFCS;
6629 cmdc = NQTX_DTYP_C | NQTX_CMD_DEXT;
6630
6631 vl_len = (offset << NQTXC_VLLEN_MACLEN_SHIFT);
6632 KASSERT((offset & ~NQTXC_VLLEN_MACLEN_MASK) == 0);
6633
6634 if ((m0->m_pkthdr.csum_flags &
6635 (M_CSUM_TSOv4 | M_CSUM_UDPv4 | M_CSUM_TCPv4 | M_CSUM_IPv4)) != 0) {
6636 iphl = M_CSUM_DATA_IPv4_IPHL(m0->m_pkthdr.csum_data);
6637 } else {
6638 iphl = M_CSUM_DATA_IPv6_HL(m0->m_pkthdr.csum_data);
6639 }
6640 vl_len |= (iphl << NQTXC_VLLEN_IPLEN_SHIFT);
6641 KASSERT((iphl & ~NQTXC_VLLEN_IPLEN_MASK) == 0);
6642
6643 if ((mtag = VLAN_OUTPUT_TAG(&sc->sc_ethercom, m0)) != NULL) {
6644 vl_len |= ((VLAN_TAG_VALUE(mtag) & NQTXC_VLLEN_VLAN_MASK)
6645 << NQTXC_VLLEN_VLAN_SHIFT);
6646 *cmdlenp |= NQTX_CMD_VLE;
6647 }
6648
6649 mssidx = 0;
6650
6651 if ((m0->m_pkthdr.csum_flags & (M_CSUM_TSOv4 | M_CSUM_TSOv6)) != 0) {
6652 int hlen = offset + iphl;
6653 int tcp_hlen;
6654 bool v4 = (m0->m_pkthdr.csum_flags & M_CSUM_TSOv4) != 0;
6655
6656 if (__predict_false(m0->m_len <
6657 (hlen + sizeof(struct tcphdr)))) {
6658 /*
6659 * TCP/IP headers are not in the first mbuf; we need
6660 * to do this the slow and painful way. Let's just
6661 * hope this doesn't happen very often.
6662 */
6663 struct tcphdr th;
6664
6665 WM_Q_EVCNT_INCR(txq, txtsopain);
6666
6667 m_copydata(m0, hlen, sizeof(th), &th);
6668 if (v4) {
6669 struct ip ip;
6670
6671 m_copydata(m0, offset, sizeof(ip), &ip);
6672 ip.ip_len = 0;
6673 m_copyback(m0,
6674 offset + offsetof(struct ip, ip_len),
6675 sizeof(ip.ip_len), &ip.ip_len);
6676 th.th_sum = in_cksum_phdr(ip.ip_src.s_addr,
6677 ip.ip_dst.s_addr, htons(IPPROTO_TCP));
6678 } else {
6679 struct ip6_hdr ip6;
6680
6681 m_copydata(m0, offset, sizeof(ip6), &ip6);
6682 ip6.ip6_plen = 0;
6683 m_copyback(m0,
6684 offset + offsetof(struct ip6_hdr, ip6_plen),
6685 sizeof(ip6.ip6_plen), &ip6.ip6_plen);
6686 th.th_sum = in6_cksum_phdr(&ip6.ip6_src,
6687 &ip6.ip6_dst, 0, htonl(IPPROTO_TCP));
6688 }
6689 m_copyback(m0, hlen + offsetof(struct tcphdr, th_sum),
6690 sizeof(th.th_sum), &th.th_sum);
6691
6692 tcp_hlen = th.th_off << 2;
6693 } else {
6694 /*
6695 * TCP/IP headers are in the first mbuf; we can do
6696 * this the easy way.
6697 */
6698 struct tcphdr *th;
6699
6700 if (v4) {
6701 struct ip *ip =
6702 (void *)(mtod(m0, char *) + offset);
6703 th = (void *)(mtod(m0, char *) + hlen);
6704
6705 ip->ip_len = 0;
6706 th->th_sum = in_cksum_phdr(ip->ip_src.s_addr,
6707 ip->ip_dst.s_addr, htons(IPPROTO_TCP));
6708 } else {
6709 struct ip6_hdr *ip6 =
6710 (void *)(mtod(m0, char *) + offset);
6711 th = (void *)(mtod(m0, char *) + hlen);
6712
6713 ip6->ip6_plen = 0;
6714 th->th_sum = in6_cksum_phdr(&ip6->ip6_src,
6715 &ip6->ip6_dst, 0, htonl(IPPROTO_TCP));
6716 }
6717 tcp_hlen = th->th_off << 2;
6718 }
6719 hlen += tcp_hlen;
6720 *cmdlenp |= NQTX_CMD_TSE;
6721
6722 if (v4) {
6723 WM_Q_EVCNT_INCR(txq, txtso);
6724 *fieldsp |= NQTXD_FIELDS_IXSM | NQTXD_FIELDS_TUXSM;
6725 } else {
6726 WM_Q_EVCNT_INCR(txq, txtso6);
6727 *fieldsp |= NQTXD_FIELDS_TUXSM;
6728 }
6729 *fieldsp |= ((m0->m_pkthdr.len - hlen) << NQTXD_FIELDS_PAYLEN_SHIFT);
6730 KASSERT(((m0->m_pkthdr.len - hlen) & ~NQTXD_FIELDS_PAYLEN_MASK) == 0);
6731 mssidx |= (m0->m_pkthdr.segsz << NQTXC_MSSIDX_MSS_SHIFT);
6732 KASSERT((m0->m_pkthdr.segsz & ~NQTXC_MSSIDX_MSS_MASK) == 0);
6733 mssidx |= (tcp_hlen << NQTXC_MSSIDX_L4LEN_SHIFT);
6734 KASSERT((tcp_hlen & ~NQTXC_MSSIDX_L4LEN_MASK) == 0);
6735 } else {
6736 *fieldsp |= (m0->m_pkthdr.len << NQTXD_FIELDS_PAYLEN_SHIFT);
6737 KASSERT((m0->m_pkthdr.len & ~NQTXD_FIELDS_PAYLEN_MASK) == 0);
6738 }
6739
6740 if (m0->m_pkthdr.csum_flags & M_CSUM_IPv4) {
6741 *fieldsp |= NQTXD_FIELDS_IXSM;
6742 cmdc |= NQTXC_CMD_IP4;
6743 }
6744
6745 if (m0->m_pkthdr.csum_flags &
6746 (M_CSUM_UDPv4 | M_CSUM_TCPv4 | M_CSUM_TSOv4)) {
6747 WM_Q_EVCNT_INCR(txq, txtusum);
6748 if (m0->m_pkthdr.csum_flags & (M_CSUM_TCPv4 | M_CSUM_TSOv4)) {
6749 cmdc |= NQTXC_CMD_TCP;
6750 } else {
6751 cmdc |= NQTXC_CMD_UDP;
6752 }
6753 cmdc |= NQTXC_CMD_IP4;
6754 *fieldsp |= NQTXD_FIELDS_TUXSM;
6755 }
6756 if (m0->m_pkthdr.csum_flags &
6757 (M_CSUM_UDPv6 | M_CSUM_TCPv6 | M_CSUM_TSOv6)) {
6758 WM_Q_EVCNT_INCR(txq, txtusum6);
6759 if (m0->m_pkthdr.csum_flags & (M_CSUM_TCPv6 | M_CSUM_TSOv6)) {
6760 cmdc |= NQTXC_CMD_TCP;
6761 } else {
6762 cmdc |= NQTXC_CMD_UDP;
6763 }
6764 cmdc |= NQTXC_CMD_IP6;
6765 *fieldsp |= NQTXD_FIELDS_TUXSM;
6766 }
6767
6768 /* Fill in the context descriptor. */
6769 txq->txq_nq_descs[txq->txq_next].nqrx_ctx.nqtxc_vl_len =
6770 htole32(vl_len);
6771 txq->txq_nq_descs[txq->txq_next].nqrx_ctx.nqtxc_sn = 0;
6772 txq->txq_nq_descs[txq->txq_next].nqrx_ctx.nqtxc_cmd =
6773 htole32(cmdc);
6774 txq->txq_nq_descs[txq->txq_next].nqrx_ctx.nqtxc_mssidx =
6775 htole32(mssidx);
6776 wm_cdtxsync(txq, txq->txq_next, 1, BUS_DMASYNC_PREWRITE);
6777 DPRINTF(WM_DEBUG_TX,
6778 ("%s: TX: context desc %d 0x%08x%08x\n", device_xname(sc->sc_dev),
6779 txq->txq_next, 0, vl_len));
6780 DPRINTF(WM_DEBUG_TX, ("\t0x%08x%08x\n", mssidx, cmdc));
6781 txq->txq_next = WM_NEXTTX(txq, txq->txq_next);
6782 txs->txs_ndesc++;
6783 return 0;
6784 }
6785
6786 /*
6787 * wm_nq_start: [ifnet interface function]
6788 *
6789 * Start packet transmission on the interface for NEWQUEUE devices
6790 */
6791 static void
6792 wm_nq_start(struct ifnet *ifp)
6793 {
6794 struct wm_softc *sc = ifp->if_softc;
6795 struct wm_txqueue *txq = &sc->sc_queue[0].wmq_txq;
6796
6797 KASSERT(ifp->if_extflags & IFEF_START_MPSAFE);
6798
6799 mutex_enter(txq->txq_lock);
6800 if (!txq->txq_stopping)
6801 wm_nq_start_locked(ifp);
6802 mutex_exit(txq->txq_lock);
6803 }
6804
6805 static void
6806 wm_nq_start_locked(struct ifnet *ifp)
6807 {
6808 struct wm_softc *sc = ifp->if_softc;
6809 struct wm_txqueue *txq = &sc->sc_queue[0].wmq_txq;
6810
6811 wm_nq_send_common_locked(ifp, txq, false);
6812 }
6813
6814 static inline int
6815 wm_nq_select_txqueue(struct ifnet *ifp, struct mbuf *m)
6816 {
6817 struct wm_softc *sc = ifp->if_softc;
6818 u_int cpuid = cpu_index(curcpu());
6819
6820 /*
6821 * Currently, simple distribute strategy.
6822 * TODO:
6823 * destribute by flowid(RSS has value).
6824 */
6825 return (cpuid + sc->sc_affinity_offset) % sc->sc_nqueues;
6826 }
6827
6828 static int
6829 wm_nq_transmit(struct ifnet *ifp, struct mbuf *m)
6830 {
6831 int qid;
6832 struct wm_softc *sc = ifp->if_softc;
6833 struct wm_txqueue *txq;
6834
6835 qid = wm_nq_select_txqueue(ifp, m);
6836 txq = &sc->sc_queue[qid].wmq_txq;
6837
6838 if (__predict_false(!pcq_put(txq->txq_interq, m))) {
6839 m_freem(m);
6840 WM_Q_EVCNT_INCR(txq, txdrop);
6841 return ENOBUFS;
6842 }
6843
6844 if (mutex_tryenter(txq->txq_lock)) {
6845 /* XXXX should be per TX queue */
6846 ifp->if_obytes += m->m_pkthdr.len;
6847 if (m->m_flags & M_MCAST)
6848 ifp->if_omcasts++;
6849
6850 if (!txq->txq_stopping)
6851 wm_nq_transmit_locked(ifp, txq);
6852 mutex_exit(txq->txq_lock);
6853 }
6854
6855 return 0;
6856 }
6857
6858 static void
6859 wm_nq_transmit_locked(struct ifnet *ifp, struct wm_txqueue *txq)
6860 {
6861
6862 wm_nq_send_common_locked(ifp, txq, true);
6863 }
6864
6865 static void
6866 wm_nq_send_common_locked(struct ifnet *ifp, struct wm_txqueue *txq,
6867 bool is_transmit)
6868 {
6869 struct wm_softc *sc = ifp->if_softc;
6870 struct mbuf *m0;
6871 struct m_tag *mtag;
6872 struct wm_txsoft *txs;
6873 bus_dmamap_t dmamap;
6874 int error, nexttx, lasttx = -1, seg, segs_needed;
6875 bool do_csum, sent;
6876
6877 KASSERT(mutex_owned(txq->txq_lock));
6878
6879 if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
6880 return;
6881 if ((txq->txq_flags & WM_TXQ_NO_SPACE) != 0)
6882 return;
6883
6884 sent = false;
6885
6886 /*
6887 * Loop through the send queue, setting up transmit descriptors
6888 * until we drain the queue, or use up all available transmit
6889 * descriptors.
6890 */
6891 for (;;) {
6892 m0 = NULL;
6893
6894 /* Get a work queue entry. */
6895 if (txq->txq_sfree < WM_TXQUEUE_GC(txq)) {
6896 wm_txeof(sc, txq);
6897 if (txq->txq_sfree == 0) {
6898 DPRINTF(WM_DEBUG_TX,
6899 ("%s: TX: no free job descriptors\n",
6900 device_xname(sc->sc_dev)));
6901 WM_Q_EVCNT_INCR(txq, txsstall);
6902 break;
6903 }
6904 }
6905
6906 /* Grab a packet off the queue. */
6907 if (is_transmit)
6908 m0 = pcq_get(txq->txq_interq);
6909 else
6910 IFQ_DEQUEUE(&ifp->if_snd, m0);
6911 if (m0 == NULL)
6912 break;
6913
6914 DPRINTF(WM_DEBUG_TX,
6915 ("%s: TX: have packet to transmit: %p\n",
6916 device_xname(sc->sc_dev), m0));
6917
6918 txs = &txq->txq_soft[txq->txq_snext];
6919 dmamap = txs->txs_dmamap;
6920
6921 /*
6922 * Load the DMA map. If this fails, the packet either
6923 * didn't fit in the allotted number of segments, or we
6924 * were short on resources. For the too-many-segments
6925 * case, we simply report an error and drop the packet,
6926 * since we can't sanely copy a jumbo packet to a single
6927 * buffer.
6928 */
6929 error = bus_dmamap_load_mbuf(sc->sc_dmat, dmamap, m0,
6930 BUS_DMA_WRITE | BUS_DMA_NOWAIT);
6931 if (error) {
6932 if (error == EFBIG) {
6933 WM_Q_EVCNT_INCR(txq, txdrop);
6934 log(LOG_ERR, "%s: Tx packet consumes too many "
6935 "DMA segments, dropping...\n",
6936 device_xname(sc->sc_dev));
6937 wm_dump_mbuf_chain(sc, m0);
6938 m_freem(m0);
6939 continue;
6940 }
6941 /* Short on resources, just stop for now. */
6942 DPRINTF(WM_DEBUG_TX,
6943 ("%s: TX: dmamap load failed: %d\n",
6944 device_xname(sc->sc_dev), error));
6945 break;
6946 }
6947
6948 segs_needed = dmamap->dm_nsegs;
6949
6950 /*
6951 * Ensure we have enough descriptors free to describe
6952 * the packet. Note, we always reserve one descriptor
6953 * at the end of the ring due to the semantics of the
6954 * TDT register, plus one more in the event we need
6955 * to load offload context.
6956 */
6957 if (segs_needed > txq->txq_free - 2) {
6958 /*
6959 * Not enough free descriptors to transmit this
6960 * packet. We haven't committed anything yet,
6961 * so just unload the DMA map, put the packet
6962 * pack on the queue, and punt. Notify the upper
6963 * layer that there are no more slots left.
6964 */
6965 DPRINTF(WM_DEBUG_TX,
6966 ("%s: TX: need %d (%d) descriptors, have %d\n",
6967 device_xname(sc->sc_dev), dmamap->dm_nsegs,
6968 segs_needed, txq->txq_free - 1));
6969 txq->txq_flags |= WM_TXQ_NO_SPACE;
6970 bus_dmamap_unload(sc->sc_dmat, dmamap);
6971 WM_Q_EVCNT_INCR(txq, txdstall);
6972 break;
6973 }
6974
6975 /* WE ARE NOW COMMITTED TO TRANSMITTING THE PACKET. */
6976
6977 DPRINTF(WM_DEBUG_TX,
6978 ("%s: TX: packet has %d (%d) DMA segments\n",
6979 device_xname(sc->sc_dev), dmamap->dm_nsegs, segs_needed));
6980
6981 WM_EVCNT_INCR(&txq->txq_ev_txseg[dmamap->dm_nsegs - 1]);
6982
6983 /*
6984 * Store a pointer to the packet so that we can free it
6985 * later.
6986 *
6987 * Initially, we consider the number of descriptors the
6988 * packet uses the number of DMA segments. This may be
6989 * incremented by 1 if we do checksum offload (a descriptor
6990 * is used to set the checksum context).
6991 */
6992 txs->txs_mbuf = m0;
6993 txs->txs_firstdesc = txq->txq_next;
6994 txs->txs_ndesc = segs_needed;
6995
6996 /* Set up offload parameters for this packet. */
6997 uint32_t cmdlen, fields, dcmdlen;
6998 if (m0->m_pkthdr.csum_flags &
6999 (M_CSUM_TSOv4 | M_CSUM_TSOv6 |
7000 M_CSUM_IPv4 | M_CSUM_TCPv4 | M_CSUM_UDPv4 |
7001 M_CSUM_TCPv6 | M_CSUM_UDPv6)) {
7002 if (wm_nq_tx_offload(sc, txq, txs, &cmdlen, &fields,
7003 &do_csum) != 0) {
7004 /* Error message already displayed. */
7005 bus_dmamap_unload(sc->sc_dmat, dmamap);
7006 continue;
7007 }
7008 } else {
7009 do_csum = false;
7010 cmdlen = 0;
7011 fields = 0;
7012 }
7013
7014 /* Sync the DMA map. */
7015 bus_dmamap_sync(sc->sc_dmat, dmamap, 0, dmamap->dm_mapsize,
7016 BUS_DMASYNC_PREWRITE);
7017
7018 /* Initialize the first transmit descriptor. */
7019 nexttx = txq->txq_next;
7020 if (!do_csum) {
7021 /* setup a legacy descriptor */
7022 wm_set_dma_addr(&txq->txq_descs[nexttx].wtx_addr,
7023 dmamap->dm_segs[0].ds_addr);
7024 txq->txq_descs[nexttx].wtx_cmdlen =
7025 htole32(WTX_CMD_IFCS | dmamap->dm_segs[0].ds_len);
7026 txq->txq_descs[nexttx].wtx_fields.wtxu_status = 0;
7027 txq->txq_descs[nexttx].wtx_fields.wtxu_options = 0;
7028 if ((mtag = VLAN_OUTPUT_TAG(&sc->sc_ethercom, m0)) !=
7029 NULL) {
7030 txq->txq_descs[nexttx].wtx_cmdlen |=
7031 htole32(WTX_CMD_VLE);
7032 txq->txq_descs[nexttx].wtx_fields.wtxu_vlan =
7033 htole16(VLAN_TAG_VALUE(mtag) & 0xffff);
7034 } else {
7035 txq->txq_descs[nexttx].wtx_fields.wtxu_vlan =0;
7036 }
7037 dcmdlen = 0;
7038 } else {
7039 /* setup an advanced data descriptor */
7040 txq->txq_nq_descs[nexttx].nqtx_data.nqtxd_addr =
7041 htole64(dmamap->dm_segs[0].ds_addr);
7042 KASSERT((dmamap->dm_segs[0].ds_len & cmdlen) == 0);
7043 txq->txq_nq_descs[nexttx].nqtx_data.nqtxd_cmdlen =
7044 htole32(dmamap->dm_segs[0].ds_len | cmdlen );
7045 txq->txq_nq_descs[nexttx].nqtx_data.nqtxd_fields =
7046 htole32(fields);
7047 DPRINTF(WM_DEBUG_TX,
7048 ("%s: TX: adv data desc %d 0x%" PRIx64 "\n",
7049 device_xname(sc->sc_dev), nexttx,
7050 (uint64_t)dmamap->dm_segs[0].ds_addr));
7051 DPRINTF(WM_DEBUG_TX,
7052 ("\t 0x%08x%08x\n", fields,
7053 (uint32_t)dmamap->dm_segs[0].ds_len | cmdlen));
7054 dcmdlen = NQTX_DTYP_D | NQTX_CMD_DEXT;
7055 }
7056
7057 lasttx = nexttx;
7058 nexttx = WM_NEXTTX(txq, nexttx);
7059 /*
7060 * fill in the next descriptors. legacy or adcanced format
7061 * is the same here
7062 */
7063 for (seg = 1; seg < dmamap->dm_nsegs;
7064 seg++, nexttx = WM_NEXTTX(txq, nexttx)) {
7065 txq->txq_nq_descs[nexttx].nqtx_data.nqtxd_addr =
7066 htole64(dmamap->dm_segs[seg].ds_addr);
7067 txq->txq_nq_descs[nexttx].nqtx_data.nqtxd_cmdlen =
7068 htole32(dcmdlen | dmamap->dm_segs[seg].ds_len);
7069 KASSERT((dcmdlen & dmamap->dm_segs[seg].ds_len) == 0);
7070 txq->txq_nq_descs[nexttx].nqtx_data.nqtxd_fields = 0;
7071 lasttx = nexttx;
7072
7073 DPRINTF(WM_DEBUG_TX,
7074 ("%s: TX: desc %d: %#" PRIx64 ", "
7075 "len %#04zx\n",
7076 device_xname(sc->sc_dev), nexttx,
7077 (uint64_t)dmamap->dm_segs[seg].ds_addr,
7078 dmamap->dm_segs[seg].ds_len));
7079 }
7080
7081 KASSERT(lasttx != -1);
7082
7083 /*
7084 * Set up the command byte on the last descriptor of
7085 * the packet. If we're in the interrupt delay window,
7086 * delay the interrupt.
7087 */
7088 KASSERT((WTX_CMD_EOP | WTX_CMD_RS) ==
7089 (NQTX_CMD_EOP | NQTX_CMD_RS));
7090 txq->txq_descs[lasttx].wtx_cmdlen |=
7091 htole32(WTX_CMD_EOP | WTX_CMD_RS);
7092
7093 txs->txs_lastdesc = lasttx;
7094
7095 DPRINTF(WM_DEBUG_TX, ("%s: TX: desc %d: cmdlen 0x%08x\n",
7096 device_xname(sc->sc_dev),
7097 lasttx, le32toh(txq->txq_descs[lasttx].wtx_cmdlen)));
7098
7099 /* Sync the descriptors we're using. */
7100 wm_cdtxsync(txq, txq->txq_next, txs->txs_ndesc,
7101 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
7102
7103 /* Give the packet to the chip. */
7104 CSR_WRITE(sc, txq->txq_tdt_reg, nexttx);
7105 sent = true;
7106
7107 DPRINTF(WM_DEBUG_TX,
7108 ("%s: TX: TDT -> %d\n", device_xname(sc->sc_dev), nexttx));
7109
7110 DPRINTF(WM_DEBUG_TX,
7111 ("%s: TX: finished transmitting packet, job %d\n",
7112 device_xname(sc->sc_dev), txq->txq_snext));
7113
7114 /* Advance the tx pointer. */
7115 txq->txq_free -= txs->txs_ndesc;
7116 txq->txq_next = nexttx;
7117
7118 txq->txq_sfree--;
7119 txq->txq_snext = WM_NEXTTXS(txq, txq->txq_snext);
7120
7121 /* Pass the packet to any BPF listeners. */
7122 bpf_mtap(ifp, m0);
7123 }
7124
7125 if (m0 != NULL) {
7126 txq->txq_flags |= WM_TXQ_NO_SPACE;
7127 WM_Q_EVCNT_INCR(txq, txdrop);
7128 DPRINTF(WM_DEBUG_TX, ("%s: TX: error after IFQ_DEQUEUE\n",
7129 __func__));
7130 m_freem(m0);
7131 }
7132
7133 if (txq->txq_sfree == 0 || txq->txq_free <= 2) {
7134 /* No more slots; notify upper layer. */
7135 txq->txq_flags |= WM_TXQ_NO_SPACE;
7136 }
7137
7138 if (sent) {
7139 /* Set a watchdog timer in case the chip flakes out. */
7140 ifp->if_timer = 5;
7141 }
7142 }
7143
7144 /* Interrupt */
7145
7146 /*
7147 * wm_txeof:
7148 *
7149 * Helper; handle transmit interrupts.
7150 */
7151 static int
7152 wm_txeof(struct wm_softc *sc, struct wm_txqueue *txq)
7153 {
7154 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
7155 struct wm_txsoft *txs;
7156 bool processed = false;
7157 int count = 0;
7158 int i;
7159 uint8_t status;
7160
7161 KASSERT(mutex_owned(txq->txq_lock));
7162
7163 if (txq->txq_stopping)
7164 return 0;
7165
7166 if ((sc->sc_flags & WM_F_NEWQUEUE) != 0)
7167 txq->txq_flags &= ~WM_TXQ_NO_SPACE;
7168 else
7169 ifp->if_flags &= ~IFF_OACTIVE;
7170
7171 /*
7172 * Go through the Tx list and free mbufs for those
7173 * frames which have been transmitted.
7174 */
7175 for (i = txq->txq_sdirty; txq->txq_sfree != WM_TXQUEUELEN(txq);
7176 i = WM_NEXTTXS(txq, i), txq->txq_sfree++) {
7177 txs = &txq->txq_soft[i];
7178
7179 DPRINTF(WM_DEBUG_TX, ("%s: TX: checking job %d\n",
7180 device_xname(sc->sc_dev), i));
7181
7182 wm_cdtxsync(txq, txs->txs_firstdesc, txs->txs_ndesc,
7183 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
7184
7185 status =
7186 txq->txq_descs[txs->txs_lastdesc].wtx_fields.wtxu_status;
7187 if ((status & WTX_ST_DD) == 0) {
7188 wm_cdtxsync(txq, txs->txs_lastdesc, 1,
7189 BUS_DMASYNC_PREREAD);
7190 break;
7191 }
7192
7193 processed = true;
7194 count++;
7195 DPRINTF(WM_DEBUG_TX,
7196 ("%s: TX: job %d done: descs %d..%d\n",
7197 device_xname(sc->sc_dev), i, txs->txs_firstdesc,
7198 txs->txs_lastdesc));
7199
7200 /*
7201 * XXX We should probably be using the statistics
7202 * XXX registers, but I don't know if they exist
7203 * XXX on chips before the i82544.
7204 */
7205
7206 #ifdef WM_EVENT_COUNTERS
7207 if (status & WTX_ST_TU)
7208 WM_Q_EVCNT_INCR(txq, tu);
7209 #endif /* WM_EVENT_COUNTERS */
7210
7211 if (status & (WTX_ST_EC | WTX_ST_LC)) {
7212 ifp->if_oerrors++;
7213 if (status & WTX_ST_LC)
7214 log(LOG_WARNING, "%s: late collision\n",
7215 device_xname(sc->sc_dev));
7216 else if (status & WTX_ST_EC) {
7217 ifp->if_collisions += 16;
7218 log(LOG_WARNING, "%s: excessive collisions\n",
7219 device_xname(sc->sc_dev));
7220 }
7221 } else
7222 ifp->if_opackets++;
7223
7224 txq->txq_free += txs->txs_ndesc;
7225 bus_dmamap_sync(sc->sc_dmat, txs->txs_dmamap,
7226 0, txs->txs_dmamap->dm_mapsize, BUS_DMASYNC_POSTWRITE);
7227 bus_dmamap_unload(sc->sc_dmat, txs->txs_dmamap);
7228 m_freem(txs->txs_mbuf);
7229 txs->txs_mbuf = NULL;
7230 }
7231
7232 /* Update the dirty transmit buffer pointer. */
7233 txq->txq_sdirty = i;
7234 DPRINTF(WM_DEBUG_TX,
7235 ("%s: TX: txsdirty -> %d\n", device_xname(sc->sc_dev), i));
7236
7237 if (count != 0)
7238 rnd_add_uint32(&sc->rnd_source, count);
7239
7240 /*
7241 * If there are no more pending transmissions, cancel the watchdog
7242 * timer.
7243 */
7244 if (txq->txq_sfree == WM_TXQUEUELEN(txq))
7245 ifp->if_timer = 0;
7246
7247 return processed;
7248 }
7249
7250 /*
7251 * wm_rxeof:
7252 *
7253 * Helper; handle receive interrupts.
7254 */
7255 static void
7256 wm_rxeof(struct wm_rxqueue *rxq)
7257 {
7258 struct wm_softc *sc = rxq->rxq_sc;
7259 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
7260 struct wm_rxsoft *rxs;
7261 struct mbuf *m;
7262 int i, len;
7263 int count = 0;
7264 uint8_t status, errors;
7265 uint16_t vlantag;
7266
7267 KASSERT(mutex_owned(rxq->rxq_lock));
7268
7269 for (i = rxq->rxq_ptr;; i = WM_NEXTRX(i)) {
7270 rxs = &rxq->rxq_soft[i];
7271
7272 DPRINTF(WM_DEBUG_RX,
7273 ("%s: RX: checking descriptor %d\n",
7274 device_xname(sc->sc_dev), i));
7275
7276 wm_cdrxsync(rxq, i,BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
7277
7278 status = rxq->rxq_descs[i].wrx_status;
7279 errors = rxq->rxq_descs[i].wrx_errors;
7280 len = le16toh(rxq->rxq_descs[i].wrx_len);
7281 vlantag = rxq->rxq_descs[i].wrx_special;
7282
7283 if ((status & WRX_ST_DD) == 0) {
7284 /* We have processed all of the receive descriptors. */
7285 wm_cdrxsync(rxq, i, BUS_DMASYNC_PREREAD);
7286 break;
7287 }
7288
7289 count++;
7290 if (__predict_false(rxq->rxq_discard)) {
7291 DPRINTF(WM_DEBUG_RX,
7292 ("%s: RX: discarding contents of descriptor %d\n",
7293 device_xname(sc->sc_dev), i));
7294 wm_init_rxdesc(rxq, i);
7295 if (status & WRX_ST_EOP) {
7296 /* Reset our state. */
7297 DPRINTF(WM_DEBUG_RX,
7298 ("%s: RX: resetting rxdiscard -> 0\n",
7299 device_xname(sc->sc_dev)));
7300 rxq->rxq_discard = 0;
7301 }
7302 continue;
7303 }
7304
7305 bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
7306 rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_POSTREAD);
7307
7308 m = rxs->rxs_mbuf;
7309
7310 /*
7311 * Add a new receive buffer to the ring, unless of
7312 * course the length is zero. Treat the latter as a
7313 * failed mapping.
7314 */
7315 if ((len == 0) || (wm_add_rxbuf(rxq, i) != 0)) {
7316 /*
7317 * Failed, throw away what we've done so
7318 * far, and discard the rest of the packet.
7319 */
7320 ifp->if_ierrors++;
7321 bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
7322 rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
7323 wm_init_rxdesc(rxq, i);
7324 if ((status & WRX_ST_EOP) == 0)
7325 rxq->rxq_discard = 1;
7326 if (rxq->rxq_head != NULL)
7327 m_freem(rxq->rxq_head);
7328 WM_RXCHAIN_RESET(rxq);
7329 DPRINTF(WM_DEBUG_RX,
7330 ("%s: RX: Rx buffer allocation failed, "
7331 "dropping packet%s\n", device_xname(sc->sc_dev),
7332 rxq->rxq_discard ? " (discard)" : ""));
7333 continue;
7334 }
7335
7336 m->m_len = len;
7337 rxq->rxq_len += len;
7338 DPRINTF(WM_DEBUG_RX,
7339 ("%s: RX: buffer at %p len %d\n",
7340 device_xname(sc->sc_dev), m->m_data, len));
7341
7342 /* If this is not the end of the packet, keep looking. */
7343 if ((status & WRX_ST_EOP) == 0) {
7344 WM_RXCHAIN_LINK(rxq, m);
7345 DPRINTF(WM_DEBUG_RX,
7346 ("%s: RX: not yet EOP, rxlen -> %d\n",
7347 device_xname(sc->sc_dev), rxq->rxq_len));
7348 continue;
7349 }
7350
7351 /*
7352 * Okay, we have the entire packet now. The chip is
7353 * configured to include the FCS except I350 and I21[01]
7354 * (not all chips can be configured to strip it),
7355 * so we need to trim it.
7356 * May need to adjust length of previous mbuf in the
7357 * chain if the current mbuf is too short.
7358 * For an eratta, the RCTL_SECRC bit in RCTL register
7359 * is always set in I350, so we don't trim it.
7360 */
7361 if ((sc->sc_type != WM_T_I350) && (sc->sc_type != WM_T_I354)
7362 && (sc->sc_type != WM_T_I210)
7363 && (sc->sc_type != WM_T_I211)) {
7364 if (m->m_len < ETHER_CRC_LEN) {
7365 rxq->rxq_tail->m_len
7366 -= (ETHER_CRC_LEN - m->m_len);
7367 m->m_len = 0;
7368 } else
7369 m->m_len -= ETHER_CRC_LEN;
7370 len = rxq->rxq_len - ETHER_CRC_LEN;
7371 } else
7372 len = rxq->rxq_len;
7373
7374 WM_RXCHAIN_LINK(rxq, m);
7375
7376 *rxq->rxq_tailp = NULL;
7377 m = rxq->rxq_head;
7378
7379 WM_RXCHAIN_RESET(rxq);
7380
7381 DPRINTF(WM_DEBUG_RX,
7382 ("%s: RX: have entire packet, len -> %d\n",
7383 device_xname(sc->sc_dev), len));
7384
7385 /* If an error occurred, update stats and drop the packet. */
7386 if (errors &
7387 (WRX_ER_CE|WRX_ER_SE|WRX_ER_SEQ|WRX_ER_CXE|WRX_ER_RXE)) {
7388 if (errors & WRX_ER_SE)
7389 log(LOG_WARNING, "%s: symbol error\n",
7390 device_xname(sc->sc_dev));
7391 else if (errors & WRX_ER_SEQ)
7392 log(LOG_WARNING, "%s: receive sequence error\n",
7393 device_xname(sc->sc_dev));
7394 else if (errors & WRX_ER_CE)
7395 log(LOG_WARNING, "%s: CRC error\n",
7396 device_xname(sc->sc_dev));
7397 m_freem(m);
7398 continue;
7399 }
7400
7401 /* No errors. Receive the packet. */
7402 m_set_rcvif(m, ifp);
7403 m->m_pkthdr.len = len;
7404
7405 /*
7406 * If VLANs are enabled, VLAN packets have been unwrapped
7407 * for us. Associate the tag with the packet.
7408 */
7409 /* XXXX should check for i350 and i354 */
7410 if ((status & WRX_ST_VP) != 0) {
7411 VLAN_INPUT_TAG(ifp, m, le16toh(vlantag), continue);
7412 }
7413
7414 /* Set up checksum info for this packet. */
7415 if ((status & WRX_ST_IXSM) == 0) {
7416 if (status & WRX_ST_IPCS) {
7417 WM_Q_EVCNT_INCR(rxq, rxipsum);
7418 m->m_pkthdr.csum_flags |= M_CSUM_IPv4;
7419 if (errors & WRX_ER_IPE)
7420 m->m_pkthdr.csum_flags |=
7421 M_CSUM_IPv4_BAD;
7422 }
7423 if (status & WRX_ST_TCPCS) {
7424 /*
7425 * Note: we don't know if this was TCP or UDP,
7426 * so we just set both bits, and expect the
7427 * upper layers to deal.
7428 */
7429 WM_Q_EVCNT_INCR(rxq, rxtusum);
7430 m->m_pkthdr.csum_flags |=
7431 M_CSUM_TCPv4 | M_CSUM_UDPv4 |
7432 M_CSUM_TCPv6 | M_CSUM_UDPv6;
7433 if (errors & WRX_ER_TCPE)
7434 m->m_pkthdr.csum_flags |=
7435 M_CSUM_TCP_UDP_BAD;
7436 }
7437 }
7438
7439 ifp->if_ipackets++;
7440
7441 mutex_exit(rxq->rxq_lock);
7442
7443 /* Pass this up to any BPF listeners. */
7444 bpf_mtap(ifp, m);
7445
7446 /* Pass it on. */
7447 if_percpuq_enqueue(sc->sc_ipq, m);
7448
7449 mutex_enter(rxq->rxq_lock);
7450
7451 if (rxq->rxq_stopping)
7452 break;
7453 }
7454
7455 /* Update the receive pointer. */
7456 rxq->rxq_ptr = i;
7457 if (count != 0)
7458 rnd_add_uint32(&sc->rnd_source, count);
7459
7460 DPRINTF(WM_DEBUG_RX,
7461 ("%s: RX: rxptr -> %d\n", device_xname(sc->sc_dev), i));
7462 }
7463
7464 /*
7465 * wm_linkintr_gmii:
7466 *
7467 * Helper; handle link interrupts for GMII.
7468 */
7469 static void
7470 wm_linkintr_gmii(struct wm_softc *sc, uint32_t icr)
7471 {
7472
7473 KASSERT(WM_CORE_LOCKED(sc));
7474
7475 DPRINTF(WM_DEBUG_LINK, ("%s: %s:\n", device_xname(sc->sc_dev),
7476 __func__));
7477
7478 if (icr & ICR_LSC) {
7479 uint32_t status = CSR_READ(sc, WMREG_STATUS);
7480
7481 if ((sc->sc_type == WM_T_ICH8) && ((status & STATUS_LU) == 0))
7482 wm_gig_downshift_workaround_ich8lan(sc);
7483
7484 DPRINTF(WM_DEBUG_LINK, ("%s: LINK: LSC -> mii_pollstat\n",
7485 device_xname(sc->sc_dev)));
7486 mii_pollstat(&sc->sc_mii);
7487 if (sc->sc_type == WM_T_82543) {
7488 int miistatus, active;
7489
7490 /*
7491 * With 82543, we need to force speed and
7492 * duplex on the MAC equal to what the PHY
7493 * speed and duplex configuration is.
7494 */
7495 miistatus = sc->sc_mii.mii_media_status;
7496
7497 if (miistatus & IFM_ACTIVE) {
7498 active = sc->sc_mii.mii_media_active;
7499 sc->sc_ctrl &= ~(CTRL_SPEED_MASK | CTRL_FD);
7500 switch (IFM_SUBTYPE(active)) {
7501 case IFM_10_T:
7502 sc->sc_ctrl |= CTRL_SPEED_10;
7503 break;
7504 case IFM_100_TX:
7505 sc->sc_ctrl |= CTRL_SPEED_100;
7506 break;
7507 case IFM_1000_T:
7508 sc->sc_ctrl |= CTRL_SPEED_1000;
7509 break;
7510 default:
7511 /*
7512 * fiber?
7513 * Shoud not enter here.
7514 */
7515 printf("unknown media (%x)\n", active);
7516 break;
7517 }
7518 if (active & IFM_FDX)
7519 sc->sc_ctrl |= CTRL_FD;
7520 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
7521 }
7522 } else if ((sc->sc_type == WM_T_ICH8)
7523 && (sc->sc_phytype == WMPHY_IGP_3)) {
7524 wm_kmrn_lock_loss_workaround_ich8lan(sc);
7525 } else if (sc->sc_type == WM_T_PCH) {
7526 wm_k1_gig_workaround_hv(sc,
7527 ((sc->sc_mii.mii_media_status & IFM_ACTIVE) != 0));
7528 }
7529
7530 if ((sc->sc_phytype == WMPHY_82578)
7531 && (IFM_SUBTYPE(sc->sc_mii.mii_media_active)
7532 == IFM_1000_T)) {
7533
7534 if ((sc->sc_mii.mii_media_status & IFM_ACTIVE) != 0) {
7535 delay(200*1000); /* XXX too big */
7536
7537 /* Link stall fix for link up */
7538 wm_gmii_hv_writereg(sc->sc_dev, 1,
7539 HV_MUX_DATA_CTRL,
7540 HV_MUX_DATA_CTRL_GEN_TO_MAC
7541 | HV_MUX_DATA_CTRL_FORCE_SPEED);
7542 wm_gmii_hv_writereg(sc->sc_dev, 1,
7543 HV_MUX_DATA_CTRL,
7544 HV_MUX_DATA_CTRL_GEN_TO_MAC);
7545 }
7546 }
7547 } else if (icr & ICR_RXSEQ) {
7548 DPRINTF(WM_DEBUG_LINK, ("%s: LINK Receive sequence error\n",
7549 device_xname(sc->sc_dev)));
7550 }
7551 }
7552
7553 /*
7554 * wm_linkintr_tbi:
7555 *
7556 * Helper; handle link interrupts for TBI mode.
7557 */
7558 static void
7559 wm_linkintr_tbi(struct wm_softc *sc, uint32_t icr)
7560 {
7561 uint32_t status;
7562
7563 DPRINTF(WM_DEBUG_LINK, ("%s: %s:\n", device_xname(sc->sc_dev),
7564 __func__));
7565
7566 status = CSR_READ(sc, WMREG_STATUS);
7567 if (icr & ICR_LSC) {
7568 if (status & STATUS_LU) {
7569 DPRINTF(WM_DEBUG_LINK, ("%s: LINK: LSC -> up %s\n",
7570 device_xname(sc->sc_dev),
7571 (status & STATUS_FD) ? "FDX" : "HDX"));
7572 /*
7573 * NOTE: CTRL will update TFCE and RFCE automatically,
7574 * so we should update sc->sc_ctrl
7575 */
7576
7577 sc->sc_ctrl = CSR_READ(sc, WMREG_CTRL);
7578 sc->sc_tctl &= ~TCTL_COLD(0x3ff);
7579 sc->sc_fcrtl &= ~FCRTL_XONE;
7580 if (status & STATUS_FD)
7581 sc->sc_tctl |=
7582 TCTL_COLD(TX_COLLISION_DISTANCE_FDX);
7583 else
7584 sc->sc_tctl |=
7585 TCTL_COLD(TX_COLLISION_DISTANCE_HDX);
7586 if (sc->sc_ctrl & CTRL_TFCE)
7587 sc->sc_fcrtl |= FCRTL_XONE;
7588 CSR_WRITE(sc, WMREG_TCTL, sc->sc_tctl);
7589 CSR_WRITE(sc, (sc->sc_type < WM_T_82543) ?
7590 WMREG_OLD_FCRTL : WMREG_FCRTL,
7591 sc->sc_fcrtl);
7592 sc->sc_tbi_linkup = 1;
7593 } else {
7594 DPRINTF(WM_DEBUG_LINK, ("%s: LINK: LSC -> down\n",
7595 device_xname(sc->sc_dev)));
7596 sc->sc_tbi_linkup = 0;
7597 }
7598 /* Update LED */
7599 wm_tbi_serdes_set_linkled(sc);
7600 } else if (icr & ICR_RXSEQ) {
7601 DPRINTF(WM_DEBUG_LINK,
7602 ("%s: LINK: Receive sequence error\n",
7603 device_xname(sc->sc_dev)));
7604 }
7605 }
7606
7607 /*
7608 * wm_linkintr_serdes:
7609 *
7610 * Helper; handle link interrupts for TBI mode.
7611 */
7612 static void
7613 wm_linkintr_serdes(struct wm_softc *sc, uint32_t icr)
7614 {
7615 struct mii_data *mii = &sc->sc_mii;
7616 struct ifmedia_entry *ife = sc->sc_mii.mii_media.ifm_cur;
7617 uint32_t pcs_adv, pcs_lpab, reg;
7618
7619 DPRINTF(WM_DEBUG_LINK, ("%s: %s:\n", device_xname(sc->sc_dev),
7620 __func__));
7621
7622 if (icr & ICR_LSC) {
7623 /* Check PCS */
7624 reg = CSR_READ(sc, WMREG_PCS_LSTS);
7625 if ((reg & PCS_LSTS_LINKOK) != 0) {
7626 mii->mii_media_status |= IFM_ACTIVE;
7627 sc->sc_tbi_linkup = 1;
7628 } else {
7629 mii->mii_media_status |= IFM_NONE;
7630 sc->sc_tbi_linkup = 0;
7631 wm_tbi_serdes_set_linkled(sc);
7632 return;
7633 }
7634 mii->mii_media_active |= IFM_1000_SX;
7635 if ((reg & PCS_LSTS_FDX) != 0)
7636 mii->mii_media_active |= IFM_FDX;
7637 else
7638 mii->mii_media_active |= IFM_HDX;
7639 if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
7640 /* Check flow */
7641 reg = CSR_READ(sc, WMREG_PCS_LSTS);
7642 if ((reg & PCS_LSTS_AN_COMP) == 0) {
7643 DPRINTF(WM_DEBUG_LINK,
7644 ("XXX LINKOK but not ACOMP\n"));
7645 return;
7646 }
7647 pcs_adv = CSR_READ(sc, WMREG_PCS_ANADV);
7648 pcs_lpab = CSR_READ(sc, WMREG_PCS_LPAB);
7649 DPRINTF(WM_DEBUG_LINK,
7650 ("XXX AN result %08x, %08x\n", pcs_adv, pcs_lpab));
7651 if ((pcs_adv & TXCW_SYM_PAUSE)
7652 && (pcs_lpab & TXCW_SYM_PAUSE)) {
7653 mii->mii_media_active |= IFM_FLOW
7654 | IFM_ETH_TXPAUSE | IFM_ETH_RXPAUSE;
7655 } else if (((pcs_adv & TXCW_SYM_PAUSE) == 0)
7656 && (pcs_adv & TXCW_ASYM_PAUSE)
7657 && (pcs_lpab & TXCW_SYM_PAUSE)
7658 && (pcs_lpab & TXCW_ASYM_PAUSE))
7659 mii->mii_media_active |= IFM_FLOW
7660 | IFM_ETH_TXPAUSE;
7661 else if ((pcs_adv & TXCW_SYM_PAUSE)
7662 && (pcs_adv & TXCW_ASYM_PAUSE)
7663 && ((pcs_lpab & TXCW_SYM_PAUSE) == 0)
7664 && (pcs_lpab & TXCW_ASYM_PAUSE))
7665 mii->mii_media_active |= IFM_FLOW
7666 | IFM_ETH_RXPAUSE;
7667 }
7668 /* Update LED */
7669 wm_tbi_serdes_set_linkled(sc);
7670 } else {
7671 DPRINTF(WM_DEBUG_LINK,
7672 ("%s: LINK: Receive sequence error\n",
7673 device_xname(sc->sc_dev)));
7674 }
7675 }
7676
7677 /*
7678 * wm_linkintr:
7679 *
7680 * Helper; handle link interrupts.
7681 */
7682 static void
7683 wm_linkintr(struct wm_softc *sc, uint32_t icr)
7684 {
7685
7686 KASSERT(WM_CORE_LOCKED(sc));
7687
7688 if (sc->sc_flags & WM_F_HAS_MII)
7689 wm_linkintr_gmii(sc, icr);
7690 else if ((sc->sc_mediatype == WM_MEDIATYPE_SERDES)
7691 && (sc->sc_type >= WM_T_82575))
7692 wm_linkintr_serdes(sc, icr);
7693 else
7694 wm_linkintr_tbi(sc, icr);
7695 }
7696
7697 /*
7698 * wm_intr_legacy:
7699 *
7700 * Interrupt service routine for INTx and MSI.
7701 */
7702 static int
7703 wm_intr_legacy(void *arg)
7704 {
7705 struct wm_softc *sc = arg;
7706 struct wm_txqueue *txq = &sc->sc_queue[0].wmq_txq;
7707 struct wm_rxqueue *rxq = &sc->sc_queue[0].wmq_rxq;
7708 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
7709 uint32_t icr, rndval = 0;
7710 int handled = 0;
7711
7712 DPRINTF(WM_DEBUG_TX,
7713 ("%s: INTx: got intr\n", device_xname(sc->sc_dev)));
7714 while (1 /* CONSTCOND */) {
7715 icr = CSR_READ(sc, WMREG_ICR);
7716 if ((icr & sc->sc_icr) == 0)
7717 break;
7718 if (rndval == 0)
7719 rndval = icr;
7720
7721 mutex_enter(rxq->rxq_lock);
7722
7723 if (rxq->rxq_stopping) {
7724 mutex_exit(rxq->rxq_lock);
7725 break;
7726 }
7727
7728 handled = 1;
7729
7730 #if defined(WM_DEBUG) || defined(WM_EVENT_COUNTERS)
7731 if (icr & (ICR_RXDMT0 | ICR_RXT0)) {
7732 DPRINTF(WM_DEBUG_RX,
7733 ("%s: RX: got Rx intr 0x%08x\n",
7734 device_xname(sc->sc_dev),
7735 icr & (ICR_RXDMT0 | ICR_RXT0)));
7736 WM_Q_EVCNT_INCR(rxq, rxintr);
7737 }
7738 #endif
7739 wm_rxeof(rxq);
7740
7741 mutex_exit(rxq->rxq_lock);
7742 mutex_enter(txq->txq_lock);
7743
7744 if (txq->txq_stopping) {
7745 mutex_exit(txq->txq_lock);
7746 break;
7747 }
7748
7749 #if defined(WM_DEBUG) || defined(WM_EVENT_COUNTERS)
7750 if (icr & ICR_TXDW) {
7751 DPRINTF(WM_DEBUG_TX,
7752 ("%s: TX: got TXDW interrupt\n",
7753 device_xname(sc->sc_dev)));
7754 WM_Q_EVCNT_INCR(txq, txdw);
7755 }
7756 #endif
7757 wm_txeof(sc, txq);
7758
7759 mutex_exit(txq->txq_lock);
7760 WM_CORE_LOCK(sc);
7761
7762 if (sc->sc_core_stopping) {
7763 WM_CORE_UNLOCK(sc);
7764 break;
7765 }
7766
7767 if (icr & (ICR_LSC | ICR_RXSEQ)) {
7768 WM_EVCNT_INCR(&sc->sc_ev_linkintr);
7769 wm_linkintr(sc, icr);
7770 }
7771
7772 WM_CORE_UNLOCK(sc);
7773
7774 if (icr & ICR_RXO) {
7775 #if defined(WM_DEBUG)
7776 log(LOG_WARNING, "%s: Receive overrun\n",
7777 device_xname(sc->sc_dev));
7778 #endif /* defined(WM_DEBUG) */
7779 }
7780 }
7781
7782 rnd_add_uint32(&sc->rnd_source, rndval);
7783
7784 if (handled) {
7785 /* Try to get more packets going. */
7786 ifp->if_start(ifp);
7787 }
7788
7789 return handled;
7790 }
7791
7792 static int
7793 wm_txrxintr_msix(void *arg)
7794 {
7795 struct wm_queue *wmq = arg;
7796 struct wm_txqueue *txq = &wmq->wmq_txq;
7797 struct wm_rxqueue *rxq = &wmq->wmq_rxq;
7798 struct wm_softc *sc = txq->txq_sc;
7799 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
7800
7801 KASSERT(wmq->wmq_intr_idx == wmq->wmq_id);
7802
7803 DPRINTF(WM_DEBUG_TX,
7804 ("%s: TX: got Tx intr\n", device_xname(sc->sc_dev)));
7805
7806 if (sc->sc_type == WM_T_82574)
7807 CSR_WRITE(sc, WMREG_IMC, ICR_TXQ(wmq->wmq_id) | ICR_RXQ(wmq->wmq_id));
7808 else if (sc->sc_type == WM_T_82575)
7809 CSR_WRITE(sc, WMREG_EIMC, EITR_TX_QUEUE(wmq->wmq_id) | EITR_RX_QUEUE(wmq->wmq_id));
7810 else
7811 CSR_WRITE(sc, WMREG_EIMC, 1 << wmq->wmq_intr_idx);
7812
7813 mutex_enter(txq->txq_lock);
7814
7815 if (txq->txq_stopping) {
7816 mutex_exit(txq->txq_lock);
7817 return 0;
7818 }
7819
7820 WM_Q_EVCNT_INCR(txq, txdw);
7821 wm_txeof(sc, txq);
7822
7823 /* Try to get more packets going. */
7824 if (pcq_peek(txq->txq_interq) != NULL)
7825 wm_nq_transmit_locked(ifp, txq);
7826 /*
7827 * There are still some upper layer processing which call
7828 * ifp->if_start(). e.g. ALTQ
7829 */
7830 if (wmq->wmq_id == 0) {
7831 if (!IFQ_IS_EMPTY(&ifp->if_snd))
7832 wm_nq_start_locked(ifp);
7833 }
7834
7835 mutex_exit(txq->txq_lock);
7836
7837 DPRINTF(WM_DEBUG_RX,
7838 ("%s: RX: got Rx intr\n", device_xname(sc->sc_dev)));
7839 mutex_enter(rxq->rxq_lock);
7840
7841 if (rxq->rxq_stopping) {
7842 mutex_exit(rxq->rxq_lock);
7843 return 0;
7844 }
7845
7846 WM_Q_EVCNT_INCR(rxq, rxintr);
7847 wm_rxeof(rxq);
7848 mutex_exit(rxq->rxq_lock);
7849
7850 if (sc->sc_type == WM_T_82574)
7851 CSR_WRITE(sc, WMREG_IMS, ICR_TXQ(wmq->wmq_id) | ICR_RXQ(wmq->wmq_id));
7852 else if (sc->sc_type == WM_T_82575)
7853 CSR_WRITE(sc, WMREG_EIMS, EITR_TX_QUEUE(wmq->wmq_id) | EITR_RX_QUEUE(wmq->wmq_id));
7854 else
7855 CSR_WRITE(sc, WMREG_EIMS, 1 << wmq->wmq_intr_idx);
7856
7857 return 1;
7858 }
7859
7860 /*
7861 * wm_linkintr_msix:
7862 *
7863 * Interrupt service routine for link status change for MSI-X.
7864 */
7865 static int
7866 wm_linkintr_msix(void *arg)
7867 {
7868 struct wm_softc *sc = arg;
7869 uint32_t reg;
7870
7871 DPRINTF(WM_DEBUG_LINK,
7872 ("%s: LINK: got link intr\n", device_xname(sc->sc_dev)));
7873
7874 reg = CSR_READ(sc, WMREG_ICR);
7875 WM_CORE_LOCK(sc);
7876 if ((sc->sc_core_stopping) || ((reg & ICR_LSC) == 0))
7877 goto out;
7878
7879 WM_EVCNT_INCR(&sc->sc_ev_linkintr);
7880 wm_linkintr(sc, ICR_LSC);
7881
7882 out:
7883 WM_CORE_UNLOCK(sc);
7884
7885 if (sc->sc_type == WM_T_82574)
7886 CSR_WRITE(sc, WMREG_IMS, ICR_OTHER | ICR_LSC);
7887 else if (sc->sc_type == WM_T_82575)
7888 CSR_WRITE(sc, WMREG_EIMS, EITR_OTHER);
7889 else
7890 CSR_WRITE(sc, WMREG_EIMS, 1 << sc->sc_link_intr_idx);
7891
7892 return 1;
7893 }
7894
7895 /*
7896 * Media related.
7897 * GMII, SGMII, TBI (and SERDES)
7898 */
7899
7900 /* Common */
7901
7902 /*
7903 * wm_tbi_serdes_set_linkled:
7904 *
7905 * Update the link LED on TBI and SERDES devices.
7906 */
7907 static void
7908 wm_tbi_serdes_set_linkled(struct wm_softc *sc)
7909 {
7910
7911 if (sc->sc_tbi_linkup)
7912 sc->sc_ctrl |= CTRL_SWDPIN(0);
7913 else
7914 sc->sc_ctrl &= ~CTRL_SWDPIN(0);
7915
7916 /* 82540 or newer devices are active low */
7917 sc->sc_ctrl ^= (sc->sc_type >= WM_T_82540) ? CTRL_SWDPIN(0) : 0;
7918
7919 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
7920 }
7921
7922 /* GMII related */
7923
7924 /*
7925 * wm_gmii_reset:
7926 *
7927 * Reset the PHY.
7928 */
7929 static void
7930 wm_gmii_reset(struct wm_softc *sc)
7931 {
7932 uint32_t reg;
7933 int rv;
7934
7935 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
7936 device_xname(sc->sc_dev), __func__));
7937
7938 rv = sc->phy.acquire(sc);
7939 if (rv != 0) {
7940 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
7941 __func__);
7942 return;
7943 }
7944
7945 switch (sc->sc_type) {
7946 case WM_T_82542_2_0:
7947 case WM_T_82542_2_1:
7948 /* null */
7949 break;
7950 case WM_T_82543:
7951 /*
7952 * With 82543, we need to force speed and duplex on the MAC
7953 * equal to what the PHY speed and duplex configuration is.
7954 * In addition, we need to perform a hardware reset on the PHY
7955 * to take it out of reset.
7956 */
7957 sc->sc_ctrl |= CTRL_FRCSPD | CTRL_FRCFDX;
7958 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
7959
7960 /* The PHY reset pin is active-low. */
7961 reg = CSR_READ(sc, WMREG_CTRL_EXT);
7962 reg &= ~((CTRL_EXT_SWDPIO_MASK << CTRL_EXT_SWDPIO_SHIFT) |
7963 CTRL_EXT_SWDPIN(4));
7964 reg |= CTRL_EXT_SWDPIO(4);
7965
7966 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
7967 CSR_WRITE_FLUSH(sc);
7968 delay(10*1000);
7969
7970 CSR_WRITE(sc, WMREG_CTRL_EXT, reg | CTRL_EXT_SWDPIN(4));
7971 CSR_WRITE_FLUSH(sc);
7972 delay(150);
7973 #if 0
7974 sc->sc_ctrl_ext = reg | CTRL_EXT_SWDPIN(4);
7975 #endif
7976 delay(20*1000); /* XXX extra delay to get PHY ID? */
7977 break;
7978 case WM_T_82544: /* reset 10000us */
7979 case WM_T_82540:
7980 case WM_T_82545:
7981 case WM_T_82545_3:
7982 case WM_T_82546:
7983 case WM_T_82546_3:
7984 case WM_T_82541:
7985 case WM_T_82541_2:
7986 case WM_T_82547:
7987 case WM_T_82547_2:
7988 case WM_T_82571: /* reset 100us */
7989 case WM_T_82572:
7990 case WM_T_82573:
7991 case WM_T_82574:
7992 case WM_T_82575:
7993 case WM_T_82576:
7994 case WM_T_82580:
7995 case WM_T_I350:
7996 case WM_T_I354:
7997 case WM_T_I210:
7998 case WM_T_I211:
7999 case WM_T_82583:
8000 case WM_T_80003:
8001 /* generic reset */
8002 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl | CTRL_PHY_RESET);
8003 CSR_WRITE_FLUSH(sc);
8004 delay(20000);
8005 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
8006 CSR_WRITE_FLUSH(sc);
8007 delay(20000);
8008
8009 if ((sc->sc_type == WM_T_82541)
8010 || (sc->sc_type == WM_T_82541_2)
8011 || (sc->sc_type == WM_T_82547)
8012 || (sc->sc_type == WM_T_82547_2)) {
8013 /* workaround for igp are done in igp_reset() */
8014 /* XXX add code to set LED after phy reset */
8015 }
8016 break;
8017 case WM_T_ICH8:
8018 case WM_T_ICH9:
8019 case WM_T_ICH10:
8020 case WM_T_PCH:
8021 case WM_T_PCH2:
8022 case WM_T_PCH_LPT:
8023 case WM_T_PCH_SPT:
8024 /* generic reset */
8025 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl | CTRL_PHY_RESET);
8026 CSR_WRITE_FLUSH(sc);
8027 delay(100);
8028 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
8029 CSR_WRITE_FLUSH(sc);
8030 delay(150);
8031 break;
8032 default:
8033 panic("%s: %s: unknown type\n", device_xname(sc->sc_dev),
8034 __func__);
8035 break;
8036 }
8037
8038 sc->phy.release(sc);
8039
8040 /* get_cfg_done */
8041 wm_get_cfg_done(sc);
8042
8043 /* extra setup */
8044 switch (sc->sc_type) {
8045 case WM_T_82542_2_0:
8046 case WM_T_82542_2_1:
8047 case WM_T_82543:
8048 case WM_T_82544:
8049 case WM_T_82540:
8050 case WM_T_82545:
8051 case WM_T_82545_3:
8052 case WM_T_82546:
8053 case WM_T_82546_3:
8054 case WM_T_82541_2:
8055 case WM_T_82547_2:
8056 case WM_T_82571:
8057 case WM_T_82572:
8058 case WM_T_82573:
8059 case WM_T_82575:
8060 case WM_T_82576:
8061 case WM_T_82580:
8062 case WM_T_I350:
8063 case WM_T_I354:
8064 case WM_T_I210:
8065 case WM_T_I211:
8066 case WM_T_80003:
8067 /* null */
8068 break;
8069 case WM_T_82574:
8070 case WM_T_82583:
8071 wm_lplu_d0_disable(sc);
8072 break;
8073 case WM_T_82541:
8074 case WM_T_82547:
8075 /* XXX Configure actively LED after PHY reset */
8076 break;
8077 case WM_T_ICH8:
8078 case WM_T_ICH9:
8079 case WM_T_ICH10:
8080 case WM_T_PCH:
8081 case WM_T_PCH2:
8082 case WM_T_PCH_LPT:
8083 case WM_T_PCH_SPT:
8084 /* Allow time for h/w to get to a quiescent state afer reset */
8085 delay(10*1000);
8086
8087 if (sc->sc_type == WM_T_PCH)
8088 wm_hv_phy_workaround_ich8lan(sc);
8089
8090 if (sc->sc_type == WM_T_PCH2)
8091 wm_lv_phy_workaround_ich8lan(sc);
8092
8093 if ((sc->sc_type == WM_T_PCH) || (sc->sc_type == WM_T_PCH2)) {
8094 /*
8095 * dummy read to clear the phy wakeup bit after lcd
8096 * reset
8097 */
8098 reg = wm_gmii_hv_readreg(sc->sc_dev, 1, BM_WUC);
8099 }
8100
8101 /*
8102 * XXX Configure the LCD with th extended configuration region
8103 * in NVM
8104 */
8105
8106 /* Disable D0 LPLU. */
8107 if (sc->sc_type >= WM_T_PCH) /* PCH* */
8108 wm_lplu_d0_disable_pch(sc);
8109 else
8110 wm_lplu_d0_disable(sc); /* ICH* */
8111 break;
8112 default:
8113 panic("%s: unknown type\n", __func__);
8114 break;
8115 }
8116 }
8117
8118 /*
8119 * wm_get_phy_id_82575:
8120 *
8121 * Return PHY ID. Return -1 if it failed.
8122 */
8123 static int
8124 wm_get_phy_id_82575(struct wm_softc *sc)
8125 {
8126 uint32_t reg;
8127 int phyid = -1;
8128
8129 /* XXX */
8130 if ((sc->sc_flags & WM_F_SGMII) == 0)
8131 return -1;
8132
8133 if (wm_sgmii_uses_mdio(sc)) {
8134 switch (sc->sc_type) {
8135 case WM_T_82575:
8136 case WM_T_82576:
8137 reg = CSR_READ(sc, WMREG_MDIC);
8138 phyid = (reg & MDIC_PHY_MASK) >> MDIC_PHY_SHIFT;
8139 break;
8140 case WM_T_82580:
8141 case WM_T_I350:
8142 case WM_T_I354:
8143 case WM_T_I210:
8144 case WM_T_I211:
8145 reg = CSR_READ(sc, WMREG_MDICNFG);
8146 phyid = (reg & MDICNFG_PHY_MASK) >> MDICNFG_PHY_SHIFT;
8147 break;
8148 default:
8149 return -1;
8150 }
8151 }
8152
8153 return phyid;
8154 }
8155
8156
8157 /*
8158 * wm_gmii_mediainit:
8159 *
8160 * Initialize media for use on 1000BASE-T devices.
8161 */
8162 static void
8163 wm_gmii_mediainit(struct wm_softc *sc, pci_product_id_t prodid)
8164 {
8165 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
8166 struct mii_data *mii = &sc->sc_mii;
8167 uint32_t reg;
8168
8169 DPRINTF(WM_DEBUG_GMII, ("%s: %s called\n",
8170 device_xname(sc->sc_dev), __func__));
8171
8172 /* We have GMII. */
8173 sc->sc_flags |= WM_F_HAS_MII;
8174
8175 if (sc->sc_type == WM_T_80003)
8176 sc->sc_tipg = TIPG_1000T_80003_DFLT;
8177 else
8178 sc->sc_tipg = TIPG_1000T_DFLT;
8179
8180 /* XXX Not for I354? FreeBSD's e1000_82575.c doesn't include it */
8181 if ((sc->sc_type == WM_T_82580)
8182 || (sc->sc_type == WM_T_I350) || (sc->sc_type == WM_T_I210)
8183 || (sc->sc_type == WM_T_I211)) {
8184 reg = CSR_READ(sc, WMREG_PHPM);
8185 reg &= ~PHPM_GO_LINK_D;
8186 CSR_WRITE(sc, WMREG_PHPM, reg);
8187 }
8188
8189 /*
8190 * Let the chip set speed/duplex on its own based on
8191 * signals from the PHY.
8192 * XXXbouyer - I'm not sure this is right for the 80003,
8193 * the em driver only sets CTRL_SLU here - but it seems to work.
8194 */
8195 sc->sc_ctrl |= CTRL_SLU;
8196 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
8197
8198 /* Initialize our media structures and probe the GMII. */
8199 mii->mii_ifp = ifp;
8200
8201 /*
8202 * Determine the PHY access method.
8203 *
8204 * For SGMII, use SGMII specific method.
8205 *
8206 * For some devices, we can determine the PHY access method
8207 * from sc_type.
8208 *
8209 * For ICH and PCH variants, it's difficult to determine the PHY
8210 * access method by sc_type, so use the PCI product ID for some
8211 * devices.
8212 * For other ICH8 variants, try to use igp's method. If the PHY
8213 * can't detect, then use bm's method.
8214 */
8215 switch (prodid) {
8216 case PCI_PRODUCT_INTEL_PCH_M_LM:
8217 case PCI_PRODUCT_INTEL_PCH_M_LC:
8218 /* 82577 */
8219 sc->sc_phytype = WMPHY_82577;
8220 break;
8221 case PCI_PRODUCT_INTEL_PCH_D_DM:
8222 case PCI_PRODUCT_INTEL_PCH_D_DC:
8223 /* 82578 */
8224 sc->sc_phytype = WMPHY_82578;
8225 break;
8226 case PCI_PRODUCT_INTEL_PCH2_LV_LM:
8227 case PCI_PRODUCT_INTEL_PCH2_LV_V:
8228 /* 82579 */
8229 sc->sc_phytype = WMPHY_82579;
8230 break;
8231 case PCI_PRODUCT_INTEL_82801H_82567V_3:
8232 case PCI_PRODUCT_INTEL_82801I_BM:
8233 case PCI_PRODUCT_INTEL_82801J_R_BM_LM:
8234 case PCI_PRODUCT_INTEL_82801J_R_BM_LF:
8235 case PCI_PRODUCT_INTEL_82801J_D_BM_LM:
8236 case PCI_PRODUCT_INTEL_82801J_D_BM_LF:
8237 case PCI_PRODUCT_INTEL_82801J_R_BM_V:
8238 /* ICH8, 9, 10 with 82567 */
8239 sc->sc_phytype = WMPHY_BM;
8240 mii->mii_readreg = wm_gmii_bm_readreg;
8241 mii->mii_writereg = wm_gmii_bm_writereg;
8242 break;
8243 default:
8244 if (((sc->sc_flags & WM_F_SGMII) != 0)
8245 && !wm_sgmii_uses_mdio(sc)){
8246 /* SGMII */
8247 mii->mii_readreg = wm_sgmii_readreg;
8248 mii->mii_writereg = wm_sgmii_writereg;
8249 } else if (sc->sc_type >= WM_T_ICH8) {
8250 /* non-82567 ICH8, 9 and 10 */
8251 mii->mii_readreg = wm_gmii_i82544_readreg;
8252 mii->mii_writereg = wm_gmii_i82544_writereg;
8253 } else if (sc->sc_type >= WM_T_80003) {
8254 /* 80003 */
8255 sc->sc_phytype = WMPHY_GG82563;
8256 mii->mii_readreg = wm_gmii_i80003_readreg;
8257 mii->mii_writereg = wm_gmii_i80003_writereg;
8258 } else if (sc->sc_type >= WM_T_I210) {
8259 /* I210 and I211 */
8260 sc->sc_phytype = WMPHY_210;
8261 mii->mii_readreg = wm_gmii_gs40g_readreg;
8262 mii->mii_writereg = wm_gmii_gs40g_writereg;
8263 } else if (sc->sc_type >= WM_T_82580) {
8264 /* 82580, I350 and I354 */
8265 sc->sc_phytype = WMPHY_82580;
8266 mii->mii_readreg = wm_gmii_82580_readreg;
8267 mii->mii_writereg = wm_gmii_82580_writereg;
8268 } else if (sc->sc_type >= WM_T_82544) {
8269 /* 82544, 0, [56], [17], 8257[1234] and 82583 */
8270 mii->mii_readreg = wm_gmii_i82544_readreg;
8271 mii->mii_writereg = wm_gmii_i82544_writereg;
8272 } else {
8273 mii->mii_readreg = wm_gmii_i82543_readreg;
8274 mii->mii_writereg = wm_gmii_i82543_writereg;
8275 }
8276 break;
8277 }
8278 if ((sc->sc_type >= WM_T_PCH) && (sc->sc_type <= WM_T_PCH_SPT)) {
8279 /* All PCH* use _hv_ */
8280 mii->mii_readreg = wm_gmii_hv_readreg;
8281 mii->mii_writereg = wm_gmii_hv_writereg;
8282 }
8283 mii->mii_statchg = wm_gmii_statchg;
8284
8285 wm_gmii_reset(sc);
8286
8287 sc->sc_ethercom.ec_mii = &sc->sc_mii;
8288 ifmedia_init(&mii->mii_media, IFM_IMASK, wm_gmii_mediachange,
8289 wm_gmii_mediastatus);
8290
8291 if ((sc->sc_type == WM_T_82575) || (sc->sc_type == WM_T_82576)
8292 || (sc->sc_type == WM_T_82580)
8293 || (sc->sc_type == WM_T_I350) || (sc->sc_type == WM_T_I354)
8294 || (sc->sc_type == WM_T_I210) || (sc->sc_type == WM_T_I211)) {
8295 if ((sc->sc_flags & WM_F_SGMII) == 0) {
8296 /* Attach only one port */
8297 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff, 1,
8298 MII_OFFSET_ANY, MIIF_DOPAUSE);
8299 } else {
8300 int i, id;
8301 uint32_t ctrl_ext;
8302
8303 id = wm_get_phy_id_82575(sc);
8304 if (id != -1) {
8305 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff,
8306 id, MII_OFFSET_ANY, MIIF_DOPAUSE);
8307 }
8308 if ((id == -1)
8309 || (LIST_FIRST(&mii->mii_phys) == NULL)) {
8310 /* Power on sgmii phy if it is disabled */
8311 ctrl_ext = CSR_READ(sc, WMREG_CTRL_EXT);
8312 CSR_WRITE(sc, WMREG_CTRL_EXT,
8313 ctrl_ext &~ CTRL_EXT_SWDPIN(3));
8314 CSR_WRITE_FLUSH(sc);
8315 delay(300*1000); /* XXX too long */
8316
8317 /* from 1 to 8 */
8318 for (i = 1; i < 8; i++)
8319 mii_attach(sc->sc_dev, &sc->sc_mii,
8320 0xffffffff, i, MII_OFFSET_ANY,
8321 MIIF_DOPAUSE);
8322
8323 /* restore previous sfp cage power state */
8324 CSR_WRITE(sc, WMREG_CTRL_EXT, ctrl_ext);
8325 }
8326 }
8327 } else {
8328 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff, MII_PHY_ANY,
8329 MII_OFFSET_ANY, MIIF_DOPAUSE);
8330 }
8331
8332 /*
8333 * If the MAC is PCH2 or PCH_LPT and failed to detect MII PHY, call
8334 * wm_set_mdio_slow_mode_hv() for a workaround and retry.
8335 */
8336 if (((sc->sc_type == WM_T_PCH2) || (sc->sc_type == WM_T_PCH_LPT)) &&
8337 (LIST_FIRST(&mii->mii_phys) == NULL)) {
8338 wm_set_mdio_slow_mode_hv(sc);
8339 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff, MII_PHY_ANY,
8340 MII_OFFSET_ANY, MIIF_DOPAUSE);
8341 }
8342
8343 /*
8344 * (For ICH8 variants)
8345 * If PHY detection failed, use BM's r/w function and retry.
8346 */
8347 if (LIST_FIRST(&mii->mii_phys) == NULL) {
8348 /* if failed, retry with *_bm_* */
8349 mii->mii_readreg = wm_gmii_bm_readreg;
8350 mii->mii_writereg = wm_gmii_bm_writereg;
8351
8352 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff, MII_PHY_ANY,
8353 MII_OFFSET_ANY, MIIF_DOPAUSE);
8354 }
8355
8356 if (LIST_FIRST(&mii->mii_phys) == NULL) {
8357 /* Any PHY wasn't find */
8358 ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL);
8359 ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE);
8360 sc->sc_phytype = WMPHY_NONE;
8361 } else {
8362 /*
8363 * PHY Found!
8364 * Check PHY type.
8365 */
8366 uint32_t model;
8367 struct mii_softc *child;
8368
8369 child = LIST_FIRST(&mii->mii_phys);
8370 model = child->mii_mpd_model;
8371 if (model == MII_MODEL_yyINTEL_I82566)
8372 sc->sc_phytype = WMPHY_IGP_3;
8373
8374 ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);
8375 }
8376 }
8377
8378 /*
8379 * wm_gmii_mediachange: [ifmedia interface function]
8380 *
8381 * Set hardware to newly-selected media on a 1000BASE-T device.
8382 */
8383 static int
8384 wm_gmii_mediachange(struct ifnet *ifp)
8385 {
8386 struct wm_softc *sc = ifp->if_softc;
8387 struct ifmedia_entry *ife = sc->sc_mii.mii_media.ifm_cur;
8388 int rc;
8389
8390 DPRINTF(WM_DEBUG_GMII, ("%s: %s called\n",
8391 device_xname(sc->sc_dev), __func__));
8392 if ((ifp->if_flags & IFF_UP) == 0)
8393 return 0;
8394
8395 sc->sc_ctrl &= ~(CTRL_SPEED_MASK | CTRL_FD);
8396 sc->sc_ctrl |= CTRL_SLU;
8397 if ((IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO)
8398 || (sc->sc_type > WM_T_82543)) {
8399 sc->sc_ctrl &= ~(CTRL_FRCSPD | CTRL_FRCFDX);
8400 } else {
8401 sc->sc_ctrl &= ~CTRL_ASDE;
8402 sc->sc_ctrl |= CTRL_FRCSPD | CTRL_FRCFDX;
8403 if (ife->ifm_media & IFM_FDX)
8404 sc->sc_ctrl |= CTRL_FD;
8405 switch (IFM_SUBTYPE(ife->ifm_media)) {
8406 case IFM_10_T:
8407 sc->sc_ctrl |= CTRL_SPEED_10;
8408 break;
8409 case IFM_100_TX:
8410 sc->sc_ctrl |= CTRL_SPEED_100;
8411 break;
8412 case IFM_1000_T:
8413 sc->sc_ctrl |= CTRL_SPEED_1000;
8414 break;
8415 default:
8416 panic("wm_gmii_mediachange: bad media 0x%x",
8417 ife->ifm_media);
8418 }
8419 }
8420 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
8421 if (sc->sc_type <= WM_T_82543)
8422 wm_gmii_reset(sc);
8423
8424 if ((rc = mii_mediachg(&sc->sc_mii)) == ENXIO)
8425 return 0;
8426 return rc;
8427 }
8428
8429 /*
8430 * wm_gmii_mediastatus: [ifmedia interface function]
8431 *
8432 * Get the current interface media status on a 1000BASE-T device.
8433 */
8434 static void
8435 wm_gmii_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
8436 {
8437 struct wm_softc *sc = ifp->if_softc;
8438
8439 ether_mediastatus(ifp, ifmr);
8440 ifmr->ifm_active = (ifmr->ifm_active & ~IFM_ETH_FMASK)
8441 | sc->sc_flowflags;
8442 }
8443
8444 #define MDI_IO CTRL_SWDPIN(2)
8445 #define MDI_DIR CTRL_SWDPIO(2) /* host -> PHY */
8446 #define MDI_CLK CTRL_SWDPIN(3)
8447
8448 static void
8449 wm_i82543_mii_sendbits(struct wm_softc *sc, uint32_t data, int nbits)
8450 {
8451 uint32_t i, v;
8452
8453 v = CSR_READ(sc, WMREG_CTRL);
8454 v &= ~(MDI_IO | MDI_CLK | (CTRL_SWDPIO_MASK << CTRL_SWDPIO_SHIFT));
8455 v |= MDI_DIR | CTRL_SWDPIO(3);
8456
8457 for (i = 1 << (nbits - 1); i != 0; i >>= 1) {
8458 if (data & i)
8459 v |= MDI_IO;
8460 else
8461 v &= ~MDI_IO;
8462 CSR_WRITE(sc, WMREG_CTRL, v);
8463 CSR_WRITE_FLUSH(sc);
8464 delay(10);
8465 CSR_WRITE(sc, WMREG_CTRL, v | MDI_CLK);
8466 CSR_WRITE_FLUSH(sc);
8467 delay(10);
8468 CSR_WRITE(sc, WMREG_CTRL, v);
8469 CSR_WRITE_FLUSH(sc);
8470 delay(10);
8471 }
8472 }
8473
8474 static uint32_t
8475 wm_i82543_mii_recvbits(struct wm_softc *sc)
8476 {
8477 uint32_t v, i, data = 0;
8478
8479 v = CSR_READ(sc, WMREG_CTRL);
8480 v &= ~(MDI_IO | MDI_CLK | (CTRL_SWDPIO_MASK << CTRL_SWDPIO_SHIFT));
8481 v |= CTRL_SWDPIO(3);
8482
8483 CSR_WRITE(sc, WMREG_CTRL, v);
8484 CSR_WRITE_FLUSH(sc);
8485 delay(10);
8486 CSR_WRITE(sc, WMREG_CTRL, v | MDI_CLK);
8487 CSR_WRITE_FLUSH(sc);
8488 delay(10);
8489 CSR_WRITE(sc, WMREG_CTRL, v);
8490 CSR_WRITE_FLUSH(sc);
8491 delay(10);
8492
8493 for (i = 0; i < 16; i++) {
8494 data <<= 1;
8495 CSR_WRITE(sc, WMREG_CTRL, v | MDI_CLK);
8496 CSR_WRITE_FLUSH(sc);
8497 delay(10);
8498 if (CSR_READ(sc, WMREG_CTRL) & MDI_IO)
8499 data |= 1;
8500 CSR_WRITE(sc, WMREG_CTRL, v);
8501 CSR_WRITE_FLUSH(sc);
8502 delay(10);
8503 }
8504
8505 CSR_WRITE(sc, WMREG_CTRL, v | MDI_CLK);
8506 CSR_WRITE_FLUSH(sc);
8507 delay(10);
8508 CSR_WRITE(sc, WMREG_CTRL, v);
8509 CSR_WRITE_FLUSH(sc);
8510 delay(10);
8511
8512 return data;
8513 }
8514
8515 #undef MDI_IO
8516 #undef MDI_DIR
8517 #undef MDI_CLK
8518
8519 /*
8520 * wm_gmii_i82543_readreg: [mii interface function]
8521 *
8522 * Read a PHY register on the GMII (i82543 version).
8523 */
8524 static int
8525 wm_gmii_i82543_readreg(device_t self, int phy, int reg)
8526 {
8527 struct wm_softc *sc = device_private(self);
8528 int rv;
8529
8530 wm_i82543_mii_sendbits(sc, 0xffffffffU, 32);
8531 wm_i82543_mii_sendbits(sc, reg | (phy << 5) |
8532 (MII_COMMAND_READ << 10) | (MII_COMMAND_START << 12), 14);
8533 rv = wm_i82543_mii_recvbits(sc) & 0xffff;
8534
8535 DPRINTF(WM_DEBUG_GMII, ("%s: GMII: read phy %d reg %d -> 0x%04x\n",
8536 device_xname(sc->sc_dev), phy, reg, rv));
8537
8538 return rv;
8539 }
8540
8541 /*
8542 * wm_gmii_i82543_writereg: [mii interface function]
8543 *
8544 * Write a PHY register on the GMII (i82543 version).
8545 */
8546 static void
8547 wm_gmii_i82543_writereg(device_t self, int phy, int reg, int val)
8548 {
8549 struct wm_softc *sc = device_private(self);
8550
8551 wm_i82543_mii_sendbits(sc, 0xffffffffU, 32);
8552 wm_i82543_mii_sendbits(sc, val | (MII_COMMAND_ACK << 16) |
8553 (reg << 18) | (phy << 23) | (MII_COMMAND_WRITE << 28) |
8554 (MII_COMMAND_START << 30), 32);
8555 }
8556
8557 /*
8558 * wm_gmii_mdic_readreg: [mii interface function]
8559 *
8560 * Read a PHY register on the GMII.
8561 */
8562 static int
8563 wm_gmii_mdic_readreg(device_t self, int phy, int reg)
8564 {
8565 struct wm_softc *sc = device_private(self);
8566 uint32_t mdic = 0;
8567 int i, rv;
8568
8569 CSR_WRITE(sc, WMREG_MDIC, MDIC_OP_READ | MDIC_PHYADD(phy) |
8570 MDIC_REGADD(reg));
8571
8572 for (i = 0; i < WM_GEN_POLL_TIMEOUT * 3; i++) {
8573 mdic = CSR_READ(sc, WMREG_MDIC);
8574 if (mdic & MDIC_READY)
8575 break;
8576 delay(50);
8577 }
8578
8579 if ((mdic & MDIC_READY) == 0) {
8580 log(LOG_WARNING, "%s: MDIC read timed out: phy %d reg %d\n",
8581 device_xname(sc->sc_dev), phy, reg);
8582 rv = 0;
8583 } else if (mdic & MDIC_E) {
8584 #if 0 /* This is normal if no PHY is present. */
8585 log(LOG_WARNING, "%s: MDIC read error: phy %d reg %d\n",
8586 device_xname(sc->sc_dev), phy, reg);
8587 #endif
8588 rv = 0;
8589 } else {
8590 rv = MDIC_DATA(mdic);
8591 if (rv == 0xffff)
8592 rv = 0;
8593 }
8594
8595 return rv;
8596 }
8597
8598 /*
8599 * wm_gmii_mdic_writereg: [mii interface function]
8600 *
8601 * Write a PHY register on the GMII.
8602 */
8603 static void
8604 wm_gmii_mdic_writereg(device_t self, int phy, int reg, int val)
8605 {
8606 struct wm_softc *sc = device_private(self);
8607 uint32_t mdic = 0;
8608 int i;
8609
8610 CSR_WRITE(sc, WMREG_MDIC, MDIC_OP_WRITE | MDIC_PHYADD(phy) |
8611 MDIC_REGADD(reg) | MDIC_DATA(val));
8612
8613 for (i = 0; i < WM_GEN_POLL_TIMEOUT * 3; i++) {
8614 mdic = CSR_READ(sc, WMREG_MDIC);
8615 if (mdic & MDIC_READY)
8616 break;
8617 delay(50);
8618 }
8619
8620 if ((mdic & MDIC_READY) == 0)
8621 log(LOG_WARNING, "%s: MDIC write timed out: phy %d reg %d\n",
8622 device_xname(sc->sc_dev), phy, reg);
8623 else if (mdic & MDIC_E)
8624 log(LOG_WARNING, "%s: MDIC write error: phy %d reg %d\n",
8625 device_xname(sc->sc_dev), phy, reg);
8626 }
8627
8628 /*
8629 * wm_gmii_i82544_readreg: [mii interface function]
8630 *
8631 * Read a PHY register on the GMII.
8632 */
8633 static int
8634 wm_gmii_i82544_readreg(device_t self, int phy, int reg)
8635 {
8636 struct wm_softc *sc = device_private(self);
8637 int rv;
8638
8639 if (sc->phy.acquire(sc)) {
8640 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
8641 __func__);
8642 return 0;
8643 }
8644 rv = wm_gmii_mdic_readreg(self, phy, reg);
8645 sc->phy.release(sc);
8646
8647 return rv;
8648 }
8649
8650 /*
8651 * wm_gmii_i82544_writereg: [mii interface function]
8652 *
8653 * Write a PHY register on the GMII.
8654 */
8655 static void
8656 wm_gmii_i82544_writereg(device_t self, int phy, int reg, int val)
8657 {
8658 struct wm_softc *sc = device_private(self);
8659
8660 if (sc->phy.acquire(sc)) {
8661 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
8662 __func__);
8663 }
8664 wm_gmii_mdic_writereg(self, phy, reg, val);
8665 sc->phy.release(sc);
8666 }
8667
8668 /*
8669 * wm_gmii_i80003_readreg: [mii interface function]
8670 *
8671 * Read a PHY register on the kumeran
8672 * This could be handled by the PHY layer if we didn't have to lock the
8673 * ressource ...
8674 */
8675 static int
8676 wm_gmii_i80003_readreg(device_t self, int phy, int reg)
8677 {
8678 struct wm_softc *sc = device_private(self);
8679 int rv;
8680
8681 if (phy != 1) /* only one PHY on kumeran bus */
8682 return 0;
8683
8684 if (sc->phy.acquire(sc)) {
8685 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
8686 __func__);
8687 return 0;
8688 }
8689
8690 if ((reg & MII_ADDRMASK) < GG82563_MIN_ALT_REG) {
8691 wm_gmii_mdic_writereg(self, phy, GG82563_PHY_PAGE_SELECT,
8692 reg >> GG82563_PAGE_SHIFT);
8693 } else {
8694 wm_gmii_mdic_writereg(self, phy, GG82563_PHY_PAGE_SELECT_ALT,
8695 reg >> GG82563_PAGE_SHIFT);
8696 }
8697 /* Wait more 200us for a bug of the ready bit in the MDIC register */
8698 delay(200);
8699 rv = wm_gmii_mdic_readreg(self, phy, reg & MII_ADDRMASK);
8700 delay(200);
8701 sc->phy.release(sc);
8702
8703 return rv;
8704 }
8705
8706 /*
8707 * wm_gmii_i80003_writereg: [mii interface function]
8708 *
8709 * Write a PHY register on the kumeran.
8710 * This could be handled by the PHY layer if we didn't have to lock the
8711 * ressource ...
8712 */
8713 static void
8714 wm_gmii_i80003_writereg(device_t self, int phy, int reg, int val)
8715 {
8716 struct wm_softc *sc = device_private(self);
8717
8718 if (phy != 1) /* only one PHY on kumeran bus */
8719 return;
8720
8721 if (sc->phy.acquire(sc)) {
8722 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
8723 __func__);
8724 return;
8725 }
8726
8727 if ((reg & MII_ADDRMASK) < GG82563_MIN_ALT_REG) {
8728 wm_gmii_mdic_writereg(self, phy, GG82563_PHY_PAGE_SELECT,
8729 reg >> GG82563_PAGE_SHIFT);
8730 } else {
8731 wm_gmii_mdic_writereg(self, phy, GG82563_PHY_PAGE_SELECT_ALT,
8732 reg >> GG82563_PAGE_SHIFT);
8733 }
8734 /* Wait more 200us for a bug of the ready bit in the MDIC register */
8735 delay(200);
8736 wm_gmii_mdic_writereg(self, phy, reg & MII_ADDRMASK, val);
8737 delay(200);
8738
8739 sc->phy.release(sc);
8740 }
8741
8742 /*
8743 * wm_gmii_bm_readreg: [mii interface function]
8744 *
8745 * Read a PHY register on the kumeran
8746 * This could be handled by the PHY layer if we didn't have to lock the
8747 * ressource ...
8748 */
8749 static int
8750 wm_gmii_bm_readreg(device_t self, int phy, int reg)
8751 {
8752 struct wm_softc *sc = device_private(self);
8753 int rv;
8754
8755 if (sc->phy.acquire(sc)) {
8756 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
8757 __func__);
8758 return 0;
8759 }
8760
8761 if (reg > BME1000_MAX_MULTI_PAGE_REG) {
8762 if (phy == 1)
8763 wm_gmii_mdic_writereg(self, phy,
8764 MII_IGPHY_PAGE_SELECT, reg);
8765 else
8766 wm_gmii_mdic_writereg(self, phy,
8767 BME1000_PHY_PAGE_SELECT,
8768 reg >> GG82563_PAGE_SHIFT);
8769 }
8770
8771 rv = wm_gmii_mdic_readreg(self, phy, reg & MII_ADDRMASK);
8772 sc->phy.release(sc);
8773 return rv;
8774 }
8775
8776 /*
8777 * wm_gmii_bm_writereg: [mii interface function]
8778 *
8779 * Write a PHY register on the kumeran.
8780 * This could be handled by the PHY layer if we didn't have to lock the
8781 * ressource ...
8782 */
8783 static void
8784 wm_gmii_bm_writereg(device_t self, int phy, int reg, int val)
8785 {
8786 struct wm_softc *sc = device_private(self);
8787
8788 if (sc->phy.acquire(sc)) {
8789 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
8790 __func__);
8791 return;
8792 }
8793
8794 if (reg > BME1000_MAX_MULTI_PAGE_REG) {
8795 if (phy == 1)
8796 wm_gmii_mdic_writereg(self, phy,
8797 MII_IGPHY_PAGE_SELECT, reg);
8798 else
8799 wm_gmii_mdic_writereg(self, phy,
8800 BME1000_PHY_PAGE_SELECT,
8801 reg >> GG82563_PAGE_SHIFT);
8802 }
8803
8804 wm_gmii_mdic_writereg(self, phy, reg & MII_ADDRMASK, val);
8805 sc->phy.release(sc);
8806 }
8807
8808 static void
8809 wm_access_phy_wakeup_reg_bm(device_t self, int offset, int16_t *val, int rd)
8810 {
8811 struct wm_softc *sc = device_private(self);
8812 uint16_t regnum = BM_PHY_REG_NUM(offset);
8813 uint16_t wuce;
8814
8815 DPRINTF(WM_DEBUG_GMII, ("%s: %s called\n",
8816 device_xname(sc->sc_dev), __func__));
8817 /* XXX Gig must be disabled for MDIO accesses to page 800 */
8818 if (sc->sc_type == WM_T_PCH) {
8819 /* XXX e1000 driver do nothing... why? */
8820 }
8821
8822 /* Set page 769 */
8823 wm_gmii_mdic_writereg(self, 1, MII_IGPHY_PAGE_SELECT,
8824 BM_WUC_ENABLE_PAGE << BME1000_PAGE_SHIFT);
8825
8826 wuce = wm_gmii_mdic_readreg(self, 1, BM_WUC_ENABLE_REG);
8827
8828 wuce &= ~BM_WUC_HOST_WU_BIT;
8829 wm_gmii_mdic_writereg(self, 1, BM_WUC_ENABLE_REG,
8830 wuce | BM_WUC_ENABLE_BIT);
8831
8832 /* Select page 800 */
8833 wm_gmii_mdic_writereg(self, 1, MII_IGPHY_PAGE_SELECT,
8834 BM_WUC_PAGE << BME1000_PAGE_SHIFT);
8835
8836 /* Write page 800 */
8837 wm_gmii_mdic_writereg(self, 1, BM_WUC_ADDRESS_OPCODE, regnum);
8838
8839 if (rd)
8840 *val = wm_gmii_mdic_readreg(self, 1, BM_WUC_DATA_OPCODE);
8841 else
8842 wm_gmii_mdic_writereg(self, 1, BM_WUC_DATA_OPCODE, *val);
8843
8844 /* Set page 769 */
8845 wm_gmii_mdic_writereg(self, 1, MII_IGPHY_PAGE_SELECT,
8846 BM_WUC_ENABLE_PAGE << BME1000_PAGE_SHIFT);
8847
8848 wm_gmii_mdic_writereg(self, 1, BM_WUC_ENABLE_REG, wuce);
8849 }
8850
8851 /*
8852 * wm_gmii_hv_readreg: [mii interface function]
8853 *
8854 * Read a PHY register on the kumeran
8855 * This could be handled by the PHY layer if we didn't have to lock the
8856 * ressource ...
8857 */
8858 static int
8859 wm_gmii_hv_readreg(device_t self, int phy, int reg)
8860 {
8861 struct wm_softc *sc = device_private(self);
8862 int rv;
8863
8864 DPRINTF(WM_DEBUG_GMII, ("%s: %s called\n",
8865 device_xname(sc->sc_dev), __func__));
8866 if (sc->phy.acquire(sc)) {
8867 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
8868 __func__);
8869 return 0;
8870 }
8871
8872 rv = wm_gmii_hv_readreg_locked(self, phy, reg);
8873 sc->phy.release(sc);
8874 return rv;
8875 }
8876
8877 static int
8878 wm_gmii_hv_readreg_locked(device_t self, int phy, int reg)
8879 {
8880 struct wm_softc *sc = device_private(self);
8881 uint16_t page = BM_PHY_REG_PAGE(reg);
8882 uint16_t regnum = BM_PHY_REG_NUM(reg);
8883 uint16_t val;
8884 int rv;
8885
8886 /* XXX Workaround failure in MDIO access while cable is disconnected */
8887 if (sc->sc_phytype == WMPHY_82577) {
8888 /* XXX must write */
8889 }
8890
8891 /* Page 800 works differently than the rest so it has its own func */
8892 if (page == BM_WUC_PAGE) {
8893 wm_access_phy_wakeup_reg_bm(self, reg, &val, 1);
8894 return val;
8895 }
8896
8897 /*
8898 * Lower than page 768 works differently than the rest so it has its
8899 * own func
8900 */
8901 if ((page > 0) && (page < HV_INTC_FC_PAGE_START)) {
8902 printf("gmii_hv_readreg!!!\n");
8903 return 0;
8904 }
8905
8906 if (regnum > BME1000_MAX_MULTI_PAGE_REG) {
8907 wm_gmii_mdic_writereg(self, 1, MII_IGPHY_PAGE_SELECT,
8908 page << BME1000_PAGE_SHIFT);
8909 }
8910
8911 rv = wm_gmii_mdic_readreg(self, phy, regnum & MII_ADDRMASK);
8912 return rv;
8913 }
8914
8915 /*
8916 * wm_gmii_hv_writereg: [mii interface function]
8917 *
8918 * Write a PHY register on the kumeran.
8919 * This could be handled by the PHY layer if we didn't have to lock the
8920 * ressource ...
8921 */
8922 static void
8923 wm_gmii_hv_writereg(device_t self, int phy, int reg, int val)
8924 {
8925 struct wm_softc *sc = device_private(self);
8926
8927 DPRINTF(WM_DEBUG_GMII, ("%s: %s called\n",
8928 device_xname(sc->sc_dev), __func__));
8929
8930 if (sc->phy.acquire(sc)) {
8931 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
8932 __func__);
8933 return;
8934 }
8935
8936 wm_gmii_hv_writereg_locked(self, phy, reg, val);
8937 sc->phy.release(sc);
8938 }
8939
8940 static void
8941 wm_gmii_hv_writereg_locked(device_t self, int phy, int reg, int val)
8942 {
8943 uint16_t page = BM_PHY_REG_PAGE(reg);
8944 uint16_t regnum = BM_PHY_REG_NUM(reg);
8945
8946 /* XXX Workaround failure in MDIO access while cable is disconnected */
8947
8948 /* Page 800 works differently than the rest so it has its own func */
8949 if (page == BM_WUC_PAGE) {
8950 uint16_t tmp;
8951
8952 tmp = val;
8953 wm_access_phy_wakeup_reg_bm(self, reg, &tmp, 0);
8954 return;
8955 }
8956
8957 /*
8958 * Lower than page 768 works differently than the rest so it has its
8959 * own func
8960 */
8961 if ((page > 0) && (page < HV_INTC_FC_PAGE_START)) {
8962 printf("gmii_hv_writereg!!!\n");
8963 return;
8964 }
8965
8966 /*
8967 * XXX Workaround MDIO accesses being disabled after entering IEEE
8968 * Power Down (whenever bit 11 of the PHY control register is set)
8969 */
8970
8971 if (regnum > BME1000_MAX_MULTI_PAGE_REG) {
8972 wm_gmii_mdic_writereg(self, 1, MII_IGPHY_PAGE_SELECT,
8973 page << BME1000_PAGE_SHIFT);
8974 }
8975
8976 wm_gmii_mdic_writereg(self, phy, regnum & MII_ADDRMASK, val);
8977 }
8978
8979 /*
8980 * wm_gmii_82580_readreg: [mii interface function]
8981 *
8982 * Read a PHY register on the 82580 and I350.
8983 * This could be handled by the PHY layer if we didn't have to lock the
8984 * ressource ...
8985 */
8986 static int
8987 wm_gmii_82580_readreg(device_t self, int phy, int reg)
8988 {
8989 struct wm_softc *sc = device_private(self);
8990 int rv;
8991
8992 if (sc->phy.acquire(sc) != 0) {
8993 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
8994 __func__);
8995 return 0;
8996 }
8997
8998 rv = wm_gmii_mdic_readreg(self, phy, reg);
8999
9000 sc->phy.release(sc);
9001 return rv;
9002 }
9003
9004 /*
9005 * wm_gmii_82580_writereg: [mii interface function]
9006 *
9007 * Write a PHY register on the 82580 and I350.
9008 * This could be handled by the PHY layer if we didn't have to lock the
9009 * ressource ...
9010 */
9011 static void
9012 wm_gmii_82580_writereg(device_t self, int phy, int reg, int val)
9013 {
9014 struct wm_softc *sc = device_private(self);
9015
9016 if (sc->phy.acquire(sc) != 0) {
9017 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
9018 __func__);
9019 return;
9020 }
9021
9022 wm_gmii_mdic_writereg(self, phy, reg, val);
9023
9024 sc->phy.release(sc);
9025 }
9026
9027 /*
9028 * wm_gmii_gs40g_readreg: [mii interface function]
9029 *
9030 * Read a PHY register on the I2100 and I211.
9031 * This could be handled by the PHY layer if we didn't have to lock the
9032 * ressource ...
9033 */
9034 static int
9035 wm_gmii_gs40g_readreg(device_t self, int phy, int reg)
9036 {
9037 struct wm_softc *sc = device_private(self);
9038 int page, offset;
9039 int rv;
9040
9041 /* Acquire semaphore */
9042 if (sc->phy.acquire(sc)) {
9043 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
9044 __func__);
9045 return 0;
9046 }
9047
9048 /* Page select */
9049 page = reg >> GS40G_PAGE_SHIFT;
9050 wm_gmii_mdic_writereg(self, phy, GS40G_PAGE_SELECT, page);
9051
9052 /* Read reg */
9053 offset = reg & GS40G_OFFSET_MASK;
9054 rv = wm_gmii_mdic_readreg(self, phy, offset);
9055
9056 sc->phy.release(sc);
9057 return rv;
9058 }
9059
9060 /*
9061 * wm_gmii_gs40g_writereg: [mii interface function]
9062 *
9063 * Write a PHY register on the I210 and I211.
9064 * This could be handled by the PHY layer if we didn't have to lock the
9065 * ressource ...
9066 */
9067 static void
9068 wm_gmii_gs40g_writereg(device_t self, int phy, int reg, int val)
9069 {
9070 struct wm_softc *sc = device_private(self);
9071 int page, offset;
9072
9073 /* Acquire semaphore */
9074 if (sc->phy.acquire(sc)) {
9075 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
9076 __func__);
9077 return;
9078 }
9079
9080 /* Page select */
9081 page = reg >> GS40G_PAGE_SHIFT;
9082 wm_gmii_mdic_writereg(self, phy, GS40G_PAGE_SELECT, page);
9083
9084 /* Write reg */
9085 offset = reg & GS40G_OFFSET_MASK;
9086 wm_gmii_mdic_writereg(self, phy, offset, val);
9087
9088 /* Release semaphore */
9089 sc->phy.release(sc);
9090 }
9091
9092 /*
9093 * wm_gmii_statchg: [mii interface function]
9094 *
9095 * Callback from MII layer when media changes.
9096 */
9097 static void
9098 wm_gmii_statchg(struct ifnet *ifp)
9099 {
9100 struct wm_softc *sc = ifp->if_softc;
9101 struct mii_data *mii = &sc->sc_mii;
9102
9103 sc->sc_ctrl &= ~(CTRL_TFCE | CTRL_RFCE);
9104 sc->sc_tctl &= ~TCTL_COLD(0x3ff);
9105 sc->sc_fcrtl &= ~FCRTL_XONE;
9106
9107 /*
9108 * Get flow control negotiation result.
9109 */
9110 if (IFM_SUBTYPE(mii->mii_media.ifm_cur->ifm_media) == IFM_AUTO &&
9111 (mii->mii_media_active & IFM_ETH_FMASK) != sc->sc_flowflags) {
9112 sc->sc_flowflags = mii->mii_media_active & IFM_ETH_FMASK;
9113 mii->mii_media_active &= ~IFM_ETH_FMASK;
9114 }
9115
9116 if (sc->sc_flowflags & IFM_FLOW) {
9117 if (sc->sc_flowflags & IFM_ETH_TXPAUSE) {
9118 sc->sc_ctrl |= CTRL_TFCE;
9119 sc->sc_fcrtl |= FCRTL_XONE;
9120 }
9121 if (sc->sc_flowflags & IFM_ETH_RXPAUSE)
9122 sc->sc_ctrl |= CTRL_RFCE;
9123 }
9124
9125 if (sc->sc_mii.mii_media_active & IFM_FDX) {
9126 DPRINTF(WM_DEBUG_LINK,
9127 ("%s: LINK: statchg: FDX\n", ifp->if_xname));
9128 sc->sc_tctl |= TCTL_COLD(TX_COLLISION_DISTANCE_FDX);
9129 } else {
9130 DPRINTF(WM_DEBUG_LINK,
9131 ("%s: LINK: statchg: HDX\n", ifp->if_xname));
9132 sc->sc_tctl |= TCTL_COLD(TX_COLLISION_DISTANCE_HDX);
9133 }
9134
9135 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
9136 CSR_WRITE(sc, WMREG_TCTL, sc->sc_tctl);
9137 CSR_WRITE(sc, (sc->sc_type < WM_T_82543) ? WMREG_OLD_FCRTL
9138 : WMREG_FCRTL, sc->sc_fcrtl);
9139 if (sc->sc_type == WM_T_80003) {
9140 switch (IFM_SUBTYPE(sc->sc_mii.mii_media_active)) {
9141 case IFM_1000_T:
9142 wm_kmrn_writereg(sc, KUMCTRLSTA_OFFSET_HD_CTRL,
9143 KUMCTRLSTA_HD_CTRL_1000_DEFAULT);
9144 sc->sc_tipg = TIPG_1000T_80003_DFLT;
9145 break;
9146 default:
9147 wm_kmrn_writereg(sc, KUMCTRLSTA_OFFSET_HD_CTRL,
9148 KUMCTRLSTA_HD_CTRL_10_100_DEFAULT);
9149 sc->sc_tipg = TIPG_10_100_80003_DFLT;
9150 break;
9151 }
9152 CSR_WRITE(sc, WMREG_TIPG, sc->sc_tipg);
9153 }
9154 }
9155
9156 /*
9157 * wm_kmrn_readreg:
9158 *
9159 * Read a kumeran register
9160 */
9161 static int
9162 wm_kmrn_readreg(struct wm_softc *sc, int reg)
9163 {
9164 int rv;
9165
9166 if (sc->sc_type == WM_T_80003)
9167 rv = wm_get_swfw_semaphore(sc, SWFW_MAC_CSR_SM);
9168 else
9169 rv = sc->phy.acquire(sc);
9170 if (rv != 0) {
9171 aprint_error_dev(sc->sc_dev,
9172 "%s: failed to get semaphore\n", __func__);
9173 return 0;
9174 }
9175
9176 rv = wm_kmrn_readreg_locked(sc, reg);
9177
9178 if (sc->sc_type == WM_T_80003)
9179 wm_put_swfw_semaphore(sc, SWFW_MAC_CSR_SM);
9180 else
9181 sc->phy.release(sc);
9182
9183 return rv;
9184 }
9185
9186 static int
9187 wm_kmrn_readreg_locked(struct wm_softc *sc, int reg)
9188 {
9189 int rv;
9190
9191 CSR_WRITE(sc, WMREG_KUMCTRLSTA,
9192 ((reg << KUMCTRLSTA_OFFSET_SHIFT) & KUMCTRLSTA_OFFSET) |
9193 KUMCTRLSTA_REN);
9194 CSR_WRITE_FLUSH(sc);
9195 delay(2);
9196
9197 rv = CSR_READ(sc, WMREG_KUMCTRLSTA) & KUMCTRLSTA_MASK;
9198
9199 return rv;
9200 }
9201
9202 /*
9203 * wm_kmrn_writereg:
9204 *
9205 * Write a kumeran register
9206 */
9207 static void
9208 wm_kmrn_writereg(struct wm_softc *sc, int reg, int val)
9209 {
9210 int rv;
9211
9212 if (sc->sc_type == WM_T_80003)
9213 rv = wm_get_swfw_semaphore(sc, SWFW_MAC_CSR_SM);
9214 else
9215 rv = sc->phy.acquire(sc);
9216 if (rv != 0) {
9217 aprint_error_dev(sc->sc_dev,
9218 "%s: failed to get semaphore\n", __func__);
9219 return;
9220 }
9221
9222 wm_kmrn_writereg_locked(sc, reg, val);
9223
9224 if (sc->sc_type == WM_T_80003)
9225 wm_put_swfw_semaphore(sc, SWFW_MAC_CSR_SM);
9226 else
9227 sc->phy.release(sc);
9228 }
9229
9230 static void
9231 wm_kmrn_writereg_locked(struct wm_softc *sc, int reg, int val)
9232 {
9233
9234 CSR_WRITE(sc, WMREG_KUMCTRLSTA,
9235 ((reg << KUMCTRLSTA_OFFSET_SHIFT) & KUMCTRLSTA_OFFSET) |
9236 (val & KUMCTRLSTA_MASK));
9237 }
9238
9239 /* SGMII related */
9240
9241 /*
9242 * wm_sgmii_uses_mdio
9243 *
9244 * Check whether the transaction is to the internal PHY or the external
9245 * MDIO interface. Return true if it's MDIO.
9246 */
9247 static bool
9248 wm_sgmii_uses_mdio(struct wm_softc *sc)
9249 {
9250 uint32_t reg;
9251 bool ismdio = false;
9252
9253 switch (sc->sc_type) {
9254 case WM_T_82575:
9255 case WM_T_82576:
9256 reg = CSR_READ(sc, WMREG_MDIC);
9257 ismdio = ((reg & MDIC_DEST) != 0);
9258 break;
9259 case WM_T_82580:
9260 case WM_T_I350:
9261 case WM_T_I354:
9262 case WM_T_I210:
9263 case WM_T_I211:
9264 reg = CSR_READ(sc, WMREG_MDICNFG);
9265 ismdio = ((reg & MDICNFG_DEST) != 0);
9266 break;
9267 default:
9268 break;
9269 }
9270
9271 return ismdio;
9272 }
9273
9274 /*
9275 * wm_sgmii_readreg: [mii interface function]
9276 *
9277 * Read a PHY register on the SGMII
9278 * This could be handled by the PHY layer if we didn't have to lock the
9279 * ressource ...
9280 */
9281 static int
9282 wm_sgmii_readreg(device_t self, int phy, int reg)
9283 {
9284 struct wm_softc *sc = device_private(self);
9285 uint32_t i2ccmd;
9286 int i, rv;
9287
9288 if (sc->phy.acquire(sc)) {
9289 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
9290 __func__);
9291 return 0;
9292 }
9293
9294 i2ccmd = (reg << I2CCMD_REG_ADDR_SHIFT)
9295 | (phy << I2CCMD_PHY_ADDR_SHIFT)
9296 | I2CCMD_OPCODE_READ;
9297 CSR_WRITE(sc, WMREG_I2CCMD, i2ccmd);
9298
9299 /* Poll the ready bit */
9300 for (i = 0; i < I2CCMD_PHY_TIMEOUT; i++) {
9301 delay(50);
9302 i2ccmd = CSR_READ(sc, WMREG_I2CCMD);
9303 if (i2ccmd & I2CCMD_READY)
9304 break;
9305 }
9306 if ((i2ccmd & I2CCMD_READY) == 0)
9307 aprint_error_dev(sc->sc_dev, "I2CCMD Read did not complete\n");
9308 if ((i2ccmd & I2CCMD_ERROR) != 0)
9309 aprint_error_dev(sc->sc_dev, "I2CCMD Error bit set\n");
9310
9311 rv = ((i2ccmd >> 8) & 0x00ff) | ((i2ccmd << 8) & 0xff00);
9312
9313 sc->phy.release(sc);
9314 return rv;
9315 }
9316
9317 /*
9318 * wm_sgmii_writereg: [mii interface function]
9319 *
9320 * Write a PHY register on the SGMII.
9321 * This could be handled by the PHY layer if we didn't have to lock the
9322 * ressource ...
9323 */
9324 static void
9325 wm_sgmii_writereg(device_t self, int phy, int reg, int val)
9326 {
9327 struct wm_softc *sc = device_private(self);
9328 uint32_t i2ccmd;
9329 int i;
9330 int val_swapped;
9331
9332 if (sc->phy.acquire(sc) != 0) {
9333 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
9334 __func__);
9335 return;
9336 }
9337 /* Swap the data bytes for the I2C interface */
9338 val_swapped = ((val >> 8) & 0x00FF) | ((val << 8) & 0xFF00);
9339 i2ccmd = (reg << I2CCMD_REG_ADDR_SHIFT)
9340 | (phy << I2CCMD_PHY_ADDR_SHIFT)
9341 | I2CCMD_OPCODE_WRITE | val_swapped;
9342 CSR_WRITE(sc, WMREG_I2CCMD, i2ccmd);
9343
9344 /* Poll the ready bit */
9345 for (i = 0; i < I2CCMD_PHY_TIMEOUT; i++) {
9346 delay(50);
9347 i2ccmd = CSR_READ(sc, WMREG_I2CCMD);
9348 if (i2ccmd & I2CCMD_READY)
9349 break;
9350 }
9351 if ((i2ccmd & I2CCMD_READY) == 0)
9352 aprint_error_dev(sc->sc_dev, "I2CCMD Write did not complete\n");
9353 if ((i2ccmd & I2CCMD_ERROR) != 0)
9354 aprint_error_dev(sc->sc_dev, "I2CCMD Error bit set\n");
9355
9356 sc->phy.release(sc);
9357 }
9358
9359 /* TBI related */
9360
9361 /*
9362 * wm_tbi_mediainit:
9363 *
9364 * Initialize media for use on 1000BASE-X devices.
9365 */
9366 static void
9367 wm_tbi_mediainit(struct wm_softc *sc)
9368 {
9369 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
9370 const char *sep = "";
9371
9372 if (sc->sc_type < WM_T_82543)
9373 sc->sc_tipg = TIPG_WM_DFLT;
9374 else
9375 sc->sc_tipg = TIPG_LG_DFLT;
9376
9377 sc->sc_tbi_serdes_anegticks = 5;
9378
9379 /* Initialize our media structures */
9380 sc->sc_mii.mii_ifp = ifp;
9381 sc->sc_ethercom.ec_mii = &sc->sc_mii;
9382
9383 if ((sc->sc_type >= WM_T_82575)
9384 && (sc->sc_mediatype == WM_MEDIATYPE_SERDES))
9385 ifmedia_init(&sc->sc_mii.mii_media, IFM_IMASK,
9386 wm_serdes_mediachange, wm_serdes_mediastatus);
9387 else
9388 ifmedia_init(&sc->sc_mii.mii_media, IFM_IMASK,
9389 wm_tbi_mediachange, wm_tbi_mediastatus);
9390
9391 /*
9392 * SWD Pins:
9393 *
9394 * 0 = Link LED (output)
9395 * 1 = Loss Of Signal (input)
9396 */
9397 sc->sc_ctrl |= CTRL_SWDPIO(0);
9398
9399 /* XXX Perhaps this is only for TBI */
9400 if (sc->sc_mediatype != WM_MEDIATYPE_SERDES)
9401 sc->sc_ctrl &= ~CTRL_SWDPIO(1);
9402
9403 if (sc->sc_mediatype == WM_MEDIATYPE_SERDES)
9404 sc->sc_ctrl &= ~CTRL_LRST;
9405
9406 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
9407
9408 #define ADD(ss, mm, dd) \
9409 do { \
9410 aprint_normal("%s%s", sep, ss); \
9411 ifmedia_add(&sc->sc_mii.mii_media, IFM_ETHER | (mm), (dd), NULL); \
9412 sep = ", "; \
9413 } while (/*CONSTCOND*/0)
9414
9415 aprint_normal_dev(sc->sc_dev, "");
9416
9417 /* Only 82545 is LX */
9418 if (sc->sc_type == WM_T_82545) {
9419 ADD("1000baseLX", IFM_1000_LX, ANAR_X_HD);
9420 ADD("1000baseLX-FDX", IFM_1000_LX | IFM_FDX, ANAR_X_FD);
9421 } else {
9422 ADD("1000baseSX", IFM_1000_SX, ANAR_X_HD);
9423 ADD("1000baseSX-FDX", IFM_1000_SX | IFM_FDX, ANAR_X_FD);
9424 }
9425 ADD("auto", IFM_AUTO, ANAR_X_FD | ANAR_X_HD);
9426 aprint_normal("\n");
9427
9428 #undef ADD
9429
9430 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER | IFM_AUTO);
9431 }
9432
9433 /*
9434 * wm_tbi_mediachange: [ifmedia interface function]
9435 *
9436 * Set hardware to newly-selected media on a 1000BASE-X device.
9437 */
9438 static int
9439 wm_tbi_mediachange(struct ifnet *ifp)
9440 {
9441 struct wm_softc *sc = ifp->if_softc;
9442 struct ifmedia_entry *ife = sc->sc_mii.mii_media.ifm_cur;
9443 uint32_t status;
9444 int i;
9445
9446 if (sc->sc_mediatype == WM_MEDIATYPE_SERDES) {
9447 /* XXX need some work for >= 82571 and < 82575 */
9448 if (sc->sc_type < WM_T_82575)
9449 return 0;
9450 }
9451
9452 if ((sc->sc_type == WM_T_82571) || (sc->sc_type == WM_T_82572)
9453 || (sc->sc_type >= WM_T_82575))
9454 CSR_WRITE(sc, WMREG_SCTL, SCTL_DISABLE_SERDES_LOOPBACK);
9455
9456 sc->sc_ctrl &= ~CTRL_LRST;
9457 sc->sc_txcw = TXCW_ANE;
9458 if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO)
9459 sc->sc_txcw |= TXCW_FD | TXCW_HD;
9460 else if (ife->ifm_media & IFM_FDX)
9461 sc->sc_txcw |= TXCW_FD;
9462 else
9463 sc->sc_txcw |= TXCW_HD;
9464
9465 if ((sc->sc_mii.mii_media.ifm_media & IFM_FLOW) != 0)
9466 sc->sc_txcw |= TXCW_SYM_PAUSE | TXCW_ASYM_PAUSE;
9467
9468 DPRINTF(WM_DEBUG_LINK,("%s: sc_txcw = 0x%x after autoneg check\n",
9469 device_xname(sc->sc_dev), sc->sc_txcw));
9470 CSR_WRITE(sc, WMREG_TXCW, sc->sc_txcw);
9471 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
9472 CSR_WRITE_FLUSH(sc);
9473 delay(1000);
9474
9475 i = CSR_READ(sc, WMREG_CTRL) & CTRL_SWDPIN(1);
9476 DPRINTF(WM_DEBUG_LINK,("%s: i = 0x%x\n", device_xname(sc->sc_dev),i));
9477
9478 /*
9479 * On 82544 chips and later, the CTRL_SWDPIN(1) bit will be set if the
9480 * optics detect a signal, 0 if they don't.
9481 */
9482 if (((i != 0) && (sc->sc_type > WM_T_82544)) || (i == 0)) {
9483 /* Have signal; wait for the link to come up. */
9484 for (i = 0; i < WM_LINKUP_TIMEOUT; i++) {
9485 delay(10000);
9486 if (CSR_READ(sc, WMREG_STATUS) & STATUS_LU)
9487 break;
9488 }
9489
9490 DPRINTF(WM_DEBUG_LINK,("%s: i = %d after waiting for link\n",
9491 device_xname(sc->sc_dev),i));
9492
9493 status = CSR_READ(sc, WMREG_STATUS);
9494 DPRINTF(WM_DEBUG_LINK,
9495 ("%s: status after final read = 0x%x, STATUS_LU = 0x%x\n",
9496 device_xname(sc->sc_dev),status, STATUS_LU));
9497 if (status & STATUS_LU) {
9498 /* Link is up. */
9499 DPRINTF(WM_DEBUG_LINK,
9500 ("%s: LINK: set media -> link up %s\n",
9501 device_xname(sc->sc_dev),
9502 (status & STATUS_FD) ? "FDX" : "HDX"));
9503
9504 /*
9505 * NOTE: CTRL will update TFCE and RFCE automatically,
9506 * so we should update sc->sc_ctrl
9507 */
9508 sc->sc_ctrl = CSR_READ(sc, WMREG_CTRL);
9509 sc->sc_tctl &= ~TCTL_COLD(0x3ff);
9510 sc->sc_fcrtl &= ~FCRTL_XONE;
9511 if (status & STATUS_FD)
9512 sc->sc_tctl |=
9513 TCTL_COLD(TX_COLLISION_DISTANCE_FDX);
9514 else
9515 sc->sc_tctl |=
9516 TCTL_COLD(TX_COLLISION_DISTANCE_HDX);
9517 if (CSR_READ(sc, WMREG_CTRL) & CTRL_TFCE)
9518 sc->sc_fcrtl |= FCRTL_XONE;
9519 CSR_WRITE(sc, WMREG_TCTL, sc->sc_tctl);
9520 CSR_WRITE(sc, (sc->sc_type < WM_T_82543) ?
9521 WMREG_OLD_FCRTL : WMREG_FCRTL,
9522 sc->sc_fcrtl);
9523 sc->sc_tbi_linkup = 1;
9524 } else {
9525 if (i == WM_LINKUP_TIMEOUT)
9526 wm_check_for_link(sc);
9527 /* Link is down. */
9528 DPRINTF(WM_DEBUG_LINK,
9529 ("%s: LINK: set media -> link down\n",
9530 device_xname(sc->sc_dev)));
9531 sc->sc_tbi_linkup = 0;
9532 }
9533 } else {
9534 DPRINTF(WM_DEBUG_LINK, ("%s: LINK: set media -> no signal\n",
9535 device_xname(sc->sc_dev)));
9536 sc->sc_tbi_linkup = 0;
9537 }
9538
9539 wm_tbi_serdes_set_linkled(sc);
9540
9541 return 0;
9542 }
9543
9544 /*
9545 * wm_tbi_mediastatus: [ifmedia interface function]
9546 *
9547 * Get the current interface media status on a 1000BASE-X device.
9548 */
9549 static void
9550 wm_tbi_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
9551 {
9552 struct wm_softc *sc = ifp->if_softc;
9553 uint32_t ctrl, status;
9554
9555 ifmr->ifm_status = IFM_AVALID;
9556 ifmr->ifm_active = IFM_ETHER;
9557
9558 status = CSR_READ(sc, WMREG_STATUS);
9559 if ((status & STATUS_LU) == 0) {
9560 ifmr->ifm_active |= IFM_NONE;
9561 return;
9562 }
9563
9564 ifmr->ifm_status |= IFM_ACTIVE;
9565 /* Only 82545 is LX */
9566 if (sc->sc_type == WM_T_82545)
9567 ifmr->ifm_active |= IFM_1000_LX;
9568 else
9569 ifmr->ifm_active |= IFM_1000_SX;
9570 if (CSR_READ(sc, WMREG_STATUS) & STATUS_FD)
9571 ifmr->ifm_active |= IFM_FDX;
9572 else
9573 ifmr->ifm_active |= IFM_HDX;
9574 ctrl = CSR_READ(sc, WMREG_CTRL);
9575 if (ctrl & CTRL_RFCE)
9576 ifmr->ifm_active |= IFM_FLOW | IFM_ETH_RXPAUSE;
9577 if (ctrl & CTRL_TFCE)
9578 ifmr->ifm_active |= IFM_FLOW | IFM_ETH_TXPAUSE;
9579 }
9580
9581 /* XXX TBI only */
9582 static int
9583 wm_check_for_link(struct wm_softc *sc)
9584 {
9585 struct ifmedia_entry *ife = sc->sc_mii.mii_media.ifm_cur;
9586 uint32_t rxcw;
9587 uint32_t ctrl;
9588 uint32_t status;
9589 uint32_t sig;
9590
9591 if (sc->sc_mediatype == WM_MEDIATYPE_SERDES) {
9592 /* XXX need some work for >= 82571 */
9593 if (sc->sc_type >= WM_T_82571) {
9594 sc->sc_tbi_linkup = 1;
9595 return 0;
9596 }
9597 }
9598
9599 rxcw = CSR_READ(sc, WMREG_RXCW);
9600 ctrl = CSR_READ(sc, WMREG_CTRL);
9601 status = CSR_READ(sc, WMREG_STATUS);
9602
9603 sig = (sc->sc_type > WM_T_82544) ? CTRL_SWDPIN(1) : 0;
9604
9605 DPRINTF(WM_DEBUG_LINK,
9606 ("%s: %s: sig = %d, status_lu = %d, rxcw_c = %d\n",
9607 device_xname(sc->sc_dev), __func__,
9608 ((ctrl & CTRL_SWDPIN(1)) == sig),
9609 ((status & STATUS_LU) != 0), ((rxcw & RXCW_C) != 0)));
9610
9611 /*
9612 * SWDPIN LU RXCW
9613 * 0 0 0
9614 * 0 0 1 (should not happen)
9615 * 0 1 0 (should not happen)
9616 * 0 1 1 (should not happen)
9617 * 1 0 0 Disable autonego and force linkup
9618 * 1 0 1 got /C/ but not linkup yet
9619 * 1 1 0 (linkup)
9620 * 1 1 1 If IFM_AUTO, back to autonego
9621 *
9622 */
9623 if (((ctrl & CTRL_SWDPIN(1)) == sig)
9624 && ((status & STATUS_LU) == 0)
9625 && ((rxcw & RXCW_C) == 0)) {
9626 DPRINTF(WM_DEBUG_LINK, ("%s: force linkup and fullduplex\n",
9627 __func__));
9628 sc->sc_tbi_linkup = 0;
9629 /* Disable auto-negotiation in the TXCW register */
9630 CSR_WRITE(sc, WMREG_TXCW, (sc->sc_txcw & ~TXCW_ANE));
9631
9632 /*
9633 * Force link-up and also force full-duplex.
9634 *
9635 * NOTE: CTRL was updated TFCE and RFCE automatically,
9636 * so we should update sc->sc_ctrl
9637 */
9638 sc->sc_ctrl = ctrl | CTRL_SLU | CTRL_FD;
9639 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
9640 } else if (((status & STATUS_LU) != 0)
9641 && ((rxcw & RXCW_C) != 0)
9642 && (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO)) {
9643 sc->sc_tbi_linkup = 1;
9644 DPRINTF(WM_DEBUG_LINK, ("%s: go back to autonego\n",
9645 __func__));
9646 CSR_WRITE(sc, WMREG_TXCW, sc->sc_txcw);
9647 CSR_WRITE(sc, WMREG_CTRL, (ctrl & ~CTRL_SLU));
9648 } else if (((ctrl & CTRL_SWDPIN(1)) == sig)
9649 && ((rxcw & RXCW_C) != 0)) {
9650 DPRINTF(WM_DEBUG_LINK, ("/C/"));
9651 } else {
9652 DPRINTF(WM_DEBUG_LINK, ("%s: %x,%x,%x\n", __func__, rxcw, ctrl,
9653 status));
9654 }
9655
9656 return 0;
9657 }
9658
9659 /*
9660 * wm_tbi_tick:
9661 *
9662 * Check the link on TBI devices.
9663 * This function acts as mii_tick().
9664 */
9665 static void
9666 wm_tbi_tick(struct wm_softc *sc)
9667 {
9668 struct mii_data *mii = &sc->sc_mii;
9669 struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
9670 uint32_t status;
9671
9672 KASSERT(WM_CORE_LOCKED(sc));
9673
9674 status = CSR_READ(sc, WMREG_STATUS);
9675
9676 /* XXX is this needed? */
9677 (void)CSR_READ(sc, WMREG_RXCW);
9678 (void)CSR_READ(sc, WMREG_CTRL);
9679
9680 /* set link status */
9681 if ((status & STATUS_LU) == 0) {
9682 DPRINTF(WM_DEBUG_LINK,
9683 ("%s: LINK: checklink -> down\n",
9684 device_xname(sc->sc_dev)));
9685 sc->sc_tbi_linkup = 0;
9686 } else if (sc->sc_tbi_linkup == 0) {
9687 DPRINTF(WM_DEBUG_LINK,
9688 ("%s: LINK: checklink -> up %s\n",
9689 device_xname(sc->sc_dev),
9690 (status & STATUS_FD) ? "FDX" : "HDX"));
9691 sc->sc_tbi_linkup = 1;
9692 sc->sc_tbi_serdes_ticks = 0;
9693 }
9694
9695 if ((sc->sc_ethercom.ec_if.if_flags & IFF_UP) == 0)
9696 goto setled;
9697
9698 if ((status & STATUS_LU) == 0) {
9699 sc->sc_tbi_linkup = 0;
9700 /* If the timer expired, retry autonegotiation */
9701 if ((IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO)
9702 && (++sc->sc_tbi_serdes_ticks
9703 >= sc->sc_tbi_serdes_anegticks)) {
9704 DPRINTF(WM_DEBUG_LINK, ("EXPIRE\n"));
9705 sc->sc_tbi_serdes_ticks = 0;
9706 /*
9707 * Reset the link, and let autonegotiation do
9708 * its thing
9709 */
9710 sc->sc_ctrl |= CTRL_LRST;
9711 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
9712 CSR_WRITE_FLUSH(sc);
9713 delay(1000);
9714 sc->sc_ctrl &= ~CTRL_LRST;
9715 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
9716 CSR_WRITE_FLUSH(sc);
9717 delay(1000);
9718 CSR_WRITE(sc, WMREG_TXCW,
9719 sc->sc_txcw & ~TXCW_ANE);
9720 CSR_WRITE(sc, WMREG_TXCW, sc->sc_txcw);
9721 }
9722 }
9723
9724 setled:
9725 wm_tbi_serdes_set_linkled(sc);
9726 }
9727
9728 /* SERDES related */
9729 static void
9730 wm_serdes_power_up_link_82575(struct wm_softc *sc)
9731 {
9732 uint32_t reg;
9733
9734 if ((sc->sc_mediatype != WM_MEDIATYPE_SERDES)
9735 && ((sc->sc_flags & WM_F_SGMII) == 0))
9736 return;
9737
9738 reg = CSR_READ(sc, WMREG_PCS_CFG);
9739 reg |= PCS_CFG_PCS_EN;
9740 CSR_WRITE(sc, WMREG_PCS_CFG, reg);
9741
9742 reg = CSR_READ(sc, WMREG_CTRL_EXT);
9743 reg &= ~CTRL_EXT_SWDPIN(3);
9744 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
9745 CSR_WRITE_FLUSH(sc);
9746 }
9747
9748 static int
9749 wm_serdes_mediachange(struct ifnet *ifp)
9750 {
9751 struct wm_softc *sc = ifp->if_softc;
9752 bool pcs_autoneg = true; /* XXX */
9753 uint32_t ctrl_ext, pcs_lctl, reg;
9754
9755 /* XXX Currently, this function is not called on 8257[12] */
9756 if ((sc->sc_type == WM_T_82571) || (sc->sc_type == WM_T_82572)
9757 || (sc->sc_type >= WM_T_82575))
9758 CSR_WRITE(sc, WMREG_SCTL, SCTL_DISABLE_SERDES_LOOPBACK);
9759
9760 wm_serdes_power_up_link_82575(sc);
9761
9762 sc->sc_ctrl |= CTRL_SLU;
9763
9764 if ((sc->sc_type == WM_T_82575) || (sc->sc_type == WM_T_82576))
9765 sc->sc_ctrl |= CTRL_SWDPIN(0) | CTRL_SWDPIN(1);
9766
9767 ctrl_ext = CSR_READ(sc, WMREG_CTRL_EXT);
9768 pcs_lctl = CSR_READ(sc, WMREG_PCS_LCTL);
9769 switch (ctrl_ext & CTRL_EXT_LINK_MODE_MASK) {
9770 case CTRL_EXT_LINK_MODE_SGMII:
9771 pcs_autoneg = true;
9772 pcs_lctl &= ~PCS_LCTL_AN_TIMEOUT;
9773 break;
9774 case CTRL_EXT_LINK_MODE_1000KX:
9775 pcs_autoneg = false;
9776 /* FALLTHROUGH */
9777 default:
9778 if ((sc->sc_type == WM_T_82575)
9779 || (sc->sc_type == WM_T_82576)) {
9780 if ((sc->sc_flags & WM_F_PCS_DIS_AUTONEGO) != 0)
9781 pcs_autoneg = false;
9782 }
9783 sc->sc_ctrl |= CTRL_SPEED_1000 | CTRL_FRCSPD | CTRL_FD
9784 | CTRL_FRCFDX;
9785 pcs_lctl |= PCS_LCTL_FSV_1000 | PCS_LCTL_FDV_FULL;
9786 }
9787 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
9788
9789 if (pcs_autoneg) {
9790 pcs_lctl |= PCS_LCTL_AN_ENABLE | PCS_LCTL_AN_RESTART;
9791 pcs_lctl &= ~PCS_LCTL_FORCE_FC;
9792
9793 reg = CSR_READ(sc, WMREG_PCS_ANADV);
9794 reg &= ~(TXCW_ASYM_PAUSE | TXCW_SYM_PAUSE);
9795 reg |= TXCW_ASYM_PAUSE | TXCW_SYM_PAUSE;
9796 CSR_WRITE(sc, WMREG_PCS_ANADV, reg);
9797 } else
9798 pcs_lctl |= PCS_LCTL_FSD | PCS_LCTL_FORCE_FC;
9799
9800 CSR_WRITE(sc, WMREG_PCS_LCTL, pcs_lctl);
9801
9802
9803 return 0;
9804 }
9805
9806 static void
9807 wm_serdes_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
9808 {
9809 struct wm_softc *sc = ifp->if_softc;
9810 struct mii_data *mii = &sc->sc_mii;
9811 struct ifmedia_entry *ife = sc->sc_mii.mii_media.ifm_cur;
9812 uint32_t pcs_adv, pcs_lpab, reg;
9813
9814 ifmr->ifm_status = IFM_AVALID;
9815 ifmr->ifm_active = IFM_ETHER;
9816
9817 /* Check PCS */
9818 reg = CSR_READ(sc, WMREG_PCS_LSTS);
9819 if ((reg & PCS_LSTS_LINKOK) == 0) {
9820 ifmr->ifm_active |= IFM_NONE;
9821 sc->sc_tbi_linkup = 0;
9822 goto setled;
9823 }
9824
9825 sc->sc_tbi_linkup = 1;
9826 ifmr->ifm_status |= IFM_ACTIVE;
9827 ifmr->ifm_active |= IFM_1000_SX; /* XXX */
9828 if ((reg & PCS_LSTS_FDX) != 0)
9829 ifmr->ifm_active |= IFM_FDX;
9830 else
9831 ifmr->ifm_active |= IFM_HDX;
9832 mii->mii_media_active &= ~IFM_ETH_FMASK;
9833 if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
9834 /* Check flow */
9835 reg = CSR_READ(sc, WMREG_PCS_LSTS);
9836 if ((reg & PCS_LSTS_AN_COMP) == 0) {
9837 DPRINTF(WM_DEBUG_LINK, ("XXX LINKOK but not ACOMP\n"));
9838 goto setled;
9839 }
9840 pcs_adv = CSR_READ(sc, WMREG_PCS_ANADV);
9841 pcs_lpab = CSR_READ(sc, WMREG_PCS_LPAB);
9842 DPRINTF(WM_DEBUG_LINK,
9843 ("XXX AN result(2) %08x, %08x\n", pcs_adv, pcs_lpab));
9844 if ((pcs_adv & TXCW_SYM_PAUSE)
9845 && (pcs_lpab & TXCW_SYM_PAUSE)) {
9846 mii->mii_media_active |= IFM_FLOW
9847 | IFM_ETH_TXPAUSE | IFM_ETH_RXPAUSE;
9848 } else if (((pcs_adv & TXCW_SYM_PAUSE) == 0)
9849 && (pcs_adv & TXCW_ASYM_PAUSE)
9850 && (pcs_lpab & TXCW_SYM_PAUSE)
9851 && (pcs_lpab & TXCW_ASYM_PAUSE)) {
9852 mii->mii_media_active |= IFM_FLOW
9853 | IFM_ETH_TXPAUSE;
9854 } else if ((pcs_adv & TXCW_SYM_PAUSE)
9855 && (pcs_adv & TXCW_ASYM_PAUSE)
9856 && ((pcs_lpab & TXCW_SYM_PAUSE) == 0)
9857 && (pcs_lpab & TXCW_ASYM_PAUSE)) {
9858 mii->mii_media_active |= IFM_FLOW
9859 | IFM_ETH_RXPAUSE;
9860 } else {
9861 }
9862 }
9863 ifmr->ifm_active = (ifmr->ifm_active & ~IFM_ETH_FMASK)
9864 | (mii->mii_media_active & IFM_ETH_FMASK);
9865 setled:
9866 wm_tbi_serdes_set_linkled(sc);
9867 }
9868
9869 /*
9870 * wm_serdes_tick:
9871 *
9872 * Check the link on serdes devices.
9873 */
9874 static void
9875 wm_serdes_tick(struct wm_softc *sc)
9876 {
9877 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
9878 struct mii_data *mii = &sc->sc_mii;
9879 struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
9880 uint32_t reg;
9881
9882 KASSERT(WM_CORE_LOCKED(sc));
9883
9884 mii->mii_media_status = IFM_AVALID;
9885 mii->mii_media_active = IFM_ETHER;
9886
9887 /* Check PCS */
9888 reg = CSR_READ(sc, WMREG_PCS_LSTS);
9889 if ((reg & PCS_LSTS_LINKOK) != 0) {
9890 mii->mii_media_status |= IFM_ACTIVE;
9891 sc->sc_tbi_linkup = 1;
9892 sc->sc_tbi_serdes_ticks = 0;
9893 mii->mii_media_active |= IFM_1000_SX; /* XXX */
9894 if ((reg & PCS_LSTS_FDX) != 0)
9895 mii->mii_media_active |= IFM_FDX;
9896 else
9897 mii->mii_media_active |= IFM_HDX;
9898 } else {
9899 mii->mii_media_status |= IFM_NONE;
9900 sc->sc_tbi_linkup = 0;
9901 /* If the timer expired, retry autonegotiation */
9902 if ((IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO)
9903 && (++sc->sc_tbi_serdes_ticks
9904 >= sc->sc_tbi_serdes_anegticks)) {
9905 DPRINTF(WM_DEBUG_LINK, ("EXPIRE\n"));
9906 sc->sc_tbi_serdes_ticks = 0;
9907 /* XXX */
9908 wm_serdes_mediachange(ifp);
9909 }
9910 }
9911
9912 wm_tbi_serdes_set_linkled(sc);
9913 }
9914
9915 /* SFP related */
9916
9917 static int
9918 wm_sfp_read_data_byte(struct wm_softc *sc, uint16_t offset, uint8_t *data)
9919 {
9920 uint32_t i2ccmd;
9921 int i;
9922
9923 i2ccmd = (offset << I2CCMD_REG_ADDR_SHIFT) | I2CCMD_OPCODE_READ;
9924 CSR_WRITE(sc, WMREG_I2CCMD, i2ccmd);
9925
9926 /* Poll the ready bit */
9927 for (i = 0; i < I2CCMD_PHY_TIMEOUT; i++) {
9928 delay(50);
9929 i2ccmd = CSR_READ(sc, WMREG_I2CCMD);
9930 if (i2ccmd & I2CCMD_READY)
9931 break;
9932 }
9933 if ((i2ccmd & I2CCMD_READY) == 0)
9934 return -1;
9935 if ((i2ccmd & I2CCMD_ERROR) != 0)
9936 return -1;
9937
9938 *data = i2ccmd & 0x00ff;
9939
9940 return 0;
9941 }
9942
9943 static uint32_t
9944 wm_sfp_get_media_type(struct wm_softc *sc)
9945 {
9946 uint32_t ctrl_ext;
9947 uint8_t val = 0;
9948 int timeout = 3;
9949 uint32_t mediatype = WM_MEDIATYPE_UNKNOWN;
9950 int rv = -1;
9951
9952 ctrl_ext = CSR_READ(sc, WMREG_CTRL_EXT);
9953 ctrl_ext &= ~CTRL_EXT_SWDPIN(3);
9954 CSR_WRITE(sc, WMREG_CTRL_EXT, ctrl_ext | CTRL_EXT_I2C_ENA);
9955 CSR_WRITE_FLUSH(sc);
9956
9957 /* Read SFP module data */
9958 while (timeout) {
9959 rv = wm_sfp_read_data_byte(sc, SFF_SFP_ID_OFF, &val);
9960 if (rv == 0)
9961 break;
9962 delay(100*1000); /* XXX too big */
9963 timeout--;
9964 }
9965 if (rv != 0)
9966 goto out;
9967 switch (val) {
9968 case SFF_SFP_ID_SFF:
9969 aprint_normal_dev(sc->sc_dev,
9970 "Module/Connector soldered to board\n");
9971 break;
9972 case SFF_SFP_ID_SFP:
9973 aprint_normal_dev(sc->sc_dev, "SFP\n");
9974 break;
9975 case SFF_SFP_ID_UNKNOWN:
9976 goto out;
9977 default:
9978 break;
9979 }
9980
9981 rv = wm_sfp_read_data_byte(sc, SFF_SFP_ETH_FLAGS_OFF, &val);
9982 if (rv != 0) {
9983 goto out;
9984 }
9985
9986 if ((val & (SFF_SFP_ETH_FLAGS_1000SX | SFF_SFP_ETH_FLAGS_1000LX)) != 0)
9987 mediatype = WM_MEDIATYPE_SERDES;
9988 else if ((val & SFF_SFP_ETH_FLAGS_1000T) != 0){
9989 sc->sc_flags |= WM_F_SGMII;
9990 mediatype = WM_MEDIATYPE_COPPER;
9991 } else if ((val & SFF_SFP_ETH_FLAGS_100FX) != 0){
9992 sc->sc_flags |= WM_F_SGMII;
9993 mediatype = WM_MEDIATYPE_SERDES;
9994 }
9995
9996 out:
9997 /* Restore I2C interface setting */
9998 CSR_WRITE(sc, WMREG_CTRL_EXT, ctrl_ext);
9999
10000 return mediatype;
10001 }
10002 /*
10003 * NVM related.
10004 * Microwire, SPI (w/wo EERD) and Flash.
10005 */
10006
10007 /* Both spi and uwire */
10008
10009 /*
10010 * wm_eeprom_sendbits:
10011 *
10012 * Send a series of bits to the EEPROM.
10013 */
10014 static void
10015 wm_eeprom_sendbits(struct wm_softc *sc, uint32_t bits, int nbits)
10016 {
10017 uint32_t reg;
10018 int x;
10019
10020 reg = CSR_READ(sc, WMREG_EECD);
10021
10022 for (x = nbits; x > 0; x--) {
10023 if (bits & (1U << (x - 1)))
10024 reg |= EECD_DI;
10025 else
10026 reg &= ~EECD_DI;
10027 CSR_WRITE(sc, WMREG_EECD, reg);
10028 CSR_WRITE_FLUSH(sc);
10029 delay(2);
10030 CSR_WRITE(sc, WMREG_EECD, reg | EECD_SK);
10031 CSR_WRITE_FLUSH(sc);
10032 delay(2);
10033 CSR_WRITE(sc, WMREG_EECD, reg);
10034 CSR_WRITE_FLUSH(sc);
10035 delay(2);
10036 }
10037 }
10038
10039 /*
10040 * wm_eeprom_recvbits:
10041 *
10042 * Receive a series of bits from the EEPROM.
10043 */
10044 static void
10045 wm_eeprom_recvbits(struct wm_softc *sc, uint32_t *valp, int nbits)
10046 {
10047 uint32_t reg, val;
10048 int x;
10049
10050 reg = CSR_READ(sc, WMREG_EECD) & ~EECD_DI;
10051
10052 val = 0;
10053 for (x = nbits; x > 0; x--) {
10054 CSR_WRITE(sc, WMREG_EECD, reg | EECD_SK);
10055 CSR_WRITE_FLUSH(sc);
10056 delay(2);
10057 if (CSR_READ(sc, WMREG_EECD) & EECD_DO)
10058 val |= (1U << (x - 1));
10059 CSR_WRITE(sc, WMREG_EECD, reg);
10060 CSR_WRITE_FLUSH(sc);
10061 delay(2);
10062 }
10063 *valp = val;
10064 }
10065
10066 /* Microwire */
10067
10068 /*
10069 * wm_nvm_read_uwire:
10070 *
10071 * Read a word from the EEPROM using the MicroWire protocol.
10072 */
10073 static int
10074 wm_nvm_read_uwire(struct wm_softc *sc, int word, int wordcnt, uint16_t *data)
10075 {
10076 uint32_t reg, val;
10077 int i;
10078
10079 DPRINTF(WM_DEBUG_NVM, ("%s: %s called\n",
10080 device_xname(sc->sc_dev), __func__));
10081
10082 for (i = 0; i < wordcnt; i++) {
10083 /* Clear SK and DI. */
10084 reg = CSR_READ(sc, WMREG_EECD) & ~(EECD_SK | EECD_DI);
10085 CSR_WRITE(sc, WMREG_EECD, reg);
10086
10087 /*
10088 * XXX: workaround for a bug in qemu-0.12.x and prior
10089 * and Xen.
10090 *
10091 * We use this workaround only for 82540 because qemu's
10092 * e1000 act as 82540.
10093 */
10094 if (sc->sc_type == WM_T_82540) {
10095 reg |= EECD_SK;
10096 CSR_WRITE(sc, WMREG_EECD, reg);
10097 reg &= ~EECD_SK;
10098 CSR_WRITE(sc, WMREG_EECD, reg);
10099 CSR_WRITE_FLUSH(sc);
10100 delay(2);
10101 }
10102 /* XXX: end of workaround */
10103
10104 /* Set CHIP SELECT. */
10105 reg |= EECD_CS;
10106 CSR_WRITE(sc, WMREG_EECD, reg);
10107 CSR_WRITE_FLUSH(sc);
10108 delay(2);
10109
10110 /* Shift in the READ command. */
10111 wm_eeprom_sendbits(sc, UWIRE_OPC_READ, 3);
10112
10113 /* Shift in address. */
10114 wm_eeprom_sendbits(sc, word + i, sc->sc_nvm_addrbits);
10115
10116 /* Shift out the data. */
10117 wm_eeprom_recvbits(sc, &val, 16);
10118 data[i] = val & 0xffff;
10119
10120 /* Clear CHIP SELECT. */
10121 reg = CSR_READ(sc, WMREG_EECD) & ~EECD_CS;
10122 CSR_WRITE(sc, WMREG_EECD, reg);
10123 CSR_WRITE_FLUSH(sc);
10124 delay(2);
10125 }
10126
10127 return 0;
10128 }
10129
10130 /* SPI */
10131
10132 /*
10133 * Set SPI and FLASH related information from the EECD register.
10134 * For 82541 and 82547, the word size is taken from EEPROM.
10135 */
10136 static int
10137 wm_nvm_set_addrbits_size_eecd(struct wm_softc *sc)
10138 {
10139 int size;
10140 uint32_t reg;
10141 uint16_t data;
10142
10143 reg = CSR_READ(sc, WMREG_EECD);
10144 sc->sc_nvm_addrbits = (reg & EECD_EE_ABITS) ? 16 : 8;
10145
10146 /* Read the size of NVM from EECD by default */
10147 size = __SHIFTOUT(reg, EECD_EE_SIZE_EX_MASK);
10148 switch (sc->sc_type) {
10149 case WM_T_82541:
10150 case WM_T_82541_2:
10151 case WM_T_82547:
10152 case WM_T_82547_2:
10153 /* Set dummy value to access EEPROM */
10154 sc->sc_nvm_wordsize = 64;
10155 wm_nvm_read(sc, NVM_OFF_EEPROM_SIZE, 1, &data);
10156 reg = data;
10157 size = __SHIFTOUT(reg, EECD_EE_SIZE_EX_MASK);
10158 if (size == 0)
10159 size = 6; /* 64 word size */
10160 else
10161 size += NVM_WORD_SIZE_BASE_SHIFT + 1;
10162 break;
10163 case WM_T_80003:
10164 case WM_T_82571:
10165 case WM_T_82572:
10166 case WM_T_82573: /* SPI case */
10167 case WM_T_82574: /* SPI case */
10168 case WM_T_82583: /* SPI case */
10169 size += NVM_WORD_SIZE_BASE_SHIFT;
10170 if (size > 14)
10171 size = 14;
10172 break;
10173 case WM_T_82575:
10174 case WM_T_82576:
10175 case WM_T_82580:
10176 case WM_T_I350:
10177 case WM_T_I354:
10178 case WM_T_I210:
10179 case WM_T_I211:
10180 size += NVM_WORD_SIZE_BASE_SHIFT;
10181 if (size > 15)
10182 size = 15;
10183 break;
10184 default:
10185 aprint_error_dev(sc->sc_dev,
10186 "%s: unknown device(%d)?\n", __func__, sc->sc_type);
10187 return -1;
10188 break;
10189 }
10190
10191 sc->sc_nvm_wordsize = 1 << size;
10192
10193 return 0;
10194 }
10195
10196 /*
10197 * wm_nvm_ready_spi:
10198 *
10199 * Wait for a SPI EEPROM to be ready for commands.
10200 */
10201 static int
10202 wm_nvm_ready_spi(struct wm_softc *sc)
10203 {
10204 uint32_t val;
10205 int usec;
10206
10207 DPRINTF(WM_DEBUG_NVM, ("%s: %s called\n",
10208 device_xname(sc->sc_dev), __func__));
10209
10210 for (usec = 0; usec < SPI_MAX_RETRIES; delay(5), usec += 5) {
10211 wm_eeprom_sendbits(sc, SPI_OPC_RDSR, 8);
10212 wm_eeprom_recvbits(sc, &val, 8);
10213 if ((val & SPI_SR_RDY) == 0)
10214 break;
10215 }
10216 if (usec >= SPI_MAX_RETRIES) {
10217 aprint_error_dev(sc->sc_dev,"EEPROM failed to become ready\n");
10218 return 1;
10219 }
10220 return 0;
10221 }
10222
10223 /*
10224 * wm_nvm_read_spi:
10225 *
10226 * Read a work from the EEPROM using the SPI protocol.
10227 */
10228 static int
10229 wm_nvm_read_spi(struct wm_softc *sc, int word, int wordcnt, uint16_t *data)
10230 {
10231 uint32_t reg, val;
10232 int i;
10233 uint8_t opc;
10234
10235 DPRINTF(WM_DEBUG_NVM, ("%s: %s called\n",
10236 device_xname(sc->sc_dev), __func__));
10237
10238 /* Clear SK and CS. */
10239 reg = CSR_READ(sc, WMREG_EECD) & ~(EECD_SK | EECD_CS);
10240 CSR_WRITE(sc, WMREG_EECD, reg);
10241 CSR_WRITE_FLUSH(sc);
10242 delay(2);
10243
10244 if (wm_nvm_ready_spi(sc))
10245 return 1;
10246
10247 /* Toggle CS to flush commands. */
10248 CSR_WRITE(sc, WMREG_EECD, reg | EECD_CS);
10249 CSR_WRITE_FLUSH(sc);
10250 delay(2);
10251 CSR_WRITE(sc, WMREG_EECD, reg);
10252 CSR_WRITE_FLUSH(sc);
10253 delay(2);
10254
10255 opc = SPI_OPC_READ;
10256 if (sc->sc_nvm_addrbits == 8 && word >= 128)
10257 opc |= SPI_OPC_A8;
10258
10259 wm_eeprom_sendbits(sc, opc, 8);
10260 wm_eeprom_sendbits(sc, word << 1, sc->sc_nvm_addrbits);
10261
10262 for (i = 0; i < wordcnt; i++) {
10263 wm_eeprom_recvbits(sc, &val, 16);
10264 data[i] = ((val >> 8) & 0xff) | ((val & 0xff) << 8);
10265 }
10266
10267 /* Raise CS and clear SK. */
10268 reg = (CSR_READ(sc, WMREG_EECD) & ~EECD_SK) | EECD_CS;
10269 CSR_WRITE(sc, WMREG_EECD, reg);
10270 CSR_WRITE_FLUSH(sc);
10271 delay(2);
10272
10273 return 0;
10274 }
10275
10276 /* Using with EERD */
10277
10278 static int
10279 wm_poll_eerd_eewr_done(struct wm_softc *sc, int rw)
10280 {
10281 uint32_t attempts = 100000;
10282 uint32_t i, reg = 0;
10283 int32_t done = -1;
10284
10285 for (i = 0; i < attempts; i++) {
10286 reg = CSR_READ(sc, rw);
10287
10288 if (reg & EERD_DONE) {
10289 done = 0;
10290 break;
10291 }
10292 delay(5);
10293 }
10294
10295 return done;
10296 }
10297
10298 static int
10299 wm_nvm_read_eerd(struct wm_softc *sc, int offset, int wordcnt,
10300 uint16_t *data)
10301 {
10302 int i, eerd = 0;
10303 int error = 0;
10304
10305 DPRINTF(WM_DEBUG_NVM, ("%s: %s called\n",
10306 device_xname(sc->sc_dev), __func__));
10307
10308 for (i = 0; i < wordcnt; i++) {
10309 eerd = ((offset + i) << EERD_ADDR_SHIFT) | EERD_START;
10310
10311 CSR_WRITE(sc, WMREG_EERD, eerd);
10312 error = wm_poll_eerd_eewr_done(sc, WMREG_EERD);
10313 if (error != 0)
10314 break;
10315
10316 data[i] = (CSR_READ(sc, WMREG_EERD) >> EERD_DATA_SHIFT);
10317 }
10318
10319 return error;
10320 }
10321
10322 /* Flash */
10323
10324 static int
10325 wm_nvm_valid_bank_detect_ich8lan(struct wm_softc *sc, unsigned int *bank)
10326 {
10327 uint32_t eecd;
10328 uint32_t act_offset = ICH_NVM_SIG_WORD * 2 + 1;
10329 uint32_t bank1_offset = sc->sc_ich8_flash_bank_size * sizeof(uint16_t);
10330 uint8_t sig_byte = 0;
10331
10332 switch (sc->sc_type) {
10333 case WM_T_PCH_SPT:
10334 /*
10335 * In SPT, read from the CTRL_EXT reg instead of accessing the
10336 * sector valid bits from the NVM.
10337 */
10338 *bank = CSR_READ(sc, WMREG_CTRL_EXT) & CTRL_EXT_NVMVS;
10339 if ((*bank == 0) || (*bank == 1)) {
10340 aprint_error_dev(sc->sc_dev,
10341 "%s: no valid NVM bank present (%u)\n", __func__,
10342 *bank);
10343 return -1;
10344 } else {
10345 *bank = *bank - 2;
10346 return 0;
10347 }
10348 case WM_T_ICH8:
10349 case WM_T_ICH9:
10350 eecd = CSR_READ(sc, WMREG_EECD);
10351 if ((eecd & EECD_SEC1VAL_VALMASK) == EECD_SEC1VAL_VALMASK) {
10352 *bank = ((eecd & EECD_SEC1VAL) != 0) ? 1 : 0;
10353 return 0;
10354 }
10355 /* FALLTHROUGH */
10356 default:
10357 /* Default to 0 */
10358 *bank = 0;
10359
10360 /* Check bank 0 */
10361 wm_read_ich8_byte(sc, act_offset, &sig_byte);
10362 if ((sig_byte & ICH_NVM_VALID_SIG_MASK) == ICH_NVM_SIG_VALUE) {
10363 *bank = 0;
10364 return 0;
10365 }
10366
10367 /* Check bank 1 */
10368 wm_read_ich8_byte(sc, act_offset + bank1_offset,
10369 &sig_byte);
10370 if ((sig_byte & ICH_NVM_VALID_SIG_MASK) == ICH_NVM_SIG_VALUE) {
10371 *bank = 1;
10372 return 0;
10373 }
10374 }
10375
10376 DPRINTF(WM_DEBUG_NVM, ("%s: No valid NVM bank present\n",
10377 device_xname(sc->sc_dev)));
10378 return -1;
10379 }
10380
10381 /******************************************************************************
10382 * This function does initial flash setup so that a new read/write/erase cycle
10383 * can be started.
10384 *
10385 * sc - The pointer to the hw structure
10386 ****************************************************************************/
10387 static int32_t
10388 wm_ich8_cycle_init(struct wm_softc *sc)
10389 {
10390 uint16_t hsfsts;
10391 int32_t error = 1;
10392 int32_t i = 0;
10393
10394 hsfsts = ICH8_FLASH_READ16(sc, ICH_FLASH_HSFSTS);
10395
10396 /* May be check the Flash Des Valid bit in Hw status */
10397 if ((hsfsts & HSFSTS_FLDVAL) == 0) {
10398 return error;
10399 }
10400
10401 /* Clear FCERR in Hw status by writing 1 */
10402 /* Clear DAEL in Hw status by writing a 1 */
10403 hsfsts |= HSFSTS_ERR | HSFSTS_DAEL;
10404
10405 ICH8_FLASH_WRITE16(sc, ICH_FLASH_HSFSTS, hsfsts);
10406
10407 /*
10408 * Either we should have a hardware SPI cycle in progress bit to check
10409 * against, in order to start a new cycle or FDONE bit should be
10410 * changed in the hardware so that it is 1 after harware reset, which
10411 * can then be used as an indication whether a cycle is in progress or
10412 * has been completed .. we should also have some software semaphore
10413 * mechanism to guard FDONE or the cycle in progress bit so that two
10414 * threads access to those bits can be sequentiallized or a way so that
10415 * 2 threads dont start the cycle at the same time
10416 */
10417
10418 if ((hsfsts & HSFSTS_FLINPRO) == 0) {
10419 /*
10420 * There is no cycle running at present, so we can start a
10421 * cycle
10422 */
10423
10424 /* Begin by setting Flash Cycle Done. */
10425 hsfsts |= HSFSTS_DONE;
10426 ICH8_FLASH_WRITE16(sc, ICH_FLASH_HSFSTS, hsfsts);
10427 error = 0;
10428 } else {
10429 /*
10430 * otherwise poll for sometime so the current cycle has a
10431 * chance to end before giving up.
10432 */
10433 for (i = 0; i < ICH_FLASH_COMMAND_TIMEOUT; i++) {
10434 hsfsts = ICH8_FLASH_READ16(sc, ICH_FLASH_HSFSTS);
10435 if ((hsfsts & HSFSTS_FLINPRO) == 0) {
10436 error = 0;
10437 break;
10438 }
10439 delay(1);
10440 }
10441 if (error == 0) {
10442 /*
10443 * Successful in waiting for previous cycle to timeout,
10444 * now set the Flash Cycle Done.
10445 */
10446 hsfsts |= HSFSTS_DONE;
10447 ICH8_FLASH_WRITE16(sc, ICH_FLASH_HSFSTS, hsfsts);
10448 }
10449 }
10450 return error;
10451 }
10452
10453 /******************************************************************************
10454 * This function starts a flash cycle and waits for its completion
10455 *
10456 * sc - The pointer to the hw structure
10457 ****************************************************************************/
10458 static int32_t
10459 wm_ich8_flash_cycle(struct wm_softc *sc, uint32_t timeout)
10460 {
10461 uint16_t hsflctl;
10462 uint16_t hsfsts;
10463 int32_t error = 1;
10464 uint32_t i = 0;
10465
10466 /* Start a cycle by writing 1 in Flash Cycle Go in Hw Flash Control */
10467 hsflctl = ICH8_FLASH_READ16(sc, ICH_FLASH_HSFCTL);
10468 hsflctl |= HSFCTL_GO;
10469 ICH8_FLASH_WRITE16(sc, ICH_FLASH_HSFCTL, hsflctl);
10470
10471 /* Wait till FDONE bit is set to 1 */
10472 do {
10473 hsfsts = ICH8_FLASH_READ16(sc, ICH_FLASH_HSFSTS);
10474 if (hsfsts & HSFSTS_DONE)
10475 break;
10476 delay(1);
10477 i++;
10478 } while (i < timeout);
10479 if ((hsfsts & HSFSTS_DONE) == 1 && (hsfsts & HSFSTS_ERR) == 0)
10480 error = 0;
10481
10482 return error;
10483 }
10484
10485 /******************************************************************************
10486 * Reads a byte or (d)word from the NVM using the ICH8 flash access registers.
10487 *
10488 * sc - The pointer to the hw structure
10489 * index - The index of the byte or word to read.
10490 * size - Size of data to read, 1=byte 2=word, 4=dword
10491 * data - Pointer to the word to store the value read.
10492 *****************************************************************************/
10493 static int32_t
10494 wm_read_ich8_data(struct wm_softc *sc, uint32_t index,
10495 uint32_t size, uint32_t *data)
10496 {
10497 uint16_t hsfsts;
10498 uint16_t hsflctl;
10499 uint32_t flash_linear_address;
10500 uint32_t flash_data = 0;
10501 int32_t error = 1;
10502 int32_t count = 0;
10503
10504 if (size < 1 || size > 4 || data == 0x0 ||
10505 index > ICH_FLASH_LINEAR_ADDR_MASK)
10506 return error;
10507
10508 flash_linear_address = (ICH_FLASH_LINEAR_ADDR_MASK & index) +
10509 sc->sc_ich8_flash_base;
10510
10511 do {
10512 delay(1);
10513 /* Steps */
10514 error = wm_ich8_cycle_init(sc);
10515 if (error)
10516 break;
10517
10518 hsflctl = ICH8_FLASH_READ16(sc, ICH_FLASH_HSFCTL);
10519 /* 0b/1b corresponds to 1 or 2 byte size, respectively. */
10520 hsflctl |= ((size - 1) << HSFCTL_BCOUNT_SHIFT)
10521 & HSFCTL_BCOUNT_MASK;
10522 hsflctl |= ICH_CYCLE_READ << HSFCTL_CYCLE_SHIFT;
10523 if (sc->sc_type == WM_T_PCH_SPT) {
10524 /*
10525 * In SPT, This register is in Lan memory space, not
10526 * flash. Therefore, only 32 bit access is supported.
10527 */
10528 ICH8_FLASH_WRITE32(sc, ICH_FLASH_HSFCTL,
10529 (uint32_t)hsflctl);
10530 } else
10531 ICH8_FLASH_WRITE16(sc, ICH_FLASH_HSFCTL, hsflctl);
10532
10533 /*
10534 * Write the last 24 bits of index into Flash Linear address
10535 * field in Flash Address
10536 */
10537 /* TODO: TBD maybe check the index against the size of flash */
10538
10539 ICH8_FLASH_WRITE32(sc, ICH_FLASH_FADDR, flash_linear_address);
10540
10541 error = wm_ich8_flash_cycle(sc, ICH_FLASH_COMMAND_TIMEOUT);
10542
10543 /*
10544 * Check if FCERR is set to 1, if set to 1, clear it and try
10545 * the whole sequence a few more times, else read in (shift in)
10546 * the Flash Data0, the order is least significant byte first
10547 * msb to lsb
10548 */
10549 if (error == 0) {
10550 flash_data = ICH8_FLASH_READ32(sc, ICH_FLASH_FDATA0);
10551 if (size == 1)
10552 *data = (uint8_t)(flash_data & 0x000000FF);
10553 else if (size == 2)
10554 *data = (uint16_t)(flash_data & 0x0000FFFF);
10555 else if (size == 4)
10556 *data = (uint32_t)flash_data;
10557 break;
10558 } else {
10559 /*
10560 * If we've gotten here, then things are probably
10561 * completely hosed, but if the error condition is
10562 * detected, it won't hurt to give it another try...
10563 * ICH_FLASH_CYCLE_REPEAT_COUNT times.
10564 */
10565 hsfsts = ICH8_FLASH_READ16(sc, ICH_FLASH_HSFSTS);
10566 if (hsfsts & HSFSTS_ERR) {
10567 /* Repeat for some time before giving up. */
10568 continue;
10569 } else if ((hsfsts & HSFSTS_DONE) == 0)
10570 break;
10571 }
10572 } while (count++ < ICH_FLASH_CYCLE_REPEAT_COUNT);
10573
10574 return error;
10575 }
10576
10577 /******************************************************************************
10578 * Reads a single byte from the NVM using the ICH8 flash access registers.
10579 *
10580 * sc - pointer to wm_hw structure
10581 * index - The index of the byte to read.
10582 * data - Pointer to a byte to store the value read.
10583 *****************************************************************************/
10584 static int32_t
10585 wm_read_ich8_byte(struct wm_softc *sc, uint32_t index, uint8_t* data)
10586 {
10587 int32_t status;
10588 uint32_t word = 0;
10589
10590 status = wm_read_ich8_data(sc, index, 1, &word);
10591 if (status == 0)
10592 *data = (uint8_t)word;
10593 else
10594 *data = 0;
10595
10596 return status;
10597 }
10598
10599 /******************************************************************************
10600 * Reads a word from the NVM using the ICH8 flash access registers.
10601 *
10602 * sc - pointer to wm_hw structure
10603 * index - The starting byte index of the word to read.
10604 * data - Pointer to a word to store the value read.
10605 *****************************************************************************/
10606 static int32_t
10607 wm_read_ich8_word(struct wm_softc *sc, uint32_t index, uint16_t *data)
10608 {
10609 int32_t status;
10610 uint32_t word = 0;
10611
10612 status = wm_read_ich8_data(sc, index, 2, &word);
10613 if (status == 0)
10614 *data = (uint16_t)word;
10615 else
10616 *data = 0;
10617
10618 return status;
10619 }
10620
10621 /******************************************************************************
10622 * Reads a dword from the NVM using the ICH8 flash access registers.
10623 *
10624 * sc - pointer to wm_hw structure
10625 * index - The starting byte index of the word to read.
10626 * data - Pointer to a word to store the value read.
10627 *****************************************************************************/
10628 static int32_t
10629 wm_read_ich8_dword(struct wm_softc *sc, uint32_t index, uint32_t *data)
10630 {
10631 int32_t status;
10632
10633 status = wm_read_ich8_data(sc, index, 4, data);
10634 return status;
10635 }
10636
10637 /******************************************************************************
10638 * Reads a 16 bit word or words from the EEPROM using the ICH8's flash access
10639 * register.
10640 *
10641 * sc - Struct containing variables accessed by shared code
10642 * offset - offset of word in the EEPROM to read
10643 * data - word read from the EEPROM
10644 * words - number of words to read
10645 *****************************************************************************/
10646 static int
10647 wm_nvm_read_ich8(struct wm_softc *sc, int offset, int words, uint16_t *data)
10648 {
10649 int32_t error = 0;
10650 uint32_t flash_bank = 0;
10651 uint32_t act_offset = 0;
10652 uint32_t bank_offset = 0;
10653 uint16_t word = 0;
10654 uint16_t i = 0;
10655
10656 DPRINTF(WM_DEBUG_NVM, ("%s: %s called\n",
10657 device_xname(sc->sc_dev), __func__));
10658
10659 /*
10660 * We need to know which is the valid flash bank. In the event
10661 * that we didn't allocate eeprom_shadow_ram, we may not be
10662 * managing flash_bank. So it cannot be trusted and needs
10663 * to be updated with each read.
10664 */
10665 error = wm_nvm_valid_bank_detect_ich8lan(sc, &flash_bank);
10666 if (error) {
10667 DPRINTF(WM_DEBUG_NVM, ("%s: failed to detect NVM bank\n",
10668 device_xname(sc->sc_dev)));
10669 flash_bank = 0;
10670 }
10671
10672 /*
10673 * Adjust offset appropriately if we're on bank 1 - adjust for word
10674 * size
10675 */
10676 bank_offset = flash_bank * (sc->sc_ich8_flash_bank_size * 2);
10677
10678 error = wm_get_swfwhw_semaphore(sc);
10679 if (error) {
10680 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
10681 __func__);
10682 return error;
10683 }
10684
10685 for (i = 0; i < words; i++) {
10686 /* The NVM part needs a byte offset, hence * 2 */
10687 act_offset = bank_offset + ((offset + i) * 2);
10688 error = wm_read_ich8_word(sc, act_offset, &word);
10689 if (error) {
10690 aprint_error_dev(sc->sc_dev,
10691 "%s: failed to read NVM\n", __func__);
10692 break;
10693 }
10694 data[i] = word;
10695 }
10696
10697 wm_put_swfwhw_semaphore(sc);
10698 return error;
10699 }
10700
10701 /******************************************************************************
10702 * Reads a 16 bit word or words from the EEPROM using the SPT's flash access
10703 * register.
10704 *
10705 * sc - Struct containing variables accessed by shared code
10706 * offset - offset of word in the EEPROM to read
10707 * data - word read from the EEPROM
10708 * words - number of words to read
10709 *****************************************************************************/
10710 static int
10711 wm_nvm_read_spt(struct wm_softc *sc, int offset, int words, uint16_t *data)
10712 {
10713 int32_t error = 0;
10714 uint32_t flash_bank = 0;
10715 uint32_t act_offset = 0;
10716 uint32_t bank_offset = 0;
10717 uint32_t dword = 0;
10718 uint16_t i = 0;
10719
10720 DPRINTF(WM_DEBUG_NVM, ("%s: %s called\n",
10721 device_xname(sc->sc_dev), __func__));
10722
10723 /*
10724 * We need to know which is the valid flash bank. In the event
10725 * that we didn't allocate eeprom_shadow_ram, we may not be
10726 * managing flash_bank. So it cannot be trusted and needs
10727 * to be updated with each read.
10728 */
10729 error = wm_nvm_valid_bank_detect_ich8lan(sc, &flash_bank);
10730 if (error) {
10731 DPRINTF(WM_DEBUG_NVM, ("%s: failed to detect NVM bank\n",
10732 device_xname(sc->sc_dev)));
10733 flash_bank = 0;
10734 }
10735
10736 /*
10737 * Adjust offset appropriately if we're on bank 1 - adjust for word
10738 * size
10739 */
10740 bank_offset = flash_bank * (sc->sc_ich8_flash_bank_size * 2);
10741
10742 error = wm_get_swfwhw_semaphore(sc);
10743 if (error) {
10744 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
10745 __func__);
10746 return error;
10747 }
10748
10749 for (i = 0; i < words; i++) {
10750 /* The NVM part needs a byte offset, hence * 2 */
10751 act_offset = bank_offset + ((offset + i) * 2);
10752 /* but we must read dword aligned, so mask ... */
10753 error = wm_read_ich8_dword(sc, act_offset & ~0x3, &dword);
10754 if (error) {
10755 aprint_error_dev(sc->sc_dev,
10756 "%s: failed to read NVM\n", __func__);
10757 break;
10758 }
10759 /* ... and pick out low or high word */
10760 if ((act_offset & 0x2) == 0)
10761 data[i] = (uint16_t)(dword & 0xFFFF);
10762 else
10763 data[i] = (uint16_t)((dword >> 16) & 0xFFFF);
10764 }
10765
10766 wm_put_swfwhw_semaphore(sc);
10767 return error;
10768 }
10769
10770 /* iNVM */
10771
10772 static int
10773 wm_nvm_read_word_invm(struct wm_softc *sc, uint16_t address, uint16_t *data)
10774 {
10775 int32_t rv = 0;
10776 uint32_t invm_dword;
10777 uint16_t i;
10778 uint8_t record_type, word_address;
10779
10780 DPRINTF(WM_DEBUG_NVM, ("%s: %s called\n",
10781 device_xname(sc->sc_dev), __func__));
10782
10783 for (i = 0; i < INVM_SIZE; i++) {
10784 invm_dword = CSR_READ(sc, WM_INVM_DATA_REG(i));
10785 /* Get record type */
10786 record_type = INVM_DWORD_TO_RECORD_TYPE(invm_dword);
10787 if (record_type == INVM_UNINITIALIZED_STRUCTURE)
10788 break;
10789 if (record_type == INVM_CSR_AUTOLOAD_STRUCTURE)
10790 i += INVM_CSR_AUTOLOAD_DATA_SIZE_IN_DWORDS;
10791 if (record_type == INVM_RSA_KEY_SHA256_STRUCTURE)
10792 i += INVM_RSA_KEY_SHA256_DATA_SIZE_IN_DWORDS;
10793 if (record_type == INVM_WORD_AUTOLOAD_STRUCTURE) {
10794 word_address = INVM_DWORD_TO_WORD_ADDRESS(invm_dword);
10795 if (word_address == address) {
10796 *data = INVM_DWORD_TO_WORD_DATA(invm_dword);
10797 rv = 0;
10798 break;
10799 }
10800 }
10801 }
10802
10803 return rv;
10804 }
10805
10806 static int
10807 wm_nvm_read_invm(struct wm_softc *sc, int offset, int words, uint16_t *data)
10808 {
10809 int rv = 0;
10810 int i;
10811
10812 DPRINTF(WM_DEBUG_NVM, ("%s: %s called\n",
10813 device_xname(sc->sc_dev), __func__));
10814
10815 for (i = 0; i < words; i++) {
10816 switch (offset + i) {
10817 case NVM_OFF_MACADDR:
10818 case NVM_OFF_MACADDR1:
10819 case NVM_OFF_MACADDR2:
10820 rv = wm_nvm_read_word_invm(sc, offset + i, &data[i]);
10821 if (rv != 0) {
10822 data[i] = 0xffff;
10823 rv = -1;
10824 }
10825 break;
10826 case NVM_OFF_CFG2:
10827 rv = wm_nvm_read_word_invm(sc, offset, data);
10828 if (rv != 0) {
10829 *data = NVM_INIT_CTRL_2_DEFAULT_I211;
10830 rv = 0;
10831 }
10832 break;
10833 case NVM_OFF_CFG4:
10834 rv = wm_nvm_read_word_invm(sc, offset, data);
10835 if (rv != 0) {
10836 *data = NVM_INIT_CTRL_4_DEFAULT_I211;
10837 rv = 0;
10838 }
10839 break;
10840 case NVM_OFF_LED_1_CFG:
10841 rv = wm_nvm_read_word_invm(sc, offset, data);
10842 if (rv != 0) {
10843 *data = NVM_LED_1_CFG_DEFAULT_I211;
10844 rv = 0;
10845 }
10846 break;
10847 case NVM_OFF_LED_0_2_CFG:
10848 rv = wm_nvm_read_word_invm(sc, offset, data);
10849 if (rv != 0) {
10850 *data = NVM_LED_0_2_CFG_DEFAULT_I211;
10851 rv = 0;
10852 }
10853 break;
10854 case NVM_OFF_ID_LED_SETTINGS:
10855 rv = wm_nvm_read_word_invm(sc, offset, data);
10856 if (rv != 0) {
10857 *data = ID_LED_RESERVED_FFFF;
10858 rv = 0;
10859 }
10860 break;
10861 default:
10862 DPRINTF(WM_DEBUG_NVM,
10863 ("NVM word 0x%02x is not mapped.\n", offset));
10864 *data = NVM_RESERVED_WORD;
10865 break;
10866 }
10867 }
10868
10869 return rv;
10870 }
10871
10872 /* Lock, detecting NVM type, validate checksum, version and read */
10873
10874 /*
10875 * wm_nvm_acquire:
10876 *
10877 * Perform the EEPROM handshake required on some chips.
10878 */
10879 static int
10880 wm_nvm_acquire(struct wm_softc *sc)
10881 {
10882 uint32_t reg;
10883 int x;
10884 int ret = 0;
10885
10886 DPRINTF(WM_DEBUG_NVM, ("%s: %s called\n",
10887 device_xname(sc->sc_dev), __func__));
10888
10889 if (sc->sc_type >= WM_T_ICH8) {
10890 ret = wm_get_nvm_ich8lan(sc);
10891 } else if (sc->sc_flags & WM_F_LOCK_EXTCNF) {
10892 ret = wm_get_swfwhw_semaphore(sc);
10893 } else if (sc->sc_flags & WM_F_LOCK_SWFW) {
10894 /* This will also do wm_get_swsm_semaphore() if needed */
10895 ret = wm_get_swfw_semaphore(sc, SWFW_EEP_SM);
10896 } else if (sc->sc_flags & WM_F_LOCK_SWSM) {
10897 ret = wm_get_swsm_semaphore(sc);
10898 }
10899
10900 if (ret) {
10901 aprint_error_dev(sc->sc_dev, "%s: failed to get semaphore\n",
10902 __func__);
10903 return 1;
10904 }
10905
10906 if (sc->sc_flags & WM_F_LOCK_EECD) {
10907 reg = CSR_READ(sc, WMREG_EECD);
10908
10909 /* Request EEPROM access. */
10910 reg |= EECD_EE_REQ;
10911 CSR_WRITE(sc, WMREG_EECD, reg);
10912
10913 /* ..and wait for it to be granted. */
10914 for (x = 0; x < 1000; x++) {
10915 reg = CSR_READ(sc, WMREG_EECD);
10916 if (reg & EECD_EE_GNT)
10917 break;
10918 delay(5);
10919 }
10920 if ((reg & EECD_EE_GNT) == 0) {
10921 aprint_error_dev(sc->sc_dev,
10922 "could not acquire EEPROM GNT\n");
10923 reg &= ~EECD_EE_REQ;
10924 CSR_WRITE(sc, WMREG_EECD, reg);
10925 if (sc->sc_flags & WM_F_LOCK_EXTCNF)
10926 wm_put_swfwhw_semaphore(sc);
10927 if (sc->sc_flags & WM_F_LOCK_SWFW)
10928 wm_put_swfw_semaphore(sc, SWFW_EEP_SM);
10929 else if (sc->sc_flags & WM_F_LOCK_SWSM)
10930 wm_put_swsm_semaphore(sc);
10931 return 1;
10932 }
10933 }
10934
10935 return 0;
10936 }
10937
10938 /*
10939 * wm_nvm_release:
10940 *
10941 * Release the EEPROM mutex.
10942 */
10943 static void
10944 wm_nvm_release(struct wm_softc *sc)
10945 {
10946 uint32_t reg;
10947
10948 DPRINTF(WM_DEBUG_NVM, ("%s: %s called\n",
10949 device_xname(sc->sc_dev), __func__));
10950
10951 if (sc->sc_flags & WM_F_LOCK_EECD) {
10952 reg = CSR_READ(sc, WMREG_EECD);
10953 reg &= ~EECD_EE_REQ;
10954 CSR_WRITE(sc, WMREG_EECD, reg);
10955 }
10956
10957 if (sc->sc_type >= WM_T_ICH8) {
10958 wm_put_nvm_ich8lan(sc);
10959 } else if (sc->sc_flags & WM_F_LOCK_EXTCNF)
10960 wm_put_swfwhw_semaphore(sc);
10961 if (sc->sc_flags & WM_F_LOCK_SWFW)
10962 wm_put_swfw_semaphore(sc, SWFW_EEP_SM);
10963 else if (sc->sc_flags & WM_F_LOCK_SWSM)
10964 wm_put_swsm_semaphore(sc);
10965 }
10966
10967 static int
10968 wm_nvm_is_onboard_eeprom(struct wm_softc *sc)
10969 {
10970 uint32_t eecd = 0;
10971
10972 if (sc->sc_type == WM_T_82573 || sc->sc_type == WM_T_82574
10973 || sc->sc_type == WM_T_82583) {
10974 eecd = CSR_READ(sc, WMREG_EECD);
10975
10976 /* Isolate bits 15 & 16 */
10977 eecd = ((eecd >> 15) & 0x03);
10978
10979 /* If both bits are set, device is Flash type */
10980 if (eecd == 0x03)
10981 return 0;
10982 }
10983 return 1;
10984 }
10985
10986 static int
10987 wm_nvm_get_flash_presence_i210(struct wm_softc *sc)
10988 {
10989 uint32_t eec;
10990
10991 eec = CSR_READ(sc, WMREG_EEC);
10992 if ((eec & EEC_FLASH_DETECTED) != 0)
10993 return 1;
10994
10995 return 0;
10996 }
10997
10998 /*
10999 * wm_nvm_validate_checksum
11000 *
11001 * The checksum is defined as the sum of the first 64 (16 bit) words.
11002 */
11003 static int
11004 wm_nvm_validate_checksum(struct wm_softc *sc)
11005 {
11006 uint16_t checksum;
11007 uint16_t eeprom_data;
11008 #ifdef WM_DEBUG
11009 uint16_t csum_wordaddr, valid_checksum;
11010 #endif
11011 int i;
11012
11013 checksum = 0;
11014
11015 /* Don't check for I211 */
11016 if (sc->sc_type == WM_T_I211)
11017 return 0;
11018
11019 #ifdef WM_DEBUG
11020 if (sc->sc_type == WM_T_PCH_LPT) {
11021 csum_wordaddr = NVM_OFF_COMPAT;
11022 valid_checksum = NVM_COMPAT_VALID_CHECKSUM;
11023 } else {
11024 csum_wordaddr = NVM_OFF_FUTURE_INIT_WORD1;
11025 valid_checksum = NVM_FUTURE_INIT_WORD1_VALID_CHECKSUM;
11026 }
11027
11028 /* Dump EEPROM image for debug */
11029 if ((sc->sc_type == WM_T_ICH8) || (sc->sc_type == WM_T_ICH9)
11030 || (sc->sc_type == WM_T_ICH10) || (sc->sc_type == WM_T_PCH)
11031 || (sc->sc_type == WM_T_PCH2) || (sc->sc_type == WM_T_PCH_LPT)) {
11032 /* XXX PCH_SPT? */
11033 wm_nvm_read(sc, csum_wordaddr, 1, &eeprom_data);
11034 if ((eeprom_data & valid_checksum) == 0) {
11035 DPRINTF(WM_DEBUG_NVM,
11036 ("%s: NVM need to be updated (%04x != %04x)\n",
11037 device_xname(sc->sc_dev), eeprom_data,
11038 valid_checksum));
11039 }
11040 }
11041
11042 if ((wm_debug & WM_DEBUG_NVM) != 0) {
11043 printf("%s: NVM dump:\n", device_xname(sc->sc_dev));
11044 for (i = 0; i < NVM_SIZE; i++) {
11045 if (wm_nvm_read(sc, i, 1, &eeprom_data))
11046 printf("XXXX ");
11047 else
11048 printf("%04hx ", eeprom_data);
11049 if (i % 8 == 7)
11050 printf("\n");
11051 }
11052 }
11053
11054 #endif /* WM_DEBUG */
11055
11056 for (i = 0; i < NVM_SIZE; i++) {
11057 if (wm_nvm_read(sc, i, 1, &eeprom_data))
11058 return 1;
11059 checksum += eeprom_data;
11060 }
11061
11062 if (checksum != (uint16_t) NVM_CHECKSUM) {
11063 #ifdef WM_DEBUG
11064 printf("%s: NVM checksum mismatch (%04x != %04x)\n",
11065 device_xname(sc->sc_dev), checksum, NVM_CHECKSUM);
11066 #endif
11067 }
11068
11069 return 0;
11070 }
11071
11072 static void
11073 wm_nvm_version_invm(struct wm_softc *sc)
11074 {
11075 uint32_t dword;
11076
11077 /*
11078 * Linux's code to decode version is very strange, so we don't
11079 * obey that algorithm and just use word 61 as the document.
11080 * Perhaps it's not perfect though...
11081 *
11082 * Example:
11083 *
11084 * Word61: 00800030 -> Version 0.6 (I211 spec update notes about 0.6)
11085 */
11086 dword = CSR_READ(sc, WM_INVM_DATA_REG(61));
11087 dword = __SHIFTOUT(dword, INVM_VER_1);
11088 sc->sc_nvm_ver_major = __SHIFTOUT(dword, INVM_MAJOR);
11089 sc->sc_nvm_ver_minor = __SHIFTOUT(dword, INVM_MINOR);
11090 }
11091
11092 static void
11093 wm_nvm_version(struct wm_softc *sc)
11094 {
11095 uint16_t major, minor, build, patch;
11096 uint16_t uid0, uid1;
11097 uint16_t nvm_data;
11098 uint16_t off;
11099 bool check_version = false;
11100 bool check_optionrom = false;
11101 bool have_build = false;
11102
11103 /*
11104 * Version format:
11105 *
11106 * XYYZ
11107 * X0YZ
11108 * X0YY
11109 *
11110 * Example:
11111 *
11112 * 82571 0x50a2 5.10.2? (the spec update notes about 5.6-5.10)
11113 * 82571 0x50a6 5.10.6?
11114 * 82572 0x506a 5.6.10?
11115 * 82572EI 0x5069 5.6.9?
11116 * 82574L 0x1080 1.8.0? (the spec update notes about 2.1.4)
11117 * 0x2013 2.1.3?
11118 * 82583 0x10a0 1.10.0? (document says it's default vaule)
11119 */
11120 wm_nvm_read(sc, NVM_OFF_IMAGE_UID1, 1, &uid1);
11121 switch (sc->sc_type) {
11122 case WM_T_82571:
11123 case WM_T_82572:
11124 case WM_T_82574:
11125 case WM_T_82583:
11126 check_version = true;
11127 check_optionrom = true;
11128 have_build = true;
11129 break;
11130 case WM_T_82575:
11131 case WM_T_82576:
11132 case WM_T_82580:
11133 if ((uid1 & NVM_MAJOR_MASK) != NVM_UID_VALID)
11134 check_version = true;
11135 break;
11136 case WM_T_I211:
11137 wm_nvm_version_invm(sc);
11138 goto printver;
11139 case WM_T_I210:
11140 if (!wm_nvm_get_flash_presence_i210(sc)) {
11141 wm_nvm_version_invm(sc);
11142 goto printver;
11143 }
11144 /* FALLTHROUGH */
11145 case WM_T_I350:
11146 case WM_T_I354:
11147 check_version = true;
11148 check_optionrom = true;
11149 break;
11150 default:
11151 return;
11152 }
11153 if (check_version) {
11154 wm_nvm_read(sc, NVM_OFF_VERSION, 1, &nvm_data);
11155 major = (nvm_data & NVM_MAJOR_MASK) >> NVM_MAJOR_SHIFT;
11156 if (have_build || ((nvm_data & 0x0f00) != 0x0000)) {
11157 minor = (nvm_data & NVM_MINOR_MASK) >> NVM_MINOR_SHIFT;
11158 build = nvm_data & NVM_BUILD_MASK;
11159 have_build = true;
11160 } else
11161 minor = nvm_data & 0x00ff;
11162
11163 /* Decimal */
11164 minor = (minor / 16) * 10 + (minor % 16);
11165 sc->sc_nvm_ver_major = major;
11166 sc->sc_nvm_ver_minor = minor;
11167
11168 printver:
11169 aprint_verbose(", version %d.%d", sc->sc_nvm_ver_major,
11170 sc->sc_nvm_ver_minor);
11171 if (have_build) {
11172 sc->sc_nvm_ver_build = build;
11173 aprint_verbose(".%d", build);
11174 }
11175 }
11176 if (check_optionrom) {
11177 wm_nvm_read(sc, NVM_OFF_COMB_VER_PTR, 1, &off);
11178 /* Option ROM Version */
11179 if ((off != 0x0000) && (off != 0xffff)) {
11180 off += NVM_COMBO_VER_OFF;
11181 wm_nvm_read(sc, off + 1, 1, &uid1);
11182 wm_nvm_read(sc, off, 1, &uid0);
11183 if ((uid0 != 0) && (uid0 != 0xffff)
11184 && (uid1 != 0) && (uid1 != 0xffff)) {
11185 /* 16bits */
11186 major = uid0 >> 8;
11187 build = (uid0 << 8) | (uid1 >> 8);
11188 patch = uid1 & 0x00ff;
11189 aprint_verbose(", option ROM Version %d.%d.%d",
11190 major, build, patch);
11191 }
11192 }
11193 }
11194
11195 wm_nvm_read(sc, NVM_OFF_IMAGE_UID0, 1, &uid0);
11196 aprint_verbose(", Image Unique ID %08x", (uid1 << 16) | uid0);
11197 }
11198
11199 /*
11200 * wm_nvm_read:
11201 *
11202 * Read data from the serial EEPROM.
11203 */
11204 static int
11205 wm_nvm_read(struct wm_softc *sc, int word, int wordcnt, uint16_t *data)
11206 {
11207 int rv;
11208
11209 DPRINTF(WM_DEBUG_NVM, ("%s: %s called\n",
11210 device_xname(sc->sc_dev), __func__));
11211
11212 if (sc->sc_flags & WM_F_EEPROM_INVALID)
11213 return 1;
11214
11215 if (wm_nvm_acquire(sc))
11216 return 1;
11217
11218 if ((sc->sc_type == WM_T_ICH8) || (sc->sc_type == WM_T_ICH9)
11219 || (sc->sc_type == WM_T_ICH10) || (sc->sc_type == WM_T_PCH)
11220 || (sc->sc_type == WM_T_PCH2) || (sc->sc_type == WM_T_PCH_LPT))
11221 rv = wm_nvm_read_ich8(sc, word, wordcnt, data);
11222 else if (sc->sc_type == WM_T_PCH_SPT)
11223 rv = wm_nvm_read_spt(sc, word, wordcnt, data);
11224 else if (sc->sc_flags & WM_F_EEPROM_INVM)
11225 rv = wm_nvm_read_invm(sc, word, wordcnt, data);
11226 else if (sc->sc_flags & WM_F_EEPROM_EERDEEWR)
11227 rv = wm_nvm_read_eerd(sc, word, wordcnt, data);
11228 else if (sc->sc_flags & WM_F_EEPROM_SPI)
11229 rv = wm_nvm_read_spi(sc, word, wordcnt, data);
11230 else
11231 rv = wm_nvm_read_uwire(sc, word, wordcnt, data);
11232
11233 wm_nvm_release(sc);
11234 return rv;
11235 }
11236
11237 /*
11238 * Hardware semaphores.
11239 * Very complexed...
11240 */
11241
11242 static int
11243 wm_get_null(struct wm_softc *sc)
11244 {
11245
11246 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11247 device_xname(sc->sc_dev), __func__));
11248 return 0;
11249 }
11250
11251 static void
11252 wm_put_null(struct wm_softc *sc)
11253 {
11254
11255 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11256 device_xname(sc->sc_dev), __func__));
11257 return;
11258 }
11259
11260 /*
11261 * Get hardware semaphore.
11262 * Same as e1000_get_hw_semaphore_generic()
11263 */
11264 static int
11265 wm_get_swsm_semaphore(struct wm_softc *sc)
11266 {
11267 int32_t timeout;
11268 uint32_t swsm;
11269
11270 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11271 device_xname(sc->sc_dev), __func__));
11272 KASSERT(sc->sc_nvm_wordsize > 0);
11273
11274 /* Get the SW semaphore. */
11275 timeout = sc->sc_nvm_wordsize + 1;
11276 while (timeout) {
11277 swsm = CSR_READ(sc, WMREG_SWSM);
11278
11279 if ((swsm & SWSM_SMBI) == 0)
11280 break;
11281
11282 delay(50);
11283 timeout--;
11284 }
11285
11286 if (timeout == 0) {
11287 aprint_error_dev(sc->sc_dev,
11288 "could not acquire SWSM SMBI\n");
11289 return 1;
11290 }
11291
11292 /* Get the FW semaphore. */
11293 timeout = sc->sc_nvm_wordsize + 1;
11294 while (timeout) {
11295 swsm = CSR_READ(sc, WMREG_SWSM);
11296 swsm |= SWSM_SWESMBI;
11297 CSR_WRITE(sc, WMREG_SWSM, swsm);
11298 /* If we managed to set the bit we got the semaphore. */
11299 swsm = CSR_READ(sc, WMREG_SWSM);
11300 if (swsm & SWSM_SWESMBI)
11301 break;
11302
11303 delay(50);
11304 timeout--;
11305 }
11306
11307 if (timeout == 0) {
11308 aprint_error_dev(sc->sc_dev,
11309 "could not acquire SWSM SWESMBI\n");
11310 /* Release semaphores */
11311 wm_put_swsm_semaphore(sc);
11312 return 1;
11313 }
11314 return 0;
11315 }
11316
11317 /*
11318 * Put hardware semaphore.
11319 * Same as e1000_put_hw_semaphore_generic()
11320 */
11321 static void
11322 wm_put_swsm_semaphore(struct wm_softc *sc)
11323 {
11324 uint32_t swsm;
11325
11326 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11327 device_xname(sc->sc_dev), __func__));
11328
11329 swsm = CSR_READ(sc, WMREG_SWSM);
11330 swsm &= ~(SWSM_SMBI | SWSM_SWESMBI);
11331 CSR_WRITE(sc, WMREG_SWSM, swsm);
11332 }
11333
11334 /*
11335 * Get SW/FW semaphore.
11336 * Same as e1000_acquire_swfw_sync_82575().
11337 */
11338 static int
11339 wm_get_swfw_semaphore(struct wm_softc *sc, uint16_t mask)
11340 {
11341 uint32_t swfw_sync;
11342 uint32_t swmask = mask << SWFW_SOFT_SHIFT;
11343 uint32_t fwmask = mask << SWFW_FIRM_SHIFT;
11344 int timeout = 200;
11345
11346 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11347 device_xname(sc->sc_dev), __func__));
11348 KASSERT((sc->sc_flags & WM_F_LOCK_SWSM) != 0);
11349
11350 for (timeout = 0; timeout < 200; timeout++) {
11351 if (sc->sc_flags & WM_F_LOCK_SWSM) {
11352 if (wm_get_swsm_semaphore(sc)) {
11353 aprint_error_dev(sc->sc_dev,
11354 "%s: failed to get semaphore\n",
11355 __func__);
11356 return 1;
11357 }
11358 }
11359 swfw_sync = CSR_READ(sc, WMREG_SW_FW_SYNC);
11360 if ((swfw_sync & (swmask | fwmask)) == 0) {
11361 swfw_sync |= swmask;
11362 CSR_WRITE(sc, WMREG_SW_FW_SYNC, swfw_sync);
11363 if (sc->sc_flags & WM_F_LOCK_SWSM)
11364 wm_put_swsm_semaphore(sc);
11365 return 0;
11366 }
11367 if (sc->sc_flags & WM_F_LOCK_SWSM)
11368 wm_put_swsm_semaphore(sc);
11369 delay(5000);
11370 }
11371 printf("%s: failed to get swfw semaphore mask 0x%x swfw 0x%x\n",
11372 device_xname(sc->sc_dev), mask, swfw_sync);
11373 return 1;
11374 }
11375
11376 static void
11377 wm_put_swfw_semaphore(struct wm_softc *sc, uint16_t mask)
11378 {
11379 uint32_t swfw_sync;
11380
11381 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11382 device_xname(sc->sc_dev), __func__));
11383 KASSERT((sc->sc_flags & WM_F_LOCK_SWSM) != 0);
11384
11385 if (sc->sc_flags & WM_F_LOCK_SWSM) {
11386 while (wm_get_swsm_semaphore(sc) != 0)
11387 continue;
11388 }
11389 swfw_sync = CSR_READ(sc, WMREG_SW_FW_SYNC);
11390 swfw_sync &= ~(mask << SWFW_SOFT_SHIFT);
11391 CSR_WRITE(sc, WMREG_SW_FW_SYNC, swfw_sync);
11392 if (sc->sc_flags & WM_F_LOCK_SWSM)
11393 wm_put_swsm_semaphore(sc);
11394 }
11395
11396 static int
11397 wm_get_phy_82575(struct wm_softc *sc)
11398 {
11399
11400 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11401 device_xname(sc->sc_dev), __func__));
11402 return wm_get_swfw_semaphore(sc, swfwphysem[sc->sc_funcid]);
11403 }
11404
11405 static void
11406 wm_put_phy_82575(struct wm_softc *sc)
11407 {
11408
11409 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11410 device_xname(sc->sc_dev), __func__));
11411 return wm_put_swfw_semaphore(sc, swfwphysem[sc->sc_funcid]);
11412 }
11413
11414 static int
11415 wm_get_swfwhw_semaphore(struct wm_softc *sc)
11416 {
11417 uint32_t ext_ctrl;
11418 int timeout = 200;
11419
11420 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11421 device_xname(sc->sc_dev), __func__));
11422
11423 mutex_enter(sc->sc_ich_phymtx); /* Use PHY mtx for both PHY and NVM */
11424 for (timeout = 0; timeout < 200; timeout++) {
11425 ext_ctrl = CSR_READ(sc, WMREG_EXTCNFCTR);
11426 ext_ctrl |= EXTCNFCTR_MDIO_SW_OWNERSHIP;
11427 CSR_WRITE(sc, WMREG_EXTCNFCTR, ext_ctrl);
11428
11429 ext_ctrl = CSR_READ(sc, WMREG_EXTCNFCTR);
11430 if (ext_ctrl & EXTCNFCTR_MDIO_SW_OWNERSHIP)
11431 return 0;
11432 delay(5000);
11433 }
11434 printf("%s: failed to get swfwhw semaphore ext_ctrl 0x%x\n",
11435 device_xname(sc->sc_dev), ext_ctrl);
11436 mutex_exit(sc->sc_ich_phymtx); /* Use PHY mtx for both PHY and NVM */
11437 return 1;
11438 }
11439
11440 static void
11441 wm_put_swfwhw_semaphore(struct wm_softc *sc)
11442 {
11443 uint32_t ext_ctrl;
11444
11445 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11446 device_xname(sc->sc_dev), __func__));
11447
11448 ext_ctrl = CSR_READ(sc, WMREG_EXTCNFCTR);
11449 ext_ctrl &= ~EXTCNFCTR_MDIO_SW_OWNERSHIP;
11450 CSR_WRITE(sc, WMREG_EXTCNFCTR, ext_ctrl);
11451
11452 mutex_exit(sc->sc_ich_phymtx); /* Use PHY mtx for both PHY and NVM */
11453 }
11454
11455 static int
11456 wm_get_swflag_ich8lan(struct wm_softc *sc)
11457 {
11458 uint32_t ext_ctrl;
11459 int timeout;
11460
11461 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11462 device_xname(sc->sc_dev), __func__));
11463 mutex_enter(sc->sc_ich_phymtx);
11464 for (timeout = 0; timeout < WM_PHY_CFG_TIMEOUT; timeout++) {
11465 ext_ctrl = CSR_READ(sc, WMREG_EXTCNFCTR);
11466 if ((ext_ctrl & EXTCNFCTR_MDIO_SW_OWNERSHIP) == 0)
11467 break;
11468 delay(1000);
11469 }
11470 if (timeout >= WM_PHY_CFG_TIMEOUT) {
11471 printf("%s: SW has already locked the resource\n",
11472 device_xname(sc->sc_dev));
11473 goto out;
11474 }
11475
11476 ext_ctrl |= EXTCNFCTR_MDIO_SW_OWNERSHIP;
11477 CSR_WRITE(sc, WMREG_EXTCNFCTR, ext_ctrl);
11478 for (timeout = 0; timeout < 1000; timeout++) {
11479 ext_ctrl = CSR_READ(sc, WMREG_EXTCNFCTR);
11480 if (ext_ctrl & EXTCNFCTR_MDIO_SW_OWNERSHIP)
11481 break;
11482 delay(1000);
11483 }
11484 if (timeout >= 1000) {
11485 printf("%s: failed to acquire semaphore\n",
11486 device_xname(sc->sc_dev));
11487 ext_ctrl &= ~EXTCNFCTR_MDIO_SW_OWNERSHIP;
11488 CSR_WRITE(sc, WMREG_EXTCNFCTR, ext_ctrl);
11489 goto out;
11490 }
11491 return 0;
11492
11493 out:
11494 mutex_exit(sc->sc_ich_phymtx);
11495 return 1;
11496 }
11497
11498 static void
11499 wm_put_swflag_ich8lan(struct wm_softc *sc)
11500 {
11501 uint32_t ext_ctrl;
11502
11503 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11504 device_xname(sc->sc_dev), __func__));
11505 ext_ctrl = CSR_READ(sc, WMREG_EXTCNFCTR);
11506 if (ext_ctrl & EXTCNFCTR_MDIO_SW_OWNERSHIP) {
11507 ext_ctrl &= ~EXTCNFCTR_MDIO_SW_OWNERSHIP;
11508 CSR_WRITE(sc, WMREG_EXTCNFCTR, ext_ctrl);
11509 } else {
11510 printf("%s: Semaphore unexpectedly released\n",
11511 device_xname(sc->sc_dev));
11512 }
11513
11514 mutex_exit(sc->sc_ich_phymtx);
11515 }
11516
11517 static int
11518 wm_get_nvm_ich8lan(struct wm_softc *sc)
11519 {
11520
11521 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11522 device_xname(sc->sc_dev), __func__));
11523 mutex_enter(sc->sc_ich_nvmmtx);
11524
11525 return 0;
11526 }
11527
11528 static void
11529 wm_put_nvm_ich8lan(struct wm_softc *sc)
11530 {
11531
11532 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11533 device_xname(sc->sc_dev), __func__));
11534 mutex_exit(sc->sc_ich_nvmmtx);
11535 }
11536
11537 static int
11538 wm_get_hw_semaphore_82573(struct wm_softc *sc)
11539 {
11540 int i = 0;
11541 uint32_t reg;
11542
11543 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11544 device_xname(sc->sc_dev), __func__));
11545
11546 reg = CSR_READ(sc, WMREG_EXTCNFCTR);
11547 do {
11548 CSR_WRITE(sc, WMREG_EXTCNFCTR,
11549 reg | EXTCNFCTR_MDIO_SW_OWNERSHIP);
11550 reg = CSR_READ(sc, WMREG_EXTCNFCTR);
11551 if ((reg & EXTCNFCTR_MDIO_SW_OWNERSHIP) != 0)
11552 break;
11553 delay(2*1000);
11554 i++;
11555 } while (i < WM_MDIO_OWNERSHIP_TIMEOUT);
11556
11557 if (i == WM_MDIO_OWNERSHIP_TIMEOUT) {
11558 wm_put_hw_semaphore_82573(sc);
11559 log(LOG_ERR, "%s: Driver can't access the PHY\n",
11560 device_xname(sc->sc_dev));
11561 return -1;
11562 }
11563
11564 return 0;
11565 }
11566
11567 static void
11568 wm_put_hw_semaphore_82573(struct wm_softc *sc)
11569 {
11570 uint32_t reg;
11571
11572 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11573 device_xname(sc->sc_dev), __func__));
11574
11575 reg = CSR_READ(sc, WMREG_EXTCNFCTR);
11576 reg &= ~EXTCNFCTR_MDIO_SW_OWNERSHIP;
11577 CSR_WRITE(sc, WMREG_EXTCNFCTR, reg);
11578 }
11579
11580 /*
11581 * Management mode and power management related subroutines.
11582 * BMC, AMT, suspend/resume and EEE.
11583 */
11584
11585 #ifdef WM_WOL
11586 static int
11587 wm_check_mng_mode(struct wm_softc *sc)
11588 {
11589 int rv;
11590
11591 switch (sc->sc_type) {
11592 case WM_T_ICH8:
11593 case WM_T_ICH9:
11594 case WM_T_ICH10:
11595 case WM_T_PCH:
11596 case WM_T_PCH2:
11597 case WM_T_PCH_LPT:
11598 case WM_T_PCH_SPT:
11599 rv = wm_check_mng_mode_ich8lan(sc);
11600 break;
11601 case WM_T_82574:
11602 case WM_T_82583:
11603 rv = wm_check_mng_mode_82574(sc);
11604 break;
11605 case WM_T_82571:
11606 case WM_T_82572:
11607 case WM_T_82573:
11608 case WM_T_80003:
11609 rv = wm_check_mng_mode_generic(sc);
11610 break;
11611 default:
11612 /* noting to do */
11613 rv = 0;
11614 break;
11615 }
11616
11617 return rv;
11618 }
11619
11620 static int
11621 wm_check_mng_mode_ich8lan(struct wm_softc *sc)
11622 {
11623 uint32_t fwsm;
11624
11625 fwsm = CSR_READ(sc, WMREG_FWSM);
11626
11627 if (((fwsm & FWSM_FW_VALID) != 0)
11628 && (__SHIFTOUT(fwsm, FWSM_MODE) == MNG_ICH_IAMT_MODE))
11629 return 1;
11630
11631 return 0;
11632 }
11633
11634 static int
11635 wm_check_mng_mode_82574(struct wm_softc *sc)
11636 {
11637 uint16_t data;
11638
11639 wm_nvm_read(sc, NVM_OFF_CFG2, 1, &data);
11640
11641 if ((data & NVM_CFG2_MNGM_MASK) != 0)
11642 return 1;
11643
11644 return 0;
11645 }
11646
11647 static int
11648 wm_check_mng_mode_generic(struct wm_softc *sc)
11649 {
11650 uint32_t fwsm;
11651
11652 fwsm = CSR_READ(sc, WMREG_FWSM);
11653
11654 if (__SHIFTOUT(fwsm, FWSM_MODE) == MNG_IAMT_MODE)
11655 return 1;
11656
11657 return 0;
11658 }
11659 #endif /* WM_WOL */
11660
11661 static int
11662 wm_enable_mng_pass_thru(struct wm_softc *sc)
11663 {
11664 uint32_t manc, fwsm, factps;
11665
11666 if ((sc->sc_flags & WM_F_ASF_FIRMWARE_PRES) == 0)
11667 return 0;
11668
11669 manc = CSR_READ(sc, WMREG_MANC);
11670
11671 DPRINTF(WM_DEBUG_MANAGE, ("%s: MANC (%08x)\n",
11672 device_xname(sc->sc_dev), manc));
11673 if ((manc & MANC_RECV_TCO_EN) == 0)
11674 return 0;
11675
11676 if ((sc->sc_flags & WM_F_ARC_SUBSYS_VALID) != 0) {
11677 fwsm = CSR_READ(sc, WMREG_FWSM);
11678 factps = CSR_READ(sc, WMREG_FACTPS);
11679 if (((factps & FACTPS_MNGCG) == 0)
11680 && (__SHIFTOUT(fwsm, FWSM_MODE) == MNG_ICH_IAMT_MODE))
11681 return 1;
11682 } else if ((sc->sc_type == WM_T_82574) || (sc->sc_type == WM_T_82583)){
11683 uint16_t data;
11684
11685 factps = CSR_READ(sc, WMREG_FACTPS);
11686 wm_nvm_read(sc, NVM_OFF_CFG2, 1, &data);
11687 DPRINTF(WM_DEBUG_MANAGE, ("%s: FACTPS = %08x, CFG2=%04x\n",
11688 device_xname(sc->sc_dev), factps, data));
11689 if (((factps & FACTPS_MNGCG) == 0)
11690 && ((data & NVM_CFG2_MNGM_MASK)
11691 == (NVM_CFG2_MNGM_PT << NVM_CFG2_MNGM_SHIFT)))
11692 return 1;
11693 } else if (((manc & MANC_SMBUS_EN) != 0)
11694 && ((manc & MANC_ASF_EN) == 0))
11695 return 1;
11696
11697 return 0;
11698 }
11699
11700 static bool
11701 wm_phy_resetisblocked(struct wm_softc *sc)
11702 {
11703 bool blocked = false;
11704 uint32_t reg;
11705 int i = 0;
11706
11707 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
11708 device_xname(sc->sc_dev), __func__));
11709
11710 switch (sc->sc_type) {
11711 case WM_T_ICH8:
11712 case WM_T_ICH9:
11713 case WM_T_ICH10:
11714 case WM_T_PCH:
11715 case WM_T_PCH2:
11716 case WM_T_PCH_LPT:
11717 case WM_T_PCH_SPT:
11718 do {
11719 reg = CSR_READ(sc, WMREG_FWSM);
11720 if ((reg & FWSM_RSPCIPHY) == 0) {
11721 blocked = true;
11722 delay(10*1000);
11723 continue;
11724 }
11725 blocked = false;
11726 } while (blocked && (i++ < 30));
11727 return blocked;
11728 break;
11729 case WM_T_82571:
11730 case WM_T_82572:
11731 case WM_T_82573:
11732 case WM_T_82574:
11733 case WM_T_82583:
11734 case WM_T_80003:
11735 reg = CSR_READ(sc, WMREG_MANC);
11736 if ((reg & MANC_BLK_PHY_RST_ON_IDE) != 0)
11737 return true;
11738 else
11739 return false;
11740 break;
11741 default:
11742 /* no problem */
11743 break;
11744 }
11745
11746 return false;
11747 }
11748
11749 static void
11750 wm_get_hw_control(struct wm_softc *sc)
11751 {
11752 uint32_t reg;
11753
11754 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11755 device_xname(sc->sc_dev), __func__));
11756
11757 switch (sc->sc_type) {
11758 case WM_T_82573:
11759 reg = CSR_READ(sc, WMREG_SWSM);
11760 CSR_WRITE(sc, WMREG_SWSM, reg | SWSM_DRV_LOAD);
11761 break;
11762 case WM_T_82571:
11763 case WM_T_82572:
11764 case WM_T_82574:
11765 case WM_T_82583:
11766 case WM_T_80003:
11767 case WM_T_ICH8:
11768 case WM_T_ICH9:
11769 case WM_T_ICH10:
11770 case WM_T_PCH:
11771 case WM_T_PCH2:
11772 case WM_T_PCH_LPT:
11773 case WM_T_PCH_SPT:
11774 reg = CSR_READ(sc, WMREG_CTRL_EXT);
11775 CSR_WRITE(sc, WMREG_CTRL_EXT, reg | CTRL_EXT_DRV_LOAD);
11776 break;
11777 default:
11778 break;
11779 }
11780 }
11781
11782 static void
11783 wm_release_hw_control(struct wm_softc *sc)
11784 {
11785 uint32_t reg;
11786
11787 DPRINTF(WM_DEBUG_LOCK, ("%s: %s called\n",
11788 device_xname(sc->sc_dev), __func__));
11789
11790 if ((sc->sc_flags & WM_F_HAS_MANAGE) == 0)
11791 return;
11792
11793 if (sc->sc_type == WM_T_82573) {
11794 reg = CSR_READ(sc, WMREG_SWSM);
11795 reg &= ~SWSM_DRV_LOAD;
11796 CSR_WRITE(sc, WMREG_SWSM, reg & ~SWSM_DRV_LOAD);
11797 } else {
11798 reg = CSR_READ(sc, WMREG_CTRL_EXT);
11799 CSR_WRITE(sc, WMREG_CTRL_EXT, reg & ~CTRL_EXT_DRV_LOAD);
11800 }
11801 }
11802
11803 static void
11804 wm_gate_hw_phy_config_ich8lan(struct wm_softc *sc, bool gate)
11805 {
11806 uint32_t reg;
11807
11808 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
11809 device_xname(sc->sc_dev), __func__));
11810
11811 if (sc->sc_type < WM_T_PCH2)
11812 return;
11813
11814 reg = CSR_READ(sc, WMREG_EXTCNFCTR);
11815
11816 if (gate)
11817 reg |= EXTCNFCTR_GATE_PHY_CFG;
11818 else
11819 reg &= ~EXTCNFCTR_GATE_PHY_CFG;
11820
11821 CSR_WRITE(sc, WMREG_EXTCNFCTR, reg);
11822 }
11823
11824 static void
11825 wm_smbustopci(struct wm_softc *sc)
11826 {
11827 uint32_t fwsm, reg;
11828
11829 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
11830 device_xname(sc->sc_dev), __func__));
11831
11832 /* Gate automatic PHY configuration by hardware on non-managed 82579 */
11833 wm_gate_hw_phy_config_ich8lan(sc, true);
11834
11835 /* Acquire PHY semaphore */
11836 sc->phy.acquire(sc);
11837
11838 fwsm = CSR_READ(sc, WMREG_FWSM);
11839 if (((fwsm & FWSM_FW_VALID) == 0)
11840 && ((wm_phy_resetisblocked(sc) == false))) {
11841 if (sc->sc_type >= WM_T_PCH_LPT) {
11842 reg = CSR_READ(sc, WMREG_CTRL_EXT);
11843 reg |= CTRL_EXT_FORCE_SMBUS;
11844 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
11845 CSR_WRITE_FLUSH(sc);
11846 delay(50*1000);
11847 }
11848
11849 /* Toggle LANPHYPC */
11850 sc->sc_ctrl |= CTRL_LANPHYPC_OVERRIDE;
11851 sc->sc_ctrl &= ~CTRL_LANPHYPC_VALUE;
11852 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
11853 CSR_WRITE_FLUSH(sc);
11854 delay(1000);
11855 sc->sc_ctrl &= ~CTRL_LANPHYPC_OVERRIDE;
11856 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl);
11857 CSR_WRITE_FLUSH(sc);
11858 delay(50*1000);
11859
11860 if (sc->sc_type >= WM_T_PCH_LPT) {
11861 reg = CSR_READ(sc, WMREG_CTRL_EXT);
11862 reg &= ~CTRL_EXT_FORCE_SMBUS;
11863 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
11864 }
11865 }
11866
11867 /* Release semaphore */
11868 sc->phy.release(sc);
11869
11870 /*
11871 * Ungate automatic PHY configuration by hardware on non-managed 82579
11872 */
11873 if ((sc->sc_type == WM_T_PCH2) && ((fwsm & FWSM_FW_VALID) == 0))
11874 wm_gate_hw_phy_config_ich8lan(sc, false);
11875 }
11876
11877 static void
11878 wm_init_manageability(struct wm_softc *sc)
11879 {
11880
11881 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
11882 device_xname(sc->sc_dev), __func__));
11883 if (sc->sc_flags & WM_F_HAS_MANAGE) {
11884 uint32_t manc2h = CSR_READ(sc, WMREG_MANC2H);
11885 uint32_t manc = CSR_READ(sc, WMREG_MANC);
11886
11887 /* Disable hardware interception of ARP */
11888 manc &= ~MANC_ARP_EN;
11889
11890 /* Enable receiving management packets to the host */
11891 if (sc->sc_type >= WM_T_82571) {
11892 manc |= MANC_EN_MNG2HOST;
11893 manc2h |= MANC2H_PORT_623| MANC2H_PORT_624;
11894 CSR_WRITE(sc, WMREG_MANC2H, manc2h);
11895 }
11896
11897 CSR_WRITE(sc, WMREG_MANC, manc);
11898 }
11899 }
11900
11901 static void
11902 wm_release_manageability(struct wm_softc *sc)
11903 {
11904
11905 if (sc->sc_flags & WM_F_HAS_MANAGE) {
11906 uint32_t manc = CSR_READ(sc, WMREG_MANC);
11907
11908 manc |= MANC_ARP_EN;
11909 if (sc->sc_type >= WM_T_82571)
11910 manc &= ~MANC_EN_MNG2HOST;
11911
11912 CSR_WRITE(sc, WMREG_MANC, manc);
11913 }
11914 }
11915
11916 static void
11917 wm_get_wakeup(struct wm_softc *sc)
11918 {
11919
11920 /* 0: HAS_AMT, ARC_SUBSYS_VALID, ASF_FIRMWARE_PRES */
11921 switch (sc->sc_type) {
11922 case WM_T_82573:
11923 case WM_T_82583:
11924 sc->sc_flags |= WM_F_HAS_AMT;
11925 /* FALLTHROUGH */
11926 case WM_T_80003:
11927 case WM_T_82541:
11928 case WM_T_82547:
11929 case WM_T_82571:
11930 case WM_T_82572:
11931 case WM_T_82574:
11932 case WM_T_82575:
11933 case WM_T_82576:
11934 case WM_T_82580:
11935 case WM_T_I350:
11936 case WM_T_I354:
11937 if ((CSR_READ(sc, WMREG_FWSM) & FWSM_MODE) != 0)
11938 sc->sc_flags |= WM_F_ARC_SUBSYS_VALID;
11939 sc->sc_flags |= WM_F_ASF_FIRMWARE_PRES;
11940 break;
11941 case WM_T_ICH8:
11942 case WM_T_ICH9:
11943 case WM_T_ICH10:
11944 case WM_T_PCH:
11945 case WM_T_PCH2:
11946 case WM_T_PCH_LPT:
11947 case WM_T_PCH_SPT: /* XXX only Q170 chipset? */
11948 sc->sc_flags |= WM_F_HAS_AMT;
11949 sc->sc_flags |= WM_F_ASF_FIRMWARE_PRES;
11950 break;
11951 default:
11952 break;
11953 }
11954
11955 /* 1: HAS_MANAGE */
11956 if (wm_enable_mng_pass_thru(sc) != 0)
11957 sc->sc_flags |= WM_F_HAS_MANAGE;
11958
11959 #ifdef WM_DEBUG
11960 printf("\n");
11961 if ((sc->sc_flags & WM_F_HAS_AMT) != 0)
11962 printf("HAS_AMT,");
11963 if ((sc->sc_flags & WM_F_ARC_SUBSYS_VALID) != 0)
11964 printf("ARC_SUBSYS_VALID,");
11965 if ((sc->sc_flags & WM_F_ASF_FIRMWARE_PRES) != 0)
11966 printf("ASF_FIRMWARE_PRES,");
11967 if ((sc->sc_flags & WM_F_HAS_MANAGE) != 0)
11968 printf("HAS_MANAGE,");
11969 printf("\n");
11970 #endif
11971 /*
11972 * Note that the WOL flags is set after the resetting of the eeprom
11973 * stuff
11974 */
11975 }
11976
11977 #ifdef WM_WOL
11978 /* WOL in the newer chipset interfaces (pchlan) */
11979 static void
11980 wm_enable_phy_wakeup(struct wm_softc *sc)
11981 {
11982 #if 0
11983 uint16_t preg;
11984
11985 /* Copy MAC RARs to PHY RARs */
11986
11987 /* Copy MAC MTA to PHY MTA */
11988
11989 /* Configure PHY Rx Control register */
11990
11991 /* Enable PHY wakeup in MAC register */
11992
11993 /* Configure and enable PHY wakeup in PHY registers */
11994
11995 /* Activate PHY wakeup */
11996
11997 /* XXX */
11998 #endif
11999 }
12000
12001 /* Power down workaround on D3 */
12002 static void
12003 wm_igp3_phy_powerdown_workaround_ich8lan(struct wm_softc *sc)
12004 {
12005 uint32_t reg;
12006 int i;
12007
12008 for (i = 0; i < 2; i++) {
12009 /* Disable link */
12010 reg = CSR_READ(sc, WMREG_PHY_CTRL);
12011 reg |= PHY_CTRL_GBE_DIS | PHY_CTRL_NOND0A_GBE_DIS;
12012 CSR_WRITE(sc, WMREG_PHY_CTRL, reg);
12013
12014 /*
12015 * Call gig speed drop workaround on Gig disable before
12016 * accessing any PHY registers
12017 */
12018 if (sc->sc_type == WM_T_ICH8)
12019 wm_gig_downshift_workaround_ich8lan(sc);
12020
12021 /* Write VR power-down enable */
12022 reg = sc->sc_mii.mii_readreg(sc->sc_dev, 1, IGP3_VR_CTRL);
12023 reg &= ~IGP3_VR_CTRL_DEV_POWERDOWN_MODE_MASK;
12024 reg |= IGP3_VR_CTRL_MODE_SHUTDOWN;
12025 sc->sc_mii.mii_writereg(sc->sc_dev, 1, IGP3_VR_CTRL, reg);
12026
12027 /* Read it back and test */
12028 reg = sc->sc_mii.mii_readreg(sc->sc_dev, 1, IGP3_VR_CTRL);
12029 reg &= IGP3_VR_CTRL_DEV_POWERDOWN_MODE_MASK;
12030 if ((reg == IGP3_VR_CTRL_MODE_SHUTDOWN) || (i != 0))
12031 break;
12032
12033 /* Issue PHY reset and repeat at most one more time */
12034 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl | CTRL_PHY_RESET);
12035 }
12036 }
12037
12038 static void
12039 wm_enable_wakeup(struct wm_softc *sc)
12040 {
12041 uint32_t reg, pmreg;
12042 pcireg_t pmode;
12043
12044 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
12045 device_xname(sc->sc_dev), __func__));
12046
12047 if (pci_get_capability(sc->sc_pc, sc->sc_pcitag, PCI_CAP_PWRMGMT,
12048 &pmreg, NULL) == 0)
12049 return;
12050
12051 /* Advertise the wakeup capability */
12052 CSR_WRITE(sc, WMREG_CTRL, sc->sc_ctrl | CTRL_SWDPIN(2)
12053 | CTRL_SWDPIN(3));
12054 CSR_WRITE(sc, WMREG_WUC, WUC_APME);
12055
12056 /* ICH workaround */
12057 switch (sc->sc_type) {
12058 case WM_T_ICH8:
12059 case WM_T_ICH9:
12060 case WM_T_ICH10:
12061 case WM_T_PCH:
12062 case WM_T_PCH2:
12063 case WM_T_PCH_LPT:
12064 case WM_T_PCH_SPT:
12065 /* Disable gig during WOL */
12066 reg = CSR_READ(sc, WMREG_PHY_CTRL);
12067 reg |= PHY_CTRL_D0A_LPLU | PHY_CTRL_GBE_DIS;
12068 CSR_WRITE(sc, WMREG_PHY_CTRL, reg);
12069 if (sc->sc_type == WM_T_PCH)
12070 wm_gmii_reset(sc);
12071
12072 /* Power down workaround */
12073 if (sc->sc_phytype == WMPHY_82577) {
12074 struct mii_softc *child;
12075
12076 /* Assume that the PHY is copper */
12077 child = LIST_FIRST(&sc->sc_mii.mii_phys);
12078 if (child->mii_mpd_rev <= 2)
12079 sc->sc_mii.mii_writereg(sc->sc_dev, 1,
12080 (768 << 5) | 25, 0x0444); /* magic num */
12081 }
12082 break;
12083 default:
12084 break;
12085 }
12086
12087 /* Keep the laser running on fiber adapters */
12088 if ((sc->sc_mediatype == WM_MEDIATYPE_FIBER)
12089 || (sc->sc_mediatype == WM_MEDIATYPE_SERDES)) {
12090 reg = CSR_READ(sc, WMREG_CTRL_EXT);
12091 reg |= CTRL_EXT_SWDPIN(3);
12092 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
12093 }
12094
12095 reg = CSR_READ(sc, WMREG_WUFC) | WUFC_MAG;
12096 #if 0 /* for the multicast packet */
12097 reg |= WUFC_MC;
12098 CSR_WRITE(sc, WMREG_RCTL, CSR_READ(sc, WMREG_RCTL) | RCTL_MPE);
12099 #endif
12100
12101 if (sc->sc_type == WM_T_PCH) {
12102 wm_enable_phy_wakeup(sc);
12103 } else {
12104 CSR_WRITE(sc, WMREG_WUC, WUC_PME_EN);
12105 CSR_WRITE(sc, WMREG_WUFC, reg);
12106 }
12107
12108 if (((sc->sc_type == WM_T_ICH8) || (sc->sc_type == WM_T_ICH9)
12109 || (sc->sc_type == WM_T_ICH10) || (sc->sc_type == WM_T_PCH)
12110 || (sc->sc_type == WM_T_PCH2))
12111 && (sc->sc_phytype == WMPHY_IGP_3))
12112 wm_igp3_phy_powerdown_workaround_ich8lan(sc);
12113
12114 /* Request PME */
12115 pmode = pci_conf_read(sc->sc_pc, sc->sc_pcitag, pmreg + PCI_PMCSR);
12116 #if 0
12117 /* Disable WOL */
12118 pmode &= ~(PCI_PMCSR_PME_STS | PCI_PMCSR_PME_EN);
12119 #else
12120 /* For WOL */
12121 pmode |= PCI_PMCSR_PME_STS | PCI_PMCSR_PME_EN;
12122 #endif
12123 pci_conf_write(sc->sc_pc, sc->sc_pcitag, pmreg + PCI_PMCSR, pmode);
12124 }
12125 #endif /* WM_WOL */
12126
12127 /* LPLU */
12128
12129 static void
12130 wm_lplu_d0_disable(struct wm_softc *sc)
12131 {
12132 uint32_t reg;
12133
12134 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
12135 device_xname(sc->sc_dev), __func__));
12136
12137 reg = CSR_READ(sc, WMREG_PHY_CTRL);
12138 reg &= ~(PHY_CTRL_GBE_DIS | PHY_CTRL_D0A_LPLU);
12139 CSR_WRITE(sc, WMREG_PHY_CTRL, reg);
12140 }
12141
12142 static void
12143 wm_lplu_d0_disable_pch(struct wm_softc *sc)
12144 {
12145 uint32_t reg;
12146
12147 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
12148 device_xname(sc->sc_dev), __func__));
12149
12150 reg = wm_gmii_hv_readreg(sc->sc_dev, 1, HV_OEM_BITS);
12151 reg &= ~(HV_OEM_BITS_A1KDIS | HV_OEM_BITS_LPLU);
12152 reg |= HV_OEM_BITS_ANEGNOW;
12153 wm_gmii_hv_writereg(sc->sc_dev, 1, HV_OEM_BITS, reg);
12154 }
12155
12156 /* EEE */
12157
12158 static void
12159 wm_set_eee_i350(struct wm_softc *sc)
12160 {
12161 uint32_t ipcnfg, eeer;
12162
12163 ipcnfg = CSR_READ(sc, WMREG_IPCNFG);
12164 eeer = CSR_READ(sc, WMREG_EEER);
12165
12166 if ((sc->sc_flags & WM_F_EEE) != 0) {
12167 ipcnfg |= (IPCNFG_EEE_1G_AN | IPCNFG_EEE_100M_AN);
12168 eeer |= (EEER_TX_LPI_EN | EEER_RX_LPI_EN
12169 | EEER_LPI_FC);
12170 } else {
12171 ipcnfg &= ~(IPCNFG_EEE_1G_AN | IPCNFG_EEE_100M_AN);
12172 ipcnfg &= ~IPCNFG_10BASE_TE;
12173 eeer &= ~(EEER_TX_LPI_EN | EEER_RX_LPI_EN
12174 | EEER_LPI_FC);
12175 }
12176
12177 CSR_WRITE(sc, WMREG_IPCNFG, ipcnfg);
12178 CSR_WRITE(sc, WMREG_EEER, eeer);
12179 CSR_READ(sc, WMREG_IPCNFG); /* XXX flush? */
12180 CSR_READ(sc, WMREG_EEER); /* XXX flush? */
12181 }
12182
12183 /*
12184 * Workarounds (mainly PHY related).
12185 * Basically, PHY's workarounds are in the PHY drivers.
12186 */
12187
12188 /* Work-around for 82566 Kumeran PCS lock loss */
12189 static void
12190 wm_kmrn_lock_loss_workaround_ich8lan(struct wm_softc *sc)
12191 {
12192 #if 0
12193 int miistatus, active, i;
12194 int reg;
12195
12196 miistatus = sc->sc_mii.mii_media_status;
12197
12198 /* If the link is not up, do nothing */
12199 if ((miistatus & IFM_ACTIVE) == 0)
12200 return;
12201
12202 active = sc->sc_mii.mii_media_active;
12203
12204 /* Nothing to do if the link is other than 1Gbps */
12205 if (IFM_SUBTYPE(active) != IFM_1000_T)
12206 return;
12207
12208 for (i = 0; i < 10; i++) {
12209 /* read twice */
12210 reg = wm_gmii_i80003_readreg(sc->sc_dev, 1, IGP3_KMRN_DIAG);
12211 reg = wm_gmii_i80003_readreg(sc->sc_dev, 1, IGP3_KMRN_DIAG);
12212 if ((reg & IGP3_KMRN_DIAG_PCS_LOCK_LOSS) == 0)
12213 goto out; /* GOOD! */
12214
12215 /* Reset the PHY */
12216 wm_gmii_reset(sc);
12217 delay(5*1000);
12218 }
12219
12220 /* Disable GigE link negotiation */
12221 reg = CSR_READ(sc, WMREG_PHY_CTRL);
12222 reg |= PHY_CTRL_GBE_DIS | PHY_CTRL_NOND0A_GBE_DIS;
12223 CSR_WRITE(sc, WMREG_PHY_CTRL, reg);
12224
12225 /*
12226 * Call gig speed drop workaround on Gig disable before accessing
12227 * any PHY registers.
12228 */
12229 wm_gig_downshift_workaround_ich8lan(sc);
12230
12231 out:
12232 return;
12233 #endif
12234 }
12235
12236 /* WOL from S5 stops working */
12237 static void
12238 wm_gig_downshift_workaround_ich8lan(struct wm_softc *sc)
12239 {
12240 uint16_t kmrn_reg;
12241
12242 /* Only for igp3 */
12243 if (sc->sc_phytype == WMPHY_IGP_3) {
12244 kmrn_reg = wm_kmrn_readreg(sc, KUMCTRLSTA_OFFSET_DIAG);
12245 kmrn_reg |= KUMCTRLSTA_DIAG_NELPBK;
12246 wm_kmrn_writereg(sc, KUMCTRLSTA_OFFSET_DIAG, kmrn_reg);
12247 kmrn_reg &= ~KUMCTRLSTA_DIAG_NELPBK;
12248 wm_kmrn_writereg(sc, KUMCTRLSTA_OFFSET_DIAG, kmrn_reg);
12249 }
12250 }
12251
12252 /*
12253 * Workaround for pch's PHYs
12254 * XXX should be moved to new PHY driver?
12255 */
12256 static void
12257 wm_hv_phy_workaround_ich8lan(struct wm_softc *sc)
12258 {
12259
12260 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
12261 device_xname(sc->sc_dev), __func__));
12262 KASSERT(sc->sc_type == WM_T_PCH);
12263
12264 if (sc->sc_phytype == WMPHY_82577)
12265 wm_set_mdio_slow_mode_hv(sc);
12266
12267 /* (PCH rev.2) && (82577 && (phy rev 2 or 3)) */
12268
12269 /* (82577 && (phy rev 1 or 2)) || (82578 & phy rev 1)*/
12270
12271 /* 82578 */
12272 if (sc->sc_phytype == WMPHY_82578) {
12273 struct mii_softc *child;
12274
12275 /*
12276 * Return registers to default by doing a soft reset then
12277 * writing 0x3140 to the control register
12278 * 0x3140 == BMCR_SPEED0 | BMCR_AUTOEN | BMCR_FDX | BMCR_SPEED1
12279 */
12280 child = LIST_FIRST(&sc->sc_mii.mii_phys);
12281 if ((child != NULL) && (child->mii_mpd_rev < 2)) {
12282 PHY_RESET(child);
12283 sc->sc_mii.mii_writereg(sc->sc_dev, 2, MII_BMCR,
12284 0x3140);
12285 }
12286 }
12287
12288 /* Select page 0 */
12289 sc->phy.acquire(sc);
12290 wm_gmii_mdic_writereg(sc->sc_dev, 1, MII_IGPHY_PAGE_SELECT, 0);
12291 sc->phy.release(sc);
12292
12293 /*
12294 * Configure the K1 Si workaround during phy reset assuming there is
12295 * link so that it disables K1 if link is in 1Gbps.
12296 */
12297 wm_k1_gig_workaround_hv(sc, 1);
12298 }
12299
12300 static void
12301 wm_lv_phy_workaround_ich8lan(struct wm_softc *sc)
12302 {
12303
12304 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
12305 device_xname(sc->sc_dev), __func__));
12306 KASSERT(sc->sc_type == WM_T_PCH2);
12307
12308 wm_set_mdio_slow_mode_hv(sc);
12309 }
12310
12311 static int
12312 wm_k1_gig_workaround_hv(struct wm_softc *sc, int link)
12313 {
12314 int k1_enable = sc->sc_nvm_k1_enabled;
12315
12316 DPRINTF(WM_DEBUG_INIT, ("%s: %s called\n",
12317 device_xname(sc->sc_dev), __func__));
12318
12319 if (sc->phy.acquire(sc) != 0)
12320 return -1;
12321
12322 if (link) {
12323 k1_enable = 0;
12324
12325 /* Link stall fix for link up */
12326 wm_gmii_hv_writereg_locked(sc->sc_dev, 1, IGP3_KMRN_DIAG, 0x0100);
12327 } else {
12328 /* Link stall fix for link down */
12329 wm_gmii_hv_writereg_locked(sc->sc_dev, 1, IGP3_KMRN_DIAG, 0x4100);
12330 }
12331
12332 wm_configure_k1_ich8lan(sc, k1_enable);
12333 sc->phy.release(sc);
12334
12335 return 0;
12336 }
12337
12338 static void
12339 wm_set_mdio_slow_mode_hv(struct wm_softc *sc)
12340 {
12341 uint32_t reg;
12342
12343 reg = wm_gmii_hv_readreg(sc->sc_dev, 1, HV_KMRN_MODE_CTRL);
12344 wm_gmii_hv_writereg(sc->sc_dev, 1, HV_KMRN_MODE_CTRL,
12345 reg | HV_KMRN_MDIO_SLOW);
12346 }
12347
12348 static void
12349 wm_configure_k1_ich8lan(struct wm_softc *sc, int k1_enable)
12350 {
12351 uint32_t ctrl, ctrl_ext, tmp;
12352 uint16_t kmrn_reg;
12353
12354 kmrn_reg = wm_kmrn_readreg_locked(sc, KUMCTRLSTA_OFFSET_K1_CONFIG);
12355
12356 if (k1_enable)
12357 kmrn_reg |= KUMCTRLSTA_K1_ENABLE;
12358 else
12359 kmrn_reg &= ~KUMCTRLSTA_K1_ENABLE;
12360
12361 wm_kmrn_writereg_locked(sc, KUMCTRLSTA_OFFSET_K1_CONFIG, kmrn_reg);
12362
12363 delay(20);
12364
12365 ctrl = CSR_READ(sc, WMREG_CTRL);
12366 ctrl_ext = CSR_READ(sc, WMREG_CTRL_EXT);
12367
12368 tmp = ctrl & ~(CTRL_SPEED_1000 | CTRL_SPEED_100);
12369 tmp |= CTRL_FRCSPD;
12370
12371 CSR_WRITE(sc, WMREG_CTRL, tmp);
12372 CSR_WRITE(sc, WMREG_CTRL_EXT, ctrl_ext | CTRL_EXT_SPD_BYPS);
12373 CSR_WRITE_FLUSH(sc);
12374 delay(20);
12375
12376 CSR_WRITE(sc, WMREG_CTRL, ctrl);
12377 CSR_WRITE(sc, WMREG_CTRL_EXT, ctrl_ext);
12378 CSR_WRITE_FLUSH(sc);
12379 delay(20);
12380 }
12381
12382 /* special case - for 82575 - need to do manual init ... */
12383 static void
12384 wm_reset_init_script_82575(struct wm_softc *sc)
12385 {
12386 /*
12387 * remark: this is untested code - we have no board without EEPROM
12388 * same setup as mentioned int the FreeBSD driver for the i82575
12389 */
12390
12391 /* SerDes configuration via SERDESCTRL */
12392 wm_82575_write_8bit_ctlr_reg(sc, WMREG_SCTL, 0x00, 0x0c);
12393 wm_82575_write_8bit_ctlr_reg(sc, WMREG_SCTL, 0x01, 0x78);
12394 wm_82575_write_8bit_ctlr_reg(sc, WMREG_SCTL, 0x1b, 0x23);
12395 wm_82575_write_8bit_ctlr_reg(sc, WMREG_SCTL, 0x23, 0x15);
12396
12397 /* CCM configuration via CCMCTL register */
12398 wm_82575_write_8bit_ctlr_reg(sc, WMREG_CCMCTL, 0x14, 0x00);
12399 wm_82575_write_8bit_ctlr_reg(sc, WMREG_CCMCTL, 0x10, 0x00);
12400
12401 /* PCIe lanes configuration */
12402 wm_82575_write_8bit_ctlr_reg(sc, WMREG_GIOCTL, 0x00, 0xec);
12403 wm_82575_write_8bit_ctlr_reg(sc, WMREG_GIOCTL, 0x61, 0xdf);
12404 wm_82575_write_8bit_ctlr_reg(sc, WMREG_GIOCTL, 0x34, 0x05);
12405 wm_82575_write_8bit_ctlr_reg(sc, WMREG_GIOCTL, 0x2f, 0x81);
12406
12407 /* PCIe PLL Configuration */
12408 wm_82575_write_8bit_ctlr_reg(sc, WMREG_SCCTL, 0x02, 0x47);
12409 wm_82575_write_8bit_ctlr_reg(sc, WMREG_SCCTL, 0x14, 0x00);
12410 wm_82575_write_8bit_ctlr_reg(sc, WMREG_SCCTL, 0x10, 0x00);
12411 }
12412
12413 static void
12414 wm_reset_mdicnfg_82580(struct wm_softc *sc)
12415 {
12416 uint32_t reg;
12417 uint16_t nvmword;
12418 int rv;
12419
12420 if ((sc->sc_flags & WM_F_SGMII) == 0)
12421 return;
12422
12423 rv = wm_nvm_read(sc, NVM_OFF_LAN_FUNC_82580(sc->sc_funcid)
12424 + NVM_OFF_CFG3_PORTA, 1, &nvmword);
12425 if (rv != 0) {
12426 aprint_error_dev(sc->sc_dev, "%s: failed to read NVM\n",
12427 __func__);
12428 return;
12429 }
12430
12431 reg = CSR_READ(sc, WMREG_MDICNFG);
12432 if (nvmword & NVM_CFG3_PORTA_EXT_MDIO)
12433 reg |= MDICNFG_DEST;
12434 if (nvmword & NVM_CFG3_PORTA_COM_MDIO)
12435 reg |= MDICNFG_COM_MDIO;
12436 CSR_WRITE(sc, WMREG_MDICNFG, reg);
12437 }
12438
12439 /*
12440 * I210 Errata 25 and I211 Errata 10
12441 * Slow System Clock.
12442 */
12443 static void
12444 wm_pll_workaround_i210(struct wm_softc *sc)
12445 {
12446 uint32_t mdicnfg, wuc;
12447 uint32_t reg;
12448 pcireg_t pcireg;
12449 uint32_t pmreg;
12450 uint16_t nvmword, tmp_nvmword;
12451 int phyval;
12452 bool wa_done = false;
12453 int i;
12454
12455 /* Save WUC and MDICNFG registers */
12456 wuc = CSR_READ(sc, WMREG_WUC);
12457 mdicnfg = CSR_READ(sc, WMREG_MDICNFG);
12458
12459 reg = mdicnfg & ~MDICNFG_DEST;
12460 CSR_WRITE(sc, WMREG_MDICNFG, reg);
12461
12462 if (wm_nvm_read(sc, INVM_AUTOLOAD, 1, &nvmword) != 0)
12463 nvmword = INVM_DEFAULT_AL;
12464 tmp_nvmword = nvmword | INVM_PLL_WO_VAL;
12465
12466 /* Get Power Management cap offset */
12467 if (pci_get_capability(sc->sc_pc, sc->sc_pcitag, PCI_CAP_PWRMGMT,
12468 &pmreg, NULL) == 0)
12469 return;
12470 for (i = 0; i < WM_MAX_PLL_TRIES; i++) {
12471 phyval = wm_gmii_gs40g_readreg(sc->sc_dev, 1,
12472 GS40G_PHY_PLL_FREQ_PAGE | GS40G_PHY_PLL_FREQ_REG);
12473
12474 if ((phyval & GS40G_PHY_PLL_UNCONF) != GS40G_PHY_PLL_UNCONF) {
12475 break; /* OK */
12476 }
12477
12478 wa_done = true;
12479 /* Directly reset the internal PHY */
12480 reg = CSR_READ(sc, WMREG_CTRL);
12481 CSR_WRITE(sc, WMREG_CTRL, reg | CTRL_PHY_RESET);
12482
12483 reg = CSR_READ(sc, WMREG_CTRL_EXT);
12484 reg |= CTRL_EXT_PHYPDEN | CTRL_EXT_SDLPE;
12485 CSR_WRITE(sc, WMREG_CTRL_EXT, reg);
12486
12487 CSR_WRITE(sc, WMREG_WUC, 0);
12488 reg = (INVM_AUTOLOAD << 4) | (tmp_nvmword << 16);
12489 CSR_WRITE(sc, WMREG_EEARBC_I210, reg);
12490
12491 pcireg = pci_conf_read(sc->sc_pc, sc->sc_pcitag,
12492 pmreg + PCI_PMCSR);
12493 pcireg |= PCI_PMCSR_STATE_D3;
12494 pci_conf_write(sc->sc_pc, sc->sc_pcitag,
12495 pmreg + PCI_PMCSR, pcireg);
12496 delay(1000);
12497 pcireg &= ~PCI_PMCSR_STATE_D3;
12498 pci_conf_write(sc->sc_pc, sc->sc_pcitag,
12499 pmreg + PCI_PMCSR, pcireg);
12500
12501 reg = (INVM_AUTOLOAD << 4) | (nvmword << 16);
12502 CSR_WRITE(sc, WMREG_EEARBC_I210, reg);
12503
12504 /* Restore WUC register */
12505 CSR_WRITE(sc, WMREG_WUC, wuc);
12506 }
12507
12508 /* Restore MDICNFG setting */
12509 CSR_WRITE(sc, WMREG_MDICNFG, mdicnfg);
12510 if (wa_done)
12511 aprint_verbose_dev(sc->sc_dev, "I210 workaround done\n");
12512 }
12513