Commit 6d921fa7 authored by Yanling Song's avatar Yanling Song Committed by Zheng Zengkai
Browse files

net/spnic:Remove unused clp hardware channels 

Ramaxel inclusion
category: bugfix
bugzilla: https://gitee.com/openeuler/kernel/issues/I4P01N


CVE: NA

Delete all functions about clp hardware channels
since the driver does not use clp hardware channel.

Signed-off-by: default avatarYanling Song <songyl@ramaxel.com>
Reviewed-by: default avatarYang Gan <yanggan@ramaxel.com>
Acked-by: default avatarXie XiuQi <xiexiuqi@huawei.com>
Acked-by: default avatarXie XiuQi <xiexiuqi@huawei.com>
Signed-off-by: default avatarZheng Zengkai <zhengzengkai@huawei.com>
parent c8825dd3

drivers/net/ethernet/ramaxel/spnic/hw/sphw_csr.h

+0 −13
Original line number Diff line number Diff line
@@ -39,19 +39,6 @@ 
			(SPHW_CFG_REGS_FLAG + 0x0108)

#define SPHW_FUNC_CSR_MAILBOX_RESULT_L_OFF		\

			(SPHW_CFG_REGS_FLAG + 0x010C)

/*CLP registers*/

#define SPHW_BAR3_CLP_BASE_ADDR		(SPHW_MGMT_REGS_FLAG + 0x0000)



#define SPHW_UCPU_CLP_SIZE_REG		(SPHW_HOST_CSR_BASE_ADDR + 0x40)

#define SPHW_UCPU_CLP_REQBASE_REG	(SPHW_HOST_CSR_BASE_ADDR + 0x44)

#define SPHW_UCPU_CLP_RSPBASE_REG	(SPHW_HOST_CSR_BASE_ADDR + 0x48)

#define SPHW_UCPU_CLP_REQ_REG		(SPHW_HOST_CSR_BASE_ADDR + 0x4c)

#define SPHW_UCPU_CLP_RSP_REG		(SPHW_HOST_CSR_BASE_ADDR + 0x50)

#define SPHW_CLP_REG(member)		(SPHW_UCPU_CLP_##member##_REG)



#define SPHW_CLP_REQ_DATA		SPHW_BAR3_CLP_BASE_ADDR

#define SPHW_CLP_RSP_DATA		(SPHW_BAR3_CLP_BASE_ADDR + 0x1000)

#define SPHW_CLP_DATA(member)		(SPHW_CLP_##member##_DATA)



#define SPHW_PPF_ELECTION_OFFSET		0x0

#define SPHW_MPF_ELECTION_OFFSET		0x20

drivers/net/ethernet/ramaxel/spnic/hw/sphw_hw.h

+0 −2
Original line number Diff line number Diff line
@@ -482,8 +482,6 @@ int sphw_mbox_to_pf(void *hwdev, u8 mod, u16 cmd, void *buf_in, u16 in_size, voi 
int sphw_mbox_to_vf(void *hwdev, u16 vf_id, u8 mod, u16 cmd, void *buf_in,

		    u16 in_size, void *buf_out, u16 *out_size, u32 timeout, u16 channel);



int sphw_clp_to_mgmt(void *hwdev, u8 mod, u16 cmd, const void *buf_in,

		     u16 in_size, void *buf_out, u16 *out_size);

/**

 * @brief sphw_cmdq_async - cmdq asynchronous message

 * @param hwdev: device pointer to hwdev

drivers/net/ethernet/ramaxel/spnic/hw/sphw_hwdev.c

+0 −30
Original line number Diff line number Diff line
@@ -455,28 +455,6 @@ static int init_ceqs_msix_attr(struct sphw_hwdev *hwdev) 
	return 0;

}



static int sphw_comm_clp_to_mgmt_init(struct sphw_hwdev *hwdev)

{

	int err;



	if (sphw_func_type(hwdev) == TYPE_VF)

		return 0;



	err = sphw_clp_pf_to_mgmt_init(hwdev);

	if (err)

		return err;



	return 0;

}



static void sphw_comm_clp_to_mgmt_free(struct sphw_hwdev *hwdev)

{

	if (sphw_func_type(hwdev) == TYPE_VF)

		return;



	sphw_clp_pf_to_mgmt_free(hwdev);

}



static int sphw_comm_aeqs_init(struct sphw_hwdev *hwdev)

{

	struct irq_info aeq_irqs[SPHW_MAX_AEQS] = {{0} };
@@ -777,15 +755,8 @@ static int init_pf_mgmt_channel(struct sphw_hwdev *hwdev) 
{

	int err;



	err = sphw_comm_clp_to_mgmt_init(hwdev);

	if (err) {

		sdk_err(hwdev->dev_hdl, "Failed to init clp\n");

		return err;

	}



	err = sphw_comm_pf_to_mgmt_init(hwdev);

	if (err) {

		sphw_comm_clp_to_mgmt_free(hwdev);

		sdk_err(hwdev->dev_hdl, "Failed to init pf to mgmt\n");

		return err;

	}
@@ -795,7 +766,6 @@ static int init_pf_mgmt_channel(struct sphw_hwdev *hwdev) 


static void free_pf_mgmt_channel(struct sphw_hwdev *hwdev)

{

	sphw_comm_clp_to_mgmt_free(hwdev);

	sphw_comm_pf_to_mgmt_free(hwdev);

}

drivers/net/ethernet/ramaxel/spnic/hw/sphw_hwdev.h

+0 −1
Original line number Diff line number Diff line
@@ -55,7 +55,6 @@ struct sphw_hwdev { 
	struct sphw_ceqs *ceqs;

	struct sphw_mbox *func_to_func;

	struct sphw_msg_pf_to_mgmt *pf_to_mgmt;

	struct sphw_clp_pf_to_mgmt *clp_pf_to_mgmt;



	void *cqm_hdl;

	struct mqm_addr_trans_tbl_info mqm_att;

drivers/net/ethernet/ramaxel/spnic/hw/sphw_mgmt.c

+0 −487
Original line number Diff line number Diff line
@@ -174,28 +174,6 @@ static void prepare_header(struct sphw_msg_pf_to_mgmt *pf_to_mgmt, 
		SPHW_MSG_HEADER_SET(msg_id, MSG_ID);

}



static void clp_prepare_header(struct sphw_hwdev *hwdev, u64 *header,

			       u16 msg_len, u8 mod,

			       enum sphw_msg_ack_type ack_type,

			       enum sphw_msg_direction_type direction,

			       enum sphw_mgmt_cmd cmd, u32 msg_id)

{

	struct sphw_hwif *hwif = hwdev->hwif;



	*header = SPHW_MSG_HEADER_SET(msg_len, MSG_LEN) |

		SPHW_MSG_HEADER_SET(mod, MODULE) |

		SPHW_MSG_HEADER_SET(msg_len, SEG_LEN) |

		SPHW_MSG_HEADER_SET(ack_type, NO_ACK) |

		SPHW_MSG_HEADER_SET(SPHW_DATA_INLINE, DATA_TYPE) |

		SPHW_MSG_HEADER_SET(0, SEQID) |

		SPHW_MSG_HEADER_SET(SPHW_API_CHAIN_AEQ_ID, AEQ_ID) |

		SPHW_MSG_HEADER_SET(LAST_SEGMENT, LAST) |

		SPHW_MSG_HEADER_SET(direction, DIRECTION) |

		SPHW_MSG_HEADER_SET(cmd, CMD) |

		SPHW_MSG_HEADER_SET(hwif->attr.func_global_idx, SRC_GLB_FUNC_IDX) |

		SPHW_MSG_HEADER_SET(msg_id, MSG_ID);

}



/**

 * prepare_mgmt_cmd - prepare the mgmt command

 * @mgmt_cmd: pointer to the command to prepare
@@ -515,8 +493,6 @@ static void mgmt_recv_msg_handler(struct sphw_msg_pf_to_mgmt *pf_to_mgmt, 
		goto resp;

	}



	/* TO DO some message need to ack first*/



	pf_to_mgmt->recv_mgmt_msg_cb[tmp_mod](pf_to_mgmt->hwdev,

					      pf_to_mgmt->recv_mgmt_msg_data[tmp_mod],

					      cmd, buf_in, in_size, buf_out, &out_size);
@@ -917,466 +893,3 @@ int sphw_api_cmd_write_nack(void *hwdev, u8 dest, const void *cmd, u16 size) 


	return sphw_api_cmd_write(chain, dest, cmd, size);

}
 


static int get_clp_reg(void *hwdev, enum clp_data_type data_type,

		       enum clp_reg_type reg_type, u32 *reg_addr)

{

	struct sphw_hwdev *dev = hwdev;

	u32 offset;



	offset = SPHW_CLP_REG_GAP * sphw_pcie_itf_id(dev);



	switch (reg_type) {

	case SPHW_CLP_BA_HOST:

		*reg_addr = (data_type == SPHW_CLP_REQ_HOST) ?

			     SPHW_CLP_REG(REQBASE) :

			     SPHW_CLP_REG(RSPBASE);

		break;



	case SPHW_CLP_SIZE_HOST:

		*reg_addr = SPHW_CLP_REG(SIZE);

		break;



	case SPHW_CLP_LEN_HOST:

		*reg_addr = (data_type == SPHW_CLP_REQ_HOST) ?

			     SPHW_CLP_REG(REQ) : SPHW_CLP_REG(RSP);

		break;



	case SPHW_CLP_START_REQ_HOST:

		*reg_addr = SPHW_CLP_REG(REQ);

		break;



	case SPHW_CLP_READY_RSP_HOST:

		*reg_addr = SPHW_CLP_REG(RSP);

		break;



	default:

		*reg_addr = 0;

		break;

	}

	if (*reg_addr == 0)

		return -EINVAL;



	*reg_addr += offset;



	return 0;

}



static inline int clp_param_valid(struct sphw_hwdev *hwdev,

				  enum clp_data_type data_type,

				  enum clp_reg_type reg_type)

{

	if (data_type == SPHW_CLP_REQ_HOST &&

	    reg_type == SPHW_CLP_READY_RSP_HOST)

		return -EINVAL;



	if (data_type == SPHW_CLP_RSP_HOST &&

	    reg_type == SPHW_CLP_START_REQ_HOST)

		return -EINVAL;



	return 0;

}



static u32 get_clp_reg_value(struct sphw_hwdev *hwdev,

			     enum clp_data_type data_type,

			     enum clp_reg_type reg_type, u32 reg_addr)

{

	u32 value;



	value = sphw_hwif_read_reg(hwdev->hwif, reg_addr);



	switch (reg_type) {

	case SPHW_CLP_BA_HOST:

		value = ((value >> SPHW_CLP_OFFSET(BASE)) &

			SPHW_CLP_MASK(BASE));

		break;



	case SPHW_CLP_SIZE_HOST:

		if (data_type == SPHW_CLP_REQ_HOST)

			value = ((value >> SPHW_CLP_OFFSET(REQ_SIZE)) &

				SPHW_CLP_MASK(SIZE));

		else

			value = ((value >> SPHW_CLP_OFFSET(RSP_SIZE)) &

				SPHW_CLP_MASK(SIZE));

		break;



	case SPHW_CLP_LEN_HOST:

		value = ((value >> SPHW_CLP_OFFSET(LEN)) &

			SPHW_CLP_MASK(LEN));

		break;



	case SPHW_CLP_START_REQ_HOST:

		value = ((value >> SPHW_CLP_OFFSET(START)) &

			SPHW_CLP_MASK(START));

		break;



	case SPHW_CLP_READY_RSP_HOST:

		value = ((value >> SPHW_CLP_OFFSET(READY)) &

			SPHW_CLP_MASK(READY));

		break;



	default:

		break;

	}



	return value;

}



static int sphw_read_clp_reg(struct sphw_hwdev *hwdev, enum clp_data_type data_type,

			     enum clp_reg_type reg_type, u32 *read_value)

{

	u32 reg_addr;

	int err;



	err = clp_param_valid(hwdev, data_type, reg_type);

	if (err)

		return err;



	err = get_clp_reg(hwdev, data_type, reg_type, &reg_addr);

	if (err)

		return err;



	*read_value = get_clp_reg_value(hwdev, data_type, reg_type, reg_addr);



	return 0;

}



static int check_data_type(enum clp_data_type data_type, enum clp_reg_type reg_type)

{

	if (data_type == SPHW_CLP_REQ_HOST &&

	    reg_type == SPHW_CLP_READY_RSP_HOST)

		return -EINVAL;

	if (data_type == SPHW_CLP_RSP_HOST &&

	    reg_type == SPHW_CLP_START_REQ_HOST)

		return -EINVAL;



	return 0;

}



static int check_reg_value(enum clp_reg_type reg_type, u32 value)

{

	if (reg_type == SPHW_CLP_BA_HOST &&

	    value > SPHW_CLP_SRAM_BASE_REG_MAX)

		return -EINVAL;



	if (reg_type == SPHW_CLP_SIZE_HOST &&

	    value > SPHW_CLP_SRAM_SIZE_REG_MAX)

		return -EINVAL;



	if (reg_type == SPHW_CLP_LEN_HOST &&

	    value > SPHW_CLP_LEN_REG_MAX)

		return -EINVAL;



	if ((reg_type == SPHW_CLP_START_REQ_HOST ||

	     reg_type == SPHW_CLP_READY_RSP_HOST) &&

	    value > SPHW_CLP_START_OR_READY_REG_MAX)

		return -EINVAL;



	return 0;

}



static int sphw_check_clp_init_status(struct sphw_hwdev *hwdev)

{

	int err;

	u32 reg_value = 0;



	err = sphw_read_clp_reg(hwdev, SPHW_CLP_REQ_HOST, SPHW_CLP_BA_HOST, &reg_value);

	if (err || !reg_value) {

		sdk_err(hwdev->dev_hdl, "Wrong req ba value: 0x%x\n",

			reg_value);

		return -EINVAL;

	}



	err = sphw_read_clp_reg(hwdev, SPHW_CLP_RSP_HOST, SPHW_CLP_BA_HOST, &reg_value);

	if (err || !reg_value) {

		sdk_err(hwdev->dev_hdl, "Wrong rsp ba value: 0x%x\n",

			reg_value);

		return -EINVAL;

	}



	err = sphw_read_clp_reg(hwdev, SPHW_CLP_REQ_HOST, SPHW_CLP_SIZE_HOST, &reg_value);

	if (err || !reg_value) {

		sdk_err(hwdev->dev_hdl, "Wrong req size\n");

		return -EINVAL;

	}



	err = sphw_read_clp_reg(hwdev, SPHW_CLP_RSP_HOST, SPHW_CLP_SIZE_HOST, &reg_value);

	if (err || !reg_value) {

		sdk_err(hwdev->dev_hdl, "Wrong rsp size\n");

		return -EINVAL;

	}



	return 0;

}



static void sphw_write_clp_reg(struct sphw_hwdev *hwdev, enum clp_data_type data_type,

			       enum clp_reg_type reg_type, u32 value)

{

	u32 reg_addr, reg_value;



	if (check_data_type(data_type, reg_type))

		return;



	if (check_reg_value(reg_type, value))

		return;



	if (get_clp_reg(hwdev, data_type, reg_type, &reg_addr))

		return;



	reg_value = sphw_hwif_read_reg(hwdev->hwif, reg_addr);



	switch (reg_type) {

	case SPHW_CLP_LEN_HOST:

		reg_value = reg_value &

			    (~(SPHW_CLP_MASK(LEN) << SPHW_CLP_OFFSET(LEN)));

		reg_value = reg_value | (value << SPHW_CLP_OFFSET(LEN));

		break;



	case SPHW_CLP_START_REQ_HOST:

		reg_value = reg_value &

			    (~(SPHW_CLP_MASK(START) <<

			      SPHW_CLP_OFFSET(START)));

		reg_value = reg_value | (value << SPHW_CLP_OFFSET(START));

		break;



	case SPHW_CLP_READY_RSP_HOST:

		reg_value = reg_value &

			    (~(SPHW_CLP_MASK(READY) <<

			    SPHW_CLP_OFFSET(READY)));

		reg_value = reg_value | (value << SPHW_CLP_OFFSET(READY));

		break;



	default:

		return;

	}



	sphw_hwif_write_reg(hwdev->hwif, reg_addr, reg_value);

}



static int sphw_read_clp_data(struct sphw_hwdev *hwdev, void *buf_out, u16 *out_size)

{

	int err;

	u32 reg = SPHW_CLP_DATA(RSP);

	u32 ready, delay_cnt;

	u32 *ptr = (u32 *)buf_out;

	u32 temp_out_size = 0;



	err = sphw_read_clp_reg(hwdev, SPHW_CLP_RSP_HOST, SPHW_CLP_READY_RSP_HOST, &ready);

	if (err)

		return err;



	delay_cnt = 0;

	while (ready == 0) {

		usleep_range(9000, 10000);

		delay_cnt++;

		err = sphw_read_clp_reg(hwdev, SPHW_CLP_RSP_HOST, SPHW_CLP_READY_RSP_HOST, &ready);

		if (err || delay_cnt > SPHW_CLP_DELAY_CNT_MAX) {

			sdk_err(hwdev->dev_hdl, "Timeout with delay_cnt: %u\n",

				delay_cnt);

			return -EINVAL;

		}

	}



	err = sphw_read_clp_reg(hwdev, SPHW_CLP_RSP_HOST, SPHW_CLP_LEN_HOST, &temp_out_size);

	if (err)

		return err;



	if (temp_out_size > SPHW_CLP_SRAM_SIZE_REG_MAX || !temp_out_size) {

		sdk_err(hwdev->dev_hdl, "Invalid temp_out_size: %u\n",

			temp_out_size);

		return -EINVAL;

	}



	*out_size = (u16)temp_out_size;

	for (; temp_out_size > 0; temp_out_size--) {

		*ptr = sphw_hwif_read_reg(hwdev->hwif, reg);

		ptr++;

		/* read 4 bytes every time */

		reg = reg + 4;

	}



	sphw_write_clp_reg(hwdev, SPHW_CLP_RSP_HOST, SPHW_CLP_READY_RSP_HOST, (u32)0x0);

	sphw_write_clp_reg(hwdev, SPHW_CLP_RSP_HOST, SPHW_CLP_LEN_HOST, (u32)0x0);



	return 0;

}



static int sphw_write_clp_data(struct sphw_hwdev *hwdev, void *buf_in, u16 in_size)

{

	int err;

	u32 reg = SPHW_CLP_DATA(REQ);

	u32 start = 1;

	u32 delay_cnt = 0;

	u32 *ptr = (u32 *)buf_in;



	err = sphw_read_clp_reg(hwdev, SPHW_CLP_REQ_HOST, SPHW_CLP_START_REQ_HOST, &start);

	if (err)

		return err;



	while (start == 1) {

		usleep_range(9000, 10000);

		delay_cnt++;

		err = sphw_read_clp_reg(hwdev, SPHW_CLP_REQ_HOST, SPHW_CLP_START_REQ_HOST, &start);

		if (err || delay_cnt > SPHW_CLP_DELAY_CNT_MAX)

			return -EINVAL;

	}



	sphw_write_clp_reg(hwdev, SPHW_CLP_REQ_HOST, SPHW_CLP_LEN_HOST, in_size);

	sphw_write_clp_reg(hwdev, SPHW_CLP_REQ_HOST, SPHW_CLP_START_REQ_HOST, (u32)0x1);



	for (; in_size > 0; in_size--) {

		sphw_hwif_write_reg(hwdev->hwif, reg, *ptr);

		ptr++;

		reg = reg + 4;

	}



	return 0;

}



static void sphw_clear_clp_data(struct sphw_hwdev *hwdev, enum clp_data_type data_type)

{

	u32 reg = (data_type == SPHW_CLP_REQ_HOST) ?

		   SPHW_CLP_DATA(REQ) : SPHW_CLP_DATA(RSP);

	u32 count = SPHW_CLP_INPUT_BUF_LEN_HOST / SPHW_CLP_DATA_UNIT_HOST;



	for (; count > 0; count--) {

		sphw_hwif_write_reg(hwdev->hwif, reg, 0x0);

		reg = reg + 4;

	}

}



int sphw_pf_clp_to_mgmt(void *hwdev, u8 mod, u16 cmd, const void *buf_in,

			u16 in_size, void *buf_out, u16 *out_size)

{

	struct sphw_clp_pf_to_mgmt *clp_pf_to_mgmt;

	struct sphw_hwdev *dev = hwdev;

	u64 header;

	u16 real_size;

	u8 *clp_msg_buf;

	int err;



	clp_pf_to_mgmt = ((struct sphw_hwdev *)hwdev)->clp_pf_to_mgmt;

	clp_msg_buf = clp_pf_to_mgmt->clp_msg_buf;



	/* 4 bytes alignment */

	if (in_size % SPHW_CLP_DATA_UNIT_HOST)

		real_size = (in_size + (u16)sizeof(header) + SPHW_CLP_DATA_UNIT_HOST);

	else

		real_size = in_size + (u16)sizeof(header);

	real_size = real_size / SPHW_CLP_DATA_UNIT_HOST;



	if (real_size > (SPHW_CLP_INPUT_BUF_LEN_HOST / SPHW_CLP_DATA_UNIT_HOST)) {

		sdk_err(dev->dev_hdl, "Invalid real_size: %u\n", real_size);

		return -EINVAL;

	}

	down(&clp_pf_to_mgmt->clp_msg_lock);



	err = sphw_check_clp_init_status(dev);

	if (err) {

		sdk_err(dev->dev_hdl, "Check clp init status failed\n");

		up(&clp_pf_to_mgmt->clp_msg_lock);

		return err;

	}



	sphw_clear_clp_data(dev, SPHW_CLP_RSP_HOST);

	sphw_write_clp_reg(dev, SPHW_CLP_RSP_HOST, SPHW_CLP_READY_RSP_HOST, 0x0);



	/* Send request */

	memset(clp_msg_buf, 0x0, SPHW_CLP_INPUT_BUF_LEN_HOST);

	clp_prepare_header(dev, &header, in_size, mod, 0, 0, cmd, 0);



	memcpy(clp_msg_buf, &header, sizeof(header));

	clp_msg_buf += sizeof(header);

	memcpy(clp_msg_buf, buf_in, in_size);



	clp_msg_buf = clp_pf_to_mgmt->clp_msg_buf;



	sphw_clear_clp_data(dev, SPHW_CLP_REQ_HOST);

	err = sphw_write_clp_data(hwdev, clp_pf_to_mgmt->clp_msg_buf, real_size);

	if (err) {

		sdk_err(dev->dev_hdl, "Send clp request failed\n");

		up(&clp_pf_to_mgmt->clp_msg_lock);

		return -EINVAL;

	}



	/* Get response */

	clp_msg_buf = clp_pf_to_mgmt->clp_msg_buf;

	memset(clp_msg_buf, 0x0, SPHW_CLP_INPUT_BUF_LEN_HOST);

	err = sphw_read_clp_data(hwdev, clp_msg_buf, &real_size);

	sphw_clear_clp_data(dev, SPHW_CLP_RSP_HOST);

	if (err) {

		sdk_err(dev->dev_hdl, "Read clp response failed\n");

		up(&clp_pf_to_mgmt->clp_msg_lock);

		return -EINVAL;

	}



	real_size = (u16)((real_size * SPHW_CLP_DATA_UNIT_HOST) & 0xffff);

	if (real_size <= sizeof(header) || real_size > SPHW_CLP_INPUT_BUF_LEN_HOST) {

		sdk_err(dev->dev_hdl, "Invalid response size: %u", real_size);

		up(&clp_pf_to_mgmt->clp_msg_lock);

		return -EINVAL;

	}

	real_size = real_size - sizeof(header);

	if (real_size != *out_size) {

		sdk_err(dev->dev_hdl, "Invalid real_size:%u, out_size: %u\n",

			real_size, *out_size);

		up(&clp_pf_to_mgmt->clp_msg_lock);

		return -EINVAL;

	}



	memcpy(buf_out, (clp_msg_buf + sizeof(header)), real_size);

	up(&clp_pf_to_mgmt->clp_msg_lock);



	return 0;

}



int sphw_clp_to_mgmt(void *hwdev, u8 mod, u16 cmd, const void *buf_in,

		     u16 in_size, void *buf_out, u16 *out_size)



{

	struct sphw_hwdev *dev = hwdev;

	int err;



	if (!dev)

		return -EINVAL;



	if (!dev->chip_present_flag)

		return -EPERM;



	if (sphw_func_type(hwdev) == TYPE_VF)

		return -EINVAL;



	err = sphw_pf_clp_to_mgmt(dev, mod, cmd, buf_in, in_size, buf_out,

				  out_size);



	return err;

}



int sphw_clp_pf_to_mgmt_init(struct sphw_hwdev *hwdev)

{

	struct sphw_clp_pf_to_mgmt *clp_pf_to_mgmt;



	clp_pf_to_mgmt = kzalloc(sizeof(*clp_pf_to_mgmt), GFP_KERNEL);

	if (!clp_pf_to_mgmt)

		return -ENOMEM;



	clp_pf_to_mgmt->clp_msg_buf = kzalloc(SPHW_CLP_INPUT_BUF_LEN_HOST,

					      GFP_KERNEL);

	if (!clp_pf_to_mgmt->clp_msg_buf) {

		kfree(clp_pf_to_mgmt);

		return -ENOMEM;

	}

	sema_init(&clp_pf_to_mgmt->clp_msg_lock, 1);



	hwdev->clp_pf_to_mgmt = clp_pf_to_mgmt;



	return 0;

}



void sphw_clp_pf_to_mgmt_free(struct sphw_hwdev *hwdev)

{

	struct sphw_clp_pf_to_mgmt *clp_pf_to_mgmt = hwdev->clp_pf_to_mgmt;



	kfree(clp_pf_to_mgmt->clp_msg_buf);

	kfree(clp_pf_to_mgmt);

}