Michael Chan | c0c050c | 2015-10-22 16:01:17 -0400 | [diff] [blame] | 1 | /* Broadcom NetXtreme-C/E network driver. |
| 2 | * |
| 3 | * Copyright (c) 2014-2015 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 (bp->state != BNXT_STATE_OPEN) { |
| 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.vf_id = 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.vf_id = 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 | rc = bnxt_vf_ndo_prep(bp, vf_id); |
| 147 | if (rc) |
| 148 | return rc; |
| 149 | |
| 150 | /* TODO: needed to implement proper handling of user priority, |
| 151 | * currently fail the command if there is valid priority |
| 152 | */ |
| 153 | if (vlan_id > 4095 || qos) |
| 154 | return -EINVAL; |
| 155 | |
| 156 | vf = &bp->pf.vf[vf_id]; |
| 157 | vlan_tag = vlan_id; |
| 158 | if (vlan_tag == vf->vlan) |
| 159 | return 0; |
| 160 | |
| 161 | bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1); |
| 162 | req.vf_id = cpu_to_le16(vf->fw_fid); |
| 163 | req.flags = cpu_to_le32(vf->func_flags); |
| 164 | req.dflt_vlan = cpu_to_le16(vlan_tag); |
| 165 | req.enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_DFLT_VLAN); |
| 166 | rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); |
| 167 | if (!rc) |
| 168 | vf->vlan = vlan_tag; |
| 169 | return rc; |
| 170 | } |
| 171 | |
| 172 | int bnxt_set_vf_bw(struct net_device *dev, int vf_id, int min_tx_rate, |
| 173 | int max_tx_rate) |
| 174 | { |
| 175 | struct hwrm_func_cfg_input req = {0}; |
| 176 | struct bnxt *bp = netdev_priv(dev); |
| 177 | struct bnxt_vf_info *vf; |
| 178 | u32 pf_link_speed; |
| 179 | int rc; |
| 180 | |
| 181 | rc = bnxt_vf_ndo_prep(bp, vf_id); |
| 182 | if (rc) |
| 183 | return rc; |
| 184 | |
| 185 | vf = &bp->pf.vf[vf_id]; |
| 186 | pf_link_speed = bnxt_fw_to_ethtool_speed(bp->link_info.link_speed); |
| 187 | if (max_tx_rate > pf_link_speed) { |
| 188 | netdev_info(bp->dev, "max tx rate %d exceed PF link speed for VF %d\n", |
| 189 | max_tx_rate, vf_id); |
| 190 | return -EINVAL; |
| 191 | } |
| 192 | |
| 193 | if (min_tx_rate > pf_link_speed || min_tx_rate > max_tx_rate) { |
| 194 | netdev_info(bp->dev, "min tx rate %d is invalid for VF %d\n", |
| 195 | min_tx_rate, vf_id); |
| 196 | return -EINVAL; |
| 197 | } |
| 198 | if (min_tx_rate == vf->min_tx_rate && max_tx_rate == vf->max_tx_rate) |
| 199 | return 0; |
| 200 | bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1); |
| 201 | req.vf_id = cpu_to_le16(vf->fw_fid); |
| 202 | req.flags = cpu_to_le32(vf->func_flags); |
| 203 | req.enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_MAX_BW); |
| 204 | req.max_bw = cpu_to_le32(max_tx_rate); |
| 205 | req.enables |= cpu_to_le32(FUNC_CFG_REQ_ENABLES_MIN_BW); |
| 206 | req.min_bw = cpu_to_le32(min_tx_rate); |
| 207 | rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); |
| 208 | if (!rc) { |
| 209 | vf->min_tx_rate = min_tx_rate; |
| 210 | vf->max_tx_rate = max_tx_rate; |
| 211 | } |
| 212 | return rc; |
| 213 | } |
| 214 | |
| 215 | int bnxt_set_vf_link_state(struct net_device *dev, int vf_id, int link) |
| 216 | { |
| 217 | struct bnxt *bp = netdev_priv(dev); |
| 218 | struct bnxt_vf_info *vf; |
| 219 | int rc; |
| 220 | |
| 221 | rc = bnxt_vf_ndo_prep(bp, vf_id); |
| 222 | if (rc) |
| 223 | return rc; |
| 224 | |
| 225 | vf = &bp->pf.vf[vf_id]; |
| 226 | |
| 227 | vf->flags &= ~(BNXT_VF_LINK_UP | BNXT_VF_LINK_FORCED); |
| 228 | switch (link) { |
| 229 | case IFLA_VF_LINK_STATE_AUTO: |
| 230 | vf->flags |= BNXT_VF_LINK_UP; |
| 231 | break; |
| 232 | case IFLA_VF_LINK_STATE_DISABLE: |
| 233 | vf->flags |= BNXT_VF_LINK_FORCED; |
| 234 | break; |
| 235 | case IFLA_VF_LINK_STATE_ENABLE: |
| 236 | vf->flags |= BNXT_VF_LINK_UP | BNXT_VF_LINK_FORCED; |
| 237 | break; |
| 238 | default: |
| 239 | netdev_err(bp->dev, "Invalid link option\n"); |
| 240 | rc = -EINVAL; |
| 241 | break; |
| 242 | } |
| 243 | /* CHIMP TODO: send msg to VF to update new link state */ |
| 244 | |
| 245 | return rc; |
| 246 | } |
| 247 | |
| 248 | static int bnxt_set_vf_attr(struct bnxt *bp, int num_vfs) |
| 249 | { |
| 250 | int i; |
| 251 | struct bnxt_vf_info *vf; |
| 252 | |
| 253 | for (i = 0; i < num_vfs; i++) { |
| 254 | vf = &bp->pf.vf[i]; |
| 255 | memset(vf, 0, sizeof(*vf)); |
| 256 | vf->flags = BNXT_VF_QOS | BNXT_VF_LINK_UP; |
| 257 | } |
| 258 | return 0; |
| 259 | } |
| 260 | |
Jeffrey Huang | 4bb6cdc | 2015-11-05 16:25:51 -0500 | [diff] [blame] | 261 | static int bnxt_hwrm_func_vf_resource_free(struct bnxt *bp, int num_vfs) |
Michael Chan | c0c050c | 2015-10-22 16:01:17 -0400 | [diff] [blame] | 262 | { |
| 263 | int i, rc = 0; |
| 264 | struct bnxt_pf_info *pf = &bp->pf; |
| 265 | struct hwrm_func_vf_resc_free_input req = {0}; |
| 266 | |
| 267 | bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_VF_RESC_FREE, -1, -1); |
| 268 | |
| 269 | mutex_lock(&bp->hwrm_cmd_lock); |
Jeffrey Huang | 4bb6cdc | 2015-11-05 16:25:51 -0500 | [diff] [blame] | 270 | for (i = pf->first_vf_id; i < pf->first_vf_id + num_vfs; i++) { |
Michael Chan | c0c050c | 2015-10-22 16:01:17 -0400 | [diff] [blame] | 271 | req.vf_id = cpu_to_le16(i); |
| 272 | rc = _hwrm_send_message(bp, &req, sizeof(req), |
| 273 | HWRM_CMD_TIMEOUT); |
| 274 | if (rc) |
| 275 | break; |
| 276 | } |
| 277 | mutex_unlock(&bp->hwrm_cmd_lock); |
| 278 | return rc; |
| 279 | } |
| 280 | |
| 281 | static void bnxt_free_vf_resources(struct bnxt *bp) |
| 282 | { |
| 283 | struct pci_dev *pdev = bp->pdev; |
| 284 | int i; |
| 285 | |
| 286 | kfree(bp->pf.vf_event_bmap); |
| 287 | bp->pf.vf_event_bmap = NULL; |
| 288 | |
| 289 | for (i = 0; i < 4; i++) { |
| 290 | if (bp->pf.hwrm_cmd_req_addr[i]) { |
| 291 | dma_free_coherent(&pdev->dev, BNXT_PAGE_SIZE, |
| 292 | bp->pf.hwrm_cmd_req_addr[i], |
| 293 | bp->pf.hwrm_cmd_req_dma_addr[i]); |
| 294 | bp->pf.hwrm_cmd_req_addr[i] = NULL; |
| 295 | } |
| 296 | } |
| 297 | |
| 298 | kfree(bp->pf.vf); |
| 299 | bp->pf.vf = NULL; |
| 300 | } |
| 301 | |
| 302 | static int bnxt_alloc_vf_resources(struct bnxt *bp, int num_vfs) |
| 303 | { |
| 304 | struct pci_dev *pdev = bp->pdev; |
| 305 | u32 nr_pages, size, i, j, k = 0; |
| 306 | |
| 307 | bp->pf.vf = kcalloc(num_vfs, sizeof(struct bnxt_vf_info), GFP_KERNEL); |
| 308 | if (!bp->pf.vf) |
| 309 | return -ENOMEM; |
| 310 | |
| 311 | bnxt_set_vf_attr(bp, num_vfs); |
| 312 | |
| 313 | size = num_vfs * BNXT_HWRM_REQ_MAX_SIZE; |
| 314 | nr_pages = size / BNXT_PAGE_SIZE; |
| 315 | if (size & (BNXT_PAGE_SIZE - 1)) |
| 316 | nr_pages++; |
| 317 | |
| 318 | for (i = 0; i < nr_pages; i++) { |
| 319 | bp->pf.hwrm_cmd_req_addr[i] = |
| 320 | dma_alloc_coherent(&pdev->dev, BNXT_PAGE_SIZE, |
| 321 | &bp->pf.hwrm_cmd_req_dma_addr[i], |
| 322 | GFP_KERNEL); |
| 323 | |
| 324 | if (!bp->pf.hwrm_cmd_req_addr[i]) |
| 325 | return -ENOMEM; |
| 326 | |
| 327 | for (j = 0; j < BNXT_HWRM_REQS_PER_PAGE && k < num_vfs; j++) { |
| 328 | struct bnxt_vf_info *vf = &bp->pf.vf[k]; |
| 329 | |
| 330 | vf->hwrm_cmd_req_addr = bp->pf.hwrm_cmd_req_addr[i] + |
| 331 | j * BNXT_HWRM_REQ_MAX_SIZE; |
| 332 | vf->hwrm_cmd_req_dma_addr = |
| 333 | bp->pf.hwrm_cmd_req_dma_addr[i] + j * |
| 334 | BNXT_HWRM_REQ_MAX_SIZE; |
| 335 | k++; |
| 336 | } |
| 337 | } |
| 338 | |
| 339 | /* Max 128 VF's */ |
| 340 | bp->pf.vf_event_bmap = kzalloc(16, GFP_KERNEL); |
| 341 | if (!bp->pf.vf_event_bmap) |
| 342 | return -ENOMEM; |
| 343 | |
| 344 | bp->pf.hwrm_cmd_req_pages = nr_pages; |
| 345 | return 0; |
| 346 | } |
| 347 | |
| 348 | static int bnxt_hwrm_func_buf_rgtr(struct bnxt *bp) |
| 349 | { |
| 350 | struct hwrm_func_buf_rgtr_input req = {0}; |
| 351 | |
| 352 | bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_BUF_RGTR, -1, -1); |
| 353 | |
| 354 | req.req_buf_num_pages = cpu_to_le16(bp->pf.hwrm_cmd_req_pages); |
| 355 | req.req_buf_page_size = cpu_to_le16(BNXT_PAGE_SHIFT); |
| 356 | req.req_buf_len = cpu_to_le16(BNXT_HWRM_REQ_MAX_SIZE); |
| 357 | req.req_buf_page_addr0 = cpu_to_le64(bp->pf.hwrm_cmd_req_dma_addr[0]); |
| 358 | req.req_buf_page_addr1 = cpu_to_le64(bp->pf.hwrm_cmd_req_dma_addr[1]); |
| 359 | req.req_buf_page_addr2 = cpu_to_le64(bp->pf.hwrm_cmd_req_dma_addr[2]); |
| 360 | req.req_buf_page_addr3 = cpu_to_le64(bp->pf.hwrm_cmd_req_dma_addr[3]); |
| 361 | |
| 362 | return hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); |
| 363 | } |
| 364 | |
| 365 | /* only call by PF to reserve resources for VF */ |
| 366 | static int bnxt_hwrm_func_cfg(struct bnxt *bp, int *num_vfs) |
| 367 | { |
| 368 | u32 rc = 0, mtu, i; |
| 369 | u16 vf_tx_rings, vf_rx_rings, vf_cp_rings, vf_stat_ctx, vf_vnics; |
| 370 | struct hwrm_func_cfg_input req = {0}; |
| 371 | struct bnxt_pf_info *pf = &bp->pf; |
| 372 | |
| 373 | bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1); |
| 374 | |
| 375 | /* Remaining rings are distributed equally amongs VF's for now */ |
| 376 | /* TODO: the following workaroud is needed to restrict total number |
| 377 | * of vf_cp_rings not exceed number of HW ring groups. This WA should |
| 378 | * be removed once new HWRM provides HW ring groups capability in |
| 379 | * hwrm_func_qcap. |
| 380 | */ |
| 381 | vf_cp_rings = min_t(u16, bp->pf.max_cp_rings, bp->pf.max_stat_ctxs); |
| 382 | vf_cp_rings = (vf_cp_rings - bp->cp_nr_rings) / *num_vfs; |
| 383 | /* TODO: restore this logic below once the WA above is removed */ |
| 384 | /* vf_cp_rings = (bp->pf.max_cp_rings - bp->cp_nr_rings) / *num_vfs; */ |
| 385 | vf_stat_ctx = (bp->pf.max_stat_ctxs - bp->num_stat_ctxs) / *num_vfs; |
| 386 | if (bp->flags & BNXT_FLAG_AGG_RINGS) |
| 387 | vf_rx_rings = (bp->pf.max_rx_rings - bp->rx_nr_rings * 2) / |
| 388 | *num_vfs; |
| 389 | else |
| 390 | vf_rx_rings = (bp->pf.max_rx_rings - bp->rx_nr_rings) / |
| 391 | *num_vfs; |
| 392 | vf_tx_rings = (bp->pf.max_tx_rings - bp->tx_nr_rings) / *num_vfs; |
| 393 | |
| 394 | req.enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_MTU | |
| 395 | FUNC_CFG_REQ_ENABLES_MRU | |
| 396 | FUNC_CFG_REQ_ENABLES_NUM_RSSCOS_CTXS | |
| 397 | FUNC_CFG_REQ_ENABLES_NUM_STAT_CTXS | |
| 398 | FUNC_CFG_REQ_ENABLES_NUM_CMPL_RINGS | |
| 399 | FUNC_CFG_REQ_ENABLES_NUM_TX_RINGS | |
| 400 | FUNC_CFG_REQ_ENABLES_NUM_RX_RINGS | |
| 401 | FUNC_CFG_REQ_ENABLES_NUM_L2_CTXS | |
| 402 | FUNC_CFG_REQ_ENABLES_NUM_VNICS); |
| 403 | |
| 404 | mtu = bp->dev->mtu + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN; |
| 405 | req.mru = cpu_to_le16(mtu); |
| 406 | req.mtu = cpu_to_le16(mtu); |
| 407 | |
| 408 | req.num_rsscos_ctxs = cpu_to_le16(1); |
| 409 | req.num_cmpl_rings = cpu_to_le16(vf_cp_rings); |
| 410 | req.num_tx_rings = cpu_to_le16(vf_tx_rings); |
| 411 | req.num_rx_rings = cpu_to_le16(vf_rx_rings); |
| 412 | req.num_l2_ctxs = cpu_to_le16(4); |
| 413 | vf_vnics = 1; |
| 414 | |
| 415 | req.num_vnics = cpu_to_le16(vf_vnics); |
| 416 | /* FIXME spec currently uses 1 bit for stats ctx */ |
| 417 | req.num_stat_ctxs = cpu_to_le16(vf_stat_ctx); |
| 418 | |
| 419 | mutex_lock(&bp->hwrm_cmd_lock); |
| 420 | for (i = 0; i < *num_vfs; i++) { |
| 421 | req.vf_id = cpu_to_le16(pf->first_vf_id + i); |
| 422 | rc = _hwrm_send_message(bp, &req, sizeof(req), |
| 423 | HWRM_CMD_TIMEOUT); |
| 424 | if (rc) |
| 425 | break; |
| 426 | bp->pf.active_vfs = i + 1; |
| 427 | bp->pf.vf[i].fw_fid = le16_to_cpu(req.vf_id); |
| 428 | } |
| 429 | mutex_unlock(&bp->hwrm_cmd_lock); |
| 430 | if (!rc) { |
| 431 | bp->pf.max_pf_tx_rings = bp->tx_nr_rings; |
| 432 | if (bp->flags & BNXT_FLAG_AGG_RINGS) |
| 433 | bp->pf.max_pf_rx_rings = bp->rx_nr_rings * 2; |
| 434 | else |
| 435 | bp->pf.max_pf_rx_rings = bp->rx_nr_rings; |
| 436 | } |
| 437 | return rc; |
| 438 | } |
| 439 | |
| 440 | static int bnxt_sriov_enable(struct bnxt *bp, int *num_vfs) |
| 441 | { |
| 442 | int rc = 0, vfs_supported; |
| 443 | int min_rx_rings, min_tx_rings, min_rss_ctxs; |
| 444 | int tx_ok = 0, rx_ok = 0, rss_ok = 0; |
| 445 | |
| 446 | /* Check if we can enable requested num of vf's. At a mininum |
| 447 | * we require 1 RX 1 TX rings for each VF. In this minimum conf |
| 448 | * features like TPA will not be available. |
| 449 | */ |
| 450 | vfs_supported = *num_vfs; |
| 451 | |
| 452 | while (vfs_supported) { |
| 453 | min_rx_rings = vfs_supported; |
| 454 | min_tx_rings = vfs_supported; |
| 455 | min_rss_ctxs = vfs_supported; |
| 456 | |
| 457 | if (bp->flags & BNXT_FLAG_AGG_RINGS) { |
| 458 | if (bp->pf.max_rx_rings - bp->rx_nr_rings * 2 >= |
| 459 | min_rx_rings) |
| 460 | rx_ok = 1; |
| 461 | } else { |
| 462 | if (bp->pf.max_rx_rings - bp->rx_nr_rings >= |
| 463 | min_rx_rings) |
| 464 | rx_ok = 1; |
| 465 | } |
| 466 | |
| 467 | if (bp->pf.max_tx_rings - bp->tx_nr_rings >= min_tx_rings) |
| 468 | tx_ok = 1; |
| 469 | |
| 470 | if (bp->pf.max_rsscos_ctxs - bp->rsscos_nr_ctxs >= min_rss_ctxs) |
| 471 | rss_ok = 1; |
| 472 | |
| 473 | if (tx_ok && rx_ok && rss_ok) |
| 474 | break; |
| 475 | |
| 476 | vfs_supported--; |
| 477 | } |
| 478 | |
| 479 | if (!vfs_supported) { |
| 480 | netdev_err(bp->dev, "Cannot enable VF's as all resources are used by PF\n"); |
| 481 | return -EINVAL; |
| 482 | } |
| 483 | |
| 484 | if (vfs_supported != *num_vfs) { |
| 485 | netdev_info(bp->dev, "Requested VFs %d, can enable %d\n", |
| 486 | *num_vfs, vfs_supported); |
| 487 | *num_vfs = vfs_supported; |
| 488 | } |
| 489 | |
| 490 | rc = bnxt_alloc_vf_resources(bp, *num_vfs); |
| 491 | if (rc) |
| 492 | goto err_out1; |
| 493 | |
| 494 | /* Reserve resources for VFs */ |
| 495 | rc = bnxt_hwrm_func_cfg(bp, num_vfs); |
| 496 | if (rc) |
| 497 | goto err_out2; |
| 498 | |
| 499 | /* Register buffers for VFs */ |
| 500 | rc = bnxt_hwrm_func_buf_rgtr(bp); |
| 501 | if (rc) |
| 502 | goto err_out2; |
| 503 | |
| 504 | rc = pci_enable_sriov(bp->pdev, *num_vfs); |
| 505 | if (rc) |
| 506 | goto err_out2; |
| 507 | |
| 508 | return 0; |
| 509 | |
| 510 | err_out2: |
| 511 | /* Free the resources reserved for various VF's */ |
Jeffrey Huang | 4bb6cdc | 2015-11-05 16:25:51 -0500 | [diff] [blame] | 512 | bnxt_hwrm_func_vf_resource_free(bp, *num_vfs); |
Michael Chan | c0c050c | 2015-10-22 16:01:17 -0400 | [diff] [blame] | 513 | |
| 514 | err_out1: |
| 515 | bnxt_free_vf_resources(bp); |
| 516 | |
| 517 | return rc; |
| 518 | } |
| 519 | |
| 520 | void bnxt_sriov_disable(struct bnxt *bp) |
| 521 | { |
Jeffrey Huang | 4bb6cdc | 2015-11-05 16:25:51 -0500 | [diff] [blame] | 522 | u16 num_vfs = pci_num_vf(bp->pdev); |
| 523 | |
| 524 | if (!num_vfs) |
Michael Chan | c0c050c | 2015-10-22 16:01:17 -0400 | [diff] [blame] | 525 | return; |
| 526 | |
Jeffrey Huang | 4bb6cdc | 2015-11-05 16:25:51 -0500 | [diff] [blame] | 527 | if (pci_vfs_assigned(bp->pdev)) { |
| 528 | netdev_warn(bp->dev, "Unable to free %d VFs because some are assigned to VMs.\n", |
| 529 | num_vfs); |
| 530 | } else { |
| 531 | pci_disable_sriov(bp->pdev); |
| 532 | /* Free the HW resources reserved for various VF's */ |
| 533 | bnxt_hwrm_func_vf_resource_free(bp, num_vfs); |
| 534 | } |
Michael Chan | c0c050c | 2015-10-22 16:01:17 -0400 | [diff] [blame] | 535 | |
| 536 | bnxt_free_vf_resources(bp); |
| 537 | |
| 538 | bp->pf.active_vfs = 0; |
| 539 | bp->pf.max_pf_rx_rings = bp->pf.max_rx_rings; |
| 540 | bp->pf.max_pf_tx_rings = bp->pf.max_tx_rings; |
| 541 | } |
| 542 | |
| 543 | int bnxt_sriov_configure(struct pci_dev *pdev, int num_vfs) |
| 544 | { |
| 545 | struct net_device *dev = pci_get_drvdata(pdev); |
| 546 | struct bnxt *bp = netdev_priv(dev); |
| 547 | |
| 548 | if (!(bp->flags & BNXT_FLAG_USING_MSIX)) { |
| 549 | netdev_warn(dev, "Not allow SRIOV if the irq mode is not MSIX\n"); |
| 550 | return 0; |
| 551 | } |
| 552 | |
| 553 | rtnl_lock(); |
| 554 | if (!netif_running(dev)) { |
| 555 | netdev_warn(dev, "Reject SRIOV config request since if is down!\n"); |
| 556 | rtnl_unlock(); |
| 557 | return 0; |
| 558 | } |
| 559 | bp->sriov_cfg = true; |
| 560 | rtnl_unlock(); |
Jeffrey Huang | 4bb6cdc | 2015-11-05 16:25:51 -0500 | [diff] [blame] | 561 | |
| 562 | if (pci_vfs_assigned(bp->pdev)) { |
| 563 | netdev_warn(dev, "Unable to configure SRIOV since some VFs are assigned to VMs.\n"); |
| 564 | num_vfs = 0; |
| 565 | goto sriov_cfg_exit; |
Michael Chan | c0c050c | 2015-10-22 16:01:17 -0400 | [diff] [blame] | 566 | } |
| 567 | |
| 568 | /* Check if enabled VFs is same as requested */ |
Jeffrey Huang | 4bb6cdc | 2015-11-05 16:25:51 -0500 | [diff] [blame] | 569 | if (num_vfs && num_vfs == bp->pf.active_vfs) |
| 570 | goto sriov_cfg_exit; |
| 571 | |
| 572 | /* if there are previous existing VFs, clean them up */ |
| 573 | bnxt_sriov_disable(bp); |
| 574 | if (!num_vfs) |
| 575 | goto sriov_cfg_exit; |
Michael Chan | c0c050c | 2015-10-22 16:01:17 -0400 | [diff] [blame] | 576 | |
| 577 | bnxt_sriov_enable(bp, &num_vfs); |
| 578 | |
Jeffrey Huang | 4bb6cdc | 2015-11-05 16:25:51 -0500 | [diff] [blame] | 579 | sriov_cfg_exit: |
Michael Chan | c0c050c | 2015-10-22 16:01:17 -0400 | [diff] [blame] | 580 | bp->sriov_cfg = false; |
| 581 | wake_up(&bp->sriov_cfg_wait); |
| 582 | |
| 583 | return num_vfs; |
| 584 | } |
| 585 | |
| 586 | static int bnxt_hwrm_fwd_resp(struct bnxt *bp, struct bnxt_vf_info *vf, |
| 587 | void *encap_resp, __le64 encap_resp_addr, |
| 588 | __le16 encap_resp_cpr, u32 msg_size) |
| 589 | { |
| 590 | int rc = 0; |
| 591 | struct hwrm_fwd_resp_input req = {0}; |
| 592 | struct hwrm_fwd_resp_output *resp = bp->hwrm_cmd_resp_addr; |
| 593 | |
| 594 | bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FWD_RESP, -1, -1); |
| 595 | |
| 596 | /* Set the new target id */ |
| 597 | req.target_id = cpu_to_le16(vf->fw_fid); |
| 598 | req.encap_resp_len = cpu_to_le16(msg_size); |
| 599 | req.encap_resp_addr = encap_resp_addr; |
| 600 | req.encap_resp_cmpl_ring = encap_resp_cpr; |
| 601 | memcpy(req.encap_resp, encap_resp, msg_size); |
| 602 | |
| 603 | mutex_lock(&bp->hwrm_cmd_lock); |
| 604 | rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); |
| 605 | |
| 606 | if (rc) { |
| 607 | netdev_err(bp->dev, "hwrm_fwd_resp failed. rc:%d\n", rc); |
| 608 | goto fwd_resp_exit; |
| 609 | } |
| 610 | |
| 611 | if (resp->error_code) { |
| 612 | netdev_err(bp->dev, "hwrm_fwd_resp error %d\n", |
| 613 | resp->error_code); |
| 614 | rc = -1; |
| 615 | } |
| 616 | |
| 617 | fwd_resp_exit: |
| 618 | mutex_unlock(&bp->hwrm_cmd_lock); |
| 619 | return rc; |
| 620 | } |
| 621 | |
| 622 | static int bnxt_hwrm_fwd_err_resp(struct bnxt *bp, struct bnxt_vf_info *vf, |
| 623 | u32 msg_size) |
| 624 | { |
| 625 | int rc = 0; |
| 626 | struct hwrm_reject_fwd_resp_input req = {0}; |
| 627 | struct hwrm_reject_fwd_resp_output *resp = bp->hwrm_cmd_resp_addr; |
| 628 | |
| 629 | bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_REJECT_FWD_RESP, -1, -1); |
| 630 | /* Set the new target id */ |
| 631 | req.target_id = cpu_to_le16(vf->fw_fid); |
| 632 | memcpy(req.encap_request, vf->hwrm_cmd_req_addr, msg_size); |
| 633 | |
| 634 | mutex_lock(&bp->hwrm_cmd_lock); |
| 635 | rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); |
| 636 | |
| 637 | if (rc) { |
| 638 | netdev_err(bp->dev, "hwrm_fwd_err_resp failed. rc:%d\n", rc); |
| 639 | goto fwd_err_resp_exit; |
| 640 | } |
| 641 | |
| 642 | if (resp->error_code) { |
| 643 | netdev_err(bp->dev, "hwrm_fwd_err_resp error %d\n", |
| 644 | resp->error_code); |
| 645 | rc = -1; |
| 646 | } |
| 647 | |
| 648 | fwd_err_resp_exit: |
| 649 | mutex_unlock(&bp->hwrm_cmd_lock); |
| 650 | return rc; |
| 651 | } |
| 652 | |
| 653 | static int bnxt_hwrm_exec_fwd_resp(struct bnxt *bp, struct bnxt_vf_info *vf, |
| 654 | u32 msg_size) |
| 655 | { |
| 656 | int rc = 0; |
| 657 | struct hwrm_exec_fwd_resp_input req = {0}; |
| 658 | struct hwrm_exec_fwd_resp_output *resp = bp->hwrm_cmd_resp_addr; |
| 659 | |
| 660 | bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_EXEC_FWD_RESP, -1, -1); |
| 661 | /* Set the new target id */ |
| 662 | req.target_id = cpu_to_le16(vf->fw_fid); |
| 663 | memcpy(req.encap_request, vf->hwrm_cmd_req_addr, msg_size); |
| 664 | |
| 665 | mutex_lock(&bp->hwrm_cmd_lock); |
| 666 | rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT); |
| 667 | |
| 668 | if (rc) { |
| 669 | netdev_err(bp->dev, "hwrm_exec_fw_resp failed. rc:%d\n", rc); |
| 670 | goto exec_fwd_resp_exit; |
| 671 | } |
| 672 | |
| 673 | if (resp->error_code) { |
| 674 | netdev_err(bp->dev, "hwrm_exec_fw_resp error %d\n", |
| 675 | resp->error_code); |
| 676 | rc = -1; |
| 677 | } |
| 678 | |
| 679 | exec_fwd_resp_exit: |
| 680 | mutex_unlock(&bp->hwrm_cmd_lock); |
| 681 | return rc; |
| 682 | } |
| 683 | |
| 684 | static int bnxt_vf_validate_set_mac(struct bnxt *bp, struct bnxt_vf_info *vf) |
| 685 | { |
| 686 | u32 msg_size = sizeof(struct hwrm_cfa_l2_filter_alloc_input); |
| 687 | struct hwrm_cfa_l2_filter_alloc_input *req = |
| 688 | (struct hwrm_cfa_l2_filter_alloc_input *)vf->hwrm_cmd_req_addr; |
| 689 | |
| 690 | if (!is_valid_ether_addr(vf->mac_addr) || |
| 691 | ether_addr_equal((const u8 *)req->l2_addr, vf->mac_addr)) |
| 692 | return bnxt_hwrm_exec_fwd_resp(bp, vf, msg_size); |
| 693 | else |
| 694 | return bnxt_hwrm_fwd_err_resp(bp, vf, msg_size); |
| 695 | } |
| 696 | |
| 697 | static int bnxt_vf_set_link(struct bnxt *bp, struct bnxt_vf_info *vf) |
| 698 | { |
| 699 | int rc = 0; |
| 700 | |
| 701 | if (!(vf->flags & BNXT_VF_LINK_FORCED)) { |
| 702 | /* real link */ |
| 703 | rc = bnxt_hwrm_exec_fwd_resp( |
| 704 | bp, vf, sizeof(struct hwrm_port_phy_qcfg_input)); |
| 705 | } else { |
| 706 | struct hwrm_port_phy_qcfg_output phy_qcfg_resp; |
| 707 | struct hwrm_port_phy_qcfg_input *phy_qcfg_req; |
| 708 | |
| 709 | phy_qcfg_req = |
| 710 | (struct hwrm_port_phy_qcfg_input *)vf->hwrm_cmd_req_addr; |
| 711 | mutex_lock(&bp->hwrm_cmd_lock); |
| 712 | memcpy(&phy_qcfg_resp, &bp->link_info.phy_qcfg_resp, |
| 713 | sizeof(phy_qcfg_resp)); |
| 714 | mutex_unlock(&bp->hwrm_cmd_lock); |
| 715 | phy_qcfg_resp.seq_id = phy_qcfg_req->seq_id; |
| 716 | |
| 717 | if (vf->flags & BNXT_VF_LINK_UP) { |
| 718 | /* if physical link is down, force link up on VF */ |
| 719 | if (phy_qcfg_resp.link == |
| 720 | PORT_PHY_QCFG_RESP_LINK_NO_LINK) { |
| 721 | phy_qcfg_resp.link = |
| 722 | PORT_PHY_QCFG_RESP_LINK_LINK; |
| 723 | if (phy_qcfg_resp.auto_link_speed) |
| 724 | phy_qcfg_resp.link_speed = |
| 725 | phy_qcfg_resp.auto_link_speed; |
| 726 | else |
| 727 | phy_qcfg_resp.link_speed = |
| 728 | phy_qcfg_resp.force_link_speed; |
| 729 | phy_qcfg_resp.duplex = |
| 730 | PORT_PHY_QCFG_RESP_DUPLEX_FULL; |
| 731 | phy_qcfg_resp.pause = |
| 732 | (PORT_PHY_QCFG_RESP_PAUSE_TX | |
| 733 | PORT_PHY_QCFG_RESP_PAUSE_RX); |
| 734 | } |
| 735 | } else { |
| 736 | /* force link down */ |
| 737 | phy_qcfg_resp.link = PORT_PHY_QCFG_RESP_LINK_NO_LINK; |
| 738 | phy_qcfg_resp.link_speed = 0; |
| 739 | phy_qcfg_resp.duplex = PORT_PHY_QCFG_RESP_DUPLEX_HALF; |
| 740 | phy_qcfg_resp.pause = 0; |
| 741 | } |
| 742 | rc = bnxt_hwrm_fwd_resp(bp, vf, &phy_qcfg_resp, |
| 743 | phy_qcfg_req->resp_addr, |
| 744 | phy_qcfg_req->cmpl_ring, |
| 745 | sizeof(phy_qcfg_resp)); |
| 746 | } |
| 747 | return rc; |
| 748 | } |
| 749 | |
| 750 | static int bnxt_vf_req_validate_snd(struct bnxt *bp, struct bnxt_vf_info *vf) |
| 751 | { |
| 752 | int rc = 0; |
| 753 | struct hwrm_cmd_req_hdr *encap_req = vf->hwrm_cmd_req_addr; |
| 754 | u32 req_type = le32_to_cpu(encap_req->cmpl_ring_req_type) & 0xffff; |
| 755 | |
| 756 | switch (req_type) { |
| 757 | case HWRM_CFA_L2_FILTER_ALLOC: |
| 758 | rc = bnxt_vf_validate_set_mac(bp, vf); |
| 759 | break; |
| 760 | case HWRM_FUNC_CFG: |
| 761 | /* TODO Validate if VF is allowed to change mac address, |
| 762 | * mtu, num of rings etc |
| 763 | */ |
| 764 | rc = bnxt_hwrm_exec_fwd_resp( |
| 765 | bp, vf, sizeof(struct hwrm_func_cfg_input)); |
| 766 | break; |
| 767 | case HWRM_PORT_PHY_QCFG: |
| 768 | rc = bnxt_vf_set_link(bp, vf); |
| 769 | break; |
| 770 | default: |
| 771 | break; |
| 772 | } |
| 773 | return rc; |
| 774 | } |
| 775 | |
| 776 | void bnxt_hwrm_exec_fwd_req(struct bnxt *bp) |
| 777 | { |
| 778 | u32 i = 0, active_vfs = bp->pf.active_vfs, vf_id; |
| 779 | |
| 780 | /* Scan through VF's and process commands */ |
| 781 | while (1) { |
| 782 | vf_id = find_next_bit(bp->pf.vf_event_bmap, active_vfs, i); |
| 783 | if (vf_id >= active_vfs) |
| 784 | break; |
| 785 | |
| 786 | clear_bit(vf_id, bp->pf.vf_event_bmap); |
| 787 | bnxt_vf_req_validate_snd(bp, &bp->pf.vf[vf_id]); |
| 788 | i = vf_id + 1; |
| 789 | } |
| 790 | } |
Michael Chan | 379a80a | 2015-10-23 15:06:19 -0400 | [diff] [blame] | 791 | |
| 792 | void bnxt_update_vf_mac(struct bnxt *bp) |
| 793 | { |
| 794 | struct hwrm_func_qcaps_input req = {0}; |
| 795 | struct hwrm_func_qcaps_output *resp = bp->hwrm_cmd_resp_addr; |
| 796 | |
| 797 | bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_QCAPS, -1, -1); |
| 798 | req.fid = cpu_to_le16(0xffff); |
| 799 | |
| 800 | mutex_lock(&bp->hwrm_cmd_lock); |
| 801 | if (_hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT)) |
| 802 | goto update_vf_mac_exit; |
| 803 | |
| 804 | if (!is_valid_ether_addr(resp->perm_mac_address)) |
| 805 | goto update_vf_mac_exit; |
| 806 | |
Jeffrey Huang | bdd4347 | 2015-12-02 01:54:07 -0500 | [diff] [blame] | 807 | if (!ether_addr_equal(resp->perm_mac_address, bp->vf.mac_addr)) |
| 808 | memcpy(bp->vf.mac_addr, resp->perm_mac_address, ETH_ALEN); |
| 809 | /* overwrite netdev dev_adr with admin VF MAC */ |
Michael Chan | 379a80a | 2015-10-23 15:06:19 -0400 | [diff] [blame] | 810 | memcpy(bp->dev->dev_addr, bp->vf.mac_addr, ETH_ALEN); |
| 811 | update_vf_mac_exit: |
| 812 | mutex_unlock(&bp->hwrm_cmd_lock); |
| 813 | } |
| 814 | |
Michael Chan | c0c050c | 2015-10-22 16:01:17 -0400 | [diff] [blame] | 815 | #else |
| 816 | |
| 817 | void bnxt_sriov_disable(struct bnxt *bp) |
| 818 | { |
| 819 | } |
| 820 | |
| 821 | void bnxt_hwrm_exec_fwd_req(struct bnxt *bp) |
| 822 | { |
Michael Chan | 379a80a | 2015-10-23 15:06:19 -0400 | [diff] [blame] | 823 | netdev_err(bp->dev, "Invalid VF message received when SRIOV is not enable\n"); |
| 824 | } |
| 825 | |
| 826 | void bnxt_update_vf_mac(struct bnxt *bp) |
| 827 | { |
Michael Chan | c0c050c | 2015-10-22 16:01:17 -0400 | [diff] [blame] | 828 | } |
| 829 | #endif |