558 lines
15 KiB
C
558 lines
15 KiB
C
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <unistd.h>
|
||
|
|
#include <errno.h>
|
||
|
|
#include <fcntl.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <signal.h>
|
||
|
|
#include <time.h>
|
||
|
|
#include <stdint.h>
|
||
|
|
#include <sys/termios.h>
|
||
|
|
#include <sys/ioctl.h>
|
||
|
|
#include <limits.h>
|
||
|
|
#include "hciattach.h"
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
** Constants & Macros
|
||
|
|
******************************************************************************/
|
||
|
|
#define LOG_STR "XRADIO Bluetooth"
|
||
|
|
#define DBG_ON 1
|
||
|
|
|
||
|
|
#define XR_DBG(fmt, arg...) \
|
||
|
|
do { \
|
||
|
|
if (DBG_ON) \
|
||
|
|
fprintf(stderr, "%s: " fmt "\n" , LOG_STR, ##arg); \
|
||
|
|
} while(0)
|
||
|
|
|
||
|
|
#define XR_ERR(fmt, arg...) \
|
||
|
|
do { \
|
||
|
|
fprintf(stderr, "%s ERROR: " fmt "\n", LOG_STR, ##arg);\
|
||
|
|
perror(LOG_STR" ERROR reason"); \
|
||
|
|
} while(0)
|
||
|
|
|
||
|
|
#define XR_DUMP(buffer, len) \
|
||
|
|
fprintf(stderr, "%s: ", LOG_STR); \
|
||
|
|
do { \
|
||
|
|
for (int i = 0; i < len; i++) { \
|
||
|
|
if (i && !(i % 16)) { \
|
||
|
|
fprintf(stderr, "\n"); \
|
||
|
|
fprintf(stderr, "%s: ", LOG_STR); \
|
||
|
|
} \
|
||
|
|
fprintf(stderr, "%02x ", buffer[i]); \
|
||
|
|
} \
|
||
|
|
fprintf(stderr, "\n"); \
|
||
|
|
} while (0)
|
||
|
|
|
||
|
|
#define BT_FW_PATH_NAME "/system/vendor/etc/firmware/fw_xr829_bt.bin"
|
||
|
|
#define BT_FW_LOAD_ADDR 0x0000
|
||
|
|
#define BT_FW_JUMP_ADDR 0x0000
|
||
|
|
#define AW1722 1
|
||
|
|
#define AW1732 2
|
||
|
|
#define CHIP_NAME AW1722
|
||
|
|
|
||
|
|
#define SZ_1K (0x00000400U )
|
||
|
|
#define SZ_16K (0x00004000U )
|
||
|
|
|
||
|
|
#define SWAP16(d) (((d & 0xff) << 8) | ((d & 0xff00) >> 8))
|
||
|
|
#define SWAP32(d) (((d & 0xff) << 24) | ((d & 0xff00) << 8) \
|
||
|
|
| ((d & 0xff0000) >> 8) | ((d & 0xff000000) >> 24))
|
||
|
|
|
||
|
|
#define CMD_ID(group, key) (((group) << 3) | (key))
|
||
|
|
|
||
|
|
/*----------------------------*/
|
||
|
|
/* COMMANDS FORM PC TO MCU */
|
||
|
|
/*----------------------------*/
|
||
|
|
#define CMD_ID_MEMRW 0x00
|
||
|
|
#define CMD_ID_SEQRQ 0x01
|
||
|
|
#define CMD_ID_SYSCTL 0x02
|
||
|
|
#define CMD_ID_FLASH 0x03
|
||
|
|
|
||
|
|
#define CMD_ID_SEQRD CMD_ID(CMD_ID_SEQRQ, 0)
|
||
|
|
#define CMD_ID_SEQWR CMD_ID(CMD_ID_SEQRQ, 1)
|
||
|
|
/* uart commands */
|
||
|
|
#define CMD_ID_SETUART CMD_ID(CMD_ID_SYSCTL, 0)
|
||
|
|
#define CMD_ID_SETPC CMD_ID(CMD_ID_SYSCTL, 3)
|
||
|
|
|
||
|
|
#define CMD_WRITEN 0
|
||
|
|
#define CMD_WRITESEQ 1
|
||
|
|
#define CMD_SETBAUD 2
|
||
|
|
#define CMD_SETPC 3
|
||
|
|
#define DATA_RAW 4
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
** Type definitions
|
||
|
|
******************************************************************************/
|
||
|
|
|
||
|
|
/* vendor serial control block */
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
int fd; /* fd to Bluetooth device */
|
||
|
|
struct termios *ti; /* serial terminal of BT port */
|
||
|
|
} vnd_userial_cb_t;
|
||
|
|
|
||
|
|
#pragma pack(1)
|
||
|
|
/* command header
|
||
|
|
*
|
||
|
|
* byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 -7 byte 8-11
|
||
|
|
* ___________________________________________________________________________________________________
|
||
|
|
* | | | | | | | | |
|
||
|
|
* | 'B' | 'R' | 'O' | 'M' | Flags |Reserved | Checksum | Playload Length |
|
||
|
|
* |_________|_________|_________|_________|_________|_________|__________ ________|___________________|
|
||
|
|
*/
|
||
|
|
typedef struct {
|
||
|
|
uint8_t magic[4]; // magic "BROM"
|
||
|
|
#define CMD_BROM_MAGIC "BROM"
|
||
|
|
uint8_t flags;
|
||
|
|
#define CMD_HFLAG_ERROR (0x1U << 0)
|
||
|
|
#define CMD_HFLAG_ACK (0x1U << 1)
|
||
|
|
#define CMD_HFLAG_CHECK (0x1U << 2)
|
||
|
|
#define CMD_HFLAG_RETRY (0x1U << 3)
|
||
|
|
#define CMD_HFLAG_EXE (0x1U << 4)
|
||
|
|
uint8_t version:4;
|
||
|
|
uint8_t reserved:4;
|
||
|
|
uint16_t checksum;
|
||
|
|
uint32_t payload_len;
|
||
|
|
} __attribute__((packed)) cmd_header_t;
|
||
|
|
#define MB_CMD_HEADER_SIZE (sizeof(cmd_header_t))
|
||
|
|
|
||
|
|
/* acknownledge structure */
|
||
|
|
typedef struct {
|
||
|
|
cmd_header_t h;
|
||
|
|
uint8_t err;
|
||
|
|
} __attribute__((packed)) cmd_ack_t;
|
||
|
|
|
||
|
|
/* sequence read/write command structure */
|
||
|
|
typedef struct {
|
||
|
|
cmd_header_t h;
|
||
|
|
uint8_t cmdid;
|
||
|
|
uint32_t addr;
|
||
|
|
uint32_t dlen;
|
||
|
|
uint16_t dcs;
|
||
|
|
} __attribute__((packed)) cmd_seq_wr_t;
|
||
|
|
|
||
|
|
/* io change command structure */
|
||
|
|
typedef struct {
|
||
|
|
cmd_header_t h;
|
||
|
|
uint8_t cmdid;
|
||
|
|
uint32_t val;
|
||
|
|
} __attribute__((packed)) cmd_sys_t;
|
||
|
|
|
||
|
|
typedef struct {
|
||
|
|
cmd_header_t h;
|
||
|
|
uint8_t cmdid;
|
||
|
|
uint32_t lcr;
|
||
|
|
} __attribute__((packed)) cmd_sys_setuart_t;
|
||
|
|
|
||
|
|
#pragma pack()
|
||
|
|
|
||
|
|
static const uint8_t hci_reset[] = { 0x01, 0x03, 0x0c, 0x00 };
|
||
|
|
static const uint8_t hci_update_baud_rate[] = { 0x01, 0x18, 0xfc, 0x04, 0x60, 0xE3, 0x16, 0x00};
|
||
|
|
static vnd_userial_cb_t vnd_userial;
|
||
|
|
|
||
|
|
static int32_t cmd_sync_uart(void);
|
||
|
|
static int32_t cmd_sync_baud(uint32_t lcr);
|
||
|
|
static int32_t cmd_write_seq(uint32_t addr, uint32_t len, uint8_t *data);
|
||
|
|
static int32_t cmd_set_pc(uint32_t pc);
|
||
|
|
static void userial_set_hw_fctrl(uint8_t hw_fctrl);
|
||
|
|
static uint32_t userial_read(uint8_t *p_buffer, uint32_t len, uint32_t timeout);
|
||
|
|
static uint32_t userial_write(const uint8_t *p_data, uint32_t len);
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
** Functions
|
||
|
|
******************************************************************************/
|
||
|
|
static uint16_t CheckSum16(uint8_t *data, uint32_t len)
|
||
|
|
{
|
||
|
|
uint16_t cs = 0;
|
||
|
|
uint16_t *p = (uint16_t *)data;
|
||
|
|
|
||
|
|
while(len > 1) {
|
||
|
|
cs += *p++;
|
||
|
|
len -= 2;
|
||
|
|
}
|
||
|
|
if (len) {
|
||
|
|
cs += *(uint8_t *)p;
|
||
|
|
}
|
||
|
|
return cs;
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint64_t time_gettimeofday_us(void)
|
||
|
|
{
|
||
|
|
struct timeval tv;
|
||
|
|
gettimeofday(&tv, NULL);
|
||
|
|
return (uint64_t)tv.tv_sec * 1000000ULL + (uint64_t)tv.tv_usec;
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint8_t *memsearch(uint8_t *haystack, uint32_t hlen, uint8_t *needle, uint32_t nlen)
|
||
|
|
{
|
||
|
|
while (hlen-- >= nlen) {
|
||
|
|
if (!memcmp(haystack, needle, nlen)) {
|
||
|
|
return haystack;
|
||
|
|
}
|
||
|
|
haystack++;
|
||
|
|
}
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int32_t xr_raw_write(int type, uint8_t *data, uint32_t len)
|
||
|
|
{
|
||
|
|
uint8_t buffer[MB_CMD_HEADER_SIZE + 13] = {'B', 'R', 'O', 'M', 0, 0, 0, 0, 0, 0, 0, 0};
|
||
|
|
uint8_t *psend = data;
|
||
|
|
uint32_t lsend = len;
|
||
|
|
cmd_header_t *hdr = (cmd_header_t *)buffer;;
|
||
|
|
cmd_ack_t *ack = (cmd_ack_t *)buffer;
|
||
|
|
|
||
|
|
if (type != DATA_RAW) {
|
||
|
|
psend = buffer;
|
||
|
|
lsend = MB_CMD_HEADER_SIZE + len;
|
||
|
|
memcpy(buffer + MB_CMD_HEADER_SIZE, data, len);
|
||
|
|
hdr->payload_len = len;
|
||
|
|
#if ENABLE_DCS
|
||
|
|
hdr->flags = CMD_HFLAG_CHECK;
|
||
|
|
#endif
|
||
|
|
hdr->checksum = ~CheckSum16(buffer, MB_CMD_HEADER_SIZE + len);
|
||
|
|
hdr->payload_len = SWAP32(hdr->payload_len);
|
||
|
|
hdr->checksum = SWAP16(hdr->checksum);
|
||
|
|
switch (type) {
|
||
|
|
case CMD_WRITESEQ:
|
||
|
|
{
|
||
|
|
cmd_seq_wr_t *cmd = (cmd_seq_wr_t *)buffer;
|
||
|
|
cmd->addr = SWAP32(cmd->addr);
|
||
|
|
cmd->dlen = SWAP32(cmd->dlen);
|
||
|
|
cmd->dcs = SWAP16(cmd->dcs);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case CMD_SETBAUD:
|
||
|
|
{
|
||
|
|
cmd_sys_setuart_t *cmd = (cmd_sys_setuart_t*)buffer;
|
||
|
|
cmd->lcr = SWAP32(cmd->lcr);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case CMD_SETPC:
|
||
|
|
{
|
||
|
|
cmd_sys_t *cmd = (cmd_sys_t*)buffer;
|
||
|
|
cmd->val = SWAP32(cmd->val);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
XR_ERR("%s: Unsupport type %d", __func__, type);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ssize_t ret_w, ret_r;
|
||
|
|
uint64_t t0, t1, t2, t3;
|
||
|
|
|
||
|
|
tcflush(vnd_userial.fd, TCIOFLUSH);
|
||
|
|
|
||
|
|
t0 = time_gettimeofday_us();
|
||
|
|
ret_w = userial_write(psend, lsend);
|
||
|
|
t1 = time_gettimeofday_us();
|
||
|
|
|
||
|
|
memset(buffer, 0, MB_CMD_HEADER_SIZE + 1);
|
||
|
|
|
||
|
|
t2 = time_gettimeofday_us();
|
||
|
|
ret_r = userial_read(buffer, MB_CMD_HEADER_SIZE, 100000);
|
||
|
|
t3 = time_gettimeofday_us();
|
||
|
|
|
||
|
|
XR_DBG("%s, type: %d, write len: %5d, ret: %5d, time: %6lluus, read len: %2d, ret: %2d, %6lluus",
|
||
|
|
__func__, type, lsend, ret_w, t1 - t0, MB_CMD_HEADER_SIZE, ret_r, t3 - t2);
|
||
|
|
|
||
|
|
uint8_t *p = (uint8_t *)memsearch(buffer, MB_CMD_HEADER_SIZE, (uint8_t *)"BROM", 4);
|
||
|
|
if (p != buffer) {
|
||
|
|
if (p == NULL) {
|
||
|
|
XR_ERR("%s: invalid response", __func__);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
uint32_t nowread = buffer + MB_CMD_HEADER_SIZE - p;
|
||
|
|
uint32_t needread = p - buffer;
|
||
|
|
XR_DBG("%s: Index error, re-find header magic", __func__);
|
||
|
|
memcpy(buffer, p, nowread);
|
||
|
|
memset(buffer + nowread, 0x0, needread);
|
||
|
|
userial_read(buffer + nowread, needread, 100000);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* check response */
|
||
|
|
if (ack->h.flags & CMD_HFLAG_ERROR) {
|
||
|
|
userial_read(buffer + MB_CMD_HEADER_SIZE, 1, 100000);
|
||
|
|
XR_ERR("%s: resp error flag, type %d", __func__, ack->err);
|
||
|
|
return -ack->err;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ack->h.flags & CMD_HFLAG_ACK) {
|
||
|
|
/* convert network byte order to host byte order */
|
||
|
|
ack->h.payload_len = SWAP32(ack->h.payload_len);
|
||
|
|
ack->h.checksum = SWAP16(ack->h.checksum);
|
||
|
|
if (ack->h.payload_len != 0) {
|
||
|
|
XR_ERR("%s: data payload len %d != 0", __func__, ack->h.payload_len);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ack->h.flags & CMD_HFLAG_CHECK) {
|
||
|
|
if (CheckSum16(buffer, MB_CMD_HEADER_SIZE) != 0xffff) {
|
||
|
|
XR_ERR("%s: write data response 0 checksum error", __func__);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int32_t cmd_sync_uart(void)
|
||
|
|
{
|
||
|
|
uint8_t sync = 0x55;
|
||
|
|
uint8_t ack[3] = {0};
|
||
|
|
ssize_t ret = -1;
|
||
|
|
uint32_t cnt = 0;
|
||
|
|
|
||
|
|
do {
|
||
|
|
XR_DBG("uart sync count:%d.", cnt);
|
||
|
|
tcflush(vnd_userial.fd, TCIOFLUSH);
|
||
|
|
userial_write(&sync, 1);
|
||
|
|
ret = userial_read(ack, 2, 2000);
|
||
|
|
if (ret == 2 && ((ack[0] == 'O' && ack[1] == 'K') || (ack[0] == 'K' && ack[1] == 'O'))) {
|
||
|
|
XR_DBG("Receive %s, uart Sync done.", ack);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
} while (cnt++ < 50);
|
||
|
|
|
||
|
|
XR_DBG("uart sync fail.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int32_t cmd_sync_baud(uint32_t lcr)
|
||
|
|
{
|
||
|
|
uint8_t buffer[MB_CMD_HEADER_SIZE + 5];
|
||
|
|
cmd_sys_setuart_t *cmd = (cmd_sys_setuart_t*)buffer;
|
||
|
|
|
||
|
|
cmd->cmdid = CMD_ID_SETUART;
|
||
|
|
cmd->lcr = lcr;
|
||
|
|
|
||
|
|
uint8_t cnt = 0;
|
||
|
|
int ret = -1;
|
||
|
|
|
||
|
|
do {
|
||
|
|
XR_DBG("%s count:%d.", __func__, cnt);
|
||
|
|
ret = xr_raw_write(CMD_SETBAUD, buffer + MB_CMD_HEADER_SIZE, 5);
|
||
|
|
if (ret == 0) {
|
||
|
|
set_speed(vnd_userial.fd, vnd_userial.ti, lcr & 0xffffff);
|
||
|
|
return cmd_sync_uart();
|
||
|
|
}
|
||
|
|
} while (cnt++ < 3);
|
||
|
|
|
||
|
|
XR_DBG("cmd_sync_baud fail.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int32_t cmd_write_seq(uint32_t addr, uint32_t len, uint8_t *data)
|
||
|
|
{
|
||
|
|
int ret = -1;
|
||
|
|
uint8_t buffer[MB_CMD_HEADER_SIZE + 13];
|
||
|
|
cmd_seq_wr_t *cmd = (cmd_seq_wr_t *)buffer;
|
||
|
|
|
||
|
|
cmd->cmdid = CMD_ID_SEQWR;
|
||
|
|
cmd->addr = addr;
|
||
|
|
cmd->dlen = len;
|
||
|
|
#if ENABLE_DCS
|
||
|
|
cmd->dcs = ~CheckSum16(data, len);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
ret = xr_raw_write(CMD_WRITESEQ, buffer + MB_CMD_HEADER_SIZE, 11);
|
||
|
|
if (ret == 0) {
|
||
|
|
return xr_raw_write(DATA_RAW, data, len);
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int32_t cmd_set_pc(uint32_t pc)
|
||
|
|
{
|
||
|
|
uint8_t buffer[MB_CMD_HEADER_SIZE + 5];
|
||
|
|
cmd_sys_t *cmd = (cmd_sys_t*)buffer;
|
||
|
|
|
||
|
|
cmd->cmdid = CMD_ID_SETPC;
|
||
|
|
cmd->val = pc;
|
||
|
|
XR_DBG("set pc %x, val %x", pc, cmd->val);
|
||
|
|
|
||
|
|
return xr_raw_write(CMD_SETPC, buffer + MB_CMD_HEADER_SIZE, 5);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void userial_set_hw_fctrl(uint8_t hw_fctrl)
|
||
|
|
{
|
||
|
|
if (vnd_userial.fd == -1) {
|
||
|
|
XR_ERR("vnd_userial.fd is -1");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (hw_fctrl) {
|
||
|
|
XR_DBG("Set HW FlowControl On");
|
||
|
|
vnd_userial.ti->c_cflag |= CRTSCTS;
|
||
|
|
} else {
|
||
|
|
XR_DBG("Set HW FlowControl Off");
|
||
|
|
vnd_userial.ti->c_cflag &= ~CRTSCTS;
|
||
|
|
}
|
||
|
|
tcsetattr(vnd_userial.fd, TCSANOW, vnd_userial.ti);
|
||
|
|
tcflush(vnd_userial.fd, TCIOFLUSH);
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint32_t userial_read(uint8_t *buffer, uint32_t len, uint32_t timeout)
|
||
|
|
{
|
||
|
|
fd_set set;
|
||
|
|
struct timeval tv;
|
||
|
|
int rv;
|
||
|
|
|
||
|
|
FD_ZERO(&set); /* clear the set */
|
||
|
|
FD_SET(vnd_userial.fd, &set); /* add our file descriptor to the set */
|
||
|
|
|
||
|
|
/* there was data to read */
|
||
|
|
ssize_t r;
|
||
|
|
uint8_t *pos = (uint8_t*)buffer;
|
||
|
|
|
||
|
|
while (len > 0) {
|
||
|
|
tv.tv_sec = 0;
|
||
|
|
tv.tv_usec = timeout;
|
||
|
|
|
||
|
|
rv = select(vnd_userial.fd + 1, &set, NULL, NULL, &tv);
|
||
|
|
if(rv == -1) {
|
||
|
|
XR_ERR("select error"); /* an error accured */
|
||
|
|
break;
|
||
|
|
} else if(rv == 0) {
|
||
|
|
XR_ERR("read timeout"); /* a timeout occured */
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
r = read(vnd_userial.fd, pos, len);
|
||
|
|
if (r < 1)
|
||
|
|
break;
|
||
|
|
|
||
|
|
len -= r;
|
||
|
|
pos += r;
|
||
|
|
}
|
||
|
|
|
||
|
|
return pos - buffer;
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint32_t userial_write(const uint8_t *buffer, uint32_t len)
|
||
|
|
{
|
||
|
|
ssize_t r;
|
||
|
|
uint8_t *pos = (uint8_t*)buffer;
|
||
|
|
|
||
|
|
while (len > 0) {
|
||
|
|
r = write(vnd_userial.fd, pos, len);
|
||
|
|
if (r < 1)
|
||
|
|
break;
|
||
|
|
|
||
|
|
len -= r;
|
||
|
|
pos += r;
|
||
|
|
}
|
||
|
|
|
||
|
|
return pos - buffer;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int32_t load_btfirmware(void)
|
||
|
|
{
|
||
|
|
FILE *fwfile_fd = NULL;
|
||
|
|
uint32_t len;
|
||
|
|
uint8_t *data = NULL;
|
||
|
|
uint32_t addr = BT_FW_LOAD_ADDR;
|
||
|
|
uint32_t section = SZ_16K;
|
||
|
|
|
||
|
|
fwfile_fd = fopen(BT_FW_PATH_NAME, "rb");
|
||
|
|
XR_DBG("BT firmware: %s", BT_FW_PATH_NAME);
|
||
|
|
if(!fwfile_fd) {
|
||
|
|
XR_ERR("Unable to open BT firmware %s", BT_FW_PATH_NAME);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
data = (uint8_t*)malloc(section);
|
||
|
|
if (data == NULL) {
|
||
|
|
XR_DBG("failed to alloc %d byte memory.", section);
|
||
|
|
fclose(fwfile_fd);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
XR_DBG("load bt firmware starting.");
|
||
|
|
while ((len = fread(data, 1, section, fwfile_fd)) > 0) {
|
||
|
|
cmd_write_seq(addr, len, data);
|
||
|
|
addr += len;
|
||
|
|
}
|
||
|
|
|
||
|
|
free(data);
|
||
|
|
fclose(fwfile_fd);
|
||
|
|
XR_DBG("load firmware done.");
|
||
|
|
|
||
|
|
XR_DBG("Firmware run from address 0x%08X", BT_FW_JUMP_ADDR);
|
||
|
|
cmd_set_pc(BT_FW_JUMP_ADDR);
|
||
|
|
|
||
|
|
if (CHIP_NAME == AW1732) {
|
||
|
|
XR_DBG("second time sync starting....");
|
||
|
|
if (cmd_sync_uart() < 0)
|
||
|
|
return -1;
|
||
|
|
cmd_set_pc(BT_FW_JUMP_ADDR);
|
||
|
|
}
|
||
|
|
return addr;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int hci_cmd_handle(const uint8_t *cmd, uint32_t cmd_len, uint32_t event_len)
|
||
|
|
{
|
||
|
|
uint8_t buffer[256];
|
||
|
|
|
||
|
|
XR_DBG("send hci command");
|
||
|
|
userial_write(cmd, cmd_len);
|
||
|
|
XR_DUMP(cmd, cmd_len);
|
||
|
|
|
||
|
|
if (read_hci_event(vnd_userial.fd, buffer, event_len) != event_len) {
|
||
|
|
XR_ERR("Event read error");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
XR_DBG("Received event");
|
||
|
|
XR_DUMP(buffer, event_len);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int xr_init(int fd, struct uart_t *u, struct termios *ti)
|
||
|
|
{
|
||
|
|
vnd_userial.fd = fd;
|
||
|
|
vnd_userial.ti = ti;
|
||
|
|
|
||
|
|
XR_DBG("uart sync starting....");
|
||
|
|
if (cmd_sync_uart() < 0)
|
||
|
|
goto END;
|
||
|
|
XR_DBG("set bandrate to %d.", u->speed);
|
||
|
|
if (cmd_sync_baud(((u->speed) | (3<<24))) < 0)
|
||
|
|
goto END;
|
||
|
|
if (load_btfirmware() < 0)
|
||
|
|
goto END;
|
||
|
|
XR_DBG("bt firmware is running....");
|
||
|
|
|
||
|
|
XR_DBG("set baudrate to %d", u->init_speed);
|
||
|
|
set_speed(vnd_userial.fd, vnd_userial.ti, u->init_speed);
|
||
|
|
userial_set_hw_fctrl(1);
|
||
|
|
usleep(50000);
|
||
|
|
|
||
|
|
XR_DBG("process hci reset...");
|
||
|
|
if (hci_cmd_handle(hci_reset, sizeof(hci_reset), 7) < 0)
|
||
|
|
goto END;
|
||
|
|
|
||
|
|
XR_DBG("process hci update baud...");
|
||
|
|
if (hci_cmd_handle(hci_update_baud_rate, sizeof(hci_update_baud_rate), 7) < 0)
|
||
|
|
goto END;
|
||
|
|
|
||
|
|
usleep(100000);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
END:
|
||
|
|
XR_DBG("device fd = %d close", fd);
|
||
|
|
close(vnd_userial.fd);
|
||
|
|
vnd_userial.fd = -1;
|
||
|
|
vnd_userial.ti = NULL;
|
||
|
|
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
int xr_post(int fd, struct uart_t *u, struct termios *ti)
|
||
|
|
{
|
||
|
|
XR_DBG("Done setting line discpline");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|