fm_hci/fm_hci.cpp - LeafOS-Project/android_vendor_qcom_opensource_fm-commonsys - Gitiles

 /*
  * Copyright (c) 2017, The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *        * Redistributions of source code must retain the above copyright
  *            notice, this list of conditions and the following disclaimer.
  *        * Redistributions in binary form must reproduce the above
  *            copyright notice, this list of conditions and the following
  *            disclaimer in the documentation and/or other materials provided
  *            with the distribution.
  *        * Neither the name of The Linux Foundation nor the names of its
  *            contributors may be used to endorse or promote products derived
  *            from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 /*****************************************************************************
  *
  *  This file contains main functions to support FM HCI interface to send
  *  commands and  recieved events.
  *
  *****************************************************************************/

 #define LOG_TAG "fm_hci"

 #include <queue>          // std::queue
 #include <mutex>              // std::mutex, std::unique_lock
 #include <condition_variable> // std::condition_variable
 #include <cstdlib>
 #include <thread>

 #include <utils/Log.h>
 #include <unistd.h>

 #include <vendor/qti/hardware/fm/1.0/IFmHci.h>
 #include <vendor/qti/hardware/fm/1.0/IFmHciCallbacks.h>
 #include <vendor/qti/hardware/fm/1.0/types.h>
 #include "fm_hci.h"

 #include <hwbinder/ProcessState.h>

 using vendor::qti::hardware::fm::V1_0::IFmHci;
 using vendor::qti::hardware::fm::V1_0::IFmHciCallbacks;
 using vendor::qti::hardware::fm::V1_0::HciPacket;
 using vendor::qti::hardware::fm::V1_0::Status;
 using android::hardware::ProcessState;
 using ::android::hardware::Return;
 using ::android::hardware::Void;
 using ::android::hardware::hidl_vec;

 static struct fm_hci_t hci;

 typedef std::unique_lock<std::mutex> Lock;
 android::sp<IFmHci> fmHci;

 static int enqueue_fm_rx_event(struct fm_event_header_t *hdr);
 static void dequeue_fm_rx_event();
 static int enqueue_fm_tx_cmd(struct fm_command_header_t *hdr);
 static void dequeue_fm_tx_cmd();
 static void  hci_tx_thread();
 static void hci_rx_thread();
 static int start_tx_thread();
 static void stop_tx_thread();
 static int start_rx_thread();
 static void stop_rx_thread();
 static void cleanup_threads();
 static bool hci_initialize();
 static void hci_transmit(struct fm_command_header_t *hdr);
 static void hci_close();

 /*******************************************************************************
 **
 ** Function         enqueue_fm_rx_event
 **
 ** Description      This function is called in the hal daemon context to queue
 **                  FM events in RX queue.
 **
 ** Parameters:      hdr - contains the fm event header pointer
 **
 **
 ** Returns          int
 **
 *******************************************************************************/
 static int enqueue_fm_rx_event(struct fm_event_header_t *hdr)
 {

     ALOGI("%s: putting lock before enqueue ", __func__);
     hci.rx_cond_mtx.lock();
     hci.rx_event_queue.push(hdr);
     hci.rx_cond_mtx.unlock();
     ALOGI("%s:notify to waiting thred", __func__);
     hci.rx_cond.notify_all();
     ALOGI("%s: FM-Event ENQUEUED SUCCESSFULLY", __func__);

     return FM_HC_STATUS_SUCCESS;
 }

 /*******************************************************************************
 **
 ** Function         dequeue_fm_rx_event
 **
 ** Description      This function is called in the rx thread context to dequeue
 **                  FM events from RX queue & processing the FM event.
 **
 ** Parameters:      void
 **
 **
 ** Returns          void
 **
 *******************************************************************************/
 static void dequeue_fm_rx_event()
 {
     fm_event_header_t *evt_buf;

     ALOGI("%s", __func__);
     while (1) {
         if (hci.rx_event_queue.empty()) {
             ALOGI("No more FM Events are available in the RX Queue");
             return;
         } else {
         }

         evt_buf = hci.rx_event_queue.front();
         hci.rx_event_queue.pop();

         if (evt_buf->evt_code == FM_CMD_COMPLETE) {
             ALOGI("%s: FM_CMD_COMPLETE: current_credits %d, %d Credits got from the SOC", __func__, hci.command_credits, evt_buf->params[0]);
             if (hci.command_credits == 0) {
                 hci.command_credits += evt_buf->params[0];
                 ALOGI(" dequeue_fm_rx_event: wait for tx_cond_lock ");
                 hci.tx_cond_mtx.lock();
                 ALOGI(" dequeue_fm_rx_event: Notifying tx_cond_lock ");
                 hci.tx_cond.notify_all();
                 ALOGI(" dequeue_fm_rx_event: UNLOCKING tx_cond_lock ");
                 hci.tx_cond_mtx.unlock();
             } else {
                 hci.command_credits += evt_buf->params[0];
             }

         } else if (evt_buf->evt_code == FM_CMD_STATUS) {
             ALOGI("%s: FM_CMD_STATUS: current_credits %d, %d Credits got from the SOC", __func__, hci.command_credits, evt_buf->params[1]);
             if (hci.command_credits == 0) {
                 hci.command_credits += evt_buf->params[1];
                 ALOGI(" dequeue_fm_rx_event: wait for tx_cond_lock ");
                 hci.tx_cond_mtx.lock();
                 ALOGI(" dequeue_fm_rx_event: Notifying tx_cond_lock ");
                 hci.tx_cond.notify_all();
                 ALOGI(" dequeue_fm_rx_event: UNLOCKING tx_cond_lock ");
                 hci.tx_cond_mtx.unlock();
             } else {
                 hci.command_credits += evt_buf->params[1];
             }
         } else if (evt_buf->evt_code == FM_HW_ERR_EVENT) {
             ALOGI("%s: FM H/w Err Event Recvd. Event Code: 0x%x", __func__, evt_buf->evt_code);
         } else {
             ALOGE("%s: Not CS/CC Event: Recvd. Event Code: 0x%x", __func__, evt_buf->evt_code);
         }

         if (hci.cb && hci.cb->process_event) {
             ALOGI("%s: processing the event", __func__);
             hci.cb->process_event(NULL, (uint8_t *)evt_buf);
         }

         free(evt_buf);
         evt_buf = NULL;
     }

 }

 /*******************************************************************************
 **
 ** Function         enqueue_fm_tx_cmd
 **
 ** Description      This function is called in the application JNI context to
 **                  queue FM commands in TX queue.
 **
 ** Parameters:      hdr - contains the fm command header pointer
 **
 **
 ** Returns          int
 **
 *******************************************************************************/
 static int enqueue_fm_tx_cmd(struct fm_command_header_t *hdr)
 {
     ALOGI("%s:  opcode 0x%x len:%d ", __func__,  hdr->opcode, hdr->len);

     hci.tx_queue_mtx.lock();
     hci.tx_cmd_queue.push(hdr);
     hci.tx_queue_mtx.unlock();

     ALOGI("%s:  notifying credits %d", __func__, hci.command_credits);
     if (hci.command_credits > 0) {
         ALOGI(" enqueue_fm_tx_cmd: wait for tx_cond_lock ");
         hci.tx_cond_mtx.lock();
         ALOGI(" enqueue_fm_tx_cmd: Notifying tx_cond_lock ");
         hci.tx_cond.notify_all();
         ALOGI(" enqueue_fm_tx_cmd: UNLOCK tx_cond_lock ");
         hci.tx_cond_mtx.unlock();
     }

     ALOGI("%s: FM-CMD ENQUEUED SUCCESSFULLY  credits %d", __func__, hci.command_credits);

     return FM_HC_STATUS_SUCCESS;
 }

 /*******************************************************************************
 **
 ** Function         dequeue_fm_tx_cmd
 **
 ** Description      This function is called in the tx thread context to dequeue
 **                  & transmitting FM command to to HAL daemon.
 **
 ** Parameters:      void
 **
 **
 ** Returns          void
 **
 *******************************************************************************/
 static void dequeue_fm_tx_cmd()
 {
     fm_command_header_t *hdr;

     ALOGI("%s", __func__);

     while (1)
     {
        ALOGI(" dequeue_fm_tx_cmd:  command credits %d ", hci.command_credits);
        if (hci.command_credits == 0) {
           return;
        }
         hci.tx_queue_mtx.lock();
         ALOGI("%s is_que_empty %d", __func__,hci.tx_cmd_queue.empty());
         if(hci.tx_cmd_queue.empty()){
             ALOGI(" %s No more FM CMDs are available in the Queue",__func__);
             hci.tx_queue_mtx.unlock();
             return;
         }

         hdr = hci.tx_cmd_queue.front();
         hci.tx_cmd_queue.pop();
         hci.tx_queue_mtx.unlock();
         ALOGI("%s: packet popped %d credits", __func__,hci.command_credits);


         hci.command_credits--;
         hci_transmit(hdr);
         ALOGI("%s: packet transmitted %d credits", __func__,hci.command_credits);
     }
     ALOGI(" %s outside while(1), credits %d ", __func__, hci.command_credits);
 }


 /*******************************************************************************
 **
 ** Function         hci_tx_thread
 **
 ** Description      This function is main function of tx worker thread.
 **
 ** Parameters:      void
 **
 **
 ** Returns          void
 **
 *******************************************************************************/
 static void  hci_tx_thread()
 {
     ALOGI("%s: ##### starting hci_tx_thread Worker thread!!! #####", __func__);
     hci.is_tx_thread_running = true;

     Lock lk(hci.tx_cond_mtx);
     while (hci.state != FM_RADIO_DISABLING && hci.state != FM_RADIO_DISABLED) {
         //wait  for tx cmd
         ALOGI("%s: before wait %d credits!!!" , __func__,hci.command_credits);
         hci.tx_cond.wait(lk);
         ALOGV("%s: after wait dequeueing the tx cmd!!!" , __func__);
         dequeue_fm_tx_cmd();
     }

     hci.is_tx_thread_running =false;
     ALOGI("%s: ##### Exiting hci_tx_thread Worker thread!!! #####", __func__);
 }

 /*******************************************************************************
 **
 ** Function         hci_rx_thread
 **
 ** Description      This function is main function of tx worker thread.
 **
 ** Parameters:      void
 **
 **
 ** Returns          void
 **
 *******************************************************************************/
 static void hci_rx_thread()
 {

     ALOGI("%s: ##### starting hci_rx_thread Worker thread!!! #####", __func__);
     hci.is_rx_thread_running = true;

     ALOGI("%s: constr unique_lock ", __func__);
     Lock lk(hci.rx_cond_mtx);
     while (hci.state != FM_RADIO_DISABLING && hci.state != FM_RADIO_DISABLED) {
         //wait for rx event
         ALOGI("%s:before wait", __func__);
         hci.rx_cond.wait(lk);
         ALOGI("%s:after wait ", __func__);
         dequeue_fm_rx_event();
     }

     hci.is_rx_thread_running = false;
     ALOGI("%s: ##### Exiting hci_rx_thread Worker thread!!! #####", __func__);
 }

 /*******************************************************************************
 **
 ** Function         start_tx_thread
 **
 ** Description      This function is called to start tx worker thread.
 **
 ** Parameters:      void
 **
 **
 ** Returns          int
 **
 *******************************************************************************/
 static int start_tx_thread()
 {

     ALOGI("FM-HCI: Creating the FM-HCI  TX TASK...");
     hci.tx_thread_ = std::thread(hci_tx_thread);
     if (!hci.tx_thread_.joinable()) {
         ALOGE("tx thread is not joinable");
         return FM_HC_STATUS_FAIL;
     }

     return FM_HC_STATUS_SUCCESS;
 }

 /*******************************************************************************
 **
 ** Function         stop_tx_thread
 **
 ** Description      This function is called to stop tx worker thread.
 **
 ** Parameters:      void
 **
 **
 ** Returns          int
 **
 *******************************************************************************/
 static void stop_tx_thread()
 {
     int ret;

     ALOGI("%s:stop_tx_thread ++", __func__);
     hci.tx_cond_mtx.lock();
     hci.tx_cond.notify_all();
     ALOGI("%s:notify to tx thread", __func__);
     hci.tx_cond_mtx.unlock();

     hci.tx_thread_.join();
     ALOGI("%s:stop_tx_thread --", __func__);
 }

 /*******************************************************************************
 **
 ** Function         start_rx_thread
 **
 ** Description      This function is called to start rx worker thread.
 **
 ** Parameters:      void
 **
 **
 ** Returns          int
 **
 *******************************************************************************/
 static int start_rx_thread()
 {
     int ret = FM_HC_STATUS_SUCCESS;
     ALOGI("FM-HCI: Creating the FM-HCI RX TASK...");

     hci.rx_thread_ = std::thread(hci_rx_thread);
     if (!hci.rx_thread_.joinable()) {
         ALOGE("rx thread is not joinable");
         return FM_HC_STATUS_FAIL;
     }

     return ret;
 }

 /*******************************************************************************
 **
 ** Function         stop_rx_thread
 **
 ** Description      This function is called to stop rx worker thread.
 **
 ** Parameters:      void
 **
 **
 ** Returns          int
 **
 *******************************************************************************/
 static void stop_rx_thread()
 {
     ALOGI("%s:stop_rx_thread ++", __func__);
     hci.rx_cond.notify_all();

     hci.rx_thread_.join();
     ALOGI("%s:stop_rx_thread --", __func__);
 }

 /*******************************************************************************
 **
 ** Function         cleanup_threads
 **
 ** Description      This function is called to cleanup rx & tx worker thread.
 **
 ** Parameters:      void
 **
 **
 ** Returns          int
 **
 *******************************************************************************/
 static void cleanup_threads()
 {
     stop_rx_thread();
     stop_tx_thread();
 }

 /*******************************************************************************
 **
 ** Function         initialization_complete
 **
 ** Description      This function is called, when initialization complete
 **                  callback is called by hal daemon.
 **
 ** Parameters:      hdr - contains the fm event header pointer
 **
 **
 ** Returns          int
 **
 *******************************************************************************/
 static void initialization_complete(bool is_hci_initialize)
 {
     int ret;
     ALOGI("++%s: is_hci_initialize: %d", __func__, is_hci_initialize);

     while (is_hci_initialize) {
         ret = start_tx_thread();
         if (ret)
         {
             cleanup_threads();
             hci.state = FM_RADIO_DISABLING;
             break;
         }

         ret = start_rx_thread();
         if (ret)
         {
             cleanup_threads();
             hci.state = FM_RADIO_DISABLING;
             break;
         }

         hci.state = FM_RADIO_ENABLED;
         break;
     }

     hci.on_cond.notify_all();
     ALOGI("--%s: is_hci_initialize: %d", __func__, is_hci_initialize);

 }

 /*******************************************************************************
 **
 ** Class            FmHciCallbacks
 **
 ** Description      This is main class, which has the implemention for FM HCI
 **                  callback functions.
 **
 ** Member callback Functions:      initializationComplete, hciEventReceived
 **
 **
 ** Returns          int
 **
 *******************************************************************************/
 class FmHciCallbacks : public IFmHciCallbacks {
     public:
         FmHciCallbacks() {
         };
         virtual ~FmHciCallbacks() = default;

         Return<void> initializationComplete(Status status) {
             if(status == Status::SUCCESS)
             {
                 initialization_complete(true);
             } else {
                 initialization_complete(false);
             }

             return Void();
         }

         Return<void> hciEventReceived(const hidl_vec<uint8_t>& event) {
             struct fm_event_header_t *temp = (struct fm_event_header_t *) malloc(event.size());
             if (temp != nullptr) {
                 memcpy(temp, event.data(), event.size());
                 ALOGI("%s: evt_code:  0x%x", __func__, temp->evt_code);
                 enqueue_fm_rx_event(temp);
             } else {
                 ALOGE("%s: Memory Allocation failed for event buffer ",__func__);
             }
             return Void();
         }
 };

 /*******************************************************************************
 **
 ** Function         hci_initialize
 **
 ** Description      This function is used to initialize fm hci hidl transport.
 **                  It makes a binder call to hal daemon
 **
 ** Parameters:      void
 **
 **
 ** Returns          bool
 **
 *******************************************************************************/
 static bool hci_initialize()
 {
     ALOGI("%s", __func__);

     fmHci = IFmHci::getService();

     if (fmHci != nullptr) {
         hci.state = FM_RADIO_ENABLING;
         android::sp<IFmHciCallbacks> callbacks = new FmHciCallbacks();
         auto hidl_daemon_status = fmHci->initialize(callbacks);
         if(!hidl_daemon_status.isOk()) {
             ALOGE("%s: HIDL daemon is dead", __func__);
         }
         return true;
     } else {
         return false;
     }
 }

 /*******************************************************************************
 **
 ** Function         hci_transmit
 **
 ** Description      This function is used to send fm command to fm hci hidl transport.
 **                  It makes a binder call to hal daemon.
 **
 ** Parameters:      void
 **
 **
 ** Returns          void
 **
 *******************************************************************************/
 static void hci_transmit(struct fm_command_header_t *hdr) {
     HciPacket data;

     ALOGI("%s: opcode 0x%x len:%d", __func__, hdr->opcode, hdr->len);

     if (fmHci != nullptr) {
         data.setToExternal((uint8_t *)hdr, 3 + hdr->len);
         auto hidl_daemon_status = fmHci->sendHciCommand(data);
         if(!hidl_daemon_status.isOk()) {
             ALOGE("%s: send Command failed, HIDL daemon is dead", __func__);
         }
     } else {
         ALOGI("%s: fmHci is NULL", __func__);
     }

     free(hdr);
 }

 /*******************************************************************************
 **
 ** Function         hci_close
 **
 ** Description      This function is used to close fm hci hidl transport.
 **                  It makes a binder call to hal daemon
 **
 ** Parameters:      void
 **
 **
 ** Returns          void
 **
 *******************************************************************************/
 static void hci_close()
 {
     ALOGI("%s", __func__);

     if (fmHci != nullptr) {
         auto hidl_daemon_status = fmHci->close();
         if(!hidl_daemon_status.isOk()) {
             ALOGE("%s: HIDL daemon is dead", __func__);
         }
         fmHci = nullptr;
     }
 }

 /*******************************************************************************
 **
 ** Function         fm_hci_init
 **
 ** Description      This function is used to intialize fm hci
 **
 ** Parameters:     hci_hal - contains the fm helium hal hci pointer
 **
 **
 ** Returns          void
 **
 *******************************************************************************/
 int fm_hci_init(fm_hci_hal_t *hci_hal)
 {
     int ret = FM_HC_STATUS_FAIL;

     ALOGD("++%s", __func__);

     if(hci.is_rx_thread_running)
     {
         ALOGI("%s:previous rx thread running wait until rx thread stops", __func__);
         hci.rx_thread_.join();
         ALOGI("%s:stop_rx_thread completed, proceed iniialization", __func__);
     }
     if (!hci_hal || !hci_hal->hal) {
         ALOGE("NULL input argument");
         return FM_HC_STATUS_NULL_POINTER;
     }

     memset(&hci, 0, sizeof(struct fm_hci_t));

     hci.cb = hci_hal->cb;
     hci.command_credits = 1;
     hci.is_tx_thread_running = false;
     hci.is_rx_thread_running = false;
     hci.state = FM_RADIO_DISABLED;
     hci_hal->hci = &hci;

     if (hci_initialize()) {
         //wait for iniialization complete
         ALOGD("--%s waiting for iniialization complete hci state: %d ",
                 __func__, hci.state);
         if(hci.state == FM_RADIO_ENABLING){
             Lock lk(hci.on_mtx);
             std::cv_status status = std::cv_status::no_timeout;
             auto now = std::chrono::system_clock::now();
             status =
                hci.on_cond.wait_until(lk, now + std::chrono::seconds(HCI_TIMEOUT));
              if (status == std::cv_status::timeout) {
                  ALOGE("hci_initialize failed, kill the fm process");
                  kill(getpid(), SIGKILL);
              }
         }
     }

     if (hci.state == FM_RADIO_ENABLED) {
         while (hci.is_tx_thread_running == false
             || hci.is_rx_thread_running == false)
         {
             /* checking tx & rx thread running status after every
                5ms before notifying on to upper layer */
             usleep(5000);
         }
         ALOGD("--%s success", __func__);
         ret = FM_HC_STATUS_SUCCESS;
     } else {
        ALOGD("--%s failed", __func__);
        hci_close();
        hci.state = FM_RADIO_DISABLED;
     }
     return ret;
 }

 /*******************************************************************************
 **
 ** Function         fm_hci_transmit
 **
 ** Description      This function is called by helium hal & is used enqueue the
 **                  tx commands in tx queue.
 **
 ** Parameters:      p_hci - contains the fm helium hal hci pointer
 **                  hdr - contains the fm command header pointer
 **
 ** Returns          void
 **
 *******************************************************************************/
 int fm_hci_transmit(void *p_hci, struct fm_command_header_t *hdr)
 {
     if (!hdr) {
         ALOGE("NULL input arguments");
         return FM_HC_STATUS_NULL_POINTER;
     }

     return enqueue_fm_tx_cmd(hdr);
 }

 /*******************************************************************************
 **
 ** Function         fm_hci_close
 **
 ** Description      This function is used to close & cleanup hci
 **
 ** Parameters:      p_hci - contains the fm hci pointer
 **
 **
 ** Returns          void
 **
 *******************************************************************************/
 void fm_hci_close(void *p_hci)
 {
     ALOGI("%s", __func__);
     hci.state = FM_RADIO_DISABLING;

     hci_close();
     stop_tx_thread();

     if (hci.cb && hci.cb->fm_hci_close_done) {
         ALOGI("%s:Notify FM OFF to hal", __func__);
         hci.cb->fm_hci_close_done();
     }

     hci.state = FM_RADIO_DISABLED;
 }
	/*
	* Copyright (c) 2017, The Linux Foundation. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following
	* disclaimer in the documentation and/or other materials provided
	* with the distribution.
	* * Neither the name of The Linux Foundation nor the names of its
	* contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
	* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	/*****************************************************************************
	*
	* This file contains main functions to support FM HCI interface to send
	* commands and recieved events.
	*
	*****************************************************************************/

	#define LOG_TAG "fm_hci"

	#include <queue> // std::queue
	#include <mutex> // std::mutex, std::unique_lock
	#include <condition_variable> // std::condition_variable
	#include <cstdlib>
	#include <thread>

	#include <utils/Log.h>
	#include <unistd.h>

	#include <vendor/qti/hardware/fm/1.0/IFmHci.h>
	#include <vendor/qti/hardware/fm/1.0/IFmHciCallbacks.h>
	#include <vendor/qti/hardware/fm/1.0/types.h>
	#include "fm_hci.h"

	#include <hwbinder/ProcessState.h>

	using vendor::qti::hardware::fm::V1_0::IFmHci;
	using vendor::qti::hardware::fm::V1_0::IFmHciCallbacks;
	using vendor::qti::hardware::fm::V1_0::HciPacket;
	using vendor::qti::hardware::fm::V1_0::Status;
	using android::hardware::ProcessState;
	using ::android::hardware::Return;
	using ::android::hardware::Void;
	using ::android::hardware::hidl_vec;

	static struct fm_hci_t hci;

	typedef std::unique_lock<std::mutex> Lock;
	android::sp<IFmHci> fmHci;

	static int enqueue_fm_rx_event(struct fm_event_header_t *hdr);
	static void dequeue_fm_rx_event();
	static int enqueue_fm_tx_cmd(struct fm_command_header_t *hdr);
	static void dequeue_fm_tx_cmd();
	static void hci_tx_thread();
	static void hci_rx_thread();
	static int start_tx_thread();
	static void stop_tx_thread();
	static int start_rx_thread();
	static void stop_rx_thread();
	static void cleanup_threads();
	static bool hci_initialize();
	static void hci_transmit(struct fm_command_header_t *hdr);
	static void hci_close();

	/*******************************************************************************
	**
	** Function enqueue_fm_rx_event
	**
	** Description This function is called in the hal daemon context to queue
	** FM events in RX queue.
	**
	** Parameters: hdr - contains the fm event header pointer
	**
	**
	** Returns int
	**
	*******************************************************************************/
	static int enqueue_fm_rx_event(struct fm_event_header_t *hdr)
	{

	ALOGI("%s: putting lock before enqueue ", __func__);
	hci.rx_cond_mtx.lock();
	hci.rx_event_queue.push(hdr);
	hci.rx_cond_mtx.unlock();
	ALOGI("%s:notify to waiting thred", __func__);
	hci.rx_cond.notify_all();
	ALOGI("%s: FM-Event ENQUEUED SUCCESSFULLY", __func__);

	return FM_HC_STATUS_SUCCESS;
	}

	/*******************************************************************************
	**
	** Function dequeue_fm_rx_event
	**
	** Description This function is called in the rx thread context to dequeue
	** FM events from RX queue & processing the FM event.
	**
	** Parameters: void
	**
	**
	** Returns void
	**
	*******************************************************************************/
	static void dequeue_fm_rx_event()
	{
	fm_event_header_t *evt_buf;

	ALOGI("%s", __func__);
	while (1) {
	if (hci.rx_event_queue.empty()) {
	ALOGI("No more FM Events are available in the RX Queue");
	return;
	} else {
	}

	evt_buf = hci.rx_event_queue.front();
	hci.rx_event_queue.pop();

	if (evt_buf->evt_code == FM_CMD_COMPLETE) {
	ALOGI("%s: FM_CMD_COMPLETE: current_credits %d, %d Credits got from the SOC", __func__, hci.command_credits, evt_buf->params[0]);
	if (hci.command_credits == 0) {
	hci.command_credits += evt_buf->params[0];
	ALOGI(" dequeue_fm_rx_event: wait for tx_cond_lock ");
	hci.tx_cond_mtx.lock();
	ALOGI(" dequeue_fm_rx_event: Notifying tx_cond_lock ");
	hci.tx_cond.notify_all();
	ALOGI(" dequeue_fm_rx_event: UNLOCKING tx_cond_lock ");
	hci.tx_cond_mtx.unlock();
	} else {
	hci.command_credits += evt_buf->params[0];
	}

	} else if (evt_buf->evt_code == FM_CMD_STATUS) {
	ALOGI("%s: FM_CMD_STATUS: current_credits %d, %d Credits got from the SOC", __func__, hci.command_credits, evt_buf->params[1]);
	if (hci.command_credits == 0) {
	hci.command_credits += evt_buf->params[1];
	ALOGI(" dequeue_fm_rx_event: wait for tx_cond_lock ");
	hci.tx_cond_mtx.lock();
	ALOGI(" dequeue_fm_rx_event: Notifying tx_cond_lock ");
	hci.tx_cond.notify_all();
	ALOGI(" dequeue_fm_rx_event: UNLOCKING tx_cond_lock ");
	hci.tx_cond_mtx.unlock();
	} else {
	hci.command_credits += evt_buf->params[1];
	}
	} else if (evt_buf->evt_code == FM_HW_ERR_EVENT) {
	ALOGI("%s: FM H/w Err Event Recvd. Event Code: 0x%x", __func__, evt_buf->evt_code);
	} else {
	ALOGE("%s: Not CS/CC Event: Recvd. Event Code: 0x%x", __func__, evt_buf->evt_code);
	}

	if (hci.cb && hci.cb->process_event) {
	ALOGI("%s: processing the event", __func__);
	hci.cb->process_event(NULL, (uint8_t *)evt_buf);
	}

	free(evt_buf);
	evt_buf = NULL;
	}

	}

	/*******************************************************************************
	**
	** Function enqueue_fm_tx_cmd
	**
	** Description This function is called in the application JNI context to
	** queue FM commands in TX queue.
	**
	** Parameters: hdr - contains the fm command header pointer
	**
	**
	** Returns int
	**
	*******************************************************************************/
	static int enqueue_fm_tx_cmd(struct fm_command_header_t *hdr)
	{
	ALOGI("%s: opcode 0x%x len:%d ", __func__, hdr->opcode, hdr->len);

	hci.tx_queue_mtx.lock();
	hci.tx_cmd_queue.push(hdr);
	hci.tx_queue_mtx.unlock();

	ALOGI("%s: notifying credits %d", __func__, hci.command_credits);
	if (hci.command_credits > 0) {
	ALOGI(" enqueue_fm_tx_cmd: wait for tx_cond_lock ");
	hci.tx_cond_mtx.lock();
	ALOGI(" enqueue_fm_tx_cmd: Notifying tx_cond_lock ");
	hci.tx_cond.notify_all();
	ALOGI(" enqueue_fm_tx_cmd: UNLOCK tx_cond_lock ");
	hci.tx_cond_mtx.unlock();
	}

	ALOGI("%s: FM-CMD ENQUEUED SUCCESSFULLY credits %d", __func__, hci.command_credits);

	return FM_HC_STATUS_SUCCESS;
	}

	/*******************************************************************************
	**
	** Function dequeue_fm_tx_cmd
	**
	** Description This function is called in the tx thread context to dequeue
	** & transmitting FM command to to HAL daemon.
	**
	** Parameters: void
	**
	**
	** Returns void
	**
	*******************************************************************************/
	static void dequeue_fm_tx_cmd()
	{
	fm_command_header_t *hdr;

	ALOGI("%s", __func__);

	while (1)
	{
	ALOGI(" dequeue_fm_tx_cmd: command credits %d ", hci.command_credits);
	if (hci.command_credits == 0) {
	return;
	}
	hci.tx_queue_mtx.lock();
	ALOGI("%s is_que_empty %d", __func__,hci.tx_cmd_queue.empty());
	if(hci.tx_cmd_queue.empty()){
	ALOGI(" %s No more FM CMDs are available in the Queue",__func__);
	hci.tx_queue_mtx.unlock();
	return;
	}

	hdr = hci.tx_cmd_queue.front();
	hci.tx_cmd_queue.pop();
	hci.tx_queue_mtx.unlock();
	ALOGI("%s: packet popped %d credits", __func__,hci.command_credits);


	hci.command_credits--;
	hci_transmit(hdr);
	ALOGI("%s: packet transmitted %d credits", __func__,hci.command_credits);
	}
	ALOGI(" %s outside while(1), credits %d ", __func__, hci.command_credits);
	}


	/*******************************************************************************
	**
	** Function hci_tx_thread
	**
	** Description This function is main function of tx worker thread.
	**
	** Parameters: void
	**
	**
	** Returns void
	**
	*******************************************************************************/
	static void hci_tx_thread()
	{
	ALOGI("%s: ##### starting hci_tx_thread Worker thread!!! #####", __func__);
	hci.is_tx_thread_running = true;

	Lock lk(hci.tx_cond_mtx);
	while (hci.state != FM_RADIO_DISABLING && hci.state != FM_RADIO_DISABLED) {
	//wait for tx cmd
	ALOGI("%s: before wait %d credits!!!" , __func__,hci.command_credits);
	hci.tx_cond.wait(lk);
	ALOGV("%s: after wait dequeueing the tx cmd!!!" , __func__);
	dequeue_fm_tx_cmd();
	}

	hci.is_tx_thread_running =false;
	ALOGI("%s: ##### Exiting hci_tx_thread Worker thread!!! #####", __func__);
	}

	/*******************************************************************************
	**
	** Function hci_rx_thread
	**
	** Description This function is main function of tx worker thread.
	**
	** Parameters: void
	**
	**
	** Returns void
	**
	*******************************************************************************/
	static void hci_rx_thread()
	{

	ALOGI("%s: ##### starting hci_rx_thread Worker thread!!! #####", __func__);
	hci.is_rx_thread_running = true;

	ALOGI("%s: constr unique_lock ", __func__);
	Lock lk(hci.rx_cond_mtx);
	while (hci.state != FM_RADIO_DISABLING && hci.state != FM_RADIO_DISABLED) {
	//wait for rx event
	ALOGI("%s:before wait", __func__);
	hci.rx_cond.wait(lk);
	ALOGI("%s:after wait ", __func__);
	dequeue_fm_rx_event();
	}

	hci.is_rx_thread_running = false;
	ALOGI("%s: ##### Exiting hci_rx_thread Worker thread!!! #####", __func__);
	}

	/*******************************************************************************
	**
	** Function start_tx_thread
	**
	** Description This function is called to start tx worker thread.
	**
	** Parameters: void
	**
	**
	** Returns int
	**
	*******************************************************************************/
	static int start_tx_thread()
	{

	ALOGI("FM-HCI: Creating the FM-HCI TX TASK...");
	hci.tx_thread_ = std::thread(hci_tx_thread);
	if (!hci.tx_thread_.joinable()) {
	ALOGE("tx thread is not joinable");
	return FM_HC_STATUS_FAIL;
	}

	return FM_HC_STATUS_SUCCESS;
	}

	/*******************************************************************************
	**
	** Function stop_tx_thread
	**
	** Description This function is called to stop tx worker thread.
	**
	** Parameters: void
	**
	**
	** Returns int
	**
	*******************************************************************************/
	static void stop_tx_thread()
	{
	int ret;

	ALOGI("%s:stop_tx_thread ++", __func__);
	hci.tx_cond_mtx.lock();
	hci.tx_cond.notify_all();
	ALOGI("%s:notify to tx thread", __func__);
	hci.tx_cond_mtx.unlock();

	hci.tx_thread_.join();
	ALOGI("%s:stop_tx_thread --", __func__);
	}

	/*******************************************************************************
	**
	** Function start_rx_thread
	**
	** Description This function is called to start rx worker thread.
	**
	** Parameters: void
	**
	**
	** Returns int
	**
	*******************************************************************************/
	static int start_rx_thread()
	{
	int ret = FM_HC_STATUS_SUCCESS;
	ALOGI("FM-HCI: Creating the FM-HCI RX TASK...");

	hci.rx_thread_ = std::thread(hci_rx_thread);
	if (!hci.rx_thread_.joinable()) {
	ALOGE("rx thread is not joinable");
	return FM_HC_STATUS_FAIL;
	}

	return ret;
	}

	/*******************************************************************************
	**
	** Function stop_rx_thread
	**
	** Description This function is called to stop rx worker thread.
	**
	** Parameters: void
	**
	**
	** Returns int
	**
	*******************************************************************************/
	static void stop_rx_thread()
	{
	ALOGI("%s:stop_rx_thread ++", __func__);
	hci.rx_cond.notify_all();

	hci.rx_thread_.join();
	ALOGI("%s:stop_rx_thread --", __func__);
	}

	/*******************************************************************************
	**
	** Function cleanup_threads
	**
	** Description This function is called to cleanup rx & tx worker thread.
	**
	** Parameters: void
	**
	**
	** Returns int
	**
	*******************************************************************************/
	static void cleanup_threads()
	{
	stop_rx_thread();
	stop_tx_thread();
	}

	/*******************************************************************************
	**
	** Function initialization_complete
	**
	** Description This function is called, when initialization complete
	** callback is called by hal daemon.
	**
	** Parameters: hdr - contains the fm event header pointer
	**
	**
	** Returns int
	**
	*******************************************************************************/
	static void initialization_complete(bool is_hci_initialize)
	{
	int ret;
	ALOGI("++%s: is_hci_initialize: %d", __func__, is_hci_initialize);

	while (is_hci_initialize) {
	ret = start_tx_thread();
	if (ret)
	{
	cleanup_threads();
	hci.state = FM_RADIO_DISABLING;
	break;
	}

	ret = start_rx_thread();
	if (ret)
	{
	cleanup_threads();
	hci.state = FM_RADIO_DISABLING;
	break;
	}

	hci.state = FM_RADIO_ENABLED;
	break;
	}

	hci.on_cond.notify_all();
	ALOGI("--%s: is_hci_initialize: %d", __func__, is_hci_initialize);

	}

	/*******************************************************************************
	**
	** Class FmHciCallbacks
	**
	** Description This is main class, which has the implemention for FM HCI
	** callback functions.
	**
	** Member callback Functions: initializationComplete, hciEventReceived
	**
	**
	** Returns int
	**
	*******************************************************************************/
	class FmHciCallbacks : public IFmHciCallbacks {
	public:
	FmHciCallbacks() {
	};
	virtual ~FmHciCallbacks() = default;

	Return<void> initializationComplete(Status status) {
	if(status == Status::SUCCESS)
	{
	initialization_complete(true);
	} else {
	initialization_complete(false);
	}

	return Void();
	}

	Return<void> hciEventReceived(const hidl_vec<uint8_t>& event) {
	struct fm_event_header_t temp = (struct fm_event_header_t ) malloc(event.size());
	if (temp != nullptr) {
	memcpy(temp, event.data(), event.size());
	ALOGI("%s: evt_code: 0x%x", __func__, temp->evt_code);
	enqueue_fm_rx_event(temp);
	} else {
	ALOGE("%s: Memory Allocation failed for event buffer ",__func__);
	}
	return Void();
	}
	};

	/*******************************************************************************
	**
	** Function hci_initialize
	**
	** Description This function is used to initialize fm hci hidl transport.
	** It makes a binder call to hal daemon
	**
	** Parameters: void
	**
	**
	** Returns bool
	**
	*******************************************************************************/
	static bool hci_initialize()
	{
	ALOGI("%s", __func__);

	fmHci = IFmHci::getService();

	if (fmHci != nullptr) {
	hci.state = FM_RADIO_ENABLING;
	android::sp<IFmHciCallbacks> callbacks = new FmHciCallbacks();
	auto hidl_daemon_status = fmHci->initialize(callbacks);
	if(!hidl_daemon_status.isOk()) {
	ALOGE("%s: HIDL daemon is dead", __func__);
	}
	return true;
	} else {
	return false;
	}
	}

	/*******************************************************************************
	**
	** Function hci_transmit
	**
	** Description This function is used to send fm command to fm hci hidl transport.
	** It makes a binder call to hal daemon.
	**
	** Parameters: void
	**
	**
	** Returns void
	**
	*******************************************************************************/
	static void hci_transmit(struct fm_command_header_t *hdr) {
	HciPacket data;

	ALOGI("%s: opcode 0x%x len:%d", __func__, hdr->opcode, hdr->len);

	if (fmHci != nullptr) {
	data.setToExternal((uint8_t *)hdr, 3 + hdr->len);
	auto hidl_daemon_status = fmHci->sendHciCommand(data);
	if(!hidl_daemon_status.isOk()) {
	ALOGE("%s: send Command failed, HIDL daemon is dead", __func__);
	}
	} else {
	ALOGI("%s: fmHci is NULL", __func__);
	}

	free(hdr);
	}

	/*******************************************************************************
	**
	** Function hci_close
	**
	** Description This function is used to close fm hci hidl transport.
	** It makes a binder call to hal daemon
	**
	** Parameters: void
	**
	**
	** Returns void
	**
	*******************************************************************************/
	static void hci_close()
	{
	ALOGI("%s", __func__);

	if (fmHci != nullptr) {
	auto hidl_daemon_status = fmHci->close();
	if(!hidl_daemon_status.isOk()) {
	ALOGE("%s: HIDL daemon is dead", __func__);
	}
	fmHci = nullptr;
	}
	}

	/*******************************************************************************
	**
	** Function fm_hci_init
	**
	** Description This function is used to intialize fm hci
	**
	** Parameters: hci_hal - contains the fm helium hal hci pointer
	**
	**
	** Returns void
	**
	*******************************************************************************/
	int fm_hci_init(fm_hci_hal_t *hci_hal)
	{
	int ret = FM_HC_STATUS_FAIL;

	ALOGD("++%s", __func__);

	if(hci.is_rx_thread_running)
	{
	ALOGI("%s:previous rx thread running wait until rx thread stops", __func__);
	hci.rx_thread_.join();
	ALOGI("%s:stop_rx_thread completed, proceed iniialization", __func__);
	}
	if (!hci_hal \|\| !hci_hal->hal) {
	ALOGE("NULL input argument");
	return FM_HC_STATUS_NULL_POINTER;
	}

	memset(&hci, 0, sizeof(struct fm_hci_t));

	hci.cb = hci_hal->cb;
	hci.command_credits = 1;
	hci.is_tx_thread_running = false;
	hci.is_rx_thread_running = false;
	hci.state = FM_RADIO_DISABLED;
	hci_hal->hci = &hci;

	if (hci_initialize()) {
	//wait for iniialization complete
	ALOGD("--%s waiting for iniialization complete hci state: %d ",
	__func__, hci.state);
	if(hci.state == FM_RADIO_ENABLING){
	Lock lk(hci.on_mtx);
	std::cv_status status = std::cv_status::no_timeout;
	auto now = std::chrono::system_clock::now();
	status =
	hci.on_cond.wait_until(lk, now + std::chrono::seconds(HCI_TIMEOUT));
	if (status == std::cv_status::timeout) {
	ALOGE("hci_initialize failed, kill the fm process");
	kill(getpid(), SIGKILL);
	}
	}
	}

	if (hci.state == FM_RADIO_ENABLED) {
	while (hci.is_tx_thread_running == false
	\|\| hci.is_rx_thread_running == false)
	{
	/* checking tx & rx thread running status after every
	5ms before notifying on to upper layer */
	usleep(5000);
	}
	ALOGD("--%s success", __func__);
	ret = FM_HC_STATUS_SUCCESS;
	} else {
	ALOGD("--%s failed", __func__);
	hci_close();
	hci.state = FM_RADIO_DISABLED;
	}
	return ret;
	}

	/*******************************************************************************
	**
	** Function fm_hci_transmit
	**
	** Description This function is called by helium hal & is used enqueue the
	** tx commands in tx queue.
	**
	** Parameters: p_hci - contains the fm helium hal hci pointer
	** hdr - contains the fm command header pointer
	**
	** Returns void
	**
	*******************************************************************************/
	int fm_hci_transmit(void p_hci, struct fm_command_header_t hdr)
	{
	if (!hdr) {
	ALOGE("NULL input arguments");
	return FM_HC_STATUS_NULL_POINTER;
	}

	return enqueue_fm_tx_cmd(hdr);
	}

	/*******************************************************************************
	**
	** Function fm_hci_close
	**
	** Description This function is used to close & cleanup hci
	**
	** Parameters: p_hci - contains the fm hci pointer
	**
	**
	** Returns void
	**
	*******************************************************************************/
	void fm_hci_close(void *p_hci)
	{
	ALOGI("%s", __func__);
	hci.state = FM_RADIO_DISABLING;

	hci_close();
	stop_tx_thread();

	if (hci.cb && hci.cb->fm_hci_close_done) {
	ALOGI("%s:Notify FM OFF to hal", __func__);
	hci.cb->fm_hci_close_done();
	}

	hci.state = FM_RADIO_DISABLED;
	}