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