UINT32 OSW_EventWait
(
Event* pEvent,
UINT32 timeout
)
{
#if 0 // peter
DWORD rc;
SMS_ASSERT (pEvent);
timeout = (timeout == OSW_WAIT_FOREVER) ? INFINITE : timeout;
rc = WaitForSingleObject (*pEvent, timeout);
if (rc == WAIT_FAILED)
{
return OSW_ERROR;
}
else if (rc == WAIT_TIMEOUT)
{
return OSW_TIMEOUT;
}
return OSW_OK;
#else
return OSW_OK;
#endif
} /* OSW_EventWait */
//*******************************************************************************
// Get grade according to value ranges table
static INT32 SmsHostVal2Grade( const QUALITY_CALC_ENTRY_ST Table[], INT32 Val )
{
UINT32 i=0 ;
for ( i=0 ; Table[i].RangeEnd != -1 ; i++ )
{
if ( Val <= Table[i].RangeEnd )
{
SMS_ASSERT( Table[i].Grade <= 100 && Table[i].Grade >= 0 ) ;
return Table[i].Grade ;
}
}
return 0 ;
}
UINT32 OSW_EventClear
(
Event* pEvent
)
{
#if 0 // peter
BOOL rc;
SMS_ASSERT (pEvent);
rc = ResetEvent (*pEvent);
return (rc == 0) ? OSW_ERROR : OSW_OK;
#else
return OSW_OK;
#endif
} /* OSW_EventClear */
UINT32 OSW_EventSet
(
Event* pEvent
)
{
#if 0 // Peter
BOOL rc;
SMS_ASSERT (pEvent);
rc = SetEvent (*pEvent);
return (rc == 0) ? OSW_ERROR : OSW_OK;
#else
return OSW_OK;
#endif
} /* OSW_EventSet */
UINT32 OSW_EventDelete
(
Event* pEvent
)
{
#if 0 // peter
BOOL rc;
SMS_ASSERT (pEvent);
rc = CloseHandle (*pEvent);
return (rc == 0) ? OSW_ERROR : OSW_OK;
#else
return OSW_OK;
#endif
} /* OSW_EventDelete */
void SmsHwPnpCallback(char* DeviceName, BOOL fArrival)
{
if (fArrival)
{
if (g_devData.IsFound)
{
// Already have a device - ignore
return;
}
SMS_ASSERT((strlen(DeviceName) + 1) < SMS_ADR_LITE_MAX_DEVICE_NAME_LEN );
strncpy(g_devData.DeviceName, DeviceName, SMS_ADR_LITE_MAX_DEVICE_NAME_LEN);
if (ADR_DeviceInit(g_devData.DeviceMode) != SMSHOSTLIB_ERR_OK)
{
g_devData.IsFound = FALSE;
return;
}
g_devData.IsFound = TRUE;
}
else
{
BOOL IsSameName = (strncmp( g_devData.DeviceName, DeviceName, SMS_ADR_LITE_MAX_DEVICE_NAME_LEN ) == 0 );
if (!g_devData.IsFound)
{
return;
}
if (!IsSameName)
{
return;
}
ADR_DeviceTerminate();
g_devData.IsFound = FALSE;
}
}
UINT32 OSW_EventCreate
(
Event* pEvent // where to store the event
)
{
#if 0 // Peter
SMS_ASSERT (pEvent);
*pEvent = CreateEvent
(
NULL, // Security settings
0, // ManualReset - false - system resets the state after a single waiter was signaled
0, // InitialState (signaled or not)
(LPCTSTR)NULL // Event name
);
return (*pEvent == NULL) ? OSW_ERROR : OSW_OK;
#else
return OSW_OK;
#endif
} /* OSW_EventCreate */
//*******************************************************************************
//
void SmsLiteCmmbControlRxCallback( UINT32 handle_num, UINT8* p_buffer, UINT32 buff_size )
{
SmsMsgData_ST* pSmsMsg = (SmsMsgData_ST*)p_buffer;
SMSHOSTLIB_ERR_CODES_E RetCode = SMSHOSTLIB_ERR_UNDEFINED_ERR;
UINT32 ResponseMsgType = SMSHOSTLIB_MSG_INVALID_RESPONSE_VAL;
UINT8* pPayload = NULL;
UINT32 PayloadLength = 0;
// Return code and payload for the messages which have retcode as the first 4 bytes
UINT8* pPayloadWoRetCode = NULL;
UINT32 PayloadLengthWoRetCode = 0;
SMSHOSTLIB_ERR_CODES_E RetCodeFromMsg = SMSHOSTLIB_ERR_UNDEFINED_ERR;
SMS_ASSERT( handle_num == 0 );
SMS_ASSERT( p_buffer != NULL );
SMS_ASSERT( buff_size != 0 );
SMS_ASSERT( buff_size >= pSmsMsg->xMsgHeader.msgLength );
SMS_ASSERT( pSmsMsg->xMsgHeader.msgLength >= sizeof( SmsMsgHdr_ST ) );
pPayload = (UINT8*)&pSmsMsg->msgData[0];
PayloadLength = pSmsMsg->xMsgHeader.msgLength - sizeof( SmsMsgHdr_ST );
if ( PayloadLength >= 4 )
{
RetCodeFromMsg = pSmsMsg->msgData[0];
pPayloadWoRetCode = pPayload + 4;
PayloadLengthWoRetCode = PayloadLength - 4;
}
SMSHOST_LOG3( SMSLOG_ERROR, "Control RX callback. Type %d, Retcode %#x, Payload Length %d",
pSmsMsg->xMsgHeader.msgType,
RetCodeFromMsg,
PayloadLength );
switch( pSmsMsg->xMsgHeader.msgType )
{
case MSG_SMS_GET_STATISTICS_EX_RES:
{
// This response is unsolicited - i.e. it comes periodically from the chip
// without being requested.
// We cache the responses to deliver later to stats requests from the app
// We also use each response for reception quality calculation
//
// Note that the memcpy here is not protected - there is a race between here
// and the request - when the cache is delivered to the app it could be updated
// at the same time here.
//
SMSHOSTLIB_STATISTICS_CMMB_ST* pStats = (SMSHOSTLIB_STATISTICS_CMMB_ST*)pPayloadWoRetCode;
UINT32 i;
UINT32 RecQualSum = 0;
if ( pStats == NULL )
{
break;
}
memcpy( &g_LibCmmbState.StatsCache,
pStats,
SMS_MIN( PayloadLengthWoRetCode, sizeof(SMSHOSTLIB_STATISTICS_CMMB_ST) ) );
i = g_LibCmmbState.ReceptionQualityCounter++ % SMS_CMMB_RECEPTION_QUALITY_HISTORY_SIZE;
g_LibCmmbState.ReceptionQualityHistory[i] = SmsHostCmmbGetQuality( pStats );
for ( i = 0 ; i < SMS_CMMB_RECEPTION_QUALITY_HISTORY_SIZE ; i++ )
{
RecQualSum += g_LibCmmbState.ReceptionQualityHistory[i];
}
g_LibCmmbState.StatsCache.ReceptionQuality = RecQualSum / SMS_CMMB_RECEPTION_QUALITY_HISTORY_SIZE;
}
break;
case MSG_SMS_SCAN_COMPLETE_IND:
{
ResponseMsgType = SMSHOSTLIB_MSG_TUNE_RES;
RetCode = RetCodeFromMsg;
pPayload = pPayloadWoRetCode;
PayloadLength = PayloadLengthWoRetCode;
}
break;
case MSG_SMS_CMMB_START_CONTROL_INFO_RES:
{
ResponseMsgType = SMSHOSTLIB_MSG_CMMB_START_CONTROL_INFO_RES;
RetCode = RetCodeFromMsg;
pPayload = pPayloadWoRetCode;
PayloadLength = PayloadLengthWoRetCode;
}
break;
case MSG_SMS_CMMB_STOP_CONTROL_INFO_RES:
{
ResponseMsgType = SMSHOSTLIB_MSG_CMMB_STOP_CONTROL_INFO_RES;
RetCode = RetCodeFromMsg;
pPayload = pPayloadWoRetCode;
PayloadLength = PayloadLengthWoRetCode;
}
break;
case MSG_SMS_CMMB_START_SERVICE_RES:
{
ResponseMsgType = SMSHOSTLIB_MSG_CMMB_START_SERVICE_RES;
RetCode = RetCodeFromMsg;
pPayload = pPayloadWoRetCode;
PayloadLength = PayloadLengthWoRetCode;
}
break;
case MSG_SMS_CMMB_STOP_SERVICE_RES:
{
ResponseMsgType = SMSHOSTLIB_MSG_CMMB_STOP_SERVICE_RES;
RetCode = RetCodeFromMsg;
pPayload = pPayloadWoRetCode;
PayloadLength = PayloadLengthWoRetCode;
}
break;
case MSG_SMS_LOG_ENABLE_CHANGE_RES:
// NOP
break;
case MSG_SMS_INTERFACE_LOCK_IND:
{
// Firmware has requested that the host avoid sending messages to it
SMSHOST_LOG0(SMSLOG_COMM, "Interface lock");
g_LibCmmbState.IsBlockInterface = TRUE;
}
break;
case MSG_SMS_INTERFACE_UNLOCK_IND:
{
// Firmware allows host to resume transmission
SMSHOST_LOG0(SMSLOG_COMM, "Interface unlock");
g_LibCmmbState.IsBlockInterface = FALSE;
}
break;
case MSG_SMS_CMMB_GET_CHANNELS_INFO_RES:
case MSG_SMS_CMMB_GET_SERVICES_RES:
{
// "Internal" messages - forward to host as is
ResponseMsgType = pSmsMsg->xMsgHeader.msgType;
}
break;
default:
SmsLiteCommonControlRxHandler( handle_num, p_buffer, buff_size );
break;
}
// Call the user callback
if ( ResponseMsgType != SMSHOSTLIB_MSG_INVALID_RESPONSE_VAL )
{
SmsLiteCallCtrlCallback( ResponseMsgType,
RetCode,
pPayload,
PayloadLength );
}
}
