static jint nativeJAnt_Create(JNIEnv *env, jobject obj) { ANTStatus antStatus = ANT_STATUS_FAILED; (void)env; //unused warning (void)obj; //unused warning ANT_FUNC_START(); antStatus = ant_init(); if (antStatus) { ANT_DEBUG_D("failed to init ANT stack"); goto CLEANUP; } antStatus = set_ant_rx_callback(nativeJAnt_RxCallback); if (antStatus) { ANT_DEBUG_D("failed to set ANT rx callback"); goto CLEANUP; } antStatus = set_ant_state_callback(nativeJAnt_StateCallback); if (antStatus) { ANT_DEBUG_D("failed to set ANT state callback"); goto CLEANUP; } CLEANUP: ANT_FUNC_END(); return antStatus; }
int ant_disable(void) { int iRet = -1; ant_channel_type eChannel; ANT_FUNC_START(); stRxThreadInfo.ucRunThread = 0; if (stRxThreadInfo.stRxThread != 0) { ANT_DEBUG_I("Sending shutdown signal to rx thread."); if(write(stRxThreadInfo.iRxShutdownEventFd, &EVENT_FD_PLUS_ONE, sizeof(EVENT_FD_PLUS_ONE)) < 0) { ANT_ERROR("failed to signal rx thread with eventfd. Reason: %s", strerror(errno)); goto out; } ANT_DEBUG_I("Waiting for rx thread to finish."); if (pthread_join(stRxThreadInfo.stRxThread, NULL) < 0) { ANT_ERROR("failed to join rx thread: %s", strerror(errno)); goto out; } } else { ANT_DEBUG_D("rx thread is not running"); } for (eChannel = 0; eChannel < NUM_ANT_CHANNELS; eChannel++) { ant_disable_channel(&stRxThreadInfo.astChannels[eChannel]); } iRet = 0; out: stRxThreadInfo.stRxThread = 0; ANT_FUNC_END(); return iRet; }
static jint nativeJAnt_TxMessage(JNIEnv *env, jobject obj, jbyteArray msg) { (void)obj; //unused warning ANT_FUNC_START(); if (msg == NULL) { if (jniThrowException(env, "java/lang/NullPointerException", NULL)) { ANT_ERROR("Unable to throw NullPointerException"); } return -1; } jbyte* msgBytes = env->GetByteArrayElements(msg, NULL); jint msgLength = env->GetArrayLength(msg); ANTStatus status = ant_tx_message((ANT_U8) msgLength, (ANT_U8 *)msgBytes); ANT_DEBUG_D("nativeJAnt_TxMessage: ant_tx_message() returned %d", (int)status); env->ReleaseByteArrayElements(msg, msgBytes, JNI_ABORT); ANT_FUNC_END(); return status; }
void nativeJAnt_StateCallback(ANTRadioEnabledStatus uiNewState) { JNIEnv* env = NULL; jint jNewState = uiNewState; ANT_BOOL iShouldDetach = ANT_FALSE; ANT_FUNC_START(); g_jVM->GetEnv((void**) &env, JNI_VERSION_1_4); if (env == NULL) { ANT_DEBUG_D("nativeJAnt_StateCallback: called from rx thread, attaching to VM"); g_jVM->AttachCurrentThread((&env), NULL); if (env == NULL) { ANT_DEBUG_E("nativeJAnt_StateCallback: failed to attach rx thread to VM"); return; } iShouldDetach = ANT_TRUE; } else { ANT_DEBUG_D("nativeJAnt_StateCallback: called from java enable/disable" ", already attached, don't detach"); } ANT_DEBUG_V("nativeJAnt_StateCallback: Calling java state callback"); env->CallStaticVoidMethod(g_sJClazz, g_sMethodId_nativeCb_AntStateChange, jNewState); ANT_DEBUG_V("nativeJAnt_StateCallback: Called java state callback"); if (env->ExceptionOccurred()) { ANT_ERROR("nativeJAnt_StateCallback: Calling Java nativeCb_AntStateChange failed"); env->ExceptionDescribe(); env->ExceptionClear(); } if (iShouldDetach) { ANT_DEBUG_D("nativeJAnt_StateCallback: env was attached, detaching"); g_jVM->DetachCurrentThread(); } ANT_FUNC_END(); return; }
static jint nativeJAnt_Destroy(JNIEnv *env, jobject obj) { (void)env; //unused warning (void)obj; //unused warning ANTStatus status; ANT_FUNC_START(); ANT_DEBUG_D("nativeJAnt_Destroy(): calling ant_deinit"); status = ant_deinit(); if (status) { ANT_DEBUG_D("failed to deinit ANT stack returned %d",(int)status); return status; } else { ANT_DEBUG_D("deinit ANT stack Success"); } ANT_FUNC_END(); return status; }
int ant_enable(void) { int iRet = -1; ant_channel_type eChannel; ANT_FUNC_START(); // Reset the shutdown signal. uint64_t counter; ssize_t result = read(stRxThreadInfo.iRxShutdownEventFd, &counter, sizeof(counter)); // EAGAIN result indicates that the counter was already 0 in non-blocking mode. if(result < 0 && errno != EAGAIN) { ANT_ERROR("Could not clear shutdown signal in enable. Reason: %s", strerror(errno)); goto out; } stRxThreadInfo.ucRunThread = 1; for (eChannel = 0; eChannel < NUM_ANT_CHANNELS; eChannel++) { if (ant_enable_channel(&stRxThreadInfo.astChannels[eChannel]) < 0) { ANT_ERROR("failed to enable channel %s: %s", stRxThreadInfo.astChannels[eChannel].pcDevicePath, strerror(errno)); goto out; } } if (stRxThreadInfo.stRxThread == 0) { if (pthread_create(&stRxThreadInfo.stRxThread, NULL, fnRxThread, &stRxThreadInfo) < 0) { ANT_ERROR("failed to start rx thread: %s", strerror(errno)); goto out; } } else { ANT_DEBUG_D("rx thread is already running"); } if (!stRxThreadInfo.ucRunThread) { ANT_ERROR("rx thread crashed during init"); goto out; } iRet = 0; out: ANT_FUNC_END(); return iRet; }
ANTRadioEnabledStatus ant_radio_enabled_status(void) { ant_channel_type eChannel; int iOpenFiles = 0; int iOpenThread; ANTRadioEnabledStatus uiRet = RADIO_STATUS_UNKNOWN; ANT_FUNC_START(); if (stRxThreadInfo.ucChipResetting) { uiRet = RADIO_STATUS_RESETTING; goto out; } for (eChannel = 0; eChannel < NUM_ANT_CHANNELS; eChannel++) { if (stRxThreadInfo.astChannels[eChannel].iFd != -1) { iOpenFiles++; } } iOpenThread = (stRxThreadInfo.stRxThread) ? 1 : 0; if (!stRxThreadInfo.ucRunThread) { if (iOpenFiles || iOpenThread) { uiRet = RADIO_STATUS_DISABLING; } else { uiRet = RADIO_STATUS_DISABLED; } } else { if ((iOpenFiles == NUM_ANT_CHANNELS) && iOpenThread) { uiRet = RADIO_STATUS_ENABLED; } else if (!iOpenFiles && iOpenThread) { uiRet = RADIO_STATUS_UNKNOWN; } else { uiRet = RADIO_STATUS_ENABLING; } } out: ANT_DEBUG_D("get radio enabled status returned %d", uiRet); ANT_FUNC_END(); return uiRet; }
static void ant_disable_channel(ant_channel_info_t *pstChnlInfo) { ANT_FUNC_START(); if (!pstChnlInfo) { ANT_ERROR("null channel info passed to channel disable function"); goto out; } if (pstChnlInfo->iFd != -1) { // Use the new init_transport function instead of open() to get our fd. if (init_transport_bdroid(0) < 0) { ANT_ERROR("failed to close channel %s(%#x): %s", pstChnlInfo->pcDevicePath, pstChnlInfo->iFd, strerror(errno)); } pstChnlInfo->iFd = -1; //TODO can this overwrite a still valid fd? } else { ANT_DEBUG_D("%s file is already closed", pstChnlInfo->pcDevicePath); } out: ANT_FUNC_END(); }
static int ant_enable_channel(ant_channel_info_t *pstChnlInfo) { int iRet = -1; ANT_FUNC_START(); if (!pstChnlInfo) { ANT_ERROR("null channel info passed to channel enable function"); errno = EINVAL; goto out; } if (pstChnlInfo->iFd == -1) { // Use the init_transport function to release our fd instead of close() pstChnlInfo->iFd = init_transport_bdroid(1); if (pstChnlInfo->iFd < 0) { ANT_ERROR("failed to open dev %s: %s", pstChnlInfo->pcDevicePath, strerror(errno)); goto out; } } else { ANT_DEBUG_D("%s is already enabled", pstChnlInfo->pcDevicePath); } iRet = 0; out: ANT_FUNC_END(); return iRet; }
/* * This thread opens a Bluez HCI socket and waits for ANT messages. */ void *ANTHCIRxThread(void *pvHCIDevice) { int ret = ANT_STATUS_SUCCESS; int rxSocket; int len; unsigned char buf[HCI_MAX_EVENT_SIZE]; int result; struct hci_filter eventVendorFilter; ANT_FUNC_START(); (void)pvHCIDevice; //unused waring ANT_DEBUG_D("Entering ANTHCIRxThread"); rxSocket = create_hci_sock(); if (rxSocket < 0) { ANT_DEBUG_E("can't open HCI socket in rx thread: %s", strerror(errno)); ret = ANT_STATUS_FAILED; goto out; } eventVendorFilter.type_mask = TYPE_MASK_EVENT_PACKET; eventVendorFilter.event_mask[0] = 0; eventVendorFilter.event_mask[1] = EVENT_MASK_1_EVENT_VENDOR; eventVendorFilter.opcode = htobs(ANT_EVENT_VENDOR_CODE); if (setsockopt(rxSocket, SOL_HCI, HCI_FILTER, &eventVendorFilter, sizeof(eventVendorFilter)) < 0) { ANT_ERROR("failed to set socket options: %s", strerror(errno)); ret = ANT_STATUS_FAILED; goto close; } /* continue running as long as not terminated */ while (get_and_set_radio_status() == RADIO_STATUS_ENABLED) { struct pollfd p; int n; p.fd = rxSocket; p.events = POLLIN; ANT_DEBUG_V(" RX: Polling HCI for data..."); /* poll socket, wait for ANT messages */ while ((n = poll(&p, 1, 2500)) == -1) { if (errno == EAGAIN || errno == EINTR) continue; ANT_ERROR("failed to poll socket: %s", strerror(errno)); ret = ANT_STATUS_FAILED; goto close; } /* we timeout once in a while */ /* this let's us the chance to check if we were terminated */ if (0 == n) { ANT_DEBUG_V(" RX: Timeout"); continue; } ANT_DEBUG_D("New HCI data available, reading..."); /* read newly arrived data */ /* TBD: rethink assumption about single arrival */ while ((len = read(rxSocket, buf, sizeof(buf))) < 0) { if (errno == EAGAIN || errno == EINTR) continue; ANT_ERROR("failed to read socket: %s", strerror(errno)); ret = ANT_STATUS_FAILED; goto close; } hci_event_packet_t *event_packet = (hci_event_packet_t *)buf; int hci_payload_len = validate_hci_event_packet(event_packet, len); if (hci_payload_len == -1) { // part of the message is incorrect, ignore it. validate_event_packet will log error continue; } ANT_SERIAL(event_packet->hci_payload, hci_payload_len, 'R'); if(RxParams.pfRxCallback != NULL) { RxParams.pfRxCallback(hci_payload_len, event_packet->hci_payload); } else { ANT_ERROR("Can't send rx message - no callback registered"); } } close: result = pthread_mutex_trylock(&enableLock); ANT_DEBUG_D("rx thread close: trylock enableLock returned %d", result); if (result == 0) { ANT_DEBUG_W("rx thread socket has unexpectedly crashed"); #if USE_EXTERNAL_POWER_LIBRARY if (RxParams.pfStateCallback) RxParams.pfStateCallback(RADIO_STATUS_DISABLING); ant_disable(); get_and_set_radio_status(); #else radio_status = RADIO_STATUS_DISABLED; #endif RxParams.thread = 0; pthread_mutex_unlock(&enableLock); } else if (result == EBUSY) { ANT_DEBUG_V("rx thread socket was closed"); } else { ANT_ERROR("rx thread close: trylock failed: %s", strerror(result)); } if (-1 == close(rxSocket)) { ANT_ERROR("failed to close hci device (socket handle=%#x): %s", rxSocket, strerror(errno)); } else { ANT_DEBUG_D("closed hci device (socket handle=%#x)", rxSocket); } out: ANT_FUNC_END(); pthread_exit((void *)ret); #if defined(ANDROID) return 0; #endif }
/********************************************************************** * Callback registration ***********************************************************************/ void nativeJAnt_RxCallback(ANT_U8 ucLen, ANT_U8* pucData) { JNIEnv* env = NULL; jbyteArray jAntRxMsg = NULL; ANT_FUNC_START(); ANT_DEBUG_D( "got message %d bytes", ucLen); g_jVM->AttachCurrentThread((&env), NULL); if (env == NULL) { ANT_DEBUG_D("nativeJAnt_RxCallback: Entered, env is null"); return; // log error? cleanup? } else { ANT_DEBUG_D("nativeJAnt_RxCallback: jEnv %p", env); } jAntRxMsg = env->NewByteArray(ucLen); if (jAntRxMsg == NULL) { ANT_ERROR("nativeJAnt_RxCallback: Failed creating java byte[]"); goto CLEANUP; } env->SetByteArrayRegion(jAntRxMsg,0,ucLen,(jbyte*)pucData); if (env->ExceptionOccurred()) { ANT_ERROR("nativeJAnt_RxCallback: ExceptionOccurred during byte[] copy"); goto CLEANUP; } ANT_DEBUG_V("nativeJAnt_RxCallback: Calling java rx callback"); env->CallStaticVoidMethod(g_sJClazz, g_sMethodId_nativeCb_AntRxMessage, jAntRxMsg); ANT_DEBUG_V("nativeJAnt_RxCallback: Called java rx callback"); if (env->ExceptionOccurred()) { ANT_ERROR("nativeJAnt_RxCallback: Calling Java nativeCb_AntRxMessage failed"); goto CLEANUP; } //Delete the local references if (jAntRxMsg != NULL) { env->DeleteLocalRef(jAntRxMsg); } ANT_DEBUG_D("nativeJAnt_RxCallback: Exiting, Calling DetachCurrentThread at the END"); g_jVM->DetachCurrentThread(); ANT_FUNC_END(); return; CLEANUP: ANT_ERROR("nativeJAnt_RxCallback: Exiting due to failure"); if (jAntRxMsg != NULL) { env->DeleteLocalRef(jAntRxMsg); } if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear(); } g_jVM->DetachCurrentThread(); return; }
int readChannelMsg(ant_channel_type eChannel, ant_channel_info_t *pstChnlInfo) { int iRet = -1; int iRxLenRead; int iCurrentHciPacketOffset; int iHciDataSize; ANT_FUNC_START(); // Keep trying to read while there is an error, and that error is EAGAIN while (((iRxLenRead = read(pstChnlInfo->iFd, &aucRxBuffer[eChannel][iRxBufferLength[eChannel]], (sizeof(aucRxBuffer[eChannel]) - iRxBufferLength[eChannel]))) < 0) && errno == EAGAIN) ; if (iRxLenRead < 0) { if (errno == ENODEV) { ANT_ERROR("%s not enabled, exiting rx thread", pstChnlInfo->pcDevicePath); goto out; } else if (errno == ENXIO) { ANT_ERROR("%s there is no physical ANT device connected", pstChnlInfo->pcDevicePath); goto out; } else { ANT_ERROR("%s read thread exiting, unhandled error: %s", pstChnlInfo->pcDevicePath, strerror(errno)); goto out; } } else { ANT_SERIAL(aucRxBuffer[eChannel], iRxLenRead, 'R'); iRxLenRead += iRxBufferLength[eChannel]; // add existing data on // if we didn't get a full packet, then just exit if (iRxLenRead < (aucRxBuffer[eChannel][ANT_HCI_SIZE_OFFSET] + ANT_HCI_HEADER_SIZE + ANT_HCI_FOOTER_SIZE)) { iRxBufferLength[eChannel] = iRxLenRead; iRet = 0; goto out; } iRxBufferLength[eChannel] = 0; // reset buffer length here since we should have a full packet #if ANT_HCI_OPCODE_SIZE == 1 // Check the different message types by opcode ANT_U8 opcode = aucRxBuffer[eChannel][ANT_HCI_OPCODE_OFFSET]; if(ANT_HCI_OPCODE_COMMAND_COMPLETE == opcode) { // Command Complete, so signal a FLOW_GO if(setFlowControl(pstChnlInfo, ANT_FLOW_GO)) { goto out; } } else if(ANT_HCI_OPCODE_FLOW_ON == opcode) { // FLow On, so resend the last Tx #ifdef ANT_FLOW_RESEND // Check if there is a message to resend if(pstChnlInfo->ucResendMessageLength > 0) { ant_tx_message_flowcontrol_none(eChannel, pstChnlInfo->ucResendMessageLength, pstChnlInfo->pucResendMessage); } else { ANT_DEBUG_D("Resend requested by chip, but tx request cancelled"); } #endif // ANT_FLOW_RESEND } else if(ANT_HCI_OPCODE_ANT_EVENT == opcode) // ANT Event, send ANT packet to Rx Callback #endif // ANT_HCI_OPCODE_SIZE == 1 { // Received an ANT packet iCurrentHciPacketOffset = 0; while(iCurrentHciPacketOffset < iRxLenRead) { // TODO Allow HCI Packet Size value to be larger than 1 byte // This currently works as no size value is greater than 255, and little endian iHciDataSize = aucRxBuffer[eChannel][iCurrentHciPacketOffset + ANT_HCI_SIZE_OFFSET]; if ((iHciDataSize + ANT_HCI_HEADER_SIZE + ANT_HCI_FOOTER_SIZE + iCurrentHciPacketOffset) > iRxLenRead) { // we don't have a whole packet iRxBufferLength[eChannel] = iRxLenRead - iCurrentHciPacketOffset; memcpy(aucRxBuffer[eChannel], &aucRxBuffer[eChannel][iCurrentHciPacketOffset], iRxBufferLength[eChannel]); // the increment at the end should push us out of the while loop } else #ifdef ANT_MESG_FLOW_CONTROL if (aucRxBuffer[eChannel][iCurrentHciPacketOffset + ANT_HCI_DATA_OFFSET + ANT_MSG_ID_OFFSET] == ANT_MESG_FLOW_CONTROL) { // This is a flow control packet, not a standard ANT message if(setFlowControl(pstChnlInfo, \ aucRxBuffer[eChannel][iCurrentHciPacketOffset + ANT_HCI_DATA_OFFSET + ANT_MSG_DATA_OFFSET])) { goto out; } } else #endif // ANT_MESG_FLOW_CONTROL { ANT_U8 *msg = aucRxBuffer[eChannel] + iCurrentHciPacketOffset + ANT_HCI_DATA_OFFSET; ANT_BOOL bIsKeepAliveResponse = memcmp(msg, KEEPALIVE_RESP, sizeof(KEEPALIVE_RESP)/sizeof(ANT_U8)) == 0; if (bIsKeepAliveResponse) { ANT_DEBUG_V("Filtered out keepalive response."); } else if (pstChnlInfo->fnRxCallback != NULL) { // Loop through read data until all HCI packets are written to callback pstChnlInfo->fnRxCallback(iHciDataSize, \ msg); } else { ANT_WARN("%s rx callback is null", pstChnlInfo->pcDevicePath); } } iCurrentHciPacketOffset = iCurrentHciPacketOffset + ANT_HCI_HEADER_SIZE + ANT_HCI_FOOTER_SIZE + iHciDataSize; } } iRet = 0; } out: ANT_FUNC_END(); return iRet; }
/* * This thread waits for ANT messages from a VFS file. */ void *fnRxThread(void *ant_rx_thread_info) { int iMutexLockResult; int iPollRet; ant_rx_thread_info_t *stRxThreadInfo; struct pollfd astPollFd[NUM_POLL_FDS]; ant_channel_type eChannel; ANT_FUNC_START(); stRxThreadInfo = (ant_rx_thread_info_t *)ant_rx_thread_info; for (eChannel = 0; eChannel < NUM_ANT_CHANNELS; eChannel++) { astPollFd[eChannel].fd = stRxThreadInfo->astChannels[eChannel].iFd; astPollFd[eChannel].events = EVENTS_TO_LISTEN_FOR; } // Fill out poll request for the shutdown signaller. astPollFd[EVENTFD_IDX].fd = stRxThreadInfo->iRxShutdownEventFd; astPollFd[EVENTFD_IDX].events = POLL_IN; // Reset the waiting for response, since we don't want a stale value if we were reset. stRxThreadInfo->bWaitingForKeepaliveResponse = ANT_FALSE; /* continue running as long as not terminated */ while (stRxThreadInfo->ucRunThread) { /* Wait for data available on any file (transport path), shorter wait if we just timed out. */ int timeout = stRxThreadInfo->bWaitingForKeepaliveResponse ? KEEPALIVE_TIMEOUT : ANT_POLL_TIMEOUT; iPollRet = poll(astPollFd, NUM_POLL_FDS, timeout); if (!iPollRet) { if(!stRxThreadInfo->bWaitingForKeepaliveResponse) { stRxThreadInfo->bWaitingForKeepaliveResponse = ANT_TRUE; // Keep alive is done on a separate thread so that rxThread can handle flow control during // the message. pthread_t thread; // Don't care if it failed as the consequence is just a missed keep-alive. pthread_create(&thread, NULL, fnKeepAliveThread, NULL); // Detach the thread so that we don't need to join it later. pthread_detach(thread); ANT_DEBUG_V("poll timed out, checking exit cond"); } else { ANT_DEBUG_E("No response to keepalive, attempting recovery."); doReset(stRxThreadInfo); goto out; } } else if (iPollRet < 0) { ANT_ERROR("unhandled error: %s, attempting recovery.", strerror(errno)); doReset(stRxThreadInfo); goto out; } else { for (eChannel = 0; eChannel < NUM_ANT_CHANNELS; eChannel++) { if (areAllFlagsSet(astPollFd[eChannel].revents, EVENT_HARD_RESET)) { ANT_ERROR("Hard reset indicated by %s. Attempting recovery.", stRxThreadInfo->astChannels[eChannel].pcDevicePath); doReset(stRxThreadInfo); goto out; } else if (areAllFlagsSet(astPollFd[eChannel].revents, EVENT_CHIP_SHUTDOWN)) { /* chip reported it was unexpectedly disabled */ ANT_DEBUG_D( "poll hang-up from %s. exiting rx thread", stRxThreadInfo->astChannels[eChannel].pcDevicePath); doReset(stRxThreadInfo); goto out; } else if (areAllFlagsSet(astPollFd[eChannel].revents, EVENT_DATA_AVAILABLE)) { ANT_DEBUG_D("data on %s. reading it", stRxThreadInfo->astChannels[eChannel].pcDevicePath); // Doesn't matter what data we received, we know the chip is alive. stRxThreadInfo->bWaitingForKeepaliveResponse = ANT_FALSE; if (readChannelMsg(eChannel, &stRxThreadInfo->astChannels[eChannel]) < 0) { // set flag to exit out of Rx Loop stRxThreadInfo->ucRunThread = 0; } } else if (areAllFlagsSet(astPollFd[eChannel].revents, POLLNVAL)) { ANT_ERROR("poll was called on invalid file descriptor %s. Attempting recovery.", stRxThreadInfo->astChannels[eChannel].pcDevicePath); doReset(stRxThreadInfo); goto out; } else if (areAllFlagsSet(astPollFd[eChannel].revents, POLLERR)) { ANT_ERROR("Unknown error from %s. Attempting recovery.", stRxThreadInfo->astChannels[eChannel].pcDevicePath); doReset(stRxThreadInfo); goto out; } else if (astPollFd[eChannel].revents) { ANT_DEBUG_W("unhandled poll result %#x from %s", astPollFd[eChannel].revents, stRxThreadInfo->astChannels[eChannel].pcDevicePath); } } // Now check for shutdown signal if(areAllFlagsSet(astPollFd[EVENTFD_IDX].revents, POLLIN)) { ANT_DEBUG_I("rx thread caught shutdown signal."); // reset the counter by reading. uint64_t counter; read(stRxThreadInfo->iRxShutdownEventFd, &counter, sizeof(counter)); // don't care if read error, going to close the thread anyways. stRxThreadInfo->ucRunThread = 0; } else if (astPollFd[EVENTFD_IDX].revents != 0) { ANT_ERROR("Shutdown event descriptor had unexpected event: %#x. exiting rx thread.", astPollFd[EVENTFD_IDX].revents); stRxThreadInfo->ucRunThread = 0; } } } /* disable ANT radio if not already disabling */ // Try to get stEnabledStatusLock. // if you get it then no one is enabling or disabling // if you can't get it assume something made you exit ANT_DEBUG_V("try getting stEnabledStatusLock in %s", __FUNCTION__); iMutexLockResult = pthread_mutex_trylock(stRxThreadInfo->pstEnabledStatusLock); if (!iMutexLockResult) { ANT_DEBUG_V("got stEnabledStatusLock in %s", __FUNCTION__); ANT_WARN("rx thread has unexpectedly crashed, cleaning up"); // spoof our handle as closed so we don't try to join ourselves in disable stRxThreadInfo->stRxThread = 0; if (g_fnStateCallback) { g_fnStateCallback(RADIO_STATUS_DISABLING); } ant_disable(); if (g_fnStateCallback) { g_fnStateCallback(ant_radio_enabled_status()); } ANT_DEBUG_V("releasing stEnabledStatusLock in %s", __FUNCTION__); pthread_mutex_unlock(stRxThreadInfo->pstEnabledStatusLock); ANT_DEBUG_V("released stEnabledStatusLock in %s", __FUNCTION__); } else if (iMutexLockResult != EBUSY) { ANT_ERROR("rx thread closing code, trylock on state lock failed: %s", strerror(iMutexLockResult)); } else { ANT_DEBUG_V("stEnabledStatusLock busy"); } out: ANT_FUNC_END(); #ifdef ANDROID return NULL; #endif }
ANTStatus ant_tx_message(ANT_U8 ucLen, ANT_U8 *pucMesg) { ANTStatus status; /* Socket for sending HCI commands */ int tx_socket = -1; int lockResult; ANT_FUNC_START(); ANT_DEBUG_V("getting txLock in %s", __FUNCTION__); lockResult = pthread_mutex_lock(&txLock); if (lockResult) { ANT_ERROR("ant_tx_message, could not get txLock: %s", strerror(lockResult)); return ANT_STATUS_FAILED; } ANT_DEBUG_V("got txLock in %s", __FUNCTION__); if(RADIO_STATUS_ENABLED != get_and_set_radio_status()) { ANT_DEBUG_E("ant_tx_message, ANT not enabled - ABORTING. Radio status = %d", radio_status); ANT_DEBUG_V("releasing txLock in %s", __FUNCTION__); pthread_mutex_unlock(&txLock); ANT_DEBUG_V("released txLock in %s", __FUNCTION__); return ANT_STATUS_FAILED_BT_NOT_INITIALIZED; } // Open socket tx_socket = ant_open_tx_transport(); if(tx_socket < 0) { ANT_ERROR("Could not open Tx socket"); ANT_DEBUG_V("releasing txLock in %s", __FUNCTION__); pthread_mutex_unlock(&txLock); ANT_DEBUG_V("released txLock in %s", __FUNCTION__); return ANT_STATUS_FAILED; } // Send HCI packet ANT_BOOL retryRx; ANT_BOOL retryTx; status = ANT_STATUS_FAILED; int MAX_RETRIES_WRITE_FAIL = 10; int MAX_RETRY_TIME_SECS = 10; int commandWriteFailRetries = 0; // Start New timed retry code: time_t startTime = time(NULL); time_t endTime = 0; if((time_t)-1 != startTime) { endTime = startTime + MAX_RETRY_TIME_SECS; } else { ANT_ERROR("failed to get current time"); } do // while (retryTx) { retryTx = ANT_FALSE; if(ANT_STATUS_SUCCESS == write_data(pucMesg, ucLen)) { do // while (retryRx) { retryRx = ANT_FALSE; if(ANT_TRUE == wait_for_message(tx_socket)) { ANT_DEBUG_D("New HCI data available, reading..."); status = get_command_complete_result(tx_socket); switch (status) { case ANT_STATUS_NO_VALUE_AVAILABLE: { ANT_WARN("Did not get an expected response for write, trying again"); retryRx = ANT_TRUE; break; } case ANT_STATUS_FAILED: { ANT_ERROR("Command Complete: ANT_STATUS_FAILED"); break; } case ANT_STATUS_COMMAND_WRITE_FAILED: { ANT_ERROR("Command Complete: ANT_STATUS_WRITE_FAILED"); if(++commandWriteFailRetries < MAX_RETRIES_WRITE_FAIL) { ANT_DEBUG_D("Retrying. Retry count = %d", commandWriteFailRetries); retryTx = ANT_TRUE; } else { ANT_ERROR("Aborting. Retry count = %d. Max retries = %d", commandWriteFailRetries, MAX_RETRIES_WRITE_FAIL); } break; } case ANT_STATUS_TRANSPORT_UNSPECIFIED_ERROR: { ANT_DEBUG_D("Command Complete: ANT_STATUS_UNSPECIFIED_ERROR"); // Give the chip a break before we try to resend data. nanosleep((struct timespec[]) { { 0, 50000000 } }, NULL); time_t currentTime = time(NULL); if((time_t)-1 != currentTime) { if(currentTime < endTime) { ANT_DEBUG_V("Retrying. Current time = %d. " "End time = %d", (int)currentTime, (int)endTime); retryTx = ANT_TRUE; } else { ANT_ERROR("Command Complete: ANT_STATUS_UNSPECIFIED_ERROR"); ANT_ERROR("Aborting. Current time = %d. End Time = %d", (int)currentTime, (int)endTime); } } else { ANT_ERROR("Command Complete: failed to get current time"); } break; } case ANT_STATUS_SUCCESS: { break; } default: { ANT_ERROR("Unhandled command complete status"); break; } } } else { ANT_WARN("Command Complete: wait for message failed"); } } while (retryRx);
ANTStatus ant_disable_radio(void) { int result; int lockResult; ANTStatus ret = ANT_STATUS_FAILED; ANT_FUNC_START(); ANT_DEBUG_V("getting enableLock in %s", __FUNCTION__); lockResult = pthread_mutex_lock(&enableLock); if(lockResult) { ANT_ERROR("Disable failed to get enableLock mutex: %s", strerror(lockResult)); return ANT_STATUS_FAILED; } ANT_DEBUG_V("got enableLock in %s", __FUNCTION__); ANT_DEBUG_V("getting txLock in %s", __FUNCTION__); lockResult = pthread_mutex_lock(&txLock); if (lockResult) { ANT_ERROR("Disable txLock failed: %s", strerror(lockResult)); pthread_mutex_unlock(&enableLock); return ANT_STATUS_FAILED; } ANT_DEBUG_V("got txLock in %s", __FUNCTION__); #if USE_EXTERNAL_POWER_LIBRARY if (get_and_set_radio_status() != RADIO_STATUS_DISABLED) { ANT_DEBUG_I("radio_status (%d -> %d)", radio_status, RADIO_STATUS_DISABLING); radio_status = RADIO_STATUS_DISABLING; if (RxParams.pfStateCallback) RxParams.pfStateCallback(radio_status); } result = ant_disable(); ANT_DEBUG_D("ant_disable() result is %d", result); #else radio_status = RADIO_STATUS_DISABLED; #endif // If rx thread exists ( != 0) if (RxParams.thread) { ANT_DEBUG_V("quit rx thread, joining"); pthread_join(RxParams.thread, NULL); RxParams.thread = 0; ANT_DEBUG_V("joined by rx thread"); } else { ANT_DEBUG_W("rx thread is 0 (not created?)"); } switch (get_and_set_radio_status()) { case RADIO_STATUS_DISABLED: ret = ANT_STATUS_SUCCESS; break; case RADIO_STATUS_ENABLED: ANT_ERROR("SERIOUS: ANT was disabled, rx thread quit, but ANT is enabled"); ret = ANT_STATUS_FAILED; break; default: ret = ANT_STATUS_NOT_DE_INITIALIZED; break; } ANT_DEBUG_V("releasing txLock in %s", __FUNCTION__); pthread_mutex_unlock(&txLock); ANT_DEBUG_V("released txLock in %s", __FUNCTION__); ANT_DEBUG_V("releasing enableLock in %s", __FUNCTION__); pthread_mutex_unlock(&enableLock); ANT_DEBUG_V("released enableLock in %s", __FUNCTION__); ANT_FUNC_END(); return ret; }
ANTStatus ant_enable_radio(void) { int result; int lockResult; ANTStatus result_status = ANT_STATUS_FAILED; ANT_FUNC_START(); ANT_DEBUG_V("getting enableLock in %s", __FUNCTION__); lockResult = pthread_mutex_lock(&enableLock); if(lockResult) { ANT_ERROR("Enable failed to get enableLock mutex: %s", strerror(lockResult)); return ANT_STATUS_FAILED; } ANT_DEBUG_V("got enableLock in %s", __FUNCTION__); if(RADIO_STATUS_DISABLED == radio_status) { radio_status = RADIO_STATUS_ENABLING; } ANT_DEBUG_V("getting txLock in %s", __FUNCTION__); lockResult = pthread_mutex_lock(&txLock); if (lockResult) { ANT_ERROR("Enable txLock failed: %s", strerror(lockResult)); pthread_mutex_unlock(&enableLock); return ANT_STATUS_FAILED; } ANT_DEBUG_V("got txLock in %s", __FUNCTION__); if (get_and_set_radio_status() != RADIO_STATUS_ENABLED) { if (RxParams.thread) { ANT_WARN("in enable call: rx thread still exists but radio crashed. trying to recover"); ANT_DEBUG_V("radio crashed, letting rx thread join"); pthread_join(RxParams.thread, NULL); RxParams.thread = 0; ANT_DEBUG_V("recovered. joined by rx thread"); } ANT_DEBUG_I("radio_status (%d -> %d)", radio_status, RADIO_STATUS_ENABLING); radio_status = RADIO_STATUS_ENABLING; #if USE_EXTERNAL_POWER_LIBRARY if (RxParams.pfStateCallback) RxParams.pfStateCallback(radio_status); #endif } #if USE_EXTERNAL_POWER_LIBRARY result = ant_enable(); ANT_DEBUG_D("ant_enable() result is %d", result); #else result = 0; #endif if (result == 0) { if (RxParams.thread) { result_status = ANT_STATUS_SUCCESS; radio_status = RADIO_STATUS_ENABLED; // sanity assign, cant be enabling ANT_DEBUG_D("ANT radio re-enabled"); } else { result = pthread_create(&RxParams.thread, NULL, ANTHCIRxThread, NULL); if (result) { ANT_ERROR("Thread initialization failed: %s", strerror(result)); result_status = ANT_STATUS_FAILED; } else { result_status = ANT_STATUS_SUCCESS; #if USE_EXTERNAL_POWER_LIBRARY if (radio_status == RADIO_STATUS_ENABLING) { ANT_DEBUG_I("radio_status (%d -> %d)", radio_status, RADIO_STATUS_ENABLED); radio_status = RADIO_STATUS_ENABLED; if (RxParams.pfStateCallback) RxParams.pfStateCallback(radio_status); } else { ANT_WARN("radio was already enabled but rx thread was not running"); } #else radio_status = RADIO_STATUS_ENABLED; #endif } } } else { result_status = ANT_STATUS_TRANSPORT_INIT_ERR; } if (result_status != ANT_STATUS_SUCCESS) // ant_enable() or rx thread creating failed { #if USE_EXTERNAL_POWER_LIBRARY ant_disable(); #endif switch (get_and_set_radio_status()) { case RADIO_STATUS_ENABLED: ANT_ERROR("SERIOUS: enable failed, but ANT is enabled without a rx thread"); break; default: ANT_DEBUG_D("Enable failed, after cleanup chip is not enabled"); break; } } ANT_DEBUG_V("releasing txLock in %s", __FUNCTION__); pthread_mutex_unlock(&txLock); ANT_DEBUG_V("released txLock in %s", __FUNCTION__); ANT_DEBUG_V("releasing enableLock in %s", __FUNCTION__); pthread_mutex_unlock(&enableLock); ANT_DEBUG_V("released enableLock in %s", __FUNCTION__); ANT_FUNC_END(); return result_status; }