/*
|
* btif_woble.c
|
*
|
* Created on: 2020
|
* Author: Unisoc
|
*/
|
#include <linux/kernel.h>
|
#include <linux/module.h>
|
#include <linux/platform_device.h>
|
#include <linux/slab.h>
|
#include <linux/types.h>
|
#include <linux/kdev_t.h>
|
#include <linux/tty.h>
|
#include <linux/vt_kern.h>
|
#include <linux/init.h>
|
#include <linux/console.h>
|
#include <linux/delay.h>
|
#include <linux/semaphore.h>
|
#include <linux/vmalloc.h>
|
|
#include <linux/file.h>
|
#include <linux/string.h>
|
#include "woble.h"
|
#include "tty.h"
|
#include "alignment/sitm.h"
|
#include <marlin_platform.h>
|
|
#define CMD_TIMEOUT 5000
|
#define MAX_WAKE_DEVICE_MAX_NUM 36
|
#define CONFIG_FILE_PATH "/data/misc/bluedroid/bt_config.conf"
|
|
static struct hci_cmd_t hci_cmd;
|
uint8_t device_count_db;
|
const woble_config_t s_woble_config_cust = {WOBLE_MOD_ENABLE, WOBLE_SLEEP_MOD_COULD_NOT_KNOW, 0, WOBLE_SLEEP_MOD_NOT_NEED_NOTITY};
|
|
mtty_bt_wake_t bt_wake_dev_db[MAX_WAKE_DEVICE_MAX_NUM];
|
|
int woble_init(void)
|
{
|
memset(&hci_cmd, 0, sizeof(struct hci_cmd_t));
|
sema_init(&hci_cmd.wait, 0);
|
|
return 0;
|
}
|
|
int mtty_bt_str_hex(char *str, uint8_t count, char *hex)
|
{
|
uint8_t data_buf[12] = {0x00};
|
uint8_t i = 0;
|
while ((*str != '\0') && (i < count * 2)) {
|
if ((*str >= '0') && (*str <= '9')) {
|
data_buf[i] = *str - '0' + 0x00;
|
i++;
|
} else if ((*str >= 'A') && (*str <= 'F')) {
|
data_buf[i] = *str - 'A' + 0x0A;
|
i++;
|
} else if ((*str >= 'a') && (*str <= 'f')) {
|
data_buf[i] = *str - 'a' + 0x0a;
|
i++;
|
} else {
|
;
|
}
|
str++;
|
}
|
if (count == 1) {
|
*hex = data_buf[0];
|
} else {
|
for (i = 0; i < count; i++) {
|
hex[i] = (data_buf[0 + i * 2] << 4) + data_buf[1 + i * 2];
|
}
|
}
|
for (i = 0; i < count; i++) {
|
pr_info("%s data[%d] = %02x\n", __func__, i, hex[i]);
|
}
|
return 0;
|
}
|
|
int mtty_bt_conf_prase(char *conf_str)
|
{
|
char *tok_str = conf_str;
|
char *str1, *str2, *str3;
|
uint8_t device_count = 0;
|
uint8_t loop_count = 0;
|
if (conf_str) {
|
while (tok_str != NULL) {
|
tok_str = strsep(&conf_str, "\r\n");
|
if (!tok_str)
|
continue;
|
if ((strpbrk(tok_str, "[") != NULL) &&
|
(strpbrk(tok_str, "]") != NULL) &&
|
(strpbrk(tok_str, ":") != NULL)) {
|
bt_wake_dev_db[device_count].addr_str = tok_str;
|
continue;
|
}
|
if (strstr(tok_str, "DevType") != NULL) {
|
bt_wake_dev_db[device_count].dev_tp_str = tok_str;
|
continue;
|
}
|
if (strstr(tok_str, "AddrType") != NULL) {
|
bt_wake_dev_db[device_count].addr_tp_str = tok_str;
|
device_count++;
|
}
|
}
|
} else {
|
pr_info("%s conf_str is NULL\n", __func__);
|
}
|
if (device_count) {
|
for (; loop_count < device_count; loop_count++) {
|
str1 = strchr(bt_wake_dev_db[loop_count].addr_str, '[');
|
str2 = strstrip(bt_wake_dev_db[loop_count].dev_tp_str);
|
str2 = strchr(str2, '=');
|
str3 = strstrip(bt_wake_dev_db[loop_count].addr_tp_str);
|
str3 = strchr(str3, '=');
|
mtty_bt_str_hex(str1, 6, bt_wake_dev_db[loop_count].addr);
|
mtty_bt_str_hex(str2, 1, &(bt_wake_dev_db[loop_count].dev_tp));
|
mtty_bt_str_hex(str3, 1, &(bt_wake_dev_db[loop_count].addr_tp));
|
}
|
}
|
return device_count;
|
}
|
|
int mtty_bt_read_conf(void)
|
{
|
char *buffer = NULL;
|
unsigned char *p_buf = NULL;
|
struct file *bt_conf_fp;
|
unsigned int read_len, buffer_len;
|
uint8_t device_count = 0;
|
loff_t file_size = 0;
|
loff_t file_offset = 0;
|
memset(bt_wake_dev_db, 0, sizeof(mtty_bt_wake_t) * MAX_WAKE_DEVICE_MAX_NUM);
|
bt_conf_fp = filp_open(CONFIG_FILE_PATH, O_RDONLY, 0);
|
if (IS_ERR(bt_conf_fp)) {
|
pr_info("%s open file %s error %ld \n",
|
__func__, CONFIG_FILE_PATH, PTR_ERR(bt_conf_fp));
|
return device_count;
|
}
|
file_size = vfs_llseek(bt_conf_fp, 0, SEEK_END);
|
buffer_len = 0;
|
buffer = vmalloc(file_size);
|
p_buf = buffer;
|
if (!buffer) {
|
fput(bt_conf_fp);
|
pr_info("%s no memory\n", __func__);
|
return device_count;
|
}
|
|
do {
|
read_len = kernel_read(bt_conf_fp, p_buf, file_size, &file_offset);
|
if (read_len > 0) {
|
buffer_len += read_len;
|
file_size -= read_len;
|
p_buf += read_len;
|
}
|
} while ((read_len > 0) && (file_size > 0));
|
|
fput(bt_conf_fp);
|
pr_info("%s read %s data_len:0x%x\n",
|
__func__, CONFIG_FILE_PATH, buffer_len);
|
device_count = mtty_bt_conf_prase(buffer);
|
return device_count;
|
}
|
|
int woble_data_recv(const unsigned char *buf, int count)
|
{
|
unsigned short opcode = 0;
|
unsigned char status = 0;
|
const unsigned char *p = 0;
|
const unsigned char *rxmsg = buf;
|
int left_length = count;
|
int pack_length = 0;
|
int last = 0;
|
int ret = -1;
|
|
if (count < 0) {
|
pr_err("%s count < 0!!!", __func__);
|
}
|
|
do {
|
rxmsg = buf + (count - left_length);
|
switch (rxmsg[PACKET_TYPE]) {
|
case HCI_EVT:
|
if (left_length < 3) {
|
pr_err("%s left_length <3 !!!!!", __func__);
|
}
|
pack_length = rxmsg[EVT_HEADER_SIZE];
|
pack_length += 3;
|
|
if (left_length - pack_length < 0) {
|
pr_err("%s left_length - pack_length <0 !!!!!", __func__);
|
|
}
|
switch (rxmsg[EVT_HEADER_EVENT]) {
|
default:
|
case BT_HCI_EVT_CMD_COMPLETE:
|
p = rxmsg + 4;
|
STREAM_TO_UINT16(opcode, p);
|
STREAM_TO_UINT8(status, p);
|
break;
|
|
case BT_HCI_EVT_CMD_STATUS:
|
p = rxmsg + 5;
|
STREAM_TO_UINT16(opcode, p);
|
status = rxmsg[3];
|
break;
|
}
|
last = left_length;
|
left_length -= pack_length;
|
break;
|
default:
|
left_length = 0;
|
break;
|
}
|
} while (left_length);
|
|
if (hci_cmd.opcode == opcode && hci_cmd.opcode) {
|
pr_info("%s opcode: 0x%04X, status: %d\n", __func__, opcode, status);
|
up(&hci_cmd.wait);
|
ret = 0;
|
}
|
return ret;
|
}
|
|
int hci_cmd_send_sync(unsigned short opcode, struct HC_BT_HDR *py,
|
struct HC_BT_HDR *rsp)
|
{
|
unsigned char msg_req[HCI_CMD_MAX_LEN + BYTE_ALIGNMENT] = {0}, *p;
|
int ret = 0;
|
|
p = msg_req;
|
UINT8_TO_STREAM(p, HCI_CMD);
|
UINT16_TO_STREAM(p, opcode);
|
|
if (py == NULL) {
|
UINT8_TO_STREAM(p, 0);
|
} else {
|
UINT8_TO_STREAM(p, py->len);
|
ARRAY_TO_STREAM(p, py->data, py->len);
|
}
|
|
hci_cmd.opcode = opcode;
|
ret = marlin_sdio_write(msg_req, (p - msg_req) + (BYTE_ALIGNMENT - ((p - msg_req) % BYTE_ALIGNMENT)));
|
if (!ret) {
|
hci_cmd.opcode = 0;
|
pr_err("%s marlin_sdio_write fail", __func__);
|
return 0;
|
}
|
|
if (down_timeout(&hci_cmd.wait, msecs_to_jiffies(CMD_TIMEOUT))) {
|
pr_err("%s CMD_TIMEOUT for CMD: 0x%04X", __func__, opcode);
|
mdbg_assert_interface("hci cmd timeout");
|
}
|
hci_cmd.opcode = 0;
|
|
return 0;
|
}
|
|
void hci_set_ap_sleep_mode(int is_shutdown, int is_resume)
|
{
|
struct HC_BT_HDR *payload = (struct HC_BT_HDR *)vmalloc(sizeof(struct HC_BT_HDR) + 3);
|
unsigned char *p;
|
p = payload->data;
|
|
payload->len = 6;
|
if (is_resume && !is_shutdown) {
|
UINT8_TO_STREAM(p, 0);
|
} else {
|
UINT8_TO_STREAM(p, s_woble_config_cust.woble_mod);
|
}
|
|
if (is_shutdown) {
|
UINT8_TO_STREAM(p, WOBLE_SLEEP_MOD_COULD_KNOW);
|
} else {
|
UINT8_TO_STREAM(p, WOBLE_SLEEP_MOD_COULD_NOT_KNOW);
|
}
|
|
UINT16_TO_STREAM(p, s_woble_config_cust.timeout);
|
UINT8_TO_STREAM(p, s_woble_config_cust.notify);
|
UINT8_TO_STREAM(p, 0);
|
|
hci_cmd_send_sync(BT_HCI_OP_SET_SLEEPMODE, payload, NULL);
|
vfree(payload);
|
return;
|
}
|
|
void hci_add_device_to_wakeup_list(mtty_bt_wake_t bt_wakeup_dev)
|
{
|
struct HC_BT_HDR *payload = (struct HC_BT_HDR *)vmalloc(sizeof(struct HC_BT_HDR) + 3);
|
unsigned char *p;
|
p = payload->data;
|
|
payload->len = 10;
|
UINT8_TO_STREAM(p, bt_wakeup_dev.addr_tp);
|
//ARRAY_TO_STREAM(p, bt_wakeup_dev.addr,6);
|
UINT8_TO_STREAM(p, bt_wakeup_dev.addr[5]);
|
UINT8_TO_STREAM(p, bt_wakeup_dev.addr[4]);
|
UINT8_TO_STREAM(p, bt_wakeup_dev.addr[3]);
|
UINT8_TO_STREAM(p, bt_wakeup_dev.addr[2]);
|
UINT8_TO_STREAM(p, bt_wakeup_dev.addr[1]);
|
UINT8_TO_STREAM(p, bt_wakeup_dev.addr[0]);
|
UINT16_TO_STREAM(p, 3);
|
UINT8_TO_STREAM(p, 0);
|
|
hci_cmd_send_sync(BT_HCI_OP_ADD_WAKEUPLIST, payload, NULL);
|
vfree(payload);
|
return;
|
}
|
|
void hci_set_ap_start_sleep(void)
|
{
|
struct HC_BT_HDR *payload = (struct HC_BT_HDR *)vmalloc(sizeof(struct HC_BT_HDR) + 3);
|
|
hci_cmd_send_sync(BT_HCI_OP_SET_STARTSLEEP, NULL, NULL);
|
vfree(payload);
|
return;
|
}
|
