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