path: root/drivers/infiniband/hw/irdma/virtchnl.c

// SPDX-License-Identifier: GPL-2.0 or Linux-OpenIB
/* Copyright (c) 2015 - 2024 Intel Corporation */

#include "osdep.h"
#include "hmc.h"
#include "defs.h"
#include "type.h"
#include "protos.h"
#include "virtchnl.h"
#include "ws.h"
#include "i40iw_hw.h"
#include "ig3rdma_hw.h"

struct vchnl_reg_map_elem {
	u16 reg_id;
	u16 reg_idx;
	bool pg_rel;
};

struct vchnl_regfld_map_elem {
	u16 regfld_id;
	u16 regfld_idx;
};

static struct vchnl_reg_map_elem vchnl_reg_map[] = {
	{IRDMA_VCHNL_REG_ID_CQPTAIL, IRDMA_CQPTAIL, false},
	{IRDMA_VCHNL_REG_ID_CQPDB, IRDMA_CQPDB, false},
	{IRDMA_VCHNL_REG_ID_CCQPSTATUS, IRDMA_CCQPSTATUS, false},
	{IRDMA_VCHNL_REG_ID_CCQPHIGH, IRDMA_CCQPHIGH, false},
	{IRDMA_VCHNL_REG_ID_CCQPLOW, IRDMA_CCQPLOW, false},
	{IRDMA_VCHNL_REG_ID_CQARM, IRDMA_CQARM, false},
	{IRDMA_VCHNL_REG_ID_CQACK, IRDMA_CQACK, false},
	{IRDMA_VCHNL_REG_ID_AEQALLOC, IRDMA_AEQALLOC, false},
	{IRDMA_VCHNL_REG_ID_CQPERRCODES, IRDMA_CQPERRCODES, false},
	{IRDMA_VCHNL_REG_ID_WQEALLOC, IRDMA_WQEALLOC, false},
	{IRDMA_VCHNL_REG_ID_DB_ADDR_OFFSET, IRDMA_DB_ADDR_OFFSET, false },
	{IRDMA_VCHNL_REG_ID_DYN_CTL, IRDMA_GLINT_DYN_CTL, false },
	{IRDMA_VCHNL_REG_INV_ID, IRDMA_VCHNL_REG_INV_ID, false }
};

static struct vchnl_regfld_map_elem vchnl_regfld_map[] = {
	{IRDMA_VCHNL_REGFLD_ID_CCQPSTATUS_CQP_OP_ERR, IRDMA_CCQPSTATUS_CCQP_ERR_M},
	{IRDMA_VCHNL_REGFLD_ID_CCQPSTATUS_CCQP_DONE, IRDMA_CCQPSTATUS_CCQP_DONE_M},
	{IRDMA_VCHNL_REGFLD_ID_CQPSQ_STAG_PDID, IRDMA_CQPSQ_STAG_PDID_M},
	{IRDMA_VCHNL_REGFLD_ID_CQPSQ_CQ_CEQID, IRDMA_CQPSQ_CQ_CEQID_M},
	{IRDMA_VCHNL_REGFLD_ID_CQPSQ_CQ_CQID, IRDMA_CQPSQ_CQ_CQID_M},
	{IRDMA_VCHNL_REGFLD_ID_COMMIT_FPM_CQCNT, IRDMA_COMMIT_FPM_CQCNT_M},
	{IRDMA_VCHNL_REGFLD_ID_UPESD_HMCN_ID, IRDMA_CQPSQ_UPESD_HMCFNID_M},
	{IRDMA_VCHNL_REGFLD_INV_ID, IRDMA_VCHNL_REGFLD_INV_ID}
};

#define IRDMA_VCHNL_REG_COUNT ARRAY_SIZE(vchnl_reg_map)
#define IRDMA_VCHNL_REGFLD_COUNT ARRAY_SIZE(vchnl_regfld_map)
#define IRDMA_VCHNL_REGFLD_BUF_SIZE \
	(IRDMA_VCHNL_REG_COUNT * sizeof(struct irdma_vchnl_reg_info) + \
	 IRDMA_VCHNL_REGFLD_COUNT * sizeof(struct irdma_vchnl_reg_field_info))
#define IRDMA_REGMAP_RESP_BUF_SIZE (IRDMA_VCHNL_RESP_MIN_SIZE + IRDMA_VCHNL_REGFLD_BUF_SIZE)

/**
 * irdma_sc_vchnl_init - Initialize dev virtchannel and get hw_rev
 * @dev: dev structure to update
 * @info: virtchannel info parameters to fill into the dev structure
 */
int irdma_sc_vchnl_init(struct irdma_sc_dev *dev,
			struct irdma_vchnl_init_info *info)
{
	dev->vchnl_up = true;
	dev->privileged = info->privileged;
	dev->is_pf = info->is_pf;
	dev->hw_attrs.uk_attrs.hw_rev = info->hw_rev;

	if (!dev->privileged) {
		int ret = irdma_vchnl_req_get_ver(dev, IRDMA_VCHNL_CHNL_VER_MAX,
						  &dev->vchnl_ver);

		ibdev_dbg(to_ibdev(dev),
			  "DEV: Get Channel version ret = %d, version is %u\n",
			  ret, dev->vchnl_ver);

		if (ret)
			return ret;

		ret = irdma_vchnl_req_get_caps(dev);
		if (ret)
			return ret;

		dev->hw_attrs.uk_attrs.hw_rev = dev->vc_caps.hw_rev;
	}

	return 0;
}

/**
 * irdma_vchnl_req_verify_resp - Verify requested response size
 * @vchnl_req: vchnl message requested
 * @resp_len: response length sent from vchnl peer
 */
static int irdma_vchnl_req_verify_resp(struct irdma_vchnl_req *vchnl_req,
				       u16 resp_len)
{
	switch (vchnl_req->vchnl_msg->op_code) {
	case IRDMA_VCHNL_OP_GET_VER:
	case IRDMA_VCHNL_OP_GET_HMC_FCN:
	case IRDMA_VCHNL_OP_PUT_HMC_FCN:
		if (resp_len != vchnl_req->parm_len)
			return -EBADMSG;
		break;
	case IRDMA_VCHNL_OP_GET_RDMA_CAPS:
		if (resp_len < IRDMA_VCHNL_OP_GET_RDMA_CAPS_MIN_SIZE)
			return -EBADMSG;
		break;
	case IRDMA_VCHNL_OP_GET_REG_LAYOUT:
	case IRDMA_VCHNL_OP_QUEUE_VECTOR_MAP:
	case IRDMA_VCHNL_OP_QUEUE_VECTOR_UNMAP:
	case IRDMA_VCHNL_OP_ADD_VPORT:
	case IRDMA_VCHNL_OP_DEL_VPORT:
		break;
	default:
		return -EOPNOTSUPP;
	}

	return 0;
}

static void irdma_free_vchnl_req_msg(struct irdma_vchnl_req *vchnl_req)
{
	kfree(vchnl_req->vchnl_msg);
}

static int irdma_alloc_vchnl_req_msg(struct irdma_vchnl_req *vchnl_req,
				     struct irdma_vchnl_req_init_info *info)
{
	struct irdma_vchnl_op_buf *vchnl_msg;

	vchnl_msg = kzalloc(IRDMA_VCHNL_MAX_MSG_SIZE, GFP_KERNEL);

	if (!vchnl_msg)
		return -ENOMEM;

	vchnl_msg->op_ctx = (uintptr_t)vchnl_req;
	vchnl_msg->buf_len = sizeof(*vchnl_msg) + info->req_parm_len;
	if (info->req_parm_len)
		memcpy(vchnl_msg->buf, info->req_parm, info->req_parm_len);
	vchnl_msg->op_code = info->op_code;
	vchnl_msg->op_ver = info->op_ver;

	vchnl_req->vchnl_msg = vchnl_msg;
	vchnl_req->parm = info->resp_parm;
	vchnl_req->parm_len = info->resp_parm_len;

	return 0;
}

static int irdma_vchnl_req_send_sync(struct irdma_sc_dev *dev,
				     struct irdma_vchnl_req_init_info *info)
{
	u16 resp_len = sizeof(dev->vc_recv_buf);
	struct irdma_vchnl_req vchnl_req = {};
	u16 msg_len;
	u8 *msg;
	int ret;

	ret = irdma_alloc_vchnl_req_msg(&vchnl_req, info);
	if (ret)
		return ret;

	msg_len = vchnl_req.vchnl_msg->buf_len;
	msg = (u8 *)vchnl_req.vchnl_msg;

	mutex_lock(&dev->vchnl_mutex);
	ret = ig3rdma_vchnl_send_sync(dev, msg, msg_len, dev->vc_recv_buf,
				      &resp_len);
	dev->vc_recv_len = resp_len;
	if (ret)
		goto exit;

	ret = irdma_vchnl_req_get_resp(dev, &vchnl_req);
exit:
	mutex_unlock(&dev->vchnl_mutex);
	ibdev_dbg(to_ibdev(dev),
		  "VIRT: virtual channel send %s caller: %pS ret=%d op=%u op_ver=%u req_len=%u parm_len=%u resp_len=%u\n",
		  !ret ? "SUCCEEDS" : "FAILS", __builtin_return_address(0),
		  ret, vchnl_req.vchnl_msg->op_code,
		  vchnl_req.vchnl_msg->op_ver, vchnl_req.vchnl_msg->buf_len,
		  vchnl_req.parm_len, vchnl_req.resp_len);
	irdma_free_vchnl_req_msg(&vchnl_req);

	return ret;
}

/**
 * irdma_vchnl_req_get_reg_layout - Get Register Layout
 * @dev: RDMA device pointer
 */
int irdma_vchnl_req_get_reg_layout(struct irdma_sc_dev *dev)
{
	u16 reg_idx, reg_id, tmp_reg_id, regfld_idx, regfld_id, tmp_regfld_id;
	struct irdma_vchnl_reg_field_info *regfld_array = NULL;
	u8 resp_buffer[IRDMA_REGMAP_RESP_BUF_SIZE] = {};
	struct vchnl_regfld_map_elem *regfld_map_array;
	struct irdma_vchnl_req_init_info info = {};
	struct vchnl_reg_map_elem *reg_map_array;
	struct irdma_vchnl_reg_info *reg_array;
	u8 num_bits, shift_cnt;
	u16 buf_len = 0;
	u64 bitmask;
	u32 rindex;
	int ret;

	if (!dev->vchnl_up)
		return -EBUSY;

	info.op_code = IRDMA_VCHNL_OP_GET_REG_LAYOUT;
	info.op_ver = IRDMA_VCHNL_OP_GET_REG_LAYOUT_V0;
	info.resp_parm = resp_buffer;
	info.resp_parm_len = sizeof(resp_buffer);

	ret = irdma_vchnl_req_send_sync(dev, &info);

	if (ret)
		return ret;

	/* parse the response buffer and update reg info*/
	/* Parse registers till invalid */
	/* Parse register fields till invalid */
	reg_array = (struct irdma_vchnl_reg_info *)resp_buffer;
	for (rindex = 0; rindex < IRDMA_VCHNL_REG_COUNT; rindex++) {
		buf_len += sizeof(struct irdma_vchnl_reg_info);
		if (buf_len >= sizeof(resp_buffer))
			return -ENOMEM;

		regfld_array =
			(struct irdma_vchnl_reg_field_info *)&reg_array[rindex + 1];
		reg_id = reg_array[rindex].reg_id;
		if (reg_id == IRDMA_VCHNL_REG_INV_ID)
			break;

		reg_id &= ~IRDMA_VCHNL_REG_PAGE_REL;
		if (reg_id >= IRDMA_VCHNL_REG_COUNT)
			return -EINVAL;

		/* search regmap for register index in hw_regs.*/
		reg_map_array = vchnl_reg_map;
		do {
			tmp_reg_id = reg_map_array->reg_id;
			if (tmp_reg_id == reg_id)
				break;

			reg_map_array++;
		} while (tmp_reg_id != IRDMA_VCHNL_REG_INV_ID);
		if (tmp_reg_id != reg_id)
			continue;

		reg_idx = reg_map_array->reg_idx;

		/* Page relative, DB Offset do not need bar offset */
		if (reg_idx == IRDMA_DB_ADDR_OFFSET ||
		    (reg_array[rindex].reg_id & IRDMA_VCHNL_REG_PAGE_REL)) {
			dev->hw_regs[reg_idx] =
				(u32 __iomem *)(uintptr_t)reg_array[rindex].reg_offset;
			continue;
		}

		/* Update the local HW struct */
		dev->hw_regs[reg_idx] = ig3rdma_get_reg_addr(dev->hw,
						reg_array[rindex].reg_offset);
		if (!dev->hw_regs[reg_idx])
			return -EINVAL;
	}

	if (!regfld_array)
		return -ENOMEM;

	/* set up doorbell variables using mapped DB page */
	dev->wqe_alloc_db = dev->hw_regs[IRDMA_WQEALLOC];
	dev->cq_arm_db = dev->hw_regs[IRDMA_CQARM];
	dev->aeq_alloc_db = dev->hw_regs[IRDMA_AEQALLOC];
	dev->cqp_db = dev->hw_regs[IRDMA_CQPDB];
	dev->cq_ack_db = dev->hw_regs[IRDMA_CQACK];

	for (rindex = 0; rindex < IRDMA_VCHNL_REGFLD_COUNT; rindex++) {
		buf_len += sizeof(struct irdma_vchnl_reg_field_info);
		if ((buf_len - 1) > sizeof(resp_buffer))
			break;

		if (regfld_array[rindex].fld_id == IRDMA_VCHNL_REGFLD_INV_ID)
			break;

		regfld_id = regfld_array[rindex].fld_id;
		regfld_map_array = vchnl_regfld_map;
		do {
			tmp_regfld_id = regfld_map_array->regfld_id;
			if (tmp_regfld_id == regfld_id)
				break;

			regfld_map_array++;
		} while (tmp_regfld_id != IRDMA_VCHNL_REGFLD_INV_ID);

		if (tmp_regfld_id != regfld_id)
			continue;

		regfld_idx = regfld_map_array->regfld_idx;

		num_bits = regfld_array[rindex].fld_bits;
		shift_cnt = regfld_array[rindex].fld_shift;
		if ((num_bits + shift_cnt > 64) || !num_bits) {
			ibdev_dbg(to_ibdev(dev),
				  "ERR: Invalid field mask id %d bits %d shift %d",
				  regfld_id, num_bits, shift_cnt);

			continue;
		}

		bitmask = (1ULL << num_bits) - 1;
		dev->hw_masks[regfld_idx] = bitmask << shift_cnt;
		dev->hw_shifts[regfld_idx] = shift_cnt;
	}

	return 0;
}

int irdma_vchnl_req_add_vport(struct irdma_sc_dev *dev, u16 vport_id,
			      u32 qp1_id, struct irdma_qos *qos)
{
	struct irdma_vchnl_resp_vport_info resp_vport = { 0 };
	struct irdma_vchnl_req_vport_info req_vport = { 0 };
	struct irdma_vchnl_req_init_info info = { 0 };
	int ret, i;

	if (!dev->vchnl_up)
		return -EBUSY;

	info.op_code = IRDMA_VCHNL_OP_ADD_VPORT;
	info.op_ver = IRDMA_VCHNL_OP_ADD_VPORT_V0;
	req_vport.vport_id = vport_id;
	req_vport.qp1_id = qp1_id;
	info.req_parm_len = sizeof(req_vport);
	info.req_parm = &req_vport;
	info.resp_parm = &resp_vport;
	info.resp_parm_len = sizeof(resp_vport);

	ret = irdma_vchnl_req_send_sync(dev, &info);
	if (ret)
		return ret;

	for (i = 0;  i < IRDMA_MAX_USER_PRIORITY; i++) {
		qos[i].qs_handle = resp_vport.qs_handle[i];
		qos[i].valid = true;
	}

	return 0;
}

int irdma_vchnl_req_del_vport(struct irdma_sc_dev *dev, u16 vport_id, u32 qp1_id)
{
	struct irdma_vchnl_req_init_info info = { 0 };
	struct irdma_vchnl_req_vport_info req_vport = { 0 };

	if (!dev->vchnl_up)
		return -EBUSY;

	info.op_code = IRDMA_VCHNL_OP_DEL_VPORT;
	info.op_ver = IRDMA_VCHNL_OP_DEL_VPORT_V0;
	req_vport.vport_id = vport_id;
	req_vport.qp1_id = qp1_id;
	info.req_parm_len = sizeof(req_vport);
	info.req_parm = &req_vport;

	return irdma_vchnl_req_send_sync(dev, &info);
}

/**
 * irdma_vchnl_req_aeq_vec_map - Map AEQ to vector on this function
 * @dev: RDMA device pointer
 * @v_idx: vector index
 */
int irdma_vchnl_req_aeq_vec_map(struct irdma_sc_dev *dev, u32 v_idx)
{
	struct irdma_vchnl_req_init_info info = {};
	struct irdma_vchnl_qvlist_info *qvl;
	struct irdma_vchnl_qv_info *qv;
	u16 qvl_size, num_vectors = 1;
	int ret;

	if (!dev->vchnl_up)
		return -EBUSY;

	qvl_size = struct_size(qvl, qv_info, num_vectors);

	qvl = kzalloc(qvl_size, GFP_KERNEL);
	if (!qvl)
		return -ENOMEM;

	qvl->num_vectors = 1;
	qv = qvl->qv_info;

	qv->ceq_idx = IRDMA_Q_INVALID_IDX;
	qv->v_idx = v_idx;
	qv->itr_idx = IRDMA_IDX_ITR0;

	info.op_code = IRDMA_VCHNL_OP_QUEUE_VECTOR_MAP;
	info.op_ver = IRDMA_VCHNL_OP_QUEUE_VECTOR_MAP_V0;
	info.req_parm = qvl;
	info.req_parm_len = qvl_size;

	ret = irdma_vchnl_req_send_sync(dev, &info);
	kfree(qvl);

	return ret;
}

/**
 * irdma_vchnl_req_ceq_vec_map - Map CEQ to vector on this function
 * @dev: RDMA device pointer
 * @ceq_id: CEQ index
 * @v_idx: vector index
 */
int irdma_vchnl_req_ceq_vec_map(struct irdma_sc_dev *dev, u16 ceq_id, u32 v_idx)
{
	struct irdma_vchnl_req_init_info info = {};
	struct irdma_vchnl_qvlist_info *qvl;
	struct irdma_vchnl_qv_info *qv;
	u16 qvl_size, num_vectors = 1;
	int ret;

	if (!dev->vchnl_up)
		return -EBUSY;

	qvl_size = struct_size(qvl, qv_info, num_vectors);

	qvl = kzalloc(qvl_size, GFP_KERNEL);
	if (!qvl)
		return -ENOMEM;

	qvl->num_vectors = num_vectors;
	qv = qvl->qv_info;

	qv->aeq_idx = IRDMA_Q_INVALID_IDX;
	qv->ceq_idx = ceq_id;
	qv->v_idx = v_idx;
	qv->itr_idx = IRDMA_IDX_ITR0;

	info.op_code = IRDMA_VCHNL_OP_QUEUE_VECTOR_MAP;
	info.op_ver = IRDMA_VCHNL_OP_QUEUE_VECTOR_MAP_V0;
	info.req_parm = qvl;
	info.req_parm_len = qvl_size;

	ret = irdma_vchnl_req_send_sync(dev, &info);
	kfree(qvl);

	return ret;
}

/**
 * irdma_vchnl_req_get_ver - Request Channel version
 * @dev: RDMA device pointer
 * @ver_req: Virtual channel version requested
 * @ver_res: Virtual channel version response
 */
int irdma_vchnl_req_get_ver(struct irdma_sc_dev *dev, u16 ver_req, u32 *ver_res)
{
	struct irdma_vchnl_req_init_info info = {};
	int ret;

	if (!dev->vchnl_up)
		return -EBUSY;

	info.op_code = IRDMA_VCHNL_OP_GET_VER;
	info.op_ver = ver_req;
	info.resp_parm = ver_res;
	info.resp_parm_len = sizeof(*ver_res);

	ret = irdma_vchnl_req_send_sync(dev, &info);
	if (ret)
		return ret;

	if (*ver_res < IRDMA_VCHNL_CHNL_VER_MIN) {
		ibdev_dbg(to_ibdev(dev),
			  "VIRT: %s unsupported vchnl version 0x%0x\n",
			  __func__, *ver_res);
		return -EOPNOTSUPP;
	}

	return 0;
}

/**
 * irdma_vchnl_req_get_hmc_fcn - Request VF HMC Function
 * @dev: RDMA device pointer
 */
int irdma_vchnl_req_get_hmc_fcn(struct irdma_sc_dev *dev)
{
	struct irdma_vchnl_req_hmc_info req_hmc = {};
	struct irdma_vchnl_resp_hmc_info resp_hmc = {};
	struct irdma_vchnl_req_init_info info = {};
	int ret;

	if (!dev->vchnl_up)
		return -EBUSY;

	info.op_code = IRDMA_VCHNL_OP_GET_HMC_FCN;
	if (dev->hw_attrs.uk_attrs.hw_rev >= IRDMA_GEN_3) {
		info.op_ver = IRDMA_VCHNL_OP_GET_HMC_FCN_V2;
		req_hmc.protocol_used = dev->protocol_used;
		info.req_parm_len = sizeof(req_hmc);
		info.req_parm = &req_hmc;
		info.resp_parm = &resp_hmc;
		info.resp_parm_len = sizeof(resp_hmc);
	}

	ret = irdma_vchnl_req_send_sync(dev, &info);

	if (ret)
		return ret;

	if (dev->hw_attrs.uk_attrs.hw_rev >= IRDMA_GEN_3) {
		int i;

		dev->hmc_fn_id = resp_hmc.hmc_func;

		for (i = 0;  i < IRDMA_MAX_USER_PRIORITY; i++) {
			dev->qos[i].qs_handle = resp_hmc.qs_handle[i];
			dev->qos[i].valid = true;
		}
	}
	return 0;
}

/**
 * irdma_vchnl_req_put_hmc_fcn - Free VF HMC Function
 * @dev: RDMA device pointer
 */
int irdma_vchnl_req_put_hmc_fcn(struct irdma_sc_dev *dev)
{
	struct irdma_vchnl_req_init_info info = {};

	if (!dev->vchnl_up)
		return -EBUSY;

	info.op_code = IRDMA_VCHNL_OP_PUT_HMC_FCN;
	info.op_ver = IRDMA_VCHNL_OP_PUT_HMC_FCN_V0;

	return irdma_vchnl_req_send_sync(dev, &info);
}

/**
 * irdma_vchnl_req_get_caps - Request RDMA capabilities
 * @dev: RDMA device pointer
 */
int irdma_vchnl_req_get_caps(struct irdma_sc_dev *dev)
{
	struct irdma_vchnl_req_init_info info = {};
	int ret;

	if (!dev->vchnl_up)
		return -EBUSY;

	info.op_code = IRDMA_VCHNL_OP_GET_RDMA_CAPS;
	info.op_ver = IRDMA_VCHNL_OP_GET_RDMA_CAPS_V0;
	info.resp_parm = &dev->vc_caps;
	info.resp_parm_len = sizeof(dev->vc_caps);

	ret = irdma_vchnl_req_send_sync(dev, &info);

	if (ret)
		return ret;

	if (dev->vc_caps.hw_rev > IRDMA_GEN_MAX ||
	    dev->vc_caps.hw_rev < IRDMA_GEN_2) {
		ibdev_dbg(to_ibdev(dev),
			  "ERR: %s unsupported hw_rev version 0x%0x\n",
			  __func__, dev->vc_caps.hw_rev);
		return -EOPNOTSUPP;
	}

	return 0;
}

/**
 * irdma_vchnl_req_get_resp - Receive the inbound vchnl response.
 * @dev: Dev pointer
 * @vchnl_req: Vchannel request
 */
int irdma_vchnl_req_get_resp(struct irdma_sc_dev *dev,
			     struct irdma_vchnl_req *vchnl_req)
{
	struct irdma_vchnl_resp_buf *vchnl_msg_resp =
		(struct irdma_vchnl_resp_buf *)dev->vc_recv_buf;
	u16 resp_len;
	int ret;

	if ((uintptr_t)vchnl_req != (uintptr_t)vchnl_msg_resp->op_ctx) {
		ibdev_dbg(to_ibdev(dev),
			  "VIRT: error vchnl context value does not match\n");
		return -EBADMSG;
	}

	resp_len = dev->vc_recv_len - sizeof(*vchnl_msg_resp);
	resp_len = min(resp_len, vchnl_req->parm_len);

	ret = irdma_vchnl_req_verify_resp(vchnl_req, resp_len);
	if (ret)
		return ret;

	ret = (int)vchnl_msg_resp->op_ret;
	if (ret)
		return ret;

	vchnl_req->resp_len = 0;
	if (vchnl_req->parm_len && vchnl_req->parm && resp_len) {
		memcpy(vchnl_req->parm, vchnl_msg_resp->buf, resp_len);
		vchnl_req->resp_len = resp_len;
		ibdev_dbg(to_ibdev(dev), "VIRT: Got response, data size %u\n",
			  resp_len);
	}

	return 0;
}