?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/xen: resume timer irqs early
[linux/fpc-iii.git] / drivers / net / ethernet / qlogic / qlcnic / qlcnic_sriov_pf.c
blob686f460b15022b4b2b7759ad29493a64a1f84592
1 /*
2 * QLogic qlcnic NIC Driver
3 * Copyright (c) 2009-2013 QLogic Corporation
4 *
5 * See LICENSE.qlcnic for copyright and licensing details.
6 */
7
8 #include "qlcnic_sriov.h"
9 #include "qlcnic.h"
10 #include <linux/types.h>
11
12 #define QLCNIC_SRIOV_VF_MAX_MAC 1
13 #define QLC_VF_MIN_TX_RATE 100
14 #define QLC_VF_MAX_TX_RATE 9999
15
16 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *, u8);
17
18 struct qlcnic_sriov_cmd_handler {
19 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
20 };
21
22 struct qlcnic_sriov_fw_cmd_handler {
23 u32 cmd;
24 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
25 };
26
27 static int qlcnic_sriov_pf_set_vport_info(struct qlcnic_adapter *adapter,
28 struct qlcnic_info *npar_info,
29 u16 vport_id)
30 {
31 struct qlcnic_cmd_args cmd;
32 int err;
33
34 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO))
35 return -ENOMEM;
36
37 cmd.req.arg[1] = (vport_id << 16) | 0x1;
38 cmd.req.arg[2] = npar_info->bit_offsets;
39 cmd.req.arg[2] |= npar_info->min_tx_bw << 16;
40 cmd.req.arg[3] = npar_info->max_tx_bw | (npar_info->max_tx_ques << 16);
41 cmd.req.arg[4] = npar_info->max_tx_mac_filters;
42 cmd.req.arg[4] |= npar_info->max_rx_mcast_mac_filters << 16;
43 cmd.req.arg[5] = npar_info->max_rx_ucast_mac_filters |
44 (npar_info->max_rx_ip_addr << 16);
45 cmd.req.arg[6] = npar_info->max_rx_lro_flow |
46 (npar_info->max_rx_status_rings << 16);
47 cmd.req.arg[7] = npar_info->max_rx_buf_rings |
48 (npar_info->max_rx_ques << 16);
49 cmd.req.arg[8] = npar_info->max_tx_vlan_keys;
50 cmd.req.arg[8] |= npar_info->max_local_ipv6_addrs << 16;
51 cmd.req.arg[9] = npar_info->max_remote_ipv6_addrs;
52
53 err = qlcnic_issue_cmd(adapter, &cmd);
54 if (err)
55 dev_err(&adapter->pdev->dev,
56 "Failed to set vport info, err=%d\n", err);
57
58 qlcnic_free_mbx_args(&cmd);
59 return err;
60 }
61
62 static int qlcnic_sriov_pf_cal_res_limit(struct qlcnic_adapter *adapter,
63 struct qlcnic_info *info, u16 func)
64 {
65 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
66 struct qlcnic_resources *res = &sriov->ff_max;
67 u32 temp, num_vf_macs, num_vfs, max;
68 int ret = -EIO, vpid, id;
69 struct qlcnic_vport *vp;
70
71 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
72 if (vpid < 0)
73 return -EINVAL;
74
75 num_vfs = sriov->num_vfs;
76 max = num_vfs + 1;
77 info->bit_offsets = 0xffff;
78 info->max_tx_ques = res->num_tx_queues / max;
79 info->max_rx_mcast_mac_filters = res->num_rx_mcast_mac_filters;
80 num_vf_macs = QLCNIC_SRIOV_VF_MAX_MAC;
81
82 if (adapter->ahw->pci_func == func) {
83 temp = res->num_rx_mcast_mac_filters - (num_vfs * num_vf_macs);
84 info->max_rx_ucast_mac_filters = temp;
85 temp = res->num_tx_mac_filters - (num_vfs * num_vf_macs);
86 info->max_tx_mac_filters = temp;
87 info->min_tx_bw = 0;
88 info->max_tx_bw = MAX_BW;
89 } else {
90 id = qlcnic_sriov_func_to_index(adapter, func);
91 if (id < 0)
92 return id;
93 vp = sriov->vf_info[id].vp;
94 info->min_tx_bw = vp->min_tx_bw;
95 info->max_tx_bw = vp->max_tx_bw;
96 info->max_rx_ucast_mac_filters = num_vf_macs;
97 info->max_tx_mac_filters = num_vf_macs;
98 }
99
100 info->max_rx_ip_addr = res->num_destip / max;
101 info->max_rx_status_rings = res->num_rx_status_rings / max;
102 info->max_rx_buf_rings = res->num_rx_buf_rings / max;
103 info->max_rx_ques = res->num_rx_queues / max;
104 info->max_rx_lro_flow = res->num_lro_flows_supported / max;
105 info->max_tx_vlan_keys = res->num_txvlan_keys;
106 info->max_local_ipv6_addrs = res->max_local_ipv6_addrs;
107 info->max_remote_ipv6_addrs = res->max_remote_ipv6_addrs;
108
109 ret = qlcnic_sriov_pf_set_vport_info(adapter, info, vpid);
110 if (ret)
111 return ret;
112
113 return 0;
114 }
115
116 static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter *adapter,
117 struct qlcnic_info *info)
118 {
119 struct qlcnic_resources *ff_max = &adapter->ahw->sriov->ff_max;
120
121 ff_max->num_tx_mac_filters = info->max_tx_mac_filters;
122 ff_max->num_rx_ucast_mac_filters = info->max_rx_ucast_mac_filters;
123 ff_max->num_rx_mcast_mac_filters = info->max_rx_mcast_mac_filters;
124 ff_max->num_txvlan_keys = info->max_tx_vlan_keys;
125 ff_max->num_rx_queues = info->max_rx_ques;
126 ff_max->num_tx_queues = info->max_tx_ques;
127 ff_max->num_lro_flows_supported = info->max_rx_lro_flow;
128 ff_max->num_destip = info->max_rx_ip_addr;
129 ff_max->num_rx_buf_rings = info->max_rx_buf_rings;
130 ff_max->num_rx_status_rings = info->max_rx_status_rings;
131 ff_max->max_remote_ipv6_addrs = info->max_remote_ipv6_addrs;
132 ff_max->max_local_ipv6_addrs = info->max_local_ipv6_addrs;
133 }
134
135 static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter *adapter,
136 struct qlcnic_info *npar_info)
137 {
138 int err;
139 struct qlcnic_cmd_args cmd;
140
141 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_NIC_INFO))
142 return -ENOMEM;
143
144 cmd.req.arg[1] = 0x2;
145 err = qlcnic_issue_cmd(adapter, &cmd);
146 if (err) {
147 dev_err(&adapter->pdev->dev,
148 "Failed to get PF info, err=%d\n", err);
149 goto out;
150 }
151
152 npar_info->total_pf = cmd.rsp.arg[2] & 0xff;
153 npar_info->total_rss_engines = (cmd.rsp.arg[2] >> 8) & 0xff;
154 npar_info->max_vports = MSW(cmd.rsp.arg[2]);
155 npar_info->max_tx_ques = LSW(cmd.rsp.arg[3]);
156 npar_info->max_tx_mac_filters = MSW(cmd.rsp.arg[3]);
157 npar_info->max_rx_mcast_mac_filters = LSW(cmd.rsp.arg[4]);
158 npar_info->max_rx_ucast_mac_filters = MSW(cmd.rsp.arg[4]);
159 npar_info->max_rx_ip_addr = LSW(cmd.rsp.arg[5]);
160 npar_info->max_rx_lro_flow = MSW(cmd.rsp.arg[5]);
161 npar_info->max_rx_status_rings = LSW(cmd.rsp.arg[6]);
162 npar_info->max_rx_buf_rings = MSW(cmd.rsp.arg[6]);
163 npar_info->max_rx_ques = LSW(cmd.rsp.arg[7]);
164 npar_info->max_tx_vlan_keys = MSW(cmd.rsp.arg[7]);
165 npar_info->max_local_ipv6_addrs = LSW(cmd.rsp.arg[8]);
166 npar_info->max_remote_ipv6_addrs = MSW(cmd.rsp.arg[8]);
167
168 qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info);
169 dev_info(&adapter->pdev->dev,
170 "\n\ttotal_pf: %d,\n"
171 "\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n"
172 "\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n"
173 "\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n"
174 "\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n"
175 "\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n"
176 "\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n",
177 npar_info->total_pf, npar_info->total_rss_engines,
178 npar_info->max_vports, npar_info->max_tx_ques,
179 npar_info->max_tx_mac_filters,
180 npar_info->max_rx_mcast_mac_filters,
181 npar_info->max_rx_ucast_mac_filters, npar_info->max_rx_ip_addr,
182 npar_info->max_rx_lro_flow, npar_info->max_rx_status_rings,
183 npar_info->max_rx_buf_rings, npar_info->max_rx_ques,
184 npar_info->max_tx_vlan_keys, npar_info->max_local_ipv6_addrs,
185 npar_info->max_remote_ipv6_addrs);
186
187 out:
188 qlcnic_free_mbx_args(&cmd);
189 return err;
190 }
191
192 static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter,
193 u8 func)
194 {
195 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
196 struct qlcnic_vport *vp;
197 int index;
198
199 if (adapter->ahw->pci_func == func) {
200 sriov->vp_handle = 0;
201 } else {
202 index = qlcnic_sriov_func_to_index(adapter, func);
203 if (index < 0)
204 return;
205 vp = sriov->vf_info[index].vp;
206 vp->handle = 0;
207 }
208 }
209
210 static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter *adapter,
211 u16 vport_handle, u8 func)
212 {
213 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
214 struct qlcnic_vport *vp;
215 int index;
216
217 if (adapter->ahw->pci_func == func) {
218 sriov->vp_handle = vport_handle;
219 } else {
220 index = qlcnic_sriov_func_to_index(adapter, func);
221 if (index < 0)
222 return;
223 vp = sriov->vf_info[index].vp;
224 vp->handle = vport_handle;
225 }
226 }
227
228 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter,
229 u8 func)
230 {
231 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
232 struct qlcnic_vf_info *vf_info;
233 int index;
234
235 if (adapter->ahw->pci_func == func) {
236 return sriov->vp_handle;
237 } else {
238 index = qlcnic_sriov_func_to_index(adapter, func);
239 if (index >= 0) {
240 vf_info = &sriov->vf_info[index];
241 return vf_info->vp->handle;
242 }
243 }
244
245 return -EINVAL;
246 }
247
248 static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter *adapter,
249 u8 flag, u16 func)
250 {
251 struct qlcnic_cmd_args cmd;
252 int ret;
253 int vpid;
254
255 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_VPORT))
256 return -ENOMEM;
257
258 if (flag) {
259 cmd.req.arg[3] = func << 8;
260 } else {
261 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
262 if (vpid < 0) {
263 ret = -EINVAL;
264 goto out;
265 }
266 cmd.req.arg[3] = ((vpid & 0xffff) << 8) | 1;
267 }
268
269 ret = qlcnic_issue_cmd(adapter, &cmd);
270 if (ret) {
271 dev_err(&adapter->pdev->dev,
272 "Failed %s vport, err %d for func 0x%x\n",
273 (flag ? "enable" : "disable"), ret, func);
274 goto out;
275 }
276
277 if (flag) {
278 vpid = cmd.rsp.arg[2] & 0xffff;
279 qlcnic_sriov_pf_set_vport_handle(adapter, vpid, func);
280 } else {
281 qlcnic_sriov_pf_reset_vport_handle(adapter, func);
282 }
283
284 out:
285 qlcnic_free_mbx_args(&cmd);
286 return ret;
287 }
288
289 static int qlcnic_sriov_pf_cfg_vlan_filtering(struct qlcnic_adapter *adapter,
290 u8 enable)
291 {
292 struct qlcnic_cmd_args cmd;
293 int err;
294
295 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
296 if (err)
297 return err;
298
299 cmd.req.arg[1] = 0x4;
300 if (enable)
301 cmd.req.arg[1] |= BIT_16;
302
303 err = qlcnic_issue_cmd(adapter, &cmd);
304 if (err)
305 dev_err(&adapter->pdev->dev,
306 "Failed to configure VLAN filtering, err=%d\n", err);
307
308 qlcnic_free_mbx_args(&cmd);
309 return err;
310 }
311
312 static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter,
313 u8 func, u8 enable)
314 {
315 struct qlcnic_cmd_args cmd;
316 int err = -EIO;
317
318 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH))
319 return -ENOMEM;
320
321 cmd.req.arg[0] |= (3 << 29);
322 cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1;
323 if (enable)
324 cmd.req.arg[1] |= BIT_0;
325
326 err = qlcnic_issue_cmd(adapter, &cmd);
327
328 if (err != QLCNIC_RCODE_SUCCESS) {
329 dev_err(&adapter->pdev->dev,
330 "Failed to enable sriov eswitch%d\n", err);
331 err = -EIO;
332 }
333
334 qlcnic_free_mbx_args(&cmd);
335 return err;
336 }
337
338 static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter *adapter)
339 {
340 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
341 struct qlcnic_back_channel *bc = &sriov->bc;
342 int i;
343
344 for (i = 0; i < sriov->num_vfs; i++)
345 cancel_work_sync(&sriov->vf_info[i].flr_work);
346
347 destroy_workqueue(bc->bc_flr_wq);
348 }
349
350 static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter *adapter)
351 {
352 struct qlcnic_back_channel *bc = &adapter->ahw->sriov->bc;
353 struct workqueue_struct *wq;
354
355 wq = create_singlethread_workqueue("qlcnic-flr");
356 if (wq == NULL) {
357 dev_err(&adapter->pdev->dev, "Cannot create FLR workqueue\n");
358 return -ENOMEM;
359 }
360
361 bc->bc_flr_wq = wq;
362 return 0;
363 }
364
365 void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter)
366 {
367 u8 func = adapter->ahw->pci_func;
368
369 if (!qlcnic_sriov_enable_check(adapter))
370 return;
371
372 qlcnic_sriov_pf_del_flr_queue(adapter);
373 qlcnic_sriov_cfg_bc_intr(adapter, 0);
374 qlcnic_sriov_pf_config_vport(adapter, 0, func);
375 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
376 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
377 __qlcnic_sriov_cleanup(adapter);
378 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
379 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
380 }
381
382 void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter)
383 {
384 if (!qlcnic_sriov_pf_check(adapter))
385 return;
386
387 if (!qlcnic_sriov_enable_check(adapter))
388 return;
389
390 pci_disable_sriov(adapter->pdev);
391 netdev_info(adapter->netdev,
392 "SR-IOV is disabled successfully on port %d\n",
393 adapter->portnum);
394 }
395
396 static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter)
397 {
398 struct net_device *netdev = adapter->netdev;
399
400 rtnl_lock();
401 if (netif_running(netdev))
402 __qlcnic_down(adapter, netdev);
403
404 qlcnic_sriov_pf_disable(adapter);
405
406 qlcnic_sriov_pf_cleanup(adapter);
407
408 /* After disabling SRIOV re-init the driver in default mode
409 configure opmode based on op_mode of function
410 */
411 if (qlcnic_83xx_configure_opmode(adapter)) {
412 rtnl_unlock();
413 return -EIO;
414 }
415
416 if (netif_running(netdev))
417 __qlcnic_up(adapter, netdev);
418
419 rtnl_unlock();
420 return 0;
421 }
422
423 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
424 {
425 struct qlcnic_hardware_context *ahw = adapter->ahw;
426 struct qlcnic_info nic_info, pf_info, vp_info;
427 int err;
428 u8 func = ahw->pci_func;
429
430 if (!qlcnic_sriov_enable_check(adapter))
431 return 0;
432
433 err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1);
434 if (err)
435 return err;
436
437 err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
438 if (err)
439 goto disable_vlan_filtering;
440
441 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
442 if (err)
443 goto disable_eswitch;
444
445 err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
446 if (err)
447 goto delete_vport;
448
449 err = qlcnic_get_nic_info(adapter, &nic_info, func);
450 if (err)
451 goto delete_vport;
452
453 err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
454 if (err)
455 goto delete_vport;
456
457 err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
458 if (err)
459 goto delete_vport;
460
461 ahw->physical_port = (u8) nic_info.phys_port;
462 ahw->switch_mode = nic_info.switch_mode;
463 ahw->max_mtu = nic_info.max_mtu;
464 ahw->capabilities = nic_info.capabilities;
465 ahw->nic_mode = QLC_83XX_SRIOV_MODE;
466 return err;
467
468 delete_vport:
469 qlcnic_sriov_pf_config_vport(adapter, 0, func);
470
471 disable_eswitch:
472 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
473
474 disable_vlan_filtering:
475 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
476
477 return err;
478 }
479
480 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
481 {
482 int err;
483
484 if (!qlcnic_sriov_enable_check(adapter))
485 return 0;
486
487 err = pci_enable_sriov(adapter->pdev, num_vfs);
488 if (err)
489 qlcnic_sriov_pf_cleanup(adapter);
490
491 return err;
492 }
493
494 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
495 int num_vfs)
496 {
497 int err = 0;
498
499 set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
500 adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
501
502 err = qlcnic_sriov_init(adapter, num_vfs);
503 if (err)
504 goto clear_op_mode;
505
506 err = qlcnic_sriov_pf_create_flr_queue(adapter);
507 if (err)
508 goto sriov_cleanup;
509
510 err = qlcnic_sriov_pf_init(adapter);
511 if (err)
512 goto del_flr_queue;
513
514 err = qlcnic_sriov_pf_enable(adapter, num_vfs);
515 return err;
516
517 del_flr_queue:
518 qlcnic_sriov_pf_del_flr_queue(adapter);
519
520 sriov_cleanup:
521 __qlcnic_sriov_cleanup(adapter);
522
523 clear_op_mode:
524 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
525 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
526 return err;
527 }
528
529 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
530 {
531 struct net_device *netdev = adapter->netdev;
532 int err;
533
534 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
535 netdev_err(netdev,
536 "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
537 return -EIO;
538 }
539
540 rtnl_lock();
541 if (netif_running(netdev))
542 __qlcnic_down(adapter, netdev);
543
544 err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
545 if (err) {
546 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
547 adapter->portnum);
548
549 err = -EIO;
550 if (qlcnic_83xx_configure_opmode(adapter))
551 goto error;
552 } else {
553 netdev_info(netdev,
554 "SR-IOV is enabled successfully on port %d\n",
555 adapter->portnum);
556 /* Return number of vfs enabled */
557 err = num_vfs;
558 }
559 if (netif_running(netdev))
560 __qlcnic_up(adapter, netdev);
561
562 error:
563 rtnl_unlock();
564 return err;
565 }
566
567 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
568 {
569 struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
570 int err;
571
572 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
573 return -EBUSY;
574
575 if (num_vfs == 0)
576 err = qlcnic_pci_sriov_disable(adapter);
577 else
578 err = qlcnic_pci_sriov_enable(adapter, num_vfs);
579
580 clear_bit(__QLCNIC_RESETTING, &adapter->state);
581 return err;
582 }
583
584 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func)
585 {
586 struct qlcnic_cmd_args cmd;
587 struct qlcnic_vport *vp;
588 int err, id;
589 u8 *mac;
590
591 id = qlcnic_sriov_func_to_index(adapter, func);
592 if (id < 0)
593 return id;
594
595 vp = adapter->ahw->sriov->vf_info[id].vp;
596 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
597 if (err)
598 return err;
599
600 cmd.req.arg[1] = 0x3 | func << 16;
601 if (vp->spoofchk == true) {
602 mac = vp->mac;
603 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8;
604 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 |
605 mac[2] << 24;
606 cmd.req.arg[5] = mac[1] | mac[0] << 8;
607 }
608
609 if (vp->vlan_mode == QLC_PVID_MODE) {
610 cmd.req.arg[2] |= BIT_6;
611 cmd.req.arg[3] |= vp->vlan << 8;
612 }
613
614 err = qlcnic_issue_cmd(adapter, &cmd);
615 if (err)
616 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n",
617 err);
618
619 qlcnic_free_mbx_args(&cmd);
620 return err;
621 }
622
623 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
624 u16 func)
625 {
626 struct qlcnic_info defvp_info;
627 int err;
628
629 err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
630 if (err)
631 return -EIO;
632
633 err = qlcnic_sriov_set_vf_acl(adapter, func);
634 if (err)
635 return err;
636
637 return 0;
638 }
639
640 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
641 struct qlcnic_cmd_args *cmd)
642 {
643 struct qlcnic_vf_info *vf = trans->vf;
644 struct qlcnic_vport *vp = vf->vp;
645 struct qlcnic_adapter *adapter;
646 u16 func = vf->pci_func;
647 int err;
648
649 adapter = vf->adapter;
650
651 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
652 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
653 if (!err) {
654 err = qlcnic_sriov_set_vf_vport_info(adapter, func);
655 if (err)
656 qlcnic_sriov_pf_config_vport(adapter, 0, func);
657 }
658 } else {
659 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
660 vp->vlan = 0;
661 err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
662 }
663
664 if (err)
665 goto err_out;
666
667 cmd->rsp.arg[0] |= (1 << 25);
668
669 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
670 set_bit(QLC_BC_VF_STATE, &vf->state);
671 else
672 clear_bit(QLC_BC_VF_STATE, &vf->state);
673
674 return err;
675
676 err_out:
677 cmd->rsp.arg[0] |= (2 << 25);
678 return err;
679 }
680
681 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
682 struct qlcnic_vport *vp,
683 u16 func, u16 vlan, u8 op)
684 {
685 struct qlcnic_cmd_args cmd;
686 struct qlcnic_macvlan_mbx mv;
687 u8 *addr;
688 int err;
689 u32 *buf;
690 int vpid;
691
692 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN))
693 return -ENOMEM;
694
695 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
696 if (vpid < 0) {
697 err = -EINVAL;
698 goto out;
699 }
700
701 if (vlan)
702 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
703 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
704
705 cmd.req.arg[1] = op | (1 << 8) | (3 << 6);
706 cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
707
708 addr = vp->mac;
709 mv.vlan = vlan;
710 mv.mac_addr0 = addr[0];
711 mv.mac_addr1 = addr[1];
712 mv.mac_addr2 = addr[2];
713 mv.mac_addr3 = addr[3];
714 mv.mac_addr4 = addr[4];
715 mv.mac_addr5 = addr[5];
716 buf = &cmd.req.arg[2];
717 memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
718
719 err = qlcnic_issue_cmd(adapter, &cmd);
720
721 if (err)
722 dev_err(&adapter->pdev->dev,
723 "MAC-VLAN %s to CAM failed, err=%d.\n",
724 ((op == 1) ? "add " : "delete "), err);
725
726 out:
727 qlcnic_free_mbx_args(&cmd);
728 return err;
729 }
730
731 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
732 {
733 if ((cmd->req.arg[0] >> 29) != 0x3)
734 return -EINVAL;
735
736 return 0;
737 }
738
739 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
740 struct qlcnic_cmd_args *cmd)
741 {
742 struct qlcnic_vf_info *vf = tran->vf;
743 struct qlcnic_adapter *adapter = vf->adapter;
744 struct qlcnic_rcv_mbx_out *mbx_out;
745 int err;
746 u16 vlan;
747
748 err = qlcnic_sriov_validate_create_rx_ctx(cmd);
749 if (err) {
750 cmd->rsp.arg[0] |= (0x6 << 25);
751 return err;
752 }
753
754 cmd->req.arg[6] = vf->vp->handle;
755 err = qlcnic_issue_cmd(adapter, cmd);
756
757 vlan = vf->vp->vlan;
758 if (!err) {
759 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
760 vf->rx_ctx_id = mbx_out->ctx_id;
761 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
762 vlan, QLCNIC_MAC_ADD);
763 } else {
764 vf->rx_ctx_id = 0;
765 }
766
767 return err;
768 }
769
770 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
771 struct qlcnic_cmd_args *cmd)
772 {
773 struct qlcnic_vf_info *vf = trans->vf;
774 u8 type, *mac;
775
776 type = cmd->req.arg[1];
777 switch (type) {
778 case QLCNIC_SET_STATION_MAC:
779 case QLCNIC_SET_FAC_DEF_MAC:
780 cmd->rsp.arg[0] = (2 << 25);
781 break;
782 case QLCNIC_GET_CURRENT_MAC:
783 cmd->rsp.arg[0] = (1 << 25);
784 mac = vf->vp->mac;
785 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
786 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
787 ((mac[3]) << 16 & 0xff0000) |
788 ((mac[2]) << 24 & 0xff000000);
789 }
790
791 return 0;
792 }
793
794 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
795 {
796 if ((cmd->req.arg[0] >> 29) != 0x3)
797 return -EINVAL;
798
799 return 0;
800 }
801
802 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
803 struct qlcnic_cmd_args *cmd)
804 {
805 struct qlcnic_vf_info *vf = trans->vf;
806 struct qlcnic_adapter *adapter = vf->adapter;
807 struct qlcnic_tx_mbx_out *mbx_out;
808 int err;
809
810 err = qlcnic_sriov_validate_create_tx_ctx(cmd);
811 if (err) {
812 cmd->rsp.arg[0] |= (0x6 << 25);
813 return err;
814 }
815
816 cmd->req.arg[5] |= vf->vp->handle << 16;
817 err = qlcnic_issue_cmd(adapter, cmd);
818 if (!err) {
819 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
820 vf->tx_ctx_id = mbx_out->ctx_id;
821 } else {
822 vf->tx_ctx_id = 0;
823 }
824
825 return err;
826 }
827
828 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
829 struct qlcnic_cmd_args *cmd)
830 {
831 if ((cmd->req.arg[0] >> 29) != 0x3)
832 return -EINVAL;
833
834 if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
835 return -EINVAL;
836
837 return 0;
838 }
839
840 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,
841 struct qlcnic_cmd_args *cmd)
842 {
843 struct qlcnic_vf_info *vf = trans->vf;
844 struct qlcnic_adapter *adapter = vf->adapter;
845 int err;
846 u16 vlan;
847
848 err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
849 if (err) {
850 cmd->rsp.arg[0] |= (0x6 << 25);
851 return err;
852 }
853
854 vlan = vf->vp->vlan;
855 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
856 vlan, QLCNIC_MAC_DEL);
857 cmd->req.arg[1] |= vf->vp->handle << 16;
858 err = qlcnic_issue_cmd(adapter, cmd);
859
860 if (!err)
861 vf->rx_ctx_id = 0;
862
863 return err;
864 }
865
866 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf,
867 struct qlcnic_cmd_args *cmd)
868 {
869 if ((cmd->req.arg[0] >> 29) != 0x3)
870 return -EINVAL;
871
872 if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id)
873 return -EINVAL;
874
875 return 0;
876 }
877
878 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
879 struct qlcnic_cmd_args *cmd)
880 {
881 struct qlcnic_vf_info *vf = trans->vf;
882 struct qlcnic_adapter *adapter = vf->adapter;
883 int err;
884
885 err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd);
886 if (err) {
887 cmd->rsp.arg[0] |= (0x6 << 25);
888 return err;
889 }
890
891 cmd->req.arg[1] |= vf->vp->handle << 16;
892 err = qlcnic_issue_cmd(adapter, cmd);
893
894 if (!err)
895 vf->tx_ctx_id = 0;
896
897 return err;
898 }
899
900 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
901 struct qlcnic_cmd_args *cmd)
902 {
903 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
904 return -EINVAL;
905
906 return 0;
907 }
908
909 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans,
910 struct qlcnic_cmd_args *cmd)
911 {
912 struct qlcnic_vf_info *vf = trans->vf;
913 struct qlcnic_adapter *adapter = vf->adapter;
914 int err;
915
916 err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
917 if (err) {
918 cmd->rsp.arg[0] |= (0x6 << 25);
919 return err;
920 }
921
922 err = qlcnic_issue_cmd(adapter, cmd);
923 return err;
924 }
925
926 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
927 struct qlcnic_cmd_args *cmd)
928 {
929 struct qlcnic_vf_info *vf = trans->vf;
930 struct qlcnic_adapter *adapter = vf->adapter;
931 int err = -EIO;
932 u8 op;
933
934 op = cmd->req.arg[1] & 0xff;
935
936 cmd->req.arg[1] |= vf->vp->handle << 16;
937 cmd->req.arg[1] |= BIT_31;
938
939 err = qlcnic_issue_cmd(adapter, cmd);
940 return err;
941 }
942
943 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
944 struct qlcnic_cmd_args *cmd)
945 {
946 if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
947 return -EINVAL;
948
949 if (!(cmd->req.arg[1] & BIT_16))
950 return -EINVAL;
951
952 if ((cmd->req.arg[1] & 0xff) != 0x1)
953 return -EINVAL;
954
955 return 0;
956 }
957
958 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans,
959 struct qlcnic_cmd_args *cmd)
960 {
961 struct qlcnic_vf_info *vf = trans->vf;
962 struct qlcnic_adapter *adapter = vf->adapter;
963 int err;
964
965 err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd);
966 if (err)
967 cmd->rsp.arg[0] |= (0x6 << 25);
968 else
969 err = qlcnic_issue_cmd(adapter, cmd);
970
971 return err;
972 }
973
974 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
975 struct qlcnic_vf_info *vf,
976 struct qlcnic_cmd_args *cmd)
977 {
978 if (cmd->req.arg[1] != vf->rx_ctx_id)
979 return -EINVAL;
980
981 if (cmd->req.arg[2] > adapter->ahw->max_mtu)
982 return -EINVAL;
983
984 return 0;
985 }
986
987 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
988 struct qlcnic_cmd_args *cmd)
989 {
990 struct qlcnic_vf_info *vf = trans->vf;
991 struct qlcnic_adapter *adapter = vf->adapter;
992 int err;
993
994 err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
995 if (err)
996 cmd->rsp.arg[0] |= (0x6 << 25);
997 else
998 err = qlcnic_issue_cmd(adapter, cmd);
999
1000 return err;
1001 }
1002
1003 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
1004 struct qlcnic_cmd_args *cmd)
1005 {
1006 if (cmd->req.arg[1] & BIT_31) {
1007 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
1008 return -EINVAL;
1009 } else {
1010 cmd->req.arg[1] |= vf->vp->handle << 16;
1011 }
1012
1013 return 0;
1014 }
1015
1016 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
1017 struct qlcnic_cmd_args *cmd)
1018 {
1019 struct qlcnic_vf_info *vf = trans->vf;
1020 struct qlcnic_adapter *adapter = vf->adapter;
1021 int err;
1022
1023 err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
1024 if (err) {
1025 cmd->rsp.arg[0] |= (0x6 << 25);
1026 return err;
1027 }
1028
1029 err = qlcnic_issue_cmd(adapter, cmd);
1030 return err;
1031 }
1032
1033 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
1034 struct qlcnic_cmd_args *cmd)
1035 {
1036 if (cmd->req.arg[1] != vf->rx_ctx_id)
1037 return -EINVAL;
1038
1039 return 0;
1040 }
1041
1042 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
1043 struct qlcnic_cmd_args *cmd)
1044 {
1045 struct qlcnic_vf_info *vf = trans->vf;
1046 struct qlcnic_adapter *adapter = vf->adapter;
1047 int err;
1048
1049 err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
1050 if (err)
1051 cmd->rsp.arg[0] |= (0x6 << 25);
1052 else
1053 err = qlcnic_issue_cmd(adapter, cmd);
1054
1055 return err;
1056 }
1057
1058 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
1059 struct qlcnic_vf_info *vf,
1060 struct qlcnic_cmd_args *cmd)
1061 {
1062 struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
1063 u16 ctx_id, pkts, time;
1064
1065 ctx_id = cmd->req.arg[1] >> 16;
1066 pkts = cmd->req.arg[2] & 0xffff;
1067 time = cmd->req.arg[2] >> 16;
1068
1069 if (ctx_id != vf->rx_ctx_id)
1070 return -EINVAL;
1071 if (pkts > coal->rx_packets)
1072 return -EINVAL;
1073 if (time < coal->rx_time_us)
1074 return -EINVAL;
1075
1076 return 0;
1077 }
1078
1079 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
1080 struct qlcnic_cmd_args *cmd)
1081 {
1082 struct qlcnic_vf_info *vf = tran->vf;
1083 struct qlcnic_adapter *adapter = vf->adapter;
1084 int err;
1085
1086 err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
1087 if (err) {
1088 cmd->rsp.arg[0] |= (0x6 << 25);
1089 return err;
1090 }
1091
1092 err = qlcnic_issue_cmd(adapter, cmd);
1093 return err;
1094 }
1095
1096 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
1097 struct qlcnic_vf_info *vf,
1098 struct qlcnic_cmd_args *cmd)
1099 {
1100 struct qlcnic_macvlan_mbx *macvlan;
1101 struct qlcnic_vport *vp = vf->vp;
1102 u8 op, new_op;
1103
1104 if (!(cmd->req.arg[1] & BIT_8))
1105 return -EINVAL;
1106
1107 cmd->req.arg[1] |= (vf->vp->handle << 16);
1108 cmd->req.arg[1] |= BIT_31;
1109
1110 macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2];
1111 if (!(macvlan->mac_addr0 & BIT_0)) {
1112 dev_err(&adapter->pdev->dev,
1113 "MAC address change is not allowed from VF %d",
1114 vf->pci_func);
1115 return -EINVAL;
1116 }
1117
1118 if (vp->vlan_mode == QLC_PVID_MODE) {
1119 op = cmd->req.arg[1] & 0x7;
1120 cmd->req.arg[1] &= ~0x7;
1121 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
1122 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL;
1123 cmd->req.arg[3] |= vp->vlan << 16;
1124 cmd->req.arg[1] |= new_op;
1125 }
1126
1127 return 0;
1128 }
1129
1130 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
1131 struct qlcnic_cmd_args *cmd)
1132 {
1133 struct qlcnic_vf_info *vf = trans->vf;
1134 struct qlcnic_adapter *adapter = vf->adapter;
1135 int err;
1136
1137 err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
1138 if (err) {
1139 cmd->rsp.arg[0] |= (0x6 << 25);
1140 return err;
1141 }
1142
1143 err = qlcnic_issue_cmd(adapter, cmd);
1144 return err;
1145 }
1146
1147 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
1148 struct qlcnic_cmd_args *cmd)
1149 {
1150 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1151 return -EINVAL;
1152
1153 return 0;
1154 }
1155
1156 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
1157 struct qlcnic_cmd_args *cmd)
1158 {
1159 struct qlcnic_vf_info *vf = trans->vf;
1160 struct qlcnic_adapter *adapter = vf->adapter;
1161 int err;
1162
1163 err = qlcnic_sriov_validate_linkevent(vf, cmd);
1164 if (err) {
1165 cmd->rsp.arg[0] |= (0x6 << 25);
1166 return err;
1167 }
1168
1169 err = qlcnic_issue_cmd(adapter, cmd);
1170 return err;
1171 }
1172
1173 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans,
1174 struct qlcnic_cmd_args *cmd)
1175 {
1176 struct qlcnic_vf_info *vf = trans->vf;
1177 struct qlcnic_adapter *adapter = vf->adapter;
1178 int err;
1179
1180 cmd->req.arg[1] |= vf->vp->handle << 16;
1181 cmd->req.arg[1] |= BIT_31;
1182 err = qlcnic_issue_cmd(adapter, cmd);
1183 return err;
1184 }
1185
1186 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans,
1187 struct qlcnic_cmd_args *cmd)
1188 {
1189 struct qlcnic_vf_info *vf = trans->vf;
1190 struct qlcnic_vport *vp = vf->vp;
1191 u8 cmd_op, mode = vp->vlan_mode;
1192 struct qlcnic_adapter *adapter;
1193
1194 adapter = vf->adapter;
1195
1196 cmd_op = trans->req_hdr->cmd_op;
1197 cmd->rsp.arg[0] |= 1 << 25;
1198
1199 /* For 84xx adapter in case of PVID , PFD should send vlan mode as
1200 * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response
1201 */
1202 if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE)
1203 return 0;
1204
1205 switch (mode) {
1206 case QLC_GUEST_VLAN_MODE:
1207 cmd->rsp.arg[1] = mode | 1 << 8;
1208 cmd->rsp.arg[2] = 1 << 16;
1209 break;
1210 case QLC_PVID_MODE:
1211 cmd->rsp.arg[1] = mode | 1 << 8 | vp->vlan << 16;
1212 break;
1213 }
1214
1215 return 0;
1216 }
1217
1218 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter,
1219 struct qlcnic_vf_info *vf)
1220
1221 {
1222 struct qlcnic_vport *vp = vf->vp;
1223
1224 if (!vp->vlan)
1225 return -EINVAL;
1226
1227 if (!vf->rx_ctx_id) {
1228 vp->vlan = 0;
1229 return 0;
1230 }
1231
1232 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1233 vp->vlan, QLCNIC_MAC_DEL);
1234 vp->vlan = 0;
1235 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1236 0, QLCNIC_MAC_ADD);
1237 return 0;
1238 }
1239
1240 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter,
1241 struct qlcnic_vf_info *vf,
1242 struct qlcnic_cmd_args *cmd)
1243 {
1244 struct qlcnic_vport *vp = vf->vp;
1245 int err = -EIO;
1246
1247 if (vp->vlan)
1248 return err;
1249
1250 if (!vf->rx_ctx_id) {
1251 vp->vlan = cmd->req.arg[1] >> 16;
1252 return 0;
1253 }
1254
1255 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1256 0, QLCNIC_MAC_DEL);
1257 if (err)
1258 return err;
1259
1260 vp->vlan = cmd->req.arg[1] >> 16;
1261 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1262 vp->vlan, QLCNIC_MAC_ADD);
1263
1264 if (err) {
1265 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1266 0, QLCNIC_MAC_ADD);
1267 vp->vlan = 0;
1268 }
1269
1270 return err;
1271 }
1272
1273 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran,
1274 struct qlcnic_cmd_args *cmd)
1275 {
1276 struct qlcnic_vf_info *vf = tran->vf;
1277 struct qlcnic_adapter *adapter = vf->adapter;
1278 struct qlcnic_vport *vp = vf->vp;
1279 int err = -EIO;
1280 u8 op;
1281
1282 if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) {
1283 cmd->rsp.arg[0] |= 2 << 25;
1284 return err;
1285 }
1286
1287 op = cmd->req.arg[1] & 0xf;
1288
1289 if (op)
1290 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd);
1291 else
1292 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf);
1293
1294 cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25;
1295 return err;
1296 }
1297
1298 static const int qlcnic_pf_passthru_supp_cmds[] = {
1299 QLCNIC_CMD_GET_STATISTICS,
1300 QLCNIC_CMD_GET_PORT_CONFIG,
1301 QLCNIC_CMD_GET_LINK_STATUS,
1302 QLCNIC_CMD_DCB_QUERY_CAP,
1303 QLCNIC_CMD_DCB_QUERY_PARAM,
1304 QLCNIC_CMD_INIT_NIC_FUNC,
1305 QLCNIC_CMD_STOP_NIC_FUNC,
1306 };
1307
1308 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
1309 [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1310 [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1311 [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd},
1312 [QLCNIC_BC_CMD_CFG_GUEST_VLAN] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd},
1313 };
1314
1315 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
1316 {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
1317 {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
1318 {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
1319 {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
1320 {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
1321 {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
1322 {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
1323 {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
1324 {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
1325 {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
1326 {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
1327 {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
1328 {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
1329 {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
1330 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
1331 };
1332
1333 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
1334 struct qlcnic_bc_trans *trans,
1335 struct qlcnic_cmd_args *cmd)
1336 {
1337 u8 size, cmd_op;
1338
1339 cmd_op = trans->req_hdr->cmd_op;
1340
1341 if (trans->req_hdr->op_type == QLC_BC_CMD) {
1342 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
1343 if (cmd_op < size) {
1344 qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
1345 return;
1346 }
1347 } else {
1348 int i;
1349 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
1350 for (i = 0; i < size; i++) {
1351 if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
1352 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
1353 return;
1354 }
1355 }
1356
1357 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
1358 for (i = 0; i < size; i++) {
1359 if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
1360 qlcnic_issue_cmd(adapter, cmd);
1361 return;
1362 }
1363 }
1364 }
1365
1366 cmd->rsp.arg[0] |= (0x9 << 25);
1367 }
1368
1369 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
1370 u32 *int_id)
1371 {
1372 u16 vpid;
1373
1374 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1375 adapter->ahw->pci_func);
1376 *int_id |= vpid;
1377 }
1378
1379 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter,
1380 u32 *int_id)
1381 {
1382 u16 vpid;
1383
1384 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1385 adapter->ahw->pci_func);
1386 *int_id |= vpid << 16;
1387 }
1388
1389 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
1390 u32 *int_id)
1391 {
1392 int vpid;
1393
1394 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1395 adapter->ahw->pci_func);
1396 *int_id |= vpid << 16;
1397 }
1398
1399 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter,
1400 u32 *int_id)
1401 {
1402 u16 vpid;
1403
1404 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1405 adapter->ahw->pci_func);
1406 *int_id |= vpid << 16;
1407 }
1408
1409 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter,
1410 u32 *int_id)
1411 {
1412 u16 vpid;
1413
1414 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1415 adapter->ahw->pci_func);
1416 *int_id |= (vpid << 16) | BIT_31;
1417 }
1418
1419 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter,
1420 u32 *int_id)
1421 {
1422 u16 vpid;
1423
1424 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1425 adapter->ahw->pci_func);
1426 *int_id |= (vpid << 16) | BIT_31;
1427 }
1428
1429 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter,
1430 u32 *int_id)
1431 {
1432 u16 vpid;
1433
1434 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1435 adapter->ahw->pci_func);
1436 *int_id |= (vpid << 16) | BIT_31;
1437 }
1438
1439 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter,
1440 struct qlcnic_vf_info *vf)
1441 {
1442 struct qlcnic_cmd_args cmd;
1443 int vpid;
1444
1445 if (!vf->rx_ctx_id)
1446 return;
1447
1448 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX))
1449 return;
1450
1451 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1452 if (vpid >= 0) {
1453 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16;
1454 if (qlcnic_issue_cmd(adapter, &cmd))
1455 dev_err(&adapter->pdev->dev,
1456 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1457 vf->pci_func);
1458 else
1459 vf->rx_ctx_id = 0;
1460 }
1461
1462 qlcnic_free_mbx_args(&cmd);
1463 }
1464
1465 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter,
1466 struct qlcnic_vf_info *vf)
1467 {
1468 struct qlcnic_cmd_args cmd;
1469 int vpid;
1470
1471 if (!vf->tx_ctx_id)
1472 return;
1473
1474 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX))
1475 return;
1476
1477 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1478 if (vpid >= 0) {
1479 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16;
1480 if (qlcnic_issue_cmd(adapter, &cmd))
1481 dev_err(&adapter->pdev->dev,
1482 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1483 vf->pci_func);
1484 else
1485 vf->tx_ctx_id = 0;
1486 }
1487
1488 qlcnic_free_mbx_args(&cmd);
1489 }
1490
1491 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov,
1492 struct qlcnic_vf_info *vf,
1493 struct qlcnic_bc_trans *trans)
1494 {
1495 struct qlcnic_trans_list *t_list = &vf->rcv_act;
1496 unsigned long flag;
1497
1498 spin_lock_irqsave(&t_list->lock, flag);
1499
1500 __qlcnic_sriov_add_act_list(sriov, vf, trans);
1501
1502 spin_unlock_irqrestore(&t_list->lock, flag);
1503 return 0;
1504 }
1505
1506 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf)
1507 {
1508 struct qlcnic_adapter *adapter = vf->adapter;
1509
1510 qlcnic_sriov_cleanup_list(&vf->rcv_pend);
1511 cancel_work_sync(&vf->trans_work);
1512 qlcnic_sriov_cleanup_list(&vf->rcv_act);
1513
1514 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1515 qlcnic_sriov_del_tx_ctx(adapter, vf);
1516 qlcnic_sriov_del_rx_ctx(adapter, vf);
1517 }
1518
1519 qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func);
1520
1521 clear_bit(QLC_BC_VF_FLR, &vf->state);
1522 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1523 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf,
1524 vf->flr_trans);
1525 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1526 vf->flr_trans = NULL;
1527 }
1528 }
1529
1530 static void qlcnic_sriov_pf_process_flr(struct work_struct *work)
1531 {
1532 struct qlcnic_vf_info *vf;
1533
1534 vf = container_of(work, struct qlcnic_vf_info, flr_work);
1535 __qlcnic_sriov_process_flr(vf);
1536 return;
1537 }
1538
1539 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov,
1540 struct qlcnic_vf_info *vf,
1541 work_func_t func)
1542 {
1543 if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state))
1544 return;
1545
1546 INIT_WORK(&vf->flr_work, func);
1547 queue_work(sriov->bc.bc_flr_wq, &vf->flr_work);
1548 }
1549
1550 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter,
1551 struct qlcnic_bc_trans *trans,
1552 struct qlcnic_vf_info *vf)
1553 {
1554 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1555
1556 set_bit(QLC_BC_VF_FLR, &vf->state);
1557 clear_bit(QLC_BC_VF_STATE, &vf->state);
1558 set_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1559 vf->flr_trans = trans;
1560 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1561 netdev_info(adapter->netdev, "Software FLR for PCI func %d\n",
1562 vf->pci_func);
1563 }
1564
1565 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter,
1566 struct qlcnic_bc_trans *trans,
1567 struct qlcnic_vf_info *vf)
1568 {
1569 struct qlcnic_bc_hdr *hdr = trans->req_hdr;
1570
1571 if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) &&
1572 (hdr->op_type == QLC_BC_CMD) &&
1573 test_bit(QLC_BC_VF_STATE, &vf->state)) {
1574 qlcnic_sriov_handle_soft_flr(adapter, trans, vf);
1575 return true;
1576 }
1577
1578 return false;
1579 }
1580
1581 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov,
1582 struct qlcnic_vf_info *vf)
1583 {
1584 struct net_device *dev = vf->adapter->netdev;
1585 struct qlcnic_vport *vp = vf->vp;
1586
1587 if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) {
1588 clear_bit(QLC_BC_VF_FLR, &vf->state);
1589 return;
1590 }
1591
1592 if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) {
1593 netdev_info(dev, "FLR for PCI func %d in progress\n",
1594 vf->pci_func);
1595 return;
1596 }
1597
1598 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
1599 vp->vlan = 0;
1600
1601 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1602 netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func);
1603 }
1604
1605 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter)
1606 {
1607 struct qlcnic_hardware_context *ahw = adapter->ahw;
1608 struct qlcnic_sriov *sriov = ahw->sriov;
1609 struct qlcnic_vf_info *vf;
1610 u16 num_vfs = sriov->num_vfs;
1611 int i;
1612
1613 for (i = 0; i < num_vfs; i++) {
1614 vf = &sriov->vf_info[i];
1615 vf->rx_ctx_id = 0;
1616 vf->tx_ctx_id = 0;
1617 cancel_work_sync(&vf->flr_work);
1618 __qlcnic_sriov_process_flr(vf);
1619 clear_bit(QLC_BC_VF_STATE, &vf->state);
1620 }
1621
1622 qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func);
1623 QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8);
1624 }
1625
1626 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter)
1627 {
1628 struct qlcnic_hardware_context *ahw = adapter->ahw;
1629 int err;
1630
1631 if (!qlcnic_sriov_enable_check(adapter))
1632 return 0;
1633
1634 ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
1635
1636 err = qlcnic_sriov_pf_init(adapter);
1637 if (err)
1638 return err;
1639
1640 dev_info(&adapter->pdev->dev, "%s: op_mode %d\n",
1641 __func__, ahw->op_mode);
1642 return err;
1643 }
1644
1645 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1646 {
1647 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1648 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1649 int i, num_vfs;
1650 struct qlcnic_vf_info *vf_info;
1651 u8 *curr_mac;
1652
1653 if (!qlcnic_sriov_pf_check(adapter))
1654 return -EOPNOTSUPP;
1655
1656 num_vfs = sriov->num_vfs;
1657
1658 if (!is_valid_ether_addr(mac) || vf >= num_vfs)
1659 return -EINVAL;
1660
1661 if (ether_addr_equal(adapter->mac_addr, mac)) {
1662 netdev_err(netdev, "MAC address is already in use by the PF\n");
1663 return -EINVAL;
1664 }
1665
1666 for (i = 0; i < num_vfs; i++) {
1667 vf_info = &sriov->vf_info[i];
1668 if (ether_addr_equal(vf_info->vp->mac, mac)) {
1669 netdev_err(netdev,
1670 "MAC address is already in use by VF %d\n",
1671 i);
1672 return -EINVAL;
1673 }
1674 }
1675
1676 vf_info = &sriov->vf_info[vf];
1677 curr_mac = vf_info->vp->mac;
1678
1679 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1680 netdev_err(netdev,
1681 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1682 vf);
1683 return -EOPNOTSUPP;
1684 }
1685
1686 memcpy(curr_mac, mac, netdev->addr_len);
1687 netdev_info(netdev, "MAC Address %pM is configured for VF %d\n",
1688 mac, vf);
1689 return 0;
1690 }
1691
1692 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate)
1693 {
1694 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1695 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1696 struct qlcnic_vf_info *vf_info;
1697 struct qlcnic_info nic_info;
1698 struct qlcnic_vport *vp;
1699 u16 vpid;
1700
1701 if (!qlcnic_sriov_pf_check(adapter))
1702 return -EOPNOTSUPP;
1703
1704 if (vf >= sriov->num_vfs)
1705 return -EINVAL;
1706
1707 if (tx_rate >= 10000 || tx_rate < 100) {
1708 netdev_err(netdev,
1709 "Invalid Tx rate, allowed range is [%d - %d]",
1710 QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE);
1711 return -EINVAL;
1712 }
1713
1714 if (tx_rate == 0)
1715 tx_rate = 10000;
1716
1717 vf_info = &sriov->vf_info[vf];
1718 vp = vf_info->vp;
1719 vpid = vp->handle;
1720
1721 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1722 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid))
1723 return -EIO;
1724
1725 nic_info.max_tx_bw = tx_rate / 100;
1726 nic_info.bit_offsets = BIT_0;
1727
1728 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid))
1729 return -EIO;
1730 }
1731
1732 vp->max_tx_bw = tx_rate / 100;
1733 netdev_info(netdev,
1734 "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1735 tx_rate, vp->max_tx_bw, vf);
1736 return 0;
1737 }
1738
1739 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf,
1740 u16 vlan, u8 qos)
1741 {
1742 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1743 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1744 struct qlcnic_vf_info *vf_info;
1745 struct qlcnic_vport *vp;
1746
1747 if (!qlcnic_sriov_pf_check(adapter))
1748 return -EOPNOTSUPP;
1749
1750 if (vf >= sriov->num_vfs || qos > 7)
1751 return -EINVAL;
1752
1753 if (vlan > MAX_VLAN_ID) {
1754 netdev_err(netdev,
1755 "Invalid VLAN ID, allowed range is [0 - %d]\n",
1756 MAX_VLAN_ID);
1757 return -EINVAL;
1758 }
1759
1760 vf_info = &sriov->vf_info[vf];
1761 vp = vf_info->vp;
1762 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1763 netdev_err(netdev,
1764 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1765 vf);
1766 return -EOPNOTSUPP;
1767 }
1768
1769 switch (vlan) {
1770 case 4095:
1771 vp->vlan = 0;
1772 vp->vlan_mode = QLC_GUEST_VLAN_MODE;
1773 break;
1774 case 0:
1775 vp->vlan_mode = QLC_NO_VLAN_MODE;
1776 vp->vlan = 0;
1777 vp->qos = 0;
1778 break;
1779 default:
1780 vp->vlan_mode = QLC_PVID_MODE;
1781 vp->vlan = vlan;
1782 vp->qos = qos;
1783 }
1784
1785 netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n",
1786 vlan, qos, vf);
1787 return 0;
1788 }
1789
1790 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter,
1791 struct qlcnic_vport *vp, int vf)
1792 {
1793 __u32 vlan = 0;
1794
1795 switch (vp->vlan_mode) {
1796 case QLC_PVID_MODE:
1797 vlan = vp->vlan;
1798 break;
1799 case QLC_GUEST_VLAN_MODE:
1800 vlan = MAX_VLAN_ID;
1801 break;
1802 case QLC_NO_VLAN_MODE:
1803 vlan = 0;
1804 break;
1805 default:
1806 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n",
1807 vp->vlan_mode, vf);
1808 }
1809
1810 return vlan;
1811 }
1812
1813 int qlcnic_sriov_get_vf_config(struct net_device *netdev,
1814 int vf, struct ifla_vf_info *ivi)
1815 {
1816 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1817 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1818 struct qlcnic_vport *vp;
1819
1820 if (!qlcnic_sriov_pf_check(adapter))
1821 return -EOPNOTSUPP;
1822
1823 if (vf >= sriov->num_vfs)
1824 return -EINVAL;
1825
1826 vp = sriov->vf_info[vf].vp;
1827 memcpy(&ivi->mac, vp->mac, ETH_ALEN);
1828 ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf);
1829 ivi->qos = vp->qos;
1830 ivi->spoofchk = vp->spoofchk;
1831 if (vp->max_tx_bw == MAX_BW)
1832 ivi->tx_rate = 0;
1833 else
1834 ivi->tx_rate = vp->max_tx_bw * 100;
1835
1836 ivi->vf = vf;
1837 return 0;
1838 }
1839
1840 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk)
1841 {
1842 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1843 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1844 struct qlcnic_vf_info *vf_info;
1845 struct qlcnic_vport *vp;
1846
1847 if (!qlcnic_sriov_pf_check(adapter))
1848 return -EOPNOTSUPP;
1849
1850 if (vf >= sriov->num_vfs)
1851 return -EINVAL;
1852
1853 vf_info = &sriov->vf_info[vf];
1854 vp = vf_info->vp;
1855 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1856 netdev_err(netdev,
1857 "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1858 vf);
1859 return -EOPNOTSUPP;
1860 }
1861
1862 vp->spoofchk = chk;
1863 return 0;
1864 }
Linux with added FPC-III support