661f0a58ad76010e858c2fdbfa0afee6f607d1dd
[dpdk.git] / drivers / net / bnx2x / bnx2x_vfpf.c
1 /*
2  * Copyright (c) 2013-2015 Brocade Communications Systems, Inc.
3  *
4  * All rights reserved.
5  */
6
7 #include "bnx2x.h"
8
9 /* calculate the crc in the bulletin board */
10 static inline uint32_t
11 bnx2x_vf_crc(struct bnx2x_vf_bulletin *bull)
12 {
13         uint32_t crc_sz = sizeof(bull->crc), length = bull->length - crc_sz;
14
15         return ECORE_CRC32_LE(0, (uint8_t *)bull + crc_sz, length);
16 }
17
18 /* Checks are there mac/channel updates for VF
19  * returns TRUE if something was updated
20 */
21 int
22 bnx2x_check_bull(struct bnx2x_softc *sc)
23 {
24         struct bnx2x_vf_bulletin *bull;
25         uint8_t tries = 0;
26         uint16_t old_version = sc->old_bulletin.version;
27         uint64_t valid_bitmap;
28
29         bull = sc->pf2vf_bulletin;
30         if (old_version == bull->version) {
31                 return FALSE;
32         } else {
33                 /* Check the crc until we get the correct data */
34                 while (tries < BNX2X_VF_BULLETIN_TRIES) {
35                         bull = sc->pf2vf_bulletin;
36                         if (bull->crc == bnx2x_vf_crc(bull))
37                                 break;
38
39                         PMD_DRV_LOG(ERR, "bad crc on bulletin board. contained %x computed %x",
40                                         bull->crc, bnx2x_vf_crc(bull));
41                         ++tries;
42                 }
43                 if (tries == BNX2X_VF_BULLETIN_TRIES) {
44                         PMD_DRV_LOG(ERR, "pf to vf bulletin board crc was wrong %d consecutive times. Aborting",
45                                         tries);
46                         return FALSE;
47                 }
48         }
49
50         valid_bitmap = bull->valid_bitmap;
51
52         /* check the mac address and VLAN and allocate memory if valid */
53         if (valid_bitmap & (1 << MAC_ADDR_VALID) && memcmp(bull->mac, sc->old_bulletin.mac, ETH_ALEN))
54                 rte_memcpy(&sc->link_params.mac_addr, bull->mac, ETH_ALEN);
55         if (valid_bitmap & (1 << VLAN_VALID))
56                 rte_memcpy(&bull->vlan, &sc->old_bulletin.vlan, VLAN_HLEN);
57
58         sc->old_bulletin = *bull;
59
60         return TRUE;
61 }
62
63 /* add tlv to a buffer */
64 #define BNX2X_TLV_APPEND(_tlvs, _offset, _type, _length) \
65         ((struct vf_first_tlv *)((uint64_t)_tlvs + _offset))->type   = _type; \
66         ((struct vf_first_tlv *)((uint64_t)_tlvs + _offset))->length = _length
67
68 /* Initiliaze header of the first tlv and clear mailbox*/
69 static void
70 bnx2x_init_first_tlv(struct bnx2x_softc *sc, struct vf_first_tlv *tlv,
71         uint16_t type, uint16_t len)
72 {
73         struct bnx2x_vf_mbx_msg *mbox = sc->vf2pf_mbox;
74         PMD_DRV_LOG(DEBUG, "Preparing %d tlv for sending", type);
75
76         memset(mbox, 0, sizeof(struct bnx2x_vf_mbx_msg));
77
78         BNX2X_TLV_APPEND(tlv, 0, type, len);
79
80         /* Initialize header of the first tlv */
81         tlv->reply_offset = sizeof(mbox->query);
82 }
83
84 #define BNX2X_VF_CMD_ADDR_LO PXP_VF_ADDR_CSDM_GLOBAL_START
85 #define BNX2X_VF_CMD_ADDR_HI BNX2X_VF_CMD_ADDR_LO + 4
86 #define BNX2X_VF_CMD_TRIGGER BNX2X_VF_CMD_ADDR_HI + 4
87 #define BNX2X_VF_CHANNEL_DELAY 100
88 #define BNX2X_VF_CHANNEL_TRIES 100
89
90 static int
91 bnx2x_do_req4pf(struct bnx2x_softc *sc, phys_addr_t phys_addr)
92 {
93         uint8_t *status = &sc->vf2pf_mbox->resp.common_reply.status;
94         uint8_t i;
95
96         if (!*status) {
97                 bnx2x_check_bull(sc);
98                 if (sc->old_bulletin.valid_bitmap & (1 << CHANNEL_DOWN)) {
99                         PMD_DRV_LOG(ERR, "channel is down. Aborting message sending");
100                         *status = BNX2X_VF_STATUS_SUCCESS;
101                         return 0;
102                 }
103
104                 REG_WR(sc, BNX2X_VF_CMD_ADDR_LO, U64_LO(phys_addr));
105                 REG_WR(sc, BNX2X_VF_CMD_ADDR_HI, U64_HI(phys_addr));
106
107                 /* memory barrier to ensure that FW can read phys_addr */
108                 wmb();
109
110                 REG_WR8(sc, BNX2X_VF_CMD_TRIGGER, 1);
111
112                 /* Do several attempts until PF completes
113                  * "." is used to show progress
114                  */
115                 for (i = 0; i < BNX2X_VF_CHANNEL_TRIES; i++) {
116                         DELAY_MS(BNX2X_VF_CHANNEL_DELAY);
117                         if (*status)
118                                 break;
119                 }
120
121                 if (i == BNX2X_VF_CHANNEL_TRIES) {
122                         PMD_DRV_LOG(ERR, "Response from PF timed out");
123                         return -EAGAIN;
124                 }
125
126                 if (BNX2X_VF_STATUS_SUCCESS != *status) {
127                         PMD_DRV_LOG(ERR, "Bad reply from PF : %u",
128                                         *status);
129                         return -EINVAL;
130                 }
131         } else {
132                 PMD_DRV_LOG(ERR, "status should be zero before message"
133                                 "to pf was sent");
134                 return -EINVAL;
135         }
136
137         PMD_DRV_LOG(DEBUG, "Response from PF was received");
138         return 0;
139 }
140
141 static inline uint16_t bnx2x_check_me_flags(uint32_t val)
142 {
143         if (((val) & ME_REG_VF_VALID) && (!((val) & ME_REG_VF_ERR)))
144                 return ME_REG_VF_VALID;
145         else
146                 return 0;
147 }
148
149 #define BNX2X_ME_ANSWER_DELAY 100
150 #define BNX2X_ME_ANSWER_TRIES 10
151
152 static inline int bnx2x_read_vf_id(struct bnx2x_softc *sc)
153 {
154         uint32_t val;
155         uint8_t i = 0;
156
157         while (i <= BNX2X_ME_ANSWER_TRIES) {
158                 val = BNX2X_DB_READ(DOORBELL_ADDR(sc, 0));
159                 if (bnx2x_check_me_flags(val))
160                         return VF_ID(val);
161
162                 DELAY_MS(BNX2X_ME_ANSWER_DELAY);
163                 i++;
164         }
165
166         return -EINVAL;
167 }
168
169 #define BNX2X_VF_OBTAIN_MAX_TRIES 3
170 #define BNX2X_VF_OBTAIN_MAC_FILTERS 1
171 #define BNX2X_VF_OBTAIN_MC_FILTERS 10
172
173 struct bnx2x_obtain_status {
174         int success;
175         int err_code;
176 };
177
178 static
179 struct bnx2x_obtain_status bnx2x_loop_obtain_resources(struct bnx2x_softc *sc)
180 {
181         int tries = 0;
182         struct vf_acquire_resp_tlv *resp = &sc->vf2pf_mbox->resp.acquire_resp,
183                                                                  *sc_resp = &sc->acquire_resp;
184         struct vf_resource_query    *res_query;
185         struct vf_resc            *resc;
186         struct bnx2x_obtain_status     status;
187         int res_obtained = false;
188
189         do {
190                 PMD_DRV_LOG(DEBUG, "trying to get resources");
191
192                 if ( bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr) ) {
193                         /* timeout */
194                         status.success = 0;
195                         status.err_code = 0;
196                         return status;
197                 }
198
199                 memcpy(sc_resp, resp, sizeof(sc->acquire_resp));
200
201                 tries++;
202
203                 /* check PF to request acceptance */
204                 if (sc_resp->status == BNX2X_VF_STATUS_SUCCESS) {
205                         PMD_DRV_LOG(DEBUG, "resources obtained successfully");
206                         res_obtained = true;
207                 } else if (sc_resp->status == BNX2X_VF_STATUS_NO_RESOURCES &&
208                         tries < BNX2X_VF_OBTAIN_MAX_TRIES) {
209                         PMD_DRV_LOG(DEBUG,
210                            "PF cannot allocate requested amount of resources");
211
212                         res_query = &sc->vf2pf_mbox->query[0].acquire.res_query;
213                         resc     = &sc_resp->resc;
214
215                         /* PF refused our request. Try to decrease request params */
216                         res_query->num_txqs         = min(res_query->num_txqs, resc->num_txqs);
217                         res_query->num_rxqs         = min(res_query->num_rxqs, resc->num_rxqs);
218                         res_query->num_sbs          = min(res_query->num_sbs, resc->num_sbs);
219                         res_query->num_mac_filters  = min(res_query->num_mac_filters, resc->num_mac_filters);
220                         res_query->num_vlan_filters = min(res_query->num_vlan_filters, resc->num_vlan_filters);
221                         res_query->num_mc_filters   = min(res_query->num_mc_filters, resc->num_mc_filters);
222
223                         memset(&sc->vf2pf_mbox->resp, 0, sizeof(union resp_tlvs));
224                 } else {
225                         PMD_DRV_LOG(ERR, "Resources cannot be obtained. Status of handling: %d. Aborting",
226                                         sc_resp->status);
227                         status.success = 0;
228                         status.err_code = -EAGAIN;
229                         return status;
230                 }
231         } while (!res_obtained);
232
233         status.success = 1;
234         return status;
235 }
236
237 int bnx2x_vf_get_resources(struct bnx2x_softc *sc, uint8_t tx_count, uint8_t rx_count)
238 {
239         struct vf_acquire_tlv *acq = &sc->vf2pf_mbox->query[0].acquire;
240         int vf_id;
241         struct bnx2x_obtain_status obtain_status;
242
243         bnx2x_vf_close(sc);
244         bnx2x_init_first_tlv(sc, &acq->first_tlv, BNX2X_VF_TLV_ACQUIRE, sizeof(*acq));
245
246         vf_id = bnx2x_read_vf_id(sc);
247         if (vf_id < 0)
248                 return -EAGAIN;
249
250         acq->vf_id = vf_id;
251
252         acq->res_query.num_rxqs = rx_count;
253         acq->res_query.num_txqs = tx_count;
254         acq->res_query.num_sbs = sc->igu_sb_cnt;
255         acq->res_query.num_mac_filters = BNX2X_VF_OBTAIN_MAC_FILTERS;
256         acq->res_query.num_mc_filters = BNX2X_VF_OBTAIN_MC_FILTERS;
257
258         acq->bulletin_addr = sc->pf2vf_bulletin_mapping.paddr;
259
260         BNX2X_TLV_APPEND(acq, acq->first_tlv.length, BNX2X_VF_TLV_LIST_END,
261                         sizeof(struct channel_list_end_tlv));
262
263         /* requesting the resources in loop */
264         obtain_status = bnx2x_loop_obtain_resources(sc);
265         if (!obtain_status.success)
266                 return obtain_status.err_code;
267
268         struct vf_acquire_resp_tlv sc_resp = sc->acquire_resp;
269
270         sc->devinfo.chip_id        |= (sc_resp.chip_num & 0xFFFF);
271         sc->devinfo.int_block       = INT_BLOCK_IGU;
272         sc->devinfo.chip_port_mode  = CHIP_2_PORT_MODE;
273         sc->devinfo.mf_info.mf_ov   = 0;
274         sc->devinfo.mf_info.mf_mode = 0;
275         sc->devinfo.flash_size      = 0;
276
277         sc->igu_sb_cnt  = sc_resp.resc.num_sbs;
278         sc->igu_base_sb = sc_resp.resc.hw_sbs[0] & 0xFF;
279         sc->igu_dsb_id  = -1;
280
281         sc->link_params.chip_id = sc->devinfo.chip_id;
282         sc->doorbell_size = sc_resp.db_size;
283         sc->flags |= BNX2X_NO_WOL_FLAG | BNX2X_NO_ISCSI_OOO_FLAG | BNX2X_NO_ISCSI_FLAG | BNX2X_NO_FCOE_FLAG;
284
285         PMD_DRV_LOG(DEBUG, "status block count = %d, base status block = %x",
286                 sc->igu_sb_cnt, sc->igu_base_sb);
287         strncpy(sc->fw_ver, sc_resp.fw_ver, sizeof(sc->fw_ver));
288
289         if (is_valid_ether_addr(sc_resp.resc.current_mac_addr))
290                 (void)rte_memcpy(sc->link_params.mac_addr,
291                        sc_resp.resc.current_mac_addr,
292                        ETH_ALEN);
293
294         return 0;
295 }
296
297 /* Ask PF to release VF's resources */
298 void
299 bnx2x_vf_close(struct bnx2x_softc *sc)
300 {
301         struct vf_release_tlv *query;
302         int vf_id = bnx2x_read_vf_id(sc);
303         int ret;
304
305         if (vf_id >= 0) {
306                 query = &sc->vf2pf_mbox->query[0].release;
307                 bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_RELEASE,
308                                 sizeof(*query));
309
310                 query->vf_id = vf_id;
311                 BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
312                                 sizeof(struct channel_list_end_tlv));
313
314                 ret = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
315
316                 if (ret) {
317                         PMD_DRV_LOG(ERR, "Failed to release VF");
318                 }
319         }
320 }
321
322 /* Let PF know the VF status blocks phys_addrs */
323 int
324 bnx2x_vf_init(struct bnx2x_softc *sc)
325 {
326         struct vf_init_tlv *query;
327         int i, ret;
328
329         query = &sc->vf2pf_mbox->query[0].init;
330         bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_INIT,
331                         sizeof(*query));
332
333         FOR_EACH_QUEUE(sc, i) {
334                 query->sb_addr[i] = (unsigned long)(sc->fp[i].sb_dma.paddr);
335         }
336
337         query->stats_step = sizeof(struct per_queue_stats);
338         query->stats_addr = sc->fw_stats_data_mapping +
339                 offsetof(struct bnx2x_fw_stats_data, queue_stats);
340
341         BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
342                         sizeof(struct channel_list_end_tlv));
343
344         ret = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
345
346         if (ret) {
347                 PMD_DRV_LOG(ERR, "Failed to init VF");
348                 return ret;
349         }
350
351         PMD_DRV_LOG(DEBUG, "VF was initialized");
352         return 0;
353 }
354
355 void
356 bnx2x_vf_unload(struct bnx2x_softc *sc)
357 {
358         struct vf_close_tlv *query;
359         struct vf_q_op_tlv *query_op;
360         int i, vf_id, ret;
361
362         vf_id = bnx2x_read_vf_id(sc);
363         if (vf_id > 0) {
364                 FOR_EACH_QUEUE(sc, i) {
365                         query_op = &sc->vf2pf_mbox->query[0].q_op;
366                         bnx2x_init_first_tlv(sc, &query_op->first_tlv,
367                                         BNX2X_VF_TLV_TEARDOWN_Q,
368                                         sizeof(*query_op));
369
370                         query_op->vf_qid = i;
371
372                         BNX2X_TLV_APPEND(query_op, query_op->first_tlv.length,
373                                         BNX2X_VF_TLV_LIST_END,
374                                         sizeof(struct channel_list_end_tlv));
375
376                         ret = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
377                         if (ret)
378                                 PMD_DRV_LOG(ERR,
379                                                 "Bad reply for vf_q %d teardown", i);
380                 }
381
382                 bnx2x_vf_set_mac(sc, false);
383
384                 query = &sc->vf2pf_mbox->query[0].close;
385                 bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_CLOSE,
386                                 sizeof(*query));
387
388                 query->vf_id = vf_id;
389
390                 BNX2X_TLV_APPEND(query, query->first_tlv.length,
391                                 BNX2X_VF_TLV_LIST_END,
392                                 sizeof(struct channel_list_end_tlv));
393
394                 ret = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
395
396                 if (ret)
397                         PMD_DRV_LOG(ERR,
398                                 "Bad reply from PF for close message");
399         }
400 }
401
402 static inline uint16_t
403 bnx2x_vf_q_flags(uint8_t leading)
404 {
405         uint16_t flags = leading ? BNX2X_VF_Q_FLAG_LEADING_RSS : 0;
406
407         flags |= BNX2X_VF_Q_FLAG_CACHE_ALIGN;
408         flags |= BNX2X_VF_Q_FLAG_STATS;
409         flags |= BNX2X_VF_Q_FLAG_VLAN;
410
411         return flags;
412 }
413
414 static void
415 bnx2x_vf_rx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
416                 struct vf_rxq_params *rxq_init, uint16_t flags)
417 {
418         struct bnx2x_rx_queue *rxq;
419
420         rxq = sc->rx_queues[fp->index];
421         if (!rxq) {
422                 PMD_DRV_LOG(ERR, "RX queue %d is NULL", fp->index);
423                 return;
424         }
425
426         rxq_init->rcq_addr = rxq->cq_ring_phys_addr;
427         rxq_init->rcq_np_addr = rxq->cq_ring_phys_addr + BNX2X_PAGE_SIZE;
428         rxq_init->rxq_addr = rxq->rx_ring_phys_addr;
429         rxq_init->vf_sb_id = fp->index;
430         rxq_init->sb_cq_index = HC_INDEX_ETH_RX_CQ_CONS;
431         rxq_init->mtu = sc->mtu;
432         rxq_init->buf_sz = fp->rx_buf_size;
433         rxq_init->flags = flags;
434         rxq_init->stat_id = -1;
435         rxq_init->cache_line_log = BNX2X_RX_ALIGN_SHIFT;
436 }
437
438 static void
439 bnx2x_vf_tx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
440                 struct vf_txq_params *txq_init, uint16_t flags)
441 {
442         struct bnx2x_tx_queue *txq;
443
444         txq = sc->tx_queues[fp->index];
445         if (!txq) {
446                 PMD_DRV_LOG(ERR, "TX queue %d is NULL", fp->index);
447                 return;
448         }
449
450         txq_init->txq_addr = txq->tx_ring_phys_addr;
451         txq_init->sb_index = HC_INDEX_ETH_TX_CQ_CONS_COS0;
452         txq_init->flags = flags;
453         txq_init->traffic_type = LLFC_TRAFFIC_TYPE_NW;
454         txq_init->vf_sb_id = fp->index;
455 }
456
457 int
458 bnx2x_vf_setup_queue(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, int leading)
459 {
460         struct vf_setup_q_tlv *query;
461         uint16_t flags = bnx2x_vf_q_flags(leading);
462         int ret;
463
464         query = &sc->vf2pf_mbox->query[0].setup_q;
465         bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_SETUP_Q,
466                         sizeof(*query));
467
468         query->vf_qid = fp->index;
469         query->param_valid = VF_RXQ_VALID | VF_TXQ_VALID;
470
471         bnx2x_vf_rx_q_prep(sc, fp, &query->rxq, flags);
472         bnx2x_vf_tx_q_prep(sc, fp, &query->txq, flags);
473
474         BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
475                         sizeof(struct channel_list_end_tlv));
476
477         ret = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
478
479         if (ret) {
480                 PMD_DRV_LOG(ERR, "Failed to setup VF queue[%d]",
481                                 fp->index);
482                 return -EINVAL;
483         }
484
485         return 0;
486 }
487
488 int
489 bnx2x_vf_set_mac(struct bnx2x_softc *sc, int set)
490 {
491         struct vf_set_q_filters_tlv *query;
492         struct vf_common_reply_tlv *reply;
493
494         query = &sc->vf2pf_mbox->query[0].set_q_filters;
495         bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_SET_Q_FILTERS,
496                         sizeof(*query));
497
498         query->vf_qid = sc->fp->index;
499         query->mac_filters_cnt = 1;
500         query->flags = BNX2X_VF_MAC_VLAN_CHANGED;
501
502         query->filters[0].flags = (set ? BNX2X_VF_Q_FILTER_SET_MAC : 0) |
503                 BNX2X_VF_Q_FILTER_DEST_MAC_VALID;
504
505         bnx2x_check_bull(sc);
506
507         rte_memcpy(query->filters[0].mac, sc->link_params.mac_addr, ETH_ALEN);
508
509         BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
510                         sizeof(struct channel_list_end_tlv));
511
512         bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
513         reply = &sc->vf2pf_mbox->resp.common_reply;
514
515         while (BNX2X_VF_STATUS_FAILURE == reply->status &&
516                         bnx2x_check_bull(sc)) {
517                 /* A new mac was configured by PF for us */
518                 rte_memcpy(sc->link_params.mac_addr, sc->pf2vf_bulletin->mac,
519                                 ETH_ALEN);
520                 rte_memcpy(query->filters[0].mac, sc->pf2vf_bulletin->mac,
521                                 ETH_ALEN);
522
523                 bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
524         }
525
526         if (BNX2X_VF_STATUS_SUCCESS != reply->status) {
527                 PMD_DRV_LOG(ERR, "Bad reply from PF for SET MAC message: %d",
528                                 reply->status);
529                 return -EINVAL;
530         }
531
532         return 0;
533 }
534
535 int
536 bnx2x_vf_config_rss(struct bnx2x_softc *sc,
537                           struct ecore_config_rss_params *params)
538 {
539         struct vf_rss_tlv *query;
540         int ret;
541
542         query = &sc->vf2pf_mbox->query[0].update_rss;
543
544         bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_UPDATE_RSS,
545                         sizeof(*query));
546
547         /* add list termination tlv */
548         BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
549                         sizeof(struct channel_list_end_tlv));
550
551         rte_memcpy(query->rss_key, params->rss_key, sizeof(params->rss_key));
552         query->rss_key_size = T_ETH_RSS_KEY;
553
554         rte_memcpy(query->ind_table, params->ind_table, T_ETH_INDIRECTION_TABLE_SIZE);
555         query->ind_table_size = T_ETH_INDIRECTION_TABLE_SIZE;
556
557         query->rss_result_mask = params->rss_result_mask;
558         query->rss_flags = params->rss_flags;
559
560         ret = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
561         if (ret) {
562                 PMD_DRV_LOG(ERR, "Failed to send message to PF, rc %d", ret);
563                 return ret;
564         }
565
566         return 0;
567 }
568
569 int
570 bnx2x_vf_set_rx_mode(struct bnx2x_softc *sc)
571 {
572         struct vf_set_q_filters_tlv *query;
573         unsigned long tx_mask;
574         int ret;
575
576         query = &sc->vf2pf_mbox->query[0].set_q_filters;
577         bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_SET_Q_FILTERS,
578                         sizeof(*query));
579
580         query->vf_qid = 0;
581         query->flags = BNX2X_VF_RX_MASK_CHANGED;
582
583         if (bnx2x_fill_accept_flags(sc, sc->rx_mode, &query->rx_mask, &tx_mask)) {
584                 return -EINVAL;
585         }
586
587         BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
588                         sizeof(struct channel_list_end_tlv));
589
590         ret = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
591         if (ret) {
592                 PMD_DRV_LOG(ERR, "Failed to send message to PF, rc %d", ret);
593                 return ret;
594         }
595
596         return 0;
597 }