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

int adm_matrix_map(int session_id, int path, int num_copps,			unsigned int *port_id, int copp_id){	struct adm_routings_command	route;	int ret = 0, i = 0;	/* Assumes port_ids have already been validated during adm_open */	int index = afe_get_port_index(copp_id);	pr_debug("%s: session 0x%x path:%d num_copps:%d port_id[0]:%d/n",		 __func__, session_id, path, num_copps, port_id[0]);	route.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,				APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);	route.hdr.pkt_size = sizeof(route);	route.hdr.src_svc = 0;	route.hdr.src_domain = APR_DOMAIN_APPS;	route.hdr.src_port = copp_id;	route.hdr.dest_svc = APR_SVC_ADM;	route.hdr.dest_domain = APR_DOMAIN_ADSP;	route.hdr.dest_port = atomic_read(&this_adm.copp_id[index]);	route.hdr.token = copp_id;	route.hdr.opcode = ADM_CMD_MATRIX_MAP_ROUTINGS;	route.num_sessions = 1;	route.session[0].id = session_id;	route.session[0].num_copps = num_copps;	for (i = 0; i < num_copps; i++) {		int tmp;		tmp = afe_get_port_index(port_id[i]);		pr_debug("%s: port_id[%d]: %d, index: %d/n", __func__, i,			 port_id[i], tmp);		route.session[0].copp_id[i] =					atomic_read(&this_adm.copp_id[tmp]);	}	if (num_copps % 2)		route.session[0].copp_id[i] = 0;	switch (path) {	case 0x1:		route.path = AUDIO_RX;		break;	case 0x2:	case 0x3:		route.path = AUDIO_TX;		break;	default:		pr_err("%s: Wrong path set[%d]/n", __func__, path);		break;	}	atomic_set(&this_adm.copp_stat[index], 0);	ret = apr_send_pkt(this_adm.apr, (uint32_t *)&route);	if (ret < 0) {		pr_err("%s: ADM routing for port %d failed/n",					__func__, port_id[0]);		ret = -EINVAL;		goto fail_cmd;	}	ret = wait_event_timeout(this_adm.wait,				atomic_read(&this_adm.copp_stat[index]),				msecs_to_jiffies(TIMEOUT_MS));	if (!ret) {		pr_err("%s: ADM cmd Route failed for port %d/n",					__func__, port_id[0]);		ret = -EINVAL;		goto fail_cmd;	}	for (i = 0; i < num_copps; i++)		send_adm_cal(port_id[i], path);	return 0;fail_cmd:	return ret;}

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

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

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;}

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;}

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

int adm_open(int port_id, int path, int rate, int channel_mode, int topology){	struct adm_copp_open_command	open;	int ret = 0;	int index;	pr_debug("%s: port %d path:%d rate:%d mode:%d/n", __func__,				port_id, path, rate, channel_mode);	pr_err("Topology = %x/n", topology);	if (afe_validate_port(port_id) < 0) {		pr_err("%s port idi[%d] is invalid/n", __func__, port_id);		return -ENODEV;	}	index = afe_get_port_index(port_id);	pr_debug("%s: Port ID %d, index %d/n", __func__, port_id, index);	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;		}#ifdef CONFIG_MSM8X60_RTAC		rtac_set_adm_handle(this_adm.apr);#endif	}	/* Create a COPP if port id are not enabled */	if (atomic_read(&this_adm.copp_cnt[index]) == 0) {		open.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,				APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);		open.hdr.pkt_size = sizeof(open);		open.hdr.src_svc = APR_SVC_ADM;		open.hdr.src_domain = APR_DOMAIN_APPS;		open.hdr.src_port = port_id;		open.hdr.dest_svc = APR_SVC_ADM;		open.hdr.dest_domain = APR_DOMAIN_ADSP;		open.hdr.dest_port = port_id;		open.hdr.token = port_id;		open.hdr.opcode = ADM_CMD_COPP_OPEN;		open.mode = path;		open.endpoint_id1 = port_id;		open.endpoint_id2 = 0xFFFF;		open.topology_id  = topology;		open.channel_config = channel_mode & 0x00FF;		open.rate  = rate;		pr_debug("%s: channel_config=%d port_id=%d rate=%d/			topology_id=0x%X/n", __func__, open.channel_config,/			open.endpoint_id1, open.rate,/			open.topology_id);		atomic_set(&this_adm.copp_stat[index], 0);		ret = apr_send_pkt(this_adm.apr, (uint32_t *)&open);		if (ret < 0) {			pr_err("%s:ADM enable for port %d failed/n",						__func__, port_id);			ret = -EINVAL;			goto fail_cmd;		}		/* Wait for the callback with copp id */		ret = wait_event_timeout(this_adm.wait,			atomic_read(&this_adm.copp_stat[index]),			msecs_to_jiffies(TIMEOUT_MS));		if (!ret) {			pr_err("%s ADM open failed for port %d/n", __func__,								port_id);			ret = -EINVAL;			goto fail_cmd;		}	}	atomic_inc(&this_adm.copp_cnt[index]);	return 0;fail_cmd:	return ret;}

int adm_memory_map_regions(uint32_t *buf_add, uint32_t mempool_id,				uint32_t *bufsz, uint32_t bufcnt){	struct  adm_cmd_memory_map_regions *mmap_regions = NULL;	struct  adm_memory_map_regions *mregions = NULL;	void    *mmap_region_cmd = NULL;	void    *payload = NULL;	int     ret = 0;	int     i = 0;	int     cmd_size = 0;	pr_info("%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;		}#ifdef CONFIG_MSM8X60_RTAC		rtac_set_adm_handle(this_adm.apr);#endif	}	cmd_size = sizeof(struct adm_cmd_memory_map_regions)			+ sizeof(struct adm_memory_map_regions) * 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 adm_cmd_memory_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_MEMORY_MAP_REGIONS;	mmap_regions->mempool_id = mempool_id & 0x00ff;	mmap_regions->nregions = bufcnt & 0x00ff;	pr_debug("%s: map_regions->nregions = %d/n", __func__,				mmap_regions->nregions);	payload = ((u8 *) mmap_region_cmd +				sizeof(struct adm_cmd_memory_map_regions));	mregions = (struct adm_memory_map_regions *)payload;	for (i = 0; i < bufcnt; i++) {		mregions->phys = buf_add[i];		mregions->buf_size = 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,			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;}

/* This function instantiates a mixer in QDSP6 audio path for * given audio hardware port. Topology should be made part * of audio calibration */int adm_open_mixer(int port_id, int path, int rate,	int channel_mode, int topology) {	struct adm_copp_open_command open;	int ret = 0;	u32 i;	int index;	pr_debug("%s: port %d path:%d rate:%d mode:%d/n", __func__,				port_id, path, rate, channel_mode);	if (afe_validate_port(port_id) < 0) {		pr_err("%s port idi[%d] is invalid/n", __func__, port_id);		return -ENODEV;	}	index = afe_get_port_index(port_id);	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;		}	}	if (atomic_read(&this_adm.copp_cnt[index]) == 0) {		open.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,				APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);		open.hdr.pkt_size = sizeof(open);		open.hdr.src_svc = APR_SVC_ADM;		open.hdr.src_domain = APR_DOMAIN_APPS;		open.hdr.src_port = port_id;		open.hdr.dest_svc = APR_SVC_ADM;		open.hdr.dest_domain = APR_DOMAIN_ADSP;		open.hdr.dest_port = port_id;		open.hdr.token = port_id;		open.hdr.opcode = ADM_CMD_COPP_OPEN;		open.mode = path;		open.endpoint_id1 = port_id;		open.endpoint_id2 = 0xFFFF;		/* convert path to acdb path */		if (path == PLAYBACK)			open.topology_id = get_adm_rx_topology();		else {			open.topology_id = get_adm_tx_topology();			if ((open.topology_id ==				VPM_TX_SM_ECNS_COPP_TOPOLOGY) ||			    (open.topology_id ==				VPM_TX_DM_FLUENCE_COPP_TOPOLOGY))				rate = 16000;		}		if (open.topology_id  == 0)			open.topology_id = topology;		open.channel_config = channel_mode & 0x00FF;		open.rate  = rate;		pr_debug("%s: channel_config=%d port_id=%d rate=%d/			topology_id=0x%X/n", __func__, open.channel_config,/			open.endpoint_id1, open.rate,/			open.topology_id);		atomic_set(&this_adm.copp_stat[index], 0);		ret = apr_send_pkt(this_adm.apr, (uint32_t *)&open);		if (ret < 0) {			pr_err("%s:ADM enable for port %d failed/n",						__func__, port_id);			ret = -EINVAL;			goto fail_cmd;		}		/* Wait for the callback with copp id */		ret = wait_event_timeout(this_adm.wait,			atomic_read(&this_adm.copp_stat[index]),			msecs_to_jiffies(TIMEOUT_MS));		if (!ret) {			pr_err("%s ADM open failed for port %d/n", __func__,								port_id);			ret = -EINVAL;			goto fail_cmd;		}	}	atomic_inc(&this_adm.copp_cnt[index]);	/* Set up routing for cached session */	for (i = find_first_bit(&this_adm.sessions[index], ASM_MAX_SESSION);	     i < ASM_MAX_SESSION; i = find_next_bit(&this_adm.sessions[index],	     ASM_MAX_SESSION, i + 1))		adm_cmd_map(port_id, i); /* Not thread safe */fail_cmd://.........这里部分代码省略.........