source: libbsdport/bsd_eth_drivers/if_em/if_em.c @ c877b08

Last change on this file since c877b08 was c877b08, checked in by Till Straumann <strauman@…>, on Apr 23, 2009 at 4:43:10 AM
  • removed 'bootverbose' -- now defined by libbsdport.
  • Property mode set to 100644
File size: 150.0 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        adapter->hw.hw_addr = (uint8_t*)&adapter->osdep.mem_bus_space_handle;
2665
2666        /* Only older adapters use IO mapping */
2667        if ((adapter->hw.mac.type >= e1000_82543) && /* __rtems__ >82542 -> >= 82543 */
2668            (adapter->hw.mac.type < e1000_82571)) {
2669                /* Figure our where our IO BAR is ? */
2670                for (rid = PCIR_BAR(0); rid < PCIR_CIS;) {
2671                        val = pci_read_config(dev, rid, 4);
2672                        if (EM_BAR_TYPE(val) == EM_BAR_TYPE_IO) {
2673                                adapter->io_rid = rid;
2674                                break;
2675                        }
2676                        rid += 4;
2677                        /* check for 64bit BAR */
2678                        if (EM_BAR_MEM_TYPE(val) == EM_BAR_MEM_TYPE_64BIT)
2679                                rid += 4;
2680                }
2681                if (rid >= PCIR_CIS) {
2682                        device_printf(dev, "Unable to locate IO BAR\n");
2683                        return (ENXIO);
2684                }
2685                adapter->res_ioport = bus_alloc_resource_any(dev,
2686                    SYS_RES_IOPORT, &adapter->io_rid, RF_ACTIVE);
2687                if (adapter->res_ioport == NULL) {
2688                        device_printf(dev, "Unable to allocate bus resource: "
2689                            "ioport\n");
2690                        return (ENXIO);
2691                }
2692                adapter->hw.io_base = 0;
2693                adapter->osdep.io_bus_space_tag =
2694                    rman_get_bustag(adapter->res_ioport);
2695                adapter->osdep.io_bus_space_handle =
2696                    rman_get_bushandle(adapter->res_ioport);
2697        }
2698
2699        /*
2700         * Setup MSI/X or MSI if PCI Express
2701         * only the latest can use MSI/X and
2702         * real support for it is forthcoming
2703         */
2704        adapter->msi = 0; /* Set defaults */
2705        rid = 0x0;
2706        if (adapter->hw.mac.type >= e1000_82575) {
2707                /*
2708                 * Setup MSI/X
2709                 */
2710                rid = PCIR_BAR(EM_MSIX_BAR);
2711                adapter->msix_mem = bus_alloc_resource_any(dev,
2712                    SYS_RES_MEMORY, &rid, RF_ACTIVE);
2713                if (!adapter->msix_mem) {
2714                        device_printf(dev,"Unable to map MSIX table \n");
2715                        return (ENXIO);
2716                }
2717                /*
2718                 * Eventually this may be used
2719                 * for Multiqueue, for now we will
2720                 * just use one vector.
2721                 *
2722                 * val = pci_msix_count(dev);
2723                 */
2724                val = 1;
2725                if ((val) && pci_alloc_msix(dev, &val) == 0) {
2726                        rid = 1;
2727                        adapter->msi = 1;
2728                }
2729        } else if (adapter->hw.mac.type > e1000_82571) {
2730                val = pci_msi_count(dev);
2731                if (val == 1 && pci_alloc_msi(dev, &val) == 0) {
2732                        rid = 1;
2733                        adapter->msi = 1;
2734                } 
2735        } 
2736        adapter->res_interrupt = bus_alloc_resource_any(dev,
2737            SYS_RES_IRQ, &rid, RF_SHAREABLE | RF_ACTIVE);
2738        if (adapter->res_interrupt == NULL) {
2739                device_printf(dev, "Unable to allocate bus resource: "
2740                    "interrupt\n");
2741                return (ENXIO);
2742        }
2743
2744        adapter->hw.back = &adapter->osdep;
2745
2746        return (0);
2747}
2748
2749/*********************************************************************
2750 *
2751 *  Setup the appropriate Interrupt handlers.
2752 *
2753 **********************************************************************/
2754int
2755em_allocate_intr(struct adapter *adapter)
2756{
2757        device_t dev = adapter->dev;
2758        int error;
2759
2760        /* Manually turn off all interrupts */
2761        E1000_WRITE_REG(&adapter->hw, E1000_IMC, 0xffffffff);
2762
2763#ifdef DEVICE_POLLING
2764        /* We do Legacy setup */
2765        if (adapter->int_handler_tag == NULL &&
2766            (error = bus_setup_intr(dev, adapter->res_interrupt,
2767            INTR_TYPE_NET | INTR_MPSAFE, NULL, em_intr, adapter,
2768            &adapter->int_handler_tag)) != 0) {
2769                device_printf(dev, "Failed to register interrupt handler");
2770                return (error);
2771        }
2772
2773#else
2774        /*
2775         * Try allocating a fast interrupt and the associated deferred
2776         * processing contexts.
2777         */
2778        TASK_INIT(&adapter->rxtx_task, 0, em_handle_rxtx, adapter);
2779        TASK_INIT(&adapter->link_task, 0, em_handle_link, adapter);
2780        adapter->tq = taskqueue_create_fast("em_taskq", M_NOWAIT,
2781            taskqueue_thread_enqueue, &adapter->tq);
2782        taskqueue_start_threads(&adapter->tq, 1, PI_NET, "%s taskq",
2783            device_get_nameunit(adapter->dev));
2784        if ((error = bus_setup_intr(dev, adapter->res_interrupt,
2785            INTR_TYPE_NET, em_intr_fast, NULL, adapter,
2786            &adapter->int_handler_tag)) != 0) {
2787                device_printf(dev, "Failed to register fast interrupt "
2788                            "handler: %d\n", error);
2789                taskqueue_free(adapter->tq);
2790                adapter->tq = NULL;
2791                return (error);
2792        }
2793#endif
2794
2795        em_enable_intr(adapter);
2796        return (0);
2797}
2798
2799static void
2800em_free_intr(struct adapter *adapter)
2801{
2802        device_t dev = adapter->dev;
2803
2804        if (adapter->res_interrupt != NULL) {
2805                bus_teardown_intr(dev, adapter->res_interrupt,
2806                        adapter->int_handler_tag);
2807                adapter->int_handler_tag = NULL;
2808        }
2809        if (adapter->tq != NULL) {
2810                taskqueue_drain(adapter->tq, &adapter->rxtx_task);
2811                taskqueue_drain(taskqueue_fast, &adapter->link_task);
2812                taskqueue_free(adapter->tq);
2813                adapter->tq = NULL;
2814        }
2815}
2816
2817static void
2818em_free_pci_resources(struct adapter *adapter)
2819{
2820        device_t dev = adapter->dev;
2821
2822        if (adapter->res_interrupt != NULL)
2823                bus_release_resource(dev, SYS_RES_IRQ,
2824                    adapter->msi ? 1 : 0, adapter->res_interrupt);
2825
2826        if (adapter->msix_mem != NULL)
2827                bus_release_resource(dev, SYS_RES_MEMORY,
2828                    PCIR_BAR(EM_MSIX_BAR), adapter->msix_mem);
2829
2830        if (adapter->msi)
2831                pci_release_msi(dev);
2832
2833        if (adapter->res_memory != NULL)
2834                bus_release_resource(dev, SYS_RES_MEMORY,
2835                    PCIR_BAR(0), adapter->res_memory);
2836
2837        if (adapter->flash_mem != NULL)
2838                bus_release_resource(dev, SYS_RES_MEMORY,
2839                    EM_FLASH, adapter->flash_mem);
2840
2841        if (adapter->res_ioport != NULL)
2842                bus_release_resource(dev, SYS_RES_IOPORT,
2843                    adapter->io_rid, adapter->res_ioport);
2844}
2845
2846/*********************************************************************
2847 *
2848 *  Initialize the hardware to a configuration
2849 *  as specified by the adapter structure.
2850 *
2851 **********************************************************************/
2852static int
2853em_hardware_init(struct adapter *adapter)
2854{
2855        device_t dev = adapter->dev;
2856        uint16_t rx_buffer_size;
2857
2858        INIT_DEBUGOUT("em_hardware_init: begin");
2859
2860        /* Issue a global reset */
2861        e1000_reset_hw(&adapter->hw);
2862
2863        /* Get control from any management/hw control */
2864        if (((adapter->hw.mac.type == e1000_82573) ||
2865            (adapter->hw.mac.type == e1000_ich8lan) ||
2866            (adapter->hw.mac.type == e1000_ich9lan)) &&
2867            e1000_check_mng_mode(&adapter->hw))
2868                em_get_hw_control(adapter);
2869
2870        /* When hardware is reset, fifo_head is also reset */
2871        adapter->tx_fifo_head = 0;
2872
2873        /* Set up smart power down as default off on newer adapters. */
2874        if (!em_smart_pwr_down && (adapter->hw.mac.type == e1000_82571 ||
2875            adapter->hw.mac.type == e1000_82572)) {
2876                uint16_t phy_tmp = 0;
2877
2878                /* Speed up time to link by disabling smart power down. */
2879                e1000_read_phy_reg(&adapter->hw,
2880                    IGP02E1000_PHY_POWER_MGMT, &phy_tmp);
2881                phy_tmp &= ~IGP02E1000_PM_SPD;
2882                e1000_write_phy_reg(&adapter->hw,
2883                    IGP02E1000_PHY_POWER_MGMT, phy_tmp);
2884        }
2885
2886        /*
2887         * These parameters control the automatic generation (Tx) and
2888         * response (Rx) to Ethernet PAUSE frames.
2889         * - High water mark should allow for at least two frames to be
2890         *   received after sending an XOFF.
2891         * - Low water mark works best when it is very near the high water mark.
2892         *   This allows the receiver to restart by sending XON when it has
2893         *   drained a bit. Here we use an arbitary value of 1500 which will
2894         *   restart after one full frame is pulled from the buffer. There
2895         *   could be several smaller frames in the buffer and if so they will
2896         *   not trigger the XON until their total number reduces the buffer
2897         *   by 1500.
2898         * - The pause time is fairly large at 1000 x 512ns = 512 usec.
2899         */
2900        rx_buffer_size = ((E1000_READ_REG(&adapter->hw, E1000_PBA) &
2901            0xffff) << 10 );
2902
2903        adapter->hw.mac.fc_high_water = rx_buffer_size -
2904            roundup2(adapter->hw.mac.max_frame_size, 1024);
2905        adapter->hw.mac.fc_low_water = adapter->hw.mac.fc_high_water - 1500;
2906        if (adapter->hw.mac.type == e1000_80003es2lan)
2907                adapter->hw.mac.fc_pause_time = 0xFFFF;
2908        else
2909                adapter->hw.mac.fc_pause_time = EM_FC_PAUSE_TIME;
2910        adapter->hw.mac.fc_send_xon = TRUE;
2911        adapter->hw.mac.fc = e1000_fc_full;
2912
2913        if (e1000_init_hw(&adapter->hw) < 0) {
2914                device_printf(dev, "Hardware Initialization Failed\n");
2915                return (EIO);
2916        }
2917
2918        e1000_check_for_link(&adapter->hw);
2919
2920        return (0);
2921}
2922
2923/*********************************************************************
2924 *
2925 *  Setup networking device structure and register an interface.
2926 *
2927 **********************************************************************/
2928static void
2929em_setup_interface(device_t dev, struct adapter *adapter)
2930{
2931        struct ifnet   *ifp;
2932
2933        INIT_DEBUGOUT("em_setup_interface: begin");
2934
2935        ifp = adapter->ifp = if_alloc(IFT_ETHER);
2936        if (ifp == NULL)
2937                panic("%s: can not if_alloc()", device_get_nameunit(dev));
2938        if_initname(ifp, device_get_name(dev), device_get_unit(dev));
2939
2940        ifp->if_mtu = ETHERMTU;
2941        ifp->if_init =  em_init;
2942        ifp->if_softc = adapter;
2943        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
2944        ifp->if_ioctl = em_ioctl;
2945        ifp->if_start = em_start;
2946        IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 1);
2947        ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 1;
2948        IFQ_SET_READY(&ifp->if_snd);
2949
2950        ether_ifattach(ifp, adapter->hw.mac.addr);
2951
2952#ifndef __rtems__
2953        ifp->if_capabilities = ifp->if_capenable = 0;
2954
2955        if (adapter->hw.mac.type >= e1000_82543) {
2956                ifp->if_capabilities |= IFCAP_HWCSUM | IFCAP_VLAN_HWCSUM;
2957                ifp->if_capenable |= IFCAP_HWCSUM | IFCAP_VLAN_HWCSUM;
2958        }
2959
2960        /* Identify TSO capable adapters */
2961        if ((adapter->hw.mac.type > e1000_82544) &&
2962            (adapter->hw.mac.type != e1000_82547))
2963                ifp->if_capabilities |= IFCAP_TSO4;
2964        /*
2965         * By default only enable on PCI-E, this
2966         * can be overriden by ifconfig.
2967         */
2968        if (adapter->hw.mac.type >= e1000_82571)
2969                ifp->if_capenable |= IFCAP_TSO4;
2970
2971        /*
2972         * Tell the upper layer(s) we support long frames.
2973         */
2974        ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
2975        ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
2976        ifp->if_capenable |= IFCAP_VLAN_MTU;
2977
2978#ifdef DEVICE_POLLING
2979        ifp->if_capabilities |= IFCAP_POLLING;
2980#endif
2981#endif
2982
2983        /*
2984         * Specify the media types supported by this adapter and register
2985         * callbacks to update media and link information
2986         */
2987        ifmedia_init(&adapter->media, IFM_IMASK,
2988            em_media_change, em_media_status);
2989        if ((adapter->hw.media_type == e1000_media_type_fiber) ||
2990            (adapter->hw.media_type == e1000_media_type_internal_serdes)) {
2991                u_char fiber_type = IFM_1000_SX;        /* default type */
2992
2993                if (adapter->hw.mac.type == e1000_82545)
2994                        fiber_type = IFM_1000_LX;
2995                ifmedia_add(&adapter->media, IFM_ETHER | fiber_type | IFM_FDX, 
2996                            0, NULL);
2997                ifmedia_add(&adapter->media, IFM_ETHER | fiber_type, 0, NULL);
2998        } else {
2999                ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL);
3000                ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX,
3001                            0, NULL);
3002                ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX,
3003                            0, NULL);
3004                ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX,
3005                            0, NULL);
3006                if (adapter->hw.phy.type != e1000_phy_ife) {
3007                        ifmedia_add(&adapter->media,
3008                                IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL);
3009                        ifmedia_add(&adapter->media,
3010                                IFM_ETHER | IFM_1000_T, 0, NULL);
3011                }
3012        }
3013        ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
3014        ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO);
3015}
3016
3017
3018/*********************************************************************
3019 *
3020 *  Workaround for SmartSpeed on 82541 and 82547 controllers
3021 *
3022 **********************************************************************/
3023static void
3024em_smartspeed(struct adapter *adapter)
3025{
3026        uint16_t phy_tmp;
3027
3028        if (adapter->link_active || (adapter->hw.phy.type != e1000_phy_igp) ||
3029            adapter->hw.mac.autoneg == 0 ||
3030            (adapter->hw.phy.autoneg_advertised & ADVERTISE_1000_FULL) == 0)
3031                return;
3032
3033        if (adapter->smartspeed == 0) {
3034                /* If Master/Slave config fault is asserted twice,
3035                 * we assume back-to-back */
3036                e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
3037                if (!(phy_tmp & SR_1000T_MS_CONFIG_FAULT))
3038                        return;
3039                e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
3040                if (phy_tmp & SR_1000T_MS_CONFIG_FAULT) {
3041                        e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp);
3042                        if(phy_tmp & CR_1000T_MS_ENABLE) {
3043                                phy_tmp &= ~CR_1000T_MS_ENABLE;
3044                                e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL,
3045                                    phy_tmp);
3046                                adapter->smartspeed++;
3047                                if(adapter->hw.mac.autoneg &&
3048                                   !e1000_phy_setup_autoneg(&adapter->hw) &&
3049                                   !e1000_read_phy_reg(&adapter->hw, PHY_CONTROL,
3050                                    &phy_tmp)) {
3051                                        phy_tmp |= (MII_CR_AUTO_NEG_EN |
3052                                                    MII_CR_RESTART_AUTO_NEG);
3053                                        e1000_write_phy_reg(&adapter->hw, PHY_CONTROL,
3054                                            phy_tmp);
3055                                }
3056                        }
3057                }
3058                return;
3059        } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) {
3060                /* If still no link, perhaps using 2/3 pair cable */
3061                e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp);
3062                phy_tmp |= CR_1000T_MS_ENABLE;
3063                e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp);
3064                if(adapter->hw.mac.autoneg &&
3065                   !e1000_phy_setup_autoneg(&adapter->hw) &&
3066                   !e1000_read_phy_reg(&adapter->hw, PHY_CONTROL, &phy_tmp)) {
3067                        phy_tmp |= (MII_CR_AUTO_NEG_EN |
3068                                    MII_CR_RESTART_AUTO_NEG);
3069                        e1000_write_phy_reg(&adapter->hw, PHY_CONTROL, phy_tmp);
3070                }
3071        }
3072        /* Restart process after EM_SMARTSPEED_MAX iterations */
3073        if(adapter->smartspeed++ == EM_SMARTSPEED_MAX)
3074                adapter->smartspeed = 0;
3075}
3076
3077
3078/*
3079 * Manage DMA'able memory.
3080 */
3081static void
3082em_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
3083{
3084        if (error)
3085                return;
3086        *(bus_addr_t *) arg = segs[0].ds_addr;
3087}
3088
3089static int
3090em_dma_malloc(struct adapter *adapter, bus_size_t size,
3091        struct em_dma_alloc *dma, int mapflags)
3092{
3093        int error;
3094
3095        error = bus_dma_tag_create(bus_get_dma_tag(adapter->dev), /* parent */
3096                                EM_DBA_ALIGN, 0,        /* alignment, bounds */
3097                                BUS_SPACE_MAXADDR,      /* lowaddr */
3098                                BUS_SPACE_MAXADDR,      /* highaddr */
3099                                NULL, NULL,             /* filter, filterarg */
3100                                size,                   /* maxsize */
3101                                1,                      /* nsegments */
3102                                size,                   /* maxsegsize */
3103                                0,                      /* flags */
3104                                NULL,                   /* lockfunc */
3105                                NULL,                   /* lockarg */
3106                                &dma->dma_tag);
3107        if (error) {
3108                device_printf(adapter->dev,
3109                    "%s: bus_dma_tag_create failed: %d\n",
3110                    __func__, error);
3111                goto fail_0;
3112        }
3113
3114        error = bus_dmamem_alloc(dma->dma_tag, (void**) &dma->dma_vaddr,
3115            BUS_DMA_NOWAIT, &dma->dma_map);
3116        if (error) {
3117                device_printf(adapter->dev,
3118                    "%s: bus_dmamem_alloc(%ju) failed: %d\n",
3119                    __func__, (uintmax_t)size, error);
3120                goto fail_2;
3121        }
3122
3123        dma->dma_paddr = 0;
3124        error = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr,
3125            size, em_dmamap_cb, &dma->dma_paddr, mapflags | BUS_DMA_NOWAIT);
3126        if (error || dma->dma_paddr == 0) {
3127                device_printf(adapter->dev,
3128                    "%s: bus_dmamap_load failed: %d\n",
3129                    __func__, error);
3130                goto fail_3;
3131        }
3132
3133        return (0);
3134
3135fail_3:
3136        bus_dmamap_unload(dma->dma_tag, dma->dma_map);
3137fail_2:
3138        bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
3139        bus_dma_tag_destroy(dma->dma_tag);
3140fail_0:
3141        dma->dma_map = NULL;
3142        dma->dma_tag = NULL;
3143
3144        return (error);
3145}
3146
3147static void
3148em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma)
3149{
3150        if (dma->dma_tag == NULL)
3151                return;
3152        if (dma->dma_map != NULL) {
3153                bus_dmamap_sync(dma->dma_tag, dma->dma_map,
3154                    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
3155                bus_dmamap_unload(dma->dma_tag, dma->dma_map);
3156                bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
3157                dma->dma_map = NULL;
3158        }
3159        bus_dma_tag_destroy(dma->dma_tag);
3160        dma->dma_tag = NULL;
3161}
3162
3163
3164/*********************************************************************
3165 *
3166 *  Allocate memory for tx_buffer structures. The tx_buffer stores all
3167 *  the information needed to transmit a packet on the wire.
3168 *
3169 **********************************************************************/
3170
3171#ifdef __rtems__
3172#define M_ZERO 0
3173#endif
3174
3175static int
3176em_allocate_transmit_structures(struct adapter *adapter)
3177{
3178        device_t dev = adapter->dev;
3179
3180        adapter->tx_buffer_area = malloc(sizeof(struct em_buffer) *
3181            adapter->num_tx_desc, M_DEVBUF, M_NOWAIT | M_ZERO);
3182        if (adapter->tx_buffer_area == NULL) {
3183                device_printf(dev, "Unable to allocate tx_buffer memory\n");
3184                return (ENOMEM);
3185        }
3186
3187        bzero(adapter->tx_buffer_area,
3188            (sizeof(struct em_buffer)) * adapter->num_tx_desc);
3189
3190        return (0);
3191}
3192
3193/*********************************************************************
3194 *
3195 *  Initialize transmit structures.
3196 *
3197 **********************************************************************/
3198static int
3199em_setup_transmit_structures(struct adapter *adapter)
3200{
3201        device_t dev = adapter->dev;
3202        struct em_buffer *tx_buffer;
3203        int error, i;
3204
3205        /*
3206         * Create DMA tags for tx descriptors
3207         */
3208        if ((error = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
3209                                1, 0,                   /* alignment, bounds */
3210                                BUS_SPACE_MAXADDR,      /* lowaddr */
3211                                BUS_SPACE_MAXADDR,      /* highaddr */
3212                                NULL, NULL,             /* filter, filterarg */
3213                                EM_TSO_SIZE,            /* maxsize */
3214                                EM_MAX_SCATTER,         /* nsegments */
3215                                EM_TSO_SEG_SIZE,        /* maxsegsize */
3216                                0,                      /* flags */
3217                                NULL,           /* lockfunc */
3218                                NULL,           /* lockarg */
3219                                &adapter->txtag)) != 0) {
3220                device_printf(dev, "Unable to allocate TX DMA tag\n");
3221                goto fail;
3222        }
3223
3224        if ((error = em_allocate_transmit_structures(adapter)) != 0)
3225                goto fail;
3226
3227        /* Clear the old ring contents */
3228        bzero(adapter->tx_desc_base,
3229            (sizeof(struct e1000_tx_desc)) * adapter->num_tx_desc);
3230
3231        /* Create the descriptor buffer dma maps */
3232        tx_buffer = adapter->tx_buffer_area;
3233        for (i = 0; i < adapter->num_tx_desc; i++) {
3234                error = bus_dmamap_create(adapter->txtag, 0, &tx_buffer->map);
3235                if (error != 0) {
3236                        device_printf(dev, "Unable to create TX DMA map\n");
3237                        goto fail;
3238                }
3239                tx_buffer->next_eop = -1;
3240                tx_buffer++;
3241        }
3242
3243        adapter->next_avail_tx_desc = 0;
3244        adapter->next_tx_to_clean = 0;
3245
3246        /* Set number of descriptors available */
3247        adapter->num_tx_desc_avail = adapter->num_tx_desc;
3248
3249        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
3250            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
3251
3252        return (0);
3253
3254fail:
3255        em_free_transmit_structures(adapter);
3256        return (error);
3257}
3258
3259/*********************************************************************
3260 *
3261 *  Enable transmit unit.
3262 *
3263 **********************************************************************/
3264static void
3265em_initialize_transmit_unit(struct adapter *adapter)
3266{
3267        uint32_t        tctl, tarc, tipg = 0;
3268        uint64_t        bus_addr;
3269
3270         INIT_DEBUGOUT("em_initialize_transmit_unit: begin");
3271        /* Setup the Base and Length of the Tx Descriptor Ring */
3272        bus_addr = adapter->txdma.dma_paddr;
3273        E1000_WRITE_REG(&adapter->hw, E1000_TDLEN,
3274            adapter->num_tx_desc * sizeof(struct e1000_tx_desc));
3275        E1000_WRITE_REG(&adapter->hw, E1000_TDBAH, (uint32_t)(bus_addr >> 32));
3276        E1000_WRITE_REG(&adapter->hw, E1000_TDBAL, (uint32_t)bus_addr);
3277
3278        /* Setup the HW Tx Head and Tail descriptor pointers */
3279        E1000_WRITE_REG(&adapter->hw, E1000_TDT, 0);
3280        E1000_WRITE_REG(&adapter->hw, E1000_TDH, 0);
3281
3282        HW_DEBUGOUT2("Base = %x, Length = %x\n",
3283            E1000_READ_REG(&adapter->hw, E1000_TDBAL),
3284            E1000_READ_REG(&adapter->hw, E1000_TDLEN));
3285
3286        /* Set the default values for the Tx Inter Packet Gap timer */
3287        switch (adapter->hw.mac.type) {
3288#if !defined(NO_82542_SUPPORT) /* __rtems__ */
3289        case e1000_82542:
3290                tipg = DEFAULT_82542_TIPG_IPGT;
3291                tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
3292                tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
3293                break;
3294#endif
3295        case e1000_80003es2lan:
3296                tipg = DEFAULT_82543_TIPG_IPGR1;
3297                tipg |= DEFAULT_80003ES2LAN_TIPG_IPGR2 <<
3298                    E1000_TIPG_IPGR2_SHIFT;
3299                break;
3300        default:
3301                if ((adapter->hw.media_type == e1000_media_type_fiber) ||
3302                    (adapter->hw.media_type ==
3303                    e1000_media_type_internal_serdes))
3304                        tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
3305                else
3306                        tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
3307                tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
3308                tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
3309        }
3310
3311        E1000_WRITE_REG(&adapter->hw, E1000_TIPG, tipg);
3312        E1000_WRITE_REG(&adapter->hw, E1000_TIDV, adapter->tx_int_delay.value);
3313        if(adapter->hw.mac.type >= e1000_82540)
3314                E1000_WRITE_REG(&adapter->hw, E1000_TADV,
3315                    adapter->tx_abs_int_delay.value);
3316
3317        if ((adapter->hw.mac.type == e1000_82571) ||
3318            (adapter->hw.mac.type == e1000_82572)) {
3319                tarc = E1000_READ_REG(&adapter->hw, E1000_TARC0);
3320                tarc |= SPEED_MODE_BIT;
3321                E1000_WRITE_REG(&adapter->hw, E1000_TARC0, tarc);
3322        } else if (adapter->hw.mac.type == e1000_80003es2lan) {
3323                tarc = E1000_READ_REG(&adapter->hw, E1000_TARC0);
3324                tarc |= 1;
3325                E1000_WRITE_REG(&adapter->hw, E1000_TARC0, tarc);
3326                tarc = E1000_READ_REG(&adapter->hw, E1000_TARC1);
3327                tarc |= 1;
3328                E1000_WRITE_REG(&adapter->hw, E1000_TARC1, tarc);
3329        }
3330
3331        /* Program the Transmit Control Register */
3332        tctl = E1000_READ_REG(&adapter->hw, E1000_TCTL);
3333        tctl &= ~E1000_TCTL_CT;
3334        tctl |= (E1000_TCTL_PSP | E1000_TCTL_RTLC | E1000_TCTL_EN |
3335                   (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT));
3336
3337        if (adapter->hw.mac.type >= e1000_82571)
3338                tctl |= E1000_TCTL_MULR;
3339
3340        /* This write will effectively turn on the transmit unit. */
3341        E1000_WRITE_REG(&adapter->hw, E1000_TCTL, tctl);
3342
3343        /* Setup Transmit Descriptor Base Settings */   
3344        adapter->txd_cmd = E1000_TXD_CMD_IFCS;
3345
3346        if ((adapter->tx_int_delay.value > 0) &&
3347            (adapter->hw.mac.type != e1000_82575))
3348                adapter->txd_cmd |= E1000_TXD_CMD_IDE;
3349
3350        /* Set the function pointer for the transmit routine */
3351        if (adapter->hw.mac.type >= e1000_82575)
3352                adapter->em_xmit = em_adv_encap;
3353        else
3354                adapter->em_xmit = em_encap;
3355}
3356
3357/*********************************************************************
3358 *
3359 *  Free all transmit related data structures.
3360 *
3361 **********************************************************************/
3362static void
3363em_free_transmit_structures(struct adapter *adapter)
3364{
3365        struct em_buffer *tx_buffer;
3366        int i;
3367
3368        INIT_DEBUGOUT("free_transmit_structures: begin");
3369
3370        if (adapter->tx_buffer_area != NULL) {
3371                tx_buffer = adapter->tx_buffer_area;
3372                for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
3373                        if (tx_buffer->m_head != NULL) {
3374                                bus_dmamap_sync(adapter->txtag, tx_buffer->map,
3375                                    BUS_DMASYNC_POSTWRITE);
3376                                bus_dmamap_unload(adapter->txtag,
3377                                    tx_buffer->map);
3378                                m_freem(tx_buffer->m_head);
3379                                tx_buffer->m_head = NULL;
3380                        } else if (tx_buffer->map != NULL)
3381                                bus_dmamap_unload(adapter->txtag,
3382                                    tx_buffer->map);
3383                        if (tx_buffer->map != NULL) {
3384                                bus_dmamap_destroy(adapter->txtag,
3385                                    tx_buffer->map);
3386                                tx_buffer->map = NULL;
3387                        }
3388                }
3389        }
3390        if (adapter->tx_buffer_area != NULL) {
3391                free(adapter->tx_buffer_area, M_DEVBUF);
3392                adapter->tx_buffer_area = NULL;
3393        }
3394        if (adapter->txtag != NULL) {
3395                bus_dma_tag_destroy(adapter->txtag);
3396                adapter->txtag = NULL;
3397        }
3398}
3399
3400#ifndef __rtems__
3401/*********************************************************************
3402 *
3403 *  The offload context needs to be set when we transfer the first
3404 *  packet of a particular protocol (TCP/UDP). This routine has been
3405 *  enhanced to deal with inserted VLAN headers, and IPV6 (not complete)
3406 *
3407 **********************************************************************/
3408static void
3409em_transmit_checksum_setup(struct adapter *adapter, struct mbuf *mp,
3410    uint32_t *txd_upper, uint32_t *txd_lower)
3411{
3412        struct e1000_context_desc *TXD;
3413        struct em_buffer *tx_buffer;
3414        struct ether_vlan_header *eh;
3415        struct ip *ip;
3416        struct ip6_hdr *ip6;
3417        struct tcp_hdr *th;
3418        int curr_txd, ehdrlen, hdr_len, ip_hlen;
3419        uint32_t cmd = 0;
3420        uint16_t etype;
3421        uint8_t ipproto;
3422
3423        /* Setup checksum offload context. */
3424        curr_txd = adapter->next_avail_tx_desc;
3425        tx_buffer = &adapter->tx_buffer_area[curr_txd];
3426        TXD = (struct e1000_context_desc *) &adapter->tx_desc_base[curr_txd];
3427
3428        *txd_lower = E1000_TXD_CMD_DEXT |       /* Extended descr type */
3429                     E1000_TXD_DTYP_D;          /* Data descr */
3430
3431        /*
3432         * Determine where frame payload starts.
3433         * Jump over vlan headers if already present,
3434         * helpful for QinQ too.
3435         */
3436        eh = mtod(mp, struct ether_vlan_header *);
3437        if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
3438                etype = ntohs(eh->evl_proto);
3439                ehdrlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
3440        } else {
3441                etype = ntohs(eh->evl_encap_proto);
3442                ehdrlen = ETHER_HDR_LEN;
3443        }
3444
3445        /*
3446         * We only support TCP/UDP for IPv4 and IPv6 for the moment.
3447         * TODO: Support SCTP too when it hits the tree.
3448         */
3449        switch (etype) {
3450        case ETHERTYPE_IP:
3451                ip = (struct ip *)(mp->m_data + ehdrlen);
3452                ip_hlen = ip->ip_hl << 2;
3453
3454                /* Setup of IP header checksum. */
3455                if (mp->m_pkthdr.csum_flags & CSUM_IP) {
3456                        /*
3457                         * Start offset for header checksum calculation.
3458                         * End offset for header checksum calculation.
3459                         * Offset of place to put the checksum.
3460                         */
3461                        TXD->lower_setup.ip_fields.ipcss = ehdrlen;
3462                        TXD->lower_setup.ip_fields.ipcse =
3463                            htole16(ehdrlen + ip_hlen);
3464                        TXD->lower_setup.ip_fields.ipcso =
3465                            ehdrlen + offsetof(struct ip, ip_sum);
3466                        cmd |= E1000_TXD_CMD_IP;
3467                        *txd_upper |= E1000_TXD_POPTS_IXSM << 8;
3468                }
3469
3470                if (mp->m_len < ehdrlen + ip_hlen)
3471                        return; /* failure */
3472
3473                hdr_len = ehdrlen + ip_hlen;
3474                ipproto = ip->ip_p;
3475
3476                break;
3477        case ETHERTYPE_IPV6:
3478                ip6 = (struct ip6_hdr *)(mp->m_data + ehdrlen);
3479                ip_hlen = sizeof(struct ip6_hdr); /* XXX: No header stacking. */
3480
3481                if (mp->m_len < ehdrlen + ip_hlen)
3482                        return; /* failure */
3483
3484                /* IPv6 doesn't have a header checksum. */
3485
3486                hdr_len = ehdrlen + ip_hlen;
3487                ipproto = ip6->ip6_nxt;
3488
3489                break;
3490        default:
3491                *txd_upper = 0;
3492                *txd_lower = 0;
3493                return;
3494        }
3495
3496        switch (ipproto) {
3497        case IPPROTO_TCP:
3498                if (mp->m_pkthdr.csum_flags & CSUM_TCP) {
3499                        /*
3500                         * Start offset for payload checksum calculation.
3501                         * End offset for payload checksum calculation.
3502                         * Offset of place to put the checksum.
3503                         */
3504                        th = (struct tcp_hdr *)(mp->m_data + hdr_len);
3505                        TXD->upper_setup.tcp_fields.tucss = hdr_len;
3506                        TXD->upper_setup.tcp_fields.tucse = htole16(0);
3507                        TXD->upper_setup.tcp_fields.tucso =
3508                            hdr_len + offsetof(struct tcphdr, th_sum);
3509                        cmd |= E1000_TXD_CMD_TCP;
3510                        *txd_upper |= E1000_TXD_POPTS_TXSM << 8;
3511                }
3512                break;
3513        case IPPROTO_UDP:
3514                if (mp->m_pkthdr.csum_flags & CSUM_UDP) {
3515                        /*
3516                         * Start offset for header checksum calculation.
3517                         * End offset for header checksum calculation.
3518                         * Offset of place to put the checksum.
3519                         */
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 udphdr, uh_sum);
3524                        *txd_upper |= E1000_TXD_POPTS_TXSM << 8;
3525                }
3526                break;
3527        default:
3528                break;
3529        }
3530
3531        TXD->tcp_seg_setup.data = htole32(0);
3532        TXD->cmd_and_length =
3533            htole32(adapter->txd_cmd | E1000_TXD_CMD_DEXT | cmd);
3534        tx_buffer->m_head = NULL;
3535        tx_buffer->next_eop = -1;
3536
3537        if (++curr_txd == adapter->num_tx_desc)
3538                curr_txd = 0;
3539
3540        adapter->num_tx_desc_avail--;
3541        adapter->next_avail_tx_desc = curr_txd;
3542}
3543
3544/**********************************************************************
3545 *
3546 *  Setup work for hardware segmentation offload (TSO)
3547 *
3548 **********************************************************************/
3549static boolean_t
3550em_tso_setup(struct adapter *adapter, struct mbuf *mp, uint32_t *txd_upper,
3551   uint32_t *txd_lower)
3552{
3553        struct e1000_context_desc *TXD;
3554        struct em_buffer *tx_buffer;
3555        struct ether_vlan_header *eh;
3556        struct ip *ip;
3557        struct ip6_hdr *ip6;
3558        struct tcphdr *th;
3559        int curr_txd, ehdrlen, hdr_len, ip_hlen, isip6;
3560        uint16_t etype;
3561
3562        /*
3563         * XXX: This is not really correct as the stack would not have
3564         * set up all checksums.
3565         * XXX: Return FALSE is not sufficient as we may have to return
3566         * in true failure cases as well.  Should do -1 (failure), 0 (no)
3567         * and 1 (success).
3568         */
3569        if (((mp->m_pkthdr.csum_flags & CSUM_TSO) == 0) ||
3570             (mp->m_pkthdr.len <= EM_TX_BUFFER_SIZE))
3571                return FALSE;
3572
3573        /*
3574         * This function could/should be extended to support IP/IPv6
3575         * fragmentation as well.  But as they say, one step at a time.
3576         */
3577
3578        /*
3579         * Determine where frame payload starts.
3580         * Jump over vlan headers if already present,
3581         * helpful for QinQ too.
3582         */
3583        eh = mtod(mp, struct ether_vlan_header *);
3584        if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
3585                etype = ntohs(eh->evl_proto);
3586                ehdrlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
3587        } else {
3588                etype = ntohs(eh->evl_encap_proto);
3589                ehdrlen = ETHER_HDR_LEN;
3590        }
3591
3592        /* Ensure we have at least the IP+TCP header in the first mbuf. */
3593        if (mp->m_len < ehdrlen + sizeof(struct ip) + sizeof(struct tcphdr))
3594                return FALSE;   /* -1 */
3595
3596        /*
3597         * We only support TCP for IPv4 and IPv6 (notyet) for the moment.
3598         * TODO: Support SCTP too when it hits the tree.
3599         */
3600        switch (etype) {
3601        case ETHERTYPE_IP:
3602                isip6 = 0;
3603                ip = (struct ip *)(mp->m_data + ehdrlen);
3604                if (ip->ip_p != IPPROTO_TCP)
3605                        return FALSE;   /* 0 */
3606                ip->ip_len = 0;
3607                ip->ip_sum = 0;
3608                ip_hlen = ip->ip_hl << 2;
3609                if (mp->m_len < ehdrlen + ip_hlen + sizeof(struct tcphdr))
3610                        return FALSE;   /* -1 */
3611                th = (struct tcphdr *)((caddr_t)ip + ip_hlen);
3612#if 1
3613                th->th_sum = in_pseudo(ip->ip_src.s_addr,
3614                    ip->ip_dst.s_addr, htons(IPPROTO_TCP));
3615#else
3616                th->th_sum = mp->m_pkthdr.csum_data;
3617#endif
3618                break;
3619        case ETHERTYPE_IPV6:
3620                isip6 = 1;
3621                return FALSE;                   /* Not supported yet. */
3622                ip6 = (struct ip6_hdr *)(mp->m_data + ehdrlen);
3623                if (ip6->ip6_nxt != IPPROTO_TCP)
3624                        return FALSE;   /* 0 */
3625                ip6->ip6_plen = 0;
3626                ip_hlen = sizeof(struct ip6_hdr); /* XXX: no header stacking. */
3627                if (mp->m_len < ehdrlen + ip_hlen + sizeof(struct tcphdr))
3628                        return FALSE;   /* -1 */
3629                th = (struct tcphdr *)((caddr_t)ip6 + ip_hlen);
3630#if 0
3631                th->th_sum = in6_pseudo(ip6->ip6_src, ip->ip6_dst,
3632                    htons(IPPROTO_TCP));        /* XXX: function notyet. */
3633#else
3634                th->th_sum = mp->m_pkthdr.csum_data;
3635#endif
3636                break;
3637        default:
3638                return FALSE;
3639        }
3640        hdr_len = ehdrlen + ip_hlen + (th->th_off << 2);
3641
3642        *txd_lower = (E1000_TXD_CMD_DEXT |      /* Extended descr type */
3643                      E1000_TXD_DTYP_D |        /* Data descr type */
3644                      E1000_TXD_CMD_TSE);       /* Do TSE on this packet */
3645
3646        /* IP and/or TCP header checksum calculation and insertion. */
3647        *txd_upper = ((isip6 ? 0 : E1000_TXD_POPTS_IXSM) |
3648                      E1000_TXD_POPTS_TXSM) << 8;
3649
3650        curr_txd = adapter->next_avail_tx_desc;
3651        tx_buffer = &adapter->tx_buffer_area[curr_txd];
3652        TXD = (struct e1000_context_desc *) &adapter->tx_desc_base[curr_txd];
3653
3654        /* IPv6 doesn't have a header checksum. */
3655        if (!isip6) {
3656                /*
3657                 * Start offset for header checksum calculation.
3658                 * End offset for header checksum calculation.
3659                 * Offset of place put the checksum.
3660                 */
3661                TXD->lower_setup.ip_fields.ipcss = ehdrlen;
3662                TXD->lower_setup.ip_fields.ipcse =
3663                    htole16(ehdrlen + ip_hlen - 1);
3664                TXD->lower_setup.ip_fields.ipcso =
3665                    ehdrlen + offsetof(struct ip, ip_sum);
3666        }
3667        /*
3668         * Start offset for payload checksum calculation.
3669         * End offset for payload checksum calculation.
3670         * Offset of place to put the checksum.
3671         */
3672        TXD->upper_setup.tcp_fields.tucss =
3673            ehdrlen + ip_hlen;
3674        TXD->upper_setup.tcp_fields.tucse = 0;
3675        TXD->upper_setup.tcp_fields.tucso =
3676            ehdrlen + ip_hlen + offsetof(struct tcphdr, th_sum);
3677        /*
3678         * Payload size per packet w/o any headers.
3679         * Length of all headers up to payload.
3680         */
3681        TXD->tcp_seg_setup.fields.mss = htole16(mp->m_pkthdr.tso_segsz);
3682        TXD->tcp_seg_setup.fields.hdr_len = hdr_len;
3683
3684        TXD->cmd_and_length = htole32(adapter->txd_cmd |
3685                                E1000_TXD_CMD_DEXT |    /* Extended descr */
3686                                E1000_TXD_CMD_TSE |     /* TSE context */
3687                                (isip6 ? 0 : E1000_TXD_CMD_IP) | /* Do IP csum */
3688                                E1000_TXD_CMD_TCP |     /* Do TCP checksum */
3689                                (mp->m_pkthdr.len - (hdr_len))); /* Total len */
3690
3691        tx_buffer->m_head = NULL;
3692        tx_buffer->next_eop = -1;
3693
3694        if (++curr_txd == adapter->num_tx_desc)
3695                curr_txd = 0;
3696
3697        adapter->num_tx_desc_avail--;
3698        adapter->next_avail_tx_desc = curr_txd;
3699        adapter->tx_tso = TRUE;
3700
3701        return TRUE;
3702}
3703
3704
3705/**********************************************************************
3706 *
3707 *  Setup work for hardware segmentation offload (TSO) on
3708 *  adapters using advanced tx descriptors
3709 *
3710 **********************************************************************/
3711static boolean_t
3712em_tso_adv_setup(struct adapter *adapter, struct mbuf *mp, u32 *paylen)
3713{
3714        struct e1000_adv_tx_context_desc *TXD;
3715        struct em_buffer        *tx_buffer;
3716        u32 vlan_macip_lens = 0, type_tucmd_mlhl = 0;
3717        u32 mss_l4len_idx = 0;
3718        u16 vtag = 0;
3719        int ctxd, ehdrlen, hdrlen, ip_hlen, tcp_hlen;
3720        struct ether_vlan_header *eh;
3721        struct ip *ip;
3722        struct tcphdr *th;
3723
3724        if (((mp->m_pkthdr.csum_flags & CSUM_TSO) == 0) ||
3725             (mp->m_pkthdr.len <= EM_TX_BUFFER_SIZE))
3726                return FALSE;
3727
3728        /*
3729         * Determine where frame payload starts.
3730         * Jump over vlan headers if already present
3731         */
3732        eh = mtod(mp, struct ether_vlan_header *);
3733        if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN))
3734                ehdrlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
3735        else
3736                ehdrlen = ETHER_HDR_LEN;
3737
3738        /* Ensure we have at least the IP+TCP header in the first mbuf. */
3739        if (mp->m_len < ehdrlen + sizeof(struct ip) + sizeof(struct tcphdr))
3740                return FALSE;
3741
3742        /* Only supports IPV4 for now */
3743        ctxd = adapter->next_avail_tx_desc;
3744        tx_buffer = &adapter->tx_buffer_area[ctxd];
3745        TXD = (struct e1000_adv_tx_context_desc *) &adapter->tx_desc_base[ctxd];
3746
3747        ip = (struct ip *)(mp->m_data + ehdrlen);
3748        if (ip->ip_p != IPPROTO_TCP)
3749                return FALSE;   /* 0 */
3750        ip->ip_len = 0;
3751        ip->ip_sum = 0;
3752        ip_hlen = ip->ip_hl << 2;
3753        th = (struct tcphdr *)((caddr_t)ip + ip_hlen);
3754        th->th_sum = in_pseudo(ip->ip_src.s_addr,
3755            ip->ip_dst.s_addr, htons(IPPROTO_TCP));
3756        tcp_hlen = th->th_off << 2;
3757        hdrlen = ehdrlen + ip_hlen + tcp_hlen;
3758        /* Calculate payload, this is used in the transmit desc in encap */
3759        *paylen = mp->m_pkthdr.len - hdrlen;
3760
3761#ifndef __rtems__
3762        /* VLAN MACLEN IPLEN */
3763        if (mp->m_flags & M_VLANTAG) {
3764                vtag = htole16(mp->m_pkthdr.ether_vtag);
3765                vlan_macip_lens |= (vtag << E1000_ADVTXD_VLAN_SHIFT);
3766        }
3767#endif
3768        vlan_macip_lens |= (ehdrlen << E1000_ADVTXD_MACLEN_SHIFT);
3769        vlan_macip_lens |= ip_hlen;
3770        TXD->vlan_macip_lens |= htole32(vlan_macip_lens);
3771
3772        /* ADV DTYPE TUCMD */
3773        type_tucmd_mlhl |= E1000_ADVTXD_DCMD_DEXT | E1000_ADVTXD_DTYP_CTXT;
3774        type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_L4T_TCP;
3775        type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_IPV4;
3776        TXD->type_tucmd_mlhl |= htole32(type_tucmd_mlhl);
3777
3778        /* MSS L4LEN IDX */
3779        mss_l4len_idx |= (mp->m_pkthdr.tso_segsz << E1000_ADVTXD_MSS_SHIFT);
3780        mss_l4len_idx |= (tcp_hlen << E1000_ADVTXD_L4LEN_SHIFT);
3781        TXD->mss_l4len_idx = htole32(mss_l4len_idx);
3782
3783        TXD->seqnum_seed = htole32(0);
3784        tx_buffer->m_head = NULL;
3785        tx_buffer->next_eop = -1;
3786
3787        if (++ctxd == adapter->num_tx_desc)
3788                ctxd = 0;
3789
3790        adapter->num_tx_desc_avail--;
3791        adapter->next_avail_tx_desc = ctxd;
3792        return TRUE;
3793}
3794
3795
3796/*********************************************************************
3797 *
3798 *  Advanced Context Descriptor setup for VLAN or CSUM
3799 *
3800 **********************************************************************/
3801
3802static boolean_t
3803em_tx_adv_ctx_setup(struct adapter *adapter, struct mbuf *mp)
3804{
3805        struct e1000_adv_tx_context_desc *TXD;
3806        struct em_buffer        *tx_buffer;
3807        uint32_t vlan_macip_lens = 0, type_tucmd_mlhl = 0;
3808        struct ether_vlan_header *eh;
3809        struct ip *ip;
3810        struct ip6_hdr *ip6;
3811        int  ehdrlen, ip_hlen;
3812        u16     etype;
3813        u8      ipproto;
3814
3815        int ctxd = adapter->next_avail_tx_desc;
3816        u16 vtag = 0;
3817
3818        tx_buffer = &adapter->tx_buffer_area[ctxd];
3819        TXD = (struct e1000_adv_tx_context_desc *) &adapter->tx_desc_base[ctxd];
3820
3821        /*
3822        ** In advanced descriptors the vlan tag must
3823        ** be placed into the descriptor itself.
3824        */
3825        if (mp->m_flags & M_VLANTAG) {
3826                vtag = htole16(mp->m_pkthdr.ether_vtag);
3827                vlan_macip_lens |= (vtag << E1000_ADVTXD_VLAN_SHIFT);
3828        }
3829
3830        /*
3831         * Determine where frame payload starts.
3832         * Jump over vlan headers if already present,
3833         * helpful for QinQ too.
3834         */
3835        eh = mtod(mp, struct ether_vlan_header *);
3836        if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
3837                etype = ntohs(eh->evl_proto);
3838                ehdrlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
3839        } else {
3840                etype = ntohs(eh->evl_encap_proto);
3841                ehdrlen = ETHER_HDR_LEN;
3842        }
3843
3844        /* Set the ether header length */
3845        vlan_macip_lens |= ehdrlen << E1000_ADVTXD_MACLEN_SHIFT;
3846
3847        switch (etype) {
3848                case ETHERTYPE_IP:
3849                        ip = (struct ip *)(mp->m_data + ehdrlen);
3850                        ip_hlen = ip->ip_hl << 2;
3851                        if (mp->m_len < ehdrlen + ip_hlen)
3852                                return FALSE; /* failure */
3853                        ipproto = ip->ip_p;
3854                        type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_IPV4;
3855                        break;
3856                case ETHERTYPE_IPV6:
3857                        ip6 = (struct ip6_hdr *)(mp->m_data + ehdrlen);
3858                        ip_hlen = sizeof(struct ip6_hdr);
3859                        if (mp->m_len < ehdrlen + ip_hlen)
3860                                return FALSE; /* failure */
3861                        ipproto = ip6->ip6_nxt;
3862                        type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_IPV6;
3863                        break;
3864                default:
3865                        return FALSE;
3866        }
3867
3868        vlan_macip_lens |= ip_hlen;
3869        type_tucmd_mlhl |= E1000_ADVTXD_DCMD_DEXT | E1000_ADVTXD_DTYP_CTXT;
3870
3871        switch (ipproto) {
3872                case IPPROTO_TCP:
3873                        if (mp->m_pkthdr.csum_flags & CSUM_TCP)
3874                                type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_L4T_TCP;
3875                        break;
3876                case IPPROTO_UDP:
3877                        if (mp->m_pkthdr.csum_flags & CSUM_UDP)
3878                                type_tucmd_mlhl |= E1000_ADVTXD_TUCMD_L4T_TCP;
3879                        break;
3880        }
3881
3882        /* Now copy bits into descriptor */
3883        TXD->vlan_macip_lens |= htole32(vlan_macip_lens);
3884        TXD->type_tucmd_mlhl |= htole32(type_tucmd_mlhl);
3885        TXD->seqnum_seed = htole32(0);
3886        TXD->mss_l4len_idx = htole32(0);
3887
3888        tx_buffer->m_head = NULL;
3889        tx_buffer->next_eop = -1;
3890
3891        /* We've consumed the first desc, adjust counters */
3892        if (++ctxd == adapter->num_tx_desc)
3893                ctxd = 0;
3894        adapter->next_avail_tx_desc = ctxd;
3895        --adapter->num_tx_desc_avail;
3896
3897        return TRUE;
3898}
3899#endif
3900
3901
3902/**********************************************************************
3903 *
3904 *  Examine each tx_buffer in the used queue. If the hardware is done
3905 *  processing the packet then free associated resources. The
3906 *  tx_buffer is put back on the free queue.
3907 *
3908 **********************************************************************/
3909static void
3910em_txeof(struct adapter *adapter)
3911{
3912        int first, last, done, num_avail;
3913        struct em_buffer *tx_buffer;
3914        struct e1000_tx_desc   *tx_desc, *eop_desc;
3915        struct ifnet   *ifp = adapter->ifp;
3916
3917        EM_LOCK_ASSERT(adapter);
3918
3919        if (adapter->num_tx_desc_avail == adapter->num_tx_desc)
3920                return;
3921
3922        num_avail = adapter->num_tx_desc_avail;
3923        first = adapter->next_tx_to_clean;
3924        tx_desc = &adapter->tx_desc_base[first];
3925        tx_buffer = &adapter->tx_buffer_area[first];
3926        last = tx_buffer->next_eop;
3927        eop_desc = &adapter->tx_desc_base[last];
3928
3929        /*
3930         * What this does is get the index of the
3931         * first descriptor AFTER the EOP of the
3932         * first packet, that way we can do the
3933         * simple comparison on the inner while loop.
3934         */
3935        if (++last == adapter->num_tx_desc)
3936                last = 0;
3937        done = last;
3938
3939        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
3940            BUS_DMASYNC_POSTREAD);
3941
3942        while (eop_desc->upper.fields.status & E1000_TXD_STAT_DD) {
3943                /* We clean the range of the packet */
3944                while (first != done) {
3945                        tx_desc->upper.data = 0;
3946                        tx_desc->lower.data = 0;
3947                        tx_desc->buffer_addr = 0;
3948                        num_avail++;
3949
3950                        if (tx_buffer->m_head) {
3951                                ifp->if_opackets++;
3952                                bus_dmamap_sync(adapter->txtag,
3953                                    tx_buffer->map,
3954                                    BUS_DMASYNC_POSTWRITE);
3955                                bus_dmamap_unload(adapter->txtag,
3956                                    tx_buffer->map);
3957
3958                                m_freem(tx_buffer->m_head);
3959                                tx_buffer->m_head = NULL;
3960                        }
3961                        tx_buffer->next_eop = -1;
3962
3963                        if (++first == adapter->num_tx_desc)
3964                                first = 0;
3965
3966                        tx_buffer = &adapter->tx_buffer_area[first];
3967                        tx_desc = &adapter->tx_desc_base[first];
3968                }
3969                /* See if we can continue to the next packet */
3970                last = tx_buffer->next_eop;
3971                if (last != -1) {
3972                        eop_desc = &adapter->tx_desc_base[last];
3973                        /* Get new done point */
3974                        if (++last == adapter->num_tx_desc) last = 0;
3975                        done = last;
3976                } else
3977                        break;
3978        }
3979        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
3980            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
3981
3982        adapter->next_tx_to_clean = first;
3983
3984        /*
3985         * If we have enough room, clear IFF_DRV_OACTIVE to tell the stack
3986         * that it is OK to send packets.
3987         * If there are no pending descriptors, clear the timeout. Otherwise,
3988         * if some descriptors have been freed, restart the timeout.
3989         */
3990        if (num_avail > EM_TX_CLEANUP_THRESHOLD) {               
3991                ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
3992                /* All clean, turn off the timer */
3993                if (num_avail == adapter->num_tx_desc)
3994                        adapter->watchdog_timer = 0;
3995                /* Some cleaned, reset the timer */
3996                else if (num_avail != adapter->num_tx_desc_avail)
3997                        adapter->watchdog_timer = EM_TX_TIMEOUT;
3998        }
3999        adapter->num_tx_desc_avail = num_avail;
4000        return;
4001}
4002
4003/*********************************************************************
4004 *
4005 *  Get a buffer from system mbuf buffer pool.
4006 *
4007 **********************************************************************/
4008static int
4009em_get_buf(struct adapter *adapter, int i)
4010{
4011        struct mbuf             *m;
4012        bus_dma_segment_t       segs[1];
4013        bus_dmamap_t            map;
4014        struct em_buffer        *rx_buffer;
4015        int                     error, nsegs;
4016
4017        m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
4018        if (m == NULL) {
4019                adapter->mbuf_cluster_failed++;
4020                return (ENOBUFS);
4021        }
4022        m->m_len = m->m_pkthdr.len = MCLBYTES;
4023
4024        if (adapter->hw.mac.max_frame_size <= (MCLBYTES - ETHER_ALIGN))
4025                m_adj(m, ETHER_ALIGN);
4026
4027        /*
4028         * Using memory from the mbuf cluster pool, invoke the
4029         * bus_dma machinery to arrange the memory mapping.
4030         */
4031        error = bus_dmamap_load_mbuf_sg(adapter->rxtag,
4032            adapter->rx_sparemap, m, segs, &nsegs, BUS_DMA_NOWAIT);
4033        if (error != 0) {
4034                m_free(m);
4035                return (error);
4036        }
4037
4038        /* If nsegs is wrong then the stack is corrupt. */
4039        KASSERT(nsegs == 1, ("Too many segments returned!"));
4040
4041        rx_buffer = &adapter->rx_buffer_area[i];
4042        if (rx_buffer->m_head != NULL)
4043                bus_dmamap_unload(adapter->rxtag, rx_buffer->map);
4044
4045        map = rx_buffer->map;
4046        rx_buffer->map = adapter->rx_sparemap;
4047        adapter->rx_sparemap = map;
4048        bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD);
4049        rx_buffer->m_head = m;
4050
4051        adapter->rx_desc_base[i].buffer_addr = htole64(segs[0].ds_addr);
4052        return (0);
4053}
4054
4055/*********************************************************************
4056 *
4057 *  Allocate memory for rx_buffer structures. Since we use one
4058 *  rx_buffer per received packet, the maximum number of rx_buffer's
4059 *  that we'll need is equal to the number of receive descriptors
4060 *  that we've allocated.
4061 *
4062 **********************************************************************/
4063static int
4064em_allocate_receive_structures(struct adapter *adapter)
4065{
4066        device_t dev = adapter->dev;
4067        struct em_buffer *rx_buffer;
4068        int i, error;
4069
4070        adapter->rx_buffer_area = malloc(sizeof(struct em_buffer) *
4071            adapter->num_rx_desc, M_DEVBUF, M_NOWAIT);
4072        if (adapter->rx_buffer_area == NULL) {
4073                device_printf(dev, "Unable to allocate rx_buffer memory\n");
4074                return (ENOMEM);
4075        }
4076
4077        bzero(adapter->rx_buffer_area,
4078            sizeof(struct em_buffer) * adapter->num_rx_desc);
4079
4080        error = bus_dma_tag_create(bus_get_dma_tag(dev),        /* parent */
4081                                1, 0,                   /* alignment, bounds */
4082                                BUS_SPACE_MAXADDR,      /* lowaddr */
4083                                BUS_SPACE_MAXADDR,      /* highaddr */
4084                                NULL, NULL,             /* filter, filterarg */
4085                                MCLBYTES,               /* maxsize */
4086                                1,                      /* nsegments */
4087                                MCLBYTES,               /* maxsegsize */
4088                                0,                      /* flags */
4089                                NULL,                   /* lockfunc */
4090                                NULL,                   /* lockarg */
4091                                &adapter->rxtag);
4092        if (error) {
4093                device_printf(dev, "%s: bus_dma_tag_create failed %d\n",
4094                    __func__, error);
4095                goto fail;
4096        }
4097
4098        /* Create the spare map (used by getbuf) */
4099        error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT,
4100             &adapter->rx_sparemap);
4101        if (error) {
4102                device_printf(dev, "%s: bus_dmamap_create failed: %d\n",
4103                    __func__, error);
4104                goto fail;
4105        }
4106
4107        rx_buffer = adapter->rx_buffer_area;
4108        for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
4109                error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT,
4110                    &rx_buffer->map);
4111                if (error) {
4112                        device_printf(dev, "%s: bus_dmamap_create failed: %d\n",
4113                            __func__, error);
4114                        goto fail;
4115                }
4116        }
4117
4118        /* Setup the initial buffers */
4119        for (i = 0; i < adapter->num_rx_desc; i++) {
4120                error = em_get_buf(adapter, i);
4121                if (error)
4122                        goto fail;
4123        }
4124        bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
4125            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
4126
4127        return (0);
4128
4129fail:
4130        em_free_receive_structures(adapter);
4131        return (error);
4132}
4133
4134/*********************************************************************
4135 *
4136 *  Allocate and initialize receive structures.
4137 *
4138 **********************************************************************/
4139static int
4140em_setup_receive_structures(struct adapter *adapter)
4141{
4142        int error;
4143
4144        bzero(adapter->rx_desc_base,
4145            (sizeof(struct e1000_rx_desc)) * adapter->num_rx_desc);
4146
4147        if ((error = em_allocate_receive_structures(adapter)) !=0)
4148                return (error);
4149
4150        /* Setup our descriptor pointers */
4151        adapter->next_rx_desc_to_check = 0;
4152
4153        return (0);
4154}
4155
4156/*********************************************************************
4157 *
4158 *  Enable receive unit.
4159 *
4160 **********************************************************************/
4161static void
4162em_initialize_receive_unit(struct adapter *adapter)
4163{
4164        struct ifnet    *ifp = adapter->ifp;
4165        uint64_t        bus_addr;
4166        uint32_t        reg_rctl;
4167#ifndef __rtems__
4168        uint32_t        reg_rxcsum;
4169#endif
4170
4171        INIT_DEBUGOUT("em_initialize_receive_unit: begin");
4172
4173        /*
4174         * Make sure receives are disabled while setting
4175         * up the descriptor ring
4176         */
4177        reg_rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
4178        E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl & ~E1000_RCTL_EN);
4179
4180        if(adapter->hw.mac.type >= e1000_82540) {
4181                E1000_WRITE_REG(&adapter->hw, E1000_RADV,
4182                    adapter->rx_abs_int_delay.value);
4183                /*
4184                 * Set the interrupt throttling rate. Value is calculated
4185                 * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns)
4186                 */
4187#define MAX_INTS_PER_SEC        8000
4188#define DEFAULT_ITR          1000000000/(MAX_INTS_PER_SEC * 256)
4189                E1000_WRITE_REG(&adapter->hw, E1000_ITR, DEFAULT_ITR);
4190        }
4191
4192        /* Setup the Base and Length of the Rx Descriptor Ring */
4193        bus_addr = adapter->rxdma.dma_paddr;
4194        E1000_WRITE_REG(&adapter->hw, E1000_RDLEN, adapter->num_rx_desc *
4195                        sizeof(struct e1000_rx_desc));
4196        E1000_WRITE_REG(&adapter->hw, E1000_RDBAH, (uint32_t)(bus_addr >> 32));
4197        E1000_WRITE_REG(&adapter->hw, E1000_RDBAL, (uint32_t)bus_addr);
4198
4199        /* Setup the Receive Control Register */
4200        reg_rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
4201        reg_rctl |= E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
4202                   E1000_RCTL_RDMTS_HALF |
4203                   (adapter->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
4204
4205        if (e1000_tbi_sbp_enabled_82543(&adapter->hw))
4206                reg_rctl |= E1000_RCTL_SBP;
4207        else
4208                reg_rctl &= ~E1000_RCTL_SBP;
4209
4210        switch (adapter->rx_buffer_len) {
4211        default:
4212        case 2048:
4213                reg_rctl |= E1000_RCTL_SZ_2048;
4214                break;
4215        case 4096:
4216                reg_rctl |= E1000_RCTL_SZ_4096 |
4217                    E1000_RCTL_BSEX | E1000_RCTL_LPE;
4218                break;
4219        case 8192:
4220                reg_rctl |= E1000_RCTL_SZ_8192 |
4221                    E1000_RCTL_BSEX | E1000_RCTL_LPE;
4222                break;
4223        case 16384:
4224                reg_rctl |= E1000_RCTL_SZ_16384 |
4225                    E1000_RCTL_BSEX | E1000_RCTL_LPE;
4226                break;
4227        }
4228
4229        if (ifp->if_mtu > ETHERMTU)
4230                reg_rctl |= E1000_RCTL_LPE;
4231        else
4232                reg_rctl &= ~E1000_RCTL_LPE;
4233
4234#ifndef __rtems__
4235        /* Enable 82543 Receive Checksum Offload for TCP and UDP */
4236        if ((adapter->hw.mac.type >= e1000_82543) &&
4237            (ifp->if_capenable & IFCAP_RXCSUM)) {
4238                reg_rxcsum = E1000_READ_REG(&adapter->hw, E1000_RXCSUM);
4239                reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL);
4240                E1000_WRITE_REG(&adapter->hw, E1000_RXCSUM, reg_rxcsum);
4241        }
4242#endif
4243
4244        /*
4245        ** XXX TEMPORARY WORKAROUND: on some systems with 82573
4246        ** long latencies are observed, like Lenovo X60. This
4247        ** change eliminates the problem, but since having positive
4248        ** values in RDTR is a known source of problems on other
4249        ** platforms another solution is being sought.
4250        */
4251        if (adapter->hw.mac.type == e1000_82573)
4252                E1000_WRITE_REG(&adapter->hw, E1000_RDTR, 0x20);
4253
4254        /* Enable Receives */
4255        E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl);
4256
4257        /*
4258         * Setup the HW Rx Head and
4259         * Tail Descriptor Pointers
4260         */
4261        E1000_WRITE_REG(&adapter->hw, E1000_RDH, 0);
4262        E1000_WRITE_REG(&adapter->hw, E1000_RDT, adapter->num_rx_desc - 1);
4263
4264        return;
4265}
4266
4267/*********************************************************************
4268 *
4269 *  Free receive related data structures.
4270 *
4271 **********************************************************************/
4272static void
4273em_free_receive_structures(struct adapter *adapter)
4274{
4275        struct em_buffer *rx_buffer;
4276        int i;
4277
4278        INIT_DEBUGOUT("free_receive_structures: begin");
4279
4280        if (adapter->rx_sparemap) {
4281                bus_dmamap_destroy(adapter->rxtag, adapter->rx_sparemap);
4282                adapter->rx_sparemap = NULL;
4283        }
4284
4285        /* Cleanup any existing buffers */
4286        if (adapter->rx_buffer_area != NULL) {
4287                rx_buffer = adapter->rx_buffer_area;
4288                for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
4289                        if (rx_buffer->m_head != NULL) {
4290                                bus_dmamap_sync(adapter->rxtag, rx_buffer->map,
4291                                    BUS_DMASYNC_POSTREAD);
4292                                bus_dmamap_unload(adapter->rxtag,
4293                                    rx_buffer->map);
4294                                m_freem(rx_buffer->m_head);
4295                                rx_buffer->m_head = NULL;
4296                        } else if (rx_buffer->map != NULL)
4297                                bus_dmamap_unload(adapter->rxtag,
4298                                    rx_buffer->map);
4299                        if (rx_buffer->map != NULL) {
4300                                bus_dmamap_destroy(adapter->rxtag,
4301                                    rx_buffer->map);
4302                                rx_buffer->map = NULL;
4303                        }
4304                }
4305        }
4306
4307        if (adapter->rx_buffer_area != NULL) {
4308                free(adapter->rx_buffer_area, M_DEVBUF);
4309                adapter->rx_buffer_area = NULL;
4310        }
4311
4312        if (adapter->rxtag != NULL) {
4313                bus_dma_tag_destroy(adapter->rxtag);
4314                adapter->rxtag = NULL;
4315        }
4316}
4317
4318/*********************************************************************
4319 *
4320 *  This routine executes in interrupt context. It replenishes
4321 *  the mbufs in the descriptor and sends data which has been
4322 *  dma'ed into host memory to upper layer.
4323 *
4324 *  We loop at most count times if count is > 0, or until done if
4325 *  count < 0.
4326 *
4327 *********************************************************************/
4328static int
4329em_rxeof(struct adapter *adapter, int count)
4330{
4331        struct ifnet    *ifp;
4332        struct mbuf     *mp;
4333        uint8_t         accept_frame = 0;
4334        uint8_t         eop = 0;
4335        uint16_t        len, desc_len, prev_len_adj;
4336        int             i;
4337
4338        /* Pointer to the receive descriptor being examined. */
4339        struct e1000_rx_desc   *current_desc;
4340        uint8_t         status;
4341
4342        ifp = adapter->ifp;
4343        i = adapter->next_rx_desc_to_check;
4344        current_desc = &adapter->rx_desc_base[i];
4345        bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
4346            BUS_DMASYNC_POSTREAD);
4347
4348        if (!((current_desc->status) & E1000_RXD_STAT_DD))
4349                return (0);
4350
4351        while ((current_desc->status & E1000_RXD_STAT_DD) &&
4352            (count != 0) &&
4353            (ifp->if_drv_flags & IFF_DRV_RUNNING)) {
4354                struct mbuf *m = NULL;
4355
4356                mp = adapter->rx_buffer_area[i].m_head;
4357                /*
4358                 * Can't defer bus_dmamap_sync(9) because TBI_ACCEPT
4359                 * needs to access the last received byte in the mbuf.
4360                 */
4361                bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map,
4362                    BUS_DMASYNC_POSTREAD);
4363
4364                accept_frame = 1;
4365                prev_len_adj = 0;
4366                desc_len = le16toh(current_desc->length);
4367                status = current_desc->status;
4368                if (status & E1000_RXD_STAT_EOP) {
4369                        count--;
4370                        eop = 1;
4371                        if (desc_len < ETHER_CRC_LEN) {
4372                                len = 0;
4373                                prev_len_adj = ETHER_CRC_LEN - desc_len;
4374                        } else
4375                                len = desc_len - ETHER_CRC_LEN;
4376                } else {
4377                        eop = 0;
4378                        len = desc_len;
4379                }
4380
4381                if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
4382                        uint8_t         last_byte;
4383                        uint32_t        pkt_len = desc_len;
4384
4385                        if (adapter->fmp != NULL)
4386                                pkt_len += adapter->fmp->m_pkthdr.len;
4387
4388                        last_byte = *(mtod(mp, caddr_t) + desc_len - 1);                       
4389                        if (TBI_ACCEPT(&adapter->hw, status,
4390                            current_desc->errors, pkt_len, last_byte)) {
4391                                e1000_tbi_adjust_stats_82543(&adapter->hw,
4392                                    &adapter->stats, pkt_len,
4393                                    adapter->hw.mac.addr);
4394                                if (len > 0)
4395                                        len--;
4396                        } else
4397                                accept_frame = 0;
4398                }
4399
4400                if (accept_frame) {
4401                        if (em_get_buf(adapter, i) != 0) {
4402                                ifp->if_iqdrops++;
4403                                goto discard;
4404                        }
4405
4406                        /* Assign correct length to the current fragment */
4407                        mp->m_len = len;
4408
4409                        if (adapter->fmp == NULL) {
4410                                mp->m_pkthdr.len = len;
4411                                adapter->fmp = mp; /* Store the first mbuf */
4412                                adapter->lmp = mp;
4413                        } else {
4414                                /* Chain mbuf's together */
4415                                mp->m_flags &= ~M_PKTHDR;
4416                                /*
4417                                 * Adjust length of previous mbuf in chain if
4418                                 * we received less than 4 bytes in the last
4419                                 * descriptor.
4420                                 */
4421                                if (prev_len_adj > 0) {
4422                                        adapter->lmp->m_len -= prev_len_adj;
4423                                        adapter->fmp->m_pkthdr.len -=
4424                                            prev_len_adj;
4425                                }
4426                                adapter->lmp->m_next = mp;
4427                                adapter->lmp = adapter->lmp->m_next;
4428                                adapter->fmp->m_pkthdr.len += len;
4429                        }
4430
4431                        if (eop) {
4432                                adapter->fmp->m_pkthdr.rcvif = ifp;
4433                                ifp->if_ipackets++;
4434#ifndef __rtems__
4435                                em_receive_checksum(adapter, current_desc,
4436                                    adapter->fmp);
4437#endif
4438#ifndef __NO_STRICT_ALIGNMENT
4439                                if (adapter->hw.mac.max_frame_size >
4440                                    (MCLBYTES - ETHER_ALIGN) &&
4441                                    em_fixup_rx(adapter) != 0)
4442                                        goto skip;
4443#endif
4444                                if (status & E1000_RXD_STAT_VP) {
4445#ifndef __rtems__
4446                                        adapter->fmp->m_pkthdr.ether_vtag =
4447                                            (le16toh(current_desc->special) &
4448                                            E1000_RXD_SPC_VLAN_MASK);
4449                                        adapter->fmp->m_flags |= M_VLANTAG;
4450#else
4451                                        ifp->if_iqdrops++;
4452                                        goto discard;
4453#endif
4454                                }
4455#ifndef __NO_STRICT_ALIGNMENT
4456skip:
4457#endif
4458                                m = adapter->fmp;
4459                                adapter->fmp = NULL;
4460                                adapter->lmp = NULL;
4461                        }
4462                } else {
4463                        ifp->if_ierrors++;
4464discard:
4465                        /* Reuse loaded DMA map and just update mbuf chain */
4466                        mp = adapter->rx_buffer_area[i].m_head;
4467                        mp->m_len = mp->m_pkthdr.len = MCLBYTES;
4468                        mp->m_data = mp->m_ext.ext_buf;
4469                        mp->m_next = NULL;
4470                        if (adapter->hw.mac.max_frame_size <=
4471                            (MCLBYTES - ETHER_ALIGN))
4472                                m_adj(mp, ETHER_ALIGN);
4473                        if (adapter->fmp != NULL) {
4474                                m_freem(adapter->fmp);
4475                                adapter->fmp = NULL;
4476                                adapter->lmp = NULL;
4477                        }
4478                        m = NULL;
4479                }
4480
4481                /* Zero out the receive descriptors status. */
4482                current_desc->status = 0;
4483                bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
4484                    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
4485
4486                /* Advance our pointers to the next descriptor. */
4487                if (++i == adapter->num_rx_desc)
4488                        i = 0;
4489                if (m != NULL) {
4490                        adapter->next_rx_desc_to_check = i;
4491#ifdef DEVICE_POLLING
4492                        EM_UNLOCK(adapter);
4493#  ifndef __rtems__
4494                        (*ifp->if_input)(ifp, m);
4495#  else
4496                        ether_input_skipping(ifp, m);
4497#  endif
4498                        EM_LOCK(adapter);
4499#else
4500                        /* Already running unlocked */
4501#  ifndef __rtems__
4502                        (*ifp->if_input)(ifp, m);
4503#  else
4504                        ether_input_skipping(ifp, m);
4505#  endif
4506#endif
4507                        i = adapter->next_rx_desc_to_check;
4508                }
4509                current_desc = &adapter->rx_desc_base[i];
4510        }
4511        adapter->next_rx_desc_to_check = i;
4512
4513        /* Advance the E1000's Receive Queue #0  "Tail Pointer". */
4514        if (--i < 0)
4515                i = adapter->num_rx_desc - 1;
4516        E1000_WRITE_REG(&adapter->hw, E1000_RDT, i);
4517        if (!((current_desc->status) & E1000_RXD_STAT_DD))
4518                return (0);
4519
4520        return (1);
4521}
4522
4523#ifndef __NO_STRICT_ALIGNMENT
4524/*
4525 * When jumbo frames are enabled we should realign entire payload on
4526 * architecures with strict alignment. This is serious design mistake of 8254x
4527 * as it nullifies DMA operations. 8254x just allows RX buffer size to be
4528 * 2048/4096/8192/16384. What we really want is 2048 - ETHER_ALIGN to align its
4529 * payload. On architecures without strict alignment restrictions 8254x still
4530 * performs unaligned memory access which would reduce the performance too.
4531 * To avoid copying over an entire frame to align, we allocate a new mbuf and
4532 * copy ethernet header to the new mbuf. The new mbuf is prepended into the
4533 * existing mbuf chain.
4534 *
4535 * Be aware, best performance of the 8254x is achived only when jumbo frame is
4536 * not used at all on architectures with strict alignment.
4537 */
4538static int
4539em_fixup_rx(struct adapter *adapter)
4540{
4541        struct mbuf *m, *n;
4542        int error;
4543
4544        error = 0;
4545        m = adapter->fmp;
4546        if (m->m_len <= (MCLBYTES - ETHER_HDR_LEN)) {
4547                bcopy(m->m_data, m->m_data + ETHER_HDR_LEN, m->m_len);
4548                m->m_data += ETHER_HDR_LEN;
4549        } else {
4550                MGETHDR(n, M_DONTWAIT, MT_DATA);
4551                if (n != NULL) {
4552                        bcopy(m->m_data, n->m_data, ETHER_HDR_LEN);
4553                        m->m_data += ETHER_HDR_LEN;
4554                        m->m_len -= ETHER_HDR_LEN;
4555                        n->m_len = ETHER_HDR_LEN;
4556                        M_MOVE_PKTHDR(n, m);
4557                        n->m_next = m;
4558                        adapter->fmp = n;
4559                } else {
4560                        adapter->dropped_pkts++;
4561                        m_freem(adapter->fmp);
4562                        adapter->fmp = NULL;
4563                        error = ENOMEM;
4564                }
4565        }
4566
4567        return (error);
4568}
4569#endif
4570
4571#ifndef __rtems__
4572/*********************************************************************
4573 *
4574 *  Verify that the hardware indicated that the checksum is valid.
4575 *  Inform the stack about the status of checksum so that stack
4576 *  doesn't spend time verifying the checksum.
4577 *
4578 *********************************************************************/
4579static void
4580em_receive_checksum(struct adapter *adapter,
4581            struct e1000_rx_desc *rx_desc, struct mbuf *mp)
4582{
4583        /* 82543 or newer only */
4584        if ((adapter->hw.mac.type < e1000_82543) ||
4585            /* Ignore Checksum bit is set */
4586            (rx_desc->status & E1000_RXD_STAT_IXSM)) {
4587                mp->m_pkthdr.csum_flags = 0;
4588                return;
4589        }
4590
4591        if (rx_desc->status & E1000_RXD_STAT_IPCS) {
4592                /* Did it pass? */
4593                if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) {
4594                        /* IP Checksum Good */
4595                        mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
4596                        mp->m_pkthdr.csum_flags |= CSUM_IP_VALID;
4597
4598                } else {
4599                        mp->m_pkthdr.csum_flags = 0;
4600                }
4601        }
4602
4603        if (rx_desc->status & E1000_RXD_STAT_TCPCS) {
4604                /* Did it pass? */
4605                if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) {
4606                        mp->m_pkthdr.csum_flags |=
4607                        (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
4608                        mp->m_pkthdr.csum_data = htons(0xffff);
4609                }
4610        }
4611}
4612
4613
4614static void
4615em_enable_vlans(struct adapter *adapter)
4616{
4617        uint32_t ctrl;
4618
4619        E1000_WRITE_REG(&adapter->hw, E1000_VET, ETHERTYPE_VLAN);
4620
4621        ctrl = E1000_READ_REG(&adapter->hw, E1000_CTRL);
4622        ctrl |= E1000_CTRL_VME;
4623        E1000_WRITE_REG(&adapter->hw, E1000_CTRL, ctrl);
4624}
4625#endif
4626
4627static void
4628em_enable_intr(struct adapter *adapter)
4629{
4630        E1000_WRITE_REG(&adapter->hw, E1000_IMS,
4631            (IMS_ENABLE_MASK));
4632}
4633
4634static void
4635em_disable_intr(struct adapter *adapter)
4636{
4637        E1000_WRITE_REG(&adapter->hw, E1000_IMC, 0xffffffff);
4638}
4639
4640/*
4641 * Bit of a misnomer, what this really means is
4642 * to enable OS management of the system... aka
4643 * to disable special hardware management features
4644 */
4645static void
4646em_init_manageability(struct adapter *adapter)
4647{
4648        /* A shared code workaround */
4649#define E1000_82542_MANC2H E1000_MANC2H
4650        if (adapter->has_manage) {
4651                int manc2h = E1000_READ_REG(&adapter->hw, E1000_MANC2H);
4652                int manc = E1000_READ_REG(&adapter->hw, E1000_MANC);
4653
4654                /* disable hardware interception of ARP */
4655                manc &= ~(E1000_MANC_ARP_EN);
4656
4657                /* enable receiving management packets to the host */
4658                if (adapter->hw.mac.type >= e1000_82571) {
4659                        manc |= E1000_MANC_EN_MNG2HOST;
4660#define E1000_MNG2HOST_PORT_623 (1 << 5)
4661#define E1000_MNG2HOST_PORT_664 (1 << 6)
4662                        manc2h |= E1000_MNG2HOST_PORT_623;
4663                        manc2h |= E1000_MNG2HOST_PORT_664;
4664                        E1000_WRITE_REG(&adapter->hw, E1000_MANC2H, manc2h);
4665                }
4666
4667                E1000_WRITE_REG(&adapter->hw, E1000_MANC, manc);
4668        }
4669}
4670
4671/*
4672 * Give control back to hardware management
4673 * controller if there is one.
4674 */
4675static void
4676em_release_manageability(struct adapter *adapter)
4677{
4678        if (adapter->has_manage) {
4679                int manc = E1000_READ_REG(&adapter->hw, E1000_MANC);
4680
4681                /* re-enable hardware interception of ARP */
4682                manc |= E1000_MANC_ARP_EN;
4683
4684                if (adapter->hw.mac.type >= e1000_82571)
4685                        manc &= ~E1000_MANC_EN_MNG2HOST;
4686
4687                E1000_WRITE_REG(&adapter->hw, E1000_MANC, manc);
4688        }
4689}
4690
4691/*
4692 * em_get_hw_control sets {CTRL_EXT|FWSM}:DRV_LOAD bit.
4693 * For ASF and Pass Through versions of f/w this means that
4694 * the driver is loaded. For AMT version (only with 82573)
4695 * of the f/w this means that the network i/f is open.
4696 *
4697 */
4698static void
4699em_get_hw_control(struct adapter *adapter)
4700{
4701        u32 ctrl_ext, swsm;
4702
4703        /* Let firmware know the driver has taken over */
4704        switch (adapter->hw.mac.type) {
4705        case e1000_82573:
4706                swsm = E1000_READ_REG(&adapter->hw, E1000_SWSM);
4707                E1000_WRITE_REG(&adapter->hw, E1000_SWSM,
4708                    swsm | E1000_SWSM_DRV_LOAD);
4709                break;
4710        case e1000_82571:
4711        case e1000_82572:
4712        case e1000_80003es2lan:
4713        case e1000_ich8lan:
4714        case e1000_ich9lan:
4715                ctrl_ext = E1000_READ_REG(&adapter->hw, E1000_CTRL_EXT);
4716                E1000_WRITE_REG(&adapter->hw, E1000_CTRL_EXT,
4717                    ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
4718                break;
4719        default:
4720                break;
4721        }
4722}
4723
4724/*
4725 * em_release_hw_control resets {CTRL_EXT|FWSM}:DRV_LOAD bit.
4726 * For ASF and Pass Through versions of f/w this means that the
4727 * driver is no longer loaded. For AMT version (only with 82573) i
4728 * of the f/w this means that the network i/f is closed.
4729 *
4730 */
4731static void
4732em_release_hw_control(struct adapter *adapter)
4733{
4734        u32 ctrl_ext, swsm;
4735
4736        /* Let firmware taken over control of h/w */
4737        switch (adapter->hw.mac.type) {
4738        case e1000_82573:
4739                swsm = E1000_READ_REG(&adapter->hw, E1000_SWSM);
4740                E1000_WRITE_REG(&adapter->hw, E1000_SWSM,
4741                    swsm & ~E1000_SWSM_DRV_LOAD);
4742                break;
4743        case e1000_82571:
4744        case e1000_82572:
4745        case e1000_80003es2lan:
4746        case e1000_ich8lan:
4747        case e1000_ich9lan:
4748                ctrl_ext = E1000_READ_REG(&adapter->hw, E1000_CTRL_EXT);
4749                E1000_WRITE_REG(&adapter->hw, E1000_CTRL_EXT,
4750                    ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
4751                break;
4752        default:
4753                break;
4754
4755        }
4756}
4757
4758static int
4759em_is_valid_ether_addr(uint8_t *addr)
4760{
4761        char zero_addr[6] = { 0, 0, 0, 0, 0, 0 };
4762
4763        if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) {
4764                return (FALSE);
4765        }
4766
4767        return (TRUE);
4768}
4769
4770/*
4771 * NOTE: the following routines using the e1000
4772 *      naming style are provided to the shared
4773 *      code which expects that rather than 'em'
4774 */
4775
4776void
4777e1000_write_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
4778{
4779        pci_write_config(((struct e1000_osdep *)hw->back)->dev, reg, *value, 2);
4780}
4781
4782void
4783e1000_read_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
4784{
4785        *value = pci_read_config(((struct e1000_osdep *)hw->back)->dev, reg, 2);
4786}
4787
4788void
4789e1000_pci_set_mwi(struct e1000_hw *hw)
4790{
4791        pci_write_config(((struct e1000_osdep *)hw->back)->dev, PCIR_COMMAND,
4792            (hw->bus.pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2);
4793}
4794
4795void
4796e1000_pci_clear_mwi(struct e1000_hw *hw)
4797{
4798        pci_write_config(((struct e1000_osdep *)hw->back)->dev, PCIR_COMMAND,
4799            (hw->bus.pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2);
4800}
4801
4802/*
4803 * Read the PCI Express capabilities
4804 */
4805int32_t
4806e1000_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
4807{
4808        int32_t         error = E1000_SUCCESS;
4809        uint16_t        cap_off;
4810
4811        switch (hw->mac.type) {
4812
4813                case e1000_82571:
4814                case e1000_82572:
4815                case e1000_82573:
4816                case e1000_80003es2lan:
4817                        cap_off = 0xE0;
4818                        e1000_read_pci_cfg(hw, cap_off + reg, value);
4819                        break;
4820                default:
4821                        error = ~E1000_NOT_IMPLEMENTED;
4822                        break;
4823        }
4824
4825        return (error); 
4826}
4827
4828int32_t
4829e1000_alloc_zeroed_dev_spec_struct(struct e1000_hw *hw, uint32_t size)
4830{
4831        int32_t error = 0;
4832
4833        hw->dev_spec = malloc(size, M_DEVBUF, M_NOWAIT | M_ZERO);
4834        if (hw->dev_spec == NULL)
4835                error = ENOMEM;
4836#ifdef __rtems__
4837        /* M_ZERO not implemented :-( */
4838        if ( hw->dev_spec )
4839                memset(hw->dev_spec, 0, size);
4840#endif
4841
4842        return (error);
4843}
4844
4845void
4846e1000_free_dev_spec_struct(struct e1000_hw *hw)
4847{
4848        if (hw->dev_spec != NULL)
4849                free(hw->dev_spec, M_DEVBUF);
4850        return;
4851}
4852
4853/*
4854 * Enable PCI Wake On Lan capability
4855 */
4856void
4857em_enable_wakeup(device_t dev)
4858{
4859        u16     cap, status;
4860        u8      id;
4861
4862        /* First find the capabilities pointer*/
4863        cap = pci_read_config(dev, PCIR_CAP_PTR, 2);
4864        /* Read the PM Capabilities */
4865        id = pci_read_config(dev, cap, 1);
4866        if (id != PCIY_PMG)     /* Something wrong */
4867                return;
4868        /* OK, we have the power capabilities, so
4869           now get the status register */
4870        cap += PCIR_POWER_STATUS;
4871        status = pci_read_config(dev, cap, 2);
4872        status |= PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE;
4873        pci_write_config(dev, cap, status, 2);
4874        return;
4875}
4876
4877
4878/*********************************************************************
4879* 82544 Coexistence issue workaround.
4880*    There are 2 issues.
4881*       1. Transmit Hang issue.
4882*    To detect this issue, following equation can be used...
4883*         SIZE[3:0] + ADDR[2:0] = SUM[3:0].
4884*         If SUM[3:0] is in between 1 to 4, we will have this issue.
4885*
4886*       2. DAC issue.
4887*    To detect this issue, following equation can be used...
4888*         SIZE[3:0] + ADDR[2:0] = SUM[3:0].
4889*         If SUM[3:0] is in between 9 to c, we will have this issue.
4890*
4891*
4892*    WORKAROUND:
4893*         Make sure we do not have ending address
4894*         as 1,2,3,4(Hang) or 9,a,b,c (DAC)
4895*
4896*************************************************************************/
4897static uint32_t
4898em_fill_descriptors (bus_addr_t address, uint32_t length,
4899                PDESC_ARRAY desc_array)
4900{
4901        /* Since issue is sensitive to length and address.*/
4902        /* Let us first check the address...*/
4903        uint32_t safe_terminator;
4904        if (length <= 4) {
4905                desc_array->descriptor[0].address = address;
4906                desc_array->descriptor[0].length = length;
4907                desc_array->elements = 1;
4908                return (desc_array->elements);
4909        }
4910        safe_terminator = (uint32_t)((((uint32_t)address & 0x7) +
4911            (length & 0xF)) & 0xF);
4912        /* if it does not fall between 0x1 to 0x4 and 0x9 to 0xC then return */
4913        if (safe_terminator == 0   ||
4914        (safe_terminator > 4   &&
4915        safe_terminator < 9)   ||
4916        (safe_terminator > 0xC &&
4917        safe_terminator <= 0xF)) {
4918                desc_array->descriptor[0].address = address;
4919                desc_array->descriptor[0].length = length;
4920                desc_array->elements = 1;
4921                return (desc_array->elements);
4922        }
4923
4924        desc_array->descriptor[0].address = address;
4925        desc_array->descriptor[0].length = length - 4;
4926        desc_array->descriptor[1].address = address + (length - 4);
4927        desc_array->descriptor[1].length = 4;
4928        desc_array->elements = 2;
4929        return (desc_array->elements);
4930}
4931
4932/**********************************************************************
4933 *
4934 *  Update the board statistics counters.
4935 *
4936 **********************************************************************/
4937static void
4938em_update_stats_counters(struct adapter *adapter)
4939{
4940        struct ifnet   *ifp;
4941
4942        if(adapter->hw.media_type == e1000_media_type_copper ||
4943           (E1000_READ_REG(&adapter->hw, E1000_STATUS) & E1000_STATUS_LU)) {
4944                adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, E1000_SYMERRS);
4945                adapter->stats.sec += E1000_READ_REG(&adapter->hw, E1000_SEC);
4946        }
4947        adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, E1000_CRCERRS);
4948        adapter->stats.mpc += E1000_READ_REG(&adapter->hw, E1000_MPC);
4949        adapter->stats.scc += E1000_READ_REG(&adapter->hw, E1000_SCC);
4950        adapter->stats.ecol += E1000_READ_REG(&adapter->hw, E1000_ECOL);
4951
4952        adapter->stats.mcc += E1000_READ_REG(&adapter->hw, E1000_MCC);
4953        adapter->stats.latecol += E1000_READ_REG(&adapter->hw, E1000_LATECOL);
4954        adapter->stats.colc += E1000_READ_REG(&adapter->hw, E1000_COLC);
4955        adapter->stats.dc += E1000_READ_REG(&adapter->hw, E1000_DC);
4956        adapter->stats.rlec += E1000_READ_REG(&adapter->hw, E1000_RLEC);
4957        adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, E1000_XONRXC);
4958        adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, E1000_XONTXC);
4959        adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, E1000_XOFFRXC);
4960        adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, E1000_XOFFTXC);
4961        adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, E1000_FCRUC);
4962        adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, E1000_PRC64);
4963        adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, E1000_PRC127);
4964        adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, E1000_PRC255);
4965        adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, E1000_PRC511);
4966        adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, E1000_PRC1023);
4967        adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, E1000_PRC1522);
4968        adapter->stats.gprc += E1000_READ_REG(&adapter->hw, E1000_GPRC);
4969        adapter->stats.bprc += E1000_READ_REG(&adapter->hw, E1000_BPRC);
4970        adapter->stats.mprc += E1000_READ_REG(&adapter->hw, E1000_MPRC);
4971        adapter->stats.gptc += E1000_READ_REG(&adapter->hw, E1000_GPTC);
4972
4973        /* For the 64-bit byte counters the low dword must be read first. */
4974        /* Both registers clear on the read of the high dword */
4975
4976        adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, E1000_GORCL);
4977        adapter->stats.gorch += E1000_READ_REG(&adapter->hw, E1000_GORCH);
4978        adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, E1000_GOTCL);
4979        adapter->stats.gotch += E1000_READ_REG(&adapter->hw, E1000_GOTCH);
4980
4981        adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, E1000_RNBC);
4982        adapter->stats.ruc += E1000_READ_REG(&adapter->hw, E1000_RUC);
4983        adapter->stats.rfc += E1000_READ_REG(&adapter->hw, E1000_RFC);
4984        adapter->stats.roc += E1000_READ_REG(&adapter->hw, E1000_ROC);
4985        adapter->stats.rjc += E1000_READ_REG(&adapter->hw, E1000_RJC);
4986
4987        adapter->stats.torl += E1000_READ_REG(&adapter->hw, E1000_TORL);
4988        adapter->stats.torh += E1000_READ_REG(&adapter->hw, E1000_TORH);
4989        adapter->stats.totl += E1000_READ_REG(&adapter->hw, E1000_TOTL);
4990        adapter->stats.toth += E1000_READ_REG(&adapter->hw, E1000_TOTH);
4991
4992        adapter->stats.tpr += E1000_READ_REG(&adapter->hw, E1000_TPR);
4993        adapter->stats.tpt += E1000_READ_REG(&adapter->hw, E1000_TPT);
4994        adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, E1000_PTC64);
4995        adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, E1000_PTC127);
4996        adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, E1000_PTC255);
4997        adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, E1000_PTC511);
4998        adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, E1000_PTC1023);
4999        adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, E1000_PTC1522);
5000        adapter->stats.mptc += E1000_READ_REG(&adapter->hw, E1000_MPTC);
5001        adapter->stats.bptc += E1000_READ_REG(&adapter->hw, E1000_BPTC);
5002
5003        if (adapter->hw.mac.type >= e1000_82543) {
5004                adapter->stats.algnerrc += 
5005                E1000_READ_REG(&adapter->hw, E1000_ALGNERRC);
5006                adapter->stats.rxerrc += 
5007                E1000_READ_REG(&adapter->hw, E1000_RXERRC);
5008                adapter->stats.tncrs += 
5009                E1000_READ_REG(&adapter->hw, E1000_TNCRS);
5010                adapter->stats.cexterr += 
5011                E1000_READ_REG(&adapter->hw, E1000_CEXTERR);
5012                adapter->stats.tsctc += 
5013                E1000_READ_REG(&adapter->hw, E1000_TSCTC);
5014                adapter->stats.tsctfc += 
5015                E1000_READ_REG(&adapter->hw, E1000_TSCTFC);
5016        }
5017        ifp = adapter->ifp;
5018
5019        ifp->if_collisions = adapter->stats.colc;
5020
5021        /* Rx Errors */
5022        ifp->if_ierrors = adapter->dropped_pkts + adapter->stats.rxerrc +
5023            adapter->stats.crcerrs + adapter->stats.algnerrc +
5024            adapter->stats.ruc + adapter->stats.roc +
5025            adapter->stats.mpc + adapter->stats.cexterr;
5026
5027        /* Tx Errors */
5028        ifp->if_oerrors = adapter->stats.ecol +
5029            adapter->stats.latecol + adapter->watchdog_events;
5030}
5031
5032
5033/**********************************************************************
5034 *
5035 *  This routine is called only when em_display_debug_stats is enabled.
5036 *  This routine provides a way to take a look at important statistics
5037 *  maintained by the driver and hardware.
5038 *
5039 **********************************************************************/
5040#ifndef __rtems__
5041static void
5042#else
5043void
5044#endif
5045em_print_debug_info(struct adapter *adapter)
5046{
5047#ifndef __rtems__
5048        device_t dev = adapter->dev;
5049        uint8_t *hw_addr = adapter->hw.hw_addr;
5050#else
5051        device_t dev;
5052        uint8_t *hw_addr;
5053        if ( !adapter ) {
5054                printk("Need 'adapter' arg\n");
5055                return;
5056        }
5057        dev = adapter->dev;
5058        hw_addr = adapter->hw.hw_addr;
5059#endif
5060
5061        device_printf(dev, "Adapter hardware address = %p \n", hw_addr);
5062        device_printf(dev, "CTRL = 0x%x RCTL = 0x%x \n",
5063            E1000_READ_REG(&adapter->hw, E1000_CTRL),
5064            E1000_READ_REG(&adapter->hw, E1000_RCTL));
5065        device_printf(dev, "Packet buffer = Tx=%dk Rx=%dk \n",
5066            ((E1000_READ_REG(&adapter->hw, E1000_PBA) & 0xffff0000) >> 16),\
5067            (E1000_READ_REG(&adapter->hw, E1000_PBA) & 0xffff) );
5068        device_printf(dev, "Flow control watermarks high = %d low = %d\n",
5069            adapter->hw.mac.fc_high_water,
5070            adapter->hw.mac.fc_low_water);
5071        device_printf(dev, "tx_int_delay = %d, tx_abs_int_delay = %d\n",
5072            E1000_READ_REG(&adapter->hw, E1000_TIDV),
5073            E1000_READ_REG(&adapter->hw, E1000_TADV));
5074        device_printf(dev, "rx_int_delay = %d, rx_abs_int_delay = %d\n",
5075            E1000_READ_REG(&adapter->hw, E1000_RDTR),
5076            E1000_READ_REG(&adapter->hw, E1000_RADV));
5077        device_printf(dev, "fifo workaround = %lld, fifo_reset_count = %lld\n",
5078            (long long)adapter->tx_fifo_wrk_cnt,
5079            (long long)adapter->tx_fifo_reset_cnt);
5080        device_printf(dev, "hw tdh = %d, hw tdt = %d\n",
5081            E1000_READ_REG(&adapter->hw, E1000_TDH),
5082            E1000_READ_REG(&adapter->hw, E1000_TDT));
5083        device_printf(dev, "hw rdh = %d, hw rdt = %d\n",
5084            E1000_READ_REG(&adapter->hw, E1000_RDH),
5085            E1000_READ_REG(&adapter->hw, E1000_RDT));
5086        device_printf(dev, "Num Tx descriptors avail = %d\n",
5087            adapter->num_tx_desc_avail);
5088        device_printf(dev, "Tx Descriptors not avail1 = %ld\n",
5089            adapter->no_tx_desc_avail1);
5090        device_printf(dev, "Tx Descriptors not avail2 = %ld\n",
5091            adapter->no_tx_desc_avail2);
5092        device_printf(dev, "Std mbuf failed = %ld\n",
5093            adapter->mbuf_alloc_failed);
5094        device_printf(dev, "Std mbuf cluster failed = %ld\n",
5095            adapter->mbuf_cluster_failed);
5096        device_printf(dev, "Driver dropped packets = %ld\n",
5097            adapter->dropped_pkts);
5098        device_printf(dev, "Driver tx dma failure in encap = %ld\n",
5099                adapter->no_tx_dma_setup);
5100}
5101
5102#ifndef __rtems__
5103static void
5104#else
5105void
5106#endif
5107em_print_hw_stats(struct adapter *adapter)
5108{
5109        device_t dev = adapter->dev;
5110
5111        device_printf(dev, "Excessive collisions = %lld\n",
5112            (long long)adapter->stats.ecol);
5113#if     (DEBUG_HW > 0)  /* Dont output these errors normally */
5114        device_printf(dev, "Symbol errors = %lld\n",
5115            (long long)adapter->stats.symerrs);
5116#endif
5117        device_printf(dev, "Sequence errors = %lld\n",
5118            (long long)adapter->stats.sec);
5119        device_printf(dev, "Defer count = %lld\n",
5120            (long long)adapter->stats.dc);
5121        device_printf(dev, "Missed Packets = %lld\n",
5122            (long long)adapter->stats.mpc);
5123        device_printf(dev, "Receive No Buffers = %lld\n",
5124            (long long)adapter->stats.rnbc);
5125        /* RLEC is inaccurate on some hardware, calculate our own. */
5126        device_printf(dev, "Receive Length Errors = %lld\n",
5127            ((long long)adapter->stats.roc + (long long)adapter->stats.ruc));
5128        device_printf(dev, "Receive errors = %lld\n",
5129            (long long)adapter->stats.rxerrc);
5130        device_printf(dev, "Crc errors = %lld\n",
5131            (long long)adapter->stats.crcerrs);
5132        device_printf(dev, "Alignment errors = %lld\n",
5133            (long long)adapter->stats.algnerrc);
5134        device_printf(dev, "Carrier extension errors = %lld\n",
5135            (long long)adapter->stats.cexterr);
5136        device_printf(dev, "RX overruns = %ld\n", adapter->rx_overruns);
5137        device_printf(dev, "watchdog timeouts = %ld\n",
5138            adapter->watchdog_events);
5139        device_printf(dev, "XON Rcvd = %lld\n",
5140            (long long)adapter->stats.xonrxc);
5141        device_printf(dev, "XON Xmtd = %lld\n",
5142            (long long)adapter->stats.xontxc);
5143        device_printf(dev, "XOFF Rcvd = %lld\n",
5144            (long long)adapter->stats.xoffrxc);
5145        device_printf(dev, "XOFF Xmtd = %lld\n",
5146            (long long)adapter->stats.xofftxc);
5147        device_printf(dev, "Good Packets Rcvd = %lld\n",
5148            (long long)adapter->stats.gprc);
5149        device_printf(dev, "Good Packets Xmtd = %lld\n",
5150            (long long)adapter->stats.gptc);
5151        device_printf(dev, "TSO Contexts Xmtd = %lld\n",
5152            (long long)adapter->stats.tsctc);
5153        device_printf(dev, "TSO Contexts Failed = %lld\n",
5154            (long long)adapter->stats.tsctfc);
5155}
5156
5157#ifndef __rtems__
5158static int
5159em_sysctl_debug_info(SYSCTL_HANDLER_ARGS)
5160{
5161        struct adapter *adapter;
5162        int error;
5163        int result;
5164
5165        result = -1;
5166        error = sysctl_handle_int(oidp, &result, 0, req);
5167
5168        if (error || !req->newptr)
5169                return (error);
5170
5171        if (result == 1) {
5172                adapter = (struct adapter *)arg1;
5173                em_print_debug_info(adapter);
5174        }
5175
5176        return (error);
5177}
5178
5179
5180static int
5181em_sysctl_stats(SYSCTL_HANDLER_ARGS)
5182{
5183        struct adapter *adapter;
5184        int error;
5185        int result;
5186
5187        result = -1;
5188        error = sysctl_handle_int(oidp, &result, 0, req);
5189
5190        if (error || !req->newptr)
5191                return (error);
5192
5193        if (result == 1) {
5194                adapter = (struct adapter *)arg1;
5195                em_print_hw_stats(adapter);
5196        }
5197
5198        return (error);
5199}
5200
5201static int
5202em_sysctl_int_delay(SYSCTL_HANDLER_ARGS)
5203{
5204        struct em_int_delay_info *info;
5205        struct adapter *adapter;
5206        uint32_t regval;
5207        int error;
5208        int usecs;
5209        int ticks;
5210
5211        info = (struct em_int_delay_info *)arg1;
5212        usecs = info->value;
5213        error = sysctl_handle_int(oidp, &usecs, 0, req);
5214        if (error != 0 || req->newptr == NULL)
5215                return (error);
5216        if (usecs < 0 || usecs > EM_TICKS_TO_USECS(65535))
5217                return (EINVAL);
5218        info->value = usecs;
5219        ticks = EM_USECS_TO_TICKS(usecs);
5220
5221        adapter = info->adapter;
5222       
5223        EM_LOCK(adapter);
5224        regval = E1000_READ_OFFSET(&adapter->hw, info->offset);
5225        regval = (regval & ~0xffff) | (ticks & 0xffff);
5226        /* Handle a few special cases. */
5227        switch (info->offset) {
5228        case E1000_RDTR:
5229                break;
5230        case E1000_TIDV:
5231                if (ticks == 0) {
5232                        adapter->txd_cmd &= ~E1000_TXD_CMD_IDE;
5233                        /* Don't write 0 into the TIDV register. */
5234                        regval++;
5235                } else
5236                        if (adapter->hw.mac.type != e1000_82575)
5237                                adapter->txd_cmd |= E1000_TXD_CMD_IDE;
5238                break;
5239        }
5240        E1000_WRITE_OFFSET(&adapter->hw, info->offset, regval);
5241        EM_UNLOCK(adapter);
5242        return (0);
5243}
5244#endif
5245
5246static void
5247em_add_int_delay_sysctl(struct adapter *adapter, const char *name,
5248        const char *description, struct em_int_delay_info *info,
5249        int offset, int value)
5250{
5251        info->adapter = adapter;
5252        info->offset = offset;
5253        info->value = value;
5254        SYSCTL_ADD_PROC(device_get_sysctl_ctx(adapter->dev),
5255            SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
5256            OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW,
5257            info, 0, em_sysctl_int_delay, "I", description);
5258}
5259
5260#ifndef DEVICE_POLLING
5261static void
5262em_add_rx_process_limit(struct adapter *adapter, const char *name,
5263        const char *description, int *limit, int value)
5264{
5265        *limit = value;
5266        SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev),
5267            SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
5268            OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description);
5269}
5270#endif
Note: See TracBrowser for help on using the repository browser.