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

int afe_rt_proxy_port_write(u32 buf_addr_p, u32 mem_map_handle, int bytes){	int ret = 0;	struct afe_port_data_cmd_rt_proxy_port_write_v2 afecmd_wr;	if (this_afe.apr == NULL) {		pr_err("%s:register to AFE is not done/n", __func__);		ret = -ENODEV;		return ret;	}	pr_debug("%s: buf_addr_p = 0x%08x bytes = %d/n", __func__,						buf_addr_p, bytes);	afecmd_wr.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,				APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);	afecmd_wr.hdr.pkt_size = sizeof(afecmd_wr);	afecmd_wr.hdr.src_port = 0;	afecmd_wr.hdr.dest_port = 0;	afecmd_wr.hdr.token = 0;	afecmd_wr.hdr.opcode = AFE_PORT_DATA_CMD_RT_PROXY_PORT_WRITE_V2;	afecmd_wr.port_id = RT_PROXY_PORT_001_TX;	afecmd_wr.buffer_address_lsw = (uint32_t)buf_addr_p;	afecmd_wr.buffer_address_msw = 0x00;	afecmd_wr.mem_map_handle = mem_map_handle;	afecmd_wr.available_bytes = bytes;	afecmd_wr.reserved = 0;	ret = apr_send_pkt(this_afe.apr, (uint32_t *) &afecmd_wr);	if (ret < 0) {		pr_err("%s: AFE rtproxy write to port 0x%x failed %d/n",			   __func__, afecmd_wr.port_id, ret);		ret = -EINVAL;		return ret;	}	return 0;}

int afe_pseudo_port_stop_nowait(u16 port_id){	int ret = 0;	struct afe_pseudoport_stop_command stop;	int index = 0;	pr_debug("%s: port_id=%d/n", __func__, port_id);	if (this_afe.apr == NULL) {		pr_err("%s: AFE is already closed/n", __func__);		return -EINVAL;	}	index = q6audio_get_port_index(port_id);	if (q6audio_validate_port(port_id) < 0)		return -EINVAL;	stop.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,				APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);	stop.hdr.pkt_size = sizeof(stop);	stop.hdr.src_port = 0;	stop.hdr.dest_port = 0;	stop.hdr.token = 0;	stop.hdr.opcode = AFE_PSEUDOPORT_CMD_STOP;	stop.port_id = port_id;	stop.reserved = 0;	stop.hdr.token = index;	atomic_set(&this_afe.state, 1);	ret = apr_send_pkt(this_afe.apr, (uint32_t *) &stop);	if (ret < 0) {		pr_err("%s: AFE close failed %d/n", __func__, ret);		return -EINVAL;	}	return 0;}

int afe_port_stop_nowait(int port_id){	struct afe_port_stop_command stop;	int ret = 0;	if (this_afe.apr == NULL) {		pr_err("AFE is already closed/n");		ret = -EINVAL;		goto fail_cmd;	}	pr_debug("%s: port_id=%d/n", __func__, port_id);	port_id = afe_convert_virtual_to_portid(port_id);	stop.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,				APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);	stop.hdr.pkt_size = sizeof(stop);	stop.hdr.src_port = 0;	stop.hdr.dest_port = 0;	stop.hdr.token = 0;	stop.hdr.opcode = AFE_PORT_CMD_STOP;	stop.port_id = port_id;	stop.reserved = 0;	ret = apr_send_pkt(this_afe.apr, (uint32_t *) &stop);	if (ret == -ENETRESET) {		pr_info("%s: Need to reset, calling APR deregister", __func__);		return apr_deregister(this_afe.apr);	} else if (IS_ERR_VALUE(ret)) {		pr_err("%s: AFE close failed/n", __func__);		ret = -EINVAL;	}fail_cmd:	return ret;}

static void q6usm_add_hdr(struct us_client *usc, struct apr_hdr *hdr,			  uint32_t pkt_size, bool cmd_flg){	pr_debug("%s: pkt size=%d; cmd_flg=%d/n",		 __func__, pkt_size, cmd_flg);	pr_debug("**************/n");	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;}

/* This function should be used by 8660 exclusively */int afe_open(u16 port_id, union afe_port_config *afe_config, int rate){	struct afe_port_start_command start;	struct afe_audioif_config_command config;	int ret = 0;	if (!afe_config) {		pr_err("%s: Error, no configuration data/n", __func__);		ret = -EINVAL;		return ret;	}	pr_debug("%s: %d %d/n", __func__, port_id, rate);	if ((port_id == RT_PROXY_DAI_001_RX) ||		(port_id == RT_PROXY_DAI_002_TX))		return 0;	if ((port_id == RT_PROXY_DAI_002_RX) ||		(port_id == RT_PROXY_DAI_001_TX))		port_id = VIRTUAL_ID_TO_PORTID(port_id);	ret = afe_q6_interface_prepare();	if (ret != 0)		return ret;	config.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,				APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);	config.hdr.pkt_size = afe_sizeof_cfg_cmd(port_id);	config.hdr.src_port = 0;	config.hdr.dest_port = 0;	config.hdr.token = 0;	switch (port_id) {	case SLIMBUS_0_RX:	case SLIMBUS_0_TX:	case SLIMBUS_1_RX:	case SLIMBUS_1_TX:	case SLIMBUS_2_RX:	case SLIMBUS_2_TX:	case SLIMBUS_3_RX:	case SLIMBUS_3_TX:	case SLIMBUS_4_RX:	case SLIMBUS_4_TX:		config.hdr.opcode = AFE_PORT_AUDIO_SLIM_SCH_CONFIG;	break;	case MI2S_TX:	case MI2S_RX:	case SECONDARY_I2S_RX:	case SECONDARY_I2S_TX:	case PRIMARY_I2S_RX:	case PRIMARY_I2S_TX:		/* AFE_PORT_CMD_I2S_CONFIG command is not supported		 * in the LPASS EL 1.0. So we have to distiguish		 * which AFE command, AFE_PORT_CMD_I2S_CONFIG or		 * AFE_PORT_AUDIO_IF_CONFIG	to use. If the format		 * is L-PCM, the AFE_PORT_AUDIO_IF_CONFIG is used		 * to make the backward compatible.		 */		pr_debug("%s: afe_config->mi2s.format = %d/n", __func__,				 afe_config->mi2s.format);		if (afe_config->mi2s.format == MSM_AFE_I2S_FORMAT_LPCM)			config.hdr.opcode = AFE_PORT_AUDIO_IF_CONFIG;		else			config.hdr.opcode = AFE_PORT_CMD_I2S_CONFIG;	break;	default:		config.hdr.opcode = AFE_PORT_AUDIO_IF_CONFIG;	break;	}	if (afe_validate_port(port_id) < 0) {		pr_err("%s: Failed : Invalid Port id = %d/n", __func__,				port_id);		ret = -EINVAL;		goto fail_cmd;	}	config.port_id = port_id;	config.port = *afe_config;	atomic_set(&this_afe.state, 1);	atomic_set(&this_afe.status, 0);	ret = apr_send_pkt(this_afe.apr, (uint32_t *) &config);	if (ret < 0) {		pr_err("%s: AFE enable for port %d failed/n", __func__,				port_id);		ret = -EINVAL;		goto fail_cmd;	}	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__);		ret = -EINVAL;		goto fail_cmd;	}	if (atomic_read(&this_afe.status) != 0) {//.........这里部分代码省略.........

static int afe_send_hw_delay(u16 port_id, u32 rate){	struct hw_delay_entry delay_entry;	struct afe_port_cmd_set_param config;	int index = 0;	int ret = -EINVAL;	pr_debug("%s/n", __func__);	delay_entry.sample_rate = rate;	if (afe_get_port_type(port_id) == MSM_AFE_PORT_TYPE_TX)		ret = get_hw_delay(TX_CAL, &delay_entry);	else if (afe_get_port_type(port_id) == MSM_AFE_PORT_TYPE_RX)		ret = get_hw_delay(RX_CAL, &delay_entry);	if (ret != 0) {		pr_debug("%s: Failed to get hw delay info/n", __func__);		goto done;	}	index = port_id;	if (index < 0) {		pr_debug("%s: AFE port index invalid!/n", __func__);		goto done;	}	config.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,				APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);	config.hdr.pkt_size = sizeof(config);	config.hdr.src_port = 0;	config.hdr.dest_port = 0;	config.hdr.token = index;	config.hdr.opcode = AFE_PORT_CMD_SET_PARAM;	config.port_id = port_id;	config.payload_size = sizeof(struct afe_param_payload_base)+				sizeof(struct afe_param_id_device_hw_delay_cfg);	config.payload_address = 0;	config.payload.base.module_id = AFE_MODULE_ID_PORT_INFO ;	config.payload.base.param_id = AFE_PARAM_ID_DEVICE_HW_DELAY;	config.payload.base.param_size = sizeof(struct afe_param_id_device_hw_delay_cfg);	config.payload.base.reserved = 0;	config.payload.param.hw_delay.delay_in_us = delay_entry.delay_usec;	config.payload.param.hw_delay.device_hw_delay_minor_version =				AFE_API_VERSION_DEVICE_HW_DELAY;	atomic_set(&this_afe.state, 1);	ret = apr_send_pkt(this_afe.apr, (uint32_t *) &config);	if (ret < 0) {		pr_err("%s: AFE enable for port %d failed/n", __func__,			port_id);		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 IF CONFIG/n", __func__);		ret = -EINVAL;		goto done;	}	if (atomic_read(&this_afe.status) != 0) {		pr_err("%s: config cmd failed/n", __func__);		ret = -EINVAL;		goto done;	}done:	pr_debug("%s port_id %u rate %u delay_usec %d status %d/n",		__func__, port_id, rate, delay_entry.delay_usec, ret);	return ret;}

//.........这里部分代码省略.........			goto done;		}		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,

//.........这里部分代码省略.........		}		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",

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);//.........这里部分代码省略.........

int adm_memory_map_regions(int port_id,		uint32_t *buf_add, uint32_t mempool_id,		uint32_t *bufsz, uint32_t bufcnt){	struct  avs_cmd_shared_mem_map_regions *mmap_regions = NULL;	struct  avs_shared_map_region_payload *mregions = NULL;	void    *mmap_region_cmd = NULL;	void    *payload = NULL;	int     ret = 0;	int     i = 0;	int     cmd_size = 0;	int     index = 0;	pr_debug("%s/n", __func__);	if (this_adm.apr == NULL) {		this_adm.apr = apr_register("ADSP", "ADM", adm_callback,						0xFFFFFFFF, &this_adm);		if (this_adm.apr == NULL) {			pr_err("%s: Unable to register ADM/n", __func__);			ret = -ENODEV;			return ret;		}		rtac_set_adm_handle(this_adm.apr);	}	port_id = q6audio_convert_virtual_to_portid(port_id);	if (q6audio_validate_port(port_id) < 0) {		pr_err("%s port id[%d] is invalid/n", __func__, port_id);		return -ENODEV;	}	index = q6audio_get_port_index(port_id);	cmd_size = sizeof(struct avs_cmd_shared_mem_map_regions)			+ sizeof(struct avs_shared_map_region_payload)			* bufcnt;	mmap_region_cmd = kzalloc(cmd_size, GFP_KERNEL);	if (!mmap_region_cmd) {		pr_err("%s: allocate mmap_region_cmd failed/n", __func__);		return -ENOMEM;	}	mmap_regions = (struct avs_cmd_shared_mem_map_regions *)mmap_region_cmd;	mmap_regions->hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,						APR_HDR_LEN(APR_HDR_SIZE),								APR_PKT_VER);	mmap_regions->hdr.pkt_size = cmd_size;	mmap_regions->hdr.src_port = 0;	mmap_regions->hdr.dest_port = 0;	mmap_regions->hdr.token = 0;	mmap_regions->hdr.opcode = ADM_CMD_SHARED_MEM_MAP_REGIONS;	mmap_regions->mem_pool_id = ADSP_MEMORY_MAP_SHMEM8_4K_POOL & 0x00ff;	mmap_regions->num_regions = bufcnt & 0x00ff;	mmap_regions->property_flag = 0x00;	pr_debug("%s: map_regions->num_regions = %d/n", __func__,				mmap_regions->num_regions);	payload = ((u8 *) mmap_region_cmd +				sizeof(struct avs_cmd_shared_mem_map_regions));	mregions = (struct avs_shared_map_region_payload *)payload;	for (i = 0; i < bufcnt; i++) {		mregions->shm_addr_lsw = buf_add[i];		mregions->shm_addr_msw = 0x00;		mregions->mem_size_bytes = bufsz[i];		++mregions;	}	atomic_set(&this_adm.copp_stat[0], 0);	ret = apr_send_pkt(this_adm.apr, (uint32_t *) mmap_region_cmd);	if (ret < 0) {		pr_err("%s: mmap_regions op[0x%x]rc[%d]/n", __func__,					mmap_regions->hdr.opcode, ret);		ret = -EINVAL;		goto fail_cmd;	}	ret = wait_event_timeout(this_adm.wait[index],			atomic_read(&this_adm.copp_stat[0]), 5 * HZ);	if (!ret) {		pr_err("%s: timeout. waited for memory_map/n", __func__);		ret = -EINVAL;		goto fail_cmd;	}fail_cmd:	kfree(mmap_region_cmd);	return ret;}

//.........这里部分代码省略.........			goto done;		}		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,

int afe_close(int port_id){	struct afe_port_stop_command stop;	int ret = 0;	if (this_afe.apr == NULL) {		pr_err("AFE is already closed/n");		ret = -EINVAL;		goto fail_cmd;	}	pr_debug("%s: port_id=%d/n", __func__, port_id);	if ((port_id == RT_PROXY_DAI_001_RX) ||		(port_id == RT_PROXY_DAI_002_TX)) {		pr_debug("%s: before decrementing pcm_afe_instance %d/n",				__func__, pcm_afe_instance[port_id & 0x1]);		port_id = VIRTUAL_ID_TO_PORTID(port_id);		pcm_afe_instance[port_id & 0x1]--;		if (!(pcm_afe_instance[port_id & 0x1] == 0 &&			proxy_afe_instance[port_id & 0x1] == 0))			return 0;		else			afe_close_done[port_id & 0x1] = true;	}	if ((port_id == RT_PROXY_DAI_002_RX) ||		(port_id == RT_PROXY_DAI_001_TX)) {		pr_debug("%s: before decrementing proxy_afe_instance %d/n",				__func__, proxy_afe_instance[port_id & 0x1]);		port_id = VIRTUAL_ID_TO_PORTID(port_id);		proxy_afe_instance[port_id & 0x1]--;		if (!(pcm_afe_instance[port_id & 0x1] == 0 &&			proxy_afe_instance[port_id & 0x1] == 0))			return 0;		else			afe_close_done[port_id & 0x1] = true;	}	port_id = afe_convert_virtual_to_portid(port_id);	stop.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,				APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);	stop.hdr.pkt_size = sizeof(stop);	stop.hdr.src_port = 0;	stop.hdr.dest_port = 0;	stop.hdr.token = 0;	stop.hdr.opcode = AFE_PORT_CMD_STOP;	stop.port_id = port_id;	stop.reserved = 0;	atomic_set(&this_afe.state, 1);	ret = apr_send_pkt(this_afe.apr, (uint32_t *) &stop);	if (ret == -ENETRESET) {		pr_info("%s: Need to reset, calling APR deregister", __func__);		return apr_deregister(this_afe.apr);	}	if (ret < 0) {		pr_err("%s: AFE close failed/n", __func__);		ret = -EINVAL;		goto fail_cmd;	}	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__);		ret = -EINVAL;		goto fail_cmd;	}fail_cmd:	return ret;}

/* This function sends multi-channel HDMI configuration command and AFE * calibration which is only supported by QDSP6 on 8960 and onward. */int afe_port_start(u16 port_id, union afe_port_config *afe_config,		   u32 rate){	struct afe_port_start_command start;	struct afe_audioif_config_command config;	int ret;	// [email
C++ APR_PKT_SIZE函数代码示例
C++ APR_HDR_FIELD函数代码示例