/*---------------------------------------------------------------------------
* HidStateClosed()
*---------------------------------------------------------------------------
*
* Synopsis: Closed state for the HID channel.
*
* Return: void
*/
void HidStateClosed(HidChannel *Channel, L2capChannelId Cid,
L2capCallbackParms *Parms)
{
kal_trace(BT_TRACE_G2_PROFILES,HIDSTATECLOSEDx02X ,Parms->event);
if ((Parms->event == L2EVENT_CONNECT_IND) ||
(Parms->event == L2EVENT_CONNECT_AUTORIZED))
{
//Channel->cmgrHandler.callback = HidCmgrCallback;
if (CMGR_CreateDataLink(&Channel->cmgrHandler,
&Parms->aclLink->bdAddr) != BT_STATUS_SUCCESS)
{
/* Could not create a link to the ACL */
(void)L2CAP_ConnectRsp(Cid, L2CONN_REJECT_NO_RESOURCES, 0);
return;
}
Channel->state = HID_STATE_CONN_PENDING;
HidAppCallback(Channel, HIDEVENT_OPEN_IND,
BT_STATUS_SUCCESS, Channel->cmgrHandler.remDev,
sizeof(BtRemoteDevice));
}
else {
/* Ignore any other events */
kal_trace(BT_TRACE_G2_PROFILES,HID_CHANNEL_CLOSED_STATE_RECEIVED_AN_UNEXPECTED_EVENT_x02X , Parms->event);
}
}
BtStatus AvrcpCreateAclLink(BD_ADDR *Addr, CmgrHandler *Handler, CmgrCallback Callback)
{
AvrcpChannel *chnl = ContainingRecord(Handler, AvrcpChannel, cmgrHandler);
BtStatus status;
status = CMGR_CreateDataLink(Handler, Addr);
kal_trace( BT_TRACE_G8_AVRCP, BT_AVRCP_SDP_CREATEACL, status);
if (status == BT_STATUS_SUCCESS)
{
#ifdef __BT_AVRCP_V14__
status = AvrcpStartServiceQuery(chnl, BSQM_FIRST);
#else
#ifdef __BT_AVRCP_V13__
status = AvrcpStartServiceQuery(chnl, BSQM_FIRST);
#else
status = AvrcpStartMultiServiceQuery(chnl, BSQM_FIRST, chnl->role);
#endif
#endif
}
return status;
}
U8 L2CA_EchoReq(L2capEchoRequest *parms)
{
BtStatus status = BT_STATUS_SUCCESS;
BD_ADDR bd_addr;
memset( (U8 *)L2CAPTS(common_data), 0x55, sizeof(L2CAPTS(common_data)));
/* Establish the ACL link */
memcpy((U8 *)bd_addr.addr, (U8 *)parms->bd_addr,6);
(void)CMGR_RegisterHandler(&L2CAPTS(cmgrHandler), l2capTesterCmgrCallback);
status = CMGR_CreateDataLink(&L2CAPTS(cmgrHandler), &bd_addr);
L2CAPTS(pending_command) = L2CAP_TESTER_PING_REQ;
if (status == BT_STATUS_SUCCESS)
{
memset( (U8 *)L2CAPTS(common_data), 0x55, sizeof(L2CAPTS(common_data)));
status = L2CAP_Ping(
&(L2CAPTS(Protocol)),
L2CAPTS(cmgrHandler).remDev,
(U8 *)L2CAPTS(common_data),
sizeof(L2CAPTS(common_data)));
}
return status;
}
BtStatus hdp_tp_connect(HdpChannel *channel)
{
BtStatus ret;
OS_Report("[HDP]hdp_tp_connect");
ret = CMGR_RegisterHandler(&channel->cmgrHdlr, hdp_cmgr_callback);
if (BT_STATUS_SUCCESS == ret || BT_STATUS_IN_USE == ret)
{
ret = CMGR_CreateDataLink(&channel->cmgrHdlr, &channel->bdAddr);
}
OS_Report("[HDP]hdp_tp_connect result %d", ret);
return ret;
}
BtStatus FMP_Open(FmpChannel **channel, BD_ADDR *addr)
{
BtStatus status = BT_STATUS_FAILED;
FmpChannel *ch;
CheckUnlockedParm(BT_STATUS_INVALID_PARM, addr != 0);
OS_LockStack();
kal_trace(BT_TRACE_BLE_PROFILES, FMP_OPENCONNECTION);
if ((*channel != NULL) && IsNodeOnList(&FMP(dev_list), &((*channel)->node)))
{
ch = *channel;
}
else
{
ch = FmpNewChannel();
if (ch == NULL)
{
return BT_STATUS_NO_RESOURCES;
}
}
if (ch->state == FMP_STATE_CLOSED)
{
status = CMGR_CreateDataLink(&ch->cmgr_handler, addr);
kal_trace(BT_TRACE_BLE_PROFILES, FMP_CREATEDATALINK_STATUS, status);
if (status == BT_STATUS_SUCCESS)
{
status = GattClientConnect(ch->cmgr_handler.remDev);
}
if (status != BT_STATUS_SUCCESS && status != BT_STATUS_PENDING)
{
FmpFreeChannel(ch);
return status;
}
ch->state = FMP_STATE_OPENING;
*channel = ch;
}
OS_UnlockStack();
return status;
}
U8 L2CA_InfoReq(L2capInfoRequest *parms)
{
BtStatus status = BT_STATUS_SUCCESS;
BD_ADDR bd_addr;
memcpy((U8 *)bd_addr.addr, (U8 *)parms->bd_addr,6);
(void)CMGR_RegisterHandler(&L2CAPTS(cmgrHandler), l2capTesterCmgrCallback);
status = CMGR_CreateDataLink(&L2CAPTS(cmgrHandler), &bd_addr);
L2CAPTS(pending_command) = L2CAP_TESTER_INFO_REQ;
L2CAPTS(info_type) = parms->info_type;
if (status == BT_STATUS_SUCCESS)
{
status = L2CAP_GetInfo(&(L2CAPTS(Protocol)), L2CAPTS(cmgrHandler).remDev, L2CAPTS(info_type));
}
return status;
}
U8 L2CA_ConnectReq(L2capConnectRequest *parms)
{
BtStatus status = BT_STATUS_SUCCESS;
BD_ADDR bd_addr;
U16 l2ChannelId;
/* Establish the ACL link */
memcpy((U8 *)bd_addr.addr, (U8 *)parms->bd_addr,6);
(void)CMGR_RegisterHandler(&L2CAPTS(cmgrHandler), l2capTesterCmgrCallback);
status = CMGR_CreateDataLink(&L2CAPTS(cmgrHandler), &bd_addr);
L2CAPTS(pending_command) = L2CAP_TESTER_CONNECT_REQ;
if (status == BT_STATUS_SUCCESS)
{
status = L2CAP_ConnectReq(&L2CAPTS(Protocol), BT_PSM_TESTING, L2CAPTS(cmgrHandler).remDev, 0, &l2ChannelId);
}
return status;
}
U8 L2CA_AddGroup(L2capGroupAddr *parms)
{
BtStatus status = BT_STATUS_SUCCESS;
BD_ADDR bd_addr;
U16 l2ChannelId;
CmgrHandler *cmgrHandler;
/* Establish the ACL link */
memcpy((U8 *)bd_addr.addr, (U8 *)parms->bd_addr,6);
if(L2CAPTS(cmgrHandler1).bdc !=0)
cmgrHandler = &L2CAPTS(cmgrHandler1);
else
cmgrHandler = &L2CAPTS(cmgrHandler2);
(void)CMGR_RegisterHandler(cmgrHandler, l2capTesterGroupCmgrCallback);
status = CMGR_CreateDataLink(cmgrHandler, &bd_addr);
if((cmgrHandler->bdc !=0) && (cmgrHandler->bdc->link !=0))
CMGR_DisableSniffTimer(cmgrHandler);
if (status == BT_STATUS_SUCCESS)
{
L2CAP_GroupAddMember(L2CAPTS(groupId), &bd_addr);
}
return status;
}
/*---------------------------------------------------------------------------
* HidL2Callback()
*---------------------------------------------------------------------------
*
* Synopsis: L2CAP callback function for the Channel.
*
* Return: void
*/
void HidL2Callback(L2capChannelId Cid, L2capCallbackParms *Parms)
{
HidChannel *channel;
channel = HidFindChannelByCid(Cid, Parms->aclLink);
kal_trace(BT_TRACE_G2_PROFILES,HIDPARMSEVENTx02X ,Parms->event);
kal_trace(BT_TRACE_G2_PROFILES,HID_CID_x02X ,Cid);
kal_trace(BT_TRACE_G2_PROFILES,HID_CHANNELx08X , channel);
switch (Parms->event)
{
case L2EVENT_CONNECT_AUTORIZED:
if (channel == NULL)
{
U8 searchType;
if (Parms->owner.psm == &HID(hidCtrlPsm))
searchType = HID_FIND_CTRL_CID;
else
searchType = HID_FIND_INTR_CID;
channel = HidFindUnusedChannel(searchType, Parms->aclLink);
if (channel == NULL)
{
if (!HidCheckValidConnect(searchType, Cid, Parms->aclLink))
{
Parms->aclLink->discFlag = TRUE;
L2CAP_ConnectRsp(Cid, L2CONN_REJECT_NO_RESOURCES, 0);
break;
}
// Get a new channel
channel = HidNewChannel();
if (channel == NULL)
{
kal_trace(BT_TRACE_G2_PROFILES,CHANNEL_IS_0_RETURN);
/* No channel available, reject the request */
Parms->aclLink->discFlag = TRUE;
L2CAP_ConnectRsp(Cid, L2CONN_REJECT_NO_RESOURCES, 0);
break;
}
channel->cmgrHandler.remDev = Parms->aclLink;
}
}
if (channel->conCount == 0)
{
/* Only create ACL link for the first L2CAP connection */
if (CMGR_CreateDataLink(&channel->cmgrHandler,
&Parms->aclLink->bdAddr) != BT_STATUS_SUCCESS)
{
/* Could not create a link to the ACL */
(void)L2CAP_ConnectRsp(Cid, L2CONN_REJECT_NO_RESOURCES, 0);
break;
}
}
if (Parms->owner.psm == &HID(hidCtrlPsm))
channel->ctrlCid = Cid;
else
channel->intrCid = Cid;
/* Call the state machine */
if (channel != 0)
{
kal_trace(BT_TRACE_G2_PROFILES,HID_A_SMAx02XBx02X ,channel->state,Cid);
HID(hidState)[channel->state](channel, Cid, Parms);
}
else
kal_trace(BT_TRACE_G2_PROFILES,HIDCHANNEL_0);
break;
case L2EVENT_CONNECT_IND:
#ifdef HID_AUTHORIZATION
//Assert(channel !=0);
if(channel ==0){
bt_prompt_trace(MOD_BT,"[HID]channel ==0");
return;
}
L2CAP_ConnectRsp(Cid, L2CONN_ACCEPTED, 0);
#else
if (channel == 0)
{
/* Get a new channel */
if (Parms->owner.psm == &HID(hidCtrlPsm))
channel = HidFindUnusedChannel(HID_FIND_CTRL_CID, Parms->aclLink);
else
channel = HidFindUnusedChannel(HID_FIND_INTR_CID, Parms->aclLink);
}
if (channel == 0)
{
/* No channel available, reject the request */
L2CAP_ConnectRsp(Cid, L2CONN_REJECT_NO_RESOURCES, 0);
break;
}
//Assert(channel !=0);
if(channel ==0){
bt_prompt_trace(MOD_BT,"[HID]channel ==0");
return;
}
if (CMGR_CreateDataLink(&channel->cmgrHandler,
&Parms->aclLink->bdAddr) != BT_STATUS_SUCCESS)
{
/* Could not create a link to the ACL */
(void)L2CAP_ConnectRsp(Cid, L2CONN_REJECT_NO_RESOURCES, 0);
break;
} /* Drop through */
//Assert(channel !=0);
if(channel ==0){
bt_prompt_trace(MOD_BT,"[HID]channel ==0");
return;
}
if (Parms->owner.psm == &HID(hidCtrlPsm))
channel->ctrlCid = Cid;
else
channel->intrCid = Cid;
/* Call the state machine */
if (channel != 0)
{
kal_trace(BT_TRACE_G2_PROFILES,HID_B_SMAx02XBx02X ,channel->state,Cid);
HID(hidState)[channel->state](channel, Cid, Parms);
}
else
kal_trace(BT_TRACE_G2_PROFILES,HIDCHANNEL_0);
#endif
break;
case L2EVENT_CONNECTED:
/* Save the channel ID for the channel being requested */
if (channel == 0)
{
L2CAP_DisconnectReq(Cid);
break;
}
if (Parms->owner.psm == &HID(hidCtrlPsm))
channel->ctrlCid = Cid;
else
channel->intrCid = Cid;
/* Call the state machine */
if (channel != 0)
{
kal_trace(BT_TRACE_G2_PROFILES,HID_C_SMAx02XBx02X ,channel->state,Cid);
HID(hidState)[channel->state](channel, Cid, Parms);
}
else
kal_trace(BT_TRACE_G2_PROFILES,HIDCHANNEL_0);
break;
case L2EVENT_DISCONNECTED:
CMGR_HidNoRoleSwitch(0);
if (channel != 0)
{
kal_trace(BT_TRACE_G2_PROFILES,HID_D_SMAx02XBx02X ,channel->state,Cid);
HID(hidState)[channel->state](channel, Cid, Parms);
}
else
{
kal_trace(BT_TRACE_G2_PROFILES,UNUSED_CHANNEL_0_IGNORE_IT);
}
break;
default:
/* Call the state machine */
if (channel != 0)
{
kal_trace(BT_TRACE_G2_PROFILES,HID_E_SMAx02XBx02X ,channel->state,Cid);
HID(hidState)[channel->state](channel, Cid, Parms);
}
else
kal_trace(BT_TRACE_G2_PROFILES,HIDCHANNEL_0);
break;
}
}
