1 /* Broadcom NetXtreme-C/E network driver. 2 * 3 * Copyright (c) 2014-2016 Broadcom Corporation 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation. 8 */ 9 10 #include <linux/module.h> 11 #include <linux/pci.h> 12 #include <linux/netdevice.h> 13 #include <linux/if_vlan.h> 14 #include <linux/interrupt.h> 15 #include <linux/etherdevice.h> 16 #include "bnxt_hsi.h" 17 #include "bnxt.h" 18 #include "bnxt_sriov.h" 19 #include "bnxt_ethtool.h" 20 21 #ifdef CONFIG_BNXT_SRIOV 22 static int bnxt_vf_ndo_prep(struct bnxt *bp, int vf_id) 23 { 24 if (!test_bit(BNXT_STATE_OPEN, &bp->state)) { 25 netdev_err(bp->dev, "vf ndo called though PF is down\n"); 26 return -EINVAL; 27 } 28 if (!bp->pf.active_vfs) { 29 netdev_err(bp->dev, "vf ndo called though sriov is disabled\n"); 30 return -EINVAL; 31 } 32 if (vf_id >= bp->pf.max_vfs) { 33 netdev_err(bp->dev, "Invalid VF id %d\n", vf_id); 34 return -EINVAL; 35 } 36 return 0; 37 } 38 39 int bnxt_set_vf_spoofchk(struct net_device *dev, int vf_id, bool setting) 40 { 41 struct hwrm_func_cfg_input req = {0}; 42 struct bnxt *bp = netdev_priv(dev); 43 struct bnxt_vf_info *vf; 44 bool old_setting = false; 45 u32 func_flags; 46 int rc; 47 48 rc = bnxt_vf_ndo_prep(bp, vf_id); 49 if (rc) 50 return rc; 51 52 vf = &bp->pf.vf[vf_id]; 53 if (vf->flags & BNXT_VF_SPOOFCHK) 54 old_setting = true; 55 if (old_setting == setting) 56 return 0; 57 58 func_flags = vf->func_flags; 59 if (setting) 60 func_flags |= FUNC_CFG_REQ_FLAGS_SRC_MAC_ADDR_CHECK; 61 else 62 func_flags &= ~FUNC_CFG_REQ_FLAGS_SRC_MAC_ADDR_CHECK; 63 /*TODO: if the driver supports VLAN filter on guest VLAN, 64 * the spoof check should also include vlan anti-spoofing 65 */ 66 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1); 67 req.fid = cpu_to_le16(vf->fw_fid); 68 req.flags = cpu_to_le32(func_flags); 69 rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); 70 if (!rc) { 71 vf->func_flags = func_flags; 72 if (setting) 73 vf->flags |= BNXT_VF_SPOOFCHK; 74 else 75 vf->flags &= ~BNXT_VF_SPOOFCHK; 76 } 77 return rc; 78 } 79 80 int bnxt_get_vf_config(struct net_device *dev, int vf_id, 81 struct ifla_vf_info *ivi) 82 { 83 struct bnxt *bp = netdev_priv(dev); 84 struct bnxt_vf_info *vf; 85 int rc; 86 87 rc = bnxt_vf_ndo_prep(bp, vf_id); 88 if (rc) 89 return rc; 90 91 ivi->vf = vf_id; 92 vf = &bp->pf.vf[vf_id]; 93 94 memcpy(&ivi->mac, vf->mac_addr, ETH_ALEN); 95 ivi->max_tx_rate = vf->max_tx_rate; 96 ivi->min_tx_rate = vf->min_tx_rate; 97 ivi->vlan = vf->vlan; 98 ivi->qos = vf->flags & BNXT_VF_QOS; 99 ivi->spoofchk = vf->flags & BNXT_VF_SPOOFCHK; 100 if (!(vf->flags & BNXT_VF_LINK_FORCED)) 101 ivi->linkstate = IFLA_VF_LINK_STATE_AUTO; 102 else if (vf->flags & BNXT_VF_LINK_UP) 103 ivi->linkstate = IFLA_VF_LINK_STATE_ENABLE; 104 else 105 ivi->linkstate = IFLA_VF_LINK_STATE_DISABLE; 106 107 return 0; 108 } 109 110 int bnxt_set_vf_mac(struct net_device *dev, int vf_id, u8 *mac) 111 { 112 struct hwrm_func_cfg_input req = {0}; 113 struct bnxt *bp = netdev_priv(dev); 114 struct bnxt_vf_info *vf; 115 int rc; 116 117 rc = bnxt_vf_ndo_prep(bp, vf_id); 118 if (rc) 119 return rc; 120 /* reject bc or mc mac addr, zero mac addr means allow 121 * VF to use its own mac addr 122 */ 123 if (is_multicast_ether_addr(mac)) { 124 netdev_err(dev, "Invalid VF ethernet address\n"); 125 return -EINVAL; 126 } 127 vf = &bp->pf.vf[vf_id]; 128 129 memcpy(vf->mac_addr, mac, ETH_ALEN); 130 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1); 131 req.fid = cpu_to_le16(vf->fw_fid); 132 req.flags = cpu_to_le32(vf->func_flags); 133 req.enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_DFLT_MAC_ADDR); 134 memcpy(req.dflt_mac_addr, mac, ETH_ALEN); 135 return hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); 136 } 137 138 int bnxt_set_vf_vlan(struct net_device *dev, int vf_id, u16 vlan_id, u8 qos) 139 { 140 struct hwrm_func_cfg_input req = {0}; 141 struct bnxt *bp = netdev_priv(dev); 142 struct bnxt_vf_info *vf; 143 u16 vlan_tag; 144 int rc; 145 146 if (bp->hwrm_spec_code < 0x10201) 147 return -ENOTSUPP; 148 149 rc = bnxt_vf_ndo_prep(bp, vf_id); 150 if (rc) 151 return rc; 152 153 /* TODO: needed to implement proper handling of user priority, 154 * currently fail the command if there is valid priority 155 */ 156 if (vlan_id > 4095 || qos) 157 return -EINVAL; 158 159 vf = &bp->pf.vf[vf_id]; 160 vlan_tag = vlan_id; 161 if (vlan_tag == vf->vlan) 162 return 0; 163 164 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1); 165 req.fid = cpu_to_le16(vf->fw_fid); 166 req.flags = cpu_to_le32(vf->func_flags); 167 req.dflt_vlan = cpu_to_le16(vlan_tag); 168 req.enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_DFLT_VLAN); 169 rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); 170 if (!rc) 171 vf->vlan = vlan_tag; 172 return rc; 173 } 174 175 int bnxt_set_vf_bw(struct net_device *dev, int vf_id, int min_tx_rate, 176 int max_tx_rate) 177 { 178 struct hwrm_func_cfg_input req = {0}; 179 struct bnxt *bp = netdev_priv(dev); 180 struct bnxt_vf_info *vf; 181 u32 pf_link_speed; 182 int rc; 183 184 rc = bnxt_vf_ndo_prep(bp, vf_id); 185 if (rc) 186 return rc; 187 188 vf = &bp->pf.vf[vf_id]; 189 pf_link_speed = bnxt_fw_to_ethtool_speed(bp->link_info.link_speed); 190 if (max_tx_rate > pf_link_speed) { 191 netdev_info(bp->dev, "max tx rate %d exceed PF link speed for VF %d\n", 192 max_tx_rate, vf_id); 193 return -EINVAL; 194 } 195 196 if (min_tx_rate > pf_link_speed || min_tx_rate > max_tx_rate) { 197 netdev_info(bp->dev, "min tx rate %d is invalid for VF %d\n", 198 min_tx_rate, vf_id); 199 return -EINVAL; 200 } 201 if (min_tx_rate == vf->min_tx_rate && max_tx_rate == vf->max_tx_rate) 202 return 0; 203 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1); 204 req.fid = cpu_to_le16(vf->fw_fid); 205 req.flags = cpu_to_le32(vf->func_flags); 206 req.enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_MAX_BW); 207 req.max_bw = cpu_to_le32(max_tx_rate); 208 req.enables |= cpu_to_le32(FUNC_CFG_REQ_ENABLES_MIN_BW); 209 req.min_bw = cpu_to_le32(min_tx_rate); 210 rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); 211 if (!rc) { 212 vf->min_tx_rate = min_tx_rate; 213 vf->max_tx_rate = max_tx_rate; 214 } 215 return rc; 216 } 217 218 int bnxt_set_vf_link_state(struct net_device *dev, int vf_id, int link) 219 { 220 struct bnxt *bp = netdev_priv(dev); 221 struct bnxt_vf_info *vf; 222 int rc; 223 224 rc = bnxt_vf_ndo_prep(bp, vf_id); 225 if (rc) 226 return rc; 227 228 vf = &bp->pf.vf[vf_id]; 229 230 vf->flags &= ~(BNXT_VF_LINK_UP | BNXT_VF_LINK_FORCED); 231 switch (link) { 232 case IFLA_VF_LINK_STATE_AUTO: 233 vf->flags |= BNXT_VF_LINK_UP; 234 break; 235 case IFLA_VF_LINK_STATE_DISABLE: 236 vf->flags |= BNXT_VF_LINK_FORCED; 237 break; 238 case IFLA_VF_LINK_STATE_ENABLE: 239 vf->flags |= BNXT_VF_LINK_UP | BNXT_VF_LINK_FORCED; 240 break; 241 default: 242 netdev_err(bp->dev, "Invalid link option\n"); 243 rc = -EINVAL; 244 break; 245 } 246 /* CHIMP TODO: send msg to VF to update new link state */ 247 248 return rc; 249 } 250 251 static int bnxt_set_vf_attr(struct bnxt *bp, int num_vfs) 252 { 253 int i; 254 struct bnxt_vf_info *vf; 255 256 for (i = 0; i < num_vfs; i++) { 257 vf = &bp->pf.vf[i]; 258 memset(vf, 0, sizeof(*vf)); 259 vf->flags = BNXT_VF_QOS | BNXT_VF_LINK_UP; 260 } 261 return 0; 262 } 263 264 static int bnxt_hwrm_func_vf_resource_free(struct bnxt *bp, int num_vfs) 265 { 266 int i, rc = 0; 267 struct bnxt_pf_info *pf = &bp->pf; 268 struct hwrm_func_vf_resc_free_input req = {0}; 269 270 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_VF_RESC_FREE, -1, -1); 271 272 mutex_lock(&bp->hwrm_cmd_lock); 273 for (i = pf->first_vf_id; i < pf->first_vf_id + num_vfs; i++) { 274 req.vf_id = cpu_to_le16(i); 275 rc = _hwrm_send_message(bp, &req, sizeof(req), 276 HWRM_CMD_TIMEOUT); 277 if (rc) 278 break; 279 } 280 mutex_unlock(&bp->hwrm_cmd_lock); 281 return rc; 282 } 283 284 static void bnxt_free_vf_resources(struct bnxt *bp) 285 { 286 struct pci_dev *pdev = bp->pdev; 287 int i; 288 289 kfree(bp->pf.vf_event_bmap); 290 bp->pf.vf_event_bmap = NULL; 291 292 for (i = 0; i < 4; i++) { 293 if (bp->pf.hwrm_cmd_req_addr[i]) { 294 dma_free_coherent(&pdev->dev, BNXT_PAGE_SIZE, 295 bp->pf.hwrm_cmd_req_addr[i], 296 bp->pf.hwrm_cmd_req_dma_addr[i]); 297 bp->pf.hwrm_cmd_req_addr[i] = NULL; 298 } 299 } 300 301 kfree(bp->pf.vf); 302 bp->pf.vf = NULL; 303 } 304 305 static int bnxt_alloc_vf_resources(struct bnxt *bp, int num_vfs) 306 { 307 struct pci_dev *pdev = bp->pdev; 308 u32 nr_pages, size, i, j, k = 0; 309 310 bp->pf.vf = kcalloc(num_vfs, sizeof(struct bnxt_vf_info), GFP_KERNEL); 311 if (!bp->pf.vf) 312 return -ENOMEM; 313 314 bnxt_set_vf_attr(bp, num_vfs); 315 316 size = num_vfs * BNXT_HWRM_REQ_MAX_SIZE; 317 nr_pages = size / BNXT_PAGE_SIZE; 318 if (size & (BNXT_PAGE_SIZE - 1)) 319 nr_pages++; 320 321 for (i = 0; i < nr_pages; i++) { 322 bp->pf.hwrm_cmd_req_addr[i] = 323 dma_alloc_coherent(&pdev->dev, BNXT_PAGE_SIZE, 324 &bp->pf.hwrm_cmd_req_dma_addr[i], 325 GFP_KERNEL); 326 327 if (!bp->pf.hwrm_cmd_req_addr[i]) 328 return -ENOMEM; 329 330 for (j = 0; j < BNXT_HWRM_REQS_PER_PAGE && k < num_vfs; j++) { 331 struct bnxt_vf_info *vf = &bp->pf.vf[k]; 332 333 vf->hwrm_cmd_req_addr = bp->pf.hwrm_cmd_req_addr[i] + 334 j * BNXT_HWRM_REQ_MAX_SIZE; 335 vf->hwrm_cmd_req_dma_addr = 336 bp->pf.hwrm_cmd_req_dma_addr[i] + j * 337 BNXT_HWRM_REQ_MAX_SIZE; 338 k++; 339 } 340 } 341 342 /* Max 128 VF's */ 343 bp->pf.vf_event_bmap = kzalloc(16, GFP_KERNEL); 344 if (!bp->pf.vf_event_bmap) 345 return -ENOMEM; 346 347 bp->pf.hwrm_cmd_req_pages = nr_pages; 348 return 0; 349 } 350 351 static int bnxt_hwrm_func_buf_rgtr(struct bnxt *bp) 352 { 353 struct hwrm_func_buf_rgtr_input req = {0}; 354 355 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_BUF_RGTR, -1, -1); 356 357 req.req_buf_num_pages = cpu_to_le16(bp->pf.hwrm_cmd_req_pages); 358 req.req_buf_page_size = cpu_to_le16(BNXT_PAGE_SHIFT); 359 req.req_buf_len = cpu_to_le16(BNXT_HWRM_REQ_MAX_SIZE); 360 req.req_buf_page_addr0 = cpu_to_le64(bp->pf.hwrm_cmd_req_dma_addr[0]); 361 req.req_buf_page_addr1 = cpu_to_le64(bp->pf.hwrm_cmd_req_dma_addr[1]); 362 req.req_buf_page_addr2 = cpu_to_le64(bp->pf.hwrm_cmd_req_dma_addr[2]); 363 req.req_buf_page_addr3 = cpu_to_le64(bp->pf.hwrm_cmd_req_dma_addr[3]); 364 365 return hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); 366 } 367 368 /* only call by PF to reserve resources for VF */ 369 static int bnxt_hwrm_func_cfg(struct bnxt *bp, int num_vfs) 370 { 371 u32 rc = 0, mtu, i; 372 u16 vf_tx_rings, vf_rx_rings, vf_cp_rings, vf_stat_ctx, vf_vnics; 373 u16 vf_ring_grps; 374 struct hwrm_func_cfg_input req = {0}; 375 struct bnxt_pf_info *pf = &bp->pf; 376 377 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1); 378 379 /* Remaining rings are distributed equally amongs VF's for now */ 380 /* TODO: the following workaroud is needed to restrict total number 381 * of vf_cp_rings not exceed number of HW ring groups. This WA should 382 * be removed once new HWRM provides HW ring groups capability in 383 * hwrm_func_qcap. 384 */ 385 vf_cp_rings = min_t(u16, pf->max_cp_rings, pf->max_stat_ctxs); 386 vf_cp_rings = (vf_cp_rings - bp->cp_nr_rings) / num_vfs; 387 /* TODO: restore this logic below once the WA above is removed */ 388 /* vf_cp_rings = (pf->max_cp_rings - bp->cp_nr_rings) / num_vfs; */ 389 vf_stat_ctx = (pf->max_stat_ctxs - bp->num_stat_ctxs) / num_vfs; 390 if (bp->flags & BNXT_FLAG_AGG_RINGS) 391 vf_rx_rings = (pf->max_rx_rings - bp->rx_nr_rings * 2) / 392 num_vfs; 393 else 394 vf_rx_rings = (pf->max_rx_rings - bp->rx_nr_rings) / num_vfs; 395 vf_ring_grps = (bp->pf.max_hw_ring_grps - bp->rx_nr_rings) / num_vfs; 396 vf_tx_rings = (pf->max_tx_rings - bp->tx_nr_rings) / num_vfs; 397 398 req.enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_MTU | 399 FUNC_CFG_REQ_ENABLES_MRU | 400 FUNC_CFG_REQ_ENABLES_NUM_RSSCOS_CTXS | 401 FUNC_CFG_REQ_ENABLES_NUM_STAT_CTXS | 402 FUNC_CFG_REQ_ENABLES_NUM_CMPL_RINGS | 403 FUNC_CFG_REQ_ENABLES_NUM_TX_RINGS | 404 FUNC_CFG_REQ_ENABLES_NUM_RX_RINGS | 405 FUNC_CFG_REQ_ENABLES_NUM_L2_CTXS | 406 FUNC_CFG_REQ_ENABLES_NUM_VNICS | 407 FUNC_CFG_REQ_ENABLES_NUM_HW_RING_GRPS); 408 409 mtu = bp->dev->mtu + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN; 410 req.mru = cpu_to_le16(mtu); 411 req.mtu = cpu_to_le16(mtu); 412 413 req.num_rsscos_ctxs = cpu_to_le16(1); 414 req.num_cmpl_rings = cpu_to_le16(vf_cp_rings); 415 req.num_tx_rings = cpu_to_le16(vf_tx_rings); 416 req.num_rx_rings = cpu_to_le16(vf_rx_rings); 417 req.num_hw_ring_grps = cpu_to_le16(vf_ring_grps); 418 req.num_l2_ctxs = cpu_to_le16(4); 419 vf_vnics = 1; 420 421 req.num_vnics = cpu_to_le16(vf_vnics); 422 /* FIXME spec currently uses 1 bit for stats ctx */ 423 req.num_stat_ctxs = cpu_to_le16(vf_stat_ctx); 424 425 mutex_lock(&bp->hwrm_cmd_lock); 426 for (i = 0; i < num_vfs; i++) { 427 req.fid = cpu_to_le16(pf->first_vf_id + i); 428 rc = _hwrm_send_message(bp, &req, sizeof(req), 429 HWRM_CMD_TIMEOUT); 430 if (rc) 431 break; 432 pf->active_vfs = i + 1; 433 pf->vf[i].fw_fid = le16_to_cpu(req.fid); 434 } 435 mutex_unlock(&bp->hwrm_cmd_lock); 436 if (!rc) { 437 pf->max_tx_rings -= vf_tx_rings * num_vfs; 438 pf->max_rx_rings -= vf_rx_rings * num_vfs; 439 pf->max_hw_ring_grps -= vf_ring_grps * num_vfs; 440 pf->max_cp_rings -= vf_cp_rings * num_vfs; 441 pf->max_rsscos_ctxs -= num_vfs; 442 pf->max_stat_ctxs -= vf_stat_ctx * num_vfs; 443 pf->max_vnics -= vf_vnics * num_vfs; 444 } 445 return rc; 446 } 447 448 static int bnxt_sriov_enable(struct bnxt *bp, int *num_vfs) 449 { 450 int rc = 0, vfs_supported; 451 int min_rx_rings, min_tx_rings, min_rss_ctxs; 452 int tx_ok = 0, rx_ok = 0, rss_ok = 0; 453 454 /* Check if we can enable requested num of vf's. At a mininum 455 * we require 1 RX 1 TX rings for each VF. In this minimum conf 456 * features like TPA will not be available. 457 */ 458 vfs_supported = *num_vfs; 459 460 while (vfs_supported) { 461 min_rx_rings = vfs_supported; 462 min_tx_rings = vfs_supported; 463 min_rss_ctxs = vfs_supported; 464 465 if (bp->flags & BNXT_FLAG_AGG_RINGS) { 466 if (bp->pf.max_rx_rings - bp->rx_nr_rings * 2 >= 467 min_rx_rings) 468 rx_ok = 1; 469 } else { 470 if (bp->pf.max_rx_rings - bp->rx_nr_rings >= 471 min_rx_rings) 472 rx_ok = 1; 473 } 474 475 if (bp->pf.max_tx_rings - bp->tx_nr_rings >= min_tx_rings) 476 tx_ok = 1; 477 478 if (bp->pf.max_rsscos_ctxs - bp->rsscos_nr_ctxs >= min_rss_ctxs) 479 rss_ok = 1; 480 481 if (tx_ok && rx_ok && rss_ok) 482 break; 483 484 vfs_supported--; 485 } 486 487 if (!vfs_supported) { 488 netdev_err(bp->dev, "Cannot enable VF's as all resources are used by PF\n"); 489 return -EINVAL; 490 } 491 492 if (vfs_supported != *num_vfs) { 493 netdev_info(bp->dev, "Requested VFs %d, can enable %d\n", 494 *num_vfs, vfs_supported); 495 *num_vfs = vfs_supported; 496 } 497 498 rc = bnxt_alloc_vf_resources(bp, *num_vfs); 499 if (rc) 500 goto err_out1; 501 502 /* Reserve resources for VFs */ 503 rc = bnxt_hwrm_func_cfg(bp, *num_vfs); 504 if (rc) 505 goto err_out2; 506 507 /* Register buffers for VFs */ 508 rc = bnxt_hwrm_func_buf_rgtr(bp); 509 if (rc) 510 goto err_out2; 511 512 rc = pci_enable_sriov(bp->pdev, *num_vfs); 513 if (rc) 514 goto err_out2; 515 516 return 0; 517 518 err_out2: 519 /* Free the resources reserved for various VF's */ 520 bnxt_hwrm_func_vf_resource_free(bp, *num_vfs); 521 522 err_out1: 523 bnxt_free_vf_resources(bp); 524 525 return rc; 526 } 527 528 static int bnxt_hwrm_fwd_async_event_cmpl(struct bnxt *bp, 529 struct bnxt_vf_info *vf, 530 u16 event_id) 531 { 532 int rc = 0; 533 struct hwrm_fwd_async_event_cmpl_input req = {0}; 534 struct hwrm_fwd_async_event_cmpl_output *resp = bp->hwrm_cmd_resp_addr; 535 struct hwrm_async_event_cmpl *async_cmpl; 536 537 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FWD_ASYNC_EVENT_CMPL, -1, -1); 538 if (vf) 539 req.encap_async_event_target_id = cpu_to_le16(vf->fw_fid); 540 else 541 /* broadcast this async event to all VFs */ 542 req.encap_async_event_target_id = cpu_to_le16(0xffff); 543 async_cmpl = (struct hwrm_async_event_cmpl *)req.encap_async_event_cmpl; 544 async_cmpl->type = 545 cpu_to_le16(HWRM_ASYNC_EVENT_CMPL_TYPE_HWRM_ASYNC_EVENT); 546 async_cmpl->event_id = cpu_to_le16(event_id); 547 548 mutex_lock(&bp->hwrm_cmd_lock); 549 rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); 550 551 if (rc) { 552 netdev_err(bp->dev, "hwrm_fwd_async_event_cmpl failed. rc:%d\n", 553 rc); 554 goto fwd_async_event_cmpl_exit; 555 } 556 557 if (resp->error_code) { 558 netdev_err(bp->dev, "hwrm_fwd_async_event_cmpl error %d\n", 559 resp->error_code); 560 rc = -1; 561 } 562 563 fwd_async_event_cmpl_exit: 564 mutex_unlock(&bp->hwrm_cmd_lock); 565 return rc; 566 } 567 568 void bnxt_sriov_disable(struct bnxt *bp) 569 { 570 u16 num_vfs = pci_num_vf(bp->pdev); 571 572 if (!num_vfs) 573 return; 574 575 if (pci_vfs_assigned(bp->pdev)) { 576 bnxt_hwrm_fwd_async_event_cmpl( 577 bp, NULL, 578 HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PF_DRVR_UNLOAD); 579 netdev_warn(bp->dev, "Unable to free %d VFs because some are assigned to VMs.\n", 580 num_vfs); 581 } else { 582 pci_disable_sriov(bp->pdev); 583 /* Free the HW resources reserved for various VF's */ 584 bnxt_hwrm_func_vf_resource_free(bp, num_vfs); 585 } 586 587 bnxt_free_vf_resources(bp); 588 589 bp->pf.active_vfs = 0; 590 /* Reclaim all resources for the PF. */ 591 bnxt_hwrm_func_qcaps(bp); 592 } 593 594 int bnxt_sriov_configure(struct pci_dev *pdev, int num_vfs) 595 { 596 struct net_device *dev = pci_get_drvdata(pdev); 597 struct bnxt *bp = netdev_priv(dev); 598 599 if (!(bp->flags & BNXT_FLAG_USING_MSIX)) { 600 netdev_warn(dev, "Not allow SRIOV if the irq mode is not MSIX\n"); 601 return 0; 602 } 603 604 rtnl_lock(); 605 if (!netif_running(dev)) { 606 netdev_warn(dev, "Reject SRIOV config request since if is down!\n"); 607 rtnl_unlock(); 608 return 0; 609 } 610 bp->sriov_cfg = true; 611 rtnl_unlock(); 612 613 if (pci_vfs_assigned(bp->pdev)) { 614 netdev_warn(dev, "Unable to configure SRIOV since some VFs are assigned to VMs.\n"); 615 num_vfs = 0; 616 goto sriov_cfg_exit; 617 } 618 619 /* Check if enabled VFs is same as requested */ 620 if (num_vfs && num_vfs == bp->pf.active_vfs) 621 goto sriov_cfg_exit; 622 623 /* if there are previous existing VFs, clean them up */ 624 bnxt_sriov_disable(bp); 625 if (!num_vfs) 626 goto sriov_cfg_exit; 627 628 bnxt_sriov_enable(bp, &num_vfs); 629 630 sriov_cfg_exit: 631 bp->sriov_cfg = false; 632 wake_up(&bp->sriov_cfg_wait); 633 634 return num_vfs; 635 } 636 637 static int bnxt_hwrm_fwd_resp(struct bnxt *bp, struct bnxt_vf_info *vf, 638 void *encap_resp, __le64 encap_resp_addr, 639 __le16 encap_resp_cpr, u32 msg_size) 640 { 641 int rc = 0; 642 struct hwrm_fwd_resp_input req = {0}; 643 struct hwrm_fwd_resp_output *resp = bp->hwrm_cmd_resp_addr; 644 645 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FWD_RESP, -1, -1); 646 647 /* Set the new target id */ 648 req.target_id = cpu_to_le16(vf->fw_fid); 649 req.encap_resp_target_id = cpu_to_le16(vf->fw_fid); 650 req.encap_resp_len = cpu_to_le16(msg_size); 651 req.encap_resp_addr = encap_resp_addr; 652 req.encap_resp_cmpl_ring = encap_resp_cpr; 653 memcpy(req.encap_resp, encap_resp, msg_size); 654 655 mutex_lock(&bp->hwrm_cmd_lock); 656 rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); 657 658 if (rc) { 659 netdev_err(bp->dev, "hwrm_fwd_resp failed. rc:%d\n", rc); 660 goto fwd_resp_exit; 661 } 662 663 if (resp->error_code) { 664 netdev_err(bp->dev, "hwrm_fwd_resp error %d\n", 665 resp->error_code); 666 rc = -1; 667 } 668 669 fwd_resp_exit: 670 mutex_unlock(&bp->hwrm_cmd_lock); 671 return rc; 672 } 673 674 static int bnxt_hwrm_fwd_err_resp(struct bnxt *bp, struct bnxt_vf_info *vf, 675 u32 msg_size) 676 { 677 int rc = 0; 678 struct hwrm_reject_fwd_resp_input req = {0}; 679 struct hwrm_reject_fwd_resp_output *resp = bp->hwrm_cmd_resp_addr; 680 681 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_REJECT_FWD_RESP, -1, -1); 682 /* Set the new target id */ 683 req.target_id = cpu_to_le16(vf->fw_fid); 684 req.encap_resp_target_id = cpu_to_le16(vf->fw_fid); 685 memcpy(req.encap_request, vf->hwrm_cmd_req_addr, msg_size); 686 687 mutex_lock(&bp->hwrm_cmd_lock); 688 rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); 689 690 if (rc) { 691 netdev_err(bp->dev, "hwrm_fwd_err_resp failed. rc:%d\n", rc); 692 goto fwd_err_resp_exit; 693 } 694 695 if (resp->error_code) { 696 netdev_err(bp->dev, "hwrm_fwd_err_resp error %d\n", 697 resp->error_code); 698 rc = -1; 699 } 700 701 fwd_err_resp_exit: 702 mutex_unlock(&bp->hwrm_cmd_lock); 703 return rc; 704 } 705 706 static int bnxt_hwrm_exec_fwd_resp(struct bnxt *bp, struct bnxt_vf_info *vf, 707 u32 msg_size) 708 { 709 int rc = 0; 710 struct hwrm_exec_fwd_resp_input req = {0}; 711 struct hwrm_exec_fwd_resp_output *resp = bp->hwrm_cmd_resp_addr; 712 713 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_EXEC_FWD_RESP, -1, -1); 714 /* Set the new target id */ 715 req.target_id = cpu_to_le16(vf->fw_fid); 716 req.encap_resp_target_id = cpu_to_le16(vf->fw_fid); 717 memcpy(req.encap_request, vf->hwrm_cmd_req_addr, msg_size); 718 719 mutex_lock(&bp->hwrm_cmd_lock); 720 rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); 721 722 if (rc) { 723 netdev_err(bp->dev, "hwrm_exec_fw_resp failed. rc:%d\n", rc); 724 goto exec_fwd_resp_exit; 725 } 726 727 if (resp->error_code) { 728 netdev_err(bp->dev, "hwrm_exec_fw_resp error %d\n", 729 resp->error_code); 730 rc = -1; 731 } 732 733 exec_fwd_resp_exit: 734 mutex_unlock(&bp->hwrm_cmd_lock); 735 return rc; 736 } 737 738 static int bnxt_vf_validate_set_mac(struct bnxt *bp, struct bnxt_vf_info *vf) 739 { 740 u32 msg_size = sizeof(struct hwrm_cfa_l2_filter_alloc_input); 741 struct hwrm_cfa_l2_filter_alloc_input *req = 742 (struct hwrm_cfa_l2_filter_alloc_input *)vf->hwrm_cmd_req_addr; 743 744 if (!is_valid_ether_addr(vf->mac_addr) || 745 ether_addr_equal((const u8 *)req->l2_addr, vf->mac_addr)) 746 return bnxt_hwrm_exec_fwd_resp(bp, vf, msg_size); 747 else 748 return bnxt_hwrm_fwd_err_resp(bp, vf, msg_size); 749 } 750 751 static int bnxt_vf_set_link(struct bnxt *bp, struct bnxt_vf_info *vf) 752 { 753 int rc = 0; 754 755 if (!(vf->flags & BNXT_VF_LINK_FORCED)) { 756 /* real link */ 757 rc = bnxt_hwrm_exec_fwd_resp( 758 bp, vf, sizeof(struct hwrm_port_phy_qcfg_input)); 759 } else { 760 struct hwrm_port_phy_qcfg_output phy_qcfg_resp; 761 struct hwrm_port_phy_qcfg_input *phy_qcfg_req; 762 763 phy_qcfg_req = 764 (struct hwrm_port_phy_qcfg_input *)vf->hwrm_cmd_req_addr; 765 mutex_lock(&bp->hwrm_cmd_lock); 766 memcpy(&phy_qcfg_resp, &bp->link_info.phy_qcfg_resp, 767 sizeof(phy_qcfg_resp)); 768 mutex_unlock(&bp->hwrm_cmd_lock); 769 phy_qcfg_resp.seq_id = phy_qcfg_req->seq_id; 770 771 if (vf->flags & BNXT_VF_LINK_UP) { 772 /* if physical link is down, force link up on VF */ 773 if (phy_qcfg_resp.link == 774 PORT_PHY_QCFG_RESP_LINK_NO_LINK) { 775 phy_qcfg_resp.link = 776 PORT_PHY_QCFG_RESP_LINK_LINK; 777 phy_qcfg_resp.link_speed = cpu_to_le16( 778 PORT_PHY_QCFG_RESP_LINK_SPEED_10GB); 779 phy_qcfg_resp.duplex = 780 PORT_PHY_QCFG_RESP_DUPLEX_FULL; 781 phy_qcfg_resp.pause = 782 (PORT_PHY_QCFG_RESP_PAUSE_TX | 783 PORT_PHY_QCFG_RESP_PAUSE_RX); 784 } 785 } else { 786 /* force link down */ 787 phy_qcfg_resp.link = PORT_PHY_QCFG_RESP_LINK_NO_LINK; 788 phy_qcfg_resp.link_speed = 0; 789 phy_qcfg_resp.duplex = PORT_PHY_QCFG_RESP_DUPLEX_HALF; 790 phy_qcfg_resp.pause = 0; 791 } 792 rc = bnxt_hwrm_fwd_resp(bp, vf, &phy_qcfg_resp, 793 phy_qcfg_req->resp_addr, 794 phy_qcfg_req->cmpl_ring, 795 sizeof(phy_qcfg_resp)); 796 } 797 return rc; 798 } 799 800 static int bnxt_vf_req_validate_snd(struct bnxt *bp, struct bnxt_vf_info *vf) 801 { 802 int rc = 0; 803 struct input *encap_req = vf->hwrm_cmd_req_addr; 804 u32 req_type = le16_to_cpu(encap_req->req_type); 805 806 switch (req_type) { 807 case HWRM_CFA_L2_FILTER_ALLOC: 808 rc = bnxt_vf_validate_set_mac(bp, vf); 809 break; 810 case HWRM_FUNC_CFG: 811 /* TODO Validate if VF is allowed to change mac address, 812 * mtu, num of rings etc 813 */ 814 rc = bnxt_hwrm_exec_fwd_resp( 815 bp, vf, sizeof(struct hwrm_func_cfg_input)); 816 break; 817 case HWRM_PORT_PHY_QCFG: 818 rc = bnxt_vf_set_link(bp, vf); 819 break; 820 default: 821 break; 822 } 823 return rc; 824 } 825 826 void bnxt_hwrm_exec_fwd_req(struct bnxt *bp) 827 { 828 u32 i = 0, active_vfs = bp->pf.active_vfs, vf_id; 829 830 /* Scan through VF's and process commands */ 831 while (1) { 832 vf_id = find_next_bit(bp->pf.vf_event_bmap, active_vfs, i); 833 if (vf_id >= active_vfs) 834 break; 835 836 clear_bit(vf_id, bp->pf.vf_event_bmap); 837 bnxt_vf_req_validate_snd(bp, &bp->pf.vf[vf_id]); 838 i = vf_id + 1; 839 } 840 } 841 842 void bnxt_update_vf_mac(struct bnxt *bp) 843 { 844 struct hwrm_func_qcaps_input req = {0}; 845 struct hwrm_func_qcaps_output *resp = bp->hwrm_cmd_resp_addr; 846 847 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_QCAPS, -1, -1); 848 req.fid = cpu_to_le16(0xffff); 849 850 mutex_lock(&bp->hwrm_cmd_lock); 851 if (_hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT)) 852 goto update_vf_mac_exit; 853 854 /* Store MAC address from the firmware. There are 2 cases: 855 * 1. MAC address is valid. It is assigned from the PF and we 856 * need to override the current VF MAC address with it. 857 * 2. MAC address is zero. The VF will use a random MAC address by 858 * default but the stored zero MAC will allow the VF user to change 859 * the random MAC address using ndo_set_mac_address() if he wants. 860 */ 861 if (!ether_addr_equal(resp->mac_address, bp->vf.mac_addr)) 862 memcpy(bp->vf.mac_addr, resp->mac_address, ETH_ALEN); 863 864 /* overwrite netdev dev_addr with admin VF MAC */ 865 if (is_valid_ether_addr(bp->vf.mac_addr)) 866 memcpy(bp->dev->dev_addr, bp->vf.mac_addr, ETH_ALEN); 867 update_vf_mac_exit: 868 mutex_unlock(&bp->hwrm_cmd_lock); 869 } 870 871 int bnxt_approve_mac(struct bnxt *bp, u8 *mac) 872 { 873 struct hwrm_func_vf_cfg_input req = {0}; 874 int rc = 0; 875 876 if (!BNXT_VF(bp)) 877 return 0; 878 879 if (bp->hwrm_spec_code < 0x10202) { 880 if (is_valid_ether_addr(bp->vf.mac_addr)) 881 rc = -EADDRNOTAVAIL; 882 goto mac_done; 883 } 884 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_VF_CFG, -1, -1); 885 req.enables = cpu_to_le32(FUNC_VF_CFG_REQ_ENABLES_DFLT_MAC_ADDR); 886 memcpy(req.dflt_mac_addr, mac, ETH_ALEN); 887 rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); 888 mac_done: 889 if (rc) { 890 rc = -EADDRNOTAVAIL; 891 netdev_warn(bp->dev, "VF MAC address %pM not approved by the PF\n", 892 mac); 893 } 894 return rc; 895 } 896 #else 897 898 void bnxt_sriov_disable(struct bnxt *bp) 899 { 900 } 901 902 void bnxt_hwrm_exec_fwd_req(struct bnxt *bp) 903 { 904 netdev_err(bp->dev, "Invalid VF message received when SRIOV is not enable\n"); 905 } 906 907 void bnxt_update_vf_mac(struct bnxt *bp) 908 { 909 } 910 911 int bnxt_approve_mac(struct bnxt *bp, u8 *mac) 912 { 913 return 0; 914 } 915 #endif 916