高通ADSP和AP间的通讯过程
AP侧 :
sensor1_handle_s *hndl1;
//创建clients_mutex等互斥锁
sensor1_init（）
/*
* 1. 首先获取Adsp的客户端；
* 2. 创建2个线程，一个线程waiting_thread首先等待获取Adsp的客户端，一个线程client_thread建立Adsp的Response的客户端处理线程；
*/
sensor1_open( hndl_ptr,notify_data_cb,(intptr_t)hndl_ptr );
{
sensor1_msg_header_s smgr_ver_req_hdr;
sns_common_version_req_msg_v01 *smgr_version_req = NULL;
//构造smgr_version_req的结构
error = sensor1_alloc_msg_buf( hndl1,
sizeof(sns_common_version_req_msg_v01),
(void**)&smgr_version_req );
//为smgr_ver_req_hdr 分配空间
alloc_smgr_smgr_ver_req(&smgr_ver_req_hdr );
//通过sensor1_write调用QMI接口Call到Adsp去
send_req( hndl1, (void *)smgr_version_req, smgr_ver_req_hdr );
while(1);
}
Adsp构造的消息如下
void alloc_smgr_smgr_ver_req(sensor1_msg_header_s *msg_hdr )
{
msg_hdr->service_number = SNS_SMGR_SVC_ID_V01;
msg_hdr->msg_id = SNS_SMGR_VERSION_REQ_V01;
msg_hdr->msg_size = sizeof(sns_common_version_req_msg_v01);
msg_hdr->txn_id = 0;
}
send_req函数实现如下：
void send_req( sensor1_handle_s *hndl, void *req, sensor1_msg_header_s msg_hdr )
{
error = sensor1_write( hndl,
&msg_hdr,
req );
if( SENSOR1_SUCCESS != error ) {
printf("\nsensor1_write returned %d\n", error);
if( SENSOR1_EWOULDBLOCK != error ) {
exit(error);
}
}
// Make sure we get a response
error = 0;
pthread_mutex_lock( &my_mutex );
clock_gettime( CLOCK_REALTIME, &ts );
while( (my_txn_id != msg_hdr.txn_id) && error == 0 ) {
ts.tv_sec += 100000000; // wait 100msec
error = pthread_cond_timedwait( &my_cond, &my_mutex, &ts );
}
my_txn_id = 0;
pthread_mutex_unlock( &my_mutex );
if( 0 != error ) {
printf("\nError while waiting for response message %d\n", error);
exit(error);
} else {
//printf("\nGot response to message\n");
}
}
消息发送后，Adsp返回的信息会通过client_thread线程调用notify_data_cb的方式返回，如下：
void notify_data_cb( intptr_t data,
sensor1_msg_header_s *msg_hdr_ptr,
sensor1_msg_type_e msg_type,
void *msg_ptr )
{
uint32_t smgr_version;
sns_common_version_resp_msg_v01* respMsgPtr;
if( NULL == msg_hdr_ptr ) {
printf("\nreceived NULL msg_hdr_ptr!\n");
} else {
printf("hdr.service_number: %u\n\thdr.msg_id: %d\n\t"
"hdr.msg_type: %d\n\thdr.msg_size: %d\n\thdr.txn_id: %d\n",
msg_hdr_ptr->service_number,
msg_hdr_ptr->msg_id,
msg_type,
msg_hdr_ptr->msg_size,
msg_hdr_ptr->txn_id );
}
if( msg_type == SENSOR1_MSG_TYPE_RESP && NULL != msg_hdr_ptr ) {
printf("received RESP\n");
if( msg_hdr_ptr->service_number == SNS_SMGR_SVC_ID_V01 ) {
switch (msg_hdr_ptr->msg_id) {
case SNS_SMGR_VERSION_RESP_V01:
printf("received smgr version resp\n");
respMsgPtr = (sns_common_version_resp_msg_v01 *)msg_ptr;
if (respMsgPtr->resp.sns_result_t == 0) {
smgr_version = respMsgPtr->interface_version_number;
printf("%s: SMGR version=%d \n", __FUNCTION__, smgr_version);
}else{
printf("SMGR Get Response Failed\n");
}
break;
case SNS_SMGR_ALL_SENSOR_INFO_RESP_V01:
handle_smgr_all_sensor_info_resp(msg_ptr );
break;
case SNS_SMGR_SINGLE_SENSOR_INFO_RESP_V01:
handle_smgr_single_sensor_info_resp( msg_ptr );
break;
case SNS_SMGR_REPORT_RESP_V01:
handle_smgr_report_resp();
break;
default:
break;
}
}
pthread_mutex_lock( &my_mutex );
my_txn_id = msg_hdr_ptr->txn_id;
pthread_cond_signal( &my_cond );
pthread_mutex_unlock( &my_mutex );
} else if( msg_type == SENSOR1_MSG_TYPE_IND ) {
printf("*");
fflush(NULL);
pthread_mutex_lock( &my_mutex );
num_indications++;
pthread_cond_signal( &my_cond );
pthread_mutex_unlock( &my_mutex );
} else if( msg_type == SENSOR1_MSG_TYPE_BROKEN_PIPE ) {
printf("\nreceived BROKEN_PIPE!!!\n");
} else {
printf( "\nreceived INVALID MSG type: %i!!!\n", msg_type );
}
if( NULL != msg_ptr ) {
sensor1_free_msg_buf( *((sensor1_handle_s**)data), msg_ptr );
}
}
Adsp的流程如下：
adsp_proc\sensors\smgr\src\sns_rh_main.c
SMGR_STATIC sns_err_code_e sns_rh_process_external_smgr_request(
sns_rh_mr_req_q_item_s** msg_ptr_ptr)
{
...
case SNS_SMGR_VERSION_REQ_V01:
err_code = sns_rh_process_version_request(*msg_ptr_ptr);
break;
...
}
————————————————
sns_rh_process_version_request调用如下：
adsp_proc\sensors\smgr\src\sns_rh_main.c
/*=========================================================================*/
SMGR_STATIC sns_err_code_e sns_rh_process_version_request(
const sns_rh_mr_req_q_item_s* msg_ptr)
{
sns_err_code_e err_code = SNS_ERR_NOMEM;
sns_common_version_resp_msg_v01* resp_ptr =
SMGR_ALLOC_STRUCT(sns_common_version_resp_msg_v01);
/* -------------------------------------------------------------------- */
if ( resp_ptr != NULL )
{
sns_rh_mr_header_s resp_msg_header = msg_ptr->header;
resp_ptr->max_message_id = SNS_SMGR_SVC_V01_MAX_MESSAGE_ID;
resp_ptr->interface_version_number = SNS_SMGR_SVC_V01_IDL_MINOR_VERS+1;
resp_msg_header.msg_id = SNS_SMGR_VERSION_RESP_V01;
resp_msg_header.body_len = sizeof(sns_common_version_resp_msg_v01);
resp_ptr->resp.sns_result_t = SNS_RESULT_SUCCESS_V01;
resp_ptr->resp.sns_err_t = SENSOR1_SUCCESS;
sns_rh_mr_send_resp(&resp_msg_header, (void**)&resp_ptr);
SNS_SMGR_PRINTF0(HIGH, "Jon smgr response");
err_code = SNS_SUCCESS;
}
return err_code;
}
————————————————
————————————————