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