151dce24bSJeff Kirsher // SPDX-License-Identifier: GPL-2.0
251dce24bSJeff Kirsher /* Copyright(c) 1999 - 2018 Intel Corporation. */
3dee1ad47SJeff Kirsher
4dee1ad47SJeff Kirsher #include "vf.h"
5b5417bf8SStephen Hemminger #include "ixgbevf.h"
6dee1ad47SJeff Kirsher
7c6d45171SKY Srinivasan /* On Hyper-V, to reset, we need to read from this offset
8c6d45171SKY Srinivasan * from the PCI config space. This is the mechanism used on
9c6d45171SKY Srinivasan * Hyper-V to support PF/VF communication.
10c6d45171SKY Srinivasan */
11c6d45171SKY Srinivasan #define IXGBE_HV_RESET_OFFSET 0x201
12c6d45171SKY Srinivasan
ixgbevf_write_msg_read_ack(struct ixgbe_hw * hw,u32 * msg,u32 * retmsg,u16 size)136a11e52bSTony Nguyen static inline s32 ixgbevf_write_msg_read_ack(struct ixgbe_hw *hw, u32 *msg,
146a11e52bSTony Nguyen u32 *retmsg, u16 size)
156a11e52bSTony Nguyen {
16c8692598SRadoslaw Tyl s32 retval = ixgbevf_write_mbx(hw, msg, size);
176a11e52bSTony Nguyen
186a11e52bSTony Nguyen if (retval)
196a11e52bSTony Nguyen return retval;
206a11e52bSTony Nguyen
21c8692598SRadoslaw Tyl return ixgbevf_poll_mbx(hw, retmsg, size);
226a11e52bSTony Nguyen }
236a11e52bSTony Nguyen
24dee1ad47SJeff Kirsher /**
25dee1ad47SJeff Kirsher * ixgbevf_start_hw_vf - Prepare hardware for Tx/Rx
26dee1ad47SJeff Kirsher * @hw: pointer to hardware structure
27dee1ad47SJeff Kirsher *
28dee1ad47SJeff Kirsher * Starts the hardware by filling the bus info structure and media type, clears
29dee1ad47SJeff Kirsher * all on chip counters, initializes receive address registers, multicast
30dee1ad47SJeff Kirsher * table, VLAN filter table, calls routine to set up link and flow control
31dee1ad47SJeff Kirsher * settings, and leaves transmit and receive units disabled and uninitialized
32dee1ad47SJeff Kirsher **/
ixgbevf_start_hw_vf(struct ixgbe_hw * hw)33dee1ad47SJeff Kirsher static s32 ixgbevf_start_hw_vf(struct ixgbe_hw *hw)
34dee1ad47SJeff Kirsher {
35dee1ad47SJeff Kirsher /* Clear adapter stopped flag */
36dee1ad47SJeff Kirsher hw->adapter_stopped = false;
37dee1ad47SJeff Kirsher
38dee1ad47SJeff Kirsher return 0;
39dee1ad47SJeff Kirsher }
40dee1ad47SJeff Kirsher
41dee1ad47SJeff Kirsher /**
42dee1ad47SJeff Kirsher * ixgbevf_init_hw_vf - virtual function hardware initialization
43dee1ad47SJeff Kirsher * @hw: pointer to hardware structure
44dee1ad47SJeff Kirsher *
45dee1ad47SJeff Kirsher * Initialize the hardware by resetting the hardware and then starting
46dee1ad47SJeff Kirsher * the hardware
47dee1ad47SJeff Kirsher **/
ixgbevf_init_hw_vf(struct ixgbe_hw * hw)48dee1ad47SJeff Kirsher static s32 ixgbevf_init_hw_vf(struct ixgbe_hw *hw)
49dee1ad47SJeff Kirsher {
50dee1ad47SJeff Kirsher s32 status = hw->mac.ops.start_hw(hw);
51dee1ad47SJeff Kirsher
52dee1ad47SJeff Kirsher hw->mac.ops.get_mac_addr(hw, hw->mac.addr);
53dee1ad47SJeff Kirsher
54dee1ad47SJeff Kirsher return status;
55dee1ad47SJeff Kirsher }
56dee1ad47SJeff Kirsher
57dee1ad47SJeff Kirsher /**
58dee1ad47SJeff Kirsher * ixgbevf_reset_hw_vf - Performs hardware reset
59dee1ad47SJeff Kirsher * @hw: pointer to hardware structure
60dee1ad47SJeff Kirsher *
61dbedd44eSJoe Perches * Resets the hardware by resetting the transmit and receive units, masks and
62dee1ad47SJeff Kirsher * clears all interrupts.
63dee1ad47SJeff Kirsher **/
ixgbevf_reset_hw_vf(struct ixgbe_hw * hw)64dee1ad47SJeff Kirsher static s32 ixgbevf_reset_hw_vf(struct ixgbe_hw *hw)
65dee1ad47SJeff Kirsher {
66dee1ad47SJeff Kirsher struct ixgbe_mbx_info *mbx = &hw->mbx;
67dee1ad47SJeff Kirsher u32 timeout = IXGBE_VF_INIT_TIMEOUT;
68dee1ad47SJeff Kirsher u32 msgbuf[IXGBE_VF_PERMADDR_MSG_LEN];
69dee1ad47SJeff Kirsher u8 *addr = (u8 *)(&msgbuf[1]);
701b9abadeSColin Ian King s32 ret_val;
71dee1ad47SJeff Kirsher
72dee1ad47SJeff Kirsher /* Call adapter stop to disable tx/rx and clear interrupts */
73dee1ad47SJeff Kirsher hw->mac.ops.stop_adapter(hw);
74dee1ad47SJeff Kirsher
7531186785SAlexander Duyck /* reset the api version */
7631186785SAlexander Duyck hw->api_version = ixgbe_mbox_api_10;
77339f2896SRadoslaw Tyl hw->mbx.ops.init_params(hw);
78339f2896SRadoslaw Tyl memcpy(&hw->mbx.ops, &ixgbevf_mbx_ops_legacy,
79339f2896SRadoslaw Tyl sizeof(struct ixgbe_mbx_operations));
8031186785SAlexander Duyck
81dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFCTRL, IXGBE_CTRL_RST);
82dee1ad47SJeff Kirsher IXGBE_WRITE_FLUSH(hw);
83dee1ad47SJeff Kirsher
84dee1ad47SJeff Kirsher /* we cannot reset while the RSTI / RSTD bits are asserted */
85dee1ad47SJeff Kirsher while (!mbx->ops.check_for_rst(hw) && timeout) {
86dee1ad47SJeff Kirsher timeout--;
87dee1ad47SJeff Kirsher udelay(5);
88dee1ad47SJeff Kirsher }
89dee1ad47SJeff Kirsher
90dee1ad47SJeff Kirsher if (!timeout)
91dee1ad47SJeff Kirsher return IXGBE_ERR_RESET_FAILED;
92dee1ad47SJeff Kirsher
93dee1ad47SJeff Kirsher /* mailbox timeout can now become active */
94dee1ad47SJeff Kirsher mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT;
95dee1ad47SJeff Kirsher
96dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_RESET;
97c8692598SRadoslaw Tyl ixgbevf_write_mbx(hw, msgbuf, 1);
98dee1ad47SJeff Kirsher
99012dc19aSJohn Fastabend mdelay(10);
100dee1ad47SJeff Kirsher
101dec0d8e4SJeff Kirsher /* set our "perm_addr" based on info provided by PF
102dec0d8e4SJeff Kirsher * also set up the mc_filter_type which is piggy backed
103dec0d8e4SJeff Kirsher * on the mac address in word 3
104dec0d8e4SJeff Kirsher */
105c8692598SRadoslaw Tyl ret_val = ixgbevf_poll_mbx(hw, msgbuf, IXGBE_VF_PERMADDR_MSG_LEN);
106dee1ad47SJeff Kirsher if (ret_val)
107dee1ad47SJeff Kirsher return ret_val;
108dee1ad47SJeff Kirsher
109e1941a74SGreg Rose /* New versions of the PF may NACK the reset return message
110e1941a74SGreg Rose * to indicate that no MAC address has yet been assigned for
111e1941a74SGreg Rose * the VF.
112e1941a74SGreg Rose */
1130edbecd5SRadoslaw Tyl if (msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_SUCCESS) &&
1140edbecd5SRadoslaw Tyl msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_FAILURE))
115dee1ad47SJeff Kirsher return IXGBE_ERR_INVALID_MAC_ADDR;
116dee1ad47SJeff Kirsher
1170edbecd5SRadoslaw Tyl if (msgbuf[0] == (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_SUCCESS))
1180d8bb414SJeff Kirsher ether_addr_copy(hw->mac.perm_addr, addr);
119465fc643SEmil Tantilov
120dee1ad47SJeff Kirsher hw->mac.mc_filter_type = msgbuf[IXGBE_VF_MC_TYPE_WORD];
121dee1ad47SJeff Kirsher
122dee1ad47SJeff Kirsher return 0;
123dee1ad47SJeff Kirsher }
124dee1ad47SJeff Kirsher
125dee1ad47SJeff Kirsher /**
126262de08fSJesse Brandeburg * ixgbevf_hv_reset_hw_vf - reset via Hyper-V
127262de08fSJesse Brandeburg * @hw: pointer to private hardware struct
128262de08fSJesse Brandeburg *
129c6d45171SKY Srinivasan * Hyper-V variant; the VF/PF communication is through the PCI
130c6d45171SKY Srinivasan * config space.
131c6d45171SKY Srinivasan */
ixgbevf_hv_reset_hw_vf(struct ixgbe_hw * hw)132c6d45171SKY Srinivasan static s32 ixgbevf_hv_reset_hw_vf(struct ixgbe_hw *hw)
133c6d45171SKY Srinivasan {
134c6d45171SKY Srinivasan #if IS_ENABLED(CONFIG_PCI_MMCONFIG)
135c6d45171SKY Srinivasan struct ixgbevf_adapter *adapter = hw->back;
136c6d45171SKY Srinivasan int i;
137c6d45171SKY Srinivasan
138c6d45171SKY Srinivasan for (i = 0; i < 6; i++)
139c6d45171SKY Srinivasan pci_read_config_byte(adapter->pdev,
140c6d45171SKY Srinivasan (i + IXGBE_HV_RESET_OFFSET),
141c6d45171SKY Srinivasan &hw->mac.perm_addr[i]);
142c6d45171SKY Srinivasan return 0;
143c6d45171SKY Srinivasan #else
144c6d45171SKY Srinivasan pr_err("PCI_MMCONFIG needs to be enabled for Hyper-V\n");
145c6d45171SKY Srinivasan return -EOPNOTSUPP;
146c6d45171SKY Srinivasan #endif
147c6d45171SKY Srinivasan }
148c6d45171SKY Srinivasan
149c6d45171SKY Srinivasan /**
150dee1ad47SJeff Kirsher * ixgbevf_stop_hw_vf - Generic stop Tx/Rx units
151dee1ad47SJeff Kirsher * @hw: pointer to hardware structure
152dee1ad47SJeff Kirsher *
153dee1ad47SJeff Kirsher * Sets the adapter_stopped flag within ixgbe_hw struct. Clears interrupts,
154dee1ad47SJeff Kirsher * disables transmit and receive units. The adapter_stopped flag is used by
155dee1ad47SJeff Kirsher * the shared code and drivers to determine if the adapter is in a stopped
156dee1ad47SJeff Kirsher * state and should not touch the hardware.
157dee1ad47SJeff Kirsher **/
ixgbevf_stop_hw_vf(struct ixgbe_hw * hw)158dee1ad47SJeff Kirsher static s32 ixgbevf_stop_hw_vf(struct ixgbe_hw *hw)
159dee1ad47SJeff Kirsher {
160dee1ad47SJeff Kirsher u32 number_of_queues;
161dee1ad47SJeff Kirsher u32 reg_val;
162dee1ad47SJeff Kirsher u16 i;
163dee1ad47SJeff Kirsher
164dec0d8e4SJeff Kirsher /* Set the adapter_stopped flag so other driver functions stop touching
165dee1ad47SJeff Kirsher * the hardware
166dee1ad47SJeff Kirsher */
167dee1ad47SJeff Kirsher hw->adapter_stopped = true;
168dee1ad47SJeff Kirsher
169dee1ad47SJeff Kirsher /* Disable the receive unit by stopped each queue */
170dee1ad47SJeff Kirsher number_of_queues = hw->mac.max_rx_queues;
171dee1ad47SJeff Kirsher for (i = 0; i < number_of_queues; i++) {
172dee1ad47SJeff Kirsher reg_val = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
173dee1ad47SJeff Kirsher if (reg_val & IXGBE_RXDCTL_ENABLE) {
174dee1ad47SJeff Kirsher reg_val &= ~IXGBE_RXDCTL_ENABLE;
175dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), reg_val);
176dee1ad47SJeff Kirsher }
177dee1ad47SJeff Kirsher }
178dee1ad47SJeff Kirsher
179dee1ad47SJeff Kirsher IXGBE_WRITE_FLUSH(hw);
180dee1ad47SJeff Kirsher
181dee1ad47SJeff Kirsher /* Clear interrupt mask to stop from interrupts being generated */
182dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, IXGBE_VF_IRQ_CLEAR_MASK);
183dee1ad47SJeff Kirsher
184dee1ad47SJeff Kirsher /* Clear any pending interrupts */
185dee1ad47SJeff Kirsher IXGBE_READ_REG(hw, IXGBE_VTEICR);
186dee1ad47SJeff Kirsher
187dee1ad47SJeff Kirsher /* Disable the transmit unit. Each queue must be disabled. */
188dee1ad47SJeff Kirsher number_of_queues = hw->mac.max_tx_queues;
189dee1ad47SJeff Kirsher for (i = 0; i < number_of_queues; i++) {
190dee1ad47SJeff Kirsher reg_val = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i));
191dee1ad47SJeff Kirsher if (reg_val & IXGBE_TXDCTL_ENABLE) {
192dee1ad47SJeff Kirsher reg_val &= ~IXGBE_TXDCTL_ENABLE;
193dee1ad47SJeff Kirsher IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), reg_val);
194dee1ad47SJeff Kirsher }
195dee1ad47SJeff Kirsher }
196dee1ad47SJeff Kirsher
197dee1ad47SJeff Kirsher return 0;
198dee1ad47SJeff Kirsher }
199dee1ad47SJeff Kirsher
200dee1ad47SJeff Kirsher /**
201dee1ad47SJeff Kirsher * ixgbevf_mta_vector - Determines bit-vector in multicast table to set
202dee1ad47SJeff Kirsher * @hw: pointer to hardware structure
203dee1ad47SJeff Kirsher * @mc_addr: the multicast address
204dee1ad47SJeff Kirsher *
205dee1ad47SJeff Kirsher * Extracts the 12 bits, from a multicast address, to determine which
206dee1ad47SJeff Kirsher * bit-vector to set in the multicast table. The hardware uses 12 bits, from
207dec0d8e4SJeff Kirsher * incoming Rx multicast addresses, to determine the bit-vector to check in
208dee1ad47SJeff Kirsher * the MTA. Which of the 4 combination, of 12-bits, the hardware uses is set
209dee1ad47SJeff Kirsher * by the MO field of the MCSTCTRL. The MO field is set during initialization
210dee1ad47SJeff Kirsher * to mc_filter_type.
211dee1ad47SJeff Kirsher **/
ixgbevf_mta_vector(struct ixgbe_hw * hw,u8 * mc_addr)212dee1ad47SJeff Kirsher static s32 ixgbevf_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr)
213dee1ad47SJeff Kirsher {
214dee1ad47SJeff Kirsher u32 vector = 0;
215dee1ad47SJeff Kirsher
216dee1ad47SJeff Kirsher switch (hw->mac.mc_filter_type) {
217dee1ad47SJeff Kirsher case 0: /* use bits [47:36] of the address */
218dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4));
219dee1ad47SJeff Kirsher break;
220dee1ad47SJeff Kirsher case 1: /* use bits [46:35] of the address */
221dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5));
222dee1ad47SJeff Kirsher break;
223dee1ad47SJeff Kirsher case 2: /* use bits [45:34] of the address */
224dee1ad47SJeff Kirsher vector = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6));
225dee1ad47SJeff Kirsher break;
226dee1ad47SJeff Kirsher case 3: /* use bits [43:32] of the address */
227dee1ad47SJeff Kirsher vector = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8));
228dee1ad47SJeff Kirsher break;
229dee1ad47SJeff Kirsher default: /* Invalid mc_filter_type */
230dee1ad47SJeff Kirsher break;
231dee1ad47SJeff Kirsher }
232dee1ad47SJeff Kirsher
233dee1ad47SJeff Kirsher /* vector can only be 12-bits or boundary will be exceeded */
234dee1ad47SJeff Kirsher vector &= 0xFFF;
235dee1ad47SJeff Kirsher return vector;
236dee1ad47SJeff Kirsher }
237dee1ad47SJeff Kirsher
238dee1ad47SJeff Kirsher /**
239dee1ad47SJeff Kirsher * ixgbevf_get_mac_addr_vf - Read device MAC address
240dee1ad47SJeff Kirsher * @hw: pointer to the HW structure
241dee1ad47SJeff Kirsher * @mac_addr: pointer to storage for retrieved MAC address
242dee1ad47SJeff Kirsher **/
ixgbevf_get_mac_addr_vf(struct ixgbe_hw * hw,u8 * mac_addr)243dee1ad47SJeff Kirsher static s32 ixgbevf_get_mac_addr_vf(struct ixgbe_hw *hw, u8 *mac_addr)
244dee1ad47SJeff Kirsher {
2450d8bb414SJeff Kirsher ether_addr_copy(mac_addr, hw->mac.perm_addr);
246dee1ad47SJeff Kirsher
247dee1ad47SJeff Kirsher return 0;
248dee1ad47SJeff Kirsher }
249dee1ad47SJeff Kirsher
ixgbevf_set_uc_addr_vf(struct ixgbe_hw * hw,u32 index,u8 * addr)250dee1ad47SJeff Kirsher static s32 ixgbevf_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr)
251dee1ad47SJeff Kirsher {
252fc355e07SEmil Tantilov u32 msgbuf[3], msgbuf_chk;
253dee1ad47SJeff Kirsher u8 *msg_addr = (u8 *)(&msgbuf[1]);
254dee1ad47SJeff Kirsher s32 ret_val;
255dee1ad47SJeff Kirsher
256dee1ad47SJeff Kirsher memset(msgbuf, 0, sizeof(msgbuf));
257dec0d8e4SJeff Kirsher /* If index is one then this is the start of a new list and needs
258dee1ad47SJeff Kirsher * indication to the PF so it can do it's own list management.
259dee1ad47SJeff Kirsher * If it is zero then that tells the PF to just clear all of
260dee1ad47SJeff Kirsher * this VF's macvlans and there is no new list.
261dee1ad47SJeff Kirsher */
262dee1ad47SJeff Kirsher msgbuf[0] |= index << IXGBE_VT_MSGINFO_SHIFT;
263dee1ad47SJeff Kirsher msgbuf[0] |= IXGBE_VF_SET_MACVLAN;
264fc355e07SEmil Tantilov msgbuf_chk = msgbuf[0];
265fc355e07SEmil Tantilov
266dee1ad47SJeff Kirsher if (addr)
2670d8bb414SJeff Kirsher ether_addr_copy(msg_addr, addr);
268dee1ad47SJeff Kirsher
269c6426971SEmil Tantilov ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
2704078ea37SColin Ian King ARRAY_SIZE(msgbuf));
271fc355e07SEmil Tantilov if (!ret_val) {
272dee1ad47SJeff Kirsher msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
273dee1ad47SJeff Kirsher
2740edbecd5SRadoslaw Tyl if (msgbuf[0] == (msgbuf_chk | IXGBE_VT_MSGTYPE_FAILURE))
275fc355e07SEmil Tantilov return -ENOMEM;
276fc355e07SEmil Tantilov }
277dee1ad47SJeff Kirsher
278dee1ad47SJeff Kirsher return ret_val;
279dee1ad47SJeff Kirsher }
280dee1ad47SJeff Kirsher
ixgbevf_hv_set_uc_addr_vf(struct ixgbe_hw * hw,u32 index,u8 * addr)281c6d45171SKY Srinivasan static s32 ixgbevf_hv_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr)
282c6d45171SKY Srinivasan {
283c6d45171SKY Srinivasan return -EOPNOTSUPP;
284c6d45171SKY Srinivasan }
285c6d45171SKY Srinivasan
286dee1ad47SJeff Kirsher /**
28794cf66f8SVlad Zolotarov * ixgbevf_get_reta_locked - get the RSS redirection table (RETA) contents.
288e23cf38fSTony Nguyen * @hw: pointer to hardware structure
28994cf66f8SVlad Zolotarov * @reta: buffer to fill with RETA contents.
29094cf66f8SVlad Zolotarov * @num_rx_queues: Number of Rx queues configured for this port
29194cf66f8SVlad Zolotarov *
29294cf66f8SVlad Zolotarov * The "reta" buffer should be big enough to contain 32 registers.
29394cf66f8SVlad Zolotarov *
29494cf66f8SVlad Zolotarov * Returns: 0 on success.
29594cf66f8SVlad Zolotarov * if API doesn't support this operation - (-EOPNOTSUPP).
29694cf66f8SVlad Zolotarov */
ixgbevf_get_reta_locked(struct ixgbe_hw * hw,u32 * reta,int num_rx_queues)29794cf66f8SVlad Zolotarov int ixgbevf_get_reta_locked(struct ixgbe_hw *hw, u32 *reta, int num_rx_queues)
29894cf66f8SVlad Zolotarov {
29994cf66f8SVlad Zolotarov int err, i, j;
30094cf66f8SVlad Zolotarov u32 msgbuf[IXGBE_VFMAILBOX_SIZE];
30194cf66f8SVlad Zolotarov u32 *hw_reta = &msgbuf[1];
30294cf66f8SVlad Zolotarov u32 mask = 0;
30394cf66f8SVlad Zolotarov
30494cf66f8SVlad Zolotarov /* We have to use a mailbox for 82599 and x540 devices only.
30594cf66f8SVlad Zolotarov * For these devices RETA has 128 entries.
30694cf66f8SVlad Zolotarov * Also these VFs support up to 4 RSS queues. Therefore PF will compress
30794cf66f8SVlad Zolotarov * 16 RETA entries in each DWORD giving 2 bits to each entry.
30894cf66f8SVlad Zolotarov */
30994cf66f8SVlad Zolotarov int dwords = IXGBEVF_82599_RETA_SIZE / 16;
31094cf66f8SVlad Zolotarov
31194cf66f8SVlad Zolotarov /* We support the RSS querying for 82599 and x540 devices only.
31294cf66f8SVlad Zolotarov * Thus return an error if API doesn't support RETA querying or querying
31394cf66f8SVlad Zolotarov * is not supported for this device type.
31494cf66f8SVlad Zolotarov */
31541e544cdSDon Skidmore switch (hw->api_version) {
316339f2896SRadoslaw Tyl case ixgbe_mbox_api_15:
3177f68d430SShannon Nelson case ixgbe_mbox_api_14:
31841e544cdSDon Skidmore case ixgbe_mbox_api_13:
31941e544cdSDon Skidmore case ixgbe_mbox_api_12:
32082fb670cSTony Nguyen if (hw->mac.type < ixgbe_mac_X550_vf)
32141e544cdSDon Skidmore break;
3225463fce6SJeff Kirsher fallthrough;
32341e544cdSDon Skidmore default:
32494cf66f8SVlad Zolotarov return -EOPNOTSUPP;
32541e544cdSDon Skidmore }
32694cf66f8SVlad Zolotarov
32794cf66f8SVlad Zolotarov msgbuf[0] = IXGBE_VF_GET_RETA;
32894cf66f8SVlad Zolotarov
329c8692598SRadoslaw Tyl err = ixgbevf_write_mbx(hw, msgbuf, 1);
33094cf66f8SVlad Zolotarov
33194cf66f8SVlad Zolotarov if (err)
33294cf66f8SVlad Zolotarov return err;
33394cf66f8SVlad Zolotarov
334c8692598SRadoslaw Tyl err = ixgbevf_poll_mbx(hw, msgbuf, dwords + 1);
33594cf66f8SVlad Zolotarov
33694cf66f8SVlad Zolotarov if (err)
33794cf66f8SVlad Zolotarov return err;
33894cf66f8SVlad Zolotarov
33994cf66f8SVlad Zolotarov msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
34094cf66f8SVlad Zolotarov
34194cf66f8SVlad Zolotarov /* If the operation has been refused by a PF return -EPERM */
3420edbecd5SRadoslaw Tyl if (msgbuf[0] == (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_FAILURE))
34394cf66f8SVlad Zolotarov return -EPERM;
34494cf66f8SVlad Zolotarov
34594cf66f8SVlad Zolotarov /* If we didn't get an ACK there must have been
34694cf66f8SVlad Zolotarov * some sort of mailbox error so we should treat it
34794cf66f8SVlad Zolotarov * as such.
34894cf66f8SVlad Zolotarov */
3490edbecd5SRadoslaw Tyl if (msgbuf[0] != (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_SUCCESS))
35094cf66f8SVlad Zolotarov return IXGBE_ERR_MBX;
35194cf66f8SVlad Zolotarov
35294cf66f8SVlad Zolotarov /* ixgbevf doesn't support more than 2 queues at the moment */
35394cf66f8SVlad Zolotarov if (num_rx_queues > 1)
35494cf66f8SVlad Zolotarov mask = 0x1;
35594cf66f8SVlad Zolotarov
35694cf66f8SVlad Zolotarov for (i = 0; i < dwords; i++)
35794cf66f8SVlad Zolotarov for (j = 0; j < 16; j++)
35894cf66f8SVlad Zolotarov reta[i * 16 + j] = (hw_reta[i] >> (2 * j)) & mask;
35994cf66f8SVlad Zolotarov
36094cf66f8SVlad Zolotarov return 0;
36194cf66f8SVlad Zolotarov }
36294cf66f8SVlad Zolotarov
36394cf66f8SVlad Zolotarov /**
364ad1431e2SVlad Zolotarov * ixgbevf_get_rss_key_locked - get the RSS Random Key
365ad1431e2SVlad Zolotarov * @hw: pointer to the HW structure
366ad1431e2SVlad Zolotarov * @rss_key: buffer to fill with RSS Hash Key contents.
367ad1431e2SVlad Zolotarov *
368ad1431e2SVlad Zolotarov * The "rss_key" buffer should be big enough to contain 10 registers.
369ad1431e2SVlad Zolotarov *
370ad1431e2SVlad Zolotarov * Returns: 0 on success.
371ad1431e2SVlad Zolotarov * if API doesn't support this operation - (-EOPNOTSUPP).
372ad1431e2SVlad Zolotarov */
ixgbevf_get_rss_key_locked(struct ixgbe_hw * hw,u8 * rss_key)373ad1431e2SVlad Zolotarov int ixgbevf_get_rss_key_locked(struct ixgbe_hw *hw, u8 *rss_key)
374ad1431e2SVlad Zolotarov {
375ad1431e2SVlad Zolotarov int err;
376ad1431e2SVlad Zolotarov u32 msgbuf[IXGBE_VFMAILBOX_SIZE];
377ad1431e2SVlad Zolotarov
378ad1431e2SVlad Zolotarov /* We currently support the RSS Random Key retrieval for 82599 and x540
379ad1431e2SVlad Zolotarov * devices only.
380ad1431e2SVlad Zolotarov *
381ad1431e2SVlad Zolotarov * Thus return an error if API doesn't support RSS Random Key retrieval
382ad1431e2SVlad Zolotarov * or if the operation is not supported for this device type.
383ad1431e2SVlad Zolotarov */
38441e544cdSDon Skidmore switch (hw->api_version) {
385339f2896SRadoslaw Tyl case ixgbe_mbox_api_15:
3867f68d430SShannon Nelson case ixgbe_mbox_api_14:
38741e544cdSDon Skidmore case ixgbe_mbox_api_13:
38841e544cdSDon Skidmore case ixgbe_mbox_api_12:
38982fb670cSTony Nguyen if (hw->mac.type < ixgbe_mac_X550_vf)
39041e544cdSDon Skidmore break;
3915463fce6SJeff Kirsher fallthrough;
39241e544cdSDon Skidmore default:
393ad1431e2SVlad Zolotarov return -EOPNOTSUPP;
39441e544cdSDon Skidmore }
395ad1431e2SVlad Zolotarov
396ad1431e2SVlad Zolotarov msgbuf[0] = IXGBE_VF_GET_RSS_KEY;
397c8692598SRadoslaw Tyl err = ixgbevf_write_mbx(hw, msgbuf, 1);
398ad1431e2SVlad Zolotarov
399ad1431e2SVlad Zolotarov if (err)
400ad1431e2SVlad Zolotarov return err;
401ad1431e2SVlad Zolotarov
402c8692598SRadoslaw Tyl err = ixgbevf_poll_mbx(hw, msgbuf, 11);
403ad1431e2SVlad Zolotarov
404ad1431e2SVlad Zolotarov if (err)
405ad1431e2SVlad Zolotarov return err;
406ad1431e2SVlad Zolotarov
407ad1431e2SVlad Zolotarov msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
408ad1431e2SVlad Zolotarov
409ad1431e2SVlad Zolotarov /* If the operation has been refused by a PF return -EPERM */
4100edbecd5SRadoslaw Tyl if (msgbuf[0] == (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_FAILURE))
411ad1431e2SVlad Zolotarov return -EPERM;
412ad1431e2SVlad Zolotarov
413ad1431e2SVlad Zolotarov /* If we didn't get an ACK there must have been
414ad1431e2SVlad Zolotarov * some sort of mailbox error so we should treat it
415ad1431e2SVlad Zolotarov * as such.
416ad1431e2SVlad Zolotarov */
4170edbecd5SRadoslaw Tyl if (msgbuf[0] != (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_SUCCESS))
418ad1431e2SVlad Zolotarov return IXGBE_ERR_MBX;
419ad1431e2SVlad Zolotarov
420ad1431e2SVlad Zolotarov memcpy(rss_key, msgbuf + 1, IXGBEVF_RSS_HASH_KEY_SIZE);
421ad1431e2SVlad Zolotarov
422ad1431e2SVlad Zolotarov return 0;
423ad1431e2SVlad Zolotarov }
424ad1431e2SVlad Zolotarov
425ad1431e2SVlad Zolotarov /**
426dee1ad47SJeff Kirsher * ixgbevf_set_rar_vf - set device MAC address
427dee1ad47SJeff Kirsher * @hw: pointer to hardware structure
428dee1ad47SJeff Kirsher * @index: Receive address register to write
429dee1ad47SJeff Kirsher * @addr: Address to put into receive address register
430dee1ad47SJeff Kirsher * @vmdq: Unused in this implementation
431dee1ad47SJeff Kirsher **/
ixgbevf_set_rar_vf(struct ixgbe_hw * hw,u32 index,u8 * addr,u32 vmdq)432dee1ad47SJeff Kirsher static s32 ixgbevf_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr,
433dee1ad47SJeff Kirsher u32 vmdq)
434dee1ad47SJeff Kirsher {
435dee1ad47SJeff Kirsher u32 msgbuf[3];
436dee1ad47SJeff Kirsher u8 *msg_addr = (u8 *)(&msgbuf[1]);
437dee1ad47SJeff Kirsher s32 ret_val;
438dee1ad47SJeff Kirsher
439dee1ad47SJeff Kirsher memset(msgbuf, 0, sizeof(msgbuf));
440dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_MAC_ADDR;
4410d8bb414SJeff Kirsher ether_addr_copy(msg_addr, addr);
442dee1ad47SJeff Kirsher
443c6426971SEmil Tantilov ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
4444078ea37SColin Ian King ARRAY_SIZE(msgbuf));
445dee1ad47SJeff Kirsher msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
446dee1ad47SJeff Kirsher
447dee1ad47SJeff Kirsher /* if nacked the address was rejected, use "perm_addr" */
448dee1ad47SJeff Kirsher if (!ret_val &&
4490edbecd5SRadoslaw Tyl (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_FAILURE))) {
450dee1ad47SJeff Kirsher ixgbevf_get_mac_addr_vf(hw, hw->mac.addr);
45132ca6868SEmil Tantilov return IXGBE_ERR_MBX;
45232ca6868SEmil Tantilov }
453dee1ad47SJeff Kirsher
454dee1ad47SJeff Kirsher return ret_val;
455dee1ad47SJeff Kirsher }
456dee1ad47SJeff Kirsher
457c6d45171SKY Srinivasan /**
458c6d45171SKY Srinivasan * ixgbevf_hv_set_rar_vf - set device MAC address Hyper-V variant
459c6d45171SKY Srinivasan * @hw: pointer to hardware structure
460c6d45171SKY Srinivasan * @index: Receive address register to write
461c6d45171SKY Srinivasan * @addr: Address to put into receive address register
462c6d45171SKY Srinivasan * @vmdq: Unused in this implementation
463c6d45171SKY Srinivasan *
464c6d45171SKY Srinivasan * We don't really allow setting the device MAC address. However,
465c6d45171SKY Srinivasan * if the address being set is the permanent MAC address we will
466c6d45171SKY Srinivasan * permit that.
467c6d45171SKY Srinivasan **/
ixgbevf_hv_set_rar_vf(struct ixgbe_hw * hw,u32 index,u8 * addr,u32 vmdq)468c6d45171SKY Srinivasan static s32 ixgbevf_hv_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr,
469c6d45171SKY Srinivasan u32 vmdq)
470c6d45171SKY Srinivasan {
471c6d45171SKY Srinivasan if (ether_addr_equal(addr, hw->mac.perm_addr))
472c6d45171SKY Srinivasan return 0;
473c6d45171SKY Srinivasan
474c6d45171SKY Srinivasan return -EOPNOTSUPP;
475c6d45171SKY Srinivasan }
476c6d45171SKY Srinivasan
477dee1ad47SJeff Kirsher /**
478dee1ad47SJeff Kirsher * ixgbevf_update_mc_addr_list_vf - Update Multicast addresses
479dee1ad47SJeff Kirsher * @hw: pointer to the HW structure
480dee1ad47SJeff Kirsher * @netdev: pointer to net device structure
481dee1ad47SJeff Kirsher *
482dee1ad47SJeff Kirsher * Updates the Multicast Table Array.
483dee1ad47SJeff Kirsher **/
ixgbevf_update_mc_addr_list_vf(struct ixgbe_hw * hw,struct net_device * netdev)484dee1ad47SJeff Kirsher static s32 ixgbevf_update_mc_addr_list_vf(struct ixgbe_hw *hw,
485dee1ad47SJeff Kirsher struct net_device *netdev)
486dee1ad47SJeff Kirsher {
487dee1ad47SJeff Kirsher struct netdev_hw_addr *ha;
488dee1ad47SJeff Kirsher u32 msgbuf[IXGBE_VFMAILBOX_SIZE];
489dee1ad47SJeff Kirsher u16 *vector_list = (u16 *)&msgbuf[1];
490dee1ad47SJeff Kirsher u32 cnt, i;
491dee1ad47SJeff Kirsher
492dee1ad47SJeff Kirsher /* Each entry in the list uses 1 16 bit word. We have 30
493dee1ad47SJeff Kirsher * 16 bit words available in our HW msg buffer (minus 1 for the
494dee1ad47SJeff Kirsher * msg type). That's 30 hash values if we pack 'em right. If
495dee1ad47SJeff Kirsher * there are more than 30 MC addresses to add then punt the
496dee1ad47SJeff Kirsher * extras for now and then add code to handle more than 30 later.
497dee1ad47SJeff Kirsher * It would be unusual for a server to request that many multi-cast
498dee1ad47SJeff Kirsher * addresses except for in large enterprise network environments.
499dee1ad47SJeff Kirsher */
500dee1ad47SJeff Kirsher
501dee1ad47SJeff Kirsher cnt = netdev_mc_count(netdev);
502dee1ad47SJeff Kirsher if (cnt > 30)
503dee1ad47SJeff Kirsher cnt = 30;
504dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_MULTICAST;
505dee1ad47SJeff Kirsher msgbuf[0] |= cnt << IXGBE_VT_MSGINFO_SHIFT;
506dee1ad47SJeff Kirsher
507dee1ad47SJeff Kirsher i = 0;
508dee1ad47SJeff Kirsher netdev_for_each_mc_addr(ha, netdev) {
509dee1ad47SJeff Kirsher if (i == cnt)
510dee1ad47SJeff Kirsher break;
51146acc460SBen Hutchings if (is_link_local_ether_addr(ha->addr))
512b3343a2aSJohn Fastabend continue;
513b3343a2aSJohn Fastabend
514dee1ad47SJeff Kirsher vector_list[i++] = ixgbevf_mta_vector(hw, ha->addr);
515dee1ad47SJeff Kirsher }
516dee1ad47SJeff Kirsher
51720d437eeSKangjie Lu return ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
51820d437eeSKangjie Lu IXGBE_VFMAILBOX_SIZE);
519dee1ad47SJeff Kirsher }
520dee1ad47SJeff Kirsher
521dee1ad47SJeff Kirsher /**
522262de08fSJesse Brandeburg * ixgbevf_hv_update_mc_addr_list_vf - stub
523e23cf38fSTony Nguyen * @hw: unused
524e23cf38fSTony Nguyen * @netdev: unused
525262de08fSJesse Brandeburg *
526262de08fSJesse Brandeburg * Hyper-V variant - just a stub.
527c6d45171SKY Srinivasan */
ixgbevf_hv_update_mc_addr_list_vf(struct ixgbe_hw * hw,struct net_device * netdev)528c6d45171SKY Srinivasan static s32 ixgbevf_hv_update_mc_addr_list_vf(struct ixgbe_hw *hw,
529c6d45171SKY Srinivasan struct net_device *netdev)
530c6d45171SKY Srinivasan {
531c6d45171SKY Srinivasan return -EOPNOTSUPP;
532c6d45171SKY Srinivasan }
533c6d45171SKY Srinivasan
534c6d45171SKY Srinivasan /**
5358443c1a4SHiroshi Shimamoto * ixgbevf_update_xcast_mode - Update Multicast mode
5368443c1a4SHiroshi Shimamoto * @hw: pointer to the HW structure
5378443c1a4SHiroshi Shimamoto * @xcast_mode: new multicast mode
5388443c1a4SHiroshi Shimamoto *
5398443c1a4SHiroshi Shimamoto * Updates the Multicast Mode of VF.
5408443c1a4SHiroshi Shimamoto **/
ixgbevf_update_xcast_mode(struct ixgbe_hw * hw,int xcast_mode)5418b44a8a0STony Nguyen static s32 ixgbevf_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode)
5428443c1a4SHiroshi Shimamoto {
5438443c1a4SHiroshi Shimamoto u32 msgbuf[2];
5448443c1a4SHiroshi Shimamoto s32 err;
5458443c1a4SHiroshi Shimamoto
5468443c1a4SHiroshi Shimamoto switch (hw->api_version) {
5478443c1a4SHiroshi Shimamoto case ixgbe_mbox_api_12:
54841e544cdSDon Skidmore /* promisc introduced in 1.3 version */
54941e544cdSDon Skidmore if (xcast_mode == IXGBEVF_XCAST_MODE_PROMISC)
55041e544cdSDon Skidmore return -EOPNOTSUPP;
5515463fce6SJeff Kirsher fallthrough;
55241e544cdSDon Skidmore case ixgbe_mbox_api_13:
553339f2896SRadoslaw Tyl case ixgbe_mbox_api_14:
554339f2896SRadoslaw Tyl case ixgbe_mbox_api_15:
5558443c1a4SHiroshi Shimamoto break;
5568443c1a4SHiroshi Shimamoto default:
5578443c1a4SHiroshi Shimamoto return -EOPNOTSUPP;
5588443c1a4SHiroshi Shimamoto }
5598443c1a4SHiroshi Shimamoto
5608443c1a4SHiroshi Shimamoto msgbuf[0] = IXGBE_VF_UPDATE_XCAST_MODE;
5618443c1a4SHiroshi Shimamoto msgbuf[1] = xcast_mode;
5628443c1a4SHiroshi Shimamoto
563c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
5644078ea37SColin Ian King ARRAY_SIZE(msgbuf));
5658443c1a4SHiroshi Shimamoto if (err)
5668443c1a4SHiroshi Shimamoto return err;
5678443c1a4SHiroshi Shimamoto
5688443c1a4SHiroshi Shimamoto msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
5690edbecd5SRadoslaw Tyl if (msgbuf[0] == (IXGBE_VF_UPDATE_XCAST_MODE | IXGBE_VT_MSGTYPE_FAILURE))
5708443c1a4SHiroshi Shimamoto return -EPERM;
5718443c1a4SHiroshi Shimamoto
5728443c1a4SHiroshi Shimamoto return 0;
5738443c1a4SHiroshi Shimamoto }
5748443c1a4SHiroshi Shimamoto
5758443c1a4SHiroshi Shimamoto /**
576262de08fSJesse Brandeburg * ixgbevf_hv_update_xcast_mode - stub
577e23cf38fSTony Nguyen * @hw: unused
578e23cf38fSTony Nguyen * @xcast_mode: unused
579262de08fSJesse Brandeburg *
580262de08fSJesse Brandeburg * Hyper-V variant - just a stub.
581c6d45171SKY Srinivasan */
ixgbevf_hv_update_xcast_mode(struct ixgbe_hw * hw,int xcast_mode)5828b44a8a0STony Nguyen static s32 ixgbevf_hv_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode)
583c6d45171SKY Srinivasan {
584c6d45171SKY Srinivasan return -EOPNOTSUPP;
585c6d45171SKY Srinivasan }
586c6d45171SKY Srinivasan
587c6d45171SKY Srinivasan /**
588443ebdd6SSlawomir Mrozowicz * ixgbevf_get_link_state_vf - Get VF link state from PF
589443ebdd6SSlawomir Mrozowicz * @hw: pointer to the HW structure
590443ebdd6SSlawomir Mrozowicz * @link_state: link state storage
591443ebdd6SSlawomir Mrozowicz *
592443ebdd6SSlawomir Mrozowicz * Returns state of the operation error or success.
593443ebdd6SSlawomir Mrozowicz */
ixgbevf_get_link_state_vf(struct ixgbe_hw * hw,bool * link_state)594443ebdd6SSlawomir Mrozowicz static s32 ixgbevf_get_link_state_vf(struct ixgbe_hw *hw, bool *link_state)
595443ebdd6SSlawomir Mrozowicz {
596443ebdd6SSlawomir Mrozowicz u32 msgbuf[2];
597443ebdd6SSlawomir Mrozowicz s32 ret_val;
598443ebdd6SSlawomir Mrozowicz s32 err;
599443ebdd6SSlawomir Mrozowicz
600443ebdd6SSlawomir Mrozowicz msgbuf[0] = IXGBE_VF_GET_LINK_STATE;
601443ebdd6SSlawomir Mrozowicz msgbuf[1] = 0x0;
602443ebdd6SSlawomir Mrozowicz
603443ebdd6SSlawomir Mrozowicz err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 2);
604443ebdd6SSlawomir Mrozowicz
605443ebdd6SSlawomir Mrozowicz if (err || (msgbuf[0] & IXGBE_VT_MSGTYPE_FAILURE)) {
606443ebdd6SSlawomir Mrozowicz ret_val = IXGBE_ERR_MBX;
607443ebdd6SSlawomir Mrozowicz } else {
608443ebdd6SSlawomir Mrozowicz ret_val = 0;
609443ebdd6SSlawomir Mrozowicz *link_state = msgbuf[1];
610443ebdd6SSlawomir Mrozowicz }
611443ebdd6SSlawomir Mrozowicz
612443ebdd6SSlawomir Mrozowicz return ret_val;
613443ebdd6SSlawomir Mrozowicz }
614443ebdd6SSlawomir Mrozowicz
615443ebdd6SSlawomir Mrozowicz /**
616443ebdd6SSlawomir Mrozowicz * ixgbevf_hv_get_link_state_vf - * Hyper-V variant - just a stub.
617443ebdd6SSlawomir Mrozowicz * @hw: unused
618443ebdd6SSlawomir Mrozowicz * @link_state: unused
619443ebdd6SSlawomir Mrozowicz *
620443ebdd6SSlawomir Mrozowicz * Hyper-V variant; there is no mailbox communication.
621443ebdd6SSlawomir Mrozowicz */
ixgbevf_hv_get_link_state_vf(struct ixgbe_hw * hw,bool * link_state)622443ebdd6SSlawomir Mrozowicz static s32 ixgbevf_hv_get_link_state_vf(struct ixgbe_hw *hw, bool *link_state)
623443ebdd6SSlawomir Mrozowicz {
624443ebdd6SSlawomir Mrozowicz return -EOPNOTSUPP;
625443ebdd6SSlawomir Mrozowicz }
626443ebdd6SSlawomir Mrozowicz
627443ebdd6SSlawomir Mrozowicz /**
628dec0d8e4SJeff Kirsher * ixgbevf_set_vfta_vf - Set/Unset VLAN filter table address
629dee1ad47SJeff Kirsher * @hw: pointer to the HW structure
630dee1ad47SJeff Kirsher * @vlan: 12 bit VLAN ID
631dee1ad47SJeff Kirsher * @vind: unused by VF drivers
632dee1ad47SJeff Kirsher * @vlan_on: if true then set bit, else clear bit
633dee1ad47SJeff Kirsher **/
ixgbevf_set_vfta_vf(struct ixgbe_hw * hw,u32 vlan,u32 vind,bool vlan_on)634dee1ad47SJeff Kirsher static s32 ixgbevf_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind,
635dee1ad47SJeff Kirsher bool vlan_on)
636dee1ad47SJeff Kirsher {
637dee1ad47SJeff Kirsher u32 msgbuf[2];
6382ddc7fe1SAlexander Duyck s32 err;
639dee1ad47SJeff Kirsher
640dee1ad47SJeff Kirsher msgbuf[0] = IXGBE_VF_SET_VLAN;
641dee1ad47SJeff Kirsher msgbuf[1] = vlan;
642dee1ad47SJeff Kirsher /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */
643dee1ad47SJeff Kirsher msgbuf[0] |= vlan_on << IXGBE_VT_MSGINFO_SHIFT;
644dee1ad47SJeff Kirsher
645c6426971SEmil Tantilov err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
6464078ea37SColin Ian King ARRAY_SIZE(msgbuf));
6472ddc7fe1SAlexander Duyck if (err)
6482ddc7fe1SAlexander Duyck goto mbx_err;
6492ddc7fe1SAlexander Duyck
6502ddc7fe1SAlexander Duyck /* remove extra bits from the message */
6512ddc7fe1SAlexander Duyck msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
6522ddc7fe1SAlexander Duyck msgbuf[0] &= ~(0xFF << IXGBE_VT_MSGINFO_SHIFT);
6532ddc7fe1SAlexander Duyck
6540edbecd5SRadoslaw Tyl if (msgbuf[0] != (IXGBE_VF_SET_VLAN | IXGBE_VT_MSGTYPE_SUCCESS))
6552ddc7fe1SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT;
6562ddc7fe1SAlexander Duyck
6572ddc7fe1SAlexander Duyck mbx_err:
6582ddc7fe1SAlexander Duyck return err;
659dee1ad47SJeff Kirsher }
660dee1ad47SJeff Kirsher
661dee1ad47SJeff Kirsher /**
662262de08fSJesse Brandeburg * ixgbevf_hv_set_vfta_vf - * Hyper-V variant - just a stub.
663e23cf38fSTony Nguyen * @hw: unused
664e23cf38fSTony Nguyen * @vlan: unused
665e23cf38fSTony Nguyen * @vind: unused
666e23cf38fSTony Nguyen * @vlan_on: unused
667c6d45171SKY Srinivasan */
ixgbevf_hv_set_vfta_vf(struct ixgbe_hw * hw,u32 vlan,u32 vind,bool vlan_on)668c6d45171SKY Srinivasan static s32 ixgbevf_hv_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind,
669c6d45171SKY Srinivasan bool vlan_on)
670c6d45171SKY Srinivasan {
671c6d45171SKY Srinivasan return -EOPNOTSUPP;
672c6d45171SKY Srinivasan }
673c6d45171SKY Srinivasan
674c6d45171SKY Srinivasan /**
675dee1ad47SJeff Kirsher * ixgbevf_setup_mac_link_vf - Setup MAC link settings
676dee1ad47SJeff Kirsher * @hw: pointer to hardware structure
677dee1ad47SJeff Kirsher * @speed: Unused in this implementation
678dee1ad47SJeff Kirsher * @autoneg: Unused in this implementation
679dee1ad47SJeff Kirsher * @autoneg_wait_to_complete: Unused in this implementation
680dee1ad47SJeff Kirsher *
681dee1ad47SJeff Kirsher * Do nothing and return success. VF drivers are not allowed to change
682dee1ad47SJeff Kirsher * global settings. Maintained for driver compatibility.
683dee1ad47SJeff Kirsher **/
ixgbevf_setup_mac_link_vf(struct ixgbe_hw * hw,ixgbe_link_speed speed,bool autoneg,bool autoneg_wait_to_complete)684dee1ad47SJeff Kirsher static s32 ixgbevf_setup_mac_link_vf(struct ixgbe_hw *hw,
685dee1ad47SJeff Kirsher ixgbe_link_speed speed, bool autoneg,
686dee1ad47SJeff Kirsher bool autoneg_wait_to_complete)
687dee1ad47SJeff Kirsher {
688dee1ad47SJeff Kirsher return 0;
689dee1ad47SJeff Kirsher }
690dee1ad47SJeff Kirsher
691dee1ad47SJeff Kirsher /**
692dee1ad47SJeff Kirsher * ixgbevf_check_mac_link_vf - Get link/speed status
693dee1ad47SJeff Kirsher * @hw: pointer to hardware structure
694dee1ad47SJeff Kirsher * @speed: pointer to link speed
695dee1ad47SJeff Kirsher * @link_up: true is link is up, false otherwise
696e23cf38fSTony Nguyen * @autoneg_wait_to_complete: unused
697dee1ad47SJeff Kirsher *
698dee1ad47SJeff Kirsher * Reads the links register to determine if link is up and the current speed
699dee1ad47SJeff Kirsher **/
ixgbevf_check_mac_link_vf(struct ixgbe_hw * hw,ixgbe_link_speed * speed,bool * link_up,bool autoneg_wait_to_complete)700dee1ad47SJeff Kirsher static s32 ixgbevf_check_mac_link_vf(struct ixgbe_hw *hw,
701dee1ad47SJeff Kirsher ixgbe_link_speed *speed,
702dee1ad47SJeff Kirsher bool *link_up,
703dee1ad47SJeff Kirsher bool autoneg_wait_to_complete)
704dee1ad47SJeff Kirsher {
7054b2cd27fSAlexander Duyck struct ixgbe_mbx_info *mbx = &hw->mbx;
7064b2cd27fSAlexander Duyck struct ixgbe_mac_info *mac = &hw->mac;
7074b2cd27fSAlexander Duyck s32 ret_val = 0;
708dee1ad47SJeff Kirsher u32 links_reg;
7094b2cd27fSAlexander Duyck u32 in_msg = 0;
710dee1ad47SJeff Kirsher
7114b2cd27fSAlexander Duyck /* If we were hit with a reset drop the link */
7124b2cd27fSAlexander Duyck if (!mbx->ops.check_for_rst(hw) || !mbx->timeout)
7134b2cd27fSAlexander Duyck mac->get_link_status = true;
714dee1ad47SJeff Kirsher
7154b2cd27fSAlexander Duyck if (!mac->get_link_status)
7164b2cd27fSAlexander Duyck goto out;
7174b2cd27fSAlexander Duyck
7184b2cd27fSAlexander Duyck /* if link status is down no point in checking to see if pf is up */
719dee1ad47SJeff Kirsher links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
7204b2cd27fSAlexander Duyck if (!(links_reg & IXGBE_LINKS_UP))
7214b2cd27fSAlexander Duyck goto out;
722dee1ad47SJeff Kirsher
723b8a2ca19SEmil Tantilov /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs
724b8a2ca19SEmil Tantilov * before the link status is correct
725b8a2ca19SEmil Tantilov */
726b8a2ca19SEmil Tantilov if (mac->type == ixgbe_mac_82599_vf) {
727b8a2ca19SEmil Tantilov int i;
728b8a2ca19SEmil Tantilov
729b8a2ca19SEmil Tantilov for (i = 0; i < 5; i++) {
730b8a2ca19SEmil Tantilov udelay(100);
731b8a2ca19SEmil Tantilov links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
732b8a2ca19SEmil Tantilov
733b8a2ca19SEmil Tantilov if (!(links_reg & IXGBE_LINKS_UP))
734b8a2ca19SEmil Tantilov goto out;
735b8a2ca19SEmil Tantilov }
736b8a2ca19SEmil Tantilov }
737b8a2ca19SEmil Tantilov
73831a1b375SGreg Rose switch (links_reg & IXGBE_LINKS_SPEED_82599) {
73931a1b375SGreg Rose case IXGBE_LINKS_SPEED_10G_82599:
740dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_10GB_FULL;
74131a1b375SGreg Rose break;
74231a1b375SGreg Rose case IXGBE_LINKS_SPEED_1G_82599:
743dee1ad47SJeff Kirsher *speed = IXGBE_LINK_SPEED_1GB_FULL;
74431a1b375SGreg Rose break;
74531a1b375SGreg Rose case IXGBE_LINKS_SPEED_100_82599:
74631a1b375SGreg Rose *speed = IXGBE_LINK_SPEED_100_FULL;
74731a1b375SGreg Rose break;
74831a1b375SGreg Rose }
749dee1ad47SJeff Kirsher
7504b2cd27fSAlexander Duyck /* if the read failed it could just be a mailbox collision, best wait
751dec0d8e4SJeff Kirsher * until we are called again and don't report an error
752dec0d8e4SJeff Kirsher */
753339f2896SRadoslaw Tyl if (mbx->ops.read(hw, &in_msg, 1)) {
754339f2896SRadoslaw Tyl if (hw->api_version >= ixgbe_mbox_api_15)
755339f2896SRadoslaw Tyl mac->get_link_status = false;
7564b2cd27fSAlexander Duyck goto out;
757339f2896SRadoslaw Tyl }
7584b2cd27fSAlexander Duyck
7594b2cd27fSAlexander Duyck if (!(in_msg & IXGBE_VT_MSGTYPE_CTS)) {
7604b2cd27fSAlexander Duyck /* msg is not CTS and is NACK we must have lost CTS status */
7610edbecd5SRadoslaw Tyl if (in_msg & IXGBE_VT_MSGTYPE_FAILURE)
7624b2cd27fSAlexander Duyck ret_val = -1;
7634b2cd27fSAlexander Duyck goto out;
7644b2cd27fSAlexander Duyck }
7654b2cd27fSAlexander Duyck
7664b2cd27fSAlexander Duyck /* the pf is talking, if we timed out in the past we reinit */
7674b2cd27fSAlexander Duyck if (!mbx->timeout) {
7684b2cd27fSAlexander Duyck ret_val = -1;
7694b2cd27fSAlexander Duyck goto out;
7704b2cd27fSAlexander Duyck }
7714b2cd27fSAlexander Duyck
7724b2cd27fSAlexander Duyck /* if we passed all the tests above then the link is up and we no
773dec0d8e4SJeff Kirsher * longer need to check for link
774dec0d8e4SJeff Kirsher */
7754b2cd27fSAlexander Duyck mac->get_link_status = false;
7764b2cd27fSAlexander Duyck
7774b2cd27fSAlexander Duyck out:
7784b2cd27fSAlexander Duyck *link_up = !mac->get_link_status;
7794b2cd27fSAlexander Duyck return ret_val;
780dee1ad47SJeff Kirsher }
781dee1ad47SJeff Kirsher
782dd1fe113SAlexander Duyck /**
783262de08fSJesse Brandeburg * ixgbevf_hv_check_mac_link_vf - check link
784e23cf38fSTony Nguyen * @hw: pointer to private hardware struct
785e23cf38fSTony Nguyen * @speed: pointer to link speed
786e23cf38fSTony Nguyen * @link_up: true is link is up, false otherwise
787e23cf38fSTony Nguyen * @autoneg_wait_to_complete: unused
788262de08fSJesse Brandeburg *
789262de08fSJesse Brandeburg * Hyper-V variant; there is no mailbox communication.
790c6d45171SKY Srinivasan */
ixgbevf_hv_check_mac_link_vf(struct ixgbe_hw * hw,ixgbe_link_speed * speed,bool * link_up,bool autoneg_wait_to_complete)791c6d45171SKY Srinivasan static s32 ixgbevf_hv_check_mac_link_vf(struct ixgbe_hw *hw,
792c6d45171SKY Srinivasan ixgbe_link_speed *speed,
793c6d45171SKY Srinivasan bool *link_up,
794c6d45171SKY Srinivasan bool autoneg_wait_to_complete)
795c6d45171SKY Srinivasan {
796c6d45171SKY Srinivasan struct ixgbe_mbx_info *mbx = &hw->mbx;
797c6d45171SKY Srinivasan struct ixgbe_mac_info *mac = &hw->mac;
798c6d45171SKY Srinivasan u32 links_reg;
799c6d45171SKY Srinivasan
800c6d45171SKY Srinivasan /* If we were hit with a reset drop the link */
801c6d45171SKY Srinivasan if (!mbx->ops.check_for_rst(hw) || !mbx->timeout)
802c6d45171SKY Srinivasan mac->get_link_status = true;
803c6d45171SKY Srinivasan
804c6d45171SKY Srinivasan if (!mac->get_link_status)
805c6d45171SKY Srinivasan goto out;
806c6d45171SKY Srinivasan
807c6d45171SKY Srinivasan /* if link status is down no point in checking to see if pf is up */
808c6d45171SKY Srinivasan links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
809c6d45171SKY Srinivasan if (!(links_reg & IXGBE_LINKS_UP))
810c6d45171SKY Srinivasan goto out;
811c6d45171SKY Srinivasan
812c6d45171SKY Srinivasan /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs
813c6d45171SKY Srinivasan * before the link status is correct
814c6d45171SKY Srinivasan */
815c6d45171SKY Srinivasan if (mac->type == ixgbe_mac_82599_vf) {
816c6d45171SKY Srinivasan int i;
817c6d45171SKY Srinivasan
818c6d45171SKY Srinivasan for (i = 0; i < 5; i++) {
819c6d45171SKY Srinivasan udelay(100);
820c6d45171SKY Srinivasan links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
821c6d45171SKY Srinivasan
822c6d45171SKY Srinivasan if (!(links_reg & IXGBE_LINKS_UP))
823c6d45171SKY Srinivasan goto out;
824c6d45171SKY Srinivasan }
825c6d45171SKY Srinivasan }
826c6d45171SKY Srinivasan
827c6d45171SKY Srinivasan switch (links_reg & IXGBE_LINKS_SPEED_82599) {
828c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_10G_82599:
829c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_10GB_FULL;
830c6d45171SKY Srinivasan break;
831c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_1G_82599:
832c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_1GB_FULL;
833c6d45171SKY Srinivasan break;
834c6d45171SKY Srinivasan case IXGBE_LINKS_SPEED_100_82599:
835c6d45171SKY Srinivasan *speed = IXGBE_LINK_SPEED_100_FULL;
836c6d45171SKY Srinivasan break;
837c6d45171SKY Srinivasan }
838c6d45171SKY Srinivasan
839c6d45171SKY Srinivasan /* if we passed all the tests above then the link is up and we no
840c6d45171SKY Srinivasan * longer need to check for link
841c6d45171SKY Srinivasan */
842c6d45171SKY Srinivasan mac->get_link_status = false;
843c6d45171SKY Srinivasan
844c6d45171SKY Srinivasan out:
845c6d45171SKY Srinivasan *link_up = !mac->get_link_status;
846c6d45171SKY Srinivasan return 0;
847c6d45171SKY Srinivasan }
848c6d45171SKY Srinivasan
849c6d45171SKY Srinivasan /**
8502f8214feSAlexander Duyck * ixgbevf_set_rlpml_vf - Set the maximum receive packet length
851dd1fe113SAlexander Duyck * @hw: pointer to the HW structure
852dd1fe113SAlexander Duyck * @max_size: value to assign to max frame size
853dd1fe113SAlexander Duyck **/
ixgbevf_set_rlpml_vf(struct ixgbe_hw * hw,u16 max_size)8546a11e52bSTony Nguyen static s32 ixgbevf_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size)
855dd1fe113SAlexander Duyck {
856dd1fe113SAlexander Duyck u32 msgbuf[2];
8576a11e52bSTony Nguyen s32 ret_val;
858dd1fe113SAlexander Duyck
859dd1fe113SAlexander Duyck msgbuf[0] = IXGBE_VF_SET_LPE;
860dd1fe113SAlexander Duyck msgbuf[1] = max_size;
8616a11e52bSTony Nguyen
862c6426971SEmil Tantilov ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
8634078ea37SColin Ian King ARRAY_SIZE(msgbuf));
8646a11e52bSTony Nguyen if (ret_val)
8656a11e52bSTony Nguyen return ret_val;
8666a11e52bSTony Nguyen if ((msgbuf[0] & IXGBE_VF_SET_LPE) &&
8670edbecd5SRadoslaw Tyl (msgbuf[0] & IXGBE_VT_MSGTYPE_FAILURE))
8686a11e52bSTony Nguyen return IXGBE_ERR_MBX;
8696a11e52bSTony Nguyen
8706a11e52bSTony Nguyen return 0;
871dd1fe113SAlexander Duyck }
872dd1fe113SAlexander Duyck
87331186785SAlexander Duyck /**
8742f8214feSAlexander Duyck * ixgbevf_hv_set_rlpml_vf - Set the maximum receive packet length
875c6d45171SKY Srinivasan * @hw: pointer to the HW structure
876c6d45171SKY Srinivasan * @max_size: value to assign to max frame size
877c6d45171SKY Srinivasan * Hyper-V variant.
878c6d45171SKY Srinivasan **/
ixgbevf_hv_set_rlpml_vf(struct ixgbe_hw * hw,u16 max_size)8796a11e52bSTony Nguyen static s32 ixgbevf_hv_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size)
880c6d45171SKY Srinivasan {
881c6d45171SKY Srinivasan u32 reg;
882c6d45171SKY Srinivasan
883c6d45171SKY Srinivasan /* If we are on Hyper-V, we implement this functionality
884c6d45171SKY Srinivasan * differently.
885c6d45171SKY Srinivasan */
886c6d45171SKY Srinivasan reg = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(0));
887c6d45171SKY Srinivasan /* CRC == 4 */
888c6d45171SKY Srinivasan reg |= ((max_size + 4) | IXGBE_RXDCTL_RLPML_EN);
889c6d45171SKY Srinivasan IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(0), reg);
8906a11e52bSTony Nguyen
8916a11e52bSTony Nguyen return 0;
892c6d45171SKY Srinivasan }
893c6d45171SKY Srinivasan
894c6d45171SKY Srinivasan /**
8957921f4dcSAlexander Duyck * ixgbevf_negotiate_api_version_vf - Negotiate supported API version
89631186785SAlexander Duyck * @hw: pointer to the HW structure
89731186785SAlexander Duyck * @api: integer containing requested API version
89831186785SAlexander Duyck **/
ixgbevf_negotiate_api_version_vf(struct ixgbe_hw * hw,int api)8997921f4dcSAlexander Duyck static int ixgbevf_negotiate_api_version_vf(struct ixgbe_hw *hw, int api)
90031186785SAlexander Duyck {
90131186785SAlexander Duyck int err;
90231186785SAlexander Duyck u32 msg[3];
90331186785SAlexander Duyck
90431186785SAlexander Duyck /* Negotiate the mailbox API version */
90531186785SAlexander Duyck msg[0] = IXGBE_VF_API_NEGOTIATE;
90631186785SAlexander Duyck msg[1] = api;
90731186785SAlexander Duyck msg[2] = 0;
90831186785SAlexander Duyck
9094078ea37SColin Ian King err = ixgbevf_write_msg_read_ack(hw, msg, msg, ARRAY_SIZE(msg));
91031186785SAlexander Duyck if (!err) {
91131186785SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS;
91231186785SAlexander Duyck
91331186785SAlexander Duyck /* Store value and return 0 on success */
9140edbecd5SRadoslaw Tyl if (msg[0] == (IXGBE_VF_API_NEGOTIATE |
9150edbecd5SRadoslaw Tyl IXGBE_VT_MSGTYPE_SUCCESS)) {
91631186785SAlexander Duyck hw->api_version = api;
91731186785SAlexander Duyck return 0;
91831186785SAlexander Duyck }
91931186785SAlexander Duyck
92031186785SAlexander Duyck err = IXGBE_ERR_INVALID_ARGUMENT;
92131186785SAlexander Duyck }
92231186785SAlexander Duyck
92331186785SAlexander Duyck return err;
92431186785SAlexander Duyck }
92531186785SAlexander Duyck
926c6d45171SKY Srinivasan /**
9272f8214feSAlexander Duyck * ixgbevf_hv_negotiate_api_version_vf - Negotiate supported API version
928c6d45171SKY Srinivasan * @hw: pointer to the HW structure
929c6d45171SKY Srinivasan * @api: integer containing requested API version
930c6d45171SKY Srinivasan * Hyper-V version - only ixgbe_mbox_api_10 supported.
931c6d45171SKY Srinivasan **/
ixgbevf_hv_negotiate_api_version_vf(struct ixgbe_hw * hw,int api)9322f8214feSAlexander Duyck static int ixgbevf_hv_negotiate_api_version_vf(struct ixgbe_hw *hw, int api)
933c6d45171SKY Srinivasan {
934c6d45171SKY Srinivasan /* Hyper-V only supports api version ixgbe_mbox_api_10 */
935c6d45171SKY Srinivasan if (api != ixgbe_mbox_api_10)
936c6d45171SKY Srinivasan return IXGBE_ERR_INVALID_ARGUMENT;
937c6d45171SKY Srinivasan
938c6d45171SKY Srinivasan return 0;
939c6d45171SKY Srinivasan }
940c6d45171SKY Srinivasan
ixgbevf_get_queues(struct ixgbe_hw * hw,unsigned int * num_tcs,unsigned int * default_tc)94156e94095SAlexander Duyck int ixgbevf_get_queues(struct ixgbe_hw *hw, unsigned int *num_tcs,
94256e94095SAlexander Duyck unsigned int *default_tc)
94356e94095SAlexander Duyck {
94456e94095SAlexander Duyck int err;
94556e94095SAlexander Duyck u32 msg[5];
94656e94095SAlexander Duyck
94756e94095SAlexander Duyck /* do nothing if API doesn't support ixgbevf_get_queues */
94856e94095SAlexander Duyck switch (hw->api_version) {
94956e94095SAlexander Duyck case ixgbe_mbox_api_11:
95094cf66f8SVlad Zolotarov case ixgbe_mbox_api_12:
95141e544cdSDon Skidmore case ixgbe_mbox_api_13:
9527f68d430SShannon Nelson case ixgbe_mbox_api_14:
953339f2896SRadoslaw Tyl case ixgbe_mbox_api_15:
95456e94095SAlexander Duyck break;
95556e94095SAlexander Duyck default:
95656e94095SAlexander Duyck return 0;
95756e94095SAlexander Duyck }
95856e94095SAlexander Duyck
95956e94095SAlexander Duyck /* Fetch queue configuration from the PF */
96056e94095SAlexander Duyck msg[0] = IXGBE_VF_GET_QUEUE;
96156e94095SAlexander Duyck msg[1] = msg[2] = msg[3] = msg[4] = 0;
96256e94095SAlexander Duyck
9634078ea37SColin Ian King err = ixgbevf_write_msg_read_ack(hw, msg, msg, ARRAY_SIZE(msg));
96456e94095SAlexander Duyck if (!err) {
96556e94095SAlexander Duyck msg[0] &= ~IXGBE_VT_MSGTYPE_CTS;
96656e94095SAlexander Duyck
967*8bfb7869SJilin Yuan /* if we didn't get an ACK there must have been
96856e94095SAlexander Duyck * some sort of mailbox error so we should treat it
96956e94095SAlexander Duyck * as such
97056e94095SAlexander Duyck */
9710edbecd5SRadoslaw Tyl if (msg[0] != (IXGBE_VF_GET_QUEUE | IXGBE_VT_MSGTYPE_SUCCESS))
97256e94095SAlexander Duyck return IXGBE_ERR_MBX;
97356e94095SAlexander Duyck
97456e94095SAlexander Duyck /* record and validate values from message */
97556e94095SAlexander Duyck hw->mac.max_tx_queues = msg[IXGBE_VF_TX_QUEUES];
97656e94095SAlexander Duyck if (hw->mac.max_tx_queues == 0 ||
97756e94095SAlexander Duyck hw->mac.max_tx_queues > IXGBE_VF_MAX_TX_QUEUES)
97856e94095SAlexander Duyck hw->mac.max_tx_queues = IXGBE_VF_MAX_TX_QUEUES;
97956e94095SAlexander Duyck
98056e94095SAlexander Duyck hw->mac.max_rx_queues = msg[IXGBE_VF_RX_QUEUES];
98156e94095SAlexander Duyck if (hw->mac.max_rx_queues == 0 ||
98256e94095SAlexander Duyck hw->mac.max_rx_queues > IXGBE_VF_MAX_RX_QUEUES)
98356e94095SAlexander Duyck hw->mac.max_rx_queues = IXGBE_VF_MAX_RX_QUEUES;
98456e94095SAlexander Duyck
98556e94095SAlexander Duyck *num_tcs = msg[IXGBE_VF_TRANS_VLAN];
98656e94095SAlexander Duyck /* in case of unknown state assume we cannot tag frames */
98756e94095SAlexander Duyck if (*num_tcs > hw->mac.max_rx_queues)
98856e94095SAlexander Duyck *num_tcs = 1;
98956e94095SAlexander Duyck
99056e94095SAlexander Duyck *default_tc = msg[IXGBE_VF_DEF_QUEUE];
99156e94095SAlexander Duyck /* default to queue 0 on out-of-bounds queue number */
99256e94095SAlexander Duyck if (*default_tc >= hw->mac.max_tx_queues)
99356e94095SAlexander Duyck *default_tc = 0;
99456e94095SAlexander Duyck }
99556e94095SAlexander Duyck
99656e94095SAlexander Duyck return err;
99756e94095SAlexander Duyck }
99856e94095SAlexander Duyck
9993d8fe98fSStephen Hemminger static const struct ixgbe_mac_operations ixgbevf_mac_ops = {
1000dee1ad47SJeff Kirsher .init_hw = ixgbevf_init_hw_vf,
1001dee1ad47SJeff Kirsher .reset_hw = ixgbevf_reset_hw_vf,
1002dee1ad47SJeff Kirsher .start_hw = ixgbevf_start_hw_vf,
1003dee1ad47SJeff Kirsher .get_mac_addr = ixgbevf_get_mac_addr_vf,
1004dee1ad47SJeff Kirsher .stop_adapter = ixgbevf_stop_hw_vf,
1005dee1ad47SJeff Kirsher .setup_link = ixgbevf_setup_mac_link_vf,
1006dee1ad47SJeff Kirsher .check_link = ixgbevf_check_mac_link_vf,
10077921f4dcSAlexander Duyck .negotiate_api_version = ixgbevf_negotiate_api_version_vf,
1008dee1ad47SJeff Kirsher .set_rar = ixgbevf_set_rar_vf,
1009dee1ad47SJeff Kirsher .update_mc_addr_list = ixgbevf_update_mc_addr_list_vf,
10108443c1a4SHiroshi Shimamoto .update_xcast_mode = ixgbevf_update_xcast_mode,
1011443ebdd6SSlawomir Mrozowicz .get_link_state = ixgbevf_get_link_state_vf,
1012dee1ad47SJeff Kirsher .set_uc_addr = ixgbevf_set_uc_addr_vf,
1013dee1ad47SJeff Kirsher .set_vfta = ixgbevf_set_vfta_vf,
10142f8214feSAlexander Duyck .set_rlpml = ixgbevf_set_rlpml_vf,
1015dee1ad47SJeff Kirsher };
1016dee1ad47SJeff Kirsher
1017c6d45171SKY Srinivasan static const struct ixgbe_mac_operations ixgbevf_hv_mac_ops = {
1018c6d45171SKY Srinivasan .init_hw = ixgbevf_init_hw_vf,
1019c6d45171SKY Srinivasan .reset_hw = ixgbevf_hv_reset_hw_vf,
1020c6d45171SKY Srinivasan .start_hw = ixgbevf_start_hw_vf,
1021c6d45171SKY Srinivasan .get_mac_addr = ixgbevf_get_mac_addr_vf,
1022c6d45171SKY Srinivasan .stop_adapter = ixgbevf_stop_hw_vf,
1023c6d45171SKY Srinivasan .setup_link = ixgbevf_setup_mac_link_vf,
1024c6d45171SKY Srinivasan .check_link = ixgbevf_hv_check_mac_link_vf,
10252f8214feSAlexander Duyck .negotiate_api_version = ixgbevf_hv_negotiate_api_version_vf,
1026c6d45171SKY Srinivasan .set_rar = ixgbevf_hv_set_rar_vf,
1027c6d45171SKY Srinivasan .update_mc_addr_list = ixgbevf_hv_update_mc_addr_list_vf,
1028c6d45171SKY Srinivasan .update_xcast_mode = ixgbevf_hv_update_xcast_mode,
1029443ebdd6SSlawomir Mrozowicz .get_link_state = ixgbevf_hv_get_link_state_vf,
1030c6d45171SKY Srinivasan .set_uc_addr = ixgbevf_hv_set_uc_addr_vf,
1031c6d45171SKY Srinivasan .set_vfta = ixgbevf_hv_set_vfta_vf,
10322f8214feSAlexander Duyck .set_rlpml = ixgbevf_hv_set_rlpml_vf,
1033c6d45171SKY Srinivasan };
1034c6d45171SKY Srinivasan
10353d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_82599_vf_info = {
1036dee1ad47SJeff Kirsher .mac = ixgbe_mac_82599_vf,
1037dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops,
1038dee1ad47SJeff Kirsher };
1039dee1ad47SJeff Kirsher
1040c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_82599_vf_hv_info = {
1041c6d45171SKY Srinivasan .mac = ixgbe_mac_82599_vf,
1042c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops,
1043c6d45171SKY Srinivasan };
1044c6d45171SKY Srinivasan
10453d8fe98fSStephen Hemminger const struct ixgbevf_info ixgbevf_X540_vf_info = {
1046dee1ad47SJeff Kirsher .mac = ixgbe_mac_X540_vf,
1047dee1ad47SJeff Kirsher .mac_ops = &ixgbevf_mac_ops,
1048dee1ad47SJeff Kirsher };
104947068b0dSEmil Tantilov
1050c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X540_vf_hv_info = {
1051c6d45171SKY Srinivasan .mac = ixgbe_mac_X540_vf,
1052c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops,
1053c6d45171SKY Srinivasan };
1054c6d45171SKY Srinivasan
105547068b0dSEmil Tantilov const struct ixgbevf_info ixgbevf_X550_vf_info = {
105647068b0dSEmil Tantilov .mac = ixgbe_mac_X550_vf,
105747068b0dSEmil Tantilov .mac_ops = &ixgbevf_mac_ops,
105847068b0dSEmil Tantilov };
105947068b0dSEmil Tantilov
1060c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X550_vf_hv_info = {
1061c6d45171SKY Srinivasan .mac = ixgbe_mac_X550_vf,
1062c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops,
1063c6d45171SKY Srinivasan };
1064c6d45171SKY Srinivasan
106547068b0dSEmil Tantilov const struct ixgbevf_info ixgbevf_X550EM_x_vf_info = {
106647068b0dSEmil Tantilov .mac = ixgbe_mac_X550EM_x_vf,
106747068b0dSEmil Tantilov .mac_ops = &ixgbevf_mac_ops,
106847068b0dSEmil Tantilov };
1069c6d45171SKY Srinivasan
1070c6d45171SKY Srinivasan const struct ixgbevf_info ixgbevf_X550EM_x_vf_hv_info = {
1071c6d45171SKY Srinivasan .mac = ixgbe_mac_X550EM_x_vf,
1072c6d45171SKY Srinivasan .mac_ops = &ixgbevf_hv_mac_ops,
1073c6d45171SKY Srinivasan };
10741d94f987SDon Skidmore
10751d94f987SDon Skidmore const struct ixgbevf_info ixgbevf_x550em_a_vf_info = {
10761d94f987SDon Skidmore .mac = ixgbe_mac_x550em_a_vf,
10771d94f987SDon Skidmore .mac_ops = &ixgbevf_mac_ops,
10781d94f987SDon Skidmore };
1079