projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branches 'acpi-resources', 'acpi-battery', 'acpi-doc' and 'acpi-pnp'
[linux-2.6-block.git] / drivers / net / ethernet / broadcom / bnx2x / bnx2x_vfpf.c
CommitLineData
be1f1ffa
AE		 1/* bnx2x_vfpf.c: Broadcom Everest network driver.
2 *
247fa82b 3 * Copyright 2009-2013 Broadcom Corporation
be1f1ffa
AE		 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 *
08f6dd89
AE		 15 * Maintained by: Ariel Elior <ariel.elior@qlogic.com>
16 * Written by: Shmulik Ravid
17 * Ariel Elior <ariel.elior@qlogic.com>
be1f1ffa
AE		 18 */
19
20#include "bnx2x.h"
6411280a 21#include "bnx2x_cmn.h"
b93288d5 22#include <linux/crc32.h>
be1f1ffa 23
a8f47eb7 24static int bnx2x_vfpf_teardown_queue(struct bnx2x *bp, int qidx);
25
be1f1ffa 26/* place a given tlv on the tlv buffer at a given offset */
a8f47eb7 27static void bnx2x_add_tlv(struct bnx2x *bp, void *tlvs_list,
28 u16 offset, u16 type, u16 length)
be1f1ffa
AE		 29{
30 struct channel_tlv *tl =
31 (struct channel_tlv *)(tlvs_list + offset);
32
33 tl->type = type;
34 tl->length = length;
35}
36
37/* Clear the mailbox and init the header of the first tlv */
a8f47eb7 38static void bnx2x_vfpf_prep(struct bnx2x *bp, struct vfpf_first_tlv *first_tlv,
39 u16 type, u16 length)
be1f1ffa 40{
1d6f3cd8
DK		 41 mutex_lock(&bp->vf2pf_mutex);
42
be1f1ffa
AE		 43 DP(BNX2X_MSG_IOV, "preparing to send %d tlv over vf pf channel\n",
44 type);
45
46 /* Clear mailbox */
47 memset(bp->vf2pf_mbox, 0, sizeof(struct bnx2x_vf_mbx_msg));
48
49 /* init type and length */
50 bnx2x_add_tlv(bp, &first_tlv->tl, 0, type, length);
51
52 /* init first tlv header */
53 first_tlv->resp_msg_offset = sizeof(bp->vf2pf_mbox->req);
54}
55
1d6f3cd8 56/* releases the mailbox */
a8f47eb7 57static void bnx2x_vfpf_finalize(struct bnx2x *bp,
58 struct vfpf_first_tlv *first_tlv)
1d6f3cd8
DK		 59{
60 DP(BNX2X_MSG_IOV, "done sending [%d] tlv over vf pf channel\n",
61 first_tlv->tl.type);
62
63 mutex_unlock(&bp->vf2pf_mutex);
64}
65
3d7d562c
YM		 66/* Finds a TLV by type in a TLV buffer; If found, returns pointer to the TLV */
67static void *bnx2x_search_tlv_list(struct bnx2x *bp, void *tlvs_list,
68 enum channel_tlvs req_tlv)
69{
70 struct channel_tlv *tlv = (struct channel_tlv *)tlvs_list;
71
72 do {
73 if (tlv->type == req_tlv)
74 return tlv;
75
76 if (!tlv->length) {
77 BNX2X_ERR("Found TLV with length 0\n");
78 return NULL;
79 }
80
81 tlvs_list += tlv->length;
82 tlv = (struct channel_tlv *)tlvs_list;
83 } while (tlv->type != CHANNEL_TLV_LIST_END);
84
85 DP(BNX2X_MSG_IOV, "TLV list does not contain %d TLV\n", req_tlv);
86
87 return NULL;
88}
89
be1f1ffa 90/* list the types and lengths of the tlvs on the buffer */
a8f47eb7 91static void bnx2x_dp_tlv_list(struct bnx2x *bp, void *tlvs_list)
be1f1ffa
AE		 92{
93 int i = 1;
94 struct channel_tlv *tlv = (struct channel_tlv *)tlvs_list;
95
96 while (tlv->type != CHANNEL_TLV_LIST_END) {
97 /* output tlv */
98 DP(BNX2X_MSG_IOV, "TLV number %d: type %d, length %d\n", i,
99 tlv->type, tlv->length);
100
101 /* advance to next tlv */
102 tlvs_list += tlv->length;
103
104 /* cast general tlv list pointer to channel tlv header*/
105 tlv = (struct channel_tlv *)tlvs_list;
106
107 i++;
108
109 /* break condition for this loop */
110 if (i > MAX_TLVS_IN_LIST) {
111 WARN(true, "corrupt tlvs");
112 return;
113 }
114 }
115
116 /* output last tlv */
117 DP(BNX2X_MSG_IOV, "TLV number %d: type %d, length %d\n", i,
118 tlv->type, tlv->length);
119}
b56e9670 120
fd1fc79d
AE		 121/* test whether we support a tlv type */
122bool bnx2x_tlv_supported(u16 tlvtype)
123{
124 return CHANNEL_TLV_NONE < tlvtype && tlvtype < CHANNEL_TLV_MAX;
125}
126
127static inline int bnx2x_pfvf_status_codes(int rc)
128{
129 switch (rc) {
130 case 0:
131 return PFVF_STATUS_SUCCESS;
132 case -ENOMEM:
133 return PFVF_STATUS_NO_RESOURCE;
134 default:
135 return PFVF_STATUS_FAILURE;
136 }
137}
138
732ac8ca 139static int bnx2x_send_msg2pf(struct bnx2x *bp, u8 *done, dma_addr_t msg_mapping)
6411280a
AE		 140{
141 struct cstorm_vf_zone_data __iomem *zone_data =
142 REG_ADDR(bp, PXP_VF_ADDR_CSDM_GLOBAL_START);
78c3bcc5 143 int tout = 100, interval = 100; /* wait for 10 seconds */
6411280a
AE		 144
145 if (*done) {
146 BNX2X_ERR("done was non zero before message to pf was sent\n");
147 WARN_ON(true);
148 return -EINVAL;
149 }
150
78c3bcc5
AE		 151 /* if PF indicated channel is down avoid sending message. Return success
152 * so calling flow can continue
153 */
154 bnx2x_sample_bulletin(bp);
155 if (bp->old_bulletin.valid_bitmap & 1 << CHANNEL_DOWN) {
156 DP(BNX2X_MSG_IOV, "detecting channel down. Aborting message\n");
157 *done = PFVF_STATUS_SUCCESS;
ffa1cb96 158 return -EINVAL;
78c3bcc5
AE		 159 }
160
6411280a
AE		 161 /* Write message address */
162 writel(U64_LO(msg_mapping),
163 &zone_data->non_trigger.vf_pf_channel.msg_addr_lo);
164 writel(U64_HI(msg_mapping),
165 &zone_data->non_trigger.vf_pf_channel.msg_addr_hi);
166
167 /* make sure the address is written before FW accesses it */
168 wmb();
169
170 /* Trigger the PF FW */
171 writeb(1, &zone_data->trigger.vf_pf_channel.addr_valid);
172
173 /* Wait for PF to complete */
174 while ((tout >= 0) && (!*done)) {
175 msleep(interval);
176 tout -= 1;
177
178 /* progress indicator - HV can take its own sweet time in
179 * answering VFs...
180 */
181 DP_CONT(BNX2X_MSG_IOV, ".");
182 }
183
184 if (!*done) {
185 BNX2X_ERR("PF response has timed out\n");
186 return -EAGAIN;
187 }
188 DP(BNX2X_MSG_SP, "Got a response from PF\n");
189 return 0;
190}
191
732ac8ca 192static int bnx2x_get_vf_id(struct bnx2x *bp, u32 *vf_id)
6411280a
AE		 193{
194 u32 me_reg;
195 int tout = 10, interval = 100; /* Wait for 1 sec */
196
197 do {
198 /* pxp traps vf read of doorbells and returns me reg value */
199 me_reg = readl(bp->doorbells);
200 if (GOOD_ME_REG(me_reg))
201 break;
202
203 msleep(interval);
204
205 BNX2X_ERR("Invalid ME register value: 0x%08x\n. Is pf driver up?",
206 me_reg);
207 } while (tout-- > 0);
208
209 if (!GOOD_ME_REG(me_reg)) {
210 BNX2X_ERR("Invalid ME register value: 0x%08x\n", me_reg);
211 return -EINVAL;
212 }
213
c047e070 214 DP(BNX2X_MSG_IOV, "valid ME register value: 0x%08x\n", me_reg);
6411280a
AE		 215
216 *vf_id = (me_reg & ME_REG_VF_NUM_MASK) >> ME_REG_VF_NUM_SHIFT;
217
218 return 0;
219}
220
221int bnx2x_vfpf_acquire(struct bnx2x *bp, u8 tx_count, u8 rx_count)
222{
223 int rc = 0, attempts = 0;
224 struct vfpf_acquire_tlv *req = &bp->vf2pf_mbox->req.acquire;
225 struct pfvf_acquire_resp_tlv *resp = &bp->vf2pf_mbox->resp.acquire_resp;
3d7d562c 226 struct vfpf_port_phys_id_resp_tlv *phys_port_resp;
02dc4025 227 struct vfpf_fp_hsi_resp_tlv *fp_hsi_resp;
6411280a
AE		 228 u32 vf_id;
229 bool resources_acquired = false;
230
231 /* clear mailbox and prep first tlv */
232 bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_ACQUIRE, sizeof(*req));
233
1d6f3cd8
DK		 234 if (bnx2x_get_vf_id(bp, &vf_id)) {
235 rc = -EAGAIN;
236 goto out;
237 }
6411280a
AE		 238
239 req->vfdev_info.vf_id = vf_id;
240 req->vfdev_info.vf_os = 0;
02dc4025 241 req->vfdev_info.fp_hsi_ver = ETH_FP_HSI_VERSION;
6411280a
AE		 242
243 req->resc_request.num_rxqs = rx_count;
244 req->resc_request.num_txqs = tx_count;
245 req->resc_request.num_sbs = bp->igu_sb_cnt;
246 req->resc_request.num_mac_filters = VF_ACQUIRE_MAC_FILTERS;
247 req->resc_request.num_mc_filters = VF_ACQUIRE_MC_FILTERS;
248
249 /* pf 2 vf bulletin board address */
250 req->bulletin_addr = bp->pf2vf_bulletin_mapping;
251
3d7d562c
YM		 252 /* Request physical port identifier */
253 bnx2x_add_tlv(bp, req, req->first_tlv.tl.length,
254 CHANNEL_TLV_PHYS_PORT_ID, sizeof(struct channel_tlv));
255
6495d15a
DK		 256 /* Bulletin support for bulletin board with length > legacy length */
257 req->vfdev_info.caps |= VF_CAP_SUPPORT_EXT_BULLETIN;
258
6411280a 259 /* add list termination tlv */
3d7d562c
YM		 260 bnx2x_add_tlv(bp, req,
261 req->first_tlv.tl.length + sizeof(struct channel_tlv),
262 CHANNEL_TLV_LIST_END,
6411280a
AE		 263 sizeof(struct channel_list_end_tlv));
264
265 /* output tlvs list */
266 bnx2x_dp_tlv_list(bp, req);
267
268 while (!resources_acquired) {
269 DP(BNX2X_MSG_SP, "attempting to acquire resources\n");
270
271 /* send acquire request */
272 rc = bnx2x_send_msg2pf(bp,
273 &resp->hdr.status,
274 bp->vf2pf_mbox_mapping);
275
276 /* PF timeout */
277 if (rc)
1d6f3cd8 278 goto out;
6411280a
AE		 279
280 /* copy acquire response from buffer to bp */
281 memcpy(&bp->acquire_resp, resp, sizeof(bp->acquire_resp));
282
283 attempts++;
284
16a5fd92 285 /* test whether the PF accepted our request. If not, humble
6411280a
AE		 286 * the request and try again.
287 */
288 if (bp->acquire_resp.hdr.status == PFVF_STATUS_SUCCESS) {
289 DP(BNX2X_MSG_SP, "resources acquired\n");
290 resources_acquired = true;
291 } else if (bp->acquire_resp.hdr.status ==
292 PFVF_STATUS_NO_RESOURCE &&
293 attempts < VF_ACQUIRE_THRESH) {
294 DP(BNX2X_MSG_SP,
295 "PF unwilling to fulfill resource request. Try PF recommended amount\n");
296
297 /* humble our request */
298 req->resc_request.num_txqs =
b9871bcf
AE		 299 min(req->resc_request.num_txqs,
300 bp->acquire_resp.resc.num_txqs);
6411280a 301 req->resc_request.num_rxqs =
b9871bcf
AE		 302 min(req->resc_request.num_rxqs,
303 bp->acquire_resp.resc.num_rxqs);
6411280a 304 req->resc_request.num_sbs =
b9871bcf
AE		 305 min(req->resc_request.num_sbs,
306 bp->acquire_resp.resc.num_sbs);
6411280a 307 req->resc_request.num_mac_filters =
b9871bcf
AE		 308 min(req->resc_request.num_mac_filters,
309 bp->acquire_resp.resc.num_mac_filters);
6411280a 310 req->resc_request.num_vlan_filters =
b9871bcf
AE		 311 min(req->resc_request.num_vlan_filters,
312 bp->acquire_resp.resc.num_vlan_filters);
6411280a 313 req->resc_request.num_mc_filters =
b9871bcf
AE		 314 min(req->resc_request.num_mc_filters,
315 bp->acquire_resp.resc.num_mc_filters);
6411280a
AE		 316
317 /* Clear response buffer */
318 memset(&bp->vf2pf_mbox->resp, 0,
319 sizeof(union pfvf_tlvs));
320 } else {
02dc4025
YM		 321 /* Determine reason of PF failure of acquire process */
322 fp_hsi_resp = bnx2x_search_tlv_list(bp, resp,
323 CHANNEL_TLV_FP_HSI_SUPPORT);
324 if (fp_hsi_resp && !fp_hsi_resp->is_supported)
325 BNX2X_ERR("Old hypervisor - doesn't support current fastpath HSI version; Need to downgrade VF driver [or upgrade hypervisor]\n");
326 else
327 BNX2X_ERR("Failed to get the requested amount of resources: %d. Breaking...\n",
328 bp->acquire_resp.hdr.status);
1d6f3cd8
DK		 329 rc = -EAGAIN;
330 goto out;
6411280a
AE		 331 }
332 }
333
3d7d562c
YM		 334 /* Retrieve physical port id (if possible) */
335 phys_port_resp = (struct vfpf_port_phys_id_resp_tlv *)
336 bnx2x_search_tlv_list(bp, resp,
337 CHANNEL_TLV_PHYS_PORT_ID);
338 if (phys_port_resp) {
339 memcpy(bp->phys_port_id, phys_port_resp->id, ETH_ALEN);
340 bp->flags |= HAS_PHYS_PORT_ID;
341 }
342
02dc4025
YM		 343 /* Old Hypevisors might not even support the FP_HSI_SUPPORT TLV.
344 * If that's the case, we need to make certain required FW was
345 * supported by such a hypervisor [i.e., v0-v2].
346 */
347 fp_hsi_resp = bnx2x_search_tlv_list(bp, resp,
348 CHANNEL_TLV_FP_HSI_SUPPORT);
349 if (!fp_hsi_resp && (ETH_FP_HSI_VERSION > ETH_FP_HSI_VER_2)) {
350 BNX2X_ERR("Old hypervisor - need to downgrade VF's driver\n");
351
352 /* Since acquire succeeded on the PF side, we need to send a
353 * release message in order to allow future probes.
354 */
355 bnx2x_vfpf_finalize(bp, &req->first_tlv);
356 bnx2x_vfpf_release(bp);
357
358 rc = -EINVAL;
359 goto out;
360 }
361
6411280a
AE		 362 /* get HW info */
363 bp->common.chip_id |= (bp->acquire_resp.pfdev_info.chip_num & 0xffff);
364 bp->link_params.chip_id = bp->common.chip_id;
365 bp->db_size = bp->acquire_resp.pfdev_info.db_size;
366 bp->common.int_block = INT_BLOCK_IGU;
367 bp->common.chip_port_mode = CHIP_2_PORT_MODE;
368 bp->igu_dsb_id = -1;
369 bp->mf_ov = 0;
370 bp->mf_mode = 0;
371 bp->common.flash_size = 0;
372 bp->flags |=
373 NO_WOL_FLAG | NO_ISCSI_OOO_FLAG | NO_ISCSI_FLAG | NO_FCOE_FLAG;
b9871bcf 374 bp->igu_sb_cnt = bp->acquire_resp.resc.num_sbs;
6411280a
AE		 375 bp->igu_base_sb = bp->acquire_resp.resc.hw_sbs[0].hw_sb_id;
376 strlcpy(bp->fw_ver, bp->acquire_resp.pfdev_info.fw_ver,
377 sizeof(bp->fw_ver));
378
379 if (is_valid_ether_addr(bp->acquire_resp.resc.current_mac_addr))
380 memcpy(bp->dev->dev_addr,
381 bp->acquire_resp.resc.current_mac_addr,
382 ETH_ALEN);
383
1d6f3cd8
DK		 384out:
385 bnx2x_vfpf_finalize(bp, &req->first_tlv);
386 return rc;
6411280a
AE		 387}
388
389int bnx2x_vfpf_release(struct bnx2x *bp)
390{
391 struct vfpf_release_tlv *req = &bp->vf2pf_mbox->req.release;
392 struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
1d6f3cd8 393 u32 rc, vf_id;
6411280a
AE		 394
395 /* clear mailbox and prep first tlv */
396 bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_RELEASE, sizeof(*req));
397
1d6f3cd8
DK		 398 if (bnx2x_get_vf_id(bp, &vf_id)) {
399 rc = -EAGAIN;
400 goto out;
401 }
6411280a
AE		 402
403 req->vf_id = vf_id;
404
405 /* add list termination tlv */
406 bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
407 sizeof(struct channel_list_end_tlv));
408
409 /* output tlvs list */
410 bnx2x_dp_tlv_list(bp, req);
411
412 /* send release request */
413 rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
414
415 if (rc)
416 /* PF timeout */
1d6f3cd8
DK		 417 goto out;
418
6411280a
AE		 419 if (resp->hdr.status == PFVF_STATUS_SUCCESS) {
420 /* PF released us */
421 DP(BNX2X_MSG_SP, "vf released\n");
422 } else {
423 /* PF reports error */
6bf07b8e 424 BNX2X_ERR("PF failed our release request - are we out of sync? Response status: %d\n",
6411280a 425 resp->hdr.status);
1d6f3cd8
DK		 426 rc = -EAGAIN;
427 goto out;
6411280a 428 }
1d6f3cd8
DK		 429out:
430 bnx2x_vfpf_finalize(bp, &req->first_tlv);
6411280a 431
1d6f3cd8 432 return rc;
6411280a
AE		 433}
434
435/* Tell PF about SB addresses */
436int bnx2x_vfpf_init(struct bnx2x *bp)
437{
438 struct vfpf_init_tlv *req = &bp->vf2pf_mbox->req.init;
439 struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
440 int rc, i;
441
442 /* clear mailbox and prep first tlv */
443 bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_INIT, sizeof(*req));
444
445 /* status blocks */
446 for_each_eth_queue(bp, i)
447 req->sb_addr[i] = (dma_addr_t)bnx2x_fp(bp, i,
448 status_blk_mapping);
449
450 /* statistics - requests only supports single queue for now */
451 req->stats_addr = bp->fw_stats_data_mapping +
452 offsetof(struct bnx2x_fw_stats_data, queue_stats);
453
60cad4e6
AE		 454 req->stats_stride = sizeof(struct per_queue_stats);
455
6411280a
AE		 456 /* add list termination tlv */
457 bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
458 sizeof(struct channel_list_end_tlv));
459
460 /* output tlvs list */
461 bnx2x_dp_tlv_list(bp, req);
462
463 rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
464 if (rc)
1d6f3cd8 465 goto out;
6411280a
AE		 466
467 if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
468 BNX2X_ERR("INIT VF failed: %d. Breaking...\n",
469 resp->hdr.status);
1d6f3cd8
DK		 470 rc = -EAGAIN;
471 goto out;
6411280a
AE		 472 }
473
474 DP(BNX2X_MSG_SP, "INIT VF Succeeded\n");
1d6f3cd8
DK		 475out:
476 bnx2x_vfpf_finalize(bp, &req->first_tlv);
477
478 return rc;
6411280a
AE		 479}
480
481/* CLOSE VF - opposite to INIT_VF */
482void bnx2x_vfpf_close_vf(struct bnx2x *bp)
483{
484 struct vfpf_close_tlv *req = &bp->vf2pf_mbox->req.close;
485 struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
486 int i, rc;
487 u32 vf_id;
488
489 /* If we haven't got a valid VF id, there is no sense to
490 * continue with sending messages
491 */
492 if (bnx2x_get_vf_id(bp, &vf_id))
493 goto free_irq;
494
495 /* Close the queues */
496 for_each_queue(bp, i)
497 bnx2x_vfpf_teardown_queue(bp, i);
498
f8f4f61a
DK		 499 /* remove mac */
500 bnx2x_vfpf_config_mac(bp, bp->dev->dev_addr, bp->fp->index, false);
501
6411280a
AE		 502 /* clear mailbox and prep first tlv */
503 bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_CLOSE, sizeof(*req));
504
505 req->vf_id = vf_id;
506
507 /* add list termination tlv */
508 bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
509 sizeof(struct channel_list_end_tlv));
510
511 /* output tlvs list */
512 bnx2x_dp_tlv_list(bp, req);
513
514 rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
515
516 if (rc)
517 BNX2X_ERR("Sending CLOSE failed. rc was: %d\n", rc);
518
519 else if (resp->hdr.status != PFVF_STATUS_SUCCESS)
520 BNX2X_ERR("Sending CLOSE failed: pf response was %d\n",
521 resp->hdr.status);
522
1d6f3cd8
DK		 523 bnx2x_vfpf_finalize(bp, &req->first_tlv);
524
6411280a
AE		 525free_irq:
526 /* Disable HW interrupts, NAPI */
527 bnx2x_netif_stop(bp, 0);
528 /* Delete all NAPI objects */
529 bnx2x_del_all_napi(bp);
530
531 /* Release IRQs */
532 bnx2x_free_irq(bp);
533}
534
b9871bcf
AE		 535static void bnx2x_leading_vfq_init(struct bnx2x *bp, struct bnx2x_virtf *vf,
536 struct bnx2x_vf_queue *q)
537{
538 u8 cl_id = vfq_cl_id(vf, q);
539 u8 func_id = FW_VF_HANDLE(vf->abs_vfid);
540
541 /* mac */
542 bnx2x_init_mac_obj(bp, &q->mac_obj,
543 cl_id, q->cid, func_id,
544 bnx2x_vf_sp(bp, vf, mac_rdata),
545 bnx2x_vf_sp_map(bp, vf, mac_rdata),
546 BNX2X_FILTER_MAC_PENDING,
547 &vf->filter_state,
548 BNX2X_OBJ_TYPE_RX_TX,
549 &bp->macs_pool);
550 /* vlan */
551 bnx2x_init_vlan_obj(bp, &q->vlan_obj,
552 cl_id, q->cid, func_id,
553 bnx2x_vf_sp(bp, vf, vlan_rdata),
554 bnx2x_vf_sp_map(bp, vf, vlan_rdata),
555 BNX2X_FILTER_VLAN_PENDING,
556 &vf->filter_state,
557 BNX2X_OBJ_TYPE_RX_TX,
558 &bp->vlans_pool);
559
560 /* mcast */
561 bnx2x_init_mcast_obj(bp, &vf->mcast_obj, cl_id,
562 q->cid, func_id, func_id,
563 bnx2x_vf_sp(bp, vf, mcast_rdata),
564 bnx2x_vf_sp_map(bp, vf, mcast_rdata),
565 BNX2X_FILTER_MCAST_PENDING,
566 &vf->filter_state,
567 BNX2X_OBJ_TYPE_RX_TX);
568
569 /* rss */
570 bnx2x_init_rss_config_obj(bp, &vf->rss_conf_obj, cl_id, q->cid,
571 func_id, func_id,
572 bnx2x_vf_sp(bp, vf, rss_rdata),
573 bnx2x_vf_sp_map(bp, vf, rss_rdata),
574 BNX2X_FILTER_RSS_CONF_PENDING,
575 &vf->filter_state,
576 BNX2X_OBJ_TYPE_RX_TX);
577
578 vf->leading_rss = cl_id;
579 q->is_leading = true;
3a3534ec 580 q->sp_initialized = true;
b9871bcf
AE		 581}
582
6411280a 583/* ask the pf to open a queue for the vf */
60cad4e6
AE		 584int bnx2x_vfpf_setup_q(struct bnx2x *bp, struct bnx2x_fastpath *fp,
585 bool is_leading)
6411280a
AE		 586{
587 struct vfpf_setup_q_tlv *req = &bp->vf2pf_mbox->req.setup_q;
588 struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
60cad4e6 589 u8 fp_idx = fp->index;
6411280a
AE		 590 u16 tpa_agg_size = 0, flags = 0;
591 int rc;
592
593 /* clear mailbox and prep first tlv */
594 bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_SETUP_Q, sizeof(*req));
595
596 /* select tpa mode to request */
7e6b4d44 597 if (fp->mode != TPA_MODE_DISABLED) {
6411280a
AE		 598 flags |= VFPF_QUEUE_FLG_TPA;
599 flags |= VFPF_QUEUE_FLG_TPA_IPV6;
600 if (fp->mode == TPA_MODE_GRO)
601 flags |= VFPF_QUEUE_FLG_TPA_GRO;
602 tpa_agg_size = TPA_AGG_SIZE;
603 }
604
60cad4e6
AE		 605 if (is_leading)
606 flags |= VFPF_QUEUE_FLG_LEADING_RSS;
607
6411280a
AE		 608 /* calculate queue flags */
609 flags |= VFPF_QUEUE_FLG_STATS;
610 flags |= VFPF_QUEUE_FLG_CACHE_ALIGN;
6411280a 611 flags |= VFPF_QUEUE_FLG_VLAN;
6411280a
AE		 612
613 /* Common */
614 req->vf_qid = fp_idx;
615 req->param_valid = VFPF_RXQ_VALID | VFPF_TXQ_VALID;
616
617 /* Rx */
618 req->rxq.rcq_addr = fp->rx_comp_mapping;
619 req->rxq.rcq_np_addr = fp->rx_comp_mapping + BCM_PAGE_SIZE;
620 req->rxq.rxq_addr = fp->rx_desc_mapping;
621 req->rxq.sge_addr = fp->rx_sge_mapping;
622 req->rxq.vf_sb = fp_idx;
623 req->rxq.sb_index = HC_INDEX_ETH_RX_CQ_CONS;
624 req->rxq.hc_rate = bp->rx_ticks ? 1000000/bp->rx_ticks : 0;
625 req->rxq.mtu = bp->dev->mtu;
626 req->rxq.buf_sz = fp->rx_buf_size;
627 req->rxq.sge_buf_sz = BCM_PAGE_SIZE * PAGES_PER_SGE;
628 req->rxq.tpa_agg_sz = tpa_agg_size;
629 req->rxq.max_sge_pkt = SGE_PAGE_ALIGN(bp->dev->mtu) >> SGE_PAGE_SHIFT;
630 req->rxq.max_sge_pkt = ((req->rxq.max_sge_pkt + PAGES_PER_SGE - 1) &
631 (~(PAGES_PER_SGE-1))) >> PAGES_PER_SGE_SHIFT;
632 req->rxq.flags = flags;
633 req->rxq.drop_flags = 0;
634 req->rxq.cache_line_log = BNX2X_RX_ALIGN_SHIFT;
635 req->rxq.stat_id = -1; /* No stats at the moment */
636
637 /* Tx */
638 req->txq.txq_addr = fp->txdata_ptr[FIRST_TX_COS_INDEX]->tx_desc_mapping;
639 req->txq.vf_sb = fp_idx;
640 req->txq.sb_index = HC_INDEX_ETH_TX_CQ_CONS_COS0;
641 req->txq.hc_rate = bp->tx_ticks ? 1000000/bp->tx_ticks : 0;
642 req->txq.flags = flags;
643 req->txq.traffic_type = LLFC_TRAFFIC_TYPE_NW;
644
645 /* add list termination tlv */
646 bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
647 sizeof(struct channel_list_end_tlv));
648
649 /* output tlvs list */
650 bnx2x_dp_tlv_list(bp, req);
651
652 rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
653 if (rc)
654 BNX2X_ERR("Sending SETUP_Q message for queue[%d] failed!\n",
655 fp_idx);
656
657 if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
658 BNX2X_ERR("Status of SETUP_Q for queue[%d] is %d\n",
659 fp_idx, resp->hdr.status);
1d6f3cd8 660 rc = -EINVAL;
6411280a 661 }
1d6f3cd8
DK		 662
663 bnx2x_vfpf_finalize(bp, &req->first_tlv);
664
6411280a
AE		 665 return rc;
666}
667
a8f47eb7 668static int bnx2x_vfpf_teardown_queue(struct bnx2x *bp, int qidx)
6411280a
AE		 669{
670 struct vfpf_q_op_tlv *req = &bp->vf2pf_mbox->req.q_op;
671 struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
672 int rc;
673
674 /* clear mailbox and prep first tlv */
675 bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_TEARDOWN_Q,
676 sizeof(*req));
677
678 req->vf_qid = qidx;
679
680 /* add list termination tlv */
681 bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
682 sizeof(struct channel_list_end_tlv));
683
684 /* output tlvs list */
685 bnx2x_dp_tlv_list(bp, req);
686
687 rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
688
689 if (rc) {
690 BNX2X_ERR("Sending TEARDOWN for queue %d failed: %d\n", qidx,
691 rc);
1d6f3cd8 692 goto out;
6411280a
AE		 693 }
694
695 /* PF failed the transaction */
696 if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
697 BNX2X_ERR("TEARDOWN for queue %d failed: %d\n", qidx,
698 resp->hdr.status);
1d6f3cd8 699 rc = -EINVAL;
6411280a
AE		 700 }
701
1d6f3cd8
DK		 702out:
703 bnx2x_vfpf_finalize(bp, &req->first_tlv);
2dc33bbc 704
1d6f3cd8 705 return rc;
6411280a
AE		 706}
707
708/* request pf to add a mac for the vf */
f8f4f61a 709int bnx2x_vfpf_config_mac(struct bnx2x *bp, u8 *addr, u8 vf_qid, bool set)
6411280a
AE		 710{
711 struct vfpf_set_q_filters_tlv *req = &bp->vf2pf_mbox->req.set_q_filters;
712 struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
f8f4f61a 713 struct pf_vf_bulletin_content bulletin = bp->pf2vf_bulletin->content;
1d6f3cd8 714 int rc = 0;
6411280a
AE		 715
716 /* clear mailbox and prep first tlv */
717 bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_SET_Q_FILTERS,
718 sizeof(*req));
719
720 req->flags = VFPF_SET_Q_FILTERS_MAC_VLAN_CHANGED;
f8f4f61a 721 req->vf_qid = vf_qid;
6411280a 722 req->n_mac_vlan_filters = 1;
f8f4f61a
DK		 723
724 req->filters[0].flags = VFPF_Q_FILTER_DEST_MAC_VALID;
725 if (set)
726 req->filters[0].flags |= VFPF_Q_FILTER_SET_MAC;
6411280a
AE		 727
728 /* sample bulletin board for new mac */
729 bnx2x_sample_bulletin(bp);
730
731 /* copy mac from device to request */
f8f4f61a 732 memcpy(req->filters[0].mac, addr, ETH_ALEN);
6411280a
AE		 733
734 /* add list termination tlv */
735 bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
736 sizeof(struct channel_list_end_tlv));
737
738 /* output tlvs list */
739 bnx2x_dp_tlv_list(bp, req);
740
741 /* send message to pf */
742 rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
743 if (rc) {
744 BNX2X_ERR("failed to send message to pf. rc was %d\n", rc);
1d6f3cd8 745 goto out;
6411280a
AE		 746 }
747
748 /* failure may mean PF was configured with a new mac for us */
749 while (resp->hdr.status == PFVF_STATUS_FAILURE) {
750 DP(BNX2X_MSG_IOV,
751 "vfpf SET MAC failed. Check bulletin board for new posts\n");
752
f8f4f61a
DK		 753 /* copy mac from bulletin to device */
754 memcpy(bp->dev->dev_addr, bulletin.mac, ETH_ALEN);
755
6411280a
AE		 756 /* check if bulletin board was updated */
757 if (bnx2x_sample_bulletin(bp) == PFVF_BULLETIN_UPDATED) {
758 /* copy mac from device to request */
759 memcpy(req->filters[0].mac, bp->dev->dev_addr,
760 ETH_ALEN);
761
762 /* send message to pf */
763 rc = bnx2x_send_msg2pf(bp, &resp->hdr.status,
764 bp->vf2pf_mbox_mapping);
765 } else {
766 /* no new info in bulletin */
767 break;
768 }
769 }
770
771 if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
772 BNX2X_ERR("vfpf SET MAC failed: %d\n", resp->hdr.status);
1d6f3cd8 773 rc = -EINVAL;
6411280a 774 }
1d6f3cd8
DK		 775out:
776 bnx2x_vfpf_finalize(bp, &req->first_tlv);
6411280a 777
02948344 778 return rc;
6411280a
AE		 779}
780
60cad4e6
AE		 781/* request pf to config rss table for vf queues*/
782int bnx2x_vfpf_config_rss(struct bnx2x *bp,
783 struct bnx2x_config_rss_params *params)
784{
785 struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
786 struct vfpf_rss_tlv *req = &bp->vf2pf_mbox->req.update_rss;
787 int rc = 0;
788
789 /* clear mailbox and prep first tlv */
790 bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_UPDATE_RSS,
791 sizeof(*req));
792
793 /* add list termination tlv */
794 bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
795 sizeof(struct channel_list_end_tlv));
796
797 memcpy(req->ind_table, params->ind_table, T_ETH_INDIRECTION_TABLE_SIZE);
798 memcpy(req->rss_key, params->rss_key, sizeof(params->rss_key));
799 req->ind_table_size = T_ETH_INDIRECTION_TABLE_SIZE;
800 req->rss_key_size = T_ETH_RSS_KEY;
801 req->rss_result_mask = params->rss_result_mask;
802
dbedd44e 803 /* flags handled individually for backward/forward compatibility */
60cad4e6
AE		 804 if (params->rss_flags & (1 << BNX2X_RSS_MODE_DISABLED))
805 req->rss_flags |= VFPF_RSS_MODE_DISABLED;
806 if (params->rss_flags & (1 << BNX2X_RSS_MODE_REGULAR))
807 req->rss_flags |= VFPF_RSS_MODE_REGULAR;
808 if (params->rss_flags & (1 << BNX2X_RSS_SET_SRCH))
809 req->rss_flags |= VFPF_RSS_SET_SRCH;
810 if (params->rss_flags & (1 << BNX2X_RSS_IPV4))
811 req->rss_flags |= VFPF_RSS_IPV4;
812 if (params->rss_flags & (1 << BNX2X_RSS_IPV4_TCP))
813 req->rss_flags |= VFPF_RSS_IPV4_TCP;
814 if (params->rss_flags & (1 << BNX2X_RSS_IPV4_UDP))
815 req->rss_flags |= VFPF_RSS_IPV4_UDP;
816 if (params->rss_flags & (1 << BNX2X_RSS_IPV6))
817 req->rss_flags |= VFPF_RSS_IPV6;
818 if (params->rss_flags & (1 << BNX2X_RSS_IPV6_TCP))
819 req->rss_flags |= VFPF_RSS_IPV6_TCP;
820 if (params->rss_flags & (1 << BNX2X_RSS_IPV6_UDP))
821 req->rss_flags |= VFPF_RSS_IPV6_UDP;
822
823 DP(BNX2X_MSG_IOV, "rss flags %x\n", req->rss_flags);
824
825 /* output tlvs list */
826 bnx2x_dp_tlv_list(bp, req);
827
828 /* send message to pf */
829 rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
830 if (rc) {
831 BNX2X_ERR("failed to send message to pf. rc was %d\n", rc);
832 goto out;
833 }
834
835 if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
31b3523c
YM		 836 /* Since older drivers don't support this feature (and VF has
837 * no way of knowing other than failing this), don't propagate
838 * an error in this case.
839 */
840 DP(BNX2X_MSG_IOV,
841 "Failed to send rss message to PF over VF-PF channel [%d]\n",
842 resp->hdr.status);
60cad4e6
AE		 843 }
844out:
845 bnx2x_vfpf_finalize(bp, &req->first_tlv);
846
31b3523c 847 return rc;
60cad4e6
AE		 848}
849
6411280a
AE		 850int bnx2x_vfpf_set_mcast(struct net_device *dev)
851{
852 struct bnx2x *bp = netdev_priv(dev);
853 struct vfpf_set_q_filters_tlv *req = &bp->vf2pf_mbox->req.set_q_filters;
854 struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
855 int rc, i = 0;
856 struct netdev_hw_addr *ha;
857
858 if (bp->state != BNX2X_STATE_OPEN) {
859 DP(NETIF_MSG_IFUP, "state is %x, returning\n", bp->state);
860 return -EINVAL;
861 }
862
863 /* clear mailbox and prep first tlv */
864 bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_SET_Q_FILTERS,
865 sizeof(*req));
866
867 /* Get Rx mode requested */
868 DP(NETIF_MSG_IFUP, "dev->flags = %x\n", dev->flags);
869
870 netdev_for_each_mc_addr(ha, dev) {
871 DP(NETIF_MSG_IFUP, "Adding mcast MAC: %pM\n",
872 bnx2x_mc_addr(ha));
873 memcpy(req->multicast[i], bnx2x_mc_addr(ha), ETH_ALEN);
874 i++;
875 }
876
877 /* We support four PFVF_MAX_MULTICAST_PER_VF mcast
878 * addresses tops
879 */
880 if (i >= PFVF_MAX_MULTICAST_PER_VF) {
881 DP(NETIF_MSG_IFUP,
882 "VF supports not more than %d multicast MAC addresses\n",
883 PFVF_MAX_MULTICAST_PER_VF);
884 return -EINVAL;
885 }
886
887 req->n_multicast = i;
888 req->flags |= VFPF_SET_Q_FILTERS_MULTICAST_CHANGED;
889 req->vf_qid = 0;
890
891 /* add list termination tlv */
892 bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
893 sizeof(struct channel_list_end_tlv));
894
895 /* output tlvs list */
896 bnx2x_dp_tlv_list(bp, req);
897 rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
898 if (rc) {
899 BNX2X_ERR("Sending a message failed: %d\n", rc);
1d6f3cd8 900 goto out;
6411280a
AE		 901 }
902
903 if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
904 BNX2X_ERR("Set Rx mode/multicast failed: %d\n",
905 resp->hdr.status);
1d6f3cd8 906 rc = -EINVAL;
6411280a 907 }
1d6f3cd8
DK		 908out:
909 bnx2x_vfpf_finalize(bp, &req->first_tlv);
6411280a
AE		 910
911 return 0;
912}
913
914int bnx2x_vfpf_storm_rx_mode(struct bnx2x *bp)
915{
916 int mode = bp->rx_mode;
917 struct vfpf_set_q_filters_tlv *req = &bp->vf2pf_mbox->req.set_q_filters;
918 struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
919 int rc;
920
921 /* clear mailbox and prep first tlv */
922 bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_SET_Q_FILTERS,
923 sizeof(*req));
924
925 DP(NETIF_MSG_IFUP, "Rx mode is %d\n", mode);
926
16bd41dd
YM		 927 /* Ignore everything accept MODE_NONE */
928 if (mode == BNX2X_RX_MODE_NONE) {
6411280a 929 req->rx_mask = VFPF_RX_MASK_ACCEPT_NONE;
16bd41dd
YM		 930 } else {
931 /* Current PF driver will not look at the specific flags,
932 * but they are required when working with older drivers on hv.
933 */
6411280a
AE		 934 req->rx_mask = VFPF_RX_MASK_ACCEPT_MATCHED_MULTICAST;
935 req->rx_mask |= VFPF_RX_MASK_ACCEPT_MATCHED_UNICAST;
936 req->rx_mask |= VFPF_RX_MASK_ACCEPT_BROADCAST;
6411280a
AE		 937 }
938
939 req->flags |= VFPF_SET_Q_FILTERS_RX_MASK_CHANGED;
940 req->vf_qid = 0;
941
942 /* add list termination tlv */
943 bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
944 sizeof(struct channel_list_end_tlv));
945
946 /* output tlvs list */
947 bnx2x_dp_tlv_list(bp, req);
948
949 rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
950 if (rc)
951 BNX2X_ERR("Sending a message failed: %d\n", rc);
952
953 if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
954 BNX2X_ERR("Set Rx mode failed: %d\n", resp->hdr.status);
1d6f3cd8 955 rc = -EINVAL;
6411280a 956 }
16bd41dd 957
1d6f3cd8 958 bnx2x_vfpf_finalize(bp, &req->first_tlv);
6411280a
AE		 959
960 return rc;
961}
962
b56e9670
AE		 963/* General service functions */
964static void storm_memset_vf_mbx_ack(struct bnx2x *bp, u16 abs_fid)
965{
966 u32 addr = BAR_CSTRORM_INTMEM +
967 CSTORM_VF_PF_CHANNEL_STATE_OFFSET(abs_fid);
968
969 REG_WR8(bp, addr, VF_PF_CHANNEL_STATE_READY);
970}
971
972static void storm_memset_vf_mbx_valid(struct bnx2x *bp, u16 abs_fid)
973{
974 u32 addr = BAR_CSTRORM_INTMEM +
975 CSTORM_VF_PF_CHANNEL_VALID_OFFSET(abs_fid);
976
977 REG_WR8(bp, addr, 1);
978}
979
16a5fd92 980/* enable vf_pf mailbox (aka vf-pf-channel) */
b56e9670
AE		 981void bnx2x_vf_enable_mbx(struct bnx2x *bp, u8 abs_vfid)
982{
983 bnx2x_vf_flr_clnup_epilog(bp, abs_vfid);
984
985 /* enable the mailbox in the FW */
986 storm_memset_vf_mbx_ack(bp, abs_vfid);
987 storm_memset_vf_mbx_valid(bp, abs_vfid);
988
989 /* enable the VF access to the mailbox */
990 bnx2x_vf_enable_access(bp, abs_vfid);
991}
fd1fc79d
AE		 992
993/* this works only on !E1h */
994static int bnx2x_copy32_vf_dmae(struct bnx2x *bp, u8 from_vf,
995 dma_addr_t pf_addr, u8 vfid, u32 vf_addr_hi,
996 u32 vf_addr_lo, u32 len32)
997{
998 struct dmae_command dmae;
999
1000 if (CHIP_IS_E1x(bp)) {
1001 BNX2X_ERR("Chip revision does not support VFs\n");
1002 return DMAE_NOT_RDY;
1003 }
1004
1005 if (!bp->dmae_ready) {
1006 BNX2X_ERR("DMAE is not ready, can not copy\n");
1007 return DMAE_NOT_RDY;
1008 }
1009
1010 /* set opcode and fixed command fields */
1011 bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_PCI, DMAE_DST_PCI);
1012
1013 if (from_vf) {
1014 dmae.opcode_iov = (vfid << DMAE_COMMAND_SRC_VFID_SHIFT) |
1015 (DMAE_SRC_VF << DMAE_COMMAND_SRC_VFPF_SHIFT) |
1016 (DMAE_DST_PF << DMAE_COMMAND_DST_VFPF_SHIFT);
1017
1018 dmae.opcode |= (DMAE_C_DST << DMAE_COMMAND_C_FUNC_SHIFT);
1019
1020 dmae.src_addr_lo = vf_addr_lo;
1021 dmae.src_addr_hi = vf_addr_hi;
1022 dmae.dst_addr_lo = U64_LO(pf_addr);
1023 dmae.dst_addr_hi = U64_HI(pf_addr);
1024 } else {
1025 dmae.opcode_iov = (vfid << DMAE_COMMAND_DST_VFID_SHIFT) |
1026 (DMAE_DST_VF << DMAE_COMMAND_DST_VFPF_SHIFT) |
1027 (DMAE_SRC_PF << DMAE_COMMAND_SRC_VFPF_SHIFT);
1028
1029 dmae.opcode |= (DMAE_C_SRC << DMAE_COMMAND_C_FUNC_SHIFT);
1030
1031 dmae.src_addr_lo = U64_LO(pf_addr);
1032 dmae.src_addr_hi = U64_HI(pf_addr);
1033 dmae.dst_addr_lo = vf_addr_lo;
1034 dmae.dst_addr_hi = vf_addr_hi;
1035 }
1036 dmae.len = len32;
fd1fc79d
AE		 1037
1038 /* issue the command and wait for completion */
32316a46 1039 return bnx2x_issue_dmae_with_comp(bp, &dmae, bnx2x_sp(bp, wb_comp));
fd1fc79d
AE		 1040}
1041
3d7d562c
YM		 1042static void bnx2x_vf_mbx_resp_single_tlv(struct bnx2x *bp,
1043 struct bnx2x_virtf *vf)
8ca5e17e
AE		 1044{
1045 struct bnx2x_vf_mbx *mbx = BP_VF_MBX(bp, vf->index);
8ca5e17e 1046 u16 length, type;
8ca5e17e
AE		 1047
1048 /* prepare response */
1049 type = mbx->first_tlv.tl.type;
1050 length = type == CHANNEL_TLV_ACQUIRE ?
1051 sizeof(struct pfvf_acquire_resp_tlv) :
1052 sizeof(struct pfvf_general_resp_tlv);
3d7d562c
YM		 1053 bnx2x_add_tlv(bp, &mbx->msg->resp, 0, type, length);
1054 bnx2x_add_tlv(bp, &mbx->msg->resp, length, CHANNEL_TLV_LIST_END,
8ca5e17e 1055 sizeof(struct channel_list_end_tlv));
3d7d562c
YM		 1056}
1057
1058static void bnx2x_vf_mbx_resp_send_msg(struct bnx2x *bp,
2dc33bbc
YM		 1059 struct bnx2x_virtf *vf,
1060 int vf_rc)
3d7d562c
YM		 1061{
1062 struct bnx2x_vf_mbx *mbx = BP_VF_MBX(bp, vf->index);
1063 struct pfvf_general_resp_tlv *resp = &mbx->msg->resp.general_resp;
1064 dma_addr_t pf_addr;
1065 u64 vf_addr;
1066 int rc;
1067
8ca5e17e
AE		 1068 bnx2x_dp_tlv_list(bp, resp);
1069 DP(BNX2X_MSG_IOV, "mailbox vf address hi 0x%x, lo 0x%x, offset 0x%x\n",
1070 mbx->vf_addr_hi, mbx->vf_addr_lo, mbx->first_tlv.resp_msg_offset);
1071
2dc33bbc 1072 resp->hdr.status = bnx2x_pfvf_status_codes(vf_rc);
3d7d562c 1073
8ca5e17e
AE		 1074 /* send response */
1075 vf_addr = HILO_U64(mbx->vf_addr_hi, mbx->vf_addr_lo) +
1076 mbx->first_tlv.resp_msg_offset;
1077 pf_addr = mbx->msg_mapping +
1078 offsetof(struct bnx2x_vf_mbx_msg, resp);
1079
3d7d562c
YM		 1080 /* Copy the response buffer. The first u64 is written afterwards, as
1081 * the vf is sensitive to the header being written
8ca5e17e 1082 */
3d7d562c
YM		 1083 vf_addr += sizeof(u64);
1084 pf_addr += sizeof(u64);
1085 rc = bnx2x_copy32_vf_dmae(bp, false, pf_addr, vf->abs_vfid,
1086 U64_HI(vf_addr),
1087 U64_LO(vf_addr),
1088 (sizeof(union pfvf_tlvs) - sizeof(u64))/4);
1089 if (rc) {
1090 BNX2X_ERR("Failed to copy response body to VF %d\n",
1091 vf->abs_vfid);
1092 goto mbx_error;
8ca5e17e 1093 }
3d7d562c
YM		 1094 vf_addr -= sizeof(u64);
1095 pf_addr -= sizeof(u64);
8ca5e17e
AE		 1096
1097 /* ack the FW */
1098 storm_memset_vf_mbx_ack(bp, vf->abs_vfid);
1099 mmiowb();
1100
8ca5e17e
AE		 1101 /* copy the response header including status-done field,
1102 * must be last dmae, must be after FW is acked
1103 */
1104 rc = bnx2x_copy32_vf_dmae(bp, false, pf_addr, vf->abs_vfid,
1105 U64_HI(vf_addr),
1106 U64_LO(vf_addr),
1107 sizeof(u64)/4);
1108
1109 /* unlock channel mutex */
1110 bnx2x_unlock_vf_pf_channel(bp, vf, mbx->first_tlv.tl.type);
1111
1112 if (rc) {
1113 BNX2X_ERR("Failed to copy response status to VF %d\n",
1114 vf->abs_vfid);
f1929b01 1115 goto mbx_error;
8ca5e17e
AE		 1116 }
1117 return;
f1929b01
AE		 1118
1119mbx_error:
2dc33bbc 1120 bnx2x_vf_release(bp, vf);
8ca5e17e
AE		 1121}
1122
3d7d562c 1123static void bnx2x_vf_mbx_resp(struct bnx2x *bp,
2dc33bbc
YM		 1124 struct bnx2x_virtf *vf,
1125 int rc)
3d7d562c
YM		 1126{
1127 bnx2x_vf_mbx_resp_single_tlv(bp, vf);
2dc33bbc 1128 bnx2x_vf_mbx_resp_send_msg(bp, vf, rc);
3d7d562c
YM		 1129}
1130
1131static void bnx2x_vf_mbx_resp_phys_port(struct bnx2x *bp,
1132 struct bnx2x_virtf *vf,
1133 void *buffer,
1134 u16 *offset)
1135{
1136 struct vfpf_port_phys_id_resp_tlv *port_id;
1137
1138 if (!(bp->flags & HAS_PHYS_PORT_ID))
1139 return;
1140
1141 bnx2x_add_tlv(bp, buffer, *offset, CHANNEL_TLV_PHYS_PORT_ID,
1142 sizeof(struct vfpf_port_phys_id_resp_tlv));
1143
1144 port_id = (struct vfpf_port_phys_id_resp_tlv *)
1145 (((u8 *)buffer) + *offset);
1146 memcpy(port_id->id, bp->phys_port_id, ETH_ALEN);
1147
1148 /* Offset should continue representing the offset to the tail
1149 * of TLV data (outside this function scope)
1150 */
1151 *offset += sizeof(struct vfpf_port_phys_id_resp_tlv);
1152}
1153
02dc4025
YM		 1154static void bnx2x_vf_mbx_resp_fp_hsi_ver(struct bnx2x *bp,
1155 struct bnx2x_virtf *vf,
1156 void *buffer,
1157 u16 *offset)
1158{
1159 struct vfpf_fp_hsi_resp_tlv *fp_hsi;
1160
1161 bnx2x_add_tlv(bp, buffer, *offset, CHANNEL_TLV_FP_HSI_SUPPORT,
1162 sizeof(struct vfpf_fp_hsi_resp_tlv));
1163
1164 fp_hsi = (struct vfpf_fp_hsi_resp_tlv *)
1165 (((u8 *)buffer) + *offset);
1166 fp_hsi->is_supported = (vf->fp_hsi > ETH_FP_HSI_VERSION) ? 0 : 1;
1167
1168 /* Offset should continue representing the offset to the tail
1169 * of TLV data (outside this function scope)
1170 */
1171 *offset += sizeof(struct vfpf_fp_hsi_resp_tlv);
1172}
1173
8ca5e17e
AE		 1174static void bnx2x_vf_mbx_acquire_resp(struct bnx2x *bp, struct bnx2x_virtf *vf,
1175 struct bnx2x_vf_mbx *mbx, int vfop_status)
1176{
1177 int i;
1178 struct pfvf_acquire_resp_tlv *resp = &mbx->msg->resp.acquire_resp;
1179 struct pf_vf_resc *resc = &resp->resc;
1180 u8 status = bnx2x_pfvf_status_codes(vfop_status);
3d7d562c 1181 u16 length;
8ca5e17e
AE		 1182
1183 memset(resp, 0, sizeof(*resp));
1184
1185 /* fill in pfdev info */
1186 resp->pfdev_info.chip_num = bp->common.chip_id;
b9871bcf 1187 resp->pfdev_info.db_size = bp->db_size;
8ca5e17e
AE		 1188 resp->pfdev_info.indices_per_sb = HC_SB_MAX_INDICES_E2;
1189 resp->pfdev_info.pf_cap = (PFVF_CAP_RSS |
14a94ebd
MK		 1190 PFVF_CAP_TPA |
1191 PFVF_CAP_TPA_UPDATE);
8ca5e17e
AE		 1192 bnx2x_fill_fw_str(bp, resp->pfdev_info.fw_ver,
1193 sizeof(resp->pfdev_info.fw_ver));
1194
1195 if (status == PFVF_STATUS_NO_RESOURCE ||
1196 status == PFVF_STATUS_SUCCESS) {
1197 /* set resources numbers, if status equals NO_RESOURCE these
1198 * are max possible numbers
1199 */
1200 resc->num_rxqs = vf_rxq_count(vf) ? :
1201 bnx2x_vf_max_queue_cnt(bp, vf);
1202 resc->num_txqs = vf_txq_count(vf) ? :
1203 bnx2x_vf_max_queue_cnt(bp, vf);
1204 resc->num_sbs = vf_sb_count(vf);
1205 resc->num_mac_filters = vf_mac_rules_cnt(vf);
1a3d9424 1206 resc->num_vlan_filters = vf_vlan_rules_visible_cnt(vf);
8ca5e17e
AE		 1207 resc->num_mc_filters = 0;
1208
1209 if (status == PFVF_STATUS_SUCCESS) {
abc5a021
AE		 1210 /* fill in the allocated resources */
1211 struct pf_vf_bulletin_content *bulletin =
1212 BP_VF_BULLETIN(bp, vf->index);
1213
8ca5e17e
AE		 1214 for_each_vfq(vf, i)
1215 resc->hw_qid[i] =
1216 vfq_qzone_id(vf, vfq_get(vf, i));
1217
1218 for_each_vf_sb(vf, i) {
1219 resc->hw_sbs[i].hw_sb_id = vf_igu_sb(vf, i);
1220 resc->hw_sbs[i].sb_qid = vf_hc_qzone(vf, i);
1221 }
abc5a021
AE		 1222
1223 /* if a mac has been set for this vf, supply it */
1224 if (bulletin->valid_bitmap & 1 << MAC_ADDR_VALID) {
1225 memcpy(resc->current_mac_addr, bulletin->mac,
1226 ETH_ALEN);
1227 }
8ca5e17e
AE		 1228 }
1229 }
1230
1231 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"
1232 "resources- n_rxq-%d, n_txq-%d, n_sbs-%d, n_macs-%d, n_vlans-%d, n_mcs-%d, fw_ver: '%s'\n",
1233 vf->abs_vfid,
1234 resp->pfdev_info.chip_num,
1235 resp->pfdev_info.db_size,
1236 resp->pfdev_info.indices_per_sb,
1237 resp->pfdev_info.pf_cap,
1238 resc->num_rxqs,
1239 resc->num_txqs,
1240 resc->num_sbs,
1241 resc->num_mac_filters,
1242 resc->num_vlan_filters,
1243 resc->num_mc_filters,
1244 resp->pfdev_info.fw_ver);
1245
1246 DP_CONT(BNX2X_MSG_IOV, "hw_qids- [ ");
1247 for (i = 0; i < vf_rxq_count(vf); i++)
1248 DP_CONT(BNX2X_MSG_IOV, "%d ", resc->hw_qid[i]);
1249 DP_CONT(BNX2X_MSG_IOV, "], sb_info- [ ");
1250 for (i = 0; i < vf_sb_count(vf); i++)
1251 DP_CONT(BNX2X_MSG_IOV, "%d:%d ",
1252 resc->hw_sbs[i].hw_sb_id,
1253 resc->hw_sbs[i].sb_qid);
1254 DP_CONT(BNX2X_MSG_IOV, "]\n");
1255
3d7d562c
YM		 1256 /* prepare response */
1257 length = sizeof(struct pfvf_acquire_resp_tlv);
1258 bnx2x_add_tlv(bp, &mbx->msg->resp, 0, CHANNEL_TLV_ACQUIRE, length);
1259
1260 /* Handle possible VF requests for physical port identifiers.
1261 * 'length' should continue to indicate the offset of the first empty
1262 * place in the buffer (i.e., where next TLV should be inserted)
1263 */
1264 if (bnx2x_search_tlv_list(bp, &mbx->msg->req,
1265 CHANNEL_TLV_PHYS_PORT_ID))
1266 bnx2x_vf_mbx_resp_phys_port(bp, vf, &mbx->msg->resp, &length);
1267
02dc4025
YM		 1268 /* `New' vfs will want to know if fastpath HSI is supported, since
1269 * if that's not the case they could print into system log the fact
1270 * the driver version must be updated.
1271 */
1272 bnx2x_vf_mbx_resp_fp_hsi_ver(bp, vf, &mbx->msg->resp, &length);
1273
3d7d562c
YM		 1274 bnx2x_add_tlv(bp, &mbx->msg->resp, length, CHANNEL_TLV_LIST_END,
1275 sizeof(struct channel_list_end_tlv));
1276
8ca5e17e 1277 /* send the response */
2dc33bbc 1278 bnx2x_vf_mbx_resp_send_msg(bp, vf, vfop_status);
8ca5e17e
AE		 1279}
1280
ebf457f9
YM		 1281static bool bnx2x_vf_mbx_is_windows_vm(struct bnx2x *bp,
1282 struct vfpf_acquire_tlv *acquire)
1283{
1284 /* Windows driver does one of three things:
1285 * 1. Old driver doesn't have bulletin board address set.
1286 * 2. 'Middle' driver sends mc_num == 32.
1287 * 3. New driver sets the OS field.
1288 */
1289 if (!acquire->bulletin_addr ||
1290 acquire->resc_request.num_mc_filters == 32 ||
1291 ((acquire->vfdev_info.vf_os & VF_OS_MASK) ==
1292 VF_OS_WINDOWS))
1293 return true;
1294
1295 return false;
1296}
1297
1298static int bnx2x_vf_mbx_acquire_chk_dorq(struct bnx2x *bp,
1299 struct bnx2x_virtf *vf,
1300 struct bnx2x_vf_mbx *mbx)
1301{
1302 /* Linux drivers which correctly set the doorbell size also
1303 * send a physical port request
1304 */
1305 if (bnx2x_search_tlv_list(bp, &mbx->msg->req,
1306 CHANNEL_TLV_PHYS_PORT_ID))
1307 return 0;
1308
1309 /* Issue does not exist in windows VMs */
1310 if (bnx2x_vf_mbx_is_windows_vm(bp, &mbx->msg->req.acquire))
1311 return 0;
1312
1313 return -EOPNOTSUPP;
1314}
1315
8ca5e17e
AE		 1316static void bnx2x_vf_mbx_acquire(struct bnx2x *bp, struct bnx2x_virtf *vf,
1317 struct bnx2x_vf_mbx *mbx)
1318{
1319 int rc;
1320 struct vfpf_acquire_tlv *acquire = &mbx->msg->req.acquire;
1321
1322 /* log vfdef info */
1323 DP(BNX2X_MSG_IOV,
1324 "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",
1325 vf->abs_vfid, acquire->vfdev_info.vf_id, acquire->vfdev_info.vf_os,
1326 acquire->resc_request.num_rxqs, acquire->resc_request.num_txqs,
1327 acquire->resc_request.num_sbs, acquire->resc_request.num_mac_filters,
1328 acquire->resc_request.num_vlan_filters,
1329 acquire->resc_request.num_mc_filters);
1330
ebf457f9
YM		 1331 /* Prevent VFs with old drivers from loading, since they calculate
1332 * CIDs incorrectly requiring a VF-flr [VM reboot] in order to recover
1333 * while being upgraded.
1334 */
1335 rc = bnx2x_vf_mbx_acquire_chk_dorq(bp, vf, mbx);
1336 if (rc) {
1337 DP(BNX2X_MSG_IOV,
1338 "VF [%d] - Can't support acquire request due to doorbell mismatch. Please update VM driver\n",
1339 vf->abs_vfid);
1340 goto out;
02dc4025
YM		 1341 }
1342
1343 /* Verify the VF fastpath HSI can be supported by the loaded FW.
1344 * Linux vfs should be oblivious to changes between v0 and v2.
1345 */
1346 if (bnx2x_vf_mbx_is_windows_vm(bp, &mbx->msg->req.acquire))
1347 vf->fp_hsi = acquire->vfdev_info.fp_hsi_ver;
1348 else
1349 vf->fp_hsi = max_t(u8, acquire->vfdev_info.fp_hsi_ver,
1350 ETH_FP_HSI_VER_2);
1351 if (vf->fp_hsi > ETH_FP_HSI_VERSION) {
1352 DP(BNX2X_MSG_IOV,
1353 "VF [%d] - Can't support acquire request since VF requests a FW version which is too new [%02x > %02x]\n",
1354 vf->abs_vfid, acquire->vfdev_info.fp_hsi_ver,
1355 ETH_FP_HSI_VERSION);
1356 rc = -EINVAL;
1357 goto out;
ebf457f9
YM		 1358 }
1359
8ca5e17e
AE		 1360 /* acquire the resources */
1361 rc = bnx2x_vf_acquire(bp, vf, &acquire->resc_request);
1362
abc5a021
AE		 1363 /* store address of vf's bulletin board */
1364 vf->bulletin_map = acquire->bulletin_addr;
6495d15a
DK		 1365 if (acquire->vfdev_info.caps & VF_CAP_SUPPORT_EXT_BULLETIN) {
1366 DP(BNX2X_MSG_IOV, "VF[%d] supports long bulletin boards\n",
1367 vf->abs_vfid);
1368 vf->cfg_flags |= VF_CFG_EXT_BULLETIN;
1369 } else {
1370 vf->cfg_flags &= ~VF_CFG_EXT_BULLETIN;
1371 }
abc5a021 1372
ebf457f9 1373out:
8ca5e17e
AE		 1374 /* response */
1375 bnx2x_vf_mbx_acquire_resp(bp, vf, mbx, rc);
1376}
1377
b93288d5
AE		 1378static void bnx2x_vf_mbx_init_vf(struct bnx2x *bp, struct bnx2x_virtf *vf,
1379 struct bnx2x_vf_mbx *mbx)
1380{
1381 struct vfpf_init_tlv *init = &mbx->msg->req.init;
2dc33bbc 1382 int rc;
b93288d5
AE		 1383
1384 /* record ghost addresses from vf message */
1385 vf->spq_map = init->spq_addr;
1386 vf->fw_stat_map = init->stats_addr;
b9871bcf 1387 vf->stats_stride = init->stats_stride;
2dc33bbc 1388 rc = bnx2x_vf_init(bp, vf, (dma_addr_t *)init->sb_addr);
b93288d5 1389
b9871bcf
AE		 1390 /* set VF multiqueue statistics collection mode */
1391 if (init->flags & VFPF_INIT_FLG_STATS_COALESCE)
1392 vf->cfg_flags |= VF_CFG_STATS_COALESCE;
1393
6495d15a
DK		 1394 /* Update VF's view of link state */
1395 if (vf->cfg_flags & VF_CFG_EXT_BULLETIN)
1396 bnx2x_iov_link_update_vf(bp, vf->index);
1397
b93288d5 1398 /* response */
2dc33bbc 1399 bnx2x_vf_mbx_resp(bp, vf, rc);
b93288d5
AE		 1400}
1401
8db573ba 1402/* convert MBX queue-flags to standard SP queue-flags */
21776537 1403static void bnx2x_vf_mbx_set_q_flags(struct bnx2x *bp, u32 mbx_q_flags,
8db573ba
AE		 1404 unsigned long *sp_q_flags)
1405{
1406 if (mbx_q_flags & VFPF_QUEUE_FLG_TPA)
1407 __set_bit(BNX2X_Q_FLG_TPA, sp_q_flags);
1408 if (mbx_q_flags & VFPF_QUEUE_FLG_TPA_IPV6)
1409 __set_bit(BNX2X_Q_FLG_TPA_IPV6, sp_q_flags);
1410 if (mbx_q_flags & VFPF_QUEUE_FLG_TPA_GRO)
1411 __set_bit(BNX2X_Q_FLG_TPA_GRO, sp_q_flags);
1412 if (mbx_q_flags & VFPF_QUEUE_FLG_STATS)
1413 __set_bit(BNX2X_Q_FLG_STATS, sp_q_flags);
8db573ba
AE		 1414 if (mbx_q_flags & VFPF_QUEUE_FLG_VLAN)
1415 __set_bit(BNX2X_Q_FLG_VLAN, sp_q_flags);
1416 if (mbx_q_flags & VFPF_QUEUE_FLG_COS)
1417 __set_bit(BNX2X_Q_FLG_COS, sp_q_flags);
1418 if (mbx_q_flags & VFPF_QUEUE_FLG_HC)
1419 __set_bit(BNX2X_Q_FLG_HC, sp_q_flags);
1420 if (mbx_q_flags & VFPF_QUEUE_FLG_DHC)
1421 __set_bit(BNX2X_Q_FLG_DHC, sp_q_flags);
b9871bcf
AE		 1422 if (mbx_q_flags & VFPF_QUEUE_FLG_LEADING_RSS)
1423 __set_bit(BNX2X_Q_FLG_LEADING_RSS, sp_q_flags);
21776537 1424
16a5fd92 1425 /* outer vlan removal is set according to PF's multi function mode */
21776537
AE		 1426 if (IS_MF_SD(bp))
1427 __set_bit(BNX2X_Q_FLG_OV, sp_q_flags);
8db573ba
AE		 1428}
1429
1430static void bnx2x_vf_mbx_setup_q(struct bnx2x *bp, struct bnx2x_virtf *vf,
1431 struct bnx2x_vf_mbx *mbx)
1432{
1433 struct vfpf_setup_q_tlv *setup_q = &mbx->msg->req.setup_q;
2dc33bbc
YM		 1434 struct bnx2x_vf_queue_construct_params qctor;
1435 int rc = 0;
8db573ba
AE		 1436
1437 /* verify vf_qid */
1438 if (setup_q->vf_qid >= vf_rxq_count(vf)) {
1439 BNX2X_ERR("vf_qid %d invalid, max queue count is %d\n",
1440 setup_q->vf_qid, vf_rxq_count(vf));
2dc33bbc 1441 rc = -EINVAL;
8db573ba
AE		 1442 goto response;
1443 }
1444
1445 /* tx queues must be setup alongside rx queues thus if the rx queue
1446 * is not marked as valid there's nothing to do.
1447 */
1448 if (setup_q->param_valid & (VFPF_RXQ_VALID|VFPF_TXQ_VALID)) {
1449 struct bnx2x_vf_queue *q = vfq_get(vf, setup_q->vf_qid);
1450 unsigned long q_type = 0;
1451
1452 struct bnx2x_queue_init_params *init_p;
1453 struct bnx2x_queue_setup_params *setup_p;
1454
b9871bcf
AE		 1455 if (bnx2x_vfq_is_leading(q))
1456 bnx2x_leading_vfq_init(bp, vf, q);
1457
16a5fd92 1458 /* re-init the VF operation context */
2dc33bbc
YM		 1459 memset(&qctor, 0 ,
1460 sizeof(struct bnx2x_vf_queue_construct_params));
1461 setup_p = &qctor.prep_qsetup;
1462 init_p = &qctor.qstate.params.init;
8db573ba
AE		 1463
1464 /* activate immediately */
1465 __set_bit(BNX2X_Q_FLG_ACTIVE, &setup_p->flags);
1466
1467 if (setup_q->param_valid & VFPF_TXQ_VALID) {
1468 struct bnx2x_txq_setup_params *txq_params =
1469 &setup_p->txq_params;
1470
1471 __set_bit(BNX2X_Q_TYPE_HAS_TX, &q_type);
1472
1473 /* save sb resource index */
1474 q->sb_idx = setup_q->txq.vf_sb;
1475
1476 /* tx init */
1477 init_p->tx.hc_rate = setup_q->txq.hc_rate;
1478 init_p->tx.sb_cq_index = setup_q->txq.sb_index;
1479
21776537 1480 bnx2x_vf_mbx_set_q_flags(bp, setup_q->txq.flags,
8db573ba
AE		 1481 &init_p->tx.flags);
1482
1483 /* tx setup - flags */
21776537 1484 bnx2x_vf_mbx_set_q_flags(bp, setup_q->txq.flags,
8db573ba
AE		 1485 &setup_p->flags);
1486
1487 /* tx setup - general, nothing */
1488
1489 /* tx setup - tx */
1490 txq_params->dscr_map = setup_q->txq.txq_addr;
1491 txq_params->sb_cq_index = setup_q->txq.sb_index;
1492 txq_params->traffic_type = setup_q->txq.traffic_type;
1493
1494 bnx2x_vfop_qctor_dump_tx(bp, vf, init_p, setup_p,
1495 q->index, q->sb_idx);
1496 }
1497
1498 if (setup_q->param_valid & VFPF_RXQ_VALID) {
1499 struct bnx2x_rxq_setup_params *rxq_params =
1500 &setup_p->rxq_params;
1501
1502 __set_bit(BNX2X_Q_TYPE_HAS_RX, &q_type);
1503
1504 /* Note: there is no support for different SBs
1505 * for TX and RX
1506 */
1507 q->sb_idx = setup_q->rxq.vf_sb;
1508
1509 /* rx init */
1510 init_p->rx.hc_rate = setup_q->rxq.hc_rate;
1511 init_p->rx.sb_cq_index = setup_q->rxq.sb_index;
21776537 1512 bnx2x_vf_mbx_set_q_flags(bp, setup_q->rxq.flags,
8db573ba
AE		 1513 &init_p->rx.flags);
1514
1515 /* rx setup - flags */
21776537 1516 bnx2x_vf_mbx_set_q_flags(bp, setup_q->rxq.flags,
8db573ba
AE		 1517 &setup_p->flags);
1518
1519 /* rx setup - general */
1520 setup_p->gen_params.mtu = setup_q->rxq.mtu;
1521
1522 /* rx setup - rx */
1523 rxq_params->drop_flags = setup_q->rxq.drop_flags;
1524 rxq_params->dscr_map = setup_q->rxq.rxq_addr;
1525 rxq_params->sge_map = setup_q->rxq.sge_addr;
1526 rxq_params->rcq_map = setup_q->rxq.rcq_addr;
1527 rxq_params->rcq_np_map = setup_q->rxq.rcq_np_addr;
1528 rxq_params->buf_sz = setup_q->rxq.buf_sz;
1529 rxq_params->tpa_agg_sz = setup_q->rxq.tpa_agg_sz;
1530 rxq_params->max_sges_pkt = setup_q->rxq.max_sge_pkt;
1531 rxq_params->sge_buf_sz = setup_q->rxq.sge_buf_sz;
1532 rxq_params->cache_line_log =
1533 setup_q->rxq.cache_line_log;
1534 rxq_params->sb_cq_index = setup_q->rxq.sb_index;
1535
858f4deb
YM		 1536 /* rx setup - multicast engine */
1537 if (bnx2x_vfq_is_leading(q)) {
1538 u8 mcast_id = FW_VF_HANDLE(vf->abs_vfid);
1539
1540 rxq_params->mcast_engine_id = mcast_id;
1541 __set_bit(BNX2X_Q_FLG_MCAST, &setup_p->flags);
1542 }
1543
8db573ba
AE		 1544 bnx2x_vfop_qctor_dump_rx(bp, vf, init_p, setup_p,
1545 q->index, q->sb_idx);
1546 }
1547 /* complete the preparations */
2dc33bbc 1548 bnx2x_vfop_qctor_prep(bp, vf, q, &qctor, q_type);
8db573ba 1549
2dc33bbc
YM		 1550 rc = bnx2x_vf_queue_setup(bp, vf, q->index, &qctor);
1551 if (rc)
8db573ba 1552 goto response;
8db573ba
AE		 1553 }
1554response:
2dc33bbc 1555 bnx2x_vf_mbx_resp(bp, vf, rc);
8db573ba
AE		 1556}
1557
954ea748
AE		 1558static int bnx2x_vf_mbx_macvlan_list(struct bnx2x *bp,
1559 struct bnx2x_virtf *vf,
1560 struct vfpf_set_q_filters_tlv *tlv,
2dc33bbc 1561 struct bnx2x_vf_mac_vlan_filters **pfl,
954ea748
AE		 1562 u32 type_flag)
1563{
1564 int i, j;
2dc33bbc 1565 struct bnx2x_vf_mac_vlan_filters *fl = NULL;
954ea748
AE		 1566 size_t fsz;
1567
2dc33bbc
YM		 1568 fsz = tlv->n_mac_vlan_filters *
1569 sizeof(struct bnx2x_vf_mac_vlan_filter) +
1570 sizeof(struct bnx2x_vf_mac_vlan_filters);
954ea748
AE		 1571
1572 fl = kzalloc(fsz, GFP_KERNEL);
1573 if (!fl)
1574 return -ENOMEM;
1575
954ea748
AE		 1576 for (i = 0, j = 0; i < tlv->n_mac_vlan_filters; i++) {
1577 struct vfpf_q_mac_vlan_filter *msg_filter = &tlv->filters[i];
1578
1579 if ((msg_filter->flags & type_flag) != type_flag)
1580 continue;
1581 if (type_flag == VFPF_Q_FILTER_DEST_MAC_VALID) {
1582 fl->filters[j].mac = msg_filter->mac;
2dc33bbc 1583 fl->filters[j].type = BNX2X_VF_FILTER_MAC;
954ea748
AE		 1584 } else {
1585 fl->filters[j].vid = msg_filter->vlan_tag;
2dc33bbc 1586 fl->filters[j].type = BNX2X_VF_FILTER_VLAN;
954ea748
AE		 1587 }
1588 fl->filters[j].add =
1589 (msg_filter->flags & VFPF_Q_FILTER_SET_MAC) ?
1590 true : false;
2dc33bbc 1591 fl->count++;
954ea748 1592 }
2dc33bbc 1593 if (!fl->count)
954ea748
AE		 1594 kfree(fl);
1595 else
1596 *pfl = fl;
1597
1598 return 0;
1599}
1600
1601static void bnx2x_vf_mbx_dp_q_filter(struct bnx2x *bp, int msglvl, int idx,
1602 struct vfpf_q_mac_vlan_filter *filter)
1603{
1604 DP(msglvl, "MAC-VLAN[%d] -- flags=0x%x\n", idx, filter->flags);
1605 if (filter->flags & VFPF_Q_FILTER_VLAN_TAG_VALID)
1606 DP_CONT(msglvl, ", vlan=%d", filter->vlan_tag);
1607 if (filter->flags & VFPF_Q_FILTER_DEST_MAC_VALID)
1608 DP_CONT(msglvl, ", MAC=%pM", filter->mac);
1609 DP_CONT(msglvl, "\n");
1610}
1611
1612static void bnx2x_vf_mbx_dp_q_filters(struct bnx2x *bp, int msglvl,
1613 struct vfpf_set_q_filters_tlv *filters)
1614{
1615 int i;
1616
1617 if (filters->flags & VFPF_SET_Q_FILTERS_MAC_VLAN_CHANGED)
1618 for (i = 0; i < filters->n_mac_vlan_filters; i++)
1619 bnx2x_vf_mbx_dp_q_filter(bp, msglvl, i,
1620 &filters->filters[i]);
1621
1622 if (filters->flags & VFPF_SET_Q_FILTERS_RX_MASK_CHANGED)
1623 DP(msglvl, "RX-MASK=0x%x\n", filters->rx_mask);
1624
1625 if (filters->flags & VFPF_SET_Q_FILTERS_MULTICAST_CHANGED)
1626 for (i = 0; i < filters->n_multicast; i++)
1627 DP(msglvl, "MULTICAST=%pM\n", filters->multicast[i]);
1628}
1629
1630#define VFPF_MAC_FILTER VFPF_Q_FILTER_DEST_MAC_VALID
1631#define VFPF_VLAN_FILTER VFPF_Q_FILTER_VLAN_TAG_VALID
1632
2dc33bbc 1633static int bnx2x_vf_mbx_qfilters(struct bnx2x *bp, struct bnx2x_virtf *vf)
954ea748 1634{
2dc33bbc 1635 int rc = 0;
954ea748
AE		 1636
1637 struct vfpf_set_q_filters_tlv *msg =
1638 &BP_VF_MBX(bp, vf->index)->msg->req.set_q_filters;
1639
2dc33bbc
YM		 1640 /* check for any mac/vlan changes */
1641 if (msg->flags & VFPF_SET_Q_FILTERS_MAC_VLAN_CHANGED) {
1642 /* build mac list */
1643 struct bnx2x_vf_mac_vlan_filters *fl = NULL;
954ea748 1644
2dc33bbc
YM		 1645 rc = bnx2x_vf_mbx_macvlan_list(bp, vf, msg, &fl,
1646 VFPF_MAC_FILTER);
1647 if (rc)
1648 goto op_err;
954ea748 1649
2dc33bbc 1650 if (fl) {
954ea748 1651
2dc33bbc
YM		 1652 /* set mac list */
1653 rc = bnx2x_vf_mac_vlan_config_list(bp, vf, fl,
1654 msg->vf_qid,
1655 false);
1656 if (rc)
954ea748 1657 goto op_err;
954ea748 1658 }
954ea748 1659
2dc33bbc
YM		 1660 /* build vlan list */
1661 fl = NULL;
954ea748 1662
2dc33bbc
YM		 1663 rc = bnx2x_vf_mbx_macvlan_list(bp, vf, msg, &fl,
1664 VFPF_VLAN_FILTER);
1665 if (rc)
1666 goto op_err;
1667
1668 if (fl) {
1669 /* set vlan list */
1670 rc = bnx2x_vf_mac_vlan_config_list(bp, vf, fl,
1671 msg->vf_qid,
1672 false);
1673 if (rc)
954ea748 1674 goto op_err;
954ea748 1675 }
2dc33bbc 1676 }
954ea748 1677
2dc33bbc
YM		 1678 if (msg->flags & VFPF_SET_Q_FILTERS_RX_MASK_CHANGED) {
1679 unsigned long accept = 0;
1680 struct pf_vf_bulletin_content *bulletin =
1681 BP_VF_BULLETIN(bp, vf->index);
954ea748 1682
16bd41dd
YM		 1683 /* Ignore VF requested mode; instead set a regular mode */
1684 if (msg->rx_mask != VFPF_RX_MASK_ACCEPT_NONE) {
2dc33bbc 1685 __set_bit(BNX2X_ACCEPT_UNICAST, &accept);
2dc33bbc 1686 __set_bit(BNX2X_ACCEPT_MULTICAST, &accept);
2dc33bbc 1687 __set_bit(BNX2X_ACCEPT_BROADCAST, &accept);
16bd41dd 1688 }
954ea748 1689
2dc33bbc
YM		 1690 /* A packet arriving the vf's mac should be accepted
1691 * with any vlan, unless a vlan has already been
1692 * configured.
1693 */
1694 if (!(bulletin->valid_bitmap & (1 << VLAN_VALID)))
1695 __set_bit(BNX2X_ACCEPT_ANY_VLAN, &accept);
954ea748 1696
2dc33bbc
YM		 1697 /* set rx-mode */
1698 rc = bnx2x_vf_rxmode(bp, vf, msg->vf_qid, accept);
1699 if (rc)
1700 goto op_err;
954ea748 1701 }
954ea748 1702
2dc33bbc
YM		 1703 if (msg->flags & VFPF_SET_Q_FILTERS_MULTICAST_CHANGED) {
1704 /* set mcasts */
1705 rc = bnx2x_vf_mcast(bp, vf, msg->multicast,
1706 msg->n_multicast, false);
1707 if (rc)
1708 goto op_err;
954ea748 1709 }
2dc33bbc
YM		 1710op_err:
1711 if (rc)
1712 BNX2X_ERR("QFILTERS[%d:%d] error: rc %d\n",
1713 vf->abs_vfid, msg->vf_qid, rc);
1714 return rc;
954ea748
AE		 1715}
1716
ba72f32c
YM		 1717static int bnx2x_filters_validate_mac(struct bnx2x *bp,
1718 struct bnx2x_virtf *vf,
1719 struct vfpf_set_q_filters_tlv *filters)
954ea748 1720{
abc5a021 1721 struct pf_vf_bulletin_content *bulletin = BP_VF_BULLETIN(bp, vf->index);
ba72f32c 1722 int rc = 0;
954ea748 1723
abc5a021
AE		 1724 /* if a mac was already set for this VF via the set vf mac ndo, we only
1725 * accept mac configurations of that mac. Why accept them at all?
1726 * because PF may have been unable to configure the mac at the time
1727 * since queue was not set up.
1728 */
1729 if (bulletin->valid_bitmap & 1 << MAC_ADDR_VALID) {
1730 /* once a mac was set by ndo can only accept a single mac... */
1731 if (filters->n_mac_vlan_filters > 1) {
1732 BNX2X_ERR("VF[%d] requested the addition of multiple macs after set_vf_mac ndo was called\n",
1733 vf->abs_vfid);
ba72f32c 1734 rc = -EPERM;
abc5a021
AE		 1735 goto response;
1736 }
1737
1738 /* ...and only the mac set by the ndo */
1739 if (filters->n_mac_vlan_filters == 1 &&
8fd90de8 1740 !ether_addr_equal(filters->filters->mac, bulletin->mac)) {
abc5a021
AE		 1741 BNX2X_ERR("VF[%d] requested the addition of a mac address not matching the one configured by set_vf_mac ndo\n",
1742 vf->abs_vfid);
1743
ba72f32c 1744 rc = -EPERM;
abc5a021
AE		 1745 goto response;
1746 }
1747 }
ba72f32c
YM		 1748
1749response:
1750 return rc;
1751}
1752
1753static int bnx2x_filters_validate_vlan(struct bnx2x *bp,
1754 struct bnx2x_virtf *vf,
1755 struct vfpf_set_q_filters_tlv *filters)
1756{
1757 struct pf_vf_bulletin_content *bulletin = BP_VF_BULLETIN(bp, vf->index);
1758 int rc = 0;
1759
e8379c79
YM		 1760 /* if vlan was set by hypervisor we don't allow guest to config vlan */
1761 if (bulletin->valid_bitmap & 1 << VLAN_VALID) {
1762 int i;
1763
1764 /* search for vlan filters */
1765 for (i = 0; i < filters->n_mac_vlan_filters; i++) {
1766 if (filters->filters[i].flags &
1767 VFPF_Q_FILTER_VLAN_TAG_VALID) {
1768 BNX2X_ERR("VF[%d] attempted to configure vlan but one was already set by Hypervisor. Aborting request\n",
1769 vf->abs_vfid);
ba72f32c 1770 rc = -EPERM;
e8379c79
YM		 1771 goto response;
1772 }
1773 }
1774 }
abc5a021 1775
954ea748 1776 /* verify vf_qid */
ba72f32c
YM		 1777 if (filters->vf_qid > vf_rxq_count(vf)) {
1778 rc = -EPERM;
1779 goto response;
1780 }
1781
1782response:
1783 return rc;
1784}
1785
1786static void bnx2x_vf_mbx_set_q_filters(struct bnx2x *bp,
1787 struct bnx2x_virtf *vf,
1788 struct bnx2x_vf_mbx *mbx)
1789{
1790 struct vfpf_set_q_filters_tlv *filters = &mbx->msg->req.set_q_filters;
2dc33bbc 1791 int rc;
ba72f32c 1792
2dc33bbc
YM		 1793 rc = bnx2x_filters_validate_mac(bp, vf, filters);
1794 if (rc)
ba72f32c
YM		 1795 goto response;
1796
2dc33bbc
YM		 1797 rc = bnx2x_filters_validate_vlan(bp, vf, filters);
1798 if (rc)
954ea748
AE		 1799 goto response;
1800
1801 DP(BNX2X_MSG_IOV, "VF[%d] Q_FILTERS: queue[%d]\n",
1802 vf->abs_vfid,
1803 filters->vf_qid);
1804
1805 /* print q_filter message */
1806 bnx2x_vf_mbx_dp_q_filters(bp, BNX2X_MSG_IOV, filters);
1807
2dc33bbc 1808 rc = bnx2x_vf_mbx_qfilters(bp, vf);
954ea748 1809response:
2dc33bbc 1810 bnx2x_vf_mbx_resp(bp, vf, rc);
954ea748
AE		 1811}
1812
463a68a7
AE		 1813static void bnx2x_vf_mbx_teardown_q(struct bnx2x *bp, struct bnx2x_virtf *vf,
1814 struct bnx2x_vf_mbx *mbx)
1815{
1816 int qid = mbx->msg->req.q_op.vf_qid;
2dc33bbc 1817 int rc;
463a68a7
AE		 1818
1819 DP(BNX2X_MSG_IOV, "VF[%d] Q_TEARDOWN: vf_qid=%d\n",
1820 vf->abs_vfid, qid);
1821
2dc33bbc
YM		 1822 rc = bnx2x_vf_queue_teardown(bp, vf, qid);
1823 bnx2x_vf_mbx_resp(bp, vf, rc);
463a68a7
AE		 1824}
1825
99e9d211
AE		 1826static void bnx2x_vf_mbx_close_vf(struct bnx2x *bp, struct bnx2x_virtf *vf,
1827 struct bnx2x_vf_mbx *mbx)
1828{
2dc33bbc 1829 int rc;
99e9d211
AE		 1830
1831 DP(BNX2X_MSG_IOV, "VF[%d] VF_CLOSE\n", vf->abs_vfid);
1832
2dc33bbc
YM		 1833 rc = bnx2x_vf_close(bp, vf);
1834 bnx2x_vf_mbx_resp(bp, vf, rc);
99e9d211
AE		 1835}
1836
f1929b01
AE		 1837static void bnx2x_vf_mbx_release_vf(struct bnx2x *bp, struct bnx2x_virtf *vf,
1838 struct bnx2x_vf_mbx *mbx)
1839{
2dc33bbc 1840 int rc;
f1929b01
AE		 1841
1842 DP(BNX2X_MSG_IOV, "VF[%d] VF_RELEASE\n", vf->abs_vfid);
1843
2dc33bbc
YM		 1844 rc = bnx2x_vf_free(bp, vf);
1845 bnx2x_vf_mbx_resp(bp, vf, rc);
f1929b01
AE		 1846}
1847
b9871bcf
AE		 1848static void bnx2x_vf_mbx_update_rss(struct bnx2x *bp, struct bnx2x_virtf *vf,
1849 struct bnx2x_vf_mbx *mbx)
1850{
2dc33bbc 1851 struct bnx2x_config_rss_params rss;
b9871bcf 1852 struct vfpf_rss_tlv *rss_tlv = &mbx->msg->req.update_rss;
2dc33bbc 1853 int rc = 0;
b9871bcf
AE		 1854
1855 if (rss_tlv->ind_table_size != T_ETH_INDIRECTION_TABLE_SIZE ||
1856 rss_tlv->rss_key_size != T_ETH_RSS_KEY) {
1857 BNX2X_ERR("failing rss configuration of vf %d due to size mismatch\n",
1858 vf->index);
2dc33bbc 1859 rc = -EINVAL;
b9871bcf
AE		 1860 goto mbx_resp;
1861 }
1862
2dc33bbc
YM		 1863 memset(&rss, 0, sizeof(struct bnx2x_config_rss_params));
1864
b9871bcf 1865 /* set vfop params according to rss tlv */
2dc33bbc 1866 memcpy(rss.ind_table, rss_tlv->ind_table,
b9871bcf 1867 T_ETH_INDIRECTION_TABLE_SIZE);
2dc33bbc
YM		 1868 memcpy(rss.rss_key, rss_tlv->rss_key, sizeof(rss_tlv->rss_key));
1869 rss.rss_obj = &vf->rss_conf_obj;
1870 rss.rss_result_mask = rss_tlv->rss_result_mask;
b9871bcf 1871
dbedd44e 1872 /* flags handled individually for backward/forward compatibility */
2dc33bbc
YM		 1873 rss.rss_flags = 0;
1874 rss.ramrod_flags = 0;
5b622918 1875
b9871bcf 1876 if (rss_tlv->rss_flags & VFPF_RSS_MODE_DISABLED)
2dc33bbc 1877 __set_bit(BNX2X_RSS_MODE_DISABLED, &rss.rss_flags);
b9871bcf 1878 if (rss_tlv->rss_flags & VFPF_RSS_MODE_REGULAR)
2dc33bbc 1879 __set_bit(BNX2X_RSS_MODE_REGULAR, &rss.rss_flags);
b9871bcf 1880 if (rss_tlv->rss_flags & VFPF_RSS_SET_SRCH)
2dc33bbc 1881 __set_bit(BNX2X_RSS_SET_SRCH, &rss.rss_flags);
b9871bcf 1882 if (rss_tlv->rss_flags & VFPF_RSS_IPV4)
2dc33bbc 1883 __set_bit(BNX2X_RSS_IPV4, &rss.rss_flags);
b9871bcf 1884 if (rss_tlv->rss_flags & VFPF_RSS_IPV4_TCP)
2dc33bbc 1885 __set_bit(BNX2X_RSS_IPV4_TCP, &rss.rss_flags);
b9871bcf 1886 if (rss_tlv->rss_flags & VFPF_RSS_IPV4_UDP)
2dc33bbc 1887 __set_bit(BNX2X_RSS_IPV4_UDP, &rss.rss_flags);
b9871bcf 1888 if (rss_tlv->rss_flags & VFPF_RSS_IPV6)
2dc33bbc 1889 __set_bit(BNX2X_RSS_IPV6, &rss.rss_flags);
b9871bcf 1890 if (rss_tlv->rss_flags & VFPF_RSS_IPV6_TCP)
2dc33bbc 1891 __set_bit(BNX2X_RSS_IPV6_TCP, &rss.rss_flags);
b9871bcf 1892 if (rss_tlv->rss_flags & VFPF_RSS_IPV6_UDP)
2dc33bbc 1893 __set_bit(BNX2X_RSS_IPV6_UDP, &rss.rss_flags);
b9871bcf
AE		 1894
1895 if ((!(rss_tlv->rss_flags & VFPF_RSS_IPV4_TCP) &&
1896 rss_tlv->rss_flags & VFPF_RSS_IPV4_UDP) ||
1897 (!(rss_tlv->rss_flags & VFPF_RSS_IPV6_TCP) &&
1898 rss_tlv->rss_flags & VFPF_RSS_IPV6_UDP)) {
1899 BNX2X_ERR("about to hit a FW assert. aborting...\n");
2dc33bbc 1900 rc = -EINVAL;
b9871bcf
AE		 1901 goto mbx_resp;
1902 }
1903
2dc33bbc 1904 rc = bnx2x_vf_rss_update(bp, vf, &rss);
b9871bcf 1905mbx_resp:
2dc33bbc 1906 bnx2x_vf_mbx_resp(bp, vf, rc);
b9871bcf
AE		 1907}
1908
14a94ebd
MK		 1909static int bnx2x_validate_tpa_params(struct bnx2x *bp,
1910 struct vfpf_tpa_tlv *tpa_tlv)
1911{
1912 int rc = 0;
1913
1914 if (tpa_tlv->tpa_client_info.max_sges_for_packet >
1915 U_ETH_MAX_SGES_FOR_PACKET) {
1916 rc = -EINVAL;
1917 BNX2X_ERR("TPA update: max_sges received %d, max is %d\n",
1918 tpa_tlv->tpa_client_info.max_sges_for_packet,
1919 U_ETH_MAX_SGES_FOR_PACKET);
1920 }
1921
1922 if (tpa_tlv->tpa_client_info.max_tpa_queues > MAX_AGG_QS(bp)) {
1923 rc = -EINVAL;
1924 BNX2X_ERR("TPA update: max_tpa_queues received %d, max is %d\n",
1925 tpa_tlv->tpa_client_info.max_tpa_queues,
1926 MAX_AGG_QS(bp));
1927 }
1928
1929 return rc;
1930}
1931
1932static void bnx2x_vf_mbx_update_tpa(struct bnx2x *bp, struct bnx2x_virtf *vf,
1933 struct bnx2x_vf_mbx *mbx)
1934{
2dc33bbc 1935 struct bnx2x_queue_update_tpa_params vf_op_params;
14a94ebd 1936 struct vfpf_tpa_tlv *tpa_tlv = &mbx->msg->req.update_tpa;
2dc33bbc 1937 int rc = 0;
14a94ebd 1938
2dc33bbc 1939 memset(&vf_op_params, 0, sizeof(vf_op_params));
14a94ebd
MK		 1940
1941 if (bnx2x_validate_tpa_params(bp, tpa_tlv))
1942 goto mbx_resp;
1943
2dc33bbc 1944 vf_op_params.complete_on_both_clients =
14a94ebd 1945 tpa_tlv->tpa_client_info.complete_on_both_clients;
2dc33bbc 1946 vf_op_params.dont_verify_thr =
14a94ebd 1947 tpa_tlv->tpa_client_info.dont_verify_thr;
2dc33bbc 1948 vf_op_params.max_agg_sz =
14a94ebd 1949 tpa_tlv->tpa_client_info.max_agg_size;
2dc33bbc 1950 vf_op_params.max_sges_pkt =
14a94ebd 1951 tpa_tlv->tpa_client_info.max_sges_for_packet;
2dc33bbc 1952 vf_op_params.max_tpa_queues =
14a94ebd 1953 tpa_tlv->tpa_client_info.max_tpa_queues;
2dc33bbc 1954 vf_op_params.sge_buff_sz =
14a94ebd 1955 tpa_tlv->tpa_client_info.sge_buff_size;
2dc33bbc 1956 vf_op_params.sge_pause_thr_high =
14a94ebd 1957 tpa_tlv->tpa_client_info.sge_pause_thr_high;
2dc33bbc 1958 vf_op_params.sge_pause_thr_low =
14a94ebd 1959 tpa_tlv->tpa_client_info.sge_pause_thr_low;
2dc33bbc 1960 vf_op_params.tpa_mode =
14a94ebd 1961 tpa_tlv->tpa_client_info.tpa_mode;
2dc33bbc 1962 vf_op_params.update_ipv4 =
14a94ebd 1963 tpa_tlv->tpa_client_info.update_ipv4;
2dc33bbc 1964 vf_op_params.update_ipv6 =
14a94ebd
MK		 1965 tpa_tlv->tpa_client_info.update_ipv6;
1966
2dc33bbc 1967 rc = bnx2x_vf_tpa_update(bp, vf, tpa_tlv, &vf_op_params);
14a94ebd
MK		 1968
1969mbx_resp:
2dc33bbc 1970 bnx2x_vf_mbx_resp(bp, vf, rc);
14a94ebd
MK		 1971}
1972
fd1fc79d
AE		 1973/* dispatch request */
1974static void bnx2x_vf_mbx_request(struct bnx2x *bp, struct bnx2x_virtf *vf,
1975 struct bnx2x_vf_mbx *mbx)
1976{
1977 int i;
1978
1979 /* check if tlv type is known */
1980 if (bnx2x_tlv_supported(mbx->first_tlv.tl.type)) {
8ca5e17e
AE		 1981 /* Lock the per vf op mutex and note the locker's identity.
1982 * The unlock will take place in mbx response.
1983 */
1984 bnx2x_lock_vf_pf_channel(bp, vf, mbx->first_tlv.tl.type);
1985
fd1fc79d
AE		 1986 /* switch on the opcode */
1987 switch (mbx->first_tlv.tl.type) {
8ca5e17e
AE		 1988 case CHANNEL_TLV_ACQUIRE:
1989 bnx2x_vf_mbx_acquire(bp, vf, mbx);
cbbf77de 1990 return;
b93288d5
AE		 1991 case CHANNEL_TLV_INIT:
1992 bnx2x_vf_mbx_init_vf(bp, vf, mbx);
cbbf77de 1993 return;
8db573ba
AE		 1994 case CHANNEL_TLV_SETUP_Q:
1995 bnx2x_vf_mbx_setup_q(bp, vf, mbx);
cbbf77de 1996 return;
954ea748
AE		 1997 case CHANNEL_TLV_SET_Q_FILTERS:
1998 bnx2x_vf_mbx_set_q_filters(bp, vf, mbx);
cbbf77de 1999 return;
463a68a7
AE		 2000 case CHANNEL_TLV_TEARDOWN_Q:
2001 bnx2x_vf_mbx_teardown_q(bp, vf, mbx);
cbbf77de 2002 return;
99e9d211
AE		 2003 case CHANNEL_TLV_CLOSE:
2004 bnx2x_vf_mbx_close_vf(bp, vf, mbx);
cbbf77de 2005 return;
f1929b01
AE		 2006 case CHANNEL_TLV_RELEASE:
2007 bnx2x_vf_mbx_release_vf(bp, vf, mbx);
cbbf77de 2008 return;
b9871bcf
AE		 2009 case CHANNEL_TLV_UPDATE_RSS:
2010 bnx2x_vf_mbx_update_rss(bp, vf, mbx);
cbbf77de 2011 return;
14a94ebd
MK		 2012 case CHANNEL_TLV_UPDATE_TPA:
2013 bnx2x_vf_mbx_update_tpa(bp, vf, mbx);
2014 return;
fd1fc79d 2015 }
463a68a7 2016
fd1fc79d
AE		 2017 } else {
2018 /* unknown TLV - this may belong to a VF driver from the future
2019 * - a version written after this PF driver was written, which
2020 * supports features unknown as of yet. Too bad since we don't
2021 * support them. Or this may be because someone wrote a crappy
2022 * VF driver and is sending garbage over the channel.
2023 */
6bf07b8e
YM		 2024 BNX2X_ERR("unknown TLV. type %d length %d vf->state was %d. first 20 bytes of mailbox buffer:\n",
2025 mbx->first_tlv.tl.type, mbx->first_tlv.tl.length,
2026 vf->state);
fd1fc79d
AE		 2027 for (i = 0; i < 20; i++)
2028 DP_CONT(BNX2X_MSG_IOV, "%x ",
2029 mbx->msg->req.tlv_buf_size.tlv_buffer[i]);
cbbf77de 2030 }
8ca5e17e 2031
cbbf77de
AE		 2032 /* can we respond to VF (do we have an address for it?) */
2033 if (vf->state == VF_ACQUIRED || vf->state == VF_ENABLED) {
cbbf77de 2034 /* notify the VF that we do not support this request */
2dc33bbc 2035 bnx2x_vf_mbx_resp(bp, vf, PFVF_STATUS_NOT_SUPPORTED);
cbbf77de
AE		 2036 } else {
2037 /* can't send a response since this VF is unknown to us
2038 * just ack the FW to release the mailbox and unlock
2039 * the channel.
2040 */
2041 storm_memset_vf_mbx_ack(bp, vf->abs_vfid);
2042 /* Firmware ack should be written before unlocking channel */
2043 mmiowb();
2044 bnx2x_unlock_vf_pf_channel(bp, vf, mbx->first_tlv.tl.type);
fd1fc79d
AE		 2045 }
2046}
2047
370d4a26
YM		 2048void bnx2x_vf_mbx_schedule(struct bnx2x *bp,
2049 struct vf_pf_event_data *vfpf_event)
fd1fc79d 2050{
fd1fc79d 2051 u8 vf_idx;
fd1fc79d
AE		 2052
2053 DP(BNX2X_MSG_IOV,
2054 "vf pf event received: vfid %d, address_hi %x, address lo %x",
2055 vfpf_event->vf_id, vfpf_event->msg_addr_hi, vfpf_event->msg_addr_lo);
2056 /* Sanity checks consider removing later */
2057
2058 /* check if the vf_id is valid */
2059 if (vfpf_event->vf_id - BP_VFDB(bp)->sriov.first_vf_in_pf >
2060 BNX2X_NR_VIRTFN(bp)) {
2061 BNX2X_ERR("Illegal vf_id %d max allowed: %d\n",
2062 vfpf_event->vf_id, BNX2X_NR_VIRTFN(bp));
370d4a26 2063 return;
fd1fc79d 2064 }
370d4a26 2065
fd1fc79d 2066 vf_idx = bnx2x_vf_idx_by_abs_fid(bp, vfpf_event->vf_id);
fd1fc79d 2067
370d4a26
YM		 2068 /* Update VFDB with current message and schedule its handling */
2069 mutex_lock(&BP_VFDB(bp)->event_mutex);
2070 BP_VF_MBX(bp, vf_idx)->vf_addr_hi = vfpf_event->msg_addr_hi;
2071 BP_VF_MBX(bp, vf_idx)->vf_addr_lo = vfpf_event->msg_addr_lo;
2072 BP_VFDB(bp)->event_occur |= (1ULL << vf_idx);
2073 mutex_unlock(&BP_VFDB(bp)->event_mutex);
fd1fc79d 2074
370d4a26
YM		 2075 bnx2x_schedule_iov_task(bp, BNX2X_IOV_HANDLE_VF_MSG);
2076}
fd1fc79d 2077
370d4a26
YM		 2078/* handle new vf-pf messages */
2079void bnx2x_vf_mbx(struct bnx2x *bp)
2080{
2081 struct bnx2x_vfdb *vfdb = BP_VFDB(bp);
2082 u64 events;
2083 u8 vf_idx;
2084 int rc;
fd1fc79d 2085
370d4a26
YM		 2086 if (!vfdb)
2087 return;
fd1fc79d 2088
370d4a26
YM		 2089 mutex_lock(&vfdb->event_mutex);
2090 events = vfdb->event_occur;
2091 vfdb->event_occur = 0;
2092 mutex_unlock(&vfdb->event_mutex);
3d7d562c 2093
370d4a26
YM		 2094 for_each_vf(bp, vf_idx) {
2095 struct bnx2x_vf_mbx *mbx = BP_VF_MBX(bp, vf_idx);
2096 struct bnx2x_virtf *vf = BP_VF(bp, vf_idx);
fd1fc79d 2097
370d4a26
YM		 2098 /* Handle VFs which have pending events */
2099 if (!(events & (1ULL << vf_idx)))
2100 continue;
2101
2102 DP(BNX2X_MSG_IOV,
2103 "Handling vf pf event vfid %d, address: [%x:%x], resp_offset 0x%x\n",
2104 vf_idx, mbx->vf_addr_hi, mbx->vf_addr_lo,
2105 mbx->first_tlv.resp_msg_offset);
2106
2107 /* dmae to get the VF request */
2108 rc = bnx2x_copy32_vf_dmae(bp, true, mbx->msg_mapping,
2109 vf->abs_vfid, mbx->vf_addr_hi,
2110 mbx->vf_addr_lo,
2111 sizeof(union vfpf_tlvs)/4);
2112 if (rc) {
2113 BNX2X_ERR("Failed to copy request VF %d\n",
2114 vf->abs_vfid);
2dc33bbc 2115 bnx2x_vf_release(bp, vf);
370d4a26
YM		 2116 return;
2117 }
2118
2119 /* process the VF message header */
2120 mbx->first_tlv = mbx->msg->req.first_tlv;
2121
2122 /* Clean response buffer to refrain from falsely
2123 * seeing chains.
2124 */
2125 memset(&mbx->msg->resp, 0, sizeof(union pfvf_tlvs));
2126
2127 /* dispatch the request (will prepare the response) */
2128 bnx2x_vf_mbx_request(bp, vf, mbx);
2129 }
fd1fc79d 2130}
abc5a021 2131
6495d15a
DK		 2132void bnx2x_vf_bulletin_finalize(struct pf_vf_bulletin_content *bulletin,
2133 bool support_long)
2134{
2135 /* Older VFs contain a bug where they can't check CRC for bulletin
2136 * boards of length greater than legacy size.
2137 */
2138 bulletin->length = support_long ? BULLETIN_CONTENT_SIZE :
2139 BULLETIN_CONTENT_LEGACY_SIZE;
2140 bulletin->crc = bnx2x_crc_vf_bulletin(bulletin);
2141}
2142
abc5a021
AE		 2143/* propagate local bulletin board to vf */
2144int bnx2x_post_vf_bulletin(struct bnx2x *bp, int vf)
2145{
2146 struct pf_vf_bulletin_content *bulletin = BP_VF_BULLETIN(bp, vf);
2147 dma_addr_t pf_addr = BP_VF_BULLETIN_DMA(bp)->mapping +
2148 vf * BULLETIN_CONTENT_SIZE;
2149 dma_addr_t vf_addr = bnx2x_vf(bp, vf, bulletin_map);
abc5a021
AE		 2150 int rc;
2151
2152 /* can only update vf after init took place */
2153 if (bnx2x_vf(bp, vf, state) != VF_ENABLED &&
2154 bnx2x_vf(bp, vf, state) != VF_ACQUIRED)
2155 return 0;
2156
2157 /* increment bulletin board version and compute crc */
2158 bulletin->version++;
6495d15a
DK		 2159 bnx2x_vf_bulletin_finalize(bulletin,
2160 (bnx2x_vf(bp, vf, cfg_flags) &
2161 VF_CFG_EXT_BULLETIN) ? true : false);
abc5a021
AE		 2162
2163 /* propagate bulletin board via dmae to vm memory */
2164 rc = bnx2x_copy32_vf_dmae(bp, false, pf_addr,
2165 bnx2x_vf(bp, vf, abs_vfid), U64_HI(vf_addr),
4c133c39 2166 U64_LO(vf_addr), bulletin->length / 4);
abc5a021
AE		 2167 return rc;
2168}
Linux 6.x block layer and io_uring tree(s)