/*****************************************************************************
* FUNCTION
* btmtk_fs_delete
* DESCRIPTION
*
* PARAMETERS
* fileName [IN]
* RETURNS
*
*****************************************************************************/
S32 btmtk_fs_delete(const U8 *fileName)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
bt_prompt_trace(MOD_BT, "[FS] +btmtk_fs_delete(%s)", fileName);
#ifdef BTMTK_ON_WISE
bt_asc_str_n_to_ucs2_str((S8 *)pathBuf, (S8 *)fileName, FS_MAX_PATH_LEN * sizeof(U16));
return translateFileError(FS_Delete(pathBuf));
#else
translateFilePath(fileName, (U8 *)pathBuf);
if (remove((char *)pathBuf) != 0)
{
bt_prompt_trace(MOD_BT, "[FS] -btmtk_fs_delete failed : %s, errno=%d", strerror(errno), errno);
return BTMTK_FS_ERR;
}
bt_prompt_trace(MOD_BT, "[FS] -btmtk_fs_delete");
return BTMTK_FS_OK;
#endif /* BTMTK_ON_WISE */
}
/*****************************************************************************
* FUNCTION
* btmtk_fs_create_dir
* DESCRIPTION
*
* PARAMETERS
* dirName [IN]
* RETURNS
*
*****************************************************************************/
S32 btmtk_fs_create_dir(const U8 *dirName)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
bt_prompt_trace(MOD_BT, "[FS] +btmtk_fs_create_dir(%s)", dirName);
#ifdef BTMTK_ON_WISE
bt_asc_str_n_to_ucs2_str((S8 *)pathBuf, (S8 *)dirName, FS_MAX_PATH_LEN * sizeof(U16));
return translateFileError(FS_CreateDir(pathBuf));
#else
translateFilePath(dirName, (U8 *)pathBuf);
#ifdef BTMTK_ON_LINUX
if (mkdir((char *)pathBuf, 0777) != 0)
#else
if (_mkdir((char *)pathBuf) != 0)
#endif
{
bt_prompt_trace(MOD_BT, "[FS] -btmtk_fs_create_dir failed : %s, errno=%d", strerror(errno), errno);
return BTMTK_FS_ERR;
}
bt_prompt_trace(MOD_BT, "[FS] -btmtk_fs_create_dir");
return BTMTK_FS_OK;
#endif /* BTMTK_ON_WISE */
}
/*****************************************************************************
* FUNCTION
* btmtk_fs_close
* DESCRIPTION
*
* PARAMETERS
* fd [IN]
* RETURNS
*
*****************************************************************************/
S32 btmtk_fs_close(int fd)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
int handle = bt_file_desc[fd].handle;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (bt_file_desc[fd].used == KAL_FALSE)
{
bt_prompt_trace(MOD_BT, "[FS] +btmtk_fs_close(fd=%d) cannot found fd", fd);
return BTMTK_FS_ERR;
}
bt_prompt_trace(MOD_BT, "[FS] +btmtk_fs_close(fd=%d, handle=0x%X)", fd, handle);
bt_file_desc[fd].used = KAL_FALSE;
bt_file_desc[fd].handle = 0;
#ifdef BTMTK_ON_WISE
return translateFileError(FS_Close(handle));
#else
if (fclose((FILE*) handle) != 0)
{
bt_prompt_trace(MOD_BT, "[FS] -btmtk_fs_close failed : %s, errno=%d", strerror(errno), errno);
return BTMTK_FS_ERR;
}
return BTMTK_FS_OK;
#endif
}
static void waitWholeChipResetComplete(){
int res = 0;
char tmp;
/*
fd_set readfs;
FD_ZERO(&readfs);
FD_SET(commPort, &readfs);
do{
res = select(commPort+1,&readfs, NULL, NULL, NULL);
}while((res < 0 && errno == EAGAIN));
*/
do{
res = read(commPort, &tmp, 1);
if( res < 0 ){
if( errno == 99 ){
bt_prompt_trace(MOD_BT, "[RESET] 99 (WholeChipReset completed)");
return;
}else if(errno == 88){
bt_prompt_trace(MOD_BT, "[RESET] 88 usleep(1000)");
usleep(10000);
}else if(errno != EAGAIN){
break;
}
}else{
break;
}
}while(1);
bt_prompt_trace(MOD_BT, "[RESET] 99 (WholeChipReset completed) not waited : %d : errno=%d", res, errno);
}
/* restore bt driver */
if(commPort >= 0) {
lib_handle = getDriverHandle();
if(lib_handle) {
bt_prompt_trace(MOD_BT, "Start to restore bt driver");
SetUartSetup = dlsym(lib_handle, "SetUartSetup");
bt_restore = dlsym(lib_handle, "bt_restore");
if(bt_restore && SetUartSetup) {
setUartBlockMode(commPort, 1);
SetUartSetup(setup_uart_param);
bt_restore(commPort);
} else {
bt_prompt_trace(MOD_BT, "[ERR] can locate bt_restore function");
}
}
} else {
bt_prompt_trace(MOD_BT, "commPort is invalid when GORM_Shutdown");
}
//bt_prompt_trace(MOD_BT, "+GORM_Shutdown");
BTUartLinuxShutdown();
//bt_prompt_trace("set_bluetooth_power(0)");
if( set_bluetooth_power(0) < 0)
{
//bt_prompt_trace(MOD_BT, "[ERR] failed to set bt power");
return BT_STATUS_FAILED;
}
//bt_prompt_trace(MOD_BT, "-GORM_Shutdown");
#else
BTUartLinuxShutdown();
#endif /* __MTK_STP_SUPPORTED__ */
#endif /* !defined(__ANDROID_EMULATOR__) */
return BT_STATUS_SUCCESS;
}
#if defined(__ENABLE_SLEEP_MODE__)
static HciCommandType wOpCode2; /* Opcode of HCI command sent from init
* script.
*/
static HciReducedCommand hciHostWakeupCmd; /* Structure for sending commands. Only
* one command can be sent at a time.
*/
void Radio_hostWakeup(void)
{
HciCommandType wOpCode_enc;
/*
if((stack_query_boot_mode() != FACTORY_BOOT)
&&(0==bt_MMI_RFtest_mode)
)*/
{
bt_prompt_trace(MOD_BT, "[SM] Radio_hostWakeup");
wOpCode2 = 0xFCC1;
hciHostWakeupCmd.parms[0] = 0;
// Assert(IsEntryAvailable(&hciHostWakeupCmd.node));
//Call host provided interface to send host wakeup dummy command
if (IsEntryAvailable(&hciHostWakeupCmd.node))
{
bt_prompt_trace(MOD_BT, "[SM] IsEntryAvailable(&hciHostWakeupCmd.node) return true");
//Encrypt HCI commands
if (/*enc_state >= START_CMD_ENC*/ 1)
{
wOpCode_enc = BT_XFile_EncryptionCommandOpcode(wOpCode2);
}
else
{
wOpCode_enc = wOpCode2;
}
#ifdef __ENABLE_SLEEP_MODE__ /* avoid compile error */
HCI_HostWakeupStartTimer();
#endif /* __ENABLE_SLEEP_MODE__ */
HciTransmitCommand(wOpCode_enc, 0, (HciCommand *)&hciHostWakeupCmd, TRUE, FALSE );
}
}
}
/*static char packetbuf[1024];*/
unsigned short BTUartLinuxWrite(const unsigned char *buffer, unsigned short length)
{
int nWritten = 0;
int bytesToWrite;
U16 i;
unsigned char *ptr;
bytesToWrite = length;
/*
ptr = packetbuf;
for(i = 0;i < length;i++)
{
sprintf(ptr, "%02X ", buffer[i]);
ptr+=3;
}
//bt_prompt_trace(MOD_BT, "[BT] Write %d bytes to uart", length);
bt_prompt_trace(MOD_BT, "[BT] Write to uart %d : \"%s\"", commPort, packetbuf);
*/
if(commPort < 0)
{
bt_prompt_trace(MOD_BT, "Write com after closed");
return 0;
}
while(bytesToWrite > 0)
{
bt_prompt_trace_lv3(MOD_BT, "[BT] Start write to uart buffer=0x%x, bytesToWrite=%d", buffer, bytesToWrite);
nWritten = write(commPort, buffer, bytesToWrite);
if (nWritten > 0)
{
bt_prompt_trace_lv3(MOD_BT, "[BT][UART] %d bytes are written to uart", nWritten);
bytesToWrite -= nWritten;
buffer += nWritten;
}
else
{
bt_prompt_trace(MOD_BT, "[UART] Write uart failed : nWritten=%d, err=%s, errno=%d", nWritten, strerror(errno), errno);
break;
}
}
if(nWritten < 0){
//bt_prompt_trace(MOD_BT, "[RESET] BTUartLinuxWrite return %d, errno=%d", nWritten, errno);
if(errno == 88 || errno == 99){
wholeChipReset(errno);
return 0;
}
}
bt_prompt_trace_lv3(MOD_BT, "[BT][UART] total wrote %d bytes to uart", length - bytesToWrite);
return (length - bytesToWrite);
}
unsigned char BTUartLinuxShutdown(void)
{
bt_prompt_trace(MOD_BT, "[UART] Close UART port : %d", commPort);
if(commPort >= 0)
{
bt_android_log("[UART] Close UART port : %d", commPort);
if( close(commPort) < 0 ) {
bt_prompt_trace(MOD_BT, "[UART] Close UART port failed : %d, %s", errno, strerror(errno));
bt_android_log("[UART][ERR] Close UART port failed : %d, %s", errno, strerror(errno));
}
commPort = -1;
}
return 0x00;
}
static void* getDriverHandle() {
void *lib_handle;
lib_handle = dlopen("/data/libhciattach_mtk.so", RTLD_LAZY);
if (!lib_handle)
{
bt_prompt_trace(MOD_BT, "%s\n", dlerror());
/* not found use default */
lib_handle = dlopen("libhciattach_mtk.so", RTLD_LAZY);
}
if (!lib_handle)
{
bt_prompt_trace(MOD_BT, "[ERR] dlopen failed : %s\n", dlerror());
}
return lib_handle;
}
int setup_uart_param(
unsigned long hComPort,
int iBaudrate,
int iFlowControl)
{
struct termios ti;
int fd;
bt_prompt_trace(MOD_BT, "[UART] setup_uart_param %d %d\n", iBaudrate, iFlowControl);
fd = (int)hComPort;
if (fd < 0) {
bt_prompt_trace(MOD_BT, "[UART][ERR] Invalid serial port");
return -1;
}
tcflush(fd, TCIOFLUSH);
if (tcgetattr(fd, &ti) < 0) {
bt_prompt_trace(MOD_BT, "[UART][ERR] Can't get port settings");
return -1;
}
cfmakeraw(&ti);
ti.c_cflag |= CLOCAL;
ti.c_cflag &= ~CRTSCTS;
ti.c_iflag &= ~(IXON | IXOFF | IXANY | 0x80000000);
/* HW flow control */
if (iFlowControl == 1){
ti.c_cflag |= CRTSCTS;
bt_prompt_trace(MOD_BT, "[UART] HW flow control\n");
}
else if (iFlowControl == 2){ //MTK HW Xon/Xoff
/* SW flow control */
//ti.c_iflag |= (IXON | IXOFF | IXANY);
ti.c_iflag |= 0x80000000;
//ti.c_cflag |= CRTSCTS;
bt_prompt_trace(MOD_BT, "[UART] SW flow control\n");
}
if (tcsetattr(fd, TCSANOW, &ti) < 0) {
bt_prompt_trace(MOD_BT, "[UART][ERR] Can't set port settings");
return -1;
}
/* Set baudrate */
if (set_speed(fd, &ti, iBaudrate) < 0) {
bt_prompt_trace(MOD_BT, "[UART][ERR] Can't set initial baud rate");
return -1;
}
tcflush(fd, TCIOFLUSH);
bt_prompt_trace(MOD_BT, "[UART] setup_uart_param success\n");
return fd;
}
/* static char packetbuf[1024]; */
unsigned short BTUartLinuxRead(unsigned char *buffer, unsigned short length)
{
unsigned short bytesToCopy = 0;
int nRead = 0;
bytesToCopy = length;
bt_prompt_trace_lv3(MOD_BT, "[BT] Read uart buffer=0x%x, length=%d, commport=%d", buffer, length, commPort);
if(commPort < 0)
{
bt_prompt_trace(MOD_BT, "Read com after closed");
return 0;
}
while(bytesToCopy && (nRead = read(commPort, buffer, bytesToCopy)) > 0)
{
bt_prompt_trace_lv3(MOD_BT, "[BT] %d bytes is read from uart", nRead);
bytesToCopy -= nRead;
buffer += nRead;
}
if(nRead < 0){
//bt_prompt_trace(MOD_BT, "[RESET] BTUartLinuxRead return %d, errno=%d", nRead, errno);
if(errno == 88 || errno == 99){
wholeChipReset(errno);
return 0;
}
}
bt_prompt_trace_lv3(MOD_BT, "[BT] total %d bytes is read", length - bytesToCopy);
return (length - bytesToCopy);
}
void ShowBytes( void * s, int n)
{
U8 * start = (U8* )s;
int i=0;
bt_prompt_trace(MOD_BT,"[HID][OFFSET] ADDRESS: VALUE\n\n");
for ( i = 0 ; i < n; i ++ )
{
bt_prompt_trace(MOD_BT, "[HID][%4d] %8x: %2x\n ",i,start+i,*(start+i));
if ((i + 1 ) % 4 == 0 )
{
bt_prompt_trace(MOD_BT, " ----------------------\n " );
}
} // for
}
/*************************************************
* Name : BTUartLinuxInit
* Parameter :
* func : If there is Rx data, callback to stack to handle
* Return value :
* BT_STATUS_SUCCESS : Success
* BT_STATUS_FAILED : Failed
*************************************************/
BtStatus BTUartLinuxInit(UartCallback func)
{
// Checking if the uart is already opened
// if com port is opened, let opencomm to close then open again
/*
if (commPort >= 0)
{
bt_android_log("[UART][ERR] the uart already opened : %d", commPort);
bt_prompt_trace(MOD_BT, "[UART][ERR] the uart already opened : %d", commPort);
return BT_STATUS_SUCCESS;
}
*/
// Create this write operation's OVERLAPPED structure's hEvent.
BTAdpUartCtx.cb_func = func;
//Power on BT before open uart
set_bluetooth_power(0);
/* Power on controller */
if( set_bluetooth_power(1) < 0)
{
bt_prompt_trace(MOD_BT, "[ERR] failed to set bt power");
return BT_STATUS_FAILED;
}
if ( openComm() != 0 ){
set_bluetooth_power(0);
return BT_STATUS_FAILED;
}
else
{
return BT_STATUS_SUCCESS;
}
}
/*****************************************************************************
* FUNCTION
* btmtk_fs_seek
* DESCRIPTION
*
* PARAMETERS
* fd [IN]
* offset [IN]
* seek_mode [IN]
* RETURNS
*
*****************************************************************************/
S32 btmtk_fs_seek(int fd, U32 offset, btmtk_seek_mode_enum seek_mode)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
S32 pos;
int handle = bt_file_desc[fd].handle;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (bt_file_desc[fd].used == KAL_FALSE)
{
bt_prompt_trace(MOD_BT, "[FS] btmtk_fs_seek(fd=%d) cannot found fd", fd);
return BTMTK_FS_ERR;
}
#ifdef BTMTK_ON_WISE
pos = FS_Seek(handle, offset, translateSeekMode(seek_mode));
return translateFileError(pos);
#else
if (fseek((FILE *)handle, offset, translateSeekMode(seek_mode)) == 0)
{
pos = ftell((FILE *)handle);
return pos;
}
return BTMTK_FS_ERR;
#endif
}
U32 bt_dbg_manual_dump_req_hdlr(ilm_struct *ilm_ptr){
U32 *ptr = (U32*)1;
bt_prompt_trace(MOD_BT, "Request manual dump");
bt_android_log("Make mtkbt crash to get coredump");
usleep(200000);
*ptr= 0;
return *ptr;
}
static void wholeChipReset(int err)
{
bt_prompt_trace(MOD_BT, "[RESET] wholeChipReset : errno=%d", errno);
Assert(0);
if(err == 88){
waitWholeChipResetComplete();
}
close(commPort);
commPort = -1;
}
U8 Hid_Init_Parser(HidParseData* tmpHidParser)
{
//HidParseData* tmpHidParser = (HidParseData*)hid_malloc(sizeof(HidParseData));
if(!tmpHidParser)
{
bt_prompt_trace(MOD_BT,"[HID]HidParseData hid_malloc error");
return 0;
}
tmpHidParser->reportDesc = NULL;
tmpHidParser->usageQueue = (HidUsage*)hid_malloc(HID_USAGE_MAX * sizeof(HidUsage));
if(!tmpHidParser->usageQueue)
{
bt_prompt_trace(MOD_BT,"[HID]usageQueue hid_malloc error");
return 0;
}
btmtk_os_memset((U8*) tmpHidParser->usageQueue, 0, sizeof(HID_USAGE_MAX * sizeof(HidUsage)));
tmpHidParser->usageSize = 0;
tmpHidParser->usageNum = 0;
tmpHidParser->reportDescLength = 0;
tmpHidParser->logicalMAX = 0;
tmpHidParser->logicalMIN = 0;
tmpHidParser->physicalMAX = 0;
tmpHidParser->physicalMIN = 0;
tmpHidParser->reportCount = 0;
tmpHidParser->reportSize = 0;
tmpHidParser->reportID = 0;
tmpHidParser->usagePage = 0;
tmpHidParser->unitExponent = 0;
tmpHidParser->unit = 0;
tmpHidParser->pos = 0;
tmpHidParser->collectionArray = (HidUsageCollection*)hid_malloc(HID_COLLECTION_MAX * sizeof(HidUsageCollection));
btmtk_os_memset((HidUsageCollection*) tmpHidParser->collectionArray, 0, sizeof(HID_COLLECTION_MAX * sizeof(HidUsageCollection)));
tmpHidParser->collectionIndex = 0;
//return tmpHidParser;
Hid_Init_KeyArray();
return 1;
}
/*---------------------------------------------------------------------------
* HidStartServiceQuery()
*---------------------------------------------------------------------------
*
* Synopsis: Initiate the SDP service query for a HID device.
*
* Return: See SDP_Query().
*/
BtStatus HidStartServiceQuery(HidChannel *Channel)
{
BtStatus status = BT_STATUS_FAILED;
sdap_service_search_multi_attribute_struct search_pattern;
ReportDescriptorList* reportDescriptorList = NULL;
HidParseData* hpd ;
reportDescriptorList = HidFindReportDescriptorByAddr(Channel->cmgrHandler.remDev->bdAddr);
if(reportDescriptorList != NULL && Channel->state == HID_STATE_OPEN)
{
Channel->queryRsp.descriptorLen = reportDescriptorList->reportDescriptorLength;
Channel->queryRsp.descriptorList = (U8*)hid_malloc(reportDescriptorList->reportDescriptorLength);
btmtk_os_memset((U8*) Channel->queryRsp.descriptorList, 0, reportDescriptorList->reportDescriptorLength);
btmtk_os_memcpy((U8*) Channel->queryRsp.descriptorList, reportDescriptorList->reportDescriptor, reportDescriptorList->reportDescriptorLength);
hpd = (HidParseData*)hid_malloc(sizeof(HidParseData));
Hid_Init_Parser(hpd);
Channel->reportCons[0] = (HidReportConstructor*)hid_malloc(HID_REPORT_ID_MAX * sizeof(HidReportConstructor));
btmtk_os_memset((U8*) Channel->reportCons[0], 0, HID_REPORT_ID_MAX * sizeof(HidReportConstructor));
if(HidAddDescriptor(Channel) == BT_STATUS_SUCCESS)
bt_prompt_trace(MOD_BT,"[HID]HidAddDescriptor Successed!");
else
bt_prompt_trace(MOD_BT,"[HID]HidAddDescriptor failed!");
Hid_Free_Parser(hpd);
Channel->flags &= ~CHNL_FLAG_SERVICE_QUERY;
HidSdpCallback(Channel, BT_STATUS_SUCCESS);
return BT_STATUS_SUCCESS;
}
else
{
search_pattern.rm = Channel->cmgrHandler.remDev;
search_pattern.sqt = &Channel->sdpQueryToken;
search_pattern.uuid = SC_HUMAN_INTERFACE_DEVICE;
search_pattern.callback = HidSdpEventHandler;
search_pattern.attribute_num = sizeof(bt_hid_attr_id_list)/sizeof(bt_hid_attr_id_list[0]);
search_pattern.attribute_id = bt_hid_attr_id_list;
status = SDAP_ServiceSearchMultipleAttribute2(search_pattern);
return status;
}
}
/*****************************************************************************
* FUNCTION
* btmtk_fs_read
* DESCRIPTION
*
* PARAMETERS
* fd [IN]
* buffer [?]
* size [IN]
* RETURNS
*
*****************************************************************************/
S32 btmtk_fs_read(int fd, void *buffer, U32 size)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
int handle = bt_file_desc[fd].handle;
#ifdef BTMTK_ON_WISE
U32 byte_read = 0;
S32 err;
#else
size_t byte_read = 0;
#endif
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (bt_file_desc[fd].used == KAL_FALSE)
{
bt_prompt_trace(MOD_BT, "[FS] btmtk_fs_read(fd=%d) cannot found fd", fd);
return BTMTK_FS_ERR;
}
bt_prompt_trace(MOD_BT, "[FS] +btmtk_fs_read(handle=0x%X, buffer=0x%X, size=%d)", handle, buffer, size);
#ifdef BTMTK_ON_WISE
if ((err = FS_Read(handle, buffer, size, &byte_read)) == FS_NO_ERROR)
{
return byte_read;
}
return translateFileError(err);
#else
byte_read = fread(buffer, 1, size, (FILE *) handle);
if (byte_read == size || feof((FILE *) handle))
{
bt_prompt_trace(MOD_BT, "[FS] -btmtk_fs_read : %d", byte_read);
return byte_read;
}
bt_prompt_trace(MOD_BT, "[FS] -btmtk_fs_read failed : %s, errno=%d", strerror(errno), errno);
return BTMTK_FS_ERR;
#endif /* BTMTK_ON_WISE */
}
static BtStatus GORM_Shutdown(void)
{
#if !defined(__ANDROID_EMULATOR__)
#ifndef __MTK_STP_SUPPORTED__
void* lib_handle;
RESTORE bt_restore = NULL;
SET_UART_SETUP SetUartSetup = NULL;
/* restore bt driver */
if(commPort >= 0) {
lib_handle = getDriverHandle();
if(lib_handle) {
bt_prompt_trace(MOD_BT, "Start to restore bt driver");
SetUartSetup = dlsym(lib_handle, "SetUartSetup");
bt_restore = dlsym(lib_handle, "bt_restore");
if(bt_restore && SetUartSetup) {
setUartBlockMode(commPort, 1);
SetUartSetup(setup_uart_param);
bt_restore(commPort);
} else {
bt_prompt_trace(MOD_BT, "[ERR] can locate bt_restore function");
}
}
} else {
bt_prompt_trace(MOD_BT, "commPort is invalid when GORM_Shutdown");
}
//bt_prompt_trace(MOD_BT, "+GORM_Shutdown");
BTUartLinuxShutdown();
//bt_prompt_trace("set_bluetooth_power(0)");
if( set_bluetooth_power(0) < 0)
{
//bt_prompt_trace(MOD_BT, "[ERR] failed to set bt power");
return BT_STATUS_FAILED;
}
//bt_prompt_trace(MOD_BT, "-GORM_Shutdown");
#else
BTUartLinuxShutdown();
#endif /* __MTK_STP_SUPPORTED__ */
#endif /* !defined(__ANDROID_EMULATOR__) */
return BT_STATUS_SUCCESS;
}
/*****************************************************************************
* FUNCTION
* btmtk_fs_is_dir_exist
* DESCRIPTION
*
* PARAMETERS
* dirName [IN]
* RETURNS
*
*****************************************************************************/
BT_BOOL btmtk_fs_is_dir_exist(const U8 *dirName)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
#ifdef BTMTK_ON_WISE
FS_HANDLE file_handle;
bt_asc_str_n_to_ucs2_str((S8 *)pathBuf, (S8 *)dirName, FS_MAX_PATH_LEN * sizeof(U16));
if ((file_handle = FS_Open(pathBuf, FS_OPEN_DIR | FS_READ_ONLY)) > 0)
{
FS_Close(file_handle);
return TRUE;
}
return FALSE;
#else /* BTMTK_ON_WISE */
#ifdef BTMTK_ON_LINUX
struct stat buf;
BT_BOOL bRet;
#else
struct _stat buf;
#endif
translateFilePath(dirName, (U8 *)pathBuf);
#ifdef BTMTK_ON_LINUX
bRet = (BT_BOOL)((stat((char *)pathBuf, &buf) != 0) ? FALSE : TRUE);
if(!bRet)
{
bt_prompt_trace(MOD_BT, "[FS] btmtk_fs_is_dir_exist failed : %s, errno=%d", strerror(errno), errno);
}
return bRet;
#else
return (BT_BOOL)((_stat((char *)pathBuf, &buf) != 0) ? FALSE : TRUE);
#endif
#endif /* BTMTK_ON_WISE */
bt_prompt_trace(MOD_BT, "[FS] -btmtk_fs_is_dir_exist");
}
BtStatus HidAddDescriptor(HidChannel *channel)
{
if(!channel)
{
bt_prompt_trace(MOD_BT,"[HID]Empty Channel");
return BT_STATUS_FAILED;
}
bt_prompt_trace(MOD_BT,"[HID]channel->descLen=%d",channel->descLen);
btmtk_os_memcpy(channel->descStr + channel->descLen,
channel->queryRsp.descriptorList,
channel->queryRsp.descriptorLen);
channel->descLen += channel->queryRsp.descriptorLen;
bt_prompt_trace(MOD_BT,"[HID]channel->descLen=%d",channel->descLen);
HidShowBytes(channel->descStr, channel->descLen);
return 0;
}
int set_speed(int fd, struct termios *ti, int speed)
{
int ret;
struct serial_struct ss;
int baudenum = get_uart_speed(speed);
if((ioctl(fd,TIOCGSERIAL,&ss))<0){
bt_prompt_trace(MOD_BT, "%s: BAUD: error to get the serial_struct info:%s",__func__, strerror(errno));
return -1;
}
if ((baudenum == B57600) && (speed != 57600)) {
/* struct serial_struct ss; */
bt_prompt_trace(MOD_BT, "%s: non-standard baudrate: %d", __func__, speed);
//cfsetispeed(ti,B38400);
//cfsetospeed(ti,B38400);
tcflush(fd,TCIFLUSH);/*handle unrecevie char*/
//tcsetattr(fd,TCSANOW,ti);
/*
if((ioctl(fd,TIOCGSERIAL,&ss))<0){
bt_prompt_trace(MOD_BT, "%s: BAUD: error to get the serial_struct info:%s",__func__, strerror(errno));
return -1;
}*/
if(!(ss.flags & ASYNC_SPD_CUST)) {
bt_prompt_trace(MOD_BT, "ASYNC_SPD_CUST is not set. Set ASYNC_SPD_CUST");
ss.flags |= ASYNC_SPD_CUST;
ss.custom_divisor = ss.baud_base / speed;
if(ss.custom_divisor*speed != ss.baud_base )
ss.custom_divisor = speed | (1<<31);
if((ioctl(fd,TIOCSSERIAL,&ss))<0){
bt_prompt_trace(MOD_BT, "BAUD: error to set serial_struct:%s",strerror(errno));
return -2;
}
}
return 0;
} else {
bt_prompt_trace(MOD_BT, "%s: standard baudrate: %d -> %d", __func__, speed, baudenum);
if(ss.flags & ASYNC_SPD_CUST) {
bt_prompt_trace(MOD_BT, "ASYNC_SPD_CUST is set. Clear ASYNC_SPD_CUST");
ss.flags &= ~ASYNC_SPD_CUST;
ss.custom_divisor = 1;
if((ioctl(fd,TIOCSSERIAL,&ss))<0){
bt_prompt_trace(MOD_BT, "BAUD: error to set serial_struct:%s",strerror(errno));
return -2;
}
}
cfsetospeed(ti, baudenum);
cfsetispeed(ti, baudenum);
tcsetattr(fd, TCSANOW, ti);
return 0;
}
}
/* return value : < 0 means failed, and others means success */
static int setUartBlockMode(int handle, U8 block)
{
int val;
/* uart handle is opened as blocking, change it to non-blocking */
if( (val = fcntl(handle, F_GETFL, 0)) < 0)
{
bt_prompt_trace(MOD_BT, "[UART][ERR] get handle flag failed");
}
else
{
if(block == 0)
{
val |= O_NONBLOCK;
}
else
{
val &= ~O_NONBLOCK;
}
val = fcntl(commPort, F_SETFL, val);
}
bt_prompt_trace(MOD_BT, "setUartBlockMode(%d,%d)=%d", handle, block, val);
return val;
}
void Hid_Free_Mem()
{
int i;
for(i = 0; i < MAX_KEY_ARRAY_SIZE; i++)
{
if(keyArySet[i].firstAry == 1)
{
bt_prompt_trace(MOD_BT,"[HID]Free the array table");
hid_free(keyArySet[i].keyAry);
keyArySet[i].firstAry = 0;
}
keyArySet[i].keyAry = NULL;
keyArySet[i].keyAryIndex = 0;
keyArySet[i].reportID = 0;
}
}
void BTUartLinuxSetSpeed(unsigned short speed)
{
struct termios options;
bt_prompt_trace(MOD_BT, "[BT][UART] set uart speed to speed %d", speed);
return;
/* Get default com port setting */
if( -1 == tcgetattr(commPort, &options) )
{
return;
}
/* Set baud rate to 115200 */
cfsetispeed(&options, B115200);
cfsetospeed(&options, B115200);
/* Set new com port setting */
if( -1 == tcsetattr(commPort, TCSANOW, &options) )
{
return;
}
return;
}
/*****************************************************************************
* FUNCTION
* btmtk_fs_init
* DESCRIPTION
*
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void btmtk_fs_init(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
char cwdpath[128];
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
bt_prompt_trace(MOD_BT, "[FS] btmtk_fs_init");
OS_Report("[FS][INIT] BT_DB_PATH='%s'", BT_DB_PATH);
OS_Report("[FS][INIT] BT_DB_FILE='%s'", BT_DB_FILE);
#ifdef BTMTK_ON_LINUX
memset( cwdpath, 0 , sizeof(cwdpath));
getcwd(cwdpath, sizeof(cwdpath)-1);
OS_Report("[FS][INIT] getcwd()='%s'", cwdpath);
#else
OS_Report("[FS][INIT] getcwd() unknow" );
#endif
memset(bt_file_desc, 0x0, sizeof(file_info_struct) * BT_MAX_NUM_FILES);
}
BtStatus HidCacheReportDescriptor(BD_ADDR addr, U8* HidDescriptorList, U32 length)
{
U8 i = 0;
for (i = 0; i < HID_MAX_REPORT_DESCRIPTOR_NUM; i++)
{
if (!CachedReportDescriptor[i].inUse)
{
btmtk_os_memcpy(CachedReportDescriptor[i].BtAddr.addr, addr.addr, 6);
CachedReportDescriptor[i].inUse = TRUE;
CachedReportDescriptor[i].reportDescriptor = (U8*)hid_malloc(length);
if(!CachedReportDescriptor[i].reportDescriptor)
{
bt_prompt_trace(MOD_BT,"[HID]CachedReportDescriptor[i].reportDescriptor hid_malloc error");
return BT_STATUS_FAILED;
}
btmtk_os_memset(CachedReportDescriptor[i].reportDescriptor, 0 ,length);
btmtk_os_memcpy(CachedReportDescriptor[i].reportDescriptor, HidDescriptorList, length);
CachedReportDescriptor[i].reportDescriptorLength = length;
break;
}
}
return BT_STATUS_SUCCESS;
}
/*---------------------------------------------------------------------------
* HidStateConnPending()
*---------------------------------------------------------------------------
*
* Synopsis: Connection Pending state for the HID channel.
*
* Return: void
*/
void HidStateConnPending(HidChannel *Channel, L2capChannelId Cid,
L2capCallbackParms *Parms)
{
//BtSniffInfo sniffInfo;
BtStatus status;
kal_trace(BT_TRACE_G2_PROFILES,HIDSTATECONNPENDINGx02X ,Parms->event);
switch (Parms->event)
{
case L2EVENT_CONNECT_AUTORIZED:
L2Cap_AuthorizeConnectRsp(Cid, TRUE);
break;
case L2EVENT_CONNECT_IND:
/* A second connection was requested */
status = L2CAP_ConnectRsp(Cid, L2CONN_ACCEPTED, 0);
kal_trace(BT_TRACE_G2_PROFILES,L2CAP_CONNECTRSPx02X ,status);
break;
case L2EVENT_CONNECTED:
/* A connection is up */
//Assert(Channel->conCount < 2);
if(Channel->conCount >= 2){
bt_prompt_trace(MOD_BT,"[HID]Channel->conCount >= 2");
return;
}
Channel->conCount++;
CMGR_HidNoRoleSwitch(1);
if (Channel->conCount == 2)
{
/* Notify the application */
Channel->state = HID_STATE_OPEN;
HidAppCallback(Channel, HIDEVENT_OPEN, BT_STATUS_SUCCESS,
Channel->cmgrHandler.remDev,
sizeof(BtRemoteDevice));
/* Put it on the list of registered handlers */
CMGR_SetDeviceAsMaster(&Channel->cmgrHandler);
// CMGR_ActivateSniffTimer(&Channel->cmgrHandler);
}
else if (Channel->flags & CHNL_FLAG_INITIATOR)
{
/* The channel initiated the connection, establish the
* interrupt channel
*/
if (Channel->intrCid == Cid)
{
/* This means control channel has broken before
interrupt channel established */
L2CAP_DisconnectReq(Cid);
break;
}
if (L2CAP_ConnectReq(&HID(hidIntrPsm), BT_PSM_HID_INTR,
Channel->cmgrHandler.remDev, 0,
&(Channel->intrCid)) != BT_STATUS_PENDING)
{
/* Connect request failed, tear down the first connection */
status = L2CAP_DisconnectReq(Channel->ctrlCid);
kal_trace(BT_TRACE_G2_PROFILES,HID_L2CAP_DISCONNECT_REQ_CID_CIDx02X_STATUSx02X ,Channel->ctrlCid, status);
}
}
break;
case L2EVENT_DISCONNECTED:
/* Connection is going down */
CMGR_HidNoRoleSwitch(0);
HidStateDiscPending(Channel, Cid, Parms);
break;
default:
/* Ignore any other events */
kal_trace(BT_TRACE_G2_PROFILES,HID_CHANNEL_CONN_PENDING_STATE_RECEIVED_AN_UNEXPECTED_EVENT_x02X , Parms->event);
}
}
/*---------------------------------------------------------------------------
* HidStateOpen()
*---------------------------------------------------------------------------
*
* Synopsis: Open state for the HID channel.
*
* Return: void
*/
void HidStateOpen(HidChannel *Channel, L2capChannelId Cid,
L2capCallbackParms *Parms)
{
HidTransaction *trans = NULL;
HidInterrupt *intr = NULL;
U16 mtu;
kal_trace(BT_TRACE_G2_PROFILES,HIDSTATEOPENx02X ,Parms->event);
switch (Parms->event)
{
case L2EVENT_DISCON_IND:
case L2EVENT_DISCONNECTED:
Channel->state = HID_STATE_DISC_PENDING;
if (!(Channel->flags & CHNL_FLAG_TERMINATOR))
{
/* Call the application to indicate the connection is going down.
L2capDiscReason provided in status*/
HidAppCallback(Channel, HIDEVENT_CLOSE_IND, Parms->status,
Channel->cmgrHandler.remDev,
sizeof(BtRemoteDevice));
}
/* Connection is going down */
HidStateDiscPending(Channel, Cid, Parms);
break;
case L2EVENT_PACKET_HANDLED:
kal_trace(BT_TRACE_G2_PROFILES,CIDxDCTRLCIDxD ,Cid,Channel->ctrlCid);
if (Cid == Channel->ctrlCid)
{
trans = (HidTransaction *)Parms->ptrs.packet->ulpContext;
kal_trace(BT_TRACE_G2_PROFILES,HIDSTATEOPEN1_PKT_RETURNED_WITH_TRANS_TYPExD ,trans->type);
if (trans->flags & TRANS_FLAG_ERROR)
{
/* Ignore this event, transaction failed */
kal_trace(BT_TRACE_G2_PROFILES,HIDSTATEOPENPKT_RETURNED_WITH_ERR_FLAG);
InsertTailList(&HID(packetPool), &Parms->ptrs.packet->node);
break;
}
mtu = L2CAP_GetTxMtu(Channel->ctrlCid);
}
else
{
/* Interrupt channel */
intr = (HidInterrupt *)Parms->ptrs.packet->ulpContext;
if (intr->flags & INTR_FLAG_ERROR)
{
/* Ignore this event, interrupt failed */
InsertTailList(&HID(packetPool), &Parms->ptrs.packet->node);
break;
}
mtu = L2CAP_GetTxMtu(Channel->intrCid);
}
if (Parms->ptrs.packet->dataLen < mtu - 1)
{
/* A packet was handled, put it back in the pool */
/* Only return packet when no more data need to be sent */
InsertTailList(&HID(packetPool), &Parms->ptrs.packet->node);
}
/* See if there is more data to send */
if (Cid == Channel->ctrlCid)
{
/* Check for more data */
if (Parms->ptrs.packet->dataLen >= mtu -1)
{
/* More data to send, send another packet */
kal_trace(BT_TRACE_G2_PROFILES,HIDSTATEOPEN_SEND_MORE_DATA);
//trans->flags &= ~TRANS_FLAG_START;
if(!(trans->flags & TRANS_FLAG_SENT))
if (HidSendTransPacket(Channel, trans, Parms->ptrs.packet)
!= BT_STATUS_PENDING)
{
/* Complete the transaction with an error */
trans->flags |= TRANS_FLAG_ERROR;
InsertTailList(&HID(packetPool), &Parms->ptrs.packet->node);
/* Complete the transaction with an error, check for a new
* transaction.
*/
HidCompleteTransaction(Channel, trans, BT_STATUS_FAILED);
}
}
else
{
/* No more data to send in this transaction, complete this
* transaction (if no response is expected) and see if there
* is another transaction to start.
*/
trans->flags |= TRANS_FLAG_SENT;
kal_trace(BT_TRACE_G2_PROFILES,HIDSTATEOPEN2_PKT_RETURNED_WITH_TRANS_TYPExD ,trans->type);
switch (trans->type) {
case HID_TRANS_CONTROL:
case HID_TRANS_SET_REPORT_RSP:
case HID_TRANS_SET_PROTOCOL_RSP:
case HID_TRANS_SET_IDLE_RATE_RSP:
case HID_TRANS_GET_REPORT_RSP:
case HID_TRANS_GET_PROTOCOL_RSP:
case HID_TRANS_GET_IDLE_RATE_RSP:
//Add by stanley: 2007-0607
case HID_HANDSHAKE:
kal_trace(BT_TRACE_G2_PROFILES,HIDCOMPLETETRANSACTION_WITH_TYPExD ,trans->type);
HidCompleteTransaction(Channel, trans, BT_STATUS_SUCCESS);
break;
}
}
}
else
{
/* Check for more data */
if (Parms->ptrs.packet->dataLen >= mtu -1)
{
/* More data to send, send another packet */
//intr->flags &= ~INTR_FLAG_START;
if(!(intr->flags & INTR_FLAG_SENT))
if (HidSendIntrPacket(Channel, intr, Parms->ptrs.packet)
!= BT_STATUS_PENDING)
{
/* Complete the interrupt with an error */
intr->flags |= INTR_FLAG_ERROR;
InsertTailList(&HID(packetPool), &Parms->ptrs.packet->node);
/* Complete the interrupt with an error, check for a new
* interrupt.
*/
HidCompleteInterrupt(Channel, intr, BT_STATUS_FAILED);
}
}
else
{
/* No more data to send in this interrupt, complete this
* interrupt.
*/
intr->flags |= INTR_FLAG_SENT;
HidCompleteInterrupt(Channel, intr, BT_STATUS_SUCCESS);
}
}
break;
case L2EVENT_DATA_IND:
if (Cid == Channel->ctrlCid)
{
//Assert(Channel !=0);
if(Channel ==0){
bt_prompt_trace(MOD_BT,"[HID]channel ==0");
return;
}
/* A control channel request was received */
HidControlChannel(Channel, Cid, Parms);
}
else
{
//Assert(Channel !=0);
if(Channel ==0){
bt_prompt_trace(MOD_BT,"[HID]channel ==0");
return;
}
/* Application data was received */
HidInterruptChannel(Channel, Cid, Parms);
}
break;
default:
/* Ignore any other events */
kal_trace(BT_TRACE_G2_PROFILES,HID_SERVER_OPEN_STATE_RECEIVED_AN_UNEXPECTED_EVENT_x02X , Parms->event);
break;
}
}
/*---------------------------------------------------------------------------
* HidL2Callback()
*---------------------------------------------------------------------------
*
* Synopsis: L2CAP callback function for the Channel.
*
* Return: void
*/
void HidL2Callback(L2capChannelId Cid, L2capCallbackParms *Parms)
{
HidChannel *channel;
channel = HidFindChannelByCid(Cid, Parms->aclLink);
kal_trace(BT_TRACE_G2_PROFILES,HIDPARMSEVENTx02X ,Parms->event);
kal_trace(BT_TRACE_G2_PROFILES,HID_CID_x02X ,Cid);
kal_trace(BT_TRACE_G2_PROFILES,HID_CHANNELx08X , channel);
switch (Parms->event)
{
case L2EVENT_CONNECT_AUTORIZED:
if (channel == NULL)
{
U8 searchType;
if (Parms->owner.psm == &HID(hidCtrlPsm))
searchType = HID_FIND_CTRL_CID;
else
searchType = HID_FIND_INTR_CID;
channel = HidFindUnusedChannel(searchType, Parms->aclLink);
if (channel == NULL)
{
if (!HidCheckValidConnect(searchType, Cid, Parms->aclLink))
{
Parms->aclLink->discFlag = TRUE;
L2CAP_ConnectRsp(Cid, L2CONN_REJECT_NO_RESOURCES, 0);
break;
}
// Get a new channel
channel = HidNewChannel();
if (channel == NULL)
{
kal_trace(BT_TRACE_G2_PROFILES,CHANNEL_IS_0_RETURN);
/* No channel available, reject the request */
Parms->aclLink->discFlag = TRUE;
L2CAP_ConnectRsp(Cid, L2CONN_REJECT_NO_RESOURCES, 0);
break;
}
channel->cmgrHandler.remDev = Parms->aclLink;
}
}
if (channel->conCount == 0)
{
/* Only create ACL link for the first L2CAP connection */
if (CMGR_CreateDataLink(&channel->cmgrHandler,
&Parms->aclLink->bdAddr) != BT_STATUS_SUCCESS)
{
/* Could not create a link to the ACL */
(void)L2CAP_ConnectRsp(Cid, L2CONN_REJECT_NO_RESOURCES, 0);
break;
}
}
if (Parms->owner.psm == &HID(hidCtrlPsm))
channel->ctrlCid = Cid;
else
channel->intrCid = Cid;
/* Call the state machine */
if (channel != 0)
{
kal_trace(BT_TRACE_G2_PROFILES,HID_A_SMAx02XBx02X ,channel->state,Cid);
HID(hidState)[channel->state](channel, Cid, Parms);
}
else
kal_trace(BT_TRACE_G2_PROFILES,HIDCHANNEL_0);
break;
case L2EVENT_CONNECT_IND:
#ifdef HID_AUTHORIZATION
//Assert(channel !=0);
if(channel ==0){
bt_prompt_trace(MOD_BT,"[HID]channel ==0");
return;
}
L2CAP_ConnectRsp(Cid, L2CONN_ACCEPTED, 0);
#else
if (channel == 0)
{
/* Get a new channel */
if (Parms->owner.psm == &HID(hidCtrlPsm))
channel = HidFindUnusedChannel(HID_FIND_CTRL_CID, Parms->aclLink);
else
channel = HidFindUnusedChannel(HID_FIND_INTR_CID, Parms->aclLink);
}
if (channel == 0)
{
/* No channel available, reject the request */
L2CAP_ConnectRsp(Cid, L2CONN_REJECT_NO_RESOURCES, 0);
break;
}
//Assert(channel !=0);
if(channel ==0){
bt_prompt_trace(MOD_BT,"[HID]channel ==0");
return;
}
if (CMGR_CreateDataLink(&channel->cmgrHandler,
&Parms->aclLink->bdAddr) != BT_STATUS_SUCCESS)
{
/* Could not create a link to the ACL */
(void)L2CAP_ConnectRsp(Cid, L2CONN_REJECT_NO_RESOURCES, 0);
break;
} /* Drop through */
//Assert(channel !=0);
if(channel ==0){
bt_prompt_trace(MOD_BT,"[HID]channel ==0");
return;
}
if (Parms->owner.psm == &HID(hidCtrlPsm))
channel->ctrlCid = Cid;
else
channel->intrCid = Cid;
/* Call the state machine */
if (channel != 0)
{
kal_trace(BT_TRACE_G2_PROFILES,HID_B_SMAx02XBx02X ,channel->state,Cid);
HID(hidState)[channel->state](channel, Cid, Parms);
}
else
kal_trace(BT_TRACE_G2_PROFILES,HIDCHANNEL_0);
#endif
break;
case L2EVENT_CONNECTED:
/* Save the channel ID for the channel being requested */
if (channel == 0)
{
L2CAP_DisconnectReq(Cid);
break;
}
if (Parms->owner.psm == &HID(hidCtrlPsm))
channel->ctrlCid = Cid;
else
channel->intrCid = Cid;
/* Call the state machine */
if (channel != 0)
{
kal_trace(BT_TRACE_G2_PROFILES,HID_C_SMAx02XBx02X ,channel->state,Cid);
HID(hidState)[channel->state](channel, Cid, Parms);
}
else
kal_trace(BT_TRACE_G2_PROFILES,HIDCHANNEL_0);
break;
case L2EVENT_DISCONNECTED:
CMGR_HidNoRoleSwitch(0);
if (channel != 0)
{
kal_trace(BT_TRACE_G2_PROFILES,HID_D_SMAx02XBx02X ,channel->state,Cid);
HID(hidState)[channel->state](channel, Cid, Parms);
}
else
{
kal_trace(BT_TRACE_G2_PROFILES,UNUSED_CHANNEL_0_IGNORE_IT);
}
break;
default:
/* Call the state machine */
if (channel != 0)
{
kal_trace(BT_TRACE_G2_PROFILES,HID_E_SMAx02XBx02X ,channel->state,Cid);
HID(hidState)[channel->state](channel, Cid, Parms);
}
else
kal_trace(BT_TRACE_G2_PROFILES,HIDCHANNEL_0);
break;
}
}
