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