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; }