/*
*
* Copyright (c) 2013, The Linux Foundation. All rights reserved.
* Not a Contribution.
*
* Copyright 2012 The Android Open Source Project
*
* 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: hw_ar3k.c
*
* Description: Contains controller-specific functions, like
* firmware patch download
* low power mode operations
*
******************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
#define LOG_TAG "bt_vendor"
#include <sys/socket.h>
#include <utils/Log.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include <dirent.h>
#include <ctype.h>
#include <cutils/properties.h>
#include <stdlib.h>
#include <termios.h>
#include <string.h>
#include "bt_hci_bdroid.h"
#include "bt_vendor_qcom.h"
#include "hci_uart.h"
#include "hw_ar3k.h"
#include "bt_vendor_qcom.h"
/******************************************************************************
** Variables
******************************************************************************/
int cbstat = 0;
#define PATCH_LOC_STRING_LEN 8
char ARbyte[3];
char ARptr[MAX_PATCH_CMD + 1];
int byte_cnt;
int patch_count = 0;
char patch_loc[PATCH_LOC_STRING_LEN + 1];
int PSCounter=0;
uint32_t dev_type = 0;
uint32_t rom_version = 0;
uint32_t build_version = 0;
char patch_file[PATH_MAX];
char ps_file[PATH_MAX];
FILE *stream;
int tag_count=0;
/* for friendly debugging outpout string */
static char *lpm_mode[] = {
"UNKNOWN",
"disabled",
"enabled"
};
static char *lpm_state[] = {
"UNKNOWN",
"de-asserted",
"asserted"
};
static uint8_t upio_state[UPIO_MAX_COUNT];
struct ps_cfg_entry ps_list[MAX_TAGS];
#define PS_EVENT_LEN 100
#ifdef __cplusplus
}
#endif
#define RESERVED(p) if(p) ALOGI( "%s: reserved param", __FUNCTION__);
/*****************************************************************************
** Functions
*****************************************************************************/
int is_bt_soc_ath() {
int ret = 0;
char bt_soc_type[PROPERTY_VALUE_MAX];
ret = property_get("qcom.bluetooth.soc", bt_soc_type, NULL);
if (ret != 0) {
ALOGI("qcom.bluetooth.soc set to %s\n", bt_soc_type);
if (!strncasecmp(bt_soc_type, "ath3k", sizeof("ath3k")))
return 1;
} else {
ALOGI("qcom.bluetooth.soc not set, so using default.\n");
}
return 0;
}
/*
* Send HCI command and wait for command complete event.
* The event buffer has to be freed by the caller.
*/
static int send_hci_cmd_sync(int dev, uint8_t *cmd, int len, uint8_t **event)
{
int err;
uint8_t *hci_event;
uint8_t pkt_type = HCI_COMMAND_PKT;
if (len == 0)
return len;
if (write(dev, &pkt_type, 1) != 1)
return -EILSEQ;
if (write(dev, (unsigned char *)cmd, len) != len)
return -EILSEQ;
hci_event = (uint8_t *)malloc(PS_EVENT_LEN);
if (!hci_event)
return -ENOMEM;
err = read_hci_event(dev, (unsigned char *)hci_event, PS_EVENT_LEN);
if (err > 0) {
*event = hci_event;
} else {
free(hci_event);
return -EILSEQ;
}
return len;
}
static void convert_bdaddr(char *str_bdaddr, char *bdaddr)
{
char bdbyte[3];
char *str_byte = str_bdaddr;
int i, j;
int colon_present = 0;
if (strstr(str_bdaddr, ":"))
colon_present = 1;
bdbyte[2] = '\0';
/* Reverse the BDADDR to LSB first */
for (i = 0, j = 5; i < 6; i++, j--) {
bdbyte[0] = str_byte[0];
bdbyte[1] = str_byte[1];
bdaddr[j] = strtol(bdbyte, NULL, 16);
if (colon_present == 1)
str_byte += 3;
else
str_byte += 2;
}
}
static int uart_speed(int s)
{
switch (s) {
case 9600:
return B9600;
case 19200:
return B19200;
case 38400:
return B38400;
case 57600:
return B57600;
case 115200:
return B115200;
case 230400:
return B230400;
case 460800:
return B460800;
case 500000:
return B500000;
case 576000:
return B576000;
case 921600:
return B921600;
case 1000000:
return B1000000;
case 1152000:
return B1152000;
case 1500000:
return B1500000;
case 2000000:
return B2000000;
#ifdef B2500000
case 2500000:
return B2500000;
#endif
#ifdef B3000000
case 3000000:
return B3000000;
#endif
#ifdef B3500000
case 3500000:
return B3500000;
#endif
#ifdef B4000000
case 4000000:
return B4000000;
#endif
default:
return B57600;
}
}
int set_speed(int fd, struct termios *ti, int speed)
{
if (cfsetospeed(ti, uart_speed(speed)) < 0)
return -errno;
if (cfsetispeed(ti, uart_speed(speed)) < 0)
return -errno;
if (tcsetattr(fd, TCSANOW, ti) < 0)
return -errno;
return 0;
}
static void load_hci_ps_hdr(uint8_t *cmd, uint8_t ps_op, int len, int index)
{
hci_command_hdr *ch = (void *)cmd;
ch->opcode = htobs(cmd_opcode_pack(HCI_VENDOR_CMD_OGF,
HCI_PS_CMD_OCF));
ch->plen = len + PS_HDR_LEN;
cmd += HCI_COMMAND_HDR_SIZE;
cmd[0] = ps_op;
cmd[1] = index;
cmd[2] = index >> 8;
cmd[3] = len;
}
static int read_ps_event(uint8_t *event, uint16_t ocf)
{
hci_event_hdr *eh;
uint16_t opcode = htobs(cmd_opcode_pack(HCI_VENDOR_CMD_OGF, ocf));
event++;
eh = (void *)event;
event += HCI_EVENT_HDR_SIZE;
if (eh->evt == EVT_CMD_COMPLETE) {
evt_cmd_complete *cc = (void *)event;
event += EVT_CMD_COMPLETE_SIZE;
if (cc->opcode == opcode && event[0] == HCI_EV_SUCCESS)
return 0;
else
return -EILSEQ;
}
return -EILSEQ;
}
#define PS_WRITE 1
#define PS_RESET 2
#define WRITE_PATCH 8
#define ENABLE_PATCH 11
#define HCI_PS_CMD_HDR_LEN 7
static int write_cmd(int fd, uint8_t *buffer, int len)
{
uint8_t *event;
int err;
err = send_hci_cmd_sync(fd, buffer, len, &event);
if (err < 0)
return err;
err = read_ps_event(event, HCI_PS_CMD_OCF);
free(event);
return err;
}
#define PS_RESET_PARAM_LEN 6
#define PS_RESET_CMD_LEN (HCI_PS_CMD_HDR_LEN + PS_RESET_PARAM_LEN)
#define PS_ID_MASK 0xFF
/* Sends PS commands using vendor specficic HCI commands */
static int write_ps_cmd(int fd, uint8_t opcode, uint32_t ps_param)
{
uint8_t cmd[HCI_MAX_CMD_SIZE];
uint32_t i;
switch (opcode) {
case ENABLE_PATCH:
load_hci_ps_hdr(cmd, opcode, 0, 0x00);
if (write_cmd(fd, cmd, HCI_PS_CMD_HDR_LEN) < 0)
return -EILSEQ;
break;
case PS_RESET:
load_hci_ps_hdr(cmd, opcode, PS_RESET_PARAM_LEN, 0x00);
cmd[7] = 0x00;
cmd[PS_RESET_CMD_LEN - 2] = ps_param & PS_ID_MASK;
cmd[PS_RESET_CMD_LEN - 1] = (ps_param >> 8) & PS_ID_MASK;
if (write_cmd(fd, cmd, PS_RESET_CMD_LEN) < 0)
return -EILSEQ;
break;
case PS_WRITE:
for (i = 0; i < ps_param; i++) {
load_hci_ps_hdr(cmd, opcode, ps_list[i].len,
ps_list[i].id);
memcpy(&cmd[HCI_PS_CMD_HDR_LEN], ps_list[i].data,
ps_list[i].len);
if (write_cmd(fd, cmd, ps_list[i].len +
HCI_PS_CMD_HDR_LEN) < 0)
return -EILSEQ;
}
break;
}
return 0;
}
#define PS_ASIC_FILE "PS_ASIC.pst"
#define PS_FPGA_FILE "PS_FPGA.pst"
#define MAXPATHLEN 4096
static void get_ps_file_name(uint32_t devtype, uint32_t rom_version,char *path)
{
char *filename;
if (devtype == 0xdeadc0de)
filename = PS_ASIC_FILE;
else
filename = PS_FPGA_FILE;
snprintf(path, MAXPATHLEN, "%s%x/%s", FW_PATH, rom_version, filename);
}
#define PATCH_FILE "RamPatch.txt"
#define FPGA_ROM_VERSION 0x99999999
#define ROM_DEV_TYPE 0xdeadc0de
static void get_patch_file_name(uint32_t dev_type, uint32_t rom_version,
uint32_t build_version, char *path)
{
if (rom_version == FPGA_ROM_VERSION && dev_type != ROM_DEV_TYPE
&&dev_type != 0 && build_version == 1)
path[0] = '\0';
else
snprintf(path, MAXPATHLEN, "%s%x/%s", FW_PATH, rom_version, PATCH_FILE);
}
static int set_cntrlr_baud(int fd, int speed)
{
int baud;
struct timespec tm = { 0, 500000};
unsigned char cmd[MAX_CMD_LEN], rsp[HCI_MAX_EVENT_SIZE];
unsigned char *ptr = cmd + 1;
hci_command_hdr *ch = (void *)ptr;
cmd[0] = HCI_COMMAND_PKT;
/* set controller baud rate to user specified value */
ptr = cmd + 1;
ch->opcode = htobs(cmd_opcode_pack(HCI_VENDOR_CMD_OGF,
HCI_CHG_BAUD_CMD_OCF));
ch->plen = 2;
ptr += HCI_COMMAND_HDR_SIZE;
baud = speed/100;
ptr[0] = (char)baud;
ptr[1] = (char)(baud >> 8);
if (write(fd, cmd, WRITE_BAUD_CMD_LEN) != WRITE_BAUD_CMD_LEN) {
ALOGI("Failed to write change baud rate command");
return -ETIMEDOUT;
}
nanosleep(&tm, NULL);
if (read_hci_event(fd, rsp, sizeof(rsp)) < 0)
return -ETIMEDOUT;
return 0;
}
#define PS_UNDEF 0
#define PS_ID 1
#define PS_LEN 2
#define PS_DATA 3
#define PS_MAX_LEN 500
#define LINE_SIZE_MAX (PS_MAX_LEN * 2)
#define ENTRY_PER_LINE 16
#define __check_comment(buf) (((buf)[0] == '/') && ((buf)[1] == '/'))
#define __skip_space(str) while (*(str) == ' ') ((str)++)
#define __is_delim(ch) ((ch) == ':')
#define MAX_PREAMBLE_LEN 4
/* Parse PS entry preamble of format [X:X] for main type and subtype */
static int get_ps_type(char *ptr, int index, char *type, char *sub_type)
{
int i;
int delim = FALSE;
if (index > MAX_PREAMBLE_LEN)
return -EILSEQ;
for (i = 1; i < index; i++) {
if (__is_delim(ptr[i])) {
delim = TRUE;
continue;
}
if (isalpha(ptr[i])) {
if (delim == FALSE)
(*type) = toupper(ptr[i]);
else
(*sub_type) = toupper(ptr[i]);
}
}
return 0;
}
#define ARRAY 'A'
#define STRING 'S'
#define DECIMAL 'D'
#define BINARY 'B'
#define PS_HEX 0
#define PS_DEC 1
static int get_input_format(char *buf, struct ps_entry_type *format)
{
char *ptr = NULL;
char type = '\0';
char sub_type = '\0';
format->type = PS_HEX;
format->array = TRUE;
if (strstr(buf, "[") != buf)
return 0;
ptr = strstr(buf, "]");
if (!ptr)
return -EILSEQ;
if (get_ps_type(buf, ptr - buf, &type, &sub_type) < 0)
return -EILSEQ;
/* Check is data type is of array */
if (type == ARRAY || sub_type == ARRAY)
format->array = TRUE;
if (type == STRING || sub_type == STRING)
format->array = FALSE;
if (type == DECIMAL || type == BINARY)
format->type = PS_DEC;
else
format->type = PS_HEX;
return 0;
}
#define UNDEFINED 0xFFFF
static unsigned int read_data_in_section(char *buf, struct ps_entry_type type)
{
char *ptr = buf;
if (!buf)
return UNDEFINED;
if (buf == strstr(buf, "[")) {
ptr = strstr(buf, "]");
if (!ptr)
return UNDEFINED;
ptr++;
}
if (type.type == PS_HEX && type.array != TRUE)
return strtol(ptr, NULL, 16);
return UNDEFINED;
}
/* Read PS entries as string, convert and add to Hex array */
static void update_tag_data(struct ps_cfg_entry *tag,
struct tag_info *info, const char *ptr)
{
char buf[3];
buf[2] = '\0';
strlcpy(buf, &ptr[info->char_cnt],sizeof(buf));
tag->data[info->byte_count] = strtol(buf, NULL, 16);
info->char_cnt += 3;
info->byte_count++;
strlcpy(buf, &ptr[info->char_cnt], sizeof(buf));
tag->data[info->byte_count] = strtol(buf, NULL, 16);
info->char_cnt += 3;
info->byte_count++;
}
static inline int update_char_count(const char *buf)
{
char *end_ptr;
if (strstr(buf, "[") == buf) {
end_ptr = strstr(buf, "]");
if (!end_ptr)
return 0;
else
return(end_ptr - buf) + 1;
}
return 0;
}
#define PS_HEX 0
#define PS_DEC 1
static int ath_parse_ps(FILE *stream)
{
char buf[LINE_SIZE_MAX + 1];
char *ptr;
uint8_t tag_cnt = 0;
int16_t byte_count = 0;
struct ps_entry_type format;
struct tag_info status = { 0, 0, 0, 0};
do {
int read_count;
struct ps_cfg_entry *tag;
ptr = fgets(buf, LINE_SIZE_MAX, stream);
if (!ptr)
break;
__skip_space(ptr);
if (__check_comment(ptr))
continue;
/* Lines with a '#' will be followed by new PS entry */
if (ptr == strstr(ptr, "#")) {
if (status.section != PS_UNDEF) {
return -EILSEQ;
} else {
status.section = PS_ID;
continue;
}
}
tag = &ps_list[tag_cnt];
switch (status.section) {
case PS_ID:
if (get_input_format(ptr, &format) < 0)
return -EILSEQ;
tag->id = read_data_in_section(ptr, format);
status.section = PS_LEN;
break;
case PS_LEN:
if (get_input_format(ptr, &format) < 0)
return -EILSEQ;
byte_count = read_data_in_section(ptr, format);
if (byte_count > PS_MAX_LEN)
return -EILSEQ;
tag->len = byte_count;
tag->data = (uint8_t *)malloc(byte_count);
status.section = PS_DATA;
status.line_count = 0;
break;
case PS_DATA:
if (status.line_count == 0)
if (get_input_format(ptr, &format) < 0)
return -EILSEQ;
__skip_space(ptr);
status.char_cnt = update_char_count(ptr);
read_count = (byte_count > ENTRY_PER_LINE) ?
ENTRY_PER_LINE : byte_count;
if (format.type == PS_HEX && format.array == TRUE) {
while (read_count > 0) {
update_tag_data(tag, &status, ptr);
read_count -= 2;
}
if (byte_count > ENTRY_PER_LINE)
byte_count -= ENTRY_PER_LINE;
else
byte_count = 0;
}
status.line_count++;
if (byte_count == 0)
memset(&status, 0x00, sizeof(struct tag_info));
if (status.section == PS_UNDEF)
tag_cnt++;
if (tag_cnt == MAX_TAGS)
return -EILSEQ;
break;
}
} while (ptr);
return tag_cnt;
}
#define PS_RAM_SIZE 2048
static int ps_config_download(int fd, int tag_count)
{
if (write_ps_cmd(fd, PS_RESET, PS_RAM_SIZE) < 0)
return -1;
if (tag_count > 0)
if (write_ps_cmd(fd, PS_WRITE, tag_count) < 0)
return -1;
return 0;
}
static int write_bdaddr(int pConfig, char *bdaddr)
{
uint8_t *event;
int err;
uint8_t cmd[13];
uint8_t *ptr = cmd;
hci_command_hdr *ch = (void *)cmd;
memset(cmd, 0, sizeof(cmd));
ch->opcode = htobs(cmd_opcode_pack(HCI_VENDOR_CMD_OGF,
HCI_PS_CMD_OCF));
ch->plen = 10;
ptr += HCI_COMMAND_HDR_SIZE;
ptr[0] = 0x01;
ptr[1] = 0x01;
ptr[2] = 0x00;
ptr[3] = 0x06;
convert_bdaddr(bdaddr, (char *)&ptr[4]);
err = send_hci_cmd_sync(pConfig, cmd, sizeof(cmd), &event);
if (err < 0)
return err;
err = read_ps_event(event, HCI_PS_CMD_OCF);
free(event);
return err;
}
static void write_bdaddr_from_file(int rom_version, int fd)
{
FILE *stream;
char bdaddr[PATH_MAX];
char bdaddr_file[PATH_MAX];
snprintf(bdaddr_file, MAXPATHLEN, "%s%x/%s",
FW_PATH, rom_version, BDADDR_FILE);
stream = fopen(bdaddr_file, "r");
if (!stream)
return;
if (fgets(bdaddr, PATH_MAX - 1, stream))
write_bdaddr(fd, bdaddr);
fclose(stream);
}
#define HCI_EVT_CMD_CMPL_OPCODE 3
#define HCI_EVT_CMD_CMPL_STATUS_RET_BYTE 5
void baswap(bdaddr_t *dst, const bdaddr_t *src)
{
register unsigned char *d = (unsigned char *) dst;
register const unsigned char *s = (const unsigned char *) src;
register int i;
for (i = 0; i < 6; i++)
d[i] = s[5-i];
}
int str2ba(const char *str, bdaddr_t *ba)
{
uint8_t b[6];
const char *ptr = str;
int i;
for (i = 0; i < 6; i++) {
b[i] = (uint8_t) strtol(ptr, NULL, 16);
ptr = strchr(ptr, ':');
if (i != 5 && !ptr)
ptr = ":00:00:00:00:00";
ptr++;
}
baswap(ba, (bdaddr_t *) b);
return 0;
}
#define DEV_REGISTER 0x4FFC
#define GET_DEV_TYPE_OCF 0x05
static int get_device_type(int dev, uint32_t *code)
{
uint8_t cmd[8] = {0};
uint8_t *event;
uint32_t reg;
int err;
uint8_t *ptr = cmd;
hci_command_hdr *ch = (void *)cmd;
ch->opcode = htobs(cmd_opcode_pack(HCI_VENDOR_CMD_OGF,
GET_DEV_TYPE_OCF));
ch->plen = 5;
ptr += HCI_COMMAND_HDR_SIZE;
ptr[0] = (uint8_t)DEV_REGISTER;
ptr[1] = (uint8_t)DEV_REGISTER >> 8;
ptr[2] = (uint8_t)DEV_REGISTER >> 16;
ptr[3] = (uint8_t)DEV_REGISTER >> 24;
ptr[4] = 0x04;
err = send_hci_cmd_sync(dev, cmd, sizeof(cmd), &event);
if (err < 0)
return err;
err = read_ps_event(event, GET_DEV_TYPE_OCF);
if (err < 0)
goto cleanup;
reg = event[10];
reg = (reg << 8) | event[9];
reg = (reg << 8) | event[8];
reg = (reg << 8) | event[7];
*code = reg;
cleanup:
free(event);
return err;
}
#define GET_VERSION_OCF 0x1E
static int read_ath3k_version(int pConfig, uint32_t *rom_version,
uint32_t *build_version)
{
uint8_t cmd[3] = {0};
uint8_t *event;
int err;
int status;
hci_command_hdr *ch = (void *)cmd;
ch->opcode = htobs(cmd_opcode_pack(HCI_VENDOR_CMD_OGF,
GET_VERSION_OCF));
ch->plen = 0;
err = send_hci_cmd_sync(pConfig, cmd, sizeof(cmd), &event);
if (err < 0)
return err;
err = read_ps_event(event, GET_VERSION_OCF);
if (err < 0)
goto cleanup;
status = event[10];
status = (status << 8) | event[9];
status = (status << 8) | event[8];
status = (status << 8) | event[7];
*rom_version = status;
status = event[14];
status = (status << 8) | event[13];
status = (status << 8) | event[12];
status = (status << 8) | event[11];
*build_version = status;
cleanup:
free(event);
return err;
}
#define VERIFY_CRC 9
#define PS_REGION 1
#define PATCH_REGION 2
static int get_ath3k_crc(int dev)
{
uint8_t cmd[7] = {0};
uint8_t *event;
int err;
load_hci_ps_hdr(cmd, VERIFY_CRC, 0, PS_REGION | PATCH_REGION);
err = send_hci_cmd_sync(dev, cmd, sizeof(cmd), &event);
if (err < 0)
return err;
/* Send error code if CRC check patched */
if (read_ps_event(event, HCI_PS_CMD_OCF) >= 0)
err = -EILSEQ;
free(event);
return err;
}
#define SET_PATCH_RAM_ID 0x0D
#define SET_PATCH_RAM_CMD_SIZE 11
#define ADDRESS_LEN 4
static int set_patch_ram(int dev, char *patch_loc, int len)
{
int err;
uint8_t cmd[20] = {0};
int i, j;
char loc_byte[3];
uint8_t *event;
uint8_t *loc_ptr = &cmd[7];
RESERVED(len);
if (!patch_loc)
return -1;
loc_byte[2] = '\0';
load_hci_ps_hdr(cmd, SET_PATCH_RAM_ID, ADDRESS_LEN, 0);
for (i = 0, j = 3; i < 4; i++, j--) {
loc_byte[0] = patch_loc[0];
loc_byte[1] = patch_loc[1];
loc_ptr[j] = strtol(loc_byte, NULL, 16);
patch_loc += 2;
}
err = send_hci_cmd_sync(dev, cmd, SET_PATCH_RAM_CMD_SIZE, &event);
if (err < 0)
return err;
err = read_ps_event(event, HCI_PS_CMD_OCF);
free(event);
return err;
}
#define PATCH_LOC_KEY "DA:"
#define PATCH_LOC_STRING_LEN 8
static int ps_patch_download(int fd, FILE *stream)
{
char byte[3];
char ptr[MAX_PATCH_CMD + 1];
int byte_cnt;
int patch_count = 0;
char patch_loc[PATCH_LOC_STRING_LEN + 1];
byte[2] = '\0';
while (fgets(ptr, MAX_PATCH_CMD, stream)) {
if (strlen(ptr) <= 1)
continue;
else if (strstr(ptr, PATCH_LOC_KEY) == ptr) {
strlcpy(patch_loc, &ptr[sizeof(PATCH_LOC_KEY) - 1],
PATCH_LOC_STRING_LEN);
if (set_patch_ram(fd, patch_loc, sizeof(patch_loc)) < 0)
return -1;
} else if (isxdigit(ptr[0]))
break;
else
return -1;
}
byte_cnt = strtol(ptr, NULL, 16);
while (byte_cnt > 0) {
int i;
uint8_t cmd[HCI_MAX_CMD_SIZE] = {0};
struct patch_entry patch;
if (byte_cnt > MAX_PATCH_CMD)
patch.len = MAX_PATCH_CMD;
else
patch.len = byte_cnt;
for (i = 0; i < patch.len; i++) {
if (!fgets(byte, 3, stream))
return -1;
patch.data[i] = strtoul(byte, NULL, 16);
}
load_hci_ps_hdr(cmd, WRITE_PATCH, patch.len, patch_count);
memcpy(&cmd[HCI_PS_CMD_HDR_LEN], patch.data, patch.len);
if (write_cmd(fd, cmd, patch.len + HCI_PS_CMD_HDR_LEN) < 0)
return -1;
patch_count++;
byte_cnt = byte_cnt - MAX_PATCH_CMD;
}
if (write_ps_cmd(fd, ENABLE_PATCH, 0) < 0)
return -1;
return patch_count;
}
static int ath_ps_download(int fd)
{
int err = 0;
int tag_count;
int patch_count = 0;
uint32_t rom_version = 0;
uint32_t build_version = 0;
uint32_t dev_type = 0;
char patch_file[PATH_MAX];
char ps_file[PATH_MAX];
FILE *stream;
/*
* Verfiy firmware version. depending on it select the PS
* config file to download.
*/
if (get_device_type(fd, &dev_type) < 0) {
err = -EILSEQ;
goto download_cmplete;
}
if (read_ath3k_version(fd, &rom_version, &build_version) < 0) {
err = -EILSEQ;
goto download_cmplete;
}
/* Do not download configuration if CRC passes */
if (get_ath3k_crc(fd) < 0) {
err = 0;
goto download_cmplete;
}
get_ps_file_name(dev_type, rom_version, ps_file);
get_patch_file_name(dev_type, rom_version, build_version, patch_file);
stream = fopen(ps_file, "r");
if (!stream) {
ALOGI("firmware file open error:%s, ver:%x\n",ps_file, rom_version);
if (rom_version == 0x1020201)
err = 0;
else
err = -EILSEQ;
goto download_cmplete;
}
tag_count = ath_parse_ps(stream);
fclose(stream);
if (tag_count < 0) {
err = -EILSEQ;
goto download_cmplete;
}
/*
* It is not necessary that Patch file be available,
* continue with PS Operations if patch file is not available.
*/
if (patch_file[0] == '\0')
err = 0;
stream = fopen(patch_file, "r");
if (!stream)
err = 0;
else {
patch_count = ps_patch_download(fd, stream);
fclose(stream);
if (patch_count < 0) {
err = -EILSEQ;
goto download_cmplete;
}
}
err = ps_config_download(fd, tag_count);
download_cmplete:
if (!err)
write_bdaddr_from_file(rom_version, fd);
return err;
}
int ath3k_init(int fd, int speed, int init_speed, char *bdaddr, struct termios *ti)
{
ALOGI(" %s ", __FUNCTION__);
int r;
int err = 0;
struct timespec tm = { 0, 500000};
unsigned char cmd[MAX_CMD_LEN] = {0};
unsigned char rsp[HCI_MAX_EVENT_SIZE];
unsigned char *ptr = cmd + 1;
hci_command_hdr *ch = (void *)ptr;
int flags = 0;
if (ioctl(fd, TIOCMGET, &flags) < 0) {
ALOGI("TIOCMGET failed in init\n");
return -1;
}
flags |= TIOCM_RTS;
if (ioctl(fd, TIOCMSET, &flags) < 0) {
ALOGI("TIOCMSET failed in init: HW Flow-on error\n");
return -1;
}
/* set both controller and host baud rate to maximum possible value */
err = set_cntrlr_baud(fd, speed);
ALOGI("set_cntrlr_baud : ret:%d \n", err);
if (err < 0)
return err;
err = set_speed(fd, ti, speed);
if (err < 0) {
ALOGI("Can't set required baud rate");
return err;
}
/* Download PS and patch */
r = ath_ps_download(fd);
if (r < 0) {
ALOGI("Failed to Download configuration");
err = -ETIMEDOUT;
goto failed;
}
ALOGI("ath_ps_download is done\n");
cmd[0] = HCI_COMMAND_PKT;
/* Write BDADDR */
if (bdaddr) {
ch->opcode = htobs(cmd_opcode_pack(HCI_VENDOR_CMD_OGF,
HCI_PS_CMD_OCF));
ch->plen = 10;
ptr += HCI_COMMAND_HDR_SIZE;
ptr[0] = 0x01;
ptr[1] = 0x01;
ptr[2] = 0x00;
ptr[3] = 0x06;
str2ba(bdaddr, (bdaddr_t *)(ptr + 4));
if (write(fd, cmd, WRITE_BDADDR_CMD_LEN) !=
WRITE_BDADDR_CMD_LEN) {
ALOGI("Failed to write BD_ADDR command\n");
err = -ETIMEDOUT;
goto failed;
}
if (read_hci_event(fd, rsp, sizeof(rsp)) < 0) {
ALOGI("Failed to set BD_ADDR\n");
err = -ETIMEDOUT;
goto failed;
}
}
/* Send HCI Reset */
cmd[1] = 0x03;
cmd[2] = 0x0C;
cmd[3] = 0x00;
r = write(fd, cmd, 4);
if (r != 4) {
err = -ETIMEDOUT;
goto failed;
}
nanosleep(&tm, NULL);
if (read_hci_event(fd, rsp, sizeof(rsp)) < 0) {
err = -ETIMEDOUT;
goto failed;
}
ALOGI("HCI Reset is done\n");
err = set_cntrlr_baud(fd, speed);
if (err < 0)
ALOGI("set_cntrlr_baud0:%d,%d\n", speed, err);
failed:
if (err < 0) {
set_cntrlr_baud(fd, init_speed);
set_speed(fd, ti, init_speed);
}
return err;
}
#define BTPROTO_HCI 1
/* Open HCI device.
* Returns device descriptor (dd). */
int hci_open_dev(int dev_id)
{
struct sockaddr_hci a;
int dd, err;
/* Create HCI socket */
dd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
if (dd < 0)
return dd;
/* Bind socket to the HCI device */
memset(&a, 0, sizeof(a));
a.hci_family = AF_BLUETOOTH;
a.hci_dev = dev_id;
if (bind(dd, (struct sockaddr *) &a, sizeof(a)) < 0)
goto failed;
return dd;
failed:
err = errno;
close(dd);
errno = err;
return -1;
}
int hci_close_dev(int dd)
{
return close(dd);
}
/* HCI functions that require open device
* dd - Device descriptor returned by hci_open_dev. */
int hci_send_cmd(int dd, uint16_t ogf, uint16_t ocf, uint8_t plen, void *param)
{
uint8_t type = HCI_COMMAND_PKT;
hci_command_hdr hc;
struct iovec iv[3];
int ivn;
hc.opcode = htobs(cmd_opcode_pack(ogf, ocf));
hc.plen= plen;
iv[0].iov_base = &type;
iv[0].iov_len = 1;
iv[1].iov_base = &hc;
iv[1].iov_len = HCI_COMMAND_HDR_SIZE;
ivn = 2;
if (plen) {
iv[2].iov_base = param;
iv[2].iov_len = plen;
ivn = 3;
}
while (writev(dd, iv, ivn) < 0) {
if (errno == EAGAIN || errno == EINTR)
continue;
return -1;
}
return 0;
}
#define HCI_SLEEP_CMD_OCF 0x04
#define TIOCSETD 0x5423
#define HCIUARTSETFLAGS _IOW('U', 204, int)
#define HCIUARTSETPROTO _IOW('U', 200, int)
#define HCIUARTGETDEVICE _IOW('U', 202, int)
/*
* Atheros AR300x specific initialization post callback
*/
int ath3k_post(int fd, int pm)
{
int dev_id, dd;
struct timespec tm = { 0, 50000};
sleep(1);
dev_id = ioctl(fd, HCIUARTGETDEVICE, 0);
if (dev_id < 0) {
perror("cannot get device id");
return dev_id;
}
dd = hci_open_dev(dev_id);
if (dd < 0) {
perror("HCI device open failed");
return dd;
}
if (ioctl(dd, HCIDEVUP, dev_id) < 0 && errno != EALREADY) {
perror("hci down:Power management Disabled");
hci_close_dev(dd);
return -1;
}
/* send vendor specific command with Sleep feature Enabled */
if (hci_send_cmd(dd, OGF_VENDOR_CMD, HCI_SLEEP_CMD_OCF, 1, &pm) < 0)
perror("PM command failed, power management Disabled");
nanosleep(&tm, NULL);
hci_close_dev(dd);
return 0;
}
#define FLOW_CTL 0x0001
#define ENABLE_PM 1
#define DISABLE_PM 0
/* Initialize UART driver */
static int init_uart(char *dev, struct uart_t *u, int send_break, int raw)
{
ALOGI(" %s ", __FUNCTION__);
struct termios ti;
int i, fd;
unsigned long flags = 0;
if (raw)
flags |= 1 << HCI_UART_RAW_DEVICE;
fd = open(dev, O_RDWR | O_NOCTTY);
if (fd < 0) {
ALOGI("Can't open serial port");
return -1;
}
tcflush(fd, TCIOFLUSH);
if (tcgetattr(fd, &ti) < 0) {
ALOGI("Can't get port settings: %d\n", errno);
return -1;
}
cfmakeraw(&ti);
ti.c_cflag |= CLOCAL;
if (u->flags & FLOW_CTL)
ti.c_cflag |= CRTSCTS;
else
ti.c_cflag &= ~CRTSCTS;
if (tcsetattr(fd, TCSANOW, &ti) < 0) {
ALOGI("Can't set port settings");
return -1;
}
if (set_speed(fd, &ti, u->init_speed) < 0) {
ALOGI("Can't set initial baud rate");
return -1;
}
tcflush(fd, TCIOFLUSH);
if (send_break) {
tcsendbreak(fd, 0);
usleep(500000);
}
ath3k_init(fd,u->speed,u->init_speed,u->bdaddr, &ti);
ALOGI("Device setup complete\n");
tcflush(fd, TCIOFLUSH);
// Set actual baudrate
/*
if (set_speed(fd, &ti, u->speed) < 0) {
perror("Can't set baud rate");
return -1;
}
i = N_HCI;
if (ioctl(fd, TIOCSETD, &i) < 0) {
perror("Can't set line discipline");
return -1;
}
if (flags && ioctl(fd, HCIUARTSETFLAGS, flags) < 0) {
perror("Can't set UART flags");
return -1;
}
if (ioctl(fd, HCIUARTSETPROTO, u->proto) < 0) {
perror("Can't set device");
return -1;
}
#if !defined(SW_BOARD_HAVE_BLUETOOTH_RTK)
ath3k_post(fd, u->pm);
#endif
*/
return fd;
}
int hw_config_ath3k(char *port_name)
{
ALOGI(" %s ", __FUNCTION__);
PSCounter=0;
struct sigaction sa;
struct uart_t u ;
int n=0,send_break=0,raw=0;
memset(&u, 0, sizeof(u));
u.speed =3000000;
u.init_speed =115200;
u.flags |= FLOW_CTL;
u.pm = DISABLE_PM;
n = init_uart(port_name, &u, send_break, raw);
if (n < 0) {
ALOGI("Can't initialize device");
}
return n;
}
void lpm_set_ar3k(uint8_t pio, uint8_t action, uint8_t polarity)
{
int rc;
int fd = -1;
char buffer;
ALOGI("lpm mode: %d action: %d", pio, action);
RESERVED(polarity);
switch (pio)
{
case UPIO_LPM_MODE:
if (upio_state[UPIO_LPM_MODE] == action)
{
ALOGI("LPM is %s already", lpm_mode[action]);
return;
}
fd = open(VENDOR_LPM_PROC_NODE, O_WRONLY);
if (fd < 0)
{
ALOGE("upio_set : open(%s) for write failed: %s (%d)",
VENDOR_LPM_PROC_NODE, strerror(errno), errno);
return;
}
if (action == UPIO_ASSERT)
{
buffer = '1';
}
else
{
buffer = '0';
}
if (write(fd, &buffer, 1) < 0)
{
ALOGE("upio_set : write(%s) failed: %s (%d)",
VENDOR_LPM_PROC_NODE, strerror(errno),errno);
}
else
{
upio_state[UPIO_LPM_MODE] = action;
ALOGI("LPM is set to %s", lpm_mode[action]);
}
if (fd >= 0)
close(fd);
break;
case UPIO_BT_WAKE:
/* UPIO_DEASSERT should be allowed because in Rx case assert occur
* from the remote side where as deassert will be initiated from Host
*/
if ((action == UPIO_ASSERT) && (upio_state[UPIO_BT_WAKE] == action))
{
ALOGI("BT_WAKE is %s already", lpm_state[action]);
return;
}
if (action == UPIO_DEASSERT)
buffer = '0';
else
buffer = '1';
fd = open(VENDOR_BTWRITE_PROC_NODE, O_WRONLY);
if (fd < 0)
{
ALOGE("upio_set : open(%s) for write failed: %s (%d)",
VENDOR_BTWRITE_PROC_NODE, strerror(errno), errno);
return;
}
if (write(fd, &buffer, 1) < 0)
{
ALOGE("upio_set : write(%s) failed: %s (%d)",
VENDOR_BTWRITE_PROC_NODE, strerror(errno),errno);
}
else
{
upio_state[UPIO_BT_WAKE] = action;
ALOGI("BT_WAKE is set to %s", lpm_state[action]);
}
ALOGI("proc btwrite assertion");
if (fd >= 0)
close(fd);
break;
case UPIO_HOST_WAKE:
ALOGI("upio_set: UPIO_HOST_WAKE");
break;
}
}