Ariel Elior | be1f1ffa | 2013-01-01 05:22:24 +0000 | [diff] [blame] | 1 | /* bnx2x_vfpf.c: Broadcom Everest network driver. |
| 2 | * |
| 3 | * Copyright 2009-2012 Broadcom Corporation |
| 4 | * |
| 5 | * Unless you and Broadcom execute a separate written software license |
| 6 | * agreement governing use of this software, this software is licensed to you |
| 7 | * under the terms of the GNU General Public License version 2, available |
| 8 | * at http://www.gnu.org/licenses/old-licenses/gpl-2.0.html (the "GPL"). |
| 9 | * |
| 10 | * Notwithstanding the above, under no circumstances may you combine this |
| 11 | * software in any way with any other Broadcom software provided under a |
| 12 | * license other than the GPL, without Broadcom's express prior written |
| 13 | * consent. |
| 14 | * |
| 15 | * Maintained by: Eilon Greenstein <eilong@broadcom.com> |
| 16 | * Written by: Shmulik Ravid <shmulikr@broadcom.com> |
| 17 | * Ariel Elior <ariele@broadcom.com> |
| 18 | */ |
| 19 | |
| 20 | #include "bnx2x.h" |
| 21 | #include "bnx2x_sriov.h" |
Ariel Elior | b93288d | 2013-01-01 05:22:35 +0000 | [diff] [blame] | 22 | #include <linux/crc32.h> |
Ariel Elior | be1f1ffa | 2013-01-01 05:22:24 +0000 | [diff] [blame] | 23 | |
| 24 | /* place a given tlv on the tlv buffer at a given offset */ |
| 25 | void bnx2x_add_tlv(struct bnx2x *bp, void *tlvs_list, u16 offset, u16 type, |
| 26 | u16 length) |
| 27 | { |
| 28 | struct channel_tlv *tl = |
| 29 | (struct channel_tlv *)(tlvs_list + offset); |
| 30 | |
| 31 | tl->type = type; |
| 32 | tl->length = length; |
| 33 | } |
| 34 | |
| 35 | /* Clear the mailbox and init the header of the first tlv */ |
| 36 | void bnx2x_vfpf_prep(struct bnx2x *bp, struct vfpf_first_tlv *first_tlv, |
| 37 | u16 type, u16 length) |
| 38 | { |
| 39 | DP(BNX2X_MSG_IOV, "preparing to send %d tlv over vf pf channel\n", |
| 40 | type); |
| 41 | |
| 42 | /* Clear mailbox */ |
| 43 | memset(bp->vf2pf_mbox, 0, sizeof(struct bnx2x_vf_mbx_msg)); |
| 44 | |
| 45 | /* init type and length */ |
| 46 | bnx2x_add_tlv(bp, &first_tlv->tl, 0, type, length); |
| 47 | |
| 48 | /* init first tlv header */ |
| 49 | first_tlv->resp_msg_offset = sizeof(bp->vf2pf_mbox->req); |
| 50 | } |
| 51 | |
| 52 | /* list the types and lengths of the tlvs on the buffer */ |
| 53 | void bnx2x_dp_tlv_list(struct bnx2x *bp, void *tlvs_list) |
| 54 | { |
| 55 | int i = 1; |
| 56 | struct channel_tlv *tlv = (struct channel_tlv *)tlvs_list; |
| 57 | |
| 58 | while (tlv->type != CHANNEL_TLV_LIST_END) { |
| 59 | /* output tlv */ |
| 60 | DP(BNX2X_MSG_IOV, "TLV number %d: type %d, length %d\n", i, |
| 61 | tlv->type, tlv->length); |
| 62 | |
| 63 | /* advance to next tlv */ |
| 64 | tlvs_list += tlv->length; |
| 65 | |
| 66 | /* cast general tlv list pointer to channel tlv header*/ |
| 67 | tlv = (struct channel_tlv *)tlvs_list; |
| 68 | |
| 69 | i++; |
| 70 | |
| 71 | /* break condition for this loop */ |
| 72 | if (i > MAX_TLVS_IN_LIST) { |
| 73 | WARN(true, "corrupt tlvs"); |
| 74 | return; |
| 75 | } |
| 76 | } |
| 77 | |
| 78 | /* output last tlv */ |
| 79 | DP(BNX2X_MSG_IOV, "TLV number %d: type %d, length %d\n", i, |
| 80 | tlv->type, tlv->length); |
| 81 | } |
Ariel Elior | b56e967 | 2013-01-01 05:22:32 +0000 | [diff] [blame] | 82 | |
Ariel Elior | fd1fc79 | 2013-01-01 05:22:33 +0000 | [diff] [blame] | 83 | /* test whether we support a tlv type */ |
| 84 | bool bnx2x_tlv_supported(u16 tlvtype) |
| 85 | { |
| 86 | return CHANNEL_TLV_NONE < tlvtype && tlvtype < CHANNEL_TLV_MAX; |
| 87 | } |
| 88 | |
| 89 | static inline int bnx2x_pfvf_status_codes(int rc) |
| 90 | { |
| 91 | switch (rc) { |
| 92 | case 0: |
| 93 | return PFVF_STATUS_SUCCESS; |
| 94 | case -ENOMEM: |
| 95 | return PFVF_STATUS_NO_RESOURCE; |
| 96 | default: |
| 97 | return PFVF_STATUS_FAILURE; |
| 98 | } |
| 99 | } |
| 100 | |
Ariel Elior | b56e967 | 2013-01-01 05:22:32 +0000 | [diff] [blame] | 101 | /* General service functions */ |
| 102 | static void storm_memset_vf_mbx_ack(struct bnx2x *bp, u16 abs_fid) |
| 103 | { |
| 104 | u32 addr = BAR_CSTRORM_INTMEM + |
| 105 | CSTORM_VF_PF_CHANNEL_STATE_OFFSET(abs_fid); |
| 106 | |
| 107 | REG_WR8(bp, addr, VF_PF_CHANNEL_STATE_READY); |
| 108 | } |
| 109 | |
| 110 | static void storm_memset_vf_mbx_valid(struct bnx2x *bp, u16 abs_fid) |
| 111 | { |
| 112 | u32 addr = BAR_CSTRORM_INTMEM + |
| 113 | CSTORM_VF_PF_CHANNEL_VALID_OFFSET(abs_fid); |
| 114 | |
| 115 | REG_WR8(bp, addr, 1); |
| 116 | } |
| 117 | |
| 118 | static inline void bnx2x_set_vf_mbxs_valid(struct bnx2x *bp) |
| 119 | { |
| 120 | int i; |
| 121 | |
| 122 | for_each_vf(bp, i) |
| 123 | storm_memset_vf_mbx_valid(bp, bnx2x_vf(bp, i, abs_vfid)); |
| 124 | } |
| 125 | |
| 126 | /* enable vf_pf mailbox (aka vf-pf-chanell) */ |
| 127 | void bnx2x_vf_enable_mbx(struct bnx2x *bp, u8 abs_vfid) |
| 128 | { |
| 129 | bnx2x_vf_flr_clnup_epilog(bp, abs_vfid); |
| 130 | |
| 131 | /* enable the mailbox in the FW */ |
| 132 | storm_memset_vf_mbx_ack(bp, abs_vfid); |
| 133 | storm_memset_vf_mbx_valid(bp, abs_vfid); |
| 134 | |
| 135 | /* enable the VF access to the mailbox */ |
| 136 | bnx2x_vf_enable_access(bp, abs_vfid); |
| 137 | } |
Ariel Elior | fd1fc79 | 2013-01-01 05:22:33 +0000 | [diff] [blame] | 138 | |
| 139 | /* this works only on !E1h */ |
| 140 | static int bnx2x_copy32_vf_dmae(struct bnx2x *bp, u8 from_vf, |
| 141 | dma_addr_t pf_addr, u8 vfid, u32 vf_addr_hi, |
| 142 | u32 vf_addr_lo, u32 len32) |
| 143 | { |
| 144 | struct dmae_command dmae; |
| 145 | |
| 146 | if (CHIP_IS_E1x(bp)) { |
| 147 | BNX2X_ERR("Chip revision does not support VFs\n"); |
| 148 | return DMAE_NOT_RDY; |
| 149 | } |
| 150 | |
| 151 | if (!bp->dmae_ready) { |
| 152 | BNX2X_ERR("DMAE is not ready, can not copy\n"); |
| 153 | return DMAE_NOT_RDY; |
| 154 | } |
| 155 | |
| 156 | /* set opcode and fixed command fields */ |
| 157 | bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_PCI, DMAE_DST_PCI); |
| 158 | |
| 159 | if (from_vf) { |
| 160 | dmae.opcode_iov = (vfid << DMAE_COMMAND_SRC_VFID_SHIFT) | |
| 161 | (DMAE_SRC_VF << DMAE_COMMAND_SRC_VFPF_SHIFT) | |
| 162 | (DMAE_DST_PF << DMAE_COMMAND_DST_VFPF_SHIFT); |
| 163 | |
| 164 | dmae.opcode |= (DMAE_C_DST << DMAE_COMMAND_C_FUNC_SHIFT); |
| 165 | |
| 166 | dmae.src_addr_lo = vf_addr_lo; |
| 167 | dmae.src_addr_hi = vf_addr_hi; |
| 168 | dmae.dst_addr_lo = U64_LO(pf_addr); |
| 169 | dmae.dst_addr_hi = U64_HI(pf_addr); |
| 170 | } else { |
| 171 | dmae.opcode_iov = (vfid << DMAE_COMMAND_DST_VFID_SHIFT) | |
| 172 | (DMAE_DST_VF << DMAE_COMMAND_DST_VFPF_SHIFT) | |
| 173 | (DMAE_SRC_PF << DMAE_COMMAND_SRC_VFPF_SHIFT); |
| 174 | |
| 175 | dmae.opcode |= (DMAE_C_SRC << DMAE_COMMAND_C_FUNC_SHIFT); |
| 176 | |
| 177 | dmae.src_addr_lo = U64_LO(pf_addr); |
| 178 | dmae.src_addr_hi = U64_HI(pf_addr); |
| 179 | dmae.dst_addr_lo = vf_addr_lo; |
| 180 | dmae.dst_addr_hi = vf_addr_hi; |
| 181 | } |
| 182 | dmae.len = len32; |
| 183 | bnx2x_dp_dmae(bp, &dmae, BNX2X_MSG_DMAE); |
| 184 | |
| 185 | /* issue the command and wait for completion */ |
| 186 | return bnx2x_issue_dmae_with_comp(bp, &dmae); |
| 187 | } |
| 188 | |
Ariel Elior | 8ca5e17 | 2013-01-01 05:22:34 +0000 | [diff] [blame] | 189 | static void bnx2x_vf_mbx_resp(struct bnx2x *bp, struct bnx2x_virtf *vf) |
| 190 | { |
| 191 | struct bnx2x_vf_mbx *mbx = BP_VF_MBX(bp, vf->index); |
| 192 | u64 vf_addr; |
| 193 | dma_addr_t pf_addr; |
| 194 | u16 length, type; |
| 195 | int rc; |
| 196 | struct pfvf_general_resp_tlv *resp = &mbx->msg->resp.general_resp; |
| 197 | |
| 198 | /* prepare response */ |
| 199 | type = mbx->first_tlv.tl.type; |
| 200 | length = type == CHANNEL_TLV_ACQUIRE ? |
| 201 | sizeof(struct pfvf_acquire_resp_tlv) : |
| 202 | sizeof(struct pfvf_general_resp_tlv); |
| 203 | bnx2x_add_tlv(bp, resp, 0, type, length); |
| 204 | resp->hdr.status = bnx2x_pfvf_status_codes(vf->op_rc); |
| 205 | bnx2x_add_tlv(bp, resp, length, CHANNEL_TLV_LIST_END, |
| 206 | sizeof(struct channel_list_end_tlv)); |
| 207 | bnx2x_dp_tlv_list(bp, resp); |
| 208 | DP(BNX2X_MSG_IOV, "mailbox vf address hi 0x%x, lo 0x%x, offset 0x%x\n", |
| 209 | mbx->vf_addr_hi, mbx->vf_addr_lo, mbx->first_tlv.resp_msg_offset); |
| 210 | |
| 211 | /* send response */ |
| 212 | vf_addr = HILO_U64(mbx->vf_addr_hi, mbx->vf_addr_lo) + |
| 213 | mbx->first_tlv.resp_msg_offset; |
| 214 | pf_addr = mbx->msg_mapping + |
| 215 | offsetof(struct bnx2x_vf_mbx_msg, resp); |
| 216 | |
| 217 | /* copy the response body, if there is one, before the header, as the vf |
| 218 | * is sensitive to the header being written |
| 219 | */ |
| 220 | if (resp->hdr.tl.length > sizeof(u64)) { |
| 221 | length = resp->hdr.tl.length - sizeof(u64); |
| 222 | vf_addr += sizeof(u64); |
| 223 | pf_addr += sizeof(u64); |
| 224 | rc = bnx2x_copy32_vf_dmae(bp, false, pf_addr, vf->abs_vfid, |
| 225 | U64_HI(vf_addr), |
| 226 | U64_LO(vf_addr), |
| 227 | length/4); |
| 228 | if (rc) { |
| 229 | BNX2X_ERR("Failed to copy response body to VF %d\n", |
| 230 | vf->abs_vfid); |
| 231 | return; |
| 232 | } |
| 233 | vf_addr -= sizeof(u64); |
| 234 | pf_addr -= sizeof(u64); |
| 235 | } |
| 236 | |
| 237 | /* ack the FW */ |
| 238 | storm_memset_vf_mbx_ack(bp, vf->abs_vfid); |
| 239 | mmiowb(); |
| 240 | |
| 241 | /* initiate dmae to send the response */ |
| 242 | mbx->flags &= ~VF_MSG_INPROCESS; |
| 243 | |
| 244 | /* copy the response header including status-done field, |
| 245 | * must be last dmae, must be after FW is acked |
| 246 | */ |
| 247 | rc = bnx2x_copy32_vf_dmae(bp, false, pf_addr, vf->abs_vfid, |
| 248 | U64_HI(vf_addr), |
| 249 | U64_LO(vf_addr), |
| 250 | sizeof(u64)/4); |
| 251 | |
| 252 | /* unlock channel mutex */ |
| 253 | bnx2x_unlock_vf_pf_channel(bp, vf, mbx->first_tlv.tl.type); |
| 254 | |
| 255 | if (rc) { |
| 256 | BNX2X_ERR("Failed to copy response status to VF %d\n", |
| 257 | vf->abs_vfid); |
| 258 | } |
| 259 | return; |
| 260 | } |
| 261 | |
| 262 | static void bnx2x_vf_mbx_acquire_resp(struct bnx2x *bp, struct bnx2x_virtf *vf, |
| 263 | struct bnx2x_vf_mbx *mbx, int vfop_status) |
| 264 | { |
| 265 | int i; |
| 266 | struct pfvf_acquire_resp_tlv *resp = &mbx->msg->resp.acquire_resp; |
| 267 | struct pf_vf_resc *resc = &resp->resc; |
| 268 | u8 status = bnx2x_pfvf_status_codes(vfop_status); |
| 269 | |
| 270 | memset(resp, 0, sizeof(*resp)); |
| 271 | |
| 272 | /* fill in pfdev info */ |
| 273 | resp->pfdev_info.chip_num = bp->common.chip_id; |
| 274 | resp->pfdev_info.db_size = (1 << BNX2X_DB_SHIFT); |
| 275 | resp->pfdev_info.indices_per_sb = HC_SB_MAX_INDICES_E2; |
| 276 | resp->pfdev_info.pf_cap = (PFVF_CAP_RSS | |
| 277 | /* PFVF_CAP_DHC |*/ PFVF_CAP_TPA); |
| 278 | bnx2x_fill_fw_str(bp, resp->pfdev_info.fw_ver, |
| 279 | sizeof(resp->pfdev_info.fw_ver)); |
| 280 | |
| 281 | if (status == PFVF_STATUS_NO_RESOURCE || |
| 282 | status == PFVF_STATUS_SUCCESS) { |
| 283 | /* set resources numbers, if status equals NO_RESOURCE these |
| 284 | * are max possible numbers |
| 285 | */ |
| 286 | resc->num_rxqs = vf_rxq_count(vf) ? : |
| 287 | bnx2x_vf_max_queue_cnt(bp, vf); |
| 288 | resc->num_txqs = vf_txq_count(vf) ? : |
| 289 | bnx2x_vf_max_queue_cnt(bp, vf); |
| 290 | resc->num_sbs = vf_sb_count(vf); |
| 291 | resc->num_mac_filters = vf_mac_rules_cnt(vf); |
| 292 | resc->num_vlan_filters = vf_vlan_rules_cnt(vf); |
| 293 | resc->num_mc_filters = 0; |
| 294 | |
| 295 | if (status == PFVF_STATUS_SUCCESS) { |
| 296 | for_each_vfq(vf, i) |
| 297 | resc->hw_qid[i] = |
| 298 | vfq_qzone_id(vf, vfq_get(vf, i)); |
| 299 | |
| 300 | for_each_vf_sb(vf, i) { |
| 301 | resc->hw_sbs[i].hw_sb_id = vf_igu_sb(vf, i); |
| 302 | resc->hw_sbs[i].sb_qid = vf_hc_qzone(vf, i); |
| 303 | } |
| 304 | } |
| 305 | } |
| 306 | |
| 307 | DP(BNX2X_MSG_IOV, "VF[%d] ACQUIRE_RESPONSE: pfdev_info- chip_num=0x%x, db_size=%d, idx_per_sb=%d, pf_cap=0x%x\n" |
| 308 | "resources- n_rxq-%d, n_txq-%d, n_sbs-%d, n_macs-%d, n_vlans-%d, n_mcs-%d, fw_ver: '%s'\n", |
| 309 | vf->abs_vfid, |
| 310 | resp->pfdev_info.chip_num, |
| 311 | resp->pfdev_info.db_size, |
| 312 | resp->pfdev_info.indices_per_sb, |
| 313 | resp->pfdev_info.pf_cap, |
| 314 | resc->num_rxqs, |
| 315 | resc->num_txqs, |
| 316 | resc->num_sbs, |
| 317 | resc->num_mac_filters, |
| 318 | resc->num_vlan_filters, |
| 319 | resc->num_mc_filters, |
| 320 | resp->pfdev_info.fw_ver); |
| 321 | |
| 322 | DP_CONT(BNX2X_MSG_IOV, "hw_qids- [ "); |
| 323 | for (i = 0; i < vf_rxq_count(vf); i++) |
| 324 | DP_CONT(BNX2X_MSG_IOV, "%d ", resc->hw_qid[i]); |
| 325 | DP_CONT(BNX2X_MSG_IOV, "], sb_info- [ "); |
| 326 | for (i = 0; i < vf_sb_count(vf); i++) |
| 327 | DP_CONT(BNX2X_MSG_IOV, "%d:%d ", |
| 328 | resc->hw_sbs[i].hw_sb_id, |
| 329 | resc->hw_sbs[i].sb_qid); |
| 330 | DP_CONT(BNX2X_MSG_IOV, "]\n"); |
| 331 | |
| 332 | /* send the response */ |
| 333 | vf->op_rc = vfop_status; |
| 334 | bnx2x_vf_mbx_resp(bp, vf); |
| 335 | } |
| 336 | |
| 337 | static void bnx2x_vf_mbx_acquire(struct bnx2x *bp, struct bnx2x_virtf *vf, |
| 338 | struct bnx2x_vf_mbx *mbx) |
| 339 | { |
| 340 | int rc; |
| 341 | struct vfpf_acquire_tlv *acquire = &mbx->msg->req.acquire; |
| 342 | |
| 343 | /* log vfdef info */ |
| 344 | DP(BNX2X_MSG_IOV, |
| 345 | "VF[%d] ACQUIRE: vfdev_info- vf_id %d, vf_os %d resources- n_rxq-%d, n_txq-%d, n_sbs-%d, n_macs-%d, n_vlans-%d, n_mcs-%d\n", |
| 346 | vf->abs_vfid, acquire->vfdev_info.vf_id, acquire->vfdev_info.vf_os, |
| 347 | acquire->resc_request.num_rxqs, acquire->resc_request.num_txqs, |
| 348 | acquire->resc_request.num_sbs, acquire->resc_request.num_mac_filters, |
| 349 | acquire->resc_request.num_vlan_filters, |
| 350 | acquire->resc_request.num_mc_filters); |
| 351 | |
| 352 | /* acquire the resources */ |
| 353 | rc = bnx2x_vf_acquire(bp, vf, &acquire->resc_request); |
| 354 | |
| 355 | /* response */ |
| 356 | bnx2x_vf_mbx_acquire_resp(bp, vf, mbx, rc); |
| 357 | } |
| 358 | |
Ariel Elior | b93288d | 2013-01-01 05:22:35 +0000 | [diff] [blame] | 359 | static void bnx2x_vf_mbx_init_vf(struct bnx2x *bp, struct bnx2x_virtf *vf, |
| 360 | struct bnx2x_vf_mbx *mbx) |
| 361 | { |
| 362 | struct vfpf_init_tlv *init = &mbx->msg->req.init; |
| 363 | |
| 364 | /* record ghost addresses from vf message */ |
| 365 | vf->spq_map = init->spq_addr; |
| 366 | vf->fw_stat_map = init->stats_addr; |
| 367 | vf->op_rc = bnx2x_vf_init(bp, vf, (dma_addr_t *)init->sb_addr); |
| 368 | |
| 369 | /* response */ |
| 370 | bnx2x_vf_mbx_resp(bp, vf); |
| 371 | } |
| 372 | |
Ariel Elior | 8db573b | 2013-01-01 05:22:37 +0000 | [diff] [blame^] | 373 | /* convert MBX queue-flags to standard SP queue-flags */ |
| 374 | static void bnx2x_vf_mbx_set_q_flags(u32 mbx_q_flags, |
| 375 | unsigned long *sp_q_flags) |
| 376 | { |
| 377 | if (mbx_q_flags & VFPF_QUEUE_FLG_TPA) |
| 378 | __set_bit(BNX2X_Q_FLG_TPA, sp_q_flags); |
| 379 | if (mbx_q_flags & VFPF_QUEUE_FLG_TPA_IPV6) |
| 380 | __set_bit(BNX2X_Q_FLG_TPA_IPV6, sp_q_flags); |
| 381 | if (mbx_q_flags & VFPF_QUEUE_FLG_TPA_GRO) |
| 382 | __set_bit(BNX2X_Q_FLG_TPA_GRO, sp_q_flags); |
| 383 | if (mbx_q_flags & VFPF_QUEUE_FLG_STATS) |
| 384 | __set_bit(BNX2X_Q_FLG_STATS, sp_q_flags); |
| 385 | if (mbx_q_flags & VFPF_QUEUE_FLG_OV) |
| 386 | __set_bit(BNX2X_Q_FLG_OV, sp_q_flags); |
| 387 | if (mbx_q_flags & VFPF_QUEUE_FLG_VLAN) |
| 388 | __set_bit(BNX2X_Q_FLG_VLAN, sp_q_flags); |
| 389 | if (mbx_q_flags & VFPF_QUEUE_FLG_COS) |
| 390 | __set_bit(BNX2X_Q_FLG_COS, sp_q_flags); |
| 391 | if (mbx_q_flags & VFPF_QUEUE_FLG_HC) |
| 392 | __set_bit(BNX2X_Q_FLG_HC, sp_q_flags); |
| 393 | if (mbx_q_flags & VFPF_QUEUE_FLG_DHC) |
| 394 | __set_bit(BNX2X_Q_FLG_DHC, sp_q_flags); |
| 395 | } |
| 396 | |
| 397 | static void bnx2x_vf_mbx_setup_q(struct bnx2x *bp, struct bnx2x_virtf *vf, |
| 398 | struct bnx2x_vf_mbx *mbx) |
| 399 | { |
| 400 | struct vfpf_setup_q_tlv *setup_q = &mbx->msg->req.setup_q; |
| 401 | struct bnx2x_vfop_cmd cmd = { |
| 402 | .done = bnx2x_vf_mbx_resp, |
| 403 | .block = false, |
| 404 | }; |
| 405 | |
| 406 | /* verify vf_qid */ |
| 407 | if (setup_q->vf_qid >= vf_rxq_count(vf)) { |
| 408 | BNX2X_ERR("vf_qid %d invalid, max queue count is %d\n", |
| 409 | setup_q->vf_qid, vf_rxq_count(vf)); |
| 410 | vf->op_rc = -EINVAL; |
| 411 | goto response; |
| 412 | } |
| 413 | |
| 414 | /* tx queues must be setup alongside rx queues thus if the rx queue |
| 415 | * is not marked as valid there's nothing to do. |
| 416 | */ |
| 417 | if (setup_q->param_valid & (VFPF_RXQ_VALID|VFPF_TXQ_VALID)) { |
| 418 | struct bnx2x_vf_queue *q = vfq_get(vf, setup_q->vf_qid); |
| 419 | unsigned long q_type = 0; |
| 420 | |
| 421 | struct bnx2x_queue_init_params *init_p; |
| 422 | struct bnx2x_queue_setup_params *setup_p; |
| 423 | |
| 424 | /* reinit the VF operation context */ |
| 425 | memset(&vf->op_params.qctor, 0 , sizeof(vf->op_params.qctor)); |
| 426 | setup_p = &vf->op_params.qctor.prep_qsetup; |
| 427 | init_p = &vf->op_params.qctor.qstate.params.init; |
| 428 | |
| 429 | /* activate immediately */ |
| 430 | __set_bit(BNX2X_Q_FLG_ACTIVE, &setup_p->flags); |
| 431 | |
| 432 | if (setup_q->param_valid & VFPF_TXQ_VALID) { |
| 433 | struct bnx2x_txq_setup_params *txq_params = |
| 434 | &setup_p->txq_params; |
| 435 | |
| 436 | __set_bit(BNX2X_Q_TYPE_HAS_TX, &q_type); |
| 437 | |
| 438 | /* save sb resource index */ |
| 439 | q->sb_idx = setup_q->txq.vf_sb; |
| 440 | |
| 441 | /* tx init */ |
| 442 | init_p->tx.hc_rate = setup_q->txq.hc_rate; |
| 443 | init_p->tx.sb_cq_index = setup_q->txq.sb_index; |
| 444 | |
| 445 | bnx2x_vf_mbx_set_q_flags(setup_q->txq.flags, |
| 446 | &init_p->tx.flags); |
| 447 | |
| 448 | /* tx setup - flags */ |
| 449 | bnx2x_vf_mbx_set_q_flags(setup_q->txq.flags, |
| 450 | &setup_p->flags); |
| 451 | |
| 452 | /* tx setup - general, nothing */ |
| 453 | |
| 454 | /* tx setup - tx */ |
| 455 | txq_params->dscr_map = setup_q->txq.txq_addr; |
| 456 | txq_params->sb_cq_index = setup_q->txq.sb_index; |
| 457 | txq_params->traffic_type = setup_q->txq.traffic_type; |
| 458 | |
| 459 | bnx2x_vfop_qctor_dump_tx(bp, vf, init_p, setup_p, |
| 460 | q->index, q->sb_idx); |
| 461 | } |
| 462 | |
| 463 | if (setup_q->param_valid & VFPF_RXQ_VALID) { |
| 464 | struct bnx2x_rxq_setup_params *rxq_params = |
| 465 | &setup_p->rxq_params; |
| 466 | |
| 467 | __set_bit(BNX2X_Q_TYPE_HAS_RX, &q_type); |
| 468 | |
| 469 | /* Note: there is no support for different SBs |
| 470 | * for TX and RX |
| 471 | */ |
| 472 | q->sb_idx = setup_q->rxq.vf_sb; |
| 473 | |
| 474 | /* rx init */ |
| 475 | init_p->rx.hc_rate = setup_q->rxq.hc_rate; |
| 476 | init_p->rx.sb_cq_index = setup_q->rxq.sb_index; |
| 477 | bnx2x_vf_mbx_set_q_flags(setup_q->rxq.flags, |
| 478 | &init_p->rx.flags); |
| 479 | |
| 480 | /* rx setup - flags */ |
| 481 | bnx2x_vf_mbx_set_q_flags(setup_q->rxq.flags, |
| 482 | &setup_p->flags); |
| 483 | |
| 484 | /* rx setup - general */ |
| 485 | setup_p->gen_params.mtu = setup_q->rxq.mtu; |
| 486 | |
| 487 | /* rx setup - rx */ |
| 488 | rxq_params->drop_flags = setup_q->rxq.drop_flags; |
| 489 | rxq_params->dscr_map = setup_q->rxq.rxq_addr; |
| 490 | rxq_params->sge_map = setup_q->rxq.sge_addr; |
| 491 | rxq_params->rcq_map = setup_q->rxq.rcq_addr; |
| 492 | rxq_params->rcq_np_map = setup_q->rxq.rcq_np_addr; |
| 493 | rxq_params->buf_sz = setup_q->rxq.buf_sz; |
| 494 | rxq_params->tpa_agg_sz = setup_q->rxq.tpa_agg_sz; |
| 495 | rxq_params->max_sges_pkt = setup_q->rxq.max_sge_pkt; |
| 496 | rxq_params->sge_buf_sz = setup_q->rxq.sge_buf_sz; |
| 497 | rxq_params->cache_line_log = |
| 498 | setup_q->rxq.cache_line_log; |
| 499 | rxq_params->sb_cq_index = setup_q->rxq.sb_index; |
| 500 | |
| 501 | bnx2x_vfop_qctor_dump_rx(bp, vf, init_p, setup_p, |
| 502 | q->index, q->sb_idx); |
| 503 | } |
| 504 | /* complete the preparations */ |
| 505 | bnx2x_vfop_qctor_prep(bp, vf, q, &vf->op_params.qctor, q_type); |
| 506 | |
| 507 | vf->op_rc = bnx2x_vfop_qsetup_cmd(bp, vf, &cmd, q->index); |
| 508 | if (vf->op_rc) |
| 509 | goto response; |
| 510 | return; |
| 511 | } |
| 512 | response: |
| 513 | bnx2x_vf_mbx_resp(bp, vf); |
| 514 | } |
| 515 | |
Ariel Elior | fd1fc79 | 2013-01-01 05:22:33 +0000 | [diff] [blame] | 516 | /* dispatch request */ |
| 517 | static void bnx2x_vf_mbx_request(struct bnx2x *bp, struct bnx2x_virtf *vf, |
| 518 | struct bnx2x_vf_mbx *mbx) |
| 519 | { |
| 520 | int i; |
| 521 | |
| 522 | /* check if tlv type is known */ |
| 523 | if (bnx2x_tlv_supported(mbx->first_tlv.tl.type)) { |
Ariel Elior | 8ca5e17 | 2013-01-01 05:22:34 +0000 | [diff] [blame] | 524 | /* Lock the per vf op mutex and note the locker's identity. |
| 525 | * The unlock will take place in mbx response. |
| 526 | */ |
| 527 | bnx2x_lock_vf_pf_channel(bp, vf, mbx->first_tlv.tl.type); |
| 528 | |
Ariel Elior | fd1fc79 | 2013-01-01 05:22:33 +0000 | [diff] [blame] | 529 | /* switch on the opcode */ |
| 530 | switch (mbx->first_tlv.tl.type) { |
Ariel Elior | 8ca5e17 | 2013-01-01 05:22:34 +0000 | [diff] [blame] | 531 | case CHANNEL_TLV_ACQUIRE: |
| 532 | bnx2x_vf_mbx_acquire(bp, vf, mbx); |
| 533 | break; |
Ariel Elior | b93288d | 2013-01-01 05:22:35 +0000 | [diff] [blame] | 534 | case CHANNEL_TLV_INIT: |
| 535 | bnx2x_vf_mbx_init_vf(bp, vf, mbx); |
| 536 | break; |
Ariel Elior | 8db573b | 2013-01-01 05:22:37 +0000 | [diff] [blame^] | 537 | case CHANNEL_TLV_SETUP_Q: |
| 538 | bnx2x_vf_mbx_setup_q(bp, vf, mbx); |
| 539 | break; |
Ariel Elior | fd1fc79 | 2013-01-01 05:22:33 +0000 | [diff] [blame] | 540 | } |
| 541 | } else { |
| 542 | /* unknown TLV - this may belong to a VF driver from the future |
| 543 | * - a version written after this PF driver was written, which |
| 544 | * supports features unknown as of yet. Too bad since we don't |
| 545 | * support them. Or this may be because someone wrote a crappy |
| 546 | * VF driver and is sending garbage over the channel. |
| 547 | */ |
| 548 | BNX2X_ERR("unknown TLV. type %d length %d. first 20 bytes of mailbox buffer:\n", |
| 549 | mbx->first_tlv.tl.type, mbx->first_tlv.tl.length); |
| 550 | for (i = 0; i < 20; i++) |
| 551 | DP_CONT(BNX2X_MSG_IOV, "%x ", |
| 552 | mbx->msg->req.tlv_buf_size.tlv_buffer[i]); |
Ariel Elior | 8ca5e17 | 2013-01-01 05:22:34 +0000 | [diff] [blame] | 553 | |
| 554 | /* test whether we can respond to the VF (do we have an address |
| 555 | * for it?) |
| 556 | */ |
| 557 | if (vf->state == VF_ACQUIRED) { |
| 558 | /* mbx_resp uses the op_rc of the VF */ |
| 559 | vf->op_rc = PFVF_STATUS_NOT_SUPPORTED; |
| 560 | |
| 561 | /* notify the VF that we do not support this request */ |
| 562 | bnx2x_vf_mbx_resp(bp, vf); |
| 563 | } else { |
| 564 | /* can't send a response since this VF is unknown to us |
| 565 | * just unlock the channel and be done with. |
| 566 | */ |
| 567 | bnx2x_unlock_vf_pf_channel(bp, vf, |
| 568 | mbx->first_tlv.tl.type); |
| 569 | } |
Ariel Elior | fd1fc79 | 2013-01-01 05:22:33 +0000 | [diff] [blame] | 570 | } |
| 571 | } |
| 572 | |
| 573 | /* handle new vf-pf message */ |
| 574 | void bnx2x_vf_mbx(struct bnx2x *bp, struct vf_pf_event_data *vfpf_event) |
| 575 | { |
| 576 | struct bnx2x_virtf *vf; |
| 577 | struct bnx2x_vf_mbx *mbx; |
| 578 | u8 vf_idx; |
| 579 | int rc; |
| 580 | |
| 581 | DP(BNX2X_MSG_IOV, |
| 582 | "vf pf event received: vfid %d, address_hi %x, address lo %x", |
| 583 | vfpf_event->vf_id, vfpf_event->msg_addr_hi, vfpf_event->msg_addr_lo); |
| 584 | /* Sanity checks consider removing later */ |
| 585 | |
| 586 | /* check if the vf_id is valid */ |
| 587 | if (vfpf_event->vf_id - BP_VFDB(bp)->sriov.first_vf_in_pf > |
| 588 | BNX2X_NR_VIRTFN(bp)) { |
| 589 | BNX2X_ERR("Illegal vf_id %d max allowed: %d\n", |
| 590 | vfpf_event->vf_id, BNX2X_NR_VIRTFN(bp)); |
| 591 | goto mbx_done; |
| 592 | } |
| 593 | vf_idx = bnx2x_vf_idx_by_abs_fid(bp, vfpf_event->vf_id); |
| 594 | mbx = BP_VF_MBX(bp, vf_idx); |
| 595 | |
| 596 | /* verify an event is not currently being processed - |
| 597 | * debug failsafe only |
| 598 | */ |
| 599 | if (mbx->flags & VF_MSG_INPROCESS) { |
| 600 | BNX2X_ERR("Previous message is still being processed, vf_id %d\n", |
| 601 | vfpf_event->vf_id); |
| 602 | goto mbx_done; |
| 603 | } |
| 604 | vf = BP_VF(bp, vf_idx); |
| 605 | |
| 606 | /* save the VF message address */ |
| 607 | mbx->vf_addr_hi = vfpf_event->msg_addr_hi; |
| 608 | mbx->vf_addr_lo = vfpf_event->msg_addr_lo; |
| 609 | DP(BNX2X_MSG_IOV, "mailbox vf address hi 0x%x, lo 0x%x, offset 0x%x\n", |
| 610 | mbx->vf_addr_hi, mbx->vf_addr_lo, mbx->first_tlv.resp_msg_offset); |
| 611 | |
| 612 | /* dmae to get the VF request */ |
| 613 | rc = bnx2x_copy32_vf_dmae(bp, true, mbx->msg_mapping, vf->abs_vfid, |
| 614 | mbx->vf_addr_hi, mbx->vf_addr_lo, |
| 615 | sizeof(union vfpf_tlvs)/4); |
| 616 | if (rc) { |
| 617 | BNX2X_ERR("Failed to copy request VF %d\n", vf->abs_vfid); |
| 618 | goto mbx_error; |
| 619 | } |
| 620 | |
| 621 | /* process the VF message header */ |
| 622 | mbx->first_tlv = mbx->msg->req.first_tlv; |
| 623 | |
| 624 | /* dispatch the request (will prepare the response) */ |
| 625 | bnx2x_vf_mbx_request(bp, vf, mbx); |
| 626 | goto mbx_done; |
| 627 | |
| 628 | mbx_error: |
| 629 | mbx_done: |
| 630 | return; |
| 631 | } |