11f4d4ed6SAlexander Lobakin // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
232a47e72SYuval Mintz /* QLogic qed NIC Driver
3e8f1cb50SMintz, Yuval * Copyright (c) 2015-2017 QLogic Corporation
4663eacd8SAlexander Lobakin * Copyright (c) 2019-2020 Marvell International Ltd.
532a47e72SYuval Mintz */
632a47e72SYuval Mintz
7dacd88d6SYuval Mintz #include <linux/etherdevice.h>
836558c3dSYuval Mintz #include <linux/crc32.h>
9f29ffdb6SMintz, Yuval #include <linux/vmalloc.h>
106da95b52SAlok Prasad #include <linux/crash_dump.h>
110b55e27dSYuval Mintz #include <linux/qed/qed_iov_if.h>
121408cc1fSYuval Mintz #include "qed_cxt.h"
131408cc1fSYuval Mintz #include "qed_hsi.h"
14ee824f4bSOmkar Kulkarni #include "qed_iro_hsi.h"
1532a47e72SYuval Mintz #include "qed_hw.h"
161408cc1fSYuval Mintz #include "qed_init_ops.h"
1732a47e72SYuval Mintz #include "qed_int.h"
181408cc1fSYuval Mintz #include "qed_mcp.h"
1932a47e72SYuval Mintz #include "qed_reg_addr.h"
201408cc1fSYuval Mintz #include "qed_sp.h"
2132a47e72SYuval Mintz #include "qed_sriov.h"
2232a47e72SYuval Mintz #include "qed_vf.h"
237425d822SShahed Shaikh static int qed_iov_bulletin_set_mac(struct qed_hwfn *p_hwfn, u8 *mac, int vfid);
2432a47e72SYuval Mintz
qed_vf_from_entity_id(__le16 entity_id)25fe40a830SPrabhakar Kushwaha static u16 qed_vf_from_entity_id(__le16 entity_id)
26fe40a830SPrabhakar Kushwaha {
27fe40a830SPrabhakar Kushwaha return le16_to_cpu(entity_id) - MAX_NUM_PFS;
28fe40a830SPrabhakar Kushwaha }
29fe40a830SPrabhakar Kushwaha
qed_vf_calculate_legacy(struct qed_vf_info * p_vf)303b19f478SMintz, Yuval static u8 qed_vf_calculate_legacy(struct qed_vf_info *p_vf)
313b19f478SMintz, Yuval {
3208bc8f15SMintz, Yuval u8 legacy = 0;
333b19f478SMintz, Yuval
343b19f478SMintz, Yuval if (p_vf->acquire.vfdev_info.eth_fp_hsi_minor ==
353b19f478SMintz, Yuval ETH_HSI_VER_NO_PKT_LEN_TUNN)
363b19f478SMintz, Yuval legacy |= QED_QCID_LEGACY_VF_RX_PROD;
373b19f478SMintz, Yuval
3808bc8f15SMintz, Yuval if (!(p_vf->acquire.vfdev_info.capabilities &
3908bc8f15SMintz, Yuval VFPF_ACQUIRE_CAP_QUEUE_QIDS))
4008bc8f15SMintz, Yuval legacy |= QED_QCID_LEGACY_VF_CID;
4108bc8f15SMintz, Yuval
423b19f478SMintz, Yuval return legacy;
433b19f478SMintz, Yuval }
443b19f478SMintz, Yuval
451408cc1fSYuval Mintz /* IOV ramrods */
qed_sp_vf_start(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf)461fe614d1SYuval Mintz static int qed_sp_vf_start(struct qed_hwfn *p_hwfn, struct qed_vf_info *p_vf)
471408cc1fSYuval Mintz {
481408cc1fSYuval Mintz struct vf_start_ramrod_data *p_ramrod = NULL;
491408cc1fSYuval Mintz struct qed_spq_entry *p_ent = NULL;
501408cc1fSYuval Mintz struct qed_sp_init_data init_data;
511408cc1fSYuval Mintz int rc = -EINVAL;
521fe614d1SYuval Mintz u8 fp_minor;
531408cc1fSYuval Mintz
541408cc1fSYuval Mintz /* Get SPQ entry */
551408cc1fSYuval Mintz memset(&init_data, 0, sizeof(init_data));
561408cc1fSYuval Mintz init_data.cid = qed_spq_get_cid(p_hwfn);
571fe614d1SYuval Mintz init_data.opaque_fid = p_vf->opaque_fid;
581408cc1fSYuval Mintz init_data.comp_mode = QED_SPQ_MODE_EBLOCK;
591408cc1fSYuval Mintz
601408cc1fSYuval Mintz rc = qed_sp_init_request(p_hwfn, &p_ent,
611408cc1fSYuval Mintz COMMON_RAMROD_VF_START,
621408cc1fSYuval Mintz PROTOCOLID_COMMON, &init_data);
631408cc1fSYuval Mintz if (rc)
641408cc1fSYuval Mintz return rc;
651408cc1fSYuval Mintz
661408cc1fSYuval Mintz p_ramrod = &p_ent->ramrod.vf_start;
671408cc1fSYuval Mintz
681fe614d1SYuval Mintz p_ramrod->vf_id = GET_FIELD(p_vf->concrete_fid, PXP_CONCRETE_FID_VFID);
691fe614d1SYuval Mintz p_ramrod->opaque_fid = cpu_to_le16(p_vf->opaque_fid);
701408cc1fSYuval Mintz
711fe614d1SYuval Mintz switch (p_hwfn->hw_info.personality) {
721fe614d1SYuval Mintz case QED_PCI_ETH:
731408cc1fSYuval Mintz p_ramrod->personality = PERSONALITY_ETH;
741fe614d1SYuval Mintz break;
751fe614d1SYuval Mintz case QED_PCI_ETH_ROCE:
76ce1cf9e5SDmitry Bogdanov case QED_PCI_ETH_IWARP:
771fe614d1SYuval Mintz p_ramrod->personality = PERSONALITY_RDMA_AND_ETH;
781fe614d1SYuval Mintz break;
791fe614d1SYuval Mintz default:
801fe614d1SYuval Mintz DP_NOTICE(p_hwfn, "Unknown VF personality %d\n",
811fe614d1SYuval Mintz p_hwfn->hw_info.personality);
82fb5e7438SDenis Bolotin qed_sp_destroy_request(p_hwfn, p_ent);
831fe614d1SYuval Mintz return -EINVAL;
841fe614d1SYuval Mintz }
851fe614d1SYuval Mintz
861fe614d1SYuval Mintz fp_minor = p_vf->acquire.vfdev_info.eth_fp_hsi_minor;
87a044df83SYuval Mintz if (fp_minor > ETH_HSI_VER_MINOR &&
88a044df83SYuval Mintz fp_minor != ETH_HSI_VER_NO_PKT_LEN_TUNN) {
891fe614d1SYuval Mintz DP_VERBOSE(p_hwfn,
901fe614d1SYuval Mintz QED_MSG_IOV,
911fe614d1SYuval Mintz "VF [%d] - Requested fp hsi %02x.%02x which is slightly newer than PF's %02x.%02x; Configuring PFs version\n",
921fe614d1SYuval Mintz p_vf->abs_vf_id,
931fe614d1SYuval Mintz ETH_HSI_VER_MAJOR,
941fe614d1SYuval Mintz fp_minor, ETH_HSI_VER_MAJOR, ETH_HSI_VER_MINOR);
951fe614d1SYuval Mintz fp_minor = ETH_HSI_VER_MINOR;
961fe614d1SYuval Mintz }
971fe614d1SYuval Mintz
98351a4dedSYuval Mintz p_ramrod->hsi_fp_ver.major_ver_arr[ETH_VER_KEY] = ETH_HSI_VER_MAJOR;
991fe614d1SYuval Mintz p_ramrod->hsi_fp_ver.minor_ver_arr[ETH_VER_KEY] = fp_minor;
1001fe614d1SYuval Mintz
1011fe614d1SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
1021fe614d1SYuval Mintz "VF[%d] - Starting using HSI %02x.%02x\n",
1031fe614d1SYuval Mintz p_vf->abs_vf_id, ETH_HSI_VER_MAJOR, fp_minor);
1041408cc1fSYuval Mintz
1051408cc1fSYuval Mintz return qed_spq_post(p_hwfn, p_ent, NULL);
1061408cc1fSYuval Mintz }
1071408cc1fSYuval Mintz
qed_sp_vf_stop(struct qed_hwfn * p_hwfn,u32 concrete_vfid,u16 opaque_vfid)1080b55e27dSYuval Mintz static int qed_sp_vf_stop(struct qed_hwfn *p_hwfn,
1090b55e27dSYuval Mintz u32 concrete_vfid, u16 opaque_vfid)
1100b55e27dSYuval Mintz {
1110b55e27dSYuval Mintz struct vf_stop_ramrod_data *p_ramrod = NULL;
1120b55e27dSYuval Mintz struct qed_spq_entry *p_ent = NULL;
1130b55e27dSYuval Mintz struct qed_sp_init_data init_data;
1140b55e27dSYuval Mintz int rc = -EINVAL;
1150b55e27dSYuval Mintz
1160b55e27dSYuval Mintz /* Get SPQ entry */
1170b55e27dSYuval Mintz memset(&init_data, 0, sizeof(init_data));
1180b55e27dSYuval Mintz init_data.cid = qed_spq_get_cid(p_hwfn);
1190b55e27dSYuval Mintz init_data.opaque_fid = opaque_vfid;
1200b55e27dSYuval Mintz init_data.comp_mode = QED_SPQ_MODE_EBLOCK;
1210b55e27dSYuval Mintz
1220b55e27dSYuval Mintz rc = qed_sp_init_request(p_hwfn, &p_ent,
1230b55e27dSYuval Mintz COMMON_RAMROD_VF_STOP,
1240b55e27dSYuval Mintz PROTOCOLID_COMMON, &init_data);
1250b55e27dSYuval Mintz if (rc)
1260b55e27dSYuval Mintz return rc;
1270b55e27dSYuval Mintz
1280b55e27dSYuval Mintz p_ramrod = &p_ent->ramrod.vf_stop;
1290b55e27dSYuval Mintz
1300b55e27dSYuval Mintz p_ramrod->vf_id = GET_FIELD(concrete_vfid, PXP_CONCRETE_FID_VFID);
1310b55e27dSYuval Mintz
1320b55e27dSYuval Mintz return qed_spq_post(p_hwfn, p_ent, NULL);
1330b55e27dSYuval Mintz }
1340b55e27dSYuval Mintz
qed_iov_is_valid_vfid(struct qed_hwfn * p_hwfn,int rel_vf_id,bool b_enabled_only,bool b_non_malicious)135da090917STomer Tayar bool qed_iov_is_valid_vfid(struct qed_hwfn *p_hwfn,
1367eff82b0SYuval Mintz int rel_vf_id,
1377eff82b0SYuval Mintz bool b_enabled_only, bool b_non_malicious)
13832a47e72SYuval Mintz {
13932a47e72SYuval Mintz if (!p_hwfn->pf_iov_info) {
14032a47e72SYuval Mintz DP_NOTICE(p_hwfn->cdev, "No iov info\n");
14132a47e72SYuval Mintz return false;
14232a47e72SYuval Mintz }
14332a47e72SYuval Mintz
14432a47e72SYuval Mintz if ((rel_vf_id >= p_hwfn->cdev->p_iov_info->total_vfs) ||
14532a47e72SYuval Mintz (rel_vf_id < 0))
14632a47e72SYuval Mintz return false;
14732a47e72SYuval Mintz
14832a47e72SYuval Mintz if ((!p_hwfn->pf_iov_info->vfs_array[rel_vf_id].b_init) &&
14932a47e72SYuval Mintz b_enabled_only)
15032a47e72SYuval Mintz return false;
15132a47e72SYuval Mintz
1527eff82b0SYuval Mintz if ((p_hwfn->pf_iov_info->vfs_array[rel_vf_id].b_malicious) &&
1537eff82b0SYuval Mintz b_non_malicious)
1547eff82b0SYuval Mintz return false;
1557eff82b0SYuval Mintz
15632a47e72SYuval Mintz return true;
15732a47e72SYuval Mintz }
15832a47e72SYuval Mintz
qed_iov_get_vf_info(struct qed_hwfn * p_hwfn,u16 relative_vf_id,bool b_enabled_only)15937bff2b9SYuval Mintz static struct qed_vf_info *qed_iov_get_vf_info(struct qed_hwfn *p_hwfn,
16037bff2b9SYuval Mintz u16 relative_vf_id,
16137bff2b9SYuval Mintz bool b_enabled_only)
16237bff2b9SYuval Mintz {
16337bff2b9SYuval Mintz struct qed_vf_info *vf = NULL;
16437bff2b9SYuval Mintz
16537bff2b9SYuval Mintz if (!p_hwfn->pf_iov_info) {
16637bff2b9SYuval Mintz DP_NOTICE(p_hwfn->cdev, "No iov info\n");
16737bff2b9SYuval Mintz return NULL;
16837bff2b9SYuval Mintz }
16937bff2b9SYuval Mintz
1707eff82b0SYuval Mintz if (qed_iov_is_valid_vfid(p_hwfn, relative_vf_id,
1717eff82b0SYuval Mintz b_enabled_only, false))
17237bff2b9SYuval Mintz vf = &p_hwfn->pf_iov_info->vfs_array[relative_vf_id];
17337bff2b9SYuval Mintz else
174fe40a830SPrabhakar Kushwaha DP_ERR(p_hwfn, "%s: VF[%d] is not enabled\n",
175fe40a830SPrabhakar Kushwaha __func__, relative_vf_id);
17637bff2b9SYuval Mintz
17737bff2b9SYuval Mintz return vf;
17837bff2b9SYuval Mintz }
17937bff2b9SYuval Mintz
180007bc371SMintz, Yuval static struct qed_queue_cid *
qed_iov_get_vf_rx_queue_cid(struct qed_vf_queue * p_queue)181007bc371SMintz, Yuval qed_iov_get_vf_rx_queue_cid(struct qed_vf_queue *p_queue)
182007bc371SMintz, Yuval {
183007bc371SMintz, Yuval int i;
184007bc371SMintz, Yuval
185007bc371SMintz, Yuval for (i = 0; i < MAX_QUEUES_PER_QZONE; i++) {
186007bc371SMintz, Yuval if (p_queue->cids[i].p_cid && !p_queue->cids[i].b_is_tx)
187007bc371SMintz, Yuval return p_queue->cids[i].p_cid;
188007bc371SMintz, Yuval }
189007bc371SMintz, Yuval
190007bc371SMintz, Yuval return NULL;
191007bc371SMintz, Yuval }
192007bc371SMintz, Yuval
193f109c240SMintz, Yuval enum qed_iov_validate_q_mode {
194f109c240SMintz, Yuval QED_IOV_VALIDATE_Q_NA,
195f109c240SMintz, Yuval QED_IOV_VALIDATE_Q_ENABLE,
196f109c240SMintz, Yuval QED_IOV_VALIDATE_Q_DISABLE,
197f109c240SMintz, Yuval };
198f109c240SMintz, Yuval
qed_iov_validate_queue_mode(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,u16 qid,enum qed_iov_validate_q_mode mode,bool b_is_tx)199f109c240SMintz, Yuval static bool qed_iov_validate_queue_mode(struct qed_hwfn *p_hwfn,
200f109c240SMintz, Yuval struct qed_vf_info *p_vf,
201f109c240SMintz, Yuval u16 qid,
202f109c240SMintz, Yuval enum qed_iov_validate_q_mode mode,
203f109c240SMintz, Yuval bool b_is_tx)
20441086467SYuval Mintz {
205007bc371SMintz, Yuval int i;
206007bc371SMintz, Yuval
207f109c240SMintz, Yuval if (mode == QED_IOV_VALIDATE_Q_NA)
208f109c240SMintz, Yuval return true;
209f109c240SMintz, Yuval
210007bc371SMintz, Yuval for (i = 0; i < MAX_QUEUES_PER_QZONE; i++) {
211007bc371SMintz, Yuval struct qed_vf_queue_cid *p_qcid;
212007bc371SMintz, Yuval
213007bc371SMintz, Yuval p_qcid = &p_vf->vf_queues[qid].cids[i];
214007bc371SMintz, Yuval
215007bc371SMintz, Yuval if (!p_qcid->p_cid)
216007bc371SMintz, Yuval continue;
217007bc371SMintz, Yuval
218007bc371SMintz, Yuval if (p_qcid->b_is_tx != b_is_tx)
219007bc371SMintz, Yuval continue;
220007bc371SMintz, Yuval
221f109c240SMintz, Yuval return mode == QED_IOV_VALIDATE_Q_ENABLE;
222007bc371SMintz, Yuval }
223f109c240SMintz, Yuval
224f109c240SMintz, Yuval /* In case we haven't found any valid cid, then its disabled */
225f109c240SMintz, Yuval return mode == QED_IOV_VALIDATE_Q_DISABLE;
226f109c240SMintz, Yuval }
227f109c240SMintz, Yuval
qed_iov_validate_rxq(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,u16 rx_qid,enum qed_iov_validate_q_mode mode)228f109c240SMintz, Yuval static bool qed_iov_validate_rxq(struct qed_hwfn *p_hwfn,
229f109c240SMintz, Yuval struct qed_vf_info *p_vf,
230f109c240SMintz, Yuval u16 rx_qid,
231f109c240SMintz, Yuval enum qed_iov_validate_q_mode mode)
232f109c240SMintz, Yuval {
233f109c240SMintz, Yuval if (rx_qid >= p_vf->num_rxqs) {
23441086467SYuval Mintz DP_VERBOSE(p_hwfn,
23541086467SYuval Mintz QED_MSG_IOV,
23641086467SYuval Mintz "VF[0x%02x] - can't touch Rx queue[%04x]; Only 0x%04x are allocated\n",
23741086467SYuval Mintz p_vf->abs_vf_id, rx_qid, p_vf->num_rxqs);
238f109c240SMintz, Yuval return false;
239f109c240SMintz, Yuval }
240f109c240SMintz, Yuval
241f109c240SMintz, Yuval return qed_iov_validate_queue_mode(p_hwfn, p_vf, rx_qid, mode, false);
24241086467SYuval Mintz }
24341086467SYuval Mintz
qed_iov_validate_txq(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,u16 tx_qid,enum qed_iov_validate_q_mode mode)24441086467SYuval Mintz static bool qed_iov_validate_txq(struct qed_hwfn *p_hwfn,
245f109c240SMintz, Yuval struct qed_vf_info *p_vf,
246f109c240SMintz, Yuval u16 tx_qid,
247f109c240SMintz, Yuval enum qed_iov_validate_q_mode mode)
24841086467SYuval Mintz {
249f109c240SMintz, Yuval if (tx_qid >= p_vf->num_txqs) {
25041086467SYuval Mintz DP_VERBOSE(p_hwfn,
25141086467SYuval Mintz QED_MSG_IOV,
25241086467SYuval Mintz "VF[0x%02x] - can't touch Tx queue[%04x]; Only 0x%04x are allocated\n",
25341086467SYuval Mintz p_vf->abs_vf_id, tx_qid, p_vf->num_txqs);
254f109c240SMintz, Yuval return false;
255f109c240SMintz, Yuval }
256f109c240SMintz, Yuval
257f109c240SMintz, Yuval return qed_iov_validate_queue_mode(p_hwfn, p_vf, tx_qid, mode, true);
25841086467SYuval Mintz }
25941086467SYuval Mintz
qed_iov_validate_sb(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,u16 sb_idx)26041086467SYuval Mintz static bool qed_iov_validate_sb(struct qed_hwfn *p_hwfn,
26141086467SYuval Mintz struct qed_vf_info *p_vf, u16 sb_idx)
26241086467SYuval Mintz {
26341086467SYuval Mintz int i;
26441086467SYuval Mintz
26541086467SYuval Mintz for (i = 0; i < p_vf->num_sbs; i++)
26641086467SYuval Mintz if (p_vf->igu_sbs[i] == sb_idx)
26741086467SYuval Mintz return true;
26841086467SYuval Mintz
26941086467SYuval Mintz DP_VERBOSE(p_hwfn,
27041086467SYuval Mintz QED_MSG_IOV,
27141086467SYuval Mintz "VF[0%02x] - tried using sb_idx %04x which doesn't exist as one of its 0x%02x SBs\n",
27241086467SYuval Mintz p_vf->abs_vf_id, sb_idx, p_vf->num_sbs);
27341086467SYuval Mintz
27441086467SYuval Mintz return false;
27541086467SYuval Mintz }
27641086467SYuval Mintz
qed_iov_validate_active_rxq(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf)277f109c240SMintz, Yuval static bool qed_iov_validate_active_rxq(struct qed_hwfn *p_hwfn,
278f109c240SMintz, Yuval struct qed_vf_info *p_vf)
279f109c240SMintz, Yuval {
280f109c240SMintz, Yuval u8 i;
281f109c240SMintz, Yuval
282f109c240SMintz, Yuval for (i = 0; i < p_vf->num_rxqs; i++)
283f109c240SMintz, Yuval if (qed_iov_validate_queue_mode(p_hwfn, p_vf, i,
284f109c240SMintz, Yuval QED_IOV_VALIDATE_Q_ENABLE,
285f109c240SMintz, Yuval false))
286f109c240SMintz, Yuval return true;
287f109c240SMintz, Yuval
288f109c240SMintz, Yuval return false;
289f109c240SMintz, Yuval }
290f109c240SMintz, Yuval
qed_iov_validate_active_txq(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf)291f109c240SMintz, Yuval static bool qed_iov_validate_active_txq(struct qed_hwfn *p_hwfn,
292f109c240SMintz, Yuval struct qed_vf_info *p_vf)
293f109c240SMintz, Yuval {
294f109c240SMintz, Yuval u8 i;
295f109c240SMintz, Yuval
296f109c240SMintz, Yuval for (i = 0; i < p_vf->num_txqs; i++)
297f109c240SMintz, Yuval if (qed_iov_validate_queue_mode(p_hwfn, p_vf, i,
298f109c240SMintz, Yuval QED_IOV_VALIDATE_Q_ENABLE,
299f109c240SMintz, Yuval true))
300f109c240SMintz, Yuval return true;
301f109c240SMintz, Yuval
302f109c240SMintz, Yuval return false;
303f109c240SMintz, Yuval }
304f109c240SMintz, Yuval
qed_iov_post_vf_bulletin(struct qed_hwfn * p_hwfn,int vfid,struct qed_ptt * p_ptt)305ba56947aSBaoyou Xie static int qed_iov_post_vf_bulletin(struct qed_hwfn *p_hwfn,
30636558c3dSYuval Mintz int vfid, struct qed_ptt *p_ptt)
30736558c3dSYuval Mintz {
30836558c3dSYuval Mintz struct qed_bulletin_content *p_bulletin;
30936558c3dSYuval Mintz int crc_size = sizeof(p_bulletin->crc);
31036558c3dSYuval Mintz struct qed_dmae_params params;
31136558c3dSYuval Mintz struct qed_vf_info *p_vf;
31236558c3dSYuval Mintz
31336558c3dSYuval Mintz p_vf = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
31436558c3dSYuval Mintz if (!p_vf)
31536558c3dSYuval Mintz return -EINVAL;
31636558c3dSYuval Mintz
31736558c3dSYuval Mintz if (!p_vf->vf_bulletin)
31836558c3dSYuval Mintz return -EINVAL;
31936558c3dSYuval Mintz
32036558c3dSYuval Mintz p_bulletin = p_vf->bulletin.p_virt;
32136558c3dSYuval Mintz
32236558c3dSYuval Mintz /* Increment bulletin board version and compute crc */
32336558c3dSYuval Mintz p_bulletin->version++;
32436558c3dSYuval Mintz p_bulletin->crc = crc32(0, (u8 *)p_bulletin + crc_size,
32536558c3dSYuval Mintz p_vf->bulletin.size - crc_size);
32636558c3dSYuval Mintz
32736558c3dSYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
32836558c3dSYuval Mintz "Posting Bulletin 0x%08x to VF[%d] (CRC 0x%08x)\n",
32936558c3dSYuval Mintz p_bulletin->version, p_vf->relative_vf_id, p_bulletin->crc);
33036558c3dSYuval Mintz
33136558c3dSYuval Mintz /* propagate bulletin board via dmae to vm memory */
33236558c3dSYuval Mintz memset(¶ms, 0, sizeof(params));
333804c5702SMichal Kalderon SET_FIELD(params.flags, QED_DMAE_PARAMS_DST_VF_VALID, 0x1);
33436558c3dSYuval Mintz params.dst_vfid = p_vf->abs_vf_id;
33536558c3dSYuval Mintz return qed_dmae_host2host(p_hwfn, p_ptt, p_vf->bulletin.phys,
33636558c3dSYuval Mintz p_vf->vf_bulletin, p_vf->bulletin.size / 4,
33736558c3dSYuval Mintz ¶ms);
33836558c3dSYuval Mintz }
33936558c3dSYuval Mintz
qed_iov_pci_cfg_info(struct qed_dev * cdev)34032a47e72SYuval Mintz static int qed_iov_pci_cfg_info(struct qed_dev *cdev)
34132a47e72SYuval Mintz {
34232a47e72SYuval Mintz struct qed_hw_sriov_info *iov = cdev->p_iov_info;
34332a47e72SYuval Mintz int pos = iov->pos;
34432a47e72SYuval Mintz
34532a47e72SYuval Mintz DP_VERBOSE(cdev, QED_MSG_IOV, "sriov ext pos %d\n", pos);
34632a47e72SYuval Mintz pci_read_config_word(cdev->pdev, pos + PCI_SRIOV_CTRL, &iov->ctrl);
34732a47e72SYuval Mintz
34832a47e72SYuval Mintz pci_read_config_word(cdev->pdev,
34932a47e72SYuval Mintz pos + PCI_SRIOV_TOTAL_VF, &iov->total_vfs);
35032a47e72SYuval Mintz pci_read_config_word(cdev->pdev,
35132a47e72SYuval Mintz pos + PCI_SRIOV_INITIAL_VF, &iov->initial_vfs);
35232a47e72SYuval Mintz
35332a47e72SYuval Mintz pci_read_config_word(cdev->pdev, pos + PCI_SRIOV_NUM_VF, &iov->num_vfs);
35432a47e72SYuval Mintz if (iov->num_vfs) {
35532a47e72SYuval Mintz DP_VERBOSE(cdev,
35632a47e72SYuval Mintz QED_MSG_IOV,
35732a47e72SYuval Mintz "Number of VFs are already set to non-zero value. Ignoring PCI configuration value\n");
35832a47e72SYuval Mintz iov->num_vfs = 0;
35932a47e72SYuval Mintz }
36032a47e72SYuval Mintz
36132a47e72SYuval Mintz pci_read_config_word(cdev->pdev,
36232a47e72SYuval Mintz pos + PCI_SRIOV_VF_OFFSET, &iov->offset);
36332a47e72SYuval Mintz
36432a47e72SYuval Mintz pci_read_config_word(cdev->pdev,
36532a47e72SYuval Mintz pos + PCI_SRIOV_VF_STRIDE, &iov->stride);
36632a47e72SYuval Mintz
36732a47e72SYuval Mintz pci_read_config_word(cdev->pdev,
36832a47e72SYuval Mintz pos + PCI_SRIOV_VF_DID, &iov->vf_device_id);
36932a47e72SYuval Mintz
37032a47e72SYuval Mintz pci_read_config_dword(cdev->pdev,
37132a47e72SYuval Mintz pos + PCI_SRIOV_SUP_PGSIZE, &iov->pgsz);
37232a47e72SYuval Mintz
37332a47e72SYuval Mintz pci_read_config_dword(cdev->pdev, pos + PCI_SRIOV_CAP, &iov->cap);
37432a47e72SYuval Mintz
37532a47e72SYuval Mintz pci_read_config_byte(cdev->pdev, pos + PCI_SRIOV_FUNC_LINK, &iov->link);
37632a47e72SYuval Mintz
37732a47e72SYuval Mintz DP_VERBOSE(cdev,
37832a47e72SYuval Mintz QED_MSG_IOV,
37932a47e72SYuval Mintz "IOV info: nres %d, cap 0x%x, ctrl 0x%x, total %d, initial %d, num vfs %d, offset %d, stride %d, page size 0x%x\n",
38032a47e72SYuval Mintz iov->nres,
38132a47e72SYuval Mintz iov->cap,
38232a47e72SYuval Mintz iov->ctrl,
38332a47e72SYuval Mintz iov->total_vfs,
38432a47e72SYuval Mintz iov->initial_vfs,
38532a47e72SYuval Mintz iov->nr_virtfn, iov->offset, iov->stride, iov->pgsz);
38632a47e72SYuval Mintz
38732a47e72SYuval Mintz /* Some sanity checks */
38832a47e72SYuval Mintz if (iov->num_vfs > NUM_OF_VFS(cdev) ||
38932a47e72SYuval Mintz iov->total_vfs > NUM_OF_VFS(cdev)) {
39032a47e72SYuval Mintz /* This can happen only due to a bug. In this case we set
39132a47e72SYuval Mintz * num_vfs to zero to avoid memory corruption in the code that
39232a47e72SYuval Mintz * assumes max number of vfs
39332a47e72SYuval Mintz */
39432a47e72SYuval Mintz DP_NOTICE(cdev,
39532a47e72SYuval Mintz "IOV: Unexpected number of vfs set: %d setting num_vf to zero\n",
39632a47e72SYuval Mintz iov->num_vfs);
39732a47e72SYuval Mintz
39832a47e72SYuval Mintz iov->num_vfs = 0;
39932a47e72SYuval Mintz iov->total_vfs = 0;
40032a47e72SYuval Mintz }
40132a47e72SYuval Mintz
40232a47e72SYuval Mintz return 0;
40332a47e72SYuval Mintz }
40432a47e72SYuval Mintz
qed_iov_setup_vfdb(struct qed_hwfn * p_hwfn)40532a47e72SYuval Mintz static void qed_iov_setup_vfdb(struct qed_hwfn *p_hwfn)
40632a47e72SYuval Mintz {
40732a47e72SYuval Mintz struct qed_hw_sriov_info *p_iov = p_hwfn->cdev->p_iov_info;
40832a47e72SYuval Mintz struct qed_pf_iov *p_iov_info = p_hwfn->pf_iov_info;
40932a47e72SYuval Mintz struct qed_bulletin_content *p_bulletin_virt;
41032a47e72SYuval Mintz dma_addr_t req_p, rply_p, bulletin_p;
41132a47e72SYuval Mintz union pfvf_tlvs *p_reply_virt_addr;
41232a47e72SYuval Mintz union vfpf_tlvs *p_req_virt_addr;
41332a47e72SYuval Mintz u8 idx = 0;
41432a47e72SYuval Mintz
41532a47e72SYuval Mintz memset(p_iov_info->vfs_array, 0, sizeof(p_iov_info->vfs_array));
41632a47e72SYuval Mintz
41732a47e72SYuval Mintz p_req_virt_addr = p_iov_info->mbx_msg_virt_addr;
41832a47e72SYuval Mintz req_p = p_iov_info->mbx_msg_phys_addr;
41932a47e72SYuval Mintz p_reply_virt_addr = p_iov_info->mbx_reply_virt_addr;
42032a47e72SYuval Mintz rply_p = p_iov_info->mbx_reply_phys_addr;
42132a47e72SYuval Mintz p_bulletin_virt = p_iov_info->p_bulletins;
42232a47e72SYuval Mintz bulletin_p = p_iov_info->bulletins_phys;
42332a47e72SYuval Mintz if (!p_req_virt_addr || !p_reply_virt_addr || !p_bulletin_virt) {
42432a47e72SYuval Mintz DP_ERR(p_hwfn,
425fe40a830SPrabhakar Kushwaha "%s called without allocating mem first\n", __func__);
42632a47e72SYuval Mintz return;
42732a47e72SYuval Mintz }
42832a47e72SYuval Mintz
42932a47e72SYuval Mintz for (idx = 0; idx < p_iov->total_vfs; idx++) {
43032a47e72SYuval Mintz struct qed_vf_info *vf = &p_iov_info->vfs_array[idx];
43132a47e72SYuval Mintz u32 concrete;
43232a47e72SYuval Mintz
43332a47e72SYuval Mintz vf->vf_mbx.req_virt = p_req_virt_addr + idx;
43432a47e72SYuval Mintz vf->vf_mbx.req_phys = req_p + idx * sizeof(union vfpf_tlvs);
43532a47e72SYuval Mintz vf->vf_mbx.reply_virt = p_reply_virt_addr + idx;
43632a47e72SYuval Mintz vf->vf_mbx.reply_phys = rply_p + idx * sizeof(union pfvf_tlvs);
43732a47e72SYuval Mintz
43832a47e72SYuval Mintz vf->state = VF_STOPPED;
43932a47e72SYuval Mintz vf->b_init = false;
44032a47e72SYuval Mintz
44132a47e72SYuval Mintz vf->bulletin.phys = idx *
44232a47e72SYuval Mintz sizeof(struct qed_bulletin_content) +
44332a47e72SYuval Mintz bulletin_p;
44432a47e72SYuval Mintz vf->bulletin.p_virt = p_bulletin_virt + idx;
44532a47e72SYuval Mintz vf->bulletin.size = sizeof(struct qed_bulletin_content);
44632a47e72SYuval Mintz
44732a47e72SYuval Mintz vf->relative_vf_id = idx;
44832a47e72SYuval Mintz vf->abs_vf_id = idx + p_iov->first_vf_in_pf;
44932a47e72SYuval Mintz concrete = qed_vfid_to_concrete(p_hwfn, vf->abs_vf_id);
45032a47e72SYuval Mintz vf->concrete_fid = concrete;
45132a47e72SYuval Mintz vf->opaque_fid = (p_hwfn->hw_info.opaque_fid & 0xff) |
45232a47e72SYuval Mintz (vf->abs_vf_id << 8);
45332a47e72SYuval Mintz vf->vport_id = idx + 1;
4541cf2b1a9SYuval Mintz
4551cf2b1a9SYuval Mintz vf->num_mac_filters = QED_ETH_VF_NUM_MAC_FILTERS;
4561cf2b1a9SYuval Mintz vf->num_vlan_filters = QED_ETH_VF_NUM_VLAN_FILTERS;
45732a47e72SYuval Mintz }
45832a47e72SYuval Mintz }
45932a47e72SYuval Mintz
qed_iov_allocate_vfdb(struct qed_hwfn * p_hwfn)46032a47e72SYuval Mintz static int qed_iov_allocate_vfdb(struct qed_hwfn *p_hwfn)
46132a47e72SYuval Mintz {
46232a47e72SYuval Mintz struct qed_pf_iov *p_iov_info = p_hwfn->pf_iov_info;
46332a47e72SYuval Mintz void **p_v_addr;
46432a47e72SYuval Mintz u16 num_vfs = 0;
46532a47e72SYuval Mintz
46632a47e72SYuval Mintz num_vfs = p_hwfn->cdev->p_iov_info->total_vfs;
46732a47e72SYuval Mintz
46832a47e72SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
469fe40a830SPrabhakar Kushwaha "%s for %d VFs\n", __func__, num_vfs);
47032a47e72SYuval Mintz
47132a47e72SYuval Mintz /* Allocate PF Mailbox buffer (per-VF) */
47232a47e72SYuval Mintz p_iov_info->mbx_msg_size = sizeof(union vfpf_tlvs) * num_vfs;
47332a47e72SYuval Mintz p_v_addr = &p_iov_info->mbx_msg_virt_addr;
47432a47e72SYuval Mintz *p_v_addr = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev,
47532a47e72SYuval Mintz p_iov_info->mbx_msg_size,
47632a47e72SYuval Mintz &p_iov_info->mbx_msg_phys_addr,
47732a47e72SYuval Mintz GFP_KERNEL);
47832a47e72SYuval Mintz if (!*p_v_addr)
47932a47e72SYuval Mintz return -ENOMEM;
48032a47e72SYuval Mintz
48132a47e72SYuval Mintz /* Allocate PF Mailbox Reply buffer (per-VF) */
48232a47e72SYuval Mintz p_iov_info->mbx_reply_size = sizeof(union pfvf_tlvs) * num_vfs;
48332a47e72SYuval Mintz p_v_addr = &p_iov_info->mbx_reply_virt_addr;
48432a47e72SYuval Mintz *p_v_addr = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev,
48532a47e72SYuval Mintz p_iov_info->mbx_reply_size,
48632a47e72SYuval Mintz &p_iov_info->mbx_reply_phys_addr,
48732a47e72SYuval Mintz GFP_KERNEL);
48832a47e72SYuval Mintz if (!*p_v_addr)
48932a47e72SYuval Mintz return -ENOMEM;
49032a47e72SYuval Mintz
49132a47e72SYuval Mintz p_iov_info->bulletins_size = sizeof(struct qed_bulletin_content) *
49232a47e72SYuval Mintz num_vfs;
49332a47e72SYuval Mintz p_v_addr = &p_iov_info->p_bulletins;
49432a47e72SYuval Mintz *p_v_addr = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev,
49532a47e72SYuval Mintz p_iov_info->bulletins_size,
49632a47e72SYuval Mintz &p_iov_info->bulletins_phys,
49732a47e72SYuval Mintz GFP_KERNEL);
49832a47e72SYuval Mintz if (!*p_v_addr)
49932a47e72SYuval Mintz return -ENOMEM;
50032a47e72SYuval Mintz
50132a47e72SYuval Mintz DP_VERBOSE(p_hwfn,
50232a47e72SYuval Mintz QED_MSG_IOV,
50332a47e72SYuval Mintz "PF's Requests mailbox [%p virt 0x%llx phys], Response mailbox [%p virt 0x%llx phys] Bulletins [%p virt 0x%llx phys]\n",
50432a47e72SYuval Mintz p_iov_info->mbx_msg_virt_addr,
50532a47e72SYuval Mintz (u64)p_iov_info->mbx_msg_phys_addr,
50632a47e72SYuval Mintz p_iov_info->mbx_reply_virt_addr,
50732a47e72SYuval Mintz (u64)p_iov_info->mbx_reply_phys_addr,
50832a47e72SYuval Mintz p_iov_info->p_bulletins, (u64)p_iov_info->bulletins_phys);
50932a47e72SYuval Mintz
51032a47e72SYuval Mintz return 0;
51132a47e72SYuval Mintz }
51232a47e72SYuval Mintz
qed_iov_free_vfdb(struct qed_hwfn * p_hwfn)51332a47e72SYuval Mintz static void qed_iov_free_vfdb(struct qed_hwfn *p_hwfn)
51432a47e72SYuval Mintz {
51532a47e72SYuval Mintz struct qed_pf_iov *p_iov_info = p_hwfn->pf_iov_info;
51632a47e72SYuval Mintz
51732a47e72SYuval Mintz if (p_hwfn->pf_iov_info->mbx_msg_virt_addr)
51832a47e72SYuval Mintz dma_free_coherent(&p_hwfn->cdev->pdev->dev,
51932a47e72SYuval Mintz p_iov_info->mbx_msg_size,
52032a47e72SYuval Mintz p_iov_info->mbx_msg_virt_addr,
52132a47e72SYuval Mintz p_iov_info->mbx_msg_phys_addr);
52232a47e72SYuval Mintz
52332a47e72SYuval Mintz if (p_hwfn->pf_iov_info->mbx_reply_virt_addr)
52432a47e72SYuval Mintz dma_free_coherent(&p_hwfn->cdev->pdev->dev,
52532a47e72SYuval Mintz p_iov_info->mbx_reply_size,
52632a47e72SYuval Mintz p_iov_info->mbx_reply_virt_addr,
52732a47e72SYuval Mintz p_iov_info->mbx_reply_phys_addr);
52832a47e72SYuval Mintz
52932a47e72SYuval Mintz if (p_iov_info->p_bulletins)
53032a47e72SYuval Mintz dma_free_coherent(&p_hwfn->cdev->pdev->dev,
53132a47e72SYuval Mintz p_iov_info->bulletins_size,
53232a47e72SYuval Mintz p_iov_info->p_bulletins,
53332a47e72SYuval Mintz p_iov_info->bulletins_phys);
53432a47e72SYuval Mintz }
53532a47e72SYuval Mintz
qed_iov_alloc(struct qed_hwfn * p_hwfn)53632a47e72SYuval Mintz int qed_iov_alloc(struct qed_hwfn *p_hwfn)
53732a47e72SYuval Mintz {
53832a47e72SYuval Mintz struct qed_pf_iov *p_sriov;
53932a47e72SYuval Mintz
54032a47e72SYuval Mintz if (!IS_PF_SRIOV(p_hwfn)) {
54132a47e72SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
54232a47e72SYuval Mintz "No SR-IOV - no need for IOV db\n");
54332a47e72SYuval Mintz return 0;
54432a47e72SYuval Mintz }
54532a47e72SYuval Mintz
54632a47e72SYuval Mintz p_sriov = kzalloc(sizeof(*p_sriov), GFP_KERNEL);
5472591c280SJoe Perches if (!p_sriov)
54832a47e72SYuval Mintz return -ENOMEM;
54932a47e72SYuval Mintz
55032a47e72SYuval Mintz p_hwfn->pf_iov_info = p_sriov;
55132a47e72SYuval Mintz
5526c9e80eaSMichal Kalderon qed_spq_register_async_cb(p_hwfn, PROTOCOLID_COMMON,
5536c9e80eaSMichal Kalderon qed_sriov_eqe_event);
5546c9e80eaSMichal Kalderon
55532a47e72SYuval Mintz return qed_iov_allocate_vfdb(p_hwfn);
55632a47e72SYuval Mintz }
55732a47e72SYuval Mintz
qed_iov_setup(struct qed_hwfn * p_hwfn)5581ee240e3SMintz, Yuval void qed_iov_setup(struct qed_hwfn *p_hwfn)
55932a47e72SYuval Mintz {
56032a47e72SYuval Mintz if (!IS_PF_SRIOV(p_hwfn) || !IS_PF_SRIOV_ALLOC(p_hwfn))
56132a47e72SYuval Mintz return;
56232a47e72SYuval Mintz
56332a47e72SYuval Mintz qed_iov_setup_vfdb(p_hwfn);
56432a47e72SYuval Mintz }
56532a47e72SYuval Mintz
qed_iov_free(struct qed_hwfn * p_hwfn)56632a47e72SYuval Mintz void qed_iov_free(struct qed_hwfn *p_hwfn)
56732a47e72SYuval Mintz {
5686c9e80eaSMichal Kalderon qed_spq_unregister_async_cb(p_hwfn, PROTOCOLID_COMMON);
5696c9e80eaSMichal Kalderon
57032a47e72SYuval Mintz if (IS_PF_SRIOV_ALLOC(p_hwfn)) {
57132a47e72SYuval Mintz qed_iov_free_vfdb(p_hwfn);
57232a47e72SYuval Mintz kfree(p_hwfn->pf_iov_info);
57332a47e72SYuval Mintz }
57432a47e72SYuval Mintz }
57532a47e72SYuval Mintz
qed_iov_free_hw_info(struct qed_dev * cdev)57632a47e72SYuval Mintz void qed_iov_free_hw_info(struct qed_dev *cdev)
57732a47e72SYuval Mintz {
57832a47e72SYuval Mintz kfree(cdev->p_iov_info);
57932a47e72SYuval Mintz cdev->p_iov_info = NULL;
58032a47e72SYuval Mintz }
58132a47e72SYuval Mintz
qed_iov_hw_info(struct qed_hwfn * p_hwfn)58232a47e72SYuval Mintz int qed_iov_hw_info(struct qed_hwfn *p_hwfn)
58332a47e72SYuval Mintz {
58432a47e72SYuval Mintz struct qed_dev *cdev = p_hwfn->cdev;
58532a47e72SYuval Mintz int pos;
58632a47e72SYuval Mintz int rc;
58732a47e72SYuval Mintz
5886da95b52SAlok Prasad if (is_kdump_kernel())
5896da95b52SAlok Prasad return 0;
5906da95b52SAlok Prasad
5911408cc1fSYuval Mintz if (IS_VF(p_hwfn->cdev))
5921408cc1fSYuval Mintz return 0;
5931408cc1fSYuval Mintz
59432a47e72SYuval Mintz /* Learn the PCI configuration */
59532a47e72SYuval Mintz pos = pci_find_ext_capability(p_hwfn->cdev->pdev,
59632a47e72SYuval Mintz PCI_EXT_CAP_ID_SRIOV);
59732a47e72SYuval Mintz if (!pos) {
59832a47e72SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV, "No PCIe IOV support\n");
59932a47e72SYuval Mintz return 0;
60032a47e72SYuval Mintz }
60132a47e72SYuval Mintz
60232a47e72SYuval Mintz /* Allocate a new struct for IOV information */
60332a47e72SYuval Mintz cdev->p_iov_info = kzalloc(sizeof(*cdev->p_iov_info), GFP_KERNEL);
6042591c280SJoe Perches if (!cdev->p_iov_info)
60532a47e72SYuval Mintz return -ENOMEM;
6062591c280SJoe Perches
60732a47e72SYuval Mintz cdev->p_iov_info->pos = pos;
60832a47e72SYuval Mintz
60932a47e72SYuval Mintz rc = qed_iov_pci_cfg_info(cdev);
61032a47e72SYuval Mintz if (rc)
61132a47e72SYuval Mintz return rc;
61232a47e72SYuval Mintz
613fe40a830SPrabhakar Kushwaha /* We want PF IOV to be synonemous with the existence of p_iov_info;
61432a47e72SYuval Mintz * In case the capability is published but there are no VFs, simply
61532a47e72SYuval Mintz * de-allocate the struct.
61632a47e72SYuval Mintz */
61732a47e72SYuval Mintz if (!cdev->p_iov_info->total_vfs) {
61832a47e72SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
61932a47e72SYuval Mintz "IOV capabilities, but no VFs are published\n");
62032a47e72SYuval Mintz kfree(cdev->p_iov_info);
62132a47e72SYuval Mintz cdev->p_iov_info = NULL;
62232a47e72SYuval Mintz return 0;
62332a47e72SYuval Mintz }
62432a47e72SYuval Mintz
6259c79ddaaSMintz, Yuval /* First VF index based on offset is tricky:
6269c79ddaaSMintz, Yuval * - If ARI is supported [likely], offset - (16 - pf_id) would
6279c79ddaaSMintz, Yuval * provide the number for eng0. 2nd engine Vfs would begin
62832a47e72SYuval Mintz * after the first engine's VFs.
6299c79ddaaSMintz, Yuval * - If !ARI, VFs would start on next device.
6309c79ddaaSMintz, Yuval * so offset - (256 - pf_id) would provide the number.
6319c79ddaaSMintz, Yuval * Utilize the fact that (256 - pf_id) is achieved only by later
6328ac1ed79SJoe Perches * to differentiate between the two.
63332a47e72SYuval Mintz */
6349c79ddaaSMintz, Yuval
6359c79ddaaSMintz, Yuval if (p_hwfn->cdev->p_iov_info->offset < (256 - p_hwfn->abs_pf_id)) {
6369c79ddaaSMintz, Yuval u32 first = p_hwfn->cdev->p_iov_info->offset +
63732a47e72SYuval Mintz p_hwfn->abs_pf_id - 16;
6389c79ddaaSMintz, Yuval
6399c79ddaaSMintz, Yuval cdev->p_iov_info->first_vf_in_pf = first;
6409c79ddaaSMintz, Yuval
64132a47e72SYuval Mintz if (QED_PATH_ID(p_hwfn))
64232a47e72SYuval Mintz cdev->p_iov_info->first_vf_in_pf -= MAX_NUM_VFS_BB;
6439c79ddaaSMintz, Yuval } else {
6449c79ddaaSMintz, Yuval u32 first = p_hwfn->cdev->p_iov_info->offset +
6459c79ddaaSMintz, Yuval p_hwfn->abs_pf_id - 256;
6469c79ddaaSMintz, Yuval
6479c79ddaaSMintz, Yuval cdev->p_iov_info->first_vf_in_pf = first;
6489c79ddaaSMintz, Yuval }
64932a47e72SYuval Mintz
65032a47e72SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
65132a47e72SYuval Mintz "First VF in hwfn 0x%08x\n",
65232a47e72SYuval Mintz cdev->p_iov_info->first_vf_in_pf);
65332a47e72SYuval Mintz
65432a47e72SYuval Mintz return 0;
65532a47e72SYuval Mintz }
65632a47e72SYuval Mintz
_qed_iov_pf_sanity_check(struct qed_hwfn * p_hwfn,int vfid,bool b_fail_malicious)657bf774d14SYueHaibing static bool _qed_iov_pf_sanity_check(struct qed_hwfn *p_hwfn,
6587eff82b0SYuval Mintz int vfid, bool b_fail_malicious)
65937bff2b9SYuval Mintz {
66037bff2b9SYuval Mintz /* Check PF supports sriov */
661b0409fa0SYuval Mintz if (IS_VF(p_hwfn->cdev) || !IS_QED_SRIOV(p_hwfn->cdev) ||
662b0409fa0SYuval Mintz !IS_PF_SRIOV_ALLOC(p_hwfn))
66337bff2b9SYuval Mintz return false;
66437bff2b9SYuval Mintz
66537bff2b9SYuval Mintz /* Check VF validity */
6667eff82b0SYuval Mintz if (!qed_iov_is_valid_vfid(p_hwfn, vfid, true, b_fail_malicious))
66737bff2b9SYuval Mintz return false;
66837bff2b9SYuval Mintz
66937bff2b9SYuval Mintz return true;
67037bff2b9SYuval Mintz }
67137bff2b9SYuval Mintz
qed_iov_pf_sanity_check(struct qed_hwfn * p_hwfn,int vfid)672bf774d14SYueHaibing static bool qed_iov_pf_sanity_check(struct qed_hwfn *p_hwfn, int vfid)
6737eff82b0SYuval Mintz {
6747eff82b0SYuval Mintz return _qed_iov_pf_sanity_check(p_hwfn, vfid, true);
6757eff82b0SYuval Mintz }
6767eff82b0SYuval Mintz
qed_iov_set_vf_to_disable(struct qed_dev * cdev,u16 rel_vf_id,u8 to_disable)6770b55e27dSYuval Mintz static void qed_iov_set_vf_to_disable(struct qed_dev *cdev,
6780b55e27dSYuval Mintz u16 rel_vf_id, u8 to_disable)
6790b55e27dSYuval Mintz {
6800b55e27dSYuval Mintz struct qed_vf_info *vf;
6810b55e27dSYuval Mintz int i;
6820b55e27dSYuval Mintz
6830b55e27dSYuval Mintz for_each_hwfn(cdev, i) {
6840b55e27dSYuval Mintz struct qed_hwfn *p_hwfn = &cdev->hwfns[i];
6850b55e27dSYuval Mintz
6860b55e27dSYuval Mintz vf = qed_iov_get_vf_info(p_hwfn, rel_vf_id, false);
6870b55e27dSYuval Mintz if (!vf)
6880b55e27dSYuval Mintz continue;
6890b55e27dSYuval Mintz
6900b55e27dSYuval Mintz vf->to_disable = to_disable;
6910b55e27dSYuval Mintz }
6920b55e27dSYuval Mintz }
6930b55e27dSYuval Mintz
qed_iov_set_vfs_to_disable(struct qed_dev * cdev,u8 to_disable)694ba56947aSBaoyou Xie static void qed_iov_set_vfs_to_disable(struct qed_dev *cdev, u8 to_disable)
6950b55e27dSYuval Mintz {
6960b55e27dSYuval Mintz u16 i;
6970b55e27dSYuval Mintz
6980b55e27dSYuval Mintz if (!IS_QED_SRIOV(cdev))
6990b55e27dSYuval Mintz return;
7000b55e27dSYuval Mintz
7010b55e27dSYuval Mintz for (i = 0; i < cdev->p_iov_info->total_vfs; i++)
7020b55e27dSYuval Mintz qed_iov_set_vf_to_disable(cdev, i, to_disable);
7030b55e27dSYuval Mintz }
7040b55e27dSYuval Mintz
qed_iov_vf_pglue_clear_err(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,u8 abs_vfid)7051408cc1fSYuval Mintz static void qed_iov_vf_pglue_clear_err(struct qed_hwfn *p_hwfn,
7061408cc1fSYuval Mintz struct qed_ptt *p_ptt, u8 abs_vfid)
7071408cc1fSYuval Mintz {
7081408cc1fSYuval Mintz qed_wr(p_hwfn, p_ptt,
7091408cc1fSYuval Mintz PGLUE_B_REG_WAS_ERROR_VF_31_0_CLR + (abs_vfid >> 5) * 4,
7101408cc1fSYuval Mintz 1 << (abs_vfid & 0x1f));
7111408cc1fSYuval Mintz }
7121408cc1fSYuval Mintz
qed_iov_vf_igu_reset(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)713dacd88d6SYuval Mintz static void qed_iov_vf_igu_reset(struct qed_hwfn *p_hwfn,
714dacd88d6SYuval Mintz struct qed_ptt *p_ptt, struct qed_vf_info *vf)
715dacd88d6SYuval Mintz {
716dacd88d6SYuval Mintz int i;
717dacd88d6SYuval Mintz
718dacd88d6SYuval Mintz /* Set VF masks and configuration - pretend */
719dacd88d6SYuval Mintz qed_fid_pretend(p_hwfn, p_ptt, (u16)vf->concrete_fid);
720dacd88d6SYuval Mintz
721dacd88d6SYuval Mintz qed_wr(p_hwfn, p_ptt, IGU_REG_STATISTIC_NUM_VF_MSG_SENT, 0);
722dacd88d6SYuval Mintz
723dacd88d6SYuval Mintz /* unpretend */
724dacd88d6SYuval Mintz qed_fid_pretend(p_hwfn, p_ptt, (u16)p_hwfn->hw_info.concrete_fid);
725dacd88d6SYuval Mintz
726dacd88d6SYuval Mintz /* iterate over all queues, clear sb consumer */
727b2b897ebSYuval Mintz for (i = 0; i < vf->num_sbs; i++)
728b2b897ebSYuval Mintz qed_int_igu_init_pure_rt_single(p_hwfn, p_ptt,
729b2b897ebSYuval Mintz vf->igu_sbs[i],
730b2b897ebSYuval Mintz vf->opaque_fid, true);
731dacd88d6SYuval Mintz }
732dacd88d6SYuval Mintz
qed_iov_vf_igu_set_int(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf,bool enable)7330b55e27dSYuval Mintz static void qed_iov_vf_igu_set_int(struct qed_hwfn *p_hwfn,
7340b55e27dSYuval Mintz struct qed_ptt *p_ptt,
7350b55e27dSYuval Mintz struct qed_vf_info *vf, bool enable)
7360b55e27dSYuval Mintz {
7370b55e27dSYuval Mintz u32 igu_vf_conf;
7380b55e27dSYuval Mintz
7390b55e27dSYuval Mintz qed_fid_pretend(p_hwfn, p_ptt, (u16)vf->concrete_fid);
7400b55e27dSYuval Mintz
7410b55e27dSYuval Mintz igu_vf_conf = qed_rd(p_hwfn, p_ptt, IGU_REG_VF_CONFIGURATION);
7420b55e27dSYuval Mintz
7430b55e27dSYuval Mintz if (enable)
7440b55e27dSYuval Mintz igu_vf_conf |= IGU_VF_CONF_MSI_MSIX_EN;
7450b55e27dSYuval Mintz else
7460b55e27dSYuval Mintz igu_vf_conf &= ~IGU_VF_CONF_MSI_MSIX_EN;
7470b55e27dSYuval Mintz
7480b55e27dSYuval Mintz qed_wr(p_hwfn, p_ptt, IGU_REG_VF_CONFIGURATION, igu_vf_conf);
7490b55e27dSYuval Mintz
7500b55e27dSYuval Mintz /* unpretend */
7510b55e27dSYuval Mintz qed_fid_pretend(p_hwfn, p_ptt, (u16)p_hwfn->hw_info.concrete_fid);
7520b55e27dSYuval Mintz }
7530b55e27dSYuval Mintz
75488072fd4SMintz, Yuval static int
qed_iov_enable_vf_access_msix(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,u8 abs_vf_id,u8 num_sbs)75588072fd4SMintz, Yuval qed_iov_enable_vf_access_msix(struct qed_hwfn *p_hwfn,
75688072fd4SMintz, Yuval struct qed_ptt *p_ptt, u8 abs_vf_id, u8 num_sbs)
75788072fd4SMintz, Yuval {
75888072fd4SMintz, Yuval u8 current_max = 0;
75988072fd4SMintz, Yuval int i;
76088072fd4SMintz, Yuval
76188072fd4SMintz, Yuval /* For AH onward, configuration is per-PF. Find maximum of all
76288072fd4SMintz, Yuval * the currently enabled child VFs, and set the number to be that.
76388072fd4SMintz, Yuval */
76488072fd4SMintz, Yuval if (!QED_IS_BB(p_hwfn->cdev)) {
76588072fd4SMintz, Yuval qed_for_each_vf(p_hwfn, i) {
76688072fd4SMintz, Yuval struct qed_vf_info *p_vf;
76788072fd4SMintz, Yuval
76888072fd4SMintz, Yuval p_vf = qed_iov_get_vf_info(p_hwfn, (u16)i, true);
76988072fd4SMintz, Yuval if (!p_vf)
77088072fd4SMintz, Yuval continue;
77188072fd4SMintz, Yuval
77288072fd4SMintz, Yuval current_max = max_t(u8, current_max, p_vf->num_sbs);
77388072fd4SMintz, Yuval }
77488072fd4SMintz, Yuval }
77588072fd4SMintz, Yuval
77688072fd4SMintz, Yuval if (num_sbs > current_max)
77788072fd4SMintz, Yuval return qed_mcp_config_vf_msix(p_hwfn, p_ptt,
77888072fd4SMintz, Yuval abs_vf_id, num_sbs);
77988072fd4SMintz, Yuval
78088072fd4SMintz, Yuval return 0;
78188072fd4SMintz, Yuval }
78288072fd4SMintz, Yuval
qed_iov_enable_vf_access(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)7831408cc1fSYuval Mintz static int qed_iov_enable_vf_access(struct qed_hwfn *p_hwfn,
7841408cc1fSYuval Mintz struct qed_ptt *p_ptt,
7851408cc1fSYuval Mintz struct qed_vf_info *vf)
7861408cc1fSYuval Mintz {
7871408cc1fSYuval Mintz u32 igu_vf_conf = IGU_VF_CONF_FUNC_EN;
7881408cc1fSYuval Mintz int rc;
7891408cc1fSYuval Mintz
7904e9b2a67SMintz, Yuval /* It's possible VF was previously considered malicious -
7914e9b2a67SMintz, Yuval * clear the indication even if we're only going to disable VF.
7924e9b2a67SMintz, Yuval */
7934e9b2a67SMintz, Yuval vf->b_malicious = false;
7944e9b2a67SMintz, Yuval
7950b55e27dSYuval Mintz if (vf->to_disable)
7960b55e27dSYuval Mintz return 0;
7970b55e27dSYuval Mintz
7981408cc1fSYuval Mintz DP_VERBOSE(p_hwfn,
7991408cc1fSYuval Mintz QED_MSG_IOV,
8001408cc1fSYuval Mintz "Enable internal access for vf %x [abs %x]\n",
8011408cc1fSYuval Mintz vf->abs_vf_id, QED_VF_ABS_ID(p_hwfn, vf));
8021408cc1fSYuval Mintz
8031408cc1fSYuval Mintz qed_iov_vf_pglue_clear_err(p_hwfn, p_ptt, QED_VF_ABS_ID(p_hwfn, vf));
8041408cc1fSYuval Mintz
805b2b897ebSYuval Mintz qed_iov_vf_igu_reset(p_hwfn, p_ptt, vf);
806b2b897ebSYuval Mintz
80788072fd4SMintz, Yuval rc = qed_iov_enable_vf_access_msix(p_hwfn, p_ptt,
80888072fd4SMintz, Yuval vf->abs_vf_id, vf->num_sbs);
8091408cc1fSYuval Mintz if (rc)
8101408cc1fSYuval Mintz return rc;
8111408cc1fSYuval Mintz
8121408cc1fSYuval Mintz qed_fid_pretend(p_hwfn, p_ptt, (u16)vf->concrete_fid);
8131408cc1fSYuval Mintz
8141408cc1fSYuval Mintz SET_FIELD(igu_vf_conf, IGU_VF_CONF_PARENT, p_hwfn->rel_pf_id);
8151408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, IGU_REG_VF_CONFIGURATION_RT_OFFSET, igu_vf_conf);
8161408cc1fSYuval Mintz
8171408cc1fSYuval Mintz qed_init_run(p_hwfn, p_ptt, PHASE_VF, vf->abs_vf_id,
8181408cc1fSYuval Mintz p_hwfn->hw_info.hw_mode);
8191408cc1fSYuval Mintz
8201408cc1fSYuval Mintz /* unpretend */
8211408cc1fSYuval Mintz qed_fid_pretend(p_hwfn, p_ptt, (u16)p_hwfn->hw_info.concrete_fid);
8221408cc1fSYuval Mintz
8231408cc1fSYuval Mintz vf->state = VF_FREE;
8241408cc1fSYuval Mintz
8251408cc1fSYuval Mintz return rc;
8261408cc1fSYuval Mintz }
8271408cc1fSYuval Mintz
8280b55e27dSYuval Mintz /**
82971e11a3fSAlexander Lobakin * qed_iov_config_perm_table() - Configure the permission zone table.
83071e11a3fSAlexander Lobakin *
83171e11a3fSAlexander Lobakin * @p_hwfn: HW device data.
83271e11a3fSAlexander Lobakin * @p_ptt: PTT window for writing the registers.
83371e11a3fSAlexander Lobakin * @vf: VF info data.
834a6f53606SDai Shixin * @enable: The actual permission for this VF.
83571e11a3fSAlexander Lobakin *
8360b55e27dSYuval Mintz * In E4, queue zone permission table size is 320x9. There
8370b55e27dSYuval Mintz * are 320 VF queues for single engine device (256 for dual
8380b55e27dSYuval Mintz * engine device), and each entry has the following format:
8390b55e27dSYuval Mintz * {Valid, VF[7:0]}
8400b55e27dSYuval Mintz */
qed_iov_config_perm_table(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf,u8 enable)8410b55e27dSYuval Mintz static void qed_iov_config_perm_table(struct qed_hwfn *p_hwfn,
8420b55e27dSYuval Mintz struct qed_ptt *p_ptt,
8430b55e27dSYuval Mintz struct qed_vf_info *vf, u8 enable)
8440b55e27dSYuval Mintz {
8450b55e27dSYuval Mintz u32 reg_addr, val;
8460b55e27dSYuval Mintz u16 qzone_id = 0;
8470b55e27dSYuval Mintz int qid;
8480b55e27dSYuval Mintz
8490b55e27dSYuval Mintz for (qid = 0; qid < vf->num_rxqs; qid++) {
8500b55e27dSYuval Mintz qed_fw_l2_queue(p_hwfn, vf->vf_queues[qid].fw_rx_qid,
8510b55e27dSYuval Mintz &qzone_id);
8520b55e27dSYuval Mintz
8530b55e27dSYuval Mintz reg_addr = PSWHST_REG_ZONE_PERMISSION_TABLE + qzone_id * 4;
8541a635e48SYuval Mintz val = enable ? (vf->abs_vf_id | BIT(8)) : 0;
8550b55e27dSYuval Mintz qed_wr(p_hwfn, p_ptt, reg_addr, val);
8560b55e27dSYuval Mintz }
8570b55e27dSYuval Mintz }
8580b55e27dSYuval Mintz
qed_iov_enable_vf_traffic(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)859dacd88d6SYuval Mintz static void qed_iov_enable_vf_traffic(struct qed_hwfn *p_hwfn,
860dacd88d6SYuval Mintz struct qed_ptt *p_ptt,
861dacd88d6SYuval Mintz struct qed_vf_info *vf)
862dacd88d6SYuval Mintz {
863dacd88d6SYuval Mintz /* Reset vf in IGU - interrupts are still disabled */
864dacd88d6SYuval Mintz qed_iov_vf_igu_reset(p_hwfn, p_ptt, vf);
865dacd88d6SYuval Mintz
866dacd88d6SYuval Mintz qed_iov_vf_igu_set_int(p_hwfn, p_ptt, vf, 1);
867dacd88d6SYuval Mintz
868dacd88d6SYuval Mintz /* Permission Table */
869dacd88d6SYuval Mintz qed_iov_config_perm_table(p_hwfn, p_ptt, vf, true);
870dacd88d6SYuval Mintz }
871dacd88d6SYuval Mintz
qed_iov_alloc_vf_igu_sbs(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf,u16 num_rx_queues)8721408cc1fSYuval Mintz static u8 qed_iov_alloc_vf_igu_sbs(struct qed_hwfn *p_hwfn,
8731408cc1fSYuval Mintz struct qed_ptt *p_ptt,
8741408cc1fSYuval Mintz struct qed_vf_info *vf, u16 num_rx_queues)
8751408cc1fSYuval Mintz {
87609b6b147SMintz, Yuval struct qed_igu_block *p_block;
87709b6b147SMintz, Yuval struct cau_sb_entry sb_entry;
87809b6b147SMintz, Yuval int qid = 0;
8791408cc1fSYuval Mintz u32 val = 0;
8801408cc1fSYuval Mintz
881726fdbe9SMintz, Yuval if (num_rx_queues > p_hwfn->hw_info.p_igu_info->usage.free_cnt_iov)
882726fdbe9SMintz, Yuval num_rx_queues = p_hwfn->hw_info.p_igu_info->usage.free_cnt_iov;
883726fdbe9SMintz, Yuval p_hwfn->hw_info.p_igu_info->usage.free_cnt_iov -= num_rx_queues;
8841408cc1fSYuval Mintz
8851408cc1fSYuval Mintz SET_FIELD(val, IGU_MAPPING_LINE_FUNCTION_NUMBER, vf->abs_vf_id);
8861408cc1fSYuval Mintz SET_FIELD(val, IGU_MAPPING_LINE_VALID, 1);
8871408cc1fSYuval Mintz SET_FIELD(val, IGU_MAPPING_LINE_PF_VALID, 0);
8881408cc1fSYuval Mintz
88909b6b147SMintz, Yuval for (qid = 0; qid < num_rx_queues; qid++) {
89009b6b147SMintz, Yuval p_block = qed_get_igu_free_sb(p_hwfn, false);
89109b6b147SMintz, Yuval vf->igu_sbs[qid] = p_block->igu_sb_id;
89209b6b147SMintz, Yuval p_block->status &= ~QED_IGU_STATUS_FREE;
8931408cc1fSYuval Mintz SET_FIELD(val, IGU_MAPPING_LINE_VECTOR_NUMBER, qid);
8941408cc1fSYuval Mintz
8951408cc1fSYuval Mintz qed_wr(p_hwfn, p_ptt,
89609b6b147SMintz, Yuval IGU_REG_MAPPING_MEMORY +
89709b6b147SMintz, Yuval sizeof(u32) * p_block->igu_sb_id, val);
8981408cc1fSYuval Mintz
8991408cc1fSYuval Mintz /* Configure igu sb in CAU which were marked valid */
9001408cc1fSYuval Mintz qed_init_cau_sb_entry(p_hwfn, &sb_entry,
90109b6b147SMintz, Yuval p_hwfn->rel_pf_id, vf->abs_vf_id, 1);
90283bf76e3SMichal Kalderon
9031408cc1fSYuval Mintz qed_dmae_host2grc(p_hwfn, p_ptt,
9041408cc1fSYuval Mintz (u64)(uintptr_t)&sb_entry,
9051408cc1fSYuval Mintz CAU_REG_SB_VAR_MEMORY +
90683bf76e3SMichal Kalderon p_block->igu_sb_id * sizeof(u64), 2, NULL);
9071408cc1fSYuval Mintz }
9081408cc1fSYuval Mintz
9091408cc1fSYuval Mintz vf->num_sbs = (u8)num_rx_queues;
9101408cc1fSYuval Mintz
9111408cc1fSYuval Mintz return vf->num_sbs;
9121408cc1fSYuval Mintz }
9131408cc1fSYuval Mintz
qed_iov_free_vf_igu_sbs(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)9140b55e27dSYuval Mintz static void qed_iov_free_vf_igu_sbs(struct qed_hwfn *p_hwfn,
9150b55e27dSYuval Mintz struct qed_ptt *p_ptt,
9160b55e27dSYuval Mintz struct qed_vf_info *vf)
9170b55e27dSYuval Mintz {
9180b55e27dSYuval Mintz struct qed_igu_info *p_info = p_hwfn->hw_info.p_igu_info;
9190b55e27dSYuval Mintz int idx, igu_id;
9200b55e27dSYuval Mintz u32 addr, val;
9210b55e27dSYuval Mintz
9220b55e27dSYuval Mintz /* Invalidate igu CAM lines and mark them as free */
9230b55e27dSYuval Mintz for (idx = 0; idx < vf->num_sbs; idx++) {
9240b55e27dSYuval Mintz igu_id = vf->igu_sbs[idx];
9250b55e27dSYuval Mintz addr = IGU_REG_MAPPING_MEMORY + sizeof(u32) * igu_id;
9260b55e27dSYuval Mintz
9270b55e27dSYuval Mintz val = qed_rd(p_hwfn, p_ptt, addr);
9280b55e27dSYuval Mintz SET_FIELD(val, IGU_MAPPING_LINE_VALID, 0);
9290b55e27dSYuval Mintz qed_wr(p_hwfn, p_ptt, addr, val);
9300b55e27dSYuval Mintz
931d749dd0dSMintz, Yuval p_info->entry[igu_id].status |= QED_IGU_STATUS_FREE;
932726fdbe9SMintz, Yuval p_hwfn->hw_info.p_igu_info->usage.free_cnt_iov++;
9330b55e27dSYuval Mintz }
9340b55e27dSYuval Mintz
9350b55e27dSYuval Mintz vf->num_sbs = 0;
9360b55e27dSYuval Mintz }
9370b55e27dSYuval Mintz
qed_iov_set_link(struct qed_hwfn * p_hwfn,u16 vfid,struct qed_mcp_link_params * params,struct qed_mcp_link_state * link,struct qed_mcp_link_capabilities * p_caps)93833b2fbd0SMintz, Yuval static void qed_iov_set_link(struct qed_hwfn *p_hwfn,
93933b2fbd0SMintz, Yuval u16 vfid,
94033b2fbd0SMintz, Yuval struct qed_mcp_link_params *params,
94133b2fbd0SMintz, Yuval struct qed_mcp_link_state *link,
94233b2fbd0SMintz, Yuval struct qed_mcp_link_capabilities *p_caps)
94333b2fbd0SMintz, Yuval {
94433b2fbd0SMintz, Yuval struct qed_vf_info *p_vf = qed_iov_get_vf_info(p_hwfn,
94533b2fbd0SMintz, Yuval vfid,
94633b2fbd0SMintz, Yuval false);
94733b2fbd0SMintz, Yuval struct qed_bulletin_content *p_bulletin;
94833b2fbd0SMintz, Yuval
94933b2fbd0SMintz, Yuval if (!p_vf)
95033b2fbd0SMintz, Yuval return;
95133b2fbd0SMintz, Yuval
95233b2fbd0SMintz, Yuval p_bulletin = p_vf->bulletin.p_virt;
95333b2fbd0SMintz, Yuval p_bulletin->req_autoneg = params->speed.autoneg;
95433b2fbd0SMintz, Yuval p_bulletin->req_adv_speed = params->speed.advertised_speeds;
95533b2fbd0SMintz, Yuval p_bulletin->req_forced_speed = params->speed.forced_speed;
95633b2fbd0SMintz, Yuval p_bulletin->req_autoneg_pause = params->pause.autoneg;
95733b2fbd0SMintz, Yuval p_bulletin->req_forced_rx = params->pause.forced_rx;
95833b2fbd0SMintz, Yuval p_bulletin->req_forced_tx = params->pause.forced_tx;
95933b2fbd0SMintz, Yuval p_bulletin->req_loopback = params->loopback_mode;
96033b2fbd0SMintz, Yuval
96133b2fbd0SMintz, Yuval p_bulletin->link_up = link->link_up;
96233b2fbd0SMintz, Yuval p_bulletin->speed = link->speed;
96333b2fbd0SMintz, Yuval p_bulletin->full_duplex = link->full_duplex;
96433b2fbd0SMintz, Yuval p_bulletin->autoneg = link->an;
96533b2fbd0SMintz, Yuval p_bulletin->autoneg_complete = link->an_complete;
96633b2fbd0SMintz, Yuval p_bulletin->parallel_detection = link->parallel_detection;
96733b2fbd0SMintz, Yuval p_bulletin->pfc_enabled = link->pfc_enabled;
96833b2fbd0SMintz, Yuval p_bulletin->partner_adv_speed = link->partner_adv_speed;
96933b2fbd0SMintz, Yuval p_bulletin->partner_tx_flow_ctrl_en = link->partner_tx_flow_ctrl_en;
97033b2fbd0SMintz, Yuval p_bulletin->partner_rx_flow_ctrl_en = link->partner_rx_flow_ctrl_en;
97133b2fbd0SMintz, Yuval p_bulletin->partner_adv_pause = link->partner_adv_pause;
97233b2fbd0SMintz, Yuval p_bulletin->sfp_tx_fault = link->sfp_tx_fault;
97333b2fbd0SMintz, Yuval
97433b2fbd0SMintz, Yuval p_bulletin->capability_speed = p_caps->speed_capabilities;
97533b2fbd0SMintz, Yuval }
97633b2fbd0SMintz, Yuval
qed_iov_init_hw_for_vf(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_iov_vf_init_params * p_params)9771408cc1fSYuval Mintz static int qed_iov_init_hw_for_vf(struct qed_hwfn *p_hwfn,
9781408cc1fSYuval Mintz struct qed_ptt *p_ptt,
9793da7a37aSMintz, Yuval struct qed_iov_vf_init_params *p_params)
9801408cc1fSYuval Mintz {
98133b2fbd0SMintz, Yuval struct qed_mcp_link_capabilities link_caps;
98233b2fbd0SMintz, Yuval struct qed_mcp_link_params link_params;
98333b2fbd0SMintz, Yuval struct qed_mcp_link_state link_state;
9841408cc1fSYuval Mintz u8 num_of_vf_avaiable_chains = 0;
9851408cc1fSYuval Mintz struct qed_vf_info *vf = NULL;
9863da7a37aSMintz, Yuval u16 qid, num_irqs;
9871408cc1fSYuval Mintz int rc = 0;
9881408cc1fSYuval Mintz u32 cids;
9891408cc1fSYuval Mintz u8 i;
9901408cc1fSYuval Mintz
9913da7a37aSMintz, Yuval vf = qed_iov_get_vf_info(p_hwfn, p_params->rel_vf_id, false);
9921408cc1fSYuval Mintz if (!vf) {
993fe40a830SPrabhakar Kushwaha DP_ERR(p_hwfn, "%s : vf is NULL\n", __func__);
9941408cc1fSYuval Mintz return -EINVAL;
9951408cc1fSYuval Mintz }
9961408cc1fSYuval Mintz
9971408cc1fSYuval Mintz if (vf->b_init) {
9983da7a37aSMintz, Yuval DP_NOTICE(p_hwfn, "VF[%d] is already active.\n",
9993da7a37aSMintz, Yuval p_params->rel_vf_id);
10001408cc1fSYuval Mintz return -EINVAL;
10011408cc1fSYuval Mintz }
10021408cc1fSYuval Mintz
10033da7a37aSMintz, Yuval /* Perform sanity checking on the requested queue_id */
10043da7a37aSMintz, Yuval for (i = 0; i < p_params->num_queues; i++) {
10053da7a37aSMintz, Yuval u16 min_vf_qzone = FEAT_NUM(p_hwfn, QED_PF_L2_QUE);
10063da7a37aSMintz, Yuval u16 max_vf_qzone = min_vf_qzone +
10073da7a37aSMintz, Yuval FEAT_NUM(p_hwfn, QED_VF_L2_QUE) - 1;
10083da7a37aSMintz, Yuval
10093da7a37aSMintz, Yuval qid = p_params->req_rx_queue[i];
10103da7a37aSMintz, Yuval if (qid < min_vf_qzone || qid > max_vf_qzone) {
10113da7a37aSMintz, Yuval DP_NOTICE(p_hwfn,
10123da7a37aSMintz, Yuval "Can't enable Rx qid [%04x] for VF[%d]: qids [0x%04x,...,0x%04x] available\n",
10133da7a37aSMintz, Yuval qid,
10143da7a37aSMintz, Yuval p_params->rel_vf_id,
10153da7a37aSMintz, Yuval min_vf_qzone, max_vf_qzone);
10163da7a37aSMintz, Yuval return -EINVAL;
10173da7a37aSMintz, Yuval }
10183da7a37aSMintz, Yuval
10193da7a37aSMintz, Yuval qid = p_params->req_tx_queue[i];
10203da7a37aSMintz, Yuval if (qid > max_vf_qzone) {
10213da7a37aSMintz, Yuval DP_NOTICE(p_hwfn,
10223da7a37aSMintz, Yuval "Can't enable Tx qid [%04x] for VF[%d]: max qid 0x%04x\n",
10233da7a37aSMintz, Yuval qid, p_params->rel_vf_id, max_vf_qzone);
10243da7a37aSMintz, Yuval return -EINVAL;
10253da7a37aSMintz, Yuval }
10263da7a37aSMintz, Yuval
10273da7a37aSMintz, Yuval /* If client *really* wants, Tx qid can be shared with PF */
10283da7a37aSMintz, Yuval if (qid < min_vf_qzone)
10293da7a37aSMintz, Yuval DP_VERBOSE(p_hwfn,
10303da7a37aSMintz, Yuval QED_MSG_IOV,
10313da7a37aSMintz, Yuval "VF[%d] is using PF qid [0x%04x] for Txq[0x%02x]\n",
10323da7a37aSMintz, Yuval p_params->rel_vf_id, qid, i);
10333da7a37aSMintz, Yuval }
10343da7a37aSMintz, Yuval
10351408cc1fSYuval Mintz /* Limit number of queues according to number of CIDs */
10361408cc1fSYuval Mintz qed_cxt_get_proto_cid_count(p_hwfn, PROTOCOLID_ETH, &cids);
10371408cc1fSYuval Mintz DP_VERBOSE(p_hwfn,
10381408cc1fSYuval Mintz QED_MSG_IOV,
10391408cc1fSYuval Mintz "VF[%d] - requesting to initialize for 0x%04x queues [0x%04x CIDs available]\n",
10403da7a37aSMintz, Yuval vf->relative_vf_id, p_params->num_queues, (u16)cids);
10413da7a37aSMintz, Yuval num_irqs = min_t(u16, p_params->num_queues, ((u16)cids));
10421408cc1fSYuval Mintz
10431408cc1fSYuval Mintz num_of_vf_avaiable_chains = qed_iov_alloc_vf_igu_sbs(p_hwfn,
10441408cc1fSYuval Mintz p_ptt,
10453da7a37aSMintz, Yuval vf, num_irqs);
10461408cc1fSYuval Mintz if (!num_of_vf_avaiable_chains) {
10471408cc1fSYuval Mintz DP_ERR(p_hwfn, "no available igu sbs\n");
10481408cc1fSYuval Mintz return -ENOMEM;
10491408cc1fSYuval Mintz }
10501408cc1fSYuval Mintz
10511408cc1fSYuval Mintz /* Choose queue number and index ranges */
10521408cc1fSYuval Mintz vf->num_rxqs = num_of_vf_avaiable_chains;
10531408cc1fSYuval Mintz vf->num_txqs = num_of_vf_avaiable_chains;
10541408cc1fSYuval Mintz
10551408cc1fSYuval Mintz for (i = 0; i < vf->num_rxqs; i++) {
1056007bc371SMintz, Yuval struct qed_vf_queue *p_queue = &vf->vf_queues[i];
10571408cc1fSYuval Mintz
10583da7a37aSMintz, Yuval p_queue->fw_rx_qid = p_params->req_rx_queue[i];
10593da7a37aSMintz, Yuval p_queue->fw_tx_qid = p_params->req_tx_queue[i];
10601408cc1fSYuval Mintz
10611408cc1fSYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
1062007bc371SMintz, Yuval "VF[%d] - Q[%d] SB %04x, qid [Rx %04x Tx %04x]\n",
1063007bc371SMintz, Yuval vf->relative_vf_id, i, vf->igu_sbs[i],
1064007bc371SMintz, Yuval p_queue->fw_rx_qid, p_queue->fw_tx_qid);
10651408cc1fSYuval Mintz }
10663da7a37aSMintz, Yuval
106733b2fbd0SMintz, Yuval /* Update the link configuration in bulletin */
106833b2fbd0SMintz, Yuval memcpy(&link_params, qed_mcp_get_link_params(p_hwfn),
106933b2fbd0SMintz, Yuval sizeof(link_params));
107033b2fbd0SMintz, Yuval memcpy(&link_state, qed_mcp_get_link_state(p_hwfn), sizeof(link_state));
107133b2fbd0SMintz, Yuval memcpy(&link_caps, qed_mcp_get_link_capabilities(p_hwfn),
107233b2fbd0SMintz, Yuval sizeof(link_caps));
107333b2fbd0SMintz, Yuval qed_iov_set_link(p_hwfn, p_params->rel_vf_id,
107433b2fbd0SMintz, Yuval &link_params, &link_state, &link_caps);
107533b2fbd0SMintz, Yuval
10761408cc1fSYuval Mintz rc = qed_iov_enable_vf_access(p_hwfn, p_ptt, vf);
10771408cc1fSYuval Mintz if (!rc) {
10781408cc1fSYuval Mintz vf->b_init = true;
10791408cc1fSYuval Mintz
10801408cc1fSYuval Mintz if (IS_LEAD_HWFN(p_hwfn))
10811408cc1fSYuval Mintz p_hwfn->cdev->p_iov_info->num_vfs++;
10821408cc1fSYuval Mintz }
10831408cc1fSYuval Mintz
10841408cc1fSYuval Mintz return rc;
10851408cc1fSYuval Mintz }
10861408cc1fSYuval Mintz
qed_iov_release_hw_for_vf(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,u16 rel_vf_id)10870b55e27dSYuval Mintz static int qed_iov_release_hw_for_vf(struct qed_hwfn *p_hwfn,
10880b55e27dSYuval Mintz struct qed_ptt *p_ptt, u16 rel_vf_id)
10890b55e27dSYuval Mintz {
1090079d20a6SManish Chopra struct qed_mcp_link_capabilities caps;
1091079d20a6SManish Chopra struct qed_mcp_link_params params;
1092079d20a6SManish Chopra struct qed_mcp_link_state link;
10930b55e27dSYuval Mintz struct qed_vf_info *vf = NULL;
10940b55e27dSYuval Mintz
10950b55e27dSYuval Mintz vf = qed_iov_get_vf_info(p_hwfn, rel_vf_id, true);
10960b55e27dSYuval Mintz if (!vf) {
1097fe40a830SPrabhakar Kushwaha DP_ERR(p_hwfn, "%s : vf is NULL\n", __func__);
10980b55e27dSYuval Mintz return -EINVAL;
10990b55e27dSYuval Mintz }
11000b55e27dSYuval Mintz
110136558c3dSYuval Mintz if (vf->bulletin.p_virt)
110236558c3dSYuval Mintz memset(vf->bulletin.p_virt, 0, sizeof(*vf->bulletin.p_virt));
110336558c3dSYuval Mintz
110436558c3dSYuval Mintz memset(&vf->p_vf_info, 0, sizeof(vf->p_vf_info));
110536558c3dSYuval Mintz
1106079d20a6SManish Chopra /* Get the link configuration back in bulletin so
1107079d20a6SManish Chopra * that when VFs are re-enabled they get the actual
1108079d20a6SManish Chopra * link configuration.
1109079d20a6SManish Chopra */
1110079d20a6SManish Chopra memcpy(¶ms, qed_mcp_get_link_params(p_hwfn), sizeof(params));
1111079d20a6SManish Chopra memcpy(&link, qed_mcp_get_link_state(p_hwfn), sizeof(link));
1112079d20a6SManish Chopra memcpy(&caps, qed_mcp_get_link_capabilities(p_hwfn), sizeof(caps));
1113079d20a6SManish Chopra qed_iov_set_link(p_hwfn, rel_vf_id, ¶ms, &link, &caps);
1114079d20a6SManish Chopra
11151fe614d1SYuval Mintz /* Forget the VF's acquisition message */
11161fe614d1SYuval Mintz memset(&vf->acquire, 0, sizeof(vf->acquire));
11170b55e27dSYuval Mintz
11180b55e27dSYuval Mintz /* disablng interrupts and resetting permission table was done during
11190b55e27dSYuval Mintz * vf-close, however, we could get here without going through vf_close
11200b55e27dSYuval Mintz */
11210b55e27dSYuval Mintz /* Disable Interrupts for VF */
11220b55e27dSYuval Mintz qed_iov_vf_igu_set_int(p_hwfn, p_ptt, vf, 0);
11230b55e27dSYuval Mintz
11240b55e27dSYuval Mintz /* Reset Permission table */
11250b55e27dSYuval Mintz qed_iov_config_perm_table(p_hwfn, p_ptt, vf, 0);
11260b55e27dSYuval Mintz
11270b55e27dSYuval Mintz vf->num_rxqs = 0;
11280b55e27dSYuval Mintz vf->num_txqs = 0;
11290b55e27dSYuval Mintz qed_iov_free_vf_igu_sbs(p_hwfn, p_ptt, vf);
11300b55e27dSYuval Mintz
11310b55e27dSYuval Mintz if (vf->b_init) {
11320b55e27dSYuval Mintz vf->b_init = false;
11330b55e27dSYuval Mintz
11340b55e27dSYuval Mintz if (IS_LEAD_HWFN(p_hwfn))
11350b55e27dSYuval Mintz p_hwfn->cdev->p_iov_info->num_vfs--;
11360b55e27dSYuval Mintz }
11370b55e27dSYuval Mintz
11380b55e27dSYuval Mintz return 0;
11390b55e27dSYuval Mintz }
11400b55e27dSYuval Mintz
qed_iov_tlv_supported(u16 tlvtype)114137bff2b9SYuval Mintz static bool qed_iov_tlv_supported(u16 tlvtype)
114237bff2b9SYuval Mintz {
114337bff2b9SYuval Mintz return CHANNEL_TLV_NONE < tlvtype && tlvtype < CHANNEL_TLV_MAX;
114437bff2b9SYuval Mintz }
114537bff2b9SYuval Mintz
114637bff2b9SYuval Mintz /* place a given tlv on the tlv buffer, continuing current tlv list */
qed_add_tlv(struct qed_hwfn * p_hwfn,u8 ** offset,u16 type,u16 length)114737bff2b9SYuval Mintz void *qed_add_tlv(struct qed_hwfn *p_hwfn, u8 **offset, u16 type, u16 length)
114837bff2b9SYuval Mintz {
114937bff2b9SYuval Mintz struct channel_tlv *tl = (struct channel_tlv *)*offset;
115037bff2b9SYuval Mintz
115137bff2b9SYuval Mintz tl->type = type;
115237bff2b9SYuval Mintz tl->length = length;
115337bff2b9SYuval Mintz
115437bff2b9SYuval Mintz /* Offset should keep pointing to next TLV (the end of the last) */
115537bff2b9SYuval Mintz *offset += length;
115637bff2b9SYuval Mintz
115737bff2b9SYuval Mintz /* Return a pointer to the start of the added tlv */
115837bff2b9SYuval Mintz return *offset - length;
115937bff2b9SYuval Mintz }
116037bff2b9SYuval Mintz
116137bff2b9SYuval Mintz /* list the types and lengths of the tlvs on the buffer */
qed_dp_tlv_list(struct qed_hwfn * p_hwfn,void * tlvs_list)116237bff2b9SYuval Mintz void qed_dp_tlv_list(struct qed_hwfn *p_hwfn, void *tlvs_list)
116337bff2b9SYuval Mintz {
116437bff2b9SYuval Mintz u16 i = 1, total_length = 0;
116537bff2b9SYuval Mintz struct channel_tlv *tlv;
116637bff2b9SYuval Mintz
116737bff2b9SYuval Mintz do {
116837bff2b9SYuval Mintz tlv = (struct channel_tlv *)((u8 *)tlvs_list + total_length);
116937bff2b9SYuval Mintz
117037bff2b9SYuval Mintz /* output tlv */
117137bff2b9SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
117237bff2b9SYuval Mintz "TLV number %d: type %d, length %d\n",
117337bff2b9SYuval Mintz i, tlv->type, tlv->length);
117437bff2b9SYuval Mintz
117537bff2b9SYuval Mintz if (tlv->type == CHANNEL_TLV_LIST_END)
117637bff2b9SYuval Mintz return;
117737bff2b9SYuval Mintz
117837bff2b9SYuval Mintz /* Validate entry - protect against malicious VFs */
117937bff2b9SYuval Mintz if (!tlv->length) {
118037bff2b9SYuval Mintz DP_NOTICE(p_hwfn, "TLV of length 0 found\n");
118137bff2b9SYuval Mintz return;
118237bff2b9SYuval Mintz }
118337bff2b9SYuval Mintz
118437bff2b9SYuval Mintz total_length += tlv->length;
118537bff2b9SYuval Mintz
118637bff2b9SYuval Mintz if (total_length >= sizeof(struct tlv_buffer_size)) {
118737bff2b9SYuval Mintz DP_NOTICE(p_hwfn, "TLV ==> Buffer overflow\n");
118837bff2b9SYuval Mintz return;
118937bff2b9SYuval Mintz }
119037bff2b9SYuval Mintz
119137bff2b9SYuval Mintz i++;
119237bff2b9SYuval Mintz } while (1);
119337bff2b9SYuval Mintz }
119437bff2b9SYuval Mintz
qed_iov_send_response(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * p_vf,u16 length,u8 status)119537bff2b9SYuval Mintz static void qed_iov_send_response(struct qed_hwfn *p_hwfn,
119637bff2b9SYuval Mintz struct qed_ptt *p_ptt,
119737bff2b9SYuval Mintz struct qed_vf_info *p_vf,
119837bff2b9SYuval Mintz u16 length, u8 status)
119937bff2b9SYuval Mintz {
120037bff2b9SYuval Mintz struct qed_iov_vf_mbx *mbx = &p_vf->vf_mbx;
120137bff2b9SYuval Mintz struct qed_dmae_params params;
120237bff2b9SYuval Mintz u8 eng_vf_id;
120337bff2b9SYuval Mintz
120437bff2b9SYuval Mintz mbx->reply_virt->default_resp.hdr.status = status;
120537bff2b9SYuval Mintz
120637bff2b9SYuval Mintz qed_dp_tlv_list(p_hwfn, mbx->reply_virt);
120737bff2b9SYuval Mintz
120837bff2b9SYuval Mintz eng_vf_id = p_vf->abs_vf_id;
120937bff2b9SYuval Mintz
1210804c5702SMichal Kalderon memset(¶ms, 0, sizeof(params));
1211804c5702SMichal Kalderon SET_FIELD(params.flags, QED_DMAE_PARAMS_DST_VF_VALID, 0x1);
121237bff2b9SYuval Mintz params.dst_vfid = eng_vf_id;
121337bff2b9SYuval Mintz
121437bff2b9SYuval Mintz qed_dmae_host2host(p_hwfn, p_ptt, mbx->reply_phys + sizeof(u64),
121537bff2b9SYuval Mintz mbx->req_virt->first_tlv.reply_address +
121637bff2b9SYuval Mintz sizeof(u64),
121737bff2b9SYuval Mintz (sizeof(union pfvf_tlvs) - sizeof(u64)) / 4,
121837bff2b9SYuval Mintz ¶ms);
121937bff2b9SYuval Mintz
1220d9194081SMintz, Yuval /* Once PF copies the rc to the VF, the latter can continue
1221d9194081SMintz, Yuval * and send an additional message. So we have to make sure the
1222d9194081SMintz, Yuval * channel would be re-set to ready prior to that.
1223d9194081SMintz, Yuval */
122437bff2b9SYuval Mintz REG_WR(p_hwfn,
1225e2dbc223SPrabhakar Kushwaha GET_GTT_REG_ADDR(GTT_BAR0_MAP_REG_USDM_RAM,
1226e2dbc223SPrabhakar Kushwaha USTORM_VF_PF_CHANNEL_READY, eng_vf_id), 1);
1227d9194081SMintz, Yuval
1228d9194081SMintz, Yuval qed_dmae_host2host(p_hwfn, p_ptt, mbx->reply_phys,
1229d9194081SMintz, Yuval mbx->req_virt->first_tlv.reply_address,
1230d9194081SMintz, Yuval sizeof(u64) / 4, ¶ms);
123137bff2b9SYuval Mintz }
123237bff2b9SYuval Mintz
qed_iov_vport_to_tlv(struct qed_hwfn * p_hwfn,enum qed_iov_vport_update_flag flag)1233dacd88d6SYuval Mintz static u16 qed_iov_vport_to_tlv(struct qed_hwfn *p_hwfn,
1234dacd88d6SYuval Mintz enum qed_iov_vport_update_flag flag)
1235dacd88d6SYuval Mintz {
1236dacd88d6SYuval Mintz switch (flag) {
1237dacd88d6SYuval Mintz case QED_IOV_VP_UPDATE_ACTIVATE:
1238dacd88d6SYuval Mintz return CHANNEL_TLV_VPORT_UPDATE_ACTIVATE;
123917b235c1SYuval Mintz case QED_IOV_VP_UPDATE_VLAN_STRIP:
124017b235c1SYuval Mintz return CHANNEL_TLV_VPORT_UPDATE_VLAN_STRIP;
124117b235c1SYuval Mintz case QED_IOV_VP_UPDATE_TX_SWITCH:
124217b235c1SYuval Mintz return CHANNEL_TLV_VPORT_UPDATE_TX_SWITCH;
1243dacd88d6SYuval Mintz case QED_IOV_VP_UPDATE_MCAST:
1244dacd88d6SYuval Mintz return CHANNEL_TLV_VPORT_UPDATE_MCAST;
1245dacd88d6SYuval Mintz case QED_IOV_VP_UPDATE_ACCEPT_PARAM:
1246dacd88d6SYuval Mintz return CHANNEL_TLV_VPORT_UPDATE_ACCEPT_PARAM;
1247dacd88d6SYuval Mintz case QED_IOV_VP_UPDATE_RSS:
1248dacd88d6SYuval Mintz return CHANNEL_TLV_VPORT_UPDATE_RSS;
124917b235c1SYuval Mintz case QED_IOV_VP_UPDATE_ACCEPT_ANY_VLAN:
125017b235c1SYuval Mintz return CHANNEL_TLV_VPORT_UPDATE_ACCEPT_ANY_VLAN;
125117b235c1SYuval Mintz case QED_IOV_VP_UPDATE_SGE_TPA:
125217b235c1SYuval Mintz return CHANNEL_TLV_VPORT_UPDATE_SGE_TPA;
1253dacd88d6SYuval Mintz default:
1254dacd88d6SYuval Mintz return 0;
1255dacd88d6SYuval Mintz }
1256dacd88d6SYuval Mintz }
1257dacd88d6SYuval Mintz
qed_iov_prep_vp_update_resp_tlvs(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,struct qed_iov_vf_mbx * p_mbx,u8 status,u16 tlvs_mask,u16 tlvs_accepted)1258dacd88d6SYuval Mintz static u16 qed_iov_prep_vp_update_resp_tlvs(struct qed_hwfn *p_hwfn,
1259dacd88d6SYuval Mintz struct qed_vf_info *p_vf,
1260dacd88d6SYuval Mintz struct qed_iov_vf_mbx *p_mbx,
1261dacd88d6SYuval Mintz u8 status,
1262dacd88d6SYuval Mintz u16 tlvs_mask, u16 tlvs_accepted)
1263dacd88d6SYuval Mintz {
1264dacd88d6SYuval Mintz struct pfvf_def_resp_tlv *resp;
1265dacd88d6SYuval Mintz u16 size, total_len, i;
1266dacd88d6SYuval Mintz
1267dacd88d6SYuval Mintz memset(p_mbx->reply_virt, 0, sizeof(union pfvf_tlvs));
1268dacd88d6SYuval Mintz p_mbx->offset = (u8 *)p_mbx->reply_virt;
1269dacd88d6SYuval Mintz size = sizeof(struct pfvf_def_resp_tlv);
1270dacd88d6SYuval Mintz total_len = size;
1271dacd88d6SYuval Mintz
1272dacd88d6SYuval Mintz qed_add_tlv(p_hwfn, &p_mbx->offset, CHANNEL_TLV_VPORT_UPDATE, size);
1273dacd88d6SYuval Mintz
1274dacd88d6SYuval Mintz /* Prepare response for all extended tlvs if they are found by PF */
1275dacd88d6SYuval Mintz for (i = 0; i < QED_IOV_VP_UPDATE_MAX; i++) {
12761a635e48SYuval Mintz if (!(tlvs_mask & BIT(i)))
1277dacd88d6SYuval Mintz continue;
1278dacd88d6SYuval Mintz
1279dacd88d6SYuval Mintz resp = qed_add_tlv(p_hwfn, &p_mbx->offset,
1280dacd88d6SYuval Mintz qed_iov_vport_to_tlv(p_hwfn, i), size);
1281dacd88d6SYuval Mintz
12821a635e48SYuval Mintz if (tlvs_accepted & BIT(i))
1283dacd88d6SYuval Mintz resp->hdr.status = status;
1284dacd88d6SYuval Mintz else
1285dacd88d6SYuval Mintz resp->hdr.status = PFVF_STATUS_NOT_SUPPORTED;
1286dacd88d6SYuval Mintz
1287dacd88d6SYuval Mintz DP_VERBOSE(p_hwfn,
1288dacd88d6SYuval Mintz QED_MSG_IOV,
1289dacd88d6SYuval Mintz "VF[%d] - vport_update response: TLV %d, status %02x\n",
1290dacd88d6SYuval Mintz p_vf->relative_vf_id,
1291dacd88d6SYuval Mintz qed_iov_vport_to_tlv(p_hwfn, i), resp->hdr.status);
1292dacd88d6SYuval Mintz
1293dacd88d6SYuval Mintz total_len += size;
1294dacd88d6SYuval Mintz }
1295dacd88d6SYuval Mintz
1296dacd88d6SYuval Mintz qed_add_tlv(p_hwfn, &p_mbx->offset, CHANNEL_TLV_LIST_END,
1297dacd88d6SYuval Mintz sizeof(struct channel_list_end_tlv));
1298dacd88d6SYuval Mintz
1299dacd88d6SYuval Mintz return total_len;
1300dacd88d6SYuval Mintz }
1301dacd88d6SYuval Mintz
qed_iov_prepare_resp(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf_info,u16 type,u16 length,u8 status)130237bff2b9SYuval Mintz static void qed_iov_prepare_resp(struct qed_hwfn *p_hwfn,
130337bff2b9SYuval Mintz struct qed_ptt *p_ptt,
130437bff2b9SYuval Mintz struct qed_vf_info *vf_info,
130537bff2b9SYuval Mintz u16 type, u16 length, u8 status)
130637bff2b9SYuval Mintz {
130737bff2b9SYuval Mintz struct qed_iov_vf_mbx *mbx = &vf_info->vf_mbx;
130837bff2b9SYuval Mintz
130937bff2b9SYuval Mintz mbx->offset = (u8 *)mbx->reply_virt;
131037bff2b9SYuval Mintz
131137bff2b9SYuval Mintz qed_add_tlv(p_hwfn, &mbx->offset, type, length);
131237bff2b9SYuval Mintz qed_add_tlv(p_hwfn, &mbx->offset, CHANNEL_TLV_LIST_END,
131337bff2b9SYuval Mintz sizeof(struct channel_list_end_tlv));
131437bff2b9SYuval Mintz
131537bff2b9SYuval Mintz qed_iov_send_response(p_hwfn, p_ptt, vf_info, length, status);
131637bff2b9SYuval Mintz }
131737bff2b9SYuval Mintz
1318ba56947aSBaoyou Xie static struct
qed_iov_get_public_vf_info(struct qed_hwfn * p_hwfn,u16 relative_vf_id,bool b_enabled_only)1319ba56947aSBaoyou Xie qed_public_vf_info *qed_iov_get_public_vf_info(struct qed_hwfn *p_hwfn,
13200b55e27dSYuval Mintz u16 relative_vf_id,
13210b55e27dSYuval Mintz bool b_enabled_only)
13220b55e27dSYuval Mintz {
13230b55e27dSYuval Mintz struct qed_vf_info *vf = NULL;
13240b55e27dSYuval Mintz
13250b55e27dSYuval Mintz vf = qed_iov_get_vf_info(p_hwfn, relative_vf_id, b_enabled_only);
13260b55e27dSYuval Mintz if (!vf)
13270b55e27dSYuval Mintz return NULL;
13280b55e27dSYuval Mintz
13290b55e27dSYuval Mintz return &vf->p_vf_info;
13300b55e27dSYuval Mintz }
13310b55e27dSYuval Mintz
qed_iov_clean_vf(struct qed_hwfn * p_hwfn,u8 vfid)1332ba56947aSBaoyou Xie static void qed_iov_clean_vf(struct qed_hwfn *p_hwfn, u8 vfid)
13330b55e27dSYuval Mintz {
13340b55e27dSYuval Mintz struct qed_public_vf_info *vf_info;
13350b55e27dSYuval Mintz
13360b55e27dSYuval Mintz vf_info = qed_iov_get_public_vf_info(p_hwfn, vfid, false);
13370b55e27dSYuval Mintz
13380b55e27dSYuval Mintz if (!vf_info)
13390b55e27dSYuval Mintz return;
13400b55e27dSYuval Mintz
13410b55e27dSYuval Mintz /* Clear the VF mac */
13420ee28e31SShyam Saini eth_zero_addr(vf_info->mac);
1343f990c82cSMintz, Yuval
1344f990c82cSMintz, Yuval vf_info->rx_accept_mode = 0;
1345f990c82cSMintz, Yuval vf_info->tx_accept_mode = 0;
13460b55e27dSYuval Mintz }
13470b55e27dSYuval Mintz
qed_iov_vf_cleanup(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf)13480b55e27dSYuval Mintz static void qed_iov_vf_cleanup(struct qed_hwfn *p_hwfn,
13490b55e27dSYuval Mintz struct qed_vf_info *p_vf)
13500b55e27dSYuval Mintz {
1351007bc371SMintz, Yuval u32 i, j;
13520b55e27dSYuval Mintz
13530b55e27dSYuval Mintz p_vf->vf_bulletin = 0;
1354dacd88d6SYuval Mintz p_vf->vport_instance = 0;
135508feecd7SYuval Mintz p_vf->configured_features = 0;
13560b55e27dSYuval Mintz
13570b55e27dSYuval Mintz /* If VF previously requested less resources, go back to default */
13580b55e27dSYuval Mintz p_vf->num_rxqs = p_vf->num_sbs;
13590b55e27dSYuval Mintz p_vf->num_txqs = p_vf->num_sbs;
13600b55e27dSYuval Mintz
1361dacd88d6SYuval Mintz p_vf->num_active_rxqs = 0;
1362dacd88d6SYuval Mintz
13633da7a37aSMintz, Yuval for (i = 0; i < QED_MAX_VF_CHAINS_PER_PF; i++) {
1364007bc371SMintz, Yuval struct qed_vf_queue *p_queue = &p_vf->vf_queues[i];
13653da7a37aSMintz, Yuval
1366007bc371SMintz, Yuval for (j = 0; j < MAX_QUEUES_PER_QZONE; j++) {
1367007bc371SMintz, Yuval if (!p_queue->cids[j].p_cid)
1368007bc371SMintz, Yuval continue;
13693da7a37aSMintz, Yuval
1370007bc371SMintz, Yuval qed_eth_queue_cid_release(p_hwfn,
1371007bc371SMintz, Yuval p_queue->cids[j].p_cid);
1372007bc371SMintz, Yuval p_queue->cids[j].p_cid = NULL;
13733da7a37aSMintz, Yuval }
13743da7a37aSMintz, Yuval }
13750b55e27dSYuval Mintz
137608feecd7SYuval Mintz memset(&p_vf->shadow_config, 0, sizeof(p_vf->shadow_config));
13771fe614d1SYuval Mintz memset(&p_vf->acquire, 0, sizeof(p_vf->acquire));
13780b55e27dSYuval Mintz qed_iov_clean_vf(p_hwfn, p_vf->relative_vf_id);
13790b55e27dSYuval Mintz }
13800b55e27dSYuval Mintz
13811a850bfcSMintz, Yuval /* Returns either 0, or log(size) */
qed_iov_vf_db_bar_size(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt)13821a850bfcSMintz, Yuval static u32 qed_iov_vf_db_bar_size(struct qed_hwfn *p_hwfn,
13831a850bfcSMintz, Yuval struct qed_ptt *p_ptt)
13841a850bfcSMintz, Yuval {
13851a850bfcSMintz, Yuval u32 val = qed_rd(p_hwfn, p_ptt, PGLUE_B_REG_VF_BAR1_SIZE);
13861a850bfcSMintz, Yuval
13871a850bfcSMintz, Yuval if (val)
13881a850bfcSMintz, Yuval return val + 11;
13891a850bfcSMintz, Yuval return 0;
13901a850bfcSMintz, Yuval }
13911a850bfcSMintz, Yuval
13921a850bfcSMintz, Yuval static void
qed_iov_vf_mbx_acquire_resc_cids(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * p_vf,struct vf_pf_resc_request * p_req,struct pf_vf_resc * p_resp)13931a850bfcSMintz, Yuval qed_iov_vf_mbx_acquire_resc_cids(struct qed_hwfn *p_hwfn,
13941a850bfcSMintz, Yuval struct qed_ptt *p_ptt,
13951a850bfcSMintz, Yuval struct qed_vf_info *p_vf,
13961a850bfcSMintz, Yuval struct vf_pf_resc_request *p_req,
13971a850bfcSMintz, Yuval struct pf_vf_resc *p_resp)
13981a850bfcSMintz, Yuval {
13991a850bfcSMintz, Yuval u8 num_vf_cons = p_hwfn->pf_params.eth_pf_params.num_vf_cons;
14001a850bfcSMintz, Yuval u8 db_size = qed_db_addr_vf(1, DQ_DEMS_LEGACY) -
14011a850bfcSMintz, Yuval qed_db_addr_vf(0, DQ_DEMS_LEGACY);
14021a850bfcSMintz, Yuval u32 bar_size;
14031a850bfcSMintz, Yuval
14041a850bfcSMintz, Yuval p_resp->num_cids = min_t(u8, p_req->num_cids, num_vf_cons);
14051a850bfcSMintz, Yuval
14061a850bfcSMintz, Yuval /* If VF didn't bother asking for QIDs than don't bother limiting
14071a850bfcSMintz, Yuval * number of CIDs. The VF doesn't care about the number, and this
14081a850bfcSMintz, Yuval * has the likely result of causing an additional acquisition.
14091a850bfcSMintz, Yuval */
14101a850bfcSMintz, Yuval if (!(p_vf->acquire.vfdev_info.capabilities &
14111a850bfcSMintz, Yuval VFPF_ACQUIRE_CAP_QUEUE_QIDS))
14121a850bfcSMintz, Yuval return;
14131a850bfcSMintz, Yuval
14141a850bfcSMintz, Yuval /* If doorbell bar was mapped by VF, limit the VF CIDs to an amount
14151a850bfcSMintz, Yuval * that would make sure doorbells for all CIDs fall within the bar.
14161a850bfcSMintz, Yuval * If it doesn't, make sure regview window is sufficient.
14171a850bfcSMintz, Yuval */
14181a850bfcSMintz, Yuval if (p_vf->acquire.vfdev_info.capabilities &
14191a850bfcSMintz, Yuval VFPF_ACQUIRE_CAP_PHYSICAL_BAR) {
14201a850bfcSMintz, Yuval bar_size = qed_iov_vf_db_bar_size(p_hwfn, p_ptt);
14211a850bfcSMintz, Yuval if (bar_size)
14221a850bfcSMintz, Yuval bar_size = 1 << bar_size;
14231a850bfcSMintz, Yuval
14241a850bfcSMintz, Yuval if (p_hwfn->cdev->num_hwfns > 1)
14251a850bfcSMintz, Yuval bar_size /= 2;
14261a850bfcSMintz, Yuval } else {
14271a850bfcSMintz, Yuval bar_size = PXP_VF_BAR0_DQ_LENGTH;
14281a850bfcSMintz, Yuval }
14291a850bfcSMintz, Yuval
14301a850bfcSMintz, Yuval if (bar_size / db_size < 256)
14311a850bfcSMintz, Yuval p_resp->num_cids = min_t(u8, p_resp->num_cids,
14321a850bfcSMintz, Yuval (u8)(bar_size / db_size));
14331a850bfcSMintz, Yuval }
14341a850bfcSMintz, Yuval
qed_iov_vf_mbx_acquire_resc(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * p_vf,struct vf_pf_resc_request * p_req,struct pf_vf_resc * p_resp)14351cf2b1a9SYuval Mintz static u8 qed_iov_vf_mbx_acquire_resc(struct qed_hwfn *p_hwfn,
14361cf2b1a9SYuval Mintz struct qed_ptt *p_ptt,
14371cf2b1a9SYuval Mintz struct qed_vf_info *p_vf,
14381cf2b1a9SYuval Mintz struct vf_pf_resc_request *p_req,
14391cf2b1a9SYuval Mintz struct pf_vf_resc *p_resp)
14401cf2b1a9SYuval Mintz {
1441007bc371SMintz, Yuval u8 i;
14421cf2b1a9SYuval Mintz
14431cf2b1a9SYuval Mintz /* Queue related information */
14441cf2b1a9SYuval Mintz p_resp->num_rxqs = p_vf->num_rxqs;
14451cf2b1a9SYuval Mintz p_resp->num_txqs = p_vf->num_txqs;
14461cf2b1a9SYuval Mintz p_resp->num_sbs = p_vf->num_sbs;
14471cf2b1a9SYuval Mintz
14481cf2b1a9SYuval Mintz for (i = 0; i < p_resp->num_sbs; i++) {
14491cf2b1a9SYuval Mintz p_resp->hw_sbs[i].hw_sb_id = p_vf->igu_sbs[i];
14501cf2b1a9SYuval Mintz p_resp->hw_sbs[i].sb_qid = 0;
14511cf2b1a9SYuval Mintz }
14521cf2b1a9SYuval Mintz
14531cf2b1a9SYuval Mintz /* These fields are filled for backward compatibility.
14541cf2b1a9SYuval Mintz * Unused by modern vfs.
14551cf2b1a9SYuval Mintz */
14561cf2b1a9SYuval Mintz for (i = 0; i < p_resp->num_rxqs; i++) {
14571cf2b1a9SYuval Mintz qed_fw_l2_queue(p_hwfn, p_vf->vf_queues[i].fw_rx_qid,
14581cf2b1a9SYuval Mintz (u16 *)&p_resp->hw_qid[i]);
1459007bc371SMintz, Yuval p_resp->cid[i] = i;
14601cf2b1a9SYuval Mintz }
14611cf2b1a9SYuval Mintz
14621cf2b1a9SYuval Mintz /* Filter related information */
14631cf2b1a9SYuval Mintz p_resp->num_mac_filters = min_t(u8, p_vf->num_mac_filters,
14641cf2b1a9SYuval Mintz p_req->num_mac_filters);
14651cf2b1a9SYuval Mintz p_resp->num_vlan_filters = min_t(u8, p_vf->num_vlan_filters,
14661cf2b1a9SYuval Mintz p_req->num_vlan_filters);
14671cf2b1a9SYuval Mintz
14681a850bfcSMintz, Yuval qed_iov_vf_mbx_acquire_resc_cids(p_hwfn, p_ptt, p_vf, p_req, p_resp);
146908bc8f15SMintz, Yuval
14701cf2b1a9SYuval Mintz /* This isn't really needed/enforced, but some legacy VFs might depend
14711cf2b1a9SYuval Mintz * on the correct filling of this field.
14721cf2b1a9SYuval Mintz */
14731cf2b1a9SYuval Mintz p_resp->num_mc_filters = QED_MAX_MC_ADDRS;
14741cf2b1a9SYuval Mintz
14751cf2b1a9SYuval Mintz /* Validate sufficient resources for VF */
14761cf2b1a9SYuval Mintz if (p_resp->num_rxqs < p_req->num_rxqs ||
14771cf2b1a9SYuval Mintz p_resp->num_txqs < p_req->num_txqs ||
14781cf2b1a9SYuval Mintz p_resp->num_sbs < p_req->num_sbs ||
14791cf2b1a9SYuval Mintz p_resp->num_mac_filters < p_req->num_mac_filters ||
14801cf2b1a9SYuval Mintz p_resp->num_vlan_filters < p_req->num_vlan_filters ||
148108bc8f15SMintz, Yuval p_resp->num_mc_filters < p_req->num_mc_filters ||
148208bc8f15SMintz, Yuval p_resp->num_cids < p_req->num_cids) {
14831cf2b1a9SYuval Mintz DP_VERBOSE(p_hwfn,
14841cf2b1a9SYuval Mintz QED_MSG_IOV,
148508bc8f15SMintz, Yuval "VF[%d] - Insufficient resources: rxq [%02x/%02x] txq [%02x/%02x] sbs [%02x/%02x] mac [%02x/%02x] vlan [%02x/%02x] mc [%02x/%02x] cids [%02x/%02x]\n",
14861cf2b1a9SYuval Mintz p_vf->abs_vf_id,
14871cf2b1a9SYuval Mintz p_req->num_rxqs,
14881cf2b1a9SYuval Mintz p_resp->num_rxqs,
14891cf2b1a9SYuval Mintz p_req->num_rxqs,
14901cf2b1a9SYuval Mintz p_resp->num_txqs,
14911cf2b1a9SYuval Mintz p_req->num_sbs,
14921cf2b1a9SYuval Mintz p_resp->num_sbs,
14931cf2b1a9SYuval Mintz p_req->num_mac_filters,
14941cf2b1a9SYuval Mintz p_resp->num_mac_filters,
14951cf2b1a9SYuval Mintz p_req->num_vlan_filters,
14961cf2b1a9SYuval Mintz p_resp->num_vlan_filters,
149708bc8f15SMintz, Yuval p_req->num_mc_filters,
149808bc8f15SMintz, Yuval p_resp->num_mc_filters,
149908bc8f15SMintz, Yuval p_req->num_cids, p_resp->num_cids);
1500a044df83SYuval Mintz
1501a044df83SYuval Mintz /* Some legacy OSes are incapable of correctly handling this
1502a044df83SYuval Mintz * failure.
1503a044df83SYuval Mintz */
1504a044df83SYuval Mintz if ((p_vf->acquire.vfdev_info.eth_fp_hsi_minor ==
1505a044df83SYuval Mintz ETH_HSI_VER_NO_PKT_LEN_TUNN) &&
1506a044df83SYuval Mintz (p_vf->acquire.vfdev_info.os_type ==
1507a044df83SYuval Mintz VFPF_ACQUIRE_OS_WINDOWS))
1508a044df83SYuval Mintz return PFVF_STATUS_SUCCESS;
1509a044df83SYuval Mintz
15101cf2b1a9SYuval Mintz return PFVF_STATUS_NO_RESOURCE;
15111cf2b1a9SYuval Mintz }
15121cf2b1a9SYuval Mintz
15131cf2b1a9SYuval Mintz return PFVF_STATUS_SUCCESS;
15141cf2b1a9SYuval Mintz }
15151cf2b1a9SYuval Mintz
qed_iov_vf_mbx_acquire_stats(struct qed_hwfn * p_hwfn,struct pfvf_stats_info * p_stats)15161cf2b1a9SYuval Mintz static void qed_iov_vf_mbx_acquire_stats(struct qed_hwfn *p_hwfn,
15171cf2b1a9SYuval Mintz struct pfvf_stats_info *p_stats)
15181cf2b1a9SYuval Mintz {
15191cf2b1a9SYuval Mintz p_stats->mstats.address = PXP_VF_BAR0_START_MSDM_ZONE_B +
15201cf2b1a9SYuval Mintz offsetof(struct mstorm_vf_zone,
15211cf2b1a9SYuval Mintz non_trigger.eth_queue_stat);
15221cf2b1a9SYuval Mintz p_stats->mstats.len = sizeof(struct eth_mstorm_per_queue_stat);
15231cf2b1a9SYuval Mintz p_stats->ustats.address = PXP_VF_BAR0_START_USDM_ZONE_B +
15241cf2b1a9SYuval Mintz offsetof(struct ustorm_vf_zone,
15251cf2b1a9SYuval Mintz non_trigger.eth_queue_stat);
15261cf2b1a9SYuval Mintz p_stats->ustats.len = sizeof(struct eth_ustorm_per_queue_stat);
15271cf2b1a9SYuval Mintz p_stats->pstats.address = PXP_VF_BAR0_START_PSDM_ZONE_B +
15281cf2b1a9SYuval Mintz offsetof(struct pstorm_vf_zone,
15291cf2b1a9SYuval Mintz non_trigger.eth_queue_stat);
15301cf2b1a9SYuval Mintz p_stats->pstats.len = sizeof(struct eth_pstorm_per_queue_stat);
15311cf2b1a9SYuval Mintz p_stats->tstats.address = 0;
15321cf2b1a9SYuval Mintz p_stats->tstats.len = 0;
15331cf2b1a9SYuval Mintz }
15341cf2b1a9SYuval Mintz
qed_iov_vf_mbx_acquire(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)15351408cc1fSYuval Mintz static void qed_iov_vf_mbx_acquire(struct qed_hwfn *p_hwfn,
153637bff2b9SYuval Mintz struct qed_ptt *p_ptt,
15371408cc1fSYuval Mintz struct qed_vf_info *vf)
153837bff2b9SYuval Mintz {
15391408cc1fSYuval Mintz struct qed_iov_vf_mbx *mbx = &vf->vf_mbx;
15401408cc1fSYuval Mintz struct pfvf_acquire_resp_tlv *resp = &mbx->reply_virt->acquire_resp;
15411408cc1fSYuval Mintz struct pf_vf_pfdev_info *pfdev_info = &resp->pfdev_info;
15421408cc1fSYuval Mintz struct vfpf_acquire_tlv *req = &mbx->req_virt->acquire;
15431cf2b1a9SYuval Mintz u8 vfpf_status = PFVF_STATUS_NOT_SUPPORTED;
15441408cc1fSYuval Mintz struct pf_vf_resc *resc = &resp->resc;
15451fe614d1SYuval Mintz int rc;
15461fe614d1SYuval Mintz
15471fe614d1SYuval Mintz memset(resp, 0, sizeof(*resp));
15481408cc1fSYuval Mintz
154905fafbfbSYuval Mintz /* Write the PF version so that VF would know which version
1550fe40a830SPrabhakar Kushwaha * is supported - might be later overridden. This guarantees that
155105fafbfbSYuval Mintz * VF could recognize legacy PF based on lack of versions in reply.
155205fafbfbSYuval Mintz */
155305fafbfbSYuval Mintz pfdev_info->major_fp_hsi = ETH_HSI_VER_MAJOR;
155405fafbfbSYuval Mintz pfdev_info->minor_fp_hsi = ETH_HSI_VER_MINOR;
155505fafbfbSYuval Mintz
1556a044df83SYuval Mintz if (vf->state != VF_FREE && vf->state != VF_STOPPED) {
1557a044df83SYuval Mintz DP_VERBOSE(p_hwfn,
1558a044df83SYuval Mintz QED_MSG_IOV,
1559a044df83SYuval Mintz "VF[%d] sent ACQUIRE but is already in state %d - fail request\n",
1560a044df83SYuval Mintz vf->abs_vf_id, vf->state);
1561a044df83SYuval Mintz goto out;
1562a044df83SYuval Mintz }
1563a044df83SYuval Mintz
15641408cc1fSYuval Mintz /* Validate FW compatibility */
15651fe614d1SYuval Mintz if (req->vfdev_info.eth_fp_hsi_major != ETH_HSI_VER_MAJOR) {
1566a044df83SYuval Mintz if (req->vfdev_info.capabilities &
1567a044df83SYuval Mintz VFPF_ACQUIRE_CAP_PRE_FP_HSI) {
1568a044df83SYuval Mintz struct vf_pf_vfdev_info *p_vfdev = &req->vfdev_info;
1569a044df83SYuval Mintz
1570a044df83SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
1571a044df83SYuval Mintz "VF[%d] is pre-fastpath HSI\n",
1572a044df83SYuval Mintz vf->abs_vf_id);
1573a044df83SYuval Mintz p_vfdev->eth_fp_hsi_major = ETH_HSI_VER_MAJOR;
1574a044df83SYuval Mintz p_vfdev->eth_fp_hsi_minor = ETH_HSI_VER_NO_PKT_LEN_TUNN;
1575a044df83SYuval Mintz } else {
15761408cc1fSYuval Mintz DP_INFO(p_hwfn,
15773321b6c2SColin Ian King "VF[%d] needs fastpath HSI %02x.%02x, which is incompatible with loaded FW's fastpath HSI %02x.%02x\n",
15781408cc1fSYuval Mintz vf->abs_vf_id,
15791fe614d1SYuval Mintz req->vfdev_info.eth_fp_hsi_major,
15801fe614d1SYuval Mintz req->vfdev_info.eth_fp_hsi_minor,
15811fe614d1SYuval Mintz ETH_HSI_VER_MAJOR, ETH_HSI_VER_MINOR);
15821fe614d1SYuval Mintz
15831408cc1fSYuval Mintz goto out;
15841408cc1fSYuval Mintz }
1585a044df83SYuval Mintz }
15861408cc1fSYuval Mintz
15871408cc1fSYuval Mintz /* On 100g PFs, prevent old VFs from loading */
15881408cc1fSYuval Mintz if ((p_hwfn->cdev->num_hwfns > 1) &&
15891408cc1fSYuval Mintz !(req->vfdev_info.capabilities & VFPF_ACQUIRE_CAP_100G)) {
15901408cc1fSYuval Mintz DP_INFO(p_hwfn,
15911408cc1fSYuval Mintz "VF[%d] is running an old driver that doesn't support 100g\n",
15921408cc1fSYuval Mintz vf->abs_vf_id);
15931408cc1fSYuval Mintz goto out;
15941408cc1fSYuval Mintz }
15951408cc1fSYuval Mintz
15961fe614d1SYuval Mintz /* Store the acquire message */
15971fe614d1SYuval Mintz memcpy(&vf->acquire, req, sizeof(vf->acquire));
15981408cc1fSYuval Mintz
15991408cc1fSYuval Mintz vf->opaque_fid = req->vfdev_info.opaque_fid;
16001408cc1fSYuval Mintz
16011408cc1fSYuval Mintz vf->vf_bulletin = req->bulletin_addr;
16021408cc1fSYuval Mintz vf->bulletin.size = (vf->bulletin.size < req->bulletin_size) ?
16031408cc1fSYuval Mintz vf->bulletin.size : req->bulletin_size;
16041408cc1fSYuval Mintz
16051408cc1fSYuval Mintz /* fill in pfdev info */
16061408cc1fSYuval Mintz pfdev_info->chip_num = p_hwfn->cdev->chip_num;
16071408cc1fSYuval Mintz pfdev_info->db_size = 0;
1608fb09a1edSShai Malin pfdev_info->indices_per_sb = PIS_PER_SB;
16091408cc1fSYuval Mintz
16101408cc1fSYuval Mintz pfdev_info->capabilities = PFVF_ACQUIRE_CAP_DEFAULT_UNTAGGED |
16111408cc1fSYuval Mintz PFVF_ACQUIRE_CAP_POST_FW_OVERRIDE;
16121408cc1fSYuval Mintz if (p_hwfn->cdev->num_hwfns > 1)
16131408cc1fSYuval Mintz pfdev_info->capabilities |= PFVF_ACQUIRE_CAP_100G;
16141408cc1fSYuval Mintz
161508bc8f15SMintz, Yuval /* Share our ability to use multiple queue-ids only with VFs
161608bc8f15SMintz, Yuval * that request it.
161708bc8f15SMintz, Yuval */
161808bc8f15SMintz, Yuval if (req->vfdev_info.capabilities & VFPF_ACQUIRE_CAP_QUEUE_QIDS)
161908bc8f15SMintz, Yuval pfdev_info->capabilities |= PFVF_ACQUIRE_CAP_QUEUE_QIDS;
162008bc8f15SMintz, Yuval
16211a850bfcSMintz, Yuval /* Share the sizes of the bars with VF */
16221a850bfcSMintz, Yuval resp->pfdev_info.bar_size = qed_iov_vf_db_bar_size(p_hwfn, p_ptt);
16231a850bfcSMintz, Yuval
16241cf2b1a9SYuval Mintz qed_iov_vf_mbx_acquire_stats(p_hwfn, &pfdev_info->stats_info);
16251408cc1fSYuval Mintz
16261408cc1fSYuval Mintz memcpy(pfdev_info->port_mac, p_hwfn->hw_info.hw_mac_addr, ETH_ALEN);
16271408cc1fSYuval Mintz
16281408cc1fSYuval Mintz pfdev_info->fw_major = FW_MAJOR_VERSION;
16291408cc1fSYuval Mintz pfdev_info->fw_minor = FW_MINOR_VERSION;
16301408cc1fSYuval Mintz pfdev_info->fw_rev = FW_REVISION_VERSION;
16311408cc1fSYuval Mintz pfdev_info->fw_eng = FW_ENGINEERING_VERSION;
1632a044df83SYuval Mintz
1633a044df83SYuval Mintz /* Incorrect when legacy, but doesn't matter as legacy isn't reading
1634a044df83SYuval Mintz * this field.
1635a044df83SYuval Mintz */
16361a635e48SYuval Mintz pfdev_info->minor_fp_hsi = min_t(u8, ETH_HSI_VER_MINOR,
16371fe614d1SYuval Mintz req->vfdev_info.eth_fp_hsi_minor);
16381408cc1fSYuval Mintz pfdev_info->os_type = VFPF_ACQUIRE_OS_LINUX;
16391408cc1fSYuval Mintz qed_mcp_get_mfw_ver(p_hwfn, p_ptt, &pfdev_info->mfw_ver, NULL);
16401408cc1fSYuval Mintz
16411408cc1fSYuval Mintz pfdev_info->dev_type = p_hwfn->cdev->type;
16421408cc1fSYuval Mintz pfdev_info->chip_rev = p_hwfn->cdev->chip_rev;
16431408cc1fSYuval Mintz
16441cf2b1a9SYuval Mintz /* Fill resources available to VF; Make sure there are enough to
16451cf2b1a9SYuval Mintz * satisfy the VF's request.
16461408cc1fSYuval Mintz */
16471cf2b1a9SYuval Mintz vfpf_status = qed_iov_vf_mbx_acquire_resc(p_hwfn, p_ptt, vf,
16481cf2b1a9SYuval Mintz &req->resc_request, resc);
16491cf2b1a9SYuval Mintz if (vfpf_status != PFVF_STATUS_SUCCESS)
16501cf2b1a9SYuval Mintz goto out;
16511408cc1fSYuval Mintz
16521fe614d1SYuval Mintz /* Start the VF in FW */
16531fe614d1SYuval Mintz rc = qed_sp_vf_start(p_hwfn, vf);
16541fe614d1SYuval Mintz if (rc) {
16551fe614d1SYuval Mintz DP_NOTICE(p_hwfn, "Failed to start VF[%02x]\n", vf->abs_vf_id);
16561fe614d1SYuval Mintz vfpf_status = PFVF_STATUS_FAILURE;
16571fe614d1SYuval Mintz goto out;
16581fe614d1SYuval Mintz }
16591fe614d1SYuval Mintz
16601408cc1fSYuval Mintz /* Fill agreed size of bulletin board in response */
16611408cc1fSYuval Mintz resp->bulletin_size = vf->bulletin.size;
166236558c3dSYuval Mintz qed_iov_post_vf_bulletin(p_hwfn, vf->relative_vf_id, p_ptt);
16631408cc1fSYuval Mintz
16641408cc1fSYuval Mintz DP_VERBOSE(p_hwfn,
16651408cc1fSYuval Mintz QED_MSG_IOV,
16661408cc1fSYuval Mintz "VF[%d] ACQUIRE_RESPONSE: pfdev_info- chip_num=0x%x, db_size=%d, idx_per_sb=%d, pf_cap=0x%llx\n"
16671408cc1fSYuval Mintz "resources- n_rxq-%d, n_txq-%d, n_sbs-%d, n_macs-%d, n_vlans-%d\n",
16681408cc1fSYuval Mintz vf->abs_vf_id,
16691408cc1fSYuval Mintz resp->pfdev_info.chip_num,
16701408cc1fSYuval Mintz resp->pfdev_info.db_size,
16711408cc1fSYuval Mintz resp->pfdev_info.indices_per_sb,
16721408cc1fSYuval Mintz resp->pfdev_info.capabilities,
16731408cc1fSYuval Mintz resc->num_rxqs,
16741408cc1fSYuval Mintz resc->num_txqs,
16751408cc1fSYuval Mintz resc->num_sbs,
16761408cc1fSYuval Mintz resc->num_mac_filters,
16771408cc1fSYuval Mintz resc->num_vlan_filters);
16781408cc1fSYuval Mintz vf->state = VF_ACQUIRED;
16791408cc1fSYuval Mintz
16801408cc1fSYuval Mintz /* Prepare Response */
16811408cc1fSYuval Mintz out:
16821408cc1fSYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, vf, CHANNEL_TLV_ACQUIRE,
16831408cc1fSYuval Mintz sizeof(struct pfvf_acquire_resp_tlv), vfpf_status);
168437bff2b9SYuval Mintz }
168537bff2b9SYuval Mintz
__qed_iov_spoofchk_set(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,bool val)16866ddc7608SYuval Mintz static int __qed_iov_spoofchk_set(struct qed_hwfn *p_hwfn,
16876ddc7608SYuval Mintz struct qed_vf_info *p_vf, bool val)
16886ddc7608SYuval Mintz {
16896ddc7608SYuval Mintz struct qed_sp_vport_update_params params;
16906ddc7608SYuval Mintz int rc;
16916ddc7608SYuval Mintz
16926ddc7608SYuval Mintz if (val == p_vf->spoof_chk) {
16936ddc7608SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
16946ddc7608SYuval Mintz "Spoofchk value[%d] is already configured\n", val);
16956ddc7608SYuval Mintz return 0;
16966ddc7608SYuval Mintz }
16976ddc7608SYuval Mintz
16986ddc7608SYuval Mintz memset(¶ms, 0, sizeof(struct qed_sp_vport_update_params));
16996ddc7608SYuval Mintz params.opaque_fid = p_vf->opaque_fid;
17006ddc7608SYuval Mintz params.vport_id = p_vf->vport_id;
17016ddc7608SYuval Mintz params.update_anti_spoofing_en_flg = 1;
17026ddc7608SYuval Mintz params.anti_spoofing_en = val;
17036ddc7608SYuval Mintz
17046ddc7608SYuval Mintz rc = qed_sp_vport_update(p_hwfn, ¶ms, QED_SPQ_MODE_EBLOCK, NULL);
1705cb1fa088SYuval Mintz if (!rc) {
17066ddc7608SYuval Mintz p_vf->spoof_chk = val;
17076ddc7608SYuval Mintz p_vf->req_spoofchk_val = p_vf->spoof_chk;
17086ddc7608SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
17096ddc7608SYuval Mintz "Spoofchk val[%d] configured\n", val);
17106ddc7608SYuval Mintz } else {
17116ddc7608SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
17126ddc7608SYuval Mintz "Spoofchk configuration[val:%d] failed for VF[%d]\n",
17136ddc7608SYuval Mintz val, p_vf->relative_vf_id);
17146ddc7608SYuval Mintz }
17156ddc7608SYuval Mintz
17166ddc7608SYuval Mintz return rc;
17176ddc7608SYuval Mintz }
17186ddc7608SYuval Mintz
qed_iov_reconfigure_unicast_vlan(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf)171908feecd7SYuval Mintz static int qed_iov_reconfigure_unicast_vlan(struct qed_hwfn *p_hwfn,
172008feecd7SYuval Mintz struct qed_vf_info *p_vf)
172108feecd7SYuval Mintz {
172208feecd7SYuval Mintz struct qed_filter_ucast filter;
172308feecd7SYuval Mintz int rc = 0;
172408feecd7SYuval Mintz int i;
172508feecd7SYuval Mintz
172608feecd7SYuval Mintz memset(&filter, 0, sizeof(filter));
172708feecd7SYuval Mintz filter.is_rx_filter = 1;
172808feecd7SYuval Mintz filter.is_tx_filter = 1;
172908feecd7SYuval Mintz filter.vport_to_add_to = p_vf->vport_id;
173008feecd7SYuval Mintz filter.opcode = QED_FILTER_ADD;
173108feecd7SYuval Mintz
173208feecd7SYuval Mintz /* Reconfigure vlans */
173308feecd7SYuval Mintz for (i = 0; i < QED_ETH_VF_NUM_VLAN_FILTERS + 1; i++) {
173408feecd7SYuval Mintz if (!p_vf->shadow_config.vlans[i].used)
173508feecd7SYuval Mintz continue;
173608feecd7SYuval Mintz
173708feecd7SYuval Mintz filter.type = QED_FILTER_VLAN;
173808feecd7SYuval Mintz filter.vlan = p_vf->shadow_config.vlans[i].vid;
17391a635e48SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
174008feecd7SYuval Mintz "Reconfiguring VLAN [0x%04x] for VF [%04x]\n",
174108feecd7SYuval Mintz filter.vlan, p_vf->relative_vf_id);
17421a635e48SYuval Mintz rc = qed_sp_eth_filter_ucast(p_hwfn, p_vf->opaque_fid,
17431a635e48SYuval Mintz &filter, QED_SPQ_MODE_CB, NULL);
174408feecd7SYuval Mintz if (rc) {
174508feecd7SYuval Mintz DP_NOTICE(p_hwfn,
174608feecd7SYuval Mintz "Failed to configure VLAN [%04x] to VF [%04x]\n",
174708feecd7SYuval Mintz filter.vlan, p_vf->relative_vf_id);
174808feecd7SYuval Mintz break;
174908feecd7SYuval Mintz }
175008feecd7SYuval Mintz }
175108feecd7SYuval Mintz
175208feecd7SYuval Mintz return rc;
175308feecd7SYuval Mintz }
175408feecd7SYuval Mintz
175508feecd7SYuval Mintz static int
qed_iov_reconfigure_unicast_shadow(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,u64 events)175608feecd7SYuval Mintz qed_iov_reconfigure_unicast_shadow(struct qed_hwfn *p_hwfn,
175708feecd7SYuval Mintz struct qed_vf_info *p_vf, u64 events)
175808feecd7SYuval Mintz {
175908feecd7SYuval Mintz int rc = 0;
176008feecd7SYuval Mintz
17611a635e48SYuval Mintz if ((events & BIT(VLAN_ADDR_FORCED)) &&
176208feecd7SYuval Mintz !(p_vf->configured_features & (1 << VLAN_ADDR_FORCED)))
176308feecd7SYuval Mintz rc = qed_iov_reconfigure_unicast_vlan(p_hwfn, p_vf);
176408feecd7SYuval Mintz
176508feecd7SYuval Mintz return rc;
176608feecd7SYuval Mintz }
176708feecd7SYuval Mintz
qed_iov_configure_vport_forced(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,u64 events)176808feecd7SYuval Mintz static int qed_iov_configure_vport_forced(struct qed_hwfn *p_hwfn,
176908feecd7SYuval Mintz struct qed_vf_info *p_vf, u64 events)
177008feecd7SYuval Mintz {
177108feecd7SYuval Mintz int rc = 0;
177208feecd7SYuval Mintz struct qed_filter_ucast filter;
177308feecd7SYuval Mintz
177408feecd7SYuval Mintz if (!p_vf->vport_instance)
177508feecd7SYuval Mintz return -EINVAL;
177608feecd7SYuval Mintz
17777425d822SShahed Shaikh if ((events & BIT(MAC_ADDR_FORCED)) ||
17787425d822SShahed Shaikh p_vf->p_vf_info.is_trusted_configured) {
1779eff16960SYuval Mintz /* Since there's no way [currently] of removing the MAC,
1780eff16960SYuval Mintz * we can always assume this means we need to force it.
1781eff16960SYuval Mintz */
1782eff16960SYuval Mintz memset(&filter, 0, sizeof(filter));
1783eff16960SYuval Mintz filter.type = QED_FILTER_MAC;
1784eff16960SYuval Mintz filter.opcode = QED_FILTER_REPLACE;
1785eff16960SYuval Mintz filter.is_rx_filter = 1;
1786eff16960SYuval Mintz filter.is_tx_filter = 1;
1787eff16960SYuval Mintz filter.vport_to_add_to = p_vf->vport_id;
1788eff16960SYuval Mintz ether_addr_copy(filter.mac, p_vf->bulletin.p_virt->mac);
1789eff16960SYuval Mintz
1790eff16960SYuval Mintz rc = qed_sp_eth_filter_ucast(p_hwfn, p_vf->opaque_fid,
1791eff16960SYuval Mintz &filter, QED_SPQ_MODE_CB, NULL);
1792eff16960SYuval Mintz if (rc) {
1793eff16960SYuval Mintz DP_NOTICE(p_hwfn,
1794eff16960SYuval Mintz "PF failed to configure MAC for VF\n");
1795eff16960SYuval Mintz return rc;
1796eff16960SYuval Mintz }
17977425d822SShahed Shaikh if (p_vf->p_vf_info.is_trusted_configured)
17987425d822SShahed Shaikh p_vf->configured_features |=
17997425d822SShahed Shaikh BIT(VFPF_BULLETIN_MAC_ADDR);
18007425d822SShahed Shaikh else
18017425d822SShahed Shaikh p_vf->configured_features |=
18027425d822SShahed Shaikh BIT(MAC_ADDR_FORCED);
1803eff16960SYuval Mintz }
1804eff16960SYuval Mintz
18051a635e48SYuval Mintz if (events & BIT(VLAN_ADDR_FORCED)) {
180608feecd7SYuval Mintz struct qed_sp_vport_update_params vport_update;
180708feecd7SYuval Mintz u8 removal;
180808feecd7SYuval Mintz int i;
180908feecd7SYuval Mintz
181008feecd7SYuval Mintz memset(&filter, 0, sizeof(filter));
181108feecd7SYuval Mintz filter.type = QED_FILTER_VLAN;
181208feecd7SYuval Mintz filter.is_rx_filter = 1;
181308feecd7SYuval Mintz filter.is_tx_filter = 1;
181408feecd7SYuval Mintz filter.vport_to_add_to = p_vf->vport_id;
181508feecd7SYuval Mintz filter.vlan = p_vf->bulletin.p_virt->pvid;
181608feecd7SYuval Mintz filter.opcode = filter.vlan ? QED_FILTER_REPLACE :
181708feecd7SYuval Mintz QED_FILTER_FLUSH;
181808feecd7SYuval Mintz
181908feecd7SYuval Mintz /* Send the ramrod */
182008feecd7SYuval Mintz rc = qed_sp_eth_filter_ucast(p_hwfn, p_vf->opaque_fid,
182108feecd7SYuval Mintz &filter, QED_SPQ_MODE_CB, NULL);
182208feecd7SYuval Mintz if (rc) {
182308feecd7SYuval Mintz DP_NOTICE(p_hwfn,
182408feecd7SYuval Mintz "PF failed to configure VLAN for VF\n");
182508feecd7SYuval Mintz return rc;
182608feecd7SYuval Mintz }
182708feecd7SYuval Mintz
182808feecd7SYuval Mintz /* Update the default-vlan & silent vlan stripping */
182908feecd7SYuval Mintz memset(&vport_update, 0, sizeof(vport_update));
183008feecd7SYuval Mintz vport_update.opaque_fid = p_vf->opaque_fid;
183108feecd7SYuval Mintz vport_update.vport_id = p_vf->vport_id;
183208feecd7SYuval Mintz vport_update.update_default_vlan_enable_flg = 1;
183308feecd7SYuval Mintz vport_update.default_vlan_enable_flg = filter.vlan ? 1 : 0;
183408feecd7SYuval Mintz vport_update.update_default_vlan_flg = 1;
183508feecd7SYuval Mintz vport_update.default_vlan = filter.vlan;
183608feecd7SYuval Mintz
183708feecd7SYuval Mintz vport_update.update_inner_vlan_removal_flg = 1;
183808feecd7SYuval Mintz removal = filter.vlan ? 1
183908feecd7SYuval Mintz : p_vf->shadow_config.inner_vlan_removal;
184008feecd7SYuval Mintz vport_update.inner_vlan_removal_flg = removal;
184108feecd7SYuval Mintz vport_update.silent_vlan_removal_flg = filter.vlan ? 1 : 0;
184208feecd7SYuval Mintz rc = qed_sp_vport_update(p_hwfn,
184308feecd7SYuval Mintz &vport_update,
184408feecd7SYuval Mintz QED_SPQ_MODE_EBLOCK, NULL);
184508feecd7SYuval Mintz if (rc) {
184608feecd7SYuval Mintz DP_NOTICE(p_hwfn,
184708feecd7SYuval Mintz "PF failed to configure VF vport for vlan\n");
184808feecd7SYuval Mintz return rc;
184908feecd7SYuval Mintz }
185008feecd7SYuval Mintz
185108feecd7SYuval Mintz /* Update all the Rx queues */
185208feecd7SYuval Mintz for (i = 0; i < QED_MAX_VF_CHAINS_PER_PF; i++) {
1853007bc371SMintz, Yuval struct qed_vf_queue *p_queue = &p_vf->vf_queues[i];
1854007bc371SMintz, Yuval struct qed_queue_cid *p_cid = NULL;
185508feecd7SYuval Mintz
1856007bc371SMintz, Yuval /* There can be at most 1 Rx queue on qzone. Find it */
1857007bc371SMintz, Yuval p_cid = qed_iov_get_vf_rx_queue_cid(p_queue);
18583da7a37aSMintz, Yuval if (!p_cid)
185908feecd7SYuval Mintz continue;
186008feecd7SYuval Mintz
18613da7a37aSMintz, Yuval rc = qed_sp_eth_rx_queues_update(p_hwfn,
18623da7a37aSMintz, Yuval (void **)&p_cid,
186308feecd7SYuval Mintz 1, 0, 1,
186408feecd7SYuval Mintz QED_SPQ_MODE_EBLOCK,
186508feecd7SYuval Mintz NULL);
186608feecd7SYuval Mintz if (rc) {
186708feecd7SYuval Mintz DP_NOTICE(p_hwfn,
186808feecd7SYuval Mintz "Failed to send Rx update fo queue[0x%04x]\n",
18693da7a37aSMintz, Yuval p_cid->rel.queue_id);
187008feecd7SYuval Mintz return rc;
187108feecd7SYuval Mintz }
187208feecd7SYuval Mintz }
187308feecd7SYuval Mintz
187408feecd7SYuval Mintz if (filter.vlan)
187508feecd7SYuval Mintz p_vf->configured_features |= 1 << VLAN_ADDR_FORCED;
187608feecd7SYuval Mintz else
18771a635e48SYuval Mintz p_vf->configured_features &= ~BIT(VLAN_ADDR_FORCED);
187808feecd7SYuval Mintz }
187908feecd7SYuval Mintz
188008feecd7SYuval Mintz /* If forced features are terminated, we need to configure the shadow
188108feecd7SYuval Mintz * configuration back again.
188208feecd7SYuval Mintz */
188308feecd7SYuval Mintz if (events)
188408feecd7SYuval Mintz qed_iov_reconfigure_unicast_shadow(p_hwfn, p_vf, events);
188508feecd7SYuval Mintz
188608feecd7SYuval Mintz return rc;
188708feecd7SYuval Mintz }
188808feecd7SYuval Mintz
qed_iov_vf_mbx_start_vport(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)1889dacd88d6SYuval Mintz static void qed_iov_vf_mbx_start_vport(struct qed_hwfn *p_hwfn,
1890dacd88d6SYuval Mintz struct qed_ptt *p_ptt,
1891dacd88d6SYuval Mintz struct qed_vf_info *vf)
1892dacd88d6SYuval Mintz {
1893dacd88d6SYuval Mintz struct qed_sp_vport_start_params params = { 0 };
1894dacd88d6SYuval Mintz struct qed_iov_vf_mbx *mbx = &vf->vf_mbx;
1895dacd88d6SYuval Mintz struct vfpf_vport_start_tlv *start;
1896dacd88d6SYuval Mintz u8 status = PFVF_STATUS_SUCCESS;
1897dacd88d6SYuval Mintz struct qed_vf_info *vf_info;
189808feecd7SYuval Mintz u64 *p_bitmap;
1899dacd88d6SYuval Mintz int sb_id;
1900dacd88d6SYuval Mintz int rc;
1901dacd88d6SYuval Mintz
1902dacd88d6SYuval Mintz vf_info = qed_iov_get_vf_info(p_hwfn, (u16)vf->relative_vf_id, true);
1903dacd88d6SYuval Mintz if (!vf_info) {
1904dacd88d6SYuval Mintz DP_NOTICE(p_hwfn->cdev,
1905dacd88d6SYuval Mintz "Failed to get VF info, invalid vfid [%d]\n",
1906dacd88d6SYuval Mintz vf->relative_vf_id);
1907dacd88d6SYuval Mintz return;
1908dacd88d6SYuval Mintz }
1909dacd88d6SYuval Mintz
1910dacd88d6SYuval Mintz vf->state = VF_ENABLED;
1911dacd88d6SYuval Mintz start = &mbx->req_virt->start_vport;
1912dacd88d6SYuval Mintz
1913b801b159SMintz, Yuval qed_iov_enable_vf_traffic(p_hwfn, p_ptt, vf);
1914b801b159SMintz, Yuval
1915dacd88d6SYuval Mintz /* Initialize Status block in CAU */
1916dacd88d6SYuval Mintz for (sb_id = 0; sb_id < vf->num_sbs; sb_id++) {
1917dacd88d6SYuval Mintz if (!start->sb_addr[sb_id]) {
1918dacd88d6SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
1919dacd88d6SYuval Mintz "VF[%d] did not fill the address of SB %d\n",
1920dacd88d6SYuval Mintz vf->relative_vf_id, sb_id);
1921dacd88d6SYuval Mintz break;
1922dacd88d6SYuval Mintz }
1923dacd88d6SYuval Mintz
1924dacd88d6SYuval Mintz qed_int_cau_conf_sb(p_hwfn, p_ptt,
1925dacd88d6SYuval Mintz start->sb_addr[sb_id],
19261a635e48SYuval Mintz vf->igu_sbs[sb_id], vf->abs_vf_id, 1);
1927dacd88d6SYuval Mintz }
1928dacd88d6SYuval Mintz
1929dacd88d6SYuval Mintz vf->mtu = start->mtu;
193008feecd7SYuval Mintz vf->shadow_config.inner_vlan_removal = start->inner_vlan_removal;
193108feecd7SYuval Mintz
193208feecd7SYuval Mintz /* Take into consideration configuration forced by hypervisor;
193308feecd7SYuval Mintz * If none is configured, use the supplied VF values [for old
193408feecd7SYuval Mintz * vfs that would still be fine, since they passed '0' as padding].
193508feecd7SYuval Mintz */
193608feecd7SYuval Mintz p_bitmap = &vf_info->bulletin.p_virt->valid_bitmap;
19371a635e48SYuval Mintz if (!(*p_bitmap & BIT(VFPF_BULLETIN_UNTAGGED_DEFAULT_FORCED))) {
193808feecd7SYuval Mintz u8 vf_req = start->only_untagged;
193908feecd7SYuval Mintz
194008feecd7SYuval Mintz vf_info->bulletin.p_virt->default_only_untagged = vf_req;
194108feecd7SYuval Mintz *p_bitmap |= 1 << VFPF_BULLETIN_UNTAGGED_DEFAULT;
194208feecd7SYuval Mintz }
1943dacd88d6SYuval Mintz
1944dacd88d6SYuval Mintz params.tpa_mode = start->tpa_mode;
1945dacd88d6SYuval Mintz params.remove_inner_vlan = start->inner_vlan_removal;
1946831bfb0eSYuval Mintz params.tx_switching = true;
1947dacd88d6SYuval Mintz
194808feecd7SYuval Mintz params.only_untagged = vf_info->bulletin.p_virt->default_only_untagged;
1949dacd88d6SYuval Mintz params.drop_ttl0 = false;
1950dacd88d6SYuval Mintz params.concrete_fid = vf->concrete_fid;
1951dacd88d6SYuval Mintz params.opaque_fid = vf->opaque_fid;
1952dacd88d6SYuval Mintz params.vport_id = vf->vport_id;
1953dacd88d6SYuval Mintz params.max_buffers_per_cqe = start->max_buffers_per_cqe;
1954dacd88d6SYuval Mintz params.mtu = vf->mtu;
1955ff929696SManish Chopra
1956ff929696SManish Chopra /* Non trusted VFs should enable control frame filtering */
1957ff929696SManish Chopra params.check_mac = !vf->p_vf_info.is_trusted_configured;
1958dacd88d6SYuval Mintz
1959dacd88d6SYuval Mintz rc = qed_sp_eth_vport_start(p_hwfn, ¶ms);
19601a635e48SYuval Mintz if (rc) {
1961dacd88d6SYuval Mintz DP_ERR(p_hwfn,
1962fe40a830SPrabhakar Kushwaha "%s returned error %d\n", __func__, rc);
1963dacd88d6SYuval Mintz status = PFVF_STATUS_FAILURE;
1964dacd88d6SYuval Mintz } else {
1965dacd88d6SYuval Mintz vf->vport_instance++;
196608feecd7SYuval Mintz
196708feecd7SYuval Mintz /* Force configuration if needed on the newly opened vport */
196808feecd7SYuval Mintz qed_iov_configure_vport_forced(p_hwfn, vf, *p_bitmap);
19696ddc7608SYuval Mintz
19706ddc7608SYuval Mintz __qed_iov_spoofchk_set(p_hwfn, vf, vf->req_spoofchk_val);
1971dacd88d6SYuval Mintz }
1972dacd88d6SYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, vf, CHANNEL_TLV_VPORT_START,
1973dacd88d6SYuval Mintz sizeof(struct pfvf_def_resp_tlv), status);
1974dacd88d6SYuval Mintz }
1975dacd88d6SYuval Mintz
qed_iov_vf_mbx_stop_vport(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)1976dacd88d6SYuval Mintz static void qed_iov_vf_mbx_stop_vport(struct qed_hwfn *p_hwfn,
1977dacd88d6SYuval Mintz struct qed_ptt *p_ptt,
1978dacd88d6SYuval Mintz struct qed_vf_info *vf)
1979dacd88d6SYuval Mintz {
1980dacd88d6SYuval Mintz u8 status = PFVF_STATUS_SUCCESS;
1981dacd88d6SYuval Mintz int rc;
1982dacd88d6SYuval Mintz
1983dacd88d6SYuval Mintz vf->vport_instance--;
19846ddc7608SYuval Mintz vf->spoof_chk = false;
1985dacd88d6SYuval Mintz
1986f109c240SMintz, Yuval if ((qed_iov_validate_active_rxq(p_hwfn, vf)) ||
1987f109c240SMintz, Yuval (qed_iov_validate_active_txq(p_hwfn, vf))) {
1988f109c240SMintz, Yuval vf->b_malicious = true;
1989f109c240SMintz, Yuval DP_NOTICE(p_hwfn,
1990dc99da4fSColin Ian King "VF [%02x] - considered malicious; Unable to stop RX/TX queues\n",
1991f109c240SMintz, Yuval vf->abs_vf_id);
1992f109c240SMintz, Yuval status = PFVF_STATUS_MALICIOUS;
1993f109c240SMintz, Yuval goto out;
1994f109c240SMintz, Yuval }
1995f109c240SMintz, Yuval
1996dacd88d6SYuval Mintz rc = qed_sp_vport_stop(p_hwfn, vf->opaque_fid, vf->vport_id);
19971a635e48SYuval Mintz if (rc) {
1998fe40a830SPrabhakar Kushwaha DP_ERR(p_hwfn, "%s returned error %d\n",
1999fe40a830SPrabhakar Kushwaha __func__, rc);
2000dacd88d6SYuval Mintz status = PFVF_STATUS_FAILURE;
2001dacd88d6SYuval Mintz }
2002dacd88d6SYuval Mintz
200308feecd7SYuval Mintz /* Forget the configuration on the vport */
200408feecd7SYuval Mintz vf->configured_features = 0;
200508feecd7SYuval Mintz memset(&vf->shadow_config, 0, sizeof(vf->shadow_config));
200608feecd7SYuval Mintz
2007f109c240SMintz, Yuval out:
2008dacd88d6SYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, vf, CHANNEL_TLV_VPORT_TEARDOWN,
2009dacd88d6SYuval Mintz sizeof(struct pfvf_def_resp_tlv), status);
2010dacd88d6SYuval Mintz }
2011dacd88d6SYuval Mintz
qed_iov_vf_mbx_start_rxq_resp(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf,u8 status,bool b_legacy)2012dacd88d6SYuval Mintz static void qed_iov_vf_mbx_start_rxq_resp(struct qed_hwfn *p_hwfn,
2013dacd88d6SYuval Mintz struct qed_ptt *p_ptt,
2014a044df83SYuval Mintz struct qed_vf_info *vf,
2015a044df83SYuval Mintz u8 status, bool b_legacy)
2016dacd88d6SYuval Mintz {
2017dacd88d6SYuval Mintz struct qed_iov_vf_mbx *mbx = &vf->vf_mbx;
2018dacd88d6SYuval Mintz struct pfvf_start_queue_resp_tlv *p_tlv;
2019dacd88d6SYuval Mintz struct vfpf_start_rxq_tlv *req;
2020a044df83SYuval Mintz u16 length;
2021dacd88d6SYuval Mintz
2022dacd88d6SYuval Mintz mbx->offset = (u8 *)mbx->reply_virt;
2023dacd88d6SYuval Mintz
2024a044df83SYuval Mintz /* Taking a bigger struct instead of adding a TLV to list was a
2025a044df83SYuval Mintz * mistake, but one which we're now stuck with, as some older
2026a044df83SYuval Mintz * clients assume the size of the previous response.
2027a044df83SYuval Mintz */
2028a044df83SYuval Mintz if (!b_legacy)
2029a044df83SYuval Mintz length = sizeof(*p_tlv);
2030a044df83SYuval Mintz else
2031a044df83SYuval Mintz length = sizeof(struct pfvf_def_resp_tlv);
2032a044df83SYuval Mintz
2033dacd88d6SYuval Mintz p_tlv = qed_add_tlv(p_hwfn, &mbx->offset, CHANNEL_TLV_START_RXQ,
2034a044df83SYuval Mintz length);
2035dacd88d6SYuval Mintz qed_add_tlv(p_hwfn, &mbx->offset, CHANNEL_TLV_LIST_END,
2036dacd88d6SYuval Mintz sizeof(struct channel_list_end_tlv));
2037dacd88d6SYuval Mintz
2038dacd88d6SYuval Mintz /* Update the TLV with the response */
2039a044df83SYuval Mintz if ((status == PFVF_STATUS_SUCCESS) && !b_legacy) {
2040dacd88d6SYuval Mintz req = &mbx->req_virt->start_rxq;
2041351a4dedSYuval Mintz p_tlv->offset = PXP_VF_BAR0_START_MSDM_ZONE_B +
2042351a4dedSYuval Mintz offsetof(struct mstorm_vf_zone,
2043351a4dedSYuval Mintz non_trigger.eth_rx_queue_producers) +
2044351a4dedSYuval Mintz sizeof(struct eth_rx_prod_data) * req->rx_qid;
2045dacd88d6SYuval Mintz }
2046dacd88d6SYuval Mintz
2047a044df83SYuval Mintz qed_iov_send_response(p_hwfn, p_ptt, vf, length, status);
2048dacd88d6SYuval Mintz }
2049dacd88d6SYuval Mintz
qed_iov_vf_mbx_qid(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,bool b_is_tx)2050bbe3f233SMintz, Yuval static u8 qed_iov_vf_mbx_qid(struct qed_hwfn *p_hwfn,
2051bbe3f233SMintz, Yuval struct qed_vf_info *p_vf, bool b_is_tx)
2052bbe3f233SMintz, Yuval {
205308bc8f15SMintz, Yuval struct qed_iov_vf_mbx *p_mbx = &p_vf->vf_mbx;
205408bc8f15SMintz, Yuval struct vfpf_qid_tlv *p_qid_tlv;
205508bc8f15SMintz, Yuval
205608bc8f15SMintz, Yuval /* Search for the qid if the VF published its going to provide it */
205708bc8f15SMintz, Yuval if (!(p_vf->acquire.vfdev_info.capabilities &
205808bc8f15SMintz, Yuval VFPF_ACQUIRE_CAP_QUEUE_QIDS)) {
2059bbe3f233SMintz, Yuval if (b_is_tx)
2060bbe3f233SMintz, Yuval return QED_IOV_LEGACY_QID_TX;
2061bbe3f233SMintz, Yuval else
2062bbe3f233SMintz, Yuval return QED_IOV_LEGACY_QID_RX;
2063bbe3f233SMintz, Yuval }
2064bbe3f233SMintz, Yuval
206508bc8f15SMintz, Yuval p_qid_tlv = (struct vfpf_qid_tlv *)
206608bc8f15SMintz, Yuval qed_iov_search_list_tlvs(p_hwfn, p_mbx->req_virt,
206708bc8f15SMintz, Yuval CHANNEL_TLV_QID);
206808bc8f15SMintz, Yuval if (!p_qid_tlv) {
206908bc8f15SMintz, Yuval DP_VERBOSE(p_hwfn, QED_MSG_IOV,
207008bc8f15SMintz, Yuval "VF[%2x]: Failed to provide qid\n",
207108bc8f15SMintz, Yuval p_vf->relative_vf_id);
207208bc8f15SMintz, Yuval
207308bc8f15SMintz, Yuval return QED_IOV_QID_INVALID;
207408bc8f15SMintz, Yuval }
207508bc8f15SMintz, Yuval
207608bc8f15SMintz, Yuval if (p_qid_tlv->qid >= MAX_QUEUES_PER_QZONE) {
207708bc8f15SMintz, Yuval DP_VERBOSE(p_hwfn, QED_MSG_IOV,
207808bc8f15SMintz, Yuval "VF[%02x]: Provided qid out-of-bounds %02x\n",
207908bc8f15SMintz, Yuval p_vf->relative_vf_id, p_qid_tlv->qid);
208008bc8f15SMintz, Yuval return QED_IOV_QID_INVALID;
208108bc8f15SMintz, Yuval }
208208bc8f15SMintz, Yuval
208308bc8f15SMintz, Yuval return p_qid_tlv->qid;
208408bc8f15SMintz, Yuval }
208508bc8f15SMintz, Yuval
qed_iov_vf_mbx_start_rxq(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)2086dacd88d6SYuval Mintz static void qed_iov_vf_mbx_start_rxq(struct qed_hwfn *p_hwfn,
2087dacd88d6SYuval Mintz struct qed_ptt *p_ptt,
2088dacd88d6SYuval Mintz struct qed_vf_info *vf)
2089dacd88d6SYuval Mintz {
2090dacd88d6SYuval Mintz struct qed_queue_start_common_params params;
20913946497aSMintz, Yuval struct qed_queue_cid_vf_params vf_params;
2092dacd88d6SYuval Mintz struct qed_iov_vf_mbx *mbx = &vf->vf_mbx;
209341086467SYuval Mintz u8 status = PFVF_STATUS_NO_RESOURCE;
20943b19f478SMintz, Yuval u8 qid_usage_idx, vf_legacy = 0;
2095dacd88d6SYuval Mintz struct vfpf_start_rxq_tlv *req;
2096007bc371SMintz, Yuval struct qed_vf_queue *p_queue;
2097007bc371SMintz, Yuval struct qed_queue_cid *p_cid;
2098f604b17dSMintz, Yuval struct qed_sb_info sb_dummy;
2099dacd88d6SYuval Mintz int rc;
2100dacd88d6SYuval Mintz
2101dacd88d6SYuval Mintz req = &mbx->req_virt->start_rxq;
210241086467SYuval Mintz
2103f109c240SMintz, Yuval if (!qed_iov_validate_rxq(p_hwfn, vf, req->rx_qid,
2104f109c240SMintz, Yuval QED_IOV_VALIDATE_Q_DISABLE) ||
210541086467SYuval Mintz !qed_iov_validate_sb(p_hwfn, vf, req->hw_sb))
210641086467SYuval Mintz goto out;
210741086467SYuval Mintz
2108bbe3f233SMintz, Yuval qid_usage_idx = qed_iov_vf_mbx_qid(p_hwfn, vf, false);
210908bc8f15SMintz, Yuval if (qid_usage_idx == QED_IOV_QID_INVALID)
211008bc8f15SMintz, Yuval goto out;
211108bc8f15SMintz, Yuval
21123da7a37aSMintz, Yuval p_queue = &vf->vf_queues[req->rx_qid];
211308bc8f15SMintz, Yuval if (p_queue->cids[qid_usage_idx].p_cid)
211408bc8f15SMintz, Yuval goto out;
21153da7a37aSMintz, Yuval
21163b19f478SMintz, Yuval vf_legacy = qed_vf_calculate_legacy(vf);
21173946497aSMintz, Yuval
2118bbe3f233SMintz, Yuval /* Acquire a new queue-cid */
21193da7a37aSMintz, Yuval memset(¶ms, 0, sizeof(params));
21203da7a37aSMintz, Yuval params.queue_id = p_queue->fw_rx_qid;
2121dacd88d6SYuval Mintz params.vport_id = vf->vport_id;
21223da7a37aSMintz, Yuval params.stats_id = vf->abs_vf_id + 0x10;
2123f604b17dSMintz, Yuval /* Since IGU index is passed via sb_info, construct a dummy one */
2124f604b17dSMintz, Yuval memset(&sb_dummy, 0, sizeof(sb_dummy));
2125f604b17dSMintz, Yuval sb_dummy.igu_sb_id = req->hw_sb;
2126f604b17dSMintz, Yuval params.p_sb = &sb_dummy;
2127dacd88d6SYuval Mintz params.sb_idx = req->sb_index;
2128dacd88d6SYuval Mintz
21293946497aSMintz, Yuval memset(&vf_params, 0, sizeof(vf_params));
21303946497aSMintz, Yuval vf_params.vfid = vf->relative_vf_id;
21313946497aSMintz, Yuval vf_params.vf_qid = (u8)req->rx_qid;
21323b19f478SMintz, Yuval vf_params.vf_legacy = vf_legacy;
2133bbe3f233SMintz, Yuval vf_params.qid_usage_idx = qid_usage_idx;
2134007bc371SMintz, Yuval p_cid = qed_eth_queue_to_cid(p_hwfn, vf->opaque_fid,
2135007bc371SMintz, Yuval ¶ms, true, &vf_params);
2136007bc371SMintz, Yuval if (!p_cid)
21373da7a37aSMintz, Yuval goto out;
21383da7a37aSMintz, Yuval
2139a044df83SYuval Mintz /* Legacy VFs have their Producers in a different location, which they
2140a044df83SYuval Mintz * calculate on their own and clean the producer prior to this.
2141a044df83SYuval Mintz */
21423b19f478SMintz, Yuval if (!(vf_legacy & QED_QCID_LEGACY_VF_RX_PROD))
2143e2dbc223SPrabhakar Kushwaha qed_wr(p_hwfn, p_ptt, MSEM_REG_FAST_MEMORY +
2144e2dbc223SPrabhakar Kushwaha SEM_FAST_REG_INT_RAM +
2145e2dbc223SPrabhakar Kushwaha MSTORM_ETH_VF_PRODS_OFFSET(vf->abs_vf_id,
2146e2dbc223SPrabhakar Kushwaha req->rx_qid), 0);
2147a044df83SYuval Mintz
2148007bc371SMintz, Yuval rc = qed_eth_rxq_start_ramrod(p_hwfn, p_cid,
2149dacd88d6SYuval Mintz req->bd_max_bytes,
2150dacd88d6SYuval Mintz req->rxq_addr,
21513da7a37aSMintz, Yuval req->cqe_pbl_addr, req->cqe_pbl_size);
2152dacd88d6SYuval Mintz if (rc) {
2153dacd88d6SYuval Mintz status = PFVF_STATUS_FAILURE;
2154007bc371SMintz, Yuval qed_eth_queue_cid_release(p_hwfn, p_cid);
2155dacd88d6SYuval Mintz } else {
2156007bc371SMintz, Yuval p_queue->cids[qid_usage_idx].p_cid = p_cid;
2157007bc371SMintz, Yuval p_queue->cids[qid_usage_idx].b_is_tx = false;
215841086467SYuval Mintz status = PFVF_STATUS_SUCCESS;
2159dacd88d6SYuval Mintz vf->num_active_rxqs++;
2160dacd88d6SYuval Mintz }
2161dacd88d6SYuval Mintz
216241086467SYuval Mintz out:
21633b19f478SMintz, Yuval qed_iov_vf_mbx_start_rxq_resp(p_hwfn, p_ptt, vf, status,
21643b19f478SMintz, Yuval !!(vf_legacy &
21653b19f478SMintz, Yuval QED_QCID_LEGACY_VF_RX_PROD));
2166dacd88d6SYuval Mintz }
2167dacd88d6SYuval Mintz
2168eaf3c0c6SChopra, Manish static void
qed_iov_pf_update_tun_response(struct pfvf_update_tunn_param_tlv * p_resp,struct qed_tunnel_info * p_tun,u16 tunn_feature_mask)2169eaf3c0c6SChopra, Manish qed_iov_pf_update_tun_response(struct pfvf_update_tunn_param_tlv *p_resp,
2170eaf3c0c6SChopra, Manish struct qed_tunnel_info *p_tun,
2171eaf3c0c6SChopra, Manish u16 tunn_feature_mask)
2172eaf3c0c6SChopra, Manish {
2173eaf3c0c6SChopra, Manish p_resp->tunn_feature_mask = tunn_feature_mask;
2174eaf3c0c6SChopra, Manish p_resp->vxlan_mode = p_tun->vxlan.b_mode_enabled;
2175eaf3c0c6SChopra, Manish p_resp->l2geneve_mode = p_tun->l2_geneve.b_mode_enabled;
2176eaf3c0c6SChopra, Manish p_resp->ipgeneve_mode = p_tun->ip_geneve.b_mode_enabled;
2177eaf3c0c6SChopra, Manish p_resp->l2gre_mode = p_tun->l2_gre.b_mode_enabled;
2178eaf3c0c6SChopra, Manish p_resp->ipgre_mode = p_tun->l2_gre.b_mode_enabled;
2179eaf3c0c6SChopra, Manish p_resp->vxlan_clss = p_tun->vxlan.tun_cls;
2180eaf3c0c6SChopra, Manish p_resp->l2gre_clss = p_tun->l2_gre.tun_cls;
2181eaf3c0c6SChopra, Manish p_resp->ipgre_clss = p_tun->ip_gre.tun_cls;
2182eaf3c0c6SChopra, Manish p_resp->l2geneve_clss = p_tun->l2_geneve.tun_cls;
2183eaf3c0c6SChopra, Manish p_resp->ipgeneve_clss = p_tun->ip_geneve.tun_cls;
2184eaf3c0c6SChopra, Manish p_resp->geneve_udp_port = p_tun->geneve_port.port;
2185eaf3c0c6SChopra, Manish p_resp->vxlan_udp_port = p_tun->vxlan_port.port;
2186eaf3c0c6SChopra, Manish }
2187eaf3c0c6SChopra, Manish
2188eaf3c0c6SChopra, Manish static void
__qed_iov_pf_update_tun_param(struct vfpf_update_tunn_param_tlv * p_req,struct qed_tunn_update_type * p_tun,enum qed_tunn_mode mask,u8 tun_cls)2189eaf3c0c6SChopra, Manish __qed_iov_pf_update_tun_param(struct vfpf_update_tunn_param_tlv *p_req,
2190eaf3c0c6SChopra, Manish struct qed_tunn_update_type *p_tun,
2191eaf3c0c6SChopra, Manish enum qed_tunn_mode mask, u8 tun_cls)
2192eaf3c0c6SChopra, Manish {
2193eaf3c0c6SChopra, Manish if (p_req->tun_mode_update_mask & BIT(mask)) {
2194eaf3c0c6SChopra, Manish p_tun->b_update_mode = true;
2195eaf3c0c6SChopra, Manish
2196eaf3c0c6SChopra, Manish if (p_req->tunn_mode & BIT(mask))
2197eaf3c0c6SChopra, Manish p_tun->b_mode_enabled = true;
2198eaf3c0c6SChopra, Manish }
2199eaf3c0c6SChopra, Manish
2200eaf3c0c6SChopra, Manish p_tun->tun_cls = tun_cls;
2201eaf3c0c6SChopra, Manish }
2202eaf3c0c6SChopra, Manish
2203eaf3c0c6SChopra, Manish static void
qed_iov_pf_update_tun_param(struct vfpf_update_tunn_param_tlv * p_req,struct qed_tunn_update_type * p_tun,struct qed_tunn_update_udp_port * p_port,enum qed_tunn_mode mask,u8 tun_cls,u8 update_port,u16 port)2204eaf3c0c6SChopra, Manish qed_iov_pf_update_tun_param(struct vfpf_update_tunn_param_tlv *p_req,
2205eaf3c0c6SChopra, Manish struct qed_tunn_update_type *p_tun,
2206eaf3c0c6SChopra, Manish struct qed_tunn_update_udp_port *p_port,
2207eaf3c0c6SChopra, Manish enum qed_tunn_mode mask,
2208eaf3c0c6SChopra, Manish u8 tun_cls, u8 update_port, u16 port)
2209eaf3c0c6SChopra, Manish {
2210eaf3c0c6SChopra, Manish if (update_port) {
2211eaf3c0c6SChopra, Manish p_port->b_update_port = true;
2212eaf3c0c6SChopra, Manish p_port->port = port;
2213eaf3c0c6SChopra, Manish }
2214eaf3c0c6SChopra, Manish
2215eaf3c0c6SChopra, Manish __qed_iov_pf_update_tun_param(p_req, p_tun, mask, tun_cls);
2216eaf3c0c6SChopra, Manish }
2217eaf3c0c6SChopra, Manish
2218eaf3c0c6SChopra, Manish static bool
qed_iov_pf_validate_tunn_param(struct vfpf_update_tunn_param_tlv * p_req)2219eaf3c0c6SChopra, Manish qed_iov_pf_validate_tunn_param(struct vfpf_update_tunn_param_tlv *p_req)
2220eaf3c0c6SChopra, Manish {
2221eaf3c0c6SChopra, Manish bool b_update_requested = false;
2222eaf3c0c6SChopra, Manish
2223eaf3c0c6SChopra, Manish if (p_req->tun_mode_update_mask || p_req->update_tun_cls ||
2224eaf3c0c6SChopra, Manish p_req->update_geneve_port || p_req->update_vxlan_port)
2225eaf3c0c6SChopra, Manish b_update_requested = true;
2226eaf3c0c6SChopra, Manish
2227eaf3c0c6SChopra, Manish return b_update_requested;
2228eaf3c0c6SChopra, Manish }
2229eaf3c0c6SChopra, Manish
qed_pf_validate_tunn_mode(struct qed_tunn_update_type * tun,int * rc)2230eaf3c0c6SChopra, Manish static void qed_pf_validate_tunn_mode(struct qed_tunn_update_type *tun, int *rc)
2231eaf3c0c6SChopra, Manish {
2232eaf3c0c6SChopra, Manish if (tun->b_update_mode && !tun->b_mode_enabled) {
2233eaf3c0c6SChopra, Manish tun->b_update_mode = false;
2234eaf3c0c6SChopra, Manish *rc = -EINVAL;
2235eaf3c0c6SChopra, Manish }
2236eaf3c0c6SChopra, Manish }
2237eaf3c0c6SChopra, Manish
2238eaf3c0c6SChopra, Manish static int
qed_pf_validate_modify_tunn_config(struct qed_hwfn * p_hwfn,u16 * tun_features,bool * update,struct qed_tunnel_info * tun_src)2239eaf3c0c6SChopra, Manish qed_pf_validate_modify_tunn_config(struct qed_hwfn *p_hwfn,
2240eaf3c0c6SChopra, Manish u16 *tun_features, bool *update,
2241eaf3c0c6SChopra, Manish struct qed_tunnel_info *tun_src)
2242eaf3c0c6SChopra, Manish {
2243eaf3c0c6SChopra, Manish struct qed_eth_cb_ops *ops = p_hwfn->cdev->protocol_ops.eth;
2244eaf3c0c6SChopra, Manish struct qed_tunnel_info *tun = &p_hwfn->cdev->tunnel;
2245eaf3c0c6SChopra, Manish u16 bultn_vxlan_port, bultn_geneve_port;
2246eaf3c0c6SChopra, Manish void *cookie = p_hwfn->cdev->ops_cookie;
2247eaf3c0c6SChopra, Manish int i, rc = 0;
2248eaf3c0c6SChopra, Manish
2249eaf3c0c6SChopra, Manish *tun_features = p_hwfn->cdev->tunn_feature_mask;
2250eaf3c0c6SChopra, Manish bultn_vxlan_port = tun->vxlan_port.port;
2251eaf3c0c6SChopra, Manish bultn_geneve_port = tun->geneve_port.port;
2252eaf3c0c6SChopra, Manish qed_pf_validate_tunn_mode(&tun_src->vxlan, &rc);
2253eaf3c0c6SChopra, Manish qed_pf_validate_tunn_mode(&tun_src->l2_geneve, &rc);
2254eaf3c0c6SChopra, Manish qed_pf_validate_tunn_mode(&tun_src->ip_geneve, &rc);
2255eaf3c0c6SChopra, Manish qed_pf_validate_tunn_mode(&tun_src->l2_gre, &rc);
2256eaf3c0c6SChopra, Manish qed_pf_validate_tunn_mode(&tun_src->ip_gre, &rc);
2257eaf3c0c6SChopra, Manish
2258eaf3c0c6SChopra, Manish if ((tun_src->b_update_rx_cls || tun_src->b_update_tx_cls) &&
2259eaf3c0c6SChopra, Manish (tun_src->vxlan.tun_cls != QED_TUNN_CLSS_MAC_VLAN ||
2260eaf3c0c6SChopra, Manish tun_src->l2_geneve.tun_cls != QED_TUNN_CLSS_MAC_VLAN ||
2261eaf3c0c6SChopra, Manish tun_src->ip_geneve.tun_cls != QED_TUNN_CLSS_MAC_VLAN ||
2262eaf3c0c6SChopra, Manish tun_src->l2_gre.tun_cls != QED_TUNN_CLSS_MAC_VLAN ||
2263eaf3c0c6SChopra, Manish tun_src->ip_gre.tun_cls != QED_TUNN_CLSS_MAC_VLAN)) {
2264eaf3c0c6SChopra, Manish tun_src->b_update_rx_cls = false;
2265eaf3c0c6SChopra, Manish tun_src->b_update_tx_cls = false;
2266eaf3c0c6SChopra, Manish rc = -EINVAL;
2267eaf3c0c6SChopra, Manish }
2268eaf3c0c6SChopra, Manish
2269eaf3c0c6SChopra, Manish if (tun_src->vxlan_port.b_update_port) {
2270eaf3c0c6SChopra, Manish if (tun_src->vxlan_port.port == tun->vxlan_port.port) {
2271eaf3c0c6SChopra, Manish tun_src->vxlan_port.b_update_port = false;
2272eaf3c0c6SChopra, Manish } else {
2273eaf3c0c6SChopra, Manish *update = true;
2274eaf3c0c6SChopra, Manish bultn_vxlan_port = tun_src->vxlan_port.port;
2275eaf3c0c6SChopra, Manish }
2276eaf3c0c6SChopra, Manish }
2277eaf3c0c6SChopra, Manish
2278eaf3c0c6SChopra, Manish if (tun_src->geneve_port.b_update_port) {
2279eaf3c0c6SChopra, Manish if (tun_src->geneve_port.port == tun->geneve_port.port) {
2280eaf3c0c6SChopra, Manish tun_src->geneve_port.b_update_port = false;
2281eaf3c0c6SChopra, Manish } else {
2282eaf3c0c6SChopra, Manish *update = true;
2283eaf3c0c6SChopra, Manish bultn_geneve_port = tun_src->geneve_port.port;
2284eaf3c0c6SChopra, Manish }
2285eaf3c0c6SChopra, Manish }
2286eaf3c0c6SChopra, Manish
2287eaf3c0c6SChopra, Manish qed_for_each_vf(p_hwfn, i) {
2288eaf3c0c6SChopra, Manish qed_iov_bulletin_set_udp_ports(p_hwfn, i, bultn_vxlan_port,
2289eaf3c0c6SChopra, Manish bultn_geneve_port);
2290eaf3c0c6SChopra, Manish }
2291eaf3c0c6SChopra, Manish
2292eaf3c0c6SChopra, Manish qed_schedule_iov(p_hwfn, QED_IOV_WQ_BULLETIN_UPDATE_FLAG);
2293eaf3c0c6SChopra, Manish ops->ports_update(cookie, bultn_vxlan_port, bultn_geneve_port);
2294eaf3c0c6SChopra, Manish
2295eaf3c0c6SChopra, Manish return rc;
2296eaf3c0c6SChopra, Manish }
2297eaf3c0c6SChopra, Manish
qed_iov_vf_mbx_update_tunn_param(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * p_vf)2298eaf3c0c6SChopra, Manish static void qed_iov_vf_mbx_update_tunn_param(struct qed_hwfn *p_hwfn,
2299eaf3c0c6SChopra, Manish struct qed_ptt *p_ptt,
2300eaf3c0c6SChopra, Manish struct qed_vf_info *p_vf)
2301eaf3c0c6SChopra, Manish {
2302eaf3c0c6SChopra, Manish struct qed_tunnel_info *p_tun = &p_hwfn->cdev->tunnel;
2303eaf3c0c6SChopra, Manish struct qed_iov_vf_mbx *mbx = &p_vf->vf_mbx;
2304eaf3c0c6SChopra, Manish struct pfvf_update_tunn_param_tlv *p_resp;
2305eaf3c0c6SChopra, Manish struct vfpf_update_tunn_param_tlv *p_req;
2306eaf3c0c6SChopra, Manish u8 status = PFVF_STATUS_SUCCESS;
2307eaf3c0c6SChopra, Manish bool b_update_required = false;
2308eaf3c0c6SChopra, Manish struct qed_tunnel_info tunn;
2309eaf3c0c6SChopra, Manish u16 tunn_feature_mask = 0;
2310eaf3c0c6SChopra, Manish int i, rc = 0;
2311eaf3c0c6SChopra, Manish
2312eaf3c0c6SChopra, Manish mbx->offset = (u8 *)mbx->reply_virt;
2313eaf3c0c6SChopra, Manish
2314eaf3c0c6SChopra, Manish memset(&tunn, 0, sizeof(tunn));
2315eaf3c0c6SChopra, Manish p_req = &mbx->req_virt->tunn_param_update;
2316eaf3c0c6SChopra, Manish
2317eaf3c0c6SChopra, Manish if (!qed_iov_pf_validate_tunn_param(p_req)) {
2318eaf3c0c6SChopra, Manish DP_VERBOSE(p_hwfn, QED_MSG_IOV,
2319eaf3c0c6SChopra, Manish "No tunnel update requested by VF\n");
2320eaf3c0c6SChopra, Manish status = PFVF_STATUS_FAILURE;
2321eaf3c0c6SChopra, Manish goto send_resp;
2322eaf3c0c6SChopra, Manish }
2323eaf3c0c6SChopra, Manish
2324eaf3c0c6SChopra, Manish tunn.b_update_rx_cls = p_req->update_tun_cls;
2325eaf3c0c6SChopra, Manish tunn.b_update_tx_cls = p_req->update_tun_cls;
2326eaf3c0c6SChopra, Manish
2327eaf3c0c6SChopra, Manish qed_iov_pf_update_tun_param(p_req, &tunn.vxlan, &tunn.vxlan_port,
2328eaf3c0c6SChopra, Manish QED_MODE_VXLAN_TUNN, p_req->vxlan_clss,
2329eaf3c0c6SChopra, Manish p_req->update_vxlan_port,
2330eaf3c0c6SChopra, Manish p_req->vxlan_port);
2331eaf3c0c6SChopra, Manish qed_iov_pf_update_tun_param(p_req, &tunn.l2_geneve, &tunn.geneve_port,
2332eaf3c0c6SChopra, Manish QED_MODE_L2GENEVE_TUNN,
2333eaf3c0c6SChopra, Manish p_req->l2geneve_clss,
2334eaf3c0c6SChopra, Manish p_req->update_geneve_port,
2335eaf3c0c6SChopra, Manish p_req->geneve_port);
2336eaf3c0c6SChopra, Manish __qed_iov_pf_update_tun_param(p_req, &tunn.ip_geneve,
2337eaf3c0c6SChopra, Manish QED_MODE_IPGENEVE_TUNN,
2338eaf3c0c6SChopra, Manish p_req->ipgeneve_clss);
2339eaf3c0c6SChopra, Manish __qed_iov_pf_update_tun_param(p_req, &tunn.l2_gre,
2340eaf3c0c6SChopra, Manish QED_MODE_L2GRE_TUNN, p_req->l2gre_clss);
2341eaf3c0c6SChopra, Manish __qed_iov_pf_update_tun_param(p_req, &tunn.ip_gre,
2342eaf3c0c6SChopra, Manish QED_MODE_IPGRE_TUNN, p_req->ipgre_clss);
2343eaf3c0c6SChopra, Manish
2344eaf3c0c6SChopra, Manish /* If PF modifies VF's req then it should
2345eaf3c0c6SChopra, Manish * still return an error in case of partial configuration
2346eaf3c0c6SChopra, Manish * or modified configuration as opposed to requested one.
2347eaf3c0c6SChopra, Manish */
2348eaf3c0c6SChopra, Manish rc = qed_pf_validate_modify_tunn_config(p_hwfn, &tunn_feature_mask,
2349eaf3c0c6SChopra, Manish &b_update_required, &tunn);
2350eaf3c0c6SChopra, Manish
2351eaf3c0c6SChopra, Manish if (rc)
2352eaf3c0c6SChopra, Manish status = PFVF_STATUS_FAILURE;
2353eaf3c0c6SChopra, Manish
2354eaf3c0c6SChopra, Manish /* If QED client is willing to update anything ? */
2355eaf3c0c6SChopra, Manish if (b_update_required) {
2356eaf3c0c6SChopra, Manish u16 geneve_port;
2357eaf3c0c6SChopra, Manish
23584f64675fSManish Chopra rc = qed_sp_pf_update_tunn_cfg(p_hwfn, p_ptt, &tunn,
2359eaf3c0c6SChopra, Manish QED_SPQ_MODE_EBLOCK, NULL);
2360eaf3c0c6SChopra, Manish if (rc)
2361eaf3c0c6SChopra, Manish status = PFVF_STATUS_FAILURE;
2362eaf3c0c6SChopra, Manish
2363eaf3c0c6SChopra, Manish geneve_port = p_tun->geneve_port.port;
2364eaf3c0c6SChopra, Manish qed_for_each_vf(p_hwfn, i) {
2365eaf3c0c6SChopra, Manish qed_iov_bulletin_set_udp_ports(p_hwfn, i,
2366eaf3c0c6SChopra, Manish p_tun->vxlan_port.port,
2367eaf3c0c6SChopra, Manish geneve_port);
2368eaf3c0c6SChopra, Manish }
2369eaf3c0c6SChopra, Manish }
2370eaf3c0c6SChopra, Manish
2371eaf3c0c6SChopra, Manish send_resp:
2372eaf3c0c6SChopra, Manish p_resp = qed_add_tlv(p_hwfn, &mbx->offset,
2373eaf3c0c6SChopra, Manish CHANNEL_TLV_UPDATE_TUNN_PARAM, sizeof(*p_resp));
2374eaf3c0c6SChopra, Manish
2375eaf3c0c6SChopra, Manish qed_iov_pf_update_tun_response(p_resp, p_tun, tunn_feature_mask);
2376eaf3c0c6SChopra, Manish qed_add_tlv(p_hwfn, &mbx->offset, CHANNEL_TLV_LIST_END,
2377eaf3c0c6SChopra, Manish sizeof(struct channel_list_end_tlv));
2378eaf3c0c6SChopra, Manish
2379eaf3c0c6SChopra, Manish qed_iov_send_response(p_hwfn, p_ptt, p_vf, sizeof(*p_resp), status);
2380eaf3c0c6SChopra, Manish }
2381eaf3c0c6SChopra, Manish
qed_iov_vf_mbx_start_txq_resp(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * p_vf,u32 cid,u8 status)23825040acf5SYuval Mintz static void qed_iov_vf_mbx_start_txq_resp(struct qed_hwfn *p_hwfn,
23835040acf5SYuval Mintz struct qed_ptt *p_ptt,
2384007bc371SMintz, Yuval struct qed_vf_info *p_vf,
2385007bc371SMintz, Yuval u32 cid, u8 status)
23865040acf5SYuval Mintz {
23875040acf5SYuval Mintz struct qed_iov_vf_mbx *mbx = &p_vf->vf_mbx;
23885040acf5SYuval Mintz struct pfvf_start_queue_resp_tlv *p_tlv;
2389a044df83SYuval Mintz bool b_legacy = false;
2390a044df83SYuval Mintz u16 length;
23915040acf5SYuval Mintz
23925040acf5SYuval Mintz mbx->offset = (u8 *)mbx->reply_virt;
23935040acf5SYuval Mintz
2394a044df83SYuval Mintz /* Taking a bigger struct instead of adding a TLV to list was a
2395a044df83SYuval Mintz * mistake, but one which we're now stuck with, as some older
2396a044df83SYuval Mintz * clients assume the size of the previous response.
2397a044df83SYuval Mintz */
2398a044df83SYuval Mintz if (p_vf->acquire.vfdev_info.eth_fp_hsi_minor ==
2399a044df83SYuval Mintz ETH_HSI_VER_NO_PKT_LEN_TUNN)
2400a044df83SYuval Mintz b_legacy = true;
2401a044df83SYuval Mintz
2402a044df83SYuval Mintz if (!b_legacy)
2403a044df83SYuval Mintz length = sizeof(*p_tlv);
2404a044df83SYuval Mintz else
2405a044df83SYuval Mintz length = sizeof(struct pfvf_def_resp_tlv);
2406a044df83SYuval Mintz
24075040acf5SYuval Mintz p_tlv = qed_add_tlv(p_hwfn, &mbx->offset, CHANNEL_TLV_START_TXQ,
2408a044df83SYuval Mintz length);
24095040acf5SYuval Mintz qed_add_tlv(p_hwfn, &mbx->offset, CHANNEL_TLV_LIST_END,
24105040acf5SYuval Mintz sizeof(struct channel_list_end_tlv));
24115040acf5SYuval Mintz
24125040acf5SYuval Mintz /* Update the TLV with the response */
2413007bc371SMintz, Yuval if ((status == PFVF_STATUS_SUCCESS) && !b_legacy)
2414007bc371SMintz, Yuval p_tlv->offset = qed_db_addr_vf(cid, DQ_DEMS_LEGACY);
24155040acf5SYuval Mintz
2416a044df83SYuval Mintz qed_iov_send_response(p_hwfn, p_ptt, p_vf, length, status);
24175040acf5SYuval Mintz }
24185040acf5SYuval Mintz
qed_iov_vf_mbx_start_txq(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)2419dacd88d6SYuval Mintz static void qed_iov_vf_mbx_start_txq(struct qed_hwfn *p_hwfn,
2420dacd88d6SYuval Mintz struct qed_ptt *p_ptt,
2421dacd88d6SYuval Mintz struct qed_vf_info *vf)
2422dacd88d6SYuval Mintz {
2423dacd88d6SYuval Mintz struct qed_queue_start_common_params params;
24243946497aSMintz, Yuval struct qed_queue_cid_vf_params vf_params;
2425dacd88d6SYuval Mintz struct qed_iov_vf_mbx *mbx = &vf->vf_mbx;
242641086467SYuval Mintz u8 status = PFVF_STATUS_NO_RESOURCE;
2427dacd88d6SYuval Mintz struct vfpf_start_txq_tlv *req;
2428007bc371SMintz, Yuval struct qed_vf_queue *p_queue;
2429007bc371SMintz, Yuval struct qed_queue_cid *p_cid;
2430f604b17dSMintz, Yuval struct qed_sb_info sb_dummy;
24313b19f478SMintz, Yuval u8 qid_usage_idx, vf_legacy;
2432007bc371SMintz, Yuval u32 cid = 0;
2433dacd88d6SYuval Mintz int rc;
24343da7a37aSMintz, Yuval u16 pq;
2435dacd88d6SYuval Mintz
2436dacd88d6SYuval Mintz memset(¶ms, 0, sizeof(params));
2437dacd88d6SYuval Mintz req = &mbx->req_virt->start_txq;
243841086467SYuval Mintz
2439f109c240SMintz, Yuval if (!qed_iov_validate_txq(p_hwfn, vf, req->tx_qid,
244008bc8f15SMintz, Yuval QED_IOV_VALIDATE_Q_NA) ||
244141086467SYuval Mintz !qed_iov_validate_sb(p_hwfn, vf, req->hw_sb))
244241086467SYuval Mintz goto out;
244341086467SYuval Mintz
2444bbe3f233SMintz, Yuval qid_usage_idx = qed_iov_vf_mbx_qid(p_hwfn, vf, true);
244508bc8f15SMintz, Yuval if (qid_usage_idx == QED_IOV_QID_INVALID)
244608bc8f15SMintz, Yuval goto out;
244708bc8f15SMintz, Yuval
24483da7a37aSMintz, Yuval p_queue = &vf->vf_queues[req->tx_qid];
244908bc8f15SMintz, Yuval if (p_queue->cids[qid_usage_idx].p_cid)
245008bc8f15SMintz, Yuval goto out;
24513da7a37aSMintz, Yuval
24523b19f478SMintz, Yuval vf_legacy = qed_vf_calculate_legacy(vf);
24533946497aSMintz, Yuval
2454bbe3f233SMintz, Yuval /* Acquire a new queue-cid */
24553da7a37aSMintz, Yuval params.queue_id = p_queue->fw_tx_qid;
2456dacd88d6SYuval Mintz params.vport_id = vf->vport_id;
24573da7a37aSMintz, Yuval params.stats_id = vf->abs_vf_id + 0x10;
2458f604b17dSMintz, Yuval
2459f604b17dSMintz, Yuval /* Since IGU index is passed via sb_info, construct a dummy one */
2460f604b17dSMintz, Yuval memset(&sb_dummy, 0, sizeof(sb_dummy));
2461f604b17dSMintz, Yuval sb_dummy.igu_sb_id = req->hw_sb;
2462f604b17dSMintz, Yuval params.p_sb = &sb_dummy;
2463dacd88d6SYuval Mintz params.sb_idx = req->sb_index;
2464dacd88d6SYuval Mintz
24653946497aSMintz, Yuval memset(&vf_params, 0, sizeof(vf_params));
24663946497aSMintz, Yuval vf_params.vfid = vf->relative_vf_id;
24673946497aSMintz, Yuval vf_params.vf_qid = (u8)req->tx_qid;
24683b19f478SMintz, Yuval vf_params.vf_legacy = vf_legacy;
2469bbe3f233SMintz, Yuval vf_params.qid_usage_idx = qid_usage_idx;
24703946497aSMintz, Yuval
2471007bc371SMintz, Yuval p_cid = qed_eth_queue_to_cid(p_hwfn, vf->opaque_fid,
2472007bc371SMintz, Yuval ¶ms, false, &vf_params);
2473007bc371SMintz, Yuval if (!p_cid)
24743da7a37aSMintz, Yuval goto out;
2475dacd88d6SYuval Mintz
2476b5a9ee7cSAriel Elior pq = qed_get_cm_pq_idx_vf(p_hwfn, vf->relative_vf_id);
2477007bc371SMintz, Yuval rc = qed_eth_txq_start_ramrod(p_hwfn, p_cid,
24783da7a37aSMintz, Yuval req->pbl_addr, req->pbl_size, pq);
247941086467SYuval Mintz if (rc) {
2480dacd88d6SYuval Mintz status = PFVF_STATUS_FAILURE;
2481007bc371SMintz, Yuval qed_eth_queue_cid_release(p_hwfn, p_cid);
248241086467SYuval Mintz } else {
248341086467SYuval Mintz status = PFVF_STATUS_SUCCESS;
2484007bc371SMintz, Yuval p_queue->cids[qid_usage_idx].p_cid = p_cid;
2485007bc371SMintz, Yuval p_queue->cids[qid_usage_idx].b_is_tx = true;
2486007bc371SMintz, Yuval cid = p_cid->cid;
248741086467SYuval Mintz }
2488dacd88d6SYuval Mintz
248941086467SYuval Mintz out:
2490007bc371SMintz, Yuval qed_iov_vf_mbx_start_txq_resp(p_hwfn, p_ptt, vf, cid, status);
2491dacd88d6SYuval Mintz }
2492dacd88d6SYuval Mintz
qed_iov_vf_stop_rxqs(struct qed_hwfn * p_hwfn,struct qed_vf_info * vf,u16 rxq_id,u8 qid_usage_idx,bool cqe_completion)2493dacd88d6SYuval Mintz static int qed_iov_vf_stop_rxqs(struct qed_hwfn *p_hwfn,
2494dacd88d6SYuval Mintz struct qed_vf_info *vf,
2495007bc371SMintz, Yuval u16 rxq_id,
2496007bc371SMintz, Yuval u8 qid_usage_idx, bool cqe_completion)
2497dacd88d6SYuval Mintz {
2498007bc371SMintz, Yuval struct qed_vf_queue *p_queue;
2499dacd88d6SYuval Mintz int rc = 0;
2500dacd88d6SYuval Mintz
250108bc8f15SMintz, Yuval if (!qed_iov_validate_rxq(p_hwfn, vf, rxq_id, QED_IOV_VALIDATE_Q_NA)) {
25024c4fa793SMintz, Yuval DP_VERBOSE(p_hwfn,
25034c4fa793SMintz, Yuval QED_MSG_IOV,
250408bc8f15SMintz, Yuval "VF[%d] Tried Closing Rx 0x%04x.%02x which is inactive\n",
250508bc8f15SMintz, Yuval vf->relative_vf_id, rxq_id, qid_usage_idx);
2506dacd88d6SYuval Mintz return -EINVAL;
25074c4fa793SMintz, Yuval }
2508dacd88d6SYuval Mintz
25094c4fa793SMintz, Yuval p_queue = &vf->vf_queues[rxq_id];
25103da7a37aSMintz, Yuval
251108bc8f15SMintz, Yuval /* We've validated the index and the existence of the active RXQ -
251208bc8f15SMintz, Yuval * now we need to make sure that it's using the correct qid.
251308bc8f15SMintz, Yuval */
251408bc8f15SMintz, Yuval if (!p_queue->cids[qid_usage_idx].p_cid ||
251508bc8f15SMintz, Yuval p_queue->cids[qid_usage_idx].b_is_tx) {
251608bc8f15SMintz, Yuval struct qed_queue_cid *p_cid;
251708bc8f15SMintz, Yuval
251808bc8f15SMintz, Yuval p_cid = qed_iov_get_vf_rx_queue_cid(p_queue);
251908bc8f15SMintz, Yuval DP_VERBOSE(p_hwfn,
252008bc8f15SMintz, Yuval QED_MSG_IOV,
252108bc8f15SMintz, Yuval "VF[%d] - Tried Closing Rx 0x%04x.%02x, but Rx is at %04x.%02x\n",
252208bc8f15SMintz, Yuval vf->relative_vf_id,
252308bc8f15SMintz, Yuval rxq_id, qid_usage_idx, rxq_id, p_cid->qid_usage_idx);
252408bc8f15SMintz, Yuval return -EINVAL;
252508bc8f15SMintz, Yuval }
252608bc8f15SMintz, Yuval
252708bc8f15SMintz, Yuval /* Now that we know we have a valid Rx-queue - close it */
25283da7a37aSMintz, Yuval rc = qed_eth_rx_queue_stop(p_hwfn,
2529007bc371SMintz, Yuval p_queue->cids[qid_usage_idx].p_cid,
25303da7a37aSMintz, Yuval false, cqe_completion);
2531dacd88d6SYuval Mintz if (rc)
2532dacd88d6SYuval Mintz return rc;
25333da7a37aSMintz, Yuval
2534007bc371SMintz, Yuval p_queue->cids[qid_usage_idx].p_cid = NULL;
2535dacd88d6SYuval Mintz vf->num_active_rxqs--;
2536dacd88d6SYuval Mintz
25374c4fa793SMintz, Yuval return 0;
2538dacd88d6SYuval Mintz }
2539dacd88d6SYuval Mintz
qed_iov_vf_stop_txqs(struct qed_hwfn * p_hwfn,struct qed_vf_info * vf,u16 txq_id,u8 qid_usage_idx)2540dacd88d6SYuval Mintz static int qed_iov_vf_stop_txqs(struct qed_hwfn *p_hwfn,
2541007bc371SMintz, Yuval struct qed_vf_info *vf,
2542007bc371SMintz, Yuval u16 txq_id, u8 qid_usage_idx)
2543dacd88d6SYuval Mintz {
2544007bc371SMintz, Yuval struct qed_vf_queue *p_queue;
25454c4fa793SMintz, Yuval int rc = 0;
2546dacd88d6SYuval Mintz
254708bc8f15SMintz, Yuval if (!qed_iov_validate_txq(p_hwfn, vf, txq_id, QED_IOV_VALIDATE_Q_NA))
2548dacd88d6SYuval Mintz return -EINVAL;
2549dacd88d6SYuval Mintz
25504c4fa793SMintz, Yuval p_queue = &vf->vf_queues[txq_id];
255108bc8f15SMintz, Yuval if (!p_queue->cids[qid_usage_idx].p_cid ||
255208bc8f15SMintz, Yuval !p_queue->cids[qid_usage_idx].b_is_tx)
255308bc8f15SMintz, Yuval return -EINVAL;
2554dacd88d6SYuval Mintz
2555007bc371SMintz, Yuval rc = qed_eth_tx_queue_stop(p_hwfn, p_queue->cids[qid_usage_idx].p_cid);
2556dacd88d6SYuval Mintz if (rc)
2557dacd88d6SYuval Mintz return rc;
25583da7a37aSMintz, Yuval
2559007bc371SMintz, Yuval p_queue->cids[qid_usage_idx].p_cid = NULL;
25604c4fa793SMintz, Yuval return 0;
2561dacd88d6SYuval Mintz }
2562dacd88d6SYuval Mintz
qed_iov_vf_mbx_stop_rxqs(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)2563dacd88d6SYuval Mintz static void qed_iov_vf_mbx_stop_rxqs(struct qed_hwfn *p_hwfn,
2564dacd88d6SYuval Mintz struct qed_ptt *p_ptt,
2565dacd88d6SYuval Mintz struct qed_vf_info *vf)
2566dacd88d6SYuval Mintz {
2567dacd88d6SYuval Mintz u16 length = sizeof(struct pfvf_def_resp_tlv);
2568dacd88d6SYuval Mintz struct qed_iov_vf_mbx *mbx = &vf->vf_mbx;
25694c4fa793SMintz, Yuval u8 status = PFVF_STATUS_FAILURE;
2570dacd88d6SYuval Mintz struct vfpf_stop_rxqs_tlv *req;
2571007bc371SMintz, Yuval u8 qid_usage_idx;
2572dacd88d6SYuval Mintz int rc;
2573dacd88d6SYuval Mintz
25744c4fa793SMintz, Yuval /* There has never been an official driver that used this interface
25754c4fa793SMintz, Yuval * for stopping multiple queues, and it is now considered deprecated.
25764c4fa793SMintz, Yuval * Validate this isn't used here.
2577dacd88d6SYuval Mintz */
2578dacd88d6SYuval Mintz req = &mbx->req_virt->stop_rxqs;
25794c4fa793SMintz, Yuval if (req->num_rxqs != 1) {
25804c4fa793SMintz, Yuval DP_VERBOSE(p_hwfn, QED_MSG_IOV,
25814c4fa793SMintz, Yuval "Odd; VF[%d] tried stopping multiple Rx queues\n",
25824c4fa793SMintz, Yuval vf->relative_vf_id);
25834c4fa793SMintz, Yuval status = PFVF_STATUS_NOT_SUPPORTED;
25844c4fa793SMintz, Yuval goto out;
25854c4fa793SMintz, Yuval }
2586dacd88d6SYuval Mintz
2587007bc371SMintz, Yuval /* Find which qid-index is associated with the queue */
2588007bc371SMintz, Yuval qid_usage_idx = qed_iov_vf_mbx_qid(p_hwfn, vf, false);
258908bc8f15SMintz, Yuval if (qid_usage_idx == QED_IOV_QID_INVALID)
259008bc8f15SMintz, Yuval goto out;
2591007bc371SMintz, Yuval
25924c4fa793SMintz, Yuval rc = qed_iov_vf_stop_rxqs(p_hwfn, vf, req->rx_qid,
2593007bc371SMintz, Yuval qid_usage_idx, req->cqe_completion);
25944c4fa793SMintz, Yuval if (!rc)
25954c4fa793SMintz, Yuval status = PFVF_STATUS_SUCCESS;
25964c4fa793SMintz, Yuval out:
2597dacd88d6SYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, vf, CHANNEL_TLV_STOP_RXQS,
2598dacd88d6SYuval Mintz length, status);
2599dacd88d6SYuval Mintz }
2600dacd88d6SYuval Mintz
qed_iov_vf_mbx_stop_txqs(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)2601dacd88d6SYuval Mintz static void qed_iov_vf_mbx_stop_txqs(struct qed_hwfn *p_hwfn,
2602dacd88d6SYuval Mintz struct qed_ptt *p_ptt,
2603dacd88d6SYuval Mintz struct qed_vf_info *vf)
2604dacd88d6SYuval Mintz {
2605dacd88d6SYuval Mintz u16 length = sizeof(struct pfvf_def_resp_tlv);
2606dacd88d6SYuval Mintz struct qed_iov_vf_mbx *mbx = &vf->vf_mbx;
26074c4fa793SMintz, Yuval u8 status = PFVF_STATUS_FAILURE;
2608dacd88d6SYuval Mintz struct vfpf_stop_txqs_tlv *req;
2609007bc371SMintz, Yuval u8 qid_usage_idx;
2610dacd88d6SYuval Mintz int rc;
2611dacd88d6SYuval Mintz
26124c4fa793SMintz, Yuval /* There has never been an official driver that used this interface
26134c4fa793SMintz, Yuval * for stopping multiple queues, and it is now considered deprecated.
26144c4fa793SMintz, Yuval * Validate this isn't used here.
2615dacd88d6SYuval Mintz */
2616dacd88d6SYuval Mintz req = &mbx->req_virt->stop_txqs;
26174c4fa793SMintz, Yuval if (req->num_txqs != 1) {
26184c4fa793SMintz, Yuval DP_VERBOSE(p_hwfn, QED_MSG_IOV,
26194c4fa793SMintz, Yuval "Odd; VF[%d] tried stopping multiple Tx queues\n",
26204c4fa793SMintz, Yuval vf->relative_vf_id);
26214c4fa793SMintz, Yuval status = PFVF_STATUS_NOT_SUPPORTED;
26224c4fa793SMintz, Yuval goto out;
26234c4fa793SMintz, Yuval }
2624007bc371SMintz, Yuval
2625007bc371SMintz, Yuval /* Find which qid-index is associated with the queue */
2626007bc371SMintz, Yuval qid_usage_idx = qed_iov_vf_mbx_qid(p_hwfn, vf, true);
262708bc8f15SMintz, Yuval if (qid_usage_idx == QED_IOV_QID_INVALID)
262808bc8f15SMintz, Yuval goto out;
2629007bc371SMintz, Yuval
2630007bc371SMintz, Yuval rc = qed_iov_vf_stop_txqs(p_hwfn, vf, req->tx_qid, qid_usage_idx);
26314c4fa793SMintz, Yuval if (!rc)
26324c4fa793SMintz, Yuval status = PFVF_STATUS_SUCCESS;
2633dacd88d6SYuval Mintz
26344c4fa793SMintz, Yuval out:
2635dacd88d6SYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, vf, CHANNEL_TLV_STOP_TXQS,
2636dacd88d6SYuval Mintz length, status);
2637dacd88d6SYuval Mintz }
2638dacd88d6SYuval Mintz
qed_iov_vf_mbx_update_rxqs(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)263917b235c1SYuval Mintz static void qed_iov_vf_mbx_update_rxqs(struct qed_hwfn *p_hwfn,
264017b235c1SYuval Mintz struct qed_ptt *p_ptt,
264117b235c1SYuval Mintz struct qed_vf_info *vf)
264217b235c1SYuval Mintz {
26433da7a37aSMintz, Yuval struct qed_queue_cid *handlers[QED_MAX_VF_CHAINS_PER_PF];
264417b235c1SYuval Mintz u16 length = sizeof(struct pfvf_def_resp_tlv);
264517b235c1SYuval Mintz struct qed_iov_vf_mbx *mbx = &vf->vf_mbx;
264617b235c1SYuval Mintz struct vfpf_update_rxq_tlv *req;
26473da7a37aSMintz, Yuval u8 status = PFVF_STATUS_FAILURE;
264817b235c1SYuval Mintz u8 complete_event_flg;
264917b235c1SYuval Mintz u8 complete_cqe_flg;
2650007bc371SMintz, Yuval u8 qid_usage_idx;
265117b235c1SYuval Mintz int rc;
265217b235c1SYuval Mintz u8 i;
265317b235c1SYuval Mintz
265417b235c1SYuval Mintz req = &mbx->req_virt->update_rxq;
265517b235c1SYuval Mintz complete_cqe_flg = !!(req->flags & VFPF_RXQ_UPD_COMPLETE_CQE_FLAG);
265617b235c1SYuval Mintz complete_event_flg = !!(req->flags & VFPF_RXQ_UPD_COMPLETE_EVENT_FLAG);
265717b235c1SYuval Mintz
2658007bc371SMintz, Yuval qid_usage_idx = qed_iov_vf_mbx_qid(p_hwfn, vf, false);
265908bc8f15SMintz, Yuval if (qid_usage_idx == QED_IOV_QID_INVALID)
26603da7a37aSMintz, Yuval goto out;
266108bc8f15SMintz, Yuval
266208bc8f15SMintz, Yuval /* There shouldn't exist a VF that uses queue-qids yet uses this
266308bc8f15SMintz, Yuval * API with multiple Rx queues. Validate this.
266408bc8f15SMintz, Yuval */
266508bc8f15SMintz, Yuval if ((vf->acquire.vfdev_info.capabilities &
266608bc8f15SMintz, Yuval VFPF_ACQUIRE_CAP_QUEUE_QIDS) && req->num_rxqs != 1) {
266708bc8f15SMintz, Yuval DP_VERBOSE(p_hwfn, QED_MSG_IOV,
266808bc8f15SMintz, Yuval "VF[%d] supports QIDs but sends multiple queues\n",
266908bc8f15SMintz, Yuval vf->relative_vf_id);
267008bc8f15SMintz, Yuval goto out;
267108bc8f15SMintz, Yuval }
267208bc8f15SMintz, Yuval
267308bc8f15SMintz, Yuval /* Validate inputs - for the legacy case this is still true since
267408bc8f15SMintz, Yuval * qid_usage_idx for each Rx queue would be LEGACY_QID_RX.
267508bc8f15SMintz, Yuval */
267608bc8f15SMintz, Yuval for (i = req->rx_qid; i < req->rx_qid + req->num_rxqs; i++) {
267708bc8f15SMintz, Yuval if (!qed_iov_validate_rxq(p_hwfn, vf, i,
267808bc8f15SMintz, Yuval QED_IOV_VALIDATE_Q_NA) ||
267908bc8f15SMintz, Yuval !vf->vf_queues[i].cids[qid_usage_idx].p_cid ||
268008bc8f15SMintz, Yuval vf->vf_queues[i].cids[qid_usage_idx].b_is_tx) {
268108bc8f15SMintz, Yuval DP_VERBOSE(p_hwfn, QED_MSG_IOV,
268208bc8f15SMintz, Yuval "VF[%d]: Incorrect Rxqs [%04x, %02x]\n",
268308bc8f15SMintz, Yuval vf->relative_vf_id, req->rx_qid,
268408bc8f15SMintz, Yuval req->num_rxqs);
268508bc8f15SMintz, Yuval goto out;
268608bc8f15SMintz, Yuval }
268717b235c1SYuval Mintz }
268817b235c1SYuval Mintz
2689f109c240SMintz, Yuval /* Prepare the handlers */
26903da7a37aSMintz, Yuval for (i = 0; i < req->num_rxqs; i++) {
2691007bc371SMintz, Yuval u16 qid = req->rx_qid + i;
2692007bc371SMintz, Yuval
2693007bc371SMintz, Yuval handlers[i] = vf->vf_queues[qid].cids[qid_usage_idx].p_cid;
26943da7a37aSMintz, Yuval }
26953da7a37aSMintz, Yuval
26963da7a37aSMintz, Yuval rc = qed_sp_eth_rx_queues_update(p_hwfn, (void **)&handlers,
26973da7a37aSMintz, Yuval req->num_rxqs,
269817b235c1SYuval Mintz complete_cqe_flg,
269917b235c1SYuval Mintz complete_event_flg,
270017b235c1SYuval Mintz QED_SPQ_MODE_EBLOCK, NULL);
27013da7a37aSMintz, Yuval if (rc)
27023da7a37aSMintz, Yuval goto out;
270317b235c1SYuval Mintz
27043da7a37aSMintz, Yuval status = PFVF_STATUS_SUCCESS;
27053da7a37aSMintz, Yuval out:
270617b235c1SYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, vf, CHANNEL_TLV_UPDATE_RXQ,
270717b235c1SYuval Mintz length, status);
270817b235c1SYuval Mintz }
270917b235c1SYuval Mintz
qed_iov_search_list_tlvs(struct qed_hwfn * p_hwfn,void * p_tlvs_list,u16 req_type)2710dacd88d6SYuval Mintz void *qed_iov_search_list_tlvs(struct qed_hwfn *p_hwfn,
2711dacd88d6SYuval Mintz void *p_tlvs_list, u16 req_type)
2712dacd88d6SYuval Mintz {
2713dacd88d6SYuval Mintz struct channel_tlv *p_tlv = (struct channel_tlv *)p_tlvs_list;
2714dacd88d6SYuval Mintz int len = 0;
2715dacd88d6SYuval Mintz
2716dacd88d6SYuval Mintz do {
2717dacd88d6SYuval Mintz if (!p_tlv->length) {
2718dacd88d6SYuval Mintz DP_NOTICE(p_hwfn, "Zero length TLV found\n");
2719dacd88d6SYuval Mintz return NULL;
2720dacd88d6SYuval Mintz }
2721dacd88d6SYuval Mintz
2722dacd88d6SYuval Mintz if (p_tlv->type == req_type) {
2723dacd88d6SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
2724dacd88d6SYuval Mintz "Extended tlv type %d, length %d found\n",
2725dacd88d6SYuval Mintz p_tlv->type, p_tlv->length);
2726dacd88d6SYuval Mintz return p_tlv;
2727dacd88d6SYuval Mintz }
2728dacd88d6SYuval Mintz
2729dacd88d6SYuval Mintz len += p_tlv->length;
2730dacd88d6SYuval Mintz p_tlv = (struct channel_tlv *)((u8 *)p_tlv + p_tlv->length);
2731dacd88d6SYuval Mintz
2732dacd88d6SYuval Mintz if ((len + p_tlv->length) > TLV_BUFFER_SIZE) {
2733dacd88d6SYuval Mintz DP_NOTICE(p_hwfn, "TLVs has overrun the buffer size\n");
2734dacd88d6SYuval Mintz return NULL;
2735dacd88d6SYuval Mintz }
2736dacd88d6SYuval Mintz } while (p_tlv->type != CHANNEL_TLV_LIST_END);
2737dacd88d6SYuval Mintz
2738dacd88d6SYuval Mintz return NULL;
2739dacd88d6SYuval Mintz }
2740dacd88d6SYuval Mintz
2741dacd88d6SYuval Mintz static void
qed_iov_vp_update_act_param(struct qed_hwfn * p_hwfn,struct qed_sp_vport_update_params * p_data,struct qed_iov_vf_mbx * p_mbx,u16 * tlvs_mask)2742dacd88d6SYuval Mintz qed_iov_vp_update_act_param(struct qed_hwfn *p_hwfn,
2743dacd88d6SYuval Mintz struct qed_sp_vport_update_params *p_data,
2744dacd88d6SYuval Mintz struct qed_iov_vf_mbx *p_mbx, u16 *tlvs_mask)
2745dacd88d6SYuval Mintz {
2746dacd88d6SYuval Mintz struct vfpf_vport_update_activate_tlv *p_act_tlv;
2747dacd88d6SYuval Mintz u16 tlv = CHANNEL_TLV_VPORT_UPDATE_ACTIVATE;
2748dacd88d6SYuval Mintz
2749dacd88d6SYuval Mintz p_act_tlv = (struct vfpf_vport_update_activate_tlv *)
2750dacd88d6SYuval Mintz qed_iov_search_list_tlvs(p_hwfn, p_mbx->req_virt, tlv);
2751dacd88d6SYuval Mintz if (!p_act_tlv)
2752dacd88d6SYuval Mintz return;
2753dacd88d6SYuval Mintz
2754dacd88d6SYuval Mintz p_data->update_vport_active_rx_flg = p_act_tlv->update_rx;
2755dacd88d6SYuval Mintz p_data->vport_active_rx_flg = p_act_tlv->active_rx;
2756dacd88d6SYuval Mintz p_data->update_vport_active_tx_flg = p_act_tlv->update_tx;
2757dacd88d6SYuval Mintz p_data->vport_active_tx_flg = p_act_tlv->active_tx;
2758dacd88d6SYuval Mintz *tlvs_mask |= 1 << QED_IOV_VP_UPDATE_ACTIVATE;
2759dacd88d6SYuval Mintz }
2760dacd88d6SYuval Mintz
2761dacd88d6SYuval Mintz static void
qed_iov_vp_update_vlan_param(struct qed_hwfn * p_hwfn,struct qed_sp_vport_update_params * p_data,struct qed_vf_info * p_vf,struct qed_iov_vf_mbx * p_mbx,u16 * tlvs_mask)276217b235c1SYuval Mintz qed_iov_vp_update_vlan_param(struct qed_hwfn *p_hwfn,
276317b235c1SYuval Mintz struct qed_sp_vport_update_params *p_data,
276417b235c1SYuval Mintz struct qed_vf_info *p_vf,
276517b235c1SYuval Mintz struct qed_iov_vf_mbx *p_mbx, u16 *tlvs_mask)
276617b235c1SYuval Mintz {
276717b235c1SYuval Mintz struct vfpf_vport_update_vlan_strip_tlv *p_vlan_tlv;
276817b235c1SYuval Mintz u16 tlv = CHANNEL_TLV_VPORT_UPDATE_VLAN_STRIP;
276917b235c1SYuval Mintz
277017b235c1SYuval Mintz p_vlan_tlv = (struct vfpf_vport_update_vlan_strip_tlv *)
277117b235c1SYuval Mintz qed_iov_search_list_tlvs(p_hwfn, p_mbx->req_virt, tlv);
277217b235c1SYuval Mintz if (!p_vlan_tlv)
277317b235c1SYuval Mintz return;
277417b235c1SYuval Mintz
277508feecd7SYuval Mintz p_vf->shadow_config.inner_vlan_removal = p_vlan_tlv->remove_vlan;
277608feecd7SYuval Mintz
277708feecd7SYuval Mintz /* Ignore the VF request if we're forcing a vlan */
27781a635e48SYuval Mintz if (!(p_vf->configured_features & BIT(VLAN_ADDR_FORCED))) {
277917b235c1SYuval Mintz p_data->update_inner_vlan_removal_flg = 1;
278017b235c1SYuval Mintz p_data->inner_vlan_removal_flg = p_vlan_tlv->remove_vlan;
278108feecd7SYuval Mintz }
278217b235c1SYuval Mintz
278317b235c1SYuval Mintz *tlvs_mask |= 1 << QED_IOV_VP_UPDATE_VLAN_STRIP;
278417b235c1SYuval Mintz }
278517b235c1SYuval Mintz
278617b235c1SYuval Mintz static void
qed_iov_vp_update_tx_switch(struct qed_hwfn * p_hwfn,struct qed_sp_vport_update_params * p_data,struct qed_iov_vf_mbx * p_mbx,u16 * tlvs_mask)278717b235c1SYuval Mintz qed_iov_vp_update_tx_switch(struct qed_hwfn *p_hwfn,
278817b235c1SYuval Mintz struct qed_sp_vport_update_params *p_data,
278917b235c1SYuval Mintz struct qed_iov_vf_mbx *p_mbx, u16 *tlvs_mask)
279017b235c1SYuval Mintz {
279117b235c1SYuval Mintz struct vfpf_vport_update_tx_switch_tlv *p_tx_switch_tlv;
279217b235c1SYuval Mintz u16 tlv = CHANNEL_TLV_VPORT_UPDATE_TX_SWITCH;
279317b235c1SYuval Mintz
279417b235c1SYuval Mintz p_tx_switch_tlv = (struct vfpf_vport_update_tx_switch_tlv *)
279517b235c1SYuval Mintz qed_iov_search_list_tlvs(p_hwfn, p_mbx->req_virt,
279617b235c1SYuval Mintz tlv);
279717b235c1SYuval Mintz if (!p_tx_switch_tlv)
279817b235c1SYuval Mintz return;
279917b235c1SYuval Mintz
280017b235c1SYuval Mintz p_data->update_tx_switching_flg = 1;
280117b235c1SYuval Mintz p_data->tx_switching_flg = p_tx_switch_tlv->tx_switching;
280217b235c1SYuval Mintz *tlvs_mask |= 1 << QED_IOV_VP_UPDATE_TX_SWITCH;
280317b235c1SYuval Mintz }
280417b235c1SYuval Mintz
280517b235c1SYuval Mintz static void
qed_iov_vp_update_mcast_bin_param(struct qed_hwfn * p_hwfn,struct qed_sp_vport_update_params * p_data,struct qed_iov_vf_mbx * p_mbx,u16 * tlvs_mask)2806dacd88d6SYuval Mintz qed_iov_vp_update_mcast_bin_param(struct qed_hwfn *p_hwfn,
2807dacd88d6SYuval Mintz struct qed_sp_vport_update_params *p_data,
2808dacd88d6SYuval Mintz struct qed_iov_vf_mbx *p_mbx, u16 *tlvs_mask)
2809dacd88d6SYuval Mintz {
2810dacd88d6SYuval Mintz struct vfpf_vport_update_mcast_bin_tlv *p_mcast_tlv;
2811dacd88d6SYuval Mintz u16 tlv = CHANNEL_TLV_VPORT_UPDATE_MCAST;
2812dacd88d6SYuval Mintz
2813dacd88d6SYuval Mintz p_mcast_tlv = (struct vfpf_vport_update_mcast_bin_tlv *)
2814dacd88d6SYuval Mintz qed_iov_search_list_tlvs(p_hwfn, p_mbx->req_virt, tlv);
2815dacd88d6SYuval Mintz if (!p_mcast_tlv)
2816dacd88d6SYuval Mintz return;
2817dacd88d6SYuval Mintz
2818dacd88d6SYuval Mintz p_data->update_approx_mcast_flg = 1;
2819dacd88d6SYuval Mintz memcpy(p_data->bins, p_mcast_tlv->bins,
282025c020a9SSudarsana Reddy Kalluru sizeof(u32) * ETH_MULTICAST_MAC_BINS_IN_REGS);
2821dacd88d6SYuval Mintz *tlvs_mask |= 1 << QED_IOV_VP_UPDATE_MCAST;
2822dacd88d6SYuval Mintz }
2823dacd88d6SYuval Mintz
2824dacd88d6SYuval Mintz static void
qed_iov_vp_update_accept_flag(struct qed_hwfn * p_hwfn,struct qed_sp_vport_update_params * p_data,struct qed_iov_vf_mbx * p_mbx,u16 * tlvs_mask)2825dacd88d6SYuval Mintz qed_iov_vp_update_accept_flag(struct qed_hwfn *p_hwfn,
2826dacd88d6SYuval Mintz struct qed_sp_vport_update_params *p_data,
2827dacd88d6SYuval Mintz struct qed_iov_vf_mbx *p_mbx, u16 *tlvs_mask)
2828dacd88d6SYuval Mintz {
2829dacd88d6SYuval Mintz struct qed_filter_accept_flags *p_flags = &p_data->accept_flags;
2830dacd88d6SYuval Mintz struct vfpf_vport_update_accept_param_tlv *p_accept_tlv;
2831dacd88d6SYuval Mintz u16 tlv = CHANNEL_TLV_VPORT_UPDATE_ACCEPT_PARAM;
2832dacd88d6SYuval Mintz
2833dacd88d6SYuval Mintz p_accept_tlv = (struct vfpf_vport_update_accept_param_tlv *)
2834dacd88d6SYuval Mintz qed_iov_search_list_tlvs(p_hwfn, p_mbx->req_virt, tlv);
2835dacd88d6SYuval Mintz if (!p_accept_tlv)
2836dacd88d6SYuval Mintz return;
2837dacd88d6SYuval Mintz
2838dacd88d6SYuval Mintz p_flags->update_rx_mode_config = p_accept_tlv->update_rx_mode;
2839dacd88d6SYuval Mintz p_flags->rx_accept_filter = p_accept_tlv->rx_accept_filter;
2840dacd88d6SYuval Mintz p_flags->update_tx_mode_config = p_accept_tlv->update_tx_mode;
2841dacd88d6SYuval Mintz p_flags->tx_accept_filter = p_accept_tlv->tx_accept_filter;
2842dacd88d6SYuval Mintz *tlvs_mask |= 1 << QED_IOV_VP_UPDATE_ACCEPT_PARAM;
2843dacd88d6SYuval Mintz }
2844dacd88d6SYuval Mintz
2845dacd88d6SYuval Mintz static void
qed_iov_vp_update_accept_any_vlan(struct qed_hwfn * p_hwfn,struct qed_sp_vport_update_params * p_data,struct qed_iov_vf_mbx * p_mbx,u16 * tlvs_mask)284617b235c1SYuval Mintz qed_iov_vp_update_accept_any_vlan(struct qed_hwfn *p_hwfn,
284717b235c1SYuval Mintz struct qed_sp_vport_update_params *p_data,
284817b235c1SYuval Mintz struct qed_iov_vf_mbx *p_mbx, u16 *tlvs_mask)
284917b235c1SYuval Mintz {
285017b235c1SYuval Mintz struct vfpf_vport_update_accept_any_vlan_tlv *p_accept_any_vlan;
285117b235c1SYuval Mintz u16 tlv = CHANNEL_TLV_VPORT_UPDATE_ACCEPT_ANY_VLAN;
285217b235c1SYuval Mintz
285317b235c1SYuval Mintz p_accept_any_vlan = (struct vfpf_vport_update_accept_any_vlan_tlv *)
285417b235c1SYuval Mintz qed_iov_search_list_tlvs(p_hwfn, p_mbx->req_virt,
285517b235c1SYuval Mintz tlv);
285617b235c1SYuval Mintz if (!p_accept_any_vlan)
285717b235c1SYuval Mintz return;
285817b235c1SYuval Mintz
285917b235c1SYuval Mintz p_data->accept_any_vlan = p_accept_any_vlan->accept_any_vlan;
286017b235c1SYuval Mintz p_data->update_accept_any_vlan_flg =
286117b235c1SYuval Mintz p_accept_any_vlan->update_accept_any_vlan_flg;
286217b235c1SYuval Mintz *tlvs_mask |= 1 << QED_IOV_VP_UPDATE_ACCEPT_ANY_VLAN;
286317b235c1SYuval Mintz }
286417b235c1SYuval Mintz
286517b235c1SYuval Mintz static void
qed_iov_vp_update_rss_param(struct qed_hwfn * p_hwfn,struct qed_vf_info * vf,struct qed_sp_vport_update_params * p_data,struct qed_rss_params * p_rss,struct qed_iov_vf_mbx * p_mbx,u16 * tlvs_mask,u16 * tlvs_accepted)2866dacd88d6SYuval Mintz qed_iov_vp_update_rss_param(struct qed_hwfn *p_hwfn,
2867dacd88d6SYuval Mintz struct qed_vf_info *vf,
2868dacd88d6SYuval Mintz struct qed_sp_vport_update_params *p_data,
2869dacd88d6SYuval Mintz struct qed_rss_params *p_rss,
2870f29ffdb6SMintz, Yuval struct qed_iov_vf_mbx *p_mbx,
2871f29ffdb6SMintz, Yuval u16 *tlvs_mask, u16 *tlvs_accepted)
2872dacd88d6SYuval Mintz {
2873dacd88d6SYuval Mintz struct vfpf_vport_update_rss_tlv *p_rss_tlv;
2874dacd88d6SYuval Mintz u16 tlv = CHANNEL_TLV_VPORT_UPDATE_RSS;
2875f29ffdb6SMintz, Yuval bool b_reject = false;
2876dacd88d6SYuval Mintz u16 table_size;
2877f29ffdb6SMintz, Yuval u16 i, q_idx;
2878dacd88d6SYuval Mintz
2879dacd88d6SYuval Mintz p_rss_tlv = (struct vfpf_vport_update_rss_tlv *)
2880dacd88d6SYuval Mintz qed_iov_search_list_tlvs(p_hwfn, p_mbx->req_virt, tlv);
2881dacd88d6SYuval Mintz if (!p_rss_tlv) {
2882dacd88d6SYuval Mintz p_data->rss_params = NULL;
2883dacd88d6SYuval Mintz return;
2884dacd88d6SYuval Mintz }
2885dacd88d6SYuval Mintz
2886dacd88d6SYuval Mintz memset(p_rss, 0, sizeof(struct qed_rss_params));
2887dacd88d6SYuval Mintz
2888dacd88d6SYuval Mintz p_rss->update_rss_config = !!(p_rss_tlv->update_rss_flags &
2889dacd88d6SYuval Mintz VFPF_UPDATE_RSS_CONFIG_FLAG);
2890dacd88d6SYuval Mintz p_rss->update_rss_capabilities = !!(p_rss_tlv->update_rss_flags &
2891dacd88d6SYuval Mintz VFPF_UPDATE_RSS_CAPS_FLAG);
2892dacd88d6SYuval Mintz p_rss->update_rss_ind_table = !!(p_rss_tlv->update_rss_flags &
2893dacd88d6SYuval Mintz VFPF_UPDATE_RSS_IND_TABLE_FLAG);
2894dacd88d6SYuval Mintz p_rss->update_rss_key = !!(p_rss_tlv->update_rss_flags &
2895dacd88d6SYuval Mintz VFPF_UPDATE_RSS_KEY_FLAG);
2896dacd88d6SYuval Mintz
2897dacd88d6SYuval Mintz p_rss->rss_enable = p_rss_tlv->rss_enable;
2898dacd88d6SYuval Mintz p_rss->rss_eng_id = vf->relative_vf_id + 1;
2899dacd88d6SYuval Mintz p_rss->rss_caps = p_rss_tlv->rss_caps;
2900dacd88d6SYuval Mintz p_rss->rss_table_size_log = p_rss_tlv->rss_table_size_log;
2901dacd88d6SYuval Mintz memcpy(p_rss->rss_key, p_rss_tlv->rss_key, sizeof(p_rss->rss_key));
2902dacd88d6SYuval Mintz
2903dacd88d6SYuval Mintz table_size = min_t(u16, ARRAY_SIZE(p_rss->rss_ind_table),
2904dacd88d6SYuval Mintz (1 << p_rss_tlv->rss_table_size_log));
2905dacd88d6SYuval Mintz
2906dacd88d6SYuval Mintz for (i = 0; i < table_size; i++) {
2907007bc371SMintz, Yuval struct qed_queue_cid *p_cid;
2908007bc371SMintz, Yuval
2909f29ffdb6SMintz, Yuval q_idx = p_rss_tlv->rss_ind_table[i];
2910f109c240SMintz, Yuval if (!qed_iov_validate_rxq(p_hwfn, vf, q_idx,
2911f109c240SMintz, Yuval QED_IOV_VALIDATE_Q_ENABLE)) {
2912f29ffdb6SMintz, Yuval DP_VERBOSE(p_hwfn,
2913f29ffdb6SMintz, Yuval QED_MSG_IOV,
2914f29ffdb6SMintz, Yuval "VF[%d]: Omitting RSS due to wrong queue %04x\n",
2915f29ffdb6SMintz, Yuval vf->relative_vf_id, q_idx);
2916f29ffdb6SMintz, Yuval b_reject = true;
2917f29ffdb6SMintz, Yuval goto out;
2918f29ffdb6SMintz, Yuval }
2919dacd88d6SYuval Mintz
2920007bc371SMintz, Yuval p_cid = qed_iov_get_vf_rx_queue_cid(&vf->vf_queues[q_idx]);
2921007bc371SMintz, Yuval p_rss->rss_ind_table[i] = p_cid;
2922dacd88d6SYuval Mintz }
2923dacd88d6SYuval Mintz
2924dacd88d6SYuval Mintz p_data->rss_params = p_rss;
2925f29ffdb6SMintz, Yuval out:
2926dacd88d6SYuval Mintz *tlvs_mask |= 1 << QED_IOV_VP_UPDATE_RSS;
2927f29ffdb6SMintz, Yuval if (!b_reject)
2928f29ffdb6SMintz, Yuval *tlvs_accepted |= 1 << QED_IOV_VP_UPDATE_RSS;
2929dacd88d6SYuval Mintz }
2930dacd88d6SYuval Mintz
293117b235c1SYuval Mintz static void
qed_iov_vp_update_sge_tpa_param(struct qed_hwfn * p_hwfn,struct qed_vf_info * vf,struct qed_sp_vport_update_params * p_data,struct qed_sge_tpa_params * p_sge_tpa,struct qed_iov_vf_mbx * p_mbx,u16 * tlvs_mask)293217b235c1SYuval Mintz qed_iov_vp_update_sge_tpa_param(struct qed_hwfn *p_hwfn,
293317b235c1SYuval Mintz struct qed_vf_info *vf,
293417b235c1SYuval Mintz struct qed_sp_vport_update_params *p_data,
293517b235c1SYuval Mintz struct qed_sge_tpa_params *p_sge_tpa,
293617b235c1SYuval Mintz struct qed_iov_vf_mbx *p_mbx, u16 *tlvs_mask)
293717b235c1SYuval Mintz {
293817b235c1SYuval Mintz struct vfpf_vport_update_sge_tpa_tlv *p_sge_tpa_tlv;
293917b235c1SYuval Mintz u16 tlv = CHANNEL_TLV_VPORT_UPDATE_SGE_TPA;
294017b235c1SYuval Mintz
294117b235c1SYuval Mintz p_sge_tpa_tlv = (struct vfpf_vport_update_sge_tpa_tlv *)
294217b235c1SYuval Mintz qed_iov_search_list_tlvs(p_hwfn, p_mbx->req_virt, tlv);
294317b235c1SYuval Mintz
294417b235c1SYuval Mintz if (!p_sge_tpa_tlv) {
294517b235c1SYuval Mintz p_data->sge_tpa_params = NULL;
294617b235c1SYuval Mintz return;
294717b235c1SYuval Mintz }
294817b235c1SYuval Mintz
294917b235c1SYuval Mintz memset(p_sge_tpa, 0, sizeof(struct qed_sge_tpa_params));
295017b235c1SYuval Mintz
295117b235c1SYuval Mintz p_sge_tpa->update_tpa_en_flg =
295217b235c1SYuval Mintz !!(p_sge_tpa_tlv->update_sge_tpa_flags & VFPF_UPDATE_TPA_EN_FLAG);
295317b235c1SYuval Mintz p_sge_tpa->update_tpa_param_flg =
295417b235c1SYuval Mintz !!(p_sge_tpa_tlv->update_sge_tpa_flags &
295517b235c1SYuval Mintz VFPF_UPDATE_TPA_PARAM_FLAG);
295617b235c1SYuval Mintz
295717b235c1SYuval Mintz p_sge_tpa->tpa_ipv4_en_flg =
295817b235c1SYuval Mintz !!(p_sge_tpa_tlv->sge_tpa_flags & VFPF_TPA_IPV4_EN_FLAG);
295917b235c1SYuval Mintz p_sge_tpa->tpa_ipv6_en_flg =
296017b235c1SYuval Mintz !!(p_sge_tpa_tlv->sge_tpa_flags & VFPF_TPA_IPV6_EN_FLAG);
296117b235c1SYuval Mintz p_sge_tpa->tpa_pkt_split_flg =
296217b235c1SYuval Mintz !!(p_sge_tpa_tlv->sge_tpa_flags & VFPF_TPA_PKT_SPLIT_FLAG);
296317b235c1SYuval Mintz p_sge_tpa->tpa_hdr_data_split_flg =
296417b235c1SYuval Mintz !!(p_sge_tpa_tlv->sge_tpa_flags & VFPF_TPA_HDR_DATA_SPLIT_FLAG);
296517b235c1SYuval Mintz p_sge_tpa->tpa_gro_consistent_flg =
296617b235c1SYuval Mintz !!(p_sge_tpa_tlv->sge_tpa_flags & VFPF_TPA_GRO_CONSIST_FLAG);
296717b235c1SYuval Mintz
296817b235c1SYuval Mintz p_sge_tpa->tpa_max_aggs_num = p_sge_tpa_tlv->tpa_max_aggs_num;
296917b235c1SYuval Mintz p_sge_tpa->tpa_max_size = p_sge_tpa_tlv->tpa_max_size;
297017b235c1SYuval Mintz p_sge_tpa->tpa_min_size_to_start = p_sge_tpa_tlv->tpa_min_size_to_start;
297117b235c1SYuval Mintz p_sge_tpa->tpa_min_size_to_cont = p_sge_tpa_tlv->tpa_min_size_to_cont;
297217b235c1SYuval Mintz p_sge_tpa->max_buffers_per_cqe = p_sge_tpa_tlv->max_buffers_per_cqe;
297317b235c1SYuval Mintz
297417b235c1SYuval Mintz p_data->sge_tpa_params = p_sge_tpa;
297517b235c1SYuval Mintz
297617b235c1SYuval Mintz *tlvs_mask |= 1 << QED_IOV_VP_UPDATE_SGE_TPA;
297717b235c1SYuval Mintz }
297817b235c1SYuval Mintz
qed_iov_pre_update_vport(struct qed_hwfn * hwfn,u8 vfid,struct qed_sp_vport_update_params * params,u16 * tlvs)2979f990c82cSMintz, Yuval static int qed_iov_pre_update_vport(struct qed_hwfn *hwfn,
2980f990c82cSMintz, Yuval u8 vfid,
2981f990c82cSMintz, Yuval struct qed_sp_vport_update_params *params,
2982f990c82cSMintz, Yuval u16 *tlvs)
2983f990c82cSMintz, Yuval {
2984f990c82cSMintz, Yuval u8 mask = QED_ACCEPT_UCAST_UNMATCHED | QED_ACCEPT_MCAST_UNMATCHED;
2985f990c82cSMintz, Yuval struct qed_filter_accept_flags *flags = ¶ms->accept_flags;
2986f990c82cSMintz, Yuval struct qed_public_vf_info *vf_info;
2987cbcc44dbSManish Chopra u16 tlv_mask;
2988cbcc44dbSManish Chopra
2989cbcc44dbSManish Chopra tlv_mask = BIT(QED_IOV_VP_UPDATE_ACCEPT_PARAM) |
2990cbcc44dbSManish Chopra BIT(QED_IOV_VP_UPDATE_ACCEPT_ANY_VLAN);
2991f990c82cSMintz, Yuval
2992f990c82cSMintz, Yuval /* Untrusted VFs can't even be trusted to know that fact.
2993f990c82cSMintz, Yuval * Simply indicate everything is configured fine, and trace
2994f990c82cSMintz, Yuval * configuration 'behind their back'.
2995f990c82cSMintz, Yuval */
2996cbcc44dbSManish Chopra if (!(*tlvs & tlv_mask))
2997f990c82cSMintz, Yuval return 0;
2998f990c82cSMintz, Yuval
2999f990c82cSMintz, Yuval vf_info = qed_iov_get_public_vf_info(hwfn, vfid, true);
3000f990c82cSMintz, Yuval
3001f990c82cSMintz, Yuval if (flags->update_rx_mode_config) {
3002f990c82cSMintz, Yuval vf_info->rx_accept_mode = flags->rx_accept_filter;
3003f990c82cSMintz, Yuval if (!vf_info->is_trusted_configured)
3004f990c82cSMintz, Yuval flags->rx_accept_filter &= ~mask;
3005f990c82cSMintz, Yuval }
3006f990c82cSMintz, Yuval
3007f990c82cSMintz, Yuval if (flags->update_tx_mode_config) {
3008f990c82cSMintz, Yuval vf_info->tx_accept_mode = flags->tx_accept_filter;
3009f990c82cSMintz, Yuval if (!vf_info->is_trusted_configured)
3010f990c82cSMintz, Yuval flags->tx_accept_filter &= ~mask;
3011f990c82cSMintz, Yuval }
3012f990c82cSMintz, Yuval
3013cbcc44dbSManish Chopra if (params->update_accept_any_vlan_flg) {
3014cbcc44dbSManish Chopra vf_info->accept_any_vlan = params->accept_any_vlan;
3015cbcc44dbSManish Chopra
3016cbcc44dbSManish Chopra if (vf_info->forced_vlan && !vf_info->is_trusted_configured)
3017cbcc44dbSManish Chopra params->accept_any_vlan = false;
3018cbcc44dbSManish Chopra }
3019cbcc44dbSManish Chopra
3020f990c82cSMintz, Yuval return 0;
3021f990c82cSMintz, Yuval }
3022f990c82cSMintz, Yuval
qed_iov_vf_mbx_vport_update(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)3023dacd88d6SYuval Mintz static void qed_iov_vf_mbx_vport_update(struct qed_hwfn *p_hwfn,
3024dacd88d6SYuval Mintz struct qed_ptt *p_ptt,
3025dacd88d6SYuval Mintz struct qed_vf_info *vf)
3026dacd88d6SYuval Mintz {
3027f29ffdb6SMintz, Yuval struct qed_rss_params *p_rss_params = NULL;
3028dacd88d6SYuval Mintz struct qed_sp_vport_update_params params;
3029dacd88d6SYuval Mintz struct qed_iov_vf_mbx *mbx = &vf->vf_mbx;
303017b235c1SYuval Mintz struct qed_sge_tpa_params sge_tpa_params;
3031f29ffdb6SMintz, Yuval u16 tlvs_mask = 0, tlvs_accepted = 0;
3032dacd88d6SYuval Mintz u8 status = PFVF_STATUS_SUCCESS;
3033dacd88d6SYuval Mintz u16 length;
3034dacd88d6SYuval Mintz int rc;
3035dacd88d6SYuval Mintz
303641086467SYuval Mintz /* Valiate PF can send such a request */
303741086467SYuval Mintz if (!vf->vport_instance) {
303841086467SYuval Mintz DP_VERBOSE(p_hwfn,
303941086467SYuval Mintz QED_MSG_IOV,
304041086467SYuval Mintz "No VPORT instance available for VF[%d], failing vport update\n",
304141086467SYuval Mintz vf->abs_vf_id);
304241086467SYuval Mintz status = PFVF_STATUS_FAILURE;
304341086467SYuval Mintz goto out;
304441086467SYuval Mintz }
3045f29ffdb6SMintz, Yuval p_rss_params = vzalloc(sizeof(*p_rss_params));
3046fe40a830SPrabhakar Kushwaha if (!p_rss_params) {
3047f29ffdb6SMintz, Yuval status = PFVF_STATUS_FAILURE;
3048f29ffdb6SMintz, Yuval goto out;
3049f29ffdb6SMintz, Yuval }
305041086467SYuval Mintz
3051dacd88d6SYuval Mintz memset(¶ms, 0, sizeof(params));
3052dacd88d6SYuval Mintz params.opaque_fid = vf->opaque_fid;
3053dacd88d6SYuval Mintz params.vport_id = vf->vport_id;
3054dacd88d6SYuval Mintz params.rss_params = NULL;
3055dacd88d6SYuval Mintz
3056dacd88d6SYuval Mintz /* Search for extended tlvs list and update values
3057dacd88d6SYuval Mintz * from VF in struct qed_sp_vport_update_params.
3058dacd88d6SYuval Mintz */
3059dacd88d6SYuval Mintz qed_iov_vp_update_act_param(p_hwfn, ¶ms, mbx, &tlvs_mask);
306017b235c1SYuval Mintz qed_iov_vp_update_vlan_param(p_hwfn, ¶ms, vf, mbx, &tlvs_mask);
306117b235c1SYuval Mintz qed_iov_vp_update_tx_switch(p_hwfn, ¶ms, mbx, &tlvs_mask);
3062dacd88d6SYuval Mintz qed_iov_vp_update_mcast_bin_param(p_hwfn, ¶ms, mbx, &tlvs_mask);
3063dacd88d6SYuval Mintz qed_iov_vp_update_accept_flag(p_hwfn, ¶ms, mbx, &tlvs_mask);
306417b235c1SYuval Mintz qed_iov_vp_update_accept_any_vlan(p_hwfn, ¶ms, mbx, &tlvs_mask);
306517b235c1SYuval Mintz qed_iov_vp_update_sge_tpa_param(p_hwfn, vf, ¶ms,
306617b235c1SYuval Mintz &sge_tpa_params, mbx, &tlvs_mask);
3067dacd88d6SYuval Mintz
3068f29ffdb6SMintz, Yuval tlvs_accepted = tlvs_mask;
3069f29ffdb6SMintz, Yuval
3070f29ffdb6SMintz, Yuval /* Some of the extended TLVs need to be validated first; In that case,
3071f29ffdb6SMintz, Yuval * they can update the mask without updating the accepted [so that
3072f29ffdb6SMintz, Yuval * PF could communicate to VF it has rejected request].
3073dacd88d6SYuval Mintz */
3074f29ffdb6SMintz, Yuval qed_iov_vp_update_rss_param(p_hwfn, vf, ¶ms, p_rss_params,
3075f29ffdb6SMintz, Yuval mbx, &tlvs_mask, &tlvs_accepted);
3076f29ffdb6SMintz, Yuval
3077f990c82cSMintz, Yuval if (qed_iov_pre_update_vport(p_hwfn, vf->relative_vf_id,
3078f990c82cSMintz, Yuval ¶ms, &tlvs_accepted)) {
3079f990c82cSMintz, Yuval tlvs_accepted = 0;
3080f990c82cSMintz, Yuval status = PFVF_STATUS_NOT_SUPPORTED;
3081f990c82cSMintz, Yuval goto out;
3082f990c82cSMintz, Yuval }
3083f990c82cSMintz, Yuval
3084f29ffdb6SMintz, Yuval if (!tlvs_accepted) {
3085f29ffdb6SMintz, Yuval if (tlvs_mask)
3086f29ffdb6SMintz, Yuval DP_VERBOSE(p_hwfn, QED_MSG_IOV,
3087f29ffdb6SMintz, Yuval "Upper-layer prevents VF vport configuration\n");
3088f29ffdb6SMintz, Yuval else
3089f29ffdb6SMintz, Yuval DP_VERBOSE(p_hwfn, QED_MSG_IOV,
3090dacd88d6SYuval Mintz "No feature tlvs found for vport update\n");
3091dacd88d6SYuval Mintz status = PFVF_STATUS_NOT_SUPPORTED;
3092dacd88d6SYuval Mintz goto out;
3093dacd88d6SYuval Mintz }
3094dacd88d6SYuval Mintz
3095dacd88d6SYuval Mintz rc = qed_sp_vport_update(p_hwfn, ¶ms, QED_SPQ_MODE_EBLOCK, NULL);
3096dacd88d6SYuval Mintz
3097dacd88d6SYuval Mintz if (rc)
3098dacd88d6SYuval Mintz status = PFVF_STATUS_FAILURE;
3099dacd88d6SYuval Mintz
3100dacd88d6SYuval Mintz out:
3101f29ffdb6SMintz, Yuval vfree(p_rss_params);
3102dacd88d6SYuval Mintz length = qed_iov_prep_vp_update_resp_tlvs(p_hwfn, vf, mbx, status,
3103f29ffdb6SMintz, Yuval tlvs_mask, tlvs_accepted);
3104dacd88d6SYuval Mintz qed_iov_send_response(p_hwfn, p_ptt, vf, length, status);
3105dacd88d6SYuval Mintz }
3106dacd88d6SYuval Mintz
qed_iov_vf_update_vlan_shadow(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,struct qed_filter_ucast * p_params)31078246d0b4SYuval Mintz static int qed_iov_vf_update_vlan_shadow(struct qed_hwfn *p_hwfn,
310808feecd7SYuval Mintz struct qed_vf_info *p_vf,
310908feecd7SYuval Mintz struct qed_filter_ucast *p_params)
311008feecd7SYuval Mintz {
311108feecd7SYuval Mintz int i;
311208feecd7SYuval Mintz
311308feecd7SYuval Mintz /* First remove entries and then add new ones */
311408feecd7SYuval Mintz if (p_params->opcode == QED_FILTER_REMOVE) {
311508feecd7SYuval Mintz for (i = 0; i < QED_ETH_VF_NUM_VLAN_FILTERS + 1; i++)
311608feecd7SYuval Mintz if (p_vf->shadow_config.vlans[i].used &&
311708feecd7SYuval Mintz p_vf->shadow_config.vlans[i].vid ==
311808feecd7SYuval Mintz p_params->vlan) {
311908feecd7SYuval Mintz p_vf->shadow_config.vlans[i].used = false;
312008feecd7SYuval Mintz break;
312108feecd7SYuval Mintz }
312208feecd7SYuval Mintz if (i == QED_ETH_VF_NUM_VLAN_FILTERS + 1) {
312308feecd7SYuval Mintz DP_VERBOSE(p_hwfn,
312408feecd7SYuval Mintz QED_MSG_IOV,
312508feecd7SYuval Mintz "VF [%d] - Tries to remove a non-existing vlan\n",
312608feecd7SYuval Mintz p_vf->relative_vf_id);
312708feecd7SYuval Mintz return -EINVAL;
312808feecd7SYuval Mintz }
312908feecd7SYuval Mintz } else if (p_params->opcode == QED_FILTER_REPLACE ||
313008feecd7SYuval Mintz p_params->opcode == QED_FILTER_FLUSH) {
313108feecd7SYuval Mintz for (i = 0; i < QED_ETH_VF_NUM_VLAN_FILTERS + 1; i++)
313208feecd7SYuval Mintz p_vf->shadow_config.vlans[i].used = false;
313308feecd7SYuval Mintz }
313408feecd7SYuval Mintz
313508feecd7SYuval Mintz /* In forced mode, we're willing to remove entries - but we don't add
313608feecd7SYuval Mintz * new ones.
313708feecd7SYuval Mintz */
31381a635e48SYuval Mintz if (p_vf->bulletin.p_virt->valid_bitmap & BIT(VLAN_ADDR_FORCED))
313908feecd7SYuval Mintz return 0;
314008feecd7SYuval Mintz
314108feecd7SYuval Mintz if (p_params->opcode == QED_FILTER_ADD ||
314208feecd7SYuval Mintz p_params->opcode == QED_FILTER_REPLACE) {
314308feecd7SYuval Mintz for (i = 0; i < QED_ETH_VF_NUM_VLAN_FILTERS + 1; i++) {
314408feecd7SYuval Mintz if (p_vf->shadow_config.vlans[i].used)
314508feecd7SYuval Mintz continue;
314608feecd7SYuval Mintz
314708feecd7SYuval Mintz p_vf->shadow_config.vlans[i].used = true;
314808feecd7SYuval Mintz p_vf->shadow_config.vlans[i].vid = p_params->vlan;
314908feecd7SYuval Mintz break;
315008feecd7SYuval Mintz }
315108feecd7SYuval Mintz
315208feecd7SYuval Mintz if (i == QED_ETH_VF_NUM_VLAN_FILTERS + 1) {
315308feecd7SYuval Mintz DP_VERBOSE(p_hwfn,
315408feecd7SYuval Mintz QED_MSG_IOV,
315508feecd7SYuval Mintz "VF [%d] - Tries to configure more than %d vlan filters\n",
315608feecd7SYuval Mintz p_vf->relative_vf_id,
315708feecd7SYuval Mintz QED_ETH_VF_NUM_VLAN_FILTERS + 1);
315808feecd7SYuval Mintz return -EINVAL;
315908feecd7SYuval Mintz }
316008feecd7SYuval Mintz }
316108feecd7SYuval Mintz
316208feecd7SYuval Mintz return 0;
316308feecd7SYuval Mintz }
316408feecd7SYuval Mintz
qed_iov_vf_update_mac_shadow(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,struct qed_filter_ucast * p_params)31658246d0b4SYuval Mintz static int qed_iov_vf_update_mac_shadow(struct qed_hwfn *p_hwfn,
31668246d0b4SYuval Mintz struct qed_vf_info *p_vf,
31678246d0b4SYuval Mintz struct qed_filter_ucast *p_params)
31688246d0b4SYuval Mintz {
31698246d0b4SYuval Mintz int i;
31708246d0b4SYuval Mintz
31718246d0b4SYuval Mintz /* If we're in forced-mode, we don't allow any change */
31721a635e48SYuval Mintz if (p_vf->bulletin.p_virt->valid_bitmap & BIT(MAC_ADDR_FORCED))
31738246d0b4SYuval Mintz return 0;
31748246d0b4SYuval Mintz
31757425d822SShahed Shaikh /* Don't keep track of shadow copy since we don't intend to restore. */
31767425d822SShahed Shaikh if (p_vf->p_vf_info.is_trusted_configured)
31777425d822SShahed Shaikh return 0;
31787425d822SShahed Shaikh
31798246d0b4SYuval Mintz /* First remove entries and then add new ones */
31808246d0b4SYuval Mintz if (p_params->opcode == QED_FILTER_REMOVE) {
31818246d0b4SYuval Mintz for (i = 0; i < QED_ETH_VF_NUM_MAC_FILTERS; i++) {
31828246d0b4SYuval Mintz if (ether_addr_equal(p_vf->shadow_config.macs[i],
31838246d0b4SYuval Mintz p_params->mac)) {
31840ee28e31SShyam Saini eth_zero_addr(p_vf->shadow_config.macs[i]);
31858246d0b4SYuval Mintz break;
31868246d0b4SYuval Mintz }
31878246d0b4SYuval Mintz }
31888246d0b4SYuval Mintz
31898246d0b4SYuval Mintz if (i == QED_ETH_VF_NUM_MAC_FILTERS) {
31908246d0b4SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
31918246d0b4SYuval Mintz "MAC isn't configured\n");
31928246d0b4SYuval Mintz return -EINVAL;
31938246d0b4SYuval Mintz }
31948246d0b4SYuval Mintz } else if (p_params->opcode == QED_FILTER_REPLACE ||
31958246d0b4SYuval Mintz p_params->opcode == QED_FILTER_FLUSH) {
31968246d0b4SYuval Mintz for (i = 0; i < QED_ETH_VF_NUM_MAC_FILTERS; i++)
31970ee28e31SShyam Saini eth_zero_addr(p_vf->shadow_config.macs[i]);
31988246d0b4SYuval Mintz }
31998246d0b4SYuval Mintz
32008246d0b4SYuval Mintz /* List the new MAC address */
32018246d0b4SYuval Mintz if (p_params->opcode != QED_FILTER_ADD &&
32028246d0b4SYuval Mintz p_params->opcode != QED_FILTER_REPLACE)
32038246d0b4SYuval Mintz return 0;
32048246d0b4SYuval Mintz
32058246d0b4SYuval Mintz for (i = 0; i < QED_ETH_VF_NUM_MAC_FILTERS; i++) {
32068246d0b4SYuval Mintz if (is_zero_ether_addr(p_vf->shadow_config.macs[i])) {
32078246d0b4SYuval Mintz ether_addr_copy(p_vf->shadow_config.macs[i],
32088246d0b4SYuval Mintz p_params->mac);
32098246d0b4SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
32108246d0b4SYuval Mintz "Added MAC at %d entry in shadow\n", i);
32118246d0b4SYuval Mintz break;
32128246d0b4SYuval Mintz }
32138246d0b4SYuval Mintz }
32148246d0b4SYuval Mintz
32158246d0b4SYuval Mintz if (i == QED_ETH_VF_NUM_MAC_FILTERS) {
32168246d0b4SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV, "No available place for MAC\n");
32178246d0b4SYuval Mintz return -EINVAL;
32188246d0b4SYuval Mintz }
32198246d0b4SYuval Mintz
32208246d0b4SYuval Mintz return 0;
32218246d0b4SYuval Mintz }
32228246d0b4SYuval Mintz
32238246d0b4SYuval Mintz static int
qed_iov_vf_update_unicast_shadow(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,struct qed_filter_ucast * p_params)32248246d0b4SYuval Mintz qed_iov_vf_update_unicast_shadow(struct qed_hwfn *p_hwfn,
32258246d0b4SYuval Mintz struct qed_vf_info *p_vf,
32268246d0b4SYuval Mintz struct qed_filter_ucast *p_params)
32278246d0b4SYuval Mintz {
32288246d0b4SYuval Mintz int rc = 0;
32298246d0b4SYuval Mintz
32308246d0b4SYuval Mintz if (p_params->type == QED_FILTER_MAC) {
32318246d0b4SYuval Mintz rc = qed_iov_vf_update_mac_shadow(p_hwfn, p_vf, p_params);
32328246d0b4SYuval Mintz if (rc)
32338246d0b4SYuval Mintz return rc;
32348246d0b4SYuval Mintz }
32358246d0b4SYuval Mintz
32368246d0b4SYuval Mintz if (p_params->type == QED_FILTER_VLAN)
32378246d0b4SYuval Mintz rc = qed_iov_vf_update_vlan_shadow(p_hwfn, p_vf, p_params);
32388246d0b4SYuval Mintz
32398246d0b4SYuval Mintz return rc;
32408246d0b4SYuval Mintz }
32418246d0b4SYuval Mintz
qed_iov_chk_ucast(struct qed_hwfn * hwfn,int vfid,struct qed_filter_ucast * params)3242ba56947aSBaoyou Xie static int qed_iov_chk_ucast(struct qed_hwfn *hwfn,
3243dacd88d6SYuval Mintz int vfid, struct qed_filter_ucast *params)
3244dacd88d6SYuval Mintz {
3245dacd88d6SYuval Mintz struct qed_public_vf_info *vf;
3246dacd88d6SYuval Mintz
3247dacd88d6SYuval Mintz vf = qed_iov_get_public_vf_info(hwfn, vfid, true);
3248dacd88d6SYuval Mintz if (!vf)
3249dacd88d6SYuval Mintz return -EINVAL;
3250dacd88d6SYuval Mintz
3251dacd88d6SYuval Mintz /* No real decision to make; Store the configured MAC */
3252dacd88d6SYuval Mintz if (params->type == QED_FILTER_MAC ||
32537425d822SShahed Shaikh params->type == QED_FILTER_MAC_VLAN) {
3254dacd88d6SYuval Mintz ether_addr_copy(vf->mac, params->mac);
3255dacd88d6SYuval Mintz
32567425d822SShahed Shaikh if (vf->is_trusted_configured) {
32577425d822SShahed Shaikh qed_iov_bulletin_set_mac(hwfn, vf->mac, vfid);
32587425d822SShahed Shaikh
32597425d822SShahed Shaikh /* Update and post bulleitin again */
32607425d822SShahed Shaikh qed_schedule_iov(hwfn, QED_IOV_WQ_BULLETIN_UPDATE_FLAG);
32617425d822SShahed Shaikh }
32627425d822SShahed Shaikh }
32637425d822SShahed Shaikh
3264dacd88d6SYuval Mintz return 0;
3265dacd88d6SYuval Mintz }
3266dacd88d6SYuval Mintz
qed_iov_vf_mbx_ucast_filter(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)3267dacd88d6SYuval Mintz static void qed_iov_vf_mbx_ucast_filter(struct qed_hwfn *p_hwfn,
3268dacd88d6SYuval Mintz struct qed_ptt *p_ptt,
3269dacd88d6SYuval Mintz struct qed_vf_info *vf)
3270dacd88d6SYuval Mintz {
327108feecd7SYuval Mintz struct qed_bulletin_content *p_bulletin = vf->bulletin.p_virt;
3272dacd88d6SYuval Mintz struct qed_iov_vf_mbx *mbx = &vf->vf_mbx;
3273dacd88d6SYuval Mintz struct vfpf_ucast_filter_tlv *req;
3274dacd88d6SYuval Mintz u8 status = PFVF_STATUS_SUCCESS;
3275dacd88d6SYuval Mintz struct qed_filter_ucast params;
3276dacd88d6SYuval Mintz int rc;
3277dacd88d6SYuval Mintz
3278dacd88d6SYuval Mintz /* Prepare the unicast filter params */
3279dacd88d6SYuval Mintz memset(¶ms, 0, sizeof(struct qed_filter_ucast));
3280dacd88d6SYuval Mintz req = &mbx->req_virt->ucast_filter;
3281dacd88d6SYuval Mintz params.opcode = (enum qed_filter_opcode)req->opcode;
3282dacd88d6SYuval Mintz params.type = (enum qed_filter_ucast_type)req->type;
3283dacd88d6SYuval Mintz
3284dacd88d6SYuval Mintz params.is_rx_filter = 1;
3285dacd88d6SYuval Mintz params.is_tx_filter = 1;
3286dacd88d6SYuval Mintz params.vport_to_remove_from = vf->vport_id;
3287dacd88d6SYuval Mintz params.vport_to_add_to = vf->vport_id;
3288dacd88d6SYuval Mintz memcpy(params.mac, req->mac, ETH_ALEN);
3289dacd88d6SYuval Mintz params.vlan = req->vlan;
3290dacd88d6SYuval Mintz
3291dacd88d6SYuval Mintz DP_VERBOSE(p_hwfn,
3292dacd88d6SYuval Mintz QED_MSG_IOV,
3293b03c3bacSAndy Shevchenko "VF[%d]: opcode 0x%02x type 0x%02x [%s %s] [vport 0x%02x] MAC %pM, vlan 0x%04x\n",
3294dacd88d6SYuval Mintz vf->abs_vf_id, params.opcode, params.type,
3295dacd88d6SYuval Mintz params.is_rx_filter ? "RX" : "",
3296dacd88d6SYuval Mintz params.is_tx_filter ? "TX" : "",
3297dacd88d6SYuval Mintz params.vport_to_add_to,
3298b03c3bacSAndy Shevchenko params.mac, params.vlan);
3299dacd88d6SYuval Mintz
3300dacd88d6SYuval Mintz if (!vf->vport_instance) {
3301dacd88d6SYuval Mintz DP_VERBOSE(p_hwfn,
3302dacd88d6SYuval Mintz QED_MSG_IOV,
3303dacd88d6SYuval Mintz "No VPORT instance available for VF[%d], failing ucast MAC configuration\n",
3304dacd88d6SYuval Mintz vf->abs_vf_id);
3305dacd88d6SYuval Mintz status = PFVF_STATUS_FAILURE;
3306dacd88d6SYuval Mintz goto out;
3307dacd88d6SYuval Mintz }
3308dacd88d6SYuval Mintz
330908feecd7SYuval Mintz /* Update shadow copy of the VF configuration */
331008feecd7SYuval Mintz if (qed_iov_vf_update_unicast_shadow(p_hwfn, vf, ¶ms)) {
331108feecd7SYuval Mintz status = PFVF_STATUS_FAILURE;
331208feecd7SYuval Mintz goto out;
331308feecd7SYuval Mintz }
331408feecd7SYuval Mintz
331508feecd7SYuval Mintz /* Determine if the unicast filtering is acceptible by PF */
33161a635e48SYuval Mintz if ((p_bulletin->valid_bitmap & BIT(VLAN_ADDR_FORCED)) &&
331708feecd7SYuval Mintz (params.type == QED_FILTER_VLAN ||
331808feecd7SYuval Mintz params.type == QED_FILTER_MAC_VLAN)) {
331908feecd7SYuval Mintz /* Once VLAN is forced or PVID is set, do not allow
332008feecd7SYuval Mintz * to add/replace any further VLANs.
332108feecd7SYuval Mintz */
332208feecd7SYuval Mintz if (params.opcode == QED_FILTER_ADD ||
332308feecd7SYuval Mintz params.opcode == QED_FILTER_REPLACE)
332408feecd7SYuval Mintz status = PFVF_STATUS_FORCED;
332508feecd7SYuval Mintz goto out;
332608feecd7SYuval Mintz }
332708feecd7SYuval Mintz
33281a635e48SYuval Mintz if ((p_bulletin->valid_bitmap & BIT(MAC_ADDR_FORCED)) &&
3329eff16960SYuval Mintz (params.type == QED_FILTER_MAC ||
3330eff16960SYuval Mintz params.type == QED_FILTER_MAC_VLAN)) {
3331eff16960SYuval Mintz if (!ether_addr_equal(p_bulletin->mac, params.mac) ||
3332eff16960SYuval Mintz (params.opcode != QED_FILTER_ADD &&
3333eff16960SYuval Mintz params.opcode != QED_FILTER_REPLACE))
3334eff16960SYuval Mintz status = PFVF_STATUS_FORCED;
3335eff16960SYuval Mintz goto out;
3336eff16960SYuval Mintz }
3337eff16960SYuval Mintz
3338dacd88d6SYuval Mintz rc = qed_iov_chk_ucast(p_hwfn, vf->relative_vf_id, ¶ms);
3339dacd88d6SYuval Mintz if (rc) {
3340dacd88d6SYuval Mintz status = PFVF_STATUS_FAILURE;
3341dacd88d6SYuval Mintz goto out;
3342dacd88d6SYuval Mintz }
3343dacd88d6SYuval Mintz
3344dacd88d6SYuval Mintz rc = qed_sp_eth_filter_ucast(p_hwfn, vf->opaque_fid, ¶ms,
3345dacd88d6SYuval Mintz QED_SPQ_MODE_CB, NULL);
3346dacd88d6SYuval Mintz if (rc)
3347dacd88d6SYuval Mintz status = PFVF_STATUS_FAILURE;
3348dacd88d6SYuval Mintz
3349dacd88d6SYuval Mintz out:
3350dacd88d6SYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, vf, CHANNEL_TLV_UCAST_FILTER,
3351dacd88d6SYuval Mintz sizeof(struct pfvf_def_resp_tlv), status);
3352dacd88d6SYuval Mintz }
3353dacd88d6SYuval Mintz
qed_iov_vf_mbx_int_cleanup(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)33540b55e27dSYuval Mintz static void qed_iov_vf_mbx_int_cleanup(struct qed_hwfn *p_hwfn,
33550b55e27dSYuval Mintz struct qed_ptt *p_ptt,
33560b55e27dSYuval Mintz struct qed_vf_info *vf)
33570b55e27dSYuval Mintz {
33580b55e27dSYuval Mintz int i;
33590b55e27dSYuval Mintz
33600b55e27dSYuval Mintz /* Reset the SBs */
33610b55e27dSYuval Mintz for (i = 0; i < vf->num_sbs; i++)
33620b55e27dSYuval Mintz qed_int_igu_init_pure_rt_single(p_hwfn, p_ptt,
33630b55e27dSYuval Mintz vf->igu_sbs[i],
33640b55e27dSYuval Mintz vf->opaque_fid, false);
33650b55e27dSYuval Mintz
33660b55e27dSYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, vf, CHANNEL_TLV_INT_CLEANUP,
33670b55e27dSYuval Mintz sizeof(struct pfvf_def_resp_tlv),
33680b55e27dSYuval Mintz PFVF_STATUS_SUCCESS);
33690b55e27dSYuval Mintz }
33700b55e27dSYuval Mintz
qed_iov_vf_mbx_close(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)33710b55e27dSYuval Mintz static void qed_iov_vf_mbx_close(struct qed_hwfn *p_hwfn,
33720b55e27dSYuval Mintz struct qed_ptt *p_ptt, struct qed_vf_info *vf)
33730b55e27dSYuval Mintz {
33740b55e27dSYuval Mintz u16 length = sizeof(struct pfvf_def_resp_tlv);
33750b55e27dSYuval Mintz u8 status = PFVF_STATUS_SUCCESS;
33760b55e27dSYuval Mintz
33770b55e27dSYuval Mintz /* Disable Interrupts for VF */
33780b55e27dSYuval Mintz qed_iov_vf_igu_set_int(p_hwfn, p_ptt, vf, 0);
33790b55e27dSYuval Mintz
33800b55e27dSYuval Mintz /* Reset Permission table */
33810b55e27dSYuval Mintz qed_iov_config_perm_table(p_hwfn, p_ptt, vf, 0);
33820b55e27dSYuval Mintz
33830b55e27dSYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, vf, CHANNEL_TLV_CLOSE,
33840b55e27dSYuval Mintz length, status);
33850b55e27dSYuval Mintz }
33860b55e27dSYuval Mintz
qed_iov_vf_mbx_release(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * p_vf)33870b55e27dSYuval Mintz static void qed_iov_vf_mbx_release(struct qed_hwfn *p_hwfn,
33880b55e27dSYuval Mintz struct qed_ptt *p_ptt,
33890b55e27dSYuval Mintz struct qed_vf_info *p_vf)
33900b55e27dSYuval Mintz {
33910b55e27dSYuval Mintz u16 length = sizeof(struct pfvf_def_resp_tlv);
33921fe614d1SYuval Mintz u8 status = PFVF_STATUS_SUCCESS;
33931fe614d1SYuval Mintz int rc = 0;
33940b55e27dSYuval Mintz
33950b55e27dSYuval Mintz qed_iov_vf_cleanup(p_hwfn, p_vf);
33960b55e27dSYuval Mintz
33971fe614d1SYuval Mintz if (p_vf->state != VF_STOPPED && p_vf->state != VF_FREE) {
33981fe614d1SYuval Mintz /* Stopping the VF */
33991fe614d1SYuval Mintz rc = qed_sp_vf_stop(p_hwfn, p_vf->concrete_fid,
34001fe614d1SYuval Mintz p_vf->opaque_fid);
34011fe614d1SYuval Mintz
34021fe614d1SYuval Mintz if (rc) {
34031fe614d1SYuval Mintz DP_ERR(p_hwfn, "qed_sp_vf_stop returned error %d\n",
34041fe614d1SYuval Mintz rc);
34051fe614d1SYuval Mintz status = PFVF_STATUS_FAILURE;
34061fe614d1SYuval Mintz }
34071fe614d1SYuval Mintz
34081fe614d1SYuval Mintz p_vf->state = VF_STOPPED;
34091fe614d1SYuval Mintz }
34101fe614d1SYuval Mintz
34110b55e27dSYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, p_vf, CHANNEL_TLV_RELEASE,
34121fe614d1SYuval Mintz length, status);
34130b55e27dSYuval Mintz }
34140b55e27dSYuval Mintz
qed_iov_vf_pf_get_coalesce(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * p_vf)3415bf5a94bfSRahul Verma static void qed_iov_vf_pf_get_coalesce(struct qed_hwfn *p_hwfn,
3416bf5a94bfSRahul Verma struct qed_ptt *p_ptt,
3417bf5a94bfSRahul Verma struct qed_vf_info *p_vf)
3418bf5a94bfSRahul Verma {
3419bf5a94bfSRahul Verma struct qed_iov_vf_mbx *mbx = &p_vf->vf_mbx;
3420bf5a94bfSRahul Verma struct pfvf_read_coal_resp_tlv *p_resp;
3421bf5a94bfSRahul Verma struct vfpf_read_coal_req_tlv *req;
3422bf5a94bfSRahul Verma u8 status = PFVF_STATUS_FAILURE;
3423bf5a94bfSRahul Verma struct qed_vf_queue *p_queue;
3424bf5a94bfSRahul Verma struct qed_queue_cid *p_cid;
3425bf5a94bfSRahul Verma u16 coal = 0, qid, i;
3426bf5a94bfSRahul Verma bool b_is_rx;
3427bf5a94bfSRahul Verma int rc = 0;
3428bf5a94bfSRahul Verma
3429bf5a94bfSRahul Verma mbx->offset = (u8 *)mbx->reply_virt;
3430bf5a94bfSRahul Verma req = &mbx->req_virt->read_coal_req;
3431bf5a94bfSRahul Verma
3432bf5a94bfSRahul Verma qid = req->qid;
3433bf5a94bfSRahul Verma b_is_rx = req->is_rx ? true : false;
3434bf5a94bfSRahul Verma
3435bf5a94bfSRahul Verma if (b_is_rx) {
3436bf5a94bfSRahul Verma if (!qed_iov_validate_rxq(p_hwfn, p_vf, qid,
3437bf5a94bfSRahul Verma QED_IOV_VALIDATE_Q_ENABLE)) {
3438bf5a94bfSRahul Verma DP_VERBOSE(p_hwfn, QED_MSG_IOV,
3439bf5a94bfSRahul Verma "VF[%d]: Invalid Rx queue_id = %d\n",
3440bf5a94bfSRahul Verma p_vf->abs_vf_id, qid);
3441bf5a94bfSRahul Verma goto send_resp;
3442bf5a94bfSRahul Verma }
3443bf5a94bfSRahul Verma
3444bf5a94bfSRahul Verma p_cid = qed_iov_get_vf_rx_queue_cid(&p_vf->vf_queues[qid]);
3445bf5a94bfSRahul Verma rc = qed_get_rxq_coalesce(p_hwfn, p_ptt, p_cid, &coal);
3446bf5a94bfSRahul Verma if (rc)
3447bf5a94bfSRahul Verma goto send_resp;
3448bf5a94bfSRahul Verma } else {
3449bf5a94bfSRahul Verma if (!qed_iov_validate_txq(p_hwfn, p_vf, qid,
3450bf5a94bfSRahul Verma QED_IOV_VALIDATE_Q_ENABLE)) {
3451bf5a94bfSRahul Verma DP_VERBOSE(p_hwfn, QED_MSG_IOV,
3452bf5a94bfSRahul Verma "VF[%d]: Invalid Tx queue_id = %d\n",
3453bf5a94bfSRahul Verma p_vf->abs_vf_id, qid);
3454bf5a94bfSRahul Verma goto send_resp;
3455bf5a94bfSRahul Verma }
3456bf5a94bfSRahul Verma for (i = 0; i < MAX_QUEUES_PER_QZONE; i++) {
3457bf5a94bfSRahul Verma p_queue = &p_vf->vf_queues[qid];
3458bf5a94bfSRahul Verma if ((!p_queue->cids[i].p_cid) ||
3459bf5a94bfSRahul Verma (!p_queue->cids[i].b_is_tx))
3460bf5a94bfSRahul Verma continue;
3461bf5a94bfSRahul Verma
3462bf5a94bfSRahul Verma p_cid = p_queue->cids[i].p_cid;
3463bf5a94bfSRahul Verma
3464bf5a94bfSRahul Verma rc = qed_get_txq_coalesce(p_hwfn, p_ptt, p_cid, &coal);
3465bf5a94bfSRahul Verma if (rc)
3466bf5a94bfSRahul Verma goto send_resp;
3467bf5a94bfSRahul Verma break;
3468bf5a94bfSRahul Verma }
3469bf5a94bfSRahul Verma }
3470bf5a94bfSRahul Verma
3471bf5a94bfSRahul Verma status = PFVF_STATUS_SUCCESS;
3472bf5a94bfSRahul Verma
3473bf5a94bfSRahul Verma send_resp:
3474bf5a94bfSRahul Verma p_resp = qed_add_tlv(p_hwfn, &mbx->offset, CHANNEL_TLV_COALESCE_READ,
3475bf5a94bfSRahul Verma sizeof(*p_resp));
3476bf5a94bfSRahul Verma p_resp->coal = coal;
3477bf5a94bfSRahul Verma
3478bf5a94bfSRahul Verma qed_add_tlv(p_hwfn, &mbx->offset, CHANNEL_TLV_LIST_END,
3479bf5a94bfSRahul Verma sizeof(struct channel_list_end_tlv));
3480bf5a94bfSRahul Verma
3481bf5a94bfSRahul Verma qed_iov_send_response(p_hwfn, p_ptt, p_vf, sizeof(*p_resp), status);
3482bf5a94bfSRahul Verma }
3483bf5a94bfSRahul Verma
qed_iov_vf_pf_set_coalesce(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * vf)3484477f2d14SRahul Verma static void qed_iov_vf_pf_set_coalesce(struct qed_hwfn *p_hwfn,
3485477f2d14SRahul Verma struct qed_ptt *p_ptt,
3486477f2d14SRahul Verma struct qed_vf_info *vf)
3487477f2d14SRahul Verma {
3488477f2d14SRahul Verma struct qed_iov_vf_mbx *mbx = &vf->vf_mbx;
3489477f2d14SRahul Verma struct vfpf_update_coalesce *req;
3490477f2d14SRahul Verma u8 status = PFVF_STATUS_FAILURE;
3491477f2d14SRahul Verma struct qed_queue_cid *p_cid;
3492477f2d14SRahul Verma u16 rx_coal, tx_coal;
3493477f2d14SRahul Verma int rc = 0, i;
3494477f2d14SRahul Verma u16 qid;
3495477f2d14SRahul Verma
3496477f2d14SRahul Verma req = &mbx->req_virt->update_coalesce;
3497477f2d14SRahul Verma
3498477f2d14SRahul Verma rx_coal = req->rx_coal;
3499477f2d14SRahul Verma tx_coal = req->tx_coal;
3500477f2d14SRahul Verma qid = req->qid;
3501477f2d14SRahul Verma
3502477f2d14SRahul Verma if (!qed_iov_validate_rxq(p_hwfn, vf, qid,
3503477f2d14SRahul Verma QED_IOV_VALIDATE_Q_ENABLE) && rx_coal) {
3504477f2d14SRahul Verma DP_VERBOSE(p_hwfn, QED_MSG_IOV,
3505477f2d14SRahul Verma "VF[%d]: Invalid Rx queue_id = %d\n",
3506477f2d14SRahul Verma vf->abs_vf_id, qid);
3507477f2d14SRahul Verma goto out;
3508477f2d14SRahul Verma }
3509477f2d14SRahul Verma
3510477f2d14SRahul Verma if (!qed_iov_validate_txq(p_hwfn, vf, qid,
3511477f2d14SRahul Verma QED_IOV_VALIDATE_Q_ENABLE) && tx_coal) {
3512477f2d14SRahul Verma DP_VERBOSE(p_hwfn, QED_MSG_IOV,
3513477f2d14SRahul Verma "VF[%d]: Invalid Tx queue_id = %d\n",
3514477f2d14SRahul Verma vf->abs_vf_id, qid);
3515477f2d14SRahul Verma goto out;
3516477f2d14SRahul Verma }
3517477f2d14SRahul Verma
3518477f2d14SRahul Verma DP_VERBOSE(p_hwfn,
3519477f2d14SRahul Verma QED_MSG_IOV,
3520477f2d14SRahul Verma "VF[%d]: Setting coalesce for VF rx_coal = %d, tx_coal = %d at queue = %d\n",
3521477f2d14SRahul Verma vf->abs_vf_id, rx_coal, tx_coal, qid);
3522477f2d14SRahul Verma
3523477f2d14SRahul Verma if (rx_coal) {
3524477f2d14SRahul Verma p_cid = qed_iov_get_vf_rx_queue_cid(&vf->vf_queues[qid]);
3525477f2d14SRahul Verma
3526477f2d14SRahul Verma rc = qed_set_rxq_coalesce(p_hwfn, p_ptt, rx_coal, p_cid);
3527477f2d14SRahul Verma if (rc) {
3528477f2d14SRahul Verma DP_VERBOSE(p_hwfn,
3529477f2d14SRahul Verma QED_MSG_IOV,
3530477f2d14SRahul Verma "VF[%d]: Unable to set rx queue = %d coalesce\n",
3531477f2d14SRahul Verma vf->abs_vf_id, vf->vf_queues[qid].fw_rx_qid);
3532477f2d14SRahul Verma goto out;
3533477f2d14SRahul Verma }
3534bf5a94bfSRahul Verma vf->rx_coal = rx_coal;
3535477f2d14SRahul Verma }
3536477f2d14SRahul Verma
3537477f2d14SRahul Verma if (tx_coal) {
3538477f2d14SRahul Verma struct qed_vf_queue *p_queue = &vf->vf_queues[qid];
3539477f2d14SRahul Verma
3540477f2d14SRahul Verma for (i = 0; i < MAX_QUEUES_PER_QZONE; i++) {
3541477f2d14SRahul Verma if (!p_queue->cids[i].p_cid)
3542477f2d14SRahul Verma continue;
3543477f2d14SRahul Verma
3544477f2d14SRahul Verma if (!p_queue->cids[i].b_is_tx)
3545477f2d14SRahul Verma continue;
3546477f2d14SRahul Verma
3547477f2d14SRahul Verma rc = qed_set_txq_coalesce(p_hwfn, p_ptt, tx_coal,
3548477f2d14SRahul Verma p_queue->cids[i].p_cid);
3549477f2d14SRahul Verma
3550477f2d14SRahul Verma if (rc) {
3551477f2d14SRahul Verma DP_VERBOSE(p_hwfn,
3552477f2d14SRahul Verma QED_MSG_IOV,
3553477f2d14SRahul Verma "VF[%d]: Unable to set tx queue coalesce\n",
3554477f2d14SRahul Verma vf->abs_vf_id);
3555477f2d14SRahul Verma goto out;
3556477f2d14SRahul Verma }
3557477f2d14SRahul Verma }
3558bf5a94bfSRahul Verma vf->tx_coal = tx_coal;
3559477f2d14SRahul Verma }
3560477f2d14SRahul Verma
3561477f2d14SRahul Verma status = PFVF_STATUS_SUCCESS;
3562477f2d14SRahul Verma out:
3563477f2d14SRahul Verma qed_iov_prepare_resp(p_hwfn, p_ptt, vf, CHANNEL_TLV_COALESCE_UPDATE,
3564477f2d14SRahul Verma sizeof(struct pfvf_def_resp_tlv), status);
3565477f2d14SRahul Verma }
3566fe40a830SPrabhakar Kushwaha
35670b55e27dSYuval Mintz static int
qed_iov_vf_flr_poll_dorq(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,struct qed_ptt * p_ptt)35680b55e27dSYuval Mintz qed_iov_vf_flr_poll_dorq(struct qed_hwfn *p_hwfn,
35690b55e27dSYuval Mintz struct qed_vf_info *p_vf, struct qed_ptt *p_ptt)
35700b55e27dSYuval Mintz {
35710b55e27dSYuval Mintz int cnt;
35720b55e27dSYuval Mintz u32 val;
35730b55e27dSYuval Mintz
35740b55e27dSYuval Mintz qed_fid_pretend(p_hwfn, p_ptt, (u16)p_vf->concrete_fid);
35750b55e27dSYuval Mintz
35760b55e27dSYuval Mintz for (cnt = 0; cnt < 50; cnt++) {
35770b55e27dSYuval Mintz val = qed_rd(p_hwfn, p_ptt, DORQ_REG_VF_USAGE_CNT);
35780b55e27dSYuval Mintz if (!val)
35790b55e27dSYuval Mintz break;
35800b55e27dSYuval Mintz msleep(20);
35810b55e27dSYuval Mintz }
35820b55e27dSYuval Mintz qed_fid_pretend(p_hwfn, p_ptt, (u16)p_hwfn->hw_info.concrete_fid);
35830b55e27dSYuval Mintz
35840b55e27dSYuval Mintz if (cnt == 50) {
35850b55e27dSYuval Mintz DP_ERR(p_hwfn,
35860b55e27dSYuval Mintz "VF[%d] - dorq failed to cleanup [usage 0x%08x]\n",
35870b55e27dSYuval Mintz p_vf->abs_vf_id, val);
35880b55e27dSYuval Mintz return -EBUSY;
35890b55e27dSYuval Mintz }
35900b55e27dSYuval Mintz
35910b55e27dSYuval Mintz return 0;
35920b55e27dSYuval Mintz }
35930b55e27dSYuval Mintz
3594b90cb538SOmkar Kulkarni #define MAX_NUM_EXT_VOQS (MAX_NUM_PORTS * NUM_OF_TCS)
3595b90cb538SOmkar Kulkarni
35960b55e27dSYuval Mintz static int
qed_iov_vf_flr_poll_pbf(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,struct qed_ptt * p_ptt)35970b55e27dSYuval Mintz qed_iov_vf_flr_poll_pbf(struct qed_hwfn *p_hwfn,
35980b55e27dSYuval Mintz struct qed_vf_info *p_vf, struct qed_ptt *p_ptt)
35990b55e27dSYuval Mintz {
3600b90cb538SOmkar Kulkarni u32 prod, cons[MAX_NUM_EXT_VOQS], distance[MAX_NUM_EXT_VOQS], tmp;
3601b90cb538SOmkar Kulkarni u8 max_phys_tcs_per_port = p_hwfn->qm_info.max_phys_tcs_per_port;
3602b90cb538SOmkar Kulkarni u8 max_ports_per_engine = p_hwfn->cdev->num_ports_in_engine;
3603b90cb538SOmkar Kulkarni u32 prod_voq0_addr = PBF_REG_NUM_BLOCKS_ALLOCATED_PROD_VOQ0;
3604b90cb538SOmkar Kulkarni u32 cons_voq0_addr = PBF_REG_NUM_BLOCKS_ALLOCATED_CONS_VOQ0;
3605b90cb538SOmkar Kulkarni u8 port_id, tc, tc_id = 0, voq = 0;
3606b90cb538SOmkar Kulkarni int cnt;
3607b90cb538SOmkar Kulkarni
3608b90cb538SOmkar Kulkarni memset(cons, 0, MAX_NUM_EXT_VOQS * sizeof(u32));
3609b90cb538SOmkar Kulkarni memset(distance, 0, MAX_NUM_EXT_VOQS * sizeof(u32));
36100b55e27dSYuval Mintz
36110b55e27dSYuval Mintz /* Read initial consumers & producers */
3612b90cb538SOmkar Kulkarni for (port_id = 0; port_id < max_ports_per_engine; port_id++) {
3613b90cb538SOmkar Kulkarni /* "max_phys_tcs_per_port" active TCs + 1 pure LB TC */
3614b90cb538SOmkar Kulkarni for (tc = 0; tc < max_phys_tcs_per_port + 1; tc++) {
3615b90cb538SOmkar Kulkarni tc_id = (tc < max_phys_tcs_per_port) ? tc : PURE_LB_TC;
3616b90cb538SOmkar Kulkarni voq = VOQ(port_id, tc_id, max_phys_tcs_per_port);
3617b90cb538SOmkar Kulkarni cons[voq] = qed_rd(p_hwfn, p_ptt,
3618b90cb538SOmkar Kulkarni cons_voq0_addr + voq * 0x40);
36190b55e27dSYuval Mintz prod = qed_rd(p_hwfn, p_ptt,
3620b90cb538SOmkar Kulkarni prod_voq0_addr + voq * 0x40);
3621b90cb538SOmkar Kulkarni distance[voq] = prod - cons[voq];
3622b90cb538SOmkar Kulkarni }
36230b55e27dSYuval Mintz }
36240b55e27dSYuval Mintz
36250b55e27dSYuval Mintz /* Wait for consumers to pass the producers */
3626b90cb538SOmkar Kulkarni port_id = 0;
3627b90cb538SOmkar Kulkarni tc = 0;
36280b55e27dSYuval Mintz for (cnt = 0; cnt < 50; cnt++) {
3629b90cb538SOmkar Kulkarni for (; port_id < max_ports_per_engine; port_id++) {
3630b90cb538SOmkar Kulkarni /* "max_phys_tcs_per_port" active TCs + 1 pure LB TC */
3631b90cb538SOmkar Kulkarni for (; tc < max_phys_tcs_per_port + 1; tc++) {
3632b90cb538SOmkar Kulkarni tc_id = (tc < max_phys_tcs_per_port) ?
3633b90cb538SOmkar Kulkarni tc : PURE_LB_TC;
3634b90cb538SOmkar Kulkarni voq = VOQ(port_id,
3635b90cb538SOmkar Kulkarni tc_id, max_phys_tcs_per_port);
36360b55e27dSYuval Mintz tmp = qed_rd(p_hwfn, p_ptt,
3637b90cb538SOmkar Kulkarni cons_voq0_addr + voq * 0x40);
3638b90cb538SOmkar Kulkarni if (distance[voq] > tmp - cons[voq])
36390b55e27dSYuval Mintz break;
36400b55e27dSYuval Mintz }
36410b55e27dSYuval Mintz
3642b90cb538SOmkar Kulkarni if (tc == max_phys_tcs_per_port + 1)
3643b90cb538SOmkar Kulkarni tc = 0;
3644b90cb538SOmkar Kulkarni else
3645b90cb538SOmkar Kulkarni break;
3646b90cb538SOmkar Kulkarni }
3647b90cb538SOmkar Kulkarni
3648b90cb538SOmkar Kulkarni if (port_id == max_ports_per_engine)
36490b55e27dSYuval Mintz break;
36500b55e27dSYuval Mintz
36510b55e27dSYuval Mintz msleep(20);
36520b55e27dSYuval Mintz }
36530b55e27dSYuval Mintz
36540b55e27dSYuval Mintz if (cnt == 50) {
3655b90cb538SOmkar Kulkarni DP_ERR(p_hwfn, "VF[%d]: pbf poll failed on VOQ%d\n",
3656b90cb538SOmkar Kulkarni p_vf->abs_vf_id, (int)voq);
3657b90cb538SOmkar Kulkarni
3658b90cb538SOmkar Kulkarni DP_ERR(p_hwfn, "VOQ %d has port_id as %d and tc_id as %d]\n",
3659b90cb538SOmkar Kulkarni (int)voq, (int)port_id, (int)tc_id);
3660b90cb538SOmkar Kulkarni
36610b55e27dSYuval Mintz return -EBUSY;
36620b55e27dSYuval Mintz }
36630b55e27dSYuval Mintz
36640b55e27dSYuval Mintz return 0;
36650b55e27dSYuval Mintz }
36660b55e27dSYuval Mintz
qed_iov_vf_flr_poll(struct qed_hwfn * p_hwfn,struct qed_vf_info * p_vf,struct qed_ptt * p_ptt)36670b55e27dSYuval Mintz static int qed_iov_vf_flr_poll(struct qed_hwfn *p_hwfn,
36680b55e27dSYuval Mintz struct qed_vf_info *p_vf, struct qed_ptt *p_ptt)
36690b55e27dSYuval Mintz {
36700b55e27dSYuval Mintz int rc;
36710b55e27dSYuval Mintz
36720b55e27dSYuval Mintz rc = qed_iov_vf_flr_poll_dorq(p_hwfn, p_vf, p_ptt);
36730b55e27dSYuval Mintz if (rc)
36740b55e27dSYuval Mintz return rc;
36750b55e27dSYuval Mintz
36760b55e27dSYuval Mintz rc = qed_iov_vf_flr_poll_pbf(p_hwfn, p_vf, p_ptt);
36770b55e27dSYuval Mintz if (rc)
36780b55e27dSYuval Mintz return rc;
36790b55e27dSYuval Mintz
36800b55e27dSYuval Mintz return 0;
36810b55e27dSYuval Mintz }
36820b55e27dSYuval Mintz
36830b55e27dSYuval Mintz static int
qed_iov_execute_vf_flr_cleanup(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,u16 rel_vf_id,u32 * ack_vfs)36840b55e27dSYuval Mintz qed_iov_execute_vf_flr_cleanup(struct qed_hwfn *p_hwfn,
36850b55e27dSYuval Mintz struct qed_ptt *p_ptt,
36860b55e27dSYuval Mintz u16 rel_vf_id, u32 *ack_vfs)
36870b55e27dSYuval Mintz {
36880b55e27dSYuval Mintz struct qed_vf_info *p_vf;
36890b55e27dSYuval Mintz int rc = 0;
36900b55e27dSYuval Mintz
36910b55e27dSYuval Mintz p_vf = qed_iov_get_vf_info(p_hwfn, rel_vf_id, false);
36920b55e27dSYuval Mintz if (!p_vf)
36930b55e27dSYuval Mintz return 0;
36940b55e27dSYuval Mintz
36950b55e27dSYuval Mintz if (p_hwfn->pf_iov_info->pending_flr[rel_vf_id / 64] &
36960b55e27dSYuval Mintz (1ULL << (rel_vf_id % 64))) {
36970b55e27dSYuval Mintz u16 vfid = p_vf->abs_vf_id;
36980b55e27dSYuval Mintz
36990b55e27dSYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
37000b55e27dSYuval Mintz "VF[%d] - Handling FLR\n", vfid);
37010b55e27dSYuval Mintz
37020b55e27dSYuval Mintz qed_iov_vf_cleanup(p_hwfn, p_vf);
37030b55e27dSYuval Mintz
37040b55e27dSYuval Mintz /* If VF isn't active, no need for anything but SW */
37050b55e27dSYuval Mintz if (!p_vf->b_init)
37060b55e27dSYuval Mintz goto cleanup;
37070b55e27dSYuval Mintz
37080b55e27dSYuval Mintz rc = qed_iov_vf_flr_poll(p_hwfn, p_vf, p_ptt);
37090b55e27dSYuval Mintz if (rc)
37100b55e27dSYuval Mintz goto cleanup;
37110b55e27dSYuval Mintz
37120b55e27dSYuval Mintz rc = qed_final_cleanup(p_hwfn, p_ptt, vfid, true);
37130b55e27dSYuval Mintz if (rc) {
37140b55e27dSYuval Mintz DP_ERR(p_hwfn, "Failed handle FLR of VF[%d]\n", vfid);
37150b55e27dSYuval Mintz return rc;
37160b55e27dSYuval Mintz }
37170b55e27dSYuval Mintz
37187eff82b0SYuval Mintz /* Workaround to make VF-PF channel ready, as FW
37197eff82b0SYuval Mintz * doesn't do that as a part of FLR.
37207eff82b0SYuval Mintz */
37217eff82b0SYuval Mintz REG_WR(p_hwfn,
3722e2dbc223SPrabhakar Kushwaha GET_GTT_REG_ADDR(GTT_BAR0_MAP_REG_USDM_RAM,
3723e2dbc223SPrabhakar Kushwaha USTORM_VF_PF_CHANNEL_READY, vfid), 1);
37247eff82b0SYuval Mintz
37250b55e27dSYuval Mintz /* VF_STOPPED has to be set only after final cleanup
37260b55e27dSYuval Mintz * but prior to re-enabling the VF.
37270b55e27dSYuval Mintz */
37280b55e27dSYuval Mintz p_vf->state = VF_STOPPED;
37290b55e27dSYuval Mintz
37300b55e27dSYuval Mintz rc = qed_iov_enable_vf_access(p_hwfn, p_ptt, p_vf);
37310b55e27dSYuval Mintz if (rc) {
37320b55e27dSYuval Mintz DP_ERR(p_hwfn, "Failed to re-enable VF[%d] acces\n",
37330b55e27dSYuval Mintz vfid);
37340b55e27dSYuval Mintz return rc;
37350b55e27dSYuval Mintz }
37360b55e27dSYuval Mintz cleanup:
37370b55e27dSYuval Mintz /* Mark VF for ack and clean pending state */
37380b55e27dSYuval Mintz if (p_vf->state == VF_RESET)
37390b55e27dSYuval Mintz p_vf->state = VF_STOPPED;
37401a635e48SYuval Mintz ack_vfs[vfid / 32] |= BIT((vfid % 32));
37410b55e27dSYuval Mintz p_hwfn->pf_iov_info->pending_flr[rel_vf_id / 64] &=
37420b55e27dSYuval Mintz ~(1ULL << (rel_vf_id % 64));
3743fd3c615aSMintz, Yuval p_vf->vf_mbx.b_pending_msg = false;
37440b55e27dSYuval Mintz }
37450b55e27dSYuval Mintz
37460b55e27dSYuval Mintz return rc;
37470b55e27dSYuval Mintz }
37480b55e27dSYuval Mintz
3749ba56947aSBaoyou Xie static int
qed_iov_vf_flr_cleanup(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt)3750ba56947aSBaoyou Xie qed_iov_vf_flr_cleanup(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt)
37510b55e27dSYuval Mintz {
37520b55e27dSYuval Mintz u32 ack_vfs[VF_MAX_STATIC / 32];
37530b55e27dSYuval Mintz int rc = 0;
37540b55e27dSYuval Mintz u16 i;
37550b55e27dSYuval Mintz
37560b55e27dSYuval Mintz memset(ack_vfs, 0, sizeof(u32) * (VF_MAX_STATIC / 32));
37570b55e27dSYuval Mintz
37580b55e27dSYuval Mintz /* Since BRB <-> PRS interface can't be tested as part of the flr
37590b55e27dSYuval Mintz * polling due to HW limitations, simply sleep a bit. And since
37600b55e27dSYuval Mintz * there's no need to wait per-vf, do it before looping.
37610b55e27dSYuval Mintz */
37620b55e27dSYuval Mintz msleep(100);
37630b55e27dSYuval Mintz
37640b55e27dSYuval Mintz for (i = 0; i < p_hwfn->cdev->p_iov_info->total_vfs; i++)
37650b55e27dSYuval Mintz qed_iov_execute_vf_flr_cleanup(p_hwfn, p_ptt, i, ack_vfs);
37660b55e27dSYuval Mintz
37670b55e27dSYuval Mintz rc = qed_mcp_ack_vf_flr(p_hwfn, p_ptt, ack_vfs);
37680b55e27dSYuval Mintz return rc;
37690b55e27dSYuval Mintz }
37700b55e27dSYuval Mintz
qed_iov_mark_vf_flr(struct qed_hwfn * p_hwfn,u32 * p_disabled_vfs)3771cccf6f5cSMintz, Yuval bool qed_iov_mark_vf_flr(struct qed_hwfn *p_hwfn, u32 *p_disabled_vfs)
37720b55e27dSYuval Mintz {
3773cccf6f5cSMintz, Yuval bool found = false;
3774cccf6f5cSMintz, Yuval u16 i;
37750b55e27dSYuval Mintz
37760b55e27dSYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV, "Marking FLR-ed VFs\n");
37770b55e27dSYuval Mintz for (i = 0; i < (VF_MAX_STATIC / 32); i++)
37780b55e27dSYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
37790b55e27dSYuval Mintz "[%08x,...,%08x]: %08x\n",
37800b55e27dSYuval Mintz i * 32, (i + 1) * 32 - 1, p_disabled_vfs[i]);
37810b55e27dSYuval Mintz
37820b55e27dSYuval Mintz if (!p_hwfn->cdev->p_iov_info) {
37830b55e27dSYuval Mintz DP_NOTICE(p_hwfn, "VF flr but no IOV\n");
3784cccf6f5cSMintz, Yuval return false;
37850b55e27dSYuval Mintz }
37860b55e27dSYuval Mintz
37870b55e27dSYuval Mintz /* Mark VFs */
37880b55e27dSYuval Mintz for (i = 0; i < p_hwfn->cdev->p_iov_info->total_vfs; i++) {
37890b55e27dSYuval Mintz struct qed_vf_info *p_vf;
37900b55e27dSYuval Mintz u8 vfid;
37910b55e27dSYuval Mintz
37920b55e27dSYuval Mintz p_vf = qed_iov_get_vf_info(p_hwfn, i, false);
37930b55e27dSYuval Mintz if (!p_vf)
37940b55e27dSYuval Mintz continue;
37950b55e27dSYuval Mintz
37960b55e27dSYuval Mintz vfid = p_vf->abs_vf_id;
37971a635e48SYuval Mintz if (BIT((vfid % 32)) & p_disabled_vfs[vfid / 32]) {
37980b55e27dSYuval Mintz u64 *p_flr = p_hwfn->pf_iov_info->pending_flr;
37990b55e27dSYuval Mintz u16 rel_vf_id = p_vf->relative_vf_id;
38000b55e27dSYuval Mintz
38010b55e27dSYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
38020b55e27dSYuval Mintz "VF[%d] [rel %d] got FLR-ed\n",
38030b55e27dSYuval Mintz vfid, rel_vf_id);
38040b55e27dSYuval Mintz
38050b55e27dSYuval Mintz p_vf->state = VF_RESET;
38060b55e27dSYuval Mintz
38070b55e27dSYuval Mintz /* No need to lock here, since pending_flr should
38080b55e27dSYuval Mintz * only change here and before ACKing MFw. Since
38090b55e27dSYuval Mintz * MFW will not trigger an additional attention for
38100b55e27dSYuval Mintz * VF flr until ACKs, we're safe.
38110b55e27dSYuval Mintz */
38120b55e27dSYuval Mintz p_flr[rel_vf_id / 64] |= 1ULL << (rel_vf_id % 64);
3813cccf6f5cSMintz, Yuval found = true;
38140b55e27dSYuval Mintz }
38150b55e27dSYuval Mintz }
38160b55e27dSYuval Mintz
38170b55e27dSYuval Mintz return found;
38180b55e27dSYuval Mintz }
38190b55e27dSYuval Mintz
qed_iov_get_link(struct qed_hwfn * p_hwfn,u16 vfid,struct qed_mcp_link_params * p_params,struct qed_mcp_link_state * p_link,struct qed_mcp_link_capabilities * p_caps)3820d9dc0c84STom Rix static int qed_iov_get_link(struct qed_hwfn *p_hwfn,
382173390ac9SYuval Mintz u16 vfid,
382273390ac9SYuval Mintz struct qed_mcp_link_params *p_params,
382373390ac9SYuval Mintz struct qed_mcp_link_state *p_link,
382473390ac9SYuval Mintz struct qed_mcp_link_capabilities *p_caps)
382573390ac9SYuval Mintz {
382673390ac9SYuval Mintz struct qed_vf_info *p_vf = qed_iov_get_vf_info(p_hwfn,
382773390ac9SYuval Mintz vfid,
382873390ac9SYuval Mintz false);
382973390ac9SYuval Mintz struct qed_bulletin_content *p_bulletin;
383073390ac9SYuval Mintz
383173390ac9SYuval Mintz if (!p_vf)
3832d9dc0c84STom Rix return -EINVAL;
383373390ac9SYuval Mintz
383473390ac9SYuval Mintz p_bulletin = p_vf->bulletin.p_virt;
383573390ac9SYuval Mintz
383673390ac9SYuval Mintz if (p_params)
383773390ac9SYuval Mintz __qed_vf_get_link_params(p_hwfn, p_params, p_bulletin);
383873390ac9SYuval Mintz if (p_link)
383973390ac9SYuval Mintz __qed_vf_get_link_state(p_hwfn, p_link, p_bulletin);
384073390ac9SYuval Mintz if (p_caps)
384173390ac9SYuval Mintz __qed_vf_get_link_caps(p_hwfn, p_caps, p_bulletin);
3842d9dc0c84STom Rix return 0;
384373390ac9SYuval Mintz }
384473390ac9SYuval Mintz
3845809c45a0SShahed Shaikh static int
qed_iov_vf_pf_bulletin_update_mac(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,struct qed_vf_info * p_vf)3846809c45a0SShahed Shaikh qed_iov_vf_pf_bulletin_update_mac(struct qed_hwfn *p_hwfn,
3847809c45a0SShahed Shaikh struct qed_ptt *p_ptt,
3848809c45a0SShahed Shaikh struct qed_vf_info *p_vf)
3849809c45a0SShahed Shaikh {
3850809c45a0SShahed Shaikh struct qed_bulletin_content *p_bulletin = p_vf->bulletin.p_virt;
3851809c45a0SShahed Shaikh struct qed_iov_vf_mbx *mbx = &p_vf->vf_mbx;
3852809c45a0SShahed Shaikh struct vfpf_bulletin_update_mac_tlv *p_req;
3853809c45a0SShahed Shaikh u8 status = PFVF_STATUS_SUCCESS;
3854809c45a0SShahed Shaikh int rc = 0;
3855809c45a0SShahed Shaikh
3856809c45a0SShahed Shaikh if (!p_vf->p_vf_info.is_trusted_configured) {
3857809c45a0SShahed Shaikh DP_VERBOSE(p_hwfn,
3858809c45a0SShahed Shaikh QED_MSG_IOV,
3859809c45a0SShahed Shaikh "Blocking bulletin update request from untrusted VF[%d]\n",
3860809c45a0SShahed Shaikh p_vf->abs_vf_id);
3861809c45a0SShahed Shaikh status = PFVF_STATUS_NOT_SUPPORTED;
3862809c45a0SShahed Shaikh rc = -EINVAL;
3863809c45a0SShahed Shaikh goto send_status;
3864809c45a0SShahed Shaikh }
3865809c45a0SShahed Shaikh
3866809c45a0SShahed Shaikh p_req = &mbx->req_virt->bulletin_update_mac;
3867809c45a0SShahed Shaikh ether_addr_copy(p_bulletin->mac, p_req->mac);
3868809c45a0SShahed Shaikh DP_VERBOSE(p_hwfn, QED_MSG_IOV,
3869809c45a0SShahed Shaikh "Updated bulletin of VF[%d] with requested MAC[%pM]\n",
3870809c45a0SShahed Shaikh p_vf->abs_vf_id, p_req->mac);
3871809c45a0SShahed Shaikh
3872809c45a0SShahed Shaikh send_status:
3873809c45a0SShahed Shaikh qed_iov_prepare_resp(p_hwfn, p_ptt, p_vf,
3874809c45a0SShahed Shaikh CHANNEL_TLV_BULLETIN_UPDATE_MAC,
3875809c45a0SShahed Shaikh sizeof(struct pfvf_def_resp_tlv), status);
3876809c45a0SShahed Shaikh return rc;
3877809c45a0SShahed Shaikh }
3878809c45a0SShahed Shaikh
qed_iov_process_mbx_req(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,int vfid)387937bff2b9SYuval Mintz static void qed_iov_process_mbx_req(struct qed_hwfn *p_hwfn,
388037bff2b9SYuval Mintz struct qed_ptt *p_ptt, int vfid)
388137bff2b9SYuval Mintz {
388237bff2b9SYuval Mintz struct qed_iov_vf_mbx *mbx;
388337bff2b9SYuval Mintz struct qed_vf_info *p_vf;
388437bff2b9SYuval Mintz
388537bff2b9SYuval Mintz p_vf = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
388637bff2b9SYuval Mintz if (!p_vf)
388737bff2b9SYuval Mintz return;
388837bff2b9SYuval Mintz
388937bff2b9SYuval Mintz mbx = &p_vf->vf_mbx;
389037bff2b9SYuval Mintz
389137bff2b9SYuval Mintz /* qed_iov_process_mbx_request */
3892fd3c615aSMintz, Yuval if (!mbx->b_pending_msg) {
3893fd3c615aSMintz, Yuval DP_NOTICE(p_hwfn,
3894fd3c615aSMintz, Yuval "VF[%02x]: Trying to process mailbox message when none is pending\n",
3895fd3c615aSMintz, Yuval p_vf->abs_vf_id);
3896fd3c615aSMintz, Yuval return;
3897fd3c615aSMintz, Yuval }
3898fd3c615aSMintz, Yuval mbx->b_pending_msg = false;
389937bff2b9SYuval Mintz
390037bff2b9SYuval Mintz mbx->first_tlv = mbx->req_virt->first_tlv;
390137bff2b9SYuval Mintz
3902fd3c615aSMintz, Yuval DP_VERBOSE(p_hwfn, QED_MSG_IOV,
3903fd3c615aSMintz, Yuval "VF[%02x]: Processing mailbox message [type %04x]\n",
3904fd3c615aSMintz, Yuval p_vf->abs_vf_id, mbx->first_tlv.tl.type);
3905fd3c615aSMintz, Yuval
390637bff2b9SYuval Mintz /* check if tlv type is known */
39077eff82b0SYuval Mintz if (qed_iov_tlv_supported(mbx->first_tlv.tl.type) &&
39087eff82b0SYuval Mintz !p_vf->b_malicious) {
39091408cc1fSYuval Mintz switch (mbx->first_tlv.tl.type) {
39101408cc1fSYuval Mintz case CHANNEL_TLV_ACQUIRE:
39111408cc1fSYuval Mintz qed_iov_vf_mbx_acquire(p_hwfn, p_ptt, p_vf);
39121408cc1fSYuval Mintz break;
3913dacd88d6SYuval Mintz case CHANNEL_TLV_VPORT_START:
3914dacd88d6SYuval Mintz qed_iov_vf_mbx_start_vport(p_hwfn, p_ptt, p_vf);
3915dacd88d6SYuval Mintz break;
3916dacd88d6SYuval Mintz case CHANNEL_TLV_VPORT_TEARDOWN:
3917dacd88d6SYuval Mintz qed_iov_vf_mbx_stop_vport(p_hwfn, p_ptt, p_vf);
3918dacd88d6SYuval Mintz break;
3919dacd88d6SYuval Mintz case CHANNEL_TLV_START_RXQ:
3920dacd88d6SYuval Mintz qed_iov_vf_mbx_start_rxq(p_hwfn, p_ptt, p_vf);
3921dacd88d6SYuval Mintz break;
3922dacd88d6SYuval Mintz case CHANNEL_TLV_START_TXQ:
3923dacd88d6SYuval Mintz qed_iov_vf_mbx_start_txq(p_hwfn, p_ptt, p_vf);
3924dacd88d6SYuval Mintz break;
3925dacd88d6SYuval Mintz case CHANNEL_TLV_STOP_RXQS:
3926dacd88d6SYuval Mintz qed_iov_vf_mbx_stop_rxqs(p_hwfn, p_ptt, p_vf);
3927dacd88d6SYuval Mintz break;
3928dacd88d6SYuval Mintz case CHANNEL_TLV_STOP_TXQS:
3929dacd88d6SYuval Mintz qed_iov_vf_mbx_stop_txqs(p_hwfn, p_ptt, p_vf);
3930dacd88d6SYuval Mintz break;
393117b235c1SYuval Mintz case CHANNEL_TLV_UPDATE_RXQ:
393217b235c1SYuval Mintz qed_iov_vf_mbx_update_rxqs(p_hwfn, p_ptt, p_vf);
393317b235c1SYuval Mintz break;
3934dacd88d6SYuval Mintz case CHANNEL_TLV_VPORT_UPDATE:
3935dacd88d6SYuval Mintz qed_iov_vf_mbx_vport_update(p_hwfn, p_ptt, p_vf);
3936dacd88d6SYuval Mintz break;
3937dacd88d6SYuval Mintz case CHANNEL_TLV_UCAST_FILTER:
3938dacd88d6SYuval Mintz qed_iov_vf_mbx_ucast_filter(p_hwfn, p_ptt, p_vf);
3939dacd88d6SYuval Mintz break;
39400b55e27dSYuval Mintz case CHANNEL_TLV_CLOSE:
39410b55e27dSYuval Mintz qed_iov_vf_mbx_close(p_hwfn, p_ptt, p_vf);
39420b55e27dSYuval Mintz break;
39430b55e27dSYuval Mintz case CHANNEL_TLV_INT_CLEANUP:
39440b55e27dSYuval Mintz qed_iov_vf_mbx_int_cleanup(p_hwfn, p_ptt, p_vf);
39450b55e27dSYuval Mintz break;
39460b55e27dSYuval Mintz case CHANNEL_TLV_RELEASE:
39470b55e27dSYuval Mintz qed_iov_vf_mbx_release(p_hwfn, p_ptt, p_vf);
39480b55e27dSYuval Mintz break;
3949eaf3c0c6SChopra, Manish case CHANNEL_TLV_UPDATE_TUNN_PARAM:
3950eaf3c0c6SChopra, Manish qed_iov_vf_mbx_update_tunn_param(p_hwfn, p_ptt, p_vf);
3951eaf3c0c6SChopra, Manish break;
3952477f2d14SRahul Verma case CHANNEL_TLV_COALESCE_UPDATE:
3953477f2d14SRahul Verma qed_iov_vf_pf_set_coalesce(p_hwfn, p_ptt, p_vf);
3954477f2d14SRahul Verma break;
3955bf5a94bfSRahul Verma case CHANNEL_TLV_COALESCE_READ:
3956bf5a94bfSRahul Verma qed_iov_vf_pf_get_coalesce(p_hwfn, p_ptt, p_vf);
3957bf5a94bfSRahul Verma break;
3958809c45a0SShahed Shaikh case CHANNEL_TLV_BULLETIN_UPDATE_MAC:
3959809c45a0SShahed Shaikh qed_iov_vf_pf_bulletin_update_mac(p_hwfn, p_ptt, p_vf);
3960809c45a0SShahed Shaikh break;
39611408cc1fSYuval Mintz }
39627eff82b0SYuval Mintz } else if (qed_iov_tlv_supported(mbx->first_tlv.tl.type)) {
39637eff82b0SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
39647eff82b0SYuval Mintz "VF [%02x] - considered malicious; Ignoring TLV [%04x]\n",
39657eff82b0SYuval Mintz p_vf->abs_vf_id, mbx->first_tlv.tl.type);
39667eff82b0SYuval Mintz
39677eff82b0SYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, p_vf,
39687eff82b0SYuval Mintz mbx->first_tlv.tl.type,
39697eff82b0SYuval Mintz sizeof(struct pfvf_def_resp_tlv),
39707eff82b0SYuval Mintz PFVF_STATUS_MALICIOUS);
397137bff2b9SYuval Mintz } else {
397237bff2b9SYuval Mintz /* unknown TLV - this may belong to a VF driver from the future
397337bff2b9SYuval Mintz * - a version written after this PF driver was written, which
397437bff2b9SYuval Mintz * supports features unknown as of yet. Too bad since we don't
397537bff2b9SYuval Mintz * support them. Or this may be because someone wrote a crappy
397637bff2b9SYuval Mintz * VF driver and is sending garbage over the channel.
397737bff2b9SYuval Mintz */
397854fdd80fSYuval Mintz DP_NOTICE(p_hwfn,
397954fdd80fSYuval Mintz "VF[%02x]: unknown TLV. type %04x length %04x padding %08x reply address %llu\n",
398054fdd80fSYuval Mintz p_vf->abs_vf_id,
398154fdd80fSYuval Mintz mbx->first_tlv.tl.type,
398254fdd80fSYuval Mintz mbx->first_tlv.tl.length,
398354fdd80fSYuval Mintz mbx->first_tlv.padding, mbx->first_tlv.reply_address);
398437bff2b9SYuval Mintz
398554fdd80fSYuval Mintz /* Try replying in case reply address matches the acquisition's
398654fdd80fSYuval Mintz * posted address.
398754fdd80fSYuval Mintz */
398854fdd80fSYuval Mintz if (p_vf->acquire.first_tlv.reply_address &&
398954fdd80fSYuval Mintz (mbx->first_tlv.reply_address ==
399054fdd80fSYuval Mintz p_vf->acquire.first_tlv.reply_address)) {
399154fdd80fSYuval Mintz qed_iov_prepare_resp(p_hwfn, p_ptt, p_vf,
399254fdd80fSYuval Mintz mbx->first_tlv.tl.type,
399354fdd80fSYuval Mintz sizeof(struct pfvf_def_resp_tlv),
399454fdd80fSYuval Mintz PFVF_STATUS_NOT_SUPPORTED);
399554fdd80fSYuval Mintz } else {
399637bff2b9SYuval Mintz DP_VERBOSE(p_hwfn,
399737bff2b9SYuval Mintz QED_MSG_IOV,
399854fdd80fSYuval Mintz "VF[%02x]: Can't respond to TLV - no valid reply address\n",
399954fdd80fSYuval Mintz p_vf->abs_vf_id);
400037bff2b9SYuval Mintz }
400137bff2b9SYuval Mintz }
400237bff2b9SYuval Mintz }
400337bff2b9SYuval Mintz
qed_iov_pf_get_pending_events(struct qed_hwfn * p_hwfn,u64 * events)4004bf774d14SYueHaibing static void qed_iov_pf_get_pending_events(struct qed_hwfn *p_hwfn, u64 *events)
400537bff2b9SYuval Mintz {
4006fd3c615aSMintz, Yuval int i;
400737bff2b9SYuval Mintz
4008fd3c615aSMintz, Yuval memset(events, 0, sizeof(u64) * QED_VF_ARRAY_LENGTH);
4009fd3c615aSMintz, Yuval
4010fd3c615aSMintz, Yuval qed_for_each_vf(p_hwfn, i) {
4011fd3c615aSMintz, Yuval struct qed_vf_info *p_vf;
4012fd3c615aSMintz, Yuval
4013fd3c615aSMintz, Yuval p_vf = &p_hwfn->pf_iov_info->vfs_array[i];
4014fd3c615aSMintz, Yuval if (p_vf->vf_mbx.b_pending_msg)
4015fd3c615aSMintz, Yuval events[i / 64] |= 1ULL << (i % 64);
401637bff2b9SYuval Mintz }
401737bff2b9SYuval Mintz }
401837bff2b9SYuval Mintz
qed_sriov_get_vf_from_absid(struct qed_hwfn * p_hwfn,u16 abs_vfid)40197eff82b0SYuval Mintz static struct qed_vf_info *qed_sriov_get_vf_from_absid(struct qed_hwfn *p_hwfn,
40207eff82b0SYuval Mintz u16 abs_vfid)
40217eff82b0SYuval Mintz {
40227eff82b0SYuval Mintz u8 min = (u8)p_hwfn->cdev->p_iov_info->first_vf_in_pf;
40237eff82b0SYuval Mintz
40247eff82b0SYuval Mintz if (!_qed_iov_pf_sanity_check(p_hwfn, (int)abs_vfid - min, false)) {
40257eff82b0SYuval Mintz DP_VERBOSE(p_hwfn,
40267eff82b0SYuval Mintz QED_MSG_IOV,
40277eff82b0SYuval Mintz "Got indication for VF [abs 0x%08x] that cannot be handled by PF\n",
40287eff82b0SYuval Mintz abs_vfid);
40297eff82b0SYuval Mintz return NULL;
40307eff82b0SYuval Mintz }
40317eff82b0SYuval Mintz
40327eff82b0SYuval Mintz return &p_hwfn->pf_iov_info->vfs_array[(u8)abs_vfid - min];
40337eff82b0SYuval Mintz }
40347eff82b0SYuval Mintz
qed_sriov_vfpf_msg(struct qed_hwfn * p_hwfn,u16 abs_vfid,struct regpair * vf_msg)403537bff2b9SYuval Mintz static int qed_sriov_vfpf_msg(struct qed_hwfn *p_hwfn,
403637bff2b9SYuval Mintz u16 abs_vfid, struct regpair *vf_msg)
403737bff2b9SYuval Mintz {
40387eff82b0SYuval Mintz struct qed_vf_info *p_vf = qed_sriov_get_vf_from_absid(p_hwfn,
403937bff2b9SYuval Mintz abs_vfid);
40407eff82b0SYuval Mintz
40417eff82b0SYuval Mintz if (!p_vf)
404237bff2b9SYuval Mintz return 0;
404337bff2b9SYuval Mintz
404437bff2b9SYuval Mintz /* List the physical address of the request so that handler
404537bff2b9SYuval Mintz * could later on copy the message from it.
404637bff2b9SYuval Mintz */
40475ab90341SAlexander Lobakin p_vf->vf_mbx.pending_req = HILO_64(vf_msg->hi, vf_msg->lo);
404837bff2b9SYuval Mintz
404937bff2b9SYuval Mintz /* Mark the event and schedule the workqueue */
4050fd3c615aSMintz, Yuval p_vf->vf_mbx.b_pending_msg = true;
405137bff2b9SYuval Mintz qed_schedule_iov(p_hwfn, QED_IOV_WQ_MSG_FLAG);
405237bff2b9SYuval Mintz
405337bff2b9SYuval Mintz return 0;
405437bff2b9SYuval Mintz }
405537bff2b9SYuval Mintz
qed_sriov_vfpf_malicious(struct qed_hwfn * p_hwfn,struct fw_err_data * p_data)4056fe40a830SPrabhakar Kushwaha void qed_sriov_vfpf_malicious(struct qed_hwfn *p_hwfn,
4057fe40a830SPrabhakar Kushwaha struct fw_err_data *p_data)
40587eff82b0SYuval Mintz {
40597eff82b0SYuval Mintz struct qed_vf_info *p_vf;
40607eff82b0SYuval Mintz
4061fe40a830SPrabhakar Kushwaha p_vf = qed_sriov_get_vf_from_absid(p_hwfn, qed_vf_from_entity_id
4062fe40a830SPrabhakar Kushwaha (p_data->entity_id));
40637eff82b0SYuval Mintz if (!p_vf)
40647eff82b0SYuval Mintz return;
40657eff82b0SYuval Mintz
4066e99a21cbSMintz, Yuval if (!p_vf->b_malicious) {
4067e99a21cbSMintz, Yuval DP_NOTICE(p_hwfn,
40687eff82b0SYuval Mintz "VF [%d] - Malicious behavior [%02x]\n",
40697eff82b0SYuval Mintz p_vf->abs_vf_id, p_data->err_id);
40707eff82b0SYuval Mintz
40717eff82b0SYuval Mintz p_vf->b_malicious = true;
4072e99a21cbSMintz, Yuval } else {
4073e99a21cbSMintz, Yuval DP_INFO(p_hwfn,
4074e99a21cbSMintz, Yuval "VF [%d] - Malicious behavior [%02x]\n",
4075e99a21cbSMintz, Yuval p_vf->abs_vf_id, p_data->err_id);
4076e99a21cbSMintz, Yuval }
40777eff82b0SYuval Mintz }
40787eff82b0SYuval Mintz
qed_sriov_eqe_event(struct qed_hwfn * p_hwfn,u8 opcode,__le16 echo,union event_ring_data * data,u8 fw_return_code)4079fe40a830SPrabhakar Kushwaha int qed_sriov_eqe_event(struct qed_hwfn *p_hwfn, u8 opcode, __le16 echo,
40806c9e80eaSMichal Kalderon union event_ring_data *data, u8 fw_return_code)
408137bff2b9SYuval Mintz {
408237bff2b9SYuval Mintz switch (opcode) {
408337bff2b9SYuval Mintz case COMMON_EVENT_VF_PF_CHANNEL:
408437bff2b9SYuval Mintz return qed_sriov_vfpf_msg(p_hwfn, le16_to_cpu(echo),
408537bff2b9SYuval Mintz &data->vf_pf_channel.msg_addr);
408637bff2b9SYuval Mintz default:
408737bff2b9SYuval Mintz DP_INFO(p_hwfn->cdev, "Unknown sriov eqe event 0x%02x\n",
408837bff2b9SYuval Mintz opcode);
408937bff2b9SYuval Mintz return -EINVAL;
409037bff2b9SYuval Mintz }
409137bff2b9SYuval Mintz }
409237bff2b9SYuval Mintz
qed_iov_get_next_active_vf(struct qed_hwfn * p_hwfn,u16 rel_vf_id)409332a47e72SYuval Mintz u16 qed_iov_get_next_active_vf(struct qed_hwfn *p_hwfn, u16 rel_vf_id)
409432a47e72SYuval Mintz {
409532a47e72SYuval Mintz struct qed_hw_sriov_info *p_iov = p_hwfn->cdev->p_iov_info;
409632a47e72SYuval Mintz u16 i;
409732a47e72SYuval Mintz
409832a47e72SYuval Mintz if (!p_iov)
409932a47e72SYuval Mintz goto out;
410032a47e72SYuval Mintz
410132a47e72SYuval Mintz for (i = rel_vf_id; i < p_iov->total_vfs; i++)
41027eff82b0SYuval Mintz if (qed_iov_is_valid_vfid(p_hwfn, rel_vf_id, true, false))
410332a47e72SYuval Mintz return i;
410432a47e72SYuval Mintz
410532a47e72SYuval Mintz out:
410632a47e72SYuval Mintz return MAX_NUM_VFS;
410732a47e72SYuval Mintz }
410837bff2b9SYuval Mintz
qed_iov_copy_vf_msg(struct qed_hwfn * p_hwfn,struct qed_ptt * ptt,int vfid)410937bff2b9SYuval Mintz static int qed_iov_copy_vf_msg(struct qed_hwfn *p_hwfn, struct qed_ptt *ptt,
411037bff2b9SYuval Mintz int vfid)
411137bff2b9SYuval Mintz {
411237bff2b9SYuval Mintz struct qed_dmae_params params;
411337bff2b9SYuval Mintz struct qed_vf_info *vf_info;
411437bff2b9SYuval Mintz
411537bff2b9SYuval Mintz vf_info = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
411637bff2b9SYuval Mintz if (!vf_info)
411737bff2b9SYuval Mintz return -EINVAL;
411837bff2b9SYuval Mintz
4119804c5702SMichal Kalderon memset(¶ms, 0, sizeof(params));
4120804c5702SMichal Kalderon SET_FIELD(params.flags, QED_DMAE_PARAMS_SRC_VF_VALID, 0x1);
4121804c5702SMichal Kalderon SET_FIELD(params.flags, QED_DMAE_PARAMS_COMPLETION_DST, 0x1);
412237bff2b9SYuval Mintz params.src_vfid = vf_info->abs_vf_id;
412337bff2b9SYuval Mintz
412437bff2b9SYuval Mintz if (qed_dmae_host2host(p_hwfn, ptt,
412537bff2b9SYuval Mintz vf_info->vf_mbx.pending_req,
412637bff2b9SYuval Mintz vf_info->vf_mbx.req_phys,
412737bff2b9SYuval Mintz sizeof(union vfpf_tlvs) / 4, ¶ms)) {
412837bff2b9SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_IOV,
412937bff2b9SYuval Mintz "Failed to copy message from VF 0x%02x\n", vfid);
413037bff2b9SYuval Mintz
413137bff2b9SYuval Mintz return -EIO;
413237bff2b9SYuval Mintz }
413337bff2b9SYuval Mintz
413437bff2b9SYuval Mintz return 0;
413537bff2b9SYuval Mintz }
413637bff2b9SYuval Mintz
qed_iov_bulletin_set_forced_mac(struct qed_hwfn * p_hwfn,u8 * mac,int vfid)4137eff16960SYuval Mintz static void qed_iov_bulletin_set_forced_mac(struct qed_hwfn *p_hwfn,
4138eff16960SYuval Mintz u8 *mac, int vfid)
4139eff16960SYuval Mintz {
4140eff16960SYuval Mintz struct qed_vf_info *vf_info;
4141eff16960SYuval Mintz u64 feature;
4142eff16960SYuval Mintz
4143eff16960SYuval Mintz vf_info = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
4144eff16960SYuval Mintz if (!vf_info) {
4145eff16960SYuval Mintz DP_NOTICE(p_hwfn->cdev,
4146eff16960SYuval Mintz "Can not set forced MAC, invalid vfid [%d]\n", vfid);
4147eff16960SYuval Mintz return;
4148eff16960SYuval Mintz }
4149eff16960SYuval Mintz
41507eff82b0SYuval Mintz if (vf_info->b_malicious) {
41517eff82b0SYuval Mintz DP_NOTICE(p_hwfn->cdev,
41527eff82b0SYuval Mintz "Can't set forced MAC to malicious VF [%d]\n", vfid);
41537eff82b0SYuval Mintz return;
41547eff82b0SYuval Mintz }
41557eff82b0SYuval Mintz
41567425d822SShahed Shaikh if (vf_info->p_vf_info.is_trusted_configured) {
41577425d822SShahed Shaikh feature = BIT(VFPF_BULLETIN_MAC_ADDR);
41587425d822SShahed Shaikh /* Trust mode will disable Forced MAC */
41597425d822SShahed Shaikh vf_info->bulletin.p_virt->valid_bitmap &=
41607425d822SShahed Shaikh ~BIT(MAC_ADDR_FORCED);
41617425d822SShahed Shaikh } else {
41627425d822SShahed Shaikh feature = BIT(MAC_ADDR_FORCED);
41637425d822SShahed Shaikh /* Forced MAC will disable MAC_ADDR */
41647425d822SShahed Shaikh vf_info->bulletin.p_virt->valid_bitmap &=
41657425d822SShahed Shaikh ~BIT(VFPF_BULLETIN_MAC_ADDR);
41667425d822SShahed Shaikh }
41677425d822SShahed Shaikh
4168eff16960SYuval Mintz memcpy(vf_info->bulletin.p_virt->mac, mac, ETH_ALEN);
4169eff16960SYuval Mintz
4170eff16960SYuval Mintz vf_info->bulletin.p_virt->valid_bitmap |= feature;
4171eff16960SYuval Mintz
4172eff16960SYuval Mintz qed_iov_configure_vport_forced(p_hwfn, vf_info, feature);
4173eff16960SYuval Mintz }
4174eff16960SYuval Mintz
qed_iov_bulletin_set_mac(struct qed_hwfn * p_hwfn,u8 * mac,int vfid)41757425d822SShahed Shaikh static int qed_iov_bulletin_set_mac(struct qed_hwfn *p_hwfn, u8 *mac, int vfid)
41767425d822SShahed Shaikh {
41777425d822SShahed Shaikh struct qed_vf_info *vf_info;
41787425d822SShahed Shaikh u64 feature;
41797425d822SShahed Shaikh
41807425d822SShahed Shaikh vf_info = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
41817425d822SShahed Shaikh if (!vf_info) {
41827425d822SShahed Shaikh DP_NOTICE(p_hwfn->cdev, "Can not set MAC, invalid vfid [%d]\n",
41837425d822SShahed Shaikh vfid);
41847425d822SShahed Shaikh return -EINVAL;
41857425d822SShahed Shaikh }
41867425d822SShahed Shaikh
41877425d822SShahed Shaikh if (vf_info->b_malicious) {
41887425d822SShahed Shaikh DP_NOTICE(p_hwfn->cdev, "Can't set MAC to malicious VF [%d]\n",
41897425d822SShahed Shaikh vfid);
41907425d822SShahed Shaikh return -EINVAL;
41917425d822SShahed Shaikh }
41927425d822SShahed Shaikh
41937425d822SShahed Shaikh if (vf_info->bulletin.p_virt->valid_bitmap & BIT(MAC_ADDR_FORCED)) {
41947425d822SShahed Shaikh DP_VERBOSE(p_hwfn, QED_MSG_IOV,
41957425d822SShahed Shaikh "Can not set MAC, Forced MAC is configured\n");
41967425d822SShahed Shaikh return -EINVAL;
41977425d822SShahed Shaikh }
41987425d822SShahed Shaikh
41997425d822SShahed Shaikh feature = BIT(VFPF_BULLETIN_MAC_ADDR);
42007425d822SShahed Shaikh ether_addr_copy(vf_info->bulletin.p_virt->mac, mac);
42017425d822SShahed Shaikh
42027425d822SShahed Shaikh vf_info->bulletin.p_virt->valid_bitmap |= feature;
42037425d822SShahed Shaikh
42047425d822SShahed Shaikh if (vf_info->p_vf_info.is_trusted_configured)
42057425d822SShahed Shaikh qed_iov_configure_vport_forced(p_hwfn, vf_info, feature);
42067425d822SShahed Shaikh
42077425d822SShahed Shaikh return 0;
42087425d822SShahed Shaikh }
42097425d822SShahed Shaikh
qed_iov_bulletin_set_forced_vlan(struct qed_hwfn * p_hwfn,u16 pvid,int vfid)4210ba56947aSBaoyou Xie static void qed_iov_bulletin_set_forced_vlan(struct qed_hwfn *p_hwfn,
421108feecd7SYuval Mintz u16 pvid, int vfid)
421208feecd7SYuval Mintz {
421308feecd7SYuval Mintz struct qed_vf_info *vf_info;
421408feecd7SYuval Mintz u64 feature;
421508feecd7SYuval Mintz
421608feecd7SYuval Mintz vf_info = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
421708feecd7SYuval Mintz if (!vf_info) {
421808feecd7SYuval Mintz DP_NOTICE(p_hwfn->cdev,
421908feecd7SYuval Mintz "Can not set forced MAC, invalid vfid [%d]\n", vfid);
422008feecd7SYuval Mintz return;
422108feecd7SYuval Mintz }
422208feecd7SYuval Mintz
42237eff82b0SYuval Mintz if (vf_info->b_malicious) {
42247eff82b0SYuval Mintz DP_NOTICE(p_hwfn->cdev,
42257eff82b0SYuval Mintz "Can't set forced vlan to malicious VF [%d]\n", vfid);
42267eff82b0SYuval Mintz return;
42277eff82b0SYuval Mintz }
42287eff82b0SYuval Mintz
422908feecd7SYuval Mintz feature = 1 << VLAN_ADDR_FORCED;
423008feecd7SYuval Mintz vf_info->bulletin.p_virt->pvid = pvid;
423108feecd7SYuval Mintz if (pvid)
423208feecd7SYuval Mintz vf_info->bulletin.p_virt->valid_bitmap |= feature;
423308feecd7SYuval Mintz else
423408feecd7SYuval Mintz vf_info->bulletin.p_virt->valid_bitmap &= ~feature;
423508feecd7SYuval Mintz
423608feecd7SYuval Mintz qed_iov_configure_vport_forced(p_hwfn, vf_info, feature);
423708feecd7SYuval Mintz }
423808feecd7SYuval Mintz
qed_iov_bulletin_set_udp_ports(struct qed_hwfn * p_hwfn,int vfid,u16 vxlan_port,u16 geneve_port)423997379f15SChopra, Manish void qed_iov_bulletin_set_udp_ports(struct qed_hwfn *p_hwfn,
424097379f15SChopra, Manish int vfid, u16 vxlan_port, u16 geneve_port)
424197379f15SChopra, Manish {
424297379f15SChopra, Manish struct qed_vf_info *vf_info;
424397379f15SChopra, Manish
424497379f15SChopra, Manish vf_info = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
424597379f15SChopra, Manish if (!vf_info) {
424697379f15SChopra, Manish DP_NOTICE(p_hwfn->cdev,
424797379f15SChopra, Manish "Can not set udp ports, invalid vfid [%d]\n", vfid);
424897379f15SChopra, Manish return;
424997379f15SChopra, Manish }
425097379f15SChopra, Manish
425197379f15SChopra, Manish if (vf_info->b_malicious) {
425297379f15SChopra, Manish DP_VERBOSE(p_hwfn, QED_MSG_IOV,
425397379f15SChopra, Manish "Can not set udp ports to malicious VF [%d]\n",
425497379f15SChopra, Manish vfid);
425597379f15SChopra, Manish return;
425697379f15SChopra, Manish }
425797379f15SChopra, Manish
425897379f15SChopra, Manish vf_info->bulletin.p_virt->vxlan_udp_port = vxlan_port;
425997379f15SChopra, Manish vf_info->bulletin.p_virt->geneve_udp_port = geneve_port;
426097379f15SChopra, Manish }
426197379f15SChopra, Manish
qed_iov_vf_has_vport_instance(struct qed_hwfn * p_hwfn,int vfid)42626ddc7608SYuval Mintz static bool qed_iov_vf_has_vport_instance(struct qed_hwfn *p_hwfn, int vfid)
42636ddc7608SYuval Mintz {
42646ddc7608SYuval Mintz struct qed_vf_info *p_vf_info;
42656ddc7608SYuval Mintz
42666ddc7608SYuval Mintz p_vf_info = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
42676ddc7608SYuval Mintz if (!p_vf_info)
42686ddc7608SYuval Mintz return false;
42696ddc7608SYuval Mintz
42706ddc7608SYuval Mintz return !!p_vf_info->vport_instance;
42716ddc7608SYuval Mintz }
42726ddc7608SYuval Mintz
qed_iov_is_vf_stopped(struct qed_hwfn * p_hwfn,int vfid)4273ba56947aSBaoyou Xie static bool qed_iov_is_vf_stopped(struct qed_hwfn *p_hwfn, int vfid)
42740b55e27dSYuval Mintz {
42750b55e27dSYuval Mintz struct qed_vf_info *p_vf_info;
42760b55e27dSYuval Mintz
42770b55e27dSYuval Mintz p_vf_info = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
42780b55e27dSYuval Mintz if (!p_vf_info)
42790b55e27dSYuval Mintz return true;
42800b55e27dSYuval Mintz
42810b55e27dSYuval Mintz return p_vf_info->state == VF_STOPPED;
42820b55e27dSYuval Mintz }
42830b55e27dSYuval Mintz
qed_iov_spoofchk_get(struct qed_hwfn * p_hwfn,int vfid)428473390ac9SYuval Mintz static bool qed_iov_spoofchk_get(struct qed_hwfn *p_hwfn, int vfid)
428573390ac9SYuval Mintz {
428673390ac9SYuval Mintz struct qed_vf_info *vf_info;
428773390ac9SYuval Mintz
428873390ac9SYuval Mintz vf_info = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
428973390ac9SYuval Mintz if (!vf_info)
429073390ac9SYuval Mintz return false;
429173390ac9SYuval Mintz
429273390ac9SYuval Mintz return vf_info->spoof_chk;
429373390ac9SYuval Mintz }
429473390ac9SYuval Mintz
qed_iov_spoofchk_set(struct qed_hwfn * p_hwfn,int vfid,bool val)4295ba56947aSBaoyou Xie static int qed_iov_spoofchk_set(struct qed_hwfn *p_hwfn, int vfid, bool val)
42966ddc7608SYuval Mintz {
42976ddc7608SYuval Mintz struct qed_vf_info *vf;
42986ddc7608SYuval Mintz int rc = -EINVAL;
42996ddc7608SYuval Mintz
43006ddc7608SYuval Mintz if (!qed_iov_pf_sanity_check(p_hwfn, vfid)) {
43016ddc7608SYuval Mintz DP_NOTICE(p_hwfn,
43026ddc7608SYuval Mintz "SR-IOV sanity check failed, can't set spoofchk\n");
43036ddc7608SYuval Mintz goto out;
43046ddc7608SYuval Mintz }
43056ddc7608SYuval Mintz
43066ddc7608SYuval Mintz vf = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
43076ddc7608SYuval Mintz if (!vf)
43086ddc7608SYuval Mintz goto out;
43096ddc7608SYuval Mintz
43106ddc7608SYuval Mintz if (!qed_iov_vf_has_vport_instance(p_hwfn, vfid)) {
43116ddc7608SYuval Mintz /* After VF VPORT start PF will configure spoof check */
43126ddc7608SYuval Mintz vf->req_spoofchk_val = val;
43136ddc7608SYuval Mintz rc = 0;
43146ddc7608SYuval Mintz goto out;
43156ddc7608SYuval Mintz }
43166ddc7608SYuval Mintz
43176ddc7608SYuval Mintz rc = __qed_iov_spoofchk_set(p_hwfn, vf, val);
43186ddc7608SYuval Mintz
43196ddc7608SYuval Mintz out:
43206ddc7608SYuval Mintz return rc;
43216ddc7608SYuval Mintz }
43226ddc7608SYuval Mintz
qed_iov_bulletin_get_mac(struct qed_hwfn * p_hwfn,u16 rel_vf_id)43237425d822SShahed Shaikh static u8 *qed_iov_bulletin_get_mac(struct qed_hwfn *p_hwfn, u16 rel_vf_id)
43247425d822SShahed Shaikh {
43257425d822SShahed Shaikh struct qed_vf_info *p_vf;
43267425d822SShahed Shaikh
43277425d822SShahed Shaikh p_vf = qed_iov_get_vf_info(p_hwfn, rel_vf_id, true);
43287425d822SShahed Shaikh if (!p_vf || !p_vf->bulletin.p_virt)
43297425d822SShahed Shaikh return NULL;
43307425d822SShahed Shaikh
43317425d822SShahed Shaikh if (!(p_vf->bulletin.p_virt->valid_bitmap &
43327425d822SShahed Shaikh BIT(VFPF_BULLETIN_MAC_ADDR)))
43337425d822SShahed Shaikh return NULL;
43347425d822SShahed Shaikh
43357425d822SShahed Shaikh return p_vf->bulletin.p_virt->mac;
43367425d822SShahed Shaikh }
43377425d822SShahed Shaikh
qed_iov_bulletin_get_forced_mac(struct qed_hwfn * p_hwfn,u16 rel_vf_id)4338eff16960SYuval Mintz static u8 *qed_iov_bulletin_get_forced_mac(struct qed_hwfn *p_hwfn,
4339eff16960SYuval Mintz u16 rel_vf_id)
4340eff16960SYuval Mintz {
4341eff16960SYuval Mintz struct qed_vf_info *p_vf;
4342eff16960SYuval Mintz
4343eff16960SYuval Mintz p_vf = qed_iov_get_vf_info(p_hwfn, rel_vf_id, true);
4344eff16960SYuval Mintz if (!p_vf || !p_vf->bulletin.p_virt)
4345eff16960SYuval Mintz return NULL;
4346eff16960SYuval Mintz
43471a635e48SYuval Mintz if (!(p_vf->bulletin.p_virt->valid_bitmap & BIT(MAC_ADDR_FORCED)))
4348eff16960SYuval Mintz return NULL;
4349eff16960SYuval Mintz
4350eff16960SYuval Mintz return p_vf->bulletin.p_virt->mac;
4351eff16960SYuval Mintz }
4352eff16960SYuval Mintz
4353ba56947aSBaoyou Xie static u16
qed_iov_bulletin_get_forced_vlan(struct qed_hwfn * p_hwfn,u16 rel_vf_id)4354ba56947aSBaoyou Xie qed_iov_bulletin_get_forced_vlan(struct qed_hwfn *p_hwfn, u16 rel_vf_id)
435508feecd7SYuval Mintz {
435608feecd7SYuval Mintz struct qed_vf_info *p_vf;
435708feecd7SYuval Mintz
435808feecd7SYuval Mintz p_vf = qed_iov_get_vf_info(p_hwfn, rel_vf_id, true);
435908feecd7SYuval Mintz if (!p_vf || !p_vf->bulletin.p_virt)
436008feecd7SYuval Mintz return 0;
436108feecd7SYuval Mintz
43621a635e48SYuval Mintz if (!(p_vf->bulletin.p_virt->valid_bitmap & BIT(VLAN_ADDR_FORCED)))
436308feecd7SYuval Mintz return 0;
436408feecd7SYuval Mintz
436508feecd7SYuval Mintz return p_vf->bulletin.p_virt->pvid;
436608feecd7SYuval Mintz }
436708feecd7SYuval Mintz
qed_iov_configure_tx_rate(struct qed_hwfn * p_hwfn,struct qed_ptt * p_ptt,int vfid,int val)4368733def6aSYuval Mintz static int qed_iov_configure_tx_rate(struct qed_hwfn *p_hwfn,
4369733def6aSYuval Mintz struct qed_ptt *p_ptt, int vfid, int val)
4370733def6aSYuval Mintz {
4371733def6aSYuval Mintz struct qed_vf_info *vf;
4372733def6aSYuval Mintz u8 abs_vp_id = 0;
437392fae6fbSMichal Kalderon u16 rl_id;
4374733def6aSYuval Mintz int rc;
4375733def6aSYuval Mintz
4376733def6aSYuval Mintz vf = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
4377733def6aSYuval Mintz if (!vf)
4378733def6aSYuval Mintz return -EINVAL;
4379733def6aSYuval Mintz
4380733def6aSYuval Mintz rc = qed_fw_vport(p_hwfn, vf->vport_id, &abs_vp_id);
4381733def6aSYuval Mintz if (rc)
4382733def6aSYuval Mintz return rc;
4383733def6aSYuval Mintz
438492fae6fbSMichal Kalderon rl_id = abs_vp_id; /* The "rl_id" is set as the "vport_id" */
4385fe40a830SPrabhakar Kushwaha return qed_init_global_rl(p_hwfn, p_ptt, rl_id, (u32)val,
4386fe40a830SPrabhakar Kushwaha QM_RL_TYPE_NORMAL);
4387733def6aSYuval Mintz }
4388733def6aSYuval Mintz
4389ba56947aSBaoyou Xie static int
qed_iov_configure_min_tx_rate(struct qed_dev * cdev,int vfid,u32 rate)4390ba56947aSBaoyou Xie qed_iov_configure_min_tx_rate(struct qed_dev *cdev, int vfid, u32 rate)
4391733def6aSYuval Mintz {
4392733def6aSYuval Mintz struct qed_vf_info *vf;
4393733def6aSYuval Mintz u8 vport_id;
4394733def6aSYuval Mintz int i;
4395733def6aSYuval Mintz
4396733def6aSYuval Mintz for_each_hwfn(cdev, i) {
4397733def6aSYuval Mintz struct qed_hwfn *p_hwfn = &cdev->hwfns[i];
4398733def6aSYuval Mintz
4399733def6aSYuval Mintz if (!qed_iov_pf_sanity_check(p_hwfn, vfid)) {
4400733def6aSYuval Mintz DP_NOTICE(p_hwfn,
4401733def6aSYuval Mintz "SR-IOV sanity check failed, can't set min rate\n");
4402733def6aSYuval Mintz return -EINVAL;
4403733def6aSYuval Mintz }
4404733def6aSYuval Mintz }
4405733def6aSYuval Mintz
4406733def6aSYuval Mintz vf = qed_iov_get_vf_info(QED_LEADING_HWFN(cdev), (u16)vfid, true);
4407*25143b6aSDaniil Tatianin if (!vf)
4408*25143b6aSDaniil Tatianin return -EINVAL;
4409*25143b6aSDaniil Tatianin
4410733def6aSYuval Mintz vport_id = vf->vport_id;
4411733def6aSYuval Mintz
4412733def6aSYuval Mintz return qed_configure_vport_wfq(cdev, vport_id, rate);
4413733def6aSYuval Mintz }
4414733def6aSYuval Mintz
qed_iov_get_vf_min_rate(struct qed_hwfn * p_hwfn,int vfid)441573390ac9SYuval Mintz static int qed_iov_get_vf_min_rate(struct qed_hwfn *p_hwfn, int vfid)
441673390ac9SYuval Mintz {
441773390ac9SYuval Mintz struct qed_wfq_data *vf_vp_wfq;
441873390ac9SYuval Mintz struct qed_vf_info *vf_info;
441973390ac9SYuval Mintz
442073390ac9SYuval Mintz vf_info = qed_iov_get_vf_info(p_hwfn, (u16)vfid, true);
442173390ac9SYuval Mintz if (!vf_info)
442273390ac9SYuval Mintz return 0;
442373390ac9SYuval Mintz
442473390ac9SYuval Mintz vf_vp_wfq = &p_hwfn->qm_info.wfq_data[vf_info->vport_id];
442573390ac9SYuval Mintz
442673390ac9SYuval Mintz if (vf_vp_wfq->configured)
442773390ac9SYuval Mintz return vf_vp_wfq->min_speed;
442873390ac9SYuval Mintz else
442973390ac9SYuval Mintz return 0;
443073390ac9SYuval Mintz }
443173390ac9SYuval Mintz
443237bff2b9SYuval Mintz /**
443337bff2b9SYuval Mintz * qed_schedule_iov - schedules IOV task for VF and PF
443437bff2b9SYuval Mintz * @hwfn: hardware function pointer
443537bff2b9SYuval Mintz * @flag: IOV flag for VF/PF
443637bff2b9SYuval Mintz */
qed_schedule_iov(struct qed_hwfn * hwfn,enum qed_iov_wq_flag flag)443737bff2b9SYuval Mintz void qed_schedule_iov(struct qed_hwfn *hwfn, enum qed_iov_wq_flag flag)
443837bff2b9SYuval Mintz {
4439fe40a830SPrabhakar Kushwaha /* Memory barrier for setting atomic bit */
444037bff2b9SYuval Mintz smp_mb__before_atomic();
444137bff2b9SYuval Mintz set_bit(flag, &hwfn->iov_task_flags);
4442fe40a830SPrabhakar Kushwaha /* Memory barrier after setting atomic bit */
444337bff2b9SYuval Mintz smp_mb__after_atomic();
444437bff2b9SYuval Mintz DP_VERBOSE(hwfn, QED_MSG_IOV, "Scheduling iov task [Flag: %d]\n", flag);
444537bff2b9SYuval Mintz queue_delayed_work(hwfn->iov_wq, &hwfn->iov_task, 0);
444637bff2b9SYuval Mintz }
444737bff2b9SYuval Mintz
qed_vf_start_iov_wq(struct qed_dev * cdev)44481408cc1fSYuval Mintz void qed_vf_start_iov_wq(struct qed_dev *cdev)
44491408cc1fSYuval Mintz {
44501408cc1fSYuval Mintz int i;
44511408cc1fSYuval Mintz
44521408cc1fSYuval Mintz for_each_hwfn(cdev, i)
44531408cc1fSYuval Mintz queue_delayed_work(cdev->hwfns[i].iov_wq,
44541408cc1fSYuval Mintz &cdev->hwfns[i].iov_task, 0);
44551408cc1fSYuval Mintz }
44561408cc1fSYuval Mintz
qed_sriov_disable(struct qed_dev * cdev,bool pci_enabled)44570b55e27dSYuval Mintz int qed_sriov_disable(struct qed_dev *cdev, bool pci_enabled)
44580b55e27dSYuval Mintz {
44590b55e27dSYuval Mintz int i, j;
44600b55e27dSYuval Mintz
44610b55e27dSYuval Mintz for_each_hwfn(cdev, i)
44620b55e27dSYuval Mintz if (cdev->hwfns[i].iov_wq)
44630b55e27dSYuval Mintz flush_workqueue(cdev->hwfns[i].iov_wq);
44640b55e27dSYuval Mintz
44650b55e27dSYuval Mintz /* Mark VFs for disablement */
44660b55e27dSYuval Mintz qed_iov_set_vfs_to_disable(cdev, true);
44670b55e27dSYuval Mintz
44680b55e27dSYuval Mintz if (cdev->p_iov_info && cdev->p_iov_info->num_vfs && pci_enabled)
44690b55e27dSYuval Mintz pci_disable_sriov(cdev->pdev);
44700b55e27dSYuval Mintz
447164515dc8STomer Tayar if (cdev->recov_in_prog) {
447264515dc8STomer Tayar DP_VERBOSE(cdev,
447364515dc8STomer Tayar QED_MSG_IOV,
447464515dc8STomer Tayar "Skip SRIOV disable operations in the device since a recovery is in progress\n");
447564515dc8STomer Tayar goto out;
447664515dc8STomer Tayar }
447764515dc8STomer Tayar
44780b55e27dSYuval Mintz for_each_hwfn(cdev, i) {
44790b55e27dSYuval Mintz struct qed_hwfn *hwfn = &cdev->hwfns[i];
44800b55e27dSYuval Mintz struct qed_ptt *ptt = qed_ptt_acquire(hwfn);
44810b55e27dSYuval Mintz
44820b55e27dSYuval Mintz /* Failure to acquire the ptt in 100g creates an odd error
44830b55e27dSYuval Mintz * where the first engine has already relased IOV.
44840b55e27dSYuval Mintz */
44850b55e27dSYuval Mintz if (!ptt) {
44860b55e27dSYuval Mintz DP_ERR(hwfn, "Failed to acquire ptt\n");
44870b55e27dSYuval Mintz return -EBUSY;
44880b55e27dSYuval Mintz }
44890b55e27dSYuval Mintz
4490733def6aSYuval Mintz /* Clean WFQ db and configure equal weight for all vports */
4491733def6aSYuval Mintz qed_clean_wfq_db(hwfn, ptt);
4492733def6aSYuval Mintz
44930b55e27dSYuval Mintz qed_for_each_vf(hwfn, j) {
44940b55e27dSYuval Mintz int k;
44950b55e27dSYuval Mintz
44967eff82b0SYuval Mintz if (!qed_iov_is_valid_vfid(hwfn, j, true, false))
44970b55e27dSYuval Mintz continue;
44980b55e27dSYuval Mintz
44990b55e27dSYuval Mintz /* Wait until VF is disabled before releasing */
45000b55e27dSYuval Mintz for (k = 0; k < 100; k++) {
45010b55e27dSYuval Mintz if (!qed_iov_is_vf_stopped(hwfn, j))
45020b55e27dSYuval Mintz msleep(20);
45030b55e27dSYuval Mintz else
45040b55e27dSYuval Mintz break;
45050b55e27dSYuval Mintz }
45060b55e27dSYuval Mintz
45070b55e27dSYuval Mintz if (k < 100)
45080b55e27dSYuval Mintz qed_iov_release_hw_for_vf(&cdev->hwfns[i],
45090b55e27dSYuval Mintz ptt, j);
45100b55e27dSYuval Mintz else
45110b55e27dSYuval Mintz DP_ERR(hwfn,
45120b55e27dSYuval Mintz "Timeout waiting for VF's FLR to end\n");
45130b55e27dSYuval Mintz }
45140b55e27dSYuval Mintz
45150b55e27dSYuval Mintz qed_ptt_release(hwfn, ptt);
45160b55e27dSYuval Mintz }
451764515dc8STomer Tayar out:
45180b55e27dSYuval Mintz qed_iov_set_vfs_to_disable(cdev, false);
45190b55e27dSYuval Mintz
45200b55e27dSYuval Mintz return 0;
45210b55e27dSYuval Mintz }
45220b55e27dSYuval Mintz
qed_sriov_enable_qid_config(struct qed_hwfn * hwfn,u16 vfid,struct qed_iov_vf_init_params * params)45233da7a37aSMintz, Yuval static void qed_sriov_enable_qid_config(struct qed_hwfn *hwfn,
45243da7a37aSMintz, Yuval u16 vfid,
45253da7a37aSMintz, Yuval struct qed_iov_vf_init_params *params)
45263da7a37aSMintz, Yuval {
45273da7a37aSMintz, Yuval u16 base, i;
45283da7a37aSMintz, Yuval
45293da7a37aSMintz, Yuval /* Since we have an equal resource distribution per-VF, and we assume
45303da7a37aSMintz, Yuval * PF has acquired the QED_PF_L2_QUE first queues, we start setting
45313da7a37aSMintz, Yuval * sequentially from there.
45323da7a37aSMintz, Yuval */
45333da7a37aSMintz, Yuval base = FEAT_NUM(hwfn, QED_PF_L2_QUE) + vfid * params->num_queues;
45343da7a37aSMintz, Yuval
45353da7a37aSMintz, Yuval params->rel_vf_id = vfid;
45363da7a37aSMintz, Yuval for (i = 0; i < params->num_queues; i++) {
45373da7a37aSMintz, Yuval params->req_rx_queue[i] = base + i;
45383da7a37aSMintz, Yuval params->req_tx_queue[i] = base + i;
45393da7a37aSMintz, Yuval }
45403da7a37aSMintz, Yuval }
45413da7a37aSMintz, Yuval
qed_sriov_enable(struct qed_dev * cdev,int num)45420b55e27dSYuval Mintz static int qed_sriov_enable(struct qed_dev *cdev, int num)
45430b55e27dSYuval Mintz {
45443da7a37aSMintz, Yuval struct qed_iov_vf_init_params params;
4545538f8d00SSudarsana Reddy Kalluru struct qed_hwfn *hwfn;
4546538f8d00SSudarsana Reddy Kalluru struct qed_ptt *ptt;
45470b55e27dSYuval Mintz int i, j, rc;
45480b55e27dSYuval Mintz
45490b55e27dSYuval Mintz if (num >= RESC_NUM(&cdev->hwfns[0], QED_VPORT)) {
45500b55e27dSYuval Mintz DP_NOTICE(cdev, "Can start at most %d VFs\n",
45510b55e27dSYuval Mintz RESC_NUM(&cdev->hwfns[0], QED_VPORT) - 1);
45520b55e27dSYuval Mintz return -EINVAL;
45530b55e27dSYuval Mintz }
45540b55e27dSYuval Mintz
45553da7a37aSMintz, Yuval memset(¶ms, 0, sizeof(params));
45563da7a37aSMintz, Yuval
45570b55e27dSYuval Mintz /* Initialize HW for VF access */
45580b55e27dSYuval Mintz for_each_hwfn(cdev, j) {
4559538f8d00SSudarsana Reddy Kalluru hwfn = &cdev->hwfns[j];
4560538f8d00SSudarsana Reddy Kalluru ptt = qed_ptt_acquire(hwfn);
45615a1f965aSMintz, Yuval
45625a1f965aSMintz, Yuval /* Make sure not to use more than 16 queues per VF */
45633da7a37aSMintz, Yuval params.num_queues = min_t(int,
45643da7a37aSMintz, Yuval FEAT_NUM(hwfn, QED_VF_L2_QUE) / num,
45653da7a37aSMintz, Yuval 16);
45660b55e27dSYuval Mintz
45670b55e27dSYuval Mintz if (!ptt) {
45680b55e27dSYuval Mintz DP_ERR(hwfn, "Failed to acquire ptt\n");
45690b55e27dSYuval Mintz rc = -EBUSY;
45700b55e27dSYuval Mintz goto err;
45710b55e27dSYuval Mintz }
45720b55e27dSYuval Mintz
45730b55e27dSYuval Mintz for (i = 0; i < num; i++) {
45747eff82b0SYuval Mintz if (!qed_iov_is_valid_vfid(hwfn, i, false, true))
45750b55e27dSYuval Mintz continue;
45760b55e27dSYuval Mintz
45773da7a37aSMintz, Yuval qed_sriov_enable_qid_config(hwfn, i, ¶ms);
45783da7a37aSMintz, Yuval rc = qed_iov_init_hw_for_vf(hwfn, ptt, ¶ms);
45790b55e27dSYuval Mintz if (rc) {
45800b55e27dSYuval Mintz DP_ERR(cdev, "Failed to enable VF[%d]\n", i);
45810b55e27dSYuval Mintz qed_ptt_release(hwfn, ptt);
45820b55e27dSYuval Mintz goto err;
45830b55e27dSYuval Mintz }
45840b55e27dSYuval Mintz }
45850b55e27dSYuval Mintz
45860b55e27dSYuval Mintz qed_ptt_release(hwfn, ptt);
45870b55e27dSYuval Mintz }
45880b55e27dSYuval Mintz
45890b55e27dSYuval Mintz /* Enable SRIOV PCIe functions */
45900b55e27dSYuval Mintz rc = pci_enable_sriov(cdev->pdev, num);
45910b55e27dSYuval Mintz if (rc) {
45920b55e27dSYuval Mintz DP_ERR(cdev, "Failed to enable sriov [%d]\n", rc);
45930b55e27dSYuval Mintz goto err;
45940b55e27dSYuval Mintz }
45950b55e27dSYuval Mintz
4596538f8d00SSudarsana Reddy Kalluru hwfn = QED_LEADING_HWFN(cdev);
4597538f8d00SSudarsana Reddy Kalluru ptt = qed_ptt_acquire(hwfn);
4598538f8d00SSudarsana Reddy Kalluru if (!ptt) {
4599538f8d00SSudarsana Reddy Kalluru DP_ERR(hwfn, "Failed to acquire ptt\n");
4600538f8d00SSudarsana Reddy Kalluru rc = -EBUSY;
4601538f8d00SSudarsana Reddy Kalluru goto err;
4602538f8d00SSudarsana Reddy Kalluru }
4603538f8d00SSudarsana Reddy Kalluru
4604538f8d00SSudarsana Reddy Kalluru rc = qed_mcp_ov_update_eswitch(hwfn, ptt, QED_OV_ESWITCH_VEB);
4605538f8d00SSudarsana Reddy Kalluru if (rc)
4606538f8d00SSudarsana Reddy Kalluru DP_INFO(cdev, "Failed to update eswitch mode\n");
4607538f8d00SSudarsana Reddy Kalluru qed_ptt_release(hwfn, ptt);
4608538f8d00SSudarsana Reddy Kalluru
46090b55e27dSYuval Mintz return num;
46100b55e27dSYuval Mintz
46110b55e27dSYuval Mintz err:
46120b55e27dSYuval Mintz qed_sriov_disable(cdev, false);
46130b55e27dSYuval Mintz return rc;
46140b55e27dSYuval Mintz }
46150b55e27dSYuval Mintz
qed_sriov_configure(struct qed_dev * cdev,int num_vfs_param)46160b55e27dSYuval Mintz static int qed_sriov_configure(struct qed_dev *cdev, int num_vfs_param)
46170b55e27dSYuval Mintz {
46180b55e27dSYuval Mintz if (!IS_QED_SRIOV(cdev)) {
46190b55e27dSYuval Mintz DP_VERBOSE(cdev, QED_MSG_IOV, "SR-IOV is not supported\n");
46200b55e27dSYuval Mintz return -EOPNOTSUPP;
46210b55e27dSYuval Mintz }
46220b55e27dSYuval Mintz
46230b55e27dSYuval Mintz if (num_vfs_param)
46240b55e27dSYuval Mintz return qed_sriov_enable(cdev, num_vfs_param);
46250b55e27dSYuval Mintz else
46260b55e27dSYuval Mintz return qed_sriov_disable(cdev, true);
46270b55e27dSYuval Mintz }
46280b55e27dSYuval Mintz
qed_sriov_pf_set_mac(struct qed_dev * cdev,u8 * mac,int vfid)4629eff16960SYuval Mintz static int qed_sriov_pf_set_mac(struct qed_dev *cdev, u8 *mac, int vfid)
4630eff16960SYuval Mintz {
4631eff16960SYuval Mintz int i;
4632eff16960SYuval Mintz
4633eff16960SYuval Mintz if (!IS_QED_SRIOV(cdev) || !IS_PF_SRIOV_ALLOC(&cdev->hwfns[0])) {
4634eff16960SYuval Mintz DP_VERBOSE(cdev, QED_MSG_IOV,
4635eff16960SYuval Mintz "Cannot set a VF MAC; Sriov is not enabled\n");
4636eff16960SYuval Mintz return -EINVAL;
4637eff16960SYuval Mintz }
4638eff16960SYuval Mintz
46397eff82b0SYuval Mintz if (!qed_iov_is_valid_vfid(&cdev->hwfns[0], vfid, true, true)) {
4640eff16960SYuval Mintz DP_VERBOSE(cdev, QED_MSG_IOV,
4641eff16960SYuval Mintz "Cannot set VF[%d] MAC (VF is not active)\n", vfid);
4642eff16960SYuval Mintz return -EINVAL;
4643eff16960SYuval Mintz }
4644eff16960SYuval Mintz
4645eff16960SYuval Mintz for_each_hwfn(cdev, i) {
4646eff16960SYuval Mintz struct qed_hwfn *hwfn = &cdev->hwfns[i];
4647eff16960SYuval Mintz struct qed_public_vf_info *vf_info;
4648eff16960SYuval Mintz
4649eff16960SYuval Mintz vf_info = qed_iov_get_public_vf_info(hwfn, vfid, true);
4650eff16960SYuval Mintz if (!vf_info)
4651eff16960SYuval Mintz continue;
4652eff16960SYuval Mintz
46537425d822SShahed Shaikh /* Set the MAC, and schedule the IOV task */
46547425d822SShahed Shaikh if (vf_info->is_trusted_configured)
46557425d822SShahed Shaikh ether_addr_copy(vf_info->mac, mac);
46567425d822SShahed Shaikh else
4657eff16960SYuval Mintz ether_addr_copy(vf_info->forced_mac, mac);
46587425d822SShahed Shaikh
4659eff16960SYuval Mintz qed_schedule_iov(hwfn, QED_IOV_WQ_SET_UNICAST_FILTER_FLAG);
4660eff16960SYuval Mintz }
4661eff16960SYuval Mintz
4662eff16960SYuval Mintz return 0;
4663eff16960SYuval Mintz }
4664eff16960SYuval Mintz
qed_sriov_pf_set_vlan(struct qed_dev * cdev,u16 vid,int vfid)466508feecd7SYuval Mintz static int qed_sriov_pf_set_vlan(struct qed_dev *cdev, u16 vid, int vfid)
466608feecd7SYuval Mintz {
466708feecd7SYuval Mintz int i;
466808feecd7SYuval Mintz
466908feecd7SYuval Mintz if (!IS_QED_SRIOV(cdev) || !IS_PF_SRIOV_ALLOC(&cdev->hwfns[0])) {
467008feecd7SYuval Mintz DP_VERBOSE(cdev, QED_MSG_IOV,
467108feecd7SYuval Mintz "Cannot set a VF MAC; Sriov is not enabled\n");
467208feecd7SYuval Mintz return -EINVAL;
467308feecd7SYuval Mintz }
467408feecd7SYuval Mintz
46757eff82b0SYuval Mintz if (!qed_iov_is_valid_vfid(&cdev->hwfns[0], vfid, true, true)) {
467608feecd7SYuval Mintz DP_VERBOSE(cdev, QED_MSG_IOV,
467708feecd7SYuval Mintz "Cannot set VF[%d] MAC (VF is not active)\n", vfid);
467808feecd7SYuval Mintz return -EINVAL;
467908feecd7SYuval Mintz }
468008feecd7SYuval Mintz
468108feecd7SYuval Mintz for_each_hwfn(cdev, i) {
468208feecd7SYuval Mintz struct qed_hwfn *hwfn = &cdev->hwfns[i];
468308feecd7SYuval Mintz struct qed_public_vf_info *vf_info;
468408feecd7SYuval Mintz
468508feecd7SYuval Mintz vf_info = qed_iov_get_public_vf_info(hwfn, vfid, true);
468608feecd7SYuval Mintz if (!vf_info)
468708feecd7SYuval Mintz continue;
468808feecd7SYuval Mintz
468908feecd7SYuval Mintz /* Set the forced vlan, and schedule the IOV task */
469008feecd7SYuval Mintz vf_info->forced_vlan = vid;
469108feecd7SYuval Mintz qed_schedule_iov(hwfn, QED_IOV_WQ_SET_UNICAST_FILTER_FLAG);
469208feecd7SYuval Mintz }
469308feecd7SYuval Mintz
469408feecd7SYuval Mintz return 0;
469508feecd7SYuval Mintz }
469608feecd7SYuval Mintz
qed_get_vf_config(struct qed_dev * cdev,int vf_id,struct ifla_vf_info * ivi)469773390ac9SYuval Mintz static int qed_get_vf_config(struct qed_dev *cdev,
469873390ac9SYuval Mintz int vf_id, struct ifla_vf_info *ivi)
469973390ac9SYuval Mintz {
470073390ac9SYuval Mintz struct qed_hwfn *hwfn = QED_LEADING_HWFN(cdev);
470173390ac9SYuval Mintz struct qed_public_vf_info *vf_info;
470273390ac9SYuval Mintz struct qed_mcp_link_state link;
470373390ac9SYuval Mintz u32 tx_rate;
4704d9dc0c84STom Rix int ret;
470573390ac9SYuval Mintz
470673390ac9SYuval Mintz /* Sanitize request */
470773390ac9SYuval Mintz if (IS_VF(cdev))
470873390ac9SYuval Mintz return -EINVAL;
470973390ac9SYuval Mintz
47107eff82b0SYuval Mintz if (!qed_iov_is_valid_vfid(&cdev->hwfns[0], vf_id, true, false)) {
471173390ac9SYuval Mintz DP_VERBOSE(cdev, QED_MSG_IOV,
471273390ac9SYuval Mintz "VF index [%d] isn't active\n", vf_id);
471373390ac9SYuval Mintz return -EINVAL;
471473390ac9SYuval Mintz }
471573390ac9SYuval Mintz
471673390ac9SYuval Mintz vf_info = qed_iov_get_public_vf_info(hwfn, vf_id, true);
471773390ac9SYuval Mintz
4718d9dc0c84STom Rix ret = qed_iov_get_link(hwfn, vf_id, NULL, &link, NULL);
4719d9dc0c84STom Rix if (ret)
4720d9dc0c84STom Rix return ret;
472173390ac9SYuval Mintz
472273390ac9SYuval Mintz /* Fill information about VF */
472373390ac9SYuval Mintz ivi->vf = vf_id;
472473390ac9SYuval Mintz
472573390ac9SYuval Mintz if (is_valid_ether_addr(vf_info->forced_mac))
472673390ac9SYuval Mintz ether_addr_copy(ivi->mac, vf_info->forced_mac);
472773390ac9SYuval Mintz else
472873390ac9SYuval Mintz ether_addr_copy(ivi->mac, vf_info->mac);
472973390ac9SYuval Mintz
473073390ac9SYuval Mintz ivi->vlan = vf_info->forced_vlan;
473173390ac9SYuval Mintz ivi->spoofchk = qed_iov_spoofchk_get(hwfn, vf_id);
473273390ac9SYuval Mintz ivi->linkstate = vf_info->link_state;
473373390ac9SYuval Mintz tx_rate = vf_info->tx_rate;
473473390ac9SYuval Mintz ivi->max_tx_rate = tx_rate ? tx_rate : link.speed;
473573390ac9SYuval Mintz ivi->min_tx_rate = qed_iov_get_vf_min_rate(hwfn, vf_id);
47364e6e6becSManish Chopra ivi->trusted = vf_info->is_trusted_request;
473773390ac9SYuval Mintz
473873390ac9SYuval Mintz return 0;
473973390ac9SYuval Mintz }
474073390ac9SYuval Mintz
qed_inform_vf_link_state(struct qed_hwfn * hwfn)474136558c3dSYuval Mintz void qed_inform_vf_link_state(struct qed_hwfn *hwfn)
474236558c3dSYuval Mintz {
4743e50728efSMintz, Yuval struct qed_hwfn *lead_hwfn = QED_LEADING_HWFN(hwfn->cdev);
474436558c3dSYuval Mintz struct qed_mcp_link_capabilities caps;
474536558c3dSYuval Mintz struct qed_mcp_link_params params;
474636558c3dSYuval Mintz struct qed_mcp_link_state link;
474736558c3dSYuval Mintz int i;
474836558c3dSYuval Mintz
474936558c3dSYuval Mintz if (!hwfn->pf_iov_info)
475036558c3dSYuval Mintz return;
475136558c3dSYuval Mintz
475236558c3dSYuval Mintz /* Update bulletin of all future possible VFs with link configuration */
475336558c3dSYuval Mintz for (i = 0; i < hwfn->cdev->p_iov_info->total_vfs; i++) {
4754733def6aSYuval Mintz struct qed_public_vf_info *vf_info;
4755733def6aSYuval Mintz
4756733def6aSYuval Mintz vf_info = qed_iov_get_public_vf_info(hwfn, i, false);
4757733def6aSYuval Mintz if (!vf_info)
4758733def6aSYuval Mintz continue;
4759733def6aSYuval Mintz
4760e50728efSMintz, Yuval /* Only hwfn0 is actually interested in the link speed.
4761e50728efSMintz, Yuval * But since only it would receive an MFW indication of link,
4762e50728efSMintz, Yuval * need to take configuration from it - otherwise things like
4763e50728efSMintz, Yuval * rate limiting for hwfn1 VF would not work.
4764e50728efSMintz, Yuval */
4765e50728efSMintz, Yuval memcpy(¶ms, qed_mcp_get_link_params(lead_hwfn),
4766e50728efSMintz, Yuval sizeof(params));
4767e50728efSMintz, Yuval memcpy(&link, qed_mcp_get_link_state(lead_hwfn), sizeof(link));
4768e50728efSMintz, Yuval memcpy(&caps, qed_mcp_get_link_capabilities(lead_hwfn),
476936558c3dSYuval Mintz sizeof(caps));
477036558c3dSYuval Mintz
4771733def6aSYuval Mintz /* Modify link according to the VF's configured link state */
4772733def6aSYuval Mintz switch (vf_info->link_state) {
4773733def6aSYuval Mintz case IFLA_VF_LINK_STATE_DISABLE:
4774733def6aSYuval Mintz link.link_up = false;
4775733def6aSYuval Mintz break;
4776733def6aSYuval Mintz case IFLA_VF_LINK_STATE_ENABLE:
4777733def6aSYuval Mintz link.link_up = true;
4778733def6aSYuval Mintz /* Set speed according to maximum supported by HW.
4779733def6aSYuval Mintz * that is 40G for regular devices and 100G for CMT
4780733def6aSYuval Mintz * mode devices.
4781733def6aSYuval Mintz */
4782733def6aSYuval Mintz link.speed = (hwfn->cdev->num_hwfns > 1) ?
4783733def6aSYuval Mintz 100000 : 40000;
4784134639e9SGustavo A. R. Silva break;
4785733def6aSYuval Mintz default:
4786733def6aSYuval Mintz /* In auto mode pass PF link image to VF */
4787733def6aSYuval Mintz break;
4788733def6aSYuval Mintz }
4789733def6aSYuval Mintz
4790733def6aSYuval Mintz if (link.link_up && vf_info->tx_rate) {
4791733def6aSYuval Mintz struct qed_ptt *ptt;
4792733def6aSYuval Mintz int rate;
4793733def6aSYuval Mintz
4794733def6aSYuval Mintz rate = min_t(int, vf_info->tx_rate, link.speed);
4795733def6aSYuval Mintz
4796733def6aSYuval Mintz ptt = qed_ptt_acquire(hwfn);
4797733def6aSYuval Mintz if (!ptt) {
4798733def6aSYuval Mintz DP_NOTICE(hwfn, "Failed to acquire PTT\n");
4799733def6aSYuval Mintz return;
4800733def6aSYuval Mintz }
4801733def6aSYuval Mintz
4802733def6aSYuval Mintz if (!qed_iov_configure_tx_rate(hwfn, ptt, i, rate)) {
4803733def6aSYuval Mintz vf_info->tx_rate = rate;
4804733def6aSYuval Mintz link.speed = rate;
4805733def6aSYuval Mintz }
4806733def6aSYuval Mintz
4807733def6aSYuval Mintz qed_ptt_release(hwfn, ptt);
4808733def6aSYuval Mintz }
4809733def6aSYuval Mintz
481036558c3dSYuval Mintz qed_iov_set_link(hwfn, i, ¶ms, &link, &caps);
481136558c3dSYuval Mintz }
481236558c3dSYuval Mintz
481336558c3dSYuval Mintz qed_schedule_iov(hwfn, QED_IOV_WQ_BULLETIN_UPDATE_FLAG);
481436558c3dSYuval Mintz }
481536558c3dSYuval Mintz
qed_set_vf_link_state(struct qed_dev * cdev,int vf_id,int link_state)4816733def6aSYuval Mintz static int qed_set_vf_link_state(struct qed_dev *cdev,
4817733def6aSYuval Mintz int vf_id, int link_state)
4818733def6aSYuval Mintz {
4819733def6aSYuval Mintz int i;
4820733def6aSYuval Mintz
4821733def6aSYuval Mintz /* Sanitize request */
4822733def6aSYuval Mintz if (IS_VF(cdev))
4823733def6aSYuval Mintz return -EINVAL;
4824733def6aSYuval Mintz
48257eff82b0SYuval Mintz if (!qed_iov_is_valid_vfid(&cdev->hwfns[0], vf_id, true, true)) {
4826733def6aSYuval Mintz DP_VERBOSE(cdev, QED_MSG_IOV,
4827733def6aSYuval Mintz "VF index [%d] isn't active\n", vf_id);
4828733def6aSYuval Mintz return -EINVAL;
4829733def6aSYuval Mintz }
4830733def6aSYuval Mintz
4831733def6aSYuval Mintz /* Handle configuration of link state */
4832733def6aSYuval Mintz for_each_hwfn(cdev, i) {
4833733def6aSYuval Mintz struct qed_hwfn *hwfn = &cdev->hwfns[i];
4834733def6aSYuval Mintz struct qed_public_vf_info *vf;
4835733def6aSYuval Mintz
4836733def6aSYuval Mintz vf = qed_iov_get_public_vf_info(hwfn, vf_id, true);
4837733def6aSYuval Mintz if (!vf)
4838733def6aSYuval Mintz continue;
4839733def6aSYuval Mintz
4840733def6aSYuval Mintz if (vf->link_state == link_state)
4841733def6aSYuval Mintz continue;
4842733def6aSYuval Mintz
4843733def6aSYuval Mintz vf->link_state = link_state;
4844733def6aSYuval Mintz qed_inform_vf_link_state(&cdev->hwfns[i]);
4845733def6aSYuval Mintz }
4846733def6aSYuval Mintz
4847733def6aSYuval Mintz return 0;
4848733def6aSYuval Mintz }
4849733def6aSYuval Mintz
qed_spoof_configure(struct qed_dev * cdev,int vfid,bool val)48506ddc7608SYuval Mintz static int qed_spoof_configure(struct qed_dev *cdev, int vfid, bool val)
48516ddc7608SYuval Mintz {
48526ddc7608SYuval Mintz int i, rc = -EINVAL;
48536ddc7608SYuval Mintz
48546ddc7608SYuval Mintz for_each_hwfn(cdev, i) {
48556ddc7608SYuval Mintz struct qed_hwfn *p_hwfn = &cdev->hwfns[i];
48566ddc7608SYuval Mintz
48576ddc7608SYuval Mintz rc = qed_iov_spoofchk_set(p_hwfn, vfid, val);
48586ddc7608SYuval Mintz if (rc)
48596ddc7608SYuval Mintz break;
48606ddc7608SYuval Mintz }
48616ddc7608SYuval Mintz
48626ddc7608SYuval Mintz return rc;
48636ddc7608SYuval Mintz }
48646ddc7608SYuval Mintz
qed_configure_max_vf_rate(struct qed_dev * cdev,int vfid,int rate)4865733def6aSYuval Mintz static int qed_configure_max_vf_rate(struct qed_dev *cdev, int vfid, int rate)
4866733def6aSYuval Mintz {
4867733def6aSYuval Mintz int i;
4868733def6aSYuval Mintz
4869733def6aSYuval Mintz for_each_hwfn(cdev, i) {
4870733def6aSYuval Mintz struct qed_hwfn *p_hwfn = &cdev->hwfns[i];
4871733def6aSYuval Mintz struct qed_public_vf_info *vf;
4872733def6aSYuval Mintz
4873733def6aSYuval Mintz if (!qed_iov_pf_sanity_check(p_hwfn, vfid)) {
4874733def6aSYuval Mintz DP_NOTICE(p_hwfn,
4875733def6aSYuval Mintz "SR-IOV sanity check failed, can't set tx rate\n");
4876733def6aSYuval Mintz return -EINVAL;
4877733def6aSYuval Mintz }
4878733def6aSYuval Mintz
4879733def6aSYuval Mintz vf = qed_iov_get_public_vf_info(p_hwfn, vfid, true);
4880733def6aSYuval Mintz
4881733def6aSYuval Mintz vf->tx_rate = rate;
4882733def6aSYuval Mintz
4883733def6aSYuval Mintz qed_inform_vf_link_state(p_hwfn);
4884733def6aSYuval Mintz }
4885733def6aSYuval Mintz
4886733def6aSYuval Mintz return 0;
4887733def6aSYuval Mintz }
4888733def6aSYuval Mintz
qed_set_vf_rate(struct qed_dev * cdev,int vfid,u32 min_rate,u32 max_rate)4889733def6aSYuval Mintz static int qed_set_vf_rate(struct qed_dev *cdev,
4890733def6aSYuval Mintz int vfid, u32 min_rate, u32 max_rate)
4891733def6aSYuval Mintz {
4892733def6aSYuval Mintz int rc_min = 0, rc_max = 0;
4893733def6aSYuval Mintz
4894733def6aSYuval Mintz if (max_rate)
4895733def6aSYuval Mintz rc_max = qed_configure_max_vf_rate(cdev, vfid, max_rate);
4896733def6aSYuval Mintz
4897733def6aSYuval Mintz if (min_rate)
4898733def6aSYuval Mintz rc_min = qed_iov_configure_min_tx_rate(cdev, vfid, min_rate);
4899733def6aSYuval Mintz
4900733def6aSYuval Mintz if (rc_max | rc_min)
4901733def6aSYuval Mintz return -EINVAL;
4902733def6aSYuval Mintz
4903733def6aSYuval Mintz return 0;
4904733def6aSYuval Mintz }
4905733def6aSYuval Mintz
qed_set_vf_trust(struct qed_dev * cdev,int vfid,bool trust)4906f990c82cSMintz, Yuval static int qed_set_vf_trust(struct qed_dev *cdev, int vfid, bool trust)
4907f990c82cSMintz, Yuval {
4908f990c82cSMintz, Yuval int i;
4909f990c82cSMintz, Yuval
4910f990c82cSMintz, Yuval for_each_hwfn(cdev, i) {
4911f990c82cSMintz, Yuval struct qed_hwfn *hwfn = &cdev->hwfns[i];
4912f990c82cSMintz, Yuval struct qed_public_vf_info *vf;
4913f990c82cSMintz, Yuval
4914f990c82cSMintz, Yuval if (!qed_iov_pf_sanity_check(hwfn, vfid)) {
4915f990c82cSMintz, Yuval DP_NOTICE(hwfn,
4916f990c82cSMintz, Yuval "SR-IOV sanity check failed, can't set trust\n");
4917f990c82cSMintz, Yuval return -EINVAL;
4918f990c82cSMintz, Yuval }
4919f990c82cSMintz, Yuval
4920f990c82cSMintz, Yuval vf = qed_iov_get_public_vf_info(hwfn, vfid, true);
4921f990c82cSMintz, Yuval
4922f990c82cSMintz, Yuval if (vf->is_trusted_request == trust)
4923f990c82cSMintz, Yuval return 0;
4924f990c82cSMintz, Yuval vf->is_trusted_request = trust;
4925f990c82cSMintz, Yuval
4926f990c82cSMintz, Yuval qed_schedule_iov(hwfn, QED_IOV_WQ_TRUST_FLAG);
4927f990c82cSMintz, Yuval }
4928f990c82cSMintz, Yuval
4929f990c82cSMintz, Yuval return 0;
4930f990c82cSMintz, Yuval }
4931f990c82cSMintz, Yuval
qed_handle_vf_msg(struct qed_hwfn * hwfn)493237bff2b9SYuval Mintz static void qed_handle_vf_msg(struct qed_hwfn *hwfn)
493337bff2b9SYuval Mintz {
493437bff2b9SYuval Mintz u64 events[QED_VF_ARRAY_LENGTH];
493537bff2b9SYuval Mintz struct qed_ptt *ptt;
493637bff2b9SYuval Mintz int i;
493737bff2b9SYuval Mintz
493837bff2b9SYuval Mintz ptt = qed_ptt_acquire(hwfn);
493937bff2b9SYuval Mintz if (!ptt) {
494037bff2b9SYuval Mintz DP_VERBOSE(hwfn, QED_MSG_IOV,
494137bff2b9SYuval Mintz "Can't acquire PTT; re-scheduling\n");
494237bff2b9SYuval Mintz qed_schedule_iov(hwfn, QED_IOV_WQ_MSG_FLAG);
494337bff2b9SYuval Mintz return;
494437bff2b9SYuval Mintz }
494537bff2b9SYuval Mintz
4946fd3c615aSMintz, Yuval qed_iov_pf_get_pending_events(hwfn, events);
494737bff2b9SYuval Mintz
494837bff2b9SYuval Mintz DP_VERBOSE(hwfn, QED_MSG_IOV,
494937bff2b9SYuval Mintz "Event mask of VF events: 0x%llx 0x%llx 0x%llx\n",
495037bff2b9SYuval Mintz events[0], events[1], events[2]);
495137bff2b9SYuval Mintz
495237bff2b9SYuval Mintz qed_for_each_vf(hwfn, i) {
495337bff2b9SYuval Mintz /* Skip VFs with no pending messages */
495437bff2b9SYuval Mintz if (!(events[i / 64] & (1ULL << (i % 64))))
495537bff2b9SYuval Mintz continue;
495637bff2b9SYuval Mintz
495737bff2b9SYuval Mintz DP_VERBOSE(hwfn, QED_MSG_IOV,
495837bff2b9SYuval Mintz "Handling VF message from VF 0x%02x [Abs 0x%02x]\n",
495937bff2b9SYuval Mintz i, hwfn->cdev->p_iov_info->first_vf_in_pf + i);
496037bff2b9SYuval Mintz
496137bff2b9SYuval Mintz /* Copy VF's message to PF's request buffer for that VF */
496237bff2b9SYuval Mintz if (qed_iov_copy_vf_msg(hwfn, ptt, i))
496337bff2b9SYuval Mintz continue;
496437bff2b9SYuval Mintz
496537bff2b9SYuval Mintz qed_iov_process_mbx_req(hwfn, ptt, i);
496637bff2b9SYuval Mintz }
496737bff2b9SYuval Mintz
496837bff2b9SYuval Mintz qed_ptt_release(hwfn, ptt);
496937bff2b9SYuval Mintz }
497037bff2b9SYuval Mintz
qed_pf_validate_req_vf_mac(struct qed_hwfn * hwfn,u8 * mac,struct qed_public_vf_info * info)49717425d822SShahed Shaikh static bool qed_pf_validate_req_vf_mac(struct qed_hwfn *hwfn,
49727425d822SShahed Shaikh u8 *mac,
49737425d822SShahed Shaikh struct qed_public_vf_info *info)
49747425d822SShahed Shaikh {
49757425d822SShahed Shaikh if (info->is_trusted_configured) {
49767425d822SShahed Shaikh if (is_valid_ether_addr(info->mac) &&
49777425d822SShahed Shaikh (!mac || !ether_addr_equal(mac, info->mac)))
49787425d822SShahed Shaikh return true;
49797425d822SShahed Shaikh } else {
49807425d822SShahed Shaikh if (is_valid_ether_addr(info->forced_mac) &&
49817425d822SShahed Shaikh (!mac || !ether_addr_equal(mac, info->forced_mac)))
49827425d822SShahed Shaikh return true;
49837425d822SShahed Shaikh }
49847425d822SShahed Shaikh
49857425d822SShahed Shaikh return false;
49867425d822SShahed Shaikh }
49877425d822SShahed Shaikh
qed_set_bulletin_mac(struct qed_hwfn * hwfn,struct qed_public_vf_info * info,int vfid)49887425d822SShahed Shaikh static void qed_set_bulletin_mac(struct qed_hwfn *hwfn,
49897425d822SShahed Shaikh struct qed_public_vf_info *info,
49907425d822SShahed Shaikh int vfid)
49917425d822SShahed Shaikh {
49927425d822SShahed Shaikh if (info->is_trusted_configured)
49937425d822SShahed Shaikh qed_iov_bulletin_set_mac(hwfn, info->mac, vfid);
49947425d822SShahed Shaikh else
49957425d822SShahed Shaikh qed_iov_bulletin_set_forced_mac(hwfn, info->forced_mac, vfid);
49967425d822SShahed Shaikh }
49977425d822SShahed Shaikh
qed_handle_pf_set_vf_unicast(struct qed_hwfn * hwfn)499808feecd7SYuval Mintz static void qed_handle_pf_set_vf_unicast(struct qed_hwfn *hwfn)
499908feecd7SYuval Mintz {
500008feecd7SYuval Mintz int i;
500108feecd7SYuval Mintz
500208feecd7SYuval Mintz qed_for_each_vf(hwfn, i) {
500308feecd7SYuval Mintz struct qed_public_vf_info *info;
500408feecd7SYuval Mintz bool update = false;
5005eff16960SYuval Mintz u8 *mac;
500608feecd7SYuval Mintz
500708feecd7SYuval Mintz info = qed_iov_get_public_vf_info(hwfn, i, true);
500808feecd7SYuval Mintz if (!info)
500908feecd7SYuval Mintz continue;
501008feecd7SYuval Mintz
501108feecd7SYuval Mintz /* Update data on bulletin board */
50127425d822SShahed Shaikh if (info->is_trusted_configured)
50137425d822SShahed Shaikh mac = qed_iov_bulletin_get_mac(hwfn, i);
50147425d822SShahed Shaikh else
5015eff16960SYuval Mintz mac = qed_iov_bulletin_get_forced_mac(hwfn, i);
50167425d822SShahed Shaikh
50177425d822SShahed Shaikh if (qed_pf_validate_req_vf_mac(hwfn, mac, info)) {
5018eff16960SYuval Mintz DP_VERBOSE(hwfn,
5019eff16960SYuval Mintz QED_MSG_IOV,
5020eff16960SYuval Mintz "Handling PF setting of VF MAC to VF 0x%02x [Abs 0x%02x]\n",
5021eff16960SYuval Mintz i,
5022eff16960SYuval Mintz hwfn->cdev->p_iov_info->first_vf_in_pf + i);
5023eff16960SYuval Mintz
50247425d822SShahed Shaikh /* Update bulletin board with MAC */
50257425d822SShahed Shaikh qed_set_bulletin_mac(hwfn, info, i);
5026eff16960SYuval Mintz update = true;
5027eff16960SYuval Mintz }
502808feecd7SYuval Mintz
502908feecd7SYuval Mintz if (qed_iov_bulletin_get_forced_vlan(hwfn, i) ^
503008feecd7SYuval Mintz info->forced_vlan) {
503108feecd7SYuval Mintz DP_VERBOSE(hwfn,
503208feecd7SYuval Mintz QED_MSG_IOV,
503308feecd7SYuval Mintz "Handling PF setting of pvid [0x%04x] to VF 0x%02x [Abs 0x%02x]\n",
503408feecd7SYuval Mintz info->forced_vlan,
503508feecd7SYuval Mintz i,
503608feecd7SYuval Mintz hwfn->cdev->p_iov_info->first_vf_in_pf + i);
503708feecd7SYuval Mintz qed_iov_bulletin_set_forced_vlan(hwfn,
503808feecd7SYuval Mintz info->forced_vlan, i);
503908feecd7SYuval Mintz update = true;
504008feecd7SYuval Mintz }
504108feecd7SYuval Mintz
504208feecd7SYuval Mintz if (update)
504308feecd7SYuval Mintz qed_schedule_iov(hwfn, QED_IOV_WQ_BULLETIN_UPDATE_FLAG);
504408feecd7SYuval Mintz }
504508feecd7SYuval Mintz }
504608feecd7SYuval Mintz
qed_handle_bulletin_post(struct qed_hwfn * hwfn)504736558c3dSYuval Mintz static void qed_handle_bulletin_post(struct qed_hwfn *hwfn)
504836558c3dSYuval Mintz {
504936558c3dSYuval Mintz struct qed_ptt *ptt;
505036558c3dSYuval Mintz int i;
505136558c3dSYuval Mintz
505236558c3dSYuval Mintz ptt = qed_ptt_acquire(hwfn);
505336558c3dSYuval Mintz if (!ptt) {
505436558c3dSYuval Mintz DP_NOTICE(hwfn, "Failed allocating a ptt entry\n");
505536558c3dSYuval Mintz qed_schedule_iov(hwfn, QED_IOV_WQ_BULLETIN_UPDATE_FLAG);
505636558c3dSYuval Mintz return;
505736558c3dSYuval Mintz }
505836558c3dSYuval Mintz
505936558c3dSYuval Mintz qed_for_each_vf(hwfn, i)
506036558c3dSYuval Mintz qed_iov_post_vf_bulletin(hwfn, i, ptt);
506136558c3dSYuval Mintz
506236558c3dSYuval Mintz qed_ptt_release(hwfn, ptt);
506336558c3dSYuval Mintz }
506436558c3dSYuval Mintz
qed_update_mac_for_vf_trust_change(struct qed_hwfn * hwfn,int vf_id)50657425d822SShahed Shaikh static void qed_update_mac_for_vf_trust_change(struct qed_hwfn *hwfn, int vf_id)
50667425d822SShahed Shaikh {
50677425d822SShahed Shaikh struct qed_public_vf_info *vf_info;
50687425d822SShahed Shaikh struct qed_vf_info *vf;
50697425d822SShahed Shaikh u8 *force_mac;
50707425d822SShahed Shaikh int i;
50717425d822SShahed Shaikh
50727425d822SShahed Shaikh vf_info = qed_iov_get_public_vf_info(hwfn, vf_id, true);
50737425d822SShahed Shaikh vf = qed_iov_get_vf_info(hwfn, vf_id, true);
50747425d822SShahed Shaikh
50757425d822SShahed Shaikh if (!vf_info || !vf)
50767425d822SShahed Shaikh return;
50777425d822SShahed Shaikh
50787425d822SShahed Shaikh /* Force MAC converted to generic MAC in case of VF trust on */
50797425d822SShahed Shaikh if (vf_info->is_trusted_configured &&
50807425d822SShahed Shaikh (vf->bulletin.p_virt->valid_bitmap & BIT(MAC_ADDR_FORCED))) {
50817425d822SShahed Shaikh force_mac = qed_iov_bulletin_get_forced_mac(hwfn, vf_id);
50827425d822SShahed Shaikh
50837425d822SShahed Shaikh if (force_mac) {
50847425d822SShahed Shaikh /* Clear existing shadow copy of MAC to have a clean
50857425d822SShahed Shaikh * slate.
50867425d822SShahed Shaikh */
50877425d822SShahed Shaikh for (i = 0; i < QED_ETH_VF_NUM_MAC_FILTERS; i++) {
50887425d822SShahed Shaikh if (ether_addr_equal(vf->shadow_config.macs[i],
50897425d822SShahed Shaikh vf_info->mac)) {
509083403036SMiaohe Lin eth_zero_addr(vf->shadow_config.macs[i]);
50917425d822SShahed Shaikh DP_VERBOSE(hwfn, QED_MSG_IOV,
50927425d822SShahed Shaikh "Shadow MAC %pM removed for VF 0x%02x, VF trust mode is ON\n",
50937425d822SShahed Shaikh vf_info->mac, vf_id);
50947425d822SShahed Shaikh break;
50957425d822SShahed Shaikh }
50967425d822SShahed Shaikh }
50977425d822SShahed Shaikh
50987425d822SShahed Shaikh ether_addr_copy(vf_info->mac, force_mac);
509983403036SMiaohe Lin eth_zero_addr(vf_info->forced_mac);
51007425d822SShahed Shaikh vf->bulletin.p_virt->valid_bitmap &=
51017425d822SShahed Shaikh ~BIT(MAC_ADDR_FORCED);
51027425d822SShahed Shaikh qed_schedule_iov(hwfn, QED_IOV_WQ_BULLETIN_UPDATE_FLAG);
51037425d822SShahed Shaikh }
51047425d822SShahed Shaikh }
51057425d822SShahed Shaikh
51067425d822SShahed Shaikh /* Update shadow copy with VF MAC when trust mode is turned off */
51077425d822SShahed Shaikh if (!vf_info->is_trusted_configured) {
51087425d822SShahed Shaikh u8 empty_mac[ETH_ALEN];
51097425d822SShahed Shaikh
511083403036SMiaohe Lin eth_zero_addr(empty_mac);
51117425d822SShahed Shaikh for (i = 0; i < QED_ETH_VF_NUM_MAC_FILTERS; i++) {
51127425d822SShahed Shaikh if (ether_addr_equal(vf->shadow_config.macs[i],
51137425d822SShahed Shaikh empty_mac)) {
51147425d822SShahed Shaikh ether_addr_copy(vf->shadow_config.macs[i],
51157425d822SShahed Shaikh vf_info->mac);
51167425d822SShahed Shaikh DP_VERBOSE(hwfn, QED_MSG_IOV,
51177425d822SShahed Shaikh "Shadow is updated with %pM for VF 0x%02x, VF trust mode is OFF\n",
51187425d822SShahed Shaikh vf_info->mac, vf_id);
51197425d822SShahed Shaikh break;
51207425d822SShahed Shaikh }
51217425d822SShahed Shaikh }
51227425d822SShahed Shaikh /* Clear bulletin when trust mode is turned off,
51237425d822SShahed Shaikh * to have a clean slate for next (normal) operations.
51247425d822SShahed Shaikh */
51257425d822SShahed Shaikh qed_iov_bulletin_set_mac(hwfn, empty_mac, vf_id);
51267425d822SShahed Shaikh qed_schedule_iov(hwfn, QED_IOV_WQ_BULLETIN_UPDATE_FLAG);
51277425d822SShahed Shaikh }
51287425d822SShahed Shaikh }
51297425d822SShahed Shaikh
qed_iov_handle_trust_change(struct qed_hwfn * hwfn)5130f990c82cSMintz, Yuval static void qed_iov_handle_trust_change(struct qed_hwfn *hwfn)
5131f990c82cSMintz, Yuval {
5132f990c82cSMintz, Yuval struct qed_sp_vport_update_params params;
5133f990c82cSMintz, Yuval struct qed_filter_accept_flags *flags;
5134f990c82cSMintz, Yuval struct qed_public_vf_info *vf_info;
5135f990c82cSMintz, Yuval struct qed_vf_info *vf;
5136f990c82cSMintz, Yuval u8 mask;
5137f990c82cSMintz, Yuval int i;
5138f990c82cSMintz, Yuval
5139f990c82cSMintz, Yuval mask = QED_ACCEPT_UCAST_UNMATCHED | QED_ACCEPT_MCAST_UNMATCHED;
5140f990c82cSMintz, Yuval flags = ¶ms.accept_flags;
5141f990c82cSMintz, Yuval
5142f990c82cSMintz, Yuval qed_for_each_vf(hwfn, i) {
5143f990c82cSMintz, Yuval /* Need to make sure current requested configuration didn't
5144f990c82cSMintz, Yuval * flip so that we'll end up configuring something that's not
5145f990c82cSMintz, Yuval * needed.
5146f990c82cSMintz, Yuval */
5147f990c82cSMintz, Yuval vf_info = qed_iov_get_public_vf_info(hwfn, i, true);
5148f990c82cSMintz, Yuval if (vf_info->is_trusted_configured ==
5149f990c82cSMintz, Yuval vf_info->is_trusted_request)
5150f990c82cSMintz, Yuval continue;
5151f990c82cSMintz, Yuval vf_info->is_trusted_configured = vf_info->is_trusted_request;
5152f990c82cSMintz, Yuval
51537425d822SShahed Shaikh /* Handle forced MAC mode */
51547425d822SShahed Shaikh qed_update_mac_for_vf_trust_change(hwfn, i);
51557425d822SShahed Shaikh
5156f990c82cSMintz, Yuval /* Validate that the VF has a configured vport */
5157f990c82cSMintz, Yuval vf = qed_iov_get_vf_info(hwfn, i, true);
5158*25143b6aSDaniil Tatianin if (!vf || !vf->vport_instance)
5159f990c82cSMintz, Yuval continue;
5160f990c82cSMintz, Yuval
5161f990c82cSMintz, Yuval memset(¶ms, 0, sizeof(params));
5162f990c82cSMintz, Yuval params.opaque_fid = vf->opaque_fid;
5163f990c82cSMintz, Yuval params.vport_id = vf->vport_id;
5164f990c82cSMintz, Yuval
5165ff929696SManish Chopra params.update_ctl_frame_check = 1;
5166ff929696SManish Chopra params.mac_chk_en = !vf_info->is_trusted_configured;
5167cbcc44dbSManish Chopra params.update_accept_any_vlan_flg = 0;
5168cbcc44dbSManish Chopra
5169cbcc44dbSManish Chopra if (vf_info->accept_any_vlan && vf_info->forced_vlan) {
5170cbcc44dbSManish Chopra params.update_accept_any_vlan_flg = 1;
5171cbcc44dbSManish Chopra params.accept_any_vlan = vf_info->accept_any_vlan;
5172cbcc44dbSManish Chopra }
5173ff929696SManish Chopra
5174f990c82cSMintz, Yuval if (vf_info->rx_accept_mode & mask) {
5175f990c82cSMintz, Yuval flags->update_rx_mode_config = 1;
5176f990c82cSMintz, Yuval flags->rx_accept_filter = vf_info->rx_accept_mode;
5177f990c82cSMintz, Yuval }
5178f990c82cSMintz, Yuval
5179f990c82cSMintz, Yuval if (vf_info->tx_accept_mode & mask) {
5180f990c82cSMintz, Yuval flags->update_tx_mode_config = 1;
5181f990c82cSMintz, Yuval flags->tx_accept_filter = vf_info->tx_accept_mode;
5182f990c82cSMintz, Yuval }
5183f990c82cSMintz, Yuval
5184f990c82cSMintz, Yuval /* Remove if needed; Otherwise this would set the mask */
5185f990c82cSMintz, Yuval if (!vf_info->is_trusted_configured) {
5186f990c82cSMintz, Yuval flags->rx_accept_filter &= ~mask;
5187f990c82cSMintz, Yuval flags->tx_accept_filter &= ~mask;
5188cbcc44dbSManish Chopra params.accept_any_vlan = false;
5189f990c82cSMintz, Yuval }
5190f990c82cSMintz, Yuval
5191f990c82cSMintz, Yuval if (flags->update_rx_mode_config ||
5192ff929696SManish Chopra flags->update_tx_mode_config ||
5193cbcc44dbSManish Chopra params.update_ctl_frame_check ||
5194cbcc44dbSManish Chopra params.update_accept_any_vlan_flg) {
5195cbcc44dbSManish Chopra DP_VERBOSE(hwfn, QED_MSG_IOV,
5196cbcc44dbSManish Chopra "vport update config for %s VF[abs 0x%x rel 0x%x]\n",
5197cbcc44dbSManish Chopra vf_info->is_trusted_configured ? "trusted" : "untrusted",
5198cbcc44dbSManish Chopra vf->abs_vf_id, vf->relative_vf_id);
5199f990c82cSMintz, Yuval qed_sp_vport_update(hwfn, ¶ms,
5200f990c82cSMintz, Yuval QED_SPQ_MODE_EBLOCK, NULL);
5201f990c82cSMintz, Yuval }
5202f990c82cSMintz, Yuval }
5203cbcc44dbSManish Chopra }
5204f990c82cSMintz, Yuval
qed_iov_pf_task(struct work_struct * work)5205ba56947aSBaoyou Xie static void qed_iov_pf_task(struct work_struct *work)
5206ba56947aSBaoyou Xie
520737bff2b9SYuval Mintz {
520837bff2b9SYuval Mintz struct qed_hwfn *hwfn = container_of(work, struct qed_hwfn,
520937bff2b9SYuval Mintz iov_task.work);
52100b55e27dSYuval Mintz int rc;
521137bff2b9SYuval Mintz
521237bff2b9SYuval Mintz if (test_and_clear_bit(QED_IOV_WQ_STOP_WQ_FLAG, &hwfn->iov_task_flags))
521337bff2b9SYuval Mintz return;
521437bff2b9SYuval Mintz
52150b55e27dSYuval Mintz if (test_and_clear_bit(QED_IOV_WQ_FLR_FLAG, &hwfn->iov_task_flags)) {
52160b55e27dSYuval Mintz struct qed_ptt *ptt = qed_ptt_acquire(hwfn);
52170b55e27dSYuval Mintz
52180b55e27dSYuval Mintz if (!ptt) {
52190b55e27dSYuval Mintz qed_schedule_iov(hwfn, QED_IOV_WQ_FLR_FLAG);
52200b55e27dSYuval Mintz return;
52210b55e27dSYuval Mintz }
52220b55e27dSYuval Mintz
52230b55e27dSYuval Mintz rc = qed_iov_vf_flr_cleanup(hwfn, ptt);
52240b55e27dSYuval Mintz if (rc)
52250b55e27dSYuval Mintz qed_schedule_iov(hwfn, QED_IOV_WQ_FLR_FLAG);
52260b55e27dSYuval Mintz
52270b55e27dSYuval Mintz qed_ptt_release(hwfn, ptt);
52280b55e27dSYuval Mintz }
52290b55e27dSYuval Mintz
523037bff2b9SYuval Mintz if (test_and_clear_bit(QED_IOV_WQ_MSG_FLAG, &hwfn->iov_task_flags))
523137bff2b9SYuval Mintz qed_handle_vf_msg(hwfn);
523208feecd7SYuval Mintz
523308feecd7SYuval Mintz if (test_and_clear_bit(QED_IOV_WQ_SET_UNICAST_FILTER_FLAG,
523408feecd7SYuval Mintz &hwfn->iov_task_flags))
523508feecd7SYuval Mintz qed_handle_pf_set_vf_unicast(hwfn);
523608feecd7SYuval Mintz
523736558c3dSYuval Mintz if (test_and_clear_bit(QED_IOV_WQ_BULLETIN_UPDATE_FLAG,
523836558c3dSYuval Mintz &hwfn->iov_task_flags))
523936558c3dSYuval Mintz qed_handle_bulletin_post(hwfn);
5240f990c82cSMintz, Yuval
5241f990c82cSMintz, Yuval if (test_and_clear_bit(QED_IOV_WQ_TRUST_FLAG, &hwfn->iov_task_flags))
5242f990c82cSMintz, Yuval qed_iov_handle_trust_change(hwfn);
524337bff2b9SYuval Mintz }
524437bff2b9SYuval Mintz
qed_iov_wq_stop(struct qed_dev * cdev,bool schedule_first)524537bff2b9SYuval Mintz void qed_iov_wq_stop(struct qed_dev *cdev, bool schedule_first)
524637bff2b9SYuval Mintz {
524737bff2b9SYuval Mintz int i;
524837bff2b9SYuval Mintz
524937bff2b9SYuval Mintz for_each_hwfn(cdev, i) {
525037bff2b9SYuval Mintz if (!cdev->hwfns[i].iov_wq)
525137bff2b9SYuval Mintz continue;
525237bff2b9SYuval Mintz
525337bff2b9SYuval Mintz if (schedule_first) {
525437bff2b9SYuval Mintz qed_schedule_iov(&cdev->hwfns[i],
525537bff2b9SYuval Mintz QED_IOV_WQ_STOP_WQ_FLAG);
525637bff2b9SYuval Mintz cancel_delayed_work_sync(&cdev->hwfns[i].iov_task);
525737bff2b9SYuval Mintz }
525837bff2b9SYuval Mintz
525937bff2b9SYuval Mintz destroy_workqueue(cdev->hwfns[i].iov_wq);
526037bff2b9SYuval Mintz }
526137bff2b9SYuval Mintz }
526237bff2b9SYuval Mintz
qed_iov_wq_start(struct qed_dev * cdev)526337bff2b9SYuval Mintz int qed_iov_wq_start(struct qed_dev *cdev)
526437bff2b9SYuval Mintz {
526537bff2b9SYuval Mintz char name[NAME_SIZE];
526637bff2b9SYuval Mintz int i;
526737bff2b9SYuval Mintz
526837bff2b9SYuval Mintz for_each_hwfn(cdev, i) {
526937bff2b9SYuval Mintz struct qed_hwfn *p_hwfn = &cdev->hwfns[i];
527037bff2b9SYuval Mintz
527136558c3dSYuval Mintz /* PFs needs a dedicated workqueue only if they support IOV.
527236558c3dSYuval Mintz * VFs always require one.
527336558c3dSYuval Mintz */
527436558c3dSYuval Mintz if (IS_PF(p_hwfn->cdev) && !IS_PF_SRIOV(p_hwfn))
527537bff2b9SYuval Mintz continue;
527637bff2b9SYuval Mintz
527737bff2b9SYuval Mintz snprintf(name, NAME_SIZE, "iov-%02x:%02x.%02x",
527837bff2b9SYuval Mintz cdev->pdev->bus->number,
527937bff2b9SYuval Mintz PCI_SLOT(cdev->pdev->devfn), p_hwfn->abs_pf_id);
528037bff2b9SYuval Mintz
528137bff2b9SYuval Mintz p_hwfn->iov_wq = create_singlethread_workqueue(name);
528237bff2b9SYuval Mintz if (!p_hwfn->iov_wq) {
528337bff2b9SYuval Mintz DP_NOTICE(p_hwfn, "Cannot create iov workqueue\n");
528437bff2b9SYuval Mintz return -ENOMEM;
528537bff2b9SYuval Mintz }
528637bff2b9SYuval Mintz
528736558c3dSYuval Mintz if (IS_PF(cdev))
528837bff2b9SYuval Mintz INIT_DELAYED_WORK(&p_hwfn->iov_task, qed_iov_pf_task);
528936558c3dSYuval Mintz else
529036558c3dSYuval Mintz INIT_DELAYED_WORK(&p_hwfn->iov_task, qed_iov_vf_task);
529137bff2b9SYuval Mintz }
529237bff2b9SYuval Mintz
529337bff2b9SYuval Mintz return 0;
529437bff2b9SYuval Mintz }
52950b55e27dSYuval Mintz
52960b55e27dSYuval Mintz const struct qed_iov_hv_ops qed_iov_ops_pass = {
52970b55e27dSYuval Mintz .configure = &qed_sriov_configure,
5298eff16960SYuval Mintz .set_mac = &qed_sriov_pf_set_mac,
529908feecd7SYuval Mintz .set_vlan = &qed_sriov_pf_set_vlan,
530073390ac9SYuval Mintz .get_config = &qed_get_vf_config,
5301733def6aSYuval Mintz .set_link_state = &qed_set_vf_link_state,
53026ddc7608SYuval Mintz .set_spoof = &qed_spoof_configure,
5303733def6aSYuval Mintz .set_rate = &qed_set_vf_rate,
5304f990c82cSMintz, Yuval .set_trust = &qed_set_vf_trust,
53050b55e27dSYuval Mintz };
5306