Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 38d15691 authored by Jakub Pawlowski's avatar Jakub Pawlowski Committed by android-build-merger
Browse files

Merge "Keep UIPC in local variable, rather than global struct." am: bc9ecb57 

am: 3d20c900

Change-Id: I3f276195258d503072a4b3d7876e95fa349e782e
parents f3954d4e 3d20c900

system/btif/src/btif_a2dp_control.cc

+37 −30
Original line number Diff line number Diff line
@@ -48,15 +48,16 @@ static void btif_a2dp_ctrl_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event); 


/* We can have max one command pending */

static tA2DP_CTRL_CMD a2dp_cmd_pending = A2DP_CTRL_CMD_NONE;

std::unique_ptr<tUIPC_STATE> a2dp_uipc;



void btif_a2dp_control_init(void) {

  UIPC_Init(NULL, UIPC_USER_A2DP);

  UIPC_Open(UIPC_CH_ID_AV_CTRL, btif_a2dp_ctrl_cb);

  a2dp_uipc = UIPC_Init();

  UIPC_Open(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, btif_a2dp_ctrl_cb);

}



void btif_a2dp_control_cleanup(void) {

  /* This calls blocks until UIPC is fully closed */

  UIPC_Close(UIPC_CH_ID_ALL, UIPC_USER_A2DP);

  UIPC_Close(*a2dp_uipc, UIPC_CH_ID_ALL);

}



static void btif_a2dp_recv_ctrl_data(void) {
@@ -64,13 +65,13 @@ static void btif_a2dp_recv_ctrl_data(void) { 
  int n;



  uint8_t read_cmd = 0; /* The read command size is one octet */

  n = UIPC_Read(UIPC_CH_ID_AV_CTRL, NULL, &read_cmd, 1);

  n = UIPC_Read(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, NULL, &read_cmd, 1);

  cmd = static_cast<tA2DP_CTRL_CMD>(read_cmd);



  /* detach on ctrl channel means audioflinger process was terminated */

  if (n == 0) {

    APPL_TRACE_WARNING("%s: CTRL CH DETACHED", __func__);

    UIPC_Close(UIPC_CH_ID_AV_CTRL, UIPC_USER_A2DP);

    UIPC_Close(*a2dp_uipc, UIPC_CH_ID_AV_CTRL);

    return;

  }
@@ -117,7 +118,7 @@ static void btif_a2dp_recv_ctrl_data(void) { 


      if (btif_av_stream_ready()) {

        /* Setup audio data channel listener */

        UIPC_Open(UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb);

        UIPC_Open(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb);



        /*

         * Post start event and wait for audio path to open.
@@ -135,7 +136,7 @@ static void btif_a2dp_recv_ctrl_data(void) { 
         * Already started, setup audio data channel listener and ACK

         * back immediately.

         */

        UIPC_Open(UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb);

        UIPC_Open(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb);

        btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);

        break;

      }
@@ -174,9 +175,10 @@ static void btif_a2dp_recv_ctrl_data(void) { 
      tA2DP_CHANNEL_COUNT channel_count = btif_a2dp_sink_get_channel_count();



      btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, reinterpret_cast<uint8_t*>(&sample_rate),

      UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

                reinterpret_cast<uint8_t*>(&sample_rate),

                sizeof(tA2DP_SAMPLE_RATE));

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, &channel_count,

      UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0, &channel_count,

                sizeof(tA2DP_CHANNEL_COUNT));

      break;

    }
@@ -199,24 +201,26 @@ static void btif_a2dp_recv_ctrl_data(void) { 


      btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);

      // Send the current codec config

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0,

      UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

                reinterpret_cast<const uint8_t*>(&codec_config.sample_rate),

                sizeof(btav_a2dp_codec_sample_rate_t));

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0,

      UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

                reinterpret_cast<const uint8_t*>(&codec_config.bits_per_sample),

                sizeof(btav_a2dp_codec_bits_per_sample_t));

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0,

      UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

                reinterpret_cast<const uint8_t*>(&codec_config.channel_mode),

                sizeof(btav_a2dp_codec_channel_mode_t));

      // Send the current codec capability

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0,

      UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

                reinterpret_cast<const uint8_t*>(&codec_capability.sample_rate),

                sizeof(btav_a2dp_codec_sample_rate_t));

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, reinterpret_cast<const uint8_t*>(

                                           &codec_capability.bits_per_sample),

      UIPC_Send(

          *a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

          reinterpret_cast<const uint8_t*>(&codec_capability.bits_per_sample),

          sizeof(btav_a2dp_codec_bits_per_sample_t));

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, reinterpret_cast<const uint8_t*>(

                                           &codec_capability.channel_mode),

      UIPC_Send(

          *a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

          reinterpret_cast<const uint8_t*>(&codec_capability.channel_mode),

          sizeof(btav_a2dp_codec_channel_mode_t));

      break;

    }
@@ -229,7 +233,7 @@ static void btif_a2dp_recv_ctrl_data(void) { 


      btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);

      // Send the current codec config

      if (UIPC_Read(UIPC_CH_ID_AV_CTRL, 0,

      if (UIPC_Read(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

                    reinterpret_cast<uint8_t*>(&codec_config.sample_rate),

                    sizeof(btav_a2dp_codec_sample_rate_t)) !=

          sizeof(btav_a2dp_codec_sample_rate_t)) {
@@ -237,7 +241,7 @@ static void btif_a2dp_recv_ctrl_data(void) { 
                         __func__);

        break;

      }

      if (UIPC_Read(UIPC_CH_ID_AV_CTRL, 0,

      if (UIPC_Read(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

                    reinterpret_cast<uint8_t*>(&codec_config.bits_per_sample),

                    sizeof(btav_a2dp_codec_bits_per_sample_t)) !=

          sizeof(btav_a2dp_codec_bits_per_sample_t)) {
@@ -245,7 +249,7 @@ static void btif_a2dp_recv_ctrl_data(void) { 
                         __func__);

        break;

      }

      if (UIPC_Read(UIPC_CH_ID_AV_CTRL, 0,

      if (UIPC_Read(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

                    reinterpret_cast<uint8_t*>(&codec_config.channel_mode),

                    sizeof(btav_a2dp_codec_channel_mode_t)) !=

          sizeof(btav_a2dp_codec_channel_mode_t)) {
@@ -270,17 +274,19 @@ static void btif_a2dp_recv_ctrl_data(void) { 
    case A2DP_CTRL_GET_PRESENTATION_POSITION: {

      btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);



      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0,

      UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

                (uint8_t*)&(delay_report_stats.total_bytes_read),

                sizeof(uint64_t));

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0,

      UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,

                (uint8_t*)&(delay_report_stats.audio_delay), sizeof(uint16_t));



      uint32_t seconds = delay_report_stats.timestamp.tv_sec;

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, (uint8_t*)&seconds, sizeof(seconds));

      UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0, (uint8_t*)&seconds,

                sizeof(seconds));



      uint32_t nsec = delay_report_stats.timestamp.tv_nsec;

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, (uint8_t*)&nsec, sizeof(nsec));

      UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0, (uint8_t*)&nsec,

                sizeof(nsec));

      break;

    }

    default:
@@ -304,7 +310,7 @@ static void btif_a2dp_ctrl_cb(UNUSED_ATTR tUIPC_CH_ID ch_id, 
    case UIPC_CLOSE_EVT:

      /* restart ctrl server unless we are shutting down */

      if (btif_a2dp_source_media_task_is_running())

        UIPC_Open(UIPC_CH_ID_AV_CTRL, btif_a2dp_ctrl_cb);

        UIPC_Open(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, btif_a2dp_ctrl_cb);

      break;



    case UIPC_RX_DATA_READY_EVT:
@@ -329,8 +335,9 @@ static void btif_a2dp_data_cb(UNUSED_ATTR tUIPC_CH_ID ch_id, 
       * Read directly from media task from here on (keep callback for

       * connection events.

       */

      UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REG_REMOVE_ACTIVE_READSET, NULL);

      UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_SET_READ_POLL_TMO,

      UIPC_Ioctl(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO,

                 UIPC_REG_REMOVE_ACTIVE_READSET, NULL);

      UIPC_Ioctl(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO, UIPC_SET_READ_POLL_TMO,

                 reinterpret_cast<void*>(A2DP_DATA_READ_POLL_MS));



      if (btif_av_get_peer_sep() == AVDT_TSEP_SNK) {
@@ -378,7 +385,7 @@ void btif_a2dp_command_ack(tA2DP_CTRL_ACK status) { 
  a2dp_cmd_pending = A2DP_CTRL_CMD_NONE;



  /* Acknowledge start request */

  UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, &ack, sizeof(ack));

  UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0, &ack, sizeof(ack));

}



void btif_a2dp_control_log_bytes_read(uint32_t bytes_read) {

system/btif/src/btif_a2dp_source.cc

+7 −4
Original line number Diff line number Diff line
@@ -52,6 +52,8 @@ 
using system_bt_osi::BluetoothMetricsLogger;

using system_bt_osi::A2dpSessionMetrics;



extern std::unique_ptr<tUIPC_STATE> a2dp_uipc;



/**

 * The typical runlevel of the tx queue size is ~1 buffer

 * but due to link flow control or thread preemption in lower
@@ -694,13 +696,13 @@ static void btif_a2dp_source_audio_tx_stop_event(void) { 


  // Keep track of audio data still left in the pipe

  btif_a2dp_control_log_bytes_read(

      UIPC_Read(UIPC_CH_ID_AV_AUDIO, &event, p_buf, sizeof(p_buf)));

      UIPC_Read(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO, &event, p_buf, sizeof(p_buf)));



  /* Stop the timer first */

  alarm_free(btif_a2dp_source_cb.media_alarm);

  btif_a2dp_source_cb.media_alarm = nullptr;



  UIPC_Close(UIPC_CH_ID_AV_AUDIO, UIPC_USER_A2DP);

  UIPC_Close(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO);



  /*

   * Try to send acknowldegment once the media stream is
@@ -759,7 +761,8 @@ static void btif_a2dp_source_audio_handle_timer(void) { 


static uint32_t btif_a2dp_source_read_callback(uint8_t* p_buf, uint32_t len) {

  uint16_t event;

  uint32_t bytes_read = UIPC_Read(UIPC_CH_ID_AV_AUDIO, &event, p_buf, len);

  uint32_t bytes_read =

      UIPC_Read(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO, &event, p_buf, len);



  if (bytes_read < len) {

    LOG_WARN(LOG_TAG, "%s: UNDERFLOW: ONLY READ %d BYTES OUT OF %d", __func__,
@@ -869,7 +872,7 @@ static void btif_a2dp_source_audio_tx_flush_event(void) { 
      time_get_os_boottime_us();

  fixed_queue_flush(btif_a2dp_source_cb.tx_audio_queue, osi_free);



  UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REQ_RX_FLUSH, nullptr);

  UIPC_Ioctl(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO, UIPC_REQ_RX_FLUSH, nullptr);

}



static bool btif_a2dp_source_audio_tx_flush_req(void) {

system/udrv/include/uipc.h

+30 −16
Original line number Diff line number Diff line
@@ -37,13 +37,6 @@ typedef enum { 
  UIPC_TX_DATA_READY_EVT = 0x0010

} tUIPC_EVENT;



/* UIPC users */

typedef enum {

  UIPC_USER_A2DP = 0,

  UIPC_USER_HEARING_AID = 1,

  UIPC_USER_NUM = 2

} tUIPC_USER;



/*

 * UIPC IOCTL Requests

 */
@@ -62,12 +55,33 @@ typedef void(tUIPC_RCV_CBACK)( 


const char* dump_uipc_event(tUIPC_EVENT event);



typedef struct {

  int srvfd;

  int fd;

  int read_poll_tmo_ms;

  int task_evt_flags; /* event flags pending to be processed in read task */

  tUIPC_RCV_CBACK* cback;

} tUIPC_CHAN;



struct tUIPC_STATE {

  pthread_t tid; /* main thread id */

  int running;

  std::recursive_mutex mutex;



  fd_set active_set;

  fd_set read_set;

  int max_fd;

  int signal_fds[2];



  tUIPC_CHAN ch[UIPC_CH_NUM];

};



/**

 * Initialize UIPC module

 *

 * @param user User ID who uses UIPC

 */

void UIPC_Init(void*, int user);

std::unique_ptr<tUIPC_STATE> UIPC_Init();



/**

 * Open a UIPC channel
@@ -76,15 +90,14 @@ void UIPC_Init(void*, int user); 
 * @param p_cback Callback handler

 * @return true on success, otherwise false

 */

bool UIPC_Open(tUIPC_CH_ID ch_id, tUIPC_RCV_CBACK* p_cback);

bool UIPC_Open(tUIPC_STATE& uipc, tUIPC_CH_ID ch_id, tUIPC_RCV_CBACK* p_cback);



/**

 * Closes a channel in UIPC or the entire UIPC module

 *

 * @param ch_id Channel ID; if ch_id is UIPC_CH_ID_ALL, then cleanup UIPC

 * @param user User ID who uses UIPC

 */

void UIPC_Close(tUIPC_CH_ID ch_id, int user);

void UIPC_Close(tUIPC_STATE& uipc, tUIPC_CH_ID ch_id);



/**

 * Send a message over UIPC
@@ -95,8 +108,8 @@ void UIPC_Close(tUIPC_CH_ID ch_id, int user); 
 * @param msglen Message length

 * @return true on success, otherwise false

 */

bool UIPC_Send(tUIPC_CH_ID ch_id, uint16_t msg_evt, const uint8_t* p_buf,

               uint16_t msglen);

bool UIPC_Send(tUIPC_STATE& uipc, tUIPC_CH_ID ch_id, uint16_t msg_evt,

               const uint8_t* p_buf, uint16_t msglen);



/**

 * Read a message from UIPC
@@ -107,8 +120,8 @@ bool UIPC_Send(tUIPC_CH_ID ch_id, uint16_t msg_evt, const uint8_t* p_buf, 
 * @param len Bytes to read

 * @return true on success, otherwise false

 */

uint32_t UIPC_Read(tUIPC_CH_ID ch_id, uint16_t* p_msg_evt, uint8_t* p_buf,

                   uint32_t len);

uint32_t UIPC_Read(tUIPC_STATE& uipc, tUIPC_CH_ID ch_id, uint16_t* p_msg_evt,

                   uint8_t* p_buf, uint32_t len);



/**

 * Control the UIPC parameter
@@ -118,6 +131,7 @@ uint32_t UIPC_Read(tUIPC_CH_ID ch_id, uint16_t* p_msg_evt, uint8_t* p_buf, 
 * @param param Optional parameters

 * @return true on success, otherwise false

 */

bool UIPC_Ioctl(tUIPC_CH_ID ch_id, uint32_t request, void* param);

bool UIPC_Ioctl(tUIPC_STATE& uipc, tUIPC_CH_ID ch_id, uint32_t request,

                void* param);



#endif /* UIPC_H */

system/udrv/ulinux/uipc.cc

+144 −191

File changed.

Preview size limit exceeded, changes collapsed.