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