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