Pileus Git - ~andy/linux/blob - drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_pf.c

   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
  13 #define QLC_VF_MIN_TX_RATE      100
  14 #define QLC_VF_MAX_TX_RATE      9999
  15
  16 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *, u8);
  17
  18 struct qlcnic_sriov_cmd_handler {
  19         int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
  20 };
  21
  22 struct qlcnic_sriov_fw_cmd_handler {
  23         u32 cmd;
  24         int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
  25 };
  26
  27 static 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
  62 static 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;
  67         u32 temp, num_vf_macs, num_vfs, max;
  68         int ret = -EIO, vpid, id;
  69         struct qlcnic_vport *vp;
  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;
  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;
  87                 info->min_tx_bw = 0;
  88                 info->max_tx_bw = MAX_BW;
  89         } else {
  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;
  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
 116 static 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
 135 static 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
 168         qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info);
 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
 187 out:
 188         qlcnic_free_mbx_args(&cmd);
 189         return err;
 190 }
 191
 192 static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter,
 193                                                u8 func)
 194 {
 195         struct qlcnic_sriov  *sriov = adapter->ahw->sriov;
 196         struct qlcnic_vport *vp;
 197         int index;
 198
 199         if (adapter->ahw->pci_func == func) {
 200                 sriov->vp_handle = 0;
 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         }
 208 }
 209
 210 static 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;
 214         struct qlcnic_vport *vp;
 215         int index;
 216
 217         if (adapter->ahw->pci_func == func) {
 218                 sriov->vp_handle = vport_handle;
 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         }
 226 }
 227
 228 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter,
 229                                             u8 func)
 230 {
 231         struct qlcnic_sriov  *sriov = adapter->ahw->sriov;
 232         struct qlcnic_vf_info *vf_info;
 233         int index;
 234
 235         if (adapter->ahw->pci_func == func) {
 236                 return sriov->vp_handle;
 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         }
 244
 245         return -EINVAL;
 246 }
 247
 248 static 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
 284 out:
 285         qlcnic_free_mbx_args(&cmd);
 286         return ret;
 287 }
 288
 289 static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter,
 290                                        u8 func, u8 enable)
 291 {
 292         struct qlcnic_cmd_args cmd;
 293         int err = -EIO;
 294
 295         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH))
 296                 return -ENOMEM;
 297
 298         cmd.req.arg[0] |= (3 << 29);
 299         cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1;
 300         if (enable)
 301                 cmd.req.arg[1] |= BIT_0;
 302
 303         err = qlcnic_issue_cmd(adapter, &cmd);
 304
 305         if (err != QLCNIC_RCODE_SUCCESS) {
 306                 dev_err(&adapter->pdev->dev,
 307                         "Failed to enable sriov eswitch%d\n", err);
 308                 err = -EIO;
 309         }
 310
 311         qlcnic_free_mbx_args(&cmd);
 312         return err;
 313 }
 314
 315 static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter *adapter)
 316 {
 317         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
 318         struct qlcnic_back_channel *bc = &sriov->bc;
 319         int i;
 320
 321         for (i = 0; i < sriov->num_vfs; i++)
 322                 cancel_work_sync(&sriov->vf_info[i].flr_work);
 323
 324         destroy_workqueue(bc->bc_flr_wq);
 325 }
 326
 327 static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter *adapter)
 328 {
 329         struct qlcnic_back_channel *bc = &adapter->ahw->sriov->bc;
 330         struct workqueue_struct *wq;
 331
 332         wq = create_singlethread_workqueue("qlcnic-flr");
 333         if (wq == NULL) {
 334                 dev_err(&adapter->pdev->dev, "Cannot create FLR workqueue\n");
 335                 return -ENOMEM;
 336         }
 337
 338         bc->bc_flr_wq =  wq;
 339         return 0;
 340 }
 341
 342 void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter)
 343 {
 344         u8 func = adapter->ahw->pci_func;
 345
 346         if (!qlcnic_sriov_enable_check(adapter))
 347                 return;
 348
 349         qlcnic_sriov_pf_del_flr_queue(adapter);
 350         qlcnic_sriov_cfg_bc_intr(adapter, 0);
 351         qlcnic_sriov_pf_config_vport(adapter, 0, func);
 352         qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
 353         __qlcnic_sriov_cleanup(adapter);
 354         adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
 355         clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
 356 }
 357
 358 void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter)
 359 {
 360         if (!qlcnic_sriov_pf_check(adapter))
 361                 return;
 362
 363         if (!qlcnic_sriov_enable_check(adapter))
 364                 return;
 365
 366         pci_disable_sriov(adapter->pdev);
 367         netdev_info(adapter->netdev,
 368                     "SR-IOV is disabled successfully on port %d\n",
 369                     adapter->portnum);
 370 }
 371
 372 static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter)
 373 {
 374         struct net_device *netdev = adapter->netdev;
 375
 376         if (netif_running(netdev))
 377                 __qlcnic_down(adapter, netdev);
 378
 379         qlcnic_sriov_pf_disable(adapter);
 380
 381         qlcnic_sriov_pf_cleanup(adapter);
 382
 383         /* After disabling SRIOV re-init the driver in default mode
 384            configure opmode based on op_mode of function
 385          */
 386         if (qlcnic_83xx_configure_opmode(adapter))
 387                 return -EIO;
 388
 389         if (netif_running(netdev))
 390                 __qlcnic_up(adapter, netdev);
 391
 392         return 0;
 393 }
 394
 395 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
 396 {
 397         struct qlcnic_hardware_context *ahw = adapter->ahw;
 398         struct qlcnic_info nic_info, pf_info, vp_info;
 399         int err;
 400         u8 func = ahw->pci_func;
 401
 402         if (!qlcnic_sriov_enable_check(adapter))
 403                 return 0;
 404
 405         err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
 406         if (err)
 407                 return err;
 408
 409         err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
 410         if (err)
 411                 goto disable_eswitch;
 412
 413         err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
 414         if (err)
 415                 goto delete_vport;
 416
 417         err = qlcnic_get_nic_info(adapter, &nic_info, func);
 418         if (err)
 419                 goto delete_vport;
 420
 421         err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
 422         if (err)
 423                 goto delete_vport;
 424
 425         err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
 426         if (err)
 427                 goto delete_vport;
 428
 429         ahw->physical_port = (u8) nic_info.phys_port;
 430         ahw->switch_mode = nic_info.switch_mode;
 431         ahw->max_mtu = nic_info.max_mtu;
 432         ahw->capabilities = nic_info.capabilities;
 433         ahw->nic_mode = QLC_83XX_SRIOV_MODE;
 434         return err;
 435
 436 delete_vport:
 437         qlcnic_sriov_pf_config_vport(adapter, 0, func);
 438
 439 disable_eswitch:
 440         qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
 441
 442         return err;
 443 }
 444
 445 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
 446 {
 447         int err;
 448
 449         if (!qlcnic_sriov_enable_check(adapter))
 450                 return 0;
 451
 452         err = pci_enable_sriov(adapter->pdev, num_vfs);
 453         if (err)
 454                 qlcnic_sriov_pf_cleanup(adapter);
 455
 456         return err;
 457 }
 458
 459 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
 460                                      int num_vfs)
 461 {
 462         int err = 0;
 463
 464         set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
 465         adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
 466
 467         err = qlcnic_sriov_init(adapter, num_vfs);
 468         if (err)
 469                 goto clear_op_mode;
 470
 471         err = qlcnic_sriov_pf_create_flr_queue(adapter);
 472         if (err)
 473                 goto sriov_cleanup;
 474
 475         err = qlcnic_sriov_pf_init(adapter);
 476         if (err)
 477                 goto del_flr_queue;
 478
 479         err = qlcnic_sriov_pf_enable(adapter, num_vfs);
 480         return err;
 481
 482 del_flr_queue:
 483         qlcnic_sriov_pf_del_flr_queue(adapter);
 484
 485 sriov_cleanup:
 486         __qlcnic_sriov_cleanup(adapter);
 487
 488 clear_op_mode:
 489         clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
 490         adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
 491         return err;
 492 }
 493
 494 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
 495 {
 496         struct net_device *netdev = adapter->netdev;
 497         int err;
 498
 499         if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
 500                 netdev_err(netdev,
 501                            "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
 502                 return -EIO;
 503         }
 504
 505         if (netif_running(netdev))
 506                 __qlcnic_down(adapter, netdev);
 507
 508         err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
 509         if (err) {
 510                 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
 511                             adapter->portnum);
 512
 513                 err = -EIO;
 514                 if (qlcnic_83xx_configure_opmode(adapter))
 515                         goto error;
 516         } else {
 517                 netdev_info(netdev,
 518                             "SR-IOV is enabled successfully on port %d\n",
 519                             adapter->portnum);
 520                 /* Return number of vfs enabled */
 521                 err = num_vfs;
 522         }
 523         if (netif_running(netdev))
 524                 __qlcnic_up(adapter, netdev);
 525
 526 error:
 527         return err;
 528 }
 529
 530 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
 531 {
 532         struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
 533         int err;
 534
 535         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
 536                 return -EBUSY;
 537
 538         if (num_vfs == 0)
 539                 err = qlcnic_pci_sriov_disable(adapter);
 540         else
 541                 err = qlcnic_pci_sriov_enable(adapter, num_vfs);
 542
 543         clear_bit(__QLCNIC_RESETTING, &adapter->state);
 544         return err;
 545 }
 546
 547 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
 548                                           u16 func)
 549 {
 550         struct qlcnic_info defvp_info;
 551         int err;
 552
 553         err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
 554         if (err)
 555                 return -EIO;
 556
 557         return 0;
 558 }
 559
 560 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
 561                                            struct qlcnic_cmd_args *cmd)
 562 {
 563         struct qlcnic_vf_info *vf = trans->vf;
 564         struct qlcnic_adapter *adapter = vf->adapter;
 565         int err;
 566         u16 func = vf->pci_func;
 567
 568         cmd->rsp.arg[0] = trans->req_hdr->cmd_op;
 569         cmd->rsp.arg[0] |= (1 << 16);
 570
 571         if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
 572                 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
 573                 if (!err) {
 574                         err = qlcnic_sriov_set_vf_vport_info(adapter, func);
 575                         if (err)
 576                                 qlcnic_sriov_pf_config_vport(adapter, 0, func);
 577                 }
 578         } else {
 579                 err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
 580         }
 581
 582         if (err)
 583                 goto err_out;
 584
 585         cmd->rsp.arg[0] |= (1 << 25);
 586
 587         if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
 588                 set_bit(QLC_BC_VF_STATE, &vf->state);
 589         else
 590                 clear_bit(QLC_BC_VF_STATE, &vf->state);
 591
 592         return err;
 593
 594 err_out:
 595         cmd->rsp.arg[0] |= (2 << 25);
 596         return err;
 597 }
 598
 599 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
 600                                        struct qlcnic_vport *vp,
 601                                        u16 func, u16 vlan, u8 op)
 602 {
 603         struct qlcnic_cmd_args cmd;
 604         struct qlcnic_macvlan_mbx mv;
 605         u8 *addr;
 606         int err;
 607         u32 *buf;
 608         int vpid;
 609
 610         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN))
 611                 return -ENOMEM;
 612
 613         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
 614         if (vpid < 0) {
 615                 err = -EINVAL;
 616                 goto out;
 617         }
 618
 619         if (vlan)
 620                 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
 621                       QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
 622
 623         cmd.req.arg[1] = op | (1 << 8) | (3 << 6);
 624         cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
 625
 626         addr = vp->mac;
 627         mv.vlan = vlan;
 628         mv.mac_addr0 = addr[0];
 629         mv.mac_addr1 = addr[1];
 630         mv.mac_addr2 = addr[2];
 631         mv.mac_addr3 = addr[3];
 632         mv.mac_addr4 = addr[4];
 633         mv.mac_addr5 = addr[5];
 634         buf = &cmd.req.arg[2];
 635         memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
 636
 637         err = qlcnic_issue_cmd(adapter, &cmd);
 638
 639         if (err)
 640                 dev_err(&adapter->pdev->dev,
 641                         "MAC-VLAN %s to CAM failed, err=%d.\n",
 642                         ((op == 1) ? "add " : "delete "), err);
 643
 644 out:
 645         qlcnic_free_mbx_args(&cmd);
 646         return err;
 647 }
 648
 649 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
 650 {
 651         if ((cmd->req.arg[0] >> 29) != 0x3)
 652                 return -EINVAL;
 653
 654         return 0;
 655 }
 656
 657 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
 658                                              struct qlcnic_cmd_args *cmd)
 659 {
 660         struct qlcnic_vf_info *vf = tran->vf;
 661         struct qlcnic_adapter *adapter = vf->adapter;
 662         struct qlcnic_rcv_mbx_out *mbx_out;
 663         int err;
 664
 665         err = qlcnic_sriov_validate_create_rx_ctx(cmd);
 666         if (err) {
 667                 cmd->rsp.arg[0] |= (0x6 << 25);
 668                 return err;
 669         }
 670
 671         cmd->req.arg[6] = vf->vp->handle;
 672         err = qlcnic_issue_cmd(adapter, cmd);
 673
 674         if (!err) {
 675                 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
 676                 vf->rx_ctx_id = mbx_out->ctx_id;
 677                 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
 678                                             0, QLCNIC_MAC_ADD);
 679         } else {
 680                 vf->rx_ctx_id = 0;
 681         }
 682
 683         return err;
 684 }
 685
 686 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
 687                                            struct qlcnic_cmd_args *cmd)
 688 {
 689         struct qlcnic_vf_info *vf = trans->vf;
 690         u8 type, *mac;
 691
 692         type = cmd->req.arg[1];
 693         switch (type) {
 694         case QLCNIC_SET_STATION_MAC:
 695         case QLCNIC_SET_FAC_DEF_MAC:
 696                 cmd->rsp.arg[0] = (2 << 25);
 697                 break;
 698         case QLCNIC_GET_CURRENT_MAC:
 699                 cmd->rsp.arg[0] = (1 << 25);
 700                 mac = vf->vp->mac;
 701                 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
 702                 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
 703                                   ((mac[3]) << 16 & 0xff0000) |
 704                                   ((mac[2]) << 24 & 0xff000000);
 705         }
 706
 707         return 0;
 708 }
 709
 710 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
 711 {
 712         if ((cmd->req.arg[0] >> 29) != 0x3)
 713                 return -EINVAL;
 714
 715         return 0;
 716 }
 717
 718 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
 719                                              struct qlcnic_cmd_args *cmd)
 720 {
 721         struct qlcnic_vf_info *vf = trans->vf;
 722         struct qlcnic_adapter *adapter = vf->adapter;
 723         struct qlcnic_tx_mbx_out *mbx_out;
 724         int err;
 725
 726         err = qlcnic_sriov_validate_create_tx_ctx(cmd);
 727         if (err) {
 728                 cmd->rsp.arg[0] |= (0x6 << 25);
 729                 return err;
 730         }
 731
 732         cmd->req.arg[5] |= vf->vp->handle << 16;
 733         err = qlcnic_issue_cmd(adapter, cmd);
 734         if (!err) {
 735                 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
 736                 vf->tx_ctx_id = mbx_out->ctx_id;
 737         } else {
 738                 vf->tx_ctx_id = 0;
 739         }
 740
 741         return err;
 742 }
 743
 744 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
 745                                             struct qlcnic_cmd_args *cmd)
 746 {
 747         if ((cmd->req.arg[0] >> 29) != 0x3)
 748                 return -EINVAL;
 749
 750         if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
 751                 return -EINVAL;
 752
 753         return 0;
 754 }
 755
 756 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,
 757                                           struct qlcnic_cmd_args *cmd)
 758 {
 759         struct qlcnic_vf_info *vf = trans->vf;
 760         struct qlcnic_adapter *adapter = vf->adapter;
 761         int err;
 762
 763         err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
 764         if (err) {
 765                 cmd->rsp.arg[0] |= (0x6 << 25);
 766                 return err;
 767         }
 768
 769         qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
 770                                     0, QLCNIC_MAC_DEL);
 771         cmd->req.arg[1] |= vf->vp->handle << 16;
 772         err = qlcnic_issue_cmd(adapter, cmd);
 773
 774         if (!err)
 775                 vf->rx_ctx_id = 0;
 776
 777         return err;
 778 }
 779
 780 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf,
 781                                             struct qlcnic_cmd_args *cmd)
 782 {
 783         if ((cmd->req.arg[0] >> 29) != 0x3)
 784                 return -EINVAL;
 785
 786         if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id)
 787                 return -EINVAL;
 788
 789         return 0;
 790 }
 791
 792 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
 793                                           struct qlcnic_cmd_args *cmd)
 794 {
 795         struct qlcnic_vf_info *vf = trans->vf;
 796         struct qlcnic_adapter *adapter = vf->adapter;
 797         int err;
 798
 799         err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd);
 800         if (err) {
 801                 cmd->rsp.arg[0] |= (0x6 << 25);
 802                 return err;
 803         }
 804
 805         cmd->req.arg[1] |= vf->vp->handle << 16;
 806         err = qlcnic_issue_cmd(adapter, cmd);
 807
 808         if (!err)
 809                 vf->tx_ctx_id = 0;
 810
 811         return err;
 812 }
 813
 814 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
 815                                          struct qlcnic_cmd_args *cmd)
 816 {
 817         if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
 818                 return -EINVAL;
 819
 820         return 0;
 821 }
 822
 823 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans,
 824                                        struct qlcnic_cmd_args *cmd)
 825 {
 826         struct qlcnic_vf_info *vf = trans->vf;
 827         struct qlcnic_adapter *adapter = vf->adapter;
 828         int err;
 829
 830         err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
 831         if (err) {
 832                 cmd->rsp.arg[0] |= (0x6 << 25);
 833                 return err;
 834         }
 835
 836         err = qlcnic_issue_cmd(adapter, cmd);
 837         return err;
 838 }
 839
 840 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
 841                                       struct qlcnic_cmd_args *cmd)
 842 {
 843         struct qlcnic_vf_info *vf = trans->vf;
 844         struct qlcnic_adapter *adapter = vf->adapter;
 845         int err = -EIO;
 846         u8 op;
 847
 848         op =  cmd->req.arg[1] & 0xff;
 849
 850         cmd->req.arg[1] |= vf->vp->handle << 16;
 851         cmd->req.arg[1] |= BIT_31;
 852
 853         err = qlcnic_issue_cmd(adapter, cmd);
 854         return err;
 855 }
 856
 857 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
 858                                             struct qlcnic_cmd_args *cmd)
 859 {
 860         if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
 861                 return -EINVAL;
 862
 863         if (!(cmd->req.arg[1] & BIT_16))
 864                 return -EINVAL;
 865
 866         if ((cmd->req.arg[1] & 0xff) != 0x1)
 867                 return -EINVAL;
 868
 869         return 0;
 870 }
 871
 872 static int qlcnic_sriov_pf_cfg_intrpt_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_cfg_intrpt(vf, cmd);
 880         if (err)
 881                 cmd->rsp.arg[0] |= (0x6 << 25);
 882         else
 883                 err = qlcnic_issue_cmd(adapter, cmd);
 884
 885         return err;
 886 }
 887
 888 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
 889                                      struct qlcnic_vf_info *vf,
 890                                      struct qlcnic_cmd_args *cmd)
 891 {
 892         if (cmd->req.arg[1] != vf->rx_ctx_id)
 893                 return -EINVAL;
 894
 895         if (cmd->req.arg[2] > adapter->ahw->max_mtu)
 896                 return -EINVAL;
 897
 898         return 0;
 899 }
 900
 901 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
 902                                        struct qlcnic_cmd_args *cmd)
 903 {
 904         struct qlcnic_vf_info *vf = trans->vf;
 905         struct qlcnic_adapter *adapter = vf->adapter;
 906         int err;
 907
 908         err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
 909         if (err)
 910                 cmd->rsp.arg[0] |= (0x6 << 25);
 911         else
 912                 err = qlcnic_issue_cmd(adapter, cmd);
 913
 914         return err;
 915 }
 916
 917 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
 918                                               struct qlcnic_cmd_args *cmd)
 919 {
 920         if (cmd->req.arg[1] & BIT_31) {
 921                 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
 922                         return -EINVAL;
 923         } else {
 924                 cmd->req.arg[1] |= vf->vp->handle << 16;
 925         }
 926
 927         return 0;
 928 }
 929
 930 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
 931                                             struct qlcnic_cmd_args *cmd)
 932 {
 933         struct qlcnic_vf_info *vf = trans->vf;
 934         struct qlcnic_adapter *adapter = vf->adapter;
 935         int err;
 936
 937         err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
 938         if (err) {
 939                 cmd->rsp.arg[0] |= (0x6 << 25);
 940                 return err;
 941         }
 942
 943         err = qlcnic_issue_cmd(adapter, cmd);
 944         return err;
 945 }
 946
 947 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
 948                                          struct qlcnic_cmd_args *cmd)
 949 {
 950         if (cmd->req.arg[1] != vf->rx_ctx_id)
 951                 return -EINVAL;
 952
 953         return 0;
 954 }
 955
 956 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
 957                                        struct qlcnic_cmd_args *cmd)
 958 {
 959         struct qlcnic_vf_info *vf = trans->vf;
 960         struct qlcnic_adapter *adapter = vf->adapter;
 961         int err;
 962
 963         err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
 964         if (err)
 965                 cmd->rsp.arg[0] |= (0x6 << 25);
 966         else
 967                 err = qlcnic_issue_cmd(adapter, cmd);
 968
 969         return err;
 970 }
 971
 972 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
 973                                               struct qlcnic_vf_info *vf,
 974                                               struct qlcnic_cmd_args *cmd)
 975 {
 976         struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
 977         u16 ctx_id, pkts, time;
 978
 979         ctx_id = cmd->req.arg[1] >> 16;
 980         pkts = cmd->req.arg[2] & 0xffff;
 981         time = cmd->req.arg[2] >> 16;
 982
 983         if (ctx_id != vf->rx_ctx_id)
 984                 return -EINVAL;
 985         if (pkts > coal->rx_packets)
 986                 return -EINVAL;
 987         if (time < coal->rx_time_us)
 988                 return -EINVAL;
 989
 990         return 0;
 991 }
 992
 993 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
 994                                             struct qlcnic_cmd_args *cmd)
 995 {
 996         struct qlcnic_vf_info *vf = tran->vf;
 997         struct qlcnic_adapter *adapter = vf->adapter;
 998         int err;
 999
1000         err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
1001         if (err) {
1002                 cmd->rsp.arg[0] |= (0x6 << 25);
1003                 return err;
1004         }
1005
1006         err = qlcnic_issue_cmd(adapter, cmd);
1007         return err;
1008 }
1009
1010 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
1011                                              struct qlcnic_vf_info *vf,
1012                                              struct qlcnic_cmd_args *cmd)
1013 {
1014         struct qlcnic_macvlan_mbx *macvlan;
1015
1016         if (!(cmd->req.arg[1] & BIT_8))
1017                 return -EINVAL;
1018
1019         cmd->req.arg[1] |= (vf->vp->handle << 16);
1020         cmd->req.arg[1] |= BIT_31;
1021
1022         macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2];
1023         if (!(macvlan->mac_addr0 & BIT_0)) {
1024                 dev_err(&adapter->pdev->dev,
1025                         "MAC address change is not allowed from VF %d",
1026                         vf->pci_func);
1027                 return -EINVAL;
1028         }
1029
1030         return 0;
1031 }
1032
1033 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
1034                                            struct qlcnic_cmd_args *cmd)
1035 {
1036         struct qlcnic_vf_info *vf = trans->vf;
1037         struct qlcnic_adapter *adapter = vf->adapter;
1038         int err;
1039
1040         err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
1041         if (err) {
1042                 cmd->rsp.arg[0] |= (0x6 << 25);
1043                 return err;
1044         }
1045
1046         err = qlcnic_issue_cmd(adapter, cmd);
1047         return err;
1048 }
1049
1050 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
1051                                            struct qlcnic_cmd_args *cmd)
1052 {
1053         if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1054                 return -EINVAL;
1055
1056         if (!(cmd->req.arg[1] & BIT_8))
1057                 return -EINVAL;
1058
1059         return 0;
1060 }
1061
1062 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
1063                                          struct qlcnic_cmd_args *cmd)
1064 {
1065         struct qlcnic_vf_info *vf = trans->vf;
1066         struct qlcnic_adapter *adapter = vf->adapter;
1067         int err;
1068
1069         err = qlcnic_sriov_validate_linkevent(vf, cmd);
1070         if (err) {
1071                 cmd->rsp.arg[0] |= (0x6 << 25);
1072                 return err;
1073         }
1074
1075         err = qlcnic_issue_cmd(adapter, cmd);
1076         return err;
1077 }
1078
1079 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans,
1080                                            struct qlcnic_cmd_args *cmd)
1081 {
1082         struct qlcnic_vf_info *vf = trans->vf;
1083         struct qlcnic_adapter *adapter = vf->adapter;
1084         int err;
1085
1086         cmd->req.arg[1] |= vf->vp->handle << 16;
1087         cmd->req.arg[1] |= BIT_31;
1088         err = qlcnic_issue_cmd(adapter, cmd);
1089         return err;
1090 }
1091
1092 static const int qlcnic_pf_passthru_supp_cmds[] = {
1093         QLCNIC_CMD_GET_STATISTICS,
1094         QLCNIC_CMD_GET_PORT_CONFIG,
1095         QLCNIC_CMD_GET_LINK_STATUS,
1096 };
1097
1098 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
1099         [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1100         [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1101 };
1102
1103 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
1104         {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
1105         {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
1106         {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
1107         {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
1108         {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
1109         {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
1110         {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
1111         {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
1112         {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
1113         {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
1114         {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
1115         {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
1116         {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
1117         {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
1118         {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
1119 };
1120
1121 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
1122                                     struct qlcnic_bc_trans *trans,
1123                                     struct qlcnic_cmd_args *cmd)
1124 {
1125         u8 size, cmd_op;
1126
1127         cmd_op = trans->req_hdr->cmd_op;
1128
1129         if (trans->req_hdr->op_type == QLC_BC_CMD) {
1130                 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
1131                 if (cmd_op < size) {
1132                         qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
1133                         return;
1134                 }
1135         } else {
1136                 int i;
1137                 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
1138                 for (i = 0; i < size; i++) {
1139                         if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
1140                                 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
1141                                 return;
1142                         }
1143                 }
1144
1145                 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
1146                 for (i = 0; i < size; i++) {
1147                         if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
1148                                 qlcnic_issue_cmd(adapter, cmd);
1149                                 return;
1150                         }
1151                 }
1152         }
1153
1154         cmd->rsp.arg[0] |= (0x9 << 25);
1155 }
1156
1157 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
1158                                              u32 *int_id)
1159 {
1160         u16 vpid;
1161
1162         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1163                                                 adapter->ahw->pci_func);
1164         *int_id |= vpid;
1165 }
1166
1167 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter,
1168                                            u32 *int_id)
1169 {
1170         u16 vpid;
1171
1172         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1173                                                 adapter->ahw->pci_func);
1174         *int_id |= vpid << 16;
1175 }
1176
1177 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
1178                                               u32 *int_id)
1179 {
1180         int vpid;
1181
1182         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1183                                                 adapter->ahw->pci_func);
1184         *int_id |= vpid << 16;
1185 }
1186
1187 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter,
1188                                            u32 *int_id)
1189 {
1190         u16 vpid;
1191
1192         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1193                                                 adapter->ahw->pci_func);
1194         *int_id |= vpid << 16;
1195 }
1196
1197 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter,
1198                                         u32 *int_id)
1199 {
1200         u16 vpid;
1201
1202         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1203                                                 adapter->ahw->pci_func);
1204         *int_id |= (vpid << 16) | BIT_31;
1205 }
1206
1207 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter,
1208                                        u32 *int_id)
1209 {
1210         u16 vpid;
1211
1212         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1213                                                 adapter->ahw->pci_func);
1214         *int_id |= (vpid << 16) | BIT_31;
1215 }
1216
1217 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter,
1218                                         u32 *int_id)
1219 {
1220         u16 vpid;
1221
1222         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1223                                                 adapter->ahw->pci_func);
1224         *int_id |= (vpid << 16) | BIT_31;
1225 }
1226
1227 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter,
1228                                     struct qlcnic_vf_info *vf)
1229 {
1230         struct qlcnic_cmd_args cmd;
1231         int vpid;
1232
1233         if (!vf->rx_ctx_id)
1234                 return;
1235
1236         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX))
1237                 return;
1238
1239         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1240         if (vpid >= 0) {
1241                 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16;
1242                 if (qlcnic_issue_cmd(adapter, &cmd))
1243                         dev_err(&adapter->pdev->dev,
1244                                 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1245                                 vf->pci_func);
1246                 else
1247                         vf->rx_ctx_id = 0;
1248         }
1249
1250         qlcnic_free_mbx_args(&cmd);
1251 }
1252
1253 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter,
1254                                     struct qlcnic_vf_info *vf)
1255 {
1256         struct qlcnic_cmd_args cmd;
1257         int vpid;
1258
1259         if (!vf->tx_ctx_id)
1260                 return;
1261
1262         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX))
1263                 return;
1264
1265         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1266         if (vpid >= 0) {
1267                 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16;
1268                 if (qlcnic_issue_cmd(adapter, &cmd))
1269                         dev_err(&adapter->pdev->dev,
1270                                 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1271                                 vf->pci_func);
1272                 else
1273                         vf->tx_ctx_id = 0;
1274         }
1275
1276         qlcnic_free_mbx_args(&cmd);
1277 }
1278
1279 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov,
1280                                              struct qlcnic_vf_info *vf,
1281                                              struct qlcnic_bc_trans *trans)
1282 {
1283         struct qlcnic_trans_list *t_list = &vf->rcv_act;
1284         unsigned long flag;
1285
1286         spin_lock_irqsave(&t_list->lock, flag);
1287
1288         __qlcnic_sriov_add_act_list(sriov, vf, trans);
1289
1290         spin_unlock_irqrestore(&t_list->lock, flag);
1291         return 0;
1292 }
1293
1294 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf)
1295 {
1296         struct qlcnic_adapter *adapter = vf->adapter;
1297
1298         qlcnic_sriov_cleanup_list(&vf->rcv_pend);
1299         cancel_work_sync(&vf->trans_work);
1300         qlcnic_sriov_cleanup_list(&vf->rcv_act);
1301
1302         if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1303                 qlcnic_sriov_del_tx_ctx(adapter, vf);
1304                 qlcnic_sriov_del_rx_ctx(adapter, vf);
1305         }
1306
1307         qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func);
1308
1309         clear_bit(QLC_BC_VF_FLR, &vf->state);
1310         if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1311                 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf,
1312                                                   vf->flr_trans);
1313                 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1314                 vf->flr_trans = NULL;
1315         }
1316 }
1317
1318 static void qlcnic_sriov_pf_process_flr(struct work_struct *work)
1319 {
1320         struct qlcnic_vf_info *vf;
1321
1322         vf = container_of(work, struct qlcnic_vf_info, flr_work);
1323         __qlcnic_sriov_process_flr(vf);
1324         return;
1325 }
1326
1327 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov,
1328                                       struct qlcnic_vf_info *vf,
1329                                       work_func_t func)
1330 {
1331         if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state))
1332                 return;
1333
1334         INIT_WORK(&vf->flr_work, func);
1335         queue_work(sriov->bc.bc_flr_wq, &vf->flr_work);
1336 }
1337
1338 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter,
1339                                          struct qlcnic_bc_trans *trans,
1340                                          struct qlcnic_vf_info *vf)
1341 {
1342         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1343
1344         set_bit(QLC_BC_VF_FLR, &vf->state);
1345         clear_bit(QLC_BC_VF_STATE, &vf->state);
1346         set_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1347         vf->flr_trans = trans;
1348         qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1349         netdev_info(adapter->netdev, "Software FLR for PCI func %d\n",
1350                     vf->pci_func);
1351 }
1352
1353 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter,
1354                                  struct qlcnic_bc_trans *trans,
1355                                  struct qlcnic_vf_info *vf)
1356 {
1357         struct qlcnic_bc_hdr *hdr = trans->req_hdr;
1358
1359         if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) &&
1360             (hdr->op_type == QLC_BC_CMD) &&
1361              test_bit(QLC_BC_VF_STATE, &vf->state)) {
1362                 qlcnic_sriov_handle_soft_flr(adapter, trans, vf);
1363                 return true;
1364         }
1365
1366         return false;
1367 }
1368
1369 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov,
1370                                 struct qlcnic_vf_info *vf)
1371 {
1372         struct net_device *dev = vf->adapter->netdev;
1373
1374         if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) {
1375                 clear_bit(QLC_BC_VF_FLR, &vf->state);
1376                 return;
1377         }
1378
1379         if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) {
1380                 netdev_info(dev, "FLR for PCI func %d in progress\n",
1381                             vf->pci_func);
1382                 return;
1383         }
1384
1385         qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1386         netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func);
1387 }
1388
1389 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter)
1390 {
1391         struct qlcnic_hardware_context *ahw = adapter->ahw;
1392         struct qlcnic_sriov *sriov = ahw->sriov;
1393         struct qlcnic_vf_info *vf;
1394         u16 num_vfs = sriov->num_vfs;
1395         int i;
1396
1397         for (i = 0; i < num_vfs; i++) {
1398                 vf = &sriov->vf_info[i];
1399                 vf->rx_ctx_id = 0;
1400                 vf->tx_ctx_id = 0;
1401                 cancel_work_sync(&vf->flr_work);
1402                 __qlcnic_sriov_process_flr(vf);
1403                 clear_bit(QLC_BC_VF_STATE, &vf->state);
1404         }
1405
1406         qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func);
1407         QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8);
1408 }
1409
1410 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter)
1411 {
1412         struct qlcnic_hardware_context *ahw = adapter->ahw;
1413         int err;
1414
1415         if (!qlcnic_sriov_enable_check(adapter))
1416                 return 0;
1417
1418         ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
1419
1420         err = qlcnic_sriov_pf_init(adapter);
1421         if (err)
1422                 return err;
1423
1424         dev_info(&adapter->pdev->dev, "%s: op_mode %d\n",
1425                  __func__, ahw->op_mode);
1426         return err;
1427 }
1428
1429 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1430 {
1431         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1432         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1433         int i, num_vfs = sriov->num_vfs;
1434         struct qlcnic_vf_info *vf_info;
1435         u8 *curr_mac;
1436
1437         if (!qlcnic_sriov_pf_check(adapter))
1438                 return -EOPNOTSUPP;
1439
1440         if (!is_valid_ether_addr(mac) || vf >= num_vfs)
1441                 return -EINVAL;
1442
1443         if (!compare_ether_addr(adapter->mac_addr, mac)) {
1444                 netdev_err(netdev, "MAC address is already in use by the PF\n");
1445                 return -EINVAL;
1446         }
1447
1448         for (i = 0; i < num_vfs; i++) {
1449                 vf_info = &sriov->vf_info[i];
1450                 if (!compare_ether_addr(vf_info->vp->mac, mac)) {
1451                         netdev_err(netdev,
1452                                    "MAC address is already in use by VF %d\n",
1453                                    i);
1454                         return -EINVAL;
1455                 }
1456         }
1457
1458         vf_info = &sriov->vf_info[vf];
1459         curr_mac = vf_info->vp->mac;
1460
1461         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1462                 netdev_err(netdev,
1463                            "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1464                            vf);
1465                 return -EOPNOTSUPP;
1466         }
1467
1468         memcpy(curr_mac, mac, netdev->addr_len);
1469         netdev_info(netdev, "MAC Address %pM  is configured for VF %d\n",
1470                     mac, vf);
1471         return 0;
1472 }
1473
1474 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate)
1475 {
1476         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1477         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1478         struct qlcnic_vf_info *vf_info;
1479         struct qlcnic_info nic_info;
1480         struct qlcnic_vport *vp;
1481         u16 vpid;
1482
1483         if (!qlcnic_sriov_pf_check(adapter))
1484                 return -EOPNOTSUPP;
1485
1486         if (vf >= sriov->num_vfs)
1487                 return -EINVAL;
1488
1489         if (tx_rate >= 10000 || tx_rate < 100) {
1490                 netdev_err(netdev,
1491                            "Invalid Tx rate, allowed range is [%d - %d]",
1492                            QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE);
1493                 return -EINVAL;
1494         }
1495
1496         if (tx_rate == 0)
1497                 tx_rate = 10000;
1498
1499         vf_info = &sriov->vf_info[vf];
1500         vp = vf_info->vp;
1501         vpid = vp->handle;
1502
1503         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1504                 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid))
1505                         return -EIO;
1506
1507                 nic_info.max_tx_bw = tx_rate / 100;
1508                 nic_info.bit_offsets = BIT_0;
1509
1510                 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid))
1511                         return -EIO;
1512         }
1513
1514         vp->max_tx_bw = tx_rate / 100;
1515         netdev_info(netdev,
1516                     "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1517                     tx_rate, vp->max_tx_bw, vf);
1518         return 0;
1519 }
1520
1521 int qlcnic_sriov_get_vf_config(struct net_device *netdev,
1522                                int vf, struct ifla_vf_info *ivi)
1523 {
1524         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1525         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1526         struct qlcnic_vport *vp;
1527
1528         if (!qlcnic_sriov_pf_check(adapter))
1529                 return -EOPNOTSUPP;
1530
1531         if (vf >= sriov->num_vfs)
1532                 return -EINVAL;
1533
1534         vp = sriov->vf_info[vf].vp;
1535         memcpy(&ivi->mac, vp->mac, ETH_ALEN);
1536         if (vp->max_tx_bw == MAX_BW)
1537                 ivi->tx_rate = 0;
1538         else
1539                 ivi->tx_rate = vp->max_tx_bw * 100;
1540
1541         ivi->vf = vf;
1542         return 0;
1543 }