1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018-2021 Beijing WangXun Technology Co., Ltd.
3 * Copyright(c) 2010-2017 Intel Corporation
9 #include "ngbe_eeprom.h"
14 * ngbe_start_hw - Prepare hardware for Tx/Rx
15 * @hw: pointer to hardware structure
17 * Starts the hardware.
19 s32 ngbe_start_hw(struct ngbe_hw *hw)
23 /* Clear the VLAN filter table */
24 hw->mac.clear_vfta(hw);
26 /* Clear statistics registers */
27 hw->mac.clear_hw_cntrs(hw);
29 /* Setup flow control */
30 err = hw->mac.setup_fc(hw);
31 if (err != 0 && err != NGBE_NOT_IMPLEMENTED) {
32 DEBUGOUT("Flow control setup failed, returning %d", err);
36 /* Clear adapter stopped flag */
37 hw->adapter_stopped = false;
43 * ngbe_init_hw - Generic hardware initialization
44 * @hw: pointer to hardware structure
46 * Initialize the hardware by resetting the hardware, filling the bus info
47 * structure and media type, clears all on chip counters, initializes receive
48 * address registers, multicast table, VLAN filter table, calls routine to set
49 * up link and flow control settings, and leaves transmit and receive units
50 * disabled and uninitialized
52 s32 ngbe_init_hw(struct ngbe_hw *hw)
56 ngbe_save_eeprom_version(hw);
58 /* Reset the hardware */
59 status = hw->mac.reset_hw(hw);
62 status = hw->mac.start_hw(hw);
66 DEBUGOUT("Failed to initialize HW, STATUS = %d", status);
72 ngbe_reset_misc_em(struct ngbe_hw *hw)
76 wr32(hw, NGBE_ISBADDRL, hw->isb_dma & 0xFFFFFFFF);
77 wr32(hw, NGBE_ISBADDRH, hw->isb_dma >> 32);
79 /* receive packets that size > 2048 */
80 wr32m(hw, NGBE_MACRXCFG,
81 NGBE_MACRXCFG_JUMBO, NGBE_MACRXCFG_JUMBO);
83 wr32m(hw, NGBE_FRMSZ, NGBE_FRMSZ_MAX_MASK,
84 NGBE_FRMSZ_MAX(NGBE_FRAME_SIZE_DFT));
86 /* clear counters on read */
87 wr32m(hw, NGBE_MACCNTCTL,
88 NGBE_MACCNTCTL_RC, NGBE_MACCNTCTL_RC);
90 wr32m(hw, NGBE_RXFCCFG,
91 NGBE_RXFCCFG_FC, NGBE_RXFCCFG_FC);
92 wr32m(hw, NGBE_TXFCCFG,
93 NGBE_TXFCCFG_FC, NGBE_TXFCCFG_FC);
95 wr32m(hw, NGBE_MACRXFLT,
96 NGBE_MACRXFLT_PROMISC, NGBE_MACRXFLT_PROMISC);
98 wr32m(hw, NGBE_RSTSTAT,
99 NGBE_RSTSTAT_TMRINIT_MASK, NGBE_RSTSTAT_TMRINIT(30));
101 /* errata 4: initialize mng flex tbl and wakeup flex tbl*/
102 wr32(hw, NGBE_MNGFLEXSEL, 0);
103 for (i = 0; i < 16; i++) {
104 wr32(hw, NGBE_MNGFLEXDWL(i), 0);
105 wr32(hw, NGBE_MNGFLEXDWH(i), 0);
106 wr32(hw, NGBE_MNGFLEXMSK(i), 0);
108 wr32(hw, NGBE_LANFLEXSEL, 0);
109 for (i = 0; i < 16; i++) {
110 wr32(hw, NGBE_LANFLEXDWL(i), 0);
111 wr32(hw, NGBE_LANFLEXDWH(i), 0);
112 wr32(hw, NGBE_LANFLEXMSK(i), 0);
115 /* set pause frame dst mac addr */
116 wr32(hw, NGBE_RXPBPFCDMACL, 0xC2000001);
117 wr32(hw, NGBE_RXPBPFCDMACH, 0x0180);
119 wr32(hw, NGBE_MDIOMODE, 0xF);
121 wr32m(hw, NGBE_GPIE, NGBE_GPIE_MSIX, NGBE_GPIE_MSIX);
124 /* gpio0 is used to power on/off control*/
125 wr32(hw, NGBE_GPIODIR, NGBE_GPIODIR_DDR(1));
126 wr32(hw, NGBE_GPIODATA, NGBE_GPIOBIT_0);
129 hw->mac.init_thermal_sensor_thresh(hw);
131 /* enable mac transmitter */
132 wr32m(hw, NGBE_MACTXCFG, NGBE_MACTXCFG_TE, NGBE_MACTXCFG_TE);
135 wr32m(hw, NGBE_MACTXCFG,
136 NGBE_MACTXCFG_SPEED_MASK, NGBE_MACTXCFG_SPEED_1G);
138 for (i = 0; i < 4; i++)
139 wr32m(hw, NGBE_IVAR(i), 0x80808080, 0);
143 * ngbe_reset_hw_em - Perform hardware reset
144 * @hw: pointer to hardware structure
146 * Resets the hardware by resetting the transmit and receive units, masks
147 * and clears all interrupts, perform a PHY reset, and perform a link (MAC)
150 s32 ngbe_reset_hw_em(struct ngbe_hw *hw)
154 /* Call adapter stop to disable tx/rx and clear interrupts */
155 status = hw->mac.stop_hw(hw);
159 /* Identify PHY and related function pointers */
160 status = ngbe_init_phy(hw);
165 if (!hw->phy.reset_disable)
166 hw->phy.reset_hw(hw);
168 wr32(hw, NGBE_RST, NGBE_RST_LAN(hw->bus.lan_id));
172 ngbe_reset_misc_em(hw);
173 hw->mac.clear_hw_cntrs(hw);
177 /* Store the permanent mac address */
178 hw->mac.get_mac_addr(hw, hw->mac.perm_addr);
181 * Store MAC address from RAR0, clear receive address registers, and
182 * clear the multicast table.
184 hw->mac.num_rar_entries = NGBE_EM_RAR_ENTRIES;
185 hw->mac.init_rx_addrs(hw);
191 * ngbe_clear_hw_cntrs - Generic clear hardware counters
192 * @hw: pointer to hardware structure
194 * Clears all hardware statistics counters by reading them from the hardware
195 * Statistics counters are clear on read.
197 s32 ngbe_clear_hw_cntrs(struct ngbe_hw *hw)
202 /* don't write clear queue stats */
203 for (i = 0; i < NGBE_MAX_QP; i++) {
204 hw->qp_last[i].rx_qp_packets = 0;
205 hw->qp_last[i].tx_qp_packets = 0;
206 hw->qp_last[i].rx_qp_bytes = 0;
207 hw->qp_last[i].tx_qp_bytes = 0;
208 hw->qp_last[i].rx_qp_mc_packets = 0;
209 hw->qp_last[i].tx_qp_mc_packets = 0;
210 hw->qp_last[i].rx_qp_bc_packets = 0;
211 hw->qp_last[i].tx_qp_bc_packets = 0;
215 rd32(hw, NGBE_PBRXLNKXON);
216 rd32(hw, NGBE_PBRXLNKXOFF);
217 rd32(hw, NGBE_PBTXLNKXON);
218 rd32(hw, NGBE_PBTXLNKXOFF);
221 rd32(hw, NGBE_DMARXPKT);
222 rd32(hw, NGBE_DMATXPKT);
224 rd64(hw, NGBE_DMARXOCTL);
225 rd64(hw, NGBE_DMATXOCTL);
228 rd64(hw, NGBE_MACRXERRCRCL);
229 rd64(hw, NGBE_MACRXMPKTL);
230 rd64(hw, NGBE_MACTXMPKTL);
232 rd64(hw, NGBE_MACRXPKTL);
233 rd64(hw, NGBE_MACTXPKTL);
234 rd64(hw, NGBE_MACRXGBOCTL);
236 rd64(hw, NGBE_MACRXOCTL);
237 rd32(hw, NGBE_MACTXOCTL);
239 rd64(hw, NGBE_MACRX1TO64L);
240 rd64(hw, NGBE_MACRX65TO127L);
241 rd64(hw, NGBE_MACRX128TO255L);
242 rd64(hw, NGBE_MACRX256TO511L);
243 rd64(hw, NGBE_MACRX512TO1023L);
244 rd64(hw, NGBE_MACRX1024TOMAXL);
245 rd64(hw, NGBE_MACTX1TO64L);
246 rd64(hw, NGBE_MACTX65TO127L);
247 rd64(hw, NGBE_MACTX128TO255L);
248 rd64(hw, NGBE_MACTX256TO511L);
249 rd64(hw, NGBE_MACTX512TO1023L);
250 rd64(hw, NGBE_MACTX1024TOMAXL);
252 rd64(hw, NGBE_MACRXERRLENL);
253 rd32(hw, NGBE_MACRXOVERSIZE);
254 rd32(hw, NGBE_MACRXJABBER);
257 rd32(hw, NGBE_LSECTX_UTPKT);
258 rd32(hw, NGBE_LSECTX_ENCPKT);
259 rd32(hw, NGBE_LSECTX_PROTPKT);
260 rd32(hw, NGBE_LSECTX_ENCOCT);
261 rd32(hw, NGBE_LSECTX_PROTOCT);
262 rd32(hw, NGBE_LSECRX_UTPKT);
263 rd32(hw, NGBE_LSECRX_BTPKT);
264 rd32(hw, NGBE_LSECRX_NOSCIPKT);
265 rd32(hw, NGBE_LSECRX_UNSCIPKT);
266 rd32(hw, NGBE_LSECRX_DECOCT);
267 rd32(hw, NGBE_LSECRX_VLDOCT);
268 rd32(hw, NGBE_LSECRX_UNCHKPKT);
269 rd32(hw, NGBE_LSECRX_DLYPKT);
270 rd32(hw, NGBE_LSECRX_LATEPKT);
271 for (i = 0; i < 2; i++) {
272 rd32(hw, NGBE_LSECRX_OKPKT(i));
273 rd32(hw, NGBE_LSECRX_INVPKT(i));
274 rd32(hw, NGBE_LSECRX_BADPKT(i));
276 for (i = 0; i < 4; i++) {
277 rd32(hw, NGBE_LSECRX_INVSAPKT(i));
278 rd32(hw, NGBE_LSECRX_BADSAPKT(i));
285 * ngbe_get_mac_addr - Generic get MAC address
286 * @hw: pointer to hardware structure
287 * @mac_addr: Adapter MAC address
289 * Reads the adapter's MAC address from first Receive Address Register (RAR0)
290 * A reset of the adapter must be performed prior to calling this function
291 * in order for the MAC address to have been loaded from the EEPROM into RAR0
293 s32 ngbe_get_mac_addr(struct ngbe_hw *hw, u8 *mac_addr)
299 wr32(hw, NGBE_ETHADDRIDX, 0);
300 rar_high = rd32(hw, NGBE_ETHADDRH);
301 rar_low = rd32(hw, NGBE_ETHADDRL);
303 for (i = 0; i < 2; i++)
304 mac_addr[i] = (u8)(rar_high >> (1 - i) * 8);
306 for (i = 0; i < 4; i++)
307 mac_addr[i + 2] = (u8)(rar_low >> (3 - i) * 8);
313 * ngbe_set_lan_id_multi_port - Set LAN id for PCIe multiple port devices
314 * @hw: pointer to the HW structure
316 * Determines the LAN function id by reading memory-mapped registers and swaps
317 * the port value if requested, and set MAC instance for devices.
319 void ngbe_set_lan_id_multi_port(struct ngbe_hw *hw)
321 struct ngbe_bus_info *bus = &hw->bus;
324 reg = rd32(hw, NGBE_PORTSTAT);
325 bus->lan_id = NGBE_PORTSTAT_ID(reg);
326 bus->func = bus->lan_id;
330 * ngbe_stop_hw - Generic stop Tx/Rx units
331 * @hw: pointer to hardware structure
333 * Sets the adapter_stopped flag within ngbe_hw struct. Clears interrupts,
334 * disables transmit and receive units. The adapter_stopped flag is used by
335 * the shared code and drivers to determine if the adapter is in a stopped
336 * state and should not touch the hardware.
338 s32 ngbe_stop_hw(struct ngbe_hw *hw)
344 * Set the adapter_stopped flag so other driver functions stop touching
347 hw->adapter_stopped = true;
349 /* Disable the receive unit */
352 /* Clear interrupt mask to stop interrupts from being generated */
353 wr32(hw, NGBE_IENMISC, 0);
354 wr32(hw, NGBE_IMS(0), NGBE_IMS_MASK);
356 /* Clear any pending interrupts, flush previous writes */
357 wr32(hw, NGBE_ICRMISC, NGBE_ICRMISC_MASK);
358 wr32(hw, NGBE_ICR(0), NGBE_ICR_MASK);
360 wr32(hw, NGBE_BMECTL, 0x3);
362 /* Disable the receive unit by stopping each queue */
363 for (i = 0; i < hw->mac.max_rx_queues; i++)
364 wr32(hw, NGBE_RXCFG(i), 0);
366 /* flush all queues disables */
371 * Prevent the PCI-E bus from hanging by disabling PCI-E master
372 * access and verify no pending requests
374 status = ngbe_set_pcie_master(hw, false);
378 /* Disable the transmit unit. Each queue must be disabled. */
379 for (i = 0; i < hw->mac.max_tx_queues; i++)
380 wr32(hw, NGBE_TXCFG(i), 0);
382 /* flush all queues disables */
390 * ngbe_led_on - Turns on the software controllable LEDs.
391 * @hw: pointer to hardware structure
392 * @index: led number to turn on
394 s32 ngbe_led_on(struct ngbe_hw *hw, u32 index)
396 u32 led_reg = rd32(hw, NGBE_LEDCTL);
399 return NGBE_ERR_PARAM;
401 /* To turn on the LED, set mode to ON. */
402 led_reg |= NGBE_LEDCTL_100M;
403 wr32(hw, NGBE_LEDCTL, led_reg);
410 * ngbe_led_off - Turns off the software controllable LEDs.
411 * @hw: pointer to hardware structure
412 * @index: led number to turn off
414 s32 ngbe_led_off(struct ngbe_hw *hw, u32 index)
416 u32 led_reg = rd32(hw, NGBE_LEDCTL);
419 return NGBE_ERR_PARAM;
421 /* To turn off the LED, set mode to OFF. */
422 led_reg &= ~NGBE_LEDCTL_100M;
423 wr32(hw, NGBE_LEDCTL, led_reg);
430 * ngbe_validate_mac_addr - Validate MAC address
431 * @mac_addr: pointer to MAC address.
433 * Tests a MAC address to ensure it is a valid Individual Address.
435 s32 ngbe_validate_mac_addr(u8 *mac_addr)
439 /* Make sure it is not a multicast address */
440 if (NGBE_IS_MULTICAST((struct rte_ether_addr *)mac_addr)) {
441 status = NGBE_ERR_INVALID_MAC_ADDR;
442 /* Not a broadcast address */
443 } else if (NGBE_IS_BROADCAST((struct rte_ether_addr *)mac_addr)) {
444 status = NGBE_ERR_INVALID_MAC_ADDR;
445 /* Reject the zero address */
446 } else if (mac_addr[0] == 0 && mac_addr[1] == 0 && mac_addr[2] == 0 &&
447 mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0) {
448 status = NGBE_ERR_INVALID_MAC_ADDR;
454 * ngbe_set_rar - Set Rx address register
455 * @hw: pointer to hardware structure
456 * @index: Receive address register to write
457 * @addr: Address to put into receive address register
458 * @vmdq: VMDq "set" or "pool" index
459 * @enable_addr: set flag that address is active
461 * Puts an ethernet address into a receive address register.
463 s32 ngbe_set_rar(struct ngbe_hw *hw, u32 index, u8 *addr, u32 vmdq,
466 u32 rar_low, rar_high;
467 u32 rar_entries = hw->mac.num_rar_entries;
469 /* Make sure we are using a valid rar index range */
470 if (index >= rar_entries) {
471 DEBUGOUT("RAR index %d is out of range.", index);
472 return NGBE_ERR_INVALID_ARGUMENT;
475 /* setup VMDq pool selection before this RAR gets enabled */
476 hw->mac.set_vmdq(hw, index, vmdq);
479 * HW expects these in little endian so we reverse the byte
480 * order from network order (big endian) to little endian
482 rar_low = NGBE_ETHADDRL_AD0(addr[5]) |
483 NGBE_ETHADDRL_AD1(addr[4]) |
484 NGBE_ETHADDRL_AD2(addr[3]) |
485 NGBE_ETHADDRL_AD3(addr[2]);
487 * Some parts put the VMDq setting in the extra RAH bits,
488 * so save everything except the lower 16 bits that hold part
489 * of the address and the address valid bit.
491 rar_high = rd32(hw, NGBE_ETHADDRH);
492 rar_high &= ~NGBE_ETHADDRH_AD_MASK;
493 rar_high |= (NGBE_ETHADDRH_AD4(addr[1]) |
494 NGBE_ETHADDRH_AD5(addr[0]));
496 rar_high &= ~NGBE_ETHADDRH_VLD;
497 if (enable_addr != 0)
498 rar_high |= NGBE_ETHADDRH_VLD;
500 wr32(hw, NGBE_ETHADDRIDX, index);
501 wr32(hw, NGBE_ETHADDRL, rar_low);
502 wr32(hw, NGBE_ETHADDRH, rar_high);
508 * ngbe_clear_rar - Remove Rx address register
509 * @hw: pointer to hardware structure
510 * @index: Receive address register to write
512 * Clears an ethernet address from a receive address register.
514 s32 ngbe_clear_rar(struct ngbe_hw *hw, u32 index)
517 u32 rar_entries = hw->mac.num_rar_entries;
519 /* Make sure we are using a valid rar index range */
520 if (index >= rar_entries) {
521 DEBUGOUT("RAR index %d is out of range.", index);
522 return NGBE_ERR_INVALID_ARGUMENT;
526 * Some parts put the VMDq setting in the extra RAH bits,
527 * so save everything except the lower 16 bits that hold part
528 * of the address and the address valid bit.
530 wr32(hw, NGBE_ETHADDRIDX, index);
531 rar_high = rd32(hw, NGBE_ETHADDRH);
532 rar_high &= ~(NGBE_ETHADDRH_AD_MASK | NGBE_ETHADDRH_VLD);
534 wr32(hw, NGBE_ETHADDRL, 0);
535 wr32(hw, NGBE_ETHADDRH, rar_high);
537 /* clear VMDq pool/queue selection for this RAR */
538 hw->mac.clear_vmdq(hw, index, BIT_MASK32);
544 * ngbe_init_rx_addrs - Initializes receive address filters.
545 * @hw: pointer to hardware structure
547 * Places the MAC address in receive address register 0 and clears the rest
548 * of the receive address registers. Clears the multicast table. Assumes
549 * the receiver is in reset when the routine is called.
551 s32 ngbe_init_rx_addrs(struct ngbe_hw *hw)
555 u32 rar_entries = hw->mac.num_rar_entries;
558 * If the current mac address is valid, assume it is a software override
559 * to the permanent address.
560 * Otherwise, use the permanent address from the eeprom.
562 if (ngbe_validate_mac_addr(hw->mac.addr) ==
563 NGBE_ERR_INVALID_MAC_ADDR) {
564 /* Get the MAC address from the RAR0 for later reference */
565 hw->mac.get_mac_addr(hw, hw->mac.addr);
567 DEBUGOUT(" Keeping Current RAR0 Addr = "
568 RTE_ETHER_ADDR_PRT_FMT,
569 hw->mac.addr[0], hw->mac.addr[1],
570 hw->mac.addr[2], hw->mac.addr[3],
571 hw->mac.addr[4], hw->mac.addr[5]);
573 /* Setup the receive address. */
574 DEBUGOUT("Overriding MAC Address in RAR[0]");
575 DEBUGOUT(" New MAC Addr = "
576 RTE_ETHER_ADDR_PRT_FMT,
577 hw->mac.addr[0], hw->mac.addr[1],
578 hw->mac.addr[2], hw->mac.addr[3],
579 hw->mac.addr[4], hw->mac.addr[5]);
581 hw->mac.set_rar(hw, 0, hw->mac.addr, 0, true);
584 /* clear VMDq pool/queue selection for RAR 0 */
585 hw->mac.clear_vmdq(hw, 0, BIT_MASK32);
587 /* Zero out the other receive addresses. */
588 DEBUGOUT("Clearing RAR[1-%d]", rar_entries - 1);
589 for (i = 1; i < rar_entries; i++) {
590 wr32(hw, NGBE_ETHADDRIDX, i);
591 wr32(hw, NGBE_ETHADDRL, 0);
592 wr32(hw, NGBE_ETHADDRH, 0);
596 hw->addr_ctrl.mta_in_use = 0;
597 psrctl = rd32(hw, NGBE_PSRCTL);
598 psrctl &= ~(NGBE_PSRCTL_ADHF12_MASK | NGBE_PSRCTL_MCHFENA);
599 psrctl |= NGBE_PSRCTL_ADHF12(hw->mac.mc_filter_type);
600 wr32(hw, NGBE_PSRCTL, psrctl);
602 DEBUGOUT(" Clearing MTA");
603 for (i = 0; i < hw->mac.mcft_size; i++)
604 wr32(hw, NGBE_MCADDRTBL(i), 0);
606 ngbe_init_uta_tables(hw);
612 * ngbe_mta_vector - Determines bit-vector in multicast table to set
613 * @hw: pointer to hardware structure
614 * @mc_addr: the multicast address
616 * Extracts the 12 bits, from a multicast address, to determine which
617 * bit-vector to set in the multicast table. The hardware uses 12 bits, from
618 * incoming rx multicast addresses, to determine the bit-vector to check in
619 * the MTA. Which of the 4 combination, of 12-bits, the hardware uses is set
620 * by the MO field of the PSRCTRL. The MO field is set during initialization
623 static s32 ngbe_mta_vector(struct ngbe_hw *hw, u8 *mc_addr)
627 switch (hw->mac.mc_filter_type) {
628 case 0: /* use bits [47:36] of the address */
629 vector = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4));
631 case 1: /* use bits [46:35] of the address */
632 vector = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5));
634 case 2: /* use bits [45:34] of the address */
635 vector = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6));
637 case 3: /* use bits [43:32] of the address */
638 vector = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8));
640 default: /* Invalid mc_filter_type */
641 DEBUGOUT("MC filter type param set incorrectly");
646 /* vector can only be 12-bits or boundary will be exceeded */
652 * ngbe_set_mta - Set bit-vector in multicast table
653 * @hw: pointer to hardware structure
654 * @mc_addr: Multicast address
656 * Sets the bit-vector in the multicast table.
658 void ngbe_set_mta(struct ngbe_hw *hw, u8 *mc_addr)
664 hw->addr_ctrl.mta_in_use++;
666 vector = ngbe_mta_vector(hw, mc_addr);
667 DEBUGOUT(" bit-vector = 0x%03X", vector);
670 * The MTA is a register array of 128 32-bit registers. It is treated
671 * like an array of 4096 bits. We want to set bit
672 * BitArray[vector_value]. So we figure out what register the bit is
673 * in, read it, OR in the new bit, then write back the new value. The
674 * register is determined by the upper 7 bits of the vector value and
675 * the bit within that register are determined by the lower 5 bits of
678 vector_reg = (vector >> 5) & 0x7F;
679 vector_bit = vector & 0x1F;
680 hw->mac.mta_shadow[vector_reg] |= (1 << vector_bit);
684 * ngbe_update_mc_addr_list - Updates MAC list of multicast addresses
685 * @hw: pointer to hardware structure
686 * @mc_addr_list: the list of new multicast addresses
687 * @mc_addr_count: number of addresses
688 * @next: iterator function to walk the multicast address list
689 * @clear: flag, when set clears the table beforehand
691 * When the clear flag is set, the given list replaces any existing list.
692 * Hashes the given addresses into the multicast table.
694 s32 ngbe_update_mc_addr_list(struct ngbe_hw *hw, u8 *mc_addr_list,
695 u32 mc_addr_count, ngbe_mc_addr_itr next,
702 * Set the new number of MC addresses that we are being requested to
705 hw->addr_ctrl.num_mc_addrs = mc_addr_count;
706 hw->addr_ctrl.mta_in_use = 0;
708 /* Clear mta_shadow */
710 DEBUGOUT(" Clearing MTA");
711 memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow));
714 /* Update mta_shadow */
715 for (i = 0; i < mc_addr_count; i++) {
716 DEBUGOUT(" Adding the multicast addresses:");
717 ngbe_set_mta(hw, next(hw, &mc_addr_list, &vmdq));
721 for (i = 0; i < hw->mac.mcft_size; i++)
722 wr32a(hw, NGBE_MCADDRTBL(0), i,
723 hw->mac.mta_shadow[i]);
725 if (hw->addr_ctrl.mta_in_use > 0) {
726 u32 psrctl = rd32(hw, NGBE_PSRCTL);
727 psrctl &= ~(NGBE_PSRCTL_ADHF12_MASK | NGBE_PSRCTL_MCHFENA);
728 psrctl |= NGBE_PSRCTL_MCHFENA |
729 NGBE_PSRCTL_ADHF12(hw->mac.mc_filter_type);
730 wr32(hw, NGBE_PSRCTL, psrctl);
733 DEBUGOUT("ngbe update mc addr list complete");
738 * ngbe_setup_fc_em - Set up flow control
739 * @hw: pointer to hardware structure
741 * Called at init time to set up flow control.
743 s32 ngbe_setup_fc_em(struct ngbe_hw *hw)
748 /* Validate the requested mode */
749 if (hw->fc.strict_ieee && hw->fc.requested_mode == ngbe_fc_rx_pause) {
750 DEBUGOUT("ngbe_fc_rx_pause not valid in strict IEEE mode");
751 err = NGBE_ERR_INVALID_LINK_SETTINGS;
756 * 1gig parts do not have a word in the EEPROM to determine the
757 * default flow control setting, so we explicitly set it to full.
759 if (hw->fc.requested_mode == ngbe_fc_default)
760 hw->fc.requested_mode = ngbe_fc_full;
763 * The possible values of fc.requested_mode are:
764 * 0: Flow control is completely disabled
765 * 1: Rx flow control is enabled (we can receive pause frames,
766 * but not send pause frames).
767 * 2: Tx flow control is enabled (we can send pause frames but
768 * we do not support receiving pause frames).
769 * 3: Both Rx and Tx flow control (symmetric) are enabled.
772 switch (hw->fc.requested_mode) {
774 /* Flow control completely disabled by software override. */
776 case ngbe_fc_tx_pause:
778 * Tx Flow control is enabled, and Rx Flow control is
779 * disabled by software override.
781 if (hw->phy.type == ngbe_phy_mvl_sfi ||
782 hw->phy.type == ngbe_phy_yt8521s_sfi)
783 reg_cu |= MVL_FANA_ASM_PAUSE;
785 reg_cu |= 0x800; /*need to merge rtl and mvl on page 0*/
787 case ngbe_fc_rx_pause:
789 * Rx Flow control is enabled and Tx Flow control is
790 * disabled by software override. Since there really
791 * isn't a way to advertise that we are capable of RX
792 * Pause ONLY, we will advertise that we support both
793 * symmetric and asymmetric Rx PAUSE, as such we fall
794 * through to the fc_full statement. Later, we will
795 * disable the adapter's ability to send PAUSE frames.
798 /* Flow control (both Rx and Tx) is enabled by SW override. */
799 if (hw->phy.type == ngbe_phy_mvl_sfi ||
800 hw->phy.type == ngbe_phy_yt8521s_sfi)
801 reg_cu |= MVL_FANA_SYM_PAUSE;
803 reg_cu |= 0xC00; /*need to merge rtl and mvl on page 0*/
806 DEBUGOUT("Flow control param set incorrectly");
807 err = NGBE_ERR_CONFIG;
811 err = hw->phy.set_pause_adv(hw, reg_cu);
818 * ngbe_fc_enable - Enable flow control
819 * @hw: pointer to hardware structure
821 * Enable flow control according to the current settings.
823 s32 ngbe_fc_enable(struct ngbe_hw *hw)
826 u32 mflcn_reg, fccfg_reg;
830 /* Validate the water mark configuration */
831 if (!hw->fc.pause_time) {
832 err = NGBE_ERR_INVALID_LINK_SETTINGS;
836 /* Low water mark of zero causes XOFF floods */
837 if ((hw->fc.current_mode & ngbe_fc_tx_pause) && hw->fc.high_water) {
838 if (!hw->fc.low_water ||
839 hw->fc.low_water >= hw->fc.high_water) {
840 DEBUGOUT("Invalid water mark configuration");
841 err = NGBE_ERR_INVALID_LINK_SETTINGS;
846 /* Negotiate the fc mode to use */
847 hw->mac.fc_autoneg(hw);
849 /* Disable any previous flow control settings */
850 mflcn_reg = rd32(hw, NGBE_RXFCCFG);
851 mflcn_reg &= ~NGBE_RXFCCFG_FC;
853 fccfg_reg = rd32(hw, NGBE_TXFCCFG);
854 fccfg_reg &= ~NGBE_TXFCCFG_FC;
856 * The possible values of fc.current_mode are:
857 * 0: Flow control is completely disabled
858 * 1: Rx flow control is enabled (we can receive pause frames,
859 * but not send pause frames).
860 * 2: Tx flow control is enabled (we can send pause frames but
861 * we do not support receiving pause frames).
862 * 3: Both Rx and Tx flow control (symmetric) are enabled.
865 switch (hw->fc.current_mode) {
868 * Flow control is disabled by software override or autoneg.
869 * The code below will actually disable it in the HW.
872 case ngbe_fc_rx_pause:
874 * Rx Flow control is enabled and Tx Flow control is
875 * disabled by software override. Since there really
876 * isn't a way to advertise that we are capable of RX
877 * Pause ONLY, we will advertise that we support both
878 * symmetric and asymmetric Rx PAUSE. Later, we will
879 * disable the adapter's ability to send PAUSE frames.
881 mflcn_reg |= NGBE_RXFCCFG_FC;
883 case ngbe_fc_tx_pause:
885 * Tx Flow control is enabled, and Rx Flow control is
886 * disabled by software override.
888 fccfg_reg |= NGBE_TXFCCFG_FC;
891 /* Flow control (both Rx and Tx) is enabled by SW override. */
892 mflcn_reg |= NGBE_RXFCCFG_FC;
893 fccfg_reg |= NGBE_TXFCCFG_FC;
896 DEBUGOUT("Flow control param set incorrectly");
897 err = NGBE_ERR_CONFIG;
901 /* Set 802.3x based flow control settings. */
902 wr32(hw, NGBE_RXFCCFG, mflcn_reg);
903 wr32(hw, NGBE_TXFCCFG, fccfg_reg);
905 /* Set up and enable Rx high/low water mark thresholds, enable XON. */
906 if ((hw->fc.current_mode & ngbe_fc_tx_pause) &&
908 fcrtl = NGBE_FCWTRLO_TH(hw->fc.low_water) |
910 fcrth = NGBE_FCWTRHI_TH(hw->fc.high_water) |
914 * In order to prevent Tx hangs when the internal Tx
915 * switch is enabled we must set the high water mark
916 * to the Rx packet buffer size - 24KB. This allows
917 * the Tx switch to function even under heavy Rx
921 fcrth = rd32(hw, NGBE_PBRXSIZE) - 24576;
923 wr32(hw, NGBE_FCWTRLO, fcrtl);
924 wr32(hw, NGBE_FCWTRHI, fcrth);
926 /* Configure pause time */
927 pause_time = NGBE_RXFCFSH_TIME(hw->fc.pause_time);
928 wr32(hw, NGBE_FCXOFFTM, pause_time * 0x00010000);
930 /* Configure flow control refresh threshold value */
931 wr32(hw, NGBE_RXFCRFSH, hw->fc.pause_time / 2);
938 * ngbe_negotiate_fc - Negotiate flow control
939 * @hw: pointer to hardware structure
940 * @adv_reg: flow control advertised settings
941 * @lp_reg: link partner's flow control settings
942 * @adv_sym: symmetric pause bit in advertisement
943 * @adv_asm: asymmetric pause bit in advertisement
944 * @lp_sym: symmetric pause bit in link partner advertisement
945 * @lp_asm: asymmetric pause bit in link partner advertisement
947 * Find the intersection between advertised settings and link partner's
948 * advertised settings
950 s32 ngbe_negotiate_fc(struct ngbe_hw *hw, u32 adv_reg, u32 lp_reg,
951 u32 adv_sym, u32 adv_asm, u32 lp_sym, u32 lp_asm)
953 if ((!(adv_reg)) || (!(lp_reg))) {
954 DEBUGOUT("Local or link partner's advertised flow control settings are NULL. Local: %x, link partner: %x",
956 return NGBE_ERR_FC_NOT_NEGOTIATED;
959 if ((adv_reg & adv_sym) && (lp_reg & lp_sym)) {
961 * Now we need to check if the user selected Rx ONLY
962 * of pause frames. In this case, we had to advertise
963 * FULL flow control because we could not advertise RX
964 * ONLY. Hence, we must now check to see if we need to
965 * turn OFF the TRANSMISSION of PAUSE frames.
967 if (hw->fc.requested_mode == ngbe_fc_full) {
968 hw->fc.current_mode = ngbe_fc_full;
969 DEBUGOUT("Flow Control = FULL.");
971 hw->fc.current_mode = ngbe_fc_rx_pause;
972 DEBUGOUT("Flow Control=RX PAUSE frames only");
974 } else if (!(adv_reg & adv_sym) && (adv_reg & adv_asm) &&
975 (lp_reg & lp_sym) && (lp_reg & lp_asm)) {
976 hw->fc.current_mode = ngbe_fc_tx_pause;
977 DEBUGOUT("Flow Control = TX PAUSE frames only.");
978 } else if ((adv_reg & adv_sym) && (adv_reg & adv_asm) &&
979 !(lp_reg & lp_sym) && (lp_reg & lp_asm)) {
980 hw->fc.current_mode = ngbe_fc_rx_pause;
981 DEBUGOUT("Flow Control = RX PAUSE frames only.");
983 hw->fc.current_mode = ngbe_fc_none;
984 DEBUGOUT("Flow Control = NONE.");
990 * ngbe_fc_autoneg_em - Enable flow control IEEE clause 37
991 * @hw: pointer to hardware structure
993 * Enable flow control according to IEEE clause 37.
995 STATIC s32 ngbe_fc_autoneg_em(struct ngbe_hw *hw)
997 u8 technology_ability_reg = 0;
998 u8 lp_technology_ability_reg = 0;
1000 hw->phy.get_adv_pause(hw, &technology_ability_reg);
1001 hw->phy.get_lp_adv_pause(hw, &lp_technology_ability_reg);
1003 return ngbe_negotiate_fc(hw, (u32)technology_ability_reg,
1004 (u32)lp_technology_ability_reg,
1005 NGBE_TAF_SYM_PAUSE, NGBE_TAF_ASM_PAUSE,
1006 NGBE_TAF_SYM_PAUSE, NGBE_TAF_ASM_PAUSE);
1010 * ngbe_fc_autoneg - Configure flow control
1011 * @hw: pointer to hardware structure
1013 * Compares our advertised flow control capabilities to those advertised by
1014 * our link partner, and determines the proper flow control mode to use.
1016 void ngbe_fc_autoneg(struct ngbe_hw *hw)
1018 s32 err = NGBE_ERR_FC_NOT_NEGOTIATED;
1023 * AN should have completed when the cable was plugged in.
1024 * Look for reasons to bail out. Bail out if:
1025 * - FC autoneg is disabled, or if
1028 if (hw->fc.disable_fc_autoneg) {
1029 DEBUGOUT("Flow control autoneg is disabled");
1033 hw->mac.check_link(hw, &speed, &link_up, false);
1035 DEBUGOUT("The link is down");
1039 err = ngbe_fc_autoneg_em(hw);
1043 hw->fc.fc_was_autonegged = true;
1045 hw->fc.fc_was_autonegged = false;
1046 hw->fc.current_mode = hw->fc.requested_mode;
1051 * ngbe_set_pcie_master - Disable or Enable PCI-express master access
1052 * @hw: pointer to hardware structure
1054 * Disables PCI-Express master access and verifies there are no pending
1055 * requests. NGBE_ERR_MASTER_REQUESTS_PENDING is returned if master disable
1056 * bit hasn't caused the master requests to be disabled, else 0
1057 * is returned signifying master requests disabled.
1059 s32 ngbe_set_pcie_master(struct ngbe_hw *hw, bool enable)
1065 ngbe_hic_pcie_read(hw, addr, &data, 4);
1071 ngbe_hic_pcie_write(hw, addr, &data, 4);
1076 /* Exit if master requests are blocked */
1077 if (!(rd32(hw, NGBE_BMEPEND)) ||
1078 NGBE_REMOVED(hw->hw_addr))
1081 /* Poll for master request bit to clear */
1082 for (i = 0; i < NGBE_PCI_MASTER_DISABLE_TIMEOUT; i++) {
1084 if (!(rd32(hw, NGBE_BMEPEND)))
1088 DEBUGOUT("PCIe transaction pending bit also did not clear.");
1089 status = NGBE_ERR_MASTER_REQUESTS_PENDING;
1096 * ngbe_acquire_swfw_sync - Acquire SWFW semaphore
1097 * @hw: pointer to hardware structure
1098 * @mask: Mask to specify which semaphore to acquire
1100 * Acquires the SWFW semaphore through the MNGSEM register for the specified
1101 * function (CSR, PHY0, PHY1, EEPROM, Flash)
1103 s32 ngbe_acquire_swfw_sync(struct ngbe_hw *hw, u32 mask)
1107 u32 swmask = NGBE_MNGSEM_SW(mask);
1108 u32 fwmask = NGBE_MNGSEM_FW(mask);
1112 for (i = 0; i < timeout; i++) {
1114 * SW NVM semaphore bit is used for access to all
1115 * SW_FW_SYNC bits (not just NVM)
1117 if (ngbe_get_eeprom_semaphore(hw))
1118 return NGBE_ERR_SWFW_SYNC;
1120 mngsem = rd32(hw, NGBE_MNGSEM);
1121 if (mngsem & (fwmask | swmask)) {
1122 /* Resource is currently in use by FW or SW */
1123 ngbe_release_eeprom_semaphore(hw);
1127 wr32(hw, NGBE_MNGSEM, mngsem);
1128 ngbe_release_eeprom_semaphore(hw);
1133 fwsm = rd32(hw, NGBE_MNGFWSYNC);
1134 DEBUGOUT("SWFW semaphore not granted: MNG_SWFW_SYNC = 0x%x, MNG_FW_SM = 0x%x",
1138 return NGBE_ERR_SWFW_SYNC;
1142 * ngbe_release_swfw_sync - Release SWFW semaphore
1143 * @hw: pointer to hardware structure
1144 * @mask: Mask to specify which semaphore to release
1146 * Releases the SWFW semaphore through the MNGSEM register for the specified
1147 * function (CSR, PHY0, PHY1, EEPROM, Flash)
1149 void ngbe_release_swfw_sync(struct ngbe_hw *hw, u32 mask)
1154 ngbe_get_eeprom_semaphore(hw);
1156 mngsem = rd32(hw, NGBE_MNGSEM);
1158 wr32(hw, NGBE_MNGSEM, mngsem);
1160 ngbe_release_eeprom_semaphore(hw);
1164 * ngbe_disable_sec_rx_path - Stops the receive data path
1165 * @hw: pointer to hardware structure
1167 * Stops the receive data path and waits for the HW to internally empty
1168 * the Rx security block
1170 s32 ngbe_disable_sec_rx_path(struct ngbe_hw *hw)
1172 #define NGBE_MAX_SECRX_POLL 4000
1177 secrxreg = rd32(hw, NGBE_SECRXCTL);
1178 secrxreg |= NGBE_SECRXCTL_XDSA;
1179 wr32(hw, NGBE_SECRXCTL, secrxreg);
1180 for (i = 0; i < NGBE_MAX_SECRX_POLL; i++) {
1181 secrxreg = rd32(hw, NGBE_SECRXSTAT);
1182 if (!(secrxreg & NGBE_SECRXSTAT_RDY))
1183 /* Use interrupt-safe sleep just in case */
1189 /* For informational purposes only */
1190 if (i >= NGBE_MAX_SECRX_POLL)
1191 DEBUGOUT("Rx unit being enabled before security path fully disabled. Continuing with init.");
1197 * ngbe_enable_sec_rx_path - Enables the receive data path
1198 * @hw: pointer to hardware structure
1200 * Enables the receive data path.
1202 s32 ngbe_enable_sec_rx_path(struct ngbe_hw *hw)
1206 secrxreg = rd32(hw, NGBE_SECRXCTL);
1207 secrxreg &= ~NGBE_SECRXCTL_XDSA;
1208 wr32(hw, NGBE_SECRXCTL, secrxreg);
1215 * ngbe_clear_vmdq - Disassociate a VMDq pool index from a rx address
1216 * @hw: pointer to hardware struct
1217 * @rar: receive address register index to disassociate
1218 * @vmdq: VMDq pool index to remove from the rar
1220 s32 ngbe_clear_vmdq(struct ngbe_hw *hw, u32 rar, u32 vmdq)
1223 u32 rar_entries = hw->mac.num_rar_entries;
1225 /* Make sure we are using a valid rar index range */
1226 if (rar >= rar_entries) {
1227 DEBUGOUT("RAR index %d is out of range.", rar);
1228 return NGBE_ERR_INVALID_ARGUMENT;
1231 wr32(hw, NGBE_ETHADDRIDX, rar);
1232 mpsar = rd32(hw, NGBE_ETHADDRASS);
1234 if (NGBE_REMOVED(hw->hw_addr))
1240 mpsar &= ~(1 << vmdq);
1241 wr32(hw, NGBE_ETHADDRASS, mpsar);
1243 /* was that the last pool using this rar? */
1244 if (mpsar == 0 && rar != 0)
1245 hw->mac.clear_rar(hw, rar);
1251 * ngbe_set_vmdq - Associate a VMDq pool index with a rx address
1252 * @hw: pointer to hardware struct
1253 * @rar: receive address register index to associate with a VMDq index
1254 * @vmdq: VMDq pool index
1256 s32 ngbe_set_vmdq(struct ngbe_hw *hw, u32 rar, u32 vmdq)
1259 u32 rar_entries = hw->mac.num_rar_entries;
1261 /* Make sure we are using a valid rar index range */
1262 if (rar >= rar_entries) {
1263 DEBUGOUT("RAR index %d is out of range.", rar);
1264 return NGBE_ERR_INVALID_ARGUMENT;
1267 wr32(hw, NGBE_ETHADDRIDX, rar);
1269 mpsar = rd32(hw, NGBE_ETHADDRASS);
1271 wr32(hw, NGBE_ETHADDRASS, mpsar);
1277 * ngbe_init_uta_tables - Initialize the Unicast Table Array
1278 * @hw: pointer to hardware structure
1280 s32 ngbe_init_uta_tables(struct ngbe_hw *hw)
1284 DEBUGOUT(" Clearing UTA");
1286 for (i = 0; i < 128; i++)
1287 wr32(hw, NGBE_UCADDRTBL(i), 0);
1293 * ngbe_find_vlvf_slot - find the vlanid or the first empty slot
1294 * @hw: pointer to hardware structure
1295 * @vlan: VLAN id to write to VLAN filter
1296 * @vlvf_bypass: true to find vlanid only, false returns first empty slot if
1300 * return the VLVF index where this VLAN id should be placed
1303 s32 ngbe_find_vlvf_slot(struct ngbe_hw *hw, u32 vlan, bool vlvf_bypass)
1305 s32 regindex, first_empty_slot;
1308 /* short cut the special case */
1312 /* if vlvf_bypass is set we don't want to use an empty slot, we
1313 * will simply bypass the VLVF if there are no entries present in the
1314 * VLVF that contain our VLAN
1316 first_empty_slot = vlvf_bypass ? NGBE_ERR_NO_SPACE : 0;
1318 /* add VLAN enable bit for comparison */
1319 vlan |= NGBE_PSRVLAN_EA;
1321 /* Search for the vlan id in the VLVF entries. Save off the first empty
1322 * slot found along the way.
1324 * pre-decrement loop covering (NGBE_NUM_POOL - 1) .. 1
1326 for (regindex = NGBE_NUM_POOL; --regindex;) {
1327 wr32(hw, NGBE_PSRVLANIDX, regindex);
1328 bits = rd32(hw, NGBE_PSRVLAN);
1331 if (!first_empty_slot && !bits)
1332 first_empty_slot = regindex;
1335 /* If we are here then we didn't find the VLAN. Return first empty
1336 * slot we found during our search, else error.
1338 if (!first_empty_slot)
1339 DEBUGOUT("No space in VLVF.");
1341 return first_empty_slot ? first_empty_slot : NGBE_ERR_NO_SPACE;
1345 * ngbe_set_vfta - Set VLAN filter table
1346 * @hw: pointer to hardware structure
1347 * @vlan: VLAN id to write to VLAN filter
1348 * @vind: VMDq output index that maps queue to VLAN id in VLVFB
1349 * @vlan_on: boolean flag to turn on/off VLAN
1350 * @vlvf_bypass: boolean flag indicating updating default pool is okay
1352 * Turn on/off specified VLAN in the VLAN filter table.
1354 s32 ngbe_set_vfta(struct ngbe_hw *hw, u32 vlan, u32 vind,
1355 bool vlan_on, bool vlvf_bypass)
1357 u32 regidx, vfta_delta, vfta;
1360 if (vlan > 4095 || vind > 63)
1361 return NGBE_ERR_PARAM;
1364 * this is a 2 part operation - first the VFTA, then the
1365 * VLVF and VLVFB if VT Mode is set
1366 * We don't write the VFTA until we know the VLVF part succeeded.
1370 * The VFTA is a bitstring made up of 128 32-bit registers
1371 * that enable the particular VLAN id, much like the MTA:
1372 * bits[11-5]: which register
1373 * bits[4-0]: which bit in the register
1376 vfta_delta = 1 << (vlan % 32);
1377 vfta = rd32(hw, NGBE_VLANTBL(regidx));
1380 * vfta_delta represents the difference between the current value
1381 * of vfta and the value we want in the register. Since the diff
1382 * is an XOR mask we can just update the vfta using an XOR
1384 vfta_delta &= vlan_on ? ~vfta : vfta;
1388 * Call ngbe_set_vlvf to set VLVFB and VLVF
1390 err = ngbe_set_vlvf(hw, vlan, vind, vlan_on, &vfta_delta,
1399 /* Update VFTA now that we are ready for traffic */
1401 wr32(hw, NGBE_VLANTBL(regidx), vfta);
1407 * ngbe_set_vlvf - Set VLAN Pool Filter
1408 * @hw: pointer to hardware structure
1409 * @vlan: VLAN id to write to VLAN filter
1410 * @vind: VMDq output index that maps queue to VLAN id in PSRVLANPLM
1411 * @vlan_on: boolean flag to turn on/off VLAN in PSRVLAN
1412 * @vfta_delta: pointer to the difference between the current value
1413 * of PSRVLANPLM and the desired value
1414 * @vfta: the desired value of the VFTA
1415 * @vlvf_bypass: boolean flag indicating updating default pool is okay
1417 * Turn on/off specified bit in VLVF table.
1419 s32 ngbe_set_vlvf(struct ngbe_hw *hw, u32 vlan, u32 vind,
1420 bool vlan_on, u32 *vfta_delta, u32 vfta,
1427 if (vlan > 4095 || vind > 63)
1428 return NGBE_ERR_PARAM;
1430 /* If VT Mode is set
1432 * make sure the vlan is in PSRVLAN
1433 * set the vind bit in the matching PSRVLANPLM
1435 * clear the pool bit and possibly the vind
1437 portctl = rd32(hw, NGBE_PORTCTL);
1438 if (!(portctl & NGBE_PORTCTL_NUMVT_MASK))
1441 vlvf_index = ngbe_find_vlvf_slot(hw, vlan, vlvf_bypass);
1445 wr32(hw, NGBE_PSRVLANIDX, vlvf_index);
1446 bits = rd32(hw, NGBE_PSRVLANPLM(vind / 32));
1448 /* set the pool bit */
1449 bits |= 1 << (vind % 32);
1453 /* clear the pool bit */
1454 bits ^= 1 << (vind % 32);
1457 !rd32(hw, NGBE_PSRVLANPLM(vind / 32))) {
1458 /* Clear PSRVLANPLM first, then disable PSRVLAN. Otherwise
1459 * we run the risk of stray packets leaking into
1460 * the PF via the default pool
1463 wr32(hw, NGBE_PSRVLANPLM(vlan / 32), vfta);
1465 /* disable VLVF and clear remaining bit from pool */
1466 wr32(hw, NGBE_PSRVLAN, 0);
1467 wr32(hw, NGBE_PSRVLANPLM(vind / 32), 0);
1472 /* If there are still bits set in the PSRVLANPLM registers
1473 * for the VLAN ID indicated we need to see if the
1474 * caller is requesting that we clear the PSRVLANPLM entry bit.
1475 * If the caller has requested that we clear the PSRVLANPLM
1476 * entry bit but there are still pools/VFs using this VLAN
1477 * ID entry then ignore the request. We're not worried
1478 * about the case where we're turning the PSRVLANPLM VLAN ID
1479 * entry bit on, only when requested to turn it off as
1480 * there may be multiple pools and/or VFs using the
1481 * VLAN ID entry. In that case we cannot clear the
1482 * PSRVLANPLM bit until all pools/VFs using that VLAN ID have also
1483 * been cleared. This will be indicated by "bits" being
1489 /* record pool change and enable VLAN ID if not already enabled */
1490 wr32(hw, NGBE_PSRVLANPLM(vind / 32), bits);
1491 wr32(hw, NGBE_PSRVLAN, NGBE_PSRVLAN_EA | vlan);
1497 * ngbe_clear_vfta - Clear VLAN filter table
1498 * @hw: pointer to hardware structure
1500 * Clears the VLAN filer table, and the VMDq index associated with the filter
1502 s32 ngbe_clear_vfta(struct ngbe_hw *hw)
1506 for (offset = 0; offset < hw->mac.vft_size; offset++)
1507 wr32(hw, NGBE_VLANTBL(offset), 0);
1509 for (offset = 0; offset < NGBE_NUM_POOL; offset++) {
1510 wr32(hw, NGBE_PSRVLANIDX, offset);
1511 wr32(hw, NGBE_PSRVLAN, 0);
1512 wr32(hw, NGBE_PSRVLANPLM(0), 0);
1519 * ngbe_check_mac_link_em - Determine link and speed status
1520 * @hw: pointer to hardware structure
1521 * @speed: pointer to link speed
1522 * @link_up: true when link is up
1523 * @link_up_wait_to_complete: bool used to wait for link up or not
1525 * Reads the links register to determine if link is up and the current speed
1527 s32 ngbe_check_mac_link_em(struct ngbe_hw *hw, u32 *speed,
1528 bool *link_up, bool link_up_wait_to_complete)
1533 reg = rd32(hw, NGBE_GPIOINTSTAT);
1534 wr32(hw, NGBE_GPIOEOI, reg);
1536 if (link_up_wait_to_complete) {
1537 for (i = 0; i < hw->mac.max_link_up_time; i++) {
1538 status = hw->phy.check_link(hw, speed, link_up);
1544 status = hw->phy.check_link(hw, speed, link_up);
1550 s32 ngbe_get_link_capabilities_em(struct ngbe_hw *hw,
1557 hw->mac.autoneg = *autoneg;
1559 if (hw->phy.type == ngbe_phy_rtl) {
1560 *speed = NGBE_LINK_SPEED_1GB_FULL |
1561 NGBE_LINK_SPEED_100M_FULL |
1562 NGBE_LINK_SPEED_10M_FULL;
1565 if (hw->phy.type == ngbe_phy_yt8521s_sfi) {
1566 ngbe_read_phy_reg_ext_yt(hw, YT_CHIP, 0, &value);
1567 if ((value & YT_CHIP_MODE_MASK) == YT_CHIP_MODE_SEL(1))
1568 *speed = NGBE_LINK_SPEED_1GB_FULL;
1574 s32 ngbe_setup_mac_link_em(struct ngbe_hw *hw,
1576 bool autoneg_wait_to_complete)
1580 /* Setup the PHY according to input speed */
1581 status = hw->phy.setup_link(hw, speed, autoneg_wait_to_complete);
1587 * ngbe_set_mac_anti_spoofing - Enable/Disable MAC anti-spoofing
1588 * @hw: pointer to hardware structure
1589 * @enable: enable or disable switch for MAC anti-spoofing
1590 * @vf: Virtual Function pool - VF Pool to set for MAC anti-spoofing
1593 void ngbe_set_mac_anti_spoofing(struct ngbe_hw *hw, bool enable, int vf)
1597 pfvfspoof = rd32(hw, NGBE_POOLTXASMAC);
1599 pfvfspoof |= (1 << vf);
1601 pfvfspoof &= ~(1 << vf);
1602 wr32(hw, NGBE_POOLTXASMAC, pfvfspoof);
1606 * ngbe_set_pba - Initialize Rx packet buffer
1607 * @hw: pointer to hardware structure
1608 * @headroom: reserve n KB of headroom
1610 void ngbe_set_pba(struct ngbe_hw *hw)
1612 u32 rxpktsize = hw->mac.rx_pb_size;
1613 u32 txpktsize, txpbthresh;
1615 /* Reserve 256 KB of headroom */
1619 wr32(hw, NGBE_PBRXSIZE, rxpktsize);
1621 /* Only support an equally distributed Tx packet buffer strategy. */
1622 txpktsize = NGBE_PBTXSIZE_MAX;
1623 txpbthresh = (txpktsize / 1024) - NGBE_TXPKT_SIZE_MAX;
1625 wr32(hw, NGBE_PBTXSIZE, txpktsize);
1626 wr32(hw, NGBE_PBTXDMATH, txpbthresh);
1630 * ngbe_set_vlan_anti_spoofing - Enable/Disable VLAN anti-spoofing
1631 * @hw: pointer to hardware structure
1632 * @enable: enable or disable switch for VLAN anti-spoofing
1633 * @vf: Virtual Function pool - VF Pool to set for VLAN anti-spoofing
1636 void ngbe_set_vlan_anti_spoofing(struct ngbe_hw *hw, bool enable, int vf)
1640 pfvfspoof = rd32(hw, NGBE_POOLTXASVLAN);
1642 pfvfspoof |= (1 << vf);
1644 pfvfspoof &= ~(1 << vf);
1645 wr32(hw, NGBE_POOLTXASVLAN, pfvfspoof);
1649 * ngbe_init_thermal_sensor_thresh - Inits thermal sensor thresholds
1650 * @hw: pointer to hardware structure
1652 * Inits the thermal sensor thresholds according to the NVM map
1653 * and save off the threshold and location values into mac.thermal_sensor_data
1655 s32 ngbe_init_thermal_sensor_thresh(struct ngbe_hw *hw)
1657 struct ngbe_thermal_sensor_data *data = &hw->mac.thermal_sensor_data;
1659 memset(data, 0, sizeof(struct ngbe_thermal_sensor_data));
1661 if (hw->bus.lan_id != 0)
1662 return NGBE_NOT_IMPLEMENTED;
1664 wr32(hw, NGBE_TSINTR,
1665 NGBE_TSINTR_AEN | NGBE_TSINTR_DEN);
1666 wr32(hw, NGBE_TSEN, NGBE_TSEN_ENA);
1669 data->sensor[0].alarm_thresh = 115;
1670 wr32(hw, NGBE_TSATHRE, 0x344);
1671 data->sensor[0].dalarm_thresh = 110;
1672 wr32(hw, NGBE_TSDTHRE, 0x330);
1677 s32 ngbe_mac_check_overtemp(struct ngbe_hw *hw)
1682 /* Check that the LASI temp alarm status was triggered */
1683 ts_state = rd32(hw, NGBE_TSALM);
1685 if (ts_state & NGBE_TSALM_HI)
1686 status = NGBE_ERR_UNDERTEMP;
1687 else if (ts_state & NGBE_TSALM_LO)
1688 status = NGBE_ERR_OVERTEMP;
1693 void ngbe_disable_rx(struct ngbe_hw *hw)
1697 pfdtxgswc = rd32(hw, NGBE_PSRCTL);
1698 if (pfdtxgswc & NGBE_PSRCTL_LBENA) {
1699 pfdtxgswc &= ~NGBE_PSRCTL_LBENA;
1700 wr32(hw, NGBE_PSRCTL, pfdtxgswc);
1701 hw->mac.set_lben = true;
1703 hw->mac.set_lben = false;
1706 wr32m(hw, NGBE_PBRXCTL, NGBE_PBRXCTL_ENA, 0);
1707 wr32m(hw, NGBE_MACRXCFG, NGBE_MACRXCFG_ENA, 0);
1710 void ngbe_enable_rx(struct ngbe_hw *hw)
1714 wr32m(hw, NGBE_MACRXCFG, NGBE_MACRXCFG_ENA, NGBE_MACRXCFG_ENA);
1715 wr32m(hw, NGBE_PBRXCTL, NGBE_PBRXCTL_ENA, NGBE_PBRXCTL_ENA);
1717 if (hw->mac.set_lben) {
1718 pfdtxgswc = rd32(hw, NGBE_PSRCTL);
1719 pfdtxgswc |= NGBE_PSRCTL_LBENA;
1720 wr32(hw, NGBE_PSRCTL, pfdtxgswc);
1721 hw->mac.set_lben = false;
1726 * ngbe_set_mac_type - Sets MAC type
1727 * @hw: pointer to the HW structure
1729 * This function sets the mac type of the adapter based on the
1730 * vendor ID and device ID stored in the hw structure.
1732 s32 ngbe_set_mac_type(struct ngbe_hw *hw)
1736 if (hw->vendor_id != PCI_VENDOR_ID_WANGXUN) {
1737 DEBUGOUT("Unsupported vendor id: %x", hw->vendor_id);
1738 return NGBE_ERR_DEVICE_NOT_SUPPORTED;
1741 switch (hw->sub_device_id) {
1742 case NGBE_SUB_DEV_ID_EM_RTL_SGMII:
1743 case NGBE_SUB_DEV_ID_EM_MVL_RGMII:
1744 hw->phy.media_type = ngbe_media_type_copper;
1745 hw->mac.type = ngbe_mac_em;
1746 hw->mac.link_type = ngbe_link_copper;
1748 case NGBE_SUB_DEV_ID_EM_RTL_YT8521S_SFP:
1749 hw->phy.media_type = ngbe_media_type_copper;
1750 hw->mac.type = ngbe_mac_em;
1751 hw->mac.link_type = ngbe_link_fiber;
1753 case NGBE_SUB_DEV_ID_EM_MVL_SFP:
1754 case NGBE_SUB_DEV_ID_EM_YT8521S_SFP:
1755 hw->phy.media_type = ngbe_media_type_fiber;
1756 hw->mac.type = ngbe_mac_em;
1757 hw->mac.link_type = ngbe_link_fiber;
1759 case NGBE_SUB_DEV_ID_EM_MVL_MIX:
1760 hw->phy.media_type = ngbe_media_type_unknown;
1761 hw->mac.type = ngbe_mac_em;
1762 hw->mac.link_type = ngbe_link_type_unknown;
1764 case NGBE_SUB_DEV_ID_EM_VF:
1765 hw->phy.media_type = ngbe_media_type_virtual;
1766 hw->mac.type = ngbe_mac_em_vf;
1769 err = NGBE_ERR_DEVICE_NOT_SUPPORTED;
1770 hw->phy.media_type = ngbe_media_type_unknown;
1771 hw->mac.type = ngbe_mac_unknown;
1772 DEBUGOUT("Unsupported device id: %x", hw->device_id);
1776 DEBUGOUT("found mac: %d media: %d, returns: %d",
1777 hw->mac.type, hw->phy.media_type, err);
1782 * ngbe_enable_rx_dma - Enable the Rx DMA unit
1783 * @hw: pointer to hardware structure
1784 * @regval: register value to write to RXCTRL
1786 * Enables the Rx DMA unit
1788 s32 ngbe_enable_rx_dma(struct ngbe_hw *hw, u32 regval)
1791 * Workaround silicon errata when enabling the Rx datapath.
1792 * If traffic is incoming before we enable the Rx unit, it could hang
1793 * the Rx DMA unit. Therefore, make sure the security engine is
1794 * completely disabled prior to enabling the Rx unit.
1796 hw->mac.disable_sec_rx_path(hw);
1798 if (regval & NGBE_PBRXCTL_ENA)
1801 ngbe_disable_rx(hw);
1803 hw->mac.enable_sec_rx_path(hw);
1808 void ngbe_map_device_id(struct ngbe_hw *hw)
1810 u16 oem = hw->sub_system_id & NGBE_OEM_MASK;
1814 /* move subsystem_device_id to device_id */
1815 switch (hw->device_id) {
1816 case NGBE_DEV_ID_EM_WX1860AL_W_VF:
1817 case NGBE_DEV_ID_EM_WX1860A2_VF:
1818 case NGBE_DEV_ID_EM_WX1860A2S_VF:
1819 case NGBE_DEV_ID_EM_WX1860A4_VF:
1820 case NGBE_DEV_ID_EM_WX1860A4S_VF:
1821 case NGBE_DEV_ID_EM_WX1860AL2_VF:
1822 case NGBE_DEV_ID_EM_WX1860AL2S_VF:
1823 case NGBE_DEV_ID_EM_WX1860AL4_VF:
1824 case NGBE_DEV_ID_EM_WX1860AL4S_VF:
1825 case NGBE_DEV_ID_EM_WX1860NCSI_VF:
1826 case NGBE_DEV_ID_EM_WX1860A1_VF:
1827 case NGBE_DEV_ID_EM_WX1860A1L_VF:
1828 hw->device_id = NGBE_DEV_ID_EM_VF;
1829 hw->sub_device_id = NGBE_SUB_DEV_ID_EM_VF;
1832 case NGBE_DEV_ID_EM_WX1860AL_W:
1833 case NGBE_DEV_ID_EM_WX1860A2:
1834 case NGBE_DEV_ID_EM_WX1860A2S:
1835 case NGBE_DEV_ID_EM_WX1860A4:
1836 case NGBE_DEV_ID_EM_WX1860A4S:
1837 case NGBE_DEV_ID_EM_WX1860AL2:
1838 case NGBE_DEV_ID_EM_WX1860AL2S:
1839 case NGBE_DEV_ID_EM_WX1860AL4:
1840 case NGBE_DEV_ID_EM_WX1860AL4S:
1841 case NGBE_DEV_ID_EM_WX1860NCSI:
1842 case NGBE_DEV_ID_EM_WX1860A1:
1843 case NGBE_DEV_ID_EM_WX1860A1L:
1844 hw->device_id = NGBE_DEV_ID_EM;
1845 if (oem == NGBE_M88E1512_SFP || oem == NGBE_LY_M88E1512_SFP)
1846 hw->sub_device_id = NGBE_SUB_DEV_ID_EM_MVL_SFP;
1847 else if (oem == NGBE_M88E1512_RJ45 ||
1848 (hw->sub_system_id == NGBE_SUB_DEV_ID_EM_M88E1512_RJ45))
1849 hw->sub_device_id = NGBE_SUB_DEV_ID_EM_MVL_RGMII;
1850 else if (oem == NGBE_M88E1512_MIX)
1851 hw->sub_device_id = NGBE_SUB_DEV_ID_EM_MVL_MIX;
1852 else if (oem == NGBE_YT8521S_SFP ||
1853 oem == NGBE_YT8521S_SFP_GPIO ||
1854 oem == NGBE_LY_YT8521S_SFP)
1855 hw->sub_device_id = NGBE_SUB_DEV_ID_EM_YT8521S_SFP;
1856 else if (oem == NGBE_INTERNAL_YT8521S_SFP ||
1857 oem == NGBE_INTERNAL_YT8521S_SFP_GPIO)
1858 hw->sub_device_id = NGBE_SUB_DEV_ID_EM_RTL_YT8521S_SFP;
1860 hw->sub_device_id = NGBE_SUB_DEV_ID_EM_RTL_SGMII;
1866 if (oem == NGBE_LY_M88E1512_SFP || oem == NGBE_YT8521S_SFP_GPIO ||
1867 oem == NGBE_INTERNAL_YT8521S_SFP_GPIO ||
1868 oem == NGBE_LY_YT8521S_SFP)
1869 hw->gpio_ctl = true;
1873 * ngbe_init_ops_pf - Inits func ptrs and MAC type
1874 * @hw: pointer to hardware structure
1876 * Initialize the function pointers and assign the MAC type.
1877 * Does not touch the hardware.
1879 s32 ngbe_init_ops_pf(struct ngbe_hw *hw)
1881 struct ngbe_bus_info *bus = &hw->bus;
1882 struct ngbe_mac_info *mac = &hw->mac;
1883 struct ngbe_phy_info *phy = &hw->phy;
1884 struct ngbe_rom_info *rom = &hw->rom;
1885 struct ngbe_mbx_info *mbx = &hw->mbx;
1888 bus->set_lan_id = ngbe_set_lan_id_multi_port;
1891 phy->identify = ngbe_identify_phy;
1892 phy->read_reg = ngbe_read_phy_reg;
1893 phy->write_reg = ngbe_write_phy_reg;
1894 phy->read_reg_unlocked = ngbe_read_phy_reg_mdi;
1895 phy->write_reg_unlocked = ngbe_write_phy_reg_mdi;
1896 phy->reset_hw = ngbe_reset_phy;
1897 phy->led_oem_chk = ngbe_phy_led_oem_chk;
1900 mac->init_hw = ngbe_init_hw;
1901 mac->reset_hw = ngbe_reset_hw_em;
1902 mac->start_hw = ngbe_start_hw;
1903 mac->clear_hw_cntrs = ngbe_clear_hw_cntrs;
1904 mac->enable_rx_dma = ngbe_enable_rx_dma;
1905 mac->get_mac_addr = ngbe_get_mac_addr;
1906 mac->stop_hw = ngbe_stop_hw;
1907 mac->acquire_swfw_sync = ngbe_acquire_swfw_sync;
1908 mac->release_swfw_sync = ngbe_release_swfw_sync;
1910 mac->disable_sec_rx_path = ngbe_disable_sec_rx_path;
1911 mac->enable_sec_rx_path = ngbe_enable_sec_rx_path;
1914 mac->led_on = ngbe_led_on;
1915 mac->led_off = ngbe_led_off;
1917 /* RAR, VLAN, Multicast */
1918 mac->set_rar = ngbe_set_rar;
1919 mac->clear_rar = ngbe_clear_rar;
1920 mac->init_rx_addrs = ngbe_init_rx_addrs;
1921 mac->update_mc_addr_list = ngbe_update_mc_addr_list;
1922 mac->set_vmdq = ngbe_set_vmdq;
1923 mac->clear_vmdq = ngbe_clear_vmdq;
1924 mac->set_vfta = ngbe_set_vfta;
1925 mac->set_vlvf = ngbe_set_vlvf;
1926 mac->clear_vfta = ngbe_clear_vfta;
1927 mac->set_mac_anti_spoofing = ngbe_set_mac_anti_spoofing;
1928 mac->set_vlan_anti_spoofing = ngbe_set_vlan_anti_spoofing;
1931 mac->fc_enable = ngbe_fc_enable;
1932 mac->fc_autoneg = ngbe_fc_autoneg;
1933 mac->setup_fc = ngbe_setup_fc_em;
1936 mac->get_link_capabilities = ngbe_get_link_capabilities_em;
1937 mac->check_link = ngbe_check_mac_link_em;
1938 mac->setup_link = ngbe_setup_mac_link_em;
1940 mac->setup_pba = ngbe_set_pba;
1942 /* Manageability interface */
1943 mac->init_thermal_sensor_thresh = ngbe_init_thermal_sensor_thresh;
1944 mac->check_overtemp = ngbe_mac_check_overtemp;
1946 mbx->init_params = ngbe_init_mbx_params_pf;
1947 mbx->read = ngbe_read_mbx_pf;
1948 mbx->write = ngbe_write_mbx_pf;
1949 mbx->check_for_msg = ngbe_check_for_msg_pf;
1950 mbx->check_for_ack = ngbe_check_for_ack_pf;
1951 mbx->check_for_rst = ngbe_check_for_rst_pf;
1954 rom->init_params = ngbe_init_eeprom_params;
1955 rom->readw_buffer = ngbe_ee_readw_buffer;
1956 rom->read32 = ngbe_ee_read32;
1957 rom->writew_buffer = ngbe_ee_writew_buffer;
1958 rom->validate_checksum = ngbe_validate_eeprom_checksum_em;
1960 mac->mcft_size = NGBE_EM_MC_TBL_SIZE;
1961 mac->vft_size = NGBE_EM_VFT_TBL_SIZE;
1962 mac->num_rar_entries = NGBE_EM_RAR_ENTRIES;
1963 mac->rx_pb_size = NGBE_EM_RX_PB_SIZE;
1964 mac->max_rx_queues = NGBE_EM_MAX_RX_QUEUES;
1965 mac->max_tx_queues = NGBE_EM_MAX_TX_QUEUES;
1967 mac->default_speeds = NGBE_LINK_SPEED_10M_FULL |
1968 NGBE_LINK_SPEED_100M_FULL |
1969 NGBE_LINK_SPEED_1GB_FULL;
1975 * ngbe_init_shared_code - Initialize the shared code
1976 * @hw: pointer to hardware structure
1978 * This will assign function pointers and assign the MAC type and PHY code.
1979 * Does not touch the hardware. This function must be called prior to any
1980 * other function in the shared code. The ngbe_hw structure should be
1981 * memset to 0 prior to calling this function. The following fields in
1982 * hw structure should be filled in prior to calling this function:
1983 * hw_addr, back, device_id, vendor_id, subsystem_device_id
1985 s32 ngbe_init_shared_code(struct ngbe_hw *hw)
1992 ngbe_set_mac_type(hw);
1994 ngbe_init_ops_dummy(hw);
1995 switch (hw->mac.type) {
1997 ngbe_init_ops_pf(hw);
2000 status = NGBE_ERR_DEVICE_NOT_SUPPORTED;
2003 hw->mac.max_link_up_time = NGBE_LINK_UP_TIME;
2005 hw->bus.set_lan_id(hw);