void pan_op_disconnect(BD_ADDR *bt_addr)
{
bt_pan_disconnect_req_struct msg;
btmtk_os_memset((U8 *)&msg, 0, sizeof(bt_pan_disconnect_req_struct));
btmtk_os_memcpy((U8 *)&msg.bt_addr, bt_addr, sizeof(msg.bt_addr));
BTCMD_SendMessage(MSG_ID_BT_PAN_DISCONNECT_REQ, MOD_EXTERNAL, &msg, sizeof(msg));
}
void btadp_jsr82_session_connect(BT_ADP_JSR82_SESSION *session)
{
bt_jsr82_connect_req_struct req;
ASSERT(session);
memset(&req, 0x0, sizeof(bt_jsr82_connect_req_struct));
session->conn_state = BT_ADP_JSR82_STATE_CONNECTING;
btmtk_os_memcpy(req.bd_addr, session->bd_addr, 6);
btmtk_os_memcpy(req.uuid_128, session->service, 16);
req.channel = session->channel;
req.channel_context = NULL;
req.identify = session->identify;
req.mtu = session->mtu;
req.ps_type = session->ps_type;
req.security_value = session->security_value;
bt_jsr82_HandleSessionApConnectReq(&req);
}
void btmtk_pan_disconnect_req(U8 *device_addr)
{
bt_pan_op_struct msg;
btmtk_os_memset((U8 *)&msg, 0, sizeof(bt_pan_op_struct));
msg.op = BT_PAN_OP_DISCONNECT;
btmtk_os_memcpy((U8 *)&msg.addr, device_addr, sizeof(msg.addr));
pan_process_cmd(&msg, sizeof(bt_pan_op_struct));
}
void SPPAdpScoRssiInd(SPPCallbackParms *Parms)
{
bt_spp_sco_rssi_ind_struct *rssi_ind =
(bt_spp_sco_rssi_ind_struct*) construct_local_para(sizeof(bt_spp_sco_rssi_ind_struct), TD_UL);
btmtk_os_memcpy(rssi_ind->bd_address, Parms->p.spp_sco_rssi_ind.bd_address, 6);
rssi_ind->rssi_value = Parms->p.spp_sco_rssi_ind.rssi_value;
SPPOS_sendMsg(MSG_ID_BT_SPP_SCO_RSSI_IND, Parms->dstMod, BT_APP_SAP, (local_para_struct*) rssi_ind, NULL);
}
void pan_op_connect(bt_pan_service_enum local_service, bt_pan_service_enum remote_service, BD_ADDR *bt_addr)
{
bt_pan_connect_req_struct msg;
btmtk_os_memset((U8 *)&msg, 0, sizeof(bt_pan_connect_req_struct));
msg.local_service = local_service;
msg.remote_service = remote_service;
btmtk_os_memcpy((U8 *)&msg.bt_addr, bt_addr, sizeof(msg.bt_addr));
BTCMD_SendMessage(MSG_ID_BT_PAN_CONNECT_REQ, MOD_EXTERNAL, &msg, sizeof(msg));
}
void btmtk_pan_connect_req(bt_pan_service_enum local_service, bt_pan_service_enum remote_service, U8 *device_addr)
{
bt_pan_op_struct msg;
btmtk_os_memset((U8 *)&msg, 0, sizeof(bt_pan_op_struct));
msg.op = BT_PAN_OP_CONNECT;
msg.local_service = local_service;
msg.remote_service = remote_service;
btmtk_os_memcpy((U8 *)&msg.addr, device_addr, sizeof(msg.addr));
pan_process_cmd(&msg, sizeof(bt_pan_op_struct));
}
void btadp_jsr82_session_connect_rsp(BT_ADP_JSR82_SESSION *session, kal_uint8 result)
{
bt_jsr82_connect_rsp_struct rsp;
memset(&rsp, 0x0, sizeof(bt_jsr82_connect_rsp_struct));
btmtk_os_memcpy(rsp.bd_addr, session->bd_addr, 6);
rsp.channel = session->channel;
rsp.identify = session->identify;
rsp.index = session->index;
rsp.l2cap_id = session->l2cap_id;
rsp.mtu = session->mtu;
rsp.ps_type = session->ps_type;
rsp.result = result;
bt_jsr82_HandleSessionApConnectRsp(&rsp);
}
BtStatus HidCacheReportDescriptor(BD_ADDR addr, U8* HidDescriptorList, U32 length)
{
U8 i = 0;
for (i = 0; i < HID_MAX_REPORT_DESCRIPTOR_NUM; i++)
{
if (!CachedReportDescriptor[i].inUse)
{
btmtk_os_memcpy(CachedReportDescriptor[i].BtAddr.addr, addr.addr, 6);
CachedReportDescriptor[i].inUse = TRUE;
CachedReportDescriptor[i].reportDescriptor = (U8*)hid_malloc(length);
if(!CachedReportDescriptor[i].reportDescriptor)
{
bt_prompt_trace(MOD_BT,"[HID]CachedReportDescriptor[i].reportDescriptor hid_malloc error");
return BT_STATUS_FAILED;
}
btmtk_os_memset(CachedReportDescriptor[i].reportDescriptor, 0 ,length);
btmtk_os_memcpy(CachedReportDescriptor[i].reportDescriptor, HidDescriptorList, length);
CachedReportDescriptor[i].reportDescriptorLength = length;
break;
}
}
return BT_STATUS_SUCCESS;
}
void SPPUARTGetBytesCnfSend(SPPCallbackParms *Parms, U16 lengthSent, U16 lengthToSend)
{
btmtk_spp_uart_get_bytes_cnf_struct *msg =
(btmtk_spp_uart_get_bytes_cnf_struct*) construct_local_para(sizeof(btmtk_spp_uart_get_bytes_cnf_struct), TD_UL);
msg->port = Parms->p.spp_uart_get_bytes_cnf.port;
msg->profile = Parms->p.spp_uart_get_bytes_cnf.profile;
msg->length = lengthToSend;
#ifdef __SPP_SHARED_MEMORY__
msg->buffer = Parms->p.spp_uart_get_bytes_cnf.buffer;
#else
btmtk_os_memcpy(msg->buffer, (Parms->p.spp_uart_get_bytes_cnf.buffer + lengthSent), lengthToSend);
#endif /* __SPP_SHARED_MEMORY__ */
SPPOS_sendMsg(MSG_ID_BT_SPP_UART_GET_BYTES_CNF, MOD_MMI, BT_APP_SAP, (local_para_struct*) msg, NULL);
}
void btmtk_pan_connection_authorize_rsp(U8 *device_addr, BT_BOOL result)
{
BT_PAN_DEVICE *dev = pan_find_device_by_addr(device_addr);
bt_pan_connection_authorize_rsp_struct msg;
assert(dev != NULL);
/* even if authorization is deny, set state as connecting, and wait for disconnected event */
pan_set_state(dev, BT_PAN_APP_STAT_CONNECTING);
btmtk_os_memset((U8 *)&msg, 0, sizeof(bt_pan_connection_authorize_rsp_struct));
msg.accept = result;
btmtk_os_memcpy((U8 *)&msg.bt_addr, device_addr, sizeof(msg.bt_addr));
BTCMD_SendMessage(MSG_ID_BT_PAN_CONNECTION_AUTHORIZE_RSP, MOD_EXTERNAL, &msg, sizeof(msg));
}
void SPPUARTDataAvailableIndSend(SPPCallbackParms *Parms, U16 lengthSent, U16 lengthToSend)
{
btmtk_spp_uart_data_available_ind_struct *msg =
(btmtk_spp_uart_data_available_ind_struct*) construct_local_para(sizeof(btmtk_spp_uart_data_available_ind_struct), TD_UL);
msg->port = Parms->p.spp_uart_data_available_ind.port;
msg->profile = Parms->p.spp_uart_data_available_ind.profile;
msg->length = lengthToSend;
#ifdef __SPP_SHARED_MEMORY__
msg->buffer = Parms->p.spp_uart_data_available_ind.buffer;
#else
btmtk_os_memcpy(msg->buffer, (Parms->p.spp_uart_data_available_ind.buffer + lengthSent), lengthToSend);
#endif /* __SPP_SHARED_MEMORY__ */
SPPOS_sendMsg(MSG_ID_BT_SPP_UART_DATA_AVAILABLE_IND, MOD_MMI, BT_APP_SAP, (local_para_struct*) msg, NULL);
}
/*---------------------------------------------------------------------------
* HidStartServiceQuery()
*---------------------------------------------------------------------------
*
* Synopsis: Initiate the SDP service query for a HID device.
*
* Return: See SDP_Query().
*/
BtStatus HidStartServiceQuery(HidChannel *Channel)
{
BtStatus status = BT_STATUS_FAILED;
sdap_service_search_multi_attribute_struct search_pattern;
ReportDescriptorList* reportDescriptorList = NULL;
HidParseData* hpd ;
reportDescriptorList = HidFindReportDescriptorByAddr(Channel->cmgrHandler.remDev->bdAddr);
if(reportDescriptorList != NULL && Channel->state == HID_STATE_OPEN)
{
Channel->queryRsp.descriptorLen = reportDescriptorList->reportDescriptorLength;
Channel->queryRsp.descriptorList = (U8*)hid_malloc(reportDescriptorList->reportDescriptorLength);
btmtk_os_memset((U8*) Channel->queryRsp.descriptorList, 0, reportDescriptorList->reportDescriptorLength);
btmtk_os_memcpy((U8*) Channel->queryRsp.descriptorList, reportDescriptorList->reportDescriptor, reportDescriptorList->reportDescriptorLength);
hpd = (HidParseData*)hid_malloc(sizeof(HidParseData));
Hid_Init_Parser(hpd);
Channel->reportCons[0] = (HidReportConstructor*)hid_malloc(HID_REPORT_ID_MAX * sizeof(HidReportConstructor));
btmtk_os_memset((U8*) Channel->reportCons[0], 0, HID_REPORT_ID_MAX * sizeof(HidReportConstructor));
if(HidAddDescriptor(Channel) == BT_STATUS_SUCCESS)
bt_prompt_trace(MOD_BT,"[HID]HidAddDescriptor Successed!");
else
bt_prompt_trace(MOD_BT,"[HID]HidAddDescriptor failed!");
Hid_Free_Parser(hpd);
Channel->flags &= ~CHNL_FLAG_SERVICE_QUERY;
HidSdpCallback(Channel, BT_STATUS_SUCCESS);
return BT_STATUS_SUCCESS;
}
else
{
search_pattern.rm = Channel->cmgrHandler.remDev;
search_pattern.sqt = &Channel->sdpQueryToken;
search_pattern.uuid = SC_HUMAN_INTERFACE_DEVICE;
search_pattern.callback = HidSdpEventHandler;
search_pattern.attribute_num = sizeof(bt_hid_attr_id_list)/sizeof(bt_hid_attr_id_list[0]);
search_pattern.attribute_id = bt_hid_attr_id_list;
status = SDAP_ServiceSearchMultipleAttribute2(search_pattern);
return status;
}
}
BtStatus HidAddDescriptor(HidChannel *channel)
{
if(!channel)
{
bt_prompt_trace(MOD_BT,"[HID]Empty Channel");
return BT_STATUS_FAILED;
}
bt_prompt_trace(MOD_BT,"[HID]channel->descLen=%d",channel->descLen);
btmtk_os_memcpy(channel->descStr + channel->descLen,
channel->queryRsp.descriptorList,
channel->queryRsp.descriptorLen);
channel->descLen += channel->queryRsp.descriptorLen;
bt_prompt_trace(MOD_BT,"[HID]channel->descLen=%d",channel->descLen);
HidShowBytes(channel->descStr, channel->descLen);
return 0;
}
/*****************************************************************************
* FUNCTION
* SimSrvCallback
* DESCRIPTION
*
* PARAMETERS
* Server [IN]
* Parms [IN]
* RETURNS
* void
*****************************************************************************/
void SimSrvCallback(SimServer *Server, SimCallbackParms *Parms)
{
SimCardReaderStatus cardRdrStatus;
SimCardStatus statusChange = SIM_CARD_STATUS_UNKNOWN;
SimResultCode result = SIM_RESULT_NO_REASON;
BtStatus status;
U8 *ptr;
U16 len;
switch (Parms->event)
{
case SAEVENT_SERVER_OPEN_IND:
/* When receiving this event, SimServer will send CONNECT_RSP event back to client */
if ((status = SIM_ServerRespondOpenInd(Server, SIM_CONN_STATUS_OK)) != BT_STATUS_PENDING)
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_NOT_ACCEPTED_IN_SRVCALLBACK, status);
/* In this case means that sending of CONNECT_RSP is failed */
/* Return value from RF_CloseChannel() may be BT_STATUS_IN_PROGRRESS(presenting rfchannel state is DLC_STATE_DISC_PENDING) */
status = SimApCloseRFCommChnl(&(Server->rfChannel));
if ((status != BT_STATUS_PENDING) && (status != BT_STATUS_IN_PROGRESS) && (status != BT_STATUS_SUCCESS))
{
/* Report(("SERVER_OPEN_IND and RF_CloseChannel error, status=%d",status)); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SHOW_ONE_BYTE, status);
Assert(0);
}
}
else
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_ACCEPTED_IN_SRVCALLBACK);
}
break;
case SAEVENT_SERVER_OPEN:
kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_OPEN_IN_SRVCALLBACK, Parms->status);
if (Parms->status == BT_STATUS_SUCCESS)
{
#if 0 // Reserved for MAUI
bt_simap_connect_ind_struct *bt_simap_connect_ind = NULL;
#endif
SIMAPCallbackParms parms;
/* Allocated a connection id for SIM Access Profile (SC_SIM_ACCESS: 0x112D) */
SIM(connect_id)[0] = BTBMProfileAllocateConnIndex(SC_SIM_ACCESS, Parms->ptrs.remDev->bdAddr);
SIM(allocated_connect_id)[0] = KAL_TRUE;
#if 0 // Reserved for MAUI
bt_simap_connect_ind = construct_local_para(sizeof(bt_simap_connect_ind_struct), TD_UL);
/* Reset lap,uap,nap to zero */
bt_simap_connect_ind->lap = 0;
bt_simap_connect_ind->uap = 0;
bt_simap_connect_ind->nap = 0;
memcpy(&(bt_simap_connect_ind->lap), &Parms->ptrs.remDev->bdAddr.addr[0], 3);
bt_simap_connect_ind->uap = Parms->ptrs.remDev->bdAddr.addr[3];
memcpy(&(bt_simap_connect_ind->nap), (U16*) & Parms->ptrs.remDev->bdAddr.addr[4], 2);
bt_simap_connect_ind->cid = SIM(connect_id)[0];
bt_send_msg(
MSG_ID_BT_SIMAP_CONNECT_IND,
MOD_MMI,
BT_APP_SAP,
(local_para_struct*) bt_simap_connect_ind,
NULL);
#endif
parms.event = SIMAP_EVENT_CONNECT_IND;
parms.dstMod = MOD_MMI;
parms.p.simap_connect_ind.cid = SIM(connect_id)[0];
parms.p.simap_connect_ind.lap = 0;
parms.p.simap_connect_ind.uap = 0;
parms.p.simap_connect_ind.nap = 0;
btmtk_os_memcpy((U8 *)&(parms.p.simap_connect_ind.lap), &Parms->ptrs.remDev->bdAddr.addr[0], 3);
parms.p.simap_connect_ind.uap = Parms->ptrs.remDev->bdAddr.addr[3];
btmtk_os_memcpy((U8 *)&(parms.p.simap_connect_ind.nap), (U8 *) &Parms->ptrs.remDev->bdAddr.addr[4], 2);
SIMAPCB(&parms);
}
else
{
/* Handle the failed OPEN Event */
/* Return value from RF_CloseChannel() may be BT_STATUS_IN_PROGRRESS(presenting rfchannel state is DLC_STATE_DISC_PENDING) */
status = SimApCloseRFCommChnl(&(Server->rfChannel));
if ((status != BT_STATUS_PENDING) && (status != BT_STATUS_IN_PROGRESS) && (status != BT_STATUS_SUCCESS))
{
/* Report(("SERVER_OPEN and RF_CloseChannel err, status=%d",status)); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SHOW_ONE_BYTE, status);
Assert(0);
}
}
break;
case SAEVENT_SERVER_CLOSE_IND:
kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_CLOSED_IND_IN_SRVCALLBACK, Parms->status);
break;
case SAEVENT_SERVER_CLOSED:
kal_trace(TRACE_GROUP_1, BT_SIMAP_CLOSED_IN_SRVCALLBACK, Parms->status);
/* Determine that if is is necessary to notify SIM task to start recovery mechanism */
Report(("[BT SIMAP_svr]SAEVENT_SERVER_CLOSED: substate=%d", SIM(simServer)[0].substate));
//clear the RF channel
cur_rfchannel = NULL;
if (SIM(simServer)[0].substate & BT_REJECT_SECOND_CLIENT_SESSION)
{
SIM(simServer)[0].substate &= (~BT_REJECT_SECOND_CLIENT_SESSION);
/* Report(("This closed event is due to SimServer is serving one client now, so reject another seesion")); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_CLOSED_EVENT_DUE_TO_REJECT_SECOND_CLIENT);
return;
}
if ((SIM(simServer)[0].substate & BT_SIM_CONNECT_REQ_SENT) &&
(SIM(simServer)[0].substate & BT_SIM_CONNECT_CNF_RECV) && (SIM(simServer)[0].atr.dataLen == 0))
{
//Report(("CONNECT_CNF from SIM task is error, Send DISC_REQ to SIM task is not necessary when CLOSED in SimServer"));
//Report(("Case0:In SimSrvCallback():SimServer is available again!"));
kal_trace(TRACE_GROUP_1, BT_SIMAP_SRVCALLBACK_CASE0);
SIM(simServer)[0].substate = 0;
SIM(simServer)[0].available = TRUE;
}
else if (SIM(simServer)[0].substate & BT_SIM_CONNECT_REQ_SENT)
{
/* Because the SIM task may notify other modules to enter remote SIM mode, it is necessary to recovery as normal mode */
/* Through sending disconnect_req to SIM task to notify it */
/* Check if timer for DISC_Graceful is still runing */
if (SIM(simServer)[0].substate & BT_APP_DISCONNECT_REQ_RECV)
{
/* Report(("In SimSrvCallback() recv CLOSED, check timer for DISC_Graceful type")); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SRVCALLBACK_RECV_CLOSED_CHECK_TIMER);
bt_simap_stop_timer(&SIM(simap_event_id));
}
/* Send BT_SIM_DISCONNECT_REQ message to SIM task */
SIM(simServer)[0].substate |= BT_SIM_DISCONNECT_REQ_SENT;
#if 0
#ifdef __SIMAP_TESTER_
if(SIM(simServer)[0].test_mode == 1)
bt_fakesim_disconnect_req_hdlr();
else if(SIM(simServer)[0].test_mode == 2)
bt_send_msg(MSG_ID_BT_SIM_DISCONNECT_REQ, MOD_SIM, PS_SIM_SAP, NULL, NULL);
#endif
#endif /* 0 */
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_send_msg(MSG_ID_BT_SIM_DISCONNECT_REQ, MOD_SIM, PS_SIM_SAP, NULL, NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_DISCONNECT_REQ;
parms.dstMod = MOD_SIM;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_disconnect_req_hdlr();
}
#endif /* __SIMAP_UT_ */
}
else
{
/* Note: substate field has two bytes, if U8 is used the substate (e.g., 0x1000) will be narrowed to 0x00 : 2006-12-28 */
U32 oldsubstate = SIM(simServer)[0].substate;
kal_trace(TRACE_GROUP_1, BT_SIMAP_SIMSERVER_AVAILABLE_IN_SRVCALLBACK, oldsubstate);
/* Report(("Case1:In SimSrvCallback():SimServer is available again, and Simserver substate=%d",oldsubstate)); */
/*
* Check if this CLOSED Event is triggered due to receive MMI's DEACTIVATE_REQ in SimServer's CONNECT_PENDING state
* If SimServer has not yet send CONNECT_REQ to SIM task, this case is matched (No necessary to notify SIM task)
* The DEACTIVATE_CNF is returned here directly
* At that time, we call RF_CloseChannel() to trigger this event
*/
if (SIM(simServer)[0].substate & BT_APP_DEACTIVATE_REQ_RECV)
{
#if 0 // Reserved for MAUI
bt_simap_deactivate_cnf_struct *bt_simap_deactivate_cnf = construct_local_para(sizeof(bt_simap_deactivate_cnf_struct), TD_UL);
#endif
SIMAPCallbackParms parms;
/* Using this func to deregister rfcomm server channel and sdp record of SIM Access Profile */
Assert(SIM_DeregisterServer(Server) == BT_STATUS_SUCCESS);
/* Report(("This case is SimServer closed then RFCOMM closed due to MMI Deactivate Req, return Deactivate_CNF with ok")); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SIMSRV_CLOSED_RFCOMM_CLOSED_DUE_TO_DEACTIVATE_REQ);
SIM(simServer)[0].simserver_activate_status = SIM_SERVER_STATUS_DEACTIVATED;
/* This means that SIM Access Profile connection is closed, check if conneciton_id is still allocated */
if (SIM(allocated_connect_id)[0] == KAL_TRUE)
{
BTBMProfileReleaseConnIndex(SIM(connect_id)[0]);
SIM(allocated_connect_id)[0] = KAL_FALSE;
/* Report(("Release SIM Acces Profile connect_id in Case 1")); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_RELEASE_SAP_CONID_CASE1);
}
#if 0 // Reserved for MAUI
bt_simap_deactivate_cnf->result = TRUE;
bt_send_msg(
MSG_ID_BT_SIMAP_DEACTIVATE_CNF,
MOD_MMI,
BT_APP_SAP,
(local_para_struct*) bt_simap_deactivate_cnf,
NULL);
#endif
parms.event = SIMAP_EVENT_DEACTIVATE_CNF;
parms.dstMod = MOD_MMI;
parms.p.simap_deactivate_cnf.result = TRUE;
SIMAPCB(&parms);
}
/*
* [MAUI_02129303]: As the AUTH_REQ is not responded by MMI & remote device close the RFCOMM channel (timed-out),
* we have to report this event to MMI to sync the status.
*/
else if (BT_MMI_AUTH_REQ_SENT == (SIM(simServer)[0].substate & BT_MMI_AUTH_REQ_SENT))
{
SIMAPCallbackParms parms;
btbm_bd_addr_t bd_addr;
btmtk_os_memset((kal_uint8*) & bd_addr, 0, sizeof(btbm_bd_addr_t));
CONVERT_ARRAY2BDADDR(&bd_addr, Server->remDev->bdAddr.addr);
parms.event = SIMAP_EVENT_AUTH_REQ_TIMEOUT_RFCLOSED_IND;
parms.dstMod = MOD_MMI;
parms.p.simap_auth_req_timeout_rfclose_ind.lap = bd_addr.lap;
parms.p.simap_auth_req_timeout_rfclose_ind.uap = bd_addr.uap;
parms.p.simap_auth_req_timeout_rfclose_ind.nap = bd_addr.nap;
SIMAPCB(&parms);
}
SIM(simServer)[0].substate = 0;
SIM(simServer)[0].available = TRUE;
if (SIM_SERVER_STATUS_DEACTIVATING == SIM(simServer)[0].simserver_activate_status)
{
/* Deactivate now.*/
bt_simap_deactivate_req_hdlr();
}
}
break;
case SAEVENT_SERVER_STATUS_REQ:
if (Parms->status == BT_STATUS_SUCCESS)
{
if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON)
{
statusChange = SIM_CARD_STATUS_RESET;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
statusChange = SIM_CARD_STATUS_INSERTED;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
statusChange = SIM_CARD_STATUS_REMOVED;
}
}
else if (Parms->status == BT_STATUS_FAILED)
{
statusChange = SIM_CARD_STATUS_NOT_ACCESSIBLE;
}
if ((status = SIM_ServerSendStatus(Server, statusChange)) != BT_STATUS_PENDING)
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_FAILED_SEND_STATUS_IND_IN_SRVCALLBACK, status);
}
else
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_STATUS_IND_IN_SRVCALLBACK);
}
break;
case SAEVENT_SERVER_ATR_REQ:
//kal_trace(TRACE_GROUP_1, BT_SIMAP_SIMCARDREADER_STATUS, SIM(simServer)[0].current_simcardreader_status);
Report(("[BT SIMAP]current_simcardreader_status=0x%x", SIM(simServer)[0].current_simcardreader_status));
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
result = SIM_RESULT_OK;
ptr = SIM(simServer)[0].atr.data;
len = SIM(simServer)[0].atr.dataLen;
}
else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)
{
/* Alread off : This case is POWERED_OFF but CARD_PRESENT */
result = SIM_RESULT_CARD_ALREADY_OFF;
len = 0;
ptr = NULL;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* No card inserted */
/* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */
result = SIM_RESULT_CARD_REMOVED;
len = 0;
ptr = NULL;
}
status = SIM_ServerAtrRsp(Server, len, ptr, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_FAILED_SEND_ATR_RSP_IN_SRVCALLBACK, result, status);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
break;
case SAEVENT_SERVER_APDU_REQ:
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_sim_apdu_req_struct *apdu_req = NULL;
#else
SIMAPCallbackParms parms;
#endif
SIM(simServer)[0].substate |= BT_SIM_APDU_REQ_SENT;
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_APDU_TO_SIM_IN_SRVCALLBACK);
#ifdef __SIMAP_MAUI__
/* Send APDU request to SIM task */
apdu_req = construct_local_para(sizeof(bt_sim_apdu_req_struct), TD_UL);
apdu_req->apdu_req_len = Parms->ptrs.msg->parm.apdu.dataLen;
OS_MemSet(apdu_req->apdu_req, 0, APDU_REQ_MAX_LEN);
OS_MemCopy(apdu_req->apdu_req, Parms->ptrs.msg->parm.apdu.data, apdu_req->apdu_req_len);
apdu_req->transport_protocol_type = SIM(simServer)[0].current_transport_protocol_type;
bt_send_msg(MSG_ID_BT_SIM_APDU_REQ, MOD_SIM, PS_SIM_SAP, (local_para_struct*) apdu_req, NULL);
#else
parms.event = SIM_EVENT_APDU_REQ;
parms.dstMod = MOD_SIM;
parms.p.sim_apdu_req.apdu_req_len = Parms->ptrs.msg->parm.apdu.dataLen;
btmtk_os_memset(parms.p.sim_apdu_req.apdu_req, 0, APDU_REQ_MAX_LEN);
btmtk_os_memcpy(parms.p.sim_apdu_req.apdu_req, Parms->ptrs.msg->parm.apdu.data, parms.p.sim_apdu_req.apdu_req_len);
parms.p.sim_apdu_req.transport_protocol_type = SIM(simServer)[0].current_transport_protocol_type;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_apdu_req_hdlr(Parms->ptrs.msg->parm.apdu.dataLen, Parms->ptrs.msg->parm.apdu.data);
}
#endif /* __SIMAP_UT_ */
}
else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)
{
/* Alread off : This case is POWERED_OFF but CARD_PRESENT */
result = SIM_RESULT_CARD_ALREADY_OFF;
ptr = NULL;
len = 0;
status = SIM_ServerApduRsp(&SIM(simServer)[0], len, ptr, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_APDU_RSP_TO_CLIENT, result, status, 1);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* No card inserted */
/* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */
result = SIM_RESULT_CARD_REMOVED;
ptr = NULL;
len = 0;
status = SIM_ServerApduRsp(&SIM(simServer)[0], len, ptr, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_APDU_RSP_TO_CLIENT, result, status, 2);
if (status != BT_STATUS_SUCCESS)
{
Assert(0);
}
}
break;
case SAEVENT_SERVER_SIM_OFF_REQ:
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* In this case: must SIM_CRS_CARD_POWERED_ON and SIM_CRS_CARD_PRESENT are satisfied at the same time */
/* Send POWER_OFF_REQ to SIM task */
kal_trace(TRACE_GROUP_1, BT_SIM_SEND_POWER_OFF_TO_SIM_IN_SRVCALLBACK);
SIM(simServer)[0].substate |= BT_SIM_POWER_OFF_REQ_SENT;
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_send_msg(MSG_ID_BT_SIM_POWER_OFF_REQ, MOD_SIM, PS_SIM_SAP, NULL, NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_POWER_OFF_REQ;
parms.dstMod = MOD_SIM;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_poweroff_req_hdlr();
}
#endif /* __SIMAP_UT_ */
return;
}
else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)
{
/* Alread off : This case is POWERED_OFF but CARD_PRESENT */
result = SIM_RESULT_CARD_ALREADY_OFF;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* No card inserted */
/* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */
result = SIM_RESULT_CARD_REMOVED;
}
/* Send POWER_OFF_RSP to client */
status = SIM_ServerSimOffRsp(Server, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_POWER_OFF_RSP_TO_CLIENT, result, status);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
break;
case SAEVENT_SERVER_SIM_ON_REQ:
/* if current information is enough to return rsp, then sends rsp in this function */
/* POWE_ON_REQ only let client to request T at 0 (T=0) */
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
result = SIM_RESULT_CARD_ALREADY_ON;
}
else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)
{
/*
* Because SIM card is already off, so current_transport_protocol_type is invalid
* Set T=0 directly and send BT_SIM_RESET_REQ to sim task!
*/
if (SIM(simServer)[0].supported_transport_protocol_type_capability == 2 ||
SIM(simServer)[0].supported_transport_protocol_type_capability == 0)
{
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_POWER_ON;
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_sim_reset_req_struct *reset_req = NULL;
reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL);
reset_req->transport_protocol_type = 0; /* default using T=0 transport protocol type */
bt_send_msg(
MSG_ID_BT_SIM_RESET_REQ,
MOD_SIM,
PS_SIM_SAP,
(local_para_struct*) reset_req,
NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_RESET_REQ;
parms.dstMod = MOD_SIM;
parms.p.sim_reset_req.transport_protocol_type = 0;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_poweron_req_hdlr();
}
#endif /* __SIMAP_UT_ */
return;
}
else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 1)
{
/* SIM Card only supports T=1: RESET Error! because not support T=0, RESET_REQ uses T=0! */
result = SIM_RESULT_CARD_NOT_ACCESSIBLE;
}
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */
result = SIM_RESULT_CARD_REMOVED;
}
else
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_NO_RULES_PROCESS_SIM_ON_REQ_IN_SRVCALLBACK);
Assert(0);
}
/* Send SIM_POWER_ON_RSP to sim client with result code */
status = SIM_ServerSimOnRsp(Server, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_POWER_ON_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
break;
case SAEVENT_SERVER_SET_TRANS_PROT_REQ:
#if SET_T_SUPPORTED == TRUE
/* if current information is enough to return rsp, then sends rsp in this function */
/* Set Transport Protocol Type Req will ask to reset the SIM Card */
SIM(simServer)[0].client_requested_transport_protocol_type = Parms->ptrs.msg->parm.protocolId;
/* Report(("In SimSrvCallback(): client requested T type=%d",SIM(simServer)[0].client_requested_transport_protocol_type)); */
kal_trace(
TRACE_GROUP_1,
BT_SIMAP_CLIENT_REQ_T_TYPE,
SIM(simServer)[0].client_requested_transport_protocol_type);
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
if (SIM(simServer)[0].supported_transport_protocol_type_capability == 2)
{
/* SIM Card supports both T=0 and T=1: Send BT_SIM_RESET_REQ msg to SIM task */
if (SIM(simServer)[0].current_transport_protocol_type != Parms->ptrs.msg->parm.protocolId)
{
Assert((SIM(simServer)[0].current_transport_protocol_type == 0) ||
(SIM(simServer)[0].current_transport_protocol_type == 1));
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_SET_T;
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_sim_reset_req_struct *reset_req = NULL;
reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL);
reset_req->transport_protocol_type = Parms->ptrs.msg->parm.protocolId;
bt_send_msg(
MSG_ID_BT_SIM_RESET_REQ,
MOD_SIM,
PS_SIM_SAP,
(local_para_struct*) reset_req,
NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_RESET_REQ;
parms.dstMod = MOD_SIM;
parms.p.sim_reset_req.transport_protocol_type = Parms->ptrs.msg->parm.protocolId;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_set_transprotocol_type_req_hdlr();
}
#endif /* __SIMAP_UT_ */
return;
}
else
{
/* Requested T type is the same as current T type, send rsp to sim client directly */
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_SET_T;
result = SIM_RESULT_OK;
}
}
else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 1 ||
SIM(simServer)[0].supported_transport_protocol_type_capability == 0)
{
/* In this case: SIM card only supports T=0 or T=1 and current_transport_protocol_type is equal to supported_transport_protocol_type_capability */
if (SIM(simServer)[0].current_transport_protocol_type != Parms->ptrs.msg->parm.protocolId)
{
/* Send REST_RSP with error code: Can't accessible to SIM Client */
/*
* In this case: Send SET_T_RSP first
* then in Open state PACKET_HANDLED EVENT: send STATUS_IND with card not accessible
*/
/* Report(("SET T=0/T=1 but only support T=1/T=0, Send SET_T_RSP first then STATUS_IND with card not accessible later")); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SET_T0_T1_NOT_SUPPORT_T1_T0);
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_SET_T;
result = SIM_RESULT_NOT_SUPPORTED;
}
else
{
/* Requested T type is the same as current T type, send rsp to sim client directly */
result = SIM_RESULT_OK;
}
}
}
else if ((!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON)) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
result = SIM_RESULT_CARD_ALREADY_OFF;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
result = SIM_RESULT_CARD_REMOVED;
}
#else /* SET_T_SUPPORTED == TRUE */
result = SIM_RESULT_NOT_SUPPORTED;
#endif /* SET_T_SUPPORTED == TRUE */
/* Send SIM_SET_TRANSPORT_PROTOCOL_TYPE_RSP to sim client with result code */
status = SIM_ServerSetTransProtRsp(Server, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_SET_T_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status);
if (status != BT_STATUS_SUCCESS)
{
Assert(0);
}
break;
case SAEVENT_SERVER_RESET_SIM_REQ:
/* if current information is enough to return rsp, then sends rsp in this function */
/* RESET_REQ only let client to request T at 0 (T=0) */
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/*
* The original following state is wrong!
* Because as long as one bit (SIM_CRS_CARD_POWERED_ON or SIM_CRS_CARD_PRESENT) is set in current_simcardreader_status, condition is true!
* if((SIM(simServer)[0].current_simcardreader_status & (SIM_CRS_CARD_POWERED_ON | SIM_CRS_CARD_PRESENT)))
*/
/* In this case, must POWERED_ON and CARD_PRESERT are statisfied at the same time */
if (SIM(simServer)[0].supported_transport_protocol_type_capability == 2)
{
/* SIM Card supports both T=0 and T=1: Send BT_SIM_RESET_REQ msg to SIM task */
Assert((SIM(simServer)[0].current_transport_protocol_type == 0) ||
(SIM(simServer)[0].current_transport_protocol_type == 1));
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT;
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_sim_reset_req_struct *reset_req = NULL;
reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL);
reset_req->transport_protocol_type = 0; /* default using T=0 transport protocol type */
bt_send_msg(
MSG_ID_BT_SIM_RESET_REQ,
MOD_SIM,
PS_SIM_SAP,
(local_para_struct*) reset_req,
NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_RESET_REQ;
parms.dstMod = MOD_SIM;
parms.p.sim_reset_req.transport_protocol_type = 0;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_reset_req_hdlr();
}
#endif /* __SIMAP_UT_ */
return;
}
else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 1)
{
/* SIM Card only supports T=1: RESET Error! because not support T=0, RESET_REQ uses T=0! */
Assert(SIM(simServer)[0].supported_transport_protocol_type_capability == SIM(simServer)[0].current_transport_protocol_type);
/* Send REST_RSP with error code: Can't accessible to SIM Client */
result = SIM_RESULT_CARD_NOT_ACCESSIBLE;
}
else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 0)
{
/* SIM Card only supports T=0: Send BT_SIM_RESET_REQ msg to SIM task */
Assert(SIM(simServer)[0].supported_transport_protocol_type_capability == SIM(simServer)[0].current_transport_protocol_type);
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT;
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_sim_reset_req_struct *reset_req = NULL;
reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL);
reset_req->transport_protocol_type = 0; /* default using T=0 transport protocol type */
bt_send_msg(
MSG_ID_BT_SIM_RESET_REQ,
MOD_SIM,
PS_SIM_SAP,
(local_para_struct*) reset_req,
NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_RESET_REQ;
parms.dstMod = MOD_SIM;
parms.p.sim_reset_req.transport_protocol_type = 0;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_reset_req_hdlr();
}
#endif /* __SIMAP_UT_ */
return;
}
}
else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)
{
/* This case is SIM_CRS_CARD_PRESENT(0x40) with SIM_CRS_CARD_POWERED_OFF(0x00) */
/* Send REST_RSP with error code: Card powered off to SIM Client */
result = SIM_RESULT_CARD_ALREADY_OFF;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* Send REST_RSP with error code: Card Removed to SIM Client */
/* Note: it is impossible that POWERED_ON but CRS_NOT_PRESENT case, so this is CARD_NOT_PRESENT case */
result = SIM_RESULT_CARD_REMOVED;
}
else
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_NO_RULES_PROCESS_RESET_REQ_IN_SRVCALLBACK);
Assert(0);
}
/* Send SIM_RESET_RSP to sim client with result code */
status = SIM_ServerResetSimRsp(Server, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_RESET_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
break;
case SAEVENT_SERVER_CARD_READER_STATUS_REQ:
cardRdrStatus = SIM(simServer)[0].current_simcardreader_status;
status = SIM_ServerCardReaderStatusRsp(Server, cardRdrStatus, SIM_RESULT_OK);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_CARD_RDS_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
break;
case SAEVENT_SERVER_STATUS_SENT:
kal_trace(TRACE_GROUP_1, BT_SIMAP_STATUS_IND_SENT_IN_SRVCALLBACK, Parms->status);
/* Note that the STATUS_SENT Event may be failed, handle this case here */
if (Parms->status != BT_STATUS_SUCCESS)
{
if (Server->state == SIM_SERVER_STATE_CONN_PENDING)
{
/* In CONNECT_PENDING state, this means that STATUS_IND(with reset) is sent failed */
/* Close this SIM Access Profile connection */
/* Return value from RF_CloseChannel() may be BT_STATUS_IN_PROGRRESS(presenting rfchannel state is DLC_STATE_DISC_PENDING) */
status = SimApCloseRFCommChnl(&(Server->rfChannel));
if ((status != BT_STATUS_PENDING) && (status != BT_STATUS_IN_PROGRESS) && (status != BT_STATUS_SUCCESS))
{
/* Report(("SERVER_STATUS_SENT and RF_CloseChannel err, status=%d",status)); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SHOW_ONE_BYTE, status);
Assert(0);
}
}
else if (Server->state == SIM_SERVER_STATE_OPEN)
{ /* Ignore it */
}
else
{
/* Send STATUS_IND in wrong SimServer's state and send this event fail */
Assert(0);
}
}
break;
}
}
/*---------------------------------------------------------------------------
* HidSdpParseDescriptorList()
*---------------------------------------------------------------------------
*
* Synopsis: Parses the SDP query response for an 16 bit value.
*
* Return: (see SDP_ParseAttributes)
*/
static void HidSdpParseDescriptorList(HidChannel *Channel, U8 *in_value, U16 in_len, U8 result)
{
// HidParseData *hpd;
//hpd = Hid_Init_Parser();
if (in_value == NULL)
{
return;
}
if (!(Channel->queryRsp.queryFlags & SDPQ_FLAG_DESCRIPTOR_LIST)) {
if (in_len == 0) {
return;
}
//if ((result == BT_STATUS_SDP_CONT_STATE) &&
if(Channel->queryRsp.descriptorLenOffset == 0)
{
U8 elemType = 0;
U8 elemSizeDescpt = 0;
U8 elemSize = 0;
U8 elemAddSize = 0;
U8 offset = 0;
U8 i = 0;
/* Only the first packet is preceded with data element header. The packet
* in continuation sequence is raw data.
*/
while (offset + Channel->queryRsp.descriptorLen < in_len)
{
elemType = SDP_GetElemType(in_value[offset]);
elemSizeDescpt = SDP_GetElemSize(in_value[offset]);
switch (elemType)
{
case DETD_SEQ:
if (elemSizeDescpt == DESD_ADD_8BITS)
{
offset = offset + 1;
}
else if (elemSizeDescpt == DESD_ADD_16BITS)
{
offset = offset + 2;
}
else if (elemSizeDescpt == DESD_ADD_32BITS)
{
offset = offset + 4;
}
break;
case DETD_UINT:
if (elemSizeDescpt > DESD_16BYTES)
{
return;
}
else
{
elemSize = HidSdpGetValidSize(elemSizeDescpt);
offset += elemSize;
}
break;
case DETD_TEXT:
if (elemSizeDescpt == DESD_ADD_8BITS)
{
elemAddSize = 1;
}
else if (elemSizeDescpt == DESD_ADD_16BITS)
{
elemAddSize = 2;
}
else if (elemSizeDescpt == DESD_ADD_32BITS)
{
elemAddSize = 4;
}
for (i = 0; i < elemAddSize; i++)
{
Channel->queryRsp.descriptorLen = (Channel->queryRsp.descriptorLen << 8) | (in_value[offset + i + 1]);
}
offset = offset + elemAddSize;
break;
default:
// other data element shall not be come out in HID attribute list
break;
}
offset++;
}
if((in_len - offset) <= 0)
{
return;
}
/* Allocate a new buffer */
Channel->queryRsp.descriptorList = (U8 *)hid_malloc((U32)Channel->queryRsp.descriptorLen);
if (Channel->queryRsp.descriptorList == NULL)
{
return;
}
btmtk_os_memset(Channel->queryRsp.descriptorList, 0, Channel->queryRsp.descriptorLen);
/* Copy whatever data is available */
btmtk_os_memcpy(Channel->queryRsp.descriptorList, in_value + offset, in_len - offset);
Channel->queryRsp.descriptorLenOffset = in_len - offset;
}
else
{
btmtk_os_memcpy(Channel->queryRsp.descriptorList + Channel->queryRsp.descriptorLenOffset,
in_value, in_len);
/* in case that there is more continuation packet */
Channel->queryRsp.descriptorLenOffset += in_len;
/*
if(Hid_SdpParse(Channel, hpd) == BT_STATUS_SUCCESS)
bt_prompt_trace(MOD_BT,"[HID]Successed SDP parser ");
else if(Hid_SdpParse(Channel, hpd) == BT_STATUS_FAILED)
bt_prompt_trace(MOD_BT,"[HID]Failed SDP parser ");
Hid_Free_Parser(hpd);*/
}
kal_trace(BT_TRACE_G2_PROFILES,HID_SDP_PARSEATTRIBUTES_SUCCEEDED_BYTES_READ__xD_UPDATED_BUFF_LEN__xD , in_len, Channel->queryRsp.descriptorLenOffset);
if (result == BT_STATUS_SUCCESS)
{
Channel->queryRsp.queryFlags |= SDPQ_FLAG_DESCRIPTOR_LIST;
}
}
}
void HidSdpEventHandler(SdpQueryToken *sqt, U8 result, U8 attr_idx, U8 *attr_val)
{
HidChannel *channel = ContainingRecord(sqt,
HidChannel, sdpQueryToken);
ReportDescriptorList* reportDescriptorList = NULL;
HidParseData* hpd ;
kal_trace(BT_TRACE_G2_PROFILES,BT_HID_SDP_QUERY_CALLBACK_x02X ,result);
switch (result)
{
case BT_STATUS_SDP_CONT_STATE:
kal_trace(BT_TRACE_G2_PROFILES,HID_SDP_SUCCESSFULLY);
HidVerifySdpQueryRsp(channel, bt_hid_attr_id_list[attr_idx], attr_val, sqt->availValueLen, result);
break;
case BT_STATUS_SUCCESS:
HidVerifySdpQueryRsp(channel, bt_hid_attr_id_list[attr_idx], attr_val, sqt->availValueLen, result);
if (channel->bSDPDiscPending)
{
HidClearConnection(channel, result, 0);
}
else
{
hpd = (HidParseData*)hid_malloc(sizeof(HidParseData));
Hid_Init_Parser(hpd);
channel->reportCons[0] = (HidReportConstructor*)hid_malloc(HID_REPORT_ID_MAX * sizeof(HidReportConstructor));
btmtk_os_memset((U8*) channel->reportCons[0], 0, HID_REPORT_ID_MAX * sizeof(HidReportConstructor));
reportDescriptorList = HidFindReportDescriptorByAddr(channel->cmgrHandler.remDev->bdAddr);
if(reportDescriptorList != NULL )
{
btmtk_os_memset(reportDescriptorList->BtAddr.addr, 0, 6);
reportDescriptorList->inUse = FALSE;
hid_free(reportDescriptorList->reportDescriptor);
reportDescriptorList->reportDescriptorLength = 0;
}
HidCacheReportDescriptor(channel->cmgrHandler.remDev->bdAddr, channel->queryRsp.descriptorList, channel->queryRsp.descriptorLen);
if(HidAddDescriptor(channel) == BT_STATUS_SUCCESS)
bt_prompt_trace(MOD_BT,"[HID]HidAddDescriptor Successed!");
else
bt_prompt_trace(MOD_BT,"[HID]HidAddDescriptor failed!");
Hid_Free_Parser(hpd);
channel->flags &= ~CHNL_FLAG_SERVICE_QUERY;
HidSdpCallback(channel, result);
}
break;
case BT_STATUS_NOSERVICES:
{
static const U8 HidDescriptorList[] =
{
HID_DESCRIPTOR
};
channel->queryRsp.descriptorLen = HID_DESCRIPTOR_LEN;
channel->queryRsp.descriptorList = (U8*)hid_malloc(HID_DESCRIPTOR_LEN);
btmtk_os_memset((U8*) channel->queryRsp.descriptorList, 0, HID_DESCRIPTOR_LEN);
btmtk_os_memcpy((U8*) channel->queryRsp.descriptorList, HidDescriptorList, HID_DESCRIPTOR_LEN);
hpd = (HidParseData*)hid_malloc(sizeof(HidParseData));
Hid_Init_Parser(hpd);
channel->reportCons[0] = (HidReportConstructor*)hid_malloc(HID_REPORT_ID_MAX * sizeof(HidReportConstructor));
btmtk_os_memset((U8*) channel->reportCons[0], 0, HID_REPORT_ID_MAX * sizeof(HidReportConstructor));
if(HidAddDescriptor(channel) == BT_STATUS_SUCCESS)
bt_prompt_trace(MOD_BT,"[HID]HidAddDescriptor Successed!");
else
bt_prompt_trace(MOD_BT,"[HID]HidAddDescriptor failed!");
Hid_Free_Parser(hpd);
channel->flags &= ~CHNL_FLAG_SERVICE_QUERY;
HidSdpCallback(channel, BT_STATUS_SUCCESS);
break;
}
case BT_STATUS_CONNECTION_FAILED:
case BT_STATUS_FAILED:
default:
channel->flags &= ~CHNL_FLAG_SERVICE_QUERY;
HidClearConnection(channel, result, 0);
break;
}
}
