bool BbdBridge_SendSensorData(struct BbdBridge* p,
unsigned char* pSensorData, unsigned short size)
{
if (BbdEngine_Lock(__LINE__)) {
struct sStreamEncoder* str = &p->m_otStreamEncoder;
StreamCodec_Reset (str);
StreamEncoder_PutU16 (str, size);
StreamEncoder_PutBuffer(str, pSensorData, size);
if (StreamCodec_Fail(str))
{
BbdEngine_Unlock();
return false;
}
if (!BbdBridge_AddRpc(p, RPC_DEFINITION(IRpcSensorRequest, Data)))
{
BbdEngine_Unlock();
return false;
}
TransportLayer_SendPacket(&p->m_otTL,
p->m_aucTransactionPayload,
p->m_uiTransactionPayloadSize);
p->m_uiTransactionPayloadSize = 0;
bbd_update_stat(STAT_TX_SSP, size);
bbd_update_stat(STAT_TX_RPC, size);
BbdEngine_Unlock();
return true;
}
return false;
}
void BbdBridge_SetData(struct BbdBridge *p,
const unsigned char *pucData,
unsigned short usSize)
{
if (!BbdEngine_Lock(__LINE__)) return;
if (!gpbbd_dev || !gpbbd_dev->bbd_engine.constructed || !gpbbd_dev->bbd_engine.open)
{
printk("[SSPBBD]: %s BBD engine already closed. ignore injected data\n", __func__);
goto unlock_exit;
}
if (BbdTransportLayer_IsPassThrough(&p->m_otTL))
{
p->callback->OnDataToLhd(p->callback, pucData, usSize);
bbd_update_stat(STAT_RX_LHD, usSize);
}
else
{
TransportLayer_SetData(&p->m_otTL, pucData, usSize);
}
unlock_exit:
BbdEngine_Unlock();
bbd_update_stat(STAT_RX_TL, usSize);
}
void BbdEngine_Close(struct BbdEngine* p)
{
if (p && p->constructed && p->open) {
FUNC();
p->open = false;
BbdEngine_Lock(__LINE__); //should lock BBD here. Otherwise it may crash while handling packet.
BbdBridge_dtor(&p->bridge);
BbdEngine_StopWork(p);
BbdEngine_Unlock();
}
}
/* called when LHD has a packet to send */
void BbdBridge_SendPacket(struct BbdBridge *p, unsigned char* pkt, size_t len)
{
if (!BbdEngine_Lock(__LINE__)) return;
if (!gpbbd_dev || !gpbbd_dev->bbd_engine.constructed || !gpbbd_dev->bbd_engine.open)
{
printk("[SSPBBD]: %s BBD engine already closed. ignore injected data\n", __func__);
goto unlock_exit;
}
BbdTransportLayer_SendPacket(&p->m_otTL, pkt, len);
bbd_update_stat(STAT_TX_LHD, len);
bbd_update_stat(STAT_TX_RPC, len);
unlock_exit:
BbdEngine_Unlock();
}
bool BbdBridge_SetControlMessage(struct BbdBridge *p, char *msg)
{
bool result = false;
if (!gpbbd_dev || !gpbbd_dev->bbd_engine.constructed || !gpbbd_dev->bbd_engine.open)
{
printk("[SSPBBD]: %s BBD engine already closed. ignore injected data\n", __func__);
goto exit;
}
if (BbdEngine_Lock(__LINE__)) {
result = BbdTransportLayer_SetControlMessage(&p->m_otTL, msg);
BbdEngine_Unlock();
}
exit:
return result;
}
bool BbdBridge_SendReliablePacket(struct BbdBridge *p,
struct sBbdReliableTransaction *trans)
{
bool result = false;
if (!gpbbd_dev || !gpbbd_dev->bbd_engine.constructed || !gpbbd_dev->bbd_engine.open)
{
printk("[SSPBBD]: %s BBD engine already closed. ignore injected data\n", __func__);
goto exit;
}
if (BbdEngine_Lock(__LINE__)) {
result = BbdTransportLayer_SendReliablePacket(&p->m_otTL, trans);
bbd_update_stat(STAT_TX_LHD, trans->usSize);
bbd_update_stat(STAT_TX_RPC, trans->usSize);
BbdEngine_Unlock();
}
exit:
return result;
}
unsigned long BbdEngine_OnTimer(void)
{
struct bbd_device *p = gpbbd_dev;
unsigned long result = 0;
if (!workq || mutex_is_locked(&p->bbd_engine.lock))
return 0;
if (BbdEngine_Lock(__LINE__)) {
if (p->jiffies_to_wake)
{
if (p->jiffies_to_wake > jiffies) {
result = p->jiffies_to_wake - jiffies;
}
else {
p->jiffies_to_wake = 0;
FUNC();
TransportLayer_Tick(&p->bbd_engine.bridge.m_otTL);
}
}
BbdEngine_Unlock();
}
return result;
}
