FreeBSD/Linux Kernel Cross Reference
sys/dev/em/if_em.c
1 /**************************************************************************
2
3 Copyright (c) 2001-2002, Intel Corporation
4 All rights reserved.
5
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
8
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
11
12 2. Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in the
14 documentation and/or other materials provided with the distribution.
15
16 3. Neither the name of the Intel Corporation nor the names of its
17 contributors may be used to endorse or promote products derived from
18 this software without specific prior written permission.
19
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
31
32 ***************************************************************************/
33
34 /*$FreeBSD: releng/5.0/sys/dev/em/if_em.c 107243 2002-11-25 20:00:13Z luigi $*/
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.4.7";
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 static em_vendor_info_t em_vendor_info_array[] =
67 {
68 /* Intel(R) PRO/1000 Network Connection */
69 { 0x8086, 0x1000, PCI_ANY_ID, PCI_ANY_ID, 0},
70 { 0x8086, 0x1001, PCI_ANY_ID, PCI_ANY_ID, 0},
71 { 0x8086, 0x1004, PCI_ANY_ID, PCI_ANY_ID, 0},
72 { 0x8086, 0x1008, PCI_ANY_ID, PCI_ANY_ID, 0},
73 { 0x8086, 0x1009, PCI_ANY_ID, PCI_ANY_ID, 0},
74 { 0x8086, 0x100C, PCI_ANY_ID, PCI_ANY_ID, 0},
75 { 0x8086, 0x100D, PCI_ANY_ID, PCI_ANY_ID, 0},
76 { 0x8086, 0x100E, PCI_ANY_ID, PCI_ANY_ID, 0},
77 { 0x8086, 0x100F, PCI_ANY_ID, PCI_ANY_ID, 0},
78 { 0x8086, 0x1010, PCI_ANY_ID, PCI_ANY_ID, 0},
79 { 0x8086, 0x1011, PCI_ANY_ID, PCI_ANY_ID, 0},
80 { 0x8086, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0},
81 { 0x8086, 0x1015, PCI_ANY_ID, PCI_ANY_ID, 0},
82 { 0x8086, 0x1016, PCI_ANY_ID, PCI_ANY_ID, 0},
83 { 0x8086, 0x1017, PCI_ANY_ID, PCI_ANY_ID, 0},
84 { 0x8086, 0x101E, PCI_ANY_ID, PCI_ANY_ID, 0},
85 /* required last entry */
86 { 0, 0, 0, 0, 0}
87 };
88
89 /*********************************************************************
90 * Table of branding strings for all supported NICs.
91 *********************************************************************/
92
93 static char *em_strings[] = {
94 "Intel(R) PRO/1000 Network Connection"
95 };
96
97 /*********************************************************************
98 * Function prototypes
99 *********************************************************************/
100 static int em_probe(device_t);
101 static int em_attach(device_t);
102 static int em_detach(device_t);
103 static int em_shutdown(device_t);
104 static void em_intr(void *);
105 static void em_start(struct ifnet *);
106 static int em_ioctl(struct ifnet *, IOCTL_CMD_TYPE, caddr_t);
107 static void em_watchdog(struct ifnet *);
108 static void em_init(void *);
109 static void em_stop(void *);
110 static void em_media_status(struct ifnet *, struct ifmediareq *);
111 static int em_media_change(struct ifnet *);
112 static void em_identify_hardware(struct adapter *);
113 static int em_allocate_pci_resources(struct adapter *);
114 static void em_free_pci_resources(struct adapter *);
115 static void em_local_timer(void *);
116 static int em_hardware_init(struct adapter *);
117 static void em_setup_interface(device_t, struct adapter *);
118 static int em_setup_transmit_structures(struct adapter *);
119 static void em_initialize_transmit_unit(struct adapter *);
120 static int em_setup_receive_structures(struct adapter *);
121 static void em_initialize_receive_unit(struct adapter *);
122 static void em_enable_intr(struct adapter *);
123 static void em_disable_intr(struct adapter *);
124 static void em_free_transmit_structures(struct adapter *);
125 static void em_free_receive_structures(struct adapter *);
126 static void em_update_stats_counters(struct adapter *);
127 static void em_clean_transmit_interrupts(struct adapter *);
128 static int em_allocate_receive_structures(struct adapter *);
129 static int em_allocate_transmit_structures(struct adapter *);
130 static void em_process_receive_interrupts(struct adapter *, int);
131 static void em_receive_checksum(struct adapter *,
132 struct em_rx_desc * rx_desc,
133 struct mbuf *);
134 static void em_transmit_checksum_setup(struct adapter *,
135 struct mbuf *,
136 u_int32_t *,
137 u_int32_t *);
138 static void em_set_promisc(struct adapter *);
139 static void em_disable_promisc(struct adapter *);
140 static void em_set_multi(struct adapter *);
141 static void em_print_hw_stats(struct adapter *);
142 static void em_print_link_status(struct adapter *);
143 static int em_get_buf(struct em_rx_buffer *, struct adapter *,
144 struct mbuf *);
145 static void em_enable_vlans(struct adapter *adapter);
146 static int em_encap(struct adapter *adapter, struct mbuf *m_head);
147
148 /*********************************************************************
149 * FreeBSD Device Interface Entry Points
150 *********************************************************************/
151
152 static device_method_t em_methods[] = {
153 /* Device interface */
154 DEVMETHOD(device_probe, em_probe),
155 DEVMETHOD(device_attach, em_attach),
156 DEVMETHOD(device_detach, em_detach),
157 DEVMETHOD(device_shutdown, em_shutdown),
158 {0, 0}
159 };
160
161 static driver_t em_driver = {
162 "em", em_methods, sizeof(struct adapter ),
163 };
164
165 static devclass_t em_devclass;
166 DRIVER_MODULE(if_em, pci, em_driver, em_devclass, 0, 0);
167
168 /*********************************************************************
169 * Device identification routine
170 *
171 * em_probe determines if the driver should be loaded on
172 * adapter based on PCI vendor/device id of the adapter.
173 *
174 * return 0 on success, positive on failure
175 *********************************************************************/
176
177 static int
178 em_probe(device_t dev)
179 {
180 em_vendor_info_t *ent;
181
182 u_int16_t pci_vendor_id = 0;
183 u_int16_t pci_device_id = 0;
184 u_int16_t pci_subvendor_id = 0;
185 u_int16_t pci_subdevice_id = 0;
186 char adapter_name[60];
187
188 INIT_DEBUGOUT("em_probe: begin");
189
190 pci_vendor_id = pci_get_vendor(dev);
191 if (pci_vendor_id != EM_VENDOR_ID)
192 return(ENXIO);
193
194 pci_device_id = pci_get_device(dev);
195 pci_subvendor_id = pci_get_subvendor(dev);
196 pci_subdevice_id = pci_get_subdevice(dev);
197
198 ent = em_vendor_info_array;
199 while (ent->vendor_id != 0) {
200 if ((pci_vendor_id == ent->vendor_id) &&
201 (pci_device_id == ent->device_id) &&
202
203 ((pci_subvendor_id == ent->subvendor_id) ||
204 (ent->subvendor_id == PCI_ANY_ID)) &&
205
206 ((pci_subdevice_id == ent->subdevice_id) ||
207 (ent->subdevice_id == PCI_ANY_ID))) {
208 sprintf(adapter_name, "%s, Version - %s",
209 em_strings[ent->index],
210 em_driver_version);
211 device_set_desc_copy(dev, adapter_name);
212 return(0);
213 }
214 ent++;
215 }
216
217 return(ENXIO);
218 }
219
220 /*********************************************************************
221 * Device initialization routine
222 *
223 * The attach entry point is called when the driver is being loaded.
224 * This routine identifies the type of hardware, allocates all resources
225 * and initializes the hardware.
226 *
227 * return 0 on success, positive on failure
228 *********************************************************************/
229
230 static int
231 em_attach(device_t dev)
232 {
233 struct adapter * adapter;
234 int s;
235 int tsize, rsize;
236
237 INIT_DEBUGOUT("em_attach: begin");
238 s = splimp();
239
240 /* Allocate, clear, and link in our adapter structure */
241 if (!(adapter = device_get_softc(dev))) {
242 printf("em: adapter structure allocation failed\n");
243 splx(s);
244 return(ENOMEM);
245 }
246 bzero(adapter, sizeof(struct adapter ));
247 adapter->dev = dev;
248 adapter->osdep.dev = dev;
249 adapter->unit = device_get_unit(dev);
250
251 if (em_adapter_list != NULL)
252 em_adapter_list->prev = adapter;
253 adapter->next = em_adapter_list;
254 em_adapter_list = adapter;
255
256 callout_handle_init(&adapter->timer_handle);
257
258 /* Determine hardware revision */
259 em_identify_hardware(adapter);
260
261 /* Parameters (to be read from user) */
262 adapter->num_tx_desc = EM_MAX_TXD;
263 adapter->num_rx_desc = EM_MAX_RXD;
264 adapter->tx_int_delay = EM_TIDV;
265 adapter->rx_int_delay = EM_RDTR;
266 adapter->hw.autoneg = DO_AUTO_NEG;
267 adapter->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT;
268 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
269 adapter->hw.tbi_compatibility_en = TRUE;
270 adapter->rx_buffer_len = EM_RXBUFFER_2048;
271
272 adapter->hw.fc_high_water = FC_DEFAULT_HI_THRESH;
273 adapter->hw.fc_low_water = FC_DEFAULT_LO_THRESH;
274 adapter->hw.fc_pause_time = FC_DEFAULT_TX_TIMER;
275 adapter->hw.fc_send_xon = TRUE;
276 adapter->hw.fc = em_fc_full;
277
278 /* Set the max frame size assuming standard ethernet sized frames */
279 adapter->hw.max_frame_size =
280 ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN;
281
282 adapter->hw.min_frame_size =
283 MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN;
284
285 /* This controls when hardware reports transmit completion status. */
286 if ((EM_REPORT_TX_EARLY == 0) || (EM_REPORT_TX_EARLY == 1)) {
287 adapter->hw.report_tx_early = EM_REPORT_TX_EARLY;
288 } else {
289 if (adapter->hw.mac_type < em_82543) {
290 adapter->hw.report_tx_early = 0;
291 } else {
292 adapter->hw.report_tx_early = 1;
293 }
294 }
295
296 if (em_allocate_pci_resources(adapter)) {
297 printf("em%d: Allocation of PCI resources failed\n",
298 adapter->unit);
299 em_free_pci_resources(adapter);
300 splx(s);
301 return(ENXIO);
302 }
303
304 tsize = EM_ROUNDUP(adapter->num_tx_desc *
305 sizeof(struct em_tx_desc), 4096);
306
307 /* Allocate Transmit Descriptor ring */
308 if (!(adapter->tx_desc_base = (struct em_tx_desc *)
309 contigmalloc(tsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) {
310 printf("em%d: Unable to allocate TxDescriptor memory\n",
311 adapter->unit);
312 em_free_pci_resources(adapter);
313 splx(s);
314 return(ENOMEM);
315 }
316
317 rsize = EM_ROUNDUP(adapter->num_rx_desc *
318 sizeof(struct em_rx_desc), 4096);
319
320 /* Allocate Receive Descriptor ring */
321 if (!(adapter->rx_desc_base = (struct em_rx_desc *)
322 contigmalloc(rsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) {
323 printf("em%d: Unable to allocate rx_desc memory\n",
324 adapter->unit);
325 em_free_pci_resources(adapter);
326 contigfree(adapter->tx_desc_base, tsize, M_DEVBUF);
327 splx(s);
328 return(ENOMEM);
329 }
330
331 /* Initialize the hardware */
332 if (em_hardware_init(adapter)) {
333 printf("em%d: Unable to initialize the hardware\n",
334 adapter->unit);
335 em_free_pci_resources(adapter);
336 contigfree(adapter->tx_desc_base, tsize, M_DEVBUF);
337 contigfree(adapter->rx_desc_base, rsize, M_DEVBUF);
338 splx(s);
339 return(EIO);
340 }
341
342 /* Copy the permanent MAC address out of the EEPROM */
343 if (em_read_mac_addr(&adapter->hw) < 0) {
344 printf("em%d: EEPROM read error while reading mac address\n",
345 adapter->unit);
346 return(EIO);
347 }
348
349 memcpy(adapter->interface_data.ac_enaddr, adapter->hw.mac_addr,
350 ETH_LENGTH_OF_ADDRESS);
351
352 /* Setup OS specific network interface */
353 em_setup_interface(dev, adapter);
354
355 /* Initialize statistics */
356 em_clear_hw_cntrs(&adapter->hw);
357 em_update_stats_counters(adapter);
358 adapter->hw.get_link_status = 1;
359 em_check_for_link(&adapter->hw);
360
361 /* Print the link status */
362 if (adapter->link_active == 1) {
363 em_get_speed_and_duplex(&adapter->hw, &adapter->link_speed,
364 &adapter->link_duplex);
365 printf("em%d: Speed:%d Mbps Duplex:%s\n",
366 adapter->unit,
367 adapter->link_speed,
368 adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half");
369 } else
370 printf("em%d: Speed:N/A Duplex:N/A\n", adapter->unit);
371
372
373 INIT_DEBUGOUT("em_attach: end");
374 splx(s);
375 return(0);
376 }
377
378 /*********************************************************************
379 * Device removal routine
380 *
381 * The detach entry point is called when the driver is being removed.
382 * This routine stops the adapter and deallocates all the resources
383 * that were allocated for driver operation.
384 *
385 * return 0 on success, positive on failure
386 *********************************************************************/
387
388 static int
389 em_detach(device_t dev)
390 {
391 struct adapter * adapter = device_get_softc(dev);
392 struct ifnet *ifp = &adapter->interface_data.ac_if;
393 int s;
394 int size;
395
396 INIT_DEBUGOUT("em_detach: begin");
397 s = splimp();
398
399 em_stop(adapter);
400 em_phy_hw_reset(&adapter->hw);
401 ether_ifdetach(&adapter->interface_data.ac_if);
402 em_free_pci_resources(adapter);
403
404 size = EM_ROUNDUP(adapter->num_tx_desc *
405 sizeof(struct em_tx_desc), 4096);
406
407 /* Free Transmit Descriptor ring */
408 if (adapter->tx_desc_base) {
409 contigfree(adapter->tx_desc_base, size, M_DEVBUF);
410 adapter->tx_desc_base = NULL;
411 }
412
413 size = EM_ROUNDUP(adapter->num_rx_desc *
414 sizeof(struct em_rx_desc), 4096);
415
416 /* Free Receive Descriptor ring */
417 if (adapter->rx_desc_base) {
418 contigfree(adapter->rx_desc_base, size, M_DEVBUF);
419 adapter->rx_desc_base = NULL;
420 }
421
422 /* Remove from the adapter list */
423 if (em_adapter_list == adapter)
424 em_adapter_list = adapter->next;
425 if (adapter->next != NULL)
426 adapter->next->prev = adapter->prev;
427 if (adapter->prev != NULL)
428 adapter->prev->next = adapter->next;
429
430 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
431 ifp->if_timer = 0;
432
433 splx(s);
434 return(0);
435 }
436
437 /*********************************************************************
438 *
439 * Shutdown entry point
440 *
441 **********************************************************************/
442
443 static int
444 em_shutdown(device_t dev)
445 {
446 struct adapter *adapter = device_get_softc(dev);
447 em_stop(adapter);
448 return(0);
449 }
450
451 /*********************************************************************
452 * Transmit entry point
453 *
454 * em_start is called by the stack to initiate a transmit.
455 * The driver will remain in this routine as long as there are
456 * packets to transmit and transmit resources are available.
457 * In case resources are not available stack is notified and
458 * the packet is requeued.
459 **********************************************************************/
460
461 static void
462 em_start(struct ifnet *ifp)
463 {
464 int s;
465 struct mbuf *m_head;
466 struct adapter *adapter = ifp->if_softc;
467
468 if (!adapter->link_active)
469 return;
470
471 s = splimp();
472 while (ifp->if_snd.ifq_head != NULL) {
473
474 IF_DEQUEUE(&ifp->if_snd, m_head);
475
476 if (m_head == NULL) break;
477
478 if (em_encap(adapter, m_head)) {
479 ifp->if_flags |= IFF_OACTIVE;
480 IF_PREPEND(&ifp->if_snd, m_head);
481 break;
482 }
483
484 /* Send a copy of the frame to the BPF listener */
485 BPF_MTAP(ifp, m_head);
486
487 /* Set timeout in case hardware has problems transmitting */
488 ifp->if_timer = EM_TX_TIMEOUT;
489
490 }
491 splx(s);
492 return;
493 }
494
495 /*********************************************************************
496 * Ioctl entry point
497 *
498 * em_ioctl is called when the user wants to configure the
499 * interface.
500 *
501 * return 0 on success, positive on failure
502 **********************************************************************/
503
504 static int
505 em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data)
506 {
507 int s, mask, error = 0;
508 struct ifreq *ifr = (struct ifreq *) data;
509 struct adapter * adapter = ifp->if_softc;
510
511 s = splimp();
512 switch (command) {
513 case SIOCSIFADDR:
514 case SIOCGIFADDR:
515 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)");
516 ether_ioctl(ifp, command, data);
517 break;
518 case SIOCSIFMTU:
519 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)");
520 if (ifr->ifr_mtu > MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN) {
521 error = EINVAL;
522 } else {
523 ifp->if_mtu = ifr->ifr_mtu;
524 adapter->hw.max_frame_size =
525 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
526 em_init(adapter);
527 }
528 break;
529 case SIOCSIFFLAGS:
530 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)");
531 if (ifp->if_flags & IFF_UP) {
532 /*
533 * init adapter if not running, then take care
534 * of possible changes in IFF_ALLMULTI and IFF_PROMISC
535 */
536 if (!(ifp->if_flags & IFF_RUNNING))
537 em_init(adapter);
538 em_disable_promisc(adapter);
539 em_set_promisc(adapter);
540 } else {
541 if (ifp->if_flags & IFF_RUNNING) {
542 em_stop(adapter);
543 }
544 }
545 break;
546 case SIOCADDMULTI:
547 case SIOCDELMULTI:
548 IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI");
549 if (ifp->if_flags & IFF_RUNNING) {
550 em_disable_intr(adapter);
551 em_set_multi(adapter);
552 if (adapter->hw.mac_type == em_82542_rev2_0)
553 em_initialize_receive_unit(adapter);
554 em_enable_intr(adapter);
555 }
556 break;
557 case SIOCSIFMEDIA:
558 case SIOCGIFMEDIA:
559 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)");
560 error = ifmedia_ioctl(ifp, ifr, &adapter->media, command);
561 break;
562 case SIOCSIFCAP:
563 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)");
564 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
565 if (mask & IFCAP_HWCSUM) {
566 if (IFCAP_HWCSUM & ifp->if_capenable)
567 ifp->if_capenable &= ~IFCAP_HWCSUM;
568 else
569 ifp->if_capenable |= IFCAP_HWCSUM;
570 if (ifp->if_flags & IFF_RUNNING)
571 em_init(adapter);
572 }
573 break;
574 default:
575 IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%d)\n", (int)command);
576 error = EINVAL;
577 }
578
579 splx(s);
580 return(error);
581 }
582
583 /*********************************************************************
584 * Watchdog entry point
585 *
586 * This routine is called whenever hardware quits transmitting.
587 *
588 **********************************************************************/
589
590 static void
591 em_watchdog(struct ifnet *ifp)
592 {
593 struct adapter * adapter;
594 adapter = ifp->if_softc;
595
596 /* If we are in this routine because of pause frames, then
597 * don't reset the hardware.
598 */
599 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF) {
600 ifp->if_timer = EM_TX_TIMEOUT;
601 return;
602 }
603
604 printf("em%d: watchdog timeout -- resetting\n", adapter->unit);
605
606 ifp->if_flags &= ~IFF_RUNNING;
607
608 em_stop(adapter);
609 em_init(adapter);
610
611 ifp->if_oerrors++;
612 return;
613 }
614
615 /*********************************************************************
616 * Init entry point
617 *
618 * This routine is used in two ways. It is used by the stack as
619 * init entry point in network interface structure. It is also used
620 * by the driver as a hw/sw initialization routine to get to a
621 * consistent state.
622 *
623 * return 0 on success, positive on failure
624 **********************************************************************/
625
626 static void
627 em_init(void *arg)
628 {
629 int s;
630 struct ifnet *ifp;
631 struct adapter * adapter = arg;
632
633 INIT_DEBUGOUT("em_init: begin");
634
635 s = splimp();
636
637 em_stop(adapter);
638
639 /* Initialize the hardware */
640 if (em_hardware_init(adapter)) {
641 printf("em%d: Unable to initialize the hardware\n",
642 adapter->unit);
643 splx(s);
644 return;
645 }
646
647 em_enable_vlans(adapter);
648
649 /* Prepare transmit descriptors and buffers */
650 if (em_setup_transmit_structures(adapter)) {
651 printf("em%d: Could not setup transmit structures\n",
652 adapter->unit);
653 em_stop(adapter);
654 splx(s);
655 return;
656 }
657 em_initialize_transmit_unit(adapter);
658
659 /* Setup Multicast table */
660 em_set_multi(adapter);
661
662 /* Prepare receive descriptors and buffers */
663 if (em_setup_receive_structures(adapter)) {
664 printf("em%d: Could not setup receive structures\n",
665 adapter->unit);
666 em_stop(adapter);
667 splx(s);
668 return;
669 }
670 em_initialize_receive_unit(adapter);
671
672 ifp = &adapter->interface_data.ac_if;
673 ifp->if_flags |= IFF_RUNNING;
674 ifp->if_flags &= ~IFF_OACTIVE;
675
676 if (adapter->hw.mac_type >= em_82543) {
677 if (ifp->if_capenable & IFCAP_TXCSUM)
678 ifp->if_hwassist = EM_CHECKSUM_FEATURES;
679 else
680 ifp->if_hwassist = 0;
681 }
682
683 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz);
684 em_clear_hw_cntrs(&adapter->hw);
685 #ifdef DEVICE_POLLING
686 /*
687 * Only enable interrupts if we are not polling, make sure
688 * they are off otherwise.
689 */
690 if (ifp->if_ipending & IFF_POLLING)
691 em_disable_intr(adapter);
692 else
693 #endif /* DEVICE_POLLING */
694 em_enable_intr(adapter);
695
696 splx(s);
697 return;
698 }
699
700 #ifdef DEVICE_POLLING
701 static poll_handler_t em_poll;
702
703 static void
704 em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
705 {
706 struct adapter *adapter = ifp->if_softc;
707
708 if (cmd == POLL_DEREGISTER) { /* final call, enable interrupts */
709 em_enable_intr(adapter);
710 return;
711 }
712 if (cmd == POLL_AND_CHECK_STATUS) {
713 u_int32_t reg_icr = E1000_READ_REG(&adapter->hw, ICR);
714
715 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
716 untimeout(em_local_timer, adapter,
717 adapter->timer_handle);
718 adapter->hw.get_link_status = 1;
719 em_check_for_link(&adapter->hw);
720 em_print_link_status(adapter);
721 adapter->timer_handle = timeout(em_local_timer,
722 adapter, 2*hz);
723 }
724 }
725 if (ifp->if_flags & IFF_RUNNING) {
726 em_process_receive_interrupts(adapter, count);
727 em_clean_transmit_interrupts(adapter);
728 }
729 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL)
730 em_start(ifp);
731 }
732 #endif /* DEVICE_POLLING */
733
734 /*********************************************************************
735 *
736 * Interrupt Service routine
737 *
738 **********************************************************************/
739
740 static void
741 em_intr(void *arg)
742 {
743 u_int32_t loop_cnt = EM_MAX_INTR;
744 u_int32_t reg_icr;
745 struct ifnet *ifp;
746 struct adapter *adapter = arg;
747
748 ifp = &adapter->interface_data.ac_if;
749
750 #ifdef DEVICE_POLLING
751 if (ifp->if_ipending & IFF_POLLING)
752 return;
753
754 if (ether_poll_register(em_poll, ifp)) {
755 em_disable_intr(adapter);
756 em_poll(ifp, 0, 1);
757 return;
758 }
759 #endif /* DEVICE_POLLING */
760
761 em_disable_intr(adapter);
762 while (loop_cnt > 0 &&
763 (reg_icr = E1000_READ_REG(&adapter->hw, ICR)) != 0) {
764
765 /* Link status change */
766 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
767 untimeout(em_local_timer, adapter,
768 adapter->timer_handle);
769 adapter->hw.get_link_status = 1;
770 em_check_for_link(&adapter->hw);
771 em_print_link_status(adapter);
772 adapter->timer_handle =
773 timeout(em_local_timer, adapter, 2*hz);
774 }
775
776 if (ifp->if_flags & IFF_RUNNING) {
777 em_process_receive_interrupts(adapter, -1);
778 em_clean_transmit_interrupts(adapter);
779 }
780 loop_cnt--;
781 }
782
783 em_enable_intr(adapter);
784
785 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL)
786 em_start(ifp);
787
788 return;
789 }
790
791
792 /*********************************************************************
793 *
794 * Media Ioctl callback
795 *
796 * This routine is called whenever the user queries the status of
797 * the interface using ifconfig.
798 *
799 **********************************************************************/
800 static void
801 em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
802 {
803 struct adapter * adapter = ifp->if_softc;
804
805 INIT_DEBUGOUT("em_media_status: begin");
806
807 em_check_for_link(&adapter->hw);
808 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
809 if (adapter->link_active == 0) {
810 em_get_speed_and_duplex(&adapter->hw,
811 &adapter->link_speed,
812 &adapter->link_duplex);
813 adapter->link_active = 1;
814 }
815 } else {
816 if (adapter->link_active == 1) {
817 adapter->link_speed = 0;
818 adapter->link_duplex = 0;
819 adapter->link_active = 0;
820 }
821 }
822
823 ifmr->ifm_status = IFM_AVALID;
824 ifmr->ifm_active = IFM_ETHER;
825
826 if (!adapter->link_active)
827 return;
828
829 ifmr->ifm_status |= IFM_ACTIVE;
830
831 if (adapter->hw.media_type == em_media_type_fiber) {
832 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX;
833 } else {
834 switch (adapter->link_speed) {
835 case 10:
836 ifmr->ifm_active |= IFM_10_T;
837 break;
838 case 100:
839 ifmr->ifm_active |= IFM_100_TX;
840 break;
841 case 1000:
842 #if __FreeBSD_version < 500000
843 ifmr->ifm_active |= IFM_1000_TX;
844 #else
845 ifmr->ifm_active |= IFM_1000_T;
846 #endif
847 break;
848 }
849 if (adapter->link_duplex == FULL_DUPLEX)
850 ifmr->ifm_active |= IFM_FDX;
851 else
852 ifmr->ifm_active |= IFM_HDX;
853 }
854 return;
855 }
856
857 /*********************************************************************
858 *
859 * Media Ioctl callback
860 *
861 * This routine is called when the user changes speed/duplex using
862 * media/mediopt option with ifconfig.
863 *
864 **********************************************************************/
865 static int
866 em_media_change(struct ifnet *ifp)
867 {
868 struct adapter * adapter = ifp->if_softc;
869 struct ifmedia *ifm = &adapter->media;
870
871 INIT_DEBUGOUT("em_media_change: begin");
872
873 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
874 return(EINVAL);
875
876 switch (IFM_SUBTYPE(ifm->ifm_media)) {
877 case IFM_AUTO:
878 adapter->hw.autoneg = DO_AUTO_NEG;
879 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
880 break;
881 case IFM_1000_SX:
882 #if __FreeBSD_version < 500000
883 case IFM_1000_TX:
884 #else
885 case IFM_1000_T:
886 #endif
887 adapter->hw.autoneg = DO_AUTO_NEG;
888 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
889 break;
890 case IFM_100_TX:
891 adapter->hw.autoneg = FALSE;
892 adapter->hw.autoneg_advertised = 0;
893 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
894 adapter->hw.forced_speed_duplex = em_100_full;
895 else
896 adapter->hw.forced_speed_duplex = em_100_half;
897 break;
898 case IFM_10_T:
899 adapter->hw.autoneg = FALSE;
900 adapter->hw.autoneg_advertised = 0;
901 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
902 adapter->hw.forced_speed_duplex = em_10_full;
903 else
904 adapter->hw.forced_speed_duplex = em_10_half;
905 break;
906 default:
907 printf("em%d: Unsupported media type\n", adapter->unit);
908 }
909
910 em_init(adapter);
911
912 return(0);
913 }
914
915
916 /*********************************************************************
917 *
918 * This routine maps the mbufs to tx descriptors.
919 *
920 * return 0 on success, positive on failure
921 **********************************************************************/
922
923 static int
924 em_encap(struct adapter *adapter, struct mbuf *m_head)
925 {
926 vm_offset_t virtual_addr;
927 u_int32_t txd_upper;
928 u_int32_t txd_lower;
929 u_int16_t txd_used, count;
930
931 struct mbuf *mp;
932 struct em_tx_buffer *tx_buffer;
933 struct em_tx_desc *saved_tx_desc = NULL;
934 struct em_tx_desc *current_tx_desc = NULL;
935 struct ifnet *ifp = &adapter->interface_data.ac_if;
936 struct m_tag *mtag;
937
938 /* Force a cleanup if number of descriptors available hit the threshold */
939 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD)
940 em_clean_transmit_interrupts(adapter);
941
942 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
943 adapter->no_tx_desc_avail1++;
944 return (ENOBUFS);
945 }
946
947 /* Find out number of fragments in a mbuf chain */
948 count = 0;
949 for (mp = m_head; mp != NULL; mp = mp->m_next) {
950 if (mp->m_len == 0)
951 continue;
952 count++;
953 }
954
955 /* Bail out if we don't have enough descriptors */
956 if (adapter->num_tx_desc_avail <= count) {
957 em_clean_transmit_interrupts(adapter);
958 adapter->no_tx_desc_avail2++;
959 return (ENOBUFS);
960 }
961
962 tx_buffer = STAILQ_FIRST(&adapter->free_tx_buffer_list);
963 if (!tx_buffer) {
964 adapter->no_tx_buffer_avail1++;
965 return (ENOBUFS);
966 }
967
968 /* Setup checksum context */
969 if (ifp->if_hwassist > 0) {
970 em_transmit_checksum_setup(adapter, m_head,
971 &txd_upper, &txd_lower);
972 } else {
973 txd_upper = 0;
974 txd_lower = 0;
975 }
976
977 /* Find out if we are in vlan mode */
978 mtag = VLAN_OUTPUT_TAG(ifp, m_head);
979
980 txd_used = 0;
981 saved_tx_desc = adapter->next_avail_tx_desc;
982 for (mp = m_head; mp != NULL; mp = mp->m_next) {
983 if (mp->m_len == 0)
984 continue;
985
986 tx_buffer = STAILQ_FIRST(&adapter->free_tx_buffer_list);
987 if (!tx_buffer) {
988 adapter->no_tx_buffer_avail2++;
989 adapter->next_avail_tx_desc = saved_tx_desc;
990 return (ENOBUFS);
991 }
992
993 current_tx_desc = adapter->next_avail_tx_desc;
994 virtual_addr = mtod(mp, vm_offset_t);
995 current_tx_desc->buffer_addr = vtophys(virtual_addr);
996
997 current_tx_desc->lower.data = (adapter->txd_cmd | txd_lower | mp->m_len);
998 current_tx_desc->upper.data = (txd_upper);
999
1000 if (current_tx_desc == adapter->last_tx_desc)
1001 adapter->next_avail_tx_desc =
1002 adapter->first_tx_desc;
1003 else
1004 adapter->next_avail_tx_desc++;
1005
1006 txd_used++;
1007
1008 tx_buffer->m_head = NULL;
1009 tx_buffer->used_tx_desc = current_tx_desc;
1010 STAILQ_REMOVE_HEAD(&adapter->free_tx_buffer_list, em_tx_entry);
1011 STAILQ_INSERT_TAIL(&adapter->used_tx_buffer_list, tx_buffer,
1012 em_tx_entry);
1013 }
1014 adapter->num_tx_desc_avail-= txd_used;
1015
1016 if (mtag != NULL) {
1017 /* Tell hardware to add tag */
1018 current_tx_desc->lower.data |= E1000_TXD_CMD_VLE;
1019
1020 /* Set the vlan id */
1021 current_tx_desc->upper.fields.special = VLAN_TAG_VALUE(mtag);
1022 }
1023
1024 /* Last Descriptor of Packet needs End Of Packet (EOP) bit set. */
1025 current_tx_desc->lower.data |= E1000_TXD_CMD_EOP;
1026
1027 /* Save mbuf chain so that we can free it during transmit cleanup */
1028 tx_buffer->m_head = m_head;
1029
1030 /*
1031 * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000
1032 * that this frame is available to transmit.
1033 */
1034 E1000_WRITE_REG(&adapter->hw, TDT,
1035 (((uintptr_t) adapter->next_avail_tx_desc -
1036 (uintptr_t) adapter->first_tx_desc) >> 4));
1037
1038 return(0);
1039 }
1040
1041
1042 static void
1043 em_set_promisc(struct adapter * adapter)
1044 {
1045
1046 u_int32_t reg_rctl;
1047 struct ifnet *ifp = &adapter->interface_data.ac_if;
1048
1049 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1050
1051 if (ifp->if_flags & IFF_PROMISC) {
1052 reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
1053 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1054 } else if (ifp->if_flags & IFF_ALLMULTI) {
1055 reg_rctl |= E1000_RCTL_MPE;
1056 reg_rctl &= ~E1000_RCTL_UPE;
1057 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1058 }
1059
1060 return;
1061 }
1062
1063 static void
1064 em_disable_promisc(struct adapter * adapter)
1065 {
1066 u_int32_t reg_rctl;
1067
1068 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1069
1070 reg_rctl &= (~E1000_RCTL_UPE);
1071 reg_rctl &= (~E1000_RCTL_MPE);
1072 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1073
1074 return;
1075 }
1076
1077
1078 /*********************************************************************
1079 * Multicast Update
1080 *
1081 * This routine is called whenever multicast address list is updated.
1082 *
1083 **********************************************************************/
1084
1085 static void
1086 em_set_multi(struct adapter * adapter)
1087 {
1088 u_int32_t reg_rctl = 0;
1089 u_int8_t mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS];
1090 struct ifmultiaddr *ifma;
1091 int mcnt = 0;
1092 struct ifnet *ifp = &adapter->interface_data.ac_if;
1093
1094 IOCTL_DEBUGOUT("em_set_multi: begin");
1095
1096 if (adapter->hw.mac_type == em_82542_rev2_0) {
1097 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1098 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
1099 em_pci_clear_mwi(&adapter->hw);
1100 }
1101 reg_rctl |= E1000_RCTL_RST;
1102 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1103 msec_delay(5);
1104 }
1105
1106 #if __FreeBSD_version < 500000
1107 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1108 #else
1109 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1110 #endif
1111 if (ifma->ifma_addr->sa_family != AF_LINK)
1112 continue;
1113
1114 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
1115 &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS);
1116 mcnt++;
1117 }
1118
1119 if (mcnt > MAX_NUM_MULTICAST_ADDRESSES) {
1120 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1121 reg_rctl |= E1000_RCTL_MPE;
1122 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1123 } else
1124 em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0);
1125
1126 if (adapter->hw.mac_type == em_82542_rev2_0) {
1127 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1128 reg_rctl &= ~E1000_RCTL_RST;
1129 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1130 msec_delay(5);
1131 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
1132 em_pci_set_mwi(&adapter->hw);
1133 }
1134 }
1135
1136 return;
1137 }
1138
1139
1140 /*********************************************************************
1141 * Timer routine
1142 *
1143 * This routine checks for link status and updates statistics.
1144 *
1145 **********************************************************************/
1146
1147 static void
1148 em_local_timer(void *arg)
1149 {
1150 int s;
1151 struct ifnet *ifp;
1152 struct adapter * adapter = arg;
1153 ifp = &adapter->interface_data.ac_if;
1154
1155 s = splimp();
1156
1157 em_check_for_link(&adapter->hw);
1158 em_print_link_status(adapter);
1159 em_update_stats_counters(adapter);
1160 if (em_display_debug_stats && ifp->if_flags & IFF_RUNNING) {
1161 em_print_hw_stats(adapter);
1162 }
1163 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz);
1164
1165 splx(s);
1166 return;
1167 }
1168
1169 static void
1170 em_print_link_status(struct adapter * adapter)
1171 {
1172 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
1173 if (adapter->link_active == 0) {
1174 em_get_speed_and_duplex(&adapter->hw,
1175 &adapter->link_speed,
1176 &adapter->link_duplex);
1177 printf("em%d: Link is up %d Mbps %s\n",
1178 adapter->unit,
1179 adapter->link_speed,
1180 ((adapter->link_duplex == FULL_DUPLEX) ?
1181 "Full Duplex" : "Half Duplex"));
1182 adapter->link_active = 1;
1183 }
1184 } else {
1185 if (adapter->link_active == 1) {
1186 adapter->link_speed = 0;
1187 adapter->link_duplex = 0;
1188 printf("em%d: Link is Down\n", adapter->unit);
1189 adapter->link_active = 0;
1190 }
1191 }
1192
1193 return;
1194 }
1195
1196
1197 /*********************************************************************
1198 *
1199 * This routine disables all traffic on the adapter by issuing a
1200 * global reset on the MAC and deallocates TX/RX buffers.
1201 *
1202 **********************************************************************/
1203
1204 static void
1205 em_stop(void *arg)
1206 {
1207 struct ifnet *ifp;
1208 struct adapter * adapter = arg;
1209 ifp = &adapter->interface_data.ac_if;
1210
1211 INIT_DEBUGOUT("em_stop: begin\n");
1212 em_disable_intr(adapter);
1213 em_reset_hw(&adapter->hw);
1214 untimeout(em_local_timer, adapter, adapter->timer_handle);
1215 em_free_transmit_structures(adapter);
1216 em_free_receive_structures(adapter);
1217
1218
1219 /* Tell the stack that the interface is no longer active */
1220 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1221
1222 return;
1223 }
1224
1225
1226 /*********************************************************************
1227 *
1228 * Determine hardware revision.
1229 *
1230 **********************************************************************/
1231 static void
1232 em_identify_hardware(struct adapter * adapter)
1233 {
1234 device_t dev = adapter->dev;
1235
1236 /* Make sure our PCI config space has the necessary stuff set */
1237 adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
1238 if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) &&
1239 (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) {
1240 printf("em%d: Memory Access and/or Bus Master bits were not set!\n",
1241 adapter->unit);
1242 adapter->hw.pci_cmd_word |=
1243 (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN);
1244 pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2);
1245 }
1246
1247 /* Save off the information about this board */
1248 adapter->hw.vendor_id = pci_get_vendor(dev);
1249 adapter->hw.device_id = pci_get_device(dev);
1250 adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1);
1251 adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2);
1252 adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2);
1253
1254 /* Identify the MAC */
1255 if (em_set_mac_type(&adapter->hw))
1256 printf("em%d: Unknown MAC Type\n", adapter->unit);
1257
1258 return;
1259 }
1260
1261 static int
1262 em_allocate_pci_resources(struct adapter * adapter)
1263 {
1264 int i, val, rid;
1265 device_t dev = adapter->dev;
1266
1267 rid = EM_MMBA;
1268 adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY,
1269 &rid, 0, ~0, 1,
1270 RF_ACTIVE);
1271 if (!(adapter->res_memory)) {
1272 printf("em%d: Unable to allocate bus resource: memory\n",
1273 adapter->unit);
1274 return(ENXIO);
1275 }
1276 adapter->osdep.mem_bus_space_tag =
1277 rman_get_bustag(adapter->res_memory);
1278 adapter->osdep.mem_bus_space_handle =
1279 rman_get_bushandle(adapter->res_memory);
1280 adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle;
1281
1282
1283 if (adapter->hw.mac_type > em_82543) {
1284 /* Figure our where our IO BAR is ? */
1285 rid = EM_MMBA;
1286 for (i = 0; i < 5; i++) {
1287 val = pci_read_config(dev, rid, 4);
1288 if (val & 0x00000001) {
1289 adapter->io_rid = rid;
1290 break;
1291 }
1292 rid += 4;
1293 }
1294
1295 adapter->res_ioport = bus_alloc_resource(dev, SYS_RES_IOPORT,
1296 &adapter->io_rid, 0, ~0, 1,
1297 RF_ACTIVE);
1298 if (!(adapter->res_ioport)) {
1299 printf("em%d: Unable to allocate bus resource: ioport\n",
1300 adapter->unit);
1301 return(ENXIO);
1302 }
1303
1304 adapter->hw.io_base =
1305 rman_get_start(adapter->res_ioport);
1306 }
1307
1308 rid = 0x0;
1309 adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ,
1310 &rid, 0, ~0, 1,
1311 RF_SHAREABLE | RF_ACTIVE);
1312 if (!(adapter->res_interrupt)) {
1313 printf("em%d: Unable to allocate bus resource: interrupt\n",
1314 adapter->unit);
1315 return(ENXIO);
1316 }
1317 if (bus_setup_intr(dev, adapter->res_interrupt, INTR_TYPE_NET,
1318 (void (*)(void *)) em_intr, adapter,
1319 &adapter->int_handler_tag)) {
1320 printf("em%d: Error registering interrupt handler!\n",
1321 adapter->unit);
1322 return(ENXIO);
1323 }
1324
1325 adapter->hw.back = &adapter->osdep;
1326
1327 return(0);
1328 }
1329
1330 static void
1331 em_free_pci_resources(struct adapter * adapter)
1332 {
1333 device_t dev = adapter->dev;
1334
1335 if (adapter->res_interrupt != NULL) {
1336 bus_teardown_intr(dev, adapter->res_interrupt,
1337 adapter->int_handler_tag);
1338 bus_release_resource(dev, SYS_RES_IRQ, 0,
1339 adapter->res_interrupt);
1340 }
1341 if (adapter->res_memory != NULL) {
1342 bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA,
1343 adapter->res_memory);
1344 }
1345
1346 if (adapter->res_ioport != NULL) {
1347 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid,
1348 adapter->res_ioport);
1349 }
1350 return;
1351 }
1352
1353 /*********************************************************************
1354 *
1355 * Initialize the hardware to a configuration as specified by the
1356 * adapter structure. The controller is reset, the EEPROM is
1357 * verified, the MAC address is set, then the shared initialization
1358 * routines are called.
1359 *
1360 **********************************************************************/
1361 static int
1362 em_hardware_init(struct adapter * adapter)
1363 {
1364 /* Issue a global reset */
1365 em_reset_hw(&adapter->hw);
1366
1367 /* Make sure we have a good EEPROM before we read from it */
1368 if (em_validate_eeprom_checksum(&adapter->hw) < 0) {
1369 printf("em%d: The EEPROM Checksum Is Not Valid\n",
1370 adapter->unit);
1371 return(EIO);
1372 }
1373
1374 if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) {
1375 printf("em%d: EEPROM read error while reading part number\n",
1376 adapter->unit);
1377 return(EIO);
1378 }
1379
1380 if (em_init_hw(&adapter->hw) < 0) {
1381 printf("em%d: Hardware Initialization Failed",
1382 adapter->unit);
1383 return(EIO);
1384 }
1385
1386 em_check_for_link(&adapter->hw);
1387 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)
1388 adapter->link_active = 1;
1389 else
1390 adapter->link_active = 0;
1391
1392 if (adapter->link_active) {
1393 em_get_speed_and_duplex(&adapter->hw,
1394 &adapter->link_speed,
1395 &adapter->link_duplex);
1396 } else {
1397 adapter->link_speed = 0;
1398 adapter->link_duplex = 0;
1399 }
1400
1401 return(0);
1402 }
1403
1404 /*********************************************************************
1405 *
1406 * Setup networking device structure and register an interface.
1407 *
1408 **********************************************************************/
1409 static void
1410 em_setup_interface(device_t dev, struct adapter * adapter)
1411 {
1412 struct ifnet *ifp;
1413 INIT_DEBUGOUT("em_setup_interface: begin");
1414
1415 ifp = &adapter->interface_data.ac_if;
1416 ifp->if_unit = adapter->unit;
1417 ifp->if_name = "em";
1418 ifp->if_mtu = ETHERMTU;
1419 ifp->if_output = ether_output;
1420 ifp->if_baudrate = 1000000000;
1421 ifp->if_init = em_init;
1422 ifp->if_softc = adapter;
1423 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1424 ifp->if_ioctl = em_ioctl;
1425 ifp->if_start = em_start;
1426 ifp->if_watchdog = em_watchdog;
1427 ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1;
1428 ether_ifattach(ifp, adapter->interface_data.ac_enaddr);
1429
1430 if (adapter->hw.mac_type >= em_82543) {
1431 ifp->if_capabilities = IFCAP_HWCSUM;
1432 ifp->if_capenable = ifp->if_capabilities;
1433 }
1434 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
1435
1436 /*
1437 * Specify the media types supported by this adapter and register
1438 * callbacks to update media and link information
1439 */
1440 ifmedia_init(&adapter->media, IFM_IMASK, em_media_change,
1441 em_media_status);
1442 if (adapter->hw.media_type == em_media_type_fiber) {
1443 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX,
1444 0, NULL);
1445 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX,
1446 0, NULL);
1447 } else {
1448 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL);
1449 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX,
1450 0, NULL);
1451 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX,
1452 0, NULL);
1453 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX,
1454 0, NULL);
1455 #if __FreeBSD_version < 500000
1456 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX,
1457 0, NULL);
1458 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL);
1459 #else
1460 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX,
1461 0, NULL);
1462 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL);
1463 #endif
1464 }
1465 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
1466 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO);
1467
1468 return;
1469 }
1470
1471
1472 /*********************************************************************
1473 *
1474 * Allocate memory for tx_buffer structures. The tx_buffer stores all
1475 * the information needed to transmit a packet on the wire.
1476 *
1477 **********************************************************************/
1478 static int
1479 em_allocate_transmit_structures(struct adapter * adapter)
1480 {
1481 if (!(adapter->tx_buffer_area =
1482 (struct em_tx_buffer *) malloc(sizeof(struct em_tx_buffer) *
1483 adapter->num_tx_desc, M_DEVBUF,
1484 M_NOWAIT))) {
1485 printf("em%d: Unable to allocate tx_buffer memory\n",
1486 adapter->unit);
1487 return ENOMEM;
1488 }
1489
1490 bzero(adapter->tx_buffer_area,
1491 sizeof(struct em_tx_buffer) * adapter->num_tx_desc);
1492
1493 return 0;
1494 }
1495
1496 /*********************************************************************
1497 *
1498 * Allocate and initialize transmit structures.
1499 *
1500 **********************************************************************/
1501 static int
1502 em_setup_transmit_structures(struct adapter * adapter)
1503 {
1504 struct em_tx_buffer *tx_buffer;
1505 int i;
1506
1507 if (em_allocate_transmit_structures(adapter))
1508 return ENOMEM;
1509
1510 adapter->first_tx_desc = adapter->tx_desc_base;
1511 adapter->last_tx_desc =
1512 adapter->first_tx_desc + (adapter->num_tx_desc - 1);
1513
1514
1515 STAILQ_INIT(&adapter->free_tx_buffer_list);
1516 STAILQ_INIT(&adapter->used_tx_buffer_list);
1517
1518 tx_buffer = adapter->tx_buffer_area;
1519
1520 /* Setup the linked list of the tx_buffer's */
1521 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
1522 bzero((void *) tx_buffer, sizeof(struct em_tx_buffer));
1523 STAILQ_INSERT_TAIL(&adapter->free_tx_buffer_list,
1524 tx_buffer, em_tx_entry);
1525 }
1526
1527 bzero((void *) adapter->first_tx_desc,
1528 (sizeof(struct em_tx_desc)) * adapter->num_tx_desc);
1529
1530 /* Setup TX descriptor pointers */
1531 adapter->next_avail_tx_desc = adapter->first_tx_desc;
1532
1533 /* Set number of descriptors available */
1534 adapter->num_tx_desc_avail = adapter->num_tx_desc;
1535
1536 /* Set checksum context */
1537 adapter->active_checksum_context = OFFLOAD_NONE;
1538
1539 return 0;
1540 }
1541
1542 /*********************************************************************
1543 *
1544 * Enable transmit unit.
1545 *
1546 **********************************************************************/
1547 static void
1548 em_initialize_transmit_unit(struct adapter * adapter)
1549 {
1550 u_int32_t reg_tctl;
1551 u_int32_t reg_tipg = 0;
1552
1553 /* Setup the Base and Length of the Tx Descriptor Ring */
1554 E1000_WRITE_REG(&adapter->hw, TDBAL,
1555 vtophys((vm_offset_t) adapter->tx_desc_base));
1556 E1000_WRITE_REG(&adapter->hw, TDBAH, 0);
1557 E1000_WRITE_REG(&adapter->hw, TDLEN,
1558 adapter->num_tx_desc *
1559 sizeof(struct em_tx_desc));
1560
1561 /* Setup the HW Tx Head and Tail descriptor pointers */
1562 E1000_WRITE_REG(&adapter->hw, TDH, 0);
1563 E1000_WRITE_REG(&adapter->hw, TDT, 0);
1564
1565
1566 HW_DEBUGOUT2("Base = %x, Length = %x\n",
1567 E1000_READ_REG(&adapter->hw, TDBAL),
1568 E1000_READ_REG(&adapter->hw, TDLEN));
1569
1570
1571 /* Set the default values for the Tx Inter Packet Gap timer */
1572 switch (adapter->hw.mac_type) {
1573 case em_82543:
1574 case em_82544:
1575 case em_82540:
1576 case em_82545:
1577 case em_82546:
1578 if (adapter->hw.media_type == em_media_type_fiber)
1579 reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
1580 else
1581 reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
1582 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
1583 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
1584 break;
1585 case em_82542_rev2_0:
1586 case em_82542_rev2_1:
1587 reg_tipg = DEFAULT_82542_TIPG_IPGT;
1588 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
1589 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
1590 break;
1591 default:
1592 printf("em%d: Invalid mac type detected\n", adapter->unit);
1593 }
1594 E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg);
1595 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay);
1596
1597 /* Program the Transmit Control Register */
1598 reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN |
1599 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
1600 if (adapter->link_duplex == 1) {
1601 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
1602 } else {
1603 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
1604 }
1605 E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl);
1606
1607 /* Setup Transmit Descriptor Settings for this adapter */
1608 adapter->txd_cmd = E1000_TXD_CMD_IFCS;
1609
1610 if (adapter->tx_int_delay > 0)
1611 adapter->txd_cmd |= E1000_TXD_CMD_IDE;
1612
1613 if (adapter->hw.report_tx_early == 1)
1614 adapter->txd_cmd |= E1000_TXD_CMD_RS;
1615 else
1616 adapter->txd_cmd |= E1000_TXD_CMD_RPS;
1617
1618 return;
1619 }
1620
1621 /*********************************************************************
1622 *
1623 * Free all transmit related data structures.
1624 *
1625 **********************************************************************/
1626 static void
1627 em_free_transmit_structures(struct adapter * adapter)
1628 {
1629 struct em_tx_buffer *tx_buffer;
1630 int i;
1631
1632 INIT_DEBUGOUT("free_transmit_structures: begin");
1633
1634 if (adapter->tx_buffer_area != NULL) {
1635 tx_buffer = adapter->tx_buffer_area;
1636 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
1637 if (tx_buffer->m_head != NULL)
1638 m_freem(tx_buffer->m_head);
1639 tx_buffer->m_head = NULL;
1640 }
1641 }
1642 if (adapter->tx_buffer_area != NULL) {
1643 free(adapter->tx_buffer_area, M_DEVBUF);
1644 adapter->tx_buffer_area = NULL;
1645 }
1646 return;
1647 }
1648
1649 /*********************************************************************
1650 *
1651 * The offload context needs to be set when we transfer the first
1652 * packet of a particular protocol (TCP/UDP). We change the
1653 * context only if the protocol type changes.
1654 *
1655 **********************************************************************/
1656 static void
1657 em_transmit_checksum_setup(struct adapter *adapter,
1658 struct mbuf *mp,
1659 u_int32_t *txd_upper,
1660 u_int32_t *txd_lower)
1661 {
1662 struct em_context_desc *TXD;
1663 struct em_tx_desc * current_tx_desc;
1664 struct em_tx_buffer *tx_buffer;
1665
1666 if (mp->m_pkthdr.csum_flags) {
1667
1668 if (mp->m_pkthdr.csum_flags & CSUM_TCP) {
1669 *txd_upper = E1000_TXD_POPTS_TXSM << 8;
1670 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
1671 if (adapter->active_checksum_context == OFFLOAD_TCP_IP)
1672 return;
1673 else
1674 adapter->active_checksum_context = OFFLOAD_TCP_IP;
1675
1676 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) {
1677 *txd_upper = E1000_TXD_POPTS_TXSM << 8;
1678 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
1679 if (adapter->active_checksum_context == OFFLOAD_UDP_IP)
1680 return;
1681 else
1682 adapter->active_checksum_context = OFFLOAD_UDP_IP;
1683 } else {
1684 *txd_upper = 0;
1685 *txd_lower = 0;
1686 return;
1687 }
1688 } else {
1689 *txd_upper = 0;
1690 *txd_lower = 0;
1691 return;
1692 }
1693
1694 /* If we reach this point, the checksum offload context
1695 * needs to be reset.
1696 */
1697 current_tx_desc = adapter->next_avail_tx_desc;
1698 tx_buffer = STAILQ_FIRST(&adapter->free_tx_buffer_list);
1699
1700 TXD = (struct em_context_desc *)current_tx_desc;
1701 TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN;
1702 TXD->lower_setup.ip_fields.ipcso =
1703 ETHER_HDR_LEN + offsetof(struct ip, ip_sum);
1704 TXD->lower_setup.ip_fields.ipcse =
1705 ETHER_HDR_LEN + sizeof(struct ip) - 1;
1706
1707 TXD->upper_setup.tcp_fields.tucss =
1708 ETHER_HDR_LEN + sizeof(struct ip);
1709 TXD->upper_setup.tcp_fields.tucse = 0;
1710
1711 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) {
1712 TXD->upper_setup.tcp_fields.tucso =
1713 ETHER_HDR_LEN + sizeof(struct ip) +
1714 offsetof(struct tcphdr, th_sum);
1715 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) {
1716 TXD->upper_setup.tcp_fields.tucso =
1717 ETHER_HDR_LEN + sizeof(struct ip) +
1718 offsetof(struct udphdr, uh_sum);
1719 }
1720
1721 TXD->tcp_seg_setup.data = 0;
1722 TXD->cmd_and_length = (adapter->txd_cmd | E1000_TXD_CMD_DEXT);
1723
1724 if (current_tx_desc == adapter->last_tx_desc)
1725 adapter->next_avail_tx_desc = adapter->first_tx_desc;
1726 else
1727 adapter->next_avail_tx_desc++;
1728
1729 adapter->num_tx_desc_avail--;
1730
1731 tx_buffer->used_tx_desc = current_tx_desc;
1732 STAILQ_REMOVE_HEAD(&adapter->free_tx_buffer_list, em_tx_entry);
1733 STAILQ_INSERT_TAIL(&adapter->used_tx_buffer_list, tx_buffer, em_tx_entry);
1734 return;
1735 }
1736
1737 /**********************************************************************
1738 *
1739 * Examine each tx_buffer in the used queue. If the hardware is done
1740 * processing the packet then free associated resources. The
1741 * tx_buffer is put back on the free queue.
1742 *
1743 **********************************************************************/
1744 static void
1745 em_clean_transmit_interrupts(struct adapter * adapter)
1746 {
1747 struct em_tx_buffer *tx_buffer;
1748 struct em_tx_desc *tx_desc;
1749 int s;
1750 struct ifnet *ifp;
1751
1752 s = splimp();
1753 #ifdef DBG_STATS
1754 adapter->clean_tx_interrupts++;
1755 #endif
1756
1757 for (tx_buffer = STAILQ_FIRST(&adapter->used_tx_buffer_list);
1758 tx_buffer;
1759 tx_buffer = STAILQ_FIRST(&adapter->used_tx_buffer_list)) {
1760
1761 /*
1762 * Get hold of the next descriptor that the hardware will report status
1763 * back to. There is 1/1 correspondence between a tx descriptor
1764 * and tx_buffer.
1765 */
1766
1767 tx_desc = tx_buffer->used_tx_desc;
1768
1769 /*
1770 * If the descriptor done bit is set, free tx_buffer and associated
1771 * resources
1772 */
1773 if (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) {
1774
1775 tx_desc->upper.data = 0;
1776 adapter->num_tx_desc_avail++;
1777
1778 if (tx_buffer->m_head) {
1779 m_freem(tx_buffer->m_head);
1780 tx_buffer->m_head = NULL;
1781 }
1782
1783 STAILQ_REMOVE_HEAD(&adapter->used_tx_buffer_list,
1784 em_tx_entry);
1785 /* Return this tx_buffer back to the "free" list */
1786 STAILQ_INSERT_TAIL(&adapter->free_tx_buffer_list,
1787 tx_buffer, em_tx_entry);
1788 } else {
1789 /*
1790 * Found a tx_buffer that the em is not done with then there is
1791 * no reason to check the rest of the queue.
1792 */
1793 break;
1794 }
1795 } /* end for each tx_buffer */
1796
1797 ifp = &adapter->interface_data.ac_if;
1798
1799 /* Tell the stack that it is OK to send packets */
1800 if (adapter->num_tx_desc_avail > EM_TX_CLEANUP_THRESHOLD) {
1801 ifp->if_timer = 0;
1802 ifp->if_flags &= ~IFF_OACTIVE;
1803 }
1804 splx(s);
1805 return;
1806 }
1807
1808
1809 /*********************************************************************
1810 *
1811 * Get a buffer from system mbuf buffer pool.
1812 *
1813 **********************************************************************/
1814 static int
1815 em_get_buf(struct em_rx_buffer *rx_buffer, struct adapter *adapter,
1816 struct mbuf *mp)
1817 {
1818 struct mbuf *nmp;
1819 struct ifnet *ifp;
1820
1821 ifp = &adapter->interface_data.ac_if;
1822
1823 if (mp == NULL) {
1824 MGETHDR(nmp, M_DONTWAIT, MT_DATA);
1825 if (nmp == NULL) {
1826 adapter->mbuf_alloc_failed++;
1827 return(ENOBUFS);
1828 }
1829 MCLGET(nmp, M_DONTWAIT);
1830 if ((nmp->m_flags & M_EXT) == 0) {
1831 m_freem(nmp);
1832 adapter->mbuf_cluster_failed++;
1833 return(ENOBUFS);
1834 }
1835 nmp->m_len = nmp->m_pkthdr.len = MCLBYTES;
1836 } else {
1837 nmp = mp;
1838 nmp->m_len = nmp->m_pkthdr.len = MCLBYTES;
1839 nmp->m_data = nmp->m_ext.ext_buf;
1840 nmp->m_next = NULL;
1841 }
1842
1843 if (ifp->if_mtu <= ETHERMTU) {
1844 m_adj(nmp, ETHER_ALIGN);
1845 }
1846
1847 rx_buffer->m_head = nmp;
1848 rx_buffer->buffer_addr = vtophys(mtod(nmp, vm_offset_t));
1849
1850 return(0);
1851 }
1852
1853 /*********************************************************************
1854 *
1855 * Allocate memory for rx_buffer structures. Since we use one
1856 * rx_buffer per received packet, the maximum number of rx_buffer's
1857 * that we'll need is equal to the number of receive descriptors
1858 * that we've allocated.
1859 *
1860 **********************************************************************/
1861 static int
1862 em_allocate_receive_structures(struct adapter * adapter)
1863 {
1864 int i;
1865 struct em_rx_buffer *rx_buffer;
1866
1867 if (!(adapter->rx_buffer_area =
1868 (struct em_rx_buffer *) malloc(sizeof(struct em_rx_buffer) *
1869 adapter->num_rx_desc, M_DEVBUF,
1870 M_NOWAIT))) {
1871 printf("em%d: Unable to allocate rx_buffer memory\n",
1872 adapter->unit);
1873 return(ENOMEM);
1874 }
1875
1876 bzero(adapter->rx_buffer_area,
1877 sizeof(struct em_rx_buffer) * adapter->num_rx_desc);
1878
1879 for (i = 0, rx_buffer = adapter->rx_buffer_area;
1880 i < adapter->num_rx_desc; i++, rx_buffer++) {
1881
1882 if (em_get_buf(rx_buffer, adapter, NULL) == ENOBUFS) {
1883 rx_buffer->m_head = NULL;
1884 return(ENOBUFS);
1885 }
1886 }
1887
1888 return(0);
1889 }
1890
1891 /*********************************************************************
1892 *
1893 * Allocate and initialize receive structures.
1894 *
1895 **********************************************************************/
1896 static int
1897 em_setup_receive_structures(struct adapter * adapter)
1898 {
1899 struct em_rx_buffer *rx_buffer;
1900 struct em_rx_desc *rx_desc;
1901 int i;
1902
1903 if (em_allocate_receive_structures(adapter))
1904 return ENOMEM;
1905
1906 STAILQ_INIT(&adapter->rx_buffer_list);
1907
1908 adapter->first_rx_desc =
1909 (struct em_rx_desc *) adapter->rx_desc_base;
1910 adapter->last_rx_desc =
1911 adapter->first_rx_desc + (adapter->num_rx_desc - 1);
1912
1913 rx_buffer = (struct em_rx_buffer *) adapter->rx_buffer_area;
1914
1915 bzero((void *) adapter->first_rx_desc,
1916 (sizeof(struct em_rx_desc)) * adapter->num_rx_desc);
1917
1918 /* Build a linked list of rx_buffer's */
1919 for (i = 0, rx_desc = adapter->first_rx_desc;
1920 i < adapter->num_rx_desc;
1921 i++, rx_buffer++, rx_desc++) {
1922 if (rx_buffer->m_head == NULL)
1923 printf("em%d: Receive buffer memory not allocated",
1924 adapter->unit);
1925 else {
1926 rx_desc->buffer_addr = rx_buffer->buffer_addr;
1927 STAILQ_INSERT_TAIL(&adapter->rx_buffer_list,
1928 rx_buffer, em_rx_entry);
1929 }
1930 }
1931
1932 /* Setup our descriptor pointers */
1933 adapter->next_rx_desc_to_check = adapter->first_rx_desc;
1934
1935 return(0);
1936 }
1937
1938 /*********************************************************************
1939 *
1940 * Enable receive unit.
1941 *
1942 **********************************************************************/
1943 static void
1944 em_initialize_receive_unit(struct adapter * adapter)
1945 {
1946 u_int32_t reg_rctl;
1947 u_int32_t reg_rxcsum;
1948 struct ifnet *ifp;
1949
1950 ifp = &adapter->interface_data.ac_if;
1951
1952 /* Make sure receives are disabled while setting up the descriptor ring */
1953 E1000_WRITE_REG(&adapter->hw, RCTL, 0);
1954
1955 /* Set the Receive Delay Timer Register */
1956 E1000_WRITE_REG(&adapter->hw, RDTR,
1957 adapter->rx_int_delay | E1000_RDT_FPDB);
1958
1959 /* Setup the Base and Length of the Rx Descriptor Ring */
1960 E1000_WRITE_REG(&adapter->hw, RDBAL,
1961 vtophys((vm_offset_t) adapter->rx_desc_base));
1962 E1000_WRITE_REG(&adapter->hw, RDBAH, 0);
1963 E1000_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc *
1964 sizeof(struct em_rx_desc));
1965
1966 /* Setup the HW Rx Head and Tail Descriptor Pointers */
1967 E1000_WRITE_REG(&adapter->hw, RDH, 0);
1968 E1000_WRITE_REG(&adapter->hw, RDT,
1969 (((uintptr_t) adapter->last_rx_desc -
1970 (uintptr_t) adapter->first_rx_desc) >> 4));
1971
1972 /* Setup the Receive Control Register */
1973 reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
1974 E1000_RCTL_RDMTS_HALF |
1975 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);
1976
1977 if (adapter->hw.tbi_compatibility_on == TRUE)
1978 reg_rctl |= E1000_RCTL_SBP;
1979
1980
1981 switch (adapter->rx_buffer_len) {
1982 default:
1983 case EM_RXBUFFER_2048:
1984 reg_rctl |= E1000_RCTL_SZ_2048;
1985 break;
1986 case EM_RXBUFFER_4096:
1987 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
1988 break;
1989 case EM_RXBUFFER_8192:
1990 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
1991 break;
1992 case EM_RXBUFFER_16384:
1993 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
1994 break;
1995 }
1996
1997 if (ifp->if_mtu > ETHERMTU)
1998 reg_rctl |= E1000_RCTL_LPE;
1999
2000 /* Enable 82543 Receive Checksum Offload for TCP and UDP */
2001 if ((adapter->hw.mac_type >= em_82543) &&
2002 (ifp->if_capenable & IFCAP_RXCSUM)) {
2003 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
2004 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL);
2005 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum);
2006 }
2007
2008 /* Enable Receives */
2009 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
2010
2011 return;
2012 }
2013
2014 /*********************************************************************
2015 *
2016 * Free receive related data structures.
2017 *
2018 **********************************************************************/
2019 static void
2020 em_free_receive_structures(struct adapter * adapter)
2021 {
2022 struct em_rx_buffer *rx_buffer;
2023 int i;
2024
2025 INIT_DEBUGOUT("free_receive_structures: begin");
2026
2027 if (adapter->rx_buffer_area != NULL) {
2028 rx_buffer = adapter->rx_buffer_area;
2029 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
2030 if (rx_buffer->m_head != NULL)
2031 m_freem(rx_buffer->m_head);
2032 rx_buffer->m_head = NULL;
2033 }
2034 }
2035 if (adapter->rx_buffer_area != NULL) {
2036 free(adapter->rx_buffer_area, M_DEVBUF);
2037 adapter->rx_buffer_area = NULL;
2038 }
2039 return;
2040 }
2041
2042 /*********************************************************************
2043 *
2044 * This routine executes in interrupt context. It replenishes
2045 * the mbufs in the descriptor and sends data which has been
2046 * dma'ed into host memory to upper layer.
2047 *
2048 *********************************************************************/
2049 static void
2050 em_process_receive_interrupts(struct adapter * adapter, int count)
2051 {
2052 struct mbuf *mp;
2053 struct ifnet *ifp;
2054 u_int16_t len;
2055 u_int8_t last_byte;
2056 u_int8_t accept_frame = 0;
2057 u_int8_t eop = 0;
2058 u_int32_t pkt_len = 0;
2059
2060 /* Pointer to the receive descriptor being examined. */
2061 struct em_rx_desc *current_desc;
2062 struct em_rx_desc *last_desc_processed;
2063 struct em_rx_buffer *rx_buffer;
2064
2065 ifp = &adapter->interface_data.ac_if;
2066 current_desc = adapter->next_rx_desc_to_check;
2067
2068 if (!((current_desc->status) & E1000_RXD_STAT_DD)) {
2069 #ifdef DBG_STATS
2070 adapter->no_pkts_avail++;
2071 #endif
2072 return;
2073 }
2074
2075 while ((current_desc->status & E1000_RXD_STAT_DD) && (count != 0)) {
2076
2077 /* Get a pointer to the actual receive buffer */
2078 rx_buffer = STAILQ_FIRST(&adapter->rx_buffer_list);
2079
2080 if (rx_buffer == NULL) {
2081 printf("em%d: Found null rx_buffer\n", adapter->unit);
2082 return;
2083 }
2084
2085 mp = rx_buffer->m_head;
2086 accept_frame = 1;
2087
2088 if (current_desc->status & E1000_RXD_STAT_EOP) {
2089 count--;
2090 eop = 1;
2091 len = current_desc->length - ETHER_CRC_LEN;
2092 } else {
2093 eop = 0;
2094 len = current_desc->length;
2095 }
2096
2097 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
2098
2099 /* Compute packet length for tbi_accept macro */
2100 pkt_len = current_desc->length;
2101 if (adapter->fmp != NULL) {
2102 pkt_len += adapter->fmp->m_pkthdr.len;
2103 }
2104
2105 last_byte = *(mtod(rx_buffer->m_head,caddr_t) +
2106 current_desc->length - 1);
2107
2108 if (TBI_ACCEPT(&adapter->hw, current_desc->status,
2109 current_desc->errors,
2110 pkt_len, last_byte)) {
2111 em_tbi_adjust_stats(&adapter->hw,
2112 &adapter->stats,
2113 pkt_len,
2114 adapter->hw.mac_addr);
2115 len--;
2116 } else {
2117 accept_frame = 0;
2118 }
2119 }
2120
2121 if (accept_frame) {
2122
2123 if (em_get_buf(rx_buffer, adapter, NULL) == ENOBUFS) {
2124 adapter->dropped_pkts++;
2125 em_get_buf(rx_buffer, adapter, mp);
2126 if (adapter->fmp != NULL) m_freem(adapter->fmp);
2127 adapter->fmp = NULL;
2128 adapter->lmp = NULL;
2129 break;
2130 }
2131
2132 /* Assign correct length to the current fragment */
2133 mp->m_len = len;
2134
2135 if (adapter->fmp == NULL) {
2136 mp->m_pkthdr.len = len;
2137 adapter->fmp = mp; /* Store the first mbuf */
2138 adapter->lmp = mp;
2139 } else {
2140 /* Chain mbuf's together */
2141 mp->m_flags &= ~M_PKTHDR;
2142 adapter->lmp->m_next = mp;
2143 adapter->lmp = adapter->lmp->m_next;
2144 adapter->fmp->m_pkthdr.len += len;
2145 }
2146
2147 if (eop) {
2148 adapter->fmp->m_pkthdr.rcvif = ifp;
2149 em_receive_checksum(adapter, current_desc,
2150 adapter->fmp);
2151 if (current_desc->status & E1000_RXD_STAT_VP)
2152 VLAN_INPUT_TAG(ifp, adapter->fmp,
2153 current_desc->special,
2154 adapter->fmp = NULL);
2155 if (adapter->fmp != NULL)
2156 (*ifp->if_input)(ifp, adapter->fmp);
2157
2158 adapter->fmp = NULL;
2159 adapter->lmp = NULL;
2160 }
2161 } else {
2162 adapter->dropped_pkts++;
2163 em_get_buf(rx_buffer, adapter, mp);
2164 if (adapter->fmp != NULL) m_freem(adapter->fmp);
2165 adapter->fmp = NULL;
2166 adapter->lmp = NULL;
2167 }
2168
2169 /* Zero out the receive descriptors status */
2170 current_desc->status = 0;
2171
2172 if (rx_buffer->m_head != NULL) {
2173 current_desc->buffer_addr = rx_buffer->buffer_addr;
2174 }
2175
2176 /* Advance our pointers to the next descriptor (checking for wrap). */
2177 if (current_desc == adapter->last_rx_desc)
2178 adapter->next_rx_desc_to_check = adapter->first_rx_desc;
2179 else
2180 ((adapter)->next_rx_desc_to_check)++;
2181
2182 last_desc_processed = current_desc;
2183 current_desc = adapter->next_rx_desc_to_check;
2184 /*
2185 * Put the buffer that we just indicated back at the end of our list
2186 */
2187 STAILQ_REMOVE_HEAD(&adapter->rx_buffer_list, em_rx_entry);
2188 STAILQ_INSERT_TAIL(&adapter->rx_buffer_list,
2189 rx_buffer, em_rx_entry);
2190
2191 /* Advance the E1000's Receive Queue #0 "Tail Pointer". */
2192 E1000_WRITE_REG(&adapter->hw, RDT,
2193 (((u_long) last_desc_processed -
2194 (u_long) adapter->first_rx_desc) >> 4));
2195 }
2196 return;
2197 }
2198
2199 /*********************************************************************
2200 *
2201 * Verify that the hardware indicated that the checksum is valid.
2202 * Inform the stack about the status of checksum so that stack
2203 * doesn't spend time verifying the checksum.
2204 *
2205 *********************************************************************/
2206 static void
2207 em_receive_checksum(struct adapter *adapter,
2208 struct em_rx_desc *rx_desc,
2209 struct mbuf *mp)
2210 {
2211 /* 82543 or newer only */
2212 if ((adapter->hw.mac_type < em_82543) ||
2213 /* Ignore Checksum bit is set */
2214 (rx_desc->status & E1000_RXD_STAT_IXSM)) {
2215 mp->m_pkthdr.csum_flags = 0;
2216 return;
2217 }
2218
2219 if (rx_desc->status & E1000_RXD_STAT_IPCS) {
2220 /* Did it pass? */
2221 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) {
2222 /* IP Checksum Good */
2223 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
2224 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID;
2225
2226 } else {
2227 mp->m_pkthdr.csum_flags = 0;
2228 }
2229 }
2230
2231 if (rx_desc->status & E1000_RXD_STAT_TCPCS) {
2232 /* Did it pass? */
2233 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) {
2234 mp->m_pkthdr.csum_flags |=
2235 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
2236 mp->m_pkthdr.csum_data = htons(0xffff);
2237 }
2238 }
2239
2240 return;
2241 }
2242
2243
2244 static void em_enable_vlans(struct adapter *adapter)
2245 {
2246 uint32_t ctrl;
2247
2248 E1000_WRITE_REG(&adapter->hw, VET, QTAG_TYPE);
2249
2250 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2251 ctrl |= E1000_CTRL_VME;
2252 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2253
2254 return;
2255 }
2256
2257 static void
2258 em_enable_intr(struct adapter * adapter)
2259 {
2260 E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK));
2261 return;
2262 }
2263
2264 static void
2265 em_disable_intr(struct adapter *adapter)
2266 {
2267 E1000_WRITE_REG(&adapter->hw, IMC,
2268 (0xffffffff & ~E1000_IMC_RXSEQ));
2269 return;
2270 }
2271
2272 void
2273 em_write_pci_cfg(struct em_hw *hw,
2274 uint32_t reg,
2275 uint16_t *value)
2276 {
2277 pci_write_config(((struct em_osdep *)hw->back)->dev, reg,
2278 *value, 2);
2279 }
2280
2281 void
2282 em_read_pci_cfg(struct em_hw *hw, uint32_t reg,
2283 uint16_t *value)
2284 {
2285 *value = pci_read_config(((struct em_osdep *)hw->back)->dev,
2286 reg, 2);
2287 return;
2288 }
2289
2290
2291 void
2292 em_pci_set_mwi(struct em_hw *hw)
2293 {
2294 pci_write_config(((struct em_osdep *)hw->back)->dev,
2295 PCIR_COMMAND,
2296 (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2);
2297 return;
2298 }
2299
2300 void
2301 em_pci_clear_mwi(struct em_hw *hw)
2302 {
2303 pci_write_config(((struct em_osdep *)hw->back)->dev,
2304 PCIR_COMMAND,
2305 (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2);
2306 return;
2307 }
2308
2309 uint32_t
2310 em_io_read(struct em_hw *hw, uint32_t port)
2311 {
2312 return(inl(port));
2313 }
2314
2315 void
2316 em_io_write(struct em_hw *hw, uint32_t port, uint32_t value)
2317 {
2318 outl(port, value);
2319 return;
2320 }
2321
2322
2323 /**********************************************************************
2324 *
2325 * Update the board statistics counters.
2326 *
2327 **********************************************************************/
2328 static void
2329 em_update_stats_counters(struct adapter *adapter)
2330 {
2331 struct ifnet *ifp;
2332
2333 adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS);
2334 adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS);
2335 adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC);
2336 adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC);
2337 adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL);
2338 adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC);
2339 adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL);
2340 adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC);
2341 adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC);
2342 adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC);
2343 adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC);
2344 adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC);
2345 adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC);
2346 adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC);
2347 adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC);
2348 adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC);
2349 adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64);
2350 adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127);
2351 adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255);
2352 adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511);
2353 adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023);
2354 adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522);
2355 adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC);
2356 adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC);
2357 adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC);
2358 adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC);
2359
2360 /* For the 64-bit byte counters the low dword must be read first. */
2361 /* Both registers clear on the read of the high dword */
2362
2363 adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL);
2364 adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH);
2365 adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL);
2366 adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH);
2367
2368 adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC);
2369 adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC);
2370 adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC);
2371 adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC);
2372 adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC);
2373
2374 adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL);
2375 adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH);
2376 adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL);
2377 adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH);
2378
2379 adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR);
2380 adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT);
2381 adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64);
2382 adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127);
2383 adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255);
2384 adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511);
2385 adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023);
2386 adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522);
2387 adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC);
2388 adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC);
2389
2390 if (adapter->hw.mac_type >= em_82543) {
2391 adapter->stats.algnerrc +=
2392 E1000_READ_REG(&adapter->hw, ALGNERRC);
2393 adapter->stats.rxerrc +=
2394 E1000_READ_REG(&adapter->hw, RXERRC);
2395 adapter->stats.tncrs +=
2396 E1000_READ_REG(&adapter->hw, TNCRS);
2397 adapter->stats.cexterr +=
2398 E1000_READ_REG(&adapter->hw, CEXTERR);
2399 adapter->stats.tsctc +=
2400 E1000_READ_REG(&adapter->hw, TSCTC);
2401 adapter->stats.tsctfc +=
2402 E1000_READ_REG(&adapter->hw, TSCTFC);
2403 }
2404 ifp = &adapter->interface_data.ac_if;
2405
2406 /* Fill out the OS statistics structure */
2407 ifp->if_ipackets = adapter->stats.gprc;
2408 ifp->if_opackets = adapter->stats.gptc;
2409 ifp->if_ibytes = adapter->stats.gorcl;
2410 ifp->if_obytes = adapter->stats.gotcl;
2411 ifp->if_imcasts = adapter->stats.mprc;
2412 ifp->if_collisions = adapter->stats.colc;
2413
2414 /* Rx Errors */
2415 ifp->if_ierrors =
2416 adapter->dropped_pkts +
2417 adapter->stats.rxerrc +
2418 adapter->stats.crcerrs +
2419 adapter->stats.algnerrc +
2420 adapter->stats.rlec + adapter->stats.rnbc +
2421 adapter->stats.mpc + adapter->stats.cexterr;
2422
2423 /* Tx Errors */
2424 ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol;
2425
2426 }
2427
2428
2429 /**********************************************************************
2430 *
2431 * This routine is called only when em_display_debug_stats is enabled.
2432 * This routine provides a way to take a look at important statistics
2433 * maintained by the driver and hardware.
2434 *
2435 **********************************************************************/
2436 static void
2437 em_print_hw_stats(struct adapter *adapter)
2438 {
2439 int unit = adapter->unit;
2440
2441 #ifdef DBG_STATS
2442 printf("em%d: Packets not Avail = %ld\n", unit,
2443 adapter->no_pkts_avail);
2444 printf("em%d: CleanTxInterrupts = %ld\n", unit,
2445 adapter->clean_tx_interrupts);
2446 #endif
2447
2448 printf("em%d: Tx Descriptors not avail1 = %ld\n", unit,
2449 adapter->no_tx_desc_avail1);
2450 printf("em%d: Tx Descriptors not avail2 = %ld\n", unit,
2451 adapter->no_tx_desc_avail2);
2452 printf("em%d: Tx Buffer not avail1 = %ld\n", unit,
2453 adapter->no_tx_buffer_avail1);
2454 printf("em%d: Tx Buffer not avail2 = %ld\n", unit,
2455 adapter->no_tx_buffer_avail2);
2456 printf("em%d: Std Mbuf Failed = %ld\n",unit,
2457 adapter->mbuf_alloc_failed);
2458 printf("em%d: Std Cluster Failed = %ld\n",unit,
2459 adapter->mbuf_cluster_failed);
2460 printf("em%d: Number of TX desc avail = %d\n", unit,
2461 adapter->num_tx_desc_avail);
2462
2463 printf("em%d: Symbol errors = %lld\n", unit,
2464 (long long)adapter->stats.symerrs);
2465 printf("em%d: Sequence errors = %lld\n", unit,
2466 (long long)adapter->stats.sec);
2467 printf("em%d: Defer count = %lld\n", unit,
2468 (long long)adapter->stats.dc);
2469
2470 printf("em%d: Missed Packets = %lld\n", unit,
2471 (long long)adapter->stats.mpc);
2472 printf("em%d: Receive No Buffers = %lld\n", unit,
2473 (long long)adapter->stats.rnbc);
2474 printf("em%d: Receive length errors = %lld\n", unit,
2475 (long long)adapter->stats.rlec);
2476 printf("em%d: Receive errors = %lld\n", unit,
2477 (long long)adapter->stats.rxerrc);
2478 printf("em%d: Crc errors = %lld\n", unit,
2479 (long long)adapter->stats.crcerrs);
2480 printf("em%d: Alignment errors = %lld\n", unit,
2481 (long long)adapter->stats.algnerrc);
2482 printf("em%d: Carrier extension errors = %lld\n", unit,
2483 (long long)adapter->stats.cexterr);
2484 printf("em%d: Driver dropped packets = %ld\n", unit,
2485 adapter->dropped_pkts);
2486
2487 printf("em%d: XON Rcvd = %lld\n", unit,
2488 (long long)adapter->stats.xonrxc);
2489 printf("em%d: XON Xmtd = %lld\n", unit,
2490 (long long)adapter->stats.xontxc);
2491 printf("em%d: XOFF Rcvd = %lld\n", unit,
2492 (long long)adapter->stats.xoffrxc);
2493 printf("em%d: XOFF Xmtd = %lld\n", unit,
2494 (long long)adapter->stats.xofftxc);
2495
2496 printf("em%d: Good Packets Rcvd = %lld\n", unit,
2497 (long long)adapter->stats.gprc);
2498 printf("em%d: Good Packets Xmtd = %lld\n", unit,
2499 (long long)adapter->stats.gptc);
2500
2501 return;
2502 }
2503
Cache object: f9b2e680f6bec8ab88d553c43dcaf164
|