source: libbsdport/bsd_eth_drivers/if_em/if_em.c @ 88f653a

Last change on this file since 88f653a was 88f653a, checked in by Till Straumann <strauman@…>, on Jul 20, 2011 at 5:25:21 PM

2011-07-20 Till Straumann <Till.Straumann@…>

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