244718150d86656cba9245e509c465c5fad0c0af
[dragonfly.git] / sys / dev / netif / emx / if_emx.c
1 /*
2  * Copyright (c) 2004 Joerg Sonnenberger <joerg@bec.de>.  All rights reserved.
3  *
4  * Copyright (c) 2001-2008, Intel Corporation
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are met:
9  *
10  *  1. Redistributions of source code must retain the above copyright notice,
11  *     this list of conditions and the following disclaimer.
12  *
13  *  2. Redistributions in binary form must reproduce the above copyright
14  *     notice, this list of conditions and the following disclaimer in the
15  *     documentation and/or other materials provided with the distribution.
16  *
17  *  3. Neither the name of the Intel Corporation nor the names of its
18  *     contributors may be used to endorse or promote products derived from
19  *     this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31  * POSSIBILITY OF SUCH DAMAGE.
32  *
33  *
34  * Copyright (c) 2005 The DragonFly Project.  All rights reserved.
35  *
36  * This code is derived from software contributed to The DragonFly Project
37  * by Matthew Dillon <dillon@backplane.com>
38  *
39  * Redistribution and use in source and binary forms, with or without
40  * modification, are permitted provided that the following conditions
41  * are met:
42  *
43  * 1. Redistributions of source code must retain the above copyright
44  *    notice, this list of conditions and the following disclaimer.
45  * 2. Redistributions in binary form must reproduce the above copyright
46  *    notice, this list of conditions and the following disclaimer in
47  *    the documentation and/or other materials provided with the
48  *    distribution.
49  * 3. Neither the name of The DragonFly Project nor the names of its
50  *    contributors may be used to endorse or promote products derived
51  *    from this software without specific, prior written permission.
52  *
53  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
54  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
55  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
56  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
57  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
58  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
59  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
60  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
61  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
62  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
63  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64  * SUCH DAMAGE.
65  */
66
67 #include "opt_polling.h"
68 #include "opt_serializer.h"
69 #include "opt_emx.h"
70
71 #include <sys/param.h>
72 #include <sys/bus.h>
73 #include <sys/endian.h>
74 #include <sys/interrupt.h>
75 #include <sys/kernel.h>
76 #include <sys/ktr.h>
77 #include <sys/malloc.h>
78 #include <sys/mbuf.h>
79 #include <sys/proc.h>
80 #include <sys/rman.h>
81 #include <sys/serialize.h>
82 #include <sys/socket.h>
83 #include <sys/sockio.h>
84 #include <sys/sysctl.h>
85 #include <sys/systm.h>
86
87 #include <net/bpf.h>
88 #include <net/ethernet.h>
89 #include <net/if.h>
90 #include <net/if_arp.h>
91 #include <net/if_dl.h>
92 #include <net/if_media.h>
93 #include <net/ifq_var.h>
94 #include <net/vlan/if_vlan_var.h>
95 #include <net/vlan/if_vlan_ether.h>
96
97 #include <netinet/in_systm.h>
98 #include <netinet/in.h>
99 #include <netinet/ip.h>
100 #include <netinet/tcp.h>
101 #include <netinet/udp.h>
102
103 #include <bus/pci/pcivar.h>
104 #include <bus/pci/pcireg.h>
105
106 #include <dev/netif/ig_hal/e1000_api.h>
107 #include <dev/netif/ig_hal/e1000_82571.h>
108 #include <dev/netif/emx/if_emx.h>
109
110 #ifdef EMX_RSS_DEBUG
111 #define EMX_RSS_DPRINTF(sc, lvl, fmt, ...) \
112 do { \
113         if (sc->rss_debug > lvl) \
114                 if_printf(&sc->arpcom.ac_if, fmt, __VA_ARGS__); \
115 } while (0)
116 #else   /* !EMX_RSS_DEBUG */
117 #define EMX_RSS_DPRINTF(sc, lvl, fmt, ...)      ((void)0)
118 #endif  /* EMX_RSS_DEBUG */
119
120 #define EMX_NAME        "Intel(R) PRO/1000 "
121
122 #define EMX_DEVICE(id)  \
123         { EMX_VENDOR_ID, E1000_DEV_ID_##id, EMX_NAME #id }
124 #define EMX_DEVICE_NULL { 0, 0, NULL }
125
126 static const struct emx_device {
127         uint16_t        vid;
128         uint16_t        did;
129         const char      *desc;
130 } emx_devices[] = {
131         EMX_DEVICE(82571EB_COPPER),
132         EMX_DEVICE(82571EB_FIBER),
133         EMX_DEVICE(82571EB_SERDES),
134         EMX_DEVICE(82571EB_SERDES_DUAL),
135         EMX_DEVICE(82571EB_SERDES_QUAD),
136         EMX_DEVICE(82571EB_QUAD_COPPER),
137         EMX_DEVICE(82571EB_QUAD_COPPER_LP),
138         EMX_DEVICE(82571EB_QUAD_FIBER),
139         EMX_DEVICE(82571PT_QUAD_COPPER),
140
141         EMX_DEVICE(82572EI_COPPER),
142         EMX_DEVICE(82572EI_FIBER),
143         EMX_DEVICE(82572EI_SERDES),
144         EMX_DEVICE(82572EI),
145
146         EMX_DEVICE(82573E),
147         EMX_DEVICE(82573E_IAMT),
148         EMX_DEVICE(82573L),
149
150         EMX_DEVICE(80003ES2LAN_COPPER_SPT),
151         EMX_DEVICE(80003ES2LAN_SERDES_SPT),
152         EMX_DEVICE(80003ES2LAN_COPPER_DPT),
153         EMX_DEVICE(80003ES2LAN_SERDES_DPT),
154
155         EMX_DEVICE(82574L),
156
157         /* required last entry */
158         EMX_DEVICE_NULL
159 };
160
161 static int      emx_probe(device_t);
162 static int      emx_attach(device_t);
163 static int      emx_detach(device_t);
164 static int      emx_shutdown(device_t);
165 static int      emx_suspend(device_t);
166 static int      emx_resume(device_t);
167
168 static void     emx_init(void *);
169 static void     emx_stop(struct emx_softc *);
170 static int      emx_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
171 static void     emx_start(struct ifnet *);
172 #ifdef DEVICE_POLLING
173 static void     emx_poll(struct ifnet *, enum poll_cmd, int);
174 #endif
175 static void     emx_watchdog(struct ifnet *);
176 static void     emx_media_status(struct ifnet *, struct ifmediareq *);
177 static int      emx_media_change(struct ifnet *);
178 static void     emx_timer(void *);
179
180 static void     emx_intr(void *);
181 static void     emx_rxeof(struct emx_softc *, int, int);
182 static void     emx_txeof(struct emx_softc *);
183 static void     emx_tx_collect(struct emx_softc *);
184 static void     emx_tx_purge(struct emx_softc *);
185 static void     emx_enable_intr(struct emx_softc *);
186 static void     emx_disable_intr(struct emx_softc *);
187
188 static int      emx_dma_alloc(struct emx_softc *);
189 static void     emx_dma_free(struct emx_softc *);
190 static void     emx_init_tx_ring(struct emx_softc *);
191 static int      emx_init_rx_ring(struct emx_softc *, struct emx_rxdata *);
192 static void     emx_free_rx_ring(struct emx_softc *, struct emx_rxdata *);
193 static int      emx_create_tx_ring(struct emx_softc *);
194 static int      emx_create_rx_ring(struct emx_softc *, struct emx_rxdata *);
195 static void     emx_destroy_tx_ring(struct emx_softc *, int);
196 static void     emx_destroy_rx_ring(struct emx_softc *,
197                     struct emx_rxdata *, int);
198 static int      emx_newbuf(struct emx_softc *, struct emx_rxdata *, int, int);
199 static int      emx_encap(struct emx_softc *, struct mbuf **);
200 static int      emx_txcsum_pullup(struct emx_softc *, struct mbuf **);
201 static int      emx_txcsum(struct emx_softc *, struct mbuf *,
202                     uint32_t *, uint32_t *);
203
204 static int      emx_is_valid_eaddr(const uint8_t *);
205 static int      emx_hw_init(struct emx_softc *);
206 static void     emx_setup_ifp(struct emx_softc *);
207 static void     emx_init_tx_unit(struct emx_softc *);
208 static void     emx_init_rx_unit(struct emx_softc *);
209 static void     emx_update_stats(struct emx_softc *);
210 static void     emx_set_promisc(struct emx_softc *);
211 static void     emx_disable_promisc(struct emx_softc *);
212 static void     emx_set_multi(struct emx_softc *);
213 static void     emx_update_link_status(struct emx_softc *);
214 static void     emx_smartspeed(struct emx_softc *);
215
216 static void     emx_print_debug_info(struct emx_softc *);
217 static void     emx_print_nvm_info(struct emx_softc *);
218 static void     emx_print_hw_stats(struct emx_softc *);
219
220 static int      emx_sysctl_stats(SYSCTL_HANDLER_ARGS);
221 static int      emx_sysctl_debug_info(SYSCTL_HANDLER_ARGS);
222 static int      emx_sysctl_int_throttle(SYSCTL_HANDLER_ARGS);
223 static int      emx_sysctl_int_tx_nsegs(SYSCTL_HANDLER_ARGS);
224 static void     emx_add_sysctl(struct emx_softc *);
225
226 /* Management and WOL Support */
227 static void     emx_get_mgmt(struct emx_softc *);
228 static void     emx_rel_mgmt(struct emx_softc *);
229 static void     emx_get_hw_control(struct emx_softc *);
230 static void     emx_rel_hw_control(struct emx_softc *);
231 static void     emx_enable_wol(device_t);
232
233 static device_method_t emx_methods[] = {
234         /* Device interface */
235         DEVMETHOD(device_probe,         emx_probe),
236         DEVMETHOD(device_attach,        emx_attach),
237         DEVMETHOD(device_detach,        emx_detach),
238         DEVMETHOD(device_shutdown,      emx_shutdown),
239         DEVMETHOD(device_suspend,       emx_suspend),
240         DEVMETHOD(device_resume,        emx_resume),
241         { 0, 0 }
242 };
243
244 static driver_t emx_driver = {
245         "emx",
246         emx_methods,
247         sizeof(struct emx_softc),
248 };
249
250 static devclass_t emx_devclass;
251
252 DECLARE_DUMMY_MODULE(if_emx);
253 MODULE_DEPEND(emx, ig_hal, 1, 1, 1);
254 DRIVER_MODULE(if_emx, pci, emx_driver, emx_devclass, 0, 0);
255
256 /*
257  * Tunables
258  */
259 static int      emx_int_throttle_ceil = EMX_DEFAULT_ITR;
260 static int      emx_rxd = EMX_DEFAULT_RXD;
261 static int      emx_txd = EMX_DEFAULT_TXD;
262 static int      emx_smart_pwr_down = FALSE;
263 static int      emx_rss = FALSE;
264
265 /* Controls whether promiscuous also shows bad packets */
266 static int      emx_debug_sbp = FALSE;
267
268 static int      emx_82573_workaround = TRUE;
269
270 TUNABLE_INT("hw.emx.int_throttle_ceil", &emx_int_throttle_ceil);
271 TUNABLE_INT("hw.emx.rxd", &emx_rxd);
272 TUNABLE_INT("hw.emx.txd", &emx_txd);
273 TUNABLE_INT("hw.emx.smart_pwr_down", &emx_smart_pwr_down);
274 TUNABLE_INT("hw.emx.rss", &emx_rss);
275 TUNABLE_INT("hw.emx.sbp", &emx_debug_sbp);
276 TUNABLE_INT("hw.emx.82573_workaround", &emx_82573_workaround);
277
278 /* Global used in WOL setup with multiport cards */
279 static int      emx_global_quad_port_a = 0;
280
281 /* Set this to one to display debug statistics */
282 static int      emx_display_debug_stats = 0;
283
284 #if !defined(KTR_IF_EMX)
285 #define KTR_IF_EMX      KTR_ALL
286 #endif
287 KTR_INFO_MASTER(if_emx);
288 KTR_INFO(KTR_IF_EMX, if_emx, intr_beg, 0, "intr begin", 0);
289 KTR_INFO(KTR_IF_EMX, if_emx, intr_end, 1, "intr end", 0);
290 KTR_INFO(KTR_IF_EMX, if_emx, pkt_receive, 4, "rx packet", 0);
291 KTR_INFO(KTR_IF_EMX, if_emx, pkt_txqueue, 5, "tx packet", 0);
292 KTR_INFO(KTR_IF_EMX, if_emx, pkt_txclean, 6, "tx clean", 0);
293 #define logif(name)     KTR_LOG(if_emx_ ## name)
294
295 static __inline void
296 emx_setup_rxdesc(emx_rxdesc_t *rxd, const struct emx_rxbuf *rxbuf)
297 {
298         rxd->rxd_bufaddr = htole64(rxbuf->paddr);
299         /* DD bit must be cleared */
300         rxd->rxd_staterr = 0;
301 }
302
303 static __inline void
304 emx_rxcsum(uint32_t staterr, struct mbuf *mp)
305 {
306         /* Ignore Checksum bit is set */
307         if (staterr & E1000_RXD_STAT_IXSM)
308                 return;
309
310         if ((staterr & (E1000_RXD_STAT_IPCS | E1000_RXDEXT_STATERR_IPE)) ==
311             E1000_RXD_STAT_IPCS)
312                 mp->m_pkthdr.csum_flags |= CSUM_IP_CHECKED | CSUM_IP_VALID;
313
314         if ((staterr & (E1000_RXD_STAT_TCPCS | E1000_RXDEXT_STATERR_TCPE)) ==
315             E1000_RXD_STAT_TCPCS) {
316                 mp->m_pkthdr.csum_flags |= CSUM_DATA_VALID |
317                                            CSUM_PSEUDO_HDR |
318                                            CSUM_FRAG_NOT_CHECKED;
319                 mp->m_pkthdr.csum_data = htons(0xffff);
320         }
321 }
322
323 static int
324 emx_probe(device_t dev)
325 {
326         const struct emx_device *d;
327         uint16_t vid, did;
328
329         vid = pci_get_vendor(dev);
330         did = pci_get_device(dev);
331
332         for (d = emx_devices; d->desc != NULL; ++d) {
333                 if (vid == d->vid && did == d->did) {
334                         device_set_desc(dev, d->desc);
335                         device_set_async_attach(dev, TRUE);
336                         return 0;
337                 }
338         }
339         return ENXIO;
340 }
341
342 static int
343 emx_attach(device_t dev)
344 {
345         struct emx_softc *sc = device_get_softc(dev);
346         struct ifnet *ifp = &sc->arpcom.ac_if;
347         int error = 0;
348         uint16_t eeprom_data, device_id;
349
350         callout_init(&sc->timer);
351
352         sc->dev = sc->osdep.dev = dev;
353
354         /*
355          * Determine hardware and mac type
356          */
357         sc->hw.vendor_id = pci_get_vendor(dev);
358         sc->hw.device_id = pci_get_device(dev);
359         sc->hw.revision_id = pci_get_revid(dev);
360         sc->hw.subsystem_vendor_id = pci_get_subvendor(dev);
361         sc->hw.subsystem_device_id = pci_get_subdevice(dev);
362
363         if (e1000_set_mac_type(&sc->hw))
364                 return ENXIO;
365
366         /* Enable bus mastering */
367         pci_enable_busmaster(dev);
368
369         /*
370          * Allocate IO memory
371          */
372         sc->memory_rid = EMX_BAR_MEM;
373         sc->memory = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
374                                             &sc->memory_rid, RF_ACTIVE);
375         if (sc->memory == NULL) {
376                 device_printf(dev, "Unable to allocate bus resource: memory\n");
377                 error = ENXIO;
378                 goto fail;
379         }
380         sc->osdep.mem_bus_space_tag = rman_get_bustag(sc->memory);
381         sc->osdep.mem_bus_space_handle = rman_get_bushandle(sc->memory);
382
383         /* XXX This is quite goofy, it is not actually used */
384         sc->hw.hw_addr = (uint8_t *)&sc->osdep.mem_bus_space_handle;
385
386         /*
387          * Allocate interrupt
388          */
389         sc->intr_rid = 0;
390         sc->intr_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->intr_rid,
391                                               RF_SHAREABLE | RF_ACTIVE);
392         if (sc->intr_res == NULL) {
393                 device_printf(dev, "Unable to allocate bus resource: "
394                     "interrupt\n");
395                 error = ENXIO;
396                 goto fail;
397         }
398
399         /* Save PCI command register for Shared Code */
400         sc->hw.bus.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
401         sc->hw.back = &sc->osdep;
402
403         /* Do Shared Code initialization */
404         if (e1000_setup_init_funcs(&sc->hw, TRUE)) {
405                 device_printf(dev, "Setup of Shared code failed\n");
406                 error = ENXIO;
407                 goto fail;
408         }
409         e1000_get_bus_info(&sc->hw);
410
411         sc->hw.mac.autoneg = EMX_DO_AUTO_NEG;
412         sc->hw.phy.autoneg_wait_to_complete = FALSE;
413         sc->hw.phy.autoneg_advertised = EMX_AUTONEG_ADV_DEFAULT;
414
415         /*
416          * Interrupt throttle rate
417          */
418         if (emx_int_throttle_ceil == 0) {
419                 sc->int_throttle_ceil = 0;
420         } else {
421                 int throttle = emx_int_throttle_ceil;
422
423                 if (throttle < 0)
424                         throttle = EMX_DEFAULT_ITR;
425
426                 /* Recalculate the tunable value to get the exact frequency. */
427                 throttle = 1000000000 / 256 / throttle;
428
429                 /* Upper 16bits of ITR is reserved and should be zero */
430                 if (throttle & 0xffff0000)
431                         throttle = 1000000000 / 256 / EMX_DEFAULT_ITR;
432
433                 sc->int_throttle_ceil = 1000000000 / 256 / throttle;
434         }
435
436         e1000_init_script_state_82541(&sc->hw, TRUE);
437         e1000_set_tbi_compatibility_82543(&sc->hw, TRUE);
438
439         /* Copper options */
440         if (sc->hw.phy.media_type == e1000_media_type_copper) {
441                 sc->hw.phy.mdix = EMX_AUTO_ALL_MODES;
442                 sc->hw.phy.disable_polarity_correction = FALSE;
443                 sc->hw.phy.ms_type = EMX_MASTER_SLAVE;
444         }
445
446         /* Set the frame limits assuming standard ethernet sized frames. */
447         sc->max_frame_size = ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN;
448         sc->min_frame_size = ETHER_MIN_LEN;
449
450         /* This controls when hardware reports transmit completion status. */
451         sc->hw.mac.report_tx_early = 1;
452
453         /* Calculate # of RX rings */
454         if (emx_rss && ncpus > 1)
455                 sc->rx_ring_cnt = EMX_NRX_RING;
456         else
457                 sc->rx_ring_cnt = 1;
458
459         /* Allocate RX/TX rings' busdma(9) stuffs */
460         error = emx_dma_alloc(sc);
461         if (error)
462                 goto fail;
463
464         /* Make sure we have a good EEPROM before we read from it */
465         if (e1000_validate_nvm_checksum(&sc->hw) < 0) {
466                 /*
467                  * Some PCI-E parts fail the first check due to
468                  * the link being in sleep state, call it again,
469                  * if it fails a second time its a real issue.
470                  */
471                 if (e1000_validate_nvm_checksum(&sc->hw) < 0) {
472                         device_printf(dev,
473                             "The EEPROM Checksum Is Not Valid\n");
474                         error = EIO;
475                         goto fail;
476                 }
477         }
478
479         /* Initialize the hardware */
480         error = emx_hw_init(sc);
481         if (error) {
482                 device_printf(dev, "Unable to initialize the hardware\n");
483                 goto fail;
484         }
485
486         /* Copy the permanent MAC address out of the EEPROM */
487         if (e1000_read_mac_addr(&sc->hw) < 0) {
488                 device_printf(dev, "EEPROM read error while reading MAC"
489                     " address\n");
490                 error = EIO;
491                 goto fail;
492         }
493         if (!emx_is_valid_eaddr(sc->hw.mac.addr)) {
494                 device_printf(dev, "Invalid MAC address\n");
495                 error = EIO;
496                 goto fail;
497         }
498
499         /* Manually turn off all interrupts */
500         E1000_WRITE_REG(&sc->hw, E1000_IMC, 0xffffffff);
501
502         /* Setup OS specific network interface */
503         emx_setup_ifp(sc);
504
505         /* Add sysctl tree, must after emx_setup_ifp() */
506         emx_add_sysctl(sc);
507
508         /* Initialize statistics */
509         emx_update_stats(sc);
510
511         sc->hw.mac.get_link_status = 1;
512         emx_update_link_status(sc);
513
514         /* Indicate SOL/IDER usage */
515         if (e1000_check_reset_block(&sc->hw)) {
516                 device_printf(dev,
517                     "PHY reset is blocked due to SOL/IDER session.\n");
518         }
519
520         /* Determine if we have to control management hardware */
521         sc->has_manage = e1000_enable_mng_pass_thru(&sc->hw);
522
523         /*
524          * Setup Wake-on-Lan
525          */
526         switch (sc->hw.mac.type) {
527         case e1000_82571:
528         case e1000_80003es2lan:
529                 if (sc->hw.bus.func == 1) {
530                         e1000_read_nvm(&sc->hw,
531                             NVM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
532                 } else {
533                         e1000_read_nvm(&sc->hw,
534                             NVM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
535                 }
536                 eeprom_data &= EMX_EEPROM_APME;
537                 break;
538
539         default:
540                 /* APME bit in EEPROM is mapped to WUC.APME */
541                 eeprom_data =
542                     E1000_READ_REG(&sc->hw, E1000_WUC) & E1000_WUC_APME;
543                 break;
544         }
545         if (eeprom_data)
546                 sc->wol = E1000_WUFC_MAG;
547         /*
548          * We have the eeprom settings, now apply the special cases
549          * where the eeprom may be wrong or the board won't support
550          * wake on lan on a particular port
551          */
552         device_id = pci_get_device(dev);
553         switch (device_id) {
554         case E1000_DEV_ID_82571EB_FIBER:
555                 /*
556                  * Wake events only supported on port A for dual fiber
557                  * regardless of eeprom setting
558                  */
559                 if (E1000_READ_REG(&sc->hw, E1000_STATUS) &
560                     E1000_STATUS_FUNC_1)
561                         sc->wol = 0;
562                 break;
563
564         case E1000_DEV_ID_82571EB_QUAD_COPPER:
565         case E1000_DEV_ID_82571EB_QUAD_FIBER:
566         case E1000_DEV_ID_82571EB_QUAD_COPPER_LP:
567                 /* if quad port sc, disable WoL on all but port A */
568                 if (emx_global_quad_port_a != 0)
569                         sc->wol = 0;
570                 /* Reset for multiple quad port adapters */
571                 if (++emx_global_quad_port_a == 4)
572                         emx_global_quad_port_a = 0;
573                 break;
574         }
575
576         /* XXX disable wol */
577         sc->wol = 0;
578
579         sc->spare_tx_desc = EMX_TX_SPARE;
580
581         /*
582          * Keep following relationship between spare_tx_desc, oact_tx_desc
583          * and tx_int_nsegs:
584          * (spare_tx_desc + EMX_TX_RESERVED) <=
585          * oact_tx_desc <= EMX_TX_OACTIVE_MAX <= tx_int_nsegs
586          */
587         sc->oact_tx_desc = sc->num_tx_desc / 8;
588         if (sc->oact_tx_desc > EMX_TX_OACTIVE_MAX)
589                 sc->oact_tx_desc = EMX_TX_OACTIVE_MAX;
590         if (sc->oact_tx_desc < sc->spare_tx_desc + EMX_TX_RESERVED)
591                 sc->oact_tx_desc = sc->spare_tx_desc + EMX_TX_RESERVED;
592
593         sc->tx_int_nsegs = sc->num_tx_desc / 16;
594         if (sc->tx_int_nsegs < sc->oact_tx_desc)
595                 sc->tx_int_nsegs = sc->oact_tx_desc;
596
597         error = bus_setup_intr(dev, sc->intr_res, INTR_MPSAFE, emx_intr, sc,
598                                &sc->intr_tag, ifp->if_serializer);
599         if (error) {
600                 device_printf(dev, "Failed to register interrupt handler");
601                 ether_ifdetach(&sc->arpcom.ac_if);
602                 goto fail;
603         }
604
605         ifp->if_cpuid = ithread_cpuid(rman_get_start(sc->intr_res));
606         KKASSERT(ifp->if_cpuid >= 0 && ifp->if_cpuid < ncpus);
607         return (0);
608 fail:
609         emx_detach(dev);
610         return (error);
611 }
612
613 static int
614 emx_detach(device_t dev)
615 {
616         struct emx_softc *sc = device_get_softc(dev);
617
618         if (device_is_attached(dev)) {
619                 struct ifnet *ifp = &sc->arpcom.ac_if;
620
621                 lwkt_serialize_enter(ifp->if_serializer);
622
623                 emx_stop(sc);
624
625                 e1000_phy_hw_reset(&sc->hw);
626
627                 emx_rel_mgmt(sc);
628
629                 if (sc->hw.mac.type == e1000_82573 &&
630                     e1000_check_mng_mode(&sc->hw))
631                         emx_rel_hw_control(sc);
632
633                 if (sc->wol) {
634                         E1000_WRITE_REG(&sc->hw, E1000_WUC, E1000_WUC_PME_EN);
635                         E1000_WRITE_REG(&sc->hw, E1000_WUFC, sc->wol);
636                         emx_enable_wol(dev);
637                 }
638
639                 bus_teardown_intr(dev, sc->intr_res, sc->intr_tag);
640
641                 lwkt_serialize_exit(ifp->if_serializer);
642
643                 ether_ifdetach(ifp);
644         }
645         bus_generic_detach(dev);
646
647         if (sc->intr_res != NULL) {
648                 bus_release_resource(dev, SYS_RES_IRQ, sc->intr_rid,
649                                      sc->intr_res);
650         }
651
652         if (sc->memory != NULL) {
653                 bus_release_resource(dev, SYS_RES_MEMORY, sc->memory_rid,
654                                      sc->memory);
655         }
656
657         emx_dma_free(sc);
658
659         /* Free sysctl tree */
660         if (sc->sysctl_tree != NULL)
661                 sysctl_ctx_free(&sc->sysctl_ctx);
662
663         return (0);
664 }
665
666 static int
667 emx_shutdown(device_t dev)
668 {
669         return emx_suspend(dev);
670 }
671
672 static int
673 emx_suspend(device_t dev)
674 {
675         struct emx_softc *sc = device_get_softc(dev);
676         struct ifnet *ifp = &sc->arpcom.ac_if;
677
678         lwkt_serialize_enter(ifp->if_serializer);
679
680         emx_stop(sc);
681
682         emx_rel_mgmt(sc);
683
684         if (sc->hw.mac.type == e1000_82573 &&
685             e1000_check_mng_mode(&sc->hw))
686                 emx_rel_hw_control(sc);
687
688         if (sc->wol) {
689                 E1000_WRITE_REG(&sc->hw, E1000_WUC, E1000_WUC_PME_EN);
690                 E1000_WRITE_REG(&sc->hw, E1000_WUFC, sc->wol);
691                 emx_enable_wol(dev);
692         }
693
694         lwkt_serialize_exit(ifp->if_serializer);
695
696         return bus_generic_suspend(dev);
697 }
698
699 static int
700 emx_resume(device_t dev)
701 {
702         struct emx_softc *sc = device_get_softc(dev);
703         struct ifnet *ifp = &sc->arpcom.ac_if;
704
705         lwkt_serialize_enter(ifp->if_serializer);
706
707         emx_init(sc);
708         emx_get_mgmt(sc);
709         if_devstart(ifp);
710
711         lwkt_serialize_exit(ifp->if_serializer);
712
713         return bus_generic_resume(dev);
714 }
715
716 static void
717 emx_start(struct ifnet *ifp)
718 {
719         struct emx_softc *sc = ifp->if_softc;
720         struct mbuf *m_head;
721
722         ASSERT_SERIALIZED(ifp->if_serializer);
723
724         if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
725                 return;
726
727         if (!sc->link_active) {
728                 ifq_purge(&ifp->if_snd);
729                 return;
730         }
731
732         while (!ifq_is_empty(&ifp->if_snd)) {
733                 /* Now do we at least have a minimal? */
734                 if (EMX_IS_OACTIVE(sc)) {
735                         emx_tx_collect(sc);
736                         if (EMX_IS_OACTIVE(sc)) {
737                                 ifp->if_flags |= IFF_OACTIVE;
738                                 sc->no_tx_desc_avail1++;
739                                 break;
740                         }
741                 }
742
743                 logif(pkt_txqueue);
744                 m_head = ifq_dequeue(&ifp->if_snd, NULL);
745                 if (m_head == NULL)
746                         break;
747
748                 if (emx_encap(sc, &m_head)) {
749                         ifp->if_oerrors++;
750                         emx_tx_collect(sc);
751                         continue;
752                 }
753
754                 /* Send a copy of the frame to the BPF listener */
755                 ETHER_BPF_MTAP(ifp, m_head);
756
757                 /* Set timeout in case hardware has problems transmitting. */
758                 ifp->if_timer = EMX_TX_TIMEOUT;
759         }
760 }
761
762 static int
763 emx_ioctl(struct ifnet *ifp, u_long command, caddr_t data, struct ucred *cr)
764 {
765         struct emx_softc *sc = ifp->if_softc;
766         struct ifreq *ifr = (struct ifreq *)data;
767         uint16_t eeprom_data = 0;
768         int max_frame_size, mask, reinit;
769         int error = 0;
770
771         ASSERT_SERIALIZED(ifp->if_serializer);
772
773         switch (command) {
774         case SIOCSIFMTU:
775                 switch (sc->hw.mac.type) {
776                 case e1000_82573:
777                         /*
778                          * 82573 only supports jumbo frames
779                          * if ASPM is disabled.
780                          */
781                         e1000_read_nvm(&sc->hw, NVM_INIT_3GIO_3, 1,
782                                        &eeprom_data);
783                         if (eeprom_data & NVM_WORD1A_ASPM_MASK) {
784                                 max_frame_size = ETHER_MAX_LEN;
785                                 break;
786                         }
787                         /* FALL THROUGH */
788
789                 /* Limit Jumbo Frame size */
790                 case e1000_82571:
791                 case e1000_82572:
792                 case e1000_82574:
793                 case e1000_80003es2lan:
794                         max_frame_size = 9234;
795                         break;
796
797                 default:
798                         max_frame_size = MAX_JUMBO_FRAME_SIZE;
799                         break;
800                 }
801                 if (ifr->ifr_mtu > max_frame_size - ETHER_HDR_LEN -
802                     ETHER_CRC_LEN) {
803                         error = EINVAL;
804                         break;
805                 }
806
807                 ifp->if_mtu = ifr->ifr_mtu;
808                 sc->max_frame_size = ifp->if_mtu + ETHER_HDR_LEN +
809                                      ETHER_CRC_LEN;
810
811                 if (ifp->if_flags & IFF_RUNNING)
812                         emx_init(sc);
813                 break;
814
815         case SIOCSIFFLAGS:
816                 if (ifp->if_flags & IFF_UP) {
817                         if ((ifp->if_flags & IFF_RUNNING)) {
818                                 if ((ifp->if_flags ^ sc->if_flags) &
819                                     (IFF_PROMISC | IFF_ALLMULTI)) {
820                                         emx_disable_promisc(sc);
821                                         emx_set_promisc(sc);
822                                 }
823                         } else {
824                                 emx_init(sc);
825                         }
826                 } else if (ifp->if_flags & IFF_RUNNING) {
827                         emx_stop(sc);
828                 }
829                 sc->if_flags = ifp->if_flags;
830                 break;
831
832         case SIOCADDMULTI:
833         case SIOCDELMULTI:
834                 if (ifp->if_flags & IFF_RUNNING) {
835                         emx_disable_intr(sc);
836                         emx_set_multi(sc);
837 #ifdef DEVICE_POLLING
838                         if (!(ifp->if_flags & IFF_POLLING))
839 #endif
840                                 emx_enable_intr(sc);
841                 }
842                 break;
843
844         case SIOCSIFMEDIA:
845                 /* Check SOL/IDER usage */
846                 if (e1000_check_reset_block(&sc->hw)) {
847                         device_printf(sc->dev, "Media change is"
848                             " blocked due to SOL/IDER session.\n");
849                         break;
850                 }
851                 /* FALL THROUGH */
852
853         case SIOCGIFMEDIA:
854                 error = ifmedia_ioctl(ifp, ifr, &sc->media, command);
855                 break;
856
857         case SIOCSIFCAP:
858                 reinit = 0;
859                 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
860                 if (mask & IFCAP_HWCSUM) {
861                         ifp->if_capenable ^= (mask & IFCAP_HWCSUM);
862                         reinit = 1;
863                 }
864                 if (mask & IFCAP_VLAN_HWTAGGING) {
865                         ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
866                         reinit = 1;
867                 }
868                 if (reinit && (ifp->if_flags & IFF_RUNNING))
869                         emx_init(sc);
870                 break;
871
872         default:
873                 error = ether_ioctl(ifp, command, data);
874                 break;
875         }
876         return (error);
877 }
878
879 static void
880 emx_watchdog(struct ifnet *ifp)
881 {
882         struct emx_softc *sc = ifp->if_softc;
883
884         ASSERT_SERIALIZED(ifp->if_serializer);
885
886         /*
887          * The timer is set to 5 every time start queues a packet.
888          * Then txeof keeps resetting it as long as it cleans at
889          * least one descriptor.
890          * Finally, anytime all descriptors are clean the timer is
891          * set to 0.
892          */
893
894         if (E1000_READ_REG(&sc->hw, E1000_TDT(0)) ==
895             E1000_READ_REG(&sc->hw, E1000_TDH(0))) {
896                 /*
897                  * If we reach here, all TX jobs are completed and
898                  * the TX engine should have been idled for some time.
899                  * We don't need to call if_devstart() here.
900                  */
901                 ifp->if_flags &= ~IFF_OACTIVE;
902                 ifp->if_timer = 0;
903                 return;
904         }
905
906         /*
907          * If we are in this routine because of pause frames, then
908          * don't reset the hardware.
909          */
910         if (E1000_READ_REG(&sc->hw, E1000_STATUS) & E1000_STATUS_TXOFF) {
911                 ifp->if_timer = EMX_TX_TIMEOUT;
912                 return;
913         }
914
915         if (e1000_check_for_link(&sc->hw) == 0)
916                 if_printf(ifp, "watchdog timeout -- resetting\n");
917
918         ifp->if_oerrors++;
919         sc->watchdog_events++;
920
921         emx_init(sc);
922
923         if (!ifq_is_empty(&ifp->if_snd))
924                 if_devstart(ifp);
925 }
926
927 static void
928 emx_init(void *xsc)
929 {
930         struct emx_softc *sc = xsc;
931         struct ifnet *ifp = &sc->arpcom.ac_if;
932         device_t dev = sc->dev;
933         uint32_t pba;
934         int i;
935
936         ASSERT_SERIALIZED(ifp->if_serializer);
937
938         emx_stop(sc);
939
940         /*
941          * Packet Buffer Allocation (PBA)
942          * Writing PBA sets the receive portion of the buffer
943          * the remainder is used for the transmit buffer.
944          */
945         switch (sc->hw.mac.type) {
946         /* Total Packet Buffer on these is 48K */
947         case e1000_82571:
948         case e1000_82572:
949         case e1000_80003es2lan:
950                 pba = E1000_PBA_32K; /* 32K for Rx, 16K for Tx */
951                 break;
952
953         case e1000_82573: /* 82573: Total Packet Buffer is 32K */
954                 pba = E1000_PBA_12K; /* 12K for Rx, 20K for Tx */
955                 break;
956
957         case e1000_82574:
958                 pba = E1000_PBA_20K; /* 20K for Rx, 20K for Tx */
959                 break;
960
961         default:
962                 /* Devices before 82547 had a Packet Buffer of 64K.   */
963                 if (sc->max_frame_size > 8192)
964                         pba = E1000_PBA_40K; /* 40K for Rx, 24K for Tx */
965                 else
966                         pba = E1000_PBA_48K; /* 48K for Rx, 16K for Tx */
967         }
968         E1000_WRITE_REG(&sc->hw, E1000_PBA, pba);
969
970         /* Get the latest mac address, User can use a LAA */
971         bcopy(IF_LLADDR(ifp), sc->hw.mac.addr, ETHER_ADDR_LEN);
972
973         /* Put the address into the Receive Address Array */
974         e1000_rar_set(&sc->hw, sc->hw.mac.addr, 0);
975
976         /*
977          * With the 82571 sc, RAR[0] may be overwritten
978          * when the other port is reset, we make a duplicate
979          * in RAR[14] for that eventuality, this assures
980          * the interface continues to function.
981          */
982         if (sc->hw.mac.type == e1000_82571) {
983                 e1000_set_laa_state_82571(&sc->hw, TRUE);
984                 e1000_rar_set(&sc->hw, sc->hw.mac.addr,
985                     E1000_RAR_ENTRIES - 1);
986         }
987
988         /* Initialize the hardware */
989         if (emx_hw_init(sc)) {
990                 device_printf(dev, "Unable to initialize the hardware\n");
991                 /* XXX emx_stop()? */
992                 return;
993         }
994         emx_update_link_status(sc);
995
996         /* Setup VLAN support, basic and offload if available */
997         E1000_WRITE_REG(&sc->hw, E1000_VET, ETHERTYPE_VLAN);
998
999         if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) {
1000                 uint32_t ctrl;
1001
1002                 ctrl = E1000_READ_REG(&sc->hw, E1000_CTRL);
1003                 ctrl |= E1000_CTRL_VME;
1004                 E1000_WRITE_REG(&sc->hw, E1000_CTRL, ctrl);
1005         }
1006
1007         /* Set hardware offload abilities */
1008         if (ifp->if_capenable & IFCAP_TXCSUM)
1009                 ifp->if_hwassist = EMX_CSUM_FEATURES;
1010         else
1011                 ifp->if_hwassist = 0;
1012
1013         /* Configure for OS presence */
1014         emx_get_mgmt(sc);
1015
1016         /* Prepare transmit descriptors and buffers */
1017         emx_init_tx_ring(sc);
1018         emx_init_tx_unit(sc);
1019
1020         /* Setup Multicast table */
1021         emx_set_multi(sc);
1022
1023         /* Prepare receive descriptors and buffers */
1024         for (i = 0; i < sc->rx_ring_cnt; ++i) {
1025                 if (emx_init_rx_ring(sc, &sc->rx_data[i])) {
1026                         device_printf(dev,
1027                             "Could not setup receive structures\n");
1028                         emx_stop(sc);
1029                         return;
1030                 }
1031         }
1032         emx_init_rx_unit(sc);
1033
1034         /* Don't lose promiscuous settings */
1035         emx_set_promisc(sc);
1036
1037         ifp->if_flags |= IFF_RUNNING;
1038         ifp->if_flags &= ~IFF_OACTIVE;
1039
1040         callout_reset(&sc->timer, hz, emx_timer, sc);
1041         e1000_clear_hw_cntrs_base_generic(&sc->hw);
1042
1043         /* MSI/X configuration for 82574 */
1044         if (sc->hw.mac.type == e1000_82574) {
1045                 int tmp;
1046
1047                 tmp = E1000_READ_REG(&sc->hw, E1000_CTRL_EXT);
1048                 tmp |= E1000_CTRL_EXT_PBA_CLR;
1049                 E1000_WRITE_REG(&sc->hw, E1000_CTRL_EXT, tmp);
1050                 /*
1051                  * Set the IVAR - interrupt vector routing.
1052                  * Each nibble represents a vector, high bit
1053                  * is enable, other 3 bits are the MSIX table
1054                  * entry, we map RXQ0 to 0, TXQ0 to 1, and
1055                  * Link (other) to 2, hence the magic number.
1056                  */
1057                 E1000_WRITE_REG(&sc->hw, E1000_IVAR, 0x800A0908);
1058         }
1059
1060 #ifdef DEVICE_POLLING
1061         /*
1062          * Only enable interrupts if we are not polling, make sure
1063          * they are off otherwise.
1064          */
1065         if (ifp->if_flags & IFF_POLLING)
1066                 emx_disable_intr(sc);
1067         else
1068 #endif /* DEVICE_POLLING */
1069                 emx_enable_intr(sc);
1070
1071         /* Don't reset the phy next time init gets called */
1072         sc->hw.phy.reset_disable = TRUE;
1073 }
1074
1075 #ifdef DEVICE_POLLING
1076
1077 static void
1078 emx_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
1079 {
1080         struct emx_softc *sc = ifp->if_softc;
1081         uint32_t reg_icr;
1082
1083         ASSERT_SERIALIZED(ifp->if_serializer);
1084
1085         switch (cmd) {
1086         case POLL_REGISTER:
1087                 emx_disable_intr(sc);
1088                 break;
1089
1090         case POLL_DEREGISTER:
1091                 emx_enable_intr(sc);
1092                 break;
1093
1094         case POLL_AND_CHECK_STATUS:
1095                 reg_icr = E1000_READ_REG(&sc->hw, E1000_ICR);
1096                 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
1097                         callout_stop(&sc->timer);
1098                         sc->hw.mac.get_link_status = 1;
1099                         emx_update_link_status(sc);
1100                         callout_reset(&sc->timer, hz, emx_timer, sc);
1101                 }
1102                 /* FALL THROUGH */
1103         case POLL_ONLY:
1104                 if (ifp->if_flags & IFF_RUNNING) {
1105                         int i;
1106
1107                         for (i = 0; i < sc->rx_ring_cnt; ++i)
1108                                 emx_rxeof(sc, i, count);
1109
1110                         emx_txeof(sc);
1111                         if (!ifq_is_empty(&ifp->if_snd))
1112                                 if_devstart(ifp);
1113                 }
1114                 break;
1115         }
1116 }
1117
1118 #endif /* DEVICE_POLLING */
1119
1120 static void
1121 emx_intr(void *xsc)
1122 {
1123         struct emx_softc *sc = xsc;
1124         struct ifnet *ifp = &sc->arpcom.ac_if;
1125         uint32_t reg_icr;
1126
1127         logif(intr_beg);
1128         ASSERT_SERIALIZED(ifp->if_serializer);
1129
1130         reg_icr = E1000_READ_REG(&sc->hw, E1000_ICR);
1131
1132         if ((reg_icr & E1000_ICR_INT_ASSERTED) == 0) {
1133                 logif(intr_end);
1134                 return;
1135         }
1136
1137         /*
1138          * XXX: some laptops trigger several spurious interrupts
1139          * on em(4) when in the resume cycle. The ICR register
1140          * reports all-ones value in this case. Processing such
1141          * interrupts would lead to a freeze. I don't know why.
1142          */
1143         if (reg_icr == 0xffffffff) {
1144                 logif(intr_end);
1145                 return;
1146         }
1147
1148         if (ifp->if_flags & IFF_RUNNING) {
1149                 if (reg_icr &
1150                     (E1000_ICR_RXT0 | E1000_ICR_RXDMT0 | E1000_ICR_RXO)) {
1151                         int i;
1152
1153                         for (i = 0; i < sc->rx_ring_cnt; ++i)
1154                                 emx_rxeof(sc, i, -1);
1155                 }
1156                 if (reg_icr & E1000_ICR_TXDW) {
1157                         emx_txeof(sc);
1158                         if (!ifq_is_empty(&ifp->if_snd))
1159                                 if_devstart(ifp);
1160                 }
1161         }
1162
1163         /* Link status change */
1164         if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
1165                 callout_stop(&sc->timer);
1166                 sc->hw.mac.get_link_status = 1;
1167                 emx_update_link_status(sc);
1168
1169                 /* Deal with TX cruft when link lost */
1170                 emx_tx_purge(sc);
1171
1172                 callout_reset(&sc->timer, hz, emx_timer, sc);
1173         }
1174
1175         if (reg_icr & E1000_ICR_RXO)
1176                 sc->rx_overruns++;
1177
1178         logif(intr_end);
1179 }
1180
1181 static void
1182 emx_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
1183 {
1184         struct emx_softc *sc = ifp->if_softc;
1185
1186         ASSERT_SERIALIZED(ifp->if_serializer);
1187
1188         emx_update_link_status(sc);
1189
1190         ifmr->ifm_status = IFM_AVALID;
1191         ifmr->ifm_active = IFM_ETHER;
1192
1193         if (!sc->link_active)
1194                 return;
1195
1196         ifmr->ifm_status |= IFM_ACTIVE;
1197
1198         if (sc->hw.phy.media_type == e1000_media_type_fiber ||
1199             sc->hw.phy.media_type == e1000_media_type_internal_serdes) {
1200                 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX;
1201         } else {
1202                 switch (sc->link_speed) {
1203                 case 10:
1204                         ifmr->ifm_active |= IFM_10_T;
1205                         break;
1206                 case 100:
1207                         ifmr->ifm_active |= IFM_100_TX;
1208                         break;
1209
1210                 case 1000:
1211                         ifmr->ifm_active |= IFM_1000_T;
1212                         break;
1213                 }
1214                 if (sc->link_duplex == FULL_DUPLEX)
1215                         ifmr->ifm_active |= IFM_FDX;
1216                 else
1217                         ifmr->ifm_active |= IFM_HDX;
1218         }
1219 }
1220
1221 static int
1222 emx_media_change(struct ifnet *ifp)
1223 {
1224         struct emx_softc *sc = ifp->if_softc;
1225         struct ifmedia *ifm = &sc->media;
1226
1227         ASSERT_SERIALIZED(ifp->if_serializer);
1228
1229         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
1230                 return (EINVAL);
1231
1232         switch (IFM_SUBTYPE(ifm->ifm_media)) {
1233         case IFM_AUTO:
1234                 sc->hw.mac.autoneg = EMX_DO_AUTO_NEG;
1235                 sc->hw.phy.autoneg_advertised = EMX_AUTONEG_ADV_DEFAULT;
1236                 break;
1237
1238         case IFM_1000_LX:
1239         case IFM_1000_SX:
1240         case IFM_1000_T:
1241                 sc->hw.mac.autoneg = EMX_DO_AUTO_NEG;
1242                 sc->hw.phy.autoneg_advertised = ADVERTISE_1000_FULL;
1243                 break;
1244
1245         case IFM_100_TX:
1246                 sc->hw.mac.autoneg = FALSE;
1247                 sc->hw.phy.autoneg_advertised = 0;
1248                 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
1249                         sc->hw.mac.forced_speed_duplex = ADVERTISE_100_FULL;
1250                 else
1251                         sc->hw.mac.forced_speed_duplex = ADVERTISE_100_HALF;
1252                 break;
1253
1254         case IFM_10_T:
1255                 sc->hw.mac.autoneg = FALSE;
1256                 sc->hw.phy.autoneg_advertised = 0;
1257                 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
1258                         sc->hw.mac.forced_speed_duplex = ADVERTISE_10_FULL;
1259                 else
1260                         sc->hw.mac.forced_speed_duplex = ADVERTISE_10_HALF;
1261                 break;
1262
1263         default:
1264                 if_printf(ifp, "Unsupported media type\n");
1265                 break;
1266         }
1267
1268         /*
1269          * As the speed/duplex settings my have changed we need to
1270          * reset the PHY.
1271          */
1272         sc->hw.phy.reset_disable = FALSE;
1273
1274         emx_init(sc);
1275
1276         return (0);
1277 }
1278
1279 static int
1280 emx_encap(struct emx_softc *sc, struct mbuf **m_headp)
1281 {
1282         bus_dma_segment_t segs[EMX_MAX_SCATTER];
1283         bus_dmamap_t map;
1284         struct emx_txbuf *tx_buffer, *tx_buffer_mapped;
1285         struct e1000_tx_desc *ctxd = NULL;
1286         struct mbuf *m_head = *m_headp;
1287         uint32_t txd_upper, txd_lower, cmd = 0;
1288         int maxsegs, nsegs, i, j, first, last = 0, error;
1289
1290         if (m_head->m_len < EMX_TXCSUM_MINHL &&
1291             (m_head->m_flags & EMX_CSUM_FEATURES)) {
1292                 /*
1293                  * Make sure that ethernet header and ip.ip_hl are in
1294                  * contiguous memory, since if TXCSUM is enabled, later
1295                  * TX context descriptor's setup need to access ip.ip_hl.
1296                  */
1297                 error = emx_txcsum_pullup(sc, m_headp);
1298                 if (error) {
1299                         KKASSERT(*m_headp == NULL);
1300                         return error;
1301                 }
1302                 m_head = *m_headp;
1303         }
1304
1305         txd_upper = txd_lower = 0;
1306
1307         /*
1308          * Capture the first descriptor index, this descriptor
1309          * will have the index of the EOP which is the only one
1310          * that now gets a DONE bit writeback.
1311          */
1312         first = sc->next_avail_tx_desc;
1313         tx_buffer = &sc->tx_buf[first];
1314         tx_buffer_mapped = tx_buffer;
1315         map = tx_buffer->map;
1316
1317         maxsegs = sc->num_tx_desc_avail - EMX_TX_RESERVED;
1318         KASSERT(maxsegs >= sc->spare_tx_desc, ("not enough spare TX desc\n"));
1319         if (maxsegs > EMX_MAX_SCATTER)
1320                 maxsegs = EMX_MAX_SCATTER;
1321
1322         error = bus_dmamap_load_mbuf_defrag(sc->txtag, map, m_headp,
1323                         segs, maxsegs, &nsegs, BUS_DMA_NOWAIT);
1324         if (error) {
1325                 if (error == ENOBUFS)
1326                         sc->mbuf_alloc_failed++;
1327                 else
1328                         sc->no_tx_dma_setup++;
1329
1330                 m_freem(*m_headp);
1331                 *m_headp = NULL;
1332                 return error;
1333         }
1334         bus_dmamap_sync(sc->txtag, map, BUS_DMASYNC_PREWRITE);
1335
1336         m_head = *m_headp;
1337         sc->tx_nsegs += nsegs;
1338
1339         if (m_head->m_pkthdr.csum_flags & EMX_CSUM_FEATURES) {
1340                 /* TX csum offloading will consume one TX desc */
1341                 sc->tx_nsegs += emx_txcsum(sc, m_head, &txd_upper, &txd_lower);
1342         }
1343         i = sc->next_avail_tx_desc;
1344
1345         /* Set up our transmit descriptors */
1346         for (j = 0; j < nsegs; j++) {
1347                 tx_buffer = &sc->tx_buf[i];
1348                 ctxd = &sc->tx_desc_base[i];
1349
1350                 ctxd->buffer_addr = htole64(segs[j].ds_addr);
1351                 ctxd->lower.data = htole32(E1000_TXD_CMD_IFCS |
1352                                            txd_lower | segs[j].ds_len);
1353                 ctxd->upper.data = htole32(txd_upper);
1354
1355                 last = i;
1356                 if (++i == sc->num_tx_desc)
1357                         i = 0;
1358         }
1359
1360         sc->next_avail_tx_desc = i;
1361
1362         KKASSERT(sc->num_tx_desc_avail > nsegs);
1363         sc->num_tx_desc_avail -= nsegs;
1364
1365         /* Handle VLAN tag */
1366         if (m_head->m_flags & M_VLANTAG) {
1367                 /* Set the vlan id. */
1368                 ctxd->upper.fields.special =
1369                     htole16(m_head->m_pkthdr.ether_vlantag);
1370
1371                 /* Tell hardware to add tag */
1372                 ctxd->lower.data |= htole32(E1000_TXD_CMD_VLE);
1373         }
1374
1375         tx_buffer->m_head = m_head;
1376         tx_buffer_mapped->map = tx_buffer->map;
1377         tx_buffer->map = map;
1378
1379         if (sc->tx_nsegs >= sc->tx_int_nsegs) {
1380                 sc->tx_nsegs = 0;
1381
1382                 /*
1383                  * Report Status (RS) is turned on
1384                  * every tx_int_nsegs descriptors.
1385                  */
1386                 cmd = E1000_TXD_CMD_RS;
1387
1388                 /*
1389                  * Keep track of the descriptor, which will
1390                  * be written back by hardware.
1391                  */
1392                 sc->tx_dd[sc->tx_dd_tail] = last;
1393                 EMX_INC_TXDD_IDX(sc->tx_dd_tail);
1394                 KKASSERT(sc->tx_dd_tail != sc->tx_dd_head);
1395         }
1396
1397         /*
1398          * Last Descriptor of Packet needs End Of Packet (EOP)
1399          */
1400         ctxd->lower.data |= htole32(E1000_TXD_CMD_EOP | cmd);
1401
1402         /*
1403          * Advance the Transmit Descriptor Tail (TDT), this tells
1404          * the E1000 that this frame is available to transmit.
1405          */
1406         E1000_WRITE_REG(&sc->hw, E1000_TDT(0), i);
1407
1408         return (0);
1409 }
1410
1411 static void
1412 emx_set_promisc(struct emx_softc *sc)
1413 {
1414         struct ifnet *ifp = &sc->arpcom.ac_if;
1415         uint32_t reg_rctl;
1416
1417         reg_rctl = E1000_READ_REG(&sc->hw, E1000_RCTL);
1418
1419         if (ifp->if_flags & IFF_PROMISC) {
1420                 reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
1421                 /* Turn this on if you want to see bad packets */
1422                 if (emx_debug_sbp)
1423                         reg_rctl |= E1000_RCTL_SBP;
1424                 E1000_WRITE_REG(&sc->hw, E1000_RCTL, reg_rctl);
1425         } else if (ifp->if_flags & IFF_ALLMULTI) {
1426                 reg_rctl |= E1000_RCTL_MPE;
1427                 reg_rctl &= ~E1000_RCTL_UPE;
1428                 E1000_WRITE_REG(&sc->hw, E1000_RCTL, reg_rctl);
1429         }
1430 }
1431
1432 static void
1433 emx_disable_promisc(struct emx_softc *sc)
1434 {
1435         uint32_t reg_rctl;
1436
1437         reg_rctl = E1000_READ_REG(&sc->hw, E1000_RCTL);
1438
1439         reg_rctl &= ~E1000_RCTL_UPE;
1440         reg_rctl &= ~E1000_RCTL_MPE;
1441         reg_rctl &= ~E1000_RCTL_SBP;
1442         E1000_WRITE_REG(&sc->hw, E1000_RCTL, reg_rctl);
1443 }
1444
1445 static void
1446 emx_set_multi(struct emx_softc *sc)
1447 {
1448         struct ifnet *ifp = &sc->arpcom.ac_if;
1449         struct ifmultiaddr *ifma;
1450         uint32_t reg_rctl = 0;
1451         uint8_t  mta[512]; /* Largest MTS is 4096 bits */
1452         int mcnt = 0;
1453
1454         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1455                 if (ifma->ifma_addr->sa_family != AF_LINK)
1456                         continue;
1457
1458                 if (mcnt == EMX_MCAST_ADDR_MAX)
1459                         break;
1460
1461                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
1462                       &mta[mcnt * ETHER_ADDR_LEN], ETHER_ADDR_LEN);
1463                 mcnt++;
1464         }
1465
1466         if (mcnt >= EMX_MCAST_ADDR_MAX) {
1467                 reg_rctl = E1000_READ_REG(&sc->hw, E1000_RCTL);
1468                 reg_rctl |= E1000_RCTL_MPE;
1469                 E1000_WRITE_REG(&sc->hw, E1000_RCTL, reg_rctl);
1470         } else {
1471                 e1000_update_mc_addr_list(&sc->hw, mta,
1472                     mcnt, 1, sc->hw.mac.rar_entry_count);
1473         }
1474 }
1475
1476 /*
1477  * This routine checks for link status and updates statistics.
1478  */
1479 static void
1480 emx_timer(void *xsc)
1481 {
1482         struct emx_softc *sc = xsc;
1483         struct ifnet *ifp = &sc->arpcom.ac_if;
1484
1485         lwkt_serialize_enter(ifp->if_serializer);
1486
1487         emx_update_link_status(sc);
1488         emx_update_stats(sc);
1489
1490         /* Reset LAA into RAR[0] on 82571 */
1491         if (e1000_get_laa_state_82571(&sc->hw) == TRUE)
1492                 e1000_rar_set(&sc->hw, sc->hw.mac.addr, 0);
1493
1494         if (emx_display_debug_stats && (ifp->if_flags & IFF_RUNNING))
1495                 emx_print_hw_stats(sc);
1496
1497         emx_smartspeed(sc);
1498
1499         callout_reset(&sc->timer, hz, emx_timer, sc);
1500
1501         lwkt_serialize_exit(ifp->if_serializer);
1502 }
1503
1504 static void
1505 emx_update_link_status(struct emx_softc *sc)
1506 {
1507         struct e1000_hw *hw = &sc->hw;
1508         struct ifnet *ifp = &sc->arpcom.ac_if;
1509         device_t dev = sc->dev;
1510         uint32_t link_check = 0;
1511
1512         /* Get the cached link value or read phy for real */
1513         switch (hw->phy.media_type) {
1514         case e1000_media_type_copper:
1515                 if (hw->mac.get_link_status) {
1516                         /* Do the work to read phy */
1517                         e1000_check_for_link(hw);
1518                         link_check = !hw->mac.get_link_status;
1519                         if (link_check) /* ESB2 fix */
1520                                 e1000_cfg_on_link_up(hw);
1521                 } else {
1522                         link_check = TRUE;
1523                 }
1524                 break;
1525
1526         case e1000_media_type_fiber:
1527                 e1000_check_for_link(hw);
1528                 link_check = E1000_READ_REG(hw, E1000_STATUS) & E1000_STATUS_LU;
1529                 break;
1530
1531         case e1000_media_type_internal_serdes:
1532                 e1000_check_for_link(hw);
1533                 link_check = sc->hw.mac.serdes_has_link;
1534                 break;
1535
1536         case e1000_media_type_unknown:
1537         default:
1538                 break;
1539         }
1540
1541         /* Now check for a transition */
1542         if (link_check && sc->link_active == 0) {
1543                 e1000_get_speed_and_duplex(hw, &sc->link_speed,
1544                     &sc->link_duplex);
1545
1546                 /*
1547                  * Check if we should enable/disable SPEED_MODE bit on
1548                  * 82571EB/82572EI
1549                  */
1550                 if (hw->mac.type == e1000_82571 ||
1551                     hw->mac.type == e1000_82572) {
1552                         int tarc0;
1553
1554                         tarc0 = E1000_READ_REG(hw, E1000_TARC(0));
1555                         if (sc->link_speed != SPEED_1000)
1556                                 tarc0 &= ~EMX_TARC_SPEED_MODE;
1557                         else
1558                                 tarc0 |= EMX_TARC_SPEED_MODE;
1559                         E1000_WRITE_REG(hw, E1000_TARC(0), tarc0);
1560                 }
1561                 if (bootverbose) {
1562                         device_printf(dev, "Link is up %d Mbps %s\n",
1563                             sc->link_speed,
1564                             ((sc->link_duplex == FULL_DUPLEX) ?
1565                             "Full Duplex" : "Half Duplex"));
1566                 }
1567                 sc->link_active = 1;
1568                 sc->smartspeed = 0;
1569                 ifp->if_baudrate = sc->link_speed * 1000000;
1570                 ifp->if_link_state = LINK_STATE_UP;
1571                 if_link_state_change(ifp);
1572         } else if (!link_check && sc->link_active == 1) {
1573                 ifp->if_baudrate = sc->link_speed = 0;
1574                 sc->link_duplex = 0;
1575                 if (bootverbose)
1576                         device_printf(dev, "Link is Down\n");
1577                 sc->link_active = 0;
1578 #if 0
1579                 /* Link down, disable watchdog */
1580                 if->if_timer = 0;
1581 #endif
1582                 ifp->if_link_state = LINK_STATE_DOWN;
1583                 if_link_state_change(ifp);
1584         }
1585 }
1586
1587 static void
1588 emx_stop(struct emx_softc *sc)
1589 {
1590         struct ifnet *ifp = &sc->arpcom.ac_if;
1591         int i;
1592
1593         ASSERT_SERIALIZED(ifp->if_serializer);
1594
1595         emx_disable_intr(sc);
1596
1597         callout_stop(&sc->timer);
1598
1599         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1600         ifp->if_timer = 0;
1601
1602         /*
1603          * Disable multiple receive queues.
1604          *
1605          * NOTE:
1606          * We should disable multiple receive queues before
1607          * resetting the hardware.
1608          */
1609         E1000_WRITE_REG(&sc->hw, E1000_MRQC, 0);
1610
1611         e1000_reset_hw(&sc->hw);
1612         E1000_WRITE_REG(&sc->hw, E1000_WUC, 0);
1613
1614         for (i = 0; i < sc->num_tx_desc; i++) {
1615                 struct emx_txbuf *tx_buffer = &sc->tx_buf[i];
1616
1617                 if (tx_buffer->m_head != NULL) {
1618                         bus_dmamap_unload(sc->txtag, tx_buffer->map);
1619                         m_freem(tx_buffer->m_head);
1620                         tx_buffer->m_head = NULL;
1621                 }
1622         }
1623
1624         for (i = 0; i < sc->rx_ring_cnt; ++i)
1625                 emx_free_rx_ring(sc, &sc->rx_data[i]);
1626
1627         sc->csum_flags = 0;
1628         sc->csum_ehlen = 0;
1629         sc->csum_iphlen = 0;
1630
1631         sc->tx_dd_head = 0;
1632         sc->tx_dd_tail = 0;
1633         sc->tx_nsegs = 0;
1634 }
1635
1636 static int
1637 emx_hw_init(struct emx_softc *sc)
1638 {
1639         device_t dev = sc->dev;
1640         uint16_t rx_buffer_size;
1641
1642         /* Issue a global reset */
1643         e1000_reset_hw(&sc->hw);
1644
1645         /* Get control from any management/hw control */
1646         if (sc->hw.mac.type == e1000_82573 &&
1647             e1000_check_mng_mode(&sc->hw))
1648                 emx_get_hw_control(sc);
1649
1650         /* Set up smart power down as default off on newer adapters. */
1651         if (!emx_smart_pwr_down &&
1652             (sc->hw.mac.type == e1000_82571 ||
1653              sc->hw.mac.type == e1000_82572)) {
1654                 uint16_t phy_tmp = 0;
1655
1656                 /* Speed up time to link by disabling smart power down. */
1657                 e1000_read_phy_reg(&sc->hw,
1658                     IGP02E1000_PHY_POWER_MGMT, &phy_tmp);
1659                 phy_tmp &= ~IGP02E1000_PM_SPD;
1660                 e1000_write_phy_reg(&sc->hw,
1661                     IGP02E1000_PHY_POWER_MGMT, phy_tmp);
1662         }
1663
1664         /*
1665          * These parameters control the automatic generation (Tx) and
1666          * response (Rx) to Ethernet PAUSE frames.
1667          * - High water mark should allow for at least two frames to be
1668          *   received after sending an XOFF.
1669          * - Low water mark works best when it is very near the high water mark.
1670          *   This allows the receiver to restart by sending XON when it has
1671          *   drained a bit. Here we use an arbitary value of 1500 which will
1672          *   restart after one full frame is pulled from the buffer. There
1673          *   could be several smaller frames in the buffer and if so they will
1674          *   not trigger the XON until their total number reduces the buffer
1675          *   by 1500.
1676          * - The pause time is fairly large at 1000 x 512ns = 512 usec.
1677          */
1678         rx_buffer_size = (E1000_READ_REG(&sc->hw, E1000_PBA) & 0xffff) << 10;
1679
1680         sc->hw.fc.high_water = rx_buffer_size -
1681                                roundup2(sc->max_frame_size, 1024);
1682         sc->hw.fc.low_water = sc->hw.fc.high_water - 1500;
1683
1684         if (sc->hw.mac.type == e1000_80003es2lan)
1685                 sc->hw.fc.pause_time = 0xFFFF;
1686         else
1687                 sc->hw.fc.pause_time = EMX_FC_PAUSE_TIME;
1688         sc->hw.fc.send_xon = TRUE;
1689         sc->hw.fc.requested_mode = e1000_fc_full;
1690
1691         if (e1000_init_hw(&sc->hw) < 0) {
1692                 device_printf(dev, "Hardware Initialization Failed\n");
1693                 return (EIO);
1694         }
1695
1696         e1000_check_for_link(&sc->hw);
1697
1698         return (0);
1699 }
1700
1701 static void
1702 emx_setup_ifp(struct emx_softc *sc)
1703 {
1704         struct ifnet *ifp = &sc->arpcom.ac_if;
1705
1706         if_initname(ifp, device_get_name(sc->dev),
1707                     device_get_unit(sc->dev));
1708         ifp->if_softc = sc;
1709         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1710         ifp->if_init =  emx_init;
1711         ifp->if_ioctl = emx_ioctl;
1712         ifp->if_start = emx_start;
1713 #ifdef DEVICE_POLLING
1714         ifp->if_poll = emx_poll;
1715 #endif
1716         ifp->if_watchdog = emx_watchdog;
1717         ifq_set_maxlen(&ifp->if_snd, sc->num_tx_desc - 1);
1718         ifq_set_ready(&ifp->if_snd);
1719
1720         ether_ifattach(ifp, sc->hw.mac.addr, NULL);
1721
1722         ifp->if_capabilities = IFCAP_HWCSUM |
1723                                IFCAP_VLAN_HWTAGGING |
1724                                IFCAP_VLAN_MTU;
1725         ifp->if_capenable = ifp->if_capabilities;
1726         ifp->if_hwassist = EMX_CSUM_FEATURES;
1727
1728         /*
1729          * Tell the upper layer(s) we support long frames.
1730          */
1731         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
1732
1733         /*
1734          * Specify the media types supported by this sc and register
1735          * callbacks to update media and link information
1736          */
1737         ifmedia_init(&sc->media, IFM_IMASK,
1738                      emx_media_change, emx_media_status);
1739         if (sc->hw.phy.media_type == e1000_media_type_fiber ||
1740             sc->hw.phy.media_type == e1000_media_type_internal_serdes) {
1741                 ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_SX | IFM_FDX,
1742                             0, NULL);
1743                 ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_SX, 0, NULL);
1744         } else {
1745                 ifmedia_add(&sc->media, IFM_ETHER | IFM_10_T, 0, NULL);
1746                 ifmedia_add(&sc->media, IFM_ETHER | IFM_10_T | IFM_FDX,
1747                             0, NULL);
1748                 ifmedia_add(&sc->media, IFM_ETHER | IFM_100_TX, 0, NULL);
1749                 ifmedia_add(&sc->media, IFM_ETHER | IFM_100_TX | IFM_FDX,
1750                             0, NULL);
1751                 if (sc->hw.phy.type != e1000_phy_ife) {
1752                         ifmedia_add(&sc->media,
1753                                 IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL);
1754                         ifmedia_add(&sc->media,
1755                                 IFM_ETHER | IFM_1000_T, 0, NULL);
1756                 }
1757         }
1758         ifmedia_add(&sc->media, IFM_ETHER | IFM_AUTO, 0, NULL);
1759         ifmedia_set(&sc->media, IFM_ETHER | IFM_AUTO);
1760 }
1761
1762 /*
1763  * Workaround for SmartSpeed on 82541 and 82547 controllers
1764  */
1765 static void
1766 emx_smartspeed(struct emx_softc *sc)
1767 {
1768         uint16_t phy_tmp;
1769
1770         if (sc->link_active || sc->hw.phy.type != e1000_phy_igp ||
1771             sc->hw.mac.autoneg == 0 ||
1772             (sc->hw.phy.autoneg_advertised & ADVERTISE_1000_FULL) == 0)
1773                 return;
1774
1775         if (sc->smartspeed == 0) {
1776                 /*
1777                  * If Master/Slave config fault is asserted twice,
1778                  * we assume back-to-back
1779                  */
1780                 e1000_read_phy_reg(&sc->hw, PHY_1000T_STATUS, &phy_tmp);
1781                 if (!(phy_tmp & SR_1000T_MS_CONFIG_FAULT))
1782                         return;
1783                 e1000_read_phy_reg(&sc->hw, PHY_1000T_STATUS, &phy_tmp);
1784                 if (phy_tmp & SR_1000T_MS_CONFIG_FAULT) {
1785                         e1000_read_phy_reg(&sc->hw,
1786                             PHY_1000T_CTRL, &phy_tmp);
1787                         if (phy_tmp & CR_1000T_MS_ENABLE) {
1788                                 phy_tmp &= ~CR_1000T_MS_ENABLE;
1789                                 e1000_write_phy_reg(&sc->hw,
1790                                     PHY_1000T_CTRL, phy_tmp);
1791                                 sc->smartspeed++;
1792                                 if (sc->hw.mac.autoneg &&
1793                                     !e1000_phy_setup_autoneg(&sc->hw) &&
1794                                     !e1000_read_phy_reg(&sc->hw,
1795                                      PHY_CONTROL, &phy_tmp)) {
1796                                         phy_tmp |= MII_CR_AUTO_NEG_EN |
1797                                                    MII_CR_RESTART_AUTO_NEG;
1798                                         e1000_write_phy_reg(&sc->hw,
1799                                             PHY_CONTROL, phy_tmp);
1800                                 }
1801                         }
1802                 }
1803                 return;
1804         } else if (sc->smartspeed == EMX_SMARTSPEED_DOWNSHIFT) {
1805                 /* If still no link, perhaps using 2/3 pair cable */
1806                 e1000_read_phy_reg(&sc->hw, PHY_1000T_CTRL, &phy_tmp);
1807                 phy_tmp |= CR_1000T_MS_ENABLE;
1808                 e1000_write_phy_reg(&sc->hw, PHY_1000T_CTRL, phy_tmp);
1809                 if (sc->hw.mac.autoneg &&
1810                     !e1000_phy_setup_autoneg(&sc->hw) &&
1811                     !e1000_read_phy_reg(&sc->hw, PHY_CONTROL, &phy_tmp)) {
1812                         phy_tmp |= MII_CR_AUTO_NEG_EN | MII_CR_RESTART_AUTO_NEG;
1813                         e1000_write_phy_reg(&sc->hw, PHY_CONTROL, phy_tmp);
1814                 }
1815         }
1816
1817         /* Restart process after EMX_SMARTSPEED_MAX iterations */
1818         if (sc->smartspeed++ == EMX_SMARTSPEED_MAX)
1819                 sc->smartspeed = 0;
1820 }
1821
1822 static int
1823 emx_create_tx_ring(struct emx_softc *sc)
1824 {
1825         device_t dev = sc->dev;
1826         struct emx_txbuf *tx_buffer;
1827         int error, i, tsize;
1828
1829         /*
1830          * Validate number of transmit descriptors.  It must not exceed
1831          * hardware maximum, and must be multiple of E1000_DBA_ALIGN.
1832          */
1833         if ((emx_txd * sizeof(struct e1000_tx_desc)) % EMX_DBA_ALIGN != 0 ||
1834             emx_txd > EMX_MAX_TXD || emx_txd < EMX_MIN_TXD) {
1835                 device_printf(dev, "Using %d TX descriptors instead of %d!\n",
1836                     EMX_DEFAULT_TXD, emx_txd);
1837                 sc->num_tx_desc = EMX_DEFAULT_TXD;
1838         } else {
1839                 sc->num_tx_desc = emx_txd;
1840         }
1841
1842         /*
1843          * Allocate Transmit Descriptor ring
1844          */
1845         tsize = roundup2(sc->num_tx_desc * sizeof(struct e1000_tx_desc),
1846                          EMX_DBA_ALIGN);
1847         sc->tx_desc_base = bus_dmamem_coherent_any(sc->parent_dtag,
1848                                 EMX_DBA_ALIGN, tsize, BUS_DMA_WAITOK,
1849                                 &sc->tx_desc_dtag, &sc->tx_desc_dmap,
1850                                 &sc->tx_desc_paddr);
1851         if (sc->tx_desc_base == NULL) {
1852                 device_printf(dev, "Unable to allocate tx_desc memory\n");
1853                 return ENOMEM;
1854         }
1855
1856         sc->tx_buf = kmalloc(sizeof(struct emx_txbuf) * sc->num_tx_desc,
1857                              M_DEVBUF, M_WAITOK | M_ZERO);
1858
1859         /*
1860          * Create DMA tags for tx buffers
1861          */
1862         error = bus_dma_tag_create(sc->parent_dtag, /* parent */
1863                         1, 0,                   /* alignment, bounds */
1864                         BUS_SPACE_MAXADDR,      /* lowaddr */
1865                         BUS_SPACE_MAXADDR,      /* highaddr */
1866                         NULL, NULL,             /* filter, filterarg */
1867                         EMX_TSO_SIZE,           /* maxsize */
1868                         EMX_MAX_SCATTER,        /* nsegments */
1869                         EMX_MAX_SEGSIZE,        /* maxsegsize */
1870                         BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW |
1871                         BUS_DMA_ONEBPAGE,       /* flags */
1872                         &sc->txtag);
1873         if (error) {
1874                 device_printf(dev, "Unable to allocate TX DMA tag\n");
1875                 kfree(sc->tx_buf, M_DEVBUF);
1876                 sc->tx_buf = NULL;
1877                 return error;
1878         }
1879
1880         /*
1881          * Create DMA maps for tx buffers
1882          */
1883         for (i = 0; i < sc->num_tx_desc; i++) {
1884                 tx_buffer = &sc->tx_buf[i];
1885
1886                 error = bus_dmamap_create(sc->txtag,
1887                                           BUS_DMA_WAITOK | BUS_DMA_ONEBPAGE,
1888                                           &tx_buffer->map);
1889                 if (error) {
1890                         device_printf(dev, "Unable to create TX DMA map\n");
1891                         emx_destroy_tx_ring(sc, i);
1892                         return error;
1893                 }
1894         }
1895         return (0);
1896 }
1897
1898 static void
1899 emx_init_tx_ring(struct emx_softc *sc)
1900 {
1901         /* Clear the old ring contents */
1902         bzero(sc->tx_desc_base,
1903               sizeof(struct e1000_tx_desc) * sc->num_tx_desc);
1904
1905         /* Reset state */
1906         sc->next_avail_tx_desc = 0;
1907         sc->next_tx_to_clean = 0;
1908         sc->num_tx_desc_avail = sc->num_tx_desc;
1909 }
1910
1911 static void
1912 emx_init_tx_unit(struct emx_softc *sc)
1913 {
1914         uint32_t tctl, tarc, tipg = 0;
1915         uint64_t bus_addr;
1916
1917         /* Setup the Base and Length of the Tx Descriptor Ring */
1918         bus_addr = sc->tx_desc_paddr;
1919         E1000_WRITE_REG(&sc->hw, E1000_TDLEN(0),
1920             sc->num_tx_desc * sizeof(struct e1000_tx_desc));
1921         E1000_WRITE_REG(&sc->hw, E1000_TDBAH(0),
1922             (uint32_t)(bus_addr >> 32));
1923         E1000_WRITE_REG(&sc->hw, E1000_TDBAL(0),
1924             (uint32_t)bus_addr);
1925         /* Setup the HW Tx Head and Tail descriptor pointers */
1926         E1000_WRITE_REG(&sc->hw, E1000_TDT(0), 0);
1927         E1000_WRITE_REG(&sc->hw, E1000_TDH(0), 0);
1928
1929         /* Set the default values for the Tx Inter Packet Gap timer */
1930         switch (sc->hw.mac.type) {
1931         case e1000_80003es2lan:
1932                 tipg = DEFAULT_82543_TIPG_IPGR1;
1933                 tipg |= DEFAULT_80003ES2LAN_TIPG_IPGR2 <<
1934                     E1000_TIPG_IPGR2_SHIFT;
1935                 break;
1936
1937         default:
1938                 if (sc->hw.phy.media_type == e1000_media_type_fiber ||
1939                     sc->hw.phy.media_type == e1000_media_type_internal_serdes)
1940                         tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
1941                 else
1942                         tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
1943                 tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
1944                 tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
1945                 break;
1946         }
1947
1948         E1000_WRITE_REG(&sc->hw, E1000_TIPG, tipg);
1949
1950         /* NOTE: 0 is not allowed for TIDV */
1951         E1000_WRITE_REG(&sc->hw, E1000_TIDV, 1);
1952         E1000_WRITE_REG(&sc->hw, E1000_TADV, 0);
1953
1954         if (sc->hw.mac.type == e1000_82571 ||
1955             sc->hw.mac.type == e1000_82572) {
1956                 tarc = E1000_READ_REG(&sc->hw, E1000_TARC(0));
1957                 tarc |= EMX_TARC_SPEED_MODE;
1958                 E1000_WRITE_REG(&sc->hw, E1000_TARC(0), tarc);
1959         } else if (sc->hw.mac.type == e1000_80003es2lan) {
1960                 tarc = E1000_READ_REG(&sc->hw, E1000_TARC(0));
1961                 tarc |= 1;
1962                 E1000_WRITE_REG(&sc->hw, E1000_TARC(0), tarc);
1963                 tarc = E1000_READ_REG(&sc->hw, E1000_TARC(1));
1964                 tarc |= 1;
1965                 E1000_WRITE_REG(&sc->hw, E1000_TARC(1), tarc);
1966         }
1967
1968         /* Program the Transmit Control Register */
1969         tctl = E1000_READ_REG(&sc->hw, E1000_TCTL);
1970         tctl &= ~E1000_TCTL_CT;
1971         tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC | E1000_TCTL_EN |
1972                 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
1973         tctl |= E1000_TCTL_MULR;
1974
1975         /* This write will effectively turn on the transmit unit. */
1976         E1000_WRITE_REG(&sc->hw, E1000_TCTL, tctl);
1977 }
1978
1979 static void
1980 emx_destroy_tx_ring(struct emx_softc *sc, int ndesc)
1981 {
1982         struct emx_txbuf *tx_buffer;
1983         int i;
1984
1985         /* Free Transmit Descriptor ring */
1986         if (sc->tx_desc_base) {
1987                 bus_dmamap_unload(sc->tx_desc_dtag, sc->tx_desc_dmap);
1988                 bus_dmamem_free(sc->tx_desc_dtag, sc->tx_desc_base,
1989                                 sc->tx_desc_dmap);
1990                 bus_dma_tag_destroy(sc->tx_desc_dtag);
1991
1992                 sc->tx_desc_base = NULL;
1993         }
1994
1995         if (sc->tx_buf == NULL)
1996                 return;
1997
1998         for (i = 0; i < ndesc; i++) {
1999                 tx_buffer = &sc->tx_buf[i];
2000
2001                 KKASSERT(tx_buffer->m_head == NULL);
2002                 bus_dmamap_destroy(sc->txtag, tx_buffer->map);
2003         }
2004         bus_dma_tag_destroy(sc->txtag);
2005
2006         kfree(sc->tx_buf, M_DEVBUF);
2007         sc->tx_buf = NULL;
2008 }
2009
2010 /*
2011  * The offload context needs to be set when we transfer the first
2012  * packet of a particular protocol (TCP/UDP).  This routine has been
2013  * enhanced to deal with inserted VLAN headers.
2014  *
2015  * If the new packet's ether header length, ip header length and
2016  * csum offloading type are same as the previous packet, we should
2017  * avoid allocating a new csum context descriptor; mainly to take
2018  * advantage of the pipeline effect of the TX data read request.
2019  *
2020  * This function returns number of TX descrptors allocated for
2021  * csum context.
2022  */
2023 static int
2024 emx_txcsum(struct emx_softc *sc, struct mbuf *mp,
2025            uint32_t *txd_upper, uint32_t *txd_lower)
2026 {
2027         struct e1000_context_desc *TXD;
2028         struct emx_txbuf *tx_buffer;
2029         struct ether_vlan_header *eh;
2030         struct ip *ip;
2031         int curr_txd, ehdrlen, csum_flags;
2032         uint32_t cmd, hdr_len, ip_hlen;
2033         uint16_t etype;
2034
2035         /*
2036          * Determine where frame payload starts.
2037          * Jump over vlan headers if already present,
2038          * helpful for QinQ too.
2039          */
2040         KASSERT(mp->m_len >= ETHER_HDR_LEN,
2041                 ("emx_txcsum_pullup is not called (eh)?\n"));
2042         eh = mtod(mp, struct ether_vlan_header *);
2043         if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
2044                 KASSERT(mp->m_len >= ETHER_HDR_LEN + EVL_ENCAPLEN,
2045                         ("emx_txcsum_pullup is not called (evh)?\n"));
2046                 etype = ntohs(eh->evl_proto);
2047                 ehdrlen = ETHER_HDR_LEN + EVL_ENCAPLEN;
2048         } else {
2049                 etype = ntohs(eh->evl_encap_proto);
2050                 ehdrlen = ETHER_HDR_LEN;
2051         }
2052
2053         /*
2054          * We only support TCP/UDP for IPv4 for the moment.
2055          * TODO: Support SCTP too when it hits the tree.
2056          */
2057         if (etype != ETHERTYPE_IP)
2058                 return 0;
2059
2060         KASSERT(mp->m_len >= ehdrlen + EMX_IPVHL_SIZE,
2061                 ("emx_txcsum_pullup is not called (eh+ip_vhl)?\n"));
2062
2063         /* NOTE: We could only safely access ip.ip_vhl part */
2064         ip = (struct ip *)(mp->m_data + ehdrlen);
2065         ip_hlen = ip->ip_hl << 2;
2066
2067         csum_flags = mp->m_pkthdr.csum_flags & EMX_CSUM_FEATURES;
2068
2069         if (sc->csum_ehlen == ehdrlen && sc->csum_iphlen == ip_hlen &&
2070             sc->csum_flags == csum_flags) {
2071                 /*
2072                  * Same csum offload context as the previous packets;
2073                  * just return.
2074                  */
2075                 *txd_upper = sc->csum_txd_upper;
2076                 *txd_lower = sc->csum_txd_lower;
2077                 return 0;
2078         }
2079
2080         /*
2081          * Setup a new csum offload context.
2082          */
2083
2084         curr_txd = sc->next_avail_tx_desc;
2085         tx_buffer = &sc->tx_buf[curr_txd];
2086         TXD = (struct e1000_context_desc *)&sc->tx_desc_base[curr_txd];
2087
2088         cmd = 0;
2089
2090         /* Setup of IP header checksum. */
2091         if (csum_flags & CSUM_IP) {
2092                 /*
2093                  * Start offset for header checksum calculation.
2094                  * End offset for header checksum calculation.
2095                  * Offset of place to put the checksum.
2096                  */
2097                 TXD->lower_setup.ip_fields.ipcss = ehdrlen;
2098                 TXD->lower_setup.ip_fields.ipcse =
2099                     htole16(ehdrlen + ip_hlen - 1);
2100                 TXD->lower_setup.ip_fields.ipcso =
2101                     ehdrlen + offsetof(struct ip, ip_sum);
2102                 cmd |= E1000_TXD_CMD_IP;
2103                 *txd_upper |= E1000_TXD_POPTS_IXSM << 8;
2104         }
2105         hdr_len = ehdrlen + ip_hlen;
2106
2107         if (csum_flags & CSUM_TCP) {
2108                 /*
2109                  * Start offset for payload checksum calculation.
2110                  * End offset for payload checksum calculation.
2111                  * Offset of place to put the checksum.
2112                  */
2113                 TXD->upper_setup.tcp_fields.tucss = hdr_len;
2114                 TXD->upper_setup.tcp_fields.tucse = htole16(0);
2115                 TXD->upper_setup.tcp_fields.tucso =
2116                     hdr_len + offsetof(struct tcphdr, th_sum);
2117                 cmd |= E1000_TXD_CMD_TCP;
2118                 *txd_upper |= E1000_TXD_POPTS_TXSM << 8;
2119         } else if (csum_flags & CSUM_UDP) {
2120                 /*
2121                  * Start offset for header checksum calculation.
2122                  * End offset for header checksum calculation.
2123                  * Offset of place to put the checksum.
2124                  */
2125                 TXD->upper_setup.tcp_fields.tucss = hdr_len;
2126                 TXD->upper_setup.tcp_fields.tucse = htole16(0);
2127                 TXD->upper_setup.tcp_fields.tucso =
2128                     hdr_len + offsetof(struct udphdr, uh_sum);
2129                 *txd_upper |= E1000_TXD_POPTS_TXSM << 8;
2130         }
2131
2132         *txd_lower = E1000_TXD_CMD_DEXT |       /* Extended descr type */
2133                      E1000_TXD_DTYP_D;          /* Data descr */
2134
2135         /* Save the information for this csum offloading context */
2136         sc->csum_ehlen = ehdrlen;
2137         sc->csum_iphlen = ip_hlen;
2138         sc->csum_flags = csum_flags;
2139         sc->csum_txd_upper = *txd_upper;
2140         sc->csum_txd_lower = *txd_lower;
2141
2142         TXD->tcp_seg_setup.data = htole32(0);
2143         TXD->cmd_and_length =
2144             htole32(E1000_TXD_CMD_IFCS | E1000_TXD_CMD_DEXT | cmd);
2145
2146         if (++curr_txd == sc->num_tx_desc)
2147                 curr_txd = 0;
2148
2149         KKASSERT(sc->num_tx_desc_avail > 0);
2150         sc->num_tx_desc_avail--;
2151
2152         sc->next_avail_tx_desc = curr_txd;
2153         return 1;
2154 }
2155
2156 static int
2157 emx_txcsum_pullup(struct emx_softc *sc, struct mbuf **m0)
2158 {
2159         struct mbuf *m = *m0;
2160         struct ether_header *eh;
2161         int len;
2162
2163         sc->tx_csum_try_pullup++;
2164
2165         len = ETHER_HDR_LEN + EMX_IPVHL_SIZE;
2166
2167         if (__predict_false(!M_WRITABLE(m))) {
2168                 if (__predict_false(m->m_len < ETHER_HDR_LEN)) {
2169                         sc->tx_csum_drop1++;
2170                         m_freem(m);
2171                         *m0 = NULL;
2172                         return ENOBUFS;
2173                 }
2174                 eh = mtod(m, struct ether_header *);
2175
2176                 if (eh->ether_type == htons(ETHERTYPE_VLAN))
2177                         len += EVL_ENCAPLEN;
2178
2179                 if (m->m_len < len) {
2180                         sc->tx_csum_drop2++;
2181                         m_freem(m);
2182                         *m0 = NULL;
2183                         return ENOBUFS;
2184                 }
2185                 return 0;
2186         }
2187
2188         if (__predict_false(m->m_len < ETHER_HDR_LEN)) {
2189                 sc->tx_csum_pullup1++;
2190                 m = m_pullup(m, ETHER_HDR_LEN);
2191                 if (m == NULL) {
2192                         sc->tx_csum_pullup1_failed++;
2193                         *m0 = NULL;
2194                         return ENOBUFS;
2195                 }
2196                 *m0 = m;
2197         }
2198         eh = mtod(m, struct ether_header *);
2199
2200         if (eh->ether_type == htons(ETHERTYPE_VLAN))
2201                 len += EVL_ENCAPLEN;
2202
2203         if (m->m_len < len) {
2204                 sc->tx_csum_pullup2++;
2205                 m = m_pullup(m, len);
2206                 if (m == NULL) {
2207                         sc->tx_csum_pullup2_failed++;
2208                         *m0 = NULL;
2209                         return ENOBUFS;
2210                 }
2211                 *m0 = m;
2212         }
2213         return 0;
2214 }
2215
2216 static void
2217 emx_txeof(struct emx_softc *sc)
2218 {
2219         struct ifnet *ifp = &sc->arpcom.ac_if;
2220         struct emx_txbuf *tx_buffer;
2221         int first, num_avail;
2222
2223         if (sc->tx_dd_head == sc->tx_dd_tail)
2224                 return;
2225
2226         if (sc->num_tx_desc_avail == sc->num_tx_desc)
2227                 return;
2228
2229         num_avail = sc->num_tx_desc_avail;
2230         first = sc->next_tx_to_clean;
2231
2232         while (sc->tx_dd_head != sc->tx_dd_tail) {
2233                 int dd_idx = sc->tx_dd[sc->tx_dd_head];
2234                 struct e1000_tx_desc *tx_desc;
2235
2236                 tx_desc = &sc->tx_desc_base[dd_idx];
2237                 if (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) {
2238                         EMX_INC_TXDD_IDX(sc->tx_dd_head);
2239
2240                         if (++dd_idx == sc->num_tx_desc)
2241                                 dd_idx = 0;
2242
2243                         while (first != dd_idx) {
2244                                 logif(pkt_txclean);
2245
2246                                 num_avail++;
2247
2248                                 tx_buffer = &sc->tx_buf[first];
2249                                 if (tx_buffer->m_head) {
2250                                         ifp->if_opackets++;
2251                                         bus_dmamap_unload(sc->txtag,
2252                                                           tx_buffer->map);
2253                                         m_freem(tx_buffer->m_head);
2254                                         tx_buffer->m_head = NULL;
2255                                 }
2256
2257                                 if (++first == sc->num_tx_desc)
2258                                         first = 0;
2259                         }
2260                 } else {
2261                         break;
2262                 }
2263         }
2264         sc->next_tx_to_clean = first;
2265         sc->num_tx_desc_avail = num_avail;
2266
2267         if (sc->tx_dd_head == sc->tx_dd_tail) {
2268                 sc->tx_dd_head = 0;
2269                 sc->tx_dd_tail = 0;
2270         }
2271
2272         if (!EMX_IS_OACTIVE(sc)) {
2273                 ifp->if_flags &= ~IFF_OACTIVE;
2274
2275                 /* All clean, turn off the timer */
2276                 if (sc->num_tx_desc_avail == sc->num_tx_desc)
2277                         ifp->if_timer = 0;
2278         }
2279 }
2280
2281 static void
2282 emx_tx_collect(struct emx_softc *sc)
2283 {
2284         struct ifnet *ifp = &sc->arpcom.ac_if;
2285         struct emx_txbuf *tx_buffer;
2286         int tdh, first, num_avail, dd_idx = -1;
2287
2288         if (sc->num_tx_desc_avail == sc->num_tx_desc)
2289                 return;
2290
2291         tdh = E1000_READ_REG(&sc->hw, E1000_TDH(0));
2292         if (tdh == sc->next_tx_to_clean)
2293                 return;
2294
2295         if (sc->tx_dd_head != sc->tx_dd_tail)
2296                 dd_idx = sc->tx_dd[sc->tx_dd_head];
2297
2298         num_avail = sc->num_tx_desc_avail;
2299         first = sc->next_tx_to_clean;
2300
2301         while (first != tdh) {
2302                 logif(pkt_txclean);
2303
2304                 num_avail++;
2305
2306                 tx_buffer = &sc->tx_buf[first];
2307                 if (tx_buffer->m_head) {
2308                         ifp->if_opackets++;
2309                         bus_dmamap_unload(sc->txtag,
2310                                           tx_buffer->map);
2311                         m_freem(tx_buffer->m_head);
2312                         tx_buffer->m_head = NULL;
2313                 }
2314
2315                 if (first == dd_idx) {
2316                         EMX_INC_TXDD_IDX(sc->tx_dd_head);
2317                         if (sc->tx_dd_head == sc->tx_dd_tail) {
2318                                 sc->tx_dd_head = 0;
2319                                 sc->tx_dd_tail = 0;
2320                                 dd_idx = -1;
2321                         } else {
2322                                 dd_idx = sc->tx_dd[sc->tx_dd_head];
2323                         }
2324                 }
2325
2326                 if (++first == sc->num_tx_desc)
2327                         first = 0;
2328         }
2329         sc->next_tx_to_clean = first;
2330         sc->num_tx_desc_avail = num_avail;
2331
2332         if (!EMX_IS_OACTIVE(sc)) {
2333                 ifp->if_flags &= ~IFF_OACTIVE;
2334
2335                 /* All clean, turn off the timer */
2336                 if (sc->num_tx_desc_avail == sc->num_tx_desc)
2337                         ifp->if_timer = 0;
2338         }
2339 }
2340
2341 /*
2342  * When Link is lost sometimes there is work still in the TX ring
2343  * which will result in a watchdog, rather than allow that do an
2344  * attempted cleanup and then reinit here.  Note that this has been
2345  * seens mostly with fiber adapters.
2346  */
2347 static void
2348 emx_tx_purge(struct emx_softc *sc)
2349 {
2350         struct ifnet *ifp = &sc->arpcom.ac_if;
2351
2352         if (!sc->link_active && ifp->if_timer) {
2353                 emx_tx_collect(sc);
2354                 if (ifp->if_timer) {
2355                         if_printf(ifp, "Link lost, TX pending, reinit\n");
2356                         ifp->if_timer = 0;
2357                         emx_init(sc);
2358                 }
2359         }
2360 }
2361
2362 static int
2363 emx_newbuf(struct emx_softc *sc, struct emx_rxdata *rdata, int i, int init)
2364 {
2365         struct mbuf *m;
2366         bus_dma_segment_t seg;
2367         bus_dmamap_t map;
2368         struct emx_rxbuf *rx_buffer;
2369         int error, nseg;
2370
2371         m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
2372         if (m == NULL) {
2373                 rdata->mbuf_cluster_failed++;
2374                 if (init) {
2375                         if_printf(&sc->arpcom.ac_if,
2376                                   "Unable to allocate RX mbuf\n");
2377                 }
2378                 return (ENOBUFS);
2379         }
2380         m->m_len = m->m_pkthdr.len = MCLBYTES;
2381
2382         if (sc->max_frame_size <= MCLBYTES - ETHER_ALIGN)
2383                 m_adj(m, ETHER_ALIGN);
2384
2385         error = bus_dmamap_load_mbuf_segment(rdata->rxtag,
2386                         rdata->rx_sparemap, m,
2387                         &seg, 1, &nseg, BUS_DMA_NOWAIT);
2388         if (error) {
2389                 m_freem(m);
2390                 if (init) {
2391                         if_printf(&sc->arpcom.ac_if,
2392                                   "Unable to load RX mbuf\n");
2393                 }
2394                 return (error);
2395         }
2396
2397         rx_buffer = &rdata->rx_buf[i];
2398         if (rx_buffer->m_head != NULL)
2399                 bus_dmamap_unload(rdata->rxtag, rx_buffer->map);
2400
2401         map = rx_buffer->map;
2402         rx_buffer->map = rdata->rx_sparemap;
2403         rdata->rx_sparemap = map;
2404
2405         rx_buffer->m_head = m;
2406         rx_buffer->paddr = seg.ds_addr;
2407
2408         emx_setup_rxdesc(&rdata->rx_desc[i], rx_buffer);
2409         return (0);
2410 }
2411
2412 static int
2413 emx_create_rx_ring(struct emx_softc *sc, struct emx_rxdata *rdata)
2414 {
2415         device_t dev = sc->dev;
2416         struct emx_rxbuf *rx_buffer;
2417         int i, error, rsize;
2418
2419         /*
2420          * Validate number of receive descriptors.  It must not exceed
2421          * hardware maximum, and must be multiple of E1000_DBA_ALIGN.
2422          */
2423         if ((emx_rxd * sizeof(emx_rxdesc_t)) % EMX_DBA_ALIGN != 0 ||
2424             emx_rxd > EMX_MAX_RXD || emx_rxd < EMX_MIN_RXD) {
2425                 device_printf(dev, "Using %d RX descriptors instead of %d!\n",
2426                     EMX_DEFAULT_RXD, emx_rxd);
2427                 rdata->num_rx_desc = EMX_DEFAULT_RXD;
2428         } else {
2429                 rdata->num_rx_desc = emx_rxd;
2430         }
2431
2432         /*
2433          * Allocate Receive Descriptor ring
2434          */
2435         rsize = roundup2(rdata->num_rx_desc * sizeof(emx_rxdesc_t),
2436                          EMX_DBA_ALIGN);
2437         rdata->rx_desc = bus_dmamem_coherent_any(sc->parent_dtag,
2438                                 EMX_DBA_ALIGN, rsize, BUS_DMA_WAITOK,
2439                                 &rdata->rx_desc_dtag, &rdata->rx_desc_dmap,
2440                                 &rdata->rx_desc_paddr);
2441         if (rdata->rx_desc == NULL) {
2442                 device_printf(dev, "Unable to allocate rx_desc memory\n");
2443                 return ENOMEM;
2444         }
2445
2446         rdata->rx_buf = kmalloc(sizeof(struct emx_rxbuf) * rdata->num_rx_desc,
2447                                 M_DEVBUF, M_WAITOK | M_ZERO);
2448
2449         /*
2450          * Create DMA tag for rx buffers
2451          */
2452         error = bus_dma_tag_create(sc->parent_dtag, /* parent */
2453                         1, 0,                   /* alignment, bounds */
2454                         BUS_SPACE_MAXADDR,      /* lowaddr */
2455                         BUS_SPACE_MAXADDR,      /* highaddr */
2456                         NULL, NULL,             /* filter, filterarg */
2457                         MCLBYTES,               /* maxsize */
2458                         1,                      /* nsegments */
2459                         MCLBYTES,               /* maxsegsize */
2460                         BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW, /* flags */
2461                         &rdata->rxtag);
2462         if (error) {
2463                 device_printf(dev, "Unable to allocate RX DMA tag\n");
2464                 kfree(rdata->rx_buf, M_DEVBUF);
2465                 rdata->rx_buf = NULL;
2466                 return error;
2467         }
2468
2469         /*
2470          * Create spare DMA map for rx buffers
2471          */
2472         error = bus_dmamap_create(rdata->rxtag, BUS_DMA_WAITOK,
2473                                   &rdata->rx_sparemap);
2474         if (error) {
2475                 device_printf(dev, "Unable to create spare RX DMA map\n");
2476                 bus_dma_tag_destroy(rdata->rxtag);
2477                 kfree(rdata->rx_buf, M_DEVBUF);
2478                 rdata->rx_buf = NULL;
2479                 return error;
2480         }
2481
2482         /*
2483          * Create DMA maps for rx buffers
2484          */
2485         for (i = 0; i < rdata->num_rx_desc; i++) {
2486                 rx_buffer = &rdata->rx_buf[i];
2487
2488                 error = bus_dmamap_create(rdata->rxtag, BUS_DMA_WAITOK,
2489                                           &rx_buffer->map);
2490                 if (error) {
2491                         device_printf(dev, "Unable to create RX DMA map\n");
2492                         emx_destroy_rx_ring(sc, rdata, i);
2493                         return error;
2494                 }
2495         }
2496         return (0);
2497 }
2498
2499 static void
2500 emx_free_rx_ring(struct emx_softc *sc, struct emx_rxdata *rdata)
2501 {
2502         int i;
2503
2504         for (i = 0; i < rdata->num_rx_desc; i++) {
2505                 struct emx_rxbuf *rx_buffer = &rdata->rx_buf[i];
2506
2507                 if (rx_buffer->m_head != NULL) {
2508                         bus_dmamap_unload(rdata->rxtag, rx_buffer->map);
2509                         m_freem(rx_buffer->m_head);
2510                         rx_buffer->m_head = NULL;
2511                 }
2512         }
2513
2514         if (rdata->fmp != NULL)
2515                 m_freem(rdata->fmp);
2516         rdata->fmp = NULL;
2517         rdata->lmp = NULL;
2518 }
2519
2520 static int
2521 emx_init_rx_ring(struct emx_softc *sc, struct emx_rxdata *rdata)
2522 {
2523         int i, error;
2524
2525         /* Reset descriptor ring */
2526         bzero(rdata->rx_desc, sizeof(emx_rxdesc_t) * rdata->num_rx_desc);
2527
2528         /* Allocate new ones. */
2529         for (i = 0; i < rdata->num_rx_desc; i++) {
2530                 error = emx_newbuf(sc, rdata, i, 1);
2531                 if (error)
2532                         return (error);
2533         }
2534
2535         /* Setup our descriptor pointers */
2536         rdata->next_rx_desc_to_check = 0;
2537
2538         return (0);
2539 }
2540
2541 static void
2542 emx_init_rx_unit(struct emx_softc *sc)
2543 {
2544         struct ifnet *ifp = &sc->arpcom.ac_if;
2545         uint64_t bus_addr;
2546         uint32_t rctl, rxcsum, rfctl, key, reta;
2547         int i;
2548
2549         /*
2550          * Make sure receives are disabled while setting
2551          * up the descriptor ring
2552          */
2553         rctl = E1000_READ_REG(&sc->hw, E1000_RCTL);
2554         E1000_WRITE_REG(&sc->hw, E1000_RCTL, rctl & ~E1000_RCTL_EN);
2555
2556         /*
2557          * Set the interrupt throttling rate. Value is calculated
2558          * as ITR = 1 / (INT_THROTTLE_CEIL * 256ns)
2559          */
2560         if (sc->int_throttle_ceil) {
2561                 E1000_WRITE_REG(&sc->hw, E1000_ITR,
2562                         1000000000 / 256 / sc->int_throttle_ceil);
2563         } else {
2564                 E1000_WRITE_REG(&sc->hw, E1000_ITR, 0);
2565         }
2566
2567         /* Use extended RX descriptor */
2568         rfctl = E1000_RFCTL_EXTEN;
2569
2570         /* Disable accelerated ackknowledge */
2571         if (sc->hw.mac.type == e1000_82574)
2572                 rfctl |= E1000_RFCTL_ACK_DIS;
2573
2574         E1000_WRITE_REG(&sc->hw, E1000_RFCTL, rfctl);
2575
2576         /* Setup the Base and Length of the Rx Descriptor Ring */
2577         for (i = 0; i < sc->rx_ring_cnt; ++i) {
2578                 struct emx_rxdata *rdata = &sc->rx_data[i];
2579
2580                 bus_addr = rdata->rx_desc_paddr;
2581                 E1000_WRITE_REG(&sc->hw, E1000_RDLEN(i),
2582                     rdata->num_rx_desc * sizeof(emx_rxdesc_t));
2583                 E1000_WRITE_REG(&sc->hw, E1000_RDBAH(i),
2584                     (uint32_t)(bus_addr >> 32));
2585                 E1000_WRITE_REG(&sc->hw, E1000_RDBAL(i),
2586                     (uint32_t)bus_addr);
2587         }
2588
2589         /* Setup the Receive Control Register */
2590         rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
2591         rctl |= E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
2592                 E1000_RCTL_RDMTS_HALF | E1000_RCTL_SECRC |
2593                 (sc->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
2594
2595         /* Make sure VLAN Filters are off */
2596         rctl &= ~E1000_RCTL_VFE;
2597
2598         /* Don't store bad paket */
2599         rctl &= ~E1000_RCTL_SBP;
2600
2601         /* MCLBYTES */
2602         rctl |= E1000_RCTL_SZ_2048;
2603
2604         if (ifp->if_mtu > ETHERMTU)
2605                 rctl |= E1000_RCTL_LPE;
2606         else
2607                 rctl &= ~E1000_RCTL_LPE;
2608
2609         /*
2610          * Receive Checksum Offload for TCP and UDP
2611          *
2612          * Checksum offloading is also enabled if multiple receive
2613          * queue is to be supported, since we need it to figure out
2614          * packet type.
2615          */
2616         if (EMX_RSS_ENABLED(sc) && (ifp->if_capenable & IFCAP_RXCSUM)) {
2617                 rxcsum = E1000_READ_REG(&sc->hw, E1000_RXCSUM);
2618
2619                 /*
2620                  * NOTE:
2621                  * PCSD must be enabled to enable multiple
2622                  * receive queues.
2623                  */
2624                 rxcsum |= E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL |
2625                           E1000_RXCSUM_PCSD;
2626                 E1000_WRITE_REG(&sc->hw, E1000_RXCSUM, rxcsum);
2627         }
2628
2629         /*
2630          * Configure multiple receive queue (RSS)
2631          */
2632         if (EMX_RSS_ENABLED(sc)) {
2633                 /*
2634                  * NOTE:
2635                  * When we reach here, RSS has already been disabled
2636                  * in emx_stop(), so we could safely configure RSS key
2637                  * and redirect table.
2638                  */
2639
2640                 /*
2641                  * Configure RSS key
2642                  */
2643                 key = 0x5a6d5a6d; /* XXX */
2644                 for (i = 0; i < EMX_NRSSRK; ++i)
2645                         E1000_WRITE_REG(&sc->hw, E1000_RSSRK(i), key);
2646
2647                 /*
2648                  * Configure RSS redirect table
2649                  */
2650                 reta = 0x80008000;
2651                 for (i = 0; i < EMX_NRETA; ++i)
2652                         E1000_WRITE_REG(&sc->hw, E1000_RETA(i), reta);
2653
2654                 /*
2655                  * Enable multiple receive queues.
2656                  * Enable IPv4 RSS standard hash functions.
2657                  * Disable RSS interrupt.
2658                  */
2659                 E1000_WRITE_REG(&sc->hw, E1000_MRQC,
2660                                 E1000_MRQC_ENABLE_RSS_2Q |
2661                                 E1000_MRQC_RSS_FIELD_IPV4_TCP |
2662                                 E1000_MRQC_RSS_FIELD_IPV4);
2663         }
2664
2665         /*
2666          * XXX TEMPORARY WORKAROUND: on some systems with 82573
2667          * long latencies are observed, like Lenovo X60. This
2668          * change eliminates the problem, but since having positive
2669          * values in RDTR is a known source of problems on other
2670          * platforms another solution is being sought.
2671          */
2672         if (emx_82573_workaround && sc->hw.mac.type == e1000_82573) {
2673                 E1000_WRITE_REG(&sc->hw, E1000_RADV, EMX_RADV_82573);
2674                 E1000_WRITE_REG(&sc->hw, E1000_RDTR, EMX_RDTR_82573);
2675         }
2676
2677         /*
2678          * Setup the HW Rx Head and Tail Descriptor Pointers
2679          */
2680         for (i = 0; i < sc->rx_ring_cnt; ++i) {
2681                 E1000_WRITE_REG(&sc->hw, E1000_RDH(i), 0);
2682                 E1000_WRITE_REG(&sc->hw, E1000_RDT(i),
2683                     sc->rx_data[i].num_rx_desc - 1);
2684         }
2685
2686         /* Enable Receives */
2687         E1000_WRITE_REG(&sc->hw, E1000_RCTL, rctl);
2688 }
2689
2690 static void
2691 emx_destroy_rx_ring(struct emx_softc *sc, struct emx_rxdata *rdata, int ndesc)
2692 {
2693         struct emx_rxbuf *rx_buffer;
2694         int i;
2695
2696         /* Free Receive Descriptor ring */
2697         if (rdata->rx_desc) {
2698                 bus_dmamap_unload(rdata->rx_desc_dtag, rdata->rx_desc_dmap);
2699                 bus_dmamem_free(rdata->rx_desc_dtag, rdata->rx_desc,
2700                                 rdata->rx_desc_dmap);
2701                 bus_dma_tag_destroy(rdata->rx_desc_dtag);
2702
2703                 rdata->rx_desc = NULL;
2704         }
2705
2706         if (rdata->rx_buf == NULL)
2707                 return;
2708
2709         for (i = 0; i < ndesc; i++) {
2710                 rx_buffer = &rdata->rx_buf[i];
2711
2712                 KKASSERT(rx_buffer->m_head == NULL);
2713                 bus_dmamap_destroy(rdata->rxtag, rx_buffer->map);
2714         }
2715         bus_dmamap_destroy(rdata->rxtag, rdata->rx_sparemap);
2716         bus_dma_tag_destroy(rdata->rxtag);
2717
2718         kfree(rdata->rx_buf, M_DEVBUF);
2719         rdata->rx_buf = NULL;
2720 }
2721
2722 static void
2723 emx_rxeof(struct emx_softc *sc, int ring_idx, int count)
2724 {
2725         struct emx_rxdata *rdata = &sc->rx_data[ring_idx];
2726         struct ifnet *ifp = &sc->arpcom.ac_if;
2727         uint32_t staterr;
2728         emx_rxdesc_t *current_desc;
2729         struct mbuf *mp;
2730         int i;
2731         struct mbuf_chain chain[MAXCPU];
2732
2733         i = rdata->next_rx_desc_to_check;
2734         current_desc = &rdata->rx_desc[i];
2735         staterr = le32toh(current_desc->rxd_staterr);
2736
2737         if (!(staterr & E1000_RXD_STAT_DD))
2738                 return;
2739
2740         ether_input_chain_init(chain);
2741
2742         while ((staterr & E1000_RXD_STAT_DD) && count != 0) {
2743                 struct emx_rxbuf *rx_buf = &rdata->rx_buf[i];
2744                 struct mbuf *m = NULL;
2745                 int eop, len;
2746
2747                 logif(pkt_receive);
2748
2749                 mp = rx_buf->m_head;
2750
2751                 /*
2752                  * Can't defer bus_dmamap_sync(9) because TBI_ACCEPT
2753                  * needs to access the last received byte in the mbuf.
2754                  */
2755                 bus_dmamap_sync(rdata->rxtag, rx_buf->map,
2756                                 BUS_DMASYNC_POSTREAD);
2757
2758                 len = le16toh(current_desc->rxd_length);
2759                 if (staterr & E1000_RXD_STAT_EOP) {
2760                         count--;
2761                         eop = 1;
2762                 } else {
2763                         eop = 0;
2764                 }
2765
2766                 if (!(staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK)) {
2767                         uint16_t vlan = 0;
2768                         uint32_t mrq, rss_hash;
2769
2770                         /*
2771                          * Save several necessary information,
2772                          * before emx_newbuf() destroy it.
2773                          */
2774                         if ((staterr & E1000_RXD_STAT_VP) && eop)
2775                                 vlan = le16toh(current_desc->rxd_vlan);
2776
2777                         mrq = le32toh(current_desc->rxd_mrq);
2778                         rss_hash = le32toh(current_desc->rxd_rss);
2779
2780                         EMX_RSS_DPRINTF(sc, 10,
2781                             "ring%d, mrq 0x%08x, rss_hash 0x%08x\n",
2782                             ring_idx, mrq, rss_hash);
2783
2784                         if (emx_newbuf(sc, rdata, i, 0) != 0) {
2785                                 ifp->if_iqdrops++;
2786                                 goto discard;
2787                         }
2788
2789                         /* Assign correct length to the current fragment */
2790                         mp->m_len = len;
2791
2792                         if (rdata->fmp == NULL) {
2793                                 mp->m_pkthdr.len = len;
2794                                 rdata->fmp = mp; /* Store the first mbuf */
2795                                 rdata->lmp = mp;
2796                         } else {
2797                                 /*
2798                                  * Chain mbuf's together
2799                                  */
2800                                 rdata->lmp->m_next = mp;
2801                                 rdata->lmp = rdata->lmp->m_next;
2802                                 rdata->fmp->m_pkthdr.len += len;
2803                         }
2804
2805                         if (eop) {
2806                                 rdata->fmp->m_pkthdr.rcvif = ifp;
2807                                 ifp->if_ipackets++;
2808
2809                                 if (ifp->if_capenable & IFCAP_RXCSUM)
2810                                         emx_rxcsum(staterr, rdata->fmp);
2811
2812                                 if (staterr & E1000_RXD_STAT_VP) {
2813                                         rdata->fmp->m_pkthdr.ether_vlantag =
2814                                             vlan;
2815                                         rdata->fmp->m_flags |= M_VLANTAG;
2816                                 }
2817                                 m = rdata->fmp;
2818                                 rdata->fmp = NULL;
2819                                 rdata->lmp = NULL;
2820
2821 #ifdef EMX_RSS_DEBUG
2822                                 rdata->rx_pkts++;
2823 #endif
2824                         }
2825                 } else {
2826                         ifp->if_ierrors++;
2827 discard:
2828                         emx_setup_rxdesc(current_desc, rx_buf);
2829                         if (rdata->fmp != NULL) {
2830                                 m_freem(rdata->fmp);
2831                                 rdata->fmp = NULL;
2832                                 rdata->lmp = NULL;
2833                         }
2834                         m = NULL;
2835                 }
2836
2837                 if (m != NULL)
2838                         ether_input_chain(ifp, m, chain);
2839
2840                 /* Advance our pointers to the next descriptor. */
2841                 if (++i == rdata->num_rx_desc)
2842                         i = 0;
2843
2844                 current_desc = &rdata->rx_desc[i];
2845                 staterr = le32toh(current_desc->rxd_staterr);
2846         }
2847         rdata->next_rx_desc_to_check = i;
2848
2849         ether_input_dispatch(chain);
2850
2851         /* Advance the E1000's Receive Queue "Tail Pointer". */
2852         if (--i < 0)
2853                 i = rdata->num_rx_desc - 1;
2854         E1000_WRITE_REG(&sc->hw, E1000_RDT(ring_idx), i);
2855 }
2856
2857 static void
2858 emx_enable_intr(struct emx_softc *sc)
2859 {
2860         lwkt_serialize_handler_enable(sc->arpcom.ac_if.if_serializer);
2861         E1000_WRITE_REG(&sc->hw, E1000_IMS, IMS_ENABLE_MASK);
2862 }
2863
2864 static void
2865 emx_disable_intr(struct emx_softc *sc)
2866 {
2867         E1000_WRITE_REG(&sc->hw, E1000_IMC, 0xffffffff);
2868         lwkt_serialize_handler_disable(sc->arpcom.ac_if.if_serializer);
2869 }
2870
2871 /*
2872  * Bit of a misnomer, what this really means is
2873  * to enable OS management of the system... aka
2874  * to disable special hardware management features 
2875  */
2876 static void
2877 emx_get_mgmt(struct emx_softc *sc)
2878 {
2879         /* A shared code workaround */
2880         if (sc->has_manage) {
2881                 int manc2h = E1000_READ_REG(&sc->hw, E1000_MANC2H);
2882                 int manc = E1000_READ_REG(&sc->hw, E1000_MANC);
2883
2884                 /* disable hardware interception of ARP */
2885                 manc &= ~(E1000_MANC_ARP_EN);
2886
2887                 /* enable receiving management packets to the host */
2888                 manc |= E1000_MANC_EN_MNG2HOST;
2889 #define E1000_MNG2HOST_PORT_623 (1 << 5)
2890 #define E1000_MNG2HOST_PORT_664 (1 << 6)
2891                 manc2h |= E1000_MNG2HOST_PORT_623;
2892                 manc2h |= E1000_MNG2HOST_PORT_664;
2893                 E1000_WRITE_REG(&sc->hw, E1000_MANC2H, manc2h);
2894
2895                 E1000_WRITE_REG(&sc->hw, E1000_MANC, manc);
2896         }
2897 }
2898
2899 /*
2900  * Give control back to hardware management
2901  * controller if there is one.
2902  */
2903 static void
2904 emx_rel_mgmt(struct emx_softc *sc)
2905 {
2906         if (sc->has_manage) {
2907                 int manc = E1000_READ_REG(&sc->hw, E1000_MANC);
2908
2909                 /* re-enable hardware interception of ARP */
2910                 manc |= E1000_MANC_ARP_EN;
2911                 manc &= ~E1000_MANC_EN_MNG2HOST;
2912
2913                 E1000_WRITE_REG(&sc->hw, E1000_MANC, manc);
2914         }
2915 }
2916
2917 /*
2918  * emx_get_hw_control() sets {CTRL_EXT|FWSM}:DRV_LOAD bit.
2919  * For ASF and Pass Through versions of f/w this means that
2920  * the driver is loaded.  For AMT version (only with 82573)
2921  * of the f/w this means that the network i/f is open.
2922  */
2923 static void
2924 emx_get_hw_control(struct emx_softc *sc)
2925 {
2926         uint32_t ctrl_ext, swsm;
2927
2928         /* Let firmware know the driver has taken over */
2929         switch (sc->hw.mac.type) {
2930         case e1000_82573:
2931                 swsm = E1000_READ_REG(&sc->hw, E1000_SWSM);
2932                 E1000_WRITE_REG(&sc->hw, E1000_SWSM,
2933                     swsm | E1000_SWSM_DRV_LOAD);
2934                 break;
2935
2936         case e1000_82571:
2937         case e1000_82572:
2938         case e1000_80003es2lan:
2939                 ctrl_ext = E1000_READ_REG(&sc->hw, E1000_CTRL_EXT);
2940                 E1000_WRITE_REG(&sc->hw, E1000_CTRL_EXT,
2941                     ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
2942                 break;
2943
2944         default:
2945                 break;
2946         }
2947 }
2948
2949 /*
2950  * emx_rel_hw_control() resets {CTRL_EXT|FWSM}:DRV_LOAD bit.
2951  * For ASF and Pass Through versions of f/w this means that the
2952  * driver is no longer loaded.  For AMT version (only with 82573)
2953  * of the f/w this means that the network i/f is closed.
2954  */
2955 static void
2956 emx_rel_hw_control(struct emx_softc *sc)
2957 {
2958         uint32_t ctrl_ext, swsm;
2959
2960         /* Let firmware taken over control of h/w */
2961         switch (sc->hw.mac.type) {
2962         case e1000_82573:
2963                 swsm = E1000_READ_REG(&sc->hw, E1000_SWSM);
2964                 E1000_WRITE_REG(&sc->hw, E1000_SWSM,
2965                     swsm & ~E1000_SWSM_DRV_LOAD);
2966                 break;
2967
2968         case e1000_82571:
2969         case e1000_82572:
2970         case e1000_80003es2lan:
2971                 ctrl_ext = E1000_READ_REG(&sc->hw, E1000_CTRL_EXT);
2972                 E1000_WRITE_REG(&sc->hw, E1000_CTRL_EXT,
2973                     ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
2974                 break;
2975
2976         default:
2977                 break;
2978         }
2979 }
2980
2981 static int
2982 emx_is_valid_eaddr(const uint8_t *addr)
2983 {
2984         char zero_addr[ETHER_ADDR_LEN] = { 0, 0, 0, 0, 0, 0 };
2985
2986         if ((addr[0] & 1) || !bcmp(addr, zero_addr, ETHER_ADDR_LEN))
2987                 return (FALSE);
2988
2989         return (TRUE);
2990 }
2991
2992 /*
2993  * Enable PCI Wake On Lan capability
2994  */
2995 void
2996 emx_enable_wol(device_t dev)
2997 {
2998         uint16_t cap, status;
2999         uint8_t id;
3000
3001         /* First find the capabilities pointer*/
3002         cap = pci_read_config(dev, PCIR_CAP_PTR, 2);
3003
3004         /* Read the PM Capabilities */
3005         id = pci_read_config(dev, cap, 1);
3006         if (id != PCIY_PMG)     /* Something wrong */
3007                 return;
3008
3009         /*
3010          * OK, we have the power capabilities,
3011          * so now get the status register
3012          */
3013         cap += PCIR_POWER_STATUS;
3014         status = pci_read_config(dev, cap, 2);
3015         status |= PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE;
3016         pci_write_config(dev, cap, status, 2);
3017 }
3018
3019 static void
3020 emx_update_stats(struct emx_softc *sc)
3021 {
3022         struct ifnet *ifp = &sc->arpcom.ac_if;
3023
3024         if (sc->hw.phy.media_type == e1000_media_type_copper ||
3025             (E1000_READ_REG(&sc->hw, E1000_STATUS) & E1000_STATUS_LU)) {
3026                 sc->stats.symerrs += E1000_READ_REG(&sc->hw, E1000_SYMERRS);
3027                 sc->stats.sec += E1000_READ_REG(&sc->hw, E1000_SEC);
3028         }
3029         sc->stats.crcerrs += E1000_READ_REG(&sc->hw, E1000_CRCERRS);
3030         sc->stats.mpc += E1000_READ_REG(&sc->hw, E1000_MPC);
3031         sc->stats.scc += E1000_READ_REG(&sc->hw, E1000_SCC);
3032         sc->stats.ecol += E1000_READ_REG(&sc->hw, E1000_ECOL);
3033
3034         sc->stats.mcc += E1000_READ_REG(&sc->hw, E1000_MCC);
3035         sc->stats.latecol += E1000_READ_REG(&sc->hw, E1000_LATECOL);
3036         sc->stats.colc += E1000_READ_REG(&sc->hw, E1000_COLC);
3037         sc->stats.dc += E1000_READ_REG(&sc->hw, E1000_DC);
3038         sc->stats.rlec += E1000_READ_REG(&sc->hw, E1000_RLEC);
3039         sc->stats.xonrxc += E1000_READ_REG(&sc->hw, E1000_XONRXC);
3040         sc->stats.xontxc += E1000_READ_REG(&sc->hw, E1000_XONTXC);
3041         sc->stats.xoffrxc += E1000_READ_REG(&sc->hw, E1000_XOFFRXC);
3042         sc->stats.xofftxc += E1000_READ_REG(&sc->hw, E1000_XOFFTXC);
3043         sc->stats.fcruc += E1000_READ_REG(&sc->hw, E1000_FCRUC);
3044         sc->stats.prc64 += E1000_READ_REG(&sc->hw, E1000_PRC64);
3045         sc->stats.prc127 += E1000_READ_REG(&sc->hw, E1000_PRC127);
3046         sc->stats.prc255 += E1000_READ_REG(&sc->hw, E1000_PRC255);
3047         sc->stats.prc511 += E1000_READ_REG(&sc->hw, E1000_PRC511);
3048         sc->stats.prc1023 += E1000_READ_REG(&sc->hw, E1000_PRC1023);
3049         sc->stats.prc1522 += E1000_READ_REG(&sc->hw, E1000_PRC1522);
3050         sc->stats.gprc += E1000_READ_REG(&sc->hw, E1000_GPRC);
3051         sc->stats.bprc += E1000_READ_REG(&sc->hw, E1000_BPRC);
3052         sc->stats.mprc += E1000_READ_REG(&sc->hw, E1000_MPRC);
3053         sc->stats.gptc += E1000_READ_REG(&sc->hw, E1000_GPTC);
3054
3055         /* For the 64-bit byte counters the low dword must be read first. */
3056         /* Both registers clear on the read of the high dword */
3057
3058         sc->stats.gorc += E1000_READ_REG(&sc->hw, E1000_GORCH);
3059         sc->stats.gotc += E1000_READ_REG(&sc->hw, E1000_GOTCH);
3060
3061         sc->stats.rnbc += E1000_READ_REG(&sc->hw, E1000_RNBC);
3062         sc->stats.ruc += E1000_READ_REG(&sc->hw, E1000_RUC);
3063         sc->stats.rfc += E1000_READ_REG(&sc->hw, E1000_RFC);
3064         sc->stats.roc += E1000_READ_REG(&sc->hw, E1000_ROC);
3065         sc->stats.rjc += E1000_READ_REG(&sc->hw, E1000_RJC);
3066
3067         sc->stats.tor += E1000_READ_REG(&sc->hw, E1000_TORH);
3068         sc->stats.tot += E1000_READ_REG(&sc->hw, E1000_TOTH);
3069
3070         sc->stats.tpr += E1000_READ_REG(&sc->hw, E1000_TPR);
3071         sc->stats.tpt += E1000_READ_REG(&sc->hw, E1000_TPT);
3072         sc->stats.ptc64 += E1000_READ_REG(&sc->hw, E1000_PTC64);
3073         sc->stats.ptc127 += E1000_READ_REG(&sc->hw, E1000_PTC127);
3074         sc->stats.ptc255 += E1000_READ_REG(&sc->hw, E1000_PTC255);
3075         sc->stats.ptc511 += E1000_READ_REG(&sc->hw, E1000_PTC511);
3076         sc->stats.ptc1023 += E1000_READ_REG(&sc->hw, E1000_PTC1023);
3077         sc->stats.ptc1522 += E1000_READ_REG(&sc->hw, E1000_PTC1522);
3078         sc->stats.mptc += E1000_READ_REG(&sc->hw, E1000_MPTC);
3079         sc->stats.bptc += E1000_READ_REG(&sc->hw, E1000_BPTC);
3080
3081         sc->stats.algnerrc += E1000_READ_REG(&sc->hw, E1000_ALGNERRC);
3082         sc->stats.rxerrc += E1000_READ_REG(&sc->hw, E1000_RXERRC);
3083         sc->stats.tncrs += E1000_READ_REG(&sc->hw, E1000_TNCRS);
3084         sc->stats.cexterr += E1000_READ_REG(&sc->hw, E1000_CEXTERR);
3085         sc->stats.tsctc += E1000_READ_REG(&sc->hw, E1000_TSCTC);
3086         sc->stats.tsctfc += E1000_READ_REG(&sc->hw, E1000_TSCTFC);
3087
3088         ifp->if_collisions = sc->stats.colc;
3089
3090         /* Rx Errors */
3091         ifp->if_ierrors = sc->dropped_pkts + sc->stats.rxerrc +
3092                           sc->stats.crcerrs + sc->stats.algnerrc +
3093                           sc->stats.ruc + sc->stats.roc +
3094                           sc->stats.mpc + sc->stats.cexterr;
3095
3096         /* Tx Errors */
3097         ifp->if_oerrors = sc->stats.ecol + sc->stats.latecol +
3098                           sc->watchdog_events;
3099 }
3100
3101 static void
3102 emx_print_debug_info(struct emx_softc *sc)
3103 {
3104         device_t dev = sc->dev;
3105         uint8_t *hw_addr = sc->hw.hw_addr;
3106
3107         device_printf(dev, "Adapter hardware address = %p \n", hw_addr);
3108         device_printf(dev, "CTRL = 0x%x RCTL = 0x%x \n",
3109             E1000_READ_REG(&sc->hw, E1000_CTRL),
3110             E1000_READ_REG(&sc->hw, E1000_RCTL));
3111         device_printf(dev, "Packet buffer = Tx=%dk Rx=%dk \n",
3112             ((E1000_READ_REG(&sc->hw, E1000_PBA) & 0xffff0000) >> 16),\
3113             (E1000_READ_REG(&sc->hw, E1000_PBA) & 0xffff) );
3114         device_printf(dev, "Flow control watermarks high = %d low = %d\n",
3115             sc->hw.fc.high_water, sc->hw.fc.low_water);
3116         device_printf(dev, "tx_int_delay = %d, tx_abs_int_delay = %d\n",
3117             E1000_READ_REG(&sc->hw, E1000_TIDV),
3118             E1000_READ_REG(&sc->hw, E1000_TADV));
3119         device_printf(dev, "rx_int_delay = %d, rx_abs_int_delay = %d\n",
3120             E1000_READ_REG(&sc->hw, E1000_RDTR),
3121             E1000_READ_REG(&sc->hw, E1000_RADV));
3122         device_printf(dev, "hw tdh = %d, hw tdt = %d\n",
3123             E1000_READ_REG(&sc->hw, E1000_TDH(0)),
3124             E1000_READ_REG(&sc->hw, E1000_TDT(0)));
3125         device_printf(dev, "hw rdh = %d, hw rdt = %d\n",
3126             E1000_READ_REG(&sc->hw, E1000_RDH(0)),
3127             E1000_READ_REG(&sc->hw, E1000_RDT(0)));
3128         device_printf(dev, "Num Tx descriptors avail = %d\n",
3129             sc->num_tx_desc_avail);
3130         device_printf(dev, "Tx Descriptors not avail1 = %ld\n",
3131             sc->no_tx_desc_avail1);
3132         device_printf(dev, "Tx Descriptors not avail2 = %ld\n",
3133             sc->no_tx_desc_avail2);
3134         device_printf(dev, "Std mbuf failed = %ld\n",
3135             sc->mbuf_alloc_failed);
3136         device_printf(dev, "Std mbuf cluster failed = %ld\n",
3137             sc->rx_data[0].mbuf_cluster_failed);
3138         device_printf(dev, "Driver dropped packets = %ld\n",
3139             sc->dropped_pkts);
3140         device_printf(dev, "Driver tx dma failure in encap = %ld\n",
3141             sc->no_tx_dma_setup);
3142
3143         device_printf(dev, "TXCSUM try pullup = %lu\n",
3144             sc->tx_csum_try_pullup);
3145         device_printf(dev, "TXCSUM m_pullup(eh) called = %lu\n",
3146             sc->tx_csum_pullup1);
3147         device_printf(dev, "TXCSUM m_pullup(eh) failed = %lu\n",
3148             sc->tx_csum_pullup1_failed);
3149         device_printf(dev, "TXCSUM m_pullup(eh+ip) called = %lu\n",
3150             sc->tx_csum_pullup2);
3151         device_printf(dev, "TXCSUM m_pullup(eh+ip) failed = %lu\n",
3152             sc->tx_csum_pullup2_failed);
3153         device_printf(dev, "TXCSUM non-writable(eh) droped = %lu\n",
3154             sc->tx_csum_drop1);
3155         device_printf(dev, "TXCSUM non-writable(eh+ip) droped = %lu\n",
3156             sc->tx_csum_drop2);
3157 }
3158
3159 static void
3160 emx_print_hw_stats(struct emx_softc *sc)
3161 {
3162         device_t dev = sc->dev;
3163
3164         device_printf(dev, "Excessive collisions = %lld\n",
3165             (long long)sc->stats.ecol);
3166 #if (DEBUG_HW > 0)  /* Dont output these errors normally */
3167         device_printf(dev, "Symbol errors = %lld\n",
3168             (long long)sc->stats.symerrs);
3169 #endif
3170         device_printf(dev, "Sequence errors = %lld\n",
3171             (long long)sc->stats.sec);
3172         device_printf(dev, "Defer count = %lld\n",
3173             (long long)sc->stats.dc);
3174         device_printf(dev, "Missed Packets = %lld\n",
3175             (long long)sc->stats.mpc);
3176         device_printf(dev, "Receive No Buffers = %lld\n",
3177             (long long)sc->stats.rnbc);
3178         /* RLEC is inaccurate on some hardware, calculate our own. */
3179         device_printf(dev, "Receive Length Errors = %lld\n",
3180             ((long long)sc->stats.roc + (long long)sc->stats.ruc));
3181         device_printf(dev, "Receive errors = %lld\n",
3182             (long long)sc->stats.rxerrc);
3183         device_printf(dev, "Crc errors = %lld\n",
3184             (long long)sc->stats.crcerrs);
3185         device_printf(dev, "Alignment errors = %lld\n",
3186             (long long)sc->stats.algnerrc);
3187         device_printf(dev, "Collision/Carrier extension errors = %lld\n",
3188             (long long)sc->stats.cexterr);
3189         device_printf(dev, "RX overruns = %ld\n", sc->rx_overruns);
3190         device_printf(dev, "watchdog timeouts = %ld\n",
3191             sc->watchdog_events);
3192         device_printf(dev, "XON Rcvd = %lld\n",
3193             (long long)sc->stats.xonrxc);
3194         device_printf(dev, "XON Xmtd = %lld\n",
3195             (long long)sc->stats.xontxc);
3196         device_printf(dev, "XOFF Rcvd = %lld\n",
3197             (long long)sc->stats.xoffrxc);
3198         device_printf(dev, "XOFF Xmtd = %lld\n",
3199             (long long)sc->stats.xofftxc);
3200         device_printf(dev, "Good Packets Rcvd = %lld\n",
3201             (long long)sc->stats.gprc);
3202         device_printf(dev, "Good Packets Xmtd = %lld\n",
3203             (long long)sc->stats.gptc);
3204 }
3205
3206 static void
3207 emx_print_nvm_info(struct emx_softc *sc)
3208 {
3209         uint16_t eeprom_data;
3210         int i, j, row = 0;
3211
3212         /* Its a bit crude, but it gets the job done */
3213         kprintf("\nInterface EEPROM Dump:\n");
3214         kprintf("Offset\n0x0000  ");
3215         for (i = 0, j = 0; i < 32; i++, j++) {
3216                 if (j == 8) { /* Make the offset block */
3217                         j = 0; ++row;
3218                         kprintf("\n0x00%x0  ",row);
3219                 }
3220                 e1000_read_nvm(&sc->hw, i, 1, &eeprom_data);
3221                 kprintf("%04x ", eeprom_data);
3222         }
3223         kprintf("\n");
3224 }
3225
3226 static int
3227 emx_sysctl_debug_info(SYSCTL_HANDLER_ARGS)
3228 {
3229         struct emx_softc *sc;
3230         struct ifnet *ifp;
3231         int error, result;
3232
3233         result = -1;
3234         error = sysctl_handle_int(oidp, &result, 0, req);
3235         if (error || !req->newptr)
3236                 return (error);
3237
3238         sc = (struct emx_softc *)arg1;
3239         ifp = &sc->arpcom.ac_if;
3240
3241         lwkt_serialize_enter(ifp->if_serializer);
3242
3243         if (result == 1)
3244                 emx_print_debug_info(sc);
3245
3246         /*
3247          * This value will cause a hex dump of the
3248          * first 32 16-bit words of the EEPROM to
3249          * the screen.
3250          */
3251         if (result == 2)
3252                 emx_print_nvm_info(sc);
3253
3254         lwkt_serialize_exit(ifp->if_serializer);
3255
3256         return (error);
3257 }
3258
3259 static int
3260 emx_sysctl_stats(SYSCTL_HANDLER_ARGS)
3261 {
3262         int error, result;
3263
3264         result = -1;
3265         error = sysctl_handle_int(oidp, &result, 0, req);
3266         if (error || !req->newptr)
3267                 return (error);
3268
3269         if (result == 1) {
3270                 struct emx_softc *sc = (struct emx_softc *)arg1;
3271                 struct ifnet *ifp = &sc->arpcom.ac_if;
3272
3273                 lwkt_serialize_enter(ifp->if_serializer);
3274                 emx_print_hw_stats(sc);
3275                 lwkt_serialize_exit(ifp->if_serializer);
3276         }
3277         return (error);
3278 }
3279
3280 static void
3281 emx_add_sysctl(struct emx_softc *sc)
3282 {
3283 #ifdef PROFILE_SERIALIZER
3284         struct ifnet *ifp = &sc->arpcom.ac_if;
3285 #endif
3286 #ifdef EMX_RSS_DEBUG
3287         char rx_pkt[32];
3288         int i;
3289 #endif
3290
3291         sysctl_ctx_init(&sc->sysctl_ctx);
3292         sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
3293                                 SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
3294                                 device_get_nameunit(sc->dev),
3295                                 CTLFLAG_RD, 0, "");
3296         if (sc->sysctl_tree == NULL) {
3297                 device_printf(sc->dev, "can't add sysctl node\n");
3298                 return;
3299         }
3300
3301         SYSCTL_ADD_PROC(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
3302                         OID_AUTO, "debug", CTLTYPE_INT|CTLFLAG_RW, sc, 0,
3303                         emx_sysctl_debug_info, "I", "Debug Information");
3304
3305         SYSCTL_ADD_PROC(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
3306                         OID_AUTO, "stats", CTLTYPE_INT|CTLFLAG_RW, sc, 0,
3307                         emx_sysctl_stats, "I", "Statistics");
3308
3309         SYSCTL_ADD_INT(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
3310                        OID_AUTO, "rxd", CTLFLAG_RD,
3311                        &sc->rx_data[0].num_rx_desc, 0, NULL);
3312         SYSCTL_ADD_INT(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
3313                        OID_AUTO, "txd", CTLFLAG_RD, &sc->num_tx_desc, 0, NULL);
3314
3315 #ifdef PROFILE_SERIALIZER
3316         SYSCTL_ADD_UINT(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
3317                         OID_AUTO, "serializer_sleep", CTLFLAG_RW,
3318                         &ifp->if_serializer->sleep_cnt, 0, NULL);
3319         SYSCTL_ADD_UINT(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
3320                         OID_AUTO, "serializer_tryfail", CTLFLAG_RW,
3321                         &ifp->if_serializer->tryfail_cnt, 0, NULL);
3322         SYSCTL_ADD_UINT(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
3323                         OID_AUTO, "serializer_enter", CTLFLAG_RW,
3324                         &ifp->if_serializer->enter_cnt, 0, NULL);
3325         SYSCTL_ADD_UINT(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
3326                         OID_AUTO, "serializer_try", CTLFLAG_RW,
3327                         &ifp->if_serializer->try_cnt, 0, NULL);
3328 #endif
3329
3330         SYSCTL_ADD_PROC(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
3331                         OID_AUTO, "int_throttle_ceil", CTLTYPE_INT|CTLFLAG_RW,
3332                         sc, 0, emx_sysctl_int_throttle, "I",
3333                         "interrupt throttling rate");
3334         SYSCTL_ADD_PROC(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
3335                         OID_AUTO, "int_tx_nsegs", CTLTYPE_INT|CTLFLAG_RW,
3336                         sc, 0, emx_sysctl_int_tx_nsegs, "I",
3337                         "# segments per TX interrupt");
3338
3339 #ifdef EMX_RSS_DEBUG
3340         SYSCTL_ADD_INT(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
3341                        OID_AUTO, "rss_debug", CTLFLAG_RW, &sc->rss_debug,
3342                        0, "RSS debug level");
3343         for (i = 0; i < sc->rx_ring_cnt; ++i) {
3344                 ksnprintf(rx_pkt, sizeof(rx_pkt), "rx%d_pkt", i);
3345                 SYSCTL_ADD_UINT(&sc->sysctl_ctx,
3346                                 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
3347                                 rx_pkt, CTLFLAG_RD,
3348                                 &sc->rx_data[i].rx_pkts, 0, "RXed packets");
3349         }
3350 #endif
3351 }
3352
3353 static int
3354 emx_sysctl_int_throttle(SYSCTL_HANDLER_ARGS)
3355 {
3356         struct emx_softc *sc = (void *)arg1;
3357         struct ifnet *ifp = &sc->arpcom.ac_if;
3358         int error, throttle;
3359
3360         throttle = sc->int_throttle_ceil;
3361         error = sysctl_handle_int(oidp, &throttle, 0, req);
3362         if (error || req->newptr == NULL)
3363                 return error;
3364         if (throttle < 0 || throttle > 1000000000 / 256)
3365                 return EINVAL;
3366
3367         if (throttle) {
3368                 /*
3369                  * Set the interrupt throttling rate in 256ns increments,
3370                  * recalculate sysctl value assignment to get exact frequency.
3371                  */
3372                 throttle = 1000000000 / 256 / throttle;
3373
3374                 /* Upper 16bits of ITR is reserved and should be zero */
3375                 if (throttle & 0xffff0000)
3376                         return EINVAL;
3377         }
3378
3379         lwkt_serialize_enter(ifp->if_serializer);
3380
3381         if (throttle)
3382                 sc->int_throttle_ceil = 1000000000 / 256 / throttle;
3383         else
3384                 sc->int_throttle_ceil = 0;
3385
3386         if (ifp->if_flags & IFF_RUNNING)
3387                 E1000_WRITE_REG(&sc->hw, E1000_ITR, throttle);
3388
3389         lwkt_serialize_exit(ifp->if_serializer);
3390
3391         if (bootverbose) {
3392                 if_printf(ifp, "Interrupt moderation set to %d/sec\n",
3393                           sc->int_throttle_ceil);
3394         }
3395         return 0;
3396 }
3397
3398 static int
3399 emx_sysctl_int_tx_nsegs(SYSCTL_HANDLER_ARGS)
3400 {
3401         struct emx_softc *sc = (void *)arg1;
3402         struct ifnet *ifp = &sc->arpcom.ac_if;
3403         int error, segs;
3404
3405         segs = sc->tx_int_nsegs;
3406         error = sysctl_handle_int(oidp, &segs, 0, req);
3407         if (error || req->newptr == NULL)
3408                 return error;
3409         if (segs <= 0)
3410                 return EINVAL;
3411
3412         lwkt_serialize_enter(ifp->if_serializer);
3413
3414         /*
3415          * Don't allow int_tx_nsegs to become:
3416          * o  Less the oact_tx_desc
3417          * o  Too large that no TX desc will cause TX interrupt to
3418          *    be generated (OACTIVE will never recover)
3419          * o  Too small that will cause tx_dd[] overflow
3420          */
3421         if (segs < sc->oact_tx_desc ||
3422             segs >= sc->num_tx_desc - sc->oact_tx_desc ||
3423             segs < sc->num_tx_desc / EMX_TXDD_SAFE) {
3424                 error = EINVAL;
3425         } else {
3426                 error = 0;
3427                 sc->tx_int_nsegs = segs;
3428         }
3429
3430         lwkt_serialize_exit(ifp->if_serializer);
3431
3432         return error;
3433 }
3434
3435 static int
3436 emx_dma_alloc(struct emx_softc *sc)
3437 {
3438         int error, i;
3439
3440         /*
3441          * Create top level busdma tag
3442          */
3443         error = bus_dma_tag_create(NULL, 1, 0,
3444                         BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR,
3445                         NULL, NULL,
3446                         BUS_SPACE_MAXSIZE_32BIT, 0, BUS_SPACE_MAXSIZE_32BIT,
3447                         0, &sc->parent_dtag);
3448         if (error) {
3449                 device_printf(sc->dev, "could not create top level DMA tag\n");
3450                 return error;
3451         }
3452
3453         /*
3454          * Allocate transmit descriptors ring and buffers
3455          */
3456         error = emx_create_tx_ring(sc);
3457         if (error) {
3458                 device_printf(sc->dev, "Could not setup transmit structures\n");
3459                 return error;
3460         }
3461
3462         /*
3463          * Allocate receive descriptors ring and buffers
3464          */
3465         for (i = 0; i < sc->rx_ring_cnt; ++i) {
3466                 error = emx_create_rx_ring(sc, &sc->rx_data[i]);
3467                 if (error) {
3468                         device_printf(sc->dev,
3469                             "Could not setup receive structures\n");
3470                         return error;
3471                 }
3472         }
3473         return 0;
3474 }
3475
3476 static void
3477 emx_dma_free(struct emx_softc *sc)
3478 {
3479         int i;
3480
3481         emx_destroy_tx_ring(sc, sc->num_tx_desc);
3482
3483         for (i = 0; i < sc->rx_ring_cnt; ++i) {
3484                 emx_destroy_rx_ring(sc, &sc->rx_data[i],
3485                                     sc->rx_data[i].num_rx_desc);
3486         }
3487
3488         /* Free top level busdma tag */
3489         if (sc->parent_dtag != NULL)
3490                 bus_dma_tag_destroy(sc->parent_dtag);
3491 }