自学教程：C++ APR_PKT_SIZE函数代码示例

int avcs_core_disable_power_collapse(int disable){	struct adsp_power_collapse pc;	int rc = 0;	if (core_handle) {		pc.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_EVENT,			APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);		pc.hdr.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,					sizeof(uint32_t));		pc.hdr.src_port = 0;		pc.hdr.dest_port = 0;		pc.hdr.token = 0;		pc.hdr.opcode = ADSP_CMD_SET_POWER_COLLAPSE_STATE;		pc.power_collapse = disable;		rc = apr_send_pkt(core_handle, (uint32_t *)&pc);		if (rc < 0) {			pr_debug("disable power collapse = %d failed/n",				disable);			return rc;		}		pr_debug("disable power collapse = %d/n", disable);	}	return 0;}

int afe_loopback(u16 enable, u16 rx_port, u16 tx_port){	struct afe_loopback_cfg_v1 lb_cmd;	int ret = 0;	int index = 0;	ret = afe_q6_interface_prepare();	if (ret != 0)		return ret;	index = q6audio_get_port_index(rx_port);	if (q6audio_validate_port(rx_port) < 0)		return -EINVAL;	lb_cmd.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,						APR_HDR_LEN(20), APR_PKT_VER);	lb_cmd.hdr.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,						sizeof(lb_cmd) - APR_HDR_SIZE);	lb_cmd.hdr.src_port = 0;	lb_cmd.hdr.dest_port = 0;	lb_cmd.hdr.token = index;	lb_cmd.hdr.opcode = AFE_PORT_CMD_SET_PARAM_V2;	lb_cmd.param.port_id = tx_port;	lb_cmd.param.payload_size = (sizeof(lb_cmd) - sizeof(struct apr_hdr) -				     sizeof(struct afe_port_cmd_set_param_v2));	lb_cmd.param.payload_address_lsw = 0x00;	lb_cmd.param.payload_address_msw = 0x00;	lb_cmd.param.mem_map_handle = 0x00;	lb_cmd.pdata.module_id = AFE_MODULE_LOOPBACK;	lb_cmd.pdata.param_id = AFE_PARAM_ID_LOOPBACK_CONFIG;	lb_cmd.pdata.param_size = lb_cmd.param.payload_size -				  sizeof(struct afe_port_param_data_v2);	lb_cmd.dst_port_id = rx_port;	lb_cmd.routing_mode = LB_MODE_DEFAULT;	lb_cmd.enable = (enable ? 1 : 0);	lb_cmd.loopback_cfg_minor_version = AFE_API_VERSION_LOOPBACK_CONFIG;	atomic_set(&this_afe.state, 1);	ret = apr_send_pkt(this_afe.apr, (uint32_t *) &lb_cmd);	if (ret < 0) {		pr_err("%s: AFE loopback failed/n", __func__);		ret = -EINVAL;		goto done;	}	pr_debug("%s: waiting for this_afe.wait[%d]/n", __func__, index);	ret = wait_event_timeout(this_afe.wait[index],				 (atomic_read(&this_afe.state) == 0),				 msecs_to_jiffies(TIMEOUT_MS));	if (!ret) {		pr_err("%s: wait_event timeout/n", __func__);		ret = -EINVAL;	}done:	return ret;}

int afe_loopback(u16 enable, u16 dst_port, u16 src_port){	struct afe_loopback_command lb_cmd;	int ret = 0;	ret = afe_q6_interface_prepare();	if (ret != 0)		return ret;	if ((afe_get_port_type(dst_port) == MSM_AFE_PORT_TYPE_RX) &&		(afe_get_port_type(src_port) == MSM_AFE_PORT_TYPE_RX))		return afe_loopback_cfg(enable, dst_port, src_port,					LB_MODE_EC_REF_VOICE_AUDIO);	lb_cmd.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,						APR_HDR_LEN(20), APR_PKT_VER);	lb_cmd.hdr.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,						sizeof(lb_cmd) - APR_HDR_SIZE);	lb_cmd.hdr.src_port = 0;	lb_cmd.hdr.dest_port = 0;	lb_cmd.hdr.token = 0;	lb_cmd.hdr.opcode = AFE_PORT_CMD_LOOPBACK;	lb_cmd.tx_port_id = src_port;	lb_cmd.rx_port_id = dst_port;	lb_cmd.mode = 0xFFFF;	lb_cmd.enable = (enable ? 1 : 0);	atomic_set(&this_afe.state, 1);        pr_info("%s: AFE loopback enable %d from src 0x%x to dst 0x%x/n", __func__,enable,src_port,dst_port);	ret = apr_send_pkt(this_afe.apr, (uint32_t *) &lb_cmd);	if (ret < 0) {		pr_err("%s: AFE loopback failed/n", __func__);		ret = -EINVAL;		goto done;	}	ret = wait_event_timeout(this_afe.wait,		(atomic_read(&this_afe.state) == 0),				msecs_to_jiffies(TIMEOUT_MS));	if (!ret) {		pr_err("%s: wait_event timeout/n", __func__);#ifdef HTC_AUD_DEBUG                BUG();#endif		ret = -EINVAL;	}done:	return ret;}

void send_cal(int port_id, struct acdb_cal_block *aud_cal){	s32				result;	struct adm_set_params_command	adm_params;	pr_debug("%s: Port id %d/n", __func__, port_id);	if (!aud_cal || aud_cal->cal_size == 0) {		pr_debug("%s: No calibration data to send!/n", __func__);		goto done;	}	adm_params.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,		APR_HDR_LEN(20), APR_PKT_VER);	adm_params.hdr.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,		sizeof(adm_params));	adm_params.hdr.src_svc = APR_SVC_ADM;	adm_params.hdr.src_domain = APR_DOMAIN_APPS;	adm_params.hdr.src_port = port_id;	adm_params.hdr.dest_svc = APR_SVC_ADM;	adm_params.hdr.dest_domain = APR_DOMAIN_ADSP;	adm_params.hdr.dest_port = atomic_read(&this_adm.copp_id[port_id]);	adm_params.hdr.token = port_id;	adm_params.hdr.opcode = ADM_CMD_SET_PARAMS;	adm_params.payload = aud_cal->cal_paddr;	adm_params.payload_size = aud_cal->cal_size;	atomic_set(&this_adm.copp_stat[port_id], 0);	pr_debug("%s: Sending SET_PARAMS payload = 0x%x, size = %d/n",		__func__, adm_params.payload, adm_params.payload_size);	result = apr_send_pkt(this_adm.apr, (uint32_t *)&adm_params);	if (result < 0) {		pr_err("%s: Set params failed port = %d payload = 0x%x/n",			__func__, port_id, aud_cal->cal_paddr);		goto done;	}	/* Wait for the callback */	result = wait_event_timeout(this_adm.wait,		atomic_read(&this_adm.copp_stat[port_id]),		msecs_to_jiffies(TIMEOUT_MS));	if (!result)		pr_err("%s: Set params timed out port = %d, payload = 0x%x/n",			__func__, port_id, aud_cal->cal_paddr);done:	return;}

static void q6usm_add_hdr(struct us_client *usc, struct apr_hdr *hdr,			  uint32_t pkt_size, bool cmd_flg){	mutex_lock(&usc->cmd_lock);	hdr->hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD, /				       APR_HDR_LEN(sizeof(struct apr_hdr)),/				       APR_PKT_VER);	hdr->src_svc = ((struct apr_svc *)usc->apr)->id;	hdr->src_domain = APR_DOMAIN_APPS;	hdr->dest_svc = APR_SVC_USM;	hdr->dest_domain = APR_DOMAIN_ADSP;	hdr->src_port = (usc->session << 8) | 0x0001;	hdr->dest_port = (usc->session << 8) | 0x0001;	if (cmd_flg) {		hdr->token = usc->session;		atomic_set(&usc->cmd_state, 1);	}	hdr->pkt_size  = APR_PKT_SIZE(APR_HDR_SIZE, pkt_size);	mutex_unlock(&usc->cmd_lock);	return;}

int avcs_core_disable_power_collapse(int disable){	struct adsp_power_collapse pc;	int rc = 0;	if (core_handle) {		pc.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_EVENT,			APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);		pc.hdr.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,					sizeof(uint32_t));		pc.hdr.src_port = 0;		pc.hdr.dest_port = 0;		pc.hdr.token = 0;		pc.hdr.opcode = ADSP_CMD_SET_POWER_COLLAPSE_STATE;		/*		* When power_collapse set to 1 -- If the aDSP is in the power		* collapsed state when this command is received, it is awakened		* from this state. The aDSP does not power collapse again until		* the client revokes this	command		* When power_collapse set to 0 -- This indicates to the aDSP		* that the remote client does not need it to be out of power		* collapse any longer. This may not always put the aDSP into		* power collapse; the aDSP must honor an internal client's		* power requirements as well.		*/		pc.power_collapse = disable;		rc = apr_send_pkt(core_handle, (uint32_t *)&pc);		if (rc < 0) {			pr_debug("disable power collapse = %d failed/n",				disable);			return rc;		}		pr_debug("disable power collapse = %d/n", disable);	}	return 0;}

//.........这里部分代码省略.........		}		payload_size = 4 * sizeof(u32);				if (copy_from_user((void *)				rtac_cal[ADM_RTAC_CAL].cal_data.kvaddr,				buf + 7 * sizeof(u32), data_size)) {			pr_err("%s: Could not copy payload from user buffer/n",				__func__);			goto err;		}				rtac_adm_buffer[8] = data_size;	} else {		if (payload_size > MAX_PAYLOAD_SIZE) {			pr_err("%s: Invalid payload size = %d/n",				__func__, payload_size);			goto done;		}				if (copy_from_user(rtac_adm_buffer +				sizeof(adm_params)/sizeof(u32),				buf + 3 * sizeof(u32), payload_size)) {			pr_err("%s: Could not copy payload from user buffer/n",				__func__);			goto err;		}	}		adm_params.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,		APR_HDR_LEN(20), APR_PKT_VER);	adm_params.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,		payload_size);	adm_params.src_svc = APR_SVC_ADM;	adm_params.src_domain = APR_DOMAIN_APPS;	adm_params.src_port = copp_id;	adm_params.dest_svc = APR_SVC_ADM;	adm_params.dest_domain = APR_DOMAIN_ADSP;	adm_params.dest_port = copp_id;	adm_params.token = port_id;	adm_params.opcode = opcode;		rtac_adm_buffer[5] = rtac_cal[ADM_RTAC_CAL].cal_data.paddr;	rtac_adm_buffer[6] = 0;	rtac_adm_buffer[7] = rtac_cal[ADM_RTAC_CAL].map_data.map_handle;	memcpy(rtac_adm_buffer, &adm_params, sizeof(adm_params));	atomic_set(&rtac_adm_apr_data.cmd_state, 1);	pr_debug("%s: Sending RTAC command ioctl 0x%x, paddr 0x%x/n",		__func__, opcode,		rtac_cal[ADM_RTAC_CAL].cal_data.paddr);	result = apr_send_pkt(rtac_adm_apr_data.apr_handle,					(uint32_t *)rtac_adm_buffer);	if (result < 0) {		pr_err("%s: Set params failed port = %d, copp = %d/n",			__func__, port_index, copp_id);		goto err;	}		result = wait_event_timeout(rtac_adm_apr_data.cmd_wait,		(atomic_read(&rtac_adm_apr_data.cmd_state) == 0),

//.........这里部分代码省略.........		}		payload_size = 4 * sizeof(u32);				if (copy_from_user((void *)				rtac_cal[VOICE_RTAC_CAL].cal_data.kvaddr,				buf + 7 * sizeof(u32), data_size)) {			pr_err("%s: Could not copy payload from user buffer/n",				__func__);			goto err;		}				rtac_voice_buffer[8] = data_size;	} else {		if (payload_size > MAX_PAYLOAD_SIZE) {			pr_err("%s: Invalid payload size = %d/n",					__func__, payload_size);			goto done;		}				if (copy_from_user(rtac_voice_buffer +				sizeof(voice_params)/sizeof(u32),				buf + 3 * sizeof(u32), payload_size)) {			pr_err("%s: Could not copy payload from user buffer/n",				__func__);			goto err;		}	}		voice_params.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,		APR_HDR_LEN(20), APR_PKT_VER);	voice_params.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,		payload_size);	voice_params.src_svc = 0;	voice_params.src_domain = APR_DOMAIN_APPS;	voice_params.src_port = get_voice_index(mode, dest_port);	voice_params.dest_svc = 0;	voice_params.dest_domain = APR_DOMAIN_MODEM;	voice_params.dest_port = (u16)dest_port;	voice_params.token = 0;	voice_params.opcode = opcode;		rtac_voice_buffer[5] = rtac_cal[VOICE_RTAC_CAL].map_data.map_handle;	rtac_voice_buffer[6] = rtac_cal[VOICE_RTAC_CAL].cal_data.paddr;	rtac_voice_buffer[7] = 0;	memcpy(rtac_voice_buffer, &voice_params, sizeof(voice_params));	atomic_set(&rtac_voice_apr_data[mode].cmd_state, 1);	pr_debug("%s: Sending RTAC command ioctl 0x%x, paddr 0x%x/n",		__func__, opcode,		rtac_cal[VOICE_RTAC_CAL].cal_data.paddr);	result = apr_send_pkt(rtac_voice_apr_data[mode].apr_handle,					(uint32_t *)rtac_voice_buffer);	if (result < 0) {		pr_err("%s: apr_send_pkt failed opcode = %x/n",			__func__, opcode);		goto err;	}		result = wait_event_timeout(rtac_voice_apr_data[mode].cmd_wait,		(atomic_read(&rtac_voice_apr_data[mode].cmd_state) == 0),

//.........这里部分代码省略.........		payload_size = 4 * sizeof(u32);				if (copy_from_user((void *)				rtac_cal[ASM_RTAC_CAL].cal_data.kvaddr,				buf + 7 * sizeof(u32), data_size)) {			pr_err("%s: Could not copy payload from user buffer/n",				__func__);			goto err;		}				rtac_asm_buffer[8] = data_size;	} else {		if (payload_size > MAX_PAYLOAD_SIZE) {			pr_err("%s: Invalid payload size = %d/n",				__func__, payload_size);			goto err; 		}				if (copy_from_user(rtac_asm_buffer +				sizeof(asm_params)/sizeof(u32),				buf + 3 * sizeof(u32), payload_size)) {			pr_err("%s: Could not copy payload from user buffer/n",				__func__);			goto err;		}	}		asm_params.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,		APR_HDR_LEN(20), APR_PKT_VER);	asm_params.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,		payload_size);	asm_params.src_svc = q6asm_get_apr_service_id(session_id);	if (asm_params.src_svc == -EINVAL) {		pr_err("%s: Could not get service id form session %d", __func__, session_id);		goto err;	}	asm_params.src_domain = APR_DOMAIN_APPS;	asm_params.src_port = (session_id << 8) | 0x0001;	asm_params.dest_svc = APR_SVC_ASM;	asm_params.dest_domain = APR_DOMAIN_ADSP;	asm_params.dest_port = (session_id << 8) | 0x0001;	asm_params.token = session_id;	asm_params.opcode = opcode;		rtac_asm_buffer[5] = rtac_cal[ASM_RTAC_CAL].cal_data.paddr;	rtac_asm_buffer[6] = 0;	rtac_asm_buffer[7] = rtac_cal[ASM_RTAC_CAL].map_data.map_handle;	memcpy(rtac_asm_buffer, &asm_params, sizeof(asm_params));	atomic_set(&rtac_asm_apr_data[session_id].cmd_state, 1);	pr_debug("%s: Sending RTAC command ioctl 0x%x, paddr 0x%x/n",		__func__, opcode,		rtac_cal[ASM_RTAC_CAL].cal_data.paddr);	result = apr_send_pkt(rtac_asm_apr_data[session_id].apr_handle,				(uint32_t *)rtac_asm_buffer);	if (result < 0) {		pr_err("%s: Set params failed session = %d/n",			__func__, session_id);

u32 send_voice_apr(u32 mode, void *buf, u32 opcode){	s32	result;	u32	count = 0;	u32	bytes_returned = 0;	u32	payload_size;	u32	dest_port;	struct	apr_hdr	voice_params;	pr_debug("%s/n", __func__);	if (copy_from_user(&count, (void *)buf, sizeof(count))) {		pr_err("%s: Copy to user failed! buf = 0x%x/n",		       __func__, (unsigned int)buf);		result = -EFAULT;		goto done;	}	if (count <= 0) {		pr_err("%s: Invalid buffer size = %d/n", __func__, count);		goto done;	}	if (copy_from_user(&payload_size, buf + sizeof(payload_size),						sizeof(payload_size))) {		pr_err("%s: Could not copy payload size from user buffer/n",			__func__);		goto done;	}	if (payload_size > MAX_PAYLOAD_SIZE) {		pr_err("%s: Invalid payload size = %d/n",			__func__, payload_size);		goto done;	}	if (copy_from_user(&dest_port, buf + 2 * sizeof(dest_port),						sizeof(dest_port))) {		pr_err("%s: Could not copy port id from user buffer/n",			__func__);		goto done;	}	if ((mode != RTAC_CVP) && (mode != RTAC_CVS)) {		pr_err("%s: Invalid Mode for APR, mode = %d/n",			__func__, mode);		goto done;	}	mutex_lock(&rtac_voice_apr_mutex);	if (rtac_voice_apr_data[mode].apr_handle == NULL) {		pr_err("%s: APR not initialized/n", __func__);		goto err;	}		rtac_voice_user_buf_size = count;		if (copy_from_user(rtac_voice_buffer + sizeof(voice_params),		buf + 3 * sizeof(u32), payload_size)) {		pr_err("%s: Could not copy payload from user buffer/n",			__func__);		goto err;	}		voice_params.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,		APR_HDR_LEN(20), APR_PKT_VER);	voice_params.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,		payload_size);	voice_params.src_svc = 0;	voice_params.src_domain = APR_DOMAIN_APPS;	voice_params.src_port = voice_session_id[					get_voice_index(mode, dest_port)];	voice_params.dest_svc = 0;	voice_params.dest_domain = APR_DOMAIN_MODEM;	voice_params.dest_port = (u16)dest_port;	voice_params.token = 0;	voice_params.opcode = opcode;	memcpy(rtac_voice_buffer, &voice_params, sizeof(voice_params));	atomic_set(&rtac_voice_apr_data[mode].cmd_state, 1);	pr_debug("%s: Sending RTAC command size = %d, opcode = %x/n",		__func__, voice_params.pkt_size, opcode);	result = apr_send_pkt(rtac_voice_apr_data[mode].apr_handle,					(uint32_t *)rtac_voice_buffer);	if (result < 0) {		pr_err("%s: apr_send_pkt failed opcode = %x/n",			__func__, opcode);		goto err;	}		result = wait_event_timeout(rtac_voice_apr_data[mode].cmd_wait,		(atomic_read(&rtac_voice_apr_data[mode].cmd_state) == 0),		msecs_to_jiffies(TIMEOUT_MS));	mutex_unlock(&rtac_voice_apr_mutex);	if (!result) {		pr_err("%s: apr_send_pkt timed out opcode = %x/n",//.........这里部分代码省略.........

u32 send_rtac_asm_apr(void *buf, u32 opcode){	s32	result;	u32	count = 0;	u32	bytes_returned = 0;	u32	session_id = 0;	u32	payload_size;	struct apr_hdr	asm_params;	pr_debug("%s/n", __func__);	if (copy_from_user(&count, (void *)buf, sizeof(count))) {		pr_err("%s: Copy to user failed! buf = 0x%x/n",		       __func__, (unsigned int)buf);		result = -EFAULT;		goto done;	}	if (count <= 0) {		pr_err("%s: Invalid buffer size = %d/n", __func__, count);		goto done;	}	if (copy_from_user(&payload_size, buf + sizeof(u32), sizeof(u32))) {		pr_err("%s: Could not copy payload size from user buffer/n",			__func__);		goto done;	}	if (payload_size > MAX_PAYLOAD_SIZE) {		pr_err("%s: Invalid payload size = %d/n",			__func__, payload_size);		goto done;	}	if (copy_from_user(&session_id, buf + 2 * sizeof(u32), sizeof(u32))) {		pr_err("%s: Could not copy session id from user buffer/n",			__func__);		goto done;	}	if (session_id > (SESSION_MAX + 1)) {		pr_err("%s: Invalid Session = %d/n", __func__, session_id);		goto done;	}	mutex_lock(&rtac_asm_apr_mutex);	if (session_id < SESSION_MAX+1) {		if (rtac_asm_apr_data[session_id].apr_handle == NULL) {			pr_err("%s: APR not initialized/n", __func__);			goto err;		}	}		rtac_asm_user_buf_size = count;		if (copy_from_user(rtac_asm_buffer + sizeof(asm_params),		buf + 3 * sizeof(u32), payload_size)) {		pr_err("%s: Could not copy payload from user buffer/n",			__func__);		goto err;	}		asm_params.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,		APR_HDR_LEN(20), APR_PKT_VER);	asm_params.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,		payload_size);	asm_params.src_svc = q6asm_get_apr_service_id(session_id);	asm_params.src_domain = APR_DOMAIN_APPS;	asm_params.src_port = (session_id << 8) | 0x0001;	asm_params.dest_svc = APR_SVC_ASM;	asm_params.dest_domain = APR_DOMAIN_ADSP;	asm_params.dest_port = (session_id << 8) | 0x0001;	asm_params.token = session_id;	asm_params.opcode = opcode;	memcpy(rtac_asm_buffer, &asm_params, sizeof(asm_params));	if (session_id < SESSION_MAX+1)		atomic_set(&rtac_asm_apr_data[session_id].cmd_state, 1);	pr_debug("%s: Sending RTAC command size = %d, session_id=%d/n",		__func__, asm_params.pkt_size, session_id);	result = apr_send_pkt(rtac_asm_apr_data[session_id].apr_handle,				(uint32_t *)rtac_asm_buffer);	if (result < 0) {		pr_err("%s: Set params failed session = %d/n",			__func__, session_id);		goto err;	}		result = wait_event_timeout(rtac_asm_apr_data[session_id].cmd_wait,		(atomic_read(&rtac_asm_apr_data[session_id].cmd_state) == 0),		5 * HZ);	mutex_unlock(&rtac_asm_apr_mutex);	if (!result) {		pr_err("%s: Set params timed out session = %d/n",			__func__, session_id);//.........这里部分代码省略.........

u32 send_adm_apr(void *buf, u32 opcode){	s32	result;	u32	count = 0;	u32	bytes_returned = 0;	u32	port_index = 0;	u32	copp_id;	u32	payload_size;	struct apr_hdr	adm_params;	pr_debug("%s/n", __func__);	if (copy_from_user(&count, (void *)buf, sizeof(count))) {		pr_err("%s: Copy to user failed! buf = 0x%x/n",		       __func__, (unsigned int)buf);		result = -EFAULT;		goto done;	}	if (count <= 0) {		pr_err("%s: Invalid buffer size = %d/n", __func__, count);		goto done;	}	if (copy_from_user(&payload_size, buf + sizeof(u32), sizeof(u32))) {		pr_err("%s: Could not copy payload size from user buffer/n",			__func__);		goto done;	}	if (payload_size > MAX_PAYLOAD_SIZE) {		pr_err("%s: Invalid payload size = %d/n",			__func__, payload_size);		goto done;	}	if (copy_from_user(&copp_id, buf + 2 * sizeof(u32), sizeof(u32))) {		pr_err("%s: Could not copy port id from user buffer/n",			__func__);		goto done;	}	for (port_index = 0; port_index < AFE_MAX_PORTS; port_index++) {		if (adm_get_copp_id(port_index) == copp_id)			break;	}	if (port_index >= AFE_MAX_PORTS) {		pr_err("%s: Could not find port index for copp = %d/n",		       __func__, copp_id);		goto done;	}	mutex_lock(&rtac_adm_apr_mutex);	if (rtac_adm_apr_data.apr_handle == NULL) {		pr_err("%s: APR not initialized/n", __func__);		goto err;	}		rtac_adm_user_buf_size = count;		if (copy_from_user(rtac_adm_buffer + sizeof(adm_params),			buf + 3 * sizeof(u32), payload_size)) {		pr_err("%s: Could not copy payload from user buffer/n",			__func__);		goto err;	}		adm_params.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,		APR_HDR_LEN(20), APR_PKT_VER);	adm_params.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,		payload_size);	adm_params.src_svc = APR_SVC_ADM;	adm_params.src_domain = APR_DOMAIN_APPS;	adm_params.src_port = copp_id;	adm_params.dest_svc = APR_SVC_ADM;	adm_params.dest_domain = APR_DOMAIN_ADSP;	adm_params.dest_port = copp_id;	adm_params.token = copp_id;	adm_params.opcode = opcode;	memcpy(rtac_adm_buffer, &adm_params, sizeof(adm_params));	atomic_set(&rtac_adm_apr_data.cmd_state, 1);	pr_debug("%s: Sending RTAC command size = %d/n",		__func__, adm_params.pkt_size);	result = apr_send_pkt(rtac_adm_apr_data.apr_handle,				(uint32_t *)rtac_adm_buffer);	if (result < 0) {		pr_err("%s: Set params failed port = %d, copp = %d/n",			__func__, port_index, copp_id);		goto err;	}		result = wait_event_timeout(rtac_adm_apr_data.cmd_wait,		(atomic_read(&rtac_adm_apr_data.cmd_state) == 0),		msecs_to_jiffies(TIMEOUT_MS));	mutex_unlock(&rtac_adm_apr_mutex);//.........这里部分代码省略.........