/****************************************************************************
NAME
audioIndicateCodec
DESCRIPTION
Sends an event to indicate which A2DP codec is in use
RETURNS
void
*/
void audioIndicateCodec(uint8 seid)
{
switch(seid)
{
case SBC_SEID:
MessageSend ( &theSink.task , EventSbcCodec , 0 ) ;
break;
case MP3_SEID:
MessageSend ( &theSink.task , EventMp3Codec , 0 ) ;
break;
case AAC_SEID:
MessageSend ( &theSink.task , EventAacCodec , 0 ) ;
break;
case APTX_SEID:
MessageSend ( &theSink.task , EventAptxCodec , 0 ) ;
break;
#ifdef INCLUDE_FASTSTREAM
case FASTSTREAM_SEID:
MessageSend ( &theSink.task , EventFaststreamCodec , 0 ) ;
break;
#endif
#ifdef INCLUDE_APTX_ACL_SPRINT
case APTX_SPRINT_SEID:
MessageSend ( &theSink.task , EventAptxLLCodec , 0 ) ;
break;
#endif
default:
AUD_DEBUG(("AUD: Unknown codec\n"));
}
}
/****************************************************************************
NAME
connectionSmInit
DESCRIPTION
This Function is called to initialise SM. The config option is not
currently used but may be in future.
RETURNS
Nothing.
*/
void connectionSmInit(cl_dm_bt_version version, connectionSmState *smState, uint8 flags)
{
MAKE_CL_MESSAGE(CL_INTERNAL_SM_INIT_REQ);
message->options = DM_SM_INIT_SECURITY_MODE |
DM_SM_INIT_MODE3_ENC;
message->config = 0;
if(version >= bluetooth4_1 && (flags & CONNECTION_FLAG_SC_ENABLE))
{
message->options |= DM_SM_INIT_SECURE_CONNECTIONS;
if(flags & CONNECTION_FLAG_SCOM_ENABLE)
{
message->config |= DM_SM_SEC_MODE_CONFIG_SC_ONLY_MODE;
message->options |= DM_SM_INIT_CONFIG;
}
}
message->write_auth_enable = cl_sm_wae_acl_owner_none;
if(version >= bluetooth2_1)
{
message->options |= DM_SM_INIT_WRITE_AUTH_ENABLE;
message->security_mode = sec_mode4_ssp;
message->mode3_enc = hci_enc_mode_pt_to_pt_and_bcast;
}
else if (version == bluetooth2_0)
{
/* As per the documentation for DM_SM_INIT_REQ_T in dm_prim.h
* write auth enable applies to security mode 2.
* mode3 encryption doesn't apply in this mode.
* No clue why mode 3 encryption is enabled.
*/
message->options |= DM_SM_INIT_WRITE_AUTH_ENABLE;
message->security_mode = sec_mode2_service;
message->mode3_enc = hci_enc_mode_pt_to_pt;
}
else
{
message->security_mode = sec_mode2_service;
message->mode3_enc = hci_enc_mode_pt_to_pt;
}
smState->security_mode = message->security_mode;
smState->enc_mode = message->mode3_enc;
MessageSend(connectionGetCmTask(), CL_INTERNAL_SM_INIT_REQ, message);
}
/****************************************************************************
*NAME
* AvrcpBrowseGetFolderItemsResponse
*
*DESCRIPTION
* This function is used to send response for GetFolderItems command to CT.
* This will be called in response to a AVRCP_BROWSE_GET_FOLDER_ITEMS_IND
* message.
*
*PARAMETRS
* avrcp - Task
* avrcp_response_type- response. avrcp_response_browsing_success on Success.
* uint16 - UID Counter. 0 for non database aware players
* uint16 - number of items returned
* uint16 - size of the item list in bytes
* Source - item list
*****************************************************************************/
void AvrcpBrowseGetFolderItemsResponse( AVRCP* avrcp,
avrcp_response_type response,
uint16 uid_counter,
uint16 num_items,
uint16 item_list_size,
Source item_list)
{
AVBP *avbp = (AVBP*)avrcp->avbp_task;
if((SourceBoundary(item_list) < item_list_size) ||
(!num_items && item_list_size) ||
(item_list_size > (avbp->avbp_mtu - AVBP_MAX_FIXED_PDU_SIZE)))
{
AVRCP_DEBUG(("Wrong parameters\n"));
if(item_list)
{
SourceEmpty(item_list);
}
return;
}
if((isAvbpCheckConnected(avbp)) &&
(avbp->blocking_cmd == AVBP_GET_FOLDER_ITEMS_PDU_ID))
{
MAKE_AVRCP_MESSAGE(AVRCP_INTERNAL_GET_FOLDER_ITEMS_RES);
message->response = response;
message->num_items = num_items;
message->item_list_size = item_list_size;
message->item_list = item_list;
if(isAvrcpDatabaseEnabled(avrcpGetDeviceTask()))
{
message->uid_counter = uid_counter;
}
else
{
message->uid_counter = 0;
}
/* Queue the Response */
MessageSend(&avbp->task,
AVRCP_INTERNAL_GET_FOLDER_ITEMS_RES,
message);
}
else
{
AVRCP_INFO(("Wrong State. Ignoring the response\n"));
if(item_list)
{
SourceEmpty(item_list);
}
}
}
void ML::MsgLoopReqSend(PS_MlRequestType pLoop_Type)
{
S_MaintenanceLoopRequest maintenanceLoopRequest ;
S_H245Msg h245Msg ;
oscl_memcpy((int8*)&maintenanceLoopRequest.mlRequestType, (int8*)pLoop_Type, sizeof(S_MlRequestType)) ;
h245Msg.Type1 = H245_MSG_REQ ;
h245Msg.Type2 = MSGTYP_ML_REQ ;
h245Msg.pData = (uint8*) & maintenanceLoopRequest ;
MessageSend(&h245Msg) ;
}
void avrcpSendGetCapsResponse(AVRCP *avrcp,
avrcp_response_type response,
avrcp_capability_id caps,
uint16 size_caps_list,
Source caps_list)
{
MAKE_AVRCP_MESSAGE(AVRCP_INTERNAL_GET_CAPS_RES);
message->caps_id = caps;
message->response = response;
message->size_caps_list = size_caps_list;
message->caps_list = caps_list;
MessageSend(&avrcp->task, AVRCP_INTERNAL_GET_CAPS_RES, message);
}
/* Send the indicator list to the app so it can parse it for any non-HFP indicators it is interested in */
static void hfpSendUnhandledIndicatorListToApp(hfp_link_data* link, uint16 register_index, uint16 cind_index, uint16 min_range, uint16 max_range)
{
MAKE_HFP_MESSAGE(HFP_EXTRA_INDICATOR_INDEX_IND);
message->priority = hfpGetLinkPriority(link);
message->indicator_register_index = register_index;
message->indicator_index = cind_index;
message->min_range = min_range;
message->max_range = max_range;
MessageSend(theHfp->clientTask, HFP_EXTRA_INDICATOR_INDEX_IND, message);
/* Store the extra indicator index internally */
hfpStoreUnhandledIndicator(link, cind_index);
}
void a2dpSendInitCfmToClient(a2dp_status_code status)
{
MAKE_A2DP_MESSAGE(A2DP_INIT_CFM);
message->status = status;
MessageSend(a2dp->clientTask, A2DP_INIT_CFM, message);
/* If the initialisation failed, free the allocated task */
if (status != a2dp_success)
{
free(a2dp);
a2dp = 0;
}
}
/****************************************************************************
NAME
batteryNormal
DESCRIPTION
Called when the battery voltage is detected to be in a Normal state
*/
static void powerManagerHandleVbatNormal(uint8 level)
{
#ifndef NO_LED
bool low_batt = powerManagerIsVbatLow();
#endif
PM_DEBUG(("PM: Battery Normal %d\n", level));
MessageSend(&theSink.task, EventSysBatteryOk, 0);
/* If charger connected send a charger gas gauge message (these don't have any functional use but can be associated with LEDs/tones) */
if (powerManagerIsChargerConnected())
MessageSend(&theSink.task, (EventSysChargerGasGauge0+level), 0);
/* reset any low battery warning that may be in place */
theSink.battery_state = POWER_BATT_LEVEL0 + level;
csr2csrHandleAgBatteryRequestRes(level);
#ifndef NO_LED
/* when changing from low battery state to a normal state, refresh the led state pattern
to replace the low battery pattern should it have been shown */
if(low_batt) LEDManagerIndicateState(stateManagerGetState());
#endif
AudioSetPower(powerManagerGetLBIPM());
}
void ConnectionAuthGetPriorityDeviceStatusTestExtra(
Task theAppTask,
const bdaddr* bd_addr,
bool *is_priority_device
)
{
CL_AUTH_GET_PRIORITY_DEVICE_STATUS_IND_TEST_EXTRA_T *new_msg =
PanicUnlessMalloc(sizeof(CL_AUTH_GET_PRIORITY_DEVICE_STATUS_IND_TEST_EXTRA_T));
new_msg->result = ConnectionAuthGetPriorityDeviceStatus(bd_addr, &(new_msg->is_priority_device));
MessageSend(theAppTask, CL_AUTH_GET_PRIORITY_DEVICE_STATUS_IND_TEST_EXTRA, new_msg);
}
/*
* B-134381
*/
void ConnectionAuthSetPriorityDeviceTestExtra(
Task theAppTask,
const bdaddr *bd_addr,
bool is_priority_device
)
{
CL_AUTH_SET_PRIORITY_DEVICE_IND_TEST_EXTRA_T *new_msg =
PanicUnlessMalloc(sizeof(CL_AUTH_SET_PRIORITY_DEVICE_IND_TEST_EXTRA_T));
new_msg->result = ConnectionAuthSetPriorityDevice(bd_addr, is_priority_device);
MessageSend(theAppTask, CL_AUTH_SET_PRIORITY_DEVICE_IND_TEST_EXTRA, new_msg);
}
void ConnectionRfcommPortNegResponse(Task appTask, Sink sink, port_par* port_params)
{
MAKE_CL_MESSAGE(CL_INTERNAL_RFCOMM_PORTNEG_RSP);
message->theAppTask = appTask;
message->sink = sink;
if (port_params)
message->port_params = *port_params;
else
initPortParams(&(message->port_params));
MessageSend(connectionGetCmTask(), CL_INTERNAL_RFCOMM_PORTNEG_RSP, message);
}
void ML::MsgLoopOffSend(void)
{
S_MaintenanceLoopOffCommand maintenanceLoopOffCommand ;
S_H245Msg h245Msg ;
oscl_memset(&maintenanceLoopOffCommand, 0, sizeof(S_MaintenanceLoopOffCommand)) ;
h245Msg.Type1 = H245_MSG_CMD ;
h245Msg.Type2 = MSGTYP_ML_OFF_CMD ;
h245Msg.pData = (uint8*) & maintenanceLoopOffCommand ;
MessageSend(&h245Msg) ;
}
void ConnectionRfcommConnectResponse(Task theAppTask, bool response, const Sink sink, uint8 local_server_channel, const rfcomm_config_params *config)
{
/* Send an internal message */
MAKE_CL_MESSAGE(CL_INTERNAL_RFCOMM_CONNECT_RES);
message->theAppTask = theAppTask;
message->response = response;
message->sink = sink;
message->server_channel = local_server_channel;
initConfigParams(config, &message->config);
MessageSend(connectionGetCmTask(), CL_INTERNAL_RFCOMM_CONNECT_RES, message);
}
static void sendSppStartServiceCfm(spp_start_status status)
{
if (sppsClientTask)
{
MAKE_SPP_MESSAGE(SPP_START_SERVICE_CFM);
message->status = status;
MessageSend(sppsClientTask, SPP_START_SERVICE_CFM, message);
}
#if SPP_DEBUG_LIB
else
SPP_DEBUG(("sppsClientTask is NULL!\n"));
#endif
}
static void sendSppStopServiceCfm(Task theClientTask, spp_stop_status status)
{
if (theClientTask)
{
MAKE_SPP_MESSAGE(SPP_STOP_SERVICE_CFM);
message->status = status;
MessageSend(theClientTask, SPP_STOP_SERVICE_CFM, message);
}
#if SPP_DEBUG_LIB
else
SPP_DEBUG(("theClientTask is NULL!\n"));
#endif
}
void sendGetValueTextResponse(AVRCP *avrcp,
avrcp_response_type response,
uint16 number_of_values,
uint16 size_values,
Source values)
{
MAKE_AVRCP_MESSAGE(AVRCP_INTERNAL_GET_APP_VALUE_TEXT_RES);
message->response = response;
message->number_of_values = number_of_values;
message->size_values_list = size_values;
message->values_list = values;
MessageSend(&avrcp->task, AVRCP_INTERNAL_GET_APP_VALUE_TEXT_RES, message);
}
void sendPlayStatusResponse(AVRCP *avrcp,
avrcp_response_type response,
uint32 song_length,
uint32 song_elapsed,
avrcp_play_status play_status)
{
MAKE_AVRCP_MESSAGE(AVRCP_INTERNAL_GET_PLAY_STATUS_RES);
message->response = response;
message->song_length = song_length;
message->song_elapsed = song_elapsed;
message->play_status = play_status;
MessageSend(&avrcp->task, AVRCP_INTERNAL_GET_PLAY_STATUS_RES, message);
}
/****************************************************************************
NAME
hidDisconnectingRemoteExit
DESCRIPTION
Called whenever the HID instance exits the remote disconnecting state.
Sends a HID_DISCONNECT_IND message to the applications and stops the
disconnect timer.
RETURNS
void
*/
static void hidDisconnectingRemoteExit(HID *hid)
{
MAKE_HID_MESSAGE(HID_DISCONNECT_IND);
HID_PRINT(("hidDisconnectingRemoteExit\n"));
/* Send HID_DISCONNECT_IND to application */
message->hid = hid;
message->status = hid->disconnect_status;
MessageSend(hid->app_task, HID_DISCONNECT_IND, message);
/* Stop disconnect timer */
MessageCancelAll(&hid->task, HID_INTERNAL_DISCONNECT_TIMEOUT_IND);
}
static void sendUnhandledIndicatorToApp(hfp_link_data* link, uint16 index, uint16 value)
{
/*
We have received an indicator not defined by the HFP spec. Pass it
up to the application as it might want to make use of these extra
indicators that some AGs send out.
*/
MAKE_HFP_MESSAGE(HFP_EXTRA_INDICATOR_UPDATE_IND);
message->priority = hfpGetLinkPriority(link);
message->index = index;
message->value = value;
MessageSend(theHfp->clientTask, HFP_EXTRA_INDICATOR_UPDATE_IND, message);
}
void ConnectionRegisterServiceRecord(Task appTask, uint16 num_rec_bytes, const uint8 *service_record)
{
/* Check some record has been supplied */
if((num_rec_bytes == 0) || (service_record == NULL))
{
/* Return Failure if there is no service record passed */
MAKE_CL_MESSAGE(CL_SDP_REGISTER_CFM);
message->status = fail;
message->service_handle = 0;
MessageSend(appTask, CL_SDP_REGISTER_CFM, message);
}
else
{
/* Send an internal message to the state machine */
MAKE_CL_MESSAGE(CL_INTERNAL_SDP_REGISTER_RECORD_REQ);
message->theAppTask = appTask;
message->record_length = num_rec_bytes;
message->record = (uint8 *) service_record;
MessageSend(connectionGetCmTask(), CL_INTERNAL_SDP_REGISTER_RECORD_REQ, message);
}
}
/****************************************************************************
NAME
sendReliableWriteExecuteCfm
DESCRIPTION
Send the GATT_RELIABLE_WRITE_EXECUTE_CFM message.
RETURNS
*/
static void sendReliableWriteExecuteCfm(Task task,
uint16 cid,
uint16 handle,
gatt_status_t status)
{
MAKE_GATT_MESSAGE(GATT_RELIABLE_WRITE_EXECUTE_CFM);
message->cid = cid;
message->handle = handle;
message->status = gatt_message_status(status);
MessageSend(task, GATT_RELIABLE_WRITE_EXECUTE_CFM, message);
}
/****************************************************************************
NAME
sendErrorToClient
DESCRIPTION
Helper function to send the error message to the client task
*/
static void sendErrorToClient(void)
{
/* Build the plugin error message to let the application know something serious in the plugin has failed */
AUDIO_PLUGIN_DSP_IND_T * message = PanicUnlessNew(AUDIO_PLUGIN_DSP_IND_T);
message->id = SUB_PLUGIN_FATAL_ERROR;
message->size_value = 1;
message->value[0] = 0;
/* Ensure all streams have been disconnected and DSP turned off before sending error (also free's all memory used by the plugin to prevent memory leak) */
CsrSubwooferPluginDisconnect();
MessageSend(plugin_data->app_task, AUDIO_PLUGIN_DSP_IND, message);
}
/****************************************************************************
* NAME
* avrcpHandleGetElementAttributesCommand
*
* DESCRIPTION
* Handle the incoming Get Element Attributes command
*
* PARAMETERS
* avrcp - AVRCP Instance
* ptr - Pointer to the data packet
* packet_size - Packet size
*******************************************************************************/
void avrcpHandleGetElementAttributesCommand(AVRCP *avrcp,
const uint8 *ptr,
uint16 packet_size)
{
uint16 data_offset=9;
uint32 identifier_high = 0, identifier_low = 0;
uint8 attribute_count=0;
Source source=0;
if(packet_size >= AVRCP_GET_ELEMENTS_HDR_SIZE)
{
data_offset=9;
identifier_high = convertUint8ValuesToUint32(&ptr[0]);
identifier_low = convertUint8ValuesToUint32(&ptr[4]);
attribute_count= ptr[8];
packet_size -= data_offset;
if(packet_size)
{
if(!(source=avrcpSourceFromConstData(avrcp,
ptr+data_offset,
packet_size)))
{
packet_size = 0;
}
}
}
{
MAKE_AVRCP_MESSAGE(AVRCP_GET_ELEMENT_ATTRIBUTES_IND);
message->avrcp = avrcp;
message->identifier_high = identifier_high;
message->identifier_low = identifier_low;
message->number_of_attributes = attribute_count;
message->size_attributes = packet_size;
message->attributes = source;
#ifdef AVRCP_ENABLE_DEPRECATED
/* Deprecated fields will be removed later */
message->metadata_packet_type = avrcp_packet_type_single;
message->transaction = avrcp->rsp_transaction_label;
message->no_packets = 1;
message->ctp_packet_type = AVCTP0_PACKET_TYPE_SINGLE;
message->data_offset = 0;
#endif
MessageSend(avrcp->clientTask, AVRCP_GET_ELEMENT_ATTRIBUTES_IND, message);
}
}
/****************************************************************************
NAME
handleMapcMnsConnectCfm
DESCRIPTION
handle after receiving MAPC_MNS_CONNECT_CFM_T
PARAMS
pMessage message
RETURNS
void
*/
static void handleMapcMnsConnectCfm(MAPC_MNS_CONNECT_CFM_T* pMsg)
{
mapc_link_priority device_id = mapcGetLinkFromBdAddr( &pMsg->addr );
mapcState * state = NULL;
/* ensure device_id has been correctly retrieved */
if(device_id != mapc_invalid_link)
state = &(theSink.rundata->mapc_data.state[device_id]);
MAPC_DEBUG(("MAPC:MAPC_MNS_CONNECT_CFM:"));
if(pMsg->status == mapc_pending)
{
MAPC_DEBUG(("Connection Pending. channel = %x \n", pMsg->mnsChannel));
if(state)
state->mnsHandle = pMsg->mnsSession;
}
else if(pMsg->status == mapc_success)
{
MAPC_DEBUG(("Connection Successfull \n"));
if(state)
{
state->mnsHandle = pMsg->mnsSession;
state->mnsChannel = pMsg->mnsChannel;
/* Send an message to indicate the mns service connection success */
MessageSend(&theSink.task, EventSysMapcMnsSuccess, 0);
}
}
else
{
MAPC_DEBUG(("MnS Connection Failed\n"));
/* Send an message to indicate the mns service connection success */
MessageSend(&theSink.task, EventSysMapcMnsFailed, 0);
}
}
/****************************************************************************
NAME
connectionHandleSdpUnregisterCfm
DESCRIPTION
Handle the response from BlueStack to an SDP unregister request
RETURNS
void
*/
void connectionHandleSdpUnregisterCfm(connectionSdpState *state, const SDS_UNREGISTER_CFM_T *cfm)
{
if (state->sdpLock)
{
/* Send response to the client */
MAKE_CL_MESSAGE(CL_SDP_UNREGISTER_CFM);
message->status = (connection_lib_status) cfm->result;
message->service_handle = cfm->svc_rec_hndl;
MessageSend(state->sdpLock, CL_SDP_UNREGISTER_CFM, message);
/* Reset the resource lock */
state->sdpLock = 0;
}
}
void aghfpHandleChldParse(Task task, const struct aghfpHandleChldParse *data)
{
MAKE_AGHFP_MESSAGE(AGHFP_INTERNAL_CALL_HOLD_REQ);
message->action = (uint16)(*data->cmd.data - '0');
if ( data->cmd.length>1 )
{
(void)UtilGetNumber(data->cmd.data+1,data->cmd.data+data->cmd.length-1, &message->index);
}
else
{
message->index = 0;
}
MessageSend(task, AGHFP_INTERNAL_CALL_HOLD_REQ, message);
}
static zSHORT
zwfnTZCMRPTD_LoadNewAudittrail( zVIEW vSubtask, zPVIEW vTZBRAU2O )
{
zVIEW vTZCMCPL;
zVIEW vKZDBHQUA;
zULONG ulZKey;
zCHAR szZKey[18];
zSHORT nRC;
if ( GetViewByName( &vTZCMCPL, "TZCMCPL", vSubtask, zLEVEL_TASK ) < 0 )
return( -1 );
if ( CheckExistenceOfEntity( vTZCMCPL, "CPLR" ) == zCURSOR_SET )
{
if ( ActivateEmptyObjectInstance( &vKZDBHQUA, "KZDBHQUA", vSubtask,
zSINGLE ) >= 0 )
{
SetNameForView( vKZDBHQUA, "KZDBHQUA", vSubtask, zLEVEL_TASK );
CreateEntity( vKZDBHQUA, "EntitySpec", zPOS_AFTER );
CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER );
}
else
return( -1 );
GetIntegerFromAttribute( (zPLONG)&ulZKey, vTZCMCPL, "CPLR", "ZKey" );
SetAttributeFromString( vKZDBHQUA, "EntitySpec", "EntityName", "CPLR" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "EntityName", "CPLR" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "AttributeName", "ZKey" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "=" );
zltoa( ulZKey, szZKey );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Value", szZKey );
nRC = ActivateObjectInstance( vTZBRAU2O, "TZBRAU2O", vSubtask,
vKZDBHQUA, zSINGLE | zLEVEL_APPLICATION );
DropObjectInstance( vKZDBHQUA );
SetNameForView( *vTZBRAU2O, "TZBRAU2O", vSubtask, zLEVEL_TASK );
}
else
{
MessageSend( vSubtask, "CM00299", "Audit Trail:",
"There are no Audit Trail Information for a non-repository LPLR.",
zMSGQ_OBJECT_CONSTRAINT_WARNING, zBEEP );
SetWindowActionBehavior( vSubtask, zWAB_StayOnWindow, 0, 0 );
return( -1 );
}
return( 0 );
} // zwfnTZCMRPTD_LoadNewAudittrail
/****************************************************************************
NAME
HfpVoiceRecognitionEnable
DESCRIPTION
Enable / disable voice recognition function at the AG. An SLC for the
supplied profile instance (hfp) must already be established before calling
this function. The enable flag determines whether a request will be made
to the AG to enabe or disable its voice recognition function. The message
returned indicates whether the command was recognised by the AG or not.
The AG may autonomously notify the HFP device of a change in the state of
its voice recognition function. This notification will be passed on to the
application using a HFP_VOICE_RECOGNITION_IND message.
MESSAGE RETURNED
HFP_VOICE_RECOGNITION_ENABLE_CFM
RETURNS
void
*/
void HfpVoiceRecognitionEnable(HFP *hfp, bool enable)
{
#ifdef HFP_DEBUG_LIB
if (!hfp)
HFP_DEBUG(("Null hfp task ptr passed in.\n"));
#endif
{
/* Send an internal message to kick off SLC creation */
MAKE_HFP_MESSAGE(HFP_INTERNAL_AT_BVRA_REQ);
message->enable = enable;
MessageSend(&hfp->task, HFP_INTERNAL_AT_BVRA_REQ, message);
}
}
static void adc_result_handler(vm_adc_source_type source, uint8 reading) {
bool vref_first_update = FALSE;
if (source == VM_ADC_SRC_VREF) {
if (battery_probe.vref_reading == 255) {
vref_first_update = TRUE;
}
battery_probe.vref_reading = reading;
}
else if (source == battery_probe.source) {
battery_probe.source_reading = reading;
}
else {
/** should not happen, but if it happens, we should not panic **/
return;
}
/*******************
condition 1: both reading must be valid
contition 2: either this is a source update or it is the vref update for the first time, that is, only first time vref update, we throw the message
******************/
if ((battery_probe.source_reading != 255) && (battery_probe.vref_reading != 255) &&
((source == battery_probe.source) || (source == VM_ADC_SRC_VREF && vref_first_update == TRUE))) {
/** to avoid integer overflow **/
unsigned long src, vref;
uint32* mV;
src = battery_probe.source_reading;
vref = battery_probe.vref_reading;
if (vref == 0) { /** to avoid division overflow **/
return;
}
mV = (uint32*)malloc(sizeof(uint32));
*mV = 1250UL * src / vref;
MessageSend(battery_probe.client, BATTERY_PROBING_MESSAGE, mV);
}
}
void ConnectionL2capConnectResponse(Task appTask, bool response, uint16 psm, uint16 connection_id, uint8 identifier, uint16 conftab_length, uint16* conftab)
{
/* Send an internal message */
MAKE_CL_MESSAGE(CL_INTERNAL_L2CAP_CONNECT_RES);
message->theAppTask = appTask;
message->response = response;
message->identifier = identifier;
message->psm_local = psm;
message->connection_id = connection_id;
message->length = conftab_length;
message->data = conftab;
MessageSend(connectionGetCmTask(), CL_INTERNAL_L2CAP_CONNECT_RES, message);
}