/******************************************************************************
*
* Copyright (C) 2009-2012 Broadcom Corporation
*
* 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.
*
******************************************************************************/
/******************************************************************************
*
* Filename: userial.c
*
* Description: Contains open/read/write/close functions on serial port
*
******************************************************************************/
#define LOG_TAG "bt_userial"
#include <utils/Log.h>
#include <pthread.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <sys/socket.h>
#include "bt_hci_bdroid.h"
#include "userial.h"
#include "utils.h"
#include "bt_vendor_lib.h"
#include <sys/prctl.h>
/******************************************************************************
** Constants & Macros
******************************************************************************/
#ifndef USERIAL_DBG
#define USERIAL_DBG FALSE
#endif
#if (USERIAL_DBG == TRUE)
#define USERIALDBG(param, ...) {ALOGD(param, ## __VA_ARGS__);}
#else
#define USERIALDBG(param, ...) {}
#endif
#ifndef ENABLE_USERIAL_TIMING_LOGS
#define ENABLE_USERIAL_TIMING_LOGS FALSE
#endif
#define MAX_SERIAL_PORT (USERIAL_PORT_3 + 1)
#define READ_LIMIT (BTHC_USERIAL_READ_MEM_SIZE - BT_HC_HDR_SIZE)
enum {
USERIAL_RX_EXIT,
USERIAL_RX_FLOW_OFF,
USERIAL_RX_FLOW_ON
};
/******************************************************************************
** Externs
******************************************************************************/
extern bt_vendor_interface_t *bt_vnd_if;
/******************************************************************************
** Local type definitions
******************************************************************************/
typedef struct
{
int fd;
uint8_t port;
pthread_t read_thread;
BUFFER_Q rx_q;
HC_BT_HDR *p_rx_hdr;
} tUSERIAL_CB;
/******************************************************************************
** Static variables
******************************************************************************/
static tUSERIAL_CB userial_cb;
static volatile uint8_t userial_running = 0;
/******************************************************************************
** Static functions
******************************************************************************/
#if defined(ENABLE_USERIAL_TIMING_LOGS) && (ENABLE_USERIAL_TIMING_LOGS==TRUE)
static void log_userial_tx_timing(int len)
{
#define USEC_PER_SEC 1000000L
static struct timespec prev = {0, 0};
struct timespec now, diff;
unsigned int diff_us = 0;
unsigned int now_us = 0;
clock_gettime(CLOCK_MONOTONIC, &now);
now_us = now.tv_sec*USEC_PER_SEC + now.tv_nsec/1000;
diff_us = (now.tv_sec - prev.tv_sec) * USEC_PER_SEC + (now.tv_nsec - prev.tv_nsec)/1000;
ALOGW("[userial] ts %08d diff : %08d len %d", now_us, diff_us,
len);
prev = now;
}
#endif
/*****************************************************************************
** Socket signal functions to wake up userial_read_thread for termination
**
** creating an unnamed pair of connected sockets
** - signal_fds[0]: join fd_set in select call of userial_read_thread
** - signal_fds[1]: trigger from userial_close
*****************************************************************************/
static int signal_fds[2]={0,1};
static uint8_t rx_flow_on = TRUE;
static inline int create_signal_fds(fd_set* set)
{
if(signal_fds[0]==0 && socketpair(AF_UNIX, SOCK_STREAM, 0, signal_fds)<0)
{
ALOGE("create_signal_sockets:socketpair failed, errno: %d", errno);
return -1;
}
FD_SET(signal_fds[0], set);
return signal_fds[0];
}
static inline int send_wakeup_signal(char sig_cmd)
{
return send(signal_fds[1], &sig_cmd, sizeof(sig_cmd), 0);
}
static inline char reset_signal()
{
char sig_recv = -1;
recv(signal_fds[0], &sig_recv, sizeof(sig_recv), MSG_WAITALL);
return sig_recv;
}
static inline int is_signaled(fd_set* set)
{
return FD_ISSET(signal_fds[0], set);
}
/*******************************************************************************
**
** Function select_read
**
** Description check if fd is ready for reading and listen for termination
** signal. need to use select in order to avoid collision
** between read and close on the same fd
**
** Returns -1: termination
** >=0: numbers of bytes read back from fd
**
*******************************************************************************/
static int select_read(int fd, uint8_t *pbuf, int len)
{
fd_set input;
int n = 0, ret = -1;
char reason = 0;
while (userial_running)
{
/* Initialize the input fd set */
FD_ZERO(&input);
if (rx_flow_on == TRUE)
{
FD_SET(fd, &input);
}
int fd_max = create_signal_fds(&input);
fd_max = fd_max > fd ? fd_max : fd;
/* Do the select */
n = select(fd_max+1, &input, NULL, NULL, NULL);
if(is_signaled(&input))
{
reason = reset_signal();
if (reason == USERIAL_RX_EXIT)
{
USERIALDBG("RX termination");
return -1;
}
else if (reason == USERIAL_RX_FLOW_OFF)
{
USERIALDBG("RX flow OFF");
rx_flow_on = FALSE;
}
else if (reason == USERIAL_RX_FLOW_ON)
{
USERIALDBG("RX flow ON");
rx_flow_on = TRUE;
}
}
if (n > 0)
{
/* We might have input */
if (FD_ISSET(fd, &input))
{
ret = read(fd, pbuf, (size_t)len);
if (0 == ret)
ALOGW( "read() returned 0!" );
return ret;
}
}
else if (n < 0)
ALOGW( "select() Failed");
else if (n == 0)
ALOGW( "Got a select() TIMEOUT");
}
return ret;
}
/*******************************************************************************
**
** Function userial_read_thread
**
** Description
**
** Returns void *
**
*******************************************************************************/
static void *userial_read_thread(void *arg)
{
int rx_length = 0;
HC_BT_HDR *p_buf = NULL;
uint8_t *p;
USERIALDBG("Entering userial_read_thread()");
prctl(PR_SET_NAME, (unsigned long)"userial_read", 0, 0, 0);
rx_flow_on = TRUE;
userial_running = 1;
while (userial_running)
{
if (bt_hc_cbacks)
{
p_buf = (HC_BT_HDR *) bt_hc_cbacks->alloc( \
BTHC_USERIAL_READ_MEM_SIZE);
}
else
p_buf = NULL;
if (p_buf != NULL)
{
p_buf->offset = 0;
p_buf->layer_specific = 0;
p = (uint8_t *) (p_buf + 1);
rx_length = select_read(userial_cb.fd, p, READ_LIMIT);
}
else
{
rx_length = 0;
utils_delay(100);
ALOGW("userial_read_thread() failed to gain buffers");
continue;
}
if (rx_length > 0)
{
p_buf->len = (uint16_t)rx_length;
utils_enqueue(&(userial_cb.rx_q), p_buf);
bthc_signal_event(HC_EVENT_RX);
}
else /* either 0 or < 0 */
{
ALOGW("select_read return size <=0:%d, exiting userial_read_thread",\
rx_length);
/* if we get here, we should have a buffer */
bt_hc_cbacks->dealloc((TRANSAC) p_buf, (char *) (p_buf + 1));
/* negative value means exit thread */
break;
}
} /* for */
userial_running = 0;
USERIALDBG("Leaving userial_read_thread()");
pthread_exit(NULL);
return NULL; // Compiler friendly
}
/*****************************************************************************
** Userial API Functions
*****************************************************************************/
/*******************************************************************************
**
** Function userial_init
**
** Description Initializes the userial driver
**
** Returns TRUE/FALSE
**
*******************************************************************************/
uint8_t userial_init(void)
{
USERIALDBG("userial_init");
memset(&userial_cb, 0, sizeof(tUSERIAL_CB));
userial_cb.fd = -1;
utils_queue_init(&(userial_cb.rx_q));
return TRUE;
}
/*******************************************************************************
**
** Function userial_open
**
** Description Open Bluetooth device with the port ID
**
** Returns TRUE/FALSE
**
*******************************************************************************/
uint8_t userial_open(uint8_t port)
{
struct sched_param param;
int policy, result;
pthread_attr_t thread_attr;
int fd_array[CH_MAX];
USERIALDBG("userial_open(port:%d)", port);
if (userial_running)
{
/* Userial is open; close it first */
userial_close();
utils_delay(50);
}
if (port >= MAX_SERIAL_PORT)
{
ALOGE("Port > MAX_SERIAL_PORT");
return FALSE;
}
/* Calling vendor-specific part */
if (bt_vnd_if)
{
result = bt_vnd_if->op(BT_VND_OP_USERIAL_OPEN, &fd_array);
if (result != 1)
{
ALOGE("userial_open: wrong numbers of open fd in vendor lib [%d]!",
result);
ALOGE("userial_open: HCI UART expects only one open fd");
bt_vnd_if->op(BT_VND_OP_USERIAL_CLOSE, NULL);
return FALSE;
}
userial_cb.fd = fd_array[0];
}
else
{
ALOGE("userial_open: missing vendor lib interface !!!");
ALOGE("userial_open: unable to open UART port");
return FALSE;
}
if (userial_cb.fd == -1)
{
ALOGE("userial_open: failed to open UART port");
return FALSE;
}
USERIALDBG( "fd = %d", userial_cb.fd);
userial_cb.port = port;
pthread_attr_init(&thread_attr);
if (pthread_create(&(userial_cb.read_thread), &thread_attr, \
userial_read_thread, NULL) != 0 )
{
ALOGE("pthread_create failed!");
return FALSE;
}
if(pthread_getschedparam(userial_cb.read_thread, &policy, ¶m)==0)
{
policy = BTHC_LINUX_BASE_POLICY;
#if (BTHC_LINUX_BASE_POLICY!=SCHED_NORMAL)
param.sched_priority = BTHC_USERIAL_READ_THREAD_PRIORITY;
#endif
result = pthread_setschedparam(userial_cb.read_thread, policy, ¶m);
if (result != 0)
{
ALOGW("userial_open: pthread_setschedparam failed (%s)", \
strerror(result));
}
}
return TRUE;
}
/*******************************************************************************
**
** Function userial_read
**
** Description Read data from the userial port
**
** Returns Number of bytes actually read from the userial port and
** copied into p_data. This may be less than len.
**
*******************************************************************************/
uint16_t userial_read(uint16_t msg_id, uint8_t *p_buffer, uint16_t len)
{
uint16_t total_len = 0;
uint16_t copy_len = 0;
uint8_t *p_data = NULL;
do
{
if(userial_cb.p_rx_hdr != NULL)
{
p_data = ((uint8_t *)(userial_cb.p_rx_hdr + 1)) + \
(userial_cb.p_rx_hdr->offset);
if((userial_cb.p_rx_hdr->len) <= (len - total_len))
copy_len = userial_cb.p_rx_hdr->len;
else
copy_len = (len - total_len);
memcpy((p_buffer + total_len), p_data, copy_len);
total_len += copy_len;
userial_cb.p_rx_hdr->offset += copy_len;
userial_cb.p_rx_hdr->len -= copy_len;
if(userial_cb.p_rx_hdr->len == 0)
{
if (bt_hc_cbacks)
bt_hc_cbacks->dealloc((TRANSAC) userial_cb.p_rx_hdr, \
(char *) (userial_cb.p_rx_hdr+1));
userial_cb.p_rx_hdr = NULL;
}
}
if(userial_cb.p_rx_hdr == NULL)
{
userial_cb.p_rx_hdr=(HC_BT_HDR *)utils_dequeue(&(userial_cb.rx_q));
}
} while ((userial_cb.p_rx_hdr != NULL) && (total_len < len));
return total_len;
}
/*******************************************************************************
**
** Function userial_write
**
** Description Write data to the userial port
**
** Returns Number of bytes actually written to the userial port. This
** may be less than len.
**
*******************************************************************************/
uint16_t userial_write(uint16_t msg_id, uint8_t *p_data, uint16_t len)
{
int ret, total = 0;
while(len != 0)
{
#if defined(ENABLE_USERIAL_TIMING_LOGS) && (ENABLE_USERIAL_TIMING_LOGS==TRUE)
log_userial_tx_timing(len);
#endif
ret = write(userial_cb.fd, p_data+total, len);
total += ret;
len -= ret;
}
return ((uint16_t)total);
}
/*******************************************************************************
**
** Function userial_close
**
** Description Close the userial port
**
** Returns None
**
*******************************************************************************/
void userial_close(void)
{
int result;
TRANSAC p_buf;
USERIALDBG("userial_close(fd:%d)", userial_cb.fd);
if (userial_running)
send_wakeup_signal(USERIAL_RX_EXIT);
if ((result=pthread_join(userial_cb.read_thread, NULL)) < 0)
ALOGE( "pthread_join() FAILED result:%d", result);
/* Calling vendor-specific part */
if (bt_vnd_if)
bt_vnd_if->op(BT_VND_OP_USERIAL_CLOSE, NULL);
userial_cb.fd = -1;
if (bt_hc_cbacks)
{
while ((p_buf = utils_dequeue (&(userial_cb.rx_q))) != NULL)
{
bt_hc_cbacks->dealloc(p_buf, (char *) ((HC_BT_HDR *)p_buf+1));
}
}
}
/*******************************************************************************
**
** Function userial_ioctl
**
** Description ioctl inteface
**
** Returns None
**
*******************************************************************************/
void userial_ioctl(userial_ioctl_op_t op, void *p_data)
{
switch(op)
{
case USERIAL_OP_RXFLOW_ON:
if (userial_running)
send_wakeup_signal(USERIAL_RX_FLOW_ON);
break;
case USERIAL_OP_RXFLOW_OFF:
if (userial_running)
send_wakeup_signal(USERIAL_RX_FLOW_OFF);
break;
case USERIAL_OP_INIT:
default:
break;
}
}