/*****************************************************************************
* FUNCTION
* tp_ps_handling_at_indication
* DESCRIPTION
* This function is used to handle the response/URC data from MOD_ATCI
*
* PARAMETERS
* channelId [IN]
* buf [IN]
* iDataLen [IN]
*
* RETURNS
* void
*****************************************************************************/
static void tp_ps_handling_at_indication(kal_uint8 channelId, kal_char *buf, kal_uint16 iDataLen)
{
kal_char *data;
if (tp_callback == NULL || tp_port_begin == -1)
{
if (tp_callback == NULL)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] ERROR: havn't register TP callback function");
}
else if (tp_port_begin == -1)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] ERROR: havn't start PS, please call tp_ps_start first");
}
// buffer the URC
if (channelId == RMMI_MSG_BASED_URC_CHANNEL)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] Buffer the URC: %s", buf);
if ( (tp_urc_buffer_len + iDataLen) > MAX_TP_URC_BUFFER_LENGTH)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] URC buffer is full, clean the buffer", buf);
tp_urc_buffer_len = 0;
}
if (iDataLen > MAX_TP_URC_BUFFER_LENGTH)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] ERROR: the URC is too large, please increase the URC buffer");
}
else
{
kal_mem_cpy(tp_urc_buffer+tp_urc_buffer_len, buf, iDataLen);
tp_urc_buffer_len += iDataLen;
}
}
}
else
{
data = get_ctrl_buffer(iDataLen);
kal_mem_cpy(data, buf, iDataLen);
tp_callback(channelId, data, iDataLen, 1);
free_ctrl_buffer(data);
}
}
/*****************************************************************************
* FUNCTION
* rmmi_msgbased_send_ilm
* DESCRIPTION
* This function is used to send ILM to dest_id using the msg_id with data local_param_ptr and peer_buf_ptr
*
* PARAMETERS
* dest_id [IN]
* msg_id [IN]
* local_param_ptr [IN]
* peer_buf_ptr [IN]
*
* RETURNS
* void
*****************************************************************************/
static void rmmi_msgbased_send_ilm(module_type dest_id, kal_uint16 msg_id, void *local_param_ptr, void *peer_buf_ptr)
{
module_type module = stack_get_active_module_id();
msg_send6(module, dest_id, ATCI_SAP, (msg_type)msg_id, (local_para_struct *) local_param_ptr, (peer_buff_struct*) peer_buf_ptr);
}
/*****************************************************************************
* FUNCTION
* tp_ps_start
* DESCRIPTION
* This function is used to start message based AT command mechanism by customer
*
* PARAMETERS
* buffer [IN] output data
*
* RETURNS
* TP_SUCCESS or TP_ERROR
*****************************************************************************/
kal_int32 tp_ps_start(kal_int8 channelNum)
{
kal_uint8 i;
rmmi_register_channel_req_struct *req_ptr;
if(channelNum > RMMI_MSG_BASED_CUSTOM_AT_CHANNEL)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Start] Register channel number(%d) is larger than the maximum supported number: %d",
channelNum, RMMI_MSG_BASED_CUSTOM_AT_CHANNEL);
return TP_ERROR;
}
else if (tp_channelNum != 0)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Start] We have already been started");
return TP_ERROR;
}
tp_channelNum = channelNum;
//init buffers
for(i=0; i<channelNum; i++)
{
tp_buffer[i].length = 0;
tp_buffer[i].data[0] = '\0';
tp_buffer[i].is_sms_cmd = KAL_FALSE;
}
//send MSG_ID_ATCI_REGISTER_CHANNEL_REQ
req_ptr = (rmmi_register_channel_req_struct*)
construct_local_para((kal_uint16) sizeof(rmmi_register_channel_req_struct), TD_RESET);
req_ptr->ch_num = channelNum;
rmmi_msgbased_send_ilm(
RMMI_MSG_BASED_HANDLER_MODULE,
MSG_ID_RMMI_REGISTER_CHANNEL_REQ,
req_ptr, NULL);
return TP_SUCCESS;
}
/*****************************************************************************
* FUNCTION
* aud_bt_a2dp_codec_callback
* DESCRIPTION
*
* PARAMETERS
* event [IN]
* param [?]
* RETURNS
* void
*****************************************************************************/
void aud_bt_a2dp_codec_callback(A2DP_Event event, void *param)
{
A2DP_codec_struct* codec_p = (A2DP_codec_struct*)param;
module_type src_mod_id;
if(kal_if_hisr() != KAL_FALSE)
src_mod_id = MOD_L1SPHISR;
else
src_mod_id = stack_get_active_module_id();
bt_a2dp_send_stream_data_send_req(src_mod_id, stream_handle, codec_p);
}
/*****************************************************************************
* FUNCTION
* tp_ps_exe_at_cnf_hdlr
* DESCRIPTION
* This function is used to handle the message MSG_ID_RMMI_EXE_AT_CNF
*
* PARAMETERS
* local_para_ptr [IN]
* peer_buff_ptr [IN]
*
* RETURNS
* void
*****************************************************************************/
static void tp_ps_exe_at_cnf_hdlr(local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr)
{
rmmi_exe_at_cnf_struct *cnf_ptr;
cnf_ptr = (rmmi_exe_at_cnf_struct*) local_para_ptr;
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] ATCI has received the request, result:%d, from port:%d",
cnf_ptr->result, cnf_ptr->port_id);
}
/*****************************************************************************
* FUNCTION
* tp_ps_test_callback
* DESCRIPTION
* This function is the test purpose callback function for testing
*
* PARAMETERS
* channelId [IN] always be 1
* buf [IN]
* iDataLen [IN]
* iFlag [IN]
*
* RETURNS
* TP_SUCCESS or TP_ERROR
*****************************************************************************/
static kal_int32 tp_ps_test_callback(kal_uint8 channelId, kal_char *buf, kal_uint16 iDataLen, kal_uint8 iFlag)
{
/*This function is used to test the tp ps functions*/
module_type type;
type = stack_get_active_module_id();
kal_prompt_trace(
type,
"[Callback] Ch: %d, length: %d, flag: %d, buf:%s",
channelId, iDataLen, iFlag, buf);
return 0;
}
/*****************************************************************************
* FUNCTION
* rmmi_msgbased_register_channel
* DESCRIPTION
* This function is used to init source/port mapping accroding the ch_num
* PARAMETERS
* ch_num [IN]
* RETURNS
* RMMI_MSG_BASED_PORT_BEGIN
*****************************************************************************/
kal_uint8 rmmi_msgbased_register_channel(kal_uint8 ch_num)
{
kal_uint8 i, src;
src = RMMI_MSG_AT_SRC;
for (i=0; i<ch_num; i++)
{
kal_prompt_trace(
stack_get_active_module_id(),
"[Reg] Register channel(%d): source: %d, port: %d",
i, src, RMMI_MSG_BASED_PORT_BEGIN+i);
rmmi_msgbased_port[i] = RMMI_MSG_BASED_PORT_BEGIN + i;
rmmi_msgbased_src[i] = src++;
}
return RMMI_MSG_BASED_PORT_BEGIN;
}
static module_type get_current_module_id(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
switch (stack_get_active_module_id())
{
#ifdef __J2ME__
case MOD_J2ME:
return MOD_J2ME;
case MOD_JASYN:
return MOD_JASYN;
#endif /* __J2ME__ */
default:
return MOD_MMI;
}
}
/*****************************************************************************
* FUNCTION
* tp_ps_register_channel_cnf_hdlr
* DESCRIPTION
* This function is used to handle the message MSG_ID_RMMI_REGISTER_CHANNEL_CNF
*
* PARAMETERS
* local_para_ptr [IN]
* peer_buff_ptr [IN]
*
* RETURNS
* void
*****************************************************************************/
static void tp_ps_register_channel_cnf_hdlr(local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr)
{
rmmi_register_channel_cnf_struct *cnf_ptr;
cnf_ptr = (rmmi_register_channel_cnf_struct*) local_para_ptr;
tp_port_begin = cnf_ptr->begin_port_id;
kal_prompt_trace(
stack_get_active_module_id(),
"[Hdlr] Receive register channel confirm, result:%d, begin_port:%d",
cnf_ptr->result, tp_port_begin);
if ( !(tp_callback == NULL || tp_port_begin == -1))
{
if (tp_urc_buffer_len > 0)
{
tp_callback(
RMMI_MSG_BASED_URC_CHANNEL,
tp_urc_buffer,
tp_urc_buffer_len, 1);
}
}
}
/*****************************************************************************
* FUNCTION
* tp_ps_urc_at_ind_hdlr
* DESCRIPTION
* This function is used to handle the message relative to message based AT command mechanism
*
* PARAMETERS
* ilm_ptr [IN]
*
* RETURNS
* void
*****************************************************************************/
void tp_ps_message_handler(ilm_struct *ilm_ptr)
{
kal_prompt_trace(MOD_ATCI, "Enter TP Handler");
if (ilm_ptr->msg_id == MSG_ID_RMMI_REGISTER_CHANNEL_CNF)
{
tp_ps_register_channel_cnf_hdlr(ilm_ptr->local_para_ptr, ilm_ptr->peer_buff_ptr);
}
else if (ilm_ptr->msg_id == MSG_ID_RMMI_EXE_AT_CNF)
{
tp_ps_exe_at_cnf_hdlr(ilm_ptr->local_para_ptr, ilm_ptr->peer_buff_ptr);
}
else if (ilm_ptr->msg_id == MSG_ID_RMMI_RESPONSE_AT_IND)
{
tp_ps_response_at_ind_hdlr(ilm_ptr->local_para_ptr, ilm_ptr->peer_buff_ptr);
}
else if (ilm_ptr->msg_id == MSG_ID_RMMI_URC_AT_IND)
{
tp_ps_urc_at_ind_hdlr(ilm_ptr->local_para_ptr, ilm_ptr->peer_buff_ptr);
}
#ifdef TP_PS_NDEBUG
else if (ilm_ptr->msg_id == MSG_ID_TST_INJECT_STRING)
{
kal_int8 num;
tst_module_string_inject_struct *msg_ptr;
msg_ptr = (tst_module_string_inject_struct*) ilm_ptr->local_para_ptr;
switch(msg_ptr->index)
{
case 0: //reg_callback
tp_ps_reg_callback(tp_ps_test_callback);
break;
case 1: //start
num = atoi((kal_char *)msg_ptr->string);
kal_prompt_trace(stack_get_active_module_id(), "NUM: %d", num);
tp_ps_start(num);
break;
case 2: // send
tp_ps_Send(1, 0, msg_ptr->string, strlen((kal_char*)msg_ptr->string));
break;
case 3: // send <CR>
tp_ps_Send(1, 0, "\r", 1);
break;
case 4: // send <CTRL+Z>
num = RMMI_MSGBASED_CTRLZ;
tp_ps_Send(1, 0, (kal_uint8*) &num, 1);
break;
case 5: // send <ESC>
num = RMMI_MSGBASED_ESC;
tp_ps_Send(1, 0, (kal_uint8*) &num, 1);
break;
case 6: // send with invalid iFlag
tp_ps_Send(0, 0, msg_ptr->string, strlen((kal_char*)msg_ptr->string));
break;
case 7: // send with invalid channel
tp_ps_Send(1, 25, msg_ptr->string, strlen((kal_char*)msg_ptr->string));
break;
case 8: // send with invalid pointer
tp_ps_Send(1, 0, NULL, strlen((kal_char*)msg_ptr->string));
break;
case 9: // send to max channel
tp_ps_Send(1, RMMI_MSG_BASED_CUSTOM_AT_CHANNEL-1, msg_ptr->string, strlen((kal_char*)msg_ptr->string));
break;
case 10: // send <CR>
tp_ps_Send(1, RMMI_MSG_BASED_CUSTOM_AT_CHANNEL-1, "\r", 1);
break;
case 11: // send <CTRL+Z>
num = RMMI_MSGBASED_CTRLZ;
tp_ps_Send(1, RMMI_MSG_BASED_CUSTOM_AT_CHANNEL-1, (kal_uint8*) &num, 1);
break;
case 12: // send <ESC>
num = RMMI_MSGBASED_ESC;
tp_ps_Send(1, RMMI_MSG_BASED_CUSTOM_AT_CHANNEL-1, (kal_uint8*) &num, 1);
break;
case 13: // send <ESC>
tp_ps_Send(1, 0, msg_ptr->string, strlen((kal_char*)msg_ptr->string));
tp_ps_Send(1, 0, "\r", 1);
break;
case 14: // send <ESC>
tp_ps_Send(1, RMMI_MSG_BASED_CUSTOM_AT_CHANNEL-1, msg_ptr->string, strlen((kal_char*)msg_ptr->string));
tp_ps_Send(1, RMMI_MSG_BASED_CUSTOM_AT_CHANNEL-1, "\r", 1);
break;
default:
break;
}
}
#endif
}
/*****************************************************************************
* FUNCTION
* tp_ps_Send
* DESCRIPTION
* This function is used to send AT command to MOD_ATCI
* Return success means that the command is sent, not the command is executed successfully
* PARAMETERS
* iFlag [IN] always be 1
* channelId [IN]
* pDataPtr [IN]
* iDataLen [IN]
*
* RETURNS
* TP_SUCCESS or TP_ERROR
*****************************************************************************/
kal_int32 tp_ps_Send(kal_uint8 iFlag, kal_uint8 channelId, kal_uint8 *pDataPtr, kal_uint16 iDataLen)
{
kal_uint16 i;
kal_int32 result = TP_ERROR;
module_type type;
tp_queue_struct *buffer;
rmmi_exe_at_req_struct *req_ptr;
peer_buff_struct *peer_ptr;
kal_uint8 *data_ptr;
kal_uint8 cmd_string[10];
kal_char input_hint_string[] = "\r\n> ";
type = stack_get_active_module_id();
if (iFlag != 1)
{
kal_prompt_trace(
type,
"[Send] Warning: iFlag shoulbe be 1: %d", iFlag);
}
if (tp_port_begin == -1)
{
kal_prompt_trace(
type,
"[Send] ERROR: havn't start PS, please call tp_ps_start first");
}
else if(pDataPtr == NULL)
{
kal_prompt_trace(
type,
"[Send] ERROR: input data pointer is NULL!!!");
}
else if (tp_callback == NULL)
{
kal_prompt_trace(
type,
"[Send] ERROR: havn't register TP callback function");
}
else if(channelId >= tp_channelNum)
{
kal_prompt_trace(
type,
"[Send] ERROR: invalid channelID: ch:%d, max:%d ", channelId, tp_channelNum);
}
else
{
buffer = &tp_buffer[channelId];
if ( (buffer->length + iDataLen) > MAX_TP_QUEUE_LENGTH)
{
kal_prompt_trace(
type,
"[Send] ERROR: buffer[%d] is full, clean the buffer!!! Org:%d, New:%d, Max: %d",
channelId, buffer->length, iDataLen,
MAX_TP_QUEUE_LENGTH);
buffer->length = 0;
buffer->is_sms_cmd = KAL_FALSE;
}
else
{
result = TP_SUCCESS;
//Put the data into the buffer
kal_mem_cpy(buffer->data+buffer->length, pDataPtr, iDataLen);
//Update buffer length
buffer->length += iDataLen;
//check if the data is a complete command according to the <CR><LF>
for(i=0; i<buffer->length;i++)
{
if (buffer->is_sms_cmd == KAL_FALSE &&
(buffer->data[i] == RMMI_MSGBASED_CR || buffer->data[i] == RMMI_MSGBASED_LF) )
{
kal_mem_cpy(cmd_string, buffer->data, 10);
toUpper(cmd_string);
if (is_sms_command(cmd_string, 10) == KAL_TRUE)
{
buffer->is_sms_cmd = KAL_TRUE;
// send hint string
tp_callback(channelId, input_hint_string, strlen(input_hint_string), 1);
buffer->data[i] = RMMI_MSGBASED_LF;
kal_prompt_trace(
type,
"[Send] INFO: Enter SMS input mode");
}
break;
}
else if (buffer->is_sms_cmd == KAL_TRUE &&
(buffer->data[i] == RMMI_MSGBASED_CTRLZ || buffer->data[i] == RMMI_MSGBASED_ESC) )
{
kal_prompt_trace(
type,
"[Send] INFO: Leave SMS input mode");
buffer->is_sms_cmd = KAL_FALSE;
if (buffer->data[i] == RMMI_MSGBASED_ESC)
{
tp_callback(channelId, "\r\nOK\r\n", 6, 1);
//clean the buffer
buffer->length = 0;
return;
}
break;
}
}
if (i != buffer->length)
{
if (buffer->is_sms_cmd == KAL_TRUE)
{
kal_prompt_trace(
type,
"[Send] INFO: in SMS input mode, length: %d",
buffer->length);
}
else
{
// send the command
req_ptr = (rmmi_exe_at_req_struct*)
construct_local_para((kal_uint16) sizeof(rmmi_exe_at_req_struct), TD_RESET);
peer_ptr = (peer_buff_struct*) construct_peer_buff(buffer->length, 0, 0, TD_RESET);
data_ptr= (kal_uint8 *)get_peer_buff_pdu(peer_ptr, &i);
req_ptr->length = buffer->length;
req_ptr->port_id = channelId + tp_port_begin;
kal_mem_cpy(data_ptr, buffer->data, buffer->length);
rmmi_msgbased_send_ilm(
RMMI_MSG_BASED_HANDLER_MODULE,
MSG_ID_RMMI_EXE_AT_REQ,
req_ptr, peer_ptr);
//clean the buffer
buffer->length = 0;
}
}
}
}
return result;
}
kal_bool video_renderer_task_req_msg(
void * exec_task_name,
video_renderer_task_exec_func_t exec_func,
void * exec_param,
kal_uint32 exec_param_size)
{
#if defined(__MTK_TARGET__)
#if (defined(ISP_SUPPORT))
_video_renderer_task_local_param_t *ilm_param;
ilm_struct *p_ilm = NULL;
module_type eActiveModuleId;
kal_uint32 local_param_size;
kal_uint32 construct_size;
// Here, I utilize some behavior of arm compilier for struct "_video_renderer_task_local_param_t"
// 1. For exec_param, it is a pointer, and it's size must be 4 byte
// 2. The start address of struct must be 4 byte align
// 3. The start address of exec_param in the struct must be 4 byte align
// Then I will put the input exec_param to stuct exec_param
local_param_size = sizeof(_video_renderer_task_local_param_t);
construct_size = local_param_size - 4 + exec_param_size; // -4 is the size of exec_param in the struct
ilm_param = (_video_renderer_task_local_param_t*)
construct_local_para(construct_size, TD_CTRL);
ASSERT(NULL != ilm_param);
ilm_param->exec_func = exec_func;
kal_mem_cpy(&(ilm_param->exec_param), exec_param, exec_param_size);
eActiveModuleId = stack_get_active_module_id();
p_ilm = allocate_ilm(eActiveModuleId);
ASSERT(NULL != p_ilm);
// check target task
// Why not use return KAL_FALSE to instead
// When ilm was allocated but not send to msg queue, ASSERT will happen when next
// user to try to allocate ilm in the same thread
if (NULL == exec_task_name)
{
ASSERT(0);
}
else
{
if (0 == strcmp(exec_task_name, "MOD_CAL"))
{
p_ilm->dest_mod_id = MOD_CAL;
p_ilm->sap_id = CAL_SAP;
p_ilm->msg_id = (msg_type) MSG_ID_CAL_VIDEO_RENDERER_REQ;
}
else
{
ASSERT(0);
}
}
p_ilm->src_mod_id = eActiveModuleId;
p_ilm->local_para_ptr = (local_para_struct*) ilm_param;
p_ilm->peer_buff_ptr = NULL;
msg_send_ext_queue(p_ilm);
return KAL_TRUE;
#else //#if (defined(ISP_SUPPORT))
return KAL_FALSE;
#endif //#if (defined(ISP_SUPPORT))
#else //#if defined(__MTK_TARGET__)
return KAL_FALSE;
#endif //#if defined(__MTK_TARGET__)
}
