1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2013 - 2018 Intel Corporation. */
3
4 #include "fm10k.h"
5 #include "fm10k_vf.h"
6 #include "fm10k_pf.h"
7
fm10k_iov_msg_error(struct fm10k_hw * hw,u32 ** results,struct fm10k_mbx_info * mbx)8 static s32 fm10k_iov_msg_error(struct fm10k_hw *hw, u32 **results,
9 struct fm10k_mbx_info *mbx)
10 {
11 struct fm10k_vf_info *vf_info = (struct fm10k_vf_info *)mbx;
12 struct fm10k_intfc *interface = hw->back;
13 struct pci_dev *pdev = interface->pdev;
14
15 dev_err(&pdev->dev, "Unknown message ID %u on VF %d\n",
16 **results & FM10K_TLV_ID_MASK, vf_info->vf_idx);
17
18 return fm10k_tlv_msg_error(hw, results, mbx);
19 }
20
21 /**
22 * fm10k_iov_msg_queue_mac_vlan - Message handler for MAC/VLAN request from VF
23 * @hw: Pointer to hardware structure
24 * @results: Pointer array to message, results[0] is pointer to message
25 * @mbx: Pointer to mailbox information structure
26 *
27 * This function is a custom handler for MAC/VLAN requests from the VF. The
28 * assumption is that it is acceptable to directly hand off the message from
29 * the VF to the PF's switch manager. However, we use a MAC/VLAN message
30 * queue to avoid overloading the mailbox when a large number of requests
31 * come in.
32 **/
fm10k_iov_msg_queue_mac_vlan(struct fm10k_hw * hw,u32 ** results,struct fm10k_mbx_info * mbx)33 static s32 fm10k_iov_msg_queue_mac_vlan(struct fm10k_hw *hw, u32 **results,
34 struct fm10k_mbx_info *mbx)
35 {
36 struct fm10k_vf_info *vf_info = (struct fm10k_vf_info *)mbx;
37 struct fm10k_intfc *interface = hw->back;
38 u8 mac[ETH_ALEN];
39 u32 *result;
40 int err = 0;
41 bool set;
42 u16 vlan;
43 u32 vid;
44
45 /* we shouldn't be updating rules on a disabled interface */
46 if (!FM10K_VF_FLAG_ENABLED(vf_info))
47 err = FM10K_ERR_PARAM;
48
49 if (!err && !!results[FM10K_MAC_VLAN_MSG_VLAN]) {
50 result = results[FM10K_MAC_VLAN_MSG_VLAN];
51
52 /* record VLAN id requested */
53 err = fm10k_tlv_attr_get_u32(result, &vid);
54 if (err)
55 return err;
56
57 set = !(vid & FM10K_VLAN_CLEAR);
58 vid &= ~FM10K_VLAN_CLEAR;
59
60 /* if the length field has been set, this is a multi-bit
61 * update request. For multi-bit requests, simply disallow
62 * them when the pf_vid has been set. In this case, the PF
63 * should have already cleared the VLAN_TABLE, and if we
64 * allowed them, it could allow a rogue VF to receive traffic
65 * on a VLAN it was not assigned. In the single-bit case, we
66 * need to modify requests for VLAN 0 to use the default PF or
67 * SW vid when assigned.
68 */
69
70 if (vid >> 16) {
71 /* prevent multi-bit requests when PF has
72 * administratively set the VLAN for this VF
73 */
74 if (vf_info->pf_vid)
75 return FM10K_ERR_PARAM;
76 } else {
77 err = fm10k_iov_select_vid(vf_info, (u16)vid);
78 if (err < 0)
79 return err;
80
81 vid = err;
82 }
83
84 /* update VSI info for VF in regards to VLAN table */
85 err = hw->mac.ops.update_vlan(hw, vid, vf_info->vsi, set);
86 }
87
88 if (!err && !!results[FM10K_MAC_VLAN_MSG_MAC]) {
89 result = results[FM10K_MAC_VLAN_MSG_MAC];
90
91 /* record unicast MAC address requested */
92 err = fm10k_tlv_attr_get_mac_vlan(result, mac, &vlan);
93 if (err)
94 return err;
95
96 /* block attempts to set MAC for a locked device */
97 if (is_valid_ether_addr(vf_info->mac) &&
98 !ether_addr_equal(mac, vf_info->mac))
99 return FM10K_ERR_PARAM;
100
101 set = !(vlan & FM10K_VLAN_CLEAR);
102 vlan &= ~FM10K_VLAN_CLEAR;
103
104 err = fm10k_iov_select_vid(vf_info, vlan);
105 if (err < 0)
106 return err;
107
108 vlan = (u16)err;
109
110 /* Add this request to the MAC/VLAN queue */
111 err = fm10k_queue_mac_request(interface, vf_info->glort,
112 mac, vlan, set);
113 }
114
115 if (!err && !!results[FM10K_MAC_VLAN_MSG_MULTICAST]) {
116 result = results[FM10K_MAC_VLAN_MSG_MULTICAST];
117
118 /* record multicast MAC address requested */
119 err = fm10k_tlv_attr_get_mac_vlan(result, mac, &vlan);
120 if (err)
121 return err;
122
123 /* verify that the VF is allowed to request multicast */
124 if (!(vf_info->vf_flags & FM10K_VF_FLAG_MULTI_ENABLED))
125 return FM10K_ERR_PARAM;
126
127 set = !(vlan & FM10K_VLAN_CLEAR);
128 vlan &= ~FM10K_VLAN_CLEAR;
129
130 err = fm10k_iov_select_vid(vf_info, vlan);
131 if (err < 0)
132 return err;
133
134 vlan = (u16)err;
135
136 /* Add this request to the MAC/VLAN queue */
137 err = fm10k_queue_mac_request(interface, vf_info->glort,
138 mac, vlan, set);
139 }
140
141 return err;
142 }
143
144 static const struct fm10k_msg_data iov_mbx_data[] = {
145 FM10K_TLV_MSG_TEST_HANDLER(fm10k_tlv_msg_test),
146 FM10K_VF_MSG_MSIX_HANDLER(fm10k_iov_msg_msix_pf),
147 FM10K_VF_MSG_MAC_VLAN_HANDLER(fm10k_iov_msg_queue_mac_vlan),
148 FM10K_VF_MSG_LPORT_STATE_HANDLER(fm10k_iov_msg_lport_state_pf),
149 FM10K_TLV_MSG_ERROR_HANDLER(fm10k_iov_msg_error),
150 };
151
fm10k_iov_event(struct fm10k_intfc * interface)152 s32 fm10k_iov_event(struct fm10k_intfc *interface)
153 {
154 struct fm10k_hw *hw = &interface->hw;
155 struct fm10k_iov_data *iov_data;
156 s64 vflre;
157 int i;
158
159 /* if there is no iov_data then there is no mailbox to process */
160 if (!READ_ONCE(interface->iov_data))
161 return 0;
162
163 rcu_read_lock();
164
165 iov_data = interface->iov_data;
166
167 /* check again now that we are in the RCU block */
168 if (!iov_data)
169 goto read_unlock;
170
171 if (!(fm10k_read_reg(hw, FM10K_EICR) & FM10K_EICR_VFLR))
172 goto read_unlock;
173
174 /* read VFLRE to determine if any VFs have been reset */
175 vflre = fm10k_read_reg(hw, FM10K_PFVFLRE(1));
176 vflre <<= 32;
177 vflre |= fm10k_read_reg(hw, FM10K_PFVFLRE(0));
178
179 i = iov_data->num_vfs;
180
181 for (vflre <<= 64 - i; vflre && i--; vflre += vflre) {
182 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i];
183
184 if (vflre >= 0)
185 continue;
186
187 hw->iov.ops.reset_resources(hw, vf_info);
188 vf_info->mbx.ops.connect(hw, &vf_info->mbx);
189 }
190
191 read_unlock:
192 rcu_read_unlock();
193
194 return 0;
195 }
196
fm10k_iov_mbx(struct fm10k_intfc * interface)197 s32 fm10k_iov_mbx(struct fm10k_intfc *interface)
198 {
199 struct fm10k_hw *hw = &interface->hw;
200 struct fm10k_iov_data *iov_data;
201 int i;
202
203 /* if there is no iov_data then there is no mailbox to process */
204 if (!READ_ONCE(interface->iov_data))
205 return 0;
206
207 rcu_read_lock();
208
209 iov_data = interface->iov_data;
210
211 /* check again now that we are in the RCU block */
212 if (!iov_data)
213 goto read_unlock;
214
215 /* lock the mailbox for transmit and receive */
216 fm10k_mbx_lock(interface);
217
218 /* Most VF messages sent to the PF cause the PF to respond by
219 * requesting from the SM mailbox. This means that too many VF
220 * messages processed at once could cause a mailbox timeout on the PF.
221 * To prevent this, store a pointer to the next VF mbx to process. Use
222 * that as the start of the loop so that we don't starve whichever VF
223 * got ignored on the previous run.
224 */
225 process_mbx:
226 for (i = iov_data->next_vf_mbx ? : iov_data->num_vfs; i--;) {
227 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i];
228 struct fm10k_mbx_info *mbx = &vf_info->mbx;
229 u16 glort = vf_info->glort;
230
231 /* process the SM mailbox first to drain outgoing messages */
232 hw->mbx.ops.process(hw, &hw->mbx);
233
234 /* verify port mapping is valid, if not reset port */
235 if (vf_info->vf_flags && !fm10k_glort_valid_pf(hw, glort)) {
236 hw->iov.ops.reset_lport(hw, vf_info);
237 fm10k_clear_macvlan_queue(interface, glort, false);
238 }
239
240 /* reset VFs that have mailbox timed out */
241 if (!mbx->timeout) {
242 hw->iov.ops.reset_resources(hw, vf_info);
243 mbx->ops.connect(hw, mbx);
244 }
245
246 /* guarantee we have free space in the SM mailbox */
247 if (!hw->mbx.ops.tx_ready(&hw->mbx, FM10K_VFMBX_MSG_MTU)) {
248 /* keep track of how many times this occurs */
249 interface->hw_sm_mbx_full++;
250
251 /* make sure we try again momentarily */
252 fm10k_service_event_schedule(interface);
253
254 break;
255 }
256
257 /* cleanup mailbox and process received messages */
258 mbx->ops.process(hw, mbx);
259 }
260
261 /* if we stopped processing mailboxes early, update next_vf_mbx.
262 * Otherwise, reset next_vf_mbx, and restart loop so that we process
263 * the remaining mailboxes we skipped at the start.
264 */
265 if (i >= 0) {
266 iov_data->next_vf_mbx = i + 1;
267 } else if (iov_data->next_vf_mbx) {
268 iov_data->next_vf_mbx = 0;
269 goto process_mbx;
270 }
271
272 /* free the lock */
273 fm10k_mbx_unlock(interface);
274
275 read_unlock:
276 rcu_read_unlock();
277
278 return 0;
279 }
280
fm10k_iov_suspend(struct pci_dev * pdev)281 void fm10k_iov_suspend(struct pci_dev *pdev)
282 {
283 struct fm10k_intfc *interface = pci_get_drvdata(pdev);
284 struct fm10k_iov_data *iov_data = interface->iov_data;
285 struct fm10k_hw *hw = &interface->hw;
286 int num_vfs, i;
287
288 /* pull out num_vfs from iov_data */
289 num_vfs = iov_data ? iov_data->num_vfs : 0;
290
291 /* shut down queue mapping for VFs */
292 fm10k_write_reg(hw, FM10K_DGLORTMAP(fm10k_dglort_vf_rss),
293 FM10K_DGLORTMAP_NONE);
294
295 /* Stop any active VFs and reset their resources */
296 for (i = 0; i < num_vfs; i++) {
297 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i];
298
299 hw->iov.ops.reset_resources(hw, vf_info);
300 hw->iov.ops.reset_lport(hw, vf_info);
301 fm10k_clear_macvlan_queue(interface, vf_info->glort, false);
302 }
303 }
304
fm10k_iov_resume(struct pci_dev * pdev)305 int fm10k_iov_resume(struct pci_dev *pdev)
306 {
307 struct fm10k_intfc *interface = pci_get_drvdata(pdev);
308 struct fm10k_iov_data *iov_data = interface->iov_data;
309 struct fm10k_dglort_cfg dglort = { 0 };
310 struct fm10k_hw *hw = &interface->hw;
311 int num_vfs, i;
312
313 /* pull out num_vfs from iov_data */
314 num_vfs = iov_data ? iov_data->num_vfs : 0;
315
316 /* return error if iov_data is not already populated */
317 if (!iov_data)
318 return -ENOMEM;
319
320 /* allocate hardware resources for the VFs */
321 hw->iov.ops.assign_resources(hw, num_vfs, num_vfs);
322
323 /* configure DGLORT mapping for RSS */
324 dglort.glort = hw->mac.dglort_map & FM10K_DGLORTMAP_NONE;
325 dglort.idx = fm10k_dglort_vf_rss;
326 dglort.inner_rss = 1;
327 dglort.rss_l = fls(fm10k_queues_per_pool(hw) - 1);
328 dglort.queue_b = fm10k_vf_queue_index(hw, 0);
329 dglort.vsi_l = fls(hw->iov.total_vfs - 1);
330 dglort.vsi_b = 1;
331
332 hw->mac.ops.configure_dglort_map(hw, &dglort);
333
334 /* assign resources to the device */
335 for (i = 0; i < num_vfs; i++) {
336 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i];
337
338 /* allocate all but the last GLORT to the VFs */
339 if (i == (~hw->mac.dglort_map >> FM10K_DGLORTMAP_MASK_SHIFT))
340 break;
341
342 /* assign GLORT to VF, and restrict it to multicast */
343 hw->iov.ops.set_lport(hw, vf_info, i,
344 FM10K_VF_FLAG_MULTI_CAPABLE);
345
346 /* mailbox is disconnected so we don't send a message */
347 hw->iov.ops.assign_default_mac_vlan(hw, vf_info);
348
349 /* now we are ready so we can connect */
350 vf_info->mbx.ops.connect(hw, &vf_info->mbx);
351 }
352
353 return 0;
354 }
355
fm10k_iov_update_pvid(struct fm10k_intfc * interface,u16 glort,u16 pvid)356 s32 fm10k_iov_update_pvid(struct fm10k_intfc *interface, u16 glort, u16 pvid)
357 {
358 struct fm10k_iov_data *iov_data = interface->iov_data;
359 struct fm10k_hw *hw = &interface->hw;
360 struct fm10k_vf_info *vf_info;
361 u16 vf_idx = (glort - hw->mac.dglort_map) & FM10K_DGLORTMAP_NONE;
362
363 /* no IOV support, not our message to process */
364 if (!iov_data)
365 return FM10K_ERR_PARAM;
366
367 /* glort outside our range, not our message to process */
368 if (vf_idx >= iov_data->num_vfs)
369 return FM10K_ERR_PARAM;
370
371 /* determine if an update has occurred and if so notify the VF */
372 vf_info = &iov_data->vf_info[vf_idx];
373 if (vf_info->sw_vid != pvid) {
374 vf_info->sw_vid = pvid;
375 hw->iov.ops.assign_default_mac_vlan(hw, vf_info);
376 }
377
378 return 0;
379 }
380
fm10k_iov_free_data(struct pci_dev * pdev)381 static void fm10k_iov_free_data(struct pci_dev *pdev)
382 {
383 struct fm10k_intfc *interface = pci_get_drvdata(pdev);
384
385 if (!interface->iov_data)
386 return;
387
388 /* reclaim hardware resources */
389 fm10k_iov_suspend(pdev);
390
391 /* drop iov_data from interface */
392 kfree_rcu(interface->iov_data, rcu);
393 interface->iov_data = NULL;
394 }
395
fm10k_iov_alloc_data(struct pci_dev * pdev,int num_vfs)396 static s32 fm10k_iov_alloc_data(struct pci_dev *pdev, int num_vfs)
397 {
398 struct fm10k_intfc *interface = pci_get_drvdata(pdev);
399 struct fm10k_iov_data *iov_data = interface->iov_data;
400 struct fm10k_hw *hw = &interface->hw;
401 size_t size;
402 int i, err;
403
404 /* return error if iov_data is already populated */
405 if (iov_data)
406 return -EBUSY;
407
408 /* The PF should always be able to assign resources */
409 if (!hw->iov.ops.assign_resources)
410 return -ENODEV;
411
412 /* nothing to do if no VFs are requested */
413 if (!num_vfs)
414 return 0;
415
416 /* allocate memory for VF storage */
417 size = offsetof(struct fm10k_iov_data, vf_info[num_vfs]);
418 iov_data = kzalloc(size, GFP_KERNEL);
419 if (!iov_data)
420 return -ENOMEM;
421
422 /* record number of VFs */
423 iov_data->num_vfs = num_vfs;
424
425 /* loop through vf_info structures initializing each entry */
426 for (i = 0; i < num_vfs; i++) {
427 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i];
428
429 /* Record VF VSI value */
430 vf_info->vsi = i + 1;
431 vf_info->vf_idx = i;
432
433 /* initialize mailbox memory */
434 err = fm10k_pfvf_mbx_init(hw, &vf_info->mbx, iov_mbx_data, i);
435 if (err) {
436 dev_err(&pdev->dev,
437 "Unable to initialize SR-IOV mailbox\n");
438 kfree(iov_data);
439 return err;
440 }
441 }
442
443 /* assign iov_data to interface */
444 interface->iov_data = iov_data;
445
446 /* allocate hardware resources for the VFs */
447 fm10k_iov_resume(pdev);
448
449 return 0;
450 }
451
fm10k_iov_disable(struct pci_dev * pdev)452 void fm10k_iov_disable(struct pci_dev *pdev)
453 {
454 if (pci_num_vf(pdev) && pci_vfs_assigned(pdev))
455 dev_err(&pdev->dev,
456 "Cannot disable SR-IOV while VFs are assigned\n");
457 else
458 pci_disable_sriov(pdev);
459
460 fm10k_iov_free_data(pdev);
461 }
462
fm10k_disable_aer_comp_abort(struct pci_dev * pdev)463 static void fm10k_disable_aer_comp_abort(struct pci_dev *pdev)
464 {
465 u32 err_sev;
466 int pos;
467
468 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
469 if (!pos)
470 return;
471
472 pci_read_config_dword(pdev, pos + PCI_ERR_UNCOR_SEVER, &err_sev);
473 err_sev &= ~PCI_ERR_UNC_COMP_ABORT;
474 pci_write_config_dword(pdev, pos + PCI_ERR_UNCOR_SEVER, err_sev);
475 }
476
fm10k_iov_configure(struct pci_dev * pdev,int num_vfs)477 int fm10k_iov_configure(struct pci_dev *pdev, int num_vfs)
478 {
479 int current_vfs = pci_num_vf(pdev);
480 int err = 0;
481
482 if (current_vfs && pci_vfs_assigned(pdev)) {
483 dev_err(&pdev->dev,
484 "Cannot modify SR-IOV while VFs are assigned\n");
485 num_vfs = current_vfs;
486 } else {
487 pci_disable_sriov(pdev);
488 fm10k_iov_free_data(pdev);
489 }
490
491 /* allocate resources for the VFs */
492 err = fm10k_iov_alloc_data(pdev, num_vfs);
493 if (err)
494 return err;
495
496 /* allocate VFs if not already allocated */
497 if (num_vfs && num_vfs != current_vfs) {
498 /* Disable completer abort error reporting as
499 * the VFs can trigger this any time they read a queue
500 * that they don't own.
501 */
502 fm10k_disable_aer_comp_abort(pdev);
503
504 err = pci_enable_sriov(pdev, num_vfs);
505 if (err) {
506 dev_err(&pdev->dev,
507 "Enable PCI SR-IOV failed: %d\n", err);
508 return err;
509 }
510 }
511
512 return num_vfs;
513 }
514
fm10k_reset_vf_info(struct fm10k_intfc * interface,struct fm10k_vf_info * vf_info)515 static inline void fm10k_reset_vf_info(struct fm10k_intfc *interface,
516 struct fm10k_vf_info *vf_info)
517 {
518 struct fm10k_hw *hw = &interface->hw;
519
520 /* assigning the MAC address will send a mailbox message */
521 fm10k_mbx_lock(interface);
522
523 /* disable LPORT for this VF which clears switch rules */
524 hw->iov.ops.reset_lport(hw, vf_info);
525
526 fm10k_clear_macvlan_queue(interface, vf_info->glort, false);
527
528 /* assign new MAC+VLAN for this VF */
529 hw->iov.ops.assign_default_mac_vlan(hw, vf_info);
530
531 /* re-enable the LPORT for this VF */
532 hw->iov.ops.set_lport(hw, vf_info, vf_info->vf_idx,
533 FM10K_VF_FLAG_MULTI_CAPABLE);
534
535 fm10k_mbx_unlock(interface);
536 }
537
fm10k_ndo_set_vf_mac(struct net_device * netdev,int vf_idx,u8 * mac)538 int fm10k_ndo_set_vf_mac(struct net_device *netdev, int vf_idx, u8 *mac)
539 {
540 struct fm10k_intfc *interface = netdev_priv(netdev);
541 struct fm10k_iov_data *iov_data = interface->iov_data;
542 struct fm10k_vf_info *vf_info;
543
544 /* verify SR-IOV is active and that vf idx is valid */
545 if (!iov_data || vf_idx >= iov_data->num_vfs)
546 return -EINVAL;
547
548 /* verify MAC addr is valid */
549 if (!is_zero_ether_addr(mac) && !is_valid_ether_addr(mac))
550 return -EINVAL;
551
552 /* record new MAC address */
553 vf_info = &iov_data->vf_info[vf_idx];
554 ether_addr_copy(vf_info->mac, mac);
555
556 fm10k_reset_vf_info(interface, vf_info);
557
558 return 0;
559 }
560
fm10k_ndo_set_vf_vlan(struct net_device * netdev,int vf_idx,u16 vid,u8 qos,__be16 vlan_proto)561 int fm10k_ndo_set_vf_vlan(struct net_device *netdev, int vf_idx, u16 vid,
562 u8 qos, __be16 vlan_proto)
563 {
564 struct fm10k_intfc *interface = netdev_priv(netdev);
565 struct fm10k_iov_data *iov_data = interface->iov_data;
566 struct fm10k_hw *hw = &interface->hw;
567 struct fm10k_vf_info *vf_info;
568
569 /* verify SR-IOV is active and that vf idx is valid */
570 if (!iov_data || vf_idx >= iov_data->num_vfs)
571 return -EINVAL;
572
573 /* QOS is unsupported and VLAN IDs accepted range 0-4094 */
574 if (qos || (vid > (VLAN_VID_MASK - 1)))
575 return -EINVAL;
576
577 /* VF VLAN Protocol part to default is unsupported */
578 if (vlan_proto != htons(ETH_P_8021Q))
579 return -EPROTONOSUPPORT;
580
581 vf_info = &iov_data->vf_info[vf_idx];
582
583 /* exit if there is nothing to do */
584 if (vf_info->pf_vid == vid)
585 return 0;
586
587 /* record default VLAN ID for VF */
588 vf_info->pf_vid = vid;
589
590 /* Clear the VLAN table for the VF */
591 hw->mac.ops.update_vlan(hw, FM10K_VLAN_ALL, vf_info->vsi, false);
592
593 fm10k_reset_vf_info(interface, vf_info);
594
595 return 0;
596 }
597
fm10k_ndo_set_vf_bw(struct net_device * netdev,int vf_idx,int __always_unused min_rate,int max_rate)598 int fm10k_ndo_set_vf_bw(struct net_device *netdev, int vf_idx,
599 int __always_unused min_rate, int max_rate)
600 {
601 struct fm10k_intfc *interface = netdev_priv(netdev);
602 struct fm10k_iov_data *iov_data = interface->iov_data;
603 struct fm10k_hw *hw = &interface->hw;
604
605 /* verify SR-IOV is active and that vf idx is valid */
606 if (!iov_data || vf_idx >= iov_data->num_vfs)
607 return -EINVAL;
608
609 /* rate limit cannot be less than 10Mbs or greater than link speed */
610 if (max_rate &&
611 (max_rate < FM10K_VF_TC_MIN || max_rate > FM10K_VF_TC_MAX))
612 return -EINVAL;
613
614 /* store values */
615 iov_data->vf_info[vf_idx].rate = max_rate;
616
617 /* update hardware configuration */
618 hw->iov.ops.configure_tc(hw, vf_idx, max_rate);
619
620 return 0;
621 }
622
fm10k_ndo_get_vf_config(struct net_device * netdev,int vf_idx,struct ifla_vf_info * ivi)623 int fm10k_ndo_get_vf_config(struct net_device *netdev,
624 int vf_idx, struct ifla_vf_info *ivi)
625 {
626 struct fm10k_intfc *interface = netdev_priv(netdev);
627 struct fm10k_iov_data *iov_data = interface->iov_data;
628 struct fm10k_vf_info *vf_info;
629
630 /* verify SR-IOV is active and that vf idx is valid */
631 if (!iov_data || vf_idx >= iov_data->num_vfs)
632 return -EINVAL;
633
634 vf_info = &iov_data->vf_info[vf_idx];
635
636 ivi->vf = vf_idx;
637 ivi->max_tx_rate = vf_info->rate;
638 ivi->min_tx_rate = 0;
639 ether_addr_copy(ivi->mac, vf_info->mac);
640 ivi->vlan = vf_info->pf_vid;
641 ivi->qos = 0;
642
643 return 0;
644 }
645
