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