Broke Android_System_package in to individual repositories

31 files changed, 5030 insertions, 1 deletions

diff --git a/Android.mk b/Android.mk
new file mode 100644
index 0000000..801a40c
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,70 @@
+#
+# Copyright (C) 2009 Dynastream Innovations
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+ifneq ($(BOARD_ANT_WIRELESS_DEVICE),)
+
+#
+# ANT native library
+#
+
+include $(CLEAR_VARS)
+
+ifeq ($(BOARD_ANT_WIRELESS_DEVICE),"wl12xx")
+
+include $(LOCAL_PATH)/hal/bluez_hci/Android.mk
+
+else ifeq ($(BOARD_ANT_WIRELESS_DEVICE),"chip-B")
+
+include $(LOCAL_PATH)/hal/chip-B/Android.mk
+
+else ifeq ($(BOARD_ANT_WIRELESS_DEVICE),"chip-C")
+
+include $(LOCAL_PATH)/hal/chip-C/Android.mk
+
+else
+
+$(error Unsupported BOARD_ANT_WIRELESS_DEVICE := $(BOARD_ANT_WIRELESS_DEVICE))
+
+endif # BOARD_ANT_WIRELESS_DEVICE type
+
+
+#
+# ANT Application
+#
+
+include $(CLEAR_VARS)
+
+LOCAL_C_INCLUDES:= \
+	$(LOCAL_PATH)/src/common/inc \
+	$(LOCAL_PATH)/app
+
+LOCAL_CFLAGS:= -g -c -W -Wall -O2
+
+LOCAL_SRC_FILES:= \
+	$(LOCAL_PATH)/app/ant_app.c
+
+LOCAL_SHARED_LIBRARIES := \
+	libantradio \
+	libcutils
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := debug
+LOCAL_MODULE:=antradio_app
+
+include $(BUILD_EXECUTABLE)
+
+
+endif # BOARD_ANT_WIRELESS_DEVICE defined
diff --git a/JAntNative.cpp b/JAntNative.cpp
new file mode 100644
index 0000000..2e3beb0
--- /dev/null
+++ b/JAntNative.cpp
@@ -0,0 +1,366 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*******************************************************************************\
+*
+*   FILE NAME:     JAntNative.cpp
+*
+*   BRIEF:
+*      This file provides the implementation of the native interface functions for ANT
+*
+*
+\*******************************************************************************/
+
+#include "android_runtime/AndroidRuntime.h"
+#include "jni.h"
+#include "nativehelper/JNIHelp.h"
+
+static JNIEnv *g_jEnv = NULL;
+static JavaVM *g_jVM = NULL;
+static jclass g_sJClazz;
+static jmethodID g_sMethodId_nativeCb_AntRxMessage;
+static jmethodID g_sMethodId_nativeCb_AntStateChange;
+
+extern "C"
+{
+   #include "ant_native.h"
+   #include "ant_log.h"
+   #undef LOG_TAG
+   #define LOG_TAG "JAntNative"
+
+   void nativeJAnt_RxCallback(ANT_U8 ucLen, ANT_U8* pucData);
+   void nativeJAnt_StateCallback(ANTRadioEnabledStatus uiNewState);
+}
+
+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;
+}
+
+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;
+}
+
+static jint nativeJAnt_Enable(JNIEnv *env, jobject obj)
+{
+   (void)env; //unused warning
+   (void)obj; //unused warning
+   ANT_FUNC_START();
+
+   ANTStatus status = ant_enable_radio();
+
+   ANT_FUNC_END();
+   return status;
+}
+
+static jint nativeJAnt_Disable(JNIEnv *env, jobject obj)
+{
+   (void)env; //unused warning
+   (void)obj; //unused warning
+   ANT_FUNC_START();
+
+   ANTStatus status = ant_disable_radio();
+
+   ANT_FUNC_END();
+   return status;
+}
+
+static jint nativeJAnt_GetRadioEnabledStatus(JNIEnv *env, jobject obj)
+{
+   (void)env; //unused warning
+   (void)obj; //unused warning
+   ANT_FUNC_START();
+
+   jint status = ant_radio_enabled_status();
+
+   ANT_FUNC_END();
+   return status;
+}
+
+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;
+}
+
+static jint nativeJAnt_HardReset(JNIEnv *env, jobject obj)
+{
+   (void)env; //unused warning
+   (void)obj; //unused warning
+   ANT_FUNC_START();
+
+   ANTStatus status = ant_radio_hard_reset();
+
+   ANT_FUNC_END();
+   return status;
+}
+
+extern "C"
+{
+
+   /**********************************************************************
+    *                              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;
+   }
+
+   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 JNINativeMethod g_sMethods[] =
+{
+   /* name, signature, funcPtr */
+   {"nativeJAnt_Create", "()I", (void*)nativeJAnt_Create},
+   {"nativeJAnt_Destroy", "()I", (void*)nativeJAnt_Destroy},
+   {"nativeJAnt_Enable", "()I", (void*)nativeJAnt_Enable},
+   {"nativeJAnt_Disable", "()I", (void*)nativeJAnt_Disable},
+   {"nativeJAnt_GetRadioEnabledStatus", "()I", (void*)nativeJAnt_GetRadioEnabledStatus},
+   {"nativeJAnt_TxMessage","([B)I", (void*)nativeJAnt_TxMessage},
+   {"nativeJAnt_HardReset", "()I", (void *)nativeJAnt_HardReset}
+};
+
+jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+   ANT_FUNC_START();
+   (void)reserved; //unused warning
+
+   g_jVM = vm;
+   if (g_jVM->GetEnv((void**) &g_jEnv, JNI_VERSION_1_4) != JNI_OK) {
+      ANT_ERROR("GetEnv failed");
+      return -1;
+   }
+   if (NULL == g_jEnv) {
+      ANT_ERROR("env is null");
+      return -1;
+   }
+
+   g_sJClazz = g_jEnv->FindClass("com/dsi/ant/core/JAntJava");
+   if (NULL == g_sJClazz) {
+      ANT_ERROR("could not find class \"com/dsi/ant/core/JAntJava\"");
+      return -1;
+   }
+
+   /* Save class information in global reference to prevent class unloading */
+   g_sJClazz = (jclass)g_jEnv->NewGlobalRef(g_sJClazz);
+
+   if (g_jEnv->RegisterNatives(g_sJClazz, g_sMethods, NELEM(g_sMethods)) != JNI_OK) {
+      ANT_ERROR("failed to register methods");
+      return -1;
+   }
+
+   g_sMethodId_nativeCb_AntRxMessage = g_jEnv->GetStaticMethodID(g_sJClazz,
+                                             "nativeCb_AntRxMessage", "([B)V");
+   if (NULL == g_sMethodId_nativeCb_AntRxMessage) {
+      ANT_ERROR("VerifyMethodId: Failed getting method id of \"void nativeCb_AntRxMessage(byte[])\"");
+      return -1;
+   }
+
+   g_sMethodId_nativeCb_AntStateChange = g_jEnv->GetStaticMethodID(g_sJClazz,
+                                             "nativeCb_AntStateChange", "(I)V");
+   if (NULL == g_sMethodId_nativeCb_AntStateChange) {
+      ANT_ERROR("VerifyMethodId: Failed getting method id of \"void nativeCb_AntStateChange(int)\"");
+      return -1;
+   }
+
+   ANT_FUNC_END();
+   return JNI_VERSION_1_4;
+}
+
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/NOTICE b/NOTICE
new file mode 100644
index 0000000..0dafa6b
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,5 @@
+ANT Android System Package
+Copyright 2009-2012 Dynastream Innovations
+
+This product includes software developed at
+Dynastream Innovations (http://www.dynastream.com/).
\ No newline at end of file
diff --git a/README.md b/README.md
index 5d4d917..2d7f30d 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,2 @@
-Linux_commandline-app
+Linux ANT HAL library
 =====================
\ No newline at end of file
diff --git a/app/ant_app.c b/app/ant_app.c
new file mode 100644
index 0000000..b0090ba
--- /dev/null
+++ b/app/ant_app.c
@@ -0,0 +1,326 @@
+/*
+ * ANT Stack testing appication
+ *
+ * Copyright 2009 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <pthread.h>
+#include <string.h>
+#include <errno.h>
+#include <math.h>
+#include <signal.h>
+
+#include "ant_native.h"
+#include "ant_types.h"
+#include "ant_log.h"
+#undef LOG_TAG
+#define LOG_TAG "antradio_app"
+
+/* transient stage */
+typedef ANTStatus ant_status;
+
+void app_ANT_rx_callback(ANT_U8 ucLen, ANT_U8* pucData);
+void app_ANT_state_callback(ANTRadioEnabledStatus uiNewState);
+
+static int Ant_Create(void)
+{
+    ANTStatus antStatus;
+
+    //register_antsig_handlers();
+
+   antStatus = ant_init();
+   if (antStatus)
+   {
+      printf("failed to init ANT rx stacki\n");
+      goto CLEANUP;
+   }
+
+   antStatus = set_ant_rx_callback(app_ANT_rx_callback);
+   if (antStatus)
+   {
+      printf("failed to set ANT rx callback");
+      goto CLEANUP;
+   }
+
+   antStatus = set_ant_state_callback(app_ANT_state_callback);
+   if (antStatus)
+   {
+      printf("failed to set ANT rx callback");
+      goto CLEANUP;
+   }
+   return antStatus;
+
+CLEANUP:
+   return ANT_STATUS_FAILED;
+}
+
+void ProcessCommand(char cCmd)
+{
+   ANT_U8 TxMessage[256];
+   switch (cCmd)
+   {
+      case 'V':
+         TxMessage[0] = 0x02;   //Size
+         TxMessage[1] = 0x4D;   //MESG_REQUEST_ID
+         TxMessage[2] = 0x00;   //Ch0
+         TxMessage[3] = 0x3E;
+         ant_tx_message(4,TxMessage);
+         break;
+      case 'R':
+         TxMessage[0] = 0x01;   //Size
+         TxMessage[1] = 0x4A;   //MESG_RESET_ID
+         TxMessage[2] = 0x00;   //Ch0
+         ant_tx_message(3,TxMessage);
+         break;
+      case 'K':
+         printf("Hard Reset returned: %d\n", ant_radio_hard_reset());
+         break;
+
+      case 'H':
+         //Normally we will not blindly send commands like this and actually check for responses before sending the next command, but this is just for a quick test.
+         ProcessCommand('R');   //Reset chip
+         ProcessCommand('A');   //Assign channel
+         ProcessCommand('F');   //Set RF Freq
+         ProcessCommand('I');   //Set Channel ID
+         ProcessCommand('P');   //Set Channel Period
+         ProcessCommand('O');   //Open Channel
+         break;
+
+      case 'A':
+         TxMessage[0] = 0x03;   //Size
+         TxMessage[1] = 0x42;   //MESG_ASSIGN_ID
+         TxMessage[2] = 0x00;   //Ch0
+         TxMessage[3] = 0x00;   //Assignment Params (Rx channel)
+         TxMessage[4] = 0x01;   //Network 1 (ANT+)
+         ant_tx_message(5,TxMessage);
+         break;
+
+      case 'F':
+         TxMessage[0] = 0x02;   //Size
+         TxMessage[1] = 0x45;   //MESG_CHANNEL_RADIO_FREQ_ID
+         TxMessage[2] = 0x00;   //Ch0
+         TxMessage[3] = 57;   //2.457GHz
+         ant_tx_message(4,TxMessage);
+         break;
+
+      case 'I':
+         TxMessage[0] = 0x05;   //Size
+         TxMessage[1] = 0x51;   //MESG_CHANNEL_ID_ID
+         TxMessage[2] = 0x00;   //Ch0
+         TxMessage[3] = 0x00;   //Wildcard Device Number
+         TxMessage[4] = 0x00;   //Wildcard Device Number
+         TxMessage[5] = 0x78;   //Set HRM Device Type
+         TxMessage[6] = 0x00;   //Wildcard Transmission Type
+         ant_tx_message(7,TxMessage);
+         break;
+
+      case 'P':
+         TxMessage[0] = 0x03;   //Size
+         TxMessage[1] = 0x43;   //MESG_CHANNEL_MESG_PERIOD_ID
+         TxMessage[2] = 0x00;   //Ch0
+         TxMessage[3] = 0x86;   //
+         TxMessage[4] = 0x1F;   // HRM MESG Peroid 0x1F86 (8070)
+         ant_tx_message(5,TxMessage);
+         break;
+
+      case 'O':
+         TxMessage[0] = 0x01;   //Size
+         TxMessage[1] = 0x4B;   //MESG_OPEN_CHANNEL__ID
+         TxMessage[2] = 0x00;   //Ch0
+         ant_tx_message(3,TxMessage);
+         break;
+      case 'E':
+         printf("Enable returned: %d\n", ant_enable_radio());
+         break;
+      case 'D':
+         printf("Disable returned: %d\n", ant_disable_radio());
+         break;
+      case 'S':
+         printf("State is: %d\n", ant_radio_enabled_status());
+         break;
+      case '1':
+         TxMessage[0] = 0x0A;   //Size
+         TxMessage[1] = 0x01;   //Enable
+         TxMessage[2] = 0x00;   //Code upload
+         TxMessage[3] = 0x00;
+         TxMessage[4] = 0x00;
+         TxMessage[5] = 0x00;
+         TxMessage[6] = 0x00;
+         TxMessage[7] = 0x00;
+         TxMessage[8] = 0x00;
+         TxMessage[9] = 0x00;
+         TxMessage[10] = 0x00;
+         //ANT_CORE_Send_VS_Command(0xFDD0, 11, TxMessage);
+         printf("Not Implemented\n");
+         break;
+
+      case '2':
+         TxMessage[0] = 0x00;   //Size
+         //ANT_CORE_Send_VS_Command(0xFF22, 1, TxMessage);
+         printf("Not Implemented\n");
+         break;
+
+
+      case 'X':
+         printf("Exiting\n");
+         break;
+
+      default:
+         printf("Invalid command: %#02x\n", cCmd);
+         break;
+   }
+}
+
+
+void app_ANT_rx_callback(ANT_U8 ucLen, ANT_U8* pucData)
+{
+   ANT_U8 i;
+
+   for(i=0; i <ucLen; i++)
+      printf("[%02X]",pucData[i]);
+   switch (pucData[1])
+   {
+      case 0x3E:
+         printf(" ANT FW Version:%s\n", &(pucData[2]));
+         break;
+      case 0x6F:
+         printf(" Chip Reset\n");
+         break;
+      case 0x40:
+         if (pucData[3] != 0x01)
+         {
+            printf(" Response (Ch:%d Mesg:%02X) ", pucData[2], pucData[3]);
+            if (pucData[4] == 0)
+               printf("Success\n");
+            else
+               printf("Error - %02X\n", pucData[4]);
+         }
+         else
+         {
+            printf(" Event (Ch:%d) %02X\n", pucData[2], pucData[4]);
+         }
+         break;
+      case 0x4E:
+         if (pucData[2] == 0)  //we are using channel 0 for HRM
+         {
+            // We are just assuming this is a HRM message and pulling the BPM out, refer to the ANT+ HRM profile documentation for proper/complete decoding instructions.
+            printf(" BPM: %u\n", pucData[10]);
+         }
+         break;
+
+      default:
+
+         break;
+   }
+   return;
+}
+
+void app_ANT_state_callback(ANTRadioEnabledStatus uiNewState)
+{
+   const char *pcState;
+   switch (uiNewState) {
+   case RADIO_STATUS_UNKNOWN:
+      pcState = "UNKNOWN";
+      break;
+   case RADIO_STATUS_ENABLING:
+      pcState = "ENABLING";
+      break;
+   case RADIO_STATUS_ENABLED:
+      pcState = "ENABLED";
+      break;
+   case RADIO_STATUS_DISABLING:
+      pcState = "DISABLING";
+      break;
+   case RADIO_STATUS_DISABLED:
+      pcState = "DISABLED";
+      break;
+   case RADIO_STATUS_NOT_SUPPORTED:
+      pcState = "NOT SUPPORTED";
+      break;
+   case RADIO_STATUS_SERVICE_NOT_INSTALLED:
+      pcState = "SERVICE NOT INSTALLED";
+      break;
+   case RADIO_STATUS_SERVICE_NOT_CONNECTED:
+      pcState = "SERVICE NOT CONNECTED";
+      break;
+   case RADIO_STATUS_RESETTING:
+      pcState = "RESETTING";
+      break;
+   case RADIO_STATUS_RESET:
+      pcState = "RESET";
+      break;
+   default:
+      printf("State change to: %d is an undefined state\n", uiNewState);
+      return;
+   }
+   printf("State change to: %s\n", pcState);
+}
+
+int main(void)
+{
+   char buffer[1024];
+   int ret = 0;
+
+   if (Ant_Create())
+   {
+      printf("failed to init ANT\n");
+      goto out;
+   }
+
+   printf("===ANT Test===\n");
+   printf("Using libantradio version:\n");
+   printf("%s\n", ant_get_lib_version());
+   printf("\n");
+   printf("Press V to get Version\n");
+   printf("Press R to Reset\n");
+   printf("Press K to hard reset\n");
+   printf("Press H to setup an ANT+ HRM rx channel\n");
+   printf("\n");
+   printf("Press A to Assign channel\n");
+   printf("Press F to set radio Frequency\n");
+   printf("Press I to set channel Id\n");
+   printf("Press P to set channel Peroid\n");
+   printf("Press O to Open channel\n");
+   printf("\n");
+   printf("Press E to Enable ANT\n");
+   printf("Press D to Disable ANT\n");
+   printf("Press S to get State\n");
+   printf("\n");
+   printf("Press X to eXit\n");
+
+   while (1)
+   {
+      memset(&buffer,0,sizeof(buffer));
+      fgets(buffer, sizeof(buffer), stdin);
+      ProcessCommand(buffer[0]);
+      if (buffer[0] == 'X')
+         goto done;
+   }
+
+done:
+   ProcessCommand('R');
+   sleep(1);
+   ProcessCommand('D');
+   ant_deinit();
+
+
+out:
+   return ret;
+}
+
diff --git a/app/ant_app.h b/app/ant_app.h
new file mode 100644
index 0000000..1806975
--- /dev/null
+++ b/app/ant_app.h
@@ -0,0 +1,25 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and  
+ * limitations under the License.
+ */
+
+
+#ifndef __ANT_APP_H
+#define __ANT_APP_H
+
+
+
+#endif
diff --git a/src/bluez_hci/Android.mk b/src/bluez_hci/Android.mk
new file mode 100644
index 0000000..0320a39
--- /dev/null
+++ b/src/bluez_hci/Android.mk
@@ -0,0 +1,67 @@
+#
+# Copyright (C) 2009 Dynastream Innovations
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+ifeq ($(BOARD_ANT_WIRELESS_DEVICE),"wl12xx")
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_CFLAGS := -g -c -W -Wall -O2
+
+# Check which chip is used so correct values in messages
+ifeq ($(BOARD_ANT_WIRELESS_DEVICE),"wl12xx")
+LOCAL_CFLAGS += -DBOARD_ANT_DEVICE_WILINK
+endif # BOARD_ANT_WIRELESS_DEVICE = wl12xx
+
+LOCAL_C_INCLUDES := \
+   $(LOCAL_PATH)/../common/inc \
+   $(LOCAL_PATH)/inc \
+   system/bluetooth/bluez-clean-headers \
+
+ifeq ($(BOARD_ANT_WIRELESS_POWER),"bluedroid")
+LOCAL_CFLAGS += -DBOARD_HAVE_ANT_WIRELESS
+LOCAL_C_INCLUDES += system/bluetooth/bluedroid/include/bluedroid
+endif # BOARD_ANT_WIRELESS_POWER = bluedroid
+
+LOCAL_C_INCLUDE += $(JNI_H_INCLUDE)
+
+LOCAL_SRC_FILES := \
+   ../../JAntNative.cpp \
+   ../common/ant_utils.c \
+   ant_native_hci.c \
+   ant_rx.c \
+   ant_tx.c \
+
+# jni
+LOCAL_SHARED_LIBRARIES +=  \
+   libnativehelper \
+
+# chip power
+LOCAL_SHARED_LIBRARIES += \
+   libbluedroid \
+
+# logging
+LOCAL_SHARED_LIBRARIES += \
+   libcutils \
+
+LOCAL_MODULE_TAGS := optional
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libantradio
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif # BOARD_ANT_WIRELESS_DEVICE = "wl12xx"
+
diff --git a/src/bluez_hci/ant_native_hci.c b/src/bluez_hci/ant_native_hci.c
new file mode 100644
index 0000000..4650f62
--- /dev/null
+++ b/src/bluez_hci/ant_native_hci.c
@@ -0,0 +1,823 @@
+/*
+* ANT Stack
+*
+* Copyright 2009 Dynastream Innovations
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+/******************************************************************************\
+*
+*   FILE NAME:      ant_native_hci.c
+*
+*   BRIEF:
+*        This file provides the HCI implementation of ant_native.h
+*
+*
+\******************************************************************************/
+
+#include <pthread.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "antradio_power.h"
+
+#include "ant_types.h"
+#include "ant_native.h"
+#include "ant_utils.h"
+#include "ant_version.h"
+
+#include "ant_rx.h"
+#include "ant_tx.h"
+#include "ant_hciutils.h"
+#include "ant_log.h"
+
+static pthread_mutex_t         txLock;
+pthread_mutex_t                enableLock;
+
+static ANTRadioEnabledStatus radio_status = RADIO_STATUS_DISABLED;
+ANTRadioEnabledStatus get_and_set_radio_status(void);
+
+////////////////////////////////////////////////////////////////////
+//  ant_init
+//
+//  Initialises the native environment.
+//
+//  Parameters:
+//      -
+//
+//  Returns:
+//      Success:
+//          ANT_STATUS_SUCCESS
+//      Failures:
+//          ANT_STATUS_FAILED if could not initialize mutex
+//
+//  Psuedocode:
+/*
+LOCK antdevice_LOCK
+    CREATE mutex for locking Tx attempt
+    IF could not create mutex
+        RESULT = ANT_STATUS_FAILED
+    ELSE
+        CREATE mutex for locking enable/disable
+        IF could not create mutex
+            RESULT = ANT_STATUS_FAILED
+        ELSE
+            RESULT = ANT_STATUS_SUCCESS
+        ENDIF
+    ENDIF
+UNLOCK
+*/
+////////////////////////////////////////////////////////////////////
+ANTStatus ant_init(void)
+{
+   int mutexResult;
+   ANTStatus status = ANT_STATUS_FAILED;
+   ANT_FUNC_START();
+
+   mutexResult = pthread_mutex_init(&txLock, NULL); //use default attr
+   if (mutexResult)
+   {
+      ANT_ERROR("Tx Lock mutex initialization failed: %s", strerror(mutexResult));
+   }
+   else
+   {
+      mutexResult = pthread_mutex_init(&enableLock, NULL);
+      if (mutexResult)
+      {
+         ANT_ERROR("Enable Lock mutex init failed %s", strerror(mutexResult));
+      }
+      else
+      {
+         status = ANT_STATUS_SUCCESS;
+      }
+   }
+
+   ANT_FUNC_END();
+   return status;
+}
+
+
+////////////////////////////////////////////////////////////////////
+//  ant_deinit
+//
+//  De-initialises the native environment.
+//
+//  Parameters:
+//      -
+//
+//  Returns:
+//      Success:
+//          ANT_STATUS_SUCCESS
+//      Failures:
+//          ANT_STATUS_FAILED if could not de-initialize mutex
+//
+//  Psuedocode:
+/*
+LOCK antdevice_LOCK (also Init and Tx)
+    DESTROY mutex for locking Tx attempt
+    IF could not destroy mutex
+        RESULT = ANT_STATUS_FAILED
+    ELSE
+        DESTROY mutex for locking enable/disable
+        IF coult not destroy mutex
+            RESULT = ANT_STATUS_FAILED
+        ELSE
+            RESULT = ANT_STATUS_SUCCESS
+        ENDIF
+    ENDIF
+UNLOCK
+*/
+////////////////////////////////////////////////////////////////////
+ANTStatus ant_deinit(void)
+{
+   int mutexResult;
+   ANTStatus result_status = ANT_STATUS_FAILED;
+   ANT_FUNC_START();
+
+   mutexResult = pthread_mutex_destroy(&txLock);
+   if (mutexResult)
+   {
+      ANT_ERROR("Tx Lock mutex destroy failed: %s", strerror(mutexResult));
+   }
+   else
+   {
+      mutexResult = pthread_mutex_destroy(&enableLock);
+      if (mutexResult)
+      {
+         ANT_ERROR("Enable Lock mutex destroy failed: %s", strerror(mutexResult));
+      }
+      else
+      {
+         result_status = ANT_STATUS_SUCCESS;
+      }
+   }
+
+   ANT_FUNC_END();
+   return result_status;
+}
+
+
+////////////////////////////////////////////////////////////////////
+//  ant_enable_radio
+//
+//  Powers on the ANT part and initialises the transport to the chip.
+//  Changes occur in part implementing ant_enable() call
+//      On Android this is in the Bluedroid module.
+//      On Linux this is device specific
+//
+//  Parameters:
+//      -
+//
+//  Returns:
+//      Success:
+//          ANT_STATUS_SUCCESS
+//      Failures:
+//          ANT_STATUS_TRANSPORT_INIT_ERR if could not enable
+//          ANT_STATUS_FAILED if failed to get mutex or init rx thread
+//
+//  Psuedocode:
+/*
+LOCK enable_LOCK
+    LOCK tx_LOCK
+        IF state is not enabled
+            STATE = ENABLING
+        ENDIF
+        ant enable
+        IF ant_enable success
+            IF rx thread is running
+                STATE = ENABLED
+                RESULT = SUCCESS
+            ELSE
+                start rx thread
+                IF starting rx thread fails
+                    ant disable
+                    get state
+                    IF state is enabled
+                        log a serious error
+                    ENDIF
+                    RESULT = FAILED
+                ELSE
+                    STATE = ENABLED
+                    RESULT = SUCCESS
+                ENDIF
+            ENDIF
+        ELSE
+            get state
+            IF state is enabled
+                log a serious error
+            ENDIF
+            RESULT = FAILURE
+        ENDIF
+    UNLOCK
+UNLOCK
+*/
+////////////////////////////////////////////////////////////////////
+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__);
+
+   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 (RxParams.pfStateCallback)
+         RxParams.pfStateCallback(radio_status);
+   }
+
+   result = ant_enable();
+   ANT_DEBUG_D("ant_enable() result is %d", result);
+   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 (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
+   {
+      result_status = ANT_STATUS_TRANSPORT_INIT_ERR;
+   }
+
+   if (result_status != ANT_STATUS_SUCCESS)
+   {
+      ant_disable();
+
+      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;
+}
+
+ANTStatus ant_radio_hard_reset(void)
+{
+   ANTStatus result_status = ANT_STATUS_NOT_SUPPORTED;
+   ANT_FUNC_START();
+   ANT_FUNC_END();
+   return result_status;
+}
+
+////////////////////////////////////////////////////////////////////
+//  ant_disable_radio
+//
+//  Disables the HCI transport and powers off the ANT part.
+//
+//  Parameters:
+//      -
+//
+//  Returns:
+//      Success:
+//          ANT_STATUS_SUCCESS
+//      Failures:
+//          ANT_STATUS_FAILED if could not get mutex
+//          ANT_STATUS_NOT_DE_INITIALIZED if ant_disable failed
+//
+//  Psuedocode:
+/*
+LOCK enable_LOCK
+    LOCK tx_LOCK
+        IF not disabled
+            STATE = DISABLING
+        ENDIF
+        ant disable
+        IF rx thread is running
+            wait for rx thread to terminate
+        ENDIF
+        get radio status
+        IF radio is disabled
+            RESULT = SUCCESS
+        ELSE IF radio is enabled
+            log a serious error
+            RESULT = FAILURE
+        ELSE
+            RESULT = FAILURE
+        ENDIF
+    UNLOCK
+UNLOCK
+*/
+////////////////////////////////////////////////////////////////////
+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 (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);
+
+   // 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;
+}
+
+
+////////////////////////////////////////////////////////////////////
+//  ant_radio_enabled_status
+//
+//  Returns if the chip/transport is disabled/disabling/enabling/enabled. This
+//  function will NOT overwrite internal state variable enabling or disabling.
+//  It will call get_and_set_radio_status() if not enabling/disabling which can
+//  change internal state on errors.
+//
+//  Parameters:
+//      -
+//
+//  Returns:
+//      The current radio status (ANTRadioEnabledStatus)
+//
+//  Psuedocode:
+/*
+IF Enabling
+    RESULT = Enabling
+ELSE IF Disabling
+    RESULT = Disabling
+ELSE
+    IF ant_is_enabled
+        Enabled
+        RESULT = Enabled
+    ELSE
+        Disabled
+        RESULT = Disabled
+    ENDIF
+ENDIF
+*/
+////////////////////////////////////////////////////////////////////
+ANTRadioEnabledStatus ant_radio_enabled_status(void)
+{
+   ANT_FUNC_START();
+
+   if ((RADIO_STATUS_ENABLING != radio_status) &&
+         (RADIO_STATUS_DISABLING != radio_status))
+   {
+      get_and_set_radio_status();
+   }
+
+   ANT_FUNC_END();
+   return radio_status;
+}
+
+////////////////////////////////////////////////////////////////////
+//  get_and_set_radio_status
+//
+//  Returns if the chip/transport is disabled/enabled/unknown This function WILL
+//  overwrite what it thinks the state is with what the BlueZ core (kernel)
+//  thinks it is. It will overwrite enabling or disabling states, and might
+//  change internal state from enabled, disabled, or unknown to any of these
+//  three on errors.
+//
+//  Paramerters:
+//      -
+//
+//  Returns:
+//      The current radio status (ANTRadioEnabledStatus)
+//
+////////////////////////////////////////////////////////////////////
+ANTRadioEnabledStatus get_and_set_radio_status(void)
+{
+   ANTRadioEnabledStatus orig_status = radio_status;
+   ANT_FUNC_START();
+
+   switch (ant_is_enabled())
+   {
+      case 0:
+         radio_status = RADIO_STATUS_DISABLED;
+         break;
+      case 1:
+         radio_status = RADIO_STATUS_ENABLED;
+         break;
+      default:
+         ANT_ERROR("getting chip state returned an error");
+         radio_status = RADIO_STATUS_UNKNOWN;
+         break;
+   }
+   if (orig_status != radio_status)
+   {
+      ANT_DEBUG_I("radio_status (%d -> %d)", orig_status, radio_status);
+
+      if (RxParams.pfStateCallback)
+         RxParams.pfStateCallback(radio_status);
+   }
+
+   ANT_FUNC_END();
+   return radio_status;
+}
+
+////////////////////////////////////////////////////////////////////
+//  set_ant_rx_callback
+//
+//  Sets which function to call when an ANT message is received.
+//
+//  Parameters:
+//      rx_callback_func   the ANTNativeANTEventCb function to be used
+//                         for recieved messages.
+//
+//  Returns:
+//          ANT_STATUS_SUCCESS
+//
+//  Psuedocode:
+/*
+    Rx Callback = rx_callback_func
+*/
+////////////////////////////////////////////////////////////////////
+ANTStatus set_ant_rx_callback(ANTNativeANTEventCb rx_callback_func)
+{
+   ANTStatus status = ANT_STATUS_SUCCESS;
+
+   ANT_FUNC_START();
+
+   RxParams.pfRxCallback = rx_callback_func;
+
+   ANT_FUNC_END();
+
+   return status;
+}
+
+////////////////////////////////////////////////////////////////////
+//  set_ant_state_callback
+//
+//  Sets which function to call when an ANT state change occurs.
+//
+//  Parameters:
+//      state_callback_func   the ANTNativeANTStateCb function to be used
+//                            for recieved state changes.
+//
+//  Returns:
+//          ANT_STATUS_SUCCESS
+//
+//  Psuedocode:
+/*
+    State Callback = state_callback_func
+*/
+////////////////////////////////////////////////////////////////////
+ANTStatus set_ant_state_callback(ANTNativeANTStateCb state_callback_func)
+{
+   ANTStatus status = ANT_STATUS_SUCCESS;
+
+   ANT_FUNC_START();
+
+   RxParams.pfStateCallback = state_callback_func;
+
+   ANT_FUNC_END();
+
+   return status;
+}
+
+////////////////////////////////////////////////////////////////////
+//  ant_tx_message
+//
+//  Sends an ANT message to the chip
+//
+//  Parameters:
+//      ucLen   the length of the message
+//      pucMesg pointer to the message data
+//
+//  Returns:
+//      Success:
+//          ANT_STATUS_SUCCESS
+//      Failure:
+//          ANT_STATUS_NOT_ENABLED
+//
+//  Psuedocode:
+/*
+IF not enabled
+    RESULT = NOT ENABLED
+ELSE
+    Lock
+    IF Lock failed
+        RESULT = FAILED
+    ELSE
+        STORE length (little endian) in send buffer
+        STORE data in send buffer
+    ENDIF
+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");
+                   
+                     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);
+      }
+      else
+      {
+         ANT_ERROR("write failed");
+         retryRx = ANT_FALSE;
+      
+         status = ANT_STATUS_FAILED;
+      }
+   } while(retryTx);
+   
+   ant_close_tx_transport(tx_socket);
+
+   ANT_DEBUG_V("releasing txLock in %s", __FUNCTION__);
+   pthread_mutex_unlock(&txLock);
+   ANT_DEBUG_V("released txLock in %s", __FUNCTION__);
+
+   ANT_FUNC_END();
+
+   return status;
+}
+
+const char *ant_get_lib_version()
+{
+   return "libantradio.so Bluez HCI Transport Version " 
+          LIBANT_STACK_MAJOR "." LIBANT_STACK_MINOR "." LIBANT_STACK_INCRE;
+}
+
diff --git a/src/bluez_hci/ant_rx.c b/src/bluez_hci/ant_rx.c
new file mode 100644
index 0000000..76d29ff
--- /dev/null
+++ b/src/bluez_hci/ant_rx.c
@@ -0,0 +1,275 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/******************************************************************************\
+*
+*   FILE NAME:      ant_rx.c
+*
+*   BRIEF:
+*      This file Implements the receive thread for an HCI implementation
+*      using Vendor Specific messages.
+*
+*
+\******************************************************************************/
+
+
+#define _GNU_SOURCE /* needed for PTHREAD_MUTEX_RECURSIVE */
+
+#include <errno.h>
+#include <poll.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <sys/resource.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/un.h>
+
+#include "antradio_power.h"
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+
+#include "ant_rx.h"
+#include "ant_hciutils.h"
+#include "ant_types.h"
+#include "ant_framing.h"
+#include "ant_log.h"
+#undef LOG_TAG
+#define LOG_TAG "antradio_rx"
+
+static char EVT_PKT_VENDOR_FILTER[] = {0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                                       0x00,0x00,0x00,0x80,0x00,0x05,0x00,0x00};
+
+/* Global Options */
+ANTHCIRxParams RxParams = {
+   .pfRxCallback = NULL,
+   .pfStateCallback = NULL,
+   .thread = 0
+};
+
+extern pthread_mutex_t enableLock;
+extern ANTRadioEnabledStatus get_and_set_radio_status(void);
+/*
+ * 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;
+   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;
+   }
+
+   if (setsockopt(rxSocket, SOL_HCI, HCI_FILTER, &EVT_PKT_VENDOR_FILTER,
+                                             sizeof(EVT_PKT_VENDOR_FILTER)) < 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;
+      }
+
+    // 0 = packet type eg. HCI_EVENT_PKT
+    // FOR EVENT:
+    //   1 = event code  eg. EVT_VENDOR, EVT_CMD_COMPLETE
+    //   2 = Parameter total length
+    //   3... parameters
+    //  FOR CC
+    //      3   = Num HCI Command packets allowed to be sent
+    //      4+5 = ANT Opcode
+    //      6   = Result ??
+    //   FOR VS
+    //     3+4 = ANT Opcode
+    //     5   = length
+    //     6 ? MSB of length ?
+    //     7... ant message
+
+      if (len >= 7)
+      {
+          ANT_DEBUG_V("HCI Data: [%02X][%02X][%02X][%02X][%02X][%02X][%02X]...",
+             buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
+      }
+      else
+      {
+         ANT_ERROR("Failed to read full header off socket. len = %d", len);
+         continue;
+      }
+
+      if (len != (buf[2] + 3))
+      {
+         ANT_WARN("HCI packet length(%d) and bytes read(%d) dont match", buf[2] + 3, len);
+      }
+
+      if(HCI_EVENT_PKT == buf[0])
+      {
+         ANT_DEBUG_D("Received Event Packet");
+
+         if (EVT_VENDOR == buf[1])
+         {
+            if ((HCI_VSOP_ANT_LSB == buf[3]) && (HCI_VSOP_ANT_MSB == buf[4]))
+            {
+               ANT_DEBUG_D("Received ANT VS Message");
+
+               if (len < 9)
+               {
+                  ANT_ERROR("Malformed ANT header");
+                  ret = ANT_STATUS_FAILED;
+                  goto close;
+               }
+
+               ANT_DEBUG_V("ANT Mesg: ANTMesgSize:%d ANTMesgID:0x%02X ...",
+                                                               buf[7], buf[8]);
+
+               ANT_SERIAL(&(buf[7]), buf[5], 'R');
+
+               if(RxParams.pfRxCallback != NULL)
+               {
+                  RxParams.pfRxCallback(buf[5], &(buf[7]));
+               }
+               else
+               {
+                  ANT_ERROR("Can't send rx message - no callback registered");
+               }
+
+               continue;
+            }
+            else
+            {
+               ANT_DEBUG_W("Vendor Specific message for another vendor. "
+                                                         "Should filter out");
+            }
+         }
+         else
+         {
+            ANT_DEBUG_V("Other Event Packet, Ignoring");
+         }
+      }
+      else
+      {
+         ANT_DEBUG_V("Non-Event Packet, Ignoring");
+      }
+   }
+
+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 (RxParams.pfStateCallback)
+         RxParams.pfStateCallback(RADIO_STATUS_DISABLING);
+      ant_disable();
+      get_and_set_radio_status();
+      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
+}
+
diff --git a/src/bluez_hci/ant_tx.c b/src/bluez_hci/ant_tx.c
new file mode 100644
index 0000000..2757a3b
--- /dev/null
+++ b/src/bluez_hci/ant_tx.c
@@ -0,0 +1,358 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/******************************************************************************\
+*
+*   FILE NAME:      ant_tx.c
+*
+*   BRIEF:
+*      This file Implements the transmit functionality for an HCI implementation
+*      using Vendor Specific messages.
+*
+*
+\******************************************************************************/
+
+#include <errno.h>
+#include <poll.h>
+#include <sys/uio.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+
+#include "ant_types.h"
+#include "ant_hciutils.h"
+#include "ant_framing.h"
+#include "ant_utils.h"
+#include "ant_log.h"
+#undef LOG_TAG
+#define LOG_TAG "antradio_tx"
+
+static char EVT_PKT_CMD_COMPLETE_FILTER[] = {0x10,0x00,0x00,0x00,0x00,0x40,0x00,
+                                 0x00,0x00,0x00,0x00,0x00,0xD1,0xFD,0x00,0x00};
+
+int g_ant_cmd_socket = -1;
+
+int ant_open_tx_transport(void)
+{
+   int socket = -1;
+   ANT_FUNC_START();
+
+   socket = create_hci_sock();
+   
+   if (socket < 0) 
+   {
+      ANT_DEBUG_E("failed to open HCI socket for tx: %s", strerror(errno));
+   }
+   else
+   {
+      g_ant_cmd_socket = socket;
+      ANT_DEBUG_D("socket handle %#x", g_ant_cmd_socket);
+      if (setsockopt(g_ant_cmd_socket, SOL_HCI, HCI_FILTER, 
+         &EVT_PKT_CMD_COMPLETE_FILTER, sizeof(EVT_PKT_CMD_COMPLETE_FILTER)) < 0)
+      {
+         ANT_ERROR("failed to set socket options: %s", strerror(errno));
+         close(socket);
+         socket = -1;
+      }
+   }
+
+   ANT_FUNC_END();
+   return socket;
+}
+
+void ant_close_tx_transport(int socket)
+{
+   ANT_FUNC_START();
+
+   if(0 < socket)
+   {
+      if (0 == close(socket)) 
+      {
+         ANT_DEBUG_D("closed hci device (socket handle=%#x)", socket);
+      }
+      else
+      {
+         ANT_ERROR("failed to close hci device (socket handle=%#x): %s", socket, strerror(errno));
+      }
+   }
+   else
+   {
+      ANT_DEBUG_E("requested close on socket %#x. invalid param", socket);
+   }
+
+   ANT_FUNC_END();
+}
+
+/* 
+Format of an HCI WRITE command to ANT chip:
+
+HCI Header:
+----------
+- HCI Packet Type:                                                      1 byte
+
+- HCI Opcode:                                                           2 bytes
+                                                               (LSB, MSB - LE)
+- HCI Parameters Total Len (total length of all subsequent fields):     1 byte
+
+HCI Parameters:
+--------------
+- VS Parameters Len (total length of ANT Mesg inculding Len/ID)         2 bytes
+                                                               (LSB, MSB - LE)
+- ANT Mesg Len (N = number of bytes in ANT Mesg Data):                  1 byte
+- ANT Mesg ID:                                                          1 byte
+- ANT Mesg Data:                                                        N bytes 
+*/
+
+ANT_BOOL wait_for_message(int socket)
+{
+   struct pollfd p;
+   int n;
+
+   ANT_BOOL bReturn = ANT_FALSE;
+   ANT_BOOL bRetry = ANT_FALSE;
+
+   ANT_FUNC_START();
+
+   p.fd = socket;
+   p.events = POLLIN;
+
+   do
+   {
+      bRetry = ANT_FALSE;
+   
+      ANT_DEBUG_V("    CC: Polling HCI for data...");
+   
+      /* poll socket, wait for ANT messages */
+      n = poll(&p, 1, 2500);
+      if (0 > n)
+      {
+         if (errno == EAGAIN || errno == EINTR)
+         {
+            ANT_DEBUG_W("    CC: error: %s", strerror(errno));
+            bRetry = ANT_TRUE;
+         }
+         else
+         {
+            ANT_ERROR("failed to poll socket. error: %s", strerror(errno));
+         }
+      }
+
+      /* timeout */
+      else if (0 == n)
+      {
+         ANT_ERROR("SERIOUS: Timeouted getting Command Complete");
+      }
+      else if(0 < n)
+      {
+         // There is data to read.
+         bReturn = ANT_TRUE;
+      }
+
+   } while(ANT_TRUE == bRetry);
+
+   ANT_FUNC_END();
+   
+   return bReturn;
+}
+
+ANTStatus write_data(ANT_U8 ant_message[], int ant_message_len)
+{
+   ANTStatus ret = ANT_STATUS_FAILED;
+   ANT_BOOL retry = ANT_FALSE;
+   int bytes_written;
+   struct iovec iov[2];
+   hci_vendor_cmd_packet_t hci_header;
+   ANT_U16 hci_opcode;
+
+   ANT_FUNC_START();
+
+   hci_opcode = cmd_opcode_pack(OGF_VENDOR_CMD, HCI_CMD_ANT_MESSAGE_WRITE);
+
+   hci_header.packet_type = HCI_COMMAND_PKT;
+   ANT_UTILS_StoreLE16(hci_header.cmd_header.opcode, hci_opcode);
+   hci_header.cmd_header.plen = ((ant_message_len + HCI_VENDOR_HEADER_SIZE) & 0xFF);
+   ANT_UTILS_StoreLE16(hci_header.vendor_header.hcilen, ant_message_len);
+
+   iov[0].iov_base = &hci_header;
+   iov[0].iov_len = sizeof(hci_header);
+   iov[1].iov_base = ant_message;
+   iov[1].iov_len = ant_message_len;
+
+   do //while retry
+   {
+      retry = ANT_FALSE;
+
+      if (g_ant_cmd_socket < 0)
+      {
+         ANT_DEBUG_E("bad socket handle %#x", g_ant_cmd_socket);
+         return ANT_STATUS_INTERNAL_ERROR;
+      }
+
+      ANT_SERIAL(ant_message, ant_message_len, 'T');
+
+      bytes_written = writev(g_ant_cmd_socket, iov, 2);
+
+      ANT_DEBUG_D("writing to socket %#x returned %d", g_ant_cmd_socket, 
+                                                               bytes_written);
+
+//      bytes_written < 0                   = error (check errno)
+//      bytes_written = 0                   = No data written
+//      bytes_written < sizeof(hci_message) = not all data written
+//      bytes_written = sizeof(hci_message) = all data written
+
+      if(bytes_written < 0)
+      {
+         ANT_ERROR("write to HCI failed: %s", strerror(errno));
+
+         if (errno == EAGAIN || errno == EINTR)
+         {
+            ANT_DEBUG_D("Retrying write to HCI");
+            retry = ANT_TRUE;
+         }
+         else
+         {
+            ret = ANT_STATUS_FAILED;
+         }
+      }
+      else if(bytes_written < ((int)sizeof(hci_header) + ant_message_len))
+      {
+         ANT_DEBUG_D("Only %d bytes written to HCI.", bytes_written);
+         ret = ANT_STATUS_FAILED;
+      }
+      else
+      {
+         ANT_DEBUG_V("writev successful");
+         ret = ANT_STATUS_SUCCESS;
+      }
+   } while(retry);
+
+   ANT_FUNC_END();
+ 
+   return ret;
+}
+
+// Returns:
+//  ANT_STATUS_NO_VALUE_AVAILABLE          if not a CC packet
+//  ANT_STATUS_FAILED                      if could not read socket or not a 
+//                                                       valid length CC packet
+//  ANT_STATUS_TRANSPORT_UNSPECIFIED_ERROR if CC indicates an unspecified error
+//  ANT_STATUS_COMMAND_WRITE_FAILED        if CC indicates a failure
+//  ANT_STATUS_SUCCESS                     if CC indicates message was received 
+ANTStatus get_command_complete_result(int socket)
+{
+   ANTStatus status = ANT_STATUS_NO_VALUE_AVAILABLE;
+   int len;
+   ANTStatus ret = ANT_STATUS_SUCCESS;
+   ANT_U8 ucResult = -1;
+   ANT_U8 buf[ANT_NATIVE_MAX_PARMS_LEN];
+
+   ANT_FUNC_START();
+   ANT_DEBUG_V("reading off socket %#x", socket);
+
+   /* read newly arrived data */
+   while ((len = read(socket, buf, sizeof(buf))) < 0)
+   {
+      if (errno == EAGAIN || errno == EINTR)
+         continue;
+
+      ANT_ERROR("failed to read socket. error: %s", strerror(errno));
+
+      ret = ANT_STATUS_FAILED;
+      goto close;
+   }
+
+   ANT_SERIAL(buf, len, 'C');
+
+   ANT_DEBUG_V("HCI Data: [%02X][%02X][%02X][%02X][%02X][%02X][%02X]...", 
+              buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
+
+   // 0 = packet type eg. HCI_EVENT_PKT
+   // FOR EVENT:
+   //   1 = event code  eg. EVT_VENDOR, EVT_CMD_COMPLETE
+   //   2 = Parameter total length
+   //   3... parameters
+   //  FOR CC
+   //      3   = Num HCI Vommand packets (allowed to be sent)
+   //      4+5 = ANT Opcode
+   //      6   = Result ??
+   //   FOR VS
+   //     3+4 = ANT Opcode
+   //     5   = length
+   //     6 ? MSB of length ?
+   //     7... ant message
+
+   if(HCI_EVENT_PKT == buf[0])
+   {
+      ANT_DEBUG_D("Received Event Packet");
+
+      if(EVT_CMD_COMPLETE == buf[1])
+      {
+         if(len < HCI_EVENT_OVERHEAD_SIZE) 
+         {
+            status = ANT_STATUS_FAILED;
+         }
+         else
+         {
+            if((HCI_CMD_OPCODE_ANT_LSB == buf[4]) && 
+                                         (HCI_CMD_OPCODE_ANT_MSB == buf[5]))
+            {
+               ucResult = buf[6];
+
+               ANT_DEBUG_V("Received COMMAND COMPLETE");
+            }
+            else
+            {
+               ANT_DEBUG_V("Command complete has wrong opcode");
+            }
+         }
+
+         /*
+          * if got a status byte, pass it forward, otherwise pass a failure
+          * status
+          */
+         if(status != ANT_STATUS_FAILED)
+         {
+            if(ucResult == 0)
+            {
+               ANT_DEBUG_D("Command Complete = SUCCESS");
+               status = ANT_STATUS_SUCCESS;
+            }
+            else if(ucResult == HCI_UNSPECIFIED_ERROR)
+            {
+               ANT_DEBUG_D("Command Complete = UNSPECIFIED_ERROR");
+
+               status = ANT_STATUS_TRANSPORT_UNSPECIFIED_ERROR;
+            }
+            else
+            {
+               status = ANT_STATUS_COMMAND_WRITE_FAILED;
+               ANT_DEBUG_D("Command Complete = WRITE_FAILED");
+            }
+         }
+      }
+      else
+      {
+         ANT_DEBUG_W("Other Event Packet, Should filter out");
+      }
+   }
+
+close:
+   ANT_FUNC_END();
+   return status;
+}
+
diff --git a/src/bluez_hci/inc/ant_framing.h b/src/bluez_hci/inc/ant_framing.h
new file mode 100644
index 0000000..7d01844
--- /dev/null
+++ b/src/bluez_hci/inc/ant_framing.h
@@ -0,0 +1,50 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and  
+ * limitations under the License.
+ */
+/******************************************************************************\
+*
+*   FILE NAME:      ANT_Framing.h
+*
+*   BRIEF:          
+*		This file defines ANT specific HCI values used by the ANT chip.
+*
+*
+\******************************************************************************/
+
+#ifndef __ANT_HCIFRAMING_H
+#define __ANT_HCIFRAMING_H
+
+#ifdef BOARD_ANT_DEVICE_WILINK
+
+/* Number to used by the VS Parameters Len field */
+#define ANT_NATIVE_HCI_VS_PARMS_LEN_FIELD_LEN    (2)
+
+#define HCI_CMD_ANT_MESSAGE_WRITE                ((ANT_U16)0x01D1)
+
+#define HCI_CMD_OPCODE_ANT_LSB                   0xD1
+#define HCI_CMD_OPCODE_ANT_MSB                   0xFD
+
+#define HCI_VSOP_ANT_LSB                         0x00
+#define HCI_VSOP_ANT_MSB                         0x05
+
+#else
+
+#error "Board ANT Device Type not recognised"
+
+#endif
+
+#endif /* __ANT_HCIFRAMING_H */
diff --git a/src/bluez_hci/inc/ant_hciutils.h b/src/bluez_hci/inc/ant_hciutils.h
new file mode 100644
index 0000000..f8cf579
--- /dev/null
+++ b/src/bluez_hci/inc/ant_hciutils.h
@@ -0,0 +1,121 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/******************************************************************************\
+*
+*   FILE NAME:      ant_hciuntils.h
+*
+*   BRIEF:
+*		This file defines the utility functions for an HCI implementation
+*
+*
+\******************************************************************************/
+
+#ifndef __ANT_HCIUTILS_H
+#define __ANT_HCIUTILS_H
+
+#include <errno.h>
+#include <sys/socket.h>
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+
+#include "ant_types.h"
+#include "ant_native.h"
+#include "ant_log.h"
+// -------------------------------------------------
+
+#define HCI_COMMAND_HEADER_SIZE 3
+typedef struct {
+   ANT_U8                     opcode[2];           // 0xFDD1 for ANT
+   ANT_U8                     plen;
+} __attribute__ ((packed)) hci_command_header_t;
+
+#define HCI_VENDOR_HEADER_SIZE 2
+typedef struct {
+   ANT_U8                  hcilen[2];
+} __attribute__ ((packed)) hci_vendor_header_t;
+
+#define HCI_COMMAND_OVERHEAD_SIZE ( HCI_COMMAND_HEADER_SIZE + \
+                                    HCI_VENDOR_HEADER_SIZE + 1)
+typedef struct {
+   ANT_U8                     packet_type;         // 0x01 for HCI_COMMAND_PKT
+   hci_command_header_t       cmd_header;
+   hci_vendor_header_t        vendor_header;
+} __attribute__ ((packed)) hci_vendor_cmd_packet_t;
+
+#define HCI_EVENT_HEADER_SIZE 2
+typedef struct {
+   ANT_U8                     event_c;             // 0xFF for Vendor Specific,
+                                                   // 0x0E for EVNT_CMD_COMPLETE
+   ANT_U8                     plen;                // data/parameter length
+} __attribute__ ((packed)) hci_event_header_t;
+
+#define HCI_EVENT_OVERHEAD_SIZE (HCI_EVENT_HEADER_SIZE + 5)
+typedef struct {
+   ANT_U8                     packet_type;         // HCI_EVENT_PKT
+   hci_event_header_t         header;
+   union {
+      struct {
+         ANT_U8               vendor_c[2];         // 0x0500 for ANT
+         ANT_U8               hcilen[2];
+      } vendor;
+      struct {
+         ANT_U8               num_token;
+         ANT_U8               opcode[2];           // 0xFDD1 for ANT
+         ANT_U8               resp;
+      } cmd_cmplt;
+   };
+   ANT_U8                     data[ANT_NATIVE_MAX_PARMS_LEN];  // Should be 255
+} __attribute__ ((packed)) hci_event_packet_t;
+
+typedef struct {
+   union {
+      hci_event_packet_t      hci_event_packet;
+      ANT_U8                  raw_packet[sizeof(hci_event_packet_t)];
+   };
+} rx_data_t;  // Use this is for vendor specific and command complete events
+
+
+// -------------------------------------------------
+
+static inline int create_hci_sock() {
+   struct sockaddr_hci sa;
+   int sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
+   if (sk < 0)
+   {
+      ANT_ERROR("Failed to create bluetooth hci socket: %s", strerror(errno));
+   }
+   else
+   {
+      memset(&sa, 0, sizeof(sa));
+      // sockaddr_hci changed from kernel 2.6.37 to 2.6.38 adding member hci_channel
+      // In order to be backwards compatible set it to 0 if it exists (HCI_CHANNEL_RAW)
+      sa.hci_family = AF_BLUETOOTH;
+      sa.hci_dev = 0;
+      if (bind(sk, (struct sockaddr *) &sa, sizeof(sa)) < 0)
+      {
+         ANT_ERROR("Failed to bind socket %#x to hci0: %s", sk, strerror(errno));
+         close(sk);
+         sk = -1;
+      }
+   }
+   return sk;
+}
+
+#endif /* __ANT_HCIUTILS_H */
+
+
diff --git a/src/bluez_hci/inc/ant_rx.h b/src/bluez_hci/inc/ant_rx.h
new file mode 100644
index 0000000..c914bb6
--- /dev/null
+++ b/src/bluez_hci/inc/ant_rx.h
@@ -0,0 +1,54 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/******************************************************************************\
+*
+*   FILE NAME:      ant_rx.h
+*
+*   BRIEF:
+*		This file defines the receive thread function
+*
+*
+\******************************************************************************/
+
+#ifndef __ANT_OS_H
+#define __ANT_OS_H
+
+#include <pthread.h>
+#include "ant_types.h"
+#include "ant_native.h"
+
+typedef struct
+{
+   //The function to call back with received data
+   ANTNativeANTEventCb pfRxCallback;
+
+   //The function to call back with state changes
+   ANTNativeANTStateCb pfStateCallback;
+
+   //The thread object itself
+   pthread_t thread;
+
+} ANTHCIRxParams;
+
+extern ANTHCIRxParams RxParams;
+
+//The message receive thread
+void* ANTHCIRxThread(void* pvHCIDevice);
+
+#endif  /* __ANT_OS_H */
+
diff --git a/src/bluez_hci/inc/ant_tx.h b/src/bluez_hci/inc/ant_tx.h
new file mode 100644
index 0000000..5057011
--- /dev/null
+++ b/src/bluez_hci/inc/ant_tx.h
@@ -0,0 +1,42 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/******************************************************************************\
+*
+*   FILE NAME:      ant_tx.h
+*
+*   BRIEF:
+*		This file defines the transmit function
+*
+*
+\******************************************************************************/
+
+#ifndef __ANT_TX_H
+#define __ANT_TX_H
+
+#include "ant_types.h"
+#include "ant_hciutils.h"
+
+int         ant_open_tx_transport(void);
+void        ant_close_tx_transport(int socket);
+ANT_BOOL    wait_for_message(int socket);
+ANTStatus   write_data(ANT_U8 ant_message[], int ant_message_len);
+
+ANTStatus get_command_complete_result(int socket);
+
+#endif /* __ANT_TX_H */
+
diff --git a/src/chip-B/Android.mk b/src/chip-B/Android.mk
new file mode 100644
index 0000000..5b030ff
--- /dev/null
+++ b/src/chip-B/Android.mk
@@ -0,0 +1,50 @@
+#
+# Copyright (C) 2011 Dynastream Innovations
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+ifeq ($(BOARD_ANT_WIRELESS_DEVICE),"chip-B")
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_CFLAGS := -g -c -W -Wall -O2
+
+LOCAL_C_INCLUDES := \
+    $(LOCAL_PATH)/../common/inc \
+    $(LOCAL_PATH)/inc \
+
+LOCAL_SRC_FILES:= \
+    ../../JAntNative.cpp \
+    ../common/ant_utils.c \
+    ant_native_chardev.c \
+    ant_rx_chardev.c \
+
+#JNI
+LOCAL_C_INCLUDE += $(JNI_H_INCLUDE)
+
+LOCAL_SHARED_LIBRARIES += \
+    libnativehelper
+
+# logging
+LOCAL_SHARED_LIBRARIES += \
+    libcutils
+
+LOCAL_MODULE_TAGS := optional
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libantradio
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif # BOARD_ANT_WIRELESS_DEVICE = "chip-B"
diff --git a/src/chip-B/ant_native_chardev.c b/src/chip-B/ant_native_chardev.c
new file mode 100644
index 0000000..39e61d7
--- /dev/null
+++ b/src/chip-B/ant_native_chardev.c
@@ -0,0 +1,424 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2011 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*******************************************************************************\
+*
+*   FILE NAME:     ant_native_chardev.c
+*
+*   BRIEF:
+*      This file provides the character device implementation of ant_native.h
+*
+*
+\*******************************************************************************/
+
+#include <errno.h>
+#include <fcntl.h> /* for open() */
+#include <linux/ioctl.h>
+#include <pthread.h>
+
+#include "ant_native.h"
+#include "ant_types.h"
+#include "ant_log.h"
+#include "ant_version.h"
+
+#include "ant_native_chardev.h"
+#include "ant_rx_chardev.h"
+
+#define CHIP_B_CHAR_DEV_IOCTL_RESET          _IO('H', 160)
+
+#define MESG_BROADCAST_DATA_ID               ((ANT_U8)0x4E)
+#define MESG_ACKNOWLEDGED_DATA_ID            ((ANT_U8)0x4F)
+#define MESG_BURST_DATA_ID                   ((ANT_U8)0x50)
+#define MESG_EXT_BROADCAST_DATA_ID           ((ANT_U8)0x5D)
+#define MESG_EXT_ACKNOWLEDGED_DATA_ID        ((ANT_U8)0x5E)
+#define MESG_EXT_BURST_DATA_ID               ((ANT_U8)0x5F)
+
+static ant_rx_thread_info_t stRxThreadInfo;
+static pthread_mutex_t stEnabledStatusLock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t stFlowControlLock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t stFlowControlCond = PTHREAD_COND_INITIALIZER;
+ANTNativeANTStateCb g_fnStateCallback;
+
+static void ant_channel_init(ant_channel_info_t *pstChnlInfo, const char *pcCharDevName)
+{
+   pstChnlInfo->pcDevicePath = pcCharDevName;
+   pstChnlInfo->iFd = -1;
+   pstChnlInfo->fnRxCallback = NULL;
+   pstChnlInfo->ucFlowControlResp = FLOW_GO;
+   pstChnlInfo->pstFlowControlCond = &stFlowControlCond;
+   pstChnlInfo->pstFlowControlLock = &stFlowControlLock;
+}
+
+ANTStatus ant_init(void)
+{
+   ANTStatus uiRet = ANT_STATUS_FAILED;
+   ANT_FUNC_START();
+   stRxThreadInfo.stRxThread = 0;
+   stRxThreadInfo.ucRunThread = 0;
+   stRxThreadInfo.ucChipResetting = 0;
+   stRxThreadInfo.pstEnabledStatusLock = &stEnabledStatusLock;
+   g_fnStateCallback = 0;
+   ant_channel_init(&stRxThreadInfo.astChannels[COMMAND_CHANNEL], ANT_COMMANDS_DEVICE_NAME);
+   ant_channel_init(&stRxThreadInfo.astChannels[DATA_CHANNEL], ANT_DATA_DEVICE_NAME);
+   uiRet = ANT_STATUS_SUCCESS;
+   ANT_FUNC_END();
+   return uiRet;
+}
+
+ANTStatus ant_deinit(void)
+{
+   ANTStatus uiRet = ANT_STATUS_FAILED;
+   ANT_FUNC_START();
+   uiRet = ANT_STATUS_SUCCESS;
+   ANT_FUNC_END();
+   return uiRet;
+}
+
+ANTStatus set_ant_rx_callback(ANTNativeANTEventCb rx_callback_func)
+{
+   ANT_FUNC_START();
+   stRxThreadInfo.astChannels[COMMAND_CHANNEL].fnRxCallback = rx_callback_func;
+   stRxThreadInfo.astChannels[DATA_CHANNEL].fnRxCallback = rx_callback_func;
+   ANT_FUNC_END();
+   return ANT_STATUS_SUCCESS;
+}
+
+ANTStatus set_ant_state_callback(ANTNativeANTStateCb state_callback_func)
+{
+   ANT_FUNC_START();
+   g_fnStateCallback = state_callback_func;
+   ANT_FUNC_END();
+   return ANT_STATUS_SUCCESS;
+}
+
+ANTStatus ant_tx_message(ANT_U8 ucLen, ANT_U8 *pucMesg)
+{
+   ANTStatus uiRet = ANT_STATUS_FAILED;
+   int iMutexResult;
+   int iResult;
+   struct timespec stTimeout;
+   int iCondWaitResult;
+   ANT_U8 txBuffer[ANT_HCI_MAX_MSG_SIZE];
+   ANT_FUNC_START();
+   if (ant_radio_enabled_status() != RADIO_STATUS_ENABLED) {
+      uiRet = ANT_STATUS_FAILED_BT_NOT_INITIALIZED;
+      goto out;
+   }
+   txBuffer[CHIP_B_HCI_SIZE_OFFSET] = ucLen;
+   memcpy(txBuffer + CHIP_B_HCI_HEADER_SIZE, pucMesg, ucLen);
+   ANT_SERIAL(txBuffer, ucLen + CHIP_B_HCI_HEADER_SIZE, 'T');
+   switch (txBuffer[CHIP_B_HCI_DATA_OFFSET + ANT_MSG_ID_OFFSET]) {
+   case MESG_BROADCAST_DATA_ID:
+   case MESG_ACKNOWLEDGED_DATA_ID:
+   case MESG_BURST_DATA_ID:
+   case MESG_EXT_BROADCAST_DATA_ID:
+   case MESG_EXT_ACKNOWLEDGED_DATA_ID:
+   case MESG_EXT_BURST_DATA_ID:
+      ANT_DEBUG_V("getting stFlowControlLock in %s", __FUNCTION__);
+      iMutexResult = pthread_mutex_lock(&stFlowControlLock);
+      if (iMutexResult) {
+         ANT_ERROR("failed to lock flow control mutex during tx: %s", strerror(iMutexResult));
+         goto out;
+      }
+      ANT_DEBUG_V("got stFlowControlLock in %s", __FUNCTION__);
+
+      stRxThreadInfo.astChannels[COMMAND_CHANNEL].ucFlowControlResp = FLOW_STOP;
+      iResult = write(stRxThreadInfo.astChannels[DATA_CHANNEL].iFd, txBuffer, ucLen + CHIP_B_HCI_HEADER_SIZE);
+      if (iResult < 0) {
+         ANT_ERROR("failed to write data message to device: %s", strerror(errno));
+      } else if (iResult != ucLen + CHIP_B_HCI_HEADER_SIZE) {
+         ANT_ERROR("bytes written and message size dont match up");
+      } else {
+         stTimeout.tv_sec = time(0) + CHIP_B_FLOW_GO_WAIT_TIMEOUT_SEC;
+         stTimeout.tv_nsec = 0;
+
+         while (stRxThreadInfo.astChannels[COMMAND_CHANNEL].ucFlowControlResp != FLOW_GO) {
+            iCondWaitResult = pthread_cond_timedwait(&stFlowControlCond, &stFlowControlLock, &stTimeout);
+            if (iCondWaitResult) {
+               ANT_ERROR("failed to wait for flow control response: %s", strerror(iCondWaitResult));
+               if (iCondWaitResult == ETIMEDOUT)
+                  uiRet = ANT_STATUS_HARDWARE_ERR;
+               goto wait_error;
+            }
+         }
+         uiRet = ANT_STATUS_SUCCESS;
+      }
+wait_error:
+      ANT_DEBUG_V("releasing stFlowControlLock in %s", __FUNCTION__);
+      pthread_mutex_unlock(&stFlowControlLock);
+      ANT_DEBUG_V("released stFlowControlLock in %s", __FUNCTION__);
+      break;
+   default:
+      iResult = write(stRxThreadInfo.astChannels[COMMAND_CHANNEL].iFd, txBuffer, ucLen + CHIP_B_HCI_HEADER_SIZE);
+      if (iResult < 0) {
+         ANT_ERROR("failed to write message to device: %s", strerror(errno));
+      }  else if (iResult != ucLen + CHIP_B_HCI_HEADER_SIZE) {
+         ANT_ERROR("bytes written and message size dont match up");
+      } else {
+         uiRet = ANT_STATUS_SUCCESS;
+      }
+   }
+out:
+   ANT_FUNC_END();
+   return uiRet;
+}
+
+ANTStatus ant_radio_hard_reset(void)
+{
+   enum ant_channel_type eChannel;
+   int iLockResult;
+   ANTStatus uiRet = ANT_STATUS_FAILED;
+   ANT_FUNC_START();
+   ANT_DEBUG_V("getting stEnabledStatusLock in %s", __FUNCTION__);
+   iLockResult = pthread_mutex_lock(&stEnabledStatusLock);
+   if(iLockResult) {
+      ANT_ERROR("enable failed to get state lock: %s", strerror(iLockResult));
+      goto out;
+   }
+   ANT_DEBUG_V("got stEnabledStatusLock in %s", __FUNCTION__);
+
+   stRxThreadInfo.ucChipResetting = 1;
+   if (g_fnStateCallback)
+      g_fnStateCallback(RADIO_STATUS_RESETTING);
+
+   for (eChannel = 0; eChannel < NUM_ANT_CHANNELS; eChannel++)
+      ioctl(stRxThreadInfo.astChannels[eChannel].iFd, CHIP_B_CHAR_DEV_IOCTL_RESET); //TODO only one?
+
+   ant_do_disable();
+
+   if (ant_do_enable()) { /* failed */
+      if (g_fnStateCallback)
+         g_fnStateCallback(RADIO_STATUS_DISABLED);
+   } else { /* success */
+      if (g_fnStateCallback)
+         g_fnStateCallback(RADIO_STATUS_RESET);
+      uiRet = ANT_STATUS_SUCCESS;
+   }
+   stRxThreadInfo.ucChipResetting = 0;
+
+   ANT_DEBUG_V("releasing stEnabledStatusLock in %s", __FUNCTION__);
+   pthread_mutex_unlock(&stEnabledStatusLock);
+   ANT_DEBUG_V("released stEnabledStatusLock in %s", __FUNCTION__);
+out:
+   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) {
+      if (close(pstChnlInfo->iFd) < 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) {
+      pstChnlInfo->iFd = open(pstChnlInfo->pcDevicePath, O_RDWR);
+      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;
+}
+
+int ant_do_enable(void)
+{
+   int iRet = -1;
+   enum ant_channel_type eChannel;
+   ANT_FUNC_START();
+
+   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;
+}
+
+void ant_do_disable(void)
+{
+   enum ant_channel_type eChannel;
+   ANT_FUNC_START();
+   stRxThreadInfo.ucRunThread = 0;
+   for (eChannel = 0; eChannel < NUM_ANT_CHANNELS; eChannel++)
+      ant_disable_channel(&stRxThreadInfo.astChannels[eChannel]);
+   if (stRxThreadInfo.stRxThread != 0) {
+      if (pthread_join(stRxThreadInfo.stRxThread, NULL) < 0) {
+         ANT_ERROR("failed to join rx thread: %s", strerror(errno));
+      }
+      stRxThreadInfo.stRxThread = 0;
+   } else {
+      ANT_DEBUG_D("rx thread is not running");
+   }
+   ANT_FUNC_END();
+}
+
+ANTStatus ant_enable_radio(void)
+{
+   int iLockResult;
+   ANTStatus uiRet = ANT_STATUS_FAILED;
+   ANT_FUNC_START();
+   ANT_DEBUG_V("getting stEnabledStatusLock in %s", __FUNCTION__);
+   iLockResult = pthread_mutex_lock(&stEnabledStatusLock);
+   if(iLockResult) {
+      ANT_ERROR("enable failed to get state lock: %s", strerror(iLockResult));
+      goto out;
+   }
+   ANT_DEBUG_V("got stEnabledStatusLock in %s", __FUNCTION__);
+
+   if (g_fnStateCallback)
+      g_fnStateCallback(RADIO_STATUS_ENABLING);
+
+   if (ant_do_enable() < 0) {
+      ANT_ERROR("ant enable failed: %s", strerror(errno));
+
+      ant_do_disable();
+
+      if (g_fnStateCallback)
+         g_fnStateCallback(ant_radio_enabled_status());
+   } else {
+      if (g_fnStateCallback)
+         g_fnStateCallback(RADIO_STATUS_ENABLED);
+      uiRet = ANT_STATUS_SUCCESS;
+   }
+
+   ANT_DEBUG_V("releasing stEnabledStatusLock in %s", __FUNCTION__);
+   pthread_mutex_unlock(&stEnabledStatusLock);
+   ANT_DEBUG_V("released stEnabledStatusLock in %s", __FUNCTION__);
+out:
+   ANT_FUNC_END();
+   return uiRet;
+}
+
+ANTStatus ant_disable_radio(void)
+{
+   int iLockResult;
+   ANTStatus uiRet = ANT_STATUS_FAILED;
+   ANT_FUNC_START();
+   ANT_DEBUG_V("getting stEnabledStatusLock in %s", __FUNCTION__);
+   iLockResult = pthread_mutex_lock(&stEnabledStatusLock);
+   if(iLockResult) {
+      ANT_ERROR("disable failed to get state lock: %s", strerror(iLockResult));
+      goto out;
+   }
+   ANT_DEBUG_V("got stEnabledStatusLock in %s", __FUNCTION__);
+
+   if (g_fnStateCallback)
+      g_fnStateCallback(RADIO_STATUS_DISABLING);
+
+   ant_do_disable();
+
+   if (g_fnStateCallback)
+      g_fnStateCallback(ant_radio_enabled_status());
+   uiRet = ANT_STATUS_SUCCESS;
+
+   ANT_DEBUG_V("releasing stEnabledStatusLock in %s", __FUNCTION__);
+   pthread_mutex_unlock(&stEnabledStatusLock);
+   ANT_DEBUG_V("released stEnabledStatusLock in %s", __FUNCTION__);
+out:
+   ANT_FUNC_END();
+   return uiRet;
+}
+
+ANTRadioEnabledStatus ant_radio_enabled_status(void)
+{
+   enum 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;
+}
+
+const char *ant_get_lib_version()
+{
+   return "libantradio.so: CHIP_B Character Device Transport. Version "
+      LIBANT_STACK_MAJOR"."LIBANT_STACK_MINOR"."LIBANT_STACK_INCRE;
+}
+
diff --git a/src/chip-B/ant_rx_chardev.c b/src/chip-B/ant_rx_chardev.c
new file mode 100644
index 0000000..c4aedac
--- /dev/null
+++ b/src/chip-B/ant_rx_chardev.c
@@ -0,0 +1,213 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2011 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*******************************************************************************\
+*
+*   FILE NAME:     ant_rx_chardev.c
+*
+*   BRIEF:
+*      This file provides the rx function which will loop reading ANT messages
+*        until told to exit.
+*
+*
+\*******************************************************************************/
+
+#include <errno.h>
+#include <poll.h>
+#include <pthread.h>
+
+#include "ant_rx_chardev.h"
+#include "ant_native_chardev.h"
+
+#include "ant_native.h"
+#include "ant_types.h"
+#include "ant_log.h"
+#undef LOG_TAG
+#define LOG_TAG "antradio_rx"
+
+#define ANT_POLL_TIMEOUT         ((int)30000)
+
+int readChannelMsg(ant_channel_info_t *pstChnlInfo)
+{
+   int iRet = -1;
+   ANT_U8 aucRxBuffer[ANT_HCI_MAX_MSG_SIZE];
+   int iRxLenRead;
+   int iMutexResult;
+   ANT_FUNC_START();
+
+   while (((iRxLenRead = read(pstChnlInfo->iFd, aucRxBuffer, sizeof(aucRxBuffer))) < 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, iRxLenRead, 'R');
+      if (aucRxBuffer[CHIP_B_HCI_DATA_OFFSET + ANT_MSG_ID_OFFSET] == ANT_MESG_FLOW_CONTROL) {
+         ANT_DEBUG_V("getting stFlowControlLock in %s", __FUNCTION__);
+         iMutexResult = pthread_mutex_lock(pstChnlInfo->pstFlowControlLock);
+         if (iMutexResult) {
+            ANT_ERROR("failed to lock flow control mutex during response: %s", strerror(iMutexResult));
+            goto out;
+         }
+         ANT_DEBUG_V("got stFlowControlLock in %s", __FUNCTION__);
+
+         pstChnlInfo->ucFlowControlResp = aucRxBuffer[CHIP_B_HCI_DATA_OFFSET + ANT_MSG_DATA_OFFSET];
+
+         ANT_DEBUG_V("releasing stFlowControlLock in %s", __FUNCTION__);
+         pthread_mutex_unlock(pstChnlInfo->pstFlowControlLock);
+         ANT_DEBUG_V("released stFlowControlLock in %s", __FUNCTION__);
+         pthread_cond_signal(pstChnlInfo->pstFlowControlCond);
+      } else {
+         if (pstChnlInfo->fnRxCallback != NULL) {
+            pstChnlInfo->fnRxCallback(aucRxBuffer[CHIP_B_HCI_SIZE_OFFSET], &aucRxBuffer[CHIP_B_HCI_DATA_OFFSET]);
+         } else {
+            ANT_WARN("%s rx callback is null", pstChnlInfo->pcDevicePath);
+         }
+      }
+      iRet = 0;
+   }
+out:
+   ANT_FUNC_END();
+   return iRet;
+}
+
+void *fnRxThread(void *ant_rx_thread_info)
+{
+   int iMutexLockResult;
+   int iPollRet;
+   ant_rx_thread_info_t *stRxThreadInfo;
+   struct pollfd astPollFd[NUM_ANT_CHANNELS];
+   enum 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 = POLLIN | POLLRDNORM;
+   }
+
+   while (stRxThreadInfo->ucRunThread) {
+      iPollRet = poll(astPollFd, NUM_ANT_CHANNELS, ANT_POLL_TIMEOUT);
+      if (!iPollRet) {
+         ANT_DEBUG_V("poll timed out, checking exit cond");
+      } else if (iPollRet < 0) {
+         ANT_ERROR("read thread exiting, unhandled error: %s", strerror(errno));
+      } else {
+         for (eChannel = 0; eChannel < NUM_ANT_CHANNELS; eChannel++) {
+            if (astPollFd[eChannel].revents & (POLLERR | POLLPRI | POLLRDHUP)) {
+               ANT_ERROR("poll error from %s. exiting rx thread",
+                            stRxThreadInfo->astChannels[eChannel].pcDevicePath);
+               /* Chip was reset or other error, only way to recover is to
+                * close and open ANT chardev */
+               stRxThreadInfo->ucChipResetting = 1;
+               if (g_fnStateCallback)
+                  g_fnStateCallback(RADIO_STATUS_RESETTING);
+               goto reset;
+
+            } else if (astPollFd[eChannel].revents & (POLLIN | POLLRDNORM)) {
+               ANT_DEBUG_D("data on %s. reading it",
+                            stRxThreadInfo->astChannels[eChannel].pcDevicePath);
+               if (readChannelMsg(&stRxThreadInfo->astChannels[eChannel]) < 0)
+                  goto out;
+            } else if (astPollFd[eChannel].revents) {
+               ANT_DEBUG_W("unhandled poll result %#x from %s",
+                            astPollFd[eChannel].revents,
+                            stRxThreadInfo->astChannels[eChannel].pcDevicePath);
+            }
+         }
+      }
+   }
+out:
+   stRxThreadInfo->ucRunThread = 0;
+   /* Try to get stEnabledStatusLock.
+    * if you get it then noone 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");
+      stRxThreadInfo->stRxThread = 0; /* spoof our handle as closed so we don't
+                                       * try to join ourselves in disable */
+
+      if (g_fnStateCallback)
+         g_fnStateCallback(RADIO_STATUS_DISABLING);
+
+      ant_do_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");
+   }
+   ANT_FUNC_END();
+#ifdef ANDROID
+   return NULL;
+#endif
+
+reset:
+   stRxThreadInfo->ucRunThread = 0;
+   ANT_DEBUG_V("getting stEnabledStatusLock in %s", __FUNCTION__);
+   iMutexLockResult = pthread_mutex_lock(stRxThreadInfo->pstEnabledStatusLock);
+   if (iMutexLockResult < 0) {
+      ANT_ERROR("chip was reset, getting state mutex failed: %s",
+            strerror(iMutexLockResult));
+      stRxThreadInfo->stRxThread = 0;
+   } else {
+      ANT_DEBUG_V("got stEnabledStatusLock in %s", __FUNCTION__);
+      stRxThreadInfo->stRxThread = 0; /* spoof our handle as closed so we don't
+                                       * try to join ourselves in disable */
+      ant_do_disable();
+
+      if (ant_do_enable()) { /* failed */
+         if (g_fnStateCallback)
+            g_fnStateCallback(RADIO_STATUS_DISABLED);
+      } else { /* success */
+         if (g_fnStateCallback)
+            g_fnStateCallback(RADIO_STATUS_RESET);
+      }
+      ANT_DEBUG_V("releasing stEnabledStatusLock in %s", __FUNCTION__);
+      pthread_mutex_unlock(stRxThreadInfo->pstEnabledStatusLock);
+      ANT_DEBUG_V("released stEnabledStatusLock in %s", __FUNCTION__);
+   }
+   stRxThreadInfo->ucChipResetting = 0;
+   ANT_FUNC_END();
+#ifdef ANDROID
+   return NULL;
+#endif
+}
+
diff --git a/src/chip-B/inc/ant_native_chardev.h b/src/chip-B/inc/ant_native_chardev.h
new file mode 100644
index 0000000..1173f08
--- /dev/null
+++ b/src/chip-B/inc/ant_native_chardev.h
@@ -0,0 +1,48 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2011 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*******************************************************************************\
+*
+*   FILE NAME:      ant_native_chardev.h
+*
+*   BRIEF:
+*       This file defines constants for the char dev implementation
+*
+*
+\*******************************************************************************/
+
+#ifndef __ANT_NATIVE_CHARDEV_H
+#define __ANT_NATIVE_CHARDEV_H
+
+#define ANT_COMMANDS_DEVICE_NAME             "/dev/antradio_cmd"
+#define ANT_DATA_DEVICE_NAME                 "/dev/antradio_data"
+
+#define CHIP_B_HCI_SIZE_OFFSET               0
+#define CHIP_B_HCI_DATA_OFFSET               1
+#define CHIP_B_HCI_HEADER_SIZE               1
+
+#define ANT_MESG_FLOW_CONTROL                ((ANT_U8)0xC9)
+#define FLOW_GO                              ((ANT_U8)0x00)
+#define FLOW_STOP                            ((ANT_U8)0x80)
+#define CHIP_B_FLOW_GO_WAIT_TIMEOUT_SEC      10
+
+int ant_do_enable(void);
+void ant_do_disable(void);
+extern ANTNativeANTStateCb g_fnStateCallback;
+
+#endif /* ifndef __ANT_NATIVE_CHARDEV_H */
+
diff --git a/src/chip-B/inc/ant_rx_chardev.h b/src/chip-B/inc/ant_rx_chardev.h
new file mode 100644
index 0000000..6721222
--- /dev/null
+++ b/src/chip-B/inc/ant_rx_chardev.h
@@ -0,0 +1,73 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2011 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*******************************************************************************\
+*
+*   FILE NAME:      ant_rx_chardev.h
+*
+*   BRIEF:
+*       This file defines public members in ant_rx_chardev.c
+*
+*
+\*******************************************************************************/
+
+#ifndef __ANT_RX_NATIVE_H
+#define __ANT_RX_NATIVE_H
+
+#include "ant_native.h"
+
+/* This struct defines the info passed to an rx thread */
+typedef struct {
+   /* Device path */
+   const char *pcDevicePath;
+   /* File descriptor to read from */
+   int iFd;
+   /* Callback to call with ANT packet */
+   ANTNativeANTEventCb fnRxCallback;
+   /* Flow control response if channel supports it */
+   ANT_U8 ucFlowControlResp;
+   /* Handle to flow control condition */
+   pthread_cond_t *pstFlowControlCond;
+   /* Handle to flow control mutex */
+   pthread_mutex_t *pstFlowControlLock;
+} ant_channel_info_t;
+
+enum ant_channel_type {
+   DATA_CHANNEL,
+   COMMAND_CHANNEL,
+   NUM_ANT_CHANNELS
+};
+
+typedef struct {
+   /* Thread handle */
+   pthread_t stRxThread;
+   /* Exit condition */
+   ANT_U8 ucRunThread;
+   /* Set state as resetting override */
+   ANT_U8 ucChipResetting;
+   /* Handle to state change lock for crash cleanup */
+   pthread_mutex_t *pstEnabledStatusLock;
+   /* ANT channels */
+   ant_channel_info_t astChannels[NUM_ANT_CHANNELS];
+} ant_rx_thread_info_t;
+
+/* This is the rx thread function. It loops reading ANT packets until told to
+ * exit */
+void *fnRxThread(void *ant_rx_thread_info);
+
+#endif /* ifndef __ANT_RX_NATIVE_H */
+
diff --git a/src/chip-C/Android.mk b/src/chip-C/Android.mk
new file mode 100644
index 0000000..1f75535
--- /dev/null
+++ b/src/chip-C/Android.mk
@@ -0,0 +1,50 @@
+#
+# Copyright (C) 2011 Dynastream Innovations
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+ifeq ($(BOARD_ANT_WIRELESS_DEVICE),"chip-C")
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_CFLAGS := -g -c -W -Wall -O2
+
+LOCAL_C_INCLUDES := \
+    $(LOCAL_PATH)/../common/inc \
+    $(LOCAL_PATH)/inc \
+
+LOCAL_SRC_FILES:= \
+    ../../JAntNative.cpp \
+    ../common/ant_utils.c \
+    ant_native_chardev.c \
+    ant_rx_chardev.c \
+
+#JNI
+LOCAL_C_INCLUDE += $(JNI_H_INCLUDE)
+
+LOCAL_SHARED_LIBRARIES += \
+    libnativehelper
+
+# logging
+LOCAL_SHARED_LIBRARIES += \
+    libcutils
+
+LOCAL_MODULE_TAGS := optional
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libantradio
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif # BOARD_ANT_WIRELESS_DEVICE = "chip-C"
diff --git a/src/chip-C/ant_native_chardev.c b/src/chip-C/ant_native_chardev.c
new file mode 100644
index 0000000..fe10382
--- /dev/null
+++ b/src/chip-C/ant_native_chardev.c
@@ -0,0 +1,389 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2011 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*******************************************************************************\
+*
+*   FILE NAME:     ant_native_chardev.c
+*
+*   BRIEF:
+*      This file provides the character device implementation of ant_native.h
+*
+*
+\*******************************************************************************/
+
+#include <errno.h>
+#include <fcntl.h> /* for open() */
+#include <linux/ioctl.h>
+#include <pthread.h>
+
+#include "ant_native.h"
+#include "ant_types.h"
+#include "ant_log.h"
+#include "ant_version.h"
+
+#include "ant_native_chardev.h"
+#include "ant_rx_chardev.h"
+
+#define MESG_BROADCAST_DATA_ID               ((ANT_U8)0x4E)
+#define MESG_ACKNOWLEDGED_DATA_ID            ((ANT_U8)0x4F)
+#define MESG_BURST_DATA_ID                   ((ANT_U8)0x50)
+#define MESG_EXT_BROADCAST_DATA_ID           ((ANT_U8)0x5D)
+#define MESG_EXT_ACKNOWLEDGED_DATA_ID        ((ANT_U8)0x5E)
+#define MESG_EXT_BURST_DATA_ID               ((ANT_U8)0x5F)
+
+static ant_rx_thread_info_t stRxThreadInfo;
+static pthread_mutex_t stEnabledStatusLock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t stFlowControlLock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t stFlowControlCond = PTHREAD_COND_INITIALIZER;
+ANTNativeANTStateCb g_fnStateCallback;
+
+static void ant_channel_init(ant_channel_info_t *pstChnlInfo, const char *pcCharDevName)
+{
+   pstChnlInfo->pcDevicePath = pcCharDevName;
+   pstChnlInfo->iFd = -1;
+   pstChnlInfo->fnRxCallback = NULL;
+   pstChnlInfo->ucFlowControlResp = FLOW_GO;
+   pstChnlInfo->pstFlowControlCond = &stFlowControlCond;
+   pstChnlInfo->pstFlowControlLock = &stFlowControlLock;
+}
+
+ANTStatus ant_init(void)
+{
+   ANTStatus uiRet = ANT_STATUS_FAILED;
+   ANT_FUNC_START();
+   stRxThreadInfo.stRxThread = 0;
+   stRxThreadInfo.ucRunThread = 0;
+   stRxThreadInfo.ucChipResetting = 0;
+   stRxThreadInfo.pstEnabledStatusLock = &stEnabledStatusLock;
+   g_fnStateCallback = 0;
+   ant_channel_init(&stRxThreadInfo.astChannels[COMMAND_CHANNEL], ANT_COMMANDS_DEVICE_NAME);
+   ant_channel_init(&stRxThreadInfo.astChannels[DATA_CHANNEL], ANT_DATA_DEVICE_NAME);
+   uiRet = ANT_STATUS_SUCCESS;
+   ANT_FUNC_END();
+   return uiRet;
+}
+
+ANTStatus ant_deinit(void)
+{
+   ANTStatus uiRet = ANT_STATUS_FAILED;
+   ANT_FUNC_START();
+   uiRet = ANT_STATUS_SUCCESS;
+   ANT_FUNC_END();
+   return uiRet;
+}
+
+ANTStatus set_ant_rx_callback(ANTNativeANTEventCb rx_callback_func)
+{
+   ANT_FUNC_START();
+   stRxThreadInfo.astChannels[COMMAND_CHANNEL].fnRxCallback = rx_callback_func;
+   stRxThreadInfo.astChannels[DATA_CHANNEL].fnRxCallback = rx_callback_func;
+   ANT_FUNC_END();
+   return ANT_STATUS_SUCCESS;
+}
+
+ANTStatus set_ant_state_callback(ANTNativeANTStateCb state_callback_func)
+{
+   ANT_FUNC_START();
+   g_fnStateCallback = state_callback_func;
+   ANT_FUNC_END();
+   return ANT_STATUS_SUCCESS;
+}
+
+ANTStatus ant_tx_message(ANT_U8 ucLen, ANT_U8 *pucMesg)
+{
+   ANTStatus uiRet = ANT_STATUS_FAILED;
+   int iMutexResult;
+   int iResult;
+   struct timespec stTimeout;
+   int iCondWaitResult;
+   ANT_U8 txBuffer[ANT_HCI_MAX_MSG_SIZE];
+   ANT_FUNC_START();
+   if (ant_radio_enabled_status() != RADIO_STATUS_ENABLED) {
+      uiRet = ANT_STATUS_FAILED_BT_NOT_INITIALIZED;
+      goto out;
+   }
+   txBuffer[CHIP_C_HCI_SIZE_OFFSET] = ucLen;
+   memcpy(txBuffer + CHIP_C_HCI_HEADER_SIZE, pucMesg, ucLen);
+   ANT_SERIAL(txBuffer, ucLen + CHIP_C_HCI_HEADER_SIZE, 'T');
+   switch (txBuffer[CHIP_C_HCI_DATA_OFFSET + ANT_MSG_ID_OFFSET]) {
+   case MESG_BROADCAST_DATA_ID:
+   case MESG_ACKNOWLEDGED_DATA_ID:
+   case MESG_BURST_DATA_ID:
+   case MESG_EXT_BROADCAST_DATA_ID:
+   case MESG_EXT_ACKNOWLEDGED_DATA_ID:
+   case MESG_EXT_BURST_DATA_ID:
+      ANT_DEBUG_V("getting stFlowControlLock in %s", __FUNCTION__);
+      iMutexResult = pthread_mutex_lock(&stFlowControlLock);
+      if (iMutexResult) {
+         ANT_ERROR("failed to lock flow control mutex during tx: %s", strerror(iMutexResult));
+         goto out;
+      }
+      ANT_DEBUG_V("got stFlowControlLock in %s", __FUNCTION__);
+
+      stRxThreadInfo.astChannels[COMMAND_CHANNEL].ucFlowControlResp = FLOW_STOP;
+      iResult = write(stRxThreadInfo.astChannels[DATA_CHANNEL].iFd, txBuffer, ucLen + CHIP_C_HCI_HEADER_SIZE);
+      if (iResult < 0) {
+         ANT_ERROR("failed to write data message to device: %s", strerror(errno));
+      } else if (iResult != ucLen + CHIP_C_HCI_HEADER_SIZE) {
+         ANT_ERROR("bytes written and message size dont match up");
+      } else {
+         stTimeout.tv_sec = time(0) + CHIP_C_FLOW_GO_WAIT_TIMEOUT_SEC;
+         stTimeout.tv_nsec = 0;
+
+         while (stRxThreadInfo.astChannels[COMMAND_CHANNEL].ucFlowControlResp != FLOW_GO) {
+            iCondWaitResult = pthread_cond_timedwait(&stFlowControlCond, &stFlowControlLock, &stTimeout);
+            if (iCondWaitResult) {
+               ANT_ERROR("failed to wait for flow control response: %s", strerror(iCondWaitResult));
+               if (iCondWaitResult == ETIMEDOUT)
+                  uiRet = ANT_STATUS_HARDWARE_ERR;
+               goto wait_error;
+            }
+         }
+         uiRet = ANT_STATUS_SUCCESS;
+      }
+wait_error:
+      ANT_DEBUG_V("releasing stFlowControlLock in %s", __FUNCTION__);
+      pthread_mutex_unlock(&stFlowControlLock);
+      ANT_DEBUG_V("released stFlowControlLock in %s", __FUNCTION__);
+      break;
+   default:
+      iResult = write(stRxThreadInfo.astChannels[COMMAND_CHANNEL].iFd, txBuffer, ucLen + CHIP_C_HCI_HEADER_SIZE);
+      if (iResult < 0) {
+         ANT_ERROR("failed to write message to device: %s", strerror(errno));
+      }  else if (iResult != ucLen + CHIP_C_HCI_HEADER_SIZE) {
+         ANT_ERROR("bytes written and message size dont match up");
+      } else {
+         uiRet = ANT_STATUS_SUCCESS;
+      }
+   }
+out:
+   ANT_FUNC_END();
+   return uiRet;
+}
+
+ANTStatus ant_radio_hard_reset(void)
+{
+   ANTStatus result_status = ANT_STATUS_NOT_SUPPORTED;
+   ANT_FUNC_START();
+   ANT_FUNC_END();
+   return result_status;
+}
+
+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) {
+      if (close(pstChnlInfo->iFd) < 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) {
+      pstChnlInfo->iFd = open(pstChnlInfo->pcDevicePath, O_RDWR);
+      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;
+}
+
+int ant_do_enable(void)
+{
+   int iRet = -1;
+   enum ant_channel_type eChannel;
+   ANT_FUNC_START();
+
+   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;
+}
+
+void ant_do_disable(void)
+{
+   enum ant_channel_type eChannel;
+   ANT_FUNC_START();
+   stRxThreadInfo.ucRunThread = 0;
+   for (eChannel = 0; eChannel < NUM_ANT_CHANNELS; eChannel++)
+      ant_disable_channel(&stRxThreadInfo.astChannels[eChannel]);
+   if (stRxThreadInfo.stRxThread != 0) {
+      if (pthread_join(stRxThreadInfo.stRxThread, NULL) < 0) {
+         ANT_ERROR("failed to join rx thread: %s", strerror(errno));
+      }
+      stRxThreadInfo.stRxThread = 0;
+   } else {
+      ANT_DEBUG_D("rx thread is not running");
+   }
+   ANT_FUNC_END();
+}
+
+ANTStatus ant_enable_radio(void)
+{
+   int iLockResult;
+   ANTStatus uiRet = ANT_STATUS_FAILED;
+   ANT_FUNC_START();
+   ANT_DEBUG_V("getting stEnabledStatusLock in %s", __FUNCTION__);
+   iLockResult = pthread_mutex_lock(&stEnabledStatusLock);
+   if(iLockResult) {
+      ANT_ERROR("enable failed to get state lock: %s", strerror(iLockResult));
+      goto out;
+   }
+   ANT_DEBUG_V("got stEnabledStatusLock in %s", __FUNCTION__);
+
+   if (g_fnStateCallback)
+      g_fnStateCallback(RADIO_STATUS_ENABLING);
+
+   if (ant_do_enable() < 0) {
+      ANT_ERROR("ant enable failed: %s", strerror(errno));
+
+      ant_do_disable();
+
+      if (g_fnStateCallback)
+         g_fnStateCallback(ant_radio_enabled_status());
+   } else {
+      if (g_fnStateCallback)
+         g_fnStateCallback(RADIO_STATUS_ENABLED);
+      uiRet = ANT_STATUS_SUCCESS;
+   }
+
+   ANT_DEBUG_V("releasing stEnabledStatusLock in %s", __FUNCTION__);
+   pthread_mutex_unlock(&stEnabledStatusLock);
+   ANT_DEBUG_V("released stEnabledStatusLock in %s", __FUNCTION__);
+out:
+   ANT_FUNC_END();
+   return uiRet;
+}
+
+ANTStatus ant_disable_radio(void)
+{
+   int iLockResult;
+   ANTStatus uiRet = ANT_STATUS_FAILED;
+   ANT_FUNC_START();
+   ANT_DEBUG_V("getting stEnabledStatusLock in %s", __FUNCTION__);
+   iLockResult = pthread_mutex_lock(&stEnabledStatusLock);
+   if(iLockResult) {
+      ANT_ERROR("disable failed to get state lock: %s", strerror(iLockResult));
+      goto out;
+   }
+   ANT_DEBUG_V("got stEnabledStatusLock in %s", __FUNCTION__);
+
+   if (g_fnStateCallback)
+      g_fnStateCallback(RADIO_STATUS_DISABLING);
+
+   ant_do_disable();
+
+   if (g_fnStateCallback)
+      g_fnStateCallback(ant_radio_enabled_status());
+   uiRet = ANT_STATUS_SUCCESS;
+
+   ANT_DEBUG_V("releasing stEnabledStatusLock in %s", __FUNCTION__);
+   pthread_mutex_unlock(&stEnabledStatusLock);
+   ANT_DEBUG_V("released stEnabledStatusLock in %s", __FUNCTION__);
+out:
+   ANT_FUNC_END();
+   return uiRet;
+}
+
+ANTRadioEnabledStatus ant_radio_enabled_status(void)
+{
+   enum 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;
+}
+
+const char *ant_get_lib_version()
+{
+   return "libantradio.so: CHIP_C TTY Transport. Version "
+      LIBANT_STACK_MAJOR"."LIBANT_STACK_MINOR"."LIBANT_STACK_INCRE;
+}
+
diff --git a/src/chip-C/ant_rx_chardev.c b/src/chip-C/ant_rx_chardev.c
new file mode 100644
index 0000000..2c0c6bd
--- /dev/null
+++ b/src/chip-C/ant_rx_chardev.c
@@ -0,0 +1,213 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2011 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*******************************************************************************\
+*
+*   FILE NAME:     ant_rx_chardev.c
+*
+*   BRIEF:
+*      This file provides the rx function which will loop reading ANT messages
+*        until told to exit.
+*
+*
+\*******************************************************************************/
+
+#include <errno.h>
+#include <poll.h>
+#include <pthread.h>
+
+#include "ant_rx_chardev.h"
+#include "ant_native_chardev.h"
+
+#include "ant_native.h"
+#include "ant_types.h"
+#include "ant_log.h"
+#undef LOG_TAG
+#define LOG_TAG "antradio_rx"
+
+#define ANT_POLL_TIMEOUT         ((int)30000)
+
+int readChannelMsg(ant_channel_info_t *pstChnlInfo)
+{
+   int iRet = -1;
+   ANT_U8 aucRxBuffer[ANT_HCI_MAX_MSG_SIZE];
+   int iRxLenRead;
+   int iMutexResult;
+   ANT_FUNC_START();
+
+   while (((iRxLenRead = read(pstChnlInfo->iFd, aucRxBuffer, sizeof(aucRxBuffer))) < 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, iRxLenRead, 'R');
+      if (aucRxBuffer[CHIP_C_HCI_DATA_OFFSET + ANT_MSG_ID_OFFSET] == ANT_MESG_FLOW_CONTROL) {
+         ANT_DEBUG_V("getting stFlowControlLock in %s", __FUNCTION__);
+         iMutexResult = pthread_mutex_lock(pstChnlInfo->pstFlowControlLock);
+         if (iMutexResult) {
+            ANT_ERROR("failed to lock flow control mutex during response: %s", strerror(iMutexResult));
+            goto out;
+         }
+         ANT_DEBUG_V("got stFlowControlLock in %s", __FUNCTION__);
+
+         pstChnlInfo->ucFlowControlResp = aucRxBuffer[CHIP_C_HCI_DATA_OFFSET + ANT_MSG_DATA_OFFSET];
+
+         ANT_DEBUG_V("releasing stFlowControlLock in %s", __FUNCTION__);
+         pthread_mutex_unlock(pstChnlInfo->pstFlowControlLock);
+         ANT_DEBUG_V("released stFlowControlLock in %s", __FUNCTION__);
+         pthread_cond_signal(pstChnlInfo->pstFlowControlCond);
+      } else {
+         if (pstChnlInfo->fnRxCallback != NULL) {
+            pstChnlInfo->fnRxCallback(aucRxBuffer[CHIP_C_HCI_SIZE_OFFSET], &aucRxBuffer[CHIP_C_HCI_DATA_OFFSET]);
+         } else {
+            ANT_WARN("%s rx callback is null", pstChnlInfo->pcDevicePath);
+         }
+      }
+      iRet = 0;
+   }
+out:
+   ANT_FUNC_END();
+   return iRet;
+}
+
+void *fnRxThread(void *ant_rx_thread_info)
+{
+   int iMutexLockResult;
+   int iPollRet;
+   ant_rx_thread_info_t *stRxThreadInfo;
+   struct pollfd astPollFd[NUM_ANT_CHANNELS];
+   enum 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 = POLLIN | POLLRDNORM;
+   }
+
+   while (stRxThreadInfo->ucRunThread) {
+      iPollRet = poll(astPollFd, NUM_ANT_CHANNELS, ANT_POLL_TIMEOUT);
+      if (!iPollRet) {
+         ANT_DEBUG_V("poll timed out, checking exit cond");
+      } else if (iPollRet < 0) {
+         ANT_ERROR("read thread exiting, unhandled error: %s", strerror(errno));
+      } else {
+         for (eChannel = 0; eChannel < NUM_ANT_CHANNELS; eChannel++) {
+            if (astPollFd[eChannel].revents & (POLLERR | POLLPRI | POLLRDHUP)) {
+               ANT_ERROR("poll error from %s. exiting rx thread",
+                            stRxThreadInfo->astChannels[eChannel].pcDevicePath);
+               /* Chip was reset or other error, only way to recover is to
+                * close and open ANT chardev */
+               stRxThreadInfo->ucChipResetting = 1;
+               if (g_fnStateCallback)
+                  g_fnStateCallback(RADIO_STATUS_RESETTING);
+               goto reset;
+
+            } else if (astPollFd[eChannel].revents & (POLLIN | POLLRDNORM)) {
+               ANT_DEBUG_D("data on %s. reading it",
+                            stRxThreadInfo->astChannels[eChannel].pcDevicePath);
+               if (readChannelMsg(&stRxThreadInfo->astChannels[eChannel]) < 0)
+                  goto out;
+            } else if (astPollFd[eChannel].revents) {
+               ANT_DEBUG_W("unhandled poll result %#x from %s",
+                            astPollFd[eChannel].revents,
+                            stRxThreadInfo->astChannels[eChannel].pcDevicePath);
+            }
+         }
+      }
+   }
+out:
+   stRxThreadInfo->ucRunThread = 0;
+   /* Try to get stEnabledStatusLock.
+    * if you get it then noone 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");
+      stRxThreadInfo->stRxThread = 0; /* spoof our handle as closed so we don't
+                                       * try to join ourselves in disable */
+
+      if (g_fnStateCallback)
+         g_fnStateCallback(RADIO_STATUS_DISABLING);
+
+      ant_do_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");
+   }
+   ANT_FUNC_END();
+#ifdef ANDROID
+   return NULL;
+#endif
+
+reset:
+   stRxThreadInfo->ucRunThread = 0;
+   ANT_DEBUG_V("getting stEnabledStatusLock in %s", __FUNCTION__);
+   iMutexLockResult = pthread_mutex_lock(stRxThreadInfo->pstEnabledStatusLock);
+   if (iMutexLockResult < 0) {
+      ANT_ERROR("chip was reset, getting state mutex failed: %s",
+            strerror(iMutexLockResult));
+      stRxThreadInfo->stRxThread = 0;
+   } else {
+      ANT_DEBUG_V("got stEnabledStatusLock in %s", __FUNCTION__);
+      stRxThreadInfo->stRxThread = 0; /* spoof our handle as closed so we don't
+                                       * try to join ourselves in disable */
+      ant_do_disable();
+
+      if (ant_do_enable()) { /* failed */
+         if (g_fnStateCallback)
+            g_fnStateCallback(RADIO_STATUS_DISABLED);
+      } else { /* success */
+         if (g_fnStateCallback)
+            g_fnStateCallback(RADIO_STATUS_RESET);
+      }
+      ANT_DEBUG_V("releasing stEnabledStatusLock in %s", __FUNCTION__);
+      pthread_mutex_unlock(stRxThreadInfo->pstEnabledStatusLock);
+      ANT_DEBUG_V("released stEnabledStatusLock in %s", __FUNCTION__);
+   }
+   stRxThreadInfo->ucChipResetting = 0;
+   ANT_FUNC_END();
+#ifdef ANDROID
+   return NULL;
+#endif
+}
+
diff --git a/src/chip-C/inc/ant_native_chardev.h b/src/chip-C/inc/ant_native_chardev.h
new file mode 100644
index 0000000..c72ac0e
--- /dev/null
+++ b/src/chip-C/inc/ant_native_chardev.h
@@ -0,0 +1,48 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2011 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*******************************************************************************\
+*
+*   FILE NAME:      ant_native_chardev.h
+*
+*   BRIEF:
+*       This file defines constants for the char dev implementation
+*
+*
+\*******************************************************************************/
+
+#ifndef __ANT_NATIVE_CHARDEV_H
+#define __ANT_NATIVE_CHARDEV_H
+
+#define ANT_COMMANDS_DEVICE_NAME             "/dev/smd5"
+#define ANT_DATA_DEVICE_NAME                 "/dev/smd6"
+
+#define CHIP_C_HCI_SIZE_OFFSET               0
+#define CHIP_C_HCI_DATA_OFFSET               1
+#define CHIP_C_HCI_HEADER_SIZE               1
+
+#define ANT_MESG_FLOW_CONTROL                ((ANT_U8)0xC9)
+#define FLOW_GO                              ((ANT_U8)0x00)
+#define FLOW_STOP                            ((ANT_U8)0x80)
+#define CHIP_C_FLOW_GO_WAIT_TIMEOUT_SEC      10
+
+int ant_do_enable(void);
+void ant_do_disable(void);
+extern ANTNativeANTStateCb g_fnStateCallback;
+
+#endif /* ifndef __ANT_NATIVE_CHARDEV_H */
+
diff --git a/src/chip-C/inc/ant_rx_chardev.h b/src/chip-C/inc/ant_rx_chardev.h
new file mode 100644
index 0000000..6721222
--- /dev/null
+++ b/src/chip-C/inc/ant_rx_chardev.h
@@ -0,0 +1,73 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2011 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*******************************************************************************\
+*
+*   FILE NAME:      ant_rx_chardev.h
+*
+*   BRIEF:
+*       This file defines public members in ant_rx_chardev.c
+*
+*
+\*******************************************************************************/
+
+#ifndef __ANT_RX_NATIVE_H
+#define __ANT_RX_NATIVE_H
+
+#include "ant_native.h"
+
+/* This struct defines the info passed to an rx thread */
+typedef struct {
+   /* Device path */
+   const char *pcDevicePath;
+   /* File descriptor to read from */
+   int iFd;
+   /* Callback to call with ANT packet */
+   ANTNativeANTEventCb fnRxCallback;
+   /* Flow control response if channel supports it */
+   ANT_U8 ucFlowControlResp;
+   /* Handle to flow control condition */
+   pthread_cond_t *pstFlowControlCond;
+   /* Handle to flow control mutex */
+   pthread_mutex_t *pstFlowControlLock;
+} ant_channel_info_t;
+
+enum ant_channel_type {
+   DATA_CHANNEL,
+   COMMAND_CHANNEL,
+   NUM_ANT_CHANNELS
+};
+
+typedef struct {
+   /* Thread handle */
+   pthread_t stRxThread;
+   /* Exit condition */
+   ANT_U8 ucRunThread;
+   /* Set state as resetting override */
+   ANT_U8 ucChipResetting;
+   /* Handle to state change lock for crash cleanup */
+   pthread_mutex_t *pstEnabledStatusLock;
+   /* ANT channels */
+   ant_channel_info_t astChannels[NUM_ANT_CHANNELS];
+} ant_rx_thread_info_t;
+
+/* This is the rx thread function. It loops reading ANT packets until told to
+ * exit */
+void *fnRxThread(void *ant_rx_thread_info);
+
+#endif /* ifndef __ANT_RX_NATIVE_H */
+
diff --git a/src/common/ant_utils.c b/src/common/ant_utils.c
new file mode 100644
index 0000000..65b35de
--- /dev/null
+++ b/src/common/ant_utils.c
@@ -0,0 +1,57 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and  
+ * limitations under the License.
+ */
+/******************************************************************************\
+*
+*   FILE NAME:      ANT_utils.c
+*
+*   BRIEF:          
+*		This file contains utility functions
+*
+*
+\******************************************************************************/
+
+#include "ant_types.h"
+#include "ant_utils.h"
+
+
+ANT_U16 ANT_UTILS_BEtoHost16(ANT_U8 * num)
+{
+    return (ANT_U16)(((ANT_U16) *(num) << 8) | ((ANT_U16) *(num+1)));
+}
+ANT_U16 ANT_UTILS_LEtoHost16(ANT_U8 * num)
+{
+    return (ANT_U16)(((ANT_U16) *(num+1) << 8) | ((ANT_U16) *(num)));
+}
+void ANT_UTILS_StoreBE16(ANT_U8 *buff, ANT_U16 be_value) 
+{
+   buff[0] = (ANT_U8)(be_value>>8);
+   buff[1] = (ANT_U8)be_value;
+}
+void ANT_UTILS_StoreLE16(ANT_U8 *buff, ANT_U16 le_value) 
+{
+   buff[1] = (ANT_U8)(le_value>>8);
+   buff[0] = (ANT_U8)le_value;
+}
+
+void ANT_UTILS_StoreBE32(ANT_U8 *buff, ANT_U32 be_value) 
+{
+   buff[0] = (ANT_U8)(be_value>>24);
+   buff[1] = (ANT_U8)(be_value>>16);
+   buff[2] = (ANT_U8)(be_value>>8);
+   buff[3] = (ANT_U8)be_value;
+}
diff --git a/src/common/inc/ant_log.h b/src/common/inc/ant_log.h
new file mode 100644
index 0000000..f2d09b5
--- /dev/null
+++ b/src/common/inc/ant_log.h
@@ -0,0 +1,174 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and  
+ * limitations under the License.
+ */
+/******************************************************************************\
+*
+*   FILE NAME:      ANT_log.h
+*
+*   BRIEF:          
+*		This file defines logging functions
+*
+*
+\******************************************************************************/
+
+#ifndef __ANT_LOG_H
+#define __ANT_LOG_H
+
+#include <unistd.h>
+#include "ant_types.h"
+
+#define LEVEL_NONE      0
+#define LEVEL_ERROR     1
+#define LEVEL_WARNING   2
+#define LEVEL_INFO      3
+#define LEVEL_DEBUG     4
+#define LEVEL_VERBOSE   5
+
+#define STREAM_STDOUT   16
+#define STREAM_LOGCAT   17
+
+/* Define what stream output should go to depending on platform */
+#if defined(__ANDROID__) || defined(ANDROID)
+   #define ANT_OUTPUT_STREAM STREAM_LOGCAT
+#elif defined(__linux__) || defined(__linux) || defined(linux)
+   #define ANT_OUTPUT_STREAM STREAM_STDOUT
+#endif
+
+/* If no debug level defined, set default as none */
+#if !defined(ANT_DEBUG)
+   #define ANT_DEBUG LEVEL_NONE
+#endif
+
+/* Define to show function entry and exit */
+//#define ANT_STACK_TRACE
+
+/* Define to show message in byte form */
+//#define ANT_LOG_SERIAL
+
+/* Define to write serial log to file instead of logcat */
+//#define ANT_LOG_SERIAL_FILE "/data/system/antseriallog.txt"
+
+#undef LOG_TAG
+#define LOG_TAG "antradio"
+
+#if ANT_DEBUG == LEVEL_NONE
+   #undef ANT_STACK_TRACE
+   #undef ANT_LOG_SERIAL
+#endif
+
+#if ANT_DEBUG >= LEVEL_ERROR
+   #define OUTPUT_LEVEL_ERROR(...)     OUTPUT_ERROR(__VA_ARGS__)
+#else
+   #define OUTPUT_LEVEL_ERROR(...)     ((void)0)
+#endif
+#if ANT_DEBUG >= LEVEL_WARNING
+   #define OUTPUT_LEVEL_WARNING(...)   OUTPUT_WARNING(__VA_ARGS__)
+#else
+   #define OUTPUT_LEVEL_WARNING(...)   ((void)0)
+#endif
+#if ANT_DEBUG >= LEVEL_INFO
+   #define OUTPUT_LEVEL_INFO(...)      OUTPUT_INFO(__VA_ARGS__)
+#else
+   #define OUTPUT_LEVEL_INFO(...)      ((void)0)
+#endif
+#if ANT_DEBUG >= LEVEL_DEBUG
+   #define OUTPUT_LEVEL_DEBUG(...)     OUTPUT_DEBUG(__VA_ARGS__)
+#else
+   #define OUTPUT_LEVEL_DEBUG(...)     ((void)0)
+#endif
+#if ANT_DEBUG >= LEVEL_VERBOSE
+   #define OUTPUT_LEVEL_VERBOSE(...)   OUTPUT_VERBOSE(__VA_ARGS__)
+#else
+   #define OUTPUT_LEVEL_VERBOSE(...)   ((void)0)
+#endif
+
+#if ANT_OUTPUT_STREAM == STREAM_STDOUT
+   #include <stdio.h>
+   #define OUTPUT_VERBOSE(fmt, ...)    fprintf(stdout, LOG_TAG "<V>: " fmt "\n", ##__VA_ARGS__)
+   #define OUTPUT_DEBUG(fmt, ...)      fprintf(stdout, LOG_TAG "<D>: " fmt "\n", ##__VA_ARGS__)
+   #define OUTPUT_INFO(fmt, ...)       fprintf(stdout, LOG_TAG "<I>: " fmt "\n", ##__VA_ARGS__)
+   #define OUTPUT_WARNING(fmt, ...)    fprintf(stdout, LOG_TAG "<W>: " fmt "\n", ##__VA_ARGS__)
+   #define OUTPUT_ERROR(fmt, ...)      fprintf(stdout, LOG_TAG "<E>: " fmt "\n", ##__VA_ARGS__)
+#elif ANT_OUTPUT_STREAM == STREAM_LOGCAT
+   #if (ANT_DEBUG >= LEVEL_VERBOSE) || (defined(ANT_LOG_SERIAL) && !defined(ANT_LOG_SERIAL_FILE))
+      #undef NDEBUG /* Define verbose logging for logcat if required */
+   #endif
+   #include <cutils/log.h>
+   #define OUTPUT_VERBOSE(...)         LOGV(__VA_ARGS__)
+   #define OUTPUT_DEBUG(...)           LOGD(__VA_ARGS__)
+   #define OUTPUT_INFO(...)            LOGI(__VA_ARGS__)
+   #define OUTPUT_WARNING(...)         LOGW(__VA_ARGS__)
+   #define OUTPUT_ERROR(...)           LOGE(__VA_ARGS__)
+#endif
+
+#define ANT_WARN(...)                  OUTPUT_WARNING(__VA_ARGS__)
+#define ANT_ERROR(...)                 OUTPUT_ERROR(__VA_ARGS__)
+
+#define ANT_DEBUG_V(...)               OUTPUT_LEVEL_VERBOSE(__VA_ARGS__)
+#define ANT_DEBUG_D(...)               OUTPUT_LEVEL_DEBUG(__VA_ARGS__)
+#define ANT_DEBUG_I(...)               OUTPUT_LEVEL_INFO(__VA_ARGS__)
+#define ANT_DEBUG_W(...)               OUTPUT_LEVEL_WARNING(__VA_ARGS__)
+#define ANT_DEBUG_E(...)               OUTPUT_LEVEL_ERROR(__VA_ARGS__)
+
+#if defined(ANT_STACK_TRACE)
+   #define ANT_FUNC_START()            OUTPUT_DEBUG("->  FUNC start %s", __FUNCTION__)
+   #define ANT_FUNC_END()              OUTPUT_DEBUG("<-  FUNC end   %s", __FUNCTION__)
+#else
+   #define ANT_FUNC_START()            ((void)0)
+   #define ANT_FUNC_END()              ((void)0)
+#endif
+
+#if defined(ANT_LOG_SERIAL)
+static inline void ANT_SERIAL(ANT_U8 *buf, ANT_U8 len, char dir)
+{
+   static const char hexToChar[] = {'0','1','2','3','4','5','6','7',
+                                    '8','9','A','B','C','D','E','F'};
+   int i;
+   static char log[1024];
+   char *ptr = log;
+
+   *(ptr++) = dir;
+   *(ptr++) = 'x';
+   *(ptr++) = ' ';
+   for (i = 0; i < len; i++) {
+      *(ptr++) = '[';
+      *(ptr++) = hexToChar[(buf[i] & 0xF0) >> 4];
+      *(ptr++) = hexToChar[(buf[i] & 0x0F) >> 0];
+      *(ptr++) = ']';
+   }
+#if defined(ANT_LOG_SERIAL_FILE)
+   *(ptr++) = '\n';
+   FILE *fd = NULL;
+   fd = fopen(ANT_LOG_SERIAL_FILE, "a");
+   if (NULL == fd) {
+      LOGW("Could not open %s for serial output. %s", ANT_LOG_SERIAL_FILE, strerror(errno));
+   } else {
+      fwrite(log, 1, (ptr - log), fd);
+      if (fclose(fd)) {
+         LOGW("Could not close file for serial output. %s", strerror(errno));
+      }
+   }
+#else
+   *(ptr++) = '\0';
+   OUTPUT_VERBOSE("%s", log);
+#endif
+}
+#else
+   #define ANT_SERIAL(...)             ((void)0)
+#endif
+
+#endif /* __ANT_LOG_H */
diff --git a/src/common/inc/ant_native.h b/src/common/inc/ant_native.h
new file mode 100644
index 0000000..eedec50
--- /dev/null
+++ b/src/common/inc/ant_native.h
@@ -0,0 +1,142 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/******************************************************************************\
+*
+*   FILE NAME:      ant_native.h
+*
+*   BRIEF:
+*		This file defines the interface to the ANT transport layer
+*
+*
+\******************************************************************************/
+
+#ifndef __ANT_NATIVE_H
+#define __ANT_NATIVE_H
+
+/*******************************************************************************
+ *
+ * Include files
+ *
+ ******************************************************************************/
+#include "ant_types.h"
+
+/*******************************************************************************
+ *
+ * Constants
+ *
+ ******************************************************************************/
+#define ANT_NATIVE_MAX_PARMS_LEN              255
+#define ANT_NATIVE_MESSAGE_OVERHEAD_SIZE      2
+#define ANT_HCI_MAX_MSG_SIZE                  260
+
+#define ANT_MSG_SIZE_OFFSET     ((ANT_U8)0)
+#define ANT_MSG_ID_OFFSET       ((ANT_U8)1)
+#define ANT_MSG_DATA_OFFSET     ((ANT_U8)2)
+
+/*******************************************************************************
+ *
+ * Types
+ *
+ ******************************************************************************/
+typedef void (*ANTNativeANTEventCb)(ANT_U8 ucLen, ANT_U8* pucData);
+typedef void (*ANTNativeANTStateCb)(ANTRadioEnabledStatus uiNewState);
+
+/*******************************************************************************
+ *
+ * Data Structures
+ *
+ ******************************************************************************/
+
+/*******************************************************************************
+ *
+ * Function declarations
+ *
+ ******************************************************************************/
+
+/*------------------------------------------------------------------------------
+ * ant_init()
+ *
+ * Called to initialize the ANT stack
+ */
+ANTStatus ant_init(void);
+
+/*------------------------------------------------------------------------------
+ * ant_deinit()
+ *
+ * Called to de-initialize the ANT stack
+ */
+ANTStatus ant_deinit(void);
+
+/*------------------------------------------------------------------------------
+ * ant_enable_radio()
+ *
+ * Power on the chip and set it to a state which can read / write to it
+ */
+ANTStatus ant_enable_radio(void);
+
+/*------------------------------------------------------------------------------
+ * ant_disable_radio()
+ *
+ * Kill power to the ANT chip and set state which doesnt allow read / write
+ */
+ANTStatus ant_disable_radio(void);
+
+/*------------------------------------------------------------------------------
+ * ant_radio_enabled_status()
+ *
+ * Gets if the chip/transport is disabled/disabling/enabling/enabled
+ */
+ANTRadioEnabledStatus ant_radio_enabled_status(void);
+
+/*------------------------------------------------------------------------------
+ * set_ant_rx_callback()
+ *
+ * Sets the callback function for receiving ANT messages
+ */
+ANTStatus set_ant_rx_callback(ANTNativeANTEventCb rx_callback_func);
+
+/*------------------------------------------------------------------------------
+ * set_ant_state_callback()
+ *
+ * Sets the callback function for any ANT radio enabled status state changes
+ */
+ANTStatus set_ant_state_callback(ANTNativeANTStateCb state_callback_func);
+
+/*------------------------------------------------------------------------------
+ * ant_tx_message()
+ *
+ * Sends an ANT message command to the chip.
+ */
+ANTStatus ant_tx_message(ANT_U8 ucLen, ANT_U8 *pucMesg);
+
+/*------------------------------------------------------------------------------
+ * ant_radio_hard_reset()
+ *
+ * If supported, forces the chip to do a power cycle reset
+ */
+ANTStatus ant_radio_hard_reset(void);
+
+/*------------------------------------------------------------------------------
+ * ant_get_lib_version()
+ *
+ * Gets the current version and transport type of libantradio.so
+ */
+const char *ant_get_lib_version(void);
+
+#endif /* ifndef __ANT_NATIVE_H */
+
diff --git a/src/common/inc/ant_types.h b/src/common/inc/ant_types.h
new file mode 100644
index 0000000..bc896b6
--- /dev/null
+++ b/src/common/inc/ant_types.h
@@ -0,0 +1,125 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/******************************************************************************\
+*
+*   FILE NAME:      ANT_types.h
+*
+*   BRIEF:
+*		This file defines types used in the ANT stack
+*
+*
+\******************************************************************************/
+
+#ifndef __ANT_TYPES_H
+#define __ANT_TYPES_H
+
+#include <stdint.h>
+
+/* -------------------------------------------------------------
+ *                  8 Bits Types
+ */
+typedef uint8_t     ANT_U8;
+typedef int8_t      ANT_S8;
+
+/* -------------------------------------------------------------
+ *                  16 Bits Types
+ */
+typedef uint16_t    ANT_U16;
+typedef int8_t      ANT_S16;
+
+/* -------------------------------------------------------------
+ *                  32 Bits Types
+ */
+typedef uint32_t    ANT_U32;
+typedef int32_t     ANT_S32;
+
+
+/* -------------------------------------------------------------
+ *          Native Integer Types (# of bits irrelevant)
+ */
+typedef int          ANT_INT;
+typedef unsigned int ANT_UINT;
+
+
+/* --------------------------------------------------------------
+ *                  Boolean Definitions
+ */
+typedef ANT_INT     ANT_BOOL;
+
+#define ANT_TRUE    (1 == 1)
+#define ANT_FALSE   (1 == 0)
+
+/*
+*/
+#define ANT_NO_VALUE                                    ((ANT_U32)0xFFFFFFFFUL)
+
+
+/* -------------------------------------------------------------
+ *              ANTRadioEnabledStatus Type
+ */
+typedef ANT_UINT ANTRadioEnabledStatus;
+
+#define RADIO_STATUS_UNKNOWN                          ((ANTRadioEnabledStatus)0)
+#define RADIO_STATUS_ENABLING                         ((ANTRadioEnabledStatus)1)
+#define RADIO_STATUS_ENABLED                          ((ANTRadioEnabledStatus)2)
+#define RADIO_STATUS_DISABLING                        ((ANTRadioEnabledStatus)3)
+#define RADIO_STATUS_DISABLED                         ((ANTRadioEnabledStatus)4)
+#define RADIO_STATUS_NOT_SUPPORTED                    ((ANTRadioEnabledStatus)5)
+#define RADIO_STATUS_SERVICE_NOT_INSTALLED            ((ANTRadioEnabledStatus)6)
+#define RADIO_STATUS_SERVICE_NOT_CONNECTED            ((ANTRadioEnabledStatus)7)
+#define RADIO_STATUS_RESETTING                        ((ANTRadioEnabledStatus)8)
+#define RADIO_STATUS_RESET                            ((ANTRadioEnabledStatus)9)
+
+/*------------------------------------------------------------------------------
+ * ANTStatus Type
+ *
+ */
+typedef ANT_UINT ANTStatus;
+
+#define ANT_STATUS_SUCCESS                                  ((ANTStatus)0)
+#define ANT_STATUS_FAILED                                   ((ANTStatus)1)
+#define ANT_STATUS_PENDING                                  ((ANTStatus)2)
+#define ANT_STATUS_INVALID_PARM                             ((ANTStatus)3)
+#define ANT_STATUS_IN_PROGRESS                              ((ANTStatus)4)
+#define ANT_STATUS_NOT_APPLICABLE                           ((ANTStatus)5)
+#define ANT_STATUS_NOT_SUPPORTED                            ((ANTStatus)6)
+#define ANT_STATUS_INTERNAL_ERROR                           ((ANTStatus)7)
+#define ANT_STATUS_TRANSPORT_INIT_ERR                       ((ANTStatus)8)
+#define ANT_STATUS_HARDWARE_ERR                             ((ANTStatus)9)
+#define ANT_STATUS_NO_VALUE_AVAILABLE                       ((ANTStatus)10)
+#define ANT_STATUS_CONTEXT_DOESNT_EXIST                     ((ANTStatus)11)
+#define ANT_STATUS_CONTEXT_NOT_DESTROYED                    ((ANTStatus)12)
+#define ANT_STATUS_CONTEXT_NOT_ENABLED                      ((ANTStatus)13)
+#define ANT_STATUS_CONTEXT_NOT_DISABLED                     ((ANTStatus)14)
+#define ANT_STATUS_NOT_DE_INITIALIZED                       ((ANTStatus)15)
+#define ANT_STATUS_NOT_INITIALIZED                          ((ANTStatus)16)
+#define ANT_STATUS_TOO_MANY_PENDING_CMDS                    ((ANTStatus)17)
+#define ANT_STATUS_DISABLING_IN_PROGRESS                    ((ANTStatus)18)
+
+#define ANT_STATUS_COMMAND_WRITE_FAILED                     ((ANTStatus)20)
+#define ANT_STATUS_SCRIPT_EXEC_FAILED                       ((ANTStatus)21)
+
+#define ANT_STATUS_FAILED_BT_NOT_INITIALIZED                ((ANTStatus)23)
+#define ANT_STATUS_AUDIO_OPERATION_UNAVAILIBLE_RESOURCES    ((ANTStatus)24)
+
+#define ANT_STATUS_TRANSPORT_UNSPECIFIED_ERROR              ((ANTStatus)30)
+
+#define ANT_STATUS_NO_VALUE                                 ((ANTStatus)100)
+
+#endif  /* __ANT_TYPES_H */
+
diff --git a/src/common/inc/ant_utils.h b/src/common/inc/ant_utils.h
new file mode 100644
index 0000000..60abe8c
--- /dev/null
+++ b/src/common/inc/ant_utils.h
@@ -0,0 +1,139 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2009 Dynastream Innovations
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and  
+ * limitations under the License.
+ */
+/******************************************************************************\
+*
+*   FILE NAME:      ANT_utils.h
+*
+*   BRIEF:          
+*		This file defines utility functions
+*
+*
+\******************************************************************************/
+#ifndef __ANT_UTILS_H
+#define __ANT_UTILS_H
+
+#include "ant_types.h"
+
+/****************************************************************************
+ *
+ * Type Definitions
+ *
+ ****************************************************************************/
+
+
+
+/*------------------------------------------------------------------------------
+ * ANT_xxx()
+ *
+ * Brief:  
+ *      xxx
+ *
+ * Description:
+ *      xxx
+ *
+ * Type:
+ *      Syxxx/As
+ *
+ * Parameters:
+ *      xxx [in]    - 
+ *
+ * Returns:
+ *      xxx
+ */
+ANT_U16 ANT_UTILS_BEtoHost16(ANT_U8 * num);
+/*------------------------------------------------------------------------------
+ * ANT_xxx()
+ *
+ * Brief:  
+ *      xxx
+ *
+ * Description:
+ *      xxx
+ *
+ * Type:
+ *      Syxxx/As
+ *
+ * Parameters:
+ *      xxx [in]    - 
+ *
+ * Returns:
+ *      xxx
+ */
+ANT_U16 ANT_UTILS_LEtoHost16(ANT_U8 * num);
+/*------------------------------------------------------------------------------
+ * ANT_xxx()
+ *
+ * Brief:  
+ *      xxx
+ *
+ * Description:
+ *      xxx
+ *
+ * Type:
+ *      Syxxx/As
+ *
+ * Parameters:
+ *      xxx [in]    - 
+ *
+ * Returns:
+ *      xxx
+ */
+void ANT_UTILS_StoreBE16(ANT_U8 *buff, ANT_U16 be_value) ;
+/*------------------------------------------------------------------------------
+ * ANT_xxx()
+ *
+ * Brief:  
+ *      xxx
+ *
+ * Description:
+ *      xxx
+ *
+ * Type:
+ *      Syxxx/As
+ *
+ * Parameters:
+ *      xxx [in]    - 
+ *
+ * Returns:
+ *      xxx
+ */
+void ANT_UTILS_StoreLE16(ANT_U8 *buff, ANT_U16 le_value) ;
+/*------------------------------------------------------------------------------
+ * ANT_xxx()
+ *
+ * Brief:  
+ *      xxx
+ *
+ * Description:
+ *      xxx
+ *
+ * Type:
+ *      Syxxx/As
+ *
+ * Parameters:
+ *      xxx [in]    - 
+ *
+ * Returns:
+ *      xxx
+ */
+void ANT_UTILS_StoreBE32(ANT_U8 *buff, ANT_U32 be_value) ;
+
+
+
+#endif  /* __ANT_UTILS_H */
+
diff --git a/src/common/inc/ant_version.h b/src/common/inc/ant_version.h
new file mode 100644
index 0000000..bc1f239
--- /dev/null
+++ b/src/common/inc/ant_version.h
@@ -0,0 +1,27 @@
+/*
+ * ANT Stack
+ *
+ * Copyright 2011 Dynastream Innovations
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __ANT_VERSION_H
+#define __ANT_VERSION_H
+
+#define LIBANT_STACK_MAJOR "0"
+#define LIBANT_STACK_MINOR "7"
+#define LIBANT_STACK_INCRE "0"
+
+#endif // __ANT_VERSION_H
+