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