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