source: rtems/bsps/powerpc/beatnik/net/if_em/if_em.c @ 031df391

5
Last change on this file since 031df391 was 031df391, checked in by Sebastian Huber <sebastian.huber@…>, on Apr 23, 2018 at 7:53:31 AM

bsps: Move legacy network drivers to bsps

This patch is a part of the BSP source reorganization.

Update #3285.

  • Property mode set to 100644
File size: 116.3 KB
Line 
1/**************************************************************************
2
3Copyright (c) 2001-2005, 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: /repoman/r/ncvs/src/sys/dev/em/if_em.c,v 1.67 2005/08/03 00:18:29 rwatson Exp $*/
35#ifndef __rtems__
36#include <dev/em/if_em.h>
37#else
38#include <rtems.h>
39#include "rtemscompat_defs.h"
40#include "../porting/rtemscompat.h"
41#include "if_em.h"
42#include "../porting/rtemscompat1.h"
43#include <inttypes.h>
44#endif
45
46/*********************************************************************
47 *  Set this to one to display debug statistics                                                   
48 *********************************************************************/
49int             em_display_debug_stats = 0;
50
51/*********************************************************************
52 *  Linked list of board private structures for all NICs found
53 *********************************************************************/
54
55struct adapter *em_adapter_list = NULL;
56
57
58/*********************************************************************
59 *  Driver version
60 *********************************************************************/
61
62char em_driver_version[] = "2.1.7";
63
64
65/*********************************************************************
66 *  PCI Device ID Table
67 *
68 *  Used by probe to select devices to load on
69 *  Last field stores an index into em_strings
70 *  Last entry must be all 0s
71 *
72 *  { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
73 *********************************************************************/
74
75static em_vendor_info_t em_vendor_info_array[] =
76{
77        /* Intel(R) PRO/1000 Network Connection */
78        { 0x8086, E1000_DEV_ID_82540EM,             PCI_ANY_ID, PCI_ANY_ID, 0},
79        { 0x8086, E1000_DEV_ID_82540EM_LOM,         PCI_ANY_ID, PCI_ANY_ID, 0},
80        { 0x8086, E1000_DEV_ID_82540EP,             PCI_ANY_ID, PCI_ANY_ID, 0},
81        { 0x8086, E1000_DEV_ID_82540EP_LOM,         PCI_ANY_ID, PCI_ANY_ID, 0},
82        { 0x8086, E1000_DEV_ID_82540EP_LP,          PCI_ANY_ID, PCI_ANY_ID, 0},
83
84        { 0x8086, E1000_DEV_ID_82541EI,             PCI_ANY_ID, PCI_ANY_ID, 0},
85        { 0x8086, E1000_DEV_ID_82541ER,             PCI_ANY_ID, PCI_ANY_ID, 0},
86        { 0x8086, E1000_DEV_ID_82541ER_LOM,             PCI_ANY_ID, PCI_ANY_ID, 0},
87        { 0x8086, E1000_DEV_ID_82541EI_MOBILE,      PCI_ANY_ID, PCI_ANY_ID, 0},
88        { 0x8086, E1000_DEV_ID_82541GI,             PCI_ANY_ID, PCI_ANY_ID, 0},
89        { 0x8086, E1000_DEV_ID_82541GI_LF,          PCI_ANY_ID, PCI_ANY_ID, 0},
90        { 0x8086, E1000_DEV_ID_82541GI_MOBILE,      PCI_ANY_ID, PCI_ANY_ID, 0},
91
92        { 0x8086, E1000_DEV_ID_82542,               PCI_ANY_ID, PCI_ANY_ID, 0},
93
94        { 0x8086, E1000_DEV_ID_82543GC_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
95        { 0x8086, E1000_DEV_ID_82543GC_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
96
97        { 0x8086, E1000_DEV_ID_82544EI_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
98        { 0x8086, E1000_DEV_ID_82544EI_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
99        { 0x8086, E1000_DEV_ID_82544GC_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
100        { 0x8086, E1000_DEV_ID_82544GC_LOM,         PCI_ANY_ID, PCI_ANY_ID, 0},
101
102        { 0x8086, E1000_DEV_ID_82545EM_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
103        { 0x8086, E1000_DEV_ID_82545EM_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
104        { 0x8086, E1000_DEV_ID_82545GM_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
105        { 0x8086, E1000_DEV_ID_82545GM_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
106        { 0x8086, E1000_DEV_ID_82545GM_SERDES,      PCI_ANY_ID, PCI_ANY_ID, 0},
107
108        { 0x8086, E1000_DEV_ID_82546EB_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
109        { 0x8086, E1000_DEV_ID_82546EB_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
110        { 0x8086, E1000_DEV_ID_82546EB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0},
111        { 0x8086, E1000_DEV_ID_82546GB_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
112        { 0x8086, E1000_DEV_ID_82546GB_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
113        { 0x8086, E1000_DEV_ID_82546GB_SERDES,      PCI_ANY_ID, PCI_ANY_ID, 0},
114        { 0x8086, E1000_DEV_ID_82546GB_PCIE,        PCI_ANY_ID, PCI_ANY_ID, 0},
115        { 0x8086, E1000_DEV_ID_82546GB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0},
116
117        { 0x8086, E1000_DEV_ID_82547EI,             PCI_ANY_ID, PCI_ANY_ID, 0},
118        { 0x8086, E1000_DEV_ID_82547EI_MOBILE,      PCI_ANY_ID, PCI_ANY_ID, 0},
119        { 0x8086, E1000_DEV_ID_82547GI,             PCI_ANY_ID, PCI_ANY_ID, 0},
120
121        { 0x8086, E1000_DEV_ID_82573E,              PCI_ANY_ID, PCI_ANY_ID, 0},
122        { 0x8086, E1000_DEV_ID_82573E_IAMT,         PCI_ANY_ID, PCI_ANY_ID, 0},
123
124        /* required last entry */
125        { 0, 0, 0, 0, 0}
126};
127
128/*********************************************************************
129 *  Table of branding strings for all supported NICs.
130 *********************************************************************/
131
132static char *em_strings[] = {
133        "Intel(R) PRO/1000 Network Connection"
134};
135
136/*********************************************************************
137 *  Function prototypes           
138 *********************************************************************/
139static int  em_probe(device_t);
140static int  em_attach(device_t);
141#if !defined(__rtems__) || defined(DEBUG_MODULAR)
142static int  em_detach(device_t);
143#endif
144#ifndef __rtems__
145static int  em_shutdown(device_t);
146#endif
147static void em_intr(void *);
148static void em_start(struct ifnet *);
149#ifndef __rtems__
150static int  em_ioctl(struct ifnet *, u_long, caddr_t);
151#else
152static int  em_ioctl(struct ifnet *, ioctl_command_t, caddr_t);
153#endif
154static void em_watchdog(struct ifnet *);
155static void em_init(void *);
156static void em_init_locked(struct adapter *);
157static void em_stop(void *);
158static void em_media_status(struct ifnet *, struct ifmediareq *);
159#ifndef __rtems__
160static int  em_media_change(struct ifnet *);
161#else
162static int      em_media_change(struct ifnet *ifp, struct rtems_ifmedia *ifm);
163#endif
164static void em_identify_hardware(struct adapter *);
165static int  em_allocate_pci_resources(struct adapter *);
166#ifndef __rtems__
167static void em_free_pci_resources(struct adapter *);
168static void em_local_timer(void *);
169#endif
170static int  em_hardware_init(struct adapter *);
171static void em_setup_interface(device_t, struct adapter *);
172static int  em_setup_transmit_structures(struct adapter *);
173static void em_initialize_transmit_unit(struct adapter *);
174static int  em_setup_receive_structures(struct adapter *);
175static void em_initialize_receive_unit(struct adapter *);
176static void em_enable_intr(struct adapter *);
177static void em_disable_intr(struct adapter *);
178static void em_free_transmit_structures(struct adapter *);
179static void em_free_receive_structures(struct adapter *);
180static void em_update_stats_counters(struct adapter *);
181static void em_clean_transmit_interrupts(struct adapter *);
182static int  em_allocate_receive_structures(struct adapter *);
183static int  em_allocate_transmit_structures(struct adapter *);
184static void em_process_receive_interrupts(struct adapter *, int);
185#ifndef __rtems__
186static void em_receive_checksum(struct adapter *, 
187                                struct em_rx_desc *,
188                                struct mbuf *);
189static void em_transmit_checksum_setup(struct adapter *,
190                                       struct mbuf *,
191                                       u_int32_t *,
192                                       u_int32_t *);
193#endif
194static void em_set_promisc(struct adapter *);
195static void em_disable_promisc(struct adapter *);
196static void em_set_multi(struct adapter *);
197static void em_print_hw_stats(struct adapter *);
198static void em_print_link_status(struct adapter *);
199static int  em_get_buf(int i, struct adapter *,
200                       struct mbuf *);
201#ifndef __rtems__
202static void em_enable_vlans(struct adapter *);
203static void em_disable_vlans(struct adapter *);
204#endif
205static int  em_encap(struct adapter *, struct mbuf **);
206#ifndef __rtems__
207static void em_smartspeed(struct adapter *);
208#endif
209static int  em_82547_fifo_workaround(struct adapter *, int);
210static void em_82547_update_fifo_head(struct adapter *, int);
211static int  em_82547_tx_fifo_reset(struct adapter *);
212#ifndef __rtems__
213static void em_82547_move_tail(void *arg);
214#endif
215static void em_82547_move_tail_locked(struct adapter *);
216static int  em_dma_malloc(struct adapter *, bus_size_t,
217                          struct em_dma_alloc *, int);
218static void em_dma_free(struct adapter *, struct em_dma_alloc *);
219#ifndef __rtems__
220static void em_print_debug_info(struct adapter *);
221#endif
222static int  em_is_valid_ether_addr(u_int8_t *);
223#ifndef __rtems__
224static int  em_sysctl_stats(SYSCTL_HANDLER_ARGS);
225static int  em_sysctl_debug_info(SYSCTL_HANDLER_ARGS);
226#endif
227static u_int32_t em_fill_descriptors (u_int64_t address, 
228                                      u_int32_t length, 
229                                      PDESC_ARRAY desc_array);
230#ifndef __rtems__
231static int  em_sysctl_int_delay(SYSCTL_HANDLER_ARGS);
232static void em_add_int_delay_sysctl(struct adapter *, const char *,
233                                    const char *, struct em_int_delay_info *,
234                                    int, int);
235#endif
236
237/*********************************************************************
238 *  FreeBSD Device Interface Entry Points                   
239 *********************************************************************/
240
241#ifndef __rtems__
242static device_method_t em_methods[] = {
243        /* Device interface */
244        DEVMETHOD(device_probe, em_probe),
245        DEVMETHOD(device_attach, em_attach),
246        DEVMETHOD(device_detach, em_detach),
247        DEVMETHOD(device_shutdown, em_shutdown),
248        {0, 0}
249};
250
251static driver_t em_driver = {
252        "em", em_methods, sizeof(struct adapter ),
253};
254
255static devclass_t em_devclass;
256DRIVER_MODULE(em, pci, em_driver, em_devclass, 0, 0);
257MODULE_DEPEND(em, pci, 1, 1, 1);
258MODULE_DEPEND(em, ether, 1, 1, 1);
259#else
260net_drv_tbl_t METHODS = {
261        n_probe  : em_probe,
262        n_attach : em_attach,
263#ifdef DEBUG_MODULAR
264        n_detach : em_detach,
265#else
266        n_detach:  0,
267#endif
268        n_intr   : em_intr,
269};
270#endif
271
272/*********************************************************************
273 *  Tunable default values.
274 *********************************************************************/
275
276#define E1000_TICKS_TO_USECS(ticks)     ((1024 * (ticks) + 500) / 1000)
277#define E1000_USECS_TO_TICKS(usecs)     ((1000 * (usecs) + 512) / 1024)
278
279#ifndef __rtems__
280static int em_tx_int_delay_dflt = E1000_TICKS_TO_USECS(EM_TIDV);
281static int em_rx_int_delay_dflt = E1000_TICKS_TO_USECS(EM_RDTR);
282static int em_tx_abs_int_delay_dflt = E1000_TICKS_TO_USECS(EM_TADV);
283static int em_rx_abs_int_delay_dflt = E1000_TICKS_TO_USECS(EM_RADV);
284
285TUNABLE_INT("hw.em.tx_int_delay", &em_tx_int_delay_dflt);
286TUNABLE_INT("hw.em.rx_int_delay", &em_rx_int_delay_dflt);
287TUNABLE_INT("hw.em.tx_abs_int_delay", &em_tx_abs_int_delay_dflt);
288TUNABLE_INT("hw.em.rx_abs_int_delay", &em_rx_abs_int_delay_dflt);
289#endif
290
291/*********************************************************************
292 *  Device identification routine
293 *
294 *  em_probe determines if the driver should be loaded on
295 *  adapter based on PCI vendor/device id of the adapter.
296 *
297 *  return BUS_PROBE_DEFAULT on success, positive on failure
298 *********************************************************************/
299
300static int
301em_probe(device_t dev)
302{
303        em_vendor_info_t *ent;
304
305        u_int16_t       pci_vendor_id = 0;
306        u_int16_t       pci_device_id = 0;
307        u_int16_t       pci_subvendor_id = 0;
308        u_int16_t       pci_subdevice_id = 0;
309        char            adapter_name[60];
310
311        INIT_DEBUGOUT("em_probe: begin");
312
313        pci_vendor_id = pci_get_vendor(dev);
314        if (pci_vendor_id != EM_VENDOR_ID)
315                return(ENXIO);
316
317        pci_device_id = pci_get_device(dev);
318        pci_subvendor_id = pci_get_subvendor(dev);
319        pci_subdevice_id = pci_get_subdevice(dev);
320
321        ent = em_vendor_info_array;
322        while (ent->vendor_id != 0) {
323                if ((pci_vendor_id == ent->vendor_id) &&
324                    (pci_device_id == ent->device_id) &&
325
326                    ((pci_subvendor_id == ent->subvendor_id) ||
327                     (ent->subvendor_id == PCI_ANY_ID)) &&
328
329                    ((pci_subdevice_id == ent->subdevice_id) ||
330                     (ent->subdevice_id == PCI_ANY_ID))) {
331                        sprintf(adapter_name, "%s, Version - %s", 
332                                em_strings[ent->index], 
333                                em_driver_version);
334                        device_set_desc_copy(dev, adapter_name);
335                        return(BUS_PROBE_DEFAULT);
336                }
337                ent++;
338        }
339
340        return(ENXIO);
341}
342
343/*********************************************************************
344 *  Device initialization routine
345 *
346 *  The attach entry point is called when the driver is being loaded.
347 *  This routine identifies the type of hardware, allocates all resources
348 *  and initializes the hardware.     
349 * 
350 *  return 0 on success, positive on failure
351 *********************************************************************/
352
353static int
354em_attach(device_t dev)
355{
356        struct adapter * adapter;
357        int             tsize, rsize;
358        int             error = 0;
359
360        INIT_DEBUGOUT("em_attach: begin");
361
362        /* Allocate, clear, and link in our adapter structure */
363        if (!(adapter = device_get_softc(dev))) {
364                printf("em: adapter structure allocation failed\n");
365                return(ENOMEM);
366        }
367#ifndef __rtems__
368        bzero(adapter, sizeof(struct adapter ));
369#else
370        /* softc structure is maintained outside of this
371         * and the osdep already contains vital fields (memory address)
372         */
373#endif
374        adapter->dev = dev;
375        adapter->osdep.dev = dev;
376        adapter->unit = device_get_unit(dev);
377        EM_LOCK_INIT(adapter, device_get_nameunit(dev));
378
379        if (em_adapter_list != NULL)
380                em_adapter_list->prev = adapter;
381        adapter->next = em_adapter_list;
382        em_adapter_list = adapter;
383
384#ifndef __rtems__
385        /* SYSCTL stuff */
386        SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
387                        SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
388                        OID_AUTO, "debug_info", CTLTYPE_INT|CTLFLAG_RW,
389                        (void *)adapter, 0,
390                        em_sysctl_debug_info, "I", "Debug Information");
391       
392        SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
393                        SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
394                        OID_AUTO, "stats", CTLTYPE_INT|CTLFLAG_RW,
395                        (void *)adapter, 0,
396                        em_sysctl_stats, "I", "Statistics");
397#endif
398
399        callout_init(&adapter->timer, CALLOUT_MPSAFE);
400        callout_init(&adapter->tx_fifo_timer, CALLOUT_MPSAFE);
401
402        /* Determine hardware revision */
403        em_identify_hardware(adapter);
404
405#ifndef __rtems__
406        /* Set up some sysctls for the tunable interrupt delays */
407        em_add_int_delay_sysctl(adapter, "rx_int_delay",
408            "receive interrupt delay in usecs", &adapter->rx_int_delay,
409            E1000_REG_OFFSET(&adapter->hw, RDTR), em_rx_int_delay_dflt);
410        em_add_int_delay_sysctl(adapter, "tx_int_delay",
411            "transmit interrupt delay in usecs", &adapter->tx_int_delay,
412            E1000_REG_OFFSET(&adapter->hw, TIDV), em_tx_int_delay_dflt);
413        if (adapter->hw.mac_type >= em_82540) {
414                em_add_int_delay_sysctl(adapter, "rx_abs_int_delay",
415                    "receive interrupt delay limit in usecs",
416                    &adapter->rx_abs_int_delay,
417                    E1000_REG_OFFSET(&adapter->hw, RADV),
418                    em_rx_abs_int_delay_dflt);
419                em_add_int_delay_sysctl(adapter, "tx_abs_int_delay",
420                    "transmit interrupt delay limit in usecs",
421                    &adapter->tx_abs_int_delay,
422                    E1000_REG_OFFSET(&adapter->hw, TADV),
423                    em_tx_abs_int_delay_dflt);
424        }
425#endif
426     
427        /* Parameters (to be read from user) */   
428        adapter->num_tx_desc = EM_MAX_TXD;
429        adapter->num_rx_desc = EM_MAX_RXD;
430#ifdef __rtems__
431                if ( dev->d_ifconfig->rbuf_count > 0 ) {
432                        adapter->num_rx_desc = dev->d_ifconfig->rbuf_count;
433                }
434                if ( adapter->num_rx_desc < 80 )
435                        adapter->num_rx_desc = 80;
436                if ( adapter->num_rx_desc > 256 )
437                        adapter->num_rx_desc = 256;
438                if ( dev->d_ifconfig->xbuf_count > 0 ) {
439                        adapter->num_tx_desc = dev->d_ifconfig->xbuf_count;
440                }
441                if ( adapter->num_tx_desc < 80 )
442                        adapter->num_tx_desc = 80;
443                if ( adapter->num_tx_desc > 256 )
444                        adapter->num_tx_desc = 256;
445                adapter->tx_cleanup_threshold = adapter->num_tx_desc/8;
446#endif
447        adapter->hw.autoneg = DO_AUTO_NEG;
448        adapter->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT;
449        adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
450        adapter->hw.tbi_compatibility_en = TRUE;
451        adapter->rx_buffer_len = EM_RXBUFFER_2048;
452                       
453        /*
454         * These parameters control the automatic generation(Tx) and
455         * response(Rx) to Ethernet PAUSE frames.
456         */
457        adapter->hw.fc_high_water = FC_DEFAULT_HI_THRESH;
458        adapter->hw.fc_low_water  = FC_DEFAULT_LO_THRESH;
459        adapter->hw.fc_pause_time = FC_DEFAULT_TX_TIMER;
460        adapter->hw.fc_send_xon   = TRUE;
461        adapter->hw.fc = em_fc_full;
462
463        adapter->hw.phy_init_script = 1;
464        adapter->hw.phy_reset_disable = FALSE;
465
466#ifndef EM_MASTER_SLAVE
467        adapter->hw.master_slave = em_ms_hw_default;
468#else
469        adapter->hw.master_slave = EM_MASTER_SLAVE;
470#endif
471        /*
472         * Set the max frame size assuming standard ethernet
473         * sized frames
474         */   
475        adapter->hw.max_frame_size = 
476                ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN;
477
478        adapter->hw.min_frame_size = 
479                MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN;
480
481        /*
482         * This controls when hardware reports transmit completion
483         * status.
484         */
485        adapter->hw.report_tx_early = 1;
486
487
488        if (em_allocate_pci_resources(adapter)) {
489                printf("em%d: Allocation of PCI resources failed\n", 
490                       adapter->unit);
491                error = ENXIO;
492                goto err_pci;
493        }
494 
495       
496        /* Initialize eeprom parameters */
497        em_init_eeprom_params(&adapter->hw);
498
499        tsize = EM_ROUNDUP(adapter->num_tx_desc *
500                           sizeof(struct em_tx_desc), 4096);
501
502        /* Allocate Transmit Descriptor ring */
503        if (em_dma_malloc(adapter, tsize, &adapter->txdma, BUS_DMA_NOWAIT)) {
504                printf("em%d: Unable to allocate tx_desc memory\n",
505                       adapter->unit);
506                error = ENOMEM;
507                goto err_tx_desc;
508        }
509        adapter->tx_desc_base = (struct em_tx_desc *) adapter->txdma.dma_vaddr;
510
511        rsize = EM_ROUNDUP(adapter->num_rx_desc *
512                           sizeof(struct em_rx_desc), 4096);
513
514        /* Allocate Receive Descriptor ring */ 
515        if (em_dma_malloc(adapter, rsize, &adapter->rxdma, BUS_DMA_NOWAIT)) {
516                printf("em%d: Unable to allocate rx_desc memory\n",
517                        adapter->unit);
518                error = ENOMEM;
519                goto err_rx_desc;
520        }
521        adapter->rx_desc_base = (struct em_rx_desc *) adapter->rxdma.dma_vaddr;
522
523        /* Initialize the hardware */
524        if (em_hardware_init(adapter)) {
525                printf("em%d: Unable to initialize the hardware\n",
526                       adapter->unit);
527                error = EIO;
528                goto err_hw_init;
529        }
530
531        /* Copy the permanent MAC address out of the EEPROM */
532        if (em_read_mac_addr(&adapter->hw) < 0) {
533                printf("em%d: EEPROM read error while reading mac address\n",
534                       adapter->unit);
535                error = EIO;
536                goto err_mac_addr;
537        }
538
539#ifdef __rtems__
540        /* if the configuration has not set a mac address, copy the permanent
541         * address from the device to the arpcom struct.
542         */
543        {
544        int i;
545                for ( i=0; i<ETHER_ADDR_LEN; i++ ) {
546                        if ( adapter->arpcom.ac_enaddr[i] )
547                                break;
548                }
549                if ( i >= ETHER_ADDR_LEN ) {
550                        /* all nulls */
551                bcopy(adapter->hw.mac_addr, adapter->arpcom.ac_enaddr,
552                   ETHER_ADDR_LEN);
553                }
554        }
555#endif
556
557        if (!em_is_valid_ether_addr(adapter->hw.mac_addr)) {
558                printf("em%d: Invalid mac address\n", adapter->unit);
559                error = EIO;
560                goto err_mac_addr;
561        }
562
563        /* Setup OS specific network interface */
564        em_setup_interface(dev, adapter);
565
566        /* Initialize statistics */
567        em_clear_hw_cntrs(&adapter->hw);
568        em_update_stats_counters(adapter);
569        adapter->hw.get_link_status = 1;
570#ifndef __rtems__
571        em_check_for_link(&adapter->hw);
572#else
573        /* first check during hw init usually fails - probably we need to wait longer;
574         * could take a while till the link is up, depends on the partner?
575         * in any case, rather than waiting here we just proceed...
576         */
577        em_check_for_link(&adapter->hw);
578        /* em_check_for_link doesn't update 'link_active'
579         * -- they usually call em_print_link_status() right
580         * after check_for_link, so let's repeat this
581         * algorithm here.
582         */
583        em_print_link_status(adapter);
584#endif
585
586        /* Print the link status */
587        if (adapter->link_active == 1) {
588                em_get_speed_and_duplex(&adapter->hw, &adapter->link_speed, 
589                                        &adapter->link_duplex);
590                printf("em%d:  Speed:%d Mbps  Duplex:%s\n",
591                       adapter->unit,
592                       adapter->link_speed,
593                       adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half");
594        } else
595                printf("em%d:  Speed:N/A  Duplex:N/A\n", adapter->unit);
596
597        /* Identify 82544 on PCIX */
598        em_get_bus_info(&adapter->hw);
599        if(adapter->hw.bus_type == em_bus_type_pcix &&
600           adapter->hw.mac_type == em_82544) {
601                adapter->pcix_82544 = TRUE;
602        }
603        else {
604                adapter->pcix_82544 = FALSE;
605        }
606        INIT_DEBUGOUT("em_attach: end");
607        return(0);
608
609err_mac_addr:
610err_hw_init:
611        em_dma_free(adapter, &adapter->rxdma);
612err_rx_desc:
613        em_dma_free(adapter, &adapter->txdma);
614err_tx_desc:
615err_pci:
616#ifndef __rtems__
617        em_free_pci_resources(adapter);
618#endif
619        return(error);
620
621}
622
623/*********************************************************************
624 *  Device removal routine
625 *
626 *  The detach entry point is called when the driver is being removed.
627 *  This routine stops the adapter and deallocates all the resources
628 *  that were allocated for driver operation.
629 * 
630 *  return 0 on success, positive on failure
631 *********************************************************************/
632
633#if !defined(__rtems__) || defined(DEBUG_MODULAR)
634
635static int
636em_detach(device_t dev)
637{
638        struct adapter * adapter = device_get_softc(dev);
639        struct ifnet   *ifp = &adapter->arpcom.ac_if;
640
641        INIT_DEBUGOUT("em_detach: begin");
642
643        EM_LOCK(adapter);
644        adapter->in_detach = 1;
645        em_stop(adapter);
646        em_phy_hw_reset(&adapter->hw);
647        EM_UNLOCK(adapter);
648#ifndef __rtems__
649#if __FreeBSD_version < 500000
650        ether_ifdetach(adapter->ifp, ETHER_BPF_SUPPORTED);
651#else
652        ether_ifdetach(adapter->ifp);
653        if_free(ifp);
654#endif
655        em_free_pci_resources(adapter);
656        bus_generic_detach(dev);
657#else
658        ether_ifdetach(ifp);
659#endif
660
661        /* Free Transmit Descriptor ring */
662        if (adapter->tx_desc_base) {
663                em_dma_free(adapter, &adapter->txdma);
664                adapter->tx_desc_base = NULL;
665        }
666
667        /* Free Receive Descriptor ring */
668        if (adapter->rx_desc_base) {
669                em_dma_free(adapter, &adapter->rxdma);
670                adapter->rx_desc_base = NULL;
671        }
672
673        /* Remove from the adapter list */
674        if (em_adapter_list == adapter)
675                em_adapter_list = adapter->next;
676        if (adapter->next != NULL)
677                adapter->next->prev = adapter->prev;
678        if (adapter->prev != NULL)
679                adapter->prev->next = adapter->next;
680
681        EM_LOCK_DESTROY(adapter);
682
683        ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
684        ifp->if_timer = 0;
685
686        return(0);
687}
688
689#endif
690
691#ifndef __rtems__
692/*********************************************************************
693 *
694 *  Shutdown entry point
695 *
696 **********************************************************************/ 
697
698static int
699em_shutdown(device_t dev)
700{
701        struct adapter *adapter = device_get_softc(dev);
702        EM_LOCK(adapter);
703        em_stop(adapter);
704        EM_UNLOCK(adapter);
705        return(0);
706}
707#endif
708
709/*********************************************************************
710 *  Transmit entry point
711 *
712 *  em_start is called by the stack to initiate a transmit.
713 *  The driver will remain in this routine as long as there are
714 *  packets to transmit and transmit resources are available.
715 *  In case resources are not available stack is notified and
716 *  the packet is requeued.
717 **********************************************************************/
718
719static void
720em_start_locked(struct ifnet *ifp)
721{
722        struct mbuf    *m_head;
723        struct adapter *adapter = ifp->if_softc;
724
725        mtx_assert(&adapter->mtx, MA_OWNED);
726
727        if (!adapter->link_active)
728                return;
729
730        while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
731
732                IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
733               
734                if (m_head == NULL) break;
735
736                /*
737                 * em_encap() can modify our pointer, and or make it NULL on
738                 * failure.  In that event, we can't requeue.
739                 */
740                if (em_encap(adapter, &m_head)) { 
741                        if (m_head == NULL)
742                                break;
743                        ifp->if_flags |= IFF_OACTIVE;
744                        IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
745                        break;
746                }
747
748                /* Send a copy of the frame to the BPF listener */
749#if __FreeBSD_version < 500000 && !defined(__rtems__)
750                if (ifp->if_bpf)
751                        bpf_mtap(ifp, m_head);
752#else
753                BPF_MTAP(ifp, m_head);
754#endif
755       
756                /* Set timeout in case hardware has problems transmitting */
757                ifp->if_timer = EM_TX_TIMEOUT;
758       
759        }
760        return;
761}
762
763static void
764em_start(struct ifnet *ifp)
765{
766        struct adapter *adapter RTEMS_UNUSED = ifp->if_softc;
767
768        EM_LOCK(adapter);
769        em_start_locked(ifp);
770        EM_UNLOCK(adapter);
771        return;
772}
773
774/*********************************************************************
775 *  Ioctl entry point
776 *
777 *  em_ioctl is called when the user wants to configure the
778 *  interface.
779 *
780 *  return 0 on success, positive on failure
781 **********************************************************************/
782
783#ifndef __rtems__
784static int
785em_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
786#else
787static int
788em_ioctl(struct ifnet *ifp, ioctl_command_t command, caddr_t data)
789#endif
790{
791#ifndef __rtems__
792        int             mask, reinit, error = 0;
793#else
794        int             error = 0;
795#endif
796        struct ifreq   *ifr = (struct ifreq *) data;
797        struct adapter * adapter = ifp->if_softc;
798
799        if (adapter->in_detach) return(error);
800
801        switch (command) {
802        case SIOCSIFADDR:
803        case SIOCGIFADDR:
804                IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)");
805                ether_ioctl(ifp, command, data);
806                break;
807        case SIOCSIFMTU:
808                IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)");
809                if (ifr->ifr_mtu > MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN || \
810                        /* 82573 does not support jumbo frames */
811                        (adapter->hw.mac_type == em_82573 && ifr->ifr_mtu > ETHERMTU) ) {
812                        error = EINVAL;
813                } else {
814                        EM_LOCK(adapter);
815                        ifp->if_mtu = ifr->ifr_mtu;
816                        adapter->hw.max_frame_size = 
817                        ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
818                        em_init_locked(adapter);
819                        EM_UNLOCK(adapter);
820                }
821                break;
822        case SIOCSIFFLAGS:
823                IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)");
824                EM_LOCK(adapter);
825                if (ifp->if_flags & IFF_UP) {
826                        if (!(ifp->if_flags & IFF_RUNNING)) {
827                                em_init_locked(adapter);
828                        }
829
830                        em_disable_promisc(adapter);
831                        em_set_promisc(adapter);
832                } else {
833                        if (ifp->if_flags & IFF_RUNNING) {
834                                em_stop(adapter);
835                        }
836                }
837                EM_UNLOCK(adapter);
838                break;
839        case SIOCADDMULTI:
840        case SIOCDELMULTI:
841#ifdef __rtems__
842                if ( (error = ( SIOCADDMULTI == command ?
843                                                        ether_addmulti( ifr, (struct arpcom*)ifp ) :
844                                                        ether_delmulti( ifr, (struct arpcom*)ifp ) ) ) ) {
845                        if ( ENETRESET == error )
846                                error = 0;
847                        else
848                                break;
849                }
850#endif
851                IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI");
852                if (ifp->if_flags & IFF_RUNNING) {
853                        EM_LOCK(adapter);
854                        em_disable_intr(adapter);
855                        em_set_multi(adapter);
856                        if (adapter->hw.mac_type == em_82542_rev2_0) {
857                                em_initialize_receive_unit(adapter);
858                        }
859#ifdef DEVICE_POLLING
860                        if (!(ifp->if_flags & IFF_POLLING))
861#endif
862                                em_enable_intr(adapter);
863                        EM_UNLOCK(adapter);
864                }
865                break;
866#ifndef __rtems__
867        case SIOCSIFMEDIA:
868        case SIOCGIFMEDIA:
869                IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)");
870                error = ifmedia_ioctl(ifp, ifr, &adapter->media, command);
871        break;
872#else
873        case SIOCSIFMEDIA:
874                {
875                struct rtems_ifmedia mhack;
876                        mhack.ifm_media = ifr->ifr_media;
877                        error = em_media_change(ifp, &mhack);
878                }
879        break;
880        case SIOCGIFMEDIA:
881                {
882                struct ifmediareq ifmr;
883                        em_media_status(ifp, &ifmr);
884                        ifr->ifr_media = ifmr.ifm_active;
885                        /* add-in rtems flags */
886                        if ( adapter->link_active )
887                                ifr->ifr_media |= IFM_LINK_OK;
888                        if ( !adapter->hw.autoneg )
889                                ifr->ifr_media |= IFM_ANEG_DIS;
890                        error = 0;
891                }
892        break;
893#endif
894#ifndef __rtems__
895        case SIOCSIFCAP:
896                IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)");
897                reinit = 0;
898                mask = ifr->ifr_reqcap ^ ifp->if_capenable;
899                if (mask & IFCAP_POLLING)
900                        ifp->if_capenable ^= IFCAP_POLLING;
901                if (mask & IFCAP_HWCSUM) {
902                        ifp->if_capenable ^= IFCAP_HWCSUM;
903                        reinit = 1;
904                }
905                if (mask & IFCAP_VLAN_HWTAGGING) {
906                        ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
907                        reinit = 1;
908                }
909                if (reinit && (ifp->if_flags & IFF_RUNNING))
910                        em_init(adapter);
911                break;
912#endif
913
914#ifdef __rtems__
915        case SIO_RTEMS_SHOW_STATS:
916                em_print_hw_stats(adapter);
917                error = 0;
918                break;
919#endif
920
921        default:
922                IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%x)", (int)command);
923                error = EINVAL;
924        }
925
926        return(error);
927}
928
929/*********************************************************************
930 *  Watchdog entry point
931 *
932 *  This routine is called whenever hardware quits transmitting.
933 *
934 **********************************************************************/
935
936static void
937em_watchdog(struct ifnet *ifp)
938{
939        struct adapter * adapter;
940        adapter = ifp->if_softc;
941
942        /* If we are in this routine because of pause frames, then
943         * don't reset the hardware.
944         */
945        if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF) {
946                ifp->if_timer = EM_TX_TIMEOUT;
947                return;
948        }
949
950        if (em_check_for_link(&adapter->hw))
951                printf("em%d: watchdog timeout -- resetting\n", adapter->unit);
952
953        ifp->if_flags &= ~IFF_RUNNING;
954
955        em_init(adapter);
956
957        ifp->if_oerrors++;
958        return;
959}
960
961/*********************************************************************
962 *  Init entry point
963 *
964 *  This routine is used in two ways. It is used by the stack as
965 *  init entry point in network interface structure. It is also used
966 *  by the driver as a hw/sw initialization routine to get to a
967 *  consistent state.
968 *
969 *  return 0 on success, positive on failure
970 **********************************************************************/
971
972static void
973em_init_locked(struct adapter * adapter)
974{
975        struct ifnet   *ifp;
976
977        uint32_t        pba;
978        ifp = &adapter->arpcom.ac_if;
979
980        INIT_DEBUGOUT("em_init: begin");
981
982        mtx_assert(&adapter->mtx, MA_OWNED);
983
984        em_stop(adapter);
985
986        /* Packet Buffer Allocation (PBA)
987         * Writing PBA sets the receive portion of the buffer
988         * the remainder is used for the transmit buffer.
989         *
990         * Devices before the 82547 had a Packet Buffer of 64K.
991         *   Default allocation: PBA=48K for Rx, leaving 16K for Tx.
992         * After the 82547 the buffer was reduced to 40K.
993         *   Default allocation: PBA=30K for Rx, leaving 10K for Tx.
994         *   Note: default does not leave enough room for Jumbo Frame >10k.
995         */
996        if(adapter->hw.mac_type < em_82547) {
997                /* Total FIFO is 64K */
998                if(adapter->rx_buffer_len > EM_RXBUFFER_8192)
999                        pba = E1000_PBA_40K; /* 40K for Rx, 24K for Tx */
1000                else
1001                        pba = E1000_PBA_48K; /* 48K for Rx, 16K for Tx */
1002        } else {
1003                /* Total FIFO is 40K */
1004                if(adapter->hw.max_frame_size > EM_RXBUFFER_8192) {
1005                        pba = E1000_PBA_22K; /* 22K for Rx, 18K for Tx */
1006                } else {
1007                        pba = E1000_PBA_30K; /* 30K for Rx, 10K for Tx */
1008                }
1009                adapter->tx_fifo_head = 0;
1010                adapter->tx_head_addr = pba << EM_TX_HEAD_ADDR_SHIFT;
1011                adapter->tx_fifo_size = (E1000_PBA_40K - pba) << EM_PBA_BYTES_SHIFT;
1012        }
1013        INIT_DEBUGOUT1("em_init: pba=%" PRId32 "K",pba);
1014        E1000_WRITE_REG(&adapter->hw, PBA, pba);
1015       
1016        /* Get the latest mac address, User can use a LAA */
1017        bcopy(adapter->arpcom.ac_enaddr, adapter->hw.mac_addr,
1018              ETHER_ADDR_LEN);
1019
1020        /* Initialize the hardware */
1021        if (em_hardware_init(adapter)) {
1022                printf("em%d: Unable to initialize the hardware\n", 
1023                       adapter->unit);
1024                return;
1025        }
1026
1027#ifndef __rtems__
1028        if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
1029                em_enable_vlans(adapter);
1030#endif
1031
1032        /* Prepare transmit descriptors and buffers */
1033        if (em_setup_transmit_structures(adapter)) {
1034                printf("em%d: Could not setup transmit structures\n", 
1035                       adapter->unit);
1036                em_stop(adapter); 
1037                return;
1038        }
1039        em_initialize_transmit_unit(adapter);
1040
1041        /* Setup Multicast table */
1042        em_set_multi(adapter);
1043
1044        /* Prepare receive descriptors and buffers */
1045        if (em_setup_receive_structures(adapter)) {
1046                printf("em%d: Could not setup receive structures\n", 
1047                       adapter->unit);
1048                em_stop(adapter);
1049                return;
1050        }
1051        em_initialize_receive_unit(adapter);
1052 
1053        /* Don't loose promiscuous settings */
1054        em_set_promisc(adapter);
1055
1056        ifp->if_flags |= IFF_RUNNING;
1057        ifp->if_flags &= ~IFF_OACTIVE;
1058
1059#ifndef __rtems__
1060        if (adapter->hw.mac_type >= em_82543) {
1061                if (ifp->if_capenable & IFCAP_TXCSUM)
1062                        ifp->if_hwassist = EM_CHECKSUM_FEATURES;
1063                else
1064                        ifp->if_hwassist = 0;
1065        }
1066#endif
1067
1068        callout_reset(&adapter->timer, hz, em_local_timer, adapter);
1069        em_clear_hw_cntrs(&adapter->hw);
1070#ifdef DEVICE_POLLING
1071        /*
1072         * Only enable interrupts if we are not polling, make sure
1073         * they are off otherwise.
1074         */
1075        if (ifp->if_flags & IFF_POLLING)
1076                em_disable_intr(adapter);
1077        else
1078#endif /* DEVICE_POLLING */
1079                em_enable_intr(adapter);
1080
1081        /* Don't reset the phy next time init gets called */
1082        adapter->hw.phy_reset_disable = TRUE;
1083       
1084        return;
1085}
1086
1087static void
1088em_init(void *arg)
1089{
1090        struct adapter * adapter = arg;
1091
1092        EM_LOCK(adapter);
1093        em_init_locked(adapter);
1094        EM_UNLOCK(adapter);
1095        return;
1096}
1097
1098
1099#ifdef DEVICE_POLLING
1100static poll_handler_t em_poll;
1101       
1102static void     
1103em_poll_locked(struct ifnet *ifp, enum poll_cmd cmd, int count)
1104{
1105        struct adapter *adapter = ifp->if_softc;
1106        u_int32_t reg_icr;
1107
1108        mtx_assert(&adapter->mtx, MA_OWNED);
1109
1110        if (!(ifp->if_capenable & IFCAP_POLLING)) {
1111                ether_poll_deregister(ifp);
1112                cmd = POLL_DEREGISTER;
1113        }
1114        if (cmd == POLL_DEREGISTER) {       /* final call, enable interrupts */
1115                em_enable_intr(adapter);
1116                return;
1117        }
1118        if (cmd == POLL_AND_CHECK_STATUS) {
1119                reg_icr = E1000_READ_REG(&adapter->hw, ICR);
1120                if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
1121                        callout_stop(&adapter->timer);
1122                        adapter->hw.get_link_status = 1;
1123                        em_check_for_link(&adapter->hw);
1124                        em_print_link_status(adapter);
1125                        callout_reset(&adapter->timer, hz, em_local_timer, adapter);
1126                }
1127        }
1128        if (ifp->if_flags & IFF_RUNNING) {
1129                em_process_receive_interrupts(adapter, count);
1130                em_clean_transmit_interrupts(adapter);
1131        }
1132       
1133        if (ifp->if_flags & IFF_RUNNING && !IFQ_DRV_IS_EMPTY(&ifp->if_snd))
1134                em_start_locked(ifp);
1135}
1136       
1137static void     
1138em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
1139{
1140        struct adapter *adapter = ifp->if_softc;
1141
1142        EM_LOCK(adapter);
1143        em_poll_locked(ifp, cmd, count);
1144        EM_UNLOCK(adapter);
1145}
1146#endif /* DEVICE_POLLING */
1147
1148/*********************************************************************
1149 *
1150 *  Interrupt Service routine 
1151 *
1152 **********************************************************************/
1153static void
1154em_intr(void *arg)
1155{
1156        u_int32_t       loop_cnt = EM_MAX_INTR;
1157        u_int32_t       reg_icr;
1158        struct ifnet    *ifp;
1159        struct adapter  *adapter = arg;
1160
1161        EM_LOCK(adapter);
1162
1163        ifp = &adapter->arpcom.ac_if; 
1164
1165#ifdef DEVICE_POLLING
1166        if (ifp->if_flags & IFF_POLLING) {
1167                EM_UNLOCK(adapter);
1168                return;
1169        }
1170
1171        if ((ifp->if_capenable & IFCAP_POLLING) &&
1172            ether_poll_register(em_poll, ifp)) {
1173                em_disable_intr(adapter);
1174                em_poll_locked(ifp, 0, 1);
1175                EM_UNLOCK(adapter);
1176                return;
1177        }
1178#endif /* DEVICE_POLLING */
1179
1180        reg_icr = E1000_READ_REG(&adapter->hw, ICR);
1181        if (!reg_icr) { 
1182                EM_UNLOCK(adapter);
1183                return;
1184        }
1185
1186        /* Link status change */
1187        if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
1188                callout_stop(&adapter->timer);
1189                adapter->hw.get_link_status = 1;
1190                em_check_for_link(&adapter->hw);
1191                em_print_link_status(adapter);
1192                callout_reset(&adapter->timer, hz, em_local_timer, adapter);
1193        }
1194
1195        while (loop_cnt > 0) { 
1196                if (ifp->if_flags & IFF_RUNNING) {
1197                        em_process_receive_interrupts(adapter, -1);
1198                        em_clean_transmit_interrupts(adapter);
1199                }
1200                loop_cnt--;
1201        }
1202                 
1203        if (ifp->if_flags & IFF_RUNNING && !IFQ_DRV_IS_EMPTY(&ifp->if_snd))
1204                em_start_locked(ifp);
1205
1206        EM_UNLOCK(adapter);
1207        return;
1208}
1209
1210
1211
1212/*********************************************************************
1213 *
1214 *  Media Ioctl callback
1215 *
1216 *  This routine is called whenever the user queries the status of
1217 *  the interface using ifconfig.
1218 *
1219 **********************************************************************/
1220static void
1221em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
1222{
1223        struct adapter * adapter = ifp->if_softc;
1224
1225        INIT_DEBUGOUT("em_media_status: begin");
1226
1227        em_check_for_link(&adapter->hw);
1228        if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
1229                if (adapter->link_active == 0) {
1230                        em_get_speed_and_duplex(&adapter->hw, 
1231                                                &adapter->link_speed, 
1232                                                &adapter->link_duplex);
1233                        adapter->link_active = 1;
1234                }
1235        } else {
1236                if (adapter->link_active == 1) {
1237                        adapter->link_speed = 0;
1238                        adapter->link_duplex = 0;
1239                        adapter->link_active = 0;
1240                }
1241        }
1242
1243        ifmr->ifm_status = IFM_AVALID;
1244        ifmr->ifm_active = IFM_ETHER;
1245
1246        if (!adapter->link_active)
1247                return;
1248
1249        ifmr->ifm_status |= IFM_ACTIVE;
1250
1251        if (adapter->hw.media_type == em_media_type_fiber) {
1252                ifmr->ifm_active |= IFM_1000_SX | IFM_FDX;
1253        } else {
1254                switch (adapter->link_speed) {
1255                case 10:
1256                        ifmr->ifm_active |= IFM_10_T;
1257                        break;
1258                case 100:
1259                        ifmr->ifm_active |= IFM_100_TX;
1260                        break;
1261                case 1000:
1262#if __FreeBSD_version < 500000 && !defined(__rtems__)
1263                        ifmr->ifm_active |= IFM_1000_TX;
1264#else
1265                        ifmr->ifm_active |= IFM_1000_T;
1266#endif
1267                        break;
1268                }
1269                if (adapter->link_duplex == FULL_DUPLEX)
1270                        ifmr->ifm_active |= IFM_FDX;
1271                else
1272                        ifmr->ifm_active |= IFM_HDX;
1273        }
1274        return;
1275}
1276
1277/*********************************************************************
1278 *
1279 *  Media Ioctl callback
1280 *
1281 *  This routine is called when the user changes speed/duplex using
1282 *  media/mediopt option with ifconfig.
1283 *
1284 **********************************************************************/
1285static int
1286#ifndef __rtems__
1287em_media_change(struct ifnet *ifp)
1288#else
1289em_media_change(struct ifnet *ifp, struct rtems_ifmedia *ifm)
1290#endif
1291{
1292        struct adapter * adapter = ifp->if_softc;
1293#ifndef __rtems__
1294        struct ifmedia  *ifm = &adapter->media;
1295#endif
1296
1297        INIT_DEBUGOUT("em_media_change: begin");
1298
1299        if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
1300                return(EINVAL);
1301
1302        switch (IFM_SUBTYPE(ifm->ifm_media)) {
1303        case IFM_AUTO:
1304                adapter->hw.autoneg = DO_AUTO_NEG;
1305                adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
1306                break;
1307        case IFM_1000_SX:
1308#if __FreeBSD_version < 500000 && !defined(__rtems__)
1309        case IFM_1000_TX:
1310#else
1311        case IFM_1000_T:
1312#endif
1313                adapter->hw.autoneg = DO_AUTO_NEG;
1314                adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
1315                break;
1316        case IFM_100_TX:
1317                adapter->hw.autoneg = FALSE;
1318                adapter->hw.autoneg_advertised = 0;
1319                if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
1320                        adapter->hw.forced_speed_duplex = em_100_full;
1321                else
1322                        adapter->hw.forced_speed_duplex = em_100_half;
1323                break;
1324        case IFM_10_T:
1325                adapter->hw.autoneg = FALSE;
1326                adapter->hw.autoneg_advertised = 0;
1327                if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
1328                        adapter->hw.forced_speed_duplex = em_10_full;
1329                else
1330                        adapter->hw.forced_speed_duplex = em_10_half;
1331                break;
1332        default:
1333                printf("em%d: Unsupported media type\n", adapter->unit);
1334        }
1335
1336        /* As the speed/duplex settings my have changed we need to
1337         * reset the PHY.
1338         */
1339        adapter->hw.phy_reset_disable = FALSE;
1340
1341        em_init(adapter);
1342
1343        return(0);
1344}
1345
1346/*********************************************************************
1347 *
1348 *  This routine maps the mbufs to tx descriptors.
1349 *
1350 *  return 0 on success, positive on failure
1351 **********************************************************************/
1352static int             
1353em_encap(struct adapter *adapter, struct mbuf **m_headp)
1354{
1355        u_int32_t       txd_upper;
1356        u_int32_t       txd_lower, txd_used = 0, txd_saved = 0;
1357        int             i, j, error;
1358        u_int64_t       address;
1359
1360        struct mbuf     *m_head;
1361
1362        /* For 82544 Workaround */
1363        DESC_ARRAY              desc_array;
1364        u_int32_t               array_elements;
1365        u_int32_t               counter;
1366
1367#ifndef __rtems__
1368#if __FreeBSD_version < 500000
1369        struct ifvlan *ifv = NULL;
1370#else
1371        struct m_tag    *mtag;
1372#endif   
1373#endif
1374        bus_dma_segment_t       segs[EM_MAX_SCATTER];
1375#ifndef __rtems__
1376        bus_dmamap_t            map;
1377#endif
1378        int                     nsegs;
1379        struct em_buffer   *tx_buffer = NULL;
1380        struct em_tx_desc *current_tx_desc = NULL;
1381#ifndef __rtems__
1382        struct ifnet   *ifp = &adapter->arpcom.ac_if;
1383#endif
1384
1385        m_head = *m_headp;
1386
1387        /*
1388         * Force a cleanup if number of TX descriptors
1389         * available hits the threshold
1390         */
1391        if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
1392                em_clean_transmit_interrupts(adapter);
1393                if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
1394                        adapter->no_tx_desc_avail1++;
1395                        return(ENOBUFS);
1396                }
1397        }
1398
1399#ifndef __rtems__
1400        /*
1401         * Map the packet for DMA.
1402         */
1403        if (bus_dmamap_create(adapter->txtag, BUS_DMA_NOWAIT, &map)) {
1404                adapter->no_tx_map_avail++;
1405                return (ENOMEM);
1406        }
1407        error = bus_dmamap_load_mbuf_sg(adapter->txtag, map, m_head, segs,
1408                                        &nsegs, BUS_DMA_NOWAIT);
1409        if (error != 0) {
1410                adapter->no_tx_dma_setup++;
1411                bus_dmamap_destroy(adapter->txtag, map);
1412                return (error);
1413        }
1414#else
1415                (void)error;
1416                {
1417                struct mbuf *m;
1418                        for ( m=m_head, nsegs=0; m; m=m->m_next, nsegs++ ) {
1419                                if ( nsegs >= sizeof(segs)/sizeof(segs[0]) ) {
1420                                        break;
1421                                }
1422                                segs[nsegs].ds_addr = mtod(m, unsigned);
1423                                segs[nsegs].ds_len  = m->m_len;
1424                        }
1425                }
1426#endif
1427        KASSERT(nsegs != 0, ("em_encap: empty packet"));
1428
1429        if (nsegs > adapter->num_tx_desc_avail) {
1430                adapter->no_tx_desc_avail2++;
1431                bus_dmamap_destroy(adapter->txtag, map);
1432                return (ENOBUFS);
1433        }
1434
1435
1436#ifndef __rtems__
1437        if (ifp->if_hwassist > 0) {
1438                em_transmit_checksum_setup(adapter,  m_head,
1439                                           &txd_upper, &txd_lower);
1440        } else
1441#endif
1442                txd_upper = txd_lower = 0;
1443
1444
1445#ifndef __rtems__
1446        /* Find out if we are in vlan mode */
1447#if __FreeBSD_version < 500000
1448        if ((m_head->m_flags & (M_PROTO1|M_PKTHDR)) == (M_PROTO1|M_PKTHDR) &&
1449            m_head->m_pkthdr.rcvif != NULL &&
1450            m_head->m_pkthdr.rcvif->if_type == IFT_L2VLAN)
1451                ifv = m_head->m_pkthdr.rcvif->if_softc;
1452#else
1453        mtag = VLAN_OUTPUT_TAG(ifp, m_head);
1454#endif
1455
1456        /*
1457         * When operating in promiscuous mode, hardware encapsulation for
1458         * packets is disabled.  This means we have to add the vlan
1459         * encapsulation in the driver, since it will have come down from the
1460         * VLAN layer with a tag instead of a VLAN header.
1461         */
1462        if (mtag != NULL && adapter->em_insert_vlan_header) {
1463                struct ether_vlan_header *evl;
1464                struct ether_header eh;
1465
1466                m_head = m_pullup(m_head, sizeof(eh));
1467                if (m_head == NULL) {
1468                        *m_headp = NULL;
1469                        bus_dmamap_destroy(adapter->txtag, map);
1470                        return (ENOBUFS);
1471                }
1472                eh = *mtod(m_head, struct ether_header *);
1473                M_PREPEND(m_head, sizeof(*evl), M_DONTWAIT);
1474                if (m_head == NULL) {
1475                        *m_headp = NULL;
1476                        bus_dmamap_destroy(adapter->txtag, map);
1477                        return (ENOBUFS);
1478                }
1479                m_head = m_pullup(m_head, sizeof(*evl));
1480                if (m_head == NULL) {
1481                        *m_headp = NULL;
1482                        bus_dmamap_destroy(adapter->txtag, map);
1483                        return (ENOBUFS);
1484                }
1485                evl = mtod(m_head, struct ether_vlan_header *);
1486                bcopy(&eh, evl, sizeof(*evl));
1487                evl->evl_proto = evl->evl_encap_proto;
1488                evl->evl_encap_proto = htons(ETHERTYPE_VLAN);
1489                evl->evl_tag = htons(VLAN_TAG_VALUE(mtag));
1490                m_tag_delete(m_head, mtag);
1491                mtag = NULL;
1492                *m_headp = m_head;
1493        }
1494#endif
1495
1496        i = adapter->next_avail_tx_desc;
1497        if (adapter->pcix_82544) {
1498                txd_saved = i;
1499                txd_used = 0;
1500        }
1501        for (j = 0; j < nsegs; j++) {
1502                /* If adapter is 82544 and on PCIX bus */
1503                if(adapter->pcix_82544) {
1504                        array_elements = 0;
1505                        address = htole64(segs[j].ds_addr);
1506                        /*
1507                         * Check the Address and Length combination and
1508                         * split the data accordingly
1509                         */
1510                        array_elements = em_fill_descriptors(address,
1511                                                             htole32(segs[j].ds_len),
1512                                                             &desc_array);
1513                        for (counter = 0; counter < array_elements; counter++) {
1514                                if (txd_used == adapter->num_tx_desc_avail) {
1515                                         adapter->next_avail_tx_desc = txd_saved;
1516                                          adapter->no_tx_desc_avail2++;
1517                                          bus_dmamap_destroy(adapter->txtag, map);
1518                                          return (ENOBUFS);
1519                                }
1520                                tx_buffer = &adapter->tx_buffer_area[i];
1521                                current_tx_desc = &adapter->tx_desc_base[i];
1522                                current_tx_desc->buffer_addr = htole64(
1523                                        desc_array.descriptor[counter].address);
1524                                current_tx_desc->lower.data = htole32(
1525                                        (adapter->txd_cmd | txd_lower | 
1526                                         (u_int16_t)desc_array.descriptor[counter].length));
1527                                current_tx_desc->upper.data = htole32((txd_upper));
1528                                if (++i == adapter->num_tx_desc)
1529                                         i = 0;
1530
1531                                tx_buffer->m_head = NULL;
1532                                txd_used++;
1533                        }
1534                } else {
1535                        tx_buffer = &adapter->tx_buffer_area[i];
1536                        current_tx_desc = &adapter->tx_desc_base[i];
1537
1538                        current_tx_desc->buffer_addr = htole64(segs[j].ds_addr);
1539                        current_tx_desc->lower.data = htole32(
1540                                adapter->txd_cmd | txd_lower | segs[j].ds_len);
1541                        current_tx_desc->upper.data = htole32(txd_upper);
1542
1543                        if (++i == adapter->num_tx_desc)
1544                                i = 0;
1545
1546                        tx_buffer->m_head = NULL;
1547                }
1548        }
1549
1550        adapter->next_avail_tx_desc = i;
1551        if (adapter->pcix_82544) {
1552                adapter->num_tx_desc_avail -= txd_used;
1553        }
1554        else {
1555                adapter->num_tx_desc_avail -= nsegs;
1556        }
1557
1558#ifndef __rtems__
1559#if __FreeBSD_version < 500000
1560        if (ifv != NULL) {
1561                /* Set the vlan id */
1562                current_tx_desc->upper.fields.special = htole16(ifv->ifv_tag);
1563#else
1564        if (mtag != NULL) {
1565                /* Set the vlan id */
1566                current_tx_desc->upper.fields.special = htole16(VLAN_TAG_VALUE(mtag));
1567#endif
1568
1569                /* Tell hardware to add tag */
1570                current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_VLE);
1571        }
1572#endif
1573
1574        tx_buffer->m_head = m_head;
1575#ifndef __rtems__
1576        tx_buffer->map = map;
1577#endif
1578        bus_dmamap_sync(adapter->txtag, map, BUS_DMASYNC_PREWRITE);
1579
1580        /*
1581         * Last Descriptor of Packet needs End Of Packet (EOP)
1582         */
1583        current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_EOP);
1584
1585        /*
1586         * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000
1587         * that this frame is available to transmit.
1588         */
1589        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
1590            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1591        if (adapter->hw.mac_type == em_82547 &&
1592            adapter->link_duplex == HALF_DUPLEX) {
1593                em_82547_move_tail_locked(adapter);
1594        } else {
1595                E1000_WRITE_REG(&adapter->hw, TDT, i);
1596                if (adapter->hw.mac_type == em_82547) {
1597                        em_82547_update_fifo_head(adapter, m_head->m_pkthdr.len);
1598                }
1599        }
1600
1601        return(0);
1602}
1603
1604/*********************************************************************
1605 *
1606 * 82547 workaround to avoid controller hang in half-duplex environment.
1607 * The workaround is to avoid queuing a large packet that would span   
1608 * the internal Tx FIFO ring boundary. We need to reset the FIFO pointers
1609 * in this case. We do that only when FIFO is quiescent.
1610 *
1611 **********************************************************************/
1612static void
1613em_82547_move_tail_locked(struct adapter *adapter)
1614{
1615        uint16_t hw_tdt;
1616        uint16_t sw_tdt;
1617        struct em_tx_desc *tx_desc;
1618        uint16_t length = 0;
1619        boolean_t eop = 0;
1620
1621        EM_LOCK_ASSERT(adapter);
1622
1623        hw_tdt = E1000_READ_REG(&adapter->hw, TDT);
1624        sw_tdt = adapter->next_avail_tx_desc;
1625       
1626        while (hw_tdt != sw_tdt) {
1627                tx_desc = &adapter->tx_desc_base[hw_tdt];
1628                length += tx_desc->lower.flags.length;
1629                eop = tx_desc->lower.data & E1000_TXD_CMD_EOP;
1630                if(++hw_tdt == adapter->num_tx_desc)
1631                        hw_tdt = 0;
1632
1633                if(eop) {
1634                        if (em_82547_fifo_workaround(adapter, length)) {
1635                                adapter->tx_fifo_wrk_cnt++;
1636                                callout_reset(&adapter->tx_fifo_timer, 1,
1637                                        em_82547_move_tail, adapter);
1638                                break;
1639                        }
1640                        E1000_WRITE_REG(&adapter->hw, TDT, hw_tdt);
1641                        em_82547_update_fifo_head(adapter, length);
1642                        length = 0;
1643                }
1644        }       
1645        return;
1646}
1647
1648#ifndef __rtems__
1649static void
1650em_82547_move_tail(void *arg)
1651{
1652        struct adapter *adapter = arg;
1653
1654        EM_LOCK(adapter);
1655        em_82547_move_tail_locked(adapter);
1656        EM_UNLOCK(adapter);
1657}
1658#endif
1659
1660static int
1661em_82547_fifo_workaround(struct adapter *adapter, int len)
1662{       
1663        int fifo_space, fifo_pkt_len;
1664
1665        fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR);
1666
1667        if (adapter->link_duplex == HALF_DUPLEX) {
1668                fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
1669
1670                if (fifo_pkt_len >= (EM_82547_PKT_THRESH + fifo_space)) {
1671                        if (em_82547_tx_fifo_reset(adapter)) {
1672                                return(0);
1673                        }
1674                        else {
1675                                return(1);
1676                        }
1677                }
1678        }
1679
1680        return(0);
1681}
1682
1683static void
1684em_82547_update_fifo_head(struct adapter *adapter, int len)
1685{
1686        int fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR);
1687       
1688        /* tx_fifo_head is always 16 byte aligned */
1689        adapter->tx_fifo_head += fifo_pkt_len;
1690        if (adapter->tx_fifo_head >= adapter->tx_fifo_size) {
1691                adapter->tx_fifo_head -= adapter->tx_fifo_size;
1692        }
1693
1694        return;
1695}
1696
1697
1698static int
1699em_82547_tx_fifo_reset(struct adapter *adapter)
1700{       
1701        uint32_t tctl;
1702
1703        if ( (E1000_READ_REG(&adapter->hw, TDT) ==
1704              E1000_READ_REG(&adapter->hw, TDH)) &&
1705             (E1000_READ_REG(&adapter->hw, TDFT) == 
1706              E1000_READ_REG(&adapter->hw, TDFH)) &&
1707             (E1000_READ_REG(&adapter->hw, TDFTS) ==
1708              E1000_READ_REG(&adapter->hw, TDFHS)) &&
1709             (E1000_READ_REG(&adapter->hw, TDFPC) == 0)) {
1710
1711                /* Disable TX unit */
1712                tctl = E1000_READ_REG(&adapter->hw, TCTL);
1713                E1000_WRITE_REG(&adapter->hw, TCTL, tctl & ~E1000_TCTL_EN);
1714
1715                /* Reset FIFO pointers */
1716                E1000_WRITE_REG(&adapter->hw, TDFT,  adapter->tx_head_addr);
1717                E1000_WRITE_REG(&adapter->hw, TDFH,  adapter->tx_head_addr);
1718                E1000_WRITE_REG(&adapter->hw, TDFTS, adapter->tx_head_addr);
1719                E1000_WRITE_REG(&adapter->hw, TDFHS, adapter->tx_head_addr);
1720
1721                /* Re-enable TX unit */
1722                E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
1723                E1000_WRITE_FLUSH(&adapter->hw);
1724
1725                adapter->tx_fifo_head = 0;
1726                adapter->tx_fifo_reset_cnt++;
1727
1728                return(TRUE);
1729        }
1730        else {
1731                return(FALSE);
1732        }
1733}
1734
1735static void
1736em_set_promisc(struct adapter * adapter)
1737{
1738
1739        u_int32_t       reg_rctl;
1740        struct ifnet   *ifp = &adapter->arpcom.ac_if;
1741
1742        reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1743
1744        if (ifp->if_flags & IFF_PROMISC) {
1745                reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
1746                E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1747#ifndef __rtems__
1748                /* Disable VLAN stripping in promiscous mode
1749                 * This enables bridging of vlan tagged frames to occur
1750                 * and also allows vlan tags to be seen in tcpdump
1751                 */
1752                if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
1753                        em_disable_vlans(adapter);
1754                adapter->em_insert_vlan_header = 1;
1755#endif
1756        } else if (ifp->if_flags & IFF_ALLMULTI) {
1757                reg_rctl |= E1000_RCTL_MPE;
1758                reg_rctl &= ~E1000_RCTL_UPE;
1759                E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1760#ifndef __rtems__
1761                adapter->em_insert_vlan_header = 0;
1762        } else
1763                adapter->em_insert_vlan_header = 0;
1764#else
1765        }
1766#endif
1767
1768        return;
1769}
1770
1771static void
1772em_disable_promisc(struct adapter * adapter)
1773{
1774        u_int32_t       reg_rctl;
1775#ifndef __rtems__
1776        struct ifnet   *ifp = adapter->ifp;
1777#endif
1778
1779        reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1780
1781        reg_rctl &=  (~E1000_RCTL_UPE);
1782        reg_rctl &=  (~E1000_RCTL_MPE);
1783        E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1784
1785#ifndef __rtems__
1786        if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
1787                em_enable_vlans(adapter);
1788        adapter->em_insert_vlan_header = 0;
1789#endif
1790
1791        return;
1792}
1793
1794
1795/*********************************************************************
1796 *  Multicast Update
1797 *
1798 *  This routine is called whenever multicast address list is updated.
1799 *
1800 **********************************************************************/
1801
1802static void
1803em_set_multi(struct adapter * adapter)
1804{
1805        u_int32_t reg_rctl = 0;
1806        u_int8_t  mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS];
1807#ifndef __rtems__
1808        struct ifmultiaddr  *ifma;
1809#endif
1810        int mcnt = 0;
1811        struct ifnet   *ifp = &adapter->arpcom.ac_if;
1812   
1813        IOCTL_DEBUGOUT("em_set_multi: begin");
1814 
1815        if (adapter->hw.mac_type == em_82542_rev2_0) {
1816                reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1817                if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 
1818                        em_pci_clear_mwi(&adapter->hw);
1819                }
1820                reg_rctl |= E1000_RCTL_RST;
1821                E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1822                msec_delay(5);
1823        }
1824
1825#ifndef __rtems__
1826        IF_ADDR_LOCK(ifp);
1827#if __FreeBSD_version < 500000
1828        LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1829#else
1830        TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1831#endif 
1832                if (ifma->ifma_addr->sa_family != AF_LINK)
1833                        continue;
1834 
1835                if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) break;
1836
1837                bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
1838                      &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS);
1839                mcnt++;
1840        }
1841        IF_ADDR_UNLOCK(ifp);
1842#else
1843        {
1844        /* Don't know how to handle address ranges - we warn and ignore
1845         * for now...
1846         */
1847        struct ether_multi     *enm;
1848        struct ether_multistep step;
1849
1850                ETHER_FIRST_MULTI(step, (struct arpcom*)ifp, enm);
1851                while ( enm != NULL ) {
1852                        if ( mcnt == MAX_NUM_MULTICAST_ADDRESSES )
1853                                break;
1854                        if ( memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN) ) {
1855                                printk("if_em: Unable to handle multicast wildcard (not ported yet); skipping/ignoring\n");
1856                                goto skiptonext;
1857                        } else {
1858                                bcopy(enm->enm_addrlo, &mta[mcnt * ETHER_ADDR_LEN], ETHER_ADDR_LEN);
1859                        }
1860                        mcnt++;
1861skiptonext:
1862                        ETHER_NEXT_MULTI( step, enm );
1863                }
1864        }
1865#endif
1866
1867        if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) {
1868                reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1869                reg_rctl |= E1000_RCTL_MPE;
1870                E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1871        } else
1872                em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0, 1);
1873
1874        if (adapter->hw.mac_type == em_82542_rev2_0) {
1875                reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1876                reg_rctl &= ~E1000_RCTL_RST;
1877                E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1878                msec_delay(5);
1879                if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
1880                        em_pci_set_mwi(&adapter->hw);
1881                }
1882        }
1883
1884        return;
1885}
1886
1887#ifndef __rtems__
1888/*********************************************************************
1889 *  Timer routine
1890 *
1891 *  This routine checks for link status and updates statistics.
1892 *
1893 **********************************************************************/
1894
1895static void
1896em_local_timer(void *arg)
1897{
1898        struct ifnet   *ifp;
1899        struct adapter * adapter = arg;
1900        ifp = &adapter->arpcom.ac_if;
1901
1902        EM_LOCK(adapter);
1903
1904        em_check_for_link(&adapter->hw);
1905        em_print_link_status(adapter);
1906        em_update_stats_counters(adapter);   
1907        if (em_display_debug_stats && ifp->if_flags & IFF_RUNNING) {
1908                em_print_hw_stats(adapter);
1909        }
1910        em_smartspeed(adapter);
1911
1912        callout_reset(&adapter->timer, hz, em_local_timer, adapter);
1913
1914        EM_UNLOCK(adapter);
1915        return;
1916}
1917#endif
1918
1919static void
1920em_print_link_status(struct adapter * adapter)
1921{
1922#ifndef __rtems__
1923        struct ifnet *ifp = &adapter->arpcom.ac_if;
1924#endif
1925
1926        if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
1927                if (adapter->link_active == 0) {
1928                        em_get_speed_and_duplex(&adapter->hw, 
1929                                                &adapter->link_speed, 
1930                                                &adapter->link_duplex);
1931                        if (bootverbose)
1932                                printf("em%d: Link is up %d Mbps %s\n",
1933                                       adapter->unit,
1934                                       adapter->link_speed,
1935                                       ((adapter->link_duplex == FULL_DUPLEX) ?
1936                                        "Full Duplex" : "Half Duplex"));
1937                        adapter->link_active = 1;
1938                        adapter->smartspeed = 0;
1939#ifndef __rtems__
1940                        if_link_state_change(ifp, LINK_STATE_UP);
1941#endif
1942                }
1943        } else {
1944                if (adapter->link_active == 1) {
1945                        adapter->link_speed = 0;
1946                        adapter->link_duplex = 0;
1947                        if (bootverbose)
1948                                printf("em%d: Link is Down\n", adapter->unit);
1949                        adapter->link_active = 0;
1950#ifndef __rtems__
1951                        if_link_state_change(ifp, LINK_STATE_UP);
1952                        if_link_state_change(ifp, LINK_STATE_DOWN);
1953#endif
1954                }
1955        }
1956
1957        return;
1958}
1959
1960/*********************************************************************
1961 *
1962 *  This routine disables all traffic on the adapter by issuing a
1963 *  global reset on the MAC and deallocates TX/RX buffers.
1964 *
1965 **********************************************************************/
1966
1967static void
1968em_stop(void *arg)
1969{
1970        struct ifnet   *ifp;
1971        struct adapter * adapter = arg;
1972        ifp = &adapter->arpcom.ac_if;
1973
1974        mtx_assert(&adapter->mtx, MA_OWNED);
1975
1976        INIT_DEBUGOUT("em_stop: begin");
1977#ifdef DEVICE_POLLING
1978        ether_poll_deregister(ifp);
1979#endif
1980        em_disable_intr(adapter);
1981        em_reset_hw(&adapter->hw);
1982        callout_stop(&adapter->timer);
1983        callout_stop(&adapter->tx_fifo_timer);
1984        em_free_transmit_structures(adapter);
1985        em_free_receive_structures(adapter);
1986
1987
1988        /* Tell the stack that the interface is no longer active */
1989        ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1990
1991        return;
1992}
1993
1994
1995/*********************************************************************
1996 *
1997 *  Determine hardware revision.
1998 *
1999 **********************************************************************/
2000static void
2001em_identify_hardware(struct adapter * adapter)
2002{
2003        device_t dev = adapter->dev;
2004
2005        /* Make sure our PCI config space has the necessary stuff set */
2006        adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
2007        if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) &&
2008              (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) {
2009                printf("em%d: Memory Access and/or Bus Master bits were not set!\n", 
2010                       adapter->unit);
2011                adapter->hw.pci_cmd_word |= 
2012                (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN);
2013                pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2);
2014        }
2015
2016        /* Save off the information about this board */
2017        adapter->hw.vendor_id = pci_get_vendor(dev);
2018        adapter->hw.device_id = pci_get_device(dev);
2019        adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1);
2020        adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2);
2021        adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2);
2022
2023        /* Identify the MAC */
2024        if (em_set_mac_type(&adapter->hw))
2025                printf("em%d: Unknown MAC Type\n", adapter->unit);
2026       
2027        if(adapter->hw.mac_type == em_82541 || 
2028           adapter->hw.mac_type == em_82541_rev_2 ||
2029           adapter->hw.mac_type == em_82547 || 
2030           adapter->hw.mac_type == em_82547_rev_2)
2031                adapter->hw.phy_init_script = TRUE;
2032
2033        return;
2034}
2035
2036static int
2037em_allocate_pci_resources(struct adapter * adapter)
2038{
2039        int             i, val, rid;
2040        device_t        dev = adapter->dev;
2041
2042        rid = EM_MMBA;
2043
2044#ifndef __rtems__
2045        adapter->res_memory = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
2046                                                     &rid, RF_ACTIVE);
2047        if (!(adapter->res_memory)) {
2048                printf("em%d: Unable to allocate bus resource: memory\n", 
2049                       adapter->unit);
2050                return(ENXIO);
2051        }
2052        adapter->osdep.mem_bus_space_tag = 
2053        rman_get_bustag(adapter->res_memory);
2054        adapter->osdep.mem_bus_space_handle = 
2055        rman_get_bushandle(adapter->res_memory);
2056#endif
2057
2058        adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle;
2059
2060
2061        if (adapter->hw.mac_type > em_82543) {
2062                /* Figure our where our IO BAR is ? */
2063                rid = EM_MMBA;
2064                for (i = 0; i < 5; i++) {
2065                        val = pci_read_config(dev, rid, 4);
2066                        if (val & 0x00000001) {
2067#ifndef __rtems__
2068                                adapter->io_rid = rid;
2069#endif
2070                                break;
2071                        }
2072                        rid += 4;
2073                }
2074
2075#ifndef __rtems__
2076                adapter->res_ioport = bus_alloc_resource_any(dev, 
2077                                                             SYS_RES_IOPORT,
2078                                                             &adapter->io_rid,
2079                                                             RF_ACTIVE);
2080                if (!(adapter->res_ioport)) {
2081                        printf("em%d: Unable to allocate bus resource: ioport\n",
2082                               adapter->unit);
2083                        return(ENXIO); 
2084                }
2085
2086                adapter->hw.io_base =
2087                rman_get_start(adapter->res_ioport);
2088#else
2089                adapter->hw.io_base = val & PCI_BASE_ADDRESS_IO_MASK;
2090#endif
2091        }
2092
2093#ifndef __rtems__
2094        rid = 0x0;
2095        adapter->res_interrupt = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
2096                                                        RF_SHAREABLE | 
2097                                                        RF_ACTIVE);
2098        if (!(adapter->res_interrupt)) {
2099                printf("em%d: Unable to allocate bus resource: interrupt\n", 
2100                       adapter->unit);
2101                return(ENXIO);
2102        }
2103        if (bus_setup_intr(dev, adapter->res_interrupt,
2104                           INTR_TYPE_NET | INTR_MPSAFE,
2105                           (void (*)(void *)) em_intr, adapter,
2106                           &adapter->int_handler_tag)) {
2107                printf("em%d: Error registering interrupt handler!\n", 
2108                       adapter->unit);
2109                return(ENXIO);
2110        }
2111#endif
2112
2113        adapter->hw.back = &adapter->osdep;
2114
2115        return(0);
2116}
2117
2118#ifndef __rtems__
2119static void
2120em_free_pci_resources(struct adapter * adapter)
2121{
2122        device_t dev = adapter->dev;
2123
2124        if (adapter->res_interrupt != NULL) {
2125                bus_teardown_intr(dev, adapter->res_interrupt, 
2126                                  adapter->int_handler_tag);
2127                bus_release_resource(dev, SYS_RES_IRQ, 0, 
2128                                     adapter->res_interrupt);
2129        }
2130        if (adapter->res_memory != NULL) {
2131                bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA, 
2132                                     adapter->res_memory);
2133        }
2134
2135        if (adapter->res_ioport != NULL) {
2136                bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid, 
2137                                     adapter->res_ioport);
2138        }
2139        return;
2140}
2141#endif
2142
2143/*********************************************************************
2144 *
2145 *  Initialize the hardware to a configuration as specified by the
2146 *  adapter structure. The controller is reset, the EEPROM is
2147 *  verified, the MAC address is set, then the shared initialization
2148 *  routines are called.
2149 *
2150 **********************************************************************/
2151static int
2152em_hardware_init(struct adapter * adapter)
2153{
2154        INIT_DEBUGOUT("em_hardware_init: begin");
2155        /* Issue a global reset */
2156        em_reset_hw(&adapter->hw);
2157
2158        /* When hardware is reset, fifo_head is also reset */
2159        adapter->tx_fifo_head = 0;
2160
2161        /* Make sure we have a good EEPROM before we read from it */
2162        if (em_validate_eeprom_checksum(&adapter->hw) < 0) {
2163                printf("em%d: The EEPROM Checksum Is Not Valid\n",
2164                       adapter->unit);
2165                return(EIO);
2166        }
2167
2168        if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) {
2169                printf("em%d: EEPROM read error while reading part number\n",
2170                       adapter->unit);
2171                return(EIO);
2172        }
2173
2174        if (em_init_hw(&adapter->hw) < 0) {
2175                printf("em%d: Hardware Initialization Failed",
2176                       adapter->unit);
2177                return(EIO);
2178        }
2179
2180        em_check_for_link(&adapter->hw);
2181        if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)
2182                adapter->link_active = 1;
2183        else
2184                adapter->link_active = 0;
2185
2186        if (adapter->link_active) {
2187                em_get_speed_and_duplex(&adapter->hw, 
2188                                        &adapter->link_speed, 
2189                                        &adapter->link_duplex);
2190        } else {
2191                adapter->link_speed = 0;
2192                adapter->link_duplex = 0;
2193        }
2194
2195        return(0);
2196}
2197
2198/*********************************************************************
2199 *
2200 *  Setup networking device structure and register an interface.
2201 *
2202 **********************************************************************/
2203static void
2204em_setup_interface(device_t dev, struct adapter * adapter)
2205{
2206        struct ifnet   *ifp = &device_get_softc(dev)->arpcom.ac_if;
2207        INIT_DEBUGOUT("em_setup_interface: begin");
2208
2209        if_initname(ifp, device_get_name(dev), device_get_unit(dev));
2210        ifp->if_mtu = ETHERMTU;
2211        ifp->if_baudrate = 1000000000;
2212        ifp->if_init =  em_init;
2213        ifp->if_softc = adapter;
2214        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
2215#ifdef __rtems__
2216        ifp->if_output = ether_output;
2217#endif
2218        ifp->if_ioctl = em_ioctl;
2219        ifp->if_start = em_start;
2220        ifp->if_watchdog = em_watchdog;
2221#ifndef __rtems__
2222        IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 1);
2223        ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 1;
2224        IFQ_SET_READY(&ifp->if_snd);
2225#else
2226        ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1;
2227#endif
2228
2229#ifndef __rtems__
2230#if __FreeBSD_version < 500000
2231        ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
2232#else
2233        ether_ifattach(ifp, adapter->hw.mac_addr);
2234#endif
2235#else
2236        if ( !ifp->if_addrlist ) /* reattach hack */
2237        {
2238                if_attach(ifp);
2239                ether_ifattach(ifp);
2240        }
2241#endif
2242
2243#ifndef __rtems__
2244        ifp->if_capabilities = ifp->if_capenable = 0;
2245
2246        if (adapter->hw.mac_type >= em_82543) {
2247                ifp->if_capabilities |= IFCAP_HWCSUM;
2248                ifp->if_capenable |= IFCAP_HWCSUM;
2249        }
2250
2251        /*
2252         * Tell the upper layer(s) we support long frames.
2253         */
2254        ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
2255#if __FreeBSD_version >= 500000
2256        ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
2257        ifp->if_capenable |= IFCAP_VLAN_MTU;
2258#endif
2259
2260#ifdef DEVICE_POLLING
2261        ifp->if_capabilities |= IFCAP_POLLING;
2262        ifp->if_capenable |= IFCAP_POLLING;
2263#endif
2264
2265        /*
2266         * Specify the media types supported by this adapter and register
2267         * callbacks to update media and link information
2268         */
2269        ifmedia_init(&adapter->media, IFM_IMASK, em_media_change,
2270                     em_media_status);
2271        if (adapter->hw.media_type == em_media_type_fiber) {
2272                ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 
2273                            0, NULL);
2274                ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 
2275                            0, NULL);
2276        } else {
2277                ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL);
2278                ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 
2279                            0, NULL);
2280                ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 
2281                            0, NULL);
2282                ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 
2283                            0, NULL);
2284#if __FreeBSD_version < 500000
2285                ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 
2286                            0, NULL);
2287                ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL);
2288#else
2289                ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 
2290                            0, NULL);
2291                ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL);
2292#endif
2293        }
2294        ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
2295        ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO);
2296#endif
2297
2298        return;
2299}
2300
2301#ifndef __rtems__
2302/*********************************************************************
2303 *
2304 *  Workaround for SmartSpeed on 82541 and 82547 controllers
2305 *
2306 **********************************************************************/       
2307static void
2308em_smartspeed(struct adapter *adapter)
2309{
2310        uint16_t phy_tmp;
2311 
2312        if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) || 
2313           !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
2314                return;
2315
2316        if(adapter->smartspeed == 0) {
2317                /* If Master/Slave config fault is asserted twice,
2318                 * we assume back-to-back */
2319                em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
2320                if(!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) return;
2321                em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
2322                if(phy_tmp & SR_1000T_MS_CONFIG_FAULT) {
2323                        em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL,
2324                                        &phy_tmp);
2325                        if(phy_tmp & CR_1000T_MS_ENABLE) {
2326                                phy_tmp &= ~CR_1000T_MS_ENABLE;
2327                                em_write_phy_reg(&adapter->hw,
2328                                                    PHY_1000T_CTRL, phy_tmp);
2329                                adapter->smartspeed++;
2330                                if(adapter->hw.autoneg &&
2331                                   !em_phy_setup_autoneg(&adapter->hw) &&
2332                                   !em_read_phy_reg(&adapter->hw, PHY_CTRL,
2333                                                       &phy_tmp)) {
2334                                        phy_tmp |= (MII_CR_AUTO_NEG_EN | 
2335                                                    MII_CR_RESTART_AUTO_NEG);
2336                                        em_write_phy_reg(&adapter->hw,
2337                                                         PHY_CTRL, phy_tmp);
2338                                }
2339                        }
2340                }
2341                return;
2342        } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) {
2343                /* If still no link, perhaps using 2/3 pair cable */
2344                em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp);
2345                phy_tmp |= CR_1000T_MS_ENABLE;
2346                em_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp);
2347                if(adapter->hw.autoneg &&
2348                   !em_phy_setup_autoneg(&adapter->hw) &&
2349                   !em_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_tmp)) {
2350                        phy_tmp |= (MII_CR_AUTO_NEG_EN |
2351                                    MII_CR_RESTART_AUTO_NEG);
2352                        em_write_phy_reg(&adapter->hw, PHY_CTRL, phy_tmp);
2353                }
2354        }
2355        /* Restart process after EM_SMARTSPEED_MAX iterations */
2356        if(adapter->smartspeed++ == EM_SMARTSPEED_MAX)
2357                adapter->smartspeed = 0;
2358
2359        return;
2360}
2361
2362
2363/*
2364 * Manage DMA'able memory.
2365 */
2366static void
2367em_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
2368{ 
2369        if (error)
2370                return;
2371        *(bus_addr_t*) arg = segs->ds_addr;
2372        return;
2373}
2374#endif
2375
2376static int
2377em_dma_malloc(struct adapter *adapter, bus_size_t size,
2378        struct em_dma_alloc *dma, int mapflags)
2379{
2380        int r;
2381         
2382#ifndef __rtems__
2383        r = bus_dma_tag_create(NULL,                    /* parent */
2384                               PAGE_SIZE, 0,            /* alignment, bounds */
2385                               BUS_SPACE_MAXADDR,       /* lowaddr */
2386                               BUS_SPACE_MAXADDR,       /* highaddr */
2387                               NULL, NULL,              /* filter, filterarg */
2388                               size,                    /* maxsize */
2389                               1,                       /* nsegments */
2390                               size,                    /* maxsegsize */
2391                               BUS_DMA_ALLOCNOW,        /* flags */
2392                               NULL,                    /* lockfunc */
2393                               NULL,                    /* lockarg */
2394                               &dma->dma_tag);
2395        if (r != 0) {
2396                printf("em%d: em_dma_malloc: bus_dma_tag_create failed; "
2397                        "error %u\n", adapter->unit, r);
2398                goto fail_0;
2399        }
2400
2401        r = bus_dmamem_alloc(dma->dma_tag, (void**) &dma->dma_vaddr,
2402                             BUS_DMA_NOWAIT, &dma->dma_map);
2403#else
2404                if ( (dma->malloc_base = malloc( size + PAGE_SIZE, M_DEVBUF, M_NOWAIT )) ) {
2405                        r = 0; 
2406                        dma->dma_vaddr = (caddr_t)_DO_ALIGN(dma->malloc_base, PAGE_SIZE);
2407                } else {
2408                        r = -1;
2409                }
2410#endif
2411        if (r != 0) {
2412#ifndef __rtems__
2413                printf("em%d: em_dma_malloc: bus_dmammem_alloc failed; "
2414                        "size %ju, error %d\n", adapter->unit,
2415                        (uintmax_t)size, r);
2416#else
2417                printf("em%d: em_dma_malloc: bus_dmammem_alloc failed; "
2418                        "size %u, error %d\n", adapter->unit,
2419                        size, r);
2420#endif
2421                goto fail_2;
2422        }
2423
2424#ifndef __rtems__
2425        r = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr,
2426                            size,
2427                            em_dmamap_cb,
2428                            &dma->dma_paddr,
2429                            mapflags | BUS_DMA_NOWAIT);
2430#else
2431                dma->dma_paddr = kvtop(dma->dma_vaddr);
2432#endif
2433        if (r != 0) {
2434                printf("em%d: em_dma_malloc: bus_dmamap_load failed; "
2435                        "error %u\n", adapter->unit, r);
2436                goto fail_3;
2437        }
2438
2439#ifndef __rtems__
2440        dma->dma_size = size;
2441#endif
2442        return (0);
2443
2444fail_3:
2445        bus_dmamap_unload(dma->dma_tag, dma->dma_map);
2446fail_2:
2447#ifndef __rtems__
2448        bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
2449#else
2450                free(dma->malloc_base, M_DEVBUF);
2451                dma->dma_vaddr = dma->malloc_base = 0;
2452                dma->dma_paddr = 0;
2453#endif
2454        bus_dma_tag_destroy(dma->dma_tag);
2455#ifndef __rtems__
2456fail_0:
2457        dma->dma_map = NULL;
2458        dma->dma_tag = NULL;
2459#endif
2460        return (r);
2461}
2462
2463static void
2464em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma)
2465{
2466        bus_dmamap_unload(dma->dma_tag, dma->dma_map);
2467#ifndef __rtems__
2468        bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
2469#else
2470                free(dma->malloc_base, M_DEVBUF);
2471                dma->dma_vaddr = dma->malloc_base = 0;
2472                dma->dma_paddr = 0;
2473#endif
2474        bus_dma_tag_destroy(dma->dma_tag);
2475}
2476
2477
2478/*********************************************************************
2479 *
2480 *  Allocate memory for tx_buffer structures. The tx_buffer stores all
2481 *  the information needed to transmit a packet on the wire.
2482 *
2483 **********************************************************************/
2484static int
2485em_allocate_transmit_structures(struct adapter * adapter)
2486{
2487        if (!(adapter->tx_buffer_area =
2488              (struct em_buffer *) malloc(sizeof(struct em_buffer) *
2489                                             adapter->num_tx_desc, M_DEVBUF,
2490                                             M_NOWAIT))) {
2491                printf("em%d: Unable to allocate tx_buffer memory\n", 
2492                       adapter->unit);
2493                return ENOMEM;
2494        }
2495
2496        bzero(adapter->tx_buffer_area,
2497              sizeof(struct em_buffer) * adapter->num_tx_desc);
2498
2499        return 0;
2500}
2501
2502/*********************************************************************
2503 *
2504 *  Allocate and initialize transmit structures.
2505 *
2506 **********************************************************************/
2507static int
2508em_setup_transmit_structures(struct adapter * adapter)
2509{
2510#ifndef __rtems__
2511        /*
2512         * Setup DMA descriptor areas.
2513         */
2514        if (bus_dma_tag_create(NULL,                    /* parent */
2515                               1, 0,                    /* alignment, bounds */
2516                               BUS_SPACE_MAXADDR,       /* lowaddr */ 
2517                               BUS_SPACE_MAXADDR,       /* highaddr */
2518                               NULL, NULL,              /* filter, filterarg */
2519                               MCLBYTES * 8,            /* maxsize */
2520                               EM_MAX_SCATTER,          /* nsegments */
2521                               MCLBYTES * 8,            /* maxsegsize */
2522                               BUS_DMA_ALLOCNOW,        /* flags */ 
2523                               NULL,                    /* lockfunc */
2524                               NULL,                    /* lockarg */
2525                               &adapter->txtag)) {
2526                printf("em%d: Unable to allocate TX DMA tag\n", adapter->unit);
2527                return (ENOMEM);
2528        }
2529#endif
2530
2531        if (em_allocate_transmit_structures(adapter))
2532                return (ENOMEM);
2533
2534        bzero((void *) adapter->tx_desc_base,
2535              (sizeof(struct em_tx_desc)) * adapter->num_tx_desc);
2536
2537        adapter->next_avail_tx_desc = 0;
2538        adapter->oldest_used_tx_desc = 0;
2539
2540        /* Set number of descriptors available */
2541        adapter->num_tx_desc_avail = adapter->num_tx_desc;
2542
2543        /* Set checksum context */
2544        adapter->active_checksum_context = OFFLOAD_NONE;
2545
2546        return (0);
2547}
2548
2549/*********************************************************************
2550 *
2551 *  Enable transmit unit.
2552 *
2553 **********************************************************************/
2554static void
2555em_initialize_transmit_unit(struct adapter * adapter)
2556{
2557        u_int32_t       reg_tctl;
2558        u_int32_t       reg_tipg = 0;
2559        u_int64_t       bus_addr;
2560
2561         INIT_DEBUGOUT("em_initialize_transmit_unit: begin");
2562        /* Setup the Base and Length of the Tx Descriptor Ring */
2563        bus_addr = adapter->txdma.dma_paddr;
2564        E1000_WRITE_REG(&adapter->hw, TDBAL, (u_int32_t)bus_addr);
2565        E1000_WRITE_REG(&adapter->hw, TDBAH, (u_int32_t)(bus_addr >> 32));
2566        E1000_WRITE_REG(&adapter->hw, TDLEN, 
2567                        adapter->num_tx_desc *
2568                        sizeof(struct em_tx_desc));
2569
2570        /* Setup the HW Tx Head and Tail descriptor pointers */
2571        E1000_WRITE_REG(&adapter->hw, TDH, 0);
2572        E1000_WRITE_REG(&adapter->hw, TDT, 0);
2573
2574
2575        HW_DEBUGOUT2("Base = %" PRIx32 ", Length = %" PRIx32 "\n", 
2576                     E1000_READ_REG(&adapter->hw, TDBAL),
2577                     E1000_READ_REG(&adapter->hw, TDLEN));
2578
2579        /* Set the default values for the Tx Inter Packet Gap timer */
2580        switch (adapter->hw.mac_type) {
2581        case em_82542_rev2_0:
2582        case em_82542_rev2_1:
2583                reg_tipg = DEFAULT_82542_TIPG_IPGT;
2584                reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
2585                reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
2586                break;
2587        default:
2588                if (adapter->hw.media_type == em_media_type_fiber)
2589                        reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
2590                else
2591                        reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
2592                reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
2593                reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
2594        }
2595
2596        E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg);
2597        E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay.value);
2598        if(adapter->hw.mac_type >= em_82540)
2599                E1000_WRITE_REG(&adapter->hw, TADV,
2600                    adapter->tx_abs_int_delay.value);
2601
2602        /* Program the Transmit Control Register */
2603        reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN |
2604                   (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
2605        if (adapter->hw.mac_type >= em_82573)
2606                reg_tctl |= E1000_TCTL_MULR;
2607        if (adapter->link_duplex == 1) {
2608                reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
2609        } else {
2610                reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
2611        }
2612        E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl);
2613
2614        /* Setup Transmit Descriptor Settings for this adapter */   
2615        adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS;
2616
2617        if (adapter->tx_int_delay.value > 0)
2618                adapter->txd_cmd |= E1000_TXD_CMD_IDE;
2619
2620        return;
2621}
2622
2623/*********************************************************************
2624 *
2625 *  Free all transmit related data structures.
2626 *
2627 **********************************************************************/
2628static void
2629em_free_transmit_structures(struct adapter * adapter)
2630{
2631        struct em_buffer   *tx_buffer;
2632        int             i;
2633
2634        INIT_DEBUGOUT("free_transmit_structures: begin");
2635
2636        if (adapter->tx_buffer_area != NULL) {
2637                tx_buffer = adapter->tx_buffer_area;
2638                for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
2639                        if (tx_buffer->m_head != NULL) {
2640                                bus_dmamap_unload(adapter->txtag, tx_buffer->map);
2641                                bus_dmamap_destroy(adapter->txtag, tx_buffer->map);
2642                                m_freem(tx_buffer->m_head);
2643                        }
2644                        tx_buffer->m_head = NULL;
2645                }
2646        }
2647        if (adapter->tx_buffer_area != NULL) {
2648                free(adapter->tx_buffer_area, M_DEVBUF);
2649                adapter->tx_buffer_area = NULL;
2650        }
2651#ifndef __rtems__
2652        if (adapter->txtag != NULL) {
2653                bus_dma_tag_destroy(adapter->txtag);
2654                adapter->txtag = NULL;
2655        }
2656#endif
2657        return;
2658}
2659
2660#ifndef __rtems__
2661/*********************************************************************
2662 *
2663 *  The offload context needs to be set when we transfer the first
2664 *  packet of a particular protocol (TCP/UDP). We change the
2665 *  context only if the protocol type changes.
2666 *
2667 **********************************************************************/
2668static void
2669em_transmit_checksum_setup(struct adapter * adapter,
2670                           struct mbuf *mp,
2671                           u_int32_t *txd_upper,
2672                           u_int32_t *txd_lower) 
2673{
2674        struct em_context_desc *TXD;
2675        struct em_buffer *tx_buffer;
2676        int curr_txd;
2677
2678        if (mp->m_pkthdr.csum_flags) {
2679
2680                if (mp->m_pkthdr.csum_flags & CSUM_TCP) {
2681                        *txd_upper = E1000_TXD_POPTS_TXSM << 8;
2682                        *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
2683                        if (adapter->active_checksum_context == OFFLOAD_TCP_IP)
2684                                return;
2685                        else
2686                                adapter->active_checksum_context = OFFLOAD_TCP_IP;
2687
2688                } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) {
2689                        *txd_upper = E1000_TXD_POPTS_TXSM << 8;
2690                        *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
2691                        if (adapter->active_checksum_context == OFFLOAD_UDP_IP)
2692                                return;
2693                        else
2694                                adapter->active_checksum_context = OFFLOAD_UDP_IP;
2695                } else {
2696                        *txd_upper = 0;
2697                        *txd_lower = 0;
2698                        return;
2699                }
2700        } else {
2701                *txd_upper = 0;
2702                *txd_lower = 0;
2703                return;
2704        }
2705
2706        /* If we reach this point, the checksum offload context
2707         * needs to be reset.
2708         */
2709        curr_txd = adapter->next_avail_tx_desc;
2710        tx_buffer = &adapter->tx_buffer_area[curr_txd];
2711        TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd];
2712
2713        TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN;
2714        TXD->lower_setup.ip_fields.ipcso = 
2715                ETHER_HDR_LEN + offsetof(struct ip, ip_sum);
2716        TXD->lower_setup.ip_fields.ipcse = 
2717                htole16(ETHER_HDR_LEN + sizeof(struct ip) - 1);
2718
2719        TXD->upper_setup.tcp_fields.tucss = 
2720                ETHER_HDR_LEN + sizeof(struct ip);
2721        TXD->upper_setup.tcp_fields.tucse = htole16(0);
2722
2723        if (adapter->active_checksum_context == OFFLOAD_TCP_IP) {
2724                TXD->upper_setup.tcp_fields.tucso = 
2725                        ETHER_HDR_LEN + sizeof(struct ip) + 
2726                        offsetof(struct tcphdr, th_sum);
2727        } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) {
2728                TXD->upper_setup.tcp_fields.tucso = 
2729                        ETHER_HDR_LEN + sizeof(struct ip) + 
2730                        offsetof(struct udphdr, uh_sum);
2731        }
2732
2733        TXD->tcp_seg_setup.data = htole32(0);
2734        TXD->cmd_and_length = htole32(adapter->txd_cmd | E1000_TXD_CMD_DEXT);
2735
2736        tx_buffer->m_head = NULL;
2737
2738        if (++curr_txd == adapter->num_tx_desc)
2739                curr_txd = 0;
2740
2741        adapter->num_tx_desc_avail--;
2742        adapter->next_avail_tx_desc = curr_txd;
2743
2744        return;
2745}
2746#endif
2747
2748/**********************************************************************
2749 *
2750 *  Examine each tx_buffer in the used queue. If the hardware is done
2751 *  processing the packet then free associated resources. The
2752 *  tx_buffer is put back on the free queue.
2753 *
2754 **********************************************************************/
2755static void
2756em_clean_transmit_interrupts(struct adapter * adapter)
2757{
2758        int i, num_avail;
2759        struct em_buffer *tx_buffer;
2760        struct em_tx_desc   *tx_desc;
2761        struct ifnet   *ifp = &adapter->arpcom.ac_if;
2762
2763        mtx_assert(&adapter->mtx, MA_OWNED);
2764
2765        if (adapter->num_tx_desc_avail == adapter->num_tx_desc)
2766                return;
2767
2768        num_avail = adapter->num_tx_desc_avail;
2769        i = adapter->oldest_used_tx_desc;
2770
2771        tx_buffer = &adapter->tx_buffer_area[i];
2772        tx_desc = &adapter->tx_desc_base[i];
2773
2774        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
2775            BUS_DMASYNC_POSTREAD);
2776        while (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) {
2777
2778                tx_desc->upper.data = 0;
2779                num_avail++;
2780
2781                if (tx_buffer->m_head) {
2782                        ifp->if_opackets++;
2783                        bus_dmamap_unload(adapter->txtag, tx_buffer->map);
2784                        bus_dmamap_destroy(adapter->txtag, tx_buffer->map);
2785
2786                        m_freem(tx_buffer->m_head);
2787                        tx_buffer->m_head = NULL;
2788                }
2789
2790                if (++i == adapter->num_tx_desc)
2791                        i = 0;
2792
2793                tx_buffer = &adapter->tx_buffer_area[i];
2794                tx_desc = &adapter->tx_desc_base[i];
2795        }
2796        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
2797            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2798
2799        adapter->oldest_used_tx_desc = i;
2800
2801        /*
2802         * If we have enough room, clear IFF_OACTIVE to tell the stack
2803         * that it is OK to send packets.
2804         * If there are no pending descriptors, clear the timeout. Otherwise,
2805         * if some descriptors have been freed, restart the timeout.
2806         */
2807        if (num_avail > EM_TX_CLEANUP_THRESHOLD) {               
2808                ifp->if_flags &= ~IFF_OACTIVE;
2809                if (num_avail == adapter->num_tx_desc)
2810                        ifp->if_timer = 0;
2811                else if (num_avail == adapter->num_tx_desc_avail)
2812                        ifp->if_timer = EM_TX_TIMEOUT;
2813        }
2814        adapter->num_tx_desc_avail = num_avail;
2815        return;
2816}
2817
2818/*********************************************************************
2819 *
2820 *  Get a buffer from system mbuf buffer pool.
2821 *
2822 **********************************************************************/
2823static int
2824em_get_buf(int i, struct adapter *adapter,
2825           struct mbuf *nmp)
2826{
2827        register struct mbuf    *mp = nmp;
2828        struct em_buffer *rx_buffer;
2829        struct ifnet   *ifp;
2830        bus_addr_t paddr;
2831#ifndef __rtems__
2832        int error;
2833#endif
2834
2835        ifp = &adapter->arpcom.ac_if;
2836
2837        if (mp == NULL) {
2838#ifndef __rtems__
2839                mp = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
2840#else
2841                                MGETHDR(mp, M_DONTWAIT, MT_DATA);
2842                                if ( mp ) {
2843                                        MCLGET( mp, M_DONTWAIT );
2844                                        if ( !(mp->m_flags & M_EXT) ) {
2845                                                m_freem(mp);
2846                                                mp = 0;
2847                                        }
2848                                }
2849#endif
2850                if (mp == NULL) {
2851                        adapter->mbuf_cluster_failed++;
2852                        return(ENOBUFS);
2853                }
2854                mp->m_len = mp->m_pkthdr.len = MCLBYTES;
2855        } else {
2856                mp->m_len = mp->m_pkthdr.len = MCLBYTES;
2857                mp->m_data = mp->m_ext.ext_buf;
2858                mp->m_next = NULL;
2859        }
2860
2861        if (ifp->if_mtu <= ETHERMTU) {
2862                m_adj(mp, ETHER_ALIGN);
2863        }
2864
2865        rx_buffer = &adapter->rx_buffer_area[i];
2866
2867#ifndef __rtems__
2868        /*
2869         * Using memory from the mbuf cluster pool, invoke the
2870         * bus_dma machinery to arrange the memory mapping.
2871         */
2872        error = bus_dmamap_load(adapter->rxtag, rx_buffer->map,
2873                                mtod(mp, void *), mp->m_len,
2874                                em_dmamap_cb, &paddr, 0);
2875        if (error) {
2876                m_free(mp);
2877                return(error);
2878        }
2879#else
2880                paddr = kvtop(mtod(mp, void*));
2881#endif
2882
2883        rx_buffer->m_head = mp;
2884        adapter->rx_desc_base[i].buffer_addr = htole64(paddr);
2885        bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD);
2886
2887        return(0);
2888}
2889
2890/*********************************************************************
2891 *
2892 *  Allocate memory for rx_buffer structures. Since we use one
2893 *  rx_buffer per received packet, the maximum number of rx_buffer's
2894 *  that we'll need is equal to the number of receive descriptors
2895 *  that we've allocated.
2896 *
2897 **********************************************************************/
2898static int
2899em_allocate_receive_structures(struct adapter * adapter)
2900{
2901        int             i, error;
2902#ifndef __rtems__
2903        struct em_buffer *rx_buffer;
2904#endif
2905
2906        if (!(adapter->rx_buffer_area =
2907              (struct em_buffer *) malloc(sizeof(struct em_buffer) *
2908                                          adapter->num_rx_desc, M_DEVBUF,
2909                                          M_NOWAIT))) {
2910                printf("em%d: Unable to allocate rx_buffer memory\n",
2911                       adapter->unit);
2912                return(ENOMEM);
2913        }
2914
2915        bzero(adapter->rx_buffer_area,
2916              sizeof(struct em_buffer) * adapter->num_rx_desc);
2917
2918#ifndef __rtems__
2919        error = bus_dma_tag_create(NULL,                /* parent */
2920                               1, 0,                    /* alignment, bounds */
2921                               BUS_SPACE_MAXADDR,       /* lowaddr */
2922                               BUS_SPACE_MAXADDR,       /* highaddr */
2923                               NULL, NULL,              /* filter, filterarg */
2924                               MCLBYTES,                /* maxsize */
2925                               1,                       /* nsegments */
2926                               MCLBYTES,                /* maxsegsize */
2927                               BUS_DMA_ALLOCNOW,        /* flags */
2928                               NULL,                    /* lockfunc */
2929                               NULL,                    /* lockarg */
2930                               &adapter->rxtag);
2931        if (error != 0) {
2932                printf("em%d: em_allocate_receive_structures: "
2933                        "bus_dma_tag_create failed; error %u\n",
2934                       adapter->unit, error);
2935                goto fail_0;
2936        }
2937        rx_buffer = adapter->rx_buffer_area;
2938        for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
2939                error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT,
2940                                          &rx_buffer->map);
2941                if (error != 0) {
2942                        printf("em%d: em_allocate_receive_structures: "
2943                                "bus_dmamap_create failed; error %u\n",
2944                                adapter->unit, error);
2945                        goto fail_1;
2946                }
2947        }
2948
2949#else
2950                error = 0;
2951#endif
2952
2953        for (i = 0; i < adapter->num_rx_desc; i++) {
2954                error = em_get_buf(i, adapter, NULL);
2955                if (error != 0) {
2956                        adapter->rx_buffer_area[i].m_head = NULL;
2957                        adapter->rx_desc_base[i].buffer_addr = 0;
2958                        return(error);
2959                }
2960        }
2961        bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
2962            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2963
2964        return(0);
2965
2966#ifndef __rtems__
2967fail_1:
2968        bus_dma_tag_destroy(adapter->rxtag);
2969fail_0:
2970        adapter->rxtag = NULL;
2971#endif
2972        free(adapter->rx_buffer_area, M_DEVBUF);
2973        adapter->rx_buffer_area = NULL;
2974        return (error);
2975}
2976
2977/*********************************************************************
2978 *
2979 *  Allocate and initialize receive structures.
2980 * 
2981 **********************************************************************/
2982static int
2983em_setup_receive_structures(struct adapter * adapter)
2984{
2985        bzero((void *) adapter->rx_desc_base,
2986              (sizeof(struct em_rx_desc)) * adapter->num_rx_desc);
2987
2988        if (em_allocate_receive_structures(adapter))
2989                return ENOMEM;
2990
2991        /* Setup our descriptor pointers */
2992        adapter->next_rx_desc_to_check = 0;
2993        return(0);
2994}
2995
2996/*********************************************************************
2997 *
2998 *  Enable receive unit.
2999 * 
3000 **********************************************************************/
3001static void
3002em_initialize_receive_unit(struct adapter * adapter)
3003{
3004        u_int32_t       reg_rctl;
3005#ifndef __rtems__
3006        u_int32_t       reg_rxcsum;
3007#endif
3008        struct ifnet    *ifp;
3009        u_int64_t       bus_addr;
3010
3011        INIT_DEBUGOUT("em_initialize_receive_unit: begin");
3012        ifp = &adapter->arpcom.ac_if;
3013
3014        /* Make sure receives are disabled while setting up the descriptor ring */
3015        E1000_WRITE_REG(&adapter->hw, RCTL, 0);
3016
3017        /* Set the Receive Delay Timer Register */
3018        E1000_WRITE_REG(&adapter->hw, RDTR, 
3019                        adapter->rx_int_delay.value | E1000_RDT_FPDB);
3020
3021        if(adapter->hw.mac_type >= em_82540) {
3022                E1000_WRITE_REG(&adapter->hw, RADV,
3023                    adapter->rx_abs_int_delay.value);
3024
3025                /* Set the interrupt throttling rate.  Value is calculated
3026                 * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */
3027#define MAX_INTS_PER_SEC        8000
3028#define DEFAULT_ITR             1000000000/(MAX_INTS_PER_SEC * 256)
3029                E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR);
3030        }       
3031
3032        /* Setup the Base and Length of the Rx Descriptor Ring */
3033        bus_addr = adapter->rxdma.dma_paddr;
3034        E1000_WRITE_REG(&adapter->hw, RDBAL, (u_int32_t)bus_addr);
3035        E1000_WRITE_REG(&adapter->hw, RDBAH, (u_int32_t)(bus_addr >> 32));
3036        E1000_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc *
3037                        sizeof(struct em_rx_desc));
3038
3039        /* Setup the HW Rx Head and Tail Descriptor Pointers */
3040        E1000_WRITE_REG(&adapter->hw, RDH, 0);
3041        E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1);
3042
3043        /* Setup the Receive Control Register */
3044        reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
3045                   E1000_RCTL_RDMTS_HALF |
3046                   (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);
3047
3048        if (adapter->hw.tbi_compatibility_on == TRUE)
3049                reg_rctl |= E1000_RCTL_SBP;
3050
3051
3052        switch (adapter->rx_buffer_len) {
3053        default:
3054        case EM_RXBUFFER_2048:
3055                reg_rctl |= E1000_RCTL_SZ_2048;
3056                break;
3057        case EM_RXBUFFER_4096:
3058                reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
3059                break;           
3060        case EM_RXBUFFER_8192:
3061                reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
3062                break;
3063        case EM_RXBUFFER_16384:
3064                reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
3065                break;
3066        }
3067
3068        if (ifp->if_mtu > ETHERMTU)
3069                reg_rctl |= E1000_RCTL_LPE;
3070
3071#ifndef __rtems__
3072        /* Enable 82543 Receive Checksum Offload for TCP and UDP */
3073        if ((adapter->hw.mac_type >= em_82543) && 
3074            (ifp->if_capenable & IFCAP_RXCSUM)) {
3075                reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
3076                reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL);
3077                E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum);
3078        }
3079#endif
3080
3081        /* Enable Receives */
3082        E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
3083
3084        return;
3085}
3086
3087/*********************************************************************
3088 *
3089 *  Free receive related data structures.
3090 *
3091 **********************************************************************/
3092static void
3093em_free_receive_structures(struct adapter *adapter)
3094{
3095        struct em_buffer   *rx_buffer;
3096        int             i;
3097
3098        INIT_DEBUGOUT("free_receive_structures: begin");
3099
3100        if (adapter->rx_buffer_area != NULL) {
3101                rx_buffer = adapter->rx_buffer_area;
3102                for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
3103#ifndef __rtems__
3104                        if (rx_buffer->map != NULL) {
3105                                bus_dmamap_unload(adapter->rxtag, rx_buffer->map);
3106                                bus_dmamap_destroy(adapter->rxtag, rx_buffer->map);
3107                        }
3108#endif
3109                        if (rx_buffer->m_head != NULL)
3110                                m_freem(rx_buffer->m_head);
3111                        rx_buffer->m_head = NULL;
3112                }
3113        }
3114        if (adapter->rx_buffer_area != NULL) {
3115                free(adapter->rx_buffer_area, M_DEVBUF);
3116                adapter->rx_buffer_area = NULL;
3117        }
3118#ifndef __rtems__
3119        if (adapter->rxtag != NULL) {
3120                bus_dma_tag_destroy(adapter->rxtag);
3121                adapter->rxtag = NULL;
3122        }
3123#endif
3124        return;
3125}
3126
3127/*********************************************************************
3128 *
3129 *  This routine executes in interrupt context. It replenishes
3130 *  the mbufs in the descriptor and sends data which has been
3131 *  dma'ed into host memory to upper layer.
3132 *
3133 *  We loop at most count times if count is > 0, or until done if
3134 *  count < 0.
3135 *
3136 *********************************************************************/
3137static void
3138em_process_receive_interrupts(struct adapter * adapter, int count)
3139{
3140        struct ifnet        *ifp;
3141        struct mbuf         *mp;
3142#if __FreeBSD_version < 500000
3143        struct ether_header *eh;
3144#endif
3145        u_int8_t            accept_frame = 0;
3146        u_int8_t            eop = 0;
3147        u_int16_t           len, desc_len, prev_len_adj;
3148        int                 i;
3149
3150        /* Pointer to the receive descriptor being examined. */
3151        struct em_rx_desc   *current_desc;
3152
3153        mtx_assert(&adapter->mtx, MA_OWNED);
3154
3155        ifp = &adapter->arpcom.ac_if;
3156        i = adapter->next_rx_desc_to_check;
3157        current_desc = &adapter->rx_desc_base[i];
3158        bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
3159            BUS_DMASYNC_POSTREAD);
3160
3161        if (!((current_desc->status) & E1000_RXD_STAT_DD)) {
3162                return;
3163        }
3164
3165        while ((current_desc->status & E1000_RXD_STAT_DD) && (count != 0)) {
3166               
3167                mp = adapter->rx_buffer_area[i].m_head;
3168                bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map,
3169                                BUS_DMASYNC_POSTREAD);
3170
3171                accept_frame = 1;
3172                prev_len_adj = 0;
3173                desc_len = le16toh(current_desc->length);
3174                if (current_desc->status & E1000_RXD_STAT_EOP) {
3175                        count--;
3176                        eop = 1;
3177                        if (desc_len < ETHER_CRC_LEN) {
3178                                len = 0;
3179                                prev_len_adj = ETHER_CRC_LEN - desc_len;
3180                        }
3181                        else {
3182                                len = desc_len - ETHER_CRC_LEN;
3183                        }
3184                } else {
3185                        eop = 0;
3186                        len = desc_len;
3187                }
3188
3189                if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
3190                        u_int8_t            last_byte;
3191                        u_int32_t           pkt_len = desc_len;
3192
3193                        if (adapter->fmp != NULL)
3194                                pkt_len += adapter->fmp->m_pkthdr.len; 
3195 
3196                        last_byte = *(mtod(mp, caddr_t) + desc_len - 1);                       
3197
3198                        if (TBI_ACCEPT(&adapter->hw, current_desc->status, 
3199                                       current_desc->errors, 
3200                                       pkt_len, last_byte)) {
3201                                em_tbi_adjust_stats(&adapter->hw, 
3202                                                    &adapter->stats, 
3203                                                    pkt_len, 
3204                                                    adapter->hw.mac_addr);
3205                                if (len > 0) len--;
3206                        } 
3207                        else {
3208                                accept_frame = 0;
3209                        }
3210                }
3211
3212                if (accept_frame) {
3213
3214                        if (em_get_buf(i, adapter, NULL) == ENOBUFS) {
3215                                adapter->dropped_pkts++;
3216                                em_get_buf(i, adapter, mp);
3217                                if (adapter->fmp != NULL) 
3218                                        m_freem(adapter->fmp);
3219                                adapter->fmp = NULL;
3220                                adapter->lmp = NULL;
3221                                break;
3222                        }
3223
3224                        /* Assign correct length to the current fragment */
3225                        mp->m_len = len;
3226
3227                        if (adapter->fmp == NULL) {
3228                                mp->m_pkthdr.len = len;
3229                                adapter->fmp = mp;       /* Store the first mbuf */
3230                                adapter->lmp = mp;
3231                        } else {
3232                                /* Chain mbuf's together */
3233                                mp->m_flags &= ~M_PKTHDR;
3234                                /*
3235                                 * Adjust length of previous mbuf in chain if we
3236                                 * received less than 4 bytes in the last descriptor.
3237                                 */
3238                                if (prev_len_adj > 0) {
3239                                        adapter->lmp->m_len -= prev_len_adj;
3240                                        adapter->fmp->m_pkthdr.len -= prev_len_adj;
3241                                }
3242                                adapter->lmp->m_next = mp;
3243                                adapter->lmp = adapter->lmp->m_next;
3244                                adapter->fmp->m_pkthdr.len += len;
3245                        }
3246
3247                        if (eop) {
3248                                adapter->fmp->m_pkthdr.rcvif = ifp;
3249                                 ifp->if_ipackets++;
3250
3251#if __FreeBSD_version < 500000
3252                                eh = mtod(adapter->fmp, struct ether_header *);
3253                                /* Remove ethernet header from mbuf */
3254                                m_adj(adapter->fmp, sizeof(struct ether_header));
3255#ifndef __rtems__
3256                                em_receive_checksum(adapter, current_desc,
3257                                                    adapter->fmp);
3258                                if (current_desc->status & E1000_RXD_STAT_VP)
3259                                        VLAN_INPUT_TAG(eh, adapter->fmp,
3260                                                       (current_desc->special & 
3261                                                        E1000_RXD_SPC_VLAN_MASK));
3262                                else
3263#endif
3264                                        ether_input(ifp, eh, adapter->fmp);
3265#else
3266
3267                                em_receive_checksum(adapter, current_desc,
3268                                                    adapter->fmp);
3269                                if (current_desc->status & E1000_RXD_STAT_VP)
3270                                        VLAN_INPUT_TAG(ifp, adapter->fmp,
3271                                                       (current_desc->special &
3272                                                        E1000_RXD_SPC_VLAN_MASK),
3273                                                       adapter->fmp = NULL);
3274 
3275                                if (adapter->fmp != NULL) {
3276                                        EM_UNLOCK(adapter);
3277                                        (*ifp->if_input)(ifp, adapter->fmp);
3278                                        EM_LOCK(adapter);
3279                                }
3280#endif
3281                                adapter->fmp = NULL;
3282                                adapter->lmp = NULL;
3283                        }
3284                } else {
3285                        adapter->dropped_pkts++;
3286                        em_get_buf(i, adapter, mp);
3287                        if (adapter->fmp != NULL) 
3288                                m_freem(adapter->fmp);
3289                        adapter->fmp = NULL;
3290                        adapter->lmp = NULL;
3291                }
3292
3293                /* Zero out the receive descriptors status  */
3294                current_desc->status = 0;
3295 
3296                /* Advance the E1000's Receive Queue #0  "Tail Pointer". */
3297                E1000_WRITE_REG(&adapter->hw, RDT, i);
3298
3299                /* Advance our pointers to the next descriptor */
3300                if (++i == adapter->num_rx_desc) {
3301                        i = 0;
3302                        current_desc = adapter->rx_desc_base;
3303                } else
3304                        current_desc++;
3305        }
3306        bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
3307            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
3308        adapter->next_rx_desc_to_check = i;
3309        return;
3310}
3311
3312#ifndef __rtems__
3313/*********************************************************************
3314 *
3315 *  Verify that the hardware indicated that the checksum is valid.
3316 *  Inform the stack about the status of checksum so that stack
3317 *  doesn't spend time verifying the checksum.
3318 *
3319 *********************************************************************/
3320static void
3321em_receive_checksum(struct adapter *adapter,
3322                    struct em_rx_desc *rx_desc,
3323                    struct mbuf *mp)
3324{
3325        /* 82543 or newer only */
3326        if ((adapter->hw.mac_type < em_82543) ||
3327            /* Ignore Checksum bit is set */
3328            (rx_desc->status & E1000_RXD_STAT_IXSM)) {
3329                mp->m_pkthdr.csum_flags = 0;
3330                return;
3331        }
3332
3333        if (rx_desc->status & E1000_RXD_STAT_IPCS) {
3334                /* Did it pass? */
3335                if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) {
3336                        /* IP Checksum Good */
3337                        mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
3338                        mp->m_pkthdr.csum_flags |= CSUM_IP_VALID;
3339
3340                } else {
3341                        mp->m_pkthdr.csum_flags = 0;
3342                }
3343        }
3344
3345        if (rx_desc->status & E1000_RXD_STAT_TCPCS) {
3346                /* Did it pass? */       
3347                if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) {
3348                        mp->m_pkthdr.csum_flags |= 
3349                        (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
3350                        mp->m_pkthdr.csum_data = htons(0xffff);
3351                }
3352        }
3353
3354        return;
3355}
3356
3357
3358static void 
3359em_enable_vlans(struct adapter *adapter)
3360{
3361        uint32_t ctrl;
3362
3363        E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN);
3364
3365        ctrl = E1000_READ_REG(&adapter->hw, CTRL);
3366        ctrl |= E1000_CTRL_VME; 
3367        E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
3368
3369        return;
3370}
3371
3372static void
3373em_disable_vlans(struct adapter *adapter)
3374{
3375        uint32_t ctrl;
3376
3377        ctrl = E1000_READ_REG(&adapter->hw, CTRL);
3378        ctrl &= ~E1000_CTRL_VME;
3379        E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
3380
3381        return;
3382}
3383#endif
3384
3385static void
3386em_enable_intr(struct adapter * adapter)
3387{
3388        E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK));
3389        return;
3390}
3391
3392static void
3393em_disable_intr(struct adapter *adapter)
3394{
3395        /*
3396         * The first version of 82542 had an errata where when link was forced it
3397         * would stay up even up even if the cable was disconnected.  Sequence errors
3398         * were used to detect the disconnect and then the driver would unforce the link.
3399         * This code in the in the ISR.  For this to work correctly the Sequence error
3400         * interrupt had to be enabled all the time.
3401         */
3402
3403        if (adapter->hw.mac_type == em_82542_rev2_0)
3404            E1000_WRITE_REG(&adapter->hw, IMC,
3405                (0xffffffff & ~E1000_IMC_RXSEQ));
3406        else
3407            E1000_WRITE_REG(&adapter->hw, IMC,
3408                0xffffffff);
3409        return;
3410}
3411
3412static int
3413em_is_valid_ether_addr(u_int8_t *addr)
3414{
3415        char zero_addr[6] = { 0, 0, 0, 0, 0, 0 };
3416                               
3417        if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) {
3418                return (FALSE);
3419        }
3420
3421        return(TRUE);
3422}
3423
3424void 
3425em_write_pci_cfg(struct em_hw *hw,
3426                      uint32_t reg,
3427                      uint16_t *value)
3428{
3429        pci_write_config(((struct em_osdep *)hw->back)->dev, reg, 
3430                         *value, 2);
3431}
3432
3433void 
3434em_read_pci_cfg(struct em_hw *hw, uint32_t reg,
3435                     uint16_t *value)
3436{
3437        *value = pci_read_config(((struct em_osdep *)hw->back)->dev,
3438                                 reg, 2);
3439        return;
3440}
3441
3442void
3443em_pci_set_mwi(struct em_hw *hw)
3444{
3445        pci_write_config(((struct em_osdep *)hw->back)->dev,
3446                         PCIR_COMMAND,
3447                         (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2);
3448        return;
3449}
3450
3451void
3452em_pci_clear_mwi(struct em_hw *hw)
3453{
3454        pci_write_config(((struct em_osdep *)hw->back)->dev,
3455                         PCIR_COMMAND,
3456                         (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2);
3457        return;
3458}
3459
3460uint32_t 
3461em_io_read(struct em_hw *hw, unsigned long port)
3462{
3463        return(inl(port));
3464}
3465
3466void 
3467em_io_write(struct em_hw *hw, unsigned long port, uint32_t value)
3468{
3469#ifndef __rtems__
3470        outl(port, value);
3471#else
3472        /* everybody else has this the other way round! */
3473        outl(value, port);
3474#endif
3475        return;
3476}
3477
3478/*********************************************************************
3479* 82544 Coexistence issue workaround.
3480*    There are 2 issues.
3481*       1. Transmit Hang issue.
3482*    To detect this issue, following equation can be used...
3483*          SIZE[3:0] + ADDR[2:0] = SUM[3:0].
3484*          If SUM[3:0] is in between 1 to 4, we will have this issue.
3485*
3486*       2. DAC issue.
3487*    To detect this issue, following equation can be used...
3488*          SIZE[3:0] + ADDR[2:0] = SUM[3:0].
3489*          If SUM[3:0] is in between 9 to c, we will have this issue.
3490*
3491*
3492*    WORKAROUND:
3493*          Make sure we do not have ending address as 1,2,3,4(Hang) or 9,a,b,c (DAC)
3494*
3495*** *********************************************************************/
3496static u_int32_t
3497em_fill_descriptors (u_int64_t address,
3498                              u_int32_t length,
3499                              PDESC_ARRAY desc_array)
3500{
3501        /* Since issue is sensitive to length and address.*/
3502        /* Let us first check the address...*/
3503        u_int32_t safe_terminator;
3504        if (length <= 4) {
3505                desc_array->descriptor[0].address = address;
3506                desc_array->descriptor[0].length = length;
3507                desc_array->elements = 1;
3508                return desc_array->elements;
3509        }
3510        safe_terminator = (u_int32_t)((((u_int32_t)address & 0x7) + (length & 0xF)) & 0xF);
3511        /* if it does not fall between 0x1 to 0x4 and 0x9 to 0xC then return */
3512        if (safe_terminator == 0   ||
3513        (safe_terminator > 4   &&
3514        safe_terminator < 9)   ||
3515        (safe_terminator > 0xC &&
3516        safe_terminator <= 0xF)) {
3517                desc_array->descriptor[0].address = address;
3518                desc_array->descriptor[0].length = length;
3519                desc_array->elements = 1;
3520                return desc_array->elements;
3521        }
3522         
3523        desc_array->descriptor[0].address = address;
3524        desc_array->descriptor[0].length = length - 4;
3525        desc_array->descriptor[1].address = address + (length - 4);
3526        desc_array->descriptor[1].length = 4;
3527        desc_array->elements = 2;
3528        return desc_array->elements;
3529}
3530
3531/**********************************************************************
3532 *
3533 *  Update the board statistics counters.
3534 *
3535 **********************************************************************/
3536static void
3537em_update_stats_counters(struct adapter *adapter)
3538{
3539        struct ifnet   *ifp;
3540
3541        if(adapter->hw.media_type == em_media_type_copper ||
3542           (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)) {
3543                adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS);
3544                adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC);
3545        }
3546        adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS);
3547        adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC);
3548        adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC);
3549        adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL);
3550
3551        adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC);
3552        adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL);
3553        adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC);
3554        adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC);
3555        adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC);
3556        adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC);
3557        adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC);
3558        adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC);
3559        adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC);
3560        adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC);
3561        adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64);
3562        adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127);
3563        adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255);
3564        adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511);
3565        adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023);
3566        adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522);
3567        adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC);
3568        adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC);
3569        adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC);
3570        adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC);
3571
3572        /* For the 64-bit byte counters the low dword must be read first. */
3573        /* Both registers clear on the read of the high dword */
3574
3575        adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL); 
3576        adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH);
3577        adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL);
3578        adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH);
3579
3580        adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC);
3581        adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC);
3582        adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC);
3583        adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC);
3584        adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC);
3585
3586        adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL);
3587        adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH);
3588        adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL);
3589        adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH);
3590
3591        adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR);
3592        adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT);
3593        adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64);
3594        adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127);
3595        adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255);
3596        adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511);
3597        adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023);
3598        adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522);
3599        adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC);
3600        adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC);
3601
3602        if (adapter->hw.mac_type >= em_82543) {
3603                adapter->stats.algnerrc += 
3604                E1000_READ_REG(&adapter->hw, ALGNERRC);
3605                adapter->stats.rxerrc += 
3606                E1000_READ_REG(&adapter->hw, RXERRC);
3607                adapter->stats.tncrs += 
3608                E1000_READ_REG(&adapter->hw, TNCRS);
3609                adapter->stats.cexterr += 
3610                E1000_READ_REG(&adapter->hw, CEXTERR);
3611                adapter->stats.tsctc += 
3612                E1000_READ_REG(&adapter->hw, TSCTC);
3613                adapter->stats.tsctfc += 
3614                E1000_READ_REG(&adapter->hw, TSCTFC);
3615        }
3616        ifp = &adapter->arpcom.ac_if;
3617
3618        /* Fill out the OS statistics structure */
3619        ifp->if_ibytes = adapter->stats.gorcl;
3620        ifp->if_obytes = adapter->stats.gotcl;
3621        ifp->if_imcasts = adapter->stats.mprc;
3622        ifp->if_collisions = adapter->stats.colc;
3623
3624        /* Rx Errors */
3625        ifp->if_ierrors =
3626        adapter->dropped_pkts +
3627        adapter->stats.rxerrc +
3628        adapter->stats.crcerrs +
3629        adapter->stats.algnerrc +
3630        adapter->stats.rlec +
3631        adapter->stats.mpc + adapter->stats.cexterr;
3632
3633        /* Tx Errors */
3634        ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol;
3635
3636}
3637
3638#ifndef __rtems__
3639/**********************************************************************
3640 *
3641 *  This routine is called only when em_display_debug_stats is enabled.
3642 *  This routine provides a way to take a look at important statistics
3643 *  maintained by the driver and hardware.
3644 *
3645 **********************************************************************/
3646static void
3647em_print_debug_info(struct adapter *adapter)
3648{
3649        int unit = adapter->unit;
3650        uint8_t *hw_addr = adapter->hw.hw_addr;
3651 
3652        printf("em%d: Adapter hardware address = %p \n", unit, hw_addr);
3653        printf("em%d:CTRL  = 0x%x\n", unit, 
3654                E1000_READ_REG(&adapter->hw, CTRL)); 
3655        printf("em%d:RCTL  = 0x%x PS=(0x8402)\n", unit, 
3656                E1000_READ_REG(&adapter->hw, RCTL)); 
3657        printf("em%d:tx_int_delay = %d, tx_abs_int_delay = %d\n", unit, 
3658              E1000_READ_REG(&adapter->hw, TIDV),
3659              E1000_READ_REG(&adapter->hw, TADV));
3660        printf("em%d:rx_int_delay = %d, rx_abs_int_delay = %d\n", unit, 
3661              E1000_READ_REG(&adapter->hw, RDTR),
3662              E1000_READ_REG(&adapter->hw, RADV));
3663        printf("em%d: fifo workaround = %lld, fifo_reset = %lld\n", unit,
3664               (long long)adapter->tx_fifo_wrk_cnt, 
3665               (long long)adapter->tx_fifo_reset_cnt);
3666        printf("em%d: hw tdh = %d, hw tdt = %d\n", unit,
3667               E1000_READ_REG(&adapter->hw, TDH),
3668               E1000_READ_REG(&adapter->hw, TDT));
3669        printf("em%d: Num Tx descriptors avail = %d\n", unit,
3670               adapter->num_tx_desc_avail);
3671        printf("em%d: Tx Descriptors not avail1 = %ld\n", unit,
3672               adapter->no_tx_desc_avail1);
3673        printf("em%d: Tx Descriptors not avail2 = %ld\n", unit,
3674               adapter->no_tx_desc_avail2);
3675        printf("em%d: Std mbuf failed = %ld\n", unit,
3676               adapter->mbuf_alloc_failed);
3677        printf("em%d: Std mbuf cluster failed = %ld\n", unit,
3678               adapter->mbuf_cluster_failed);
3679        printf("em%d: Driver dropped packets = %ld\n", unit,
3680               adapter->dropped_pkts);
3681
3682        return;
3683}
3684#endif
3685
3686static void
3687em_print_hw_stats(struct adapter *adapter)
3688{
3689        int unit = adapter->unit;
3690
3691        printf("em%d: Excessive collisions = %lld\n", unit,
3692               (long long)adapter->stats.ecol);
3693        printf("em%d: Symbol errors = %lld\n", unit,
3694               (long long)adapter->stats.symerrs);
3695        printf("em%d: Sequence errors = %lld\n", unit,
3696               (long long)adapter->stats.sec);
3697        printf("em%d: Defer count = %lld\n", unit,
3698               (long long)adapter->stats.dc);
3699
3700        printf("em%d: Missed Packets = %lld\n", unit,
3701               (long long)adapter->stats.mpc);
3702        printf("em%d: Receive No Buffers = %lld\n", unit,
3703               (long long)adapter->stats.rnbc);
3704        printf("em%d: Receive length errors = %lld\n", unit,
3705               (long long)adapter->stats.rlec);
3706        printf("em%d: Receive errors = %lld\n", unit,
3707               (long long)adapter->stats.rxerrc);
3708        printf("em%d: Crc errors = %lld\n", unit,
3709               (long long)adapter->stats.crcerrs);
3710        printf("em%d: Alignment errors = %lld\n", unit,
3711               (long long)adapter->stats.algnerrc);
3712        printf("em%d: Carrier extension errors = %lld\n", unit,
3713               (long long)adapter->stats.cexterr);
3714
3715        printf("em%d: XON Rcvd = %lld\n", unit,
3716               (long long)adapter->stats.xonrxc);
3717        printf("em%d: XON Xmtd = %lld\n", unit,
3718               (long long)adapter->stats.xontxc);
3719        printf("em%d: XOFF Rcvd = %lld\n", unit,
3720               (long long)adapter->stats.xoffrxc);
3721        printf("em%d: XOFF Xmtd = %lld\n", unit,
3722               (long long)adapter->stats.xofftxc);
3723
3724        printf("em%d: Good Packets Rcvd = %lld\n", unit,
3725               (long long)adapter->stats.gprc);
3726        printf("em%d: Good Packets Xmtd = %lld\n", unit,
3727               (long long)adapter->stats.gptc);
3728
3729        return;
3730}
3731
3732#ifndef __rtems__
3733static int
3734em_sysctl_debug_info(SYSCTL_HANDLER_ARGS)
3735{
3736        int error;
3737        int result;
3738        struct adapter *adapter;
3739
3740        result = -1;
3741        error = sysctl_handle_int(oidp, &result, 0, req);
3742
3743        if (error || !req->newptr)
3744                return (error);
3745
3746        if (result == 1) {
3747                adapter = (struct adapter *)arg1;
3748                em_print_debug_info(adapter);
3749        }
3750
3751        return error;
3752}
3753
3754static int
3755em_sysctl_stats(SYSCTL_HANDLER_ARGS)
3756{
3757        int error;
3758        int result;
3759        struct adapter *adapter;
3760
3761        result = -1;
3762        error = sysctl_handle_int(oidp, &result, 0, req);
3763
3764        if (error || !req->newptr)
3765                return (error);
3766
3767        if (result == 1) {
3768                adapter = (struct adapter *)arg1;
3769                em_print_hw_stats(adapter);
3770        }
3771
3772        return error;
3773}
3774
3775static int
3776em_sysctl_int_delay(SYSCTL_HANDLER_ARGS)
3777{
3778        struct em_int_delay_info *info;
3779        struct adapter *adapter;
3780        u_int32_t regval;
3781        int error;
3782        int usecs;
3783        int ticks;
3784        int s;
3785
3786        info = (struct em_int_delay_info *)arg1;
3787        adapter = info->adapter;
3788        usecs = info->value;
3789        error = sysctl_handle_int(oidp, &usecs, 0, req);
3790        if (error != 0 || req->newptr == NULL)
3791                return error;
3792        if (usecs < 0 || usecs > E1000_TICKS_TO_USECS(65535))
3793                return EINVAL;
3794        info->value = usecs;
3795        ticks = E1000_USECS_TO_TICKS(usecs);
3796       
3797        s = splimp();
3798        regval = E1000_READ_OFFSET(&adapter->hw, info->offset);
3799        regval = (regval & ~0xffff) | (ticks & 0xffff);
3800        /* Handle a few special cases. */
3801        switch (info->offset) {
3802        case E1000_RDTR:
3803        case E1000_82542_RDTR:
3804                regval |= E1000_RDT_FPDB;
3805                break;
3806        case E1000_TIDV:
3807        case E1000_82542_TIDV:
3808                if (ticks == 0) {
3809                        adapter->txd_cmd &= ~E1000_TXD_CMD_IDE;
3810                        /* Don't write 0 into the TIDV register. */
3811                        regval++;
3812                } else
3813                        adapter->txd_cmd |= E1000_TXD_CMD_IDE;
3814                break;
3815        }
3816        E1000_WRITE_OFFSET(&adapter->hw, info->offset, regval);
3817        splx(s);
3818        return 0;
3819}
3820
3821static void
3822em_add_int_delay_sysctl(struct adapter *adapter, const char *name,
3823    const char *description, struct em_int_delay_info *info,
3824    int offset, int value)
3825{
3826        info->adapter = adapter;
3827        info->offset = offset;
3828        info->value = value;
3829        SYSCTL_ADD_PROC(device_get_sysctl_ctx(adapter->dev),
3830            SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
3831            OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW,
3832            info, 0, em_sysctl_int_delay, "I", description);
3833}
3834#endif
3835
3836#ifdef __rtems__
3837/* Initialize bare minimals so we can check the phy link status */
3838int
3839em_hw_early_init(device_t dev)
3840{
3841struct adapter *adapter = device_get_softc(dev);
3842        adapter->dev = dev;
3843        adapter->osdep.dev = dev;
3844        em_identify_hardware(adapter); 
3845        return em_allocate_pci_resources(adapter);
3846}
3847#endif
Note: See TracBrowser for help on using the repository browser.