source: libbsdport/bsd_eth_drivers/if_em/if_em.c @ 370f3c5

Last change on this file since 370f3c5 was 370f3c5, checked in by Till Straumann <strauman@…>, on Aug 5, 2009 at 9:41:20 PM

2009-08-05 Till Straumann <Till.Straumann@…>

  • if_em/Makefile.am, if_em/e1000_osdep.h, if_em/if_em.c: Changed 'e1000_osdep.h' to provide stdalone I/O methods for select architectures (x86 and PPC -- others fall back on libbsdport/bus.h). This lets the low-level driver (everything except for 'if_em.c/if_em.h') API be independent of BSD networking and libbsdport which is desirable since certain applications may wish to just use the low-level API for implementing dedicated 'raw-ethernet' drivers for BSD-independent, proprietary GigE communication.
  • Property mode set to 100644
File size: 150.4 KB
Line 
1/**************************************************************************
2
3Copyright (c) 2001-2007, Intel Corporation
4All rights reserved.
5
6Redistribution and use in source and binary forms, with or without
7modification, are permitted provided that the following conditions are met:
8
9 1. Redistributions of source code must retain the above copyright notice,
10    this list of conditions and the following disclaimer.
11
12 2. Redistributions in binary form must reproduce the above copyright
13    notice, this list of conditions and the following disclaimer in the
14    documentation and/or other materials provided with the distribution.
15
16 3. Neither the name of the Intel Corporation nor the names of its
17    contributors may be used to endorse or promote products derived from
18    this software without specific prior written permission.
19
20THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30POSSIBILITY OF SUCH DAMAGE.
31
32***************************************************************************/
33
34/*$FreeBSD: src/sys/dev/em/if_em.c,v 1.181 2007/05/31 23:36:21 jfv Exp $*/
35
36#ifdef HAVE_KERNEL_OPTION_HEADERS
37#include "opt_device_polling.h"
38#endif
39
40#ifdef __rtems__
41#include <libbsdport.h>
42#endif
43
44#include <sys/param.h>
45#include <sys/systm.h>
46#include <sys/bus.h>
47#include <sys/endian.h>
48#include <sys/kernel.h>
49#include <sys/kthread.h>
50#include <sys/malloc.h>
51#include <sys/mbuf.h>
52#include <sys/module.h>
53#include <sys/rman.h>
54#include <sys/socket.h>
55#include <sys/sockio.h>
56#include <sys/sysctl.h>
57#include <sys/taskqueue.h>
58
59#include <machine/bus.h>
60#include <machine/resource.h>
61
62#include <net/bpf.h>
63#include <net/ethernet.h>
64#include <net/if.h>
65#include <net/if_arp.h>
66#include <net/if_dl.h>
67#include <net/if_media.h>
68
69#include <net/if_types.h>
70#include <net/if_vlan_var.h>
71
72#include <netinet/in_systm.h>
73#include <netinet/in.h>
74#include <netinet/if_ether.h>
75#include <netinet/ip.h>
76#include <netinet/ip6.h>
77#include <netinet/tcp.h>
78#include <netinet/udp.h>
79
80#include <machine/in_cksum.h>
81#include <dev/pci/pcivar.h>
82#include <dev/pci/pcireg.h>
83
84#include "e1000_api.h"
85#include "e1000_82575.h"
86#include "if_em.h"
87
88#ifdef __rtems__
89/* Override things as necessary */
90#include <libbsdport_post.h>
91#endif
92
93/*********************************************************************
94 *  Set this to one to display debug statistics
95 *********************************************************************/
96int     em_display_debug_stats = 0;
97
98/*********************************************************************
99 *  Driver version:
100 *********************************************************************/
101char em_driver_version[] = "Version - 6.5.3";
102
103
104/*********************************************************************
105 *  PCI Device ID Table
106 *
107 *  Used by probe to select devices to load on
108 *  Last field stores an index into e1000_strings
109 *  Last entry must be all 0s
110 *
111 *  { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
112 *********************************************************************/
113
114static em_vendor_info_t em_vendor_info_array[] =
115{
116        /* Intel(R) PRO/1000 Network Connection */
117        { 0x8086, E1000_DEV_ID_82540EM,         PCI_ANY_ID, PCI_ANY_ID, 0},
118        { 0x8086, E1000_DEV_ID_82540EM_LOM,     PCI_ANY_ID, PCI_ANY_ID, 0},
119        { 0x8086, E1000_DEV_ID_82540EP,         PCI_ANY_ID, PCI_ANY_ID, 0},
120        { 0x8086, E1000_DEV_ID_82540EP_LOM,     PCI_ANY_ID, PCI_ANY_ID, 0},
121        { 0x8086, E1000_DEV_ID_82540EP_LP,      PCI_ANY_ID, PCI_ANY_ID, 0},
122
123        { 0x8086, E1000_DEV_ID_82541EI,         PCI_ANY_ID, PCI_ANY_ID, 0},
124        { 0x8086, E1000_DEV_ID_82541ER,         PCI_ANY_ID, PCI_ANY_ID, 0},
125        { 0x8086, E1000_DEV_ID_82541ER_LOM,     PCI_ANY_ID, PCI_ANY_ID, 0},
126        { 0x8086, E1000_DEV_ID_82541EI_MOBILE,  PCI_ANY_ID, PCI_ANY_ID, 0},
127        { 0x8086, E1000_DEV_ID_82541GI,         PCI_ANY_ID, PCI_ANY_ID, 0},
128        { 0x8086, E1000_DEV_ID_82541GI_LF,      PCI_ANY_ID, PCI_ANY_ID, 0},
129        { 0x8086, E1000_DEV_ID_82541GI_MOBILE,  PCI_ANY_ID, PCI_ANY_ID, 0},
130
131#if !defined(NO_82542_SUPPORT) /* __rtems__ */
132        { 0x8086, E1000_DEV_ID_82542,           PCI_ANY_ID, PCI_ANY_ID, 0},
133#endif
134
135        { 0x8086, E1000_DEV_ID_82543GC_FIBER,   PCI_ANY_ID, PCI_ANY_ID, 0},
136        { 0x8086, E1000_DEV_ID_82543GC_COPPER,  PCI_ANY_ID, PCI_ANY_ID, 0},
137
138        { 0x8086, E1000_DEV_ID_82544EI_COPPER,  PCI_ANY_ID, PCI_ANY_ID, 0},
139        { 0x8086, E1000_DEV_ID_82544EI_FIBER,   PCI_ANY_ID, PCI_ANY_ID, 0},
140        { 0x8086, E1000_DEV_ID_82544GC_COPPER,  PCI_ANY_ID, PCI_ANY_ID, 0},
141        { 0x8086, E1000_DEV_ID_82544GC_LOM,     PCI_ANY_ID, PCI_ANY_ID, 0},
142
143        { 0x8086, E1000_DEV_ID_82545EM_COPPER,  PCI_ANY_ID, PCI_ANY_ID, 0},
144        { 0x8086, E1000_DEV_ID_82545EM_FIBER,   PCI_ANY_ID, PCI_ANY_ID, 0},
145        { 0x8086, E1000_DEV_ID_82545GM_COPPER,  PCI_ANY_ID, PCI_ANY_ID, 0},
146        { 0x8086, E1000_DEV_ID_82545GM_FIBER,   PCI_ANY_ID, PCI_ANY_ID, 0},
147        { 0x8086, E1000_DEV_ID_82545GM_SERDES,  PCI_ANY_ID, PCI_ANY_ID, 0},
148
149        { 0x8086, E1000_DEV_ID_82546EB_COPPER,  PCI_ANY_ID, PCI_ANY_ID, 0},
150        { 0x8086, E1000_DEV_ID_82546EB_FIBER,   PCI_ANY_ID, PCI_ANY_ID, 0},
151        { 0x8086, E1000_DEV_ID_82546EB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0},
152        { 0x8086, E1000_DEV_ID_82546GB_COPPER,  PCI_ANY_ID, PCI_ANY_ID, 0},
153        { 0x8086, E1000_DEV_ID_82546GB_FIBER,   PCI_ANY_ID, PCI_ANY_ID, 0},
154        { 0x8086, E1000_DEV_ID_82546GB_SERDES,  PCI_ANY_ID, PCI_ANY_ID, 0},
155        { 0x8086, E1000_DEV_ID_82546GB_PCIE,    PCI_ANY_ID, PCI_ANY_ID, 0},
156        { 0x8086, E1000_DEV_ID_82546GB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0},
157        { 0x8086, E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3,
158                                                PCI_ANY_ID, PCI_ANY_ID, 0},
159
160        { 0x8086, E1000_DEV_ID_82547EI,         PCI_ANY_ID, PCI_ANY_ID, 0},
161        { 0x8086, E1000_DEV_ID_82547EI_MOBILE,  PCI_ANY_ID, PCI_ANY_ID, 0},
162        { 0x8086, E1000_DEV_ID_82547GI,         PCI_ANY_ID, PCI_ANY_ID, 0},
163
164        { 0x8086, E1000_DEV_ID_82571EB_COPPER,  PCI_ANY_ID, PCI_ANY_ID, 0},
165        { 0x8086, E1000_DEV_ID_82571EB_FIBER,   PCI_ANY_ID, PCI_ANY_ID, 0},
166        { 0x8086, E1000_DEV_ID_82571EB_SERDES,  PCI_ANY_ID, PCI_ANY_ID, 0},
167        { 0x8086, E1000_DEV_ID_82571EB_QUAD_COPPER,
168                                                PCI_ANY_ID, PCI_ANY_ID, 0},
169        { 0x8086, E1000_DEV_ID_82571EB_QUAD_COPPER_LP,
170                                                PCI_ANY_ID, PCI_ANY_ID, 0},
171        { 0x8086, E1000_DEV_ID_82571EB_QUAD_FIBER,
172                                                PCI_ANY_ID, PCI_ANY_ID, 0},
173        { 0x8086, E1000_DEV_ID_82572EI_COPPER,  PCI_ANY_ID, PCI_ANY_ID, 0},
174        { 0x8086, E1000_DEV_ID_82572EI_FIBER,   PCI_ANY_ID, PCI_ANY_ID, 0},
175        { 0x8086, E1000_DEV_ID_82572EI_SERDES,  PCI_ANY_ID, PCI_ANY_ID, 0},
176        { 0x8086, E1000_DEV_ID_82572EI,         PCI_ANY_ID, PCI_ANY_ID, 0},
177
178        { 0x8086, E1000_DEV_ID_82573E,          PCI_ANY_ID, PCI_ANY_ID, 0},
179        { 0x8086, E1000_DEV_ID_82573E_IAMT,     PCI_ANY_ID, PCI_ANY_ID, 0},
180        { 0x8086, E1000_DEV_ID_82573L,          PCI_ANY_ID, PCI_ANY_ID, 0},
181        { 0x8086, E1000_DEV_ID_80003ES2LAN_COPPER_SPT,
182                                                PCI_ANY_ID, PCI_ANY_ID, 0},
183        { 0x8086, E1000_DEV_ID_80003ES2LAN_SERDES_SPT,
184                                                PCI_ANY_ID, PCI_ANY_ID, 0},
185        { 0x8086, E1000_DEV_ID_80003ES2LAN_COPPER_DPT,
186                                                PCI_ANY_ID, PCI_ANY_ID, 0},
187        { 0x8086, E1000_DEV_ID_80003ES2LAN_SERDES_DPT,
188                                                PCI_ANY_ID, PCI_ANY_ID, 0},
189        { 0x8086, E1000_DEV_ID_ICH8_IGP_M_AMT,  PCI_ANY_ID, PCI_ANY_ID, 0},
190        { 0x8086, E1000_DEV_ID_ICH8_IGP_AMT,    PCI_ANY_ID, PCI_ANY_ID, 0},
191        { 0x8086, E1000_DEV_ID_ICH8_IGP_C,      PCI_ANY_ID, PCI_ANY_ID, 0},
192        { 0x8086, E1000_DEV_ID_ICH8_IFE,        PCI_ANY_ID, PCI_ANY_ID, 0},
193        { 0x8086, E1000_DEV_ID_ICH8_IFE_GT,     PCI_ANY_ID, PCI_ANY_ID, 0},
194        { 0x8086, E1000_DEV_ID_ICH8_IFE_G,      PCI_ANY_ID, PCI_ANY_ID, 0},
195        { 0x8086, E1000_DEV_ID_ICH8_IGP_M,      PCI_ANY_ID, PCI_ANY_ID, 0},
196
197        { 0x8086, E1000_DEV_ID_ICH9_IGP_AMT,    PCI_ANY_ID, PCI_ANY_ID, 0},
198        { 0x8086, E1000_DEV_ID_ICH9_IGP_C,      PCI_ANY_ID, PCI_ANY_ID, 0},
199        { 0x8086, E1000_DEV_ID_ICH9_IFE,        PCI_ANY_ID, PCI_ANY_ID, 0},
200        { 0x8086, E1000_DEV_ID_ICH9_IFE_GT,     PCI_ANY_ID, PCI_ANY_ID, 0},
201        { 0x8086, E1000_DEV_ID_ICH9_IFE_G,      PCI_ANY_ID, PCI_ANY_ID, 0},
202
203        { 0x8086, E1000_DEV_ID_82575EB_COPPER,  PCI_ANY_ID, PCI_ANY_ID, 0},
204        { 0x8086, E1000_DEV_ID_82575EB_FIBER_SERDES,
205                                                PCI_ANY_ID, PCI_ANY_ID, 0},
206        { 0x8086, E1000_DEV_ID_82575EM_COPPER,  PCI_ANY_ID, PCI_ANY_ID, 0},
207        { 0x8086, E1000_DEV_ID_82575EM_FIBER_SERDES,
208                                                PCI_ANY_ID, PCI_ANY_ID, 0},
209        { 0x8086, E1000_DEV_ID_82575GB_QUAD_COPPER,
210                                                PCI_ANY_ID, PCI_ANY_ID, 0},
211        /* required last entry */
212        { 0, 0, 0, 0, 0}
213};
214
215/*********************************************************************
216 *  Table of branding strings for all supported NICs.
217 *********************************************************************/
218
219static char *em_strings[] = {
220        "Intel(R) PRO/1000 Network Connection"
221};
222
223/*********************************************************************
224 *  Function prototypes
225 *********************************************************************/
226static int      em_probe(device_t);
227static int      em_attach(device_t);
228static int      em_detach(device_t);
229#ifndef __rtems__
230static int      em_shutdown(device_t);
231static int      em_suspend(device_t);
232static int      em_resume(device_t);
233#endif
234static void     em_start(struct ifnet *);
235static void     em_start_locked(struct ifnet *ifp);
236#ifndef __rtems__
237static int      em_ioctl(struct ifnet *, u_long, caddr_t);
238#else
239static int      em_ioctl(struct ifnet *, ioctl_command_t, caddr_t);
240#endif
241static void     em_watchdog(struct adapter *);
242static void     em_init(void *);
243static void     em_init_locked(struct adapter *);
244static void     em_stop(void *);
245static void     em_media_status(struct ifnet *, struct ifmediareq *);
246static int      em_media_change(struct ifnet *);
247static void     em_identify_hardware(struct adapter *);
248static int      em_allocate_pci_resources(struct adapter *);
249static int      em_allocate_intr(struct adapter *);
250static void     em_free_intr(struct adapter *);
251static void     em_free_pci_resources(struct adapter *);
252static void     em_local_timer(void *);
253static int      em_hardware_init(struct adapter *);
254static void     em_setup_interface(device_t, struct adapter *);
255static int      em_setup_transmit_structures(struct adapter *);
256static void     em_initialize_transmit_unit(struct adapter *);
257static int      em_setup_receive_structures(struct adapter *);
258static void     em_initialize_receive_unit(struct adapter *);
259static void     em_enable_intr(struct adapter *);
260static void     em_disable_intr(struct adapter *);
261static void     em_free_transmit_structures(struct adapter *);
262static void     em_free_receive_structures(struct adapter *);
263static void     em_update_stats_counters(struct adapter *);
264static void     em_txeof(struct adapter *);
265static int      em_allocate_receive_structures(struct adapter *);
266static int      em_allocate_transmit_structures(struct adapter *);
267static int      em_rxeof(struct adapter *, int);
268#ifndef __NO_STRICT_ALIGNMENT
269static int      em_fixup_rx(struct adapter *);
270#endif
271#ifndef __rtems__
272static void     em_receive_checksum(struct adapter *, struct e1000_rx_desc *,
273                    struct mbuf *);
274static void     em_transmit_checksum_setup(struct adapter *, struct mbuf *,
275                    uint32_t *, uint32_t *);
276static boolean_t em_tx_adv_ctx_setup(struct adapter *, struct mbuf *);
277static boolean_t em_tso_setup(struct adapter *, struct mbuf *, uint32_t *,
278                    uint32_t *);
279static boolean_t em_tso_adv_setup(struct adapter *, struct mbuf *, uint32_t *);
280#endif
281static void     em_set_promisc(struct adapter *);
282static void     em_disable_promisc(struct adapter *);
283static void     em_set_multi(struct adapter *);
284#ifndef __rtems__
285static void     em_print_hw_stats(struct adapter *);
286#else
287void    em_print_hw_stats(struct adapter *);
288#endif
289static void     em_update_link_status(struct adapter *);
290static int      em_get_buf(struct adapter *, int);
291#ifndef __rtems__
292static void     em_enable_vlans(struct adapter *);
293#endif
294static int      em_encap(struct adapter *, struct mbuf **);
295static int      em_adv_encap(struct adapter *, struct mbuf **);
296static void     em_smartspeed(struct adapter *);
297static int      em_82547_fifo_workaround(struct adapter *, int);
298static void     em_82547_update_fifo_head(struct adapter *, int);
299static int      em_82547_tx_fifo_reset(struct adapter *);
300static void     em_82547_move_tail(void *);
301static int      em_dma_malloc(struct adapter *, bus_size_t,
302                    struct em_dma_alloc *, int);
303static void     em_dma_free(struct adapter *, struct em_dma_alloc *);
304#ifndef __rtems__
305static void em_print_debug_info(struct adapter *);
306#else
307void    em_print_debug_info(struct adapter *);
308#endif
309static int      em_is_valid_ether_addr(uint8_t *);
310#ifndef __rtems__
311static int      em_sysctl_stats(SYSCTL_HANDLER_ARGS);
312static int      em_sysctl_debug_info(SYSCTL_HANDLER_ARGS);
313#endif
314static uint32_t em_fill_descriptors (bus_addr_t address, uint32_t length,
315                    PDESC_ARRAY desc_array);
316#ifndef __rtems__
317static int      em_sysctl_int_delay(SYSCTL_HANDLER_ARGS);
318#endif
319static void     em_add_int_delay_sysctl(struct adapter *, const char *,
320                    const char *, struct em_int_delay_info *, int, int);
321/* Management and WOL Support */
322static void     em_init_manageability(struct adapter *);
323static void     em_release_manageability(struct adapter *);
324static void     em_get_hw_control(struct adapter *);
325static void     em_release_hw_control(struct adapter *);
326static void     em_enable_wakeup(device_t);
327
328#ifdef DEVICE_POLLING
329static poll_handler_t em_poll;
330static void     em_intr(void *);
331#else
332static int      em_intr_fast(void *);
333static void     em_add_rx_process_limit(struct adapter *, const char *,
334                    const char *, int *, int);
335static void     em_handle_rxtx(void *context, int pending);
336static void     em_handle_link(void *context, int pending);
337#endif
338
339/*********************************************************************
340 *  FreeBSD Device Interface Entry Points
341 *********************************************************************/
342
343#ifndef __rtems__
344static device_method_t em_methods[] = {
345        /* Device interface */
346        DEVMETHOD(device_probe, em_probe),
347        DEVMETHOD(device_attach, em_attach),
348        DEVMETHOD(device_detach, em_detach),
349        DEVMETHOD(device_shutdown, em_shutdown),
350        DEVMETHOD(device_suspend, em_suspend),
351        DEVMETHOD(device_resume, em_resume),
352        {0, 0}
353};
354
355static driver_t em_driver = {
356        "em", em_methods, sizeof(struct adapter),
357};
358
359static devclass_t em_devclass;
360DRIVER_MODULE(em, pci, em_driver, em_devclass, 0, 0);
361MODULE_DEPEND(em, pci, 1, 1, 1);
362MODULE_DEPEND(em, ether, 1, 1, 1);
363
364#else
365static device_method_t em_methods = {
366        probe:         em_probe,
367        attach:        em_attach,
368        detach:        em_detach,
369        irq_en:        0,
370        irq_check_dis: 0,
371};
372
373driver_t libbsdport_em_driver = {
374        "em",
375        &em_methods,
376        DEV_TYPE_PCI, 
377        sizeof(struct adapter)
378};
379#endif
380
381/*********************************************************************
382 *  Tunable default values.
383 *********************************************************************/
384
385#define EM_TICKS_TO_USECS(ticks)        ((1024 * (ticks) + 500) / 1000)
386#define EM_USECS_TO_TICKS(usecs)        ((1000 * (usecs) + 512) / 1024)
387#define M_TSO_LEN                       66
388
389#ifdef __rtems__
390#define static
391#define TUNABLE_INT(a,b)
392#endif
393
394static int em_tx_int_delay_dflt = EM_TICKS_TO_USECS(EM_TIDV);
395static int em_rx_int_delay_dflt = EM_TICKS_TO_USECS(EM_RDTR);
396static int em_tx_abs_int_delay_dflt = EM_TICKS_TO_USECS(EM_TADV);
397static int em_rx_abs_int_delay_dflt = EM_TICKS_TO_USECS(EM_RADV);
398static int em_rxd = EM_DEFAULT_RXD;
399static int em_txd = EM_DEFAULT_TXD;
400static int em_smart_pwr_down = FALSE;
401
402TUNABLE_INT("hw.em.tx_int_delay", &em_tx_int_delay_dflt);
403TUNABLE_INT("hw.em.rx_int_delay", &em_rx_int_delay_dflt);
404TUNABLE_INT("hw.em.tx_abs_int_delay", &em_tx_abs_int_delay_dflt);
405TUNABLE_INT("hw.em.rx_abs_int_delay", &em_rx_abs_int_delay_dflt);
406TUNABLE_INT("hw.em.rxd", &em_rxd);
407TUNABLE_INT("hw.em.txd", &em_txd);
408TUNABLE_INT("hw.em.smart_pwr_down", &em_smart_pwr_down);
409#ifndef DEVICE_POLLING
410/* How many packets rxeof tries to clean at a time */
411static int em_rx_process_limit = 100;
412TUNABLE_INT("hw.em.rx_process_limit", &em_rx_process_limit);
413#endif
414
415#ifdef __rtems__
416#undef static
417#define static static
418#endif
419
420/* Global used in WOL setup with multiport cards */
421static int global_quad_port_a = 0;
422
423/*********************************************************************
424 *  Device identification routine
425 *
426 *  em_probe determines if the driver should be loaded on
427 *  adapter based on PCI vendor/device id of the adapter.
428 *
429 *  return BUS_PROBE_DEFAULT on success, positive on failure
430 *********************************************************************/
431
432static int
433em_probe(device_t dev)
434{
435        char            adapter_name[60];
436        uint16_t        pci_vendor_id = 0;
437        uint16_t        pci_device_id = 0;
438        uint16_t        pci_subvendor_id = 0;
439        uint16_t        pci_subdevice_id = 0;
440        em_vendor_info_t *ent;
441
442        INIT_DEBUGOUT("em_probe: begin");
443
444        pci_vendor_id = pci_get_vendor(dev);
445        if (pci_vendor_id != EM_VENDOR_ID)
446                return (ENXIO);
447
448        pci_device_id = pci_get_device(dev);
449        pci_subvendor_id = pci_get_subvendor(dev);
450        pci_subdevice_id = pci_get_subdevice(dev);
451
452        ent = em_vendor_info_array;
453        while (ent->vendor_id != 0) {
454                if ((pci_vendor_id == ent->vendor_id) &&
455                    (pci_device_id == ent->device_id) &&
456
457                    ((pci_subvendor_id == ent->subvendor_id) ||
458                    (ent->subvendor_id == PCI_ANY_ID)) &&
459
460                    ((pci_subdevice_id == ent->subdevice_id) ||
461                    (ent->subdevice_id == PCI_ANY_ID))) {
462                        sprintf(adapter_name, "%s %s",
463                                em_strings[ent->index],
464                                em_driver_version);
465                        device_set_desc_copy(dev, adapter_name);
466                        return (BUS_PROBE_DEFAULT);
467                }
468                ent++;
469        }
470
471        return (ENXIO);
472}
473
474/*********************************************************************
475 *  Device initialization routine
476 *
477 *  The attach entry point is called when the driver is being loaded.
478 *  This routine identifies the type of hardware, allocates all resources
479 *  and initializes the hardware.
480 *
481 *  return 0 on success, positive on failure
482 *********************************************************************/
483
484static int
485em_attach(device_t dev)
486{
487        struct adapter  *adapter;
488        int             tsize, rsize;
489        int             error = 0;
490        u16             eeprom_data, device_id;
491
492        INIT_DEBUGOUT("em_attach: begin");
493
494        adapter = device_get_softc(dev);
495        adapter->dev = adapter->osdep.dev = dev;
496        EM_LOCK_INIT(adapter, device_get_nameunit(dev));
497
498        /* SYSCTL stuff */
499        SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
500            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
501            OID_AUTO, "debug_info", CTLTYPE_INT|CTLFLAG_RW, adapter, 0,
502            em_sysctl_debug_info, "I", "Debug Information");
503
504        SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
505            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
506            OID_AUTO, "stats", CTLTYPE_INT|CTLFLAG_RW, adapter, 0,
507            em_sysctl_stats, "I", "Statistics");
508
509        callout_init_mtx(&adapter->timer, &adapter->mtx, 0);
510        callout_init_mtx(&adapter->tx_fifo_timer, &adapter->mtx, 0);
511
512        /* Determine hardware and mac info */
513        em_identify_hardware(adapter);
514
515        /* Setup PCI resources */
516        if (em_allocate_pci_resources(adapter)) {
517                device_printf(dev, "Allocation of PCI resources failed\n");
518                error = ENXIO;
519                goto err_pci;
520        }
521
522        /*
523        ** For ICH8 and family we need to
524        ** map the flash memory, and this
525        ** must happen after the MAC is
526        ** identified
527        */
528        if ((adapter->hw.mac.type == e1000_ich8lan) ||
529            (adapter->hw.mac.type == e1000_ich9lan)) {
530                int rid = EM_BAR_TYPE_FLASH;
531                adapter->flash_mem = bus_alloc_resource_any(dev,
532                    SYS_RES_MEMORY, &rid, RF_ACTIVE);
533                /* This is used in the shared code */
534                adapter->hw.flash_address = (u8 *)adapter->flash_mem;
535                adapter->osdep.flash_bus_space_tag =
536                    rman_get_bustag(adapter->flash_mem);
537                adapter->osdep.flash_bus_space_handle =
538                    rman_get_bushandle(adapter->flash_mem);
539        }
540
541        /* Do Shared Code initialization */
542        if (e1000_setup_init_funcs(&adapter->hw, TRUE)) {
543                device_printf(dev, "Setup of Shared code failed\n");
544                error = ENXIO;
545                goto err_pci;
546        }
547
548        e1000_get_bus_info(&adapter->hw);
549
550        /* Set up some sysctls for the tunable interrupt delays */
551        em_add_int_delay_sysctl(adapter, "rx_int_delay",
552            "receive interrupt delay in usecs", &adapter->rx_int_delay,
553            E1000_REGISTER(&adapter->hw, E1000_RDTR), em_rx_int_delay_dflt);
554        em_add_int_delay_sysctl(adapter, "tx_int_delay",
555            "transmit interrupt delay in usecs", &adapter->tx_int_delay,
556            E1000_REGISTER(&adapter->hw, E1000_TIDV), em_tx_int_delay_dflt);
557        if (adapter->hw.mac.type >= e1000_82540) {
558                em_add_int_delay_sysctl(adapter, "rx_abs_int_delay",
559                    "receive interrupt delay limit in usecs",
560                    &adapter->rx_abs_int_delay,
561                    E1000_REGISTER(&adapter->hw, E1000_RADV),
562                    em_rx_abs_int_delay_dflt);
563                em_add_int_delay_sysctl(adapter, "tx_abs_int_delay",
564                    "transmit interrupt delay limit in usecs",
565                    &adapter->tx_abs_int_delay,
566                    E1000_REGISTER(&adapter->hw, E1000_TADV),
567                    em_tx_abs_int_delay_dflt);
568        }
569
570#ifndef DEVICE_POLLING
571        /* Sysctls for limiting the amount of work done in the taskqueue */
572        em_add_rx_process_limit(adapter, "rx_processing_limit",
573            "max number of rx packets to process", &adapter->rx_process_limit,
574            em_rx_process_limit);
575#endif
576
577#ifdef __rtems__
578        {
579        int em_txd_tmp = em_txd;
580        int em_rxd_tmp = em_rxd;
581#define em_txd em_txd_tmp
582#define em_rxd em_rxd_tmp
583                /* Does ifconfig override ? */
584                if ( dev->ifconfig ) {
585                        if ( dev->ifconfig->xbuf_count )
586                                em_txd_tmp = dev->ifconfig->xbuf_count;
587                        if ( dev->ifconfig->rbuf_count )
588                                em_rxd_tmp = dev->ifconfig->rbuf_count;
589                }
590#endif
591
592        /*
593         * Validate number of transmit and receive descriptors. It
594         * must not exceed hardware maximum, and must be multiple
595         * of E1000_DBA_ALIGN.
596         */
597        if (((em_txd * sizeof(struct e1000_tx_desc)) % EM_DBA_ALIGN) != 0 ||
598            (adapter->hw.mac.type >= e1000_82544 && em_txd > EM_MAX_TXD) ||
599            (adapter->hw.mac.type < e1000_82544 && em_txd > EM_MAX_TXD_82543) ||
600            (em_txd < EM_MIN_TXD)) {
601                device_printf(dev, "Using %d TX descriptors instead of %d!\n",
602                    EM_DEFAULT_TXD, em_txd);
603                adapter->num_tx_desc = EM_DEFAULT_TXD;
604        } else
605                adapter->num_tx_desc = em_txd;
606        if (((em_rxd * sizeof(struct e1000_rx_desc)) % EM_DBA_ALIGN) != 0 ||
607            (adapter->hw.mac.type >= e1000_82544 && em_rxd > EM_MAX_RXD) ||
608            (adapter->hw.mac.type < e1000_82544 && em_rxd > EM_MAX_RXD_82543) ||
609            (em_rxd < EM_MIN_RXD)) {
610                device_printf(dev, "Using %d RX descriptors instead of %d!\n",
611                    EM_DEFAULT_RXD, em_rxd);
612                adapter->num_rx_desc = EM_DEFAULT_RXD;
613        } else
614                adapter->num_rx_desc = em_rxd;
615
616#ifdef __rtems__
617#undef em_txd
618#undef em_rxd
619        }
620#endif
621
622        adapter->hw.mac.autoneg = DO_AUTO_NEG;
623        adapter->hw.phy.wait_for_link = FALSE;
624        adapter->hw.phy.autoneg_advertised = AUTONEG_ADV_DEFAULT;
625        adapter->rx_buffer_len = 2048;
626
627        e1000_init_script_state_82541(&adapter->hw, TRUE);
628        e1000_set_tbi_compatibility_82543(&adapter->hw, TRUE);
629
630        /* Copper options */
631        if (adapter->hw.media_type == e1000_media_type_copper) {
632                adapter->hw.phy.mdix = AUTO_ALL_MODES;
633                adapter->hw.phy.disable_polarity_correction = FALSE;
634                adapter->hw.phy.ms_type = EM_MASTER_SLAVE;
635        }
636
637        /*
638         * Set the max frame size assuming standard ethernet
639         * sized frames.
640         */
641        adapter->hw.mac.max_frame_size =
642            ETHERMTU + ETHER_HDR_LEN + ETHERNET_FCS_SIZE;
643
644        adapter->hw.mac.min_frame_size = ETH_ZLEN + ETHERNET_FCS_SIZE;
645
646        /*
647         * This controls when hardware reports transmit completion
648         * status.
649         */
650        adapter->hw.mac.report_tx_early = 1;
651
652        tsize = roundup2(adapter->num_tx_desc * sizeof(struct e1000_tx_desc),
653            EM_DBA_ALIGN);
654
655        /* Allocate Transmit Descriptor ring */
656        if (em_dma_malloc(adapter, tsize, &adapter->txdma, BUS_DMA_NOWAIT)) {
657                device_printf(dev, "Unable to allocate tx_desc memory\n");
658                error = ENOMEM;
659                goto err_tx_desc;
660        }
661        adapter->tx_desc_base = 
662            (struct e1000_tx_desc *)adapter->txdma.dma_vaddr;
663
664        rsize = roundup2(adapter->num_rx_desc * sizeof(struct e1000_rx_desc),
665            EM_DBA_ALIGN);
666
667        /* Allocate Receive Descriptor ring */
668        if (em_dma_malloc(adapter, rsize, &adapter->rxdma, BUS_DMA_NOWAIT)) {
669                device_printf(dev, "Unable to allocate rx_desc memory\n");
670                error = ENOMEM;
671                goto err_rx_desc;
672        }
673        adapter->rx_desc_base =
674            (struct e1000_rx_desc *)adapter->rxdma.dma_vaddr;
675
676        /* Make sure we have a good EEPROM before we read from it */
677        if (e1000_validate_nvm_checksum(&adapter->hw) < 0) {
678                /*
679                ** Some PCI-E parts fail the first check due to
680                ** the link being in sleep state, call it again,
681                ** if it fails a second time its a real issue.
682                */
683                if (e1000_validate_nvm_checksum(&adapter->hw) < 0) {
684                        device_printf(dev,
685                            "The EEPROM Checksum Is Not Valid\n");
686                        error = EIO;
687                        goto err_hw_init;
688                }
689        }
690
691        if (e1000_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) {
692                device_printf(dev, "EEPROM read error "
693                    "reading part number\n");
694                error = EIO;
695                goto err_hw_init;
696        }
697
698        /* Initialize the hardware */
699        if (em_hardware_init(adapter)) {
700                device_printf(dev, "Unable to initialize the hardware\n");
701                error = EIO;
702                goto err_hw_init;
703        }
704
705        /* Copy the permanent MAC address out of the EEPROM */
706        if (e1000_read_mac_addr(&adapter->hw) < 0) {
707                device_printf(dev, "EEPROM read error while reading MAC"
708                    " address\n");
709                error = EIO;
710                goto err_hw_init;
711        }
712
713        if (!em_is_valid_ether_addr((uint8_t*)adapter->hw.mac.addr)) {
714                device_printf(dev, "Invalid MAC address\n");
715                error = EIO;
716                goto err_hw_init;
717        }
718
719        /* Setup OS specific network interface */
720        em_setup_interface(dev, adapter);
721
722        em_allocate_intr(adapter);
723
724        /* Initialize statistics */
725        em_update_stats_counters(adapter);
726
727        adapter->hw.mac.get_link_status = 1;
728        em_update_link_status(adapter);
729
730        /* Indicate SOL/IDER usage */
731        if (e1000_check_reset_block(&adapter->hw))
732                device_printf(dev,
733                    "PHY reset is blocked due to SOL/IDER session.\n");
734
735        /* Determine if we have to control management hardware */
736        adapter->has_manage = e1000_enable_mng_pass_thru(&adapter->hw);
737
738        /*
739         * Setup Wake-on-Lan
740         */
741        switch (adapter->hw.mac.type) {
742
743#if !defined(NO_82542_SUPPORT) /* __rtems__ */
744        case e1000_82542:
745#endif
746        case e1000_82543:
747                break;
748        case e1000_82546:
749        case e1000_82546_rev_3:
750        case e1000_82571:
751        case e1000_80003es2lan:
752                if (adapter->hw.bus.func == 1)
753                        e1000_read_nvm(&adapter->hw,
754                            NVM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
755                else
756                        e1000_read_nvm(&adapter->hw,
757                            NVM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
758                eeprom_data &= EM_EEPROM_APME;
759                break;
760        default:
761                /* APME bit in EEPROM is mapped to WUC.APME */
762                eeprom_data = E1000_READ_REG(&adapter->hw, E1000_WUC) &
763                    E1000_WUC_APME;
764                break;
765        }
766        if (eeprom_data)
767                adapter->wol = E1000_WUFC_MAG;
768        /*
769         * We have the eeprom settings, now apply the special cases
770         * where the eeprom may be wrong or the board won't support
771         * wake on lan on a particular port
772         */
773        device_id = pci_get_device(dev);
774        switch (device_id) {
775        case E1000_DEV_ID_82546GB_PCIE:
776                adapter->wol = 0;
777                break;
778        case E1000_DEV_ID_82546EB_FIBER:
779        case E1000_DEV_ID_82546GB_FIBER:
780        case E1000_DEV_ID_82571EB_FIBER:
781                /* Wake events only supported on port A for dual fiber
782                 * regardless of eeprom setting */
783                if (E1000_READ_REG(&adapter->hw, E1000_STATUS) &
784                    E1000_STATUS_FUNC_1)
785                        adapter->wol = 0;
786                break;
787        case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
788        case E1000_DEV_ID_82571EB_QUAD_COPPER:
789        case E1000_DEV_ID_82571EB_QUAD_FIBER:
790        case E1000_DEV_ID_82571EB_QUAD_COPPER_LP:
791                /* if quad port adapter, disable WoL on all but port A */
792                if (global_quad_port_a != 0)
793                        adapter->wol = 0;
794                /* Reset for multiple quad port adapters */
795                if (++global_quad_port_a == 4)
796                        global_quad_port_a = 0;
797                break;
798        }
799
800        /* Do we need workaround for 82544 PCI-X adapter? */
801        if (adapter->hw.bus.type == e1000_bus_type_pcix &&
802            adapter->hw.mac.type == e1000_82544)
803                adapter->pcix_82544 = TRUE;
804        else
805                adapter->pcix_82544 = FALSE;
806
807        /* Tell the stack that the interface is not active */
808        adapter->ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
809
810        INIT_DEBUGOUT("em_attach: end");
811
812        return (0);
813
814err_hw_init:
815        em_release_hw_control(adapter);
816        e1000_remove_device(&adapter->hw);
817        em_dma_free(adapter, &adapter->rxdma);
818err_rx_desc:
819        em_dma_free(adapter, &adapter->txdma);
820err_tx_desc:
821err_pci:
822        em_free_intr(adapter);
823        em_free_pci_resources(adapter);
824        EM_LOCK_DESTROY(adapter);
825
826        return (error);
827}
828
829/*********************************************************************
830 *  Device removal routine
831 *
832 *  The detach entry point is called when the driver is being removed.
833 *  This routine stops the adapter and deallocates all the resources
834 *  that were allocated for driver operation.
835 *
836 *  return 0 on success, positive on failure
837 *********************************************************************/
838
839static int
840em_detach(device_t dev)
841{
842        struct adapter  *adapter = device_get_softc(dev);
843        struct ifnet    *ifp = adapter->ifp;
844
845        INIT_DEBUGOUT("em_detach: begin");
846
847#ifdef DEVICE_POLLING
848        if (ifp->if_capenable & IFCAP_POLLING)
849                ether_poll_deregister(ifp);
850#endif
851
852        em_disable_intr(adapter);
853        em_free_intr(adapter);
854        EM_LOCK(adapter);
855        adapter->in_detach = 1;
856        em_stop(adapter);
857        e1000_phy_hw_reset(&adapter->hw);
858
859        em_release_manageability(adapter);
860
861        if (((adapter->hw.mac.type == e1000_82573) ||
862            (adapter->hw.mac.type == e1000_ich8lan) ||
863            (adapter->hw.mac.type == e1000_ich9lan)) &&
864            e1000_check_mng_mode(&adapter->hw))
865                em_release_hw_control(adapter);
866
867        if (adapter->wol) {
868                E1000_WRITE_REG(&adapter->hw, E1000_WUC, E1000_WUC_PME_EN);
869                E1000_WRITE_REG(&adapter->hw, E1000_WUFC, adapter->wol);
870                em_enable_wakeup(dev);
871        }
872
873        EM_UNLOCK(adapter);
874        ether_ifdetach(adapter->ifp);
875
876        callout_drain(&adapter->timer);
877        callout_drain(&adapter->tx_fifo_timer);
878
879        em_free_pci_resources(adapter);
880        bus_generic_detach(dev);
881        if_free(ifp);
882
883        e1000_remove_device(&adapter->hw);
884        em_free_transmit_structures(adapter);
885        em_free_receive_structures(adapter);
886
887        /* Free Transmit Descriptor ring */
888        if (adapter->tx_desc_base) {
889                em_dma_free(adapter, &adapter->txdma);
890                adapter->tx_desc_base = NULL;
891        }
892
893        /* Free Receive Descriptor ring */
894        if (adapter->rx_desc_base) {
895                em_dma_free(adapter, &adapter->rxdma);
896                adapter->rx_desc_base = NULL;
897        }
898
899        EM_LOCK_DESTROY(adapter);
900
901        return (0);
902}
903
904#ifndef __rtems__
905/*********************************************************************
906 *
907 *  Shutdown entry point
908 *
909 **********************************************************************/
910
911static int
912em_shutdown(device_t dev)
913{
914        return em_suspend(dev);
915}
916
917/*
918 * Suspend/resume device methods.
919 */
920static int
921em_suspend(device_t dev)
922{
923        struct adapter *adapter = device_get_softc(dev);
924
925        EM_LOCK(adapter);
926        em_stop(adapter);
927
928        em_release_manageability(adapter);
929
930        if (((adapter->hw.mac.type == e1000_82573) ||
931            (adapter->hw.mac.type == e1000_ich8lan) ||
932            (adapter->hw.mac.type == e1000_ich9lan)) &&
933            e1000_check_mng_mode(&adapter->hw))
934                em_release_hw_control(adapter);
935
936        if (adapter->wol) {
937                E1000_WRITE_REG(&adapter->hw, E1000_WUC, E1000_WUC_PME_EN);
938                E1000_WRITE_REG(&adapter->hw, E1000_WUFC, adapter->wol);
939                em_enable_wakeup(dev);
940        }
941
942        EM_UNLOCK(adapter);
943
944        return bus_generic_suspend(dev);
945}
946
947static int
948em_resume(device_t dev)
949{
950        struct adapter *adapter = device_get_softc(dev);
951        struct ifnet *ifp = adapter->ifp;
952
953        EM_LOCK(adapter);
954        em_init_locked(adapter);
955        em_init_manageability(adapter);
956
957        if ((ifp->if_flags & IFF_UP) &&
958            (ifp->if_drv_flags & IFF_DRV_RUNNING))
959                em_start_locked(ifp);
960
961        EM_UNLOCK(adapter);
962
963        return bus_generic_resume(dev);
964}
965#endif
966
967
968/*********************************************************************
969 *  Transmit entry point
970 *
971 *  em_start is called by the stack to initiate a transmit.
972 *  The driver will remain in this routine as long as there are
973 *  packets to transmit and transmit resources are available.
974 *  In case resources are not available stack is notified and
975 *  the packet is requeued.
976 **********************************************************************/
977
978static void
979em_start_locked(struct ifnet *ifp)
980{
981        struct adapter  *adapter = ifp->if_softc;
982        struct mbuf     *m_head;
983
984        EM_LOCK_ASSERT(adapter);
985
986        if ((ifp->if_drv_flags & (IFF_DRV_RUNNING|IFF_DRV_OACTIVE)) !=
987            IFF_DRV_RUNNING)
988                return;
989        if (!adapter->link_active)
990                return;
991
992        while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
993
994                IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
995                if (m_head == NULL)
996                        break;
997                /*
998                 *  Encapsulation can modify our pointer, and or make it
999                 *  NULL on failure.  In that event, we can't requeue.
1000                 *
1001                 *  We now use a pointer to accomodate legacy and
1002                 *  advanced transmit functions.
1003                 */
1004                if (adapter->em_xmit(adapter, &m_head)) {
1005                        if (m_head == NULL)
1006                                break;
1007                        ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1008                        IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
1009                        break;
1010                }
1011
1012                /* Send a copy of the frame to the BPF listener */
1013                ETHER_BPF_MTAP(ifp, m_head);
1014
1015                /* Set timeout in case hardware has problems transmitting. */
1016                adapter->watchdog_timer = EM_TX_TIMEOUT;
1017        }
1018}
1019
1020static void
1021em_start(struct ifnet *ifp)
1022{
1023        struct adapter *adapter = ifp->if_softc;
1024
1025        EM_LOCK(adapter);
1026        if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1027                em_start_locked(ifp);
1028        EM_UNLOCK(adapter);
1029}
1030
1031/*********************************************************************
1032 *  Ioctl entry point
1033 *
1034 *  em_ioctl is called when the user wants to configure the
1035 *  interface.
1036 *
1037 *  return 0 on success, positive on failure
1038 **********************************************************************/
1039
1040static int
1041#ifndef __rtems__
1042em_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
1043#else
1044em_ioctl(struct ifnet *ifp, ioctl_command_t command, caddr_t data)
1045#endif
1046{
1047        struct adapter  *adapter = ifp->if_softc;
1048        struct ifreq *ifr = (struct ifreq *)data;
1049        struct ifaddr *ifa = (struct ifaddr *)data;
1050        int error = 0;
1051
1052        if (adapter->in_detach)
1053                return (error);
1054
1055        switch (command) {
1056        case SIOCSIFADDR:
1057                if (ifa->ifa_addr->sa_family == AF_INET) {
1058                        /*
1059                         * XXX
1060                         * Since resetting hardware takes a very long time
1061                         * and results in link renegotiation we only
1062                         * initialize the hardware only when it is absolutely
1063                         * required.
1064                         */
1065                        ifp->if_flags |= IFF_UP;
1066                        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
1067                                EM_LOCK(adapter);
1068                                em_init_locked(adapter);
1069                                EM_UNLOCK(adapter);
1070                        }
1071                        arp_ifinit(ifp, ifa);
1072                } else
1073                        error = ether_ioctl(ifp, command, data);
1074                break;
1075        case SIOCSIFMTU:
1076            {
1077                int max_frame_size;
1078                uint16_t eeprom_data = 0;
1079
1080                IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)");
1081
1082                EM_LOCK(adapter);
1083                switch (adapter->hw.mac.type) {
1084                case e1000_82573:
1085                        /*
1086                         * 82573 only supports jumbo frames
1087                         * if ASPM is disabled.
1088                         */
1089                        e1000_read_nvm(&adapter->hw,
1090                            NVM_INIT_3GIO_3, 1, &eeprom_data);
1091                        if (eeprom_data & NVM_WORD1A_ASPM_MASK) {
1092                                max_frame_size = ETHER_MAX_LEN;
1093                                break;
1094                        }
1095                        /* Allow Jumbo frames - fall thru */
1096                case e1000_82571:
1097                case e1000_82572:
1098                case e1000_ich9lan:
1099                case e1000_82575:
1100                case e1000_80003es2lan: /* Limit Jumbo Frame size */
1101                        max_frame_size = 9234;
1102                        break;
1103                        /* Adapters that do not support jumbo frames */
1104#if !defined(NO_82542_SUPPORT) /* __rtems__ */
1105                case e1000_82542:
1106#endif
1107                case e1000_ich8lan:
1108                        max_frame_size = ETHER_MAX_LEN;
1109                        break;
1110                default:
1111                        max_frame_size = MAX_JUMBO_FRAME_SIZE;
1112                }
1113                if (ifr->ifr_mtu > max_frame_size - ETHER_HDR_LEN -
1114                    ETHER_CRC_LEN) {
1115                        EM_UNLOCK(adapter);
1116                        error = EINVAL;
1117                        break;
1118                }
1119
1120                ifp->if_mtu = ifr->ifr_mtu;
1121                adapter->hw.mac.max_frame_size =
1122                ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
1123                em_init_locked(adapter);
1124                EM_UNLOCK(adapter);
1125                break;
1126            }
1127        case SIOCSIFFLAGS:
1128                IOCTL_DEBUGOUT("ioctl rcv'd:\
1129                    SIOCSIFFLAGS (Set Interface Flags)");
1130                EM_LOCK(adapter);
1131                if (ifp->if_flags & IFF_UP) {
1132                        if ((ifp->if_drv_flags & IFF_DRV_RUNNING)) {
1133                                if ((ifp->if_flags ^ adapter->if_flags) &
1134                                    IFF_PROMISC) {
1135                                        em_disable_promisc(adapter);
1136                                        em_set_promisc(adapter);
1137                                }
1138                        } else
1139                                em_init_locked(adapter);
1140                } else
1141                        if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1142                                em_stop(adapter);
1143                adapter->if_flags = ifp->if_flags;
1144                EM_UNLOCK(adapter);
1145                break;
1146        case SIOCADDMULTI:
1147        case SIOCDELMULTI:
1148                IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI");
1149#ifdef __rtems__
1150                if ( ETHER_SIOCMULTIFRAG(error, command, ifr, ifp) )
1151                        break;
1152#endif
1153                if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1154                        EM_LOCK(adapter);
1155                        em_disable_intr(adapter);
1156                        em_set_multi(adapter);
1157#if !defined(NO_82542_SUPPORT) /* __rtems__ */
1158                        if (adapter->hw.mac.type == e1000_82542 && 
1159                            adapter->hw.revision_id == E1000_REVISION_2) {
1160                                em_initialize_receive_unit(adapter);
1161                        }
1162#endif
1163#ifdef DEVICE_POLLING
1164                        if (!(ifp->if_capenable & IFCAP_POLLING))
1165#endif
1166                                em_enable_intr(adapter);
1167                        EM_UNLOCK(adapter);
1168                }
1169#ifdef __rtems__
1170                  else
1171                        error = 0;
1172#endif
1173                break;
1174        case SIOCSIFMEDIA:
1175                /* Check SOL/IDER usage */
1176                EM_LOCK(adapter);
1177                if (e1000_check_reset_block(&adapter->hw)) {
1178                        EM_UNLOCK(adapter);
1179                        device_printf(adapter->dev, "Media change is"
1180                            " blocked due to SOL/IDER session.\n");
1181#ifdef __rtems__
1182                        /* it seems we should set error here */
1183                        error = EBUSY;
1184#endif
1185                        break;
1186                }
1187                EM_UNLOCK(adapter);
1188        case SIOCGIFMEDIA:
1189                IOCTL_DEBUGOUT("ioctl rcv'd: \
1190                    SIOCxIFMEDIA (Get/Set Interface Media)");
1191                error = ifmedia_ioctl(ifp, ifr, &adapter->media, command);
1192                break;
1193#ifndef __rtems__
1194        case SIOCSIFCAP:
1195            {
1196                int mask, reinit;
1197
1198                IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)");
1199                reinit = 0;
1200                mask = ifr->ifr_reqcap ^ ifp->if_capenable;
1201#ifdef DEVICE_POLLING
1202                if (mask & IFCAP_POLLING) {
1203                        if (ifr->ifr_reqcap & IFCAP_POLLING) {
1204                                error = ether_poll_register(em_poll, ifp);
1205                                if (error)
1206                                        return (error);
1207                                EM_LOCK(adapter);
1208                                em_disable_intr(adapter);
1209                                ifp->if_capenable |= IFCAP_POLLING;
1210                                EM_UNLOCK(adapter);
1211                        } else {
1212                                error = ether_poll_deregister(ifp);
1213                                /* Enable interrupt even in error case */
1214                                EM_LOCK(adapter);
1215                                em_enable_intr(adapter);
1216                                ifp->if_capenable &= ~IFCAP_POLLING;
1217                                EM_UNLOCK(adapter);
1218                        }
1219                }
1220#endif
1221                if (mask & IFCAP_HWCSUM) {
1222                        ifp->if_capenable ^= IFCAP_HWCSUM;
1223                        reinit = 1;
1224                }
1225                if (mask & IFCAP_TSO4) {
1226                        ifp->if_capenable ^= IFCAP_TSO4;
1227                        reinit = 1;
1228                }
1229                if (mask & IFCAP_VLAN_HWTAGGING) {
1230                        ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
1231                        reinit = 1;
1232                }
1233                if (reinit && (ifp->if_drv_flags & IFF_DRV_RUNNING))
1234                        em_init(adapter);
1235                VLAN_CAPABILITIES(ifp);
1236                break;
1237            }
1238#endif
1239
1240#ifdef __rtems__
1241    case SIO_RTEMS_SHOW_STATS:
1242        em_print_hw_stats(adapter);
1243        error = 0;
1244        break;
1245#endif
1246
1247        default:
1248                error = ether_ioctl(ifp, command, data);
1249                break;
1250        }
1251
1252        return (error);
1253}
1254
1255/*********************************************************************
1256 *  Watchdog timer:
1257 *
1258 *  This routine is called from the local timer every second.
1259 *  As long as transmit descriptors are being cleaned the value
1260 *  is non-zero and we do nothing. Reaching 0 indicates a tx hang
1261 *  and we then reset the device.
1262 *
1263 **********************************************************************/
1264
1265static void
1266em_watchdog(struct adapter *adapter)
1267{
1268
1269        EM_LOCK_ASSERT(adapter);
1270
1271        /*
1272        ** The timer is set to 5 every time start queues a packet.
1273        ** Then txeof keeps resetting to 5 as long as it cleans at
1274        ** least one descriptor.
1275        ** Finally, anytime all descriptors are clean the timer is
1276        ** set to 0.
1277        */
1278        if (adapter->watchdog_timer == 0 || --adapter->watchdog_timer)
1279                return;
1280
1281        /* If we are in this routine because of pause frames, then
1282         * don't reset the hardware.
1283         */
1284        if (E1000_READ_REG(&adapter->hw, E1000_STATUS) &
1285            E1000_STATUS_TXOFF) {
1286                adapter->watchdog_timer = EM_TX_TIMEOUT;
1287                return;
1288        }
1289
1290        if (e1000_check_for_link(&adapter->hw) == 0)
1291                device_printf(adapter->dev, "watchdog timeout -- resetting\n");
1292        adapter->ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1293        adapter->watchdog_events++;
1294
1295        em_init_locked(adapter);
1296}
1297
1298/*********************************************************************
1299 *  Init entry point
1300 *
1301 *  This routine is used in two ways. It is used by the stack as
1302 *  init entry point in network interface structure. It is also used
1303 *  by the driver as a hw/sw initialization routine to get to a
1304 *  consistent state.
1305 *
1306 *  return 0 on success, positive on failure
1307 **********************************************************************/
1308
1309static void
1310em_init_locked(struct adapter *adapter)
1311{
1312        struct ifnet    *ifp = adapter->ifp;
1313        device_t        dev = adapter->dev;
1314        uint32_t        pba;
1315
1316        INIT_DEBUGOUT("em_init: begin");
1317
1318        EM_LOCK_ASSERT(adapter);
1319
1320        em_stop(adapter);
1321
1322        /*
1323         * Packet Buffer Allocation (PBA)
1324         * Writing PBA sets the receive portion of the buffer
1325         * the remainder is used for the transmit buffer.
1326         *
1327         * Devices before the 82547 had a Packet Buffer of 64K.
1328         *   Default allocation: PBA=48K for Rx, leaving 16K for Tx.
1329         * After the 82547 the buffer was reduced to 40K.
1330         *   Default allocation: PBA=30K for Rx, leaving 10K for Tx.
1331         *   Note: default does not leave enough room for Jumbo Frame >10k.
1332         */
1333        switch (adapter->hw.mac.type) {
1334        case e1000_82547:
1335        case e1000_82547_rev_2: /* 82547: Total Packet Buffer is 40K */
1336                if (adapter->hw.mac.max_frame_size > 8192)
1337                        pba = E1000_PBA_22K; /* 22K for Rx, 18K for Tx */
1338                else
1339                        pba = E1000_PBA_30K; /* 30K for Rx, 10K for Tx */
1340                adapter->tx_fifo_head = 0;
1341                adapter->tx_head_addr = pba << EM_TX_HEAD_ADDR_SHIFT;
1342                adapter->tx_fifo_size =
1343                    (E1000_PBA_40K - pba) << EM_PBA_BYTES_SHIFT;
1344                break;
1345        /* Total Packet Buffer on these is 48K */
1346        case e1000_82571:
1347        case e1000_82572:
1348        case e1000_82575:
1349        case e1000_80003es2lan:
1350                        pba = E1000_PBA_32K; /* 32K for Rx, 16K for Tx */
1351                break;
1352        case e1000_82573: /* 82573: Total Packet Buffer is 32K */
1353                        pba = E1000_PBA_12K; /* 12K for Rx, 20K for Tx */
1354                break;
1355        case e1000_ich9lan:
1356#define E1000_PBA_10K   0x000A
1357                pba = E1000_PBA_10K;
1358                break;
1359        case e1000_ich8lan:
1360                pba = E1000_PBA_8K;
1361                break;
1362        default:
1363                /* Devices before 82547 had a Packet Buffer of 64K.   */
1364                if (adapter->hw.mac.max_frame_size > 8192)
1365                        pba = E1000_PBA_40K; /* 40K for Rx, 24K for Tx */
1366                else
1367                        pba = E1000_PBA_48K; /* 48K for Rx, 16K for Tx */
1368        }
1369
1370        INIT_DEBUGOUT1("em_init: pba=%dK",(int)pba);
1371        E1000_WRITE_REG(&adapter->hw, E1000_PBA, pba);
1372       
1373        /* Get the latest mac address, User can use a LAA */
1374        bcopy(IF_LLADDR(adapter->ifp), adapter->hw.mac.addr,
1375              ETHER_ADDR_LEN);
1376
1377        /* Put the address into the Receive Address Array */
1378        e1000_rar_set(&adapter->hw, adapter->hw.mac.addr, 0);
1379
1380        /*
1381         * With 82571 controllers, LAA may be overwritten
1382         * due to controller reset from the other port.
1383         */
1384        if (adapter->hw.mac.type == e1000_82571)
1385                e1000_set_laa_state_82571(&adapter->hw, TRUE);
1386
1387        /* Initialize the hardware */
1388        if (em_hardware_init(adapter)) {
1389                device_printf(dev, "Unable to initialize the hardware\n");
1390                return;
1391        }
1392        em_update_link_status(adapter);
1393
1394#ifndef __rtems__
1395        if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
1396                em_enable_vlans(adapter);
1397
1398        /* Set hardware offload abilities */
1399        ifp->if_hwassist = 0;
1400        if (adapter->hw.mac.type >= e1000_82543) {
1401                if (ifp->if_capenable & IFCAP_TXCSUM)
1402                        ifp->if_hwassist |= (CSUM_TCP | CSUM_UDP);
1403                if (ifp->if_capenable & IFCAP_TSO4)
1404                        ifp->if_hwassist |= CSUM_TSO;
1405        }
1406#endif
1407
1408        /* Configure for OS presence */
1409        em_init_manageability(adapter);
1410
1411        /* Prepare transmit descriptors and buffers */
1412        if (em_setup_transmit_structures(adapter)) {
1413                device_printf(dev, "Could not setup transmit structures\n");
1414                em_stop(adapter);
1415                return;
1416        }
1417        em_initialize_transmit_unit(adapter);
1418
1419        /* Setup Multicast table */
1420        em_set_multi(adapter);
1421
1422        /* Prepare receive descriptors and buffers */
1423        if (em_setup_receive_structures(adapter)) {
1424                device_printf(dev, "Could not setup receive structures\n");
1425                em_stop(adapter);
1426                return;
1427        }
1428        em_initialize_receive_unit(adapter);
1429
1430        /* Don't lose promiscuous settings */
1431        em_set_promisc(adapter);
1432
1433        ifp->if_drv_flags |= IFF_DRV_RUNNING;
1434        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1435
1436        callout_reset(&adapter->timer, hz, em_local_timer, adapter);
1437        e1000_clear_hw_cntrs_base_generic(&adapter->hw);
1438
1439#ifdef DEVICE_POLLING
1440        /*
1441         * Only enable interrupts if we are not polling, make sure
1442         * they are off otherwise.
1443         */
1444        if (ifp->if_capenable & IFCAP_POLLING)
1445                em_disable_intr(adapter);
1446        else
1447#endif /* DEVICE_POLLING */
1448                em_enable_intr(adapter);
1449
1450        /* Don't reset the phy next time init gets called */
1451        adapter->hw.phy.reset_disable = TRUE;
1452}
1453
1454static void
1455em_init(void *arg)
1456{
1457        struct adapter *adapter = arg;
1458
1459        EM_LOCK(adapter);
1460        em_init_locked(adapter);
1461        EM_UNLOCK(adapter);
1462}
1463
1464
1465#ifdef DEVICE_POLLING
1466/*********************************************************************
1467 *
1468 *  Legacy polling routine 
1469 *
1470 *********************************************************************/
1471static void
1472em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
1473{
1474        struct adapter *adapter = ifp->if_softc;
1475        uint32_t reg_icr;
1476
1477        EM_LOCK(adapter);
1478        if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
1479                EM_UNLOCK(adapter);
1480                return;
1481        }
1482
1483        if (cmd == POLL_AND_CHECK_STATUS) {
1484                reg_icr = E1000_READ_REG(&adapter->hw, E1000_ICR);
1485                if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
1486                        callout_stop(&adapter->timer);
1487                        adapter->hw.mac.get_link_status = 1;
1488                        e1000_check_for_link(&adapter->hw);
1489                        em_update_link_status(adapter);
1490                        callout_reset(&adapter->timer, hz,
1491                            em_local_timer, adapter);
1492                }
1493        }
1494        em_rxeof(adapter, count);
1495        em_txeof(adapter);
1496
1497        if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
1498                em_start_locked(ifp);
1499        EM_UNLOCK(adapter);
1500}
1501
1502/*********************************************************************
1503 *
1504 *  Legacy Interrupt Service routine 
1505 *
1506 *********************************************************************/
1507
1508static void
1509em_intr(void *arg)
1510{
1511        struct adapter  *adapter = arg;
1512        struct ifnet    *ifp;
1513        uint32_t        reg_icr;
1514
1515        EM_LOCK(adapter);
1516        ifp = adapter->ifp;
1517
1518        if (ifp->if_capenable & IFCAP_POLLING) {
1519                EM_UNLOCK(adapter);
1520                return;
1521        }
1522
1523        for (;;) {
1524                reg_icr = E1000_READ_REG(&adapter->hw, E1000_ICR);
1525
1526                if (adapter->hw.mac.type >= e1000_82571 &&
1527                    (reg_icr & E1000_ICR_INT_ASSERTED) == 0)
1528                        break;
1529                else if (reg_icr == 0)
1530                        break;
1531
1532                /*
1533                 * XXX: some laptops trigger several spurious interrupts
1534                 * on em(4) when in the resume cycle. The ICR register
1535                 * reports all-ones value in this case. Processing such
1536                 * interrupts would lead to a freeze. I don't know why.
1537                 */
1538                if (reg_icr == 0xffffffff)
1539                        break;
1540
1541                if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1542                        em_rxeof(adapter, -1);
1543                        em_txeof(adapter);
1544                }
1545
1546                /* Link status change */
1547                if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
1548                        callout_stop(&adapter->timer);
1549                        adapter->hw.mac.get_link_status = 1;
1550                        e1000_check_for_link(&adapter->hw);
1551                        em_update_link_status(adapter);
1552                        callout_reset(&adapter->timer, hz,
1553                            em_local_timer, adapter);
1554                }
1555
1556                if (reg_icr & E1000_ICR_RXO)
1557                        adapter->rx_overruns++;
1558        }
1559
1560        if (ifp->if_drv_flags & IFF_DRV_RUNNING &&
1561            !IFQ_DRV_IS_EMPTY(&ifp->if_snd))
1562                em_start_locked(ifp);
1563        EM_UNLOCK(adapter);
1564}
1565
1566#else /* if not DEVICE_POLLING, then fast interrupt routines only */
1567
1568static void
1569em_handle_link(void *context, int pending)
1570{
1571        struct adapter  *adapter = context;
1572        struct ifnet *ifp;
1573
1574        ifp = adapter->ifp;
1575
1576        EM_LOCK(adapter);
1577        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
1578                EM_UNLOCK(adapter);
1579                return;
1580        }
1581
1582        callout_stop(&adapter->timer);
1583        adapter->hw.mac.get_link_status = 1;
1584        e1000_check_for_link(&adapter->hw);
1585        em_update_link_status(adapter);
1586        callout_reset(&adapter->timer, hz, em_local_timer, adapter);
1587        EM_UNLOCK(adapter);
1588}
1589
1590int em_rxtx_irqs=0;
1591int em_rxtx_hirqs=0;
1592
1593static void
1594em_handle_rxtx(void *context, int pending)
1595{
1596        struct adapter  *adapter = context;
1597        struct ifnet    *ifp;
1598
1599        em_rxtx_irqs ++ ;
1600
1601        NET_LOCK_GIANT();
1602        ifp = adapter->ifp;
1603
1604        /*
1605         * TODO:
1606         * It should be possible to run the tx clean loop without the lock.
1607         */
1608        if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1609                if (em_rxeof(adapter, adapter->rx_process_limit) != 0)
1610                        taskqueue_enqueue(adapter->tq, &adapter->rxtx_task);
1611                EM_LOCK(adapter);
1612                em_txeof(adapter);
1613
1614                if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
1615                        em_start_locked(ifp);
1616                EM_UNLOCK(adapter);
1617        }
1618
1619        em_enable_intr(adapter);
1620        NET_UNLOCK_GIANT();
1621}
1622
1623/*********************************************************************
1624 *
1625 *  Fast Interrupt Service routine 
1626 *
1627 *********************************************************************/
1628static int
1629em_intr_fast(void *arg)
1630{
1631        struct adapter  *adapter = arg;
1632        struct ifnet    *ifp;
1633        uint32_t        reg_icr;
1634
1635        ifp = adapter->ifp;
1636
1637        reg_icr = E1000_READ_REG(&adapter->hw, E1000_ICR);
1638
1639        /* Hot eject?  */
1640        if (reg_icr == 0xffffffff)
1641                return (FILTER_STRAY);
1642
1643        /* Definitely not our interrupt.  */
1644        if (reg_icr == 0x0)
1645                return (FILTER_STRAY);
1646
1647        /*
1648         * Starting with the 82571 chip, bit 31 should be used to
1649         * determine whether the interrupt belongs to us.
1650         */
1651        if (adapter->hw.mac.type >= e1000_82571 &&
1652            (reg_icr & E1000_ICR_INT_ASSERTED) == 0)
1653                return (FILTER_STRAY);
1654
1655        /*
1656         * Mask interrupts until the taskqueue is finished running.  This is
1657         * cheap, just assume that it is needed.  This also works around the
1658         * MSI message reordering errata on certain systems.
1659         */
1660        em_disable_intr(adapter);
1661        taskqueue_enqueue(adapter->tq, &adapter->rxtx_task);
1662        em_rxtx_hirqs++;
1663
1664        /* Link status change */
1665        if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))
1666                taskqueue_enqueue(taskqueue_fast, &adapter->link_task);
1667
1668        if (reg_icr & E1000_ICR_RXO)
1669                adapter->rx_overruns++;
1670        return (FILTER_HANDLED);
1671}
1672#endif /* ! DEVICE_POLLING */
1673
1674/*********************************************************************
1675 *
1676 *  Media Ioctl callback
1677 *
1678 *  This routine is called whenever the user queries the status of
1679 *  the interface using ifconfig.
1680 *
1681 **********************************************************************/
1682static void
1683em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
1684{
1685        struct adapter *adapter = ifp->if_softc;
1686        u_char fiber_type = IFM_1000_SX;
1687
1688        INIT_DEBUGOUT("em_media_status: begin");
1689
1690        EM_LOCK(adapter);
1691        e1000_check_for_link(&adapter->hw);
1692        em_update_link_status(adapter);
1693
1694        ifmr->ifm_status = IFM_AVALID;
1695        ifmr->ifm_active = IFM_ETHER;
1696
1697        if (!adapter->link_active) {
1698                EM_UNLOCK(adapter);
1699                return;
1700        }
1701
1702        ifmr->ifm_status |= IFM_ACTIVE;
1703
1704        if ((adapter->hw.media_type == e1000_media_type_fiber) ||
1705            (adapter->hw.media_type == e1000_media_type_internal_serdes)) {
1706                if (adapter->hw.mac.type == e1000_82545)
1707                        fiber_type = IFM_1000_LX;
1708                ifmr->ifm_active |= fiber_type | IFM_FDX;
1709        } else {
1710                switch (adapter->link_speed) {
1711                case 10:
1712                        ifmr->ifm_active |= IFM_10_T;
1713                        break;
1714                case 100:
1715                        ifmr->ifm_active |= IFM_100_TX;
1716                        break;
1717                case 1000:
1718                        ifmr->ifm_active |= IFM_1000_T;
1719                        break;
1720                }
1721                if (adapter->link_duplex == FULL_DUPLEX)
1722                        ifmr->ifm_active |= IFM_FDX;
1723                else
1724                        ifmr->ifm_active |= IFM_HDX;
1725        }
1726        EM_UNLOCK(adapter);
1727}
1728
1729/*********************************************************************
1730 *
1731 *  Media Ioctl callback
1732 *
1733 *  This routine is called when the user changes speed/duplex using
1734 *  media/mediopt option with ifconfig.
1735 *
1736 **********************************************************************/
1737static int
1738em_media_change(struct ifnet *ifp)
1739{
1740        struct adapter *adapter = ifp->if_softc;
1741        struct ifmedia  *ifm = &adapter->media;
1742
1743        INIT_DEBUGOUT("em_media_change: begin");
1744
1745        if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
1746                return (EINVAL);
1747
1748        EM_LOCK(adapter);
1749        switch (IFM_SUBTYPE(ifm->ifm_media)) {
1750        case IFM_AUTO:
1751                adapter->hw.mac.autoneg = DO_AUTO_NEG;
1752                adapter->hw.phy.autoneg_advertised = AUTONEG_ADV_DEFAULT;
1753                break;
1754        case IFM_1000_LX:
1755        case IFM_1000_SX:
1756        case IFM_1000_T:
1757                adapter->hw.mac.autoneg = DO_AUTO_NEG;
1758                adapter->hw.phy.autoneg_advertised = ADVERTISE_1000_FULL;
1759                break;
1760        case IFM_100_TX:
1761                adapter->hw.mac.autoneg = FALSE;
1762                adapter->hw.phy.autoneg_advertised = 0;
1763                if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
1764                        adapter->hw.mac.forced_speed_duplex = ADVERTISE_100_FULL;
1765                else
1766                        adapter->hw.mac.forced_speed_duplex = ADVERTISE_100_HALF;
1767                break;
1768        case IFM_10_T:
1769                adapter->hw.mac.autoneg = FALSE;
1770                adapter->hw.phy.autoneg_advertised = 0;
1771                if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
1772                        adapter->hw.mac.forced_speed_duplex = ADVERTISE_10_FULL;
1773                else
1774                        adapter->hw.mac.forced_speed_duplex = ADVERTISE_10_HALF;
1775                break;
1776        default:
1777                device_printf(adapter->dev, "Unsupported media type\n");
1778        }
1779
1780        /* As the speed/duplex settings my have changed we need to
1781         * reset the PHY.
1782         */
1783        adapter->hw.phy.reset_disable = FALSE;
1784
1785        em_init_locked(adapter);
1786        EM_UNLOCK(adapter);
1787
1788        return (0);
1789}
1790
1791/*********************************************************************
1792 *
1793 *  This routine maps the mbufs to tx descriptors.
1794 *
1795 *  return 0 on success, positive on failure
1796 **********************************************************************/
1797
1798static int
1799em_encap(struct adapter *adapter, struct mbuf **m_headp)
1800{
1801        bus_dma_segment_t       segs[EM_MAX_SCATTER];
1802        bus_dmamap_t            map;
1803        struct em_buffer        *tx_buffer, *tx_buffer_mapped;
1804        struct e1000_tx_desc    *ctxd = NULL;
1805        struct mbuf             *m_head;
1806        uint32_t                txd_upper, txd_lower, txd_used, txd_saved;
1807        int                     nsegs, i, j, first, last = 0;
1808        int                     error, do_tso, tso_desc = 0;
1809
1810        m_head = *m_headp;
1811        txd_upper = txd_lower = txd_used = txd_saved = 0;
1812
1813#ifndef __rtems__
1814        do_tso = ((m_head->m_pkthdr.csum_flags & CSUM_TSO) != 0);
1815#else
1816        do_tso = 0;
1817#endif
1818
1819        /*
1820         * Force a cleanup if number of TX descriptors
1821         * available hits the threshold
1822         */
1823        if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
1824                em_txeof(adapter);
1825                /* Now do we at least have a minimal? */
1826                if (adapter->num_tx_desc_avail <= EM_TX_OP_THRESHOLD) {
1827                        adapter->no_tx_desc_avail1++;
1828                        return (ENOBUFS);
1829                }
1830        }
1831
1832
1833        /*
1834         * TSO workaround:
1835         *  If an mbuf is only header we need 
1836         *     to pull 4 bytes of data into it.
1837         */
1838        if (do_tso && (m_head->m_len <= M_TSO_LEN)) {
1839                m_head = m_pullup(m_head, M_TSO_LEN + 4);
1840                *m_headp = m_head;
1841                if (m_head == NULL)
1842                        return (ENOBUFS);
1843        }
1844
1845        /*
1846         * Map the packet for DMA
1847         *
1848         * Capture the first descriptor index,
1849         * this descriptor will have the index
1850         * of the EOP which is the only one that
1851         * now gets a DONE bit writeback.
1852         */
1853        first = adapter->next_avail_tx_desc;
1854        tx_buffer = &adapter->tx_buffer_area[first];
1855        tx_buffer_mapped = tx_buffer;
1856        map = tx_buffer->map;
1857
1858        error = bus_dmamap_load_mbuf_sg(adapter->txtag, map,
1859            *m_headp, segs, &nsegs, BUS_DMA_NOWAIT);
1860
1861        /*
1862         * There are two types of errors we can (try) to handle:
1863         * - EFBIG means the mbuf chain was too long and bus_dma ran
1864         *   out of segments.  Defragment the mbuf chain and try again.
1865         * - ENOMEM means bus_dma could not obtain enough bounce buffers
1866         *   at this point in time.  Defer sending and try again later.
1867         * All other errors, in particular EINVAL, are fatal and prevent the
1868         * mbuf chain from ever going through.  Drop it and report error.
1869         */
1870        if (error == EFBIG) {
1871                struct mbuf *m;
1872
1873                m = m_defrag(*m_headp, M_DONTWAIT);
1874                if (m == NULL) {
1875                        adapter->mbuf_alloc_failed++;
1876                        m_freem(*m_headp);
1877                        *m_headp = NULL;
1878                        return (ENOBUFS);
1879                }
1880                *m_headp = m;
1881
1882                /* Try it again */
1883                error = bus_dmamap_load_mbuf_sg(adapter->txtag, map,
1884                    *m_headp, segs, &nsegs, BUS_DMA_NOWAIT);
1885
1886                if (error == ENOMEM) {
1887                        adapter->no_tx_dma_setup++;
1888                        return (error);
1889                } else if (error != 0) {
1890                        adapter->no_tx_dma_setup++;
1891                        m_freem(*m_headp);
1892                        *m_headp = NULL;
1893                        return (error);
1894                }
1895        } else if (error == ENOMEM) {
1896                adapter->no_tx_dma_setup++;
1897                return (error);
1898        } else if (error != 0) {
1899                adapter->no_tx_dma_setup++;
1900                m_freem(*m_headp);
1901                *m_headp = NULL;
1902                return (error);
1903        }
1904
1905        /*
1906         * TSO Hardware workaround, if this packet is not
1907         * TSO, and is only a single descriptor long, and
1908         * it follows a TSO burst, then we need to add a
1909         * sentinel descriptor to prevent premature writeback.
1910         */
1911        if ((do_tso == 0) && (adapter->tx_tso == TRUE)) {
1912                if (nsegs == 1)
1913                        tso_desc = TRUE;
1914                adapter->tx_tso = FALSE;
1915        }
1916
1917        if (nsegs > (adapter->num_tx_desc_avail - 2)) {
1918                adapter->no_tx_desc_avail2++;
1919                bus_dmamap_unload(adapter->txtag, map);
1920                return (ENOBUFS);
1921        }
1922        m_head = *m_headp;
1923
1924#ifndef __rtems__
1925        /* Do hardware assists */
1926        if (em_tso_setup(adapter, m_head, &txd_upper, &txd_lower))
1927                /* we need to make a final sentinel transmit desc */
1928                tso_desc = TRUE;
1929        else if (m_head->m_pkthdr.csum_flags & CSUM_OFFLOAD)
1930                em_transmit_checksum_setup(adapter,  m_head,
1931                    &txd_upper, &txd_lower);
1932#endif
1933
1934        i = adapter->next_avail_tx_desc;
1935        if (adapter->pcix_82544) 
1936                txd_saved = i;
1937
1938        /* Set up our transmit descriptors */
1939        for (j = 0; j < nsegs; j++) {
1940                bus_size_t seg_len;
1941                bus_addr_t seg_addr;
1942                /* If adapter is 82544 and on PCIX bus */
1943                if(adapter->pcix_82544) {
1944                        DESC_ARRAY      desc_array;
1945                        uint32_t        array_elements, counter;
1946                        /*
1947                         * Check the Address and Length combination and
1948                         * split the data accordingly
1949                         */
1950                        array_elements = em_fill_descriptors(segs[j].ds_addr,
1951                            segs[j].ds_len, &desc_array);
1952                        for (counter = 0; counter < array_elements; counter++) {
1953                                if (txd_used == adapter->num_tx_desc_avail) {
1954                                        adapter->next_avail_tx_desc = txd_saved;
1955                                        adapter->no_tx_desc_avail2++;
1956                                        bus_dmamap_unload(adapter->txtag, map);
1957                                        return (ENOBUFS);
1958                                }
1959                                tx_buffer = &adapter->tx_buffer_area[i];
1960                                ctxd = &adapter->tx_desc_base[i];
1961                                ctxd->buffer_addr = htole64(
1962                                    desc_array.descriptor[counter].address);
1963                                ctxd->lower.data = htole32(
1964                                    (adapter->txd_cmd | txd_lower | (uint16_t) 
1965                                    desc_array.descriptor[counter].length));
1966                                ctxd->upper.data =
1967                                    htole32((txd_upper));
1968                                last = i;
1969                                if (++i == adapter->num_tx_desc)
1970                                         i = 0;
1971                                tx_buffer->m_head = NULL;
1972                                tx_buffer->next_eop = -1;
1973                                txd_used++;
1974                        }
1975                } else {
1976                        tx_buffer = &adapter->tx_buffer_area[i];
1977                        ctxd = &adapter->tx_desc_base[i];
1978                        seg_addr = segs[j].ds_addr;
1979                        seg_len  = segs[j].ds_len;
1980                        /*
1981                        ** TSO Workaround:
1982                        ** If this is the last descriptor, we want to
1983                        ** split it so we have a small final sentinel
1984                        */
1985                        if (tso_desc && (j == (nsegs -1)) && (seg_len > 8)) {
1986                                seg_len -= 4;
1987                                ctxd->buffer_addr = htole64(seg_addr);
1988                                ctxd->lower.data = htole32(
1989                                adapter->txd_cmd | txd_lower | seg_len);
1990                                ctxd->upper.data =
1991                                    htole32(txd_upper);
1992                                if (++i == adapter->num_tx_desc)
1993                                        i = 0;
1994                                /* Now make the sentinel */     
1995                                ++txd_used; /* using an extra txd */
1996                                ctxd = &adapter->tx_desc_base[i];
1997                                tx_buffer = &adapter->tx_buffer_area[i];
1998                                ctxd->buffer_addr =
1999                                    htole64(seg_addr + seg_len);
2000                                ctxd->lower.data = htole32(
2001                                adapter->txd_cmd | txd_lower | 4);
2002                                ctxd->upper.data =
2003                                    htole32(txd_upper);
2004                                last = i;
2005                                if (++i == adapter->num_tx_desc)
2006                                        i = 0;
2007                        } else {
2008                                ctxd->buffer_addr = htole64(seg_addr);
2009                                ctxd->lower.data = htole32(
2010                                adapter->txd_cmd | txd_lower | seg_len);
2011                                ctxd->upper.data =
2012                                    htole32(txd_upper);
2013                                last = i;
2014                                if (++i == adapter->num_tx_desc)
2015                                        i = 0;
2016                        }
2017                        tx_buffer->m_head = NULL;
2018                        tx_buffer->next_eop = -1;
2019                }
2020        }
2021
2022        adapter->next_avail_tx_desc = i;
2023        if (adapter->pcix_82544)
2024                adapter->num_tx_desc_avail -= txd_used;
2025        else {
2026                adapter->num_tx_desc_avail -= nsegs;
2027                if (tso_desc) /* TSO used an extra for sentinel */
2028                        adapter->num_tx_desc_avail -= txd_used;
2029        }
2030
2031#ifndef __rtems__
2032        if (m_head->m_flags & M_VLANTAG) {
2033                /* Set the vlan id. */
2034                ctxd->upper.fields.special =
2035                    htole16(m_head->m_pkthdr.ether_vtag);
2036                /* Tell hardware to add tag */
2037                ctxd->lower.data |= htole32(E1000_TXD_CMD_VLE);
2038        }
2039#endif
2040
2041        tx_buffer->m_head = m_head;
2042        tx_buffer_mapped->map = tx_buffer->map;
2043        tx_buffer->map = map;
2044        bus_dmamap_sync(adapter->txtag, map, BUS_DMASYNC_PREWRITE);
2045
2046        /*
2047         * Last Descriptor of Packet
2048         * needs End Of Packet (EOP)
2049         * and Report Status (RS)
2050         */
2051        ctxd->lower.data |=
2052            htole32(E1000_TXD_CMD_EOP | E1000_TXD_CMD_RS);
2053        /*
2054         * Keep track in the first buffer which
2055         * descriptor will be written back
2056         */
2057        tx_buffer = &adapter->tx_buffer_area[first];
2058        tx_buffer->next_eop = last;
2059
2060        /*
2061         * Advance the Transmit Descriptor Tail (TDT), this tells the E1000
2062         * that this frame is available to transmit.
2063         */
2064        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
2065            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2066        if (adapter->hw.mac.type == e1000_82547 &&
2067            adapter->link_duplex == HALF_DUPLEX)
2068                em_82547_move_tail(adapter);
2069        else {
2070                E1000_WRITE_REG(&adapter->hw, E1000_TDT, i);
2071                if (adapter->hw.mac.type == e1000_82547)
2072                        em_82547_update_fifo_head(adapter,
2073                            m_head->m_pkthdr.len);
2074        }
2075
2076        return (0);
2077}
2078
2079/*********************************************************************
2080 *
2081 *  This routine maps the mbufs to Advanced TX descriptors.
2082 *  used by the 82575 adapter. It also needs no workarounds.
2083 * 
2084 **********************************************************************/
2085
2086static int
2087em_adv_encap(struct adapter *adapter, struct mbuf **m_headp)
2088{
2089        bus_dma_segment_t       segs[EM_MAX_SCATTER];
2090        bus_dmamap_t            map;
2091        struct em_buffer        *tx_buffer, *tx_buffer_mapped;
2092        union e1000_adv_tx_desc *txd = NULL;
2093        struct mbuf             *m_head;
2094        u32                     olinfo_status = 0, cmd_type_len = 0;
2095#ifndef __rtems__
2096        u32                     paylen = 0;
2097#endif
2098        int                     nsegs, i, j, error, first, last = 0;
2099
2100        m_head = *m_headp;
2101
2102
2103        /* Set basic descriptor constants */
2104        cmd_type_len |= E1000_ADVTXD_DTYP_DATA;
2105        cmd_type_len |= E1000_ADVTXD_DCMD_IFCS | E1000_ADVTXD_DCMD_DEXT;
2106
2107        /*
2108         * Force a cleanup if number of TX descriptors
2109         * available hits the threshold
2110         */
2111        if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
2112                em_txeof(adapter);
2113                /* Now do we at least have a minimal? */
2114                if (adapter->num_tx_desc_avail <= EM_TX_OP_THRESHOLD) {
2115                        adapter->no_tx_desc_avail1++;
2116                        return (ENOBUFS);
2117                }
2118        }
2119
2120        /*
2121         * Map the packet for DMA.
2122         *
2123         * Capture the first descriptor index,
2124         * this descriptor will have the index
2125         * of the EOP which is the only one that
2126         * now gets a DONE bit writeback.
2127         */
2128        first = adapter->next_avail_tx_desc;
2129        tx_buffer = &adapter->tx_buffer_area[first];
2130        tx_buffer_mapped = tx_buffer;
2131        map = tx_buffer->map;
2132
2133        error = bus_dmamap_load_mbuf_sg(adapter->txtag, map,
2134            *m_headp, segs, &nsegs, BUS_DMA_NOWAIT);
2135
2136        if (error == EFBIG) {
2137                struct mbuf *m;
2138
2139                m = m_defrag(*m_headp, M_DONTWAIT);
2140                if (m == NULL) {
2141                        adapter->mbuf_alloc_failed++;
2142                        m_freem(*m_headp);
2143                        *m_headp = NULL;
2144                        return (ENOBUFS);
2145                }
2146                *m_headp = m;
2147
2148                /* Try it again */
2149                error = bus_dmamap_load_mbuf_sg(adapter->txtag, map,
2150                    *m_headp, segs, &nsegs, BUS_DMA_NOWAIT);
2151
2152                if (error == ENOMEM) {
2153                        adapter->no_tx_dma_setup++;
2154                        return (error);
2155                } else if (error != 0) {
2156                        adapter->no_tx_dma_setup++;
2157                        m_freem(*m_headp);
2158                        *m_headp = NULL;
2159                        return (error);
2160                }
2161        } else if (error == ENOMEM) {
2162                adapter->no_tx_dma_setup++;
2163                return (error);
2164        } else if (error != 0) {
2165                adapter->no_tx_dma_setup++;
2166                m_freem(*m_headp);
2167                *m_headp = NULL;
2168                return (error);
2169        }
2170
2171        /* Check again to be sure we have enough descriptors */
2172        if (nsegs > (adapter->num_tx_desc_avail - 2)) {
2173                adapter->no_tx_desc_avail2++;
2174                bus_dmamap_unload(adapter->txtag, map);
2175                return (ENOBUFS);
2176        }
2177        m_head = *m_headp;
2178
2179#ifndef __rtems__
2180        /*
2181         * Set up the context descriptor:
2182         * used when any hardware offload is done.
2183         * This includes CSUM, VLAN, and TSO. It
2184         * will use the first descriptor.
2185         */
2186        /* First try TSO */
2187        if (em_tso_adv_setup(adapter, m_head, &paylen)) {
2188                cmd_type_len |= E1000_ADVTXD_DCMD_TSE;
2189                olinfo_status |= E1000_TXD_POPTS_IXSM << 8;
2190                olinfo_status |= E1000_TXD_POPTS_TXSM << 8;
2191                olinfo_status |= paylen << E1000_ADVTXD_PAYLEN_SHIFT;
2192        } else if (m_head->m_pkthdr.csum_flags & CSUM_OFFLOAD) {
2193                if (em_tx_adv_ctx_setup(adapter, m_head))
2194                        olinfo_status |= E1000_TXD_POPTS_TXSM << 8;
2195        }
2196#endif
2197
2198        /* Set up our transmit descriptors */
2199        i = adapter->next_avail_tx_desc;
2200        for (j = 0; j < nsegs; j++) {
2201                bus_size_t seg_len;
2202                bus_addr_t seg_addr;
2203
2204                tx_buffer = &adapter->tx_buffer_area[i];
2205                txd = (union e1000_adv_tx_desc *)&adapter->tx_desc_base[i];
2206                seg_addr = segs[j].ds_addr;
2207                seg_len  = segs[j].ds_len;
2208
2209                txd->read.buffer_addr = htole64(seg_addr);
2210                txd->read.cmd_type_len = htole32(
2211                    adapter->txd_cmd | cmd_type_len | seg_len);
2212                txd->read.olinfo_status = htole32(olinfo_status);
2213                last = i;
2214                if (++i == adapter->num_tx_desc)
2215                        i = 0;
2216                tx_buffer->m_head = NULL;
2217                tx_buffer->next_eop = -1;
2218        }
2219
2220        adapter->next_avail_tx_desc = i;
2221        adapter->num_tx_desc_avail -= nsegs;
2222
2223        tx_buffer->m_head = m_head;
2224        tx_buffer_mapped->map = tx_buffer->map;
2225        tx_buffer->map = map;
2226        bus_dmamap_sync(adapter->txtag, map, BUS_DMASYNC_PREWRITE);
2227
2228        /*
2229         * Last Descriptor of Packet
2230         * needs End Of Packet (EOP)
2231         * and Report Status (RS)
2232         */
2233        txd->read.cmd_type_len |=
2234            htole32(E1000_TXD_CMD_EOP | E1000_TXD_CMD_RS);
2235        /*
2236         * Keep track in the first buffer which
2237         * descriptor will be written back
2238         */
2239        tx_buffer = &adapter->tx_buffer_area[first];
2240        tx_buffer->next_eop = last;
2241
2242        /*
2243         * Advance the Transmit Descriptor Tail (TDT), this tells the E1000
2244         * that this frame is available to transmit.
2245         */
2246        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
2247            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2248        E1000_WRITE_REG(&adapter->hw, E1000_TDT, i);
2249
2250        return (0);
2251
2252}
2253
2254/*********************************************************************
2255 *
2256 * 82547 workaround to avoid controller hang in half-duplex environment.
2257 * The workaround is to avoid queuing a large packet that would span
2258 * the internal Tx FIFO ring boundary. We need to reset the FIFO pointers
2259 * in this case. We do that only when FIFO is quiescent.
2260 *
2261 **********************************************************************/
2262static void
2263em_82547_move_tail(void *arg)
2264{
2265        struct adapter *adapter = arg;
2266        uint16_t hw_tdt;
2267        uint16_t sw_tdt;
2268        struct e1000_tx_desc *tx_desc;
2269        uint16_t length = 0;
2270        boolean_t eop = 0;
2271
2272        EM_LOCK_ASSERT(adapter);
2273
2274        hw_tdt = E1000_READ_REG(&adapter->hw, E1000_TDT);
2275        sw_tdt = adapter->next_avail_tx_desc;
2276       
2277        while (hw_tdt != sw_tdt) {
2278                tx_desc = &adapter->tx_desc_base[hw_tdt];
2279                length += tx_desc->lower.flags.length;
2280                eop = tx_desc->lower.data & E1000_TXD_CMD_EOP;
2281                if (++hw_tdt == adapter->num_tx_desc)
2282                        hw_tdt = 0;
2283
2284                if (eop) {
2285                        if (em_82547_fifo_workaround(adapter, length)) {
2286                                adapter->tx_fifo_wrk_cnt++;
2287                                callout_reset(&adapter->tx_fifo_timer, 1,
2288                                        em_82547_move_tail, adapter);
2289                                break;
2290                        }
2291                        E1000_WRITE_REG(&adapter->hw, E1000_TDT, hw_tdt);
2292                        em_82547_update_fifo_head(adapter, length);
2293                        length = 0;
2294                }
2295        }       
2296}
2297
2298static int
2299em_82547_fifo_workaround(struct adapter *adapter, int len)
2300{       
2301        int fifo_space, fifo_pkt_len;
2302
2303        fifo_pkt_len = roundup2(len + EM_FIFO_HDR, EM_FIFO_HDR);
2304
2305        if (adapter->link_duplex == HALF_DUPLEX) {
2306                fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
2307
2308                if (fifo_pkt_len >= (EM_82547_PKT_THRESH + fifo_space)) {
2309                        if (em_82547_tx_fifo_reset(adapter))
2310                                return (0);
2311                        else
2312                                return (1);
2313                }
2314        }
2315
2316        return (0);
2317}
2318
2319static void
2320em_82547_update_fifo_head(struct adapter *adapter, int len)
2321{
2322        int fifo_pkt_len = roundup2(len + EM_FIFO_HDR, EM_FIFO_HDR);
2323       
2324        /* tx_fifo_head is always 16 byte aligned */
2325        adapter->tx_fifo_head += fifo_pkt_len;
2326        if (adapter->tx_fifo_head >= adapter->tx_fifo_size) {
2327                adapter->tx_fifo_head -= adapter->tx_fifo_size;
2328        }
2329}
2330
2331
2332static int
2333em_82547_tx_fifo_reset(struct adapter *adapter)
2334{
2335        uint32_t tctl;
2336
2337        if ((E1000_READ_REG(&adapter->hw, E1000_TDT) ==
2338            E1000_READ_REG(&adapter->hw, E1000_TDH)) &&
2339            (E1000_READ_REG(&adapter->hw, E1000_TDFT) == 
2340            E1000_READ_REG(&adapter->hw, E1000_TDFH)) &&
2341            (E1000_READ_REG(&adapter->hw, E1000_TDFTS) ==
2342            E1000_READ_REG(&adapter->hw, E1000_TDFHS)) &&
2343            (E1000_READ_REG(&adapter->hw, E1000_TDFPC) == 0)) {
2344                /* Disable TX unit */
2345                tctl = E1000_READ_REG(&adapter->hw, E1000_TCTL);
2346                E1000_WRITE_REG(&adapter->hw, E1000_TCTL,
2347                    tctl & ~E1000_TCTL_EN);
2348
2349                /* Reset FIFO pointers */
2350                E1000_WRITE_REG(&adapter->hw, E1000_TDFT,
2351                    adapter->tx_head_addr);
2352                E1000_WRITE_REG(&adapter->hw, E1000_TDFH,
2353                    adapter->tx_head_addr);
2354                E1000_WRITE_REG(&adapter->hw, E1000_TDFTS,
2355                    adapter->tx_head_addr);
2356                E1000_WRITE_REG(&adapter->hw, E1000_TDFHS,
2357                    adapter->tx_head_addr);
2358
2359                /* Re-enable TX unit */
2360                E1000_WRITE_REG(&adapter->hw, E1000_TCTL, tctl);
2361                E1000_WRITE_FLUSH(&adapter->hw);
2362
2363                adapter->tx_fifo_head = 0;
2364                adapter->tx_fifo_reset_cnt++;
2365
2366                return (TRUE);
2367        }
2368        else {
2369                return (FALSE);
2370        }
2371}
2372
2373static void
2374em_set_promisc(struct adapter *adapter)
2375{
2376        struct ifnet    *ifp = adapter->ifp;
2377        uint32_t        reg_rctl;
2378
2379        reg_rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
2380
2381        if (ifp->if_flags & IFF_PROMISC) {
2382                reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
2383                E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl);
2384        } else if (ifp->if_flags & IFF_ALLMULTI) {
2385                reg_rctl |= E1000_RCTL_MPE;
2386                reg_rctl &= ~E1000_RCTL_UPE;
2387                E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl);
2388        }
2389}
2390
2391static void
2392em_disable_promisc(struct adapter *adapter)
2393{
2394        uint32_t        reg_rctl;
2395
2396        reg_rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
2397
2398        reg_rctl &=  (~E1000_RCTL_UPE);
2399        reg_rctl &=  (~E1000_RCTL_MPE);
2400        E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl);
2401}
2402
2403
2404/*********************************************************************
2405 *  Multicast Update
2406 *
2407 *  This routine is called whenever multicast address list is updated.
2408 *
2409 **********************************************************************/
2410
2411static void
2412em_set_multi(struct adapter *adapter)
2413{
2414        struct ifnet    *ifp = adapter->ifp;
2415#ifndef __rtems__
2416        struct ifmultiaddr *ifma;
2417#endif
2418        uint32_t reg_rctl = 0;
2419        uint8_t  mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_ADDR_LEN]; /* Largest MTS is 4096 bits */
2420        int mcnt = 0;
2421
2422        IOCTL_DEBUGOUT("em_set_multi: begin");
2423
2424#if !defined(NO_82542_SUPPORT) /* __rtems__ */
2425        if (adapter->hw.mac.type == e1000_82542 && 
2426            adapter->hw.revision_id == E1000_REVISION_2) {
2427                reg_rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
2428                if (adapter->hw.bus.pci_cmd_word & CMD_MEM_WRT_INVALIDATE)
2429                        e1000_pci_clear_mwi(&adapter->hw);
2430                reg_rctl |= E1000_RCTL_RST;
2431                E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl);
2432                msec_delay(5);
2433        }
2434#endif
2435
2436#ifndef __rtems__
2437        IF_ADDR_LOCK(ifp);
2438        TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
2439                if (ifma->ifma_addr->sa_family != AF_LINK)
2440                        continue;
2441
2442                if (mcnt == MAX_NUM_MULTICAST_ADDRESSES)
2443                        break;
2444
2445                bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
2446                    &mta[mcnt * ETH_ADDR_LEN], ETH_ADDR_LEN);
2447                mcnt++;
2448        }
2449        IF_ADDR_UNLOCK(ifp);
2450#else
2451        {
2452        /* This is untested -- in particular I don't know how to
2453         * handle address ranges in the ether_multi struct
2454         */
2455        struct ether_multi    *enm;
2456        struct ether_multistep step;
2457        ETHER_FIRST_MULTI(step, (struct arpcom *)ifp, enm);
2458        while ( enm != NULL ) {
2459                if ( mcnt == MAX_NUM_MULTICAST_ADDRESSES )
2460                        break;
2461                if ( memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN) ) {
2462                        printk("if_em: Unable to handle multicast wildcard (not ported yet); skipping\n");
2463                        goto skiptonext;
2464                } else {
2465                        bcopy(enm->enm_addrlo, &mta[mcnt * ETH_ADDR_LEN], ETH_ADDR_LEN);
2466                }
2467                mcnt++;
2468        skiptonext:
2469                ETHER_NEXT_MULTI( step, enm );
2470        }
2471        }
2472#endif
2473
2474        if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) {
2475                reg_rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
2476                reg_rctl |= E1000_RCTL_MPE;
2477                E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl);
2478        } else
2479                e1000_mc_addr_list_update(&adapter->hw, mta,
2480                    mcnt, 1, adapter->hw.mac.rar_entry_count);
2481
2482#if !defined(NO_82542_SUPPORT) /* __rtems__ */
2483        if (adapter->hw.mac.type == e1000_82542 && 
2484            adapter->hw.revision_id == E1000_REVISION_2) {
2485                reg_rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
2486                reg_rctl &= ~E1000_RCTL_RST;
2487                E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl);
2488                msec_delay(5);
2489                if (adapter->hw.bus.pci_cmd_word & CMD_MEM_WRT_INVALIDATE)
2490                        e1000_pci_set_mwi(&adapter->hw);
2491        }
2492#endif
2493}
2494
2495
2496/*********************************************************************
2497 *  Timer routine
2498 *
2499 *  This routine checks for link status and updates statistics.
2500 *
2501 **********************************************************************/
2502
2503static void
2504em_local_timer(void *arg)
2505{
2506        struct adapter  *adapter = arg;
2507        struct ifnet    *ifp = adapter->ifp;
2508
2509        EM_LOCK_ASSERT(adapter);
2510
2511        e1000_check_for_link(&adapter->hw);
2512        em_update_link_status(adapter);
2513        em_update_stats_counters(adapter);
2514
2515        /* Check for 82571 LAA reset by other port */
2516        if (e1000_get_laa_state_82571(&adapter->hw) == TRUE) 
2517                e1000_rar_set(&adapter->hw, adapter->hw.mac.addr, 0);
2518
2519        if (em_display_debug_stats && ifp->if_drv_flags & IFF_DRV_RUNNING)
2520                em_print_hw_stats(adapter);
2521
2522        em_smartspeed(adapter);
2523
2524        /*
2525         * Each second we check the watchdog to
2526         * protect against hardware hangs.
2527         */
2528        em_watchdog(adapter);
2529
2530        callout_reset(&adapter->timer, hz, em_local_timer, adapter);
2531}
2532
2533static void
2534em_update_link_status(struct adapter *adapter)
2535{
2536        struct ifnet *ifp = adapter->ifp;
2537        device_t dev = adapter->dev;
2538
2539        if (E1000_READ_REG(&adapter->hw, E1000_STATUS) &
2540            E1000_STATUS_LU) {
2541                if (adapter->link_active == 0) {
2542                        e1000_get_speed_and_duplex(&adapter->hw, 
2543                            &adapter->link_speed, &adapter->link_duplex);
2544                        /* Check if we must disable SPEED_MODE bit on PCI-E */
2545                        if ((adapter->link_speed != SPEED_1000) &&
2546                            ((adapter->hw.mac.type == e1000_82571) ||
2547                            (adapter->hw.mac.type == e1000_82572))) {
2548                                int tarc0;
2549
2550                                tarc0 = E1000_READ_REG(&adapter->hw,
2551                                    E1000_TARC0);
2552                                tarc0 &= ~SPEED_MODE_BIT;
2553                                E1000_WRITE_REG(&adapter->hw,
2554                                    E1000_TARC0, tarc0);
2555                        }
2556                        if (bootverbose)
2557                                device_printf(dev, "Link is up %d Mbps %s\n",
2558                                    adapter->link_speed,
2559                                    ((adapter->link_duplex == FULL_DUPLEX) ?
2560                                    "Full Duplex" : "Half Duplex"));
2561                        adapter->link_active = 1;
2562                        adapter->smartspeed = 0;
2563                        ifp->if_baudrate = adapter->link_speed * 1000000;
2564                        if_link_state_change(ifp, LINK_STATE_UP);
2565                }
2566        } else {
2567                if (adapter->link_active == 1) {
2568                        ifp->if_baudrate = adapter->link_speed = 0;
2569                        adapter->link_duplex = 0;
2570                        if (bootverbose)
2571                                device_printf(dev, "Link is Down\n");
2572                        adapter->link_active = 0;
2573                        if_link_state_change(ifp, LINK_STATE_DOWN);
2574                }
2575        }
2576}
2577
2578/*********************************************************************
2579 *
2580 *  This routine disables all traffic on the adapter by issuing a
2581 *  global reset on the MAC and deallocates TX/RX buffers.
2582 *
2583 **********************************************************************/
2584
2585static void
2586em_stop(void *arg)
2587{
2588        struct adapter  *adapter = arg;
2589        struct ifnet    *ifp = adapter->ifp;
2590
2591        EM_LOCK_ASSERT(adapter);
2592
2593        INIT_DEBUGOUT("em_stop: begin");
2594
2595        em_disable_intr(adapter);
2596        callout_stop(&adapter->timer);
2597        callout_stop(&adapter->tx_fifo_timer);
2598        em_free_transmit_structures(adapter);
2599        em_free_receive_structures(adapter);
2600
2601        /* Tell the stack that the interface is no longer active */
2602        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
2603
2604        e1000_reset_hw(&adapter->hw);
2605        if (adapter->hw.mac.type >= e1000_82544)
2606                E1000_WRITE_REG(&adapter->hw, E1000_WUC, 0);
2607}
2608
2609
2610/*********************************************************************
2611 *
2612 *  Determine hardware revision.
2613 *
2614 **********************************************************************/
2615static void
2616em_identify_hardware(struct adapter *adapter)
2617{
2618        device_t dev = adapter->dev;
2619
2620        /* Make sure our PCI config space has the necessary stuff set */
2621        adapter->hw.bus.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
2622        if ((adapter->hw.bus.pci_cmd_word & PCIM_CMD_BUSMASTEREN) == 0 &&
2623            (adapter->hw.bus.pci_cmd_word & PCIM_CMD_MEMEN)) {
2624                device_printf(dev, "Memory Access and/or Bus Master bits "
2625                    "were not set!\n");
2626                adapter->hw.bus.pci_cmd_word |=
2627                (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN);
2628                pci_write_config(dev, PCIR_COMMAND,
2629                    adapter->hw.bus.pci_cmd_word, 2);
2630        }
2631
2632        /* Save off the information about this board */
2633        adapter->hw.vendor_id = pci_get_vendor(dev);
2634        adapter->hw.device_id = pci_get_device(dev);
2635        adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1);
2636        adapter->hw.subsystem_vendor_id =
2637            pci_read_config(dev, PCIR_SUBVEND_0, 2);
2638        adapter->hw.subsystem_device_id = pci_read_config(dev, PCIR_SUBDEV_0, 2);
2639
2640        /* Do Shared Code Init and Setup */
2641        if (e1000_set_mac_type(&adapter->hw)) {
2642                device_printf(dev, "Setup init failure\n");
2643                return;
2644        }
2645}
2646
2647static int
2648em_allocate_pci_resources(struct adapter *adapter)
2649{
2650        device_t        dev = adapter->dev;
2651        int             val, rid;
2652
2653        rid = PCIR_BAR(0);
2654        adapter->res_memory = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
2655            &rid, RF_ACTIVE);
2656        if (adapter->res_memory == NULL) {
2657                device_printf(dev, "Unable to allocate bus resource: memory\n");
2658                return (ENXIO);
2659        }
2660        adapter->osdep.mem_bus_space_tag =
2661            rman_get_bustag(adapter->res_memory);
2662        adapter->osdep.mem_bus_space_handle =
2663            rman_get_bushandle(adapter->res_memory);
2664#ifndef __rtems__
2665        adapter->hw.hw_addr = (uint8_t*)&adapter->osdep.mem_bus_space_handle;
2666#else
2667        adapter->hw.hw_addr = (uint8_t*)adapter->res_memory;
2668#endif
2669
2670        /* Only older adapters use IO mapping */
2671        if ((adapter->hw.mac.type >= e1000_82543) && /* __rtems__ >82542 -> >= 82543 */
2672            (adapter->hw.mac.type < e1000_82571)) {
2673                /* Figure our where our IO BAR is ? */
2674                for (rid = PCIR_BAR(0); rid < PCIR_CIS;) {
2675                        val = pci_read_config(dev, rid, 4);
2676                        if (EM_BAR_TYPE(val) == EM_BAR_TYPE_IO) {
2677                                adapter->io_rid = rid;
2678                                break;
2679                        }
2680                        rid += 4;
2681                        /* check for 64bit BAR */
2682                        if (EM_BAR_MEM_TYPE(val) == EM_BAR_MEM_TYPE_64BIT)
2683                                rid += 4;
2684                }
2685                if (rid >= PCIR_CIS) {
2686                        device_printf(dev, "Unable to locate IO BAR\n");
2687                        return (ENXIO);
2688                }
2689                adapter->res_ioport = bus_alloc_resource_any(dev,
2690                    SYS_RES_IOPORT, &adapter->io_rid, RF_ACTIVE);
2691                if (adapter->res_ioport == NULL) {
2692                        device_printf(dev, "Unable to allocate bus resource: "
2693                            "ioport\n");
2694                        return (ENXIO);
2695                }
2696#ifndef __rtems__
2697                adapter->hw.io_base = 0;
2698#else
2699                adapter->hw.io_base =   (unsigned long)adapter->res_ioport
2700                              & PCI_BASE_ADDRESS_IO_MASK;
2701#endif
2702                adapter->osdep.io_bus_space_tag =
2703                    rman_get_bustag(adapter->res_ioport);
2704                adapter->osdep.io_bus_space_handle =
2705                    rman_get_bushandle(adapter->res_ioport);
2706        }
2707
2708        /*
2709         * Setup MSI/X or MSI if PCI Express
2710         * only the latest can use MSI/X and
2711         * real support for it is forthcoming
2712         */
2713        adapter->msi = 0; /* Set defaults */
2714        rid = 0x0;
2715        if (adapter->hw.mac.type >= e1000_82575) {
2716                /*
2717                 * Setup MSI/X
2718                 */
2719                rid = PCIR_BAR(EM_MSIX_BAR);
2720                adapter->msix_mem = bus_alloc_resource_any(dev,
2721                    SYS_RES_MEMORY, &rid, RF_ACTIVE);
2722                if (!adapter->msix_mem) {
2723                        device_printf(dev,"Unable to map MSIX table \n");
2724                        return (ENXIO);
2725                }
2726                /*
2727                 * Eventually this may be used
2728                 * for Multiqueue, for now we will
2729                 * just use one vector.
2730                 *
2731                 * val = pci_msix_count(dev);
2732                 */
2733                val = 1;
2734                if ((val) && pci_alloc_msix(dev, &val) == 0) {
2735                        rid = 1;
2736                        adapter->msi = 1;
2737                }
2738        } else if (adapter->hw.mac.type > e1000_82571) {
2739                val = pci_msi_count(dev);
2740                if (val == 1 && pci_alloc_msi(dev, &val) == 0) {
2741                        rid = 1;
2742                        adapter->msi = 1;
2743                } 
2744        } 
2745        adapter->res_interrupt = bus_alloc_resource_any(dev,
2746            SYS_RES_IRQ, &rid, RF_SHAREABLE | RF_ACTIVE);
2747        if (adapter->res_interrupt == NULL) {
2748                device_printf(dev, "Unable to allocate bus resource: "
2749                    "interrupt\n");
2750                return (ENXIO);
2751        }
2752
2753        adapter->hw.back = &adapter->osdep;
2754
2755        return (0);
2756}
2757
2758/*********************************************************************
2759 *
2760 *  Setup the appropriate Interrupt handlers.
2761 *
2762 **********************************************************************/
2763int
2764em_allocate_intr(struct adapter *adapter)
2765{
2766        device_t dev = adapter->dev;
2767        int error;
2768
2769        /* Manually turn off all interrupts */
2770        E1000_WRITE_REG(&adapter->hw, E1000_IMC, 0xffffffff);
2771
2772#ifdef DEVICE_POLLING
2773        /* We do Legacy setup */
2774        if (adapter->int_handler_tag == NULL &&
2775            (error = bus_setup_intr(dev, adapter->res_interrupt,
2776            INTR_TYPE_NET | INTR_MPSAFE, NULL, em_intr, adapter,
2777            &adapter->int_handler_tag)) != 0) {
2778                device_printf(dev, "Failed to register interrupt handler");
2779                return (error);
2780        }
2781
2782#else
2783        /*
2784         * Try allocating a fast interrupt and the associated deferred
2785         * processing contexts.
2786         */
2787        TASK_INIT(&adapter->rxtx_task, 0, em_handle_rxtx, adapter);
2788        TASK_INIT(&adapter->link_task, 0, em_handle_link, adapter);
2789        adapter->tq = taskqueue_create_fast("em_taskq", M_NOWAIT,
2790            taskqueue_thread_enqueue, &adapter->tq);
2791        taskqueue_start_threads(&adapter->tq, 1, PI_NET, "%s taskq",
2792            device_get_nameunit(adapter->dev));
2793        if ((error = bus_setup_intr(dev, adapter->res_interrupt,
2794            INTR_TYPE_NET, em_intr_fast, NULL, adapter,
2795            &adapter->int_handler_tag)) != 0) {
2796                device_printf(dev, "Failed to register fast interrupt "
2797                            "handler: %d\n", error);
2798                taskqueue_free(adapter->tq);
2799                adapter->tq = NULL;
2800                return (error);
2801        }
2802#endif
2803
2804        em_enable_intr(adapter);
2805        return (0);
2806}
2807
2808static void
2809em_free_intr(struct adapter *adapter)
2810{
2811        device_t dev = adapter->dev;
2812
2813        if (adapter->res_interrupt != NULL) {
2814                bus_teardown_intr(dev, adapter->res_interrupt,
2815                        adapter->int_handler_tag);
2816                adapter->int_handler_tag = NULL;
2817        }
2818        if (adapter->tq != NULL) {
2819                taskqueue_drain(adapter->tq, &adapter->rxtx_task);
2820                taskqueue_drain(taskqueue_fast, &adapter->link_task);
2821                taskqueue_free(adapter->tq);
2822                adapter->tq = NULL;
2823        }
2824}
2825
2826static void
2827em_free_pci_resources(struct adapter *adapter)
2828{
2829        device_t dev = adapter->dev;
2830
2831        if (adapter->res_interrupt != NULL)
2832                bus_release_resource(dev, SYS_RES_IRQ,
2833                    adapter->msi ? 1 : 0, adapter->res_interrupt);
2834
2835        if (adapter->msix_mem != NULL)
2836                bus_release_resource(dev, SYS_RES_MEMORY,
2837                    PCIR_BAR(EM_MSIX_BAR), adapter->msix_mem);
2838
2839        if (adapter->msi)
2840                pci_release_msi(dev);
2841
2842        if (adapter->res_memory != NULL)
2843                bus_release_resource(dev, SYS_RES_MEMORY,
2844                    PCIR_BAR(0), adapter->res_memory);
2845
2846        if (adapter->flash_mem != NULL)
2847                bus_release_resource(dev, SYS_RES_MEMORY,
2848                    EM_FLASH, adapter->flash_mem);
2849
2850        if (adapter->res_ioport != NULL)
2851                bus_release_resource(dev, SYS_RES_IOPORT,
2852                    adapter->io_rid, adapter->res_ioport);
2853}
2854
2855/*********************************************************************
2856 *
2857 *  Initialize the hardware to a configuration
2858 *  as specified by the adapter structure.
2859 *
2860 **********************************************************************/
2861static int
2862em_hardware_init(struct adapter *adapter)
2863{
2864        device_t dev = adapter->dev;
2865        uint16_t rx_buffer_size;
2866
2867        INIT_DEBUGOUT("em_hardware_init: begin");
2868
2869        /* Issue a global reset */
2870        e1000_reset_hw(&adapter->hw);
2871
2872        /* Get control from any management/hw control */
2873        if (((adapter->hw.mac.type == e1000_82573) ||
2874            (adapter->hw.mac.type == e1000_ich8lan) ||
2875            (adapter->hw.mac.type == e1000_ich9lan)) &&
2876            e1000_check_mng_mode(&adapter->hw))
2877                em_get_hw_control(adapter);
2878
2879        /* When hardware is reset, fifo_head is also reset */
2880        adapter->tx_fifo_head = 0;
2881
2882        /* Set up smart power down as default off on newer adapters. */
2883        if (!em_smart_pwr_down && (adapter->hw.mac.type == e1000_82571 ||
2884            adapter->hw.mac.type == e1000_82572)) {
2885                uint16_t phy_tmp = 0;
2886
2887                /* Speed up time to link by disabling smart power down. */
2888                e1000_read_phy_reg(&adapter->hw,
2889                    IGP02E1000_PHY_POWER_MGMT, &phy_tmp);
2890                phy_tmp &= ~IGP02E1000_PM_SPD;
2891                e1000_write_phy_reg(&adapter->hw,
2892                    IGP02E1000_PHY_POWER_MGMT, phy_tmp);
2893        }
2894
2895        /*
2896         * These parameters control the automatic generation (Tx) and
2897         * response (Rx) to Ethernet PAUSE frames.
2898         * - High water mark should allow for at least two frames to be
2899         *   received after sending an XOFF.
2900         * - Low water mark works best when it is very near the high water mark.
2901         *   This allows the receiver to restart by sending XON when it has
2902         *   drained a bit. Here we use an arbitary value of 1500 which will
2903         *   restart after one full frame is pulled from the buffer. There
2904         *   could be several smaller frames in the buffer and if so they will
2905         *   not trigger the XON until their total number reduces the buffer
2906         *   by 1500.
2907         * - The pause time is fairly large at 1000 x 512ns = 512 usec.
2908         */
2909        rx_buffer_size = ((E1000_READ_REG(&adapter->hw, E1000_PBA) &
2910            0xffff) << 10 );
2911
2912        adapter->hw.mac.fc_high_water = rx_buffer_size -
2913            roundup2(adapter->hw.mac.max_frame_size, 1024);
2914        adapter->hw.mac.fc_low_water = adapter->hw.mac.fc_high_water - 1500;
2915        if (adapter->hw.mac.type == e1000_80003es2lan)
2916                adapter->hw.mac.fc_pause_time = 0xFFFF;
2917        else
2918                adapter->hw.mac.fc_pause_time = EM_FC_PAUSE_TIME;
2919        adapter->hw.mac.fc_send_xon = TRUE;
2920        adapter->hw.mac.fc = e1000_fc_full;
2921
2922        if (e1000_init_hw(&adapter->hw) < 0) {
2923                device_printf(dev, "Hardware Initialization Failed\n");
2924                return (EIO);
2925        }
2926
2927        e1000_check_for_link(&adapter->hw);
2928
2929        return (0);
2930}
2931
2932/*********************************************************************
2933 *
2934 *  Setup networking device structure and register an interface.
2935 *
2936 **********************************************************************/
2937static void
2938em_setup_interface(device_t dev, struct adapter *adapter)
2939{
2940        struct ifnet   *ifp;
2941
2942        INIT_DEBUGOUT("em_setup_interface: begin");
2943
2944        ifp = adapter->ifp = if_alloc(IFT_ETHER);
2945        if (ifp == NULL)
2946                panic("%s: can not if_alloc()", device_get_nameunit(dev));
2947        if_initname(ifp, device_get_name(dev), device_get_unit(dev));
2948
2949        ifp->if_mtu = ETHERMTU;
2950        ifp->if_init =  em_init;
2951        ifp->if_softc = adapter;
2952        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
2953        ifp->if_ioctl = em_ioctl;
2954        ifp->if_start = em_start;
2955        IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 1);
2956        ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 1;
2957        IFQ_SET_READY(&ifp->if_snd);
2958
2959        ether_ifattach(ifp, adapter->hw.mac.addr);
2960
2961#ifndef __rtems__
2962        ifp->if_capabilities = ifp->if_capenable = 0;
2963
2964        if (adapter->hw.mac.type >= e1000_82543) {
2965                ifp->if_capabilities |= IFCAP_HWCSUM | IFCAP_VLAN_HWCSUM;
2966                ifp->if_capenable |= IFCAP_HWCSUM | IFCAP_VLAN_HWCSUM;
2967        }
2968
2969        /* Identify TSO capable adapters */
2970        if ((adapter->hw.mac.type > e1000_82544) &&
2971            (adapter->hw.mac.type != e1000_82547))
2972                ifp->if_capabilities |= IFCAP_TSO4;
2973        /*
2974         * By default only enable on PCI-E, this
2975         * can be overriden by ifconfig.
2976         */
2977        if (adapter->hw.mac.type >= e1000_82571)
2978                ifp->if_capenable |= IFCAP_TSO4;
2979
2980        /*
2981         * Tell the upper layer(s) we support long frames.
2982         */
2983        ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
2984        ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
2985        ifp->if_capenable |= IFCAP_VLAN_MTU;
2986
2987#ifdef DEVICE_POLLING
2988        ifp->if_capabilities |= IFCAP_POLLING;
2989#endif
2990#endif
2991
2992        /*
2993         * Specify the media types supported by this adapter and register
2994         * callbacks to update media and link information
2995         */
2996        ifmedia_init(&adapter->media, IFM_IMASK,
2997            em_media_change, em_media_status);
2998        if ((adapter->hw.media_type == e1000_media_type_fiber) ||
2999            (adapter->hw.media_type == e1000_media_type_internal_serdes)) {
3000                u_char fiber_type = IFM_1000_SX;        /* default type */
3001
3002                if (adapter->hw.mac.type == e1000_82545)
3003                        fiber_type = IFM_1000_LX;
3004                ifmedia_add(&adapter->media, IFM_ETHER | fiber_type | IFM_FDX, 
3005                            0, NULL);
3006                ifmedia_add(&adapter->media, IFM_ETHER | fiber_type, 0, NULL);
3007        } else {
3008                ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL);
3009                ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX,
3010                            0, NULL);
3011                ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX,
3012                            0, NULL);
3013                ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX,
3014                            0, NULL);
3015                if (adapter->hw.phy.type != e1000_phy_ife) {
3016                        ifmedia_add(&adapter->media,
3017                                IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL);
3018                        ifmedia_add(&adapter->media,
3019                                IFM_ETHER | IFM_1000_T, 0, NULL);
3020                }
3021        }
3022        ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
3023        ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO);
3024}
3025
3026
3027/*********************************************************************
3028 *
3029 *  Workaround for SmartSpeed on 82541 and 82547 controllers
3030 *
3031 **********************************************************************/
3032static void
3033em_smartspeed(struct adapter *adapter)
3034{
3035        uint16_t phy_tmp;
3036
3037        if (adapter->link_active || (adapter->hw.phy.type != e1000_phy_igp) ||
3038            adapter->hw.mac.autoneg == 0 ||
3039            (adapter->hw.phy.autoneg_advertised & ADVERTISE_1000_FULL) == 0)
3040                return;
3041
3042        if (adapter->smartspeed == 0) {
3043                /* If Master/Slave config fault is asserted twice,
3044                 * we assume back-to-back */
3045                e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
3046                if (!(phy_tmp & SR_1000T_MS_CONFIG_FAULT))
3047                        return;
3048                e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
3049                if (phy_tmp & SR_1000T_MS_CONFIG_FAULT) {
3050                        e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp);
3051                        if(phy_tmp & CR_1000T_MS_ENABLE) {
3052                                phy_tmp &= ~CR_1000T_MS_ENABLE;
3053                                e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL,
3054                                    phy_tmp);
3055                                adapter->smartspeed++;
3056                                if(adapter->hw.mac.autoneg &&
3057                                   !e1000_phy_setup_autoneg(&adapter->hw) &&
3058                                   !e1000_read_phy_reg(&adapter->hw, PHY_CONTROL,
3059                                    &phy_tmp)) {
3060                                        phy_tmp |= (MII_CR_AUTO_NEG_EN |
3061                                                    MII_CR_RESTART_AUTO_NEG);
3062                                        e1000_write_phy_reg(&adapter->hw, PHY_CONTROL,
3063                                            phy_tmp);
3064                                }
3065                        }
3066                }
3067                return;
3068        } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) {
3069                /* If still no link, perhaps using 2/3 pair cable */
3070                e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp);
3071                phy_tmp |= CR_1000T_MS_ENABLE;
3072                e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp);
3073                if(adapter->hw.mac.autoneg &&
3074                   !e1000_phy_setup_autoneg(&adapter->hw) &&
3075                   !e1000_read_phy_reg(&adapter->hw, PHY_CONTROL, &phy_tmp)) {
3076                        phy_tmp |= (MII_CR_AUTO_NEG_EN |
3077                                    MII_CR_RESTART_AUTO_NEG);
3078                        e1000_write_phy_reg(&adapter->hw, PHY_CONTROL, phy_tmp);
3079                }
3080        }
3081        /* Restart process after EM_SMARTSPEED_MAX iterations */
3082        if(adapter->smartspeed++ == EM_SMARTSPEED_MAX)
3083                adapter->smartspeed = 0;
3084}
3085
3086
3087/*
3088 * Manage DMA'able memory.
3089 */
3090static void
3091em_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
3092{
3093        if (error)
3094                return;
3095        *(bus_addr_t *) arg = segs[0].ds_addr;
3096}
3097
3098static int
3099em_dma_malloc(struct adapter *adapter, bus_size_t size,
3100        struct em_dma_alloc *dma, int mapflags)
3101{
3102        int error;
3103
3104        error = bus_dma_tag_create(bus_get_dma_tag(adapter->dev), /* parent */
3105                                EM_DBA_ALIGN, 0,        /* alignment, bounds */
3106                                BUS_SPACE_MAXADDR,      /* lowaddr */
3107                                BUS_SPACE_MAXADDR,      /* highaddr */
3108                                NULL, NULL,             /* filter, filterarg */
3109                                size,                   /* maxsize */
3110                                1,                      /* nsegments */
3111                                size,                   /* maxsegsize */
3112                                0,                      /* flags */
3113                                NULL,                   /* lockfunc */
3114                                NULL,                   /* lockarg */
3115                                &dma->dma_tag);
3116        if (error) {
3117                device_printf(adapter->dev,
3118                    "%s: bus_dma_tag_create failed: %d\n",
3119                    __func__, error);
3120                goto fail_0;
3121        }
3122
3123        error = bus_dmamem_alloc(dma->dma_tag, (void**) &dma->dma_vaddr,
3124            BUS_DMA_NOWAIT, &dma->dma_map);
3125        if (error) {
3126                device_printf(adapter->dev,
3127                    "%s: bus_dmamem_alloc(%ju) failed: %d\n",
3128                    __func__, (uintmax_t)size, error);
3129                goto fail_2;
3130        }
3131
3132        dma->dma_paddr = 0;
3133        error = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr,
3134            size, em_dmamap_cb, &dma->dma_paddr, mapflags | BUS_DMA_NOWAIT);
3135        if (error || dma->dma_paddr == 0) {
3136                device_printf(adapter->dev,
3137                    "%s: bus_dmamap_load failed: %d\n",
3138                    __func__, error);
3139                goto fail_3;
3140        }
3141
3142        return (0);
3143
3144fail_3:
3145        bus_dmamap_unload(dma->dma_tag, dma->dma_map);
3146fail_2:
3147        bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
3148        bus_dma_tag_destroy(dma->dma_tag);
3149fail_0:
3150        dma->dma_map = NULL;
3151        dma->dma_tag = NULL;
3152
3153        return (error);
3154}
3155
3156static void
3157em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma)
3158{
3159        if (dma->dma_tag == NULL)
3160                return;
3161        if (dma->dma_map != NULL) {
3162                bus_dmamap_sync(dma->dma_tag, dma->dma_map,
3163                    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
3164                bus_dmamap_unload(dma->dma_tag, dma->dma_map);
3165                bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
3166                dma->dma_map = NULL;
3167        }
3168        bus_dma_tag_destroy(dma->dma_tag);
3169        dma->dma_tag = NULL;
3170}
3171
3172
3173/*********************************************************************
3174 *
3175 *  Allocate memory for tx_buffer structures. The tx_buffer stores all
3176 *  the information needed to transmit a packet on the wire.
3177 *
3178 **********************************************************************/
3179
3180#ifdef __rtems__
3181#define M_ZERO 0
3182#endif
3183
3184static int
3185em_allocate_transmit_structures(struct adapter *adapter)
3186{
3187        device_t dev = adapter->dev;
3188
3189        adapter->tx_buffer_area = malloc(sizeof(struct em_buffer) *
3190            adapter->num_tx_desc, M_DEVBUF, M_NOWAIT | M_ZERO);
3191        if (adapter->tx_buffer_area == NULL) {
3192                device_printf(dev, "Unable to allocate tx_buffer memory\n");
3193                return (ENOMEM);
3194        }
3195
3196        bzero(adapter->tx_buffer_area,
3197            (sizeof(struct em_buffer)) * adapter->num_tx_desc);
3198
3199        return (0);
3200}
3201
3202/*********************************************************************
3203 *
3204 *  Initialize transmit structures.
3205 *
3206 **********************************************************************/
3207static int
3208em_setup_transmit_structures(struct adapter *adapter)
3209{
3210        device_t dev = adapter->dev;
3211        struct em_buffer *tx_buffer;
3212        int error, i;
3213
3214        /*
3215         * Create DMA tags for tx descriptors
3216         */
3217        if ((error = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
3218                                1, 0,                   /* alignment, bounds */
3219                                BUS_SPACE_MAXADDR,      /* lowaddr */
3220                                BUS_SPACE_MAXADDR,      /* highaddr */
3221                                NULL, NULL,             /* filter, filterarg */
3222                                EM_TSO_SIZE,            /* maxsize */
3223                                EM_MAX_SCATTER,         /* nsegments */
3224                                EM_TSO_SEG_SIZE,        /* maxsegsize */
3225                                0,                      /* flags */
3226                                NULL,           /* lockfunc */
3227                                NULL,           /* lockarg */
3228                                &adapter->txtag)) != 0) {
3229                device_printf(dev, "Unable to allocate TX DMA tag\n");
3230                goto fail;
3231        }
3232
3233        if ((error = em_allocate_transmit_structures(adapter)) != 0)
3234                goto fail;
3235
3236        /* Clear the old ring contents */
3237        bzero(adapter->tx_desc_base,
3238            (sizeof(struct e1000_tx_desc)) * adapter->num_tx_desc);
3239
3240        /* Create the descriptor buffer dma maps */
3241        tx_buffer = adapter->tx_buffer_area;
3242        for (i = 0; i < adapter->num_tx_desc; i++) {
3243                error = bus_dmamap_create(adapter->txtag, 0, &tx_buffer->map);
3244                if (error != 0) {
3245                        device_printf(dev, "Unable to create TX DMA map\n");
3246                        goto fail;
3247                }
3248                tx_buffer->next_eop = -1;
3249                tx_buffer++;
3250        }
3251
3252        adapter->next_avail_tx_desc = 0;
3253        adapter->next_tx_to_clean = 0;
3254
3255        /* Set number of descriptors available */
3256        adapter->num_tx_desc_avail = adapter->num_tx_desc;
3257
3258        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
3259            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
3260
3261        return (0);
3262
3263fail:
3264        em_free_transmit_structures(adapter);
3265        return (error);
3266}
3267
3268/*********************************************************************
3269 *
3270 *  Enable transmit unit.
3271 *
3272 **********************************************************************/
3273static void
3274em_initialize_transmit_unit(struct adapter *adapter)
3275{
3276        uint32_t        tctl, tarc, tipg = 0;
3277        uint64_t        bus_addr;
3278
3279         INIT_DEBUGOUT("em_initialize_transmit_unit: begin");
3280        /* Setup the Base and Length of the Tx Descriptor Ring */
3281        bus_addr = adapter->txdma.dma_paddr;
3282        E1000_WRITE_REG(&adapter->hw, E1000_TDLEN,
3283            adapter->num_tx_desc * sizeof(struct e1000_tx_desc));
3284        E1000_WRITE_REG(&adapter->hw, E1000_TDBAH, (uint32_t)(bus_addr >> 32));
3285        E1000_WRITE_REG(&adapter->hw, E1000_TDBAL, (uint32_t)bus_addr);
3286
3287        /* Setup the HW Tx Head and Tail descriptor pointers */
3288        E1000_WRITE_REG(&adapter->hw, E1000_TDT, 0);
3289        E1000_WRITE_REG(&adapter->hw, E1000_TDH, 0);
3290
3291#ifndef __rtems__
3292        HW_DEBUGOUT2("Base = %x, Length = %x\n",
3293            E1000_READ_REG(&adapter->hw, E1000_TDBAL),
3294            E1000_READ_REG(&adapter->hw, E1000_TDLEN));
3295#else
3296        HW_DEBUGOUT2("Base = %x, Length = %x\n",
3297            (unsigned)E1000_READ_REG(&adapter->hw, E1000_TDBAL),
3298            (unsigned)E1000_READ_REG(&adapter->hw, E1000_TDLEN));
3299#endif
3300
3301        /* Set the default values for the Tx Inter Packet Gap timer */
3302        switch (adapter->hw.mac.type) {
3303#if !defined(NO_82542_SUPPORT) /* __rtems__ */
3304        case e1000_82542:
3305                tipg = DEFAULT_82542_TIPG_IPGT;
3306                tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
3307                tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
3308                break;
3309#endif
3310        case e1000_80003es2lan:
3311                tipg = DEFAULT_82543_TIPG_IPGR1;
3312                tipg |= DEFAULT_80003ES2LAN_TIPG_IPGR2 <<
3313                    E1000_TIPG_IPGR2_SHIFT;
3314                break;
3315        default:
3316                if ((adapter->hw.media_type == e1000_media_type_fiber) ||
3317                    (adapter->hw.media_type ==
3318                    e1000_media_type_internal_serdes))
3319                        tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
3320                else
3321                        tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
3322                tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
3323                tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
3324        }
3325
3326        E1000_WRITE_REG(&adapter->hw, E1000_TIPG, tipg);
3327        E1000_WRITE_REG(&adapter->hw, E1000_TIDV, adapter->tx_int_delay.value);
3328        if(adapter->hw.mac.type >= e1000_82540)
3329                E1000_WRITE_REG(&adapter->hw, E1000_TADV,
3330                    adapter->tx_abs_int_delay.value);
3331
3332        if ((adapter->hw.mac.type == e1000_82571) ||
3333            (adapter->hw.mac.type == e1000_82572)) {
3334                tarc = E1000_READ_REG(&adapter->hw, E1000_TARC0);
3335                tarc |= SPEED_MODE_BIT;
3336                E1000_WRITE_REG(&adapter->hw, E1000_TARC0, tarc);
3337        } else if (adapter->hw.mac.type == e1000_80003es2lan) {
3338                tarc = E1000_READ_REG(&adapter->hw, E1000_TARC0);
3339                tarc |= 1;
3340                E1000_WRITE_REG(&adapter->hw, E1000_TARC0, tarc);
3341                tarc = E1000_READ_REG(&adapter->hw, E1000_TARC1);
3342                tarc |= 1;
3343                E1000_WRITE_REG(&adapter->hw, E1000_TARC1, tarc);
3344        }
3345
3346        /* Program the Transmit Control Register */
3347        tctl = E1000_READ_REG(&adapter->hw, E1000_TCTL);
3348        tctl &= ~E1000_TCTL_CT;
3349        tctl |= (E1000_TCTL_PSP | E1000_TCTL_RTLC | E1000_TCTL_EN |
3350                   (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT));
3351
3352        if (adapter->hw.mac.type >= e1000_82571)
3353                tctl |= E1000_TCTL_MULR;
3354
3355        /* This write will effectively turn on the transmit unit. */
3356        E1000_WRITE_REG(&adapter->hw, E1000_TCTL, tctl);
3357
3358        /* Setup Transmit Descriptor Base Settings */   
3359        adapter->txd_cmd = E1000_TXD_CMD_IFCS;
3360
3361        if ((adapter->tx_int_delay.value > 0) &&
3362            (adapter->hw.mac.type != e1000_82575))
3363                adapter->txd_cmd |= E1000_TXD_CMD_IDE;
3364
3365        /* Set the function pointer for the transmit routine */
3366        if (adapter->hw.mac.type >= e1000_82575)
3367                adapter->em_xmit = em_adv_encap;
3368        else
3369                adapter->em_xmit = em_encap;
3370}
3371
3372/*********************************************************************
3373 *
3374 *  Free all transmit related data structures.
3375 *
3376 **********************************************************************/
3377static void
3378em_free_transmit_structures(struct adapter *adapter)
3379{
3380        struct em_buffer *tx_buffer;
3381        int i;
3382
3383        INIT_DEBUGOUT("free_transmit_structures: begin");
3384
3385        if (adapter->tx_buffer_area != NULL) {
3386                tx_buffer = adapter->tx_buffer_area;
3387                for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
3388                        if (tx_buffer->m_head != NULL) {
3389                                bus_dmamap_sync(adapter->txtag, tx_buffer->map,
3390                                    BUS_DMASYNC_POSTWRITE);
3391                                bus_dmamap_unload(adapter->txtag,
3392                                    tx_buffer->map);
3393                                m_freem(tx_buffer->m_head);
3394                                tx_buffer->m_head = NULL;
3395                        } else if (tx_buffer->map != NULL)
3396                                bus_dmamap_unload(adapter->txtag,
3397                                    tx_buffer->map);
3398                        if (tx_buffer->map != NULL) {
3399                                bus_dmamap_destroy(adapter->txtag,
3400                                    tx_buffer->map);
3401                                tx_buffer->map = NULL;
3402                        }
3403                }
3404        }
3405        if (adapter->tx_buffer_area != NULL) {
3406                free(adapter->tx_buffer_area, M_DEVBUF);
3407                adapter->tx_buffer_area = NULL;
3408        }
3409        if (adapter->txtag != NULL) {
3410                bus_dma_tag_destroy(adapter->txtag);
3411                adapter->txtag = NULL;
3412        }
3413}
3414
3415#ifndef __rtems__
3416/*********************************************************************
3417 *
3418 *  The offload context needs to be set when we transfer the first
3419 *  packet of a particular protocol (TCP/UDP). This routine has been
3420 *  enhanced to deal with inserted VLAN headers, and IPV6 (not complete)
3421 *
3422 **********************************************************************/
3423static void
3424em_transmit_checksum_setup(struct adapter *adapter, struct mbuf *mp,
3425    uint32_t *txd_upper, uint32_t *txd_lower)
3426{
3427        struct e1000_context_desc *TXD;
3428        struct em_buffer *tx_buffer;
3429        struct ether_vlan_header *eh;
3430        struct ip *ip;
3431        struct ip6_hdr *ip6;
3432        struct tcp_hdr *th;
3433        int curr_txd, ehdrlen, hdr_len, ip_hlen;
3434        uint32_t cmd = 0;
3435        uint16_t etype;
3436        uint8_t ipproto;
3437
3438        /* Setup checksum offload context. */
3439        curr_txd = adapter->next_avail_tx_desc;
3440        tx_buffer = &adapter->tx_buffer_area[curr_txd];
3441        TXD = (struct e1000_context_desc *) &adapter->tx_desc_base[curr_txd];
3442
3443        *txd_lower = E1000_TXD_CMD_DEXT |       /* Extended descr type */
3444                     E1000_TXD_DTYP_D;          /* Data descr */
3445
3446        /*
3447         * Determine where frame payload starts.
3448         * Jump over vlan headers if already present,
3449         * helpful for QinQ too.
3450         */
3451        eh = mtod(mp, struct ether_vlan_header *);
3452        if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
3453                etype = ntohs(eh->evl_proto);
3454                ehdrlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
3455        } else {
3456                etype = ntohs(eh->evl_encap_proto);
3457                ehdrlen = ETHER_HDR_LEN;
3458        }
3459
3460        /*
3461         * We only support TCP/UDP for IPv4 and IPv6 for the moment.
3462         * TODO: Support SCTP too when it hits the tree.
3463         */
3464        switch (etype) {
3465        case ETHERTYPE_IP:
3466                ip = (struct ip *)(mp->m_data + ehdrlen);
3467                ip_hlen = ip->ip_hl << 2;
3468
3469                /* Setup of IP header checksum. */
3470                if (mp->m_pkthdr.csum_flags & CSUM_IP) {
3471                        /*
3472                         * Start offset for header checksum calculation.
3473                         * End offset for header checksum calculation.
3474                         * Offset of place to put the checksum.
3475                         */
3476                        TXD->lower_setup.ip_fields.ipcss = ehdrlen;
3477                        TXD->lower_setup.ip_fields.ipcse =
3478                            htole16(ehdrlen + ip_hlen);
3479                        TXD->lower_setup.ip_fields.ipcso =
3480                            ehdrlen + offsetof(struct ip, ip_sum);
3481                        cmd |= E1000_TXD_CMD_IP;
3482                        *txd_upper |= E1000_TXD_POPTS_IXSM << 8;
3483                }
3484
3485                if (mp->m_len < ehdrlen + ip_hlen)
3486                        return; /* failure */
3487
3488                hdr_len = ehdrlen + ip_hlen;
3489                ipproto = ip->ip_p;
3490
3491                break;
3492        case ETHERTYPE_IPV6:
3493                ip6 = (struct ip6_hdr *)(mp->m_data + ehdrlen);
3494                ip_hlen = sizeof(struct ip6_hdr); /* XXX: No header stacking. */
3495
3496                if (mp->m_len < ehdrlen + ip_hlen)
3497                        return; /* failure */
3498
3499                /* IPv6 doesn't have a header checksum. */
3500
3501                hdr_len = ehdrlen + ip_hlen;
3502                ipproto = ip6->ip6_nxt;
3503
3504                break;
3505        default:
3506                *txd_upper = 0;
3507                *txd_lower = 0;
3508                return;
3509        }
3510
3511        switch (ipproto) {
3512        case IPPROTO_TCP:
3513                if (mp->m_pkthdr.csum_flags & CSUM_TCP) {
3514                        /*
3515                         * Start offset for payload checksum calculation.
3516                         * End offset for payload checksum calculation.
3517                         * Offset of place to put the checksum.
3518                         */
3519                        th = (struct tcp_hdr *)(mp->m_data + hdr_len);
3520                        TXD->upper_setup.tcp_fields.tucss = hdr_len;
3521                        TXD->upper_setup.tcp_fields.tucse = htole16(0);
3522                        TXD->upper_setup.tcp_fields.tucso =
3523                            hdr_len + offsetof(struct tcphdr, th_sum);
3524                        cmd |= E1000_TXD_CMD_TCP;
3525                        *txd_upper |= E1000_TXD_POPTS_TXSM << 8;
3526                }
3527                break;
3528        case IPPROTO_UDP:
3529                if (mp->m_pkthdr.csum_flags & CSUM_UDP) {
3530                        /*
3531                         * Start offset for header checksum calculation.
3532                         * End offset for header checksum calculation.
3533                         * Offset of place to put the checksum.
3534                         */
3535                        TXD->upper_setup.tcp_fields.tucss = hdr_len;
3536                        TXD->upper_setup.tcp_fields.tucse = htole16(0);
3537                        TXD->upper_setup.tcp_fields.tucso =
3538                            hdr_len + offsetof(struct udphdr, uh_sum);
3539                        *txd_upper |= E1000_TXD_POPTS_TXSM << 8;
3540                }
3541                break;
3542        default:
3543                break;
3544        }
3545
3546        TXD->tcp_seg_setup.data = htole32(0);
3547        TXD->cmd_and_length =
3548            htole32(adapter->txd_cmd | E1000_TXD_CMD_DEXT | cmd);
3549        tx_buffer->m_head = NULL;
3550        tx_buffer->next_eop = -1;
3551
3552        if (++curr_txd == adapter->num_tx_desc)
3553                curr_txd = 0;
3554
3555        adapter->num_tx_desc_avail--;
3556        adapter->next_avail_tx_desc = curr_txd;
3557}
3558
3559/**********************************************************************
3560 *
3561 *  Setup work for hardware segmentation offload (TSO)
3562 *
3563 **********************************************************************/
3564static boolean_t
3565em_tso_setup(struct adapter *adapter, struct mbuf *mp, uint32_t *txd_upper,
3566   uint32_t *txd_lower)
3567{
3568        struct e1000_context_desc *TXD;
3569        struct em_buffer *tx_buffer;
3570        struct ether_vlan_header *eh;
3571        struct ip *ip;
3572        struct ip6_hdr *ip6;
3573        struct tcphdr *th;
3574        int curr_txd, ehdrlen, hdr_len, ip_hlen, isip6;
3575        uint16_t etype;
3576
3577        /*
3578         * XXX: This is not really correct as the stack would not have
3579         * set up all checksums.
3580         * XXX: Return FALSE is not sufficient as we may have to return
3581         * in true failure cases as well.  Should do -1 (failure), 0 (no)
3582         * and 1 (success).
3583         */
3584        if (((mp->m_pkthdr.csum_flags & CSUM_TSO) == 0) ||
3585             (mp->m_pkthdr.len <= EM_TX_BUFFER_SIZE))
3586                return FALSE;
3587
3588        /*
3589         * This function could/should be extended to support IP/IPv6
3590         * fragmentation as well.  But as they say, one step at a time.
3591         */
3592
3593        /*
3594         * Determine where frame payload starts.
3595         * Jump over vlan headers if already present,
3596         * helpful for QinQ too.
3597         */
3598        eh = mtod(mp, struct ether_vlan_header *);
3599        if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
3600                etype = ntohs(eh->evl_proto);
3601                ehdrlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
3602        } else {
3603                etype = ntohs(eh->evl_encap_proto);
3604                ehdrlen = ETHER_HDR_LEN;
3605        }
3606
3607        /* Ensure we have at least the IP+TCP header in the first mbuf. */
3608        if (mp->m_len < ehdrlen + sizeof(struct ip) + sizeof(struct tcphdr))
3609                return FALSE;   /* -1 */
3610
3611        /*
3612         * We only support TCP for IPv4 and IPv6 (notyet) for the moment.
3613         * TODO: Support SCTP too when it hits the tree.
3614         */
3615        switch (etype) {
3616        case ETHERTYPE_IP:
3617                isip6 = 0;
3618                ip = (struct ip *)(mp->m_data + ehdrlen);
3619                if (ip->ip_p != IPPROTO_TCP)
3620                        return FALSE;   /* 0 */
3621                ip->ip_len = 0;
3622                ip->ip_sum = 0;
3623                ip_hlen = ip->ip_hl << 2;
3624                if (mp->m_len < ehdrlen + ip_hlen + sizeof(struct tcphdr))
3625                        return FALSE;   /* -1 */
3626                th = (struct tcphdr *)((caddr_t)ip + ip_hlen);
3627#if 1
3628                th->th_sum = in_pseudo(ip->ip_src.s_addr,
3629                    ip->ip_dst.s_addr, htons(IPPROTO_TCP));
3630#else
3631                th->th_sum = mp->m_pkthdr.csum_data;
3632#endif
3633                break;
3634        case ETHERTYPE_IPV6:
3635                isip6 = 1;
3636                return FALSE;                   /* Not supported yet. */
3637                ip6 = (struct ip6_hdr *)(mp->m_data + ehdrlen);
3638                if (ip6->ip6_nxt != IPPROTO_TCP)
3639                        return FALSE;   /* 0 */
3640                ip6->ip6_plen = 0;
3641                ip_hlen = sizeof(struct ip6_hdr); /* XXX: no header stacking. */
3642                if (mp->m_len < ehdrlen + ip_hlen + sizeof(struct tcphdr))
3643                        return FALSE;   /* -1 */
3644                th = (struct tcphdr *)((caddr_t)ip6 + ip_hlen);
3645#if 0
3646                th->th_sum = in6_pseudo(ip6->ip6_src, ip->ip6_dst,
3647                    htons(IPPROTO_TCP));        /* XXX: function notyet. */
3648#else
3649                th->th_sum = mp->m_pkthdr.csum_data;
3650#endif
3651                break;
3652        default:
3653                return FALSE;
3654        }
3655        hdr_len = ehdrlen + ip_hlen + (th->th_off << 2);
3656
3657        *txd_lower = (E1000_TXD_CMD_DEXT |      /* Extended descr type */
3658                      E1000_TXD_DTYP_D |        /* Data descr type */
3659                      E1000_TXD_CMD_TSE);       /* Do TSE on this packet */
3660
3661        /* IP and/or TCP header checksum calculation and insertion. */
3662        *txd_upper = ((isip6 ? 0 : E1000_TXD_POPTS_IXSM) |
3663                      E1000_TXD_POPTS_TXSM) << 8;
3664
3665        curr_txd = adapter->next_avail_tx_desc;
3666        tx_buffer = &adapter->tx_buffer_area[curr_txd];
3667        TXD = (struct e1000_context_desc *) &adapter->tx_desc_base[curr_txd];
3668
3669        /* IPv6 doesn't have a header checksum. */
3670        if (!isip6) {
3671                /*
3672                 * Start offset for header checksum calculation.
3673                 * End offset for header checksum calculation.
3674                 * Offset of place put the checksum.
3675                 */
3676                TXD->lower_setup.ip_fields.ipcss = ehdrlen;
3677                TXD->lower_setup.ip_fields.ipcse =
3678                    htole16(ehdrlen + ip_hlen - 1);
3679                TXD->lower_setup.ip_fields.ipcso =
3680                    ehdrlen + offsetof(struct ip, ip_sum);
3681        }
3682        /*
3683         * Start offset for payload checksum calculation.
3684         * End offset for payload checksum calculation.
3685         * Offset of place to put the checksum.
3686         */
3687        TXD->upper_setup.tcp_fields.tucss =
3688            ehdrlen + ip_hlen;
3689        TXD->upper_setup.tcp_fields.tucse = 0;
3690        TXD->upper_setup.tcp_fields.tucso =
3691            ehdrlen + ip_hlen + offsetof(struct tcphdr, th_sum);
3692        /*
3693         * Payload size per packet w/o any headers.
3694         * Length of all headers up to payload.
3695         */
3696        TXD->tcp_seg_setup.fields.mss = htole16(mp->m_pkthdr.tso_segsz);
3697        TXD->tcp_seg_setup.fields.hdr_len = hdr_len;
3698
3699        TXD->cmd_and_length = htole32(adapter->txd_cmd |
3700                                E1000_TXD_CMD_DEXT |    /* Extended descr */
3701                                E1000_TXD_CMD_TSE |     /* TSE context */
3702                                (isip6 ? 0 : E1000_TXD_CMD_IP) | /* Do IP csum */
3703                                E1000_TXD_CMD_TCP |     /* Do TCP checksum */
3704                                (mp->m_pkthdr.len - (hdr_len))); /* Total len */
3705
3706        tx_buffer->m_head = NULL;
3707        tx_buffer->next_eop = -1;
3708
3709        if (++curr_txd == adapter->num_tx_desc)
3710                curr_txd = 0;
3711
3712        adapter->num_tx_desc_avail--;
3713        adapter->next_avail_tx_desc = curr_txd;
3714        adapter->tx_tso = TRUE;
3715
3716        return TRUE;
3717}
3718
3719
3720/**********************************************************************
3721 *
3722 *  Setup work for hardware segmentation offload (TSO) on
3723 *  adapters using advanced tx descriptors
3724 *
3725 **********************************************************************/
3726static boolean_t
3727em_tso_adv_setup(struct adapter *adapter, struct mbuf *mp, u32 *paylen)
3728{
3729        struct e1000_adv_tx_context_desc *TXD;
3730        struct em_buffer        *tx_buffer;
3731        u32 vlan_macip_lens = 0, type_tucmd_mlhl = 0;
3732        u32 mss_l4len_idx = 0;
3733        u16 vtag = 0;
3734        int ctxd, ehdrlen, hdrlen, ip_hlen, tcp_hlen;
3735        struct ether_vlan_header *eh;
3736        struct ip *ip;
3737        struct tcphdr *th;
3738
3739        if (((mp->m_pkthdr.csum_flags & CSUM_TSO) == 0) ||
3740             (mp->m_pkthdr.len <= EM_TX_BUFFER_SIZE))
3741                return FALSE;
3742
3743        /*
3744         * Determine where frame payload starts.
3745         * Jump over vlan headers if already present
3746         */
3747        eh = mtod(mp, struct ether_vlan_header *);
3748        if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN))
3749                ehdrlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
3750        else
3751                ehdrlen = ETHER_HDR_LEN;
3752
3753        /* Ensure we have at least the IP+TCP header in the first mbuf. */
3754        if (mp->m_len < ehdrlen + sizeof(struct ip) + sizeof(struct tcphdr))
3755                return FALSE;
3756
3757        /* Only supports IPV4 for now */
3758        ctxd = adapter->next_avail_tx_desc;
3759        tx_buffer = &adapter->tx_buffer_area[ctxd];
3760        TXD = (struct e1000_adv_tx_context_desc *) &adapter->tx_desc_base[ctxd];
3761
3762        ip = (struct ip *)(mp->m_data + ehdrlen);
3763        if (ip->ip_p != IPPROTO_TCP)
3764                return FALSE;   /* 0 */
3765        ip->ip_len = 0;
3766        ip->ip_sum = 0;
3767        ip_hlen = ip->ip_hl << 2;
3768        th = (struct tcphdr *)((caddr_t)ip + ip_hlen);
3769        th->th_sum = in_pseudo(ip->ip_src.s_addr,
3770            ip->ip_dst.s_addr, htons(IPPROTO_TCP));
3771        tcp_hlen = th->th_off << 2;
3772        hdrlen = ehdrlen + ip_hlen + tcp_hlen;
3773        /* Calculate payload, this is used in the transmit desc in encap */
3774        *paylen = mp->m_pkthdr.len - hdrlen;
3775
3776#ifndef __rtems__
3777        /* VLAN MACLEN IPLEN */
3778        if (mp->m_flags & M_VLANTAG) {
3779                vtag = htole16(mp->m_pkthdr.ether_vtag);
3780                vlan_macip_lens |= (vtag << E1000_ADVTXD_VLAN_SHIFT);
3781        }
3782#endif
3783        vlan_macip_lens |= (ehdrlen << E1000_ADVTXD_MACLEN_SHIFT);
3784        vlan_macip_lens |= ip_hlen;
3785        TXD->vlan_macip_lens |= htole32(vlan_macip_lens);
3786
3787        /* ADV DTYPE TUCMD */
3788        type_tucmd_mlhl |= E1000_ADVTXD_DCMD_DEXT | E1000_ADVTXD_DTYP_CTXT;
3789        type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_L4T_TCP;
3790        type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_IPV4;
3791        TXD->type_tucmd_mlhl |= htole32(type_tucmd_mlhl);
3792
3793        /* MSS L4LEN IDX */
3794        mss_l4len_idx |= (mp->m_pkthdr.tso_segsz << E1000_ADVTXD_MSS_SHIFT);
3795        mss_l4len_idx |= (tcp_hlen << E1000_ADVTXD_L4LEN_SHIFT);
3796        TXD->mss_l4len_idx = htole32(mss_l4len_idx);
3797
3798        TXD->seqnum_seed = htole32(0);
3799        tx_buffer->m_head = NULL;
3800        tx_buffer->next_eop = -1;
3801
3802        if (++ctxd == adapter->num_tx_desc)
3803                ctxd = 0;
3804
3805        adapter->num_tx_desc_avail--;
3806        adapter->next_avail_tx_desc = ctxd;
3807        return TRUE;
3808}
3809
3810
3811/*********************************************************************
3812 *
3813 *  Advanced Context Descriptor setup for VLAN or CSUM
3814 *
3815 **********************************************************************/
3816
3817static boolean_t
3818em_tx_adv_ctx_setup(struct adapter *adapter, struct mbuf *mp)
3819{
3820        struct e1000_adv_tx_context_desc *TXD;
3821        struct em_buffer        *tx_buffer;
3822        uint32_t vlan_macip_lens = 0, type_tucmd_mlhl = 0;
3823        struct ether_vlan_header *eh;
3824        struct ip *ip;
3825        struct ip6_hdr *ip6;
3826        int  ehdrlen, ip_hlen;
3827        u16     etype;
3828        u8      ipproto;
3829
3830        int ctxd = adapter->next_avail_tx_desc;
3831        u16 vtag = 0;
3832
3833        tx_buffer = &adapter->tx_buffer_area[ctxd];
3834        TXD = (struct e1000_adv_tx_context_desc *) &adapter->tx_desc_base[ctxd];
3835
3836        /*
3837        ** In advanced descriptors the vlan tag must
3838        ** be placed into the descriptor itself.
3839        */
3840        if (mp->m_flags & M_VLANTAG) {
3841                vtag = htole16(mp->m_pkthdr.ether_vtag);
3842                vlan_macip_lens |= (vtag << E1000_ADVTXD_VLAN_SHIFT);
3843        }
3844
3845        /*
3846         * Determine where frame payload starts.
3847         * Jump over vlan headers if already present,
3848         * helpful for QinQ too.
3849         */
3850        eh = mtod(mp, struct ether_vlan_header *);
3851        if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
3852                etype = ntohs(eh->evl_proto);
3853                ehdrlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
3854        } else {
3855                etype = ntohs(eh->evl_encap_proto);
3856                ehdrlen = ETHER_HDR_LEN;
3857        }
3858
3859        /* Set the ether header length */
3860        vlan_macip_lens |= ehdrlen << E1000_ADVTXD_MACLEN_SHIFT;
3861
3862        switch (etype) {
3863                case ETHERTYPE_IP:
3864                        ip = (struct ip *)(mp->m_data + ehdrlen);
3865                        ip_hlen = ip->ip_hl << 2;
3866                        if (mp->m_len < ehdrlen + ip_hlen)
3867                                return FALSE; /* failure */
3868                        ipproto = ip->ip_p;
3869                        type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_IPV4;
3870                        break;
3871                case ETHERTYPE_IPV6:
3872                        ip6 = (struct ip6_hdr *)(mp->m_data + ehdrlen);
3873                        ip_hlen = sizeof(struct ip6_hdr);
3874                        if (mp->m_len < ehdrlen + ip_hlen)
3875                                return FALSE; /* failure */
3876                        ipproto = ip6->ip6_nxt;
3877                        type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_IPV6;
3878                        break;
3879                default:
3880                        return FALSE;
3881        }
3882
3883        vlan_macip_lens |= ip_hlen;
3884        type_tucmd_mlhl |= E1000_ADVTXD_DCMD_DEXT | E1000_ADVTXD_DTYP_CTXT;
3885
3886        switch (ipproto) {
3887                case IPPROTO_TCP:
3888                        if (mp->m_pkthdr.csum_flags & CSUM_TCP)
3889                                type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_L4T_TCP;
3890                        break;
3891                case IPPROTO_UDP:
3892                        if (mp->m_pkthdr.csum_flags & CSUM_UDP)
3893                                type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_L4T_TCP;
3894                        break;
3895        }
3896
3897        /* Now copy bits into descriptor */
3898        TXD->vlan_macip_lens |= htole32(vlan_macip_lens);
3899        TXD->type_tucmd_mlhl |= htole32(type_tucmd_mlhl);
3900        TXD->seqnum_seed = htole32(0);
3901        TXD->mss_l4len_idx = htole32(0);
3902
3903        tx_buffer->m_head = NULL;
3904        tx_buffer->next_eop = -1;
3905
3906        /* We've consumed the first desc, adjust counters */
3907        if (++ctxd == adapter->num_tx_desc)
3908                ctxd = 0;
3909        adapter->next_avail_tx_desc = ctxd;
3910        --adapter->num_tx_desc_avail;
3911
3912        return TRUE;
3913}
3914#endif
3915
3916
3917/**********************************************************************
3918 *
3919 *  Examine each tx_buffer in the used queue. If the hardware is done
3920 *  processing the packet then free associated resources. The
3921 *  tx_buffer is put back on the free queue.
3922 *
3923 **********************************************************************/
3924static void
3925em_txeof(struct adapter *adapter)
3926{
3927        int first, last, done, num_avail;
3928        struct em_buffer *tx_buffer;
3929        struct e1000_tx_desc   *tx_desc, *eop_desc;
3930        struct ifnet   *ifp = adapter->ifp;
3931
3932        EM_LOCK_ASSERT(adapter);
3933
3934        if (adapter->num_tx_desc_avail == adapter->num_tx_desc)
3935                return;
3936
3937        num_avail = adapter->num_tx_desc_avail;
3938        first = adapter->next_tx_to_clean;
3939        tx_desc = &adapter->tx_desc_base[first];
3940        tx_buffer = &adapter->tx_buffer_area[first];
3941        last = tx_buffer->next_eop;
3942        eop_desc = &adapter->tx_desc_base[last];
3943
3944        /*
3945         * What this does is get the index of the
3946         * first descriptor AFTER the EOP of the
3947         * first packet, that way we can do the
3948         * simple comparison on the inner while loop.
3949         */
3950        if (++last == adapter->num_tx_desc)
3951                last = 0;
3952        done = last;
3953
3954        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
3955            BUS_DMASYNC_POSTREAD);
3956
3957        while (eop_desc->upper.fields.status & E1000_TXD_STAT_DD) {
3958                /* We clean the range of the packet */
3959                while (first != done) {
3960                        tx_desc->upper.data = 0;
3961                        tx_desc->lower.data = 0;
3962                        tx_desc->buffer_addr = 0;
3963                        num_avail++;
3964
3965                        if (tx_buffer->m_head) {
3966                                ifp->if_opackets++;
3967                                bus_dmamap_sync(adapter->txtag,
3968                                    tx_buffer->map,
3969                                    BUS_DMASYNC_POSTWRITE);
3970                                bus_dmamap_unload(adapter->txtag,
3971                                    tx_buffer->map);
3972
3973                                m_freem(tx_buffer->m_head);
3974                                tx_buffer->m_head = NULL;
3975                        }
3976                        tx_buffer->next_eop = -1;
3977
3978                        if (++first == adapter->num_tx_desc)
3979                                first = 0;
3980
3981                        tx_buffer = &adapter->tx_buffer_area[first];
3982                        tx_desc = &adapter->tx_desc_base[first];
3983                }
3984                /* See if we can continue to the next packet */
3985                last = tx_buffer->next_eop;
3986                if (last != -1) {
3987                        eop_desc = &adapter->tx_desc_base[last];
3988                        /* Get new done point */
3989                        if (++last == adapter->num_tx_desc) last = 0;
3990                        done = last;
3991                } else
3992                        break;
3993        }
3994        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
3995            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
3996
3997        adapter->next_tx_to_clean = first;
3998
3999        /*
4000         * If we have enough room, clear IFF_DRV_OACTIVE to tell the stack
4001         * that it is OK to send packets.
4002         * If there are no pending descriptors, clear the timeout. Otherwise,
4003         * if some descriptors have been freed, restart the timeout.
4004         */
4005        if (num_avail > EM_TX_CLEANUP_THRESHOLD) {               
4006                ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
4007                /* All clean, turn off the timer */
4008                if (num_avail == adapter->num_tx_desc)
4009                        adapter->watchdog_timer = 0;
4010                /* Some cleaned, reset the timer */
4011                else if (num_avail != adapter->num_tx_desc_avail)
4012                        adapter->watchdog_timer = EM_TX_TIMEOUT;
4013        }
4014        adapter->num_tx_desc_avail = num_avail;
4015        return;
4016}
4017
4018/*********************************************************************
4019 *
4020 *  Get a buffer from system mbuf buffer pool.
4021 *
4022 **********************************************************************/
4023static int
4024em_get_buf(struct adapter *adapter, int i)
4025{
4026        struct mbuf             *m;
4027        bus_dma_segment_t       segs[1];
4028        bus_dmamap_t            map;
4029        struct em_buffer        *rx_buffer;
4030        int                     error, nsegs;
4031
4032        m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
4033        if (m == NULL) {
4034                adapter->mbuf_cluster_failed++;
4035                return (ENOBUFS);
4036        }
4037        m->m_len = m->m_pkthdr.len = MCLBYTES;
4038
4039        if (adapter->hw.mac.max_frame_size <= (MCLBYTES - ETHER_ALIGN))
4040                m_adj(m, ETHER_ALIGN);
4041
4042        /*
4043         * Using memory from the mbuf cluster pool, invoke the
4044         * bus_dma machinery to arrange the memory mapping.
4045         */
4046        error = bus_dmamap_load_mbuf_sg(adapter->rxtag,
4047            adapter->rx_sparemap, m, segs, &nsegs, BUS_DMA_NOWAIT);
4048        if (error != 0) {
4049                m_free(m);
4050                return (error);
4051        }
4052
4053        /* If nsegs is wrong then the stack is corrupt. */
4054        KASSERT(nsegs == 1, ("Too many segments returned!"));
4055
4056        rx_buffer = &adapter->rx_buffer_area[i];
4057        if (rx_buffer->m_head != NULL)
4058                bus_dmamap_unload(adapter->rxtag, rx_buffer->map);
4059
4060        map = rx_buffer->map;
4061        rx_buffer->map = adapter->rx_sparemap;
4062        adapter->rx_sparemap = map;
4063        bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD);
4064        rx_buffer->m_head = m;
4065
4066        adapter->rx_desc_base[i].buffer_addr = htole64(segs[0].ds_addr);
4067        return (0);
4068}
4069
4070/*********************************************************************
4071 *
4072 *  Allocate memory for rx_buffer structures. Since we use one
4073 *  rx_buffer per received packet, the maximum number of rx_buffer's
4074 *  that we'll need is equal to the number of receive descriptors
4075 *  that we've allocated.
4076 *
4077 **********************************************************************/
4078static int
4079em_allocate_receive_structures(struct adapter *adapter)
4080{
4081        device_t dev = adapter->dev;
4082        struct em_buffer *rx_buffer;
4083        int i, error;
4084
4085        adapter->rx_buffer_area = malloc(sizeof(struct em_buffer) *
4086            adapter->num_rx_desc, M_DEVBUF, M_NOWAIT);
4087        if (adapter->rx_buffer_area == NULL) {
4088                device_printf(dev, "Unable to allocate rx_buffer memory\n");
4089                return (ENOMEM);
4090        }
4091
4092        bzero(adapter->rx_buffer_area,
4093            sizeof(struct em_buffer) * adapter->num_rx_desc);
4094
4095        error = bus_dma_tag_create(bus_get_dma_tag(dev),        /* parent */
4096                                1, 0,                   /* alignment, bounds */
4097                                BUS_SPACE_MAXADDR,      /* lowaddr */
4098                                BUS_SPACE_MAXADDR,      /* highaddr */
4099                                NULL, NULL,             /* filter, filterarg */
4100                                MCLBYTES,               /* maxsize */
4101                                1,                      /* nsegments */
4102                                MCLBYTES,               /* maxsegsize */
4103                                0,                      /* flags */
4104                                NULL,                   /* lockfunc */
4105                                NULL,                   /* lockarg */
4106                                &adapter->rxtag);
4107        if (error) {
4108                device_printf(dev, "%s: bus_dma_tag_create failed %d\n",
4109                    __func__, error);
4110                goto fail;
4111        }
4112
4113        /* Create the spare map (used by getbuf) */
4114        error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT,
4115             &adapter->rx_sparemap);
4116        if (error) {
4117                device_printf(dev, "%s: bus_dmamap_create failed: %d\n",
4118                    __func__, error);
4119                goto fail;
4120        }
4121
4122        rx_buffer = adapter->rx_buffer_area;
4123        for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
4124                error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT,
4125                    &rx_buffer->map);
4126                if (error) {
4127                        device_printf(dev, "%s: bus_dmamap_create failed: %d\n",
4128                            __func__, error);
4129                        goto fail;
4130                }
4131        }
4132
4133        /* Setup the initial buffers */
4134        for (i = 0; i < adapter->num_rx_desc; i++) {
4135                error = em_get_buf(adapter, i);
4136                if (error)
4137                        goto fail;
4138        }
4139        bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
4140            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
4141
4142        return (0);
4143
4144fail:
4145        em_free_receive_structures(adapter);
4146        return (error);
4147}
4148
4149/*********************************************************************
4150 *
4151 *  Allocate and initialize receive structures.
4152 *
4153 **********************************************************************/
4154static int
4155em_setup_receive_structures(struct adapter *adapter)
4156{
4157        int error;
4158
4159        bzero(adapter->rx_desc_base,
4160            (sizeof(struct e1000_rx_desc)) * adapter->num_rx_desc);
4161
4162        if ((error = em_allocate_receive_structures(adapter)) !=0)
4163                return (error);
4164
4165        /* Setup our descriptor pointers */
4166        adapter->next_rx_desc_to_check = 0;
4167
4168        return (0);
4169}
4170
4171/*********************************************************************
4172 *
4173 *  Enable receive unit.
4174 *
4175 **********************************************************************/
4176static void
4177em_initialize_receive_unit(struct adapter *adapter)
4178{
4179        struct ifnet    *ifp = adapter->ifp;
4180        uint64_t        bus_addr;
4181        uint32_t        reg_rctl;
4182#ifndef __rtems__
4183        uint32_t        reg_rxcsum;
4184#endif
4185
4186        INIT_DEBUGOUT("em_initialize_receive_unit: begin");
4187
4188        /*
4189         * Make sure receives are disabled while setting
4190         * up the descriptor ring
4191         */
4192        reg_rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
4193        E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl & ~E1000_RCTL_EN);
4194
4195        if(adapter->hw.mac.type >= e1000_82540) {
4196                E1000_WRITE_REG(&adapter->hw, E1000_RADV,
4197                    adapter->rx_abs_int_delay.value);
4198                /*
4199                 * Set the interrupt throttling rate. Value is calculated
4200                 * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns)
4201                 */
4202#define MAX_INTS_PER_SEC        8000
4203#define DEFAULT_ITR          1000000000/(MAX_INTS_PER_SEC * 256)
4204                E1000_WRITE_REG(&adapter->hw, E1000_ITR, DEFAULT_ITR);
4205        }
4206
4207        /* Setup the Base and Length of the Rx Descriptor Ring */
4208        bus_addr = adapter->rxdma.dma_paddr;
4209        E1000_WRITE_REG(&adapter->hw, E1000_RDLEN, adapter->num_rx_desc *
4210                        sizeof(struct e1000_rx_desc));
4211        E1000_WRITE_REG(&adapter->hw, E1000_RDBAH, (uint32_t)(bus_addr >> 32));
4212        E1000_WRITE_REG(&adapter->hw, E1000_RDBAL, (uint32_t)bus_addr);
4213
4214        /* Setup the Receive Control Register */
4215        reg_rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
4216        reg_rctl |= E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
4217                   E1000_RCTL_RDMTS_HALF |
4218                   (adapter->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
4219
4220        if (e1000_tbi_sbp_enabled_82543(&adapter->hw))
4221                reg_rctl |= E1000_RCTL_SBP;
4222        else
4223                reg_rctl &= ~E1000_RCTL_SBP;
4224
4225        switch (adapter->rx_buffer_len) {
4226        default:
4227        case 2048:
4228                reg_rctl |= E1000_RCTL_SZ_2048;
4229                break;
4230        case 4096:
4231                reg_rctl |= E1000_RCTL_SZ_4096 |
4232                    E1000_RCTL_BSEX | E1000_RCTL_LPE;
4233                break;
4234        case 8192:
4235                reg_rctl |= E1000_RCTL_SZ_8192 |
4236                    E1000_RCTL_BSEX | E1000_RCTL_LPE;
4237                break;
4238        case 16384:
4239                reg_rctl |= E1000_RCTL_SZ_16384 |
4240                    E1000_RCTL_BSEX | E1000_RCTL_LPE;
4241                break;
4242        }
4243
4244        if (ifp->if_mtu > ETHERMTU)
4245                reg_rctl |= E1000_RCTL_LPE;
4246        else
4247                reg_rctl &= ~E1000_RCTL_LPE;
4248
4249#ifndef __rtems__
4250        /* Enable 82543 Receive Checksum Offload for TCP and UDP */
4251        if ((adapter->hw.mac.type >= e1000_82543) &&
4252            (ifp->if_capenable & IFCAP_RXCSUM)) {
4253                reg_rxcsum = E1000_READ_REG(&adapter->hw, E1000_RXCSUM);
4254                reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL);
4255                E1000_WRITE_REG(&adapter->hw, E1000_RXCSUM, reg_rxcsum);
4256        }
4257#endif
4258
4259        /*
4260        ** XXX TEMPORARY WORKAROUND: on some systems with 82573
4261        ** long latencies are observed, like Lenovo X60. This
4262        ** change eliminates the problem, but since having positive
4263        ** values in RDTR is a known source of problems on other
4264        ** platforms another solution is being sought.
4265        */
4266        if (adapter->hw.mac.type == e1000_82573)
4267                E1000_WRITE_REG(&adapter->hw, E1000_RDTR, 0x20);
4268
4269        /* Enable Receives */
4270        E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl);
4271
4272        /*
4273         * Setup the HW Rx Head and
4274         * Tail Descriptor Pointers
4275         */
4276        E1000_WRITE_REG(&adapter->hw, E1000_RDH, 0);
4277        E1000_WRITE_REG(&adapter->hw, E1000_RDT, adapter->num_rx_desc - 1);
4278
4279        return;
4280}
4281
4282/*********************************************************************
4283 *
4284 *  Free receive related data structures.
4285 *
4286 **********************************************************************/
4287static void
4288em_free_receive_structures(struct adapter *adapter)
4289{
4290        struct em_buffer *rx_buffer;
4291        int i;
4292
4293        INIT_DEBUGOUT("free_receive_structures: begin");
4294
4295        if (adapter->rx_sparemap) {
4296                bus_dmamap_destroy(adapter->rxtag, adapter->rx_sparemap);
4297                adapter->rx_sparemap = NULL;
4298        }
4299
4300        /* Cleanup any existing buffers */
4301        if (adapter->rx_buffer_area != NULL) {
4302                rx_buffer = adapter->rx_buffer_area;
4303                for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
4304                        if (rx_buffer->m_head != NULL) {
4305                                bus_dmamap_sync(adapter->rxtag, rx_buffer->map,
4306                                    BUS_DMASYNC_POSTREAD);
4307                                bus_dmamap_unload(adapter->rxtag,
4308                                    rx_buffer->map);
4309                                m_freem(rx_buffer->m_head);
4310                                rx_buffer->m_head = NULL;
4311                        } else if (rx_buffer->map != NULL)
4312                                bus_dmamap_unload(adapter->rxtag,
4313                                    rx_buffer->map);
4314                        if (rx_buffer->map != NULL) {
4315                                bus_dmamap_destroy(adapter->rxtag,
4316                                    rx_buffer->map);
4317                                rx_buffer->map = NULL;
4318                        }
4319                }
4320        }
4321
4322        if (adapter->rx_buffer_area != NULL) {
4323                free(adapter->rx_buffer_area, M_DEVBUF);
4324                adapter->rx_buffer_area = NULL;
4325        }
4326
4327        if (adapter->rxtag != NULL) {
4328                bus_dma_tag_destroy(adapter->rxtag);
4329                adapter->rxtag = NULL;
4330        }
4331}
4332
4333/*********************************************************************
4334 *
4335 *  This routine executes in interrupt context. It replenishes
4336 *  the mbufs in the descriptor and sends data which has been
4337 *  dma'ed into host memory to upper layer.
4338 *
4339 *  We loop at most count times if count is > 0, or until done if
4340 *  count < 0.
4341 *
4342 *********************************************************************/
4343static int
4344em_rxeof(struct adapter *adapter, int count)
4345{
4346        struct ifnet    *ifp;
4347        struct mbuf     *mp;
4348        uint8_t         accept_frame = 0;
4349        uint8_t         eop = 0;
4350        uint16_t        len, desc_len, prev_len_adj;
4351        int             i;
4352
4353        /* Pointer to the receive descriptor being examined. */
4354        struct e1000_rx_desc   *current_desc;
4355        uint8_t         status;
4356
4357        ifp = adapter->ifp;
4358        i = adapter->next_rx_desc_to_check;
4359        current_desc = &adapter->rx_desc_base[i];
4360        bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
4361            BUS_DMASYNC_POSTREAD);
4362
4363        if (!((current_desc->status) & E1000_RXD_STAT_DD))
4364                return (0);
4365
4366        while ((current_desc->status & E1000_RXD_STAT_DD) &&
4367            (count != 0) &&
4368            (ifp->if_drv_flags & IFF_DRV_RUNNING)) {
4369                struct mbuf *m = NULL;
4370
4371                mp = adapter->rx_buffer_area[i].m_head;
4372                /*
4373                 * Can't defer bus_dmamap_sync(9) because TBI_ACCEPT
4374                 * needs to access the last received byte in the mbuf.
4375                 */
4376                bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map,
4377                    BUS_DMASYNC_POSTREAD);
4378
4379                accept_frame = 1;
4380                prev_len_adj = 0;
4381                desc_len = le16toh(current_desc->length);
4382                status = current_desc->status;
4383                if (status & E1000_RXD_STAT_EOP) {
4384                        count--;
4385                        eop = 1;
4386                        if (desc_len < ETHER_CRC_LEN) {
4387                                len = 0;
4388                                prev_len_adj = ETHER_CRC_LEN - desc_len;
4389                        } else
4390                                len = desc_len - ETHER_CRC_LEN;
4391                } else {
4392                        eop = 0;
4393                        len = desc_len;
4394                }
4395
4396                if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
4397                        uint8_t         last_byte;
4398                        uint32_t        pkt_len = desc_len;
4399
4400                        if (adapter->fmp != NULL)
4401                                pkt_len += adapter->fmp->m_pkthdr.len;
4402
4403                        last_byte = *(mtod(mp, caddr_t) + desc_len - 1);                       
4404                        if (TBI_ACCEPT(&adapter->hw, status,
4405                            current_desc->errors, pkt_len, last_byte)) {
4406                                e1000_tbi_adjust_stats_82543(&adapter->hw,
4407                                    &adapter->stats, pkt_len,
4408                                    adapter->hw.mac.addr);
4409                                if (len > 0)
4410                                        len--;
4411                        } else
4412                                accept_frame = 0;
4413                }
4414
4415                if (accept_frame) {
4416                        if (em_get_buf(adapter, i) != 0) {
4417                                ifp->if_iqdrops++;
4418                                goto discard;
4419                        }
4420
4421                        /* Assign correct length to the current fragment */
4422                        mp->m_len = len;
4423
4424                        if (adapter->fmp == NULL) {
4425                                mp->m_pkthdr.len = len;
4426                                adapter->fmp = mp; /* Store the first mbuf */
4427                                adapter->lmp = mp;
4428                        } else {
4429                                /* Chain mbuf's together */
4430                                mp->m_flags &= ~M_PKTHDR;
4431                                /*
4432                                 * Adjust length of previous mbuf in chain if
4433                                 * we received less than 4 bytes in the last
4434                                 * descriptor.
4435                                 */
4436                                if (prev_len_adj > 0) {
4437                                        adapter->lmp->m_len -= prev_len_adj;
4438                                        adapter->fmp->m_pkthdr.len -=
4439                                            prev_len_adj;
4440                                }
4441                                adapter->lmp->m_next = mp;
4442                                adapter->lmp = adapter->lmp->m_next;
4443                                adapter->fmp->m_pkthdr.len += len;
4444                        }
4445
4446                        if (eop) {
4447                                adapter->fmp->m_pkthdr.rcvif = ifp;
4448                                ifp->if_ipackets++;
4449#ifndef __rtems__
4450                                em_receive_checksum(adapter, current_desc,
4451                                    adapter->fmp);
4452#endif
4453#ifndef __NO_STRICT_ALIGNMENT
4454                                if (adapter->hw.mac.max_frame_size >
4455                                    (MCLBYTES - ETHER_ALIGN) &&
4456                                    em_fixup_rx(adapter) != 0)
4457                                        goto skip;
4458#endif
4459                                if (status & E1000_RXD_STAT_VP) {
4460#ifndef __rtems__
4461                                        adapter->fmp->m_pkthdr.ether_vtag =
4462                                            (le16toh(current_desc->special) &
4463                                            E1000_RXD_SPC_VLAN_MASK);
4464                                        adapter->fmp->m_flags |= M_VLANTAG;
4465#else
4466                                        ifp->if_iqdrops++;
4467                                        goto discard;
4468#endif
4469                                }
4470#ifndef __NO_STRICT_ALIGNMENT
4471skip:
4472#endif
4473                                m = adapter->fmp;
4474                                adapter->fmp = NULL;
4475                                adapter->lmp = NULL;
4476                        }
4477                } else {
4478                        ifp->if_ierrors++;
4479discard:
4480                        /* Reuse loaded DMA map and just update mbuf chain */
4481                        mp = adapter->rx_buffer_area[i].m_head;
4482                        mp->m_len = mp->m_pkthdr.len = MCLBYTES;
4483                        mp->m_data = mp->m_ext.ext_buf;
4484                        mp->m_next = NULL;
4485                        if (adapter->hw.mac.max_frame_size <=
4486                            (MCLBYTES - ETHER_ALIGN))
4487                                m_adj(mp, ETHER_ALIGN);
4488                        if (adapter->fmp != NULL) {
4489                                m_freem(adapter->fmp);
4490                                adapter->fmp = NULL;
4491                                adapter->lmp = NULL;
4492                        }
4493                        m = NULL;
4494                }
4495
4496                /* Zero out the receive descriptors status. */
4497                current_desc->status = 0;
4498                bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
4499                    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
4500
4501                /* Advance our pointers to the next descriptor. */
4502                if (++i == adapter->num_rx_desc)
4503                        i = 0;
4504                if (m != NULL) {
4505                        adapter->next_rx_desc_to_check = i;
4506#ifdef DEVICE_POLLING
4507                        EM_UNLOCK(adapter);
4508#  ifndef __rtems__
4509                        (*ifp->if_input)(ifp, m);
4510#  else
4511                        ether_input_skipping(ifp, m);
4512#  endif
4513                        EM_LOCK(adapter);
4514#else
4515                        /* Already running unlocked */
4516#  ifndef __rtems__
4517                        (*ifp->if_input)(ifp, m);
4518#  else
4519                        ether_input_skipping(ifp, m);
4520#  endif
4521#endif
4522                        i = adapter->next_rx_desc_to_check;
4523                }
4524                current_desc = &adapter->rx_desc_base[i];
4525        }
4526        adapter->next_rx_desc_to_check = i;
4527
4528        /* Advance the E1000's Receive Queue #0  "Tail Pointer". */
4529        if (--i < 0)
4530                i = adapter->num_rx_desc - 1;
4531        E1000_WRITE_REG(&adapter->hw, E1000_RDT, i);
4532        if (!((current_desc->status) & E1000_RXD_STAT_DD))
4533                return (0);
4534
4535        return (1);
4536}
4537
4538#ifndef __NO_STRICT_ALIGNMENT
4539/*
4540 * When jumbo frames are enabled we should realign entire payload on
4541 * architecures with strict alignment. This is serious design mistake of 8254x
4542 * as it nullifies DMA operations. 8254x just allows RX buffer size to be
4543 * 2048/4096/8192/16384. What we really want is 2048 - ETHER_ALIGN to align its
4544 * payload. On architecures without strict alignment restrictions 8254x still
4545 * performs unaligned memory access which would reduce the performance too.
4546 * To avoid copying over an entire frame to align, we allocate a new mbuf and
4547 * copy ethernet header to the new mbuf. The new mbuf is prepended into the
4548 * existing mbuf chain.
4549 *
4550 * Be aware, best performance of the 8254x is achived only when jumbo frame is
4551 * not used at all on architectures with strict alignment.
4552 */
4553static int
4554em_fixup_rx(struct adapter *adapter)
4555{
4556        struct mbuf *m, *n;
4557        int error;
4558
4559        error = 0;
4560        m = adapter->fmp;
4561        if (m->m_len <= (MCLBYTES - ETHER_HDR_LEN)) {
4562                bcopy(m->m_data, m->m_data + ETHER_HDR_LEN, m->m_len);
4563                m->m_data += ETHER_HDR_LEN;
4564        } else {
4565                MGETHDR(n, M_DONTWAIT, MT_DATA);
4566                if (n != NULL) {
4567                        bcopy(m->m_data, n->m_data, ETHER_HDR_LEN);
4568                        m->m_data += ETHER_HDR_LEN;
4569                        m->m_len -= ETHER_HDR_LEN;
4570                        n->m_len = ETHER_HDR_LEN;
4571                        M_MOVE_PKTHDR(n, m);
4572                        n->m_next = m;
4573                        adapter->fmp = n;
4574                } else {
4575                        adapter->dropped_pkts++;
4576                        m_freem(adapter->fmp);
4577                        adapter->fmp = NULL;
4578                        error = ENOMEM;
4579                }
4580        }
4581
4582        return (error);
4583}
4584#endif
4585
4586#ifndef __rtems__
4587/*********************************************************************
4588 *
4589 *  Verify that the hardware indicated that the checksum is valid.
4590 *  Inform the stack about the status of checksum so that stack
4591 *  doesn't spend time verifying the checksum.
4592 *
4593 *********************************************************************/
4594static void
4595em_receive_checksum(struct adapter *adapter,
4596            struct e1000_rx_desc *rx_desc, struct mbuf *mp)
4597{
4598        /* 82543 or newer only */
4599        if ((adapter->hw.mac.type < e1000_82543) ||
4600            /* Ignore Checksum bit is set */
4601            (rx_desc->status & E1000_RXD_STAT_IXSM)) {
4602                mp->m_pkthdr.csum_flags = 0;
4603                return;
4604        }
4605
4606        if (rx_desc->status & E1000_RXD_STAT_IPCS) {
4607                /* Did it pass? */
4608                if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) {
4609                        /* IP Checksum Good */
4610                        mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
4611                        mp->m_pkthdr.csum_flags |= CSUM_IP_VALID;
4612
4613                } else {
4614                        mp->m_pkthdr.csum_flags = 0;
4615                }
4616        }
4617
4618        if (rx_desc->status & E1000_RXD_STAT_TCPCS) {
4619                /* Did it pass? */
4620                if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) {
4621                        mp->m_pkthdr.csum_flags |=
4622                        (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
4623                        mp->m_pkthdr.csum_data = htons(0xffff);
4624                }
4625        }
4626}
4627
4628
4629static void
4630em_enable_vlans(struct adapter *adapter)
4631{
4632        uint32_t ctrl;
4633
4634        E1000_WRITE_REG(&adapter->hw, E1000_VET, ETHERTYPE_VLAN);
4635
4636        ctrl = E1000_READ_REG(&adapter->hw, E1000_CTRL);
4637        ctrl |= E1000_CTRL_VME;
4638        E1000_WRITE_REG(&adapter->hw, E1000_CTRL, ctrl);
4639}
4640#endif
4641
4642static void
4643em_enable_intr(struct adapter *adapter)
4644{
4645        E1000_WRITE_REG(&adapter->hw, E1000_IMS,
4646            (IMS_ENABLE_MASK));
4647}
4648
4649static void
4650em_disable_intr(struct adapter *adapter)
4651{
4652        E1000_WRITE_REG(&adapter->hw, E1000_IMC, 0xffffffff);
4653}
4654
4655/*
4656 * Bit of a misnomer, what this really means is
4657 * to enable OS management of the system... aka
4658 * to disable special hardware management features
4659 */
4660static void
4661em_init_manageability(struct adapter *adapter)
4662{
4663        /* A shared code workaround */
4664#define E1000_82542_MANC2H E1000_MANC2H
4665        if (adapter->has_manage) {
4666                int manc2h = E1000_READ_REG(&adapter->hw, E1000_MANC2H);
4667                int manc = E1000_READ_REG(&adapter->hw, E1000_MANC);
4668
4669                /* disable hardware interception of ARP */
4670                manc &= ~(E1000_MANC_ARP_EN);
4671
4672                /* enable receiving management packets to the host */
4673                if (adapter->hw.mac.type >= e1000_82571) {
4674                        manc |= E1000_MANC_EN_MNG2HOST;
4675#define E1000_MNG2HOST_PORT_623 (1 << 5)
4676#define E1000_MNG2HOST_PORT_664 (1 << 6)
4677                        manc2h |= E1000_MNG2HOST_PORT_623;
4678                        manc2h |= E1000_MNG2HOST_PORT_664;
4679                        E1000_WRITE_REG(&adapter->hw, E1000_MANC2H, manc2h);
4680                }
4681
4682                E1000_WRITE_REG(&adapter->hw, E1000_MANC, manc);
4683        }
4684}
4685
4686/*
4687 * Give control back to hardware management
4688 * controller if there is one.
4689 */
4690static void
4691em_release_manageability(struct adapter *adapter)
4692{
4693        if (adapter->has_manage) {
4694                int manc = E1000_READ_REG(&adapter->hw, E1000_MANC);
4695
4696                /* re-enable hardware interception of ARP */
4697                manc |= E1000_MANC_ARP_EN;
4698
4699                if (adapter->hw.mac.type >= e1000_82571)
4700                        manc &= ~E1000_MANC_EN_MNG2HOST;
4701
4702                E1000_WRITE_REG(&adapter->hw, E1000_MANC, manc);
4703        }
4704}
4705
4706/*
4707 * em_get_hw_control sets {CTRL_EXT|FWSM}:DRV_LOAD bit.
4708 * For ASF and Pass Through versions of f/w this means that
4709 * the driver is loaded. For AMT version (only with 82573)
4710 * of the f/w this means that the network i/f is open.
4711 *
4712 */
4713static void
4714em_get_hw_control(struct adapter *adapter)
4715{
4716        u32 ctrl_ext, swsm;
4717
4718        /* Let firmware know the driver has taken over */
4719        switch (adapter->hw.mac.type) {
4720        case e1000_82573:
4721                swsm = E1000_READ_REG(&adapter->hw, E1000_SWSM);
4722                E1000_WRITE_REG(&adapter->hw, E1000_SWSM,
4723                    swsm | E1000_SWSM_DRV_LOAD);
4724                break;
4725        case e1000_82571:
4726        case e1000_82572:
4727        case e1000_80003es2lan:
4728        case e1000_ich8lan:
4729        case e1000_ich9lan:
4730                ctrl_ext = E1000_READ_REG(&adapter->hw, E1000_CTRL_EXT);
4731                E1000_WRITE_REG(&adapter->hw, E1000_CTRL_EXT,
4732                    ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
4733                break;
4734        default:
4735                break;
4736        }
4737}
4738
4739/*
4740 * em_release_hw_control resets {CTRL_EXT|FWSM}:DRV_LOAD bit.
4741 * For ASF and Pass Through versions of f/w this means that the
4742 * driver is no longer loaded. For AMT version (only with 82573) i
4743 * of the f/w this means that the network i/f is closed.
4744 *
4745 */
4746static void
4747em_release_hw_control(struct adapter *adapter)
4748{
4749        u32 ctrl_ext, swsm;
4750
4751        /* Let firmware taken over control of h/w */
4752        switch (adapter->hw.mac.type) {
4753        case e1000_82573:
4754                swsm = E1000_READ_REG(&adapter->hw, E1000_SWSM);
4755                E1000_WRITE_REG(&adapter->hw, E1000_SWSM,
4756                    swsm & ~E1000_SWSM_DRV_LOAD);
4757                break;
4758        case e1000_82571:
4759        case e1000_82572:
4760        case e1000_80003es2lan:
4761        case e1000_ich8lan:
4762        case e1000_ich9lan:
4763                ctrl_ext = E1000_READ_REG(&adapter->hw, E1000_CTRL_EXT);
4764                E1000_WRITE_REG(&adapter->hw, E1000_CTRL_EXT,
4765                    ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
4766                break;
4767        default:
4768                break;
4769
4770        }
4771}
4772
4773static int
4774em_is_valid_ether_addr(uint8_t *addr)
4775{
4776        char zero_addr[6] = { 0, 0, 0, 0, 0, 0 };
4777
4778        if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) {
4779                return (FALSE);
4780        }
4781
4782        return (TRUE);
4783}
4784
4785/*
4786 * NOTE: the following routines using the e1000
4787 *      naming style are provided to the shared
4788 *      code which expects that rather than 'em'
4789 */
4790
4791void
4792e1000_write_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
4793{
4794        pci_write_config(((struct e1000_osdep *)hw->back)->dev, reg, *value, 2);
4795}
4796
4797void
4798e1000_read_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
4799{
4800        *value = pci_read_config(((struct e1000_osdep *)hw->back)->dev, reg, 2);
4801}
4802
4803void
4804e1000_pci_set_mwi(struct e1000_hw *hw)
4805{
4806        pci_write_config(((struct e1000_osdep *)hw->back)->dev, PCIR_COMMAND,
4807            (hw->bus.pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2);
4808}
4809
4810void
4811e1000_pci_clear_mwi(struct e1000_hw *hw)
4812{
4813        pci_write_config(((struct e1000_osdep *)hw->back)->dev, PCIR_COMMAND,
4814            (hw->bus.pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2);
4815}
4816
4817/*
4818 * Read the PCI Express capabilities
4819 */
4820int32_t
4821e1000_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
4822{
4823        int32_t         error = E1000_SUCCESS;
4824        uint16_t        cap_off;
4825
4826        switch (hw->mac.type) {
4827
4828                case e1000_82571:
4829                case e1000_82572:
4830                case e1000_82573:
4831                case e1000_80003es2lan:
4832                        cap_off = 0xE0;
4833                        e1000_read_pci_cfg(hw, cap_off + reg, value);
4834                        break;
4835                default:
4836                        error = ~E1000_NOT_IMPLEMENTED;
4837                        break;
4838        }
4839
4840        return (error); 
4841}
4842
4843int32_t
4844e1000_alloc_zeroed_dev_spec_struct(struct e1000_hw *hw, uint32_t size)
4845{
4846        int32_t error = 0;
4847
4848        hw->dev_spec = malloc(size, M_DEVBUF, M_NOWAIT | M_ZERO);
4849        if (hw->dev_spec == NULL)
4850                error = ENOMEM;
4851#ifdef __rtems__
4852        /* M_ZERO not implemented :-( */
4853        if ( hw->dev_spec )
4854                memset(hw->dev_spec, 0, size);
4855#endif
4856
4857        return (error);
4858}
4859
4860void
4861e1000_free_dev_spec_struct(struct e1000_hw *hw)
4862{
4863        if (hw->dev_spec != NULL)
4864                free(hw->dev_spec, M_DEVBUF);
4865        return;
4866}
4867
4868/*
4869 * Enable PCI Wake On Lan capability
4870 */
4871void
4872em_enable_wakeup(device_t dev)
4873{
4874        u16     cap, status;
4875        u8      id;
4876
4877        /* First find the capabilities pointer*/
4878        cap = pci_read_config(dev, PCIR_CAP_PTR, 2);
4879        /* Read the PM Capabilities */
4880        id = pci_read_config(dev, cap, 1);
4881        if (id != PCIY_PMG)     /* Something wrong */
4882                return;
4883        /* OK, we have the power capabilities, so
4884           now get the status register */
4885        cap += PCIR_POWER_STATUS;
4886        status = pci_read_config(dev, cap, 2);
4887        status |= PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE;
4888        pci_write_config(dev, cap, status, 2);
4889        return;
4890}
4891
4892
4893/*********************************************************************
4894* 82544 Coexistence issue workaround.
4895*    There are 2 issues.
4896*       1. Transmit Hang issue.
4897*    To detect this issue, following equation can be used...
4898*         SIZE[3:0] + ADDR[2:0] = SUM[3:0].
4899*         If SUM[3:0] is in between 1 to 4, we will have this issue.
4900*
4901*       2. DAC issue.
4902*    To detect this issue, following equation can be used...
4903*         SIZE[3:0] + ADDR[2:0] = SUM[3:0].
4904*         If SUM[3:0] is in between 9 to c, we will have this issue.
4905*
4906*
4907*    WORKAROUND:
4908*         Make sure we do not have ending address
4909*         as 1,2,3,4(Hang) or 9,a,b,c (DAC)
4910*
4911*************************************************************************/
4912static uint32_t
4913em_fill_descriptors (bus_addr_t address, uint32_t length,
4914                PDESC_ARRAY desc_array)
4915{
4916        /* Since issue is sensitive to length and address.*/
4917        /* Let us first check the address...*/
4918        uint32_t safe_terminator;
4919        if (length <= 4) {
4920                desc_array->descriptor[0].address = address;
4921                desc_array->descriptor[0].length = length;
4922                desc_array->elements = 1;
4923                return (desc_array->elements);
4924        }
4925        safe_terminator = (uint32_t)((((uint32_t)address & 0x7) +
4926            (length & 0xF)) & 0xF);
4927        /* if it does not fall between 0x1 to 0x4 and 0x9 to 0xC then return */
4928        if (safe_terminator == 0   ||
4929        (safe_terminator > 4   &&
4930        safe_terminator < 9)   ||
4931        (safe_terminator > 0xC &&
4932        safe_terminator <= 0xF)) {
4933                desc_array->descriptor[0].address = address;
4934                desc_array->descriptor[0].length = length;
4935                desc_array->elements = 1;
4936                return (desc_array->elements);
4937        }
4938
4939        desc_array->descriptor[0].address = address;
4940        desc_array->descriptor[0].length = length - 4;
4941        desc_array->descriptor[1].address = address + (length - 4);
4942        desc_array->descriptor[1].length = 4;
4943        desc_array->elements = 2;
4944        return (desc_array->elements);
4945}
4946
4947/**********************************************************************
4948 *
4949 *  Update the board statistics counters.
4950 *
4951 **********************************************************************/
4952static void
4953em_update_stats_counters(struct adapter *adapter)
4954{
4955        struct ifnet   *ifp;
4956
4957        if(adapter->hw.media_type == e1000_media_type_copper ||
4958           (E1000_READ_REG(&adapter->hw, E1000_STATUS) & E1000_STATUS_LU)) {
4959                adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, E1000_SYMERRS);
4960                adapter->stats.sec += E1000_READ_REG(&adapter->hw, E1000_SEC);
4961        }
4962        adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, E1000_CRCERRS);
4963        adapter->stats.mpc += E1000_READ_REG(&adapter->hw, E1000_MPC);
4964        adapter->stats.scc += E1000_READ_REG(&adapter->hw, E1000_SCC);
4965        adapter->stats.ecol += E1000_READ_REG(&adapter->hw, E1000_ECOL);
4966
4967        adapter->stats.mcc += E1000_READ_REG(&adapter->hw, E1000_MCC);
4968        adapter->stats.latecol += E1000_READ_REG(&adapter->hw, E1000_LATECOL);
4969        adapter->stats.colc += E1000_READ_REG(&adapter->hw, E1000_COLC);
4970        adapter->stats.dc += E1000_READ_REG(&adapter->hw, E1000_DC);
4971        adapter->stats.rlec += E1000_READ_REG(&adapter->hw, E1000_RLEC);
4972        adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, E1000_XONRXC);
4973        adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, E1000_XONTXC);
4974        adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, E1000_XOFFRXC);
4975        adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, E1000_XOFFTXC);
4976        adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, E1000_FCRUC);
4977        adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, E1000_PRC64);
4978        adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, E1000_PRC127);
4979        adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, E1000_PRC255);
4980        adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, E1000_PRC511);
4981        adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, E1000_PRC1023);
4982        adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, E1000_PRC1522);
4983        adapter->stats.gprc += E1000_READ_REG(&adapter->hw, E1000_GPRC);
4984        adapter->stats.bprc += E1000_READ_REG(&adapter->hw, E1000_BPRC);
4985        adapter->stats.mprc += E1000_READ_REG(&adapter->hw, E1000_MPRC);
4986        adapter->stats.gptc += E1000_READ_REG(&adapter->hw, E1000_GPTC);
4987
4988        /* For the 64-bit byte counters the low dword must be read first. */
4989        /* Both registers clear on the read of the high dword */
4990
4991        adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, E1000_GORCL);
4992        adapter->stats.gorch += E1000_READ_REG(&adapter->hw, E1000_GORCH);
4993        adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, E1000_GOTCL);
4994        adapter->stats.gotch += E1000_READ_REG(&adapter->hw, E1000_GOTCH);
4995
4996        adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, E1000_RNBC);
4997        adapter->stats.ruc += E1000_READ_REG(&adapter->hw, E1000_RUC);
4998        adapter->stats.rfc += E1000_READ_REG(&adapter->hw, E1000_RFC);
4999        adapter->stats.roc += E1000_READ_REG(&adapter->hw, E1000_ROC);
5000        adapter->stats.rjc += E1000_READ_REG(&adapter->hw, E1000_RJC);
5001
5002        adapter->stats.torl += E1000_READ_REG(&adapter->hw, E1000_TORL);
5003        adapter->stats.torh += E1000_READ_REG(&adapter->hw, E1000_TORH);
5004        adapter->stats.totl += E1000_READ_REG(&adapter->hw, E1000_TOTL);
5005        adapter->stats.toth += E1000_READ_REG(&adapter->hw, E1000_TOTH);
5006
5007        adapter->stats.tpr += E1000_READ_REG(&adapter->hw, E1000_TPR);
5008        adapter->stats.tpt += E1000_READ_REG(&adapter->hw, E1000_TPT);
5009        adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, E1000_PTC64);
5010        adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, E1000_PTC127);
5011        adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, E1000_PTC255);
5012        adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, E1000_PTC511);
5013        adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, E1000_PTC1023);
5014        adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, E1000_PTC1522);
5015        adapter->stats.mptc += E1000_READ_REG(&adapter->hw, E1000_MPTC);
5016        adapter->stats.bptc += E1000_READ_REG(&adapter->hw, E1000_BPTC);
5017
5018        if (adapter->hw.mac.type >= e1000_82543) {
5019                adapter->stats.algnerrc += 
5020                E1000_READ_REG(&adapter->hw, E1000_ALGNERRC);
5021                adapter->stats.rxerrc += 
5022                E1000_READ_REG(&adapter->hw, E1000_RXERRC);
5023                adapter->stats.tncrs += 
5024                E1000_READ_REG(&adapter->hw, E1000_TNCRS);
5025                adapter->stats.cexterr += 
5026                E1000_READ_REG(&adapter->hw, E1000_CEXTERR);
5027                adapter->stats.tsctc += 
5028                E1000_READ_REG(&adapter->hw, E1000_TSCTC);
5029                adapter->stats.tsctfc += 
5030                E1000_READ_REG(&adapter->hw, E1000_TSCTFC);
5031        }
5032        ifp = adapter->ifp;
5033
5034        ifp->if_collisions = adapter->stats.colc;
5035
5036        /* Rx Errors */
5037        ifp->if_ierrors = adapter->dropped_pkts + adapter->stats.rxerrc +
5038            adapter->stats.crcerrs + adapter->stats.algnerrc +
5039            adapter->stats.ruc + adapter->stats.roc +
5040            adapter->stats.mpc + adapter->stats.cexterr;
5041
5042        /* Tx Errors */
5043        ifp->if_oerrors = adapter->stats.ecol +
5044            adapter->stats.latecol + adapter->watchdog_events;
5045}
5046
5047
5048/**********************************************************************
5049 *
5050 *  This routine is called only when em_display_debug_stats is enabled.
5051 *  This routine provides a way to take a look at important statistics
5052 *  maintained by the driver and hardware.
5053 *
5054 **********************************************************************/
5055#ifndef __rtems__
5056static void
5057#else
5058void
5059#endif
5060em_print_debug_info(struct adapter *adapter)
5061{
5062#ifndef __rtems__
5063        device_t dev = adapter->dev;
5064        uint8_t *hw_addr = adapter->hw.hw_addr;
5065#else
5066        device_t dev;
5067        uint8_t *hw_addr;
5068        if ( !adapter ) {
5069                printk("Need 'adapter' arg\n");
5070                return;
5071        }
5072        dev = adapter->dev;
5073        hw_addr = adapter->hw.hw_addr;
5074#endif
5075
5076        device_printf(dev, "Adapter hardware address = %p \n", hw_addr);
5077        device_printf(dev, "CTRL = 0x%x RCTL = 0x%x \n",
5078            E1000_READ_REG(&adapter->hw, E1000_CTRL),
5079            E1000_READ_REG(&adapter->hw, E1000_RCTL));
5080        device_printf(dev, "Packet buffer = Tx=%dk Rx=%dk \n",
5081            ((E1000_READ_REG(&adapter->hw, E1000_PBA) & 0xffff0000) >> 16),\
5082            (E1000_READ_REG(&adapter->hw, E1000_PBA) & 0xffff) );
5083        device_printf(dev, "Flow control watermarks high = %d low = %d\n",
5084            adapter->hw.mac.fc_high_water,
5085            adapter->hw.mac.fc_low_water);
5086        device_printf(dev, "tx_int_delay = %d, tx_abs_int_delay = %d\n",
5087            E1000_READ_REG(&adapter->hw, E1000_TIDV),
5088            E1000_READ_REG(&adapter->hw, E1000_TADV));
5089        device_printf(dev, "rx_int_delay = %d, rx_abs_int_delay = %d\n",
5090            E1000_READ_REG(&adapter->hw, E1000_RDTR),
5091            E1000_READ_REG(&adapter->hw, E1000_RADV));
5092        device_printf(dev, "fifo workaround = %lld, fifo_reset_count = %lld\n",
5093            (long long)adapter->tx_fifo_wrk_cnt,
5094            (long long)adapter->tx_fifo_reset_cnt);
5095        device_printf(dev, "hw tdh = %d, hw tdt = %d\n",
5096            E1000_READ_REG(&adapter->hw, E1000_TDH),
5097            E1000_READ_REG(&adapter->hw, E1000_TDT));
5098        device_printf(dev, "hw rdh = %d, hw rdt = %d\n",
5099            E1000_READ_REG(&adapter->hw, E1000_RDH),
5100            E1000_READ_REG(&adapter->hw, E1000_RDT));
5101        device_printf(dev, "Num Tx descriptors avail = %d\n",
5102            adapter->num_tx_desc_avail);
5103        device_printf(dev, "Tx Descriptors not avail1 = %ld\n",
5104            adapter->no_tx_desc_avail1);
5105        device_printf(dev, "Tx Descriptors not avail2 = %ld\n",
5106            adapter->no_tx_desc_avail2);
5107        device_printf(dev, "Std mbuf failed = %ld\n",
5108            adapter->mbuf_alloc_failed);
5109        device_printf(dev, "Std mbuf cluster failed = %ld\n",
5110            adapter->mbuf_cluster_failed);
5111        device_printf(dev, "Driver dropped packets = %ld\n",
5112            adapter->dropped_pkts);
5113        device_printf(dev, "Driver tx dma failure in encap = %ld\n",
5114                adapter->no_tx_dma_setup);
5115}
5116
5117#ifndef __rtems__
5118static void
5119#else
5120void
5121#endif
5122em_print_hw_stats(struct adapter *adapter)
5123{
5124        device_t dev = adapter->dev;
5125
5126        device_printf(dev, "Excessive collisions = %lld\n",
5127            (long long)adapter->stats.ecol);
5128#if     (DEBUG_HW > 0)  /* Dont output these errors normally */
5129        device_printf(dev, "Symbol errors = %lld\n",
5130            (long long)adapter->stats.symerrs);
5131#endif
5132        device_printf(dev, "Sequence errors = %lld\n",
5133            (long long)adapter->stats.sec);
5134        device_printf(dev, "Defer count = %lld\n",
5135            (long long)adapter->stats.dc);
5136        device_printf(dev, "Missed Packets = %lld\n",
5137            (long long)adapter->stats.mpc);
5138        device_printf(dev, "Receive No Buffers = %lld\n",
5139            (long long)adapter->stats.rnbc);
5140        /* RLEC is inaccurate on some hardware, calculate our own. */
5141        device_printf(dev, "Receive Length Errors = %lld\n",
5142            ((long long)adapter->stats.roc + (long long)adapter->stats.ruc));
5143        device_printf(dev, "Receive errors = %lld\n",
5144            (long long)adapter->stats.rxerrc);
5145        device_printf(dev, "Crc errors = %lld\n",
5146            (long long)adapter->stats.crcerrs);
5147        device_printf(dev, "Alignment errors = %lld\n",
5148            (long long)adapter->stats.algnerrc);
5149        device_printf(dev, "Carrier extension errors = %lld\n",
5150            (long long)adapter->stats.cexterr);
5151        device_printf(dev, "RX overruns = %ld\n", adapter->rx_overruns);
5152        device_printf(dev, "watchdog timeouts = %ld\n",
5153            adapter->watchdog_events);
5154        device_printf(dev, "XON Rcvd = %lld\n",
5155            (long long)adapter->stats.xonrxc);
5156        device_printf(dev, "XON Xmtd = %lld\n",
5157            (long long)adapter->stats.xontxc);
5158        device_printf(dev, "XOFF Rcvd = %lld\n",
5159            (long long)adapter->stats.xoffrxc);
5160        device_printf(dev, "XOFF Xmtd = %lld\n",
5161            (long long)adapter->stats.xofftxc);
5162        device_printf(dev, "Good Packets Rcvd = %lld\n",
5163            (long long)adapter->stats.gprc);
5164        device_printf(dev, "Good Packets Xmtd = %lld\n",
5165            (long long)adapter->stats.gptc);
5166        device_printf(dev, "TSO Contexts Xmtd = %lld\n",
5167            (long long)adapter->stats.tsctc);
5168        device_printf(dev, "TSO Contexts Failed = %lld\n",
5169            (long long)adapter->stats.tsctfc);
5170}
5171
5172#ifndef __rtems__
5173static int
5174em_sysctl_debug_info(SYSCTL_HANDLER_ARGS)
5175{
5176        struct adapter *adapter;
5177        int error;
5178        int result;
5179
5180        result = -1;
5181        error = sysctl_handle_int(oidp, &result, 0, req);
5182
5183        if (error || !req->newptr)
5184                return (error);
5185
5186        if (result == 1) {
5187                adapter = (struct adapter *)arg1;
5188                em_print_debug_info(adapter);
5189        }
5190
5191        return (error);
5192}
5193
5194
5195static int
5196em_sysctl_stats(SYSCTL_HANDLER_ARGS)
5197{
5198        struct adapter *adapter;
5199        int error;
5200        int result;
5201
5202        result = -1;
5203        error = sysctl_handle_int(oidp, &result, 0, req);
5204
5205        if (error || !req->newptr)
5206                return (error);
5207
5208        if (result == 1) {
5209                adapter = (struct adapter *)arg1;
5210                em_print_hw_stats(adapter);
5211        }
5212
5213        return (error);
5214}
5215
5216static int
5217em_sysctl_int_delay(SYSCTL_HANDLER_ARGS)
5218{
5219        struct em_int_delay_info *info;
5220        struct adapter *adapter;
5221        uint32_t regval;
5222        int error;
5223        int usecs;
5224        int ticks;
5225
5226        info = (struct em_int_delay_info *)arg1;
5227        usecs = info->value;
5228        error = sysctl_handle_int(oidp, &usecs, 0, req);
5229        if (error != 0 || req->newptr == NULL)
5230                return (error);
5231        if (usecs < 0 || usecs > EM_TICKS_TO_USECS(65535))
5232                return (EINVAL);
5233        info->value = usecs;
5234        ticks = EM_USECS_TO_TICKS(usecs);
5235
5236        adapter = info->adapter;
5237       
5238        EM_LOCK(adapter);
5239        regval = E1000_READ_OFFSET(&adapter->hw, info->offset);
5240        regval = (regval & ~0xffff) | (ticks & 0xffff);
5241        /* Handle a few special cases. */
5242        switch (info->offset) {
5243        case E1000_RDTR:
5244                break;
5245        case E1000_TIDV:
5246                if (ticks == 0) {
5247                        adapter->txd_cmd &= ~E1000_TXD_CMD_IDE;
5248                        /* Don't write 0 into the TIDV register. */
5249                        regval++;
5250                } else
5251                        if (adapter->hw.mac.type != e1000_82575)
5252                                adapter->txd_cmd |= E1000_TXD_CMD_IDE;
5253                break;
5254        }
5255        E1000_WRITE_OFFSET(&adapter->hw, info->offset, regval);
5256        EM_UNLOCK(adapter);
5257        return (0);
5258}
5259#endif
5260
5261static void
5262em_add_int_delay_sysctl(struct adapter *adapter, const char *name,
5263        const char *description, struct em_int_delay_info *info,
5264        int offset, int value)
5265{
5266        info->adapter = adapter;
5267        info->offset = offset;
5268        info->value = value;
5269        SYSCTL_ADD_PROC(device_get_sysctl_ctx(adapter->dev),
5270            SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
5271            OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW,
5272            info, 0, em_sysctl_int_delay, "I", description);
5273}
5274
5275#ifndef DEVICE_POLLING
5276static void
5277em_add_rx_process_limit(struct adapter *adapter, const char *name,
5278        const char *description, int *limit, int value)
5279{
5280        *limit = value;
5281        SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
5282            SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
5283            OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description);
5284}
5285#endif
Note: See TracBrowser for help on using the repository browser.