1 /**************************************************************************
3 Copyright (c) 2001-2003, Intel Corporation
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
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.
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.
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
32 ***************************************************************************/
34 /*$FreeBSD: src/sys/dev/em/if_em.c,v 1.2.2.15 2003/06/09 22:10:15 pdeuskar Exp $*/
35 /*$DragonFly: src/sys/dev/netif/em/if_em.c,v 1.3 2003/08/07 21:17:01 dillon Exp $*/
39 /*********************************************************************
40 * Set this to one to display debug statistics
41 *********************************************************************/
42 int em_display_debug_stats = 0;
44 /*********************************************************************
45 * Linked list of board private structures for all NICs found
46 *********************************************************************/
48 struct adapter *em_adapter_list = NULL;
51 /*********************************************************************
53 *********************************************************************/
55 char em_driver_version[] = "1.6.6";
58 /*********************************************************************
61 * Used by probe to select devices to load on
62 * Last field stores an index into em_strings
63 * Last entry must be all 0s
65 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
66 *********************************************************************/
68 static em_vendor_info_t em_vendor_info_array[] =
70 /* Intel(R) PRO/1000 Network Connection */
71 { 0x8086, 0x1000, PCI_ANY_ID, PCI_ANY_ID, 0},
72 { 0x8086, 0x1001, PCI_ANY_ID, PCI_ANY_ID, 0},
73 { 0x8086, 0x1004, PCI_ANY_ID, PCI_ANY_ID, 0},
74 { 0x8086, 0x1008, PCI_ANY_ID, PCI_ANY_ID, 0},
75 { 0x8086, 0x1009, PCI_ANY_ID, PCI_ANY_ID, 0},
76 { 0x8086, 0x100C, PCI_ANY_ID, PCI_ANY_ID, 0},
77 { 0x8086, 0x100D, PCI_ANY_ID, PCI_ANY_ID, 0},
78 { 0x8086, 0x100E, PCI_ANY_ID, PCI_ANY_ID, 0},
79 { 0x8086, 0x100F, PCI_ANY_ID, PCI_ANY_ID, 0},
80 { 0x8086, 0x1010, PCI_ANY_ID, PCI_ANY_ID, 0},
81 { 0x8086, 0x1011, PCI_ANY_ID, PCI_ANY_ID, 0},
82 { 0x8086, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0},
83 { 0x8086, 0x1013, PCI_ANY_ID, PCI_ANY_ID, 0},
84 { 0x8086, 0x1014, PCI_ANY_ID, PCI_ANY_ID, 0},
85 { 0x8086, 0x1015, PCI_ANY_ID, PCI_ANY_ID, 0},
86 { 0x8086, 0x1016, PCI_ANY_ID, PCI_ANY_ID, 0},
87 { 0x8086, 0x1017, PCI_ANY_ID, PCI_ANY_ID, 0},
88 { 0x8086, 0x1018, PCI_ANY_ID, PCI_ANY_ID, 0},
89 { 0x8086, 0x1019, PCI_ANY_ID, PCI_ANY_ID, 0},
90 { 0x8086, 0x101A, PCI_ANY_ID, PCI_ANY_ID, 0},
91 { 0x8086, 0x101D, PCI_ANY_ID, PCI_ANY_ID, 0},
92 { 0x8086, 0x101E, PCI_ANY_ID, PCI_ANY_ID, 0},
93 /* required last entry */
97 /*********************************************************************
98 * Table of branding strings for all supported NICs.
99 *********************************************************************/
101 static char *em_strings[] = {
102 "Intel(R) PRO/1000 Network Connection"
105 /*********************************************************************
106 * Function prototypes
107 *********************************************************************/
108 static int em_probe(device_t);
109 static int em_attach(device_t);
110 static int em_detach(device_t);
111 static int em_shutdown(device_t);
112 static void em_intr(void *);
113 static void em_start(struct ifnet *);
114 static int em_ioctl(struct ifnet *, u_long, caddr_t);
115 static void em_watchdog(struct ifnet *);
116 static void em_init(void *);
117 static void em_stop(void *);
118 static void em_media_status(struct ifnet *, struct ifmediareq *);
119 static int em_media_change(struct ifnet *);
120 static void em_identify_hardware(struct adapter *);
121 static int em_allocate_pci_resources(struct adapter *);
122 static void em_free_pci_resources(struct adapter *);
123 static void em_local_timer(void *);
124 static int em_hardware_init(struct adapter *);
125 static void em_setup_interface(device_t, struct adapter *);
126 static int em_setup_transmit_structures(struct adapter *);
127 static void em_initialize_transmit_unit(struct adapter *);
128 static int em_setup_receive_structures(struct adapter *);
129 static void em_initialize_receive_unit(struct adapter *);
130 static void em_enable_intr(struct adapter *);
131 static void em_disable_intr(struct adapter *);
132 static void em_free_transmit_structures(struct adapter *);
133 static void em_free_receive_structures(struct adapter *);
134 static void em_update_stats_counters(struct adapter *);
135 static void em_clean_transmit_interrupts(struct adapter *);
136 static int em_allocate_receive_structures(struct adapter *);
137 static int em_allocate_transmit_structures(struct adapter *);
138 static void em_process_receive_interrupts(struct adapter *, int);
139 static void em_receive_checksum(struct adapter *,
142 static void em_transmit_checksum_setup(struct adapter *,
146 static void em_set_promisc(struct adapter *);
147 static void em_disable_promisc(struct adapter *);
148 static void em_set_multi(struct adapter *);
149 static void em_print_hw_stats(struct adapter *);
150 static void em_print_link_status(struct adapter *);
151 static int em_get_buf(int i, struct adapter *,
153 static void em_enable_vlans(struct adapter *);
154 static int em_encap(struct adapter *, struct mbuf *);
155 static void em_smartspeed(struct adapter *);
156 static int em_82547_fifo_workaround(struct adapter *, int);
157 static void em_82547_update_fifo_head(struct adapter *, int);
158 static int em_82547_tx_fifo_reset(struct adapter *);
159 static void em_82547_move_tail(void *arg);
160 static void em_print_debug_info(struct adapter *);
161 static int em_is_valid_ether_addr(u_int8_t *);
162 static int em_sysctl_stats(SYSCTL_HANDLER_ARGS);
163 static int em_sysctl_debug_info(SYSCTL_HANDLER_ARGS);
165 /*********************************************************************
166 * FreeBSD Device Interface Entry Points
167 *********************************************************************/
169 static device_method_t em_methods[] = {
170 /* Device interface */
171 DEVMETHOD(device_probe, em_probe),
172 DEVMETHOD(device_attach, em_attach),
173 DEVMETHOD(device_detach, em_detach),
174 DEVMETHOD(device_shutdown, em_shutdown),
178 static driver_t em_driver = {
179 "em", em_methods, sizeof(struct adapter ),
182 static devclass_t em_devclass;
183 DRIVER_MODULE(if_em, pci, em_driver, em_devclass, 0, 0);
185 /*********************************************************************
186 * Device identification routine
188 * em_probe determines if the driver should be loaded on
189 * adapter based on PCI vendor/device id of the adapter.
191 * return 0 on success, positive on failure
192 *********************************************************************/
195 em_probe(device_t dev)
197 em_vendor_info_t *ent;
199 u_int16_t pci_vendor_id = 0;
200 u_int16_t pci_device_id = 0;
201 u_int16_t pci_subvendor_id = 0;
202 u_int16_t pci_subdevice_id = 0;
203 char adapter_name[60];
205 INIT_DEBUGOUT("em_probe: begin");
207 pci_vendor_id = pci_get_vendor(dev);
208 if (pci_vendor_id != EM_VENDOR_ID)
211 pci_device_id = pci_get_device(dev);
212 pci_subvendor_id = pci_get_subvendor(dev);
213 pci_subdevice_id = pci_get_subdevice(dev);
215 ent = em_vendor_info_array;
216 while (ent->vendor_id != 0) {
217 if ((pci_vendor_id == ent->vendor_id) &&
218 (pci_device_id == ent->device_id) &&
220 ((pci_subvendor_id == ent->subvendor_id) ||
221 (ent->subvendor_id == PCI_ANY_ID)) &&
223 ((pci_subdevice_id == ent->subdevice_id) ||
224 (ent->subdevice_id == PCI_ANY_ID))) {
225 sprintf(adapter_name, "%s, Version - %s",
226 em_strings[ent->index],
228 device_set_desc_copy(dev, adapter_name);
237 /*********************************************************************
238 * Device initialization routine
240 * The attach entry point is called when the driver is being loaded.
241 * This routine identifies the type of hardware, allocates all resources
242 * and initializes the hardware.
244 * return 0 on success, positive on failure
245 *********************************************************************/
248 em_attach(device_t dev)
250 struct adapter * adapter;
255 INIT_DEBUGOUT("em_attach: begin");
258 /* Allocate, clear, and link in our adapter structure */
259 if (!(adapter = device_get_softc(dev))) {
260 printf("em: adapter structure allocation failed\n");
264 bzero(adapter, sizeof(struct adapter ));
266 adapter->osdep.dev = dev;
267 adapter->unit = device_get_unit(dev);
269 if (em_adapter_list != NULL)
270 em_adapter_list->prev = adapter;
271 adapter->next = em_adapter_list;
272 em_adapter_list = adapter;
275 sysctl_ctx_init(&adapter->sysctl_ctx);
276 adapter->sysctl_tree = SYSCTL_ADD_NODE(&adapter->sysctl_ctx,
277 SYSCTL_STATIC_CHILDREN(_hw),
279 device_get_nameunit(dev),
282 if (adapter->sysctl_tree == NULL) {
287 SYSCTL_ADD_PROC(&adapter->sysctl_ctx,
288 SYSCTL_CHILDREN(adapter->sysctl_tree),
289 OID_AUTO, "debug_info", CTLTYPE_INT|CTLFLAG_RW,
291 em_sysctl_debug_info, "I", "Debug Information");
293 SYSCTL_ADD_PROC(&adapter->sysctl_ctx,
294 SYSCTL_CHILDREN(adapter->sysctl_tree),
295 OID_AUTO, "stats", CTLTYPE_INT|CTLFLAG_RW,
297 em_sysctl_stats, "I", "Statistics");
299 callout_handle_init(&adapter->timer_handle);
300 callout_handle_init(&adapter->tx_fifo_timer_handle);
302 /* Determine hardware revision */
303 em_identify_hardware(adapter);
305 /* Parameters (to be read from user) */
306 adapter->num_tx_desc = EM_MAX_TXD;
307 adapter->num_rx_desc = EM_MAX_RXD;
308 adapter->tx_int_delay = EM_TIDV;
309 adapter->tx_abs_int_delay = EM_TADV;
310 adapter->rx_int_delay = EM_RDTR;
311 adapter->rx_abs_int_delay = EM_RADV;
312 adapter->hw.autoneg = DO_AUTO_NEG;
313 adapter->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT;
314 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
315 adapter->hw.tbi_compatibility_en = TRUE;
316 adapter->rx_buffer_len = EM_RXBUFFER_2048;
319 * These parameters control the automatic generation(Tx) and
320 * response(Rx) to Ethernet PAUSE frames.
322 adapter->hw.fc_high_water = FC_DEFAULT_HI_THRESH;
323 adapter->hw.fc_low_water = FC_DEFAULT_LO_THRESH;
324 adapter->hw.fc_pause_time = FC_DEFAULT_TX_TIMER;
325 adapter->hw.fc_send_xon = TRUE;
326 adapter->hw.fc = em_fc_full;
328 adapter->hw.phy_init_script = 1;
331 * Set the max frame size assuming standard ethernet
334 adapter->hw.max_frame_size =
335 ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN;
337 adapter->hw.min_frame_size =
338 MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN;
341 * This controls when hardware reports transmit completion
344 adapter->hw.report_tx_early = 1;
347 if (em_allocate_pci_resources(adapter)) {
348 printf("em%d: Allocation of PCI resources failed\n",
354 em_init_eeprom_params(&adapter->hw);
356 tsize = EM_ROUNDUP(adapter->num_tx_desc *
357 sizeof(struct em_tx_desc), 4096);
359 /* Allocate Transmit Descriptor ring */
360 if (!(adapter->tx_desc_base = (struct em_tx_desc *)
361 contigmalloc(tsize, M_DEVBUF, M_NOWAIT, 0, ~0,
363 printf("em%d: Unable to allocate TxDescriptor memory\n",
369 rsize = EM_ROUNDUP(adapter->num_rx_desc *
370 sizeof(struct em_rx_desc), 4096);
372 /* Allocate Receive Descriptor ring */
373 if (!(adapter->rx_desc_base = (struct em_rx_desc *)
374 contigmalloc(rsize, M_DEVBUF, M_NOWAIT, 0, ~0,
376 printf("em%d: Unable to allocate rx_desc memory\n",
382 /* Initialize the hardware */
383 if (em_hardware_init(adapter)) {
384 printf("em%d: Unable to initialize the hardware\n",
390 /* Copy the permanent MAC address out of the EEPROM */
391 if (em_read_mac_addr(&adapter->hw) < 0) {
392 printf("em%d: EEPROM read error while reading mac address\n",
398 if (!em_is_valid_ether_addr(adapter->hw.mac_addr)) {
399 printf("em%d: Invalid mac address\n", adapter->unit);
405 bcopy(adapter->hw.mac_addr, adapter->interface_data.ac_enaddr,
408 /* Setup OS specific network interface */
409 em_setup_interface(dev, adapter);
411 /* Initialize statistics */
412 em_clear_hw_cntrs(&adapter->hw);
413 em_update_stats_counters(adapter);
414 adapter->hw.get_link_status = 1;
415 em_check_for_link(&adapter->hw);
417 /* Print the link status */
418 if (adapter->link_active == 1) {
419 em_get_speed_and_duplex(&adapter->hw, &adapter->link_speed,
420 &adapter->link_duplex);
421 printf("em%d: Speed:%d Mbps Duplex:%s\n",
424 adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half");
426 printf("em%d: Speed:N/A Duplex:N/A\n", adapter->unit);
428 INIT_DEBUGOUT("em_attach: end");
435 contigfree(adapter->rx_desc_base, rsize, M_DEVBUF);
437 contigfree(adapter->tx_desc_base, tsize, M_DEVBUF);
440 em_free_pci_resources(adapter);
441 sysctl_ctx_free(&adapter->sysctl_ctx);
447 /*********************************************************************
448 * Device removal routine
450 * The detach entry point is called when the driver is being removed.
451 * This routine stops the adapter and deallocates all the resources
452 * that were allocated for driver operation.
454 * return 0 on success, positive on failure
455 *********************************************************************/
458 em_detach(device_t dev)
460 struct adapter * adapter = device_get_softc(dev);
461 struct ifnet *ifp = &adapter->interface_data.ac_if;
465 INIT_DEBUGOUT("em_detach: begin");
469 em_phy_hw_reset(&adapter->hw);
470 #if __FreeBSD_version < 500000
471 ether_ifdetach(&adapter->interface_data.ac_if, ETHER_BPF_SUPPORTED);
473 ether_ifdetach(&adapter->interface_data.ac_if);
475 em_free_pci_resources(adapter);
477 size = EM_ROUNDUP(adapter->num_tx_desc *
478 sizeof(struct em_tx_desc), 4096);
480 /* Free Transmit Descriptor ring */
481 if (adapter->tx_desc_base) {
482 contigfree(adapter->tx_desc_base, size, M_DEVBUF);
483 adapter->tx_desc_base = NULL;
486 size = EM_ROUNDUP(adapter->num_rx_desc *
487 sizeof(struct em_rx_desc), 4096);
489 /* Free Receive Descriptor ring */
490 if (adapter->rx_desc_base) {
491 contigfree(adapter->rx_desc_base, size, M_DEVBUF);
492 adapter->rx_desc_base = NULL;
495 /* Remove from the adapter list */
496 if (em_adapter_list == adapter)
497 em_adapter_list = adapter->next;
498 if (adapter->next != NULL)
499 adapter->next->prev = adapter->prev;
500 if (adapter->prev != NULL)
501 adapter->prev->next = adapter->next;
503 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
506 adapter->sysctl_tree = NULL;
507 sysctl_ctx_free(&adapter->sysctl_ctx);
513 /*********************************************************************
515 * Shutdown entry point
517 **********************************************************************/
520 em_shutdown(device_t dev)
522 struct adapter *adapter = device_get_softc(dev);
528 /*********************************************************************
529 * Transmit entry point
531 * em_start is called by the stack to initiate a transmit.
532 * The driver will remain in this routine as long as there are
533 * packets to transmit and transmit resources are available.
534 * In case resources are not available stack is notified and
535 * the packet is requeued.
536 **********************************************************************/
539 em_start(struct ifnet *ifp)
543 struct adapter *adapter = ifp->if_softc;
545 if (!adapter->link_active)
549 while (ifp->if_snd.ifq_head != NULL) {
551 IF_DEQUEUE(&ifp->if_snd, m_head);
553 if (m_head == NULL) break;
555 if (em_encap(adapter, m_head)) {
556 ifp->if_flags |= IFF_OACTIVE;
557 IF_PREPEND(&ifp->if_snd, m_head);
561 /* Send a copy of the frame to the BPF listener */
562 #if __FreeBSD_version < 500000
564 bpf_mtap(ifp, m_head);
566 BPF_MTAP(ifp, m_head);
569 /* Set timeout in case hardware has problems transmitting */
570 ifp->if_timer = EM_TX_TIMEOUT;
577 /*********************************************************************
580 * em_ioctl is called when the user wants to configure the
583 * return 0 on success, positive on failure
584 **********************************************************************/
587 em_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
589 int s, mask, error = 0;
590 struct ifreq *ifr = (struct ifreq *) data;
591 struct adapter * adapter = ifp->if_softc;
597 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)");
598 ether_ioctl(ifp, command, data);
601 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)");
602 if (ifr->ifr_mtu > MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN) {
605 ifp->if_mtu = ifr->ifr_mtu;
606 adapter->hw.max_frame_size =
607 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
612 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)");
613 if (ifp->if_flags & IFF_UP) {
614 if (!(ifp->if_flags & IFF_RUNNING))
617 em_disable_promisc(adapter);
618 em_set_promisc(adapter);
620 if (ifp->if_flags & IFF_RUNNING) {
627 IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI");
628 if (ifp->if_flags & IFF_RUNNING) {
629 em_disable_intr(adapter);
630 em_set_multi(adapter);
631 if (adapter->hw.mac_type == em_82542_rev2_0) {
632 em_initialize_receive_unit(adapter);
634 #ifdef DEVICE_POLLING
635 if (!(ifp->if_ipending & IFF_POLLING))
637 em_enable_intr(adapter);
642 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)");
643 error = ifmedia_ioctl(ifp, ifr, &adapter->media, command);
646 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)");
647 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
648 if (mask & IFCAP_HWCSUM) {
649 if (IFCAP_HWCSUM & ifp->if_capenable)
650 ifp->if_capenable &= ~IFCAP_HWCSUM;
652 ifp->if_capenable |= IFCAP_HWCSUM;
653 if (ifp->if_flags & IFF_RUNNING)
658 IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%d)\n", (int)command);
666 /*********************************************************************
667 * Watchdog entry point
669 * This routine is called whenever hardware quits transmitting.
671 **********************************************************************/
674 em_watchdog(struct ifnet *ifp)
676 struct adapter * adapter;
677 adapter = ifp->if_softc;
679 /* If we are in this routine because of pause frames, then
680 * don't reset the hardware.
682 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF) {
683 ifp->if_timer = EM_TX_TIMEOUT;
687 printf("em%d: watchdog timeout -- resetting\n", adapter->unit);
689 ifp->if_flags &= ~IFF_RUNNING;
698 /*********************************************************************
701 * This routine is used in two ways. It is used by the stack as
702 * init entry point in network interface structure. It is also used
703 * by the driver as a hw/sw initialization routine to get to a
706 * return 0 on success, positive on failure
707 **********************************************************************/
714 struct adapter * adapter = arg;
716 INIT_DEBUGOUT("em_init: begin");
722 /* Initialize the hardware */
723 if (em_hardware_init(adapter)) {
724 printf("em%d: Unable to initialize the hardware\n",
730 em_enable_vlans(adapter);
732 /* Prepare transmit descriptors and buffers */
733 if (em_setup_transmit_structures(adapter)) {
734 printf("em%d: Could not setup transmit structures\n",
740 em_initialize_transmit_unit(adapter);
742 /* Setup Multicast table */
743 em_set_multi(adapter);
745 /* Prepare receive descriptors and buffers */
746 if (em_setup_receive_structures(adapter)) {
747 printf("em%d: Could not setup receive structures\n",
753 em_initialize_receive_unit(adapter);
755 ifp = &adapter->interface_data.ac_if;
756 ifp->if_flags |= IFF_RUNNING;
757 ifp->if_flags &= ~IFF_OACTIVE;
759 if (adapter->hw.mac_type >= em_82543) {
760 if (ifp->if_capenable & IFCAP_TXCSUM)
761 ifp->if_hwassist = EM_CHECKSUM_FEATURES;
763 ifp->if_hwassist = 0;
766 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz);
767 em_clear_hw_cntrs(&adapter->hw);
768 #ifdef DEVICE_POLLING
770 * Only enable interrupts if we are not polling, make sure
771 * they are off otherwise.
773 if (ifp->if_ipending & IFF_POLLING)
774 em_disable_intr(adapter);
776 #endif /* DEVICE_POLLING */
777 em_enable_intr(adapter);
784 #ifdef DEVICE_POLLING
785 static poll_handler_t em_poll;
788 em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
790 struct adapter *adapter = ifp->if_softc;
793 if (cmd == POLL_DEREGISTER) { /* final call, enable interrupts */
794 em_enable_intr(adapter);
797 if (cmd == POLL_AND_CHECK_STATUS) {
798 reg_icr = E1000_READ_REG(&adapter->hw, ICR);
799 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
800 untimeout(em_local_timer, adapter, adapter->timer_handle);
801 adapter->hw.get_link_status = 1;
802 em_check_for_link(&adapter->hw);
803 em_print_link_status(adapter);
804 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz);
807 if (ifp->if_flags & IFF_RUNNING) {
808 em_process_receive_interrupts(adapter, count);
809 em_clean_transmit_interrupts(adapter);
812 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL)
815 #endif /* DEVICE_POLLING */
817 /*********************************************************************
819 * Interrupt Service routine
821 **********************************************************************/
825 u_int32_t loop_cnt = EM_MAX_INTR;
828 struct adapter *adapter = arg;
830 ifp = &adapter->interface_data.ac_if;
832 #ifdef DEVICE_POLLING
833 if (ifp->if_ipending & IFF_POLLING)
836 if (ether_poll_register(em_poll, ifp)) {
837 em_disable_intr(adapter);
841 #endif /* DEVICE_POLLING */
843 reg_icr = E1000_READ_REG(&adapter->hw, ICR);
848 /* Link status change */
849 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
850 untimeout(em_local_timer, adapter,
851 adapter->timer_handle);
852 adapter->hw.get_link_status = 1;
853 em_check_for_link(&adapter->hw);
854 em_print_link_status(adapter);
855 adapter->timer_handle =
856 timeout(em_local_timer, adapter, 2*hz);
859 while (loop_cnt > 0) {
860 if (ifp->if_flags & IFF_RUNNING) {
861 em_process_receive_interrupts(adapter, -1);
862 em_clean_transmit_interrupts(adapter);
867 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL)
875 /*********************************************************************
877 * Media Ioctl callback
879 * This routine is called whenever the user queries the status of
880 * the interface using ifconfig.
882 **********************************************************************/
884 em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
886 struct adapter * adapter = ifp->if_softc;
888 INIT_DEBUGOUT("em_media_status: begin");
890 em_check_for_link(&adapter->hw);
891 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
892 if (adapter->link_active == 0) {
893 em_get_speed_and_duplex(&adapter->hw,
894 &adapter->link_speed,
895 &adapter->link_duplex);
896 adapter->link_active = 1;
899 if (adapter->link_active == 1) {
900 adapter->link_speed = 0;
901 adapter->link_duplex = 0;
902 adapter->link_active = 0;
906 ifmr->ifm_status = IFM_AVALID;
907 ifmr->ifm_active = IFM_ETHER;
909 if (!adapter->link_active)
912 ifmr->ifm_status |= IFM_ACTIVE;
914 if (adapter->hw.media_type == em_media_type_fiber) {
915 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX;
917 switch (adapter->link_speed) {
919 ifmr->ifm_active |= IFM_10_T;
922 ifmr->ifm_active |= IFM_100_TX;
925 #if __FreeBSD_version < 500000
926 ifmr->ifm_active |= IFM_1000_TX;
928 ifmr->ifm_active |= IFM_1000_T;
932 if (adapter->link_duplex == FULL_DUPLEX)
933 ifmr->ifm_active |= IFM_FDX;
935 ifmr->ifm_active |= IFM_HDX;
940 /*********************************************************************
942 * Media Ioctl callback
944 * This routine is called when the user changes speed/duplex using
945 * media/mediopt option with ifconfig.
947 **********************************************************************/
949 em_media_change(struct ifnet *ifp)
951 struct adapter * adapter = ifp->if_softc;
952 struct ifmedia *ifm = &adapter->media;
954 INIT_DEBUGOUT("em_media_change: begin");
956 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
959 switch (IFM_SUBTYPE(ifm->ifm_media)) {
961 adapter->hw.autoneg = DO_AUTO_NEG;
962 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
965 #if __FreeBSD_version < 500000
970 adapter->hw.autoneg = DO_AUTO_NEG;
971 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
974 adapter->hw.autoneg = FALSE;
975 adapter->hw.autoneg_advertised = 0;
976 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
977 adapter->hw.forced_speed_duplex = em_100_full;
979 adapter->hw.forced_speed_duplex = em_100_half;
982 adapter->hw.autoneg = FALSE;
983 adapter->hw.autoneg_advertised = 0;
984 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
985 adapter->hw.forced_speed_duplex = em_10_full;
987 adapter->hw.forced_speed_duplex = em_10_half;
990 printf("em%d: Unsupported media type\n", adapter->unit);
998 #define EM_FIFO_HDR 0x10
999 #define EM_82547_PKT_THRESH 0x3e0
1000 #define EM_82547_TX_FIFO_SIZE 0x2800
1001 #define EM_82547_TX_FIFO_BEGIN 0xf00
1002 /*********************************************************************
1004 * This routine maps the mbufs to tx descriptors.
1006 * return 0 on success, positive on failure
1007 **********************************************************************/
1010 em_encap(struct adapter *adapter, struct mbuf *m_head)
1012 vm_offset_t virtual_addr;
1013 u_int32_t txd_upper;
1014 u_int32_t txd_lower;
1015 int txd_used, i, txd_saved;
1018 #if __FreeBSD_version < 500000
1019 struct ifvlan *ifv = NULL;
1023 struct em_buffer *tx_buffer = NULL;
1024 struct em_tx_desc *current_tx_desc = NULL;
1025 struct ifnet *ifp = &adapter->interface_data.ac_if;
1028 * Force a cleanup if number of TX descriptors
1029 * available hits the threshold
1031 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD)
1032 em_clean_transmit_interrupts(adapter);
1034 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
1035 adapter->no_tx_desc_avail1++;
1039 if (ifp->if_hwassist > 0) {
1040 em_transmit_checksum_setup(adapter, m_head,
1041 &txd_upper, &txd_lower);
1044 txd_upper = txd_lower = 0;
1047 /* Find out if we are in vlan mode */
1048 #if __FreeBSD_version < 500000
1049 if ((m_head->m_flags & (M_PROTO1|M_PKTHDR)) == (M_PROTO1|M_PKTHDR) &&
1050 m_head->m_pkthdr.rcvif != NULL &&
1051 m_head->m_pkthdr.rcvif->if_type == IFT_L2VLAN)
1052 ifv = m_head->m_pkthdr.rcvif->if_softc;
1054 mtag = VLAN_OUTPUT_TAG(ifp, m_head);
1057 i = adapter->next_avail_tx_desc;
1060 for (mp = m_head; mp != NULL; mp = mp->m_next) {
1064 if (txd_used == adapter->num_tx_desc_avail) {
1065 adapter->next_avail_tx_desc = txd_saved;
1066 adapter->no_tx_desc_avail2++;
1070 tx_buffer = &adapter->tx_buffer_area[i];
1071 current_tx_desc = &adapter->tx_desc_base[i];
1072 virtual_addr = mtod(mp, vm_offset_t);
1073 current_tx_desc->buffer_addr = vtophys(virtual_addr);
1075 current_tx_desc->lower.data = (adapter->txd_cmd | txd_lower | mp->m_len);
1076 current_tx_desc->upper.data = (txd_upper);
1078 if (++i == adapter->num_tx_desc)
1081 tx_buffer->m_head = NULL;
1086 adapter->num_tx_desc_avail -= txd_used;
1087 adapter->next_avail_tx_desc = i;
1089 #if __FreeBSD_version < 500000
1091 /* Set the vlan id */
1092 current_tx_desc->upper.fields.special = ifv->ifv_tag;
1095 /* Set the vlan id */
1096 current_tx_desc->upper.fields.special = VLAN_TAG_VALUE(mtag);
1098 /* Tell hardware to add tag */
1099 current_tx_desc->lower.data |= E1000_TXD_CMD_VLE;
1102 tx_buffer->m_head = m_head;
1105 * Last Descriptor of Packet needs End Of Packet (EOP)
1107 current_tx_desc->lower.data |= (E1000_TXD_CMD_EOP);
1110 * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000
1111 * that this frame is available to transmit.
1113 if (adapter->hw.mac_type == em_82547 &&
1114 adapter->link_duplex == HALF_DUPLEX) {
1115 em_82547_move_tail(adapter);
1118 E1000_WRITE_REG(&adapter->hw, TDT, i);
1119 if (adapter->hw.mac_type == em_82547) {
1120 em_82547_update_fifo_head(adapter, m_head->m_pkthdr.len);
1128 /*********************************************************************
1130 * 82547 workaround to avoid controller hang in half-duplex environment.
1131 * The workaround is to avoid queuing a large packet that would span
1132 * the internal Tx FIFO ring boundary. We need to reset the FIFO pointers
1133 * in this case. We do that only when FIFO is queiced.
1135 **********************************************************************/
1137 em_82547_move_tail(void *arg)
1140 struct adapter *adapter = arg;
1143 struct em_tx_desc *tx_desc;
1144 uint16_t length = 0;
1148 hw_tdt = E1000_READ_REG(&adapter->hw, TDT);
1149 sw_tdt = adapter->next_avail_tx_desc;
1151 while (hw_tdt != sw_tdt) {
1152 tx_desc = &adapter->tx_desc_base[hw_tdt];
1153 length += tx_desc->lower.flags.length;
1154 eop = tx_desc->lower.data & E1000_TXD_CMD_EOP;
1155 if(++hw_tdt == adapter->num_tx_desc)
1159 if (em_82547_fifo_workaround(adapter, length)) {
1160 adapter->tx_fifo_wrk++;
1161 adapter->tx_fifo_timer_handle =
1162 timeout(em_82547_move_tail,
1168 E1000_WRITE_REG(&adapter->hw, TDT, hw_tdt);
1169 em_82547_update_fifo_head(adapter, length);
1179 em_82547_fifo_workaround(struct adapter *adapter, int len)
1181 int fifo_space, fifo_pkt_len;
1183 fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR);
1185 if (adapter->link_duplex == HALF_DUPLEX) {
1186 fifo_space = EM_82547_TX_FIFO_SIZE - adapter->tx_fifo_head;
1188 if (fifo_pkt_len >= (EM_82547_PKT_THRESH + fifo_space)) {
1189 if (em_82547_tx_fifo_reset(adapter)) {
1202 em_82547_update_fifo_head(struct adapter *adapter, int len)
1204 int fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR);
1206 /* tx_fifo_head is always 16 byte aligned */
1207 adapter->tx_fifo_head += fifo_pkt_len;
1208 if (adapter->tx_fifo_head >= EM_82547_TX_FIFO_SIZE) {
1209 adapter->tx_fifo_head -= EM_82547_TX_FIFO_SIZE;
1217 em_82547_tx_fifo_reset(struct adapter *adapter)
1221 if ( (E1000_READ_REG(&adapter->hw, TDT) ==
1222 E1000_READ_REG(&adapter->hw, TDH)) &&
1223 (E1000_READ_REG(&adapter->hw, TDFT) ==
1224 E1000_READ_REG(&adapter->hw, TDFH)) &&
1225 (E1000_READ_REG(&adapter->hw, TDFTS) ==
1226 E1000_READ_REG(&adapter->hw, TDFHS)) &&
1227 (E1000_READ_REG(&adapter->hw, TDFPC) == 0)) {
1229 /* Disable TX unit */
1230 tctl = E1000_READ_REG(&adapter->hw, TCTL);
1231 E1000_WRITE_REG(&adapter->hw, TCTL, tctl & ~E1000_TCTL_EN);
1233 /* Reset FIFO pointers */
1234 E1000_WRITE_REG(&adapter->hw, TDFT, EM_82547_TX_FIFO_BEGIN);
1235 E1000_WRITE_REG(&adapter->hw, TDFH, EM_82547_TX_FIFO_BEGIN);
1236 E1000_WRITE_REG(&adapter->hw, TDFTS, EM_82547_TX_FIFO_BEGIN);
1237 E1000_WRITE_REG(&adapter->hw, TDFHS, EM_82547_TX_FIFO_BEGIN);
1239 /* Re-enable TX unit */
1240 E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
1241 E1000_WRITE_FLUSH(&adapter->hw);
1243 adapter->tx_fifo_head = 0;
1244 adapter->tx_fifo_reset++;
1254 em_set_promisc(struct adapter * adapter)
1258 struct ifnet *ifp = &adapter->interface_data.ac_if;
1260 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1262 if (ifp->if_flags & IFF_PROMISC) {
1263 reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
1264 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1265 } else if (ifp->if_flags & IFF_ALLMULTI) {
1266 reg_rctl |= E1000_RCTL_MPE;
1267 reg_rctl &= ~E1000_RCTL_UPE;
1268 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1275 em_disable_promisc(struct adapter * adapter)
1279 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1281 reg_rctl &= (~E1000_RCTL_UPE);
1282 reg_rctl &= (~E1000_RCTL_MPE);
1283 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1289 /*********************************************************************
1292 * This routine is called whenever multicast address list is updated.
1294 **********************************************************************/
1297 em_set_multi(struct adapter * adapter)
1299 u_int32_t reg_rctl = 0;
1300 u_int8_t mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS];
1301 struct ifmultiaddr *ifma;
1303 struct ifnet *ifp = &adapter->interface_data.ac_if;
1305 IOCTL_DEBUGOUT("em_set_multi: begin");
1307 if (adapter->hw.mac_type == em_82542_rev2_0) {
1308 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1309 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
1310 em_pci_clear_mwi(&adapter->hw);
1312 reg_rctl |= E1000_RCTL_RST;
1313 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1317 #if __FreeBSD_version < 500000
1318 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1320 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1322 if (ifma->ifma_addr->sa_family != AF_LINK)
1325 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) break;
1327 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
1328 &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS);
1332 if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) {
1333 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1334 reg_rctl |= E1000_RCTL_MPE;
1335 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1337 em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0);
1339 if (adapter->hw.mac_type == em_82542_rev2_0) {
1340 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1341 reg_rctl &= ~E1000_RCTL_RST;
1342 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1344 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
1345 em_pci_set_mwi(&adapter->hw);
1353 /*********************************************************************
1356 * This routine checks for link status and updates statistics.
1358 **********************************************************************/
1361 em_local_timer(void *arg)
1365 struct adapter * adapter = arg;
1366 ifp = &adapter->interface_data.ac_if;
1370 em_check_for_link(&adapter->hw);
1371 em_print_link_status(adapter);
1372 em_update_stats_counters(adapter);
1373 if (em_display_debug_stats && ifp->if_flags & IFF_RUNNING) {
1374 em_print_hw_stats(adapter);
1376 em_smartspeed(adapter);
1378 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz);
1385 em_print_link_status(struct adapter * adapter)
1387 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
1388 if (adapter->link_active == 0) {
1389 em_get_speed_and_duplex(&adapter->hw,
1390 &adapter->link_speed,
1391 &adapter->link_duplex);
1392 printf("em%d: Link is up %d Mbps %s\n",
1394 adapter->link_speed,
1395 ((adapter->link_duplex == FULL_DUPLEX) ?
1396 "Full Duplex" : "Half Duplex"));
1397 adapter->link_active = 1;
1398 adapter->smartspeed = 0;
1401 if (adapter->link_active == 1) {
1402 adapter->link_speed = 0;
1403 adapter->link_duplex = 0;
1404 printf("em%d: Link is Down\n", adapter->unit);
1405 adapter->link_active = 0;
1412 /*********************************************************************
1414 * This routine disables all traffic on the adapter by issuing a
1415 * global reset on the MAC and deallocates TX/RX buffers.
1417 **********************************************************************/
1423 struct adapter * adapter = arg;
1424 ifp = &adapter->interface_data.ac_if;
1426 INIT_DEBUGOUT("em_stop: begin\n");
1427 em_disable_intr(adapter);
1428 em_reset_hw(&adapter->hw);
1429 untimeout(em_local_timer, adapter, adapter->timer_handle);
1430 untimeout(em_82547_move_tail, adapter,
1431 adapter->tx_fifo_timer_handle);
1432 em_free_transmit_structures(adapter);
1433 em_free_receive_structures(adapter);
1436 /* Tell the stack that the interface is no longer active */
1437 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1443 /*********************************************************************
1445 * Determine hardware revision.
1447 **********************************************************************/
1449 em_identify_hardware(struct adapter * adapter)
1451 device_t dev = adapter->dev;
1453 /* Make sure our PCI config space has the necessary stuff set */
1454 adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
1455 if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) &&
1456 (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) {
1457 printf("em%d: Memory Access and/or Bus Master bits were not set!\n",
1459 adapter->hw.pci_cmd_word |=
1460 (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN);
1461 pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2);
1464 /* Save off the information about this board */
1465 adapter->hw.vendor_id = pci_get_vendor(dev);
1466 adapter->hw.device_id = pci_get_device(dev);
1467 adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1);
1468 adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2);
1469 adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2);
1471 /* Identify the MAC */
1472 if (em_set_mac_type(&adapter->hw))
1473 printf("em%d: Unknown MAC Type\n", adapter->unit);
1479 em_allocate_pci_resources(struct adapter * adapter)
1482 device_t dev = adapter->dev;
1485 adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY,
1488 if (!(adapter->res_memory)) {
1489 printf("em%d: Unable to allocate bus resource: memory\n",
1493 adapter->osdep.mem_bus_space_tag =
1494 rman_get_bustag(adapter->res_memory);
1495 adapter->osdep.mem_bus_space_handle =
1496 rman_get_bushandle(adapter->res_memory);
1497 adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle;
1500 if (adapter->hw.mac_type > em_82543) {
1501 /* Figure our where our IO BAR is ? */
1503 for (i = 0; i < 5; i++) {
1504 val = pci_read_config(dev, rid, 4);
1505 if (val & 0x00000001) {
1506 adapter->io_rid = rid;
1512 adapter->res_ioport = bus_alloc_resource(dev, SYS_RES_IOPORT,
1513 &adapter->io_rid, 0, ~0, 1,
1515 if (!(adapter->res_ioport)) {
1516 printf("em%d: Unable to allocate bus resource: ioport\n",
1521 adapter->hw.io_base =
1522 rman_get_start(adapter->res_ioport);
1526 adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ,
1528 RF_SHAREABLE | RF_ACTIVE);
1529 if (!(adapter->res_interrupt)) {
1530 printf("em%d: Unable to allocate bus resource: interrupt\n",
1534 if (bus_setup_intr(dev, adapter->res_interrupt, INTR_TYPE_NET,
1535 (void (*)(void *)) em_intr, adapter,
1536 &adapter->int_handler_tag)) {
1537 printf("em%d: Error registering interrupt handler!\n",
1542 adapter->hw.back = &adapter->osdep;
1548 em_free_pci_resources(struct adapter * adapter)
1550 device_t dev = adapter->dev;
1552 if (adapter->res_interrupt != NULL) {
1553 bus_teardown_intr(dev, adapter->res_interrupt,
1554 adapter->int_handler_tag);
1555 bus_release_resource(dev, SYS_RES_IRQ, 0,
1556 adapter->res_interrupt);
1558 if (adapter->res_memory != NULL) {
1559 bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA,
1560 adapter->res_memory);
1563 if (adapter->res_ioport != NULL) {
1564 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid,
1565 adapter->res_ioport);
1570 /*********************************************************************
1572 * Initialize the hardware to a configuration as specified by the
1573 * adapter structure. The controller is reset, the EEPROM is
1574 * verified, the MAC address is set, then the shared initialization
1575 * routines are called.
1577 **********************************************************************/
1579 em_hardware_init(struct adapter * adapter)
1581 /* Issue a global reset */
1582 em_reset_hw(&adapter->hw);
1584 /* When hardware is reset, fifo_head is also reset */
1585 adapter->tx_fifo_head = 0;
1587 /* Make sure we have a good EEPROM before we read from it */
1588 if (em_validate_eeprom_checksum(&adapter->hw) < 0) {
1589 printf("em%d: The EEPROM Checksum Is Not Valid\n",
1594 if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) {
1595 printf("em%d: EEPROM read error while reading part number\n",
1600 if (em_init_hw(&adapter->hw) < 0) {
1601 printf("em%d: Hardware Initialization Failed",
1606 em_check_for_link(&adapter->hw);
1607 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)
1608 adapter->link_active = 1;
1610 adapter->link_active = 0;
1612 if (adapter->link_active) {
1613 em_get_speed_and_duplex(&adapter->hw,
1614 &adapter->link_speed,
1615 &adapter->link_duplex);
1617 adapter->link_speed = 0;
1618 adapter->link_duplex = 0;
1624 /*********************************************************************
1626 * Setup networking device structure and register an interface.
1628 **********************************************************************/
1630 em_setup_interface(device_t dev, struct adapter * adapter)
1633 INIT_DEBUGOUT("em_setup_interface: begin");
1635 ifp = &adapter->interface_data.ac_if;
1636 ifp->if_unit = adapter->unit;
1637 ifp->if_name = "em";
1638 ifp->if_mtu = ETHERMTU;
1639 ifp->if_output = ether_output;
1640 ifp->if_baudrate = 1000000000;
1641 ifp->if_init = em_init;
1642 ifp->if_softc = adapter;
1643 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1644 ifp->if_ioctl = em_ioctl;
1645 ifp->if_start = em_start;
1646 ifp->if_watchdog = em_watchdog;
1647 ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1;
1649 #if __FreeBSD_version < 500000
1650 ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
1652 ether_ifattach(ifp, adapter->interface_data.ac_enaddr);
1655 if (adapter->hw.mac_type >= em_82543) {
1656 ifp->if_capabilities = IFCAP_HWCSUM;
1657 ifp->if_capenable = ifp->if_capabilities;
1661 * Tell the upper layer(s) we support long frames.
1663 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
1664 #if __FreeBSD_version >= 500000
1665 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
1670 * Specify the media types supported by this adapter and register
1671 * callbacks to update media and link information
1673 ifmedia_init(&adapter->media, IFM_IMASK, em_media_change,
1675 if (adapter->hw.media_type == em_media_type_fiber) {
1676 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX,
1678 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX,
1681 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL);
1682 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX,
1684 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX,
1686 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX,
1688 #if __FreeBSD_version < 500000
1689 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX,
1691 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL);
1693 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX,
1695 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL);
1698 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
1699 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO);
1705 /*********************************************************************
1707 * Workaround for SmartSpeed on 82541 and 82547 controllers
1709 **********************************************************************/
1711 em_smartspeed(struct adapter *adapter)
1715 if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) ||
1716 !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
1719 if(adapter->smartspeed == 0) {
1720 /* If Master/Slave config fault is asserted twice,
1721 * we assume back-to-back */
1722 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
1723 if(!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) return;
1724 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
1725 if(phy_tmp & SR_1000T_MS_CONFIG_FAULT) {
1726 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL,
1728 if(phy_tmp & CR_1000T_MS_ENABLE) {
1729 phy_tmp &= ~CR_1000T_MS_ENABLE;
1730 em_write_phy_reg(&adapter->hw,
1731 PHY_1000T_CTRL, phy_tmp);
1732 adapter->smartspeed++;
1733 if(adapter->hw.autoneg &&
1734 !em_phy_setup_autoneg(&adapter->hw) &&
1735 !em_read_phy_reg(&adapter->hw, PHY_CTRL,
1737 phy_tmp |= (MII_CR_AUTO_NEG_EN |
1738 MII_CR_RESTART_AUTO_NEG);
1739 em_write_phy_reg(&adapter->hw,
1745 } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) {
1746 /* If still no link, perhaps using 2/3 pair cable */
1747 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp);
1748 phy_tmp |= CR_1000T_MS_ENABLE;
1749 em_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp);
1750 if(adapter->hw.autoneg &&
1751 !em_phy_setup_autoneg(&adapter->hw) &&
1752 !em_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_tmp)) {
1753 phy_tmp |= (MII_CR_AUTO_NEG_EN |
1754 MII_CR_RESTART_AUTO_NEG);
1755 em_write_phy_reg(&adapter->hw, PHY_CTRL, phy_tmp);
1758 /* Restart process after EM_SMARTSPEED_MAX iterations */
1759 if(adapter->smartspeed++ == EM_SMARTSPEED_MAX)
1760 adapter->smartspeed = 0;
1766 /*********************************************************************
1768 * Allocate memory for tx_buffer structures. The tx_buffer stores all
1769 * the information needed to transmit a packet on the wire.
1771 **********************************************************************/
1773 em_allocate_transmit_structures(struct adapter * adapter)
1775 if (!(adapter->tx_buffer_area =
1776 (struct em_buffer *) malloc(sizeof(struct em_buffer) *
1777 adapter->num_tx_desc, M_DEVBUF,
1779 printf("em%d: Unable to allocate tx_buffer memory\n",
1784 bzero(adapter->tx_buffer_area,
1785 sizeof(struct em_buffer) * adapter->num_tx_desc);
1790 /*********************************************************************
1792 * Allocate and initialize transmit structures.
1794 **********************************************************************/
1796 em_setup_transmit_structures(struct adapter * adapter)
1798 if (em_allocate_transmit_structures(adapter))
1801 bzero((void *) adapter->tx_desc_base,
1802 (sizeof(struct em_tx_desc)) * adapter->num_tx_desc);
1804 adapter->next_avail_tx_desc = 0;
1805 adapter->oldest_used_tx_desc = 0;
1807 /* Set number of descriptors available */
1808 adapter->num_tx_desc_avail = adapter->num_tx_desc;
1810 /* Set checksum context */
1811 adapter->active_checksum_context = OFFLOAD_NONE;
1816 /*********************************************************************
1818 * Enable transmit unit.
1820 **********************************************************************/
1822 em_initialize_transmit_unit(struct adapter * adapter)
1825 u_int32_t reg_tipg = 0;
1826 u_int64_t tdba = vtophys((vm_offset_t)adapter->tx_desc_base);
1828 /* Setup the Base and Length of the Tx Descriptor Ring */
1829 E1000_WRITE_REG(&adapter->hw, TDBAL,
1830 (tdba & 0x00000000ffffffffULL));
1831 E1000_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32));
1832 E1000_WRITE_REG(&adapter->hw, TDLEN,
1833 adapter->num_tx_desc *
1834 sizeof(struct em_tx_desc));
1836 /* Setup the HW Tx Head and Tail descriptor pointers */
1837 E1000_WRITE_REG(&adapter->hw, TDH, 0);
1838 E1000_WRITE_REG(&adapter->hw, TDT, 0);
1841 HW_DEBUGOUT2("Base = %x, Length = %x\n",
1842 E1000_READ_REG(&adapter->hw, TDBAL),
1843 E1000_READ_REG(&adapter->hw, TDLEN));
1846 /* Set the default values for the Tx Inter Packet Gap timer */
1847 switch (adapter->hw.mac_type) {
1848 case em_82542_rev2_0:
1849 case em_82542_rev2_1:
1850 reg_tipg = DEFAULT_82542_TIPG_IPGT;
1851 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
1852 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
1855 if (adapter->hw.media_type == em_media_type_fiber)
1856 reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
1858 reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
1859 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
1860 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
1863 E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg);
1864 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay);
1865 if(adapter->hw.mac_type >= em_82540)
1866 E1000_WRITE_REG(&adapter->hw, TADV, adapter->tx_abs_int_delay);
1868 /* Program the Transmit Control Register */
1869 reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN |
1870 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
1871 if (adapter->link_duplex == 1) {
1872 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
1874 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
1876 E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl);
1878 /* Setup Transmit Descriptor Settings for this adapter */
1879 adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS;
1881 if (adapter->tx_int_delay > 0)
1882 adapter->txd_cmd |= E1000_TXD_CMD_IDE;
1887 /*********************************************************************
1889 * Free all transmit related data structures.
1891 **********************************************************************/
1893 em_free_transmit_structures(struct adapter * adapter)
1895 struct em_buffer *tx_buffer;
1898 INIT_DEBUGOUT("free_transmit_structures: begin");
1900 if (adapter->tx_buffer_area != NULL) {
1901 tx_buffer = adapter->tx_buffer_area;
1902 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
1903 if (tx_buffer->m_head != NULL)
1904 m_freem(tx_buffer->m_head);
1905 tx_buffer->m_head = NULL;
1908 if (adapter->tx_buffer_area != NULL) {
1909 free(adapter->tx_buffer_area, M_DEVBUF);
1910 adapter->tx_buffer_area = NULL;
1915 /*********************************************************************
1917 * The offload context needs to be set when we transfer the first
1918 * packet of a particular protocol (TCP/UDP). We change the
1919 * context only if the protocol type changes.
1921 **********************************************************************/
1923 em_transmit_checksum_setup(struct adapter * adapter,
1925 u_int32_t *txd_upper,
1926 u_int32_t *txd_lower)
1928 struct em_context_desc *TXD;
1929 struct em_buffer *tx_buffer;
1932 if (mp->m_pkthdr.csum_flags) {
1934 if (mp->m_pkthdr.csum_flags & CSUM_TCP) {
1935 *txd_upper = E1000_TXD_POPTS_TXSM << 8;
1936 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
1937 if (adapter->active_checksum_context == OFFLOAD_TCP_IP)
1940 adapter->active_checksum_context = OFFLOAD_TCP_IP;
1942 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) {
1943 *txd_upper = E1000_TXD_POPTS_TXSM << 8;
1944 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
1945 if (adapter->active_checksum_context == OFFLOAD_UDP_IP)
1948 adapter->active_checksum_context = OFFLOAD_UDP_IP;
1960 /* If we reach this point, the checksum offload context
1961 * needs to be reset.
1963 curr_txd = adapter->next_avail_tx_desc;
1964 tx_buffer = &adapter->tx_buffer_area[curr_txd];
1965 TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd];
1967 TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN;
1968 TXD->lower_setup.ip_fields.ipcso =
1969 ETHER_HDR_LEN + offsetof(struct ip, ip_sum);
1970 TXD->lower_setup.ip_fields.ipcse =
1971 ETHER_HDR_LEN + sizeof(struct ip) - 1;
1973 TXD->upper_setup.tcp_fields.tucss =
1974 ETHER_HDR_LEN + sizeof(struct ip);
1975 TXD->upper_setup.tcp_fields.tucse = 0;
1977 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) {
1978 TXD->upper_setup.tcp_fields.tucso =
1979 ETHER_HDR_LEN + sizeof(struct ip) +
1980 offsetof(struct tcphdr, th_sum);
1981 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) {
1982 TXD->upper_setup.tcp_fields.tucso =
1983 ETHER_HDR_LEN + sizeof(struct ip) +
1984 offsetof(struct udphdr, uh_sum);
1987 TXD->tcp_seg_setup.data = 0;
1988 TXD->cmd_and_length = (adapter->txd_cmd | E1000_TXD_CMD_DEXT);
1990 tx_buffer->m_head = NULL;
1992 if (++curr_txd == adapter->num_tx_desc)
1995 adapter->num_tx_desc_avail--;
1996 adapter->next_avail_tx_desc = curr_txd;
2001 /**********************************************************************
2003 * Examine each tx_buffer in the used queue. If the hardware is done
2004 * processing the packet then free associated resources. The
2005 * tx_buffer is put back on the free queue.
2007 **********************************************************************/
2009 em_clean_transmit_interrupts(struct adapter * adapter)
2013 struct em_buffer *tx_buffer;
2014 struct em_tx_desc *tx_desc;
2015 struct ifnet *ifp = &adapter->interface_data.ac_if;
2017 if (adapter->num_tx_desc_avail == adapter->num_tx_desc)
2022 adapter->clean_tx_interrupts++;
2024 num_avail = adapter->num_tx_desc_avail;
2025 i = adapter->oldest_used_tx_desc;
2027 tx_buffer = &adapter->tx_buffer_area[i];
2028 tx_desc = &adapter->tx_desc_base[i];
2030 while(tx_desc->upper.fields.status & E1000_TXD_STAT_DD) {
2032 tx_desc->upper.data = 0;
2035 if (tx_buffer->m_head) {
2037 m_freem(tx_buffer->m_head);
2038 tx_buffer->m_head = NULL;
2041 if (++i == adapter->num_tx_desc)
2044 tx_buffer = &adapter->tx_buffer_area[i];
2045 tx_desc = &adapter->tx_desc_base[i];
2048 adapter->oldest_used_tx_desc = i;
2051 * If we have enough room, clear IFF_OACTIVE to tell the stack
2052 * that it is OK to send packets.
2053 * If there are no pending descriptors, clear the timeout. Otherwise,
2054 * if some descriptors have been freed, restart the timeout.
2056 if (num_avail > EM_TX_CLEANUP_THRESHOLD) {
2057 ifp->if_flags &= ~IFF_OACTIVE;
2058 if (num_avail == adapter->num_tx_desc)
2060 else if (num_avail == adapter->num_tx_desc_avail)
2061 ifp->if_timer = EM_TX_TIMEOUT;
2063 adapter->num_tx_desc_avail = num_avail;
2068 /*********************************************************************
2070 * Get a buffer from system mbuf buffer pool.
2072 **********************************************************************/
2074 em_get_buf(int i, struct adapter *adapter,
2077 register struct mbuf *mp = nmp;
2080 ifp = &adapter->interface_data.ac_if;
2083 MGETHDR(mp, M_DONTWAIT, MT_DATA);
2085 adapter->mbuf_alloc_failed++;
2088 MCLGET(mp, M_DONTWAIT);
2089 if ((mp->m_flags & M_EXT) == 0) {
2091 adapter->mbuf_cluster_failed++;
2094 mp->m_len = mp->m_pkthdr.len = MCLBYTES;
2096 mp->m_len = mp->m_pkthdr.len = MCLBYTES;
2097 mp->m_data = mp->m_ext.ext_buf;
2101 if (ifp->if_mtu <= ETHERMTU) {
2102 m_adj(mp, ETHER_ALIGN);
2105 adapter->rx_buffer_area[i].m_head = mp;
2106 adapter->rx_desc_base[i].buffer_addr =
2107 vtophys(mtod(mp, vm_offset_t));
2112 /*********************************************************************
2114 * Allocate memory for rx_buffer structures. Since we use one
2115 * rx_buffer per received packet, the maximum number of rx_buffer's
2116 * that we'll need is equal to the number of receive descriptors
2117 * that we've allocated.
2119 **********************************************************************/
2121 em_allocate_receive_structures(struct adapter * adapter)
2125 if (!(adapter->rx_buffer_area =
2126 (struct em_buffer *) malloc(sizeof(struct em_buffer) *
2127 adapter->num_rx_desc, M_DEVBUF,
2129 printf("em%d: Unable to allocate rx_buffer memory\n",
2134 bzero(adapter->rx_buffer_area,
2135 sizeof(struct em_buffer) * adapter->num_rx_desc);
2137 for (i = 0; i < adapter->num_rx_desc; i++) {
2138 if (em_get_buf(i, adapter, NULL) == ENOBUFS) {
2139 adapter->rx_buffer_area[i].m_head = NULL;
2140 adapter->rx_desc_base[i].buffer_addr = 0;
2148 /*********************************************************************
2150 * Allocate and initialize receive structures.
2152 **********************************************************************/
2154 em_setup_receive_structures(struct adapter * adapter)
2156 bzero((void *) adapter->rx_desc_base,
2157 (sizeof(struct em_rx_desc)) * adapter->num_rx_desc);
2159 if (em_allocate_receive_structures(adapter))
2162 /* Setup our descriptor pointers */
2163 adapter->next_rx_desc_to_check = 0;
2167 /*********************************************************************
2169 * Enable receive unit.
2171 **********************************************************************/
2173 em_initialize_receive_unit(struct adapter * adapter)
2176 u_int32_t reg_rxcsum;
2178 u_int64_t rdba = vtophys((vm_offset_t)adapter->rx_desc_base);
2180 ifp = &adapter->interface_data.ac_if;
2182 /* Make sure receives are disabled while setting up the descriptor ring */
2183 E1000_WRITE_REG(&adapter->hw, RCTL, 0);
2185 /* Set the Receive Delay Timer Register */
2186 E1000_WRITE_REG(&adapter->hw, RDTR,
2187 adapter->rx_int_delay | E1000_RDT_FPDB);
2189 if(adapter->hw.mac_type >= em_82540) {
2190 E1000_WRITE_REG(&adapter->hw, RADV, adapter->rx_abs_int_delay);
2192 /* Set the interrupt throttling rate. Value is calculated
2193 * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */
2194 #define MAX_INTS_PER_SEC 8000
2195 #define DEFAULT_ITR 1000000000/(MAX_INTS_PER_SEC * 256)
2196 E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR);
2199 /* Setup the Base and Length of the Rx Descriptor Ring */
2200 E1000_WRITE_REG(&adapter->hw, RDBAL,
2201 (rdba & 0x00000000ffffffffULL));
2202 E1000_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32));
2203 E1000_WRITE_REG(&adapter->hw, RDLEN,
2204 adapter->num_rx_desc *
2205 sizeof(struct em_rx_desc));
2207 /* Setup the HW Rx Head and Tail Descriptor Pointers */
2208 E1000_WRITE_REG(&adapter->hw, RDH, 0);
2209 E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1);
2211 /* Setup the Receive Control Register */
2212 reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
2213 E1000_RCTL_RDMTS_HALF |
2214 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);
2216 if (adapter->hw.tbi_compatibility_on == TRUE)
2217 reg_rctl |= E1000_RCTL_SBP;
2220 switch (adapter->rx_buffer_len) {
2222 case EM_RXBUFFER_2048:
2223 reg_rctl |= E1000_RCTL_SZ_2048;
2225 case EM_RXBUFFER_4096:
2226 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
2228 case EM_RXBUFFER_8192:
2229 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
2231 case EM_RXBUFFER_16384:
2232 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
2236 if (ifp->if_mtu > ETHERMTU)
2237 reg_rctl |= E1000_RCTL_LPE;
2239 /* Enable 82543 Receive Checksum Offload for TCP and UDP */
2240 if ((adapter->hw.mac_type >= em_82543) &&
2241 (ifp->if_capenable & IFCAP_RXCSUM)) {
2242 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
2243 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL);
2244 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum);
2247 /* Enable Receives */
2248 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
2253 /*********************************************************************
2255 * Free receive related data structures.
2257 **********************************************************************/
2259 em_free_receive_structures(struct adapter *adapter)
2261 struct em_buffer *rx_buffer;
2264 INIT_DEBUGOUT("free_receive_structures: begin");
2266 if (adapter->rx_buffer_area != NULL) {
2267 rx_buffer = adapter->rx_buffer_area;
2268 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
2269 if (rx_buffer->m_head != NULL)
2270 m_freem(rx_buffer->m_head);
2271 rx_buffer->m_head = NULL;
2274 if (adapter->rx_buffer_area != NULL) {
2275 free(adapter->rx_buffer_area, M_DEVBUF);
2276 adapter->rx_buffer_area = NULL;
2281 /*********************************************************************
2283 * This routine executes in interrupt context. It replenishes
2284 * the mbufs in the descriptor and sends data which has been
2285 * dma'ed into host memory to upper layer.
2287 * We loop at most count times if count is > 0, or until done if
2290 *********************************************************************/
2292 em_process_receive_interrupts(struct adapter * adapter, int count)
2296 #if __FreeBSD_version < 500000
2297 struct ether_header *eh;
2299 u_int8_t accept_frame = 0;
2304 /* Pointer to the receive descriptor being examined. */
2305 struct em_rx_desc *current_desc;
2307 ifp = &adapter->interface_data.ac_if;
2308 i = adapter->next_rx_desc_to_check;
2309 current_desc = &adapter->rx_desc_base[i];
2311 if (!((current_desc->status) & E1000_RXD_STAT_DD)) {
2313 adapter->no_pkts_avail++;
2318 while ((current_desc->status & E1000_RXD_STAT_DD) && (count != 0)) {
2320 mp = adapter->rx_buffer_area[i].m_head;
2323 if (current_desc->status & E1000_RXD_STAT_EOP) {
2326 len = current_desc->length - ETHER_CRC_LEN;
2329 len = current_desc->length;
2332 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
2334 u_int32_t pkt_len = current_desc->length;
2336 if (adapter->fmp != NULL)
2337 pkt_len += adapter->fmp->m_pkthdr.len;
2339 last_byte = *(mtod(mp, caddr_t) +
2340 current_desc->length - 1);
2342 if (TBI_ACCEPT(&adapter->hw, current_desc->status,
2343 current_desc->errors,
2344 pkt_len, last_byte)) {
2345 em_tbi_adjust_stats(&adapter->hw,
2348 adapter->hw.mac_addr);
2358 if (em_get_buf(i, adapter, NULL) == ENOBUFS) {
2359 adapter->dropped_pkts++;
2360 em_get_buf(i, adapter, mp);
2361 if (adapter->fmp != NULL)
2362 m_freem(adapter->fmp);
2363 adapter->fmp = NULL;
2364 adapter->lmp = NULL;
2368 /* Assign correct length to the current fragment */
2371 if (adapter->fmp == NULL) {
2372 mp->m_pkthdr.len = len;
2373 adapter->fmp = mp; /* Store the first mbuf */
2376 /* Chain mbuf's together */
2377 mp->m_flags &= ~M_PKTHDR;
2378 adapter->lmp->m_next = mp;
2379 adapter->lmp = adapter->lmp->m_next;
2380 adapter->fmp->m_pkthdr.len += len;
2384 adapter->fmp->m_pkthdr.rcvif = ifp;
2387 #if __FreeBSD_version < 500000
2388 eh = mtod(adapter->fmp, struct ether_header *);
2389 /* Remove ethernet header from mbuf */
2390 m_adj(adapter->fmp, sizeof(struct ether_header));
2391 em_receive_checksum(adapter, current_desc,
2393 if (current_desc->status & E1000_RXD_STAT_VP)
2394 VLAN_INPUT_TAG(eh, adapter->fmp,
2395 (current_desc->special &
2396 E1000_RXD_SPC_VLAN_MASK));
2398 ether_input(ifp, eh, adapter->fmp);
2401 em_receive_checksum(adapter, current_desc,
2403 if (current_desc->status & E1000_RXD_STAT_VP)
2404 VLAN_INPUT_TAG(ifp, adapter->fmp,
2405 (current_desc->special &
2406 E1000_RXD_SPC_VLAN_MASK),
2407 adapter->fmp = NULL);
2409 if (adapter->fmp != NULL)
2410 (*ifp->if_input)(ifp, adapter->fmp);
2412 adapter->fmp = NULL;
2413 adapter->lmp = NULL;
2416 adapter->dropped_pkts++;
2417 em_get_buf(i, adapter, mp);
2418 if (adapter->fmp != NULL)
2419 m_freem(adapter->fmp);
2420 adapter->fmp = NULL;
2421 adapter->lmp = NULL;
2424 /* Zero out the receive descriptors status */
2425 current_desc->status = 0;
2427 /* Advance the E1000's Receive Queue #0 "Tail Pointer". */
2428 E1000_WRITE_REG(&adapter->hw, RDT, i);
2430 /* Advance our pointers to the next descriptor */
2431 if (++i == adapter->num_rx_desc) {
2433 current_desc = adapter->rx_desc_base;
2437 adapter->next_rx_desc_to_check = i;
2441 /*********************************************************************
2443 * Verify that the hardware indicated that the checksum is valid.
2444 * Inform the stack about the status of checksum so that stack
2445 * doesn't spend time verifying the checksum.
2447 *********************************************************************/
2449 em_receive_checksum(struct adapter *adapter,
2450 struct em_rx_desc *rx_desc,
2453 /* 82543 or newer only */
2454 if ((adapter->hw.mac_type < em_82543) ||
2455 /* Ignore Checksum bit is set */
2456 (rx_desc->status & E1000_RXD_STAT_IXSM)) {
2457 mp->m_pkthdr.csum_flags = 0;
2461 if (rx_desc->status & E1000_RXD_STAT_IPCS) {
2463 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) {
2464 /* IP Checksum Good */
2465 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
2466 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID;
2469 mp->m_pkthdr.csum_flags = 0;
2473 if (rx_desc->status & E1000_RXD_STAT_TCPCS) {
2475 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) {
2476 mp->m_pkthdr.csum_flags |=
2477 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
2478 mp->m_pkthdr.csum_data = htons(0xffff);
2487 em_enable_vlans(struct adapter *adapter)
2491 E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN);
2493 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2494 ctrl |= E1000_CTRL_VME;
2495 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2501 em_enable_intr(struct adapter * adapter)
2503 E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK));
2508 em_disable_intr(struct adapter *adapter)
2510 E1000_WRITE_REG(&adapter->hw, IMC,
2511 (0xffffffff & ~E1000_IMC_RXSEQ));
2516 em_is_valid_ether_addr(u_int8_t *addr)
2518 char zero_addr[6] = { 0, 0, 0, 0, 0, 0 };
2520 if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) {
2528 em_write_pci_cfg(struct em_hw *hw,
2532 pci_write_config(((struct em_osdep *)hw->back)->dev, reg,
2537 em_read_pci_cfg(struct em_hw *hw, uint32_t reg,
2540 *value = pci_read_config(((struct em_osdep *)hw->back)->dev,
2546 em_pci_set_mwi(struct em_hw *hw)
2548 pci_write_config(((struct em_osdep *)hw->back)->dev,
2550 (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2);
2555 em_pci_clear_mwi(struct em_hw *hw)
2557 pci_write_config(((struct em_osdep *)hw->back)->dev,
2559 (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2);
2564 em_io_read(struct em_hw *hw, uint32_t port)
2570 em_io_write(struct em_hw *hw, uint32_t port, uint32_t value)
2577 /**********************************************************************
2579 * Update the board statistics counters.
2581 **********************************************************************/
2583 em_update_stats_counters(struct adapter *adapter)
2587 adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS);
2588 adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS);
2589 adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC);
2590 adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC);
2591 adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL);
2593 adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC);
2594 adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL);
2595 adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC);
2596 adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC);
2597 adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC);
2598 adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC);
2599 adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC);
2600 adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC);
2601 adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC);
2602 adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC);
2603 adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC);
2604 adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64);
2605 adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127);
2606 adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255);
2607 adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511);
2608 adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023);
2609 adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522);
2610 adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC);
2611 adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC);
2612 adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC);
2613 adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC);
2615 /* For the 64-bit byte counters the low dword must be read first. */
2616 /* Both registers clear on the read of the high dword */
2618 adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL);
2619 adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH);
2620 adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL);
2621 adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH);
2623 adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC);
2624 adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC);
2625 adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC);
2626 adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC);
2627 adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC);
2629 adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL);
2630 adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH);
2631 adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL);
2632 adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH);
2634 adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR);
2635 adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT);
2636 adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64);
2637 adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127);
2638 adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255);
2639 adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511);
2640 adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023);
2641 adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522);
2642 adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC);
2643 adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC);
2645 if (adapter->hw.mac_type >= em_82543) {
2646 adapter->stats.algnerrc +=
2647 E1000_READ_REG(&adapter->hw, ALGNERRC);
2648 adapter->stats.rxerrc +=
2649 E1000_READ_REG(&adapter->hw, RXERRC);
2650 adapter->stats.tncrs +=
2651 E1000_READ_REG(&adapter->hw, TNCRS);
2652 adapter->stats.cexterr +=
2653 E1000_READ_REG(&adapter->hw, CEXTERR);
2654 adapter->stats.tsctc +=
2655 E1000_READ_REG(&adapter->hw, TSCTC);
2656 adapter->stats.tsctfc +=
2657 E1000_READ_REG(&adapter->hw, TSCTFC);
2659 ifp = &adapter->interface_data.ac_if;
2661 /* Fill out the OS statistics structure */
2662 ifp->if_ibytes = adapter->stats.gorcl;
2663 ifp->if_obytes = adapter->stats.gotcl;
2664 ifp->if_imcasts = adapter->stats.mprc;
2665 ifp->if_collisions = adapter->stats.colc;
2669 adapter->dropped_pkts +
2670 adapter->stats.rxerrc +
2671 adapter->stats.crcerrs +
2672 adapter->stats.algnerrc +
2673 adapter->stats.rlec + adapter->stats.rnbc +
2674 adapter->stats.mpc + adapter->stats.cexterr;
2677 ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol;
2682 /**********************************************************************
2684 * This routine is called only when em_display_debug_stats is enabled.
2685 * This routine provides a way to take a look at important statistics
2686 * maintained by the driver and hardware.
2688 **********************************************************************/
2690 em_print_debug_info(struct adapter *adapter)
2692 int unit = adapter->unit;
2695 printf("em%d: Packets not Avail = %ld\n", unit,
2696 adapter->no_pkts_avail);
2697 printf("em%d: CleanTxInterrupts = %ld\n", unit,
2698 adapter->clean_tx_interrupts);
2700 printf("em%d: fifo workaround = %lld, fifo_reset = %lld\n", unit,
2701 (long long)adapter->tx_fifo_wrk,
2702 (long long)adapter->tx_fifo_reset);
2703 printf("em%d: hw tdh = %d, hw tdt = %d\n", unit,
2704 E1000_READ_REG(&adapter->hw, TDH),
2705 E1000_READ_REG(&adapter->hw, TDT));
2706 printf("em%d: Num Tx descriptors avail = %d\n", unit,
2707 adapter->num_tx_desc_avail);
2708 printf("em%d: Tx Descriptors not avail1 = %ld\n", unit,
2709 adapter->no_tx_desc_avail1);
2710 printf("em%d: Tx Descriptors not avail2 = %ld\n", unit,
2711 adapter->no_tx_desc_avail2);
2712 printf("em%d: Std mbuf failed = %ld\n", unit,
2713 adapter->mbuf_alloc_failed);
2714 printf("em%d: Std mbuf cluster failed = %ld\n", unit,
2715 adapter->mbuf_cluster_failed);
2716 printf("em%d: Driver dropped packets = %ld\n", unit,
2717 adapter->dropped_pkts);
2723 em_print_hw_stats(struct adapter *adapter)
2725 int unit = adapter->unit;
2727 printf("em%d: Excessive collisions = %lld\n", unit,
2728 (long long)adapter->stats.ecol);
2729 printf("em%d: Symbol errors = %lld\n", unit,
2730 (long long)adapter->stats.symerrs);
2731 printf("em%d: Sequence errors = %lld\n", unit,
2732 (long long)adapter->stats.sec);
2733 printf("em%d: Defer count = %lld\n", unit,
2734 (long long)adapter->stats.dc);
2736 printf("em%d: Missed Packets = %lld\n", unit,
2737 (long long)adapter->stats.mpc);
2738 printf("em%d: Receive No Buffers = %lld\n", unit,
2739 (long long)adapter->stats.rnbc);
2740 printf("em%d: Receive length errors = %lld\n", unit,
2741 (long long)adapter->stats.rlec);
2742 printf("em%d: Receive errors = %lld\n", unit,
2743 (long long)adapter->stats.rxerrc);
2744 printf("em%d: Crc errors = %lld\n", unit,
2745 (long long)adapter->stats.crcerrs);
2746 printf("em%d: Alignment errors = %lld\n", unit,
2747 (long long)adapter->stats.algnerrc);
2748 printf("em%d: Carrier extension errors = %lld\n", unit,
2749 (long long)adapter->stats.cexterr);
2751 printf("em%d: XON Rcvd = %lld\n", unit,
2752 (long long)adapter->stats.xonrxc);
2753 printf("em%d: XON Xmtd = %lld\n", unit,
2754 (long long)adapter->stats.xontxc);
2755 printf("em%d: XOFF Rcvd = %lld\n", unit,
2756 (long long)adapter->stats.xoffrxc);
2757 printf("em%d: XOFF Xmtd = %lld\n", unit,
2758 (long long)adapter->stats.xofftxc);
2760 printf("em%d: Good Packets Rcvd = %lld\n", unit,
2761 (long long)adapter->stats.gprc);
2762 printf("em%d: Good Packets Xmtd = %lld\n", unit,
2763 (long long)adapter->stats.gptc);
2769 em_sysctl_debug_info(SYSCTL_HANDLER_ARGS)
2773 struct adapter *adapter;
2776 error = sysctl_handle_int(oidp, &result, 0, req);
2778 if (error || !req->newptr)
2782 adapter = (struct adapter *)arg1;
2783 em_print_debug_info(adapter);
2791 em_sysctl_stats(SYSCTL_HANDLER_ARGS)
2795 struct adapter *adapter;
2798 error = sysctl_handle_int(oidp, &result, 0, req);
2800 if (error || !req->newptr)
2804 adapter = (struct adapter *)arg1;
2805 em_print_hw_stats(adapter);