1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* Copyright(c) 1999 - 2018 Intel Corporation. */ |
3 | |
4 | #include "vf.h" |
5 | #include "ixgbevf.h" |
6 | |
7 | /* On Hyper-V, to reset, we need to read from this offset |
8 | * from the PCI config space. This is the mechanism used on |
9 | * Hyper-V to support PF/VF communication. |
10 | */ |
11 | #define IXGBE_HV_RESET_OFFSET 0x201 |
12 | |
13 | static inline s32 ixgbevf_write_msg_read_ack(struct ixgbe_hw *hw, u32 *msg, |
14 | u32 *retmsg, u16 size) |
15 | { |
16 | s32 retval = ixgbevf_write_mbx(hw, msg, size); |
17 | |
18 | if (retval) |
19 | return retval; |
20 | |
21 | return ixgbevf_poll_mbx(hw, msg: retmsg, size); |
22 | } |
23 | |
24 | /** |
25 | * ixgbevf_start_hw_vf - Prepare hardware for Tx/Rx |
26 | * @hw: pointer to hardware structure |
27 | * |
28 | * Starts the hardware by filling the bus info structure and media type, clears |
29 | * all on chip counters, initializes receive address registers, multicast |
30 | * table, VLAN filter table, calls routine to set up link and flow control |
31 | * settings, and leaves transmit and receive units disabled and uninitialized |
32 | **/ |
33 | static s32 ixgbevf_start_hw_vf(struct ixgbe_hw *hw) |
34 | { |
35 | /* Clear adapter stopped flag */ |
36 | hw->adapter_stopped = false; |
37 | |
38 | return 0; |
39 | } |
40 | |
41 | /** |
42 | * ixgbevf_init_hw_vf - virtual function hardware initialization |
43 | * @hw: pointer to hardware structure |
44 | * |
45 | * Initialize the hardware by resetting the hardware and then starting |
46 | * the hardware |
47 | **/ |
48 | static s32 ixgbevf_init_hw_vf(struct ixgbe_hw *hw) |
49 | { |
50 | s32 status = hw->mac.ops.start_hw(hw); |
51 | |
52 | hw->mac.ops.get_mac_addr(hw, hw->mac.addr); |
53 | |
54 | return status; |
55 | } |
56 | |
57 | /** |
58 | * ixgbevf_reset_hw_vf - Performs hardware reset |
59 | * @hw: pointer to hardware structure |
60 | * |
61 | * Resets the hardware by resetting the transmit and receive units, masks and |
62 | * clears all interrupts. |
63 | **/ |
64 | static s32 ixgbevf_reset_hw_vf(struct ixgbe_hw *hw) |
65 | { |
66 | struct ixgbe_mbx_info *mbx = &hw->mbx; |
67 | u32 timeout = IXGBE_VF_INIT_TIMEOUT; |
68 | u32 msgbuf[IXGBE_VF_PERMADDR_MSG_LEN]; |
69 | u8 *addr = (u8 *)(&msgbuf[1]); |
70 | s32 ret_val; |
71 | |
72 | /* Call adapter stop to disable tx/rx and clear interrupts */ |
73 | hw->mac.ops.stop_adapter(hw); |
74 | |
75 | /* reset the api version */ |
76 | hw->api_version = ixgbe_mbox_api_10; |
77 | hw->mbx.ops.init_params(hw); |
78 | memcpy(&hw->mbx.ops, &ixgbevf_mbx_ops_legacy, |
79 | sizeof(struct ixgbe_mbx_operations)); |
80 | |
81 | IXGBE_WRITE_REG(hw, IXGBE_VFCTRL, IXGBE_CTRL_RST); |
82 | IXGBE_WRITE_FLUSH(hw); |
83 | |
84 | /* we cannot reset while the RSTI / RSTD bits are asserted */ |
85 | while (!mbx->ops.check_for_rst(hw) && timeout) { |
86 | timeout--; |
87 | udelay(5); |
88 | } |
89 | |
90 | if (!timeout) |
91 | return IXGBE_ERR_RESET_FAILED; |
92 | |
93 | /* mailbox timeout can now become active */ |
94 | mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT; |
95 | |
96 | msgbuf[0] = IXGBE_VF_RESET; |
97 | ixgbevf_write_mbx(hw, msg: msgbuf, size: 1); |
98 | |
99 | mdelay(10); |
100 | |
101 | /* set our "perm_addr" based on info provided by PF |
102 | * also set up the mc_filter_type which is piggy backed |
103 | * on the mac address in word 3 |
104 | */ |
105 | ret_val = ixgbevf_poll_mbx(hw, msg: msgbuf, IXGBE_VF_PERMADDR_MSG_LEN); |
106 | if (ret_val) |
107 | return ret_val; |
108 | |
109 | /* New versions of the PF may NACK the reset return message |
110 | * to indicate that no MAC address has yet been assigned for |
111 | * the VF. |
112 | */ |
113 | if (msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_SUCCESS) && |
114 | msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_FAILURE)) |
115 | return IXGBE_ERR_INVALID_MAC_ADDR; |
116 | |
117 | if (msgbuf[0] == (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_SUCCESS)) |
118 | ether_addr_copy(dst: hw->mac.perm_addr, src: addr); |
119 | |
120 | hw->mac.mc_filter_type = msgbuf[IXGBE_VF_MC_TYPE_WORD]; |
121 | |
122 | return 0; |
123 | } |
124 | |
125 | /** |
126 | * ixgbevf_hv_reset_hw_vf - reset via Hyper-V |
127 | * @hw: pointer to private hardware struct |
128 | * |
129 | * Hyper-V variant; the VF/PF communication is through the PCI |
130 | * config space. |
131 | */ |
132 | static s32 ixgbevf_hv_reset_hw_vf(struct ixgbe_hw *hw) |
133 | { |
134 | #if IS_ENABLED(CONFIG_PCI_MMCONFIG) |
135 | struct ixgbevf_adapter *adapter = hw->back; |
136 | int i; |
137 | |
138 | for (i = 0; i < 6; i++) |
139 | pci_read_config_byte(dev: adapter->pdev, |
140 | where: (i + IXGBE_HV_RESET_OFFSET), |
141 | val: &hw->mac.perm_addr[i]); |
142 | return 0; |
143 | #else |
144 | pr_err("PCI_MMCONFIG needs to be enabled for Hyper-V\n" ); |
145 | return -EOPNOTSUPP; |
146 | #endif |
147 | } |
148 | |
149 | /** |
150 | * ixgbevf_stop_hw_vf - Generic stop Tx/Rx units |
151 | * @hw: pointer to hardware structure |
152 | * |
153 | * Sets the adapter_stopped flag within ixgbe_hw struct. Clears interrupts, |
154 | * disables transmit and receive units. The adapter_stopped flag is used by |
155 | * the shared code and drivers to determine if the adapter is in a stopped |
156 | * state and should not touch the hardware. |
157 | **/ |
158 | static s32 ixgbevf_stop_hw_vf(struct ixgbe_hw *hw) |
159 | { |
160 | u32 number_of_queues; |
161 | u32 reg_val; |
162 | u16 i; |
163 | |
164 | /* Set the adapter_stopped flag so other driver functions stop touching |
165 | * the hardware |
166 | */ |
167 | hw->adapter_stopped = true; |
168 | |
169 | /* Disable the receive unit by stopped each queue */ |
170 | number_of_queues = hw->mac.max_rx_queues; |
171 | for (i = 0; i < number_of_queues; i++) { |
172 | reg_val = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); |
173 | if (reg_val & IXGBE_RXDCTL_ENABLE) { |
174 | reg_val &= ~IXGBE_RXDCTL_ENABLE; |
175 | IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), reg_val); |
176 | } |
177 | } |
178 | |
179 | IXGBE_WRITE_FLUSH(hw); |
180 | |
181 | /* Clear interrupt mask to stop from interrupts being generated */ |
182 | IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, IXGBE_VF_IRQ_CLEAR_MASK); |
183 | |
184 | /* Clear any pending interrupts */ |
185 | IXGBE_READ_REG(hw, IXGBE_VTEICR); |
186 | |
187 | /* Disable the transmit unit. Each queue must be disabled. */ |
188 | number_of_queues = hw->mac.max_tx_queues; |
189 | for (i = 0; i < number_of_queues; i++) { |
190 | reg_val = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i)); |
191 | if (reg_val & IXGBE_TXDCTL_ENABLE) { |
192 | reg_val &= ~IXGBE_TXDCTL_ENABLE; |
193 | IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), reg_val); |
194 | } |
195 | } |
196 | |
197 | return 0; |
198 | } |
199 | |
200 | /** |
201 | * ixgbevf_mta_vector - Determines bit-vector in multicast table to set |
202 | * @hw: pointer to hardware structure |
203 | * @mc_addr: the multicast address |
204 | * |
205 | * Extracts the 12 bits, from a multicast address, to determine which |
206 | * bit-vector to set in the multicast table. The hardware uses 12 bits, from |
207 | * incoming Rx multicast addresses, to determine the bit-vector to check in |
208 | * the MTA. Which of the 4 combination, of 12-bits, the hardware uses is set |
209 | * by the MO field of the MCSTCTRL. The MO field is set during initialization |
210 | * to mc_filter_type. |
211 | **/ |
212 | static s32 ixgbevf_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr) |
213 | { |
214 | u32 vector = 0; |
215 | |
216 | switch (hw->mac.mc_filter_type) { |
217 | case 0: /* use bits [47:36] of the address */ |
218 | vector = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4)); |
219 | break; |
220 | case 1: /* use bits [46:35] of the address */ |
221 | vector = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5)); |
222 | break; |
223 | case 2: /* use bits [45:34] of the address */ |
224 | vector = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6)); |
225 | break; |
226 | case 3: /* use bits [43:32] of the address */ |
227 | vector = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8)); |
228 | break; |
229 | default: /* Invalid mc_filter_type */ |
230 | break; |
231 | } |
232 | |
233 | /* vector can only be 12-bits or boundary will be exceeded */ |
234 | vector &= 0xFFF; |
235 | return vector; |
236 | } |
237 | |
238 | /** |
239 | * ixgbevf_get_mac_addr_vf - Read device MAC address |
240 | * @hw: pointer to the HW structure |
241 | * @mac_addr: pointer to storage for retrieved MAC address |
242 | **/ |
243 | static s32 ixgbevf_get_mac_addr_vf(struct ixgbe_hw *hw, u8 *mac_addr) |
244 | { |
245 | ether_addr_copy(dst: mac_addr, src: hw->mac.perm_addr); |
246 | |
247 | return 0; |
248 | } |
249 | |
250 | static s32 ixgbevf_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr) |
251 | { |
252 | u32 msgbuf[3], msgbuf_chk; |
253 | u8 *msg_addr = (u8 *)(&msgbuf[1]); |
254 | s32 ret_val; |
255 | |
256 | memset(msgbuf, 0, sizeof(msgbuf)); |
257 | /* If index is one then this is the start of a new list and needs |
258 | * indication to the PF so it can do it's own list management. |
259 | * If it is zero then that tells the PF to just clear all of |
260 | * this VF's macvlans and there is no new list. |
261 | */ |
262 | msgbuf[0] |= index << IXGBE_VT_MSGINFO_SHIFT; |
263 | msgbuf[0] |= IXGBE_VF_SET_MACVLAN; |
264 | msgbuf_chk = msgbuf[0]; |
265 | |
266 | if (addr) |
267 | ether_addr_copy(dst: msg_addr, src: addr); |
268 | |
269 | ret_val = ixgbevf_write_msg_read_ack(hw, msg: msgbuf, retmsg: msgbuf, |
270 | ARRAY_SIZE(msgbuf)); |
271 | if (!ret_val) { |
272 | msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; |
273 | |
274 | if (msgbuf[0] == (msgbuf_chk | IXGBE_VT_MSGTYPE_FAILURE)) |
275 | return -ENOMEM; |
276 | } |
277 | |
278 | return ret_val; |
279 | } |
280 | |
281 | static s32 ixgbevf_hv_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr) |
282 | { |
283 | return -EOPNOTSUPP; |
284 | } |
285 | |
286 | /** |
287 | * ixgbevf_get_reta_locked - get the RSS redirection table (RETA) contents. |
288 | * @hw: pointer to hardware structure |
289 | * @reta: buffer to fill with RETA contents. |
290 | * @num_rx_queues: Number of Rx queues configured for this port |
291 | * |
292 | * The "reta" buffer should be big enough to contain 32 registers. |
293 | * |
294 | * Returns: 0 on success. |
295 | * if API doesn't support this operation - (-EOPNOTSUPP). |
296 | */ |
297 | int ixgbevf_get_reta_locked(struct ixgbe_hw *hw, u32 *reta, int num_rx_queues) |
298 | { |
299 | int err, i, j; |
300 | u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; |
301 | u32 *hw_reta = &msgbuf[1]; |
302 | u32 mask = 0; |
303 | |
304 | /* We have to use a mailbox for 82599 and x540 devices only. |
305 | * For these devices RETA has 128 entries. |
306 | * Also these VFs support up to 4 RSS queues. Therefore PF will compress |
307 | * 16 RETA entries in each DWORD giving 2 bits to each entry. |
308 | */ |
309 | int dwords = IXGBEVF_82599_RETA_SIZE / 16; |
310 | |
311 | /* We support the RSS querying for 82599 and x540 devices only. |
312 | * Thus return an error if API doesn't support RETA querying or querying |
313 | * is not supported for this device type. |
314 | */ |
315 | switch (hw->api_version) { |
316 | case ixgbe_mbox_api_15: |
317 | case ixgbe_mbox_api_14: |
318 | case ixgbe_mbox_api_13: |
319 | case ixgbe_mbox_api_12: |
320 | if (hw->mac.type < ixgbe_mac_X550_vf) |
321 | break; |
322 | fallthrough; |
323 | default: |
324 | return -EOPNOTSUPP; |
325 | } |
326 | |
327 | msgbuf[0] = IXGBE_VF_GET_RETA; |
328 | |
329 | err = ixgbevf_write_mbx(hw, msg: msgbuf, size: 1); |
330 | |
331 | if (err) |
332 | return err; |
333 | |
334 | err = ixgbevf_poll_mbx(hw, msg: msgbuf, size: dwords + 1); |
335 | |
336 | if (err) |
337 | return err; |
338 | |
339 | msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; |
340 | |
341 | /* If the operation has been refused by a PF return -EPERM */ |
342 | if (msgbuf[0] == (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_FAILURE)) |
343 | return -EPERM; |
344 | |
345 | /* If we didn't get an ACK there must have been |
346 | * some sort of mailbox error so we should treat it |
347 | * as such. |
348 | */ |
349 | if (msgbuf[0] != (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_SUCCESS)) |
350 | return IXGBE_ERR_MBX; |
351 | |
352 | /* ixgbevf doesn't support more than 2 queues at the moment */ |
353 | if (num_rx_queues > 1) |
354 | mask = 0x1; |
355 | |
356 | for (i = 0; i < dwords; i++) |
357 | for (j = 0; j < 16; j++) |
358 | reta[i * 16 + j] = (hw_reta[i] >> (2 * j)) & mask; |
359 | |
360 | return 0; |
361 | } |
362 | |
363 | /** |
364 | * ixgbevf_get_rss_key_locked - get the RSS Random Key |
365 | * @hw: pointer to the HW structure |
366 | * @rss_key: buffer to fill with RSS Hash Key contents. |
367 | * |
368 | * The "rss_key" buffer should be big enough to contain 10 registers. |
369 | * |
370 | * Returns: 0 on success. |
371 | * if API doesn't support this operation - (-EOPNOTSUPP). |
372 | */ |
373 | int (struct ixgbe_hw *hw, u8 *) |
374 | { |
375 | int err; |
376 | u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; |
377 | |
378 | /* We currently support the RSS Random Key retrieval for 82599 and x540 |
379 | * devices only. |
380 | * |
381 | * Thus return an error if API doesn't support RSS Random Key retrieval |
382 | * or if the operation is not supported for this device type. |
383 | */ |
384 | switch (hw->api_version) { |
385 | case ixgbe_mbox_api_15: |
386 | case ixgbe_mbox_api_14: |
387 | case ixgbe_mbox_api_13: |
388 | case ixgbe_mbox_api_12: |
389 | if (hw->mac.type < ixgbe_mac_X550_vf) |
390 | break; |
391 | fallthrough; |
392 | default: |
393 | return -EOPNOTSUPP; |
394 | } |
395 | |
396 | msgbuf[0] = IXGBE_VF_GET_RSS_KEY; |
397 | err = ixgbevf_write_mbx(hw, msg: msgbuf, size: 1); |
398 | |
399 | if (err) |
400 | return err; |
401 | |
402 | err = ixgbevf_poll_mbx(hw, msg: msgbuf, size: 11); |
403 | |
404 | if (err) |
405 | return err; |
406 | |
407 | msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; |
408 | |
409 | /* If the operation has been refused by a PF return -EPERM */ |
410 | if (msgbuf[0] == (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_FAILURE)) |
411 | return -EPERM; |
412 | |
413 | /* If we didn't get an ACK there must have been |
414 | * some sort of mailbox error so we should treat it |
415 | * as such. |
416 | */ |
417 | if (msgbuf[0] != (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_SUCCESS)) |
418 | return IXGBE_ERR_MBX; |
419 | |
420 | memcpy(rss_key, msgbuf + 1, IXGBEVF_RSS_HASH_KEY_SIZE); |
421 | |
422 | return 0; |
423 | } |
424 | |
425 | /** |
426 | * ixgbevf_set_rar_vf - set device MAC address |
427 | * @hw: pointer to hardware structure |
428 | * @index: Receive address register to write |
429 | * @addr: Address to put into receive address register |
430 | * @vmdq: Unused in this implementation |
431 | **/ |
432 | static s32 ixgbevf_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr, |
433 | u32 vmdq) |
434 | { |
435 | u32 msgbuf[3]; |
436 | u8 *msg_addr = (u8 *)(&msgbuf[1]); |
437 | s32 ret_val; |
438 | |
439 | memset(msgbuf, 0, sizeof(msgbuf)); |
440 | msgbuf[0] = IXGBE_VF_SET_MAC_ADDR; |
441 | ether_addr_copy(dst: msg_addr, src: addr); |
442 | |
443 | ret_val = ixgbevf_write_msg_read_ack(hw, msg: msgbuf, retmsg: msgbuf, |
444 | ARRAY_SIZE(msgbuf)); |
445 | msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; |
446 | |
447 | /* if nacked the address was rejected, use "perm_addr" */ |
448 | if (!ret_val && |
449 | (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_FAILURE))) { |
450 | ixgbevf_get_mac_addr_vf(hw, mac_addr: hw->mac.addr); |
451 | return IXGBE_ERR_MBX; |
452 | } |
453 | |
454 | return ret_val; |
455 | } |
456 | |
457 | /** |
458 | * ixgbevf_hv_set_rar_vf - set device MAC address Hyper-V variant |
459 | * @hw: pointer to hardware structure |
460 | * @index: Receive address register to write |
461 | * @addr: Address to put into receive address register |
462 | * @vmdq: Unused in this implementation |
463 | * |
464 | * We don't really allow setting the device MAC address. However, |
465 | * if the address being set is the permanent MAC address we will |
466 | * permit that. |
467 | **/ |
468 | static s32 ixgbevf_hv_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr, |
469 | u32 vmdq) |
470 | { |
471 | if (ether_addr_equal(addr1: addr, addr2: hw->mac.perm_addr)) |
472 | return 0; |
473 | |
474 | return -EOPNOTSUPP; |
475 | } |
476 | |
477 | /** |
478 | * ixgbevf_update_mc_addr_list_vf - Update Multicast addresses |
479 | * @hw: pointer to the HW structure |
480 | * @netdev: pointer to net device structure |
481 | * |
482 | * Updates the Multicast Table Array. |
483 | **/ |
484 | static s32 ixgbevf_update_mc_addr_list_vf(struct ixgbe_hw *hw, |
485 | struct net_device *netdev) |
486 | { |
487 | struct netdev_hw_addr *ha; |
488 | u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; |
489 | u16 *vector_list = (u16 *)&msgbuf[1]; |
490 | u32 cnt, i; |
491 | |
492 | /* Each entry in the list uses 1 16 bit word. We have 30 |
493 | * 16 bit words available in our HW msg buffer (minus 1 for the |
494 | * msg type). That's 30 hash values if we pack 'em right. If |
495 | * there are more than 30 MC addresses to add then punt the |
496 | * extras for now and then add code to handle more than 30 later. |
497 | * It would be unusual for a server to request that many multi-cast |
498 | * addresses except for in large enterprise network environments. |
499 | */ |
500 | |
501 | cnt = netdev_mc_count(netdev); |
502 | if (cnt > 30) |
503 | cnt = 30; |
504 | msgbuf[0] = IXGBE_VF_SET_MULTICAST; |
505 | msgbuf[0] |= cnt << IXGBE_VT_MSGINFO_SHIFT; |
506 | |
507 | i = 0; |
508 | netdev_for_each_mc_addr(ha, netdev) { |
509 | if (i == cnt) |
510 | break; |
511 | if (is_link_local_ether_addr(addr: ha->addr)) |
512 | continue; |
513 | |
514 | vector_list[i++] = ixgbevf_mta_vector(hw, mc_addr: ha->addr); |
515 | } |
516 | |
517 | return ixgbevf_write_msg_read_ack(hw, msg: msgbuf, retmsg: msgbuf, |
518 | IXGBE_VFMAILBOX_SIZE); |
519 | } |
520 | |
521 | /** |
522 | * ixgbevf_hv_update_mc_addr_list_vf - stub |
523 | * @hw: unused |
524 | * @netdev: unused |
525 | * |
526 | * Hyper-V variant - just a stub. |
527 | */ |
528 | static s32 ixgbevf_hv_update_mc_addr_list_vf(struct ixgbe_hw *hw, |
529 | struct net_device *netdev) |
530 | { |
531 | return -EOPNOTSUPP; |
532 | } |
533 | |
534 | /** |
535 | * ixgbevf_update_xcast_mode - Update Multicast mode |
536 | * @hw: pointer to the HW structure |
537 | * @xcast_mode: new multicast mode |
538 | * |
539 | * Updates the Multicast Mode of VF. |
540 | **/ |
541 | static s32 ixgbevf_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode) |
542 | { |
543 | u32 msgbuf[2]; |
544 | s32 err; |
545 | |
546 | switch (hw->api_version) { |
547 | case ixgbe_mbox_api_12: |
548 | /* promisc introduced in 1.3 version */ |
549 | if (xcast_mode == IXGBEVF_XCAST_MODE_PROMISC) |
550 | return -EOPNOTSUPP; |
551 | fallthrough; |
552 | case ixgbe_mbox_api_13: |
553 | case ixgbe_mbox_api_14: |
554 | case ixgbe_mbox_api_15: |
555 | break; |
556 | default: |
557 | return -EOPNOTSUPP; |
558 | } |
559 | |
560 | msgbuf[0] = IXGBE_VF_UPDATE_XCAST_MODE; |
561 | msgbuf[1] = xcast_mode; |
562 | |
563 | err = ixgbevf_write_msg_read_ack(hw, msg: msgbuf, retmsg: msgbuf, |
564 | ARRAY_SIZE(msgbuf)); |
565 | if (err) |
566 | return err; |
567 | |
568 | msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; |
569 | if (msgbuf[0] == (IXGBE_VF_UPDATE_XCAST_MODE | IXGBE_VT_MSGTYPE_FAILURE)) |
570 | return -EPERM; |
571 | |
572 | return 0; |
573 | } |
574 | |
575 | /** |
576 | * ixgbevf_hv_update_xcast_mode - stub |
577 | * @hw: unused |
578 | * @xcast_mode: unused |
579 | * |
580 | * Hyper-V variant - just a stub. |
581 | */ |
582 | static s32 ixgbevf_hv_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode) |
583 | { |
584 | return -EOPNOTSUPP; |
585 | } |
586 | |
587 | /** |
588 | * ixgbevf_get_link_state_vf - Get VF link state from PF |
589 | * @hw: pointer to the HW structure |
590 | * @link_state: link state storage |
591 | * |
592 | * Returns state of the operation error or success. |
593 | */ |
594 | static s32 ixgbevf_get_link_state_vf(struct ixgbe_hw *hw, bool *link_state) |
595 | { |
596 | u32 msgbuf[2]; |
597 | s32 ret_val; |
598 | s32 err; |
599 | |
600 | msgbuf[0] = IXGBE_VF_GET_LINK_STATE; |
601 | msgbuf[1] = 0x0; |
602 | |
603 | err = ixgbevf_write_msg_read_ack(hw, msg: msgbuf, retmsg: msgbuf, size: 2); |
604 | |
605 | if (err || (msgbuf[0] & IXGBE_VT_MSGTYPE_FAILURE)) { |
606 | ret_val = IXGBE_ERR_MBX; |
607 | } else { |
608 | ret_val = 0; |
609 | *link_state = msgbuf[1]; |
610 | } |
611 | |
612 | return ret_val; |
613 | } |
614 | |
615 | /** |
616 | * ixgbevf_hv_get_link_state_vf - * Hyper-V variant - just a stub. |
617 | * @hw: unused |
618 | * @link_state: unused |
619 | * |
620 | * Hyper-V variant; there is no mailbox communication. |
621 | */ |
622 | static s32 ixgbevf_hv_get_link_state_vf(struct ixgbe_hw *hw, bool *link_state) |
623 | { |
624 | return -EOPNOTSUPP; |
625 | } |
626 | |
627 | /** |
628 | * ixgbevf_set_vfta_vf - Set/Unset VLAN filter table address |
629 | * @hw: pointer to the HW structure |
630 | * @vlan: 12 bit VLAN ID |
631 | * @vind: unused by VF drivers |
632 | * @vlan_on: if true then set bit, else clear bit |
633 | **/ |
634 | static s32 ixgbevf_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, |
635 | bool vlan_on) |
636 | { |
637 | u32 msgbuf[2]; |
638 | s32 err; |
639 | |
640 | msgbuf[0] = IXGBE_VF_SET_VLAN; |
641 | msgbuf[1] = vlan; |
642 | /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */ |
643 | msgbuf[0] |= vlan_on << IXGBE_VT_MSGINFO_SHIFT; |
644 | |
645 | err = ixgbevf_write_msg_read_ack(hw, msg: msgbuf, retmsg: msgbuf, |
646 | ARRAY_SIZE(msgbuf)); |
647 | if (err) |
648 | goto mbx_err; |
649 | |
650 | /* remove extra bits from the message */ |
651 | msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; |
652 | msgbuf[0] &= ~(0xFF << IXGBE_VT_MSGINFO_SHIFT); |
653 | |
654 | if (msgbuf[0] != (IXGBE_VF_SET_VLAN | IXGBE_VT_MSGTYPE_SUCCESS)) |
655 | err = IXGBE_ERR_INVALID_ARGUMENT; |
656 | |
657 | mbx_err: |
658 | return err; |
659 | } |
660 | |
661 | /** |
662 | * ixgbevf_hv_set_vfta_vf - * Hyper-V variant - just a stub. |
663 | * @hw: unused |
664 | * @vlan: unused |
665 | * @vind: unused |
666 | * @vlan_on: unused |
667 | */ |
668 | static s32 ixgbevf_hv_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, |
669 | bool vlan_on) |
670 | { |
671 | return -EOPNOTSUPP; |
672 | } |
673 | |
674 | /** |
675 | * ixgbevf_setup_mac_link_vf - Setup MAC link settings |
676 | * @hw: pointer to hardware structure |
677 | * @speed: Unused in this implementation |
678 | * @autoneg: Unused in this implementation |
679 | * @autoneg_wait_to_complete: Unused in this implementation |
680 | * |
681 | * Do nothing and return success. VF drivers are not allowed to change |
682 | * global settings. Maintained for driver compatibility. |
683 | **/ |
684 | static s32 ixgbevf_setup_mac_link_vf(struct ixgbe_hw *hw, |
685 | ixgbe_link_speed speed, bool autoneg, |
686 | bool autoneg_wait_to_complete) |
687 | { |
688 | return 0; |
689 | } |
690 | |
691 | /** |
692 | * ixgbevf_check_mac_link_vf - Get link/speed status |
693 | * @hw: pointer to hardware structure |
694 | * @speed: pointer to link speed |
695 | * @link_up: true is link is up, false otherwise |
696 | * @autoneg_wait_to_complete: unused |
697 | * |
698 | * Reads the links register to determine if link is up and the current speed |
699 | **/ |
700 | static s32 ixgbevf_check_mac_link_vf(struct ixgbe_hw *hw, |
701 | ixgbe_link_speed *speed, |
702 | bool *link_up, |
703 | bool autoneg_wait_to_complete) |
704 | { |
705 | struct ixgbe_mbx_info *mbx = &hw->mbx; |
706 | struct ixgbe_mac_info *mac = &hw->mac; |
707 | s32 ret_val = 0; |
708 | u32 links_reg; |
709 | u32 in_msg = 0; |
710 | |
711 | /* If we were hit with a reset drop the link */ |
712 | if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) |
713 | mac->get_link_status = true; |
714 | |
715 | if (!mac->get_link_status) |
716 | goto out; |
717 | |
718 | /* if link status is down no point in checking to see if pf is up */ |
719 | links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); |
720 | if (!(links_reg & IXGBE_LINKS_UP)) |
721 | goto out; |
722 | |
723 | /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs |
724 | * before the link status is correct |
725 | */ |
726 | if (mac->type == ixgbe_mac_82599_vf) { |
727 | int i; |
728 | |
729 | for (i = 0; i < 5; i++) { |
730 | udelay(100); |
731 | links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); |
732 | |
733 | if (!(links_reg & IXGBE_LINKS_UP)) |
734 | goto out; |
735 | } |
736 | } |
737 | |
738 | switch (links_reg & IXGBE_LINKS_SPEED_82599) { |
739 | case IXGBE_LINKS_SPEED_10G_82599: |
740 | *speed = IXGBE_LINK_SPEED_10GB_FULL; |
741 | break; |
742 | case IXGBE_LINKS_SPEED_1G_82599: |
743 | *speed = IXGBE_LINK_SPEED_1GB_FULL; |
744 | break; |
745 | case IXGBE_LINKS_SPEED_100_82599: |
746 | *speed = IXGBE_LINK_SPEED_100_FULL; |
747 | break; |
748 | } |
749 | |
750 | /* if the read failed it could just be a mailbox collision, best wait |
751 | * until we are called again and don't report an error |
752 | */ |
753 | if (mbx->ops.read(hw, &in_msg, 1)) { |
754 | if (hw->api_version >= ixgbe_mbox_api_15) |
755 | mac->get_link_status = false; |
756 | goto out; |
757 | } |
758 | |
759 | if (!(in_msg & IXGBE_VT_MSGTYPE_CTS)) { |
760 | /* msg is not CTS and is NACK we must have lost CTS status */ |
761 | if (in_msg & IXGBE_VT_MSGTYPE_FAILURE) |
762 | ret_val = -1; |
763 | goto out; |
764 | } |
765 | |
766 | /* the pf is talking, if we timed out in the past we reinit */ |
767 | if (!mbx->timeout) { |
768 | ret_val = -1; |
769 | goto out; |
770 | } |
771 | |
772 | /* if we passed all the tests above then the link is up and we no |
773 | * longer need to check for link |
774 | */ |
775 | mac->get_link_status = false; |
776 | |
777 | out: |
778 | *link_up = !mac->get_link_status; |
779 | return ret_val; |
780 | } |
781 | |
782 | /** |
783 | * ixgbevf_hv_check_mac_link_vf - check link |
784 | * @hw: pointer to private hardware struct |
785 | * @speed: pointer to link speed |
786 | * @link_up: true is link is up, false otherwise |
787 | * @autoneg_wait_to_complete: unused |
788 | * |
789 | * Hyper-V variant; there is no mailbox communication. |
790 | */ |
791 | static s32 ixgbevf_hv_check_mac_link_vf(struct ixgbe_hw *hw, |
792 | ixgbe_link_speed *speed, |
793 | bool *link_up, |
794 | bool autoneg_wait_to_complete) |
795 | { |
796 | struct ixgbe_mbx_info *mbx = &hw->mbx; |
797 | struct ixgbe_mac_info *mac = &hw->mac; |
798 | u32 links_reg; |
799 | |
800 | /* If we were hit with a reset drop the link */ |
801 | if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) |
802 | mac->get_link_status = true; |
803 | |
804 | if (!mac->get_link_status) |
805 | goto out; |
806 | |
807 | /* if link status is down no point in checking to see if pf is up */ |
808 | links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); |
809 | if (!(links_reg & IXGBE_LINKS_UP)) |
810 | goto out; |
811 | |
812 | /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs |
813 | * before the link status is correct |
814 | */ |
815 | if (mac->type == ixgbe_mac_82599_vf) { |
816 | int i; |
817 | |
818 | for (i = 0; i < 5; i++) { |
819 | udelay(100); |
820 | links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); |
821 | |
822 | if (!(links_reg & IXGBE_LINKS_UP)) |
823 | goto out; |
824 | } |
825 | } |
826 | |
827 | switch (links_reg & IXGBE_LINKS_SPEED_82599) { |
828 | case IXGBE_LINKS_SPEED_10G_82599: |
829 | *speed = IXGBE_LINK_SPEED_10GB_FULL; |
830 | break; |
831 | case IXGBE_LINKS_SPEED_1G_82599: |
832 | *speed = IXGBE_LINK_SPEED_1GB_FULL; |
833 | break; |
834 | case IXGBE_LINKS_SPEED_100_82599: |
835 | *speed = IXGBE_LINK_SPEED_100_FULL; |
836 | break; |
837 | } |
838 | |
839 | /* if we passed all the tests above then the link is up and we no |
840 | * longer need to check for link |
841 | */ |
842 | mac->get_link_status = false; |
843 | |
844 | out: |
845 | *link_up = !mac->get_link_status; |
846 | return 0; |
847 | } |
848 | |
849 | /** |
850 | * ixgbevf_set_rlpml_vf - Set the maximum receive packet length |
851 | * @hw: pointer to the HW structure |
852 | * @max_size: value to assign to max frame size |
853 | **/ |
854 | static s32 ixgbevf_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size) |
855 | { |
856 | u32 msgbuf[2]; |
857 | s32 ret_val; |
858 | |
859 | msgbuf[0] = IXGBE_VF_SET_LPE; |
860 | msgbuf[1] = max_size; |
861 | |
862 | ret_val = ixgbevf_write_msg_read_ack(hw, msg: msgbuf, retmsg: msgbuf, |
863 | ARRAY_SIZE(msgbuf)); |
864 | if (ret_val) |
865 | return ret_val; |
866 | if ((msgbuf[0] & IXGBE_VF_SET_LPE) && |
867 | (msgbuf[0] & IXGBE_VT_MSGTYPE_FAILURE)) |
868 | return IXGBE_ERR_MBX; |
869 | |
870 | return 0; |
871 | } |
872 | |
873 | /** |
874 | * ixgbevf_hv_set_rlpml_vf - Set the maximum receive packet length |
875 | * @hw: pointer to the HW structure |
876 | * @max_size: value to assign to max frame size |
877 | * Hyper-V variant. |
878 | **/ |
879 | static s32 ixgbevf_hv_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size) |
880 | { |
881 | u32 reg; |
882 | |
883 | /* If we are on Hyper-V, we implement this functionality |
884 | * differently. |
885 | */ |
886 | reg = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(0)); |
887 | /* CRC == 4 */ |
888 | reg |= ((max_size + 4) | IXGBE_RXDCTL_RLPML_EN); |
889 | IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(0), reg); |
890 | |
891 | return 0; |
892 | } |
893 | |
894 | /** |
895 | * ixgbevf_negotiate_api_version_vf - Negotiate supported API version |
896 | * @hw: pointer to the HW structure |
897 | * @api: integer containing requested API version |
898 | **/ |
899 | static int ixgbevf_negotiate_api_version_vf(struct ixgbe_hw *hw, int api) |
900 | { |
901 | int err; |
902 | u32 msg[3]; |
903 | |
904 | /* Negotiate the mailbox API version */ |
905 | msg[0] = IXGBE_VF_API_NEGOTIATE; |
906 | msg[1] = api; |
907 | msg[2] = 0; |
908 | |
909 | err = ixgbevf_write_msg_read_ack(hw, msg, retmsg: msg, ARRAY_SIZE(msg)); |
910 | if (!err) { |
911 | msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; |
912 | |
913 | /* Store value and return 0 on success */ |
914 | if (msg[0] == (IXGBE_VF_API_NEGOTIATE | |
915 | IXGBE_VT_MSGTYPE_SUCCESS)) { |
916 | hw->api_version = api; |
917 | return 0; |
918 | } |
919 | |
920 | err = IXGBE_ERR_INVALID_ARGUMENT; |
921 | } |
922 | |
923 | return err; |
924 | } |
925 | |
926 | /** |
927 | * ixgbevf_hv_negotiate_api_version_vf - Negotiate supported API version |
928 | * @hw: pointer to the HW structure |
929 | * @api: integer containing requested API version |
930 | * Hyper-V version - only ixgbe_mbox_api_10 supported. |
931 | **/ |
932 | static int ixgbevf_hv_negotiate_api_version_vf(struct ixgbe_hw *hw, int api) |
933 | { |
934 | /* Hyper-V only supports api version ixgbe_mbox_api_10 */ |
935 | if (api != ixgbe_mbox_api_10) |
936 | return IXGBE_ERR_INVALID_ARGUMENT; |
937 | |
938 | return 0; |
939 | } |
940 | |
941 | int ixgbevf_get_queues(struct ixgbe_hw *hw, unsigned int *num_tcs, |
942 | unsigned int *default_tc) |
943 | { |
944 | int err; |
945 | u32 msg[5]; |
946 | |
947 | /* do nothing if API doesn't support ixgbevf_get_queues */ |
948 | switch (hw->api_version) { |
949 | case ixgbe_mbox_api_11: |
950 | case ixgbe_mbox_api_12: |
951 | case ixgbe_mbox_api_13: |
952 | case ixgbe_mbox_api_14: |
953 | case ixgbe_mbox_api_15: |
954 | break; |
955 | default: |
956 | return 0; |
957 | } |
958 | |
959 | /* Fetch queue configuration from the PF */ |
960 | msg[0] = IXGBE_VF_GET_QUEUE; |
961 | msg[1] = msg[2] = msg[3] = msg[4] = 0; |
962 | |
963 | err = ixgbevf_write_msg_read_ack(hw, msg, retmsg: msg, ARRAY_SIZE(msg)); |
964 | if (!err) { |
965 | msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; |
966 | |
967 | /* if we didn't get an ACK there must have been |
968 | * some sort of mailbox error so we should treat it |
969 | * as such |
970 | */ |
971 | if (msg[0] != (IXGBE_VF_GET_QUEUE | IXGBE_VT_MSGTYPE_SUCCESS)) |
972 | return IXGBE_ERR_MBX; |
973 | |
974 | /* record and validate values from message */ |
975 | hw->mac.max_tx_queues = msg[IXGBE_VF_TX_QUEUES]; |
976 | if (hw->mac.max_tx_queues == 0 || |
977 | hw->mac.max_tx_queues > IXGBE_VF_MAX_TX_QUEUES) |
978 | hw->mac.max_tx_queues = IXGBE_VF_MAX_TX_QUEUES; |
979 | |
980 | hw->mac.max_rx_queues = msg[IXGBE_VF_RX_QUEUES]; |
981 | if (hw->mac.max_rx_queues == 0 || |
982 | hw->mac.max_rx_queues > IXGBE_VF_MAX_RX_QUEUES) |
983 | hw->mac.max_rx_queues = IXGBE_VF_MAX_RX_QUEUES; |
984 | |
985 | *num_tcs = msg[IXGBE_VF_TRANS_VLAN]; |
986 | /* in case of unknown state assume we cannot tag frames */ |
987 | if (*num_tcs > hw->mac.max_rx_queues) |
988 | *num_tcs = 1; |
989 | |
990 | *default_tc = msg[IXGBE_VF_DEF_QUEUE]; |
991 | /* default to queue 0 on out-of-bounds queue number */ |
992 | if (*default_tc >= hw->mac.max_tx_queues) |
993 | *default_tc = 0; |
994 | } |
995 | |
996 | return err; |
997 | } |
998 | |
999 | static const struct ixgbe_mac_operations ixgbevf_mac_ops = { |
1000 | .init_hw = ixgbevf_init_hw_vf, |
1001 | .reset_hw = ixgbevf_reset_hw_vf, |
1002 | .start_hw = ixgbevf_start_hw_vf, |
1003 | .get_mac_addr = ixgbevf_get_mac_addr_vf, |
1004 | .stop_adapter = ixgbevf_stop_hw_vf, |
1005 | .setup_link = ixgbevf_setup_mac_link_vf, |
1006 | .check_link = ixgbevf_check_mac_link_vf, |
1007 | .negotiate_api_version = ixgbevf_negotiate_api_version_vf, |
1008 | .set_rar = ixgbevf_set_rar_vf, |
1009 | .update_mc_addr_list = ixgbevf_update_mc_addr_list_vf, |
1010 | .update_xcast_mode = ixgbevf_update_xcast_mode, |
1011 | .get_link_state = ixgbevf_get_link_state_vf, |
1012 | .set_uc_addr = ixgbevf_set_uc_addr_vf, |
1013 | .set_vfta = ixgbevf_set_vfta_vf, |
1014 | .set_rlpml = ixgbevf_set_rlpml_vf, |
1015 | }; |
1016 | |
1017 | static const struct ixgbe_mac_operations ixgbevf_hv_mac_ops = { |
1018 | .init_hw = ixgbevf_init_hw_vf, |
1019 | .reset_hw = ixgbevf_hv_reset_hw_vf, |
1020 | .start_hw = ixgbevf_start_hw_vf, |
1021 | .get_mac_addr = ixgbevf_get_mac_addr_vf, |
1022 | .stop_adapter = ixgbevf_stop_hw_vf, |
1023 | .setup_link = ixgbevf_setup_mac_link_vf, |
1024 | .check_link = ixgbevf_hv_check_mac_link_vf, |
1025 | .negotiate_api_version = ixgbevf_hv_negotiate_api_version_vf, |
1026 | .set_rar = ixgbevf_hv_set_rar_vf, |
1027 | .update_mc_addr_list = ixgbevf_hv_update_mc_addr_list_vf, |
1028 | .update_xcast_mode = ixgbevf_hv_update_xcast_mode, |
1029 | .get_link_state = ixgbevf_hv_get_link_state_vf, |
1030 | .set_uc_addr = ixgbevf_hv_set_uc_addr_vf, |
1031 | .set_vfta = ixgbevf_hv_set_vfta_vf, |
1032 | .set_rlpml = ixgbevf_hv_set_rlpml_vf, |
1033 | }; |
1034 | |
1035 | const struct ixgbevf_info ixgbevf_82599_vf_info = { |
1036 | .mac = ixgbe_mac_82599_vf, |
1037 | .mac_ops = &ixgbevf_mac_ops, |
1038 | }; |
1039 | |
1040 | const struct ixgbevf_info ixgbevf_82599_vf_hv_info = { |
1041 | .mac = ixgbe_mac_82599_vf, |
1042 | .mac_ops = &ixgbevf_hv_mac_ops, |
1043 | }; |
1044 | |
1045 | const struct ixgbevf_info ixgbevf_X540_vf_info = { |
1046 | .mac = ixgbe_mac_X540_vf, |
1047 | .mac_ops = &ixgbevf_mac_ops, |
1048 | }; |
1049 | |
1050 | const struct ixgbevf_info ixgbevf_X540_vf_hv_info = { |
1051 | .mac = ixgbe_mac_X540_vf, |
1052 | .mac_ops = &ixgbevf_hv_mac_ops, |
1053 | }; |
1054 | |
1055 | const struct ixgbevf_info ixgbevf_X550_vf_info = { |
1056 | .mac = ixgbe_mac_X550_vf, |
1057 | .mac_ops = &ixgbevf_mac_ops, |
1058 | }; |
1059 | |
1060 | const struct ixgbevf_info ixgbevf_X550_vf_hv_info = { |
1061 | .mac = ixgbe_mac_X550_vf, |
1062 | .mac_ops = &ixgbevf_hv_mac_ops, |
1063 | }; |
1064 | |
1065 | const struct ixgbevf_info ixgbevf_X550EM_x_vf_info = { |
1066 | .mac = ixgbe_mac_X550EM_x_vf, |
1067 | .mac_ops = &ixgbevf_mac_ops, |
1068 | }; |
1069 | |
1070 | const struct ixgbevf_info ixgbevf_X550EM_x_vf_hv_info = { |
1071 | .mac = ixgbe_mac_X550EM_x_vf, |
1072 | .mac_ops = &ixgbevf_hv_mac_ops, |
1073 | }; |
1074 | |
1075 | const struct ixgbevf_info ixgbevf_x550em_a_vf_info = { |
1076 | .mac = ixgbe_mac_x550em_a_vf, |
1077 | .mac_ops = &ixgbevf_mac_ops, |
1078 | }; |
1079 | |