| /* |
| * Copyright (c) 2014 MediaTek Inc. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| |
| /** steve wang 2015/11/26 */ |
| //--------------------------------------------------------------------------- |
| #include "LD_usbbt.h" |
| #include "LD_btmtk_usb.h" |
| #include "errno.h" |
| |
| //- Local Configuration ----------------------------------------------------- |
| #define LD_VERSION "1.2.0.1" |
| |
| #define BUFFER_SIZE (1024 * 4) /* Size of RX Queue */ |
| #define BT_SEND_HCI_CMD_BEFORE_SUSPEND 1 |
| #define LD_SUPPORT_FW_DUMP 0 |
| #define LD_BT_ALLOC_BUF 0 |
| #define LD_NOT_FIX_BUILD_WARN 0 |
| |
| #define FIDX 0x5A /* Unify WoBLE APCF Filtering Index */ |
| |
| #ifndef strtol |
| #define strtol simple_strtol |
| #endif |
| |
| //--------------------------------------------------------------------------- |
| static char driver_version[64] = { 0 }; |
| static unsigned char probe_counter = 0; |
| static volatile int metaMode; |
| static volatile int metaCount; |
| /* 0: False; 1: True */ |
| static int isbtready; |
| static int isUsbDisconnet; |
| static volatile int is_assert = 0; |
| |
| //--------------------------------------------------------------------------- |
| static inline int is_mt7630(struct LD_btmtk_usb_data *data) |
| { |
| return ((data->chip_id & 0xffff0000) == 0x76300000); |
| } |
| |
| //--------------------------------------------------------------------------- |
| static inline int is_mt7650(struct LD_btmtk_usb_data *data) |
| { |
| return ((data->chip_id & 0xffff0000) == 0x76500000); |
| } |
| |
| //--------------------------------------------------------------------------- |
| static inline int is_mt7632(struct LD_btmtk_usb_data *data) |
| { |
| return ((data->chip_id & 0xffff0000) == 0x76320000); |
| } |
| |
| //--------------------------------------------------------------------------- |
| static inline int is_mt7662(struct LD_btmtk_usb_data *data) |
| { |
| return ((data->chip_id & 0xffff0000) == 0x76620000); |
| } |
| |
| //--------------------------------------------------------------------------- |
| static inline int is_mt7662T(struct LD_btmtk_usb_data *data) |
| { |
| return ((data->chip_id & 0xffffffff) == 0x76620100); |
| } |
| |
| //--------------------------------------------------------------------------- |
| static inline int is_mt7632T(struct LD_btmtk_usb_data *data) |
| { |
| return ((data->chip_id & 0xffffffff) == 0x76320100); |
| } |
| |
| //--------------------------------------------------------------------------- |
| static inline int is_mt7668(struct LD_btmtk_usb_data *data) |
| { |
| return ((data->chip_id & 0xffff) == 0x7668); |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_io_read32(struct LD_btmtk_usb_data *data, u32 reg, u32 *val) |
| { |
| u8 request = data->r_request; |
| int ret; |
| |
| ret = data->hcif->usb_control_msg(data->udev, MTKBT_CTRL_RX_EP, request, |
| DEVICE_VENDOR_REQUEST_IN, 0, (u16)reg, data->io_buf, sizeof(u32), |
| CONTROL_TIMEOUT_JIFFIES); |
| |
| if (ret < 0) |
| { |
| *val = 0xffffffff; |
| usb_debug("error(%d), reg=%x, value=%x\n", ret, reg, *val); |
| return ret; |
| } |
| |
| os_memmove(val, data->io_buf, sizeof(u32)); |
| *val = le32_to_cpu(*val); |
| return 0; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_io_read32_7668(struct LD_btmtk_usb_data *data, u32 reg, u32 *val) |
| { |
| int ret = -1; |
| __le16 reg_high; |
| __le16 reg_low; |
| |
| reg_high = ((reg >> 16) & 0xFFFF); |
| reg_low = (reg & 0xFFFF); |
| |
| ret = data->hcif->usb_control_msg(data->udev, MTKBT_CTRL_RX_EP, 0x63, |
| DEVICE_VENDOR_REQUEST_IN, reg_high, reg_low, data->io_buf, sizeof(u32), |
| CONTROL_TIMEOUT_JIFFIES); |
| if (ret < 0) { |
| *val = 0xFFFFFFFF; |
| usb_debug("error(%d), reg=%X, value=%X\n", ret, reg, *val); |
| return ret; |
| } |
| |
| os_memmove(val, data->io_buf, sizeof(u32)); |
| *val = le32_to_cpu(*val); |
| return 0; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_io_write32(struct LD_btmtk_usb_data *data, u32 reg, u32 val) |
| { |
| u16 value, index; |
| u8 request = data->w_request; |
| mtkbt_dev_t *udev = data->udev; |
| int ret; |
| |
| index = (u16) reg; |
| value = val & 0x0000ffff; |
| |
| ret = data->hcif->usb_control_msg(udev, MTKBT_CTRL_TX_EP, request, DEVICE_VENDOR_REQUEST_OUT, |
| value, index, NULL, 0, CONTROL_TIMEOUT_JIFFIES); |
| |
| if (ret < 0) |
| { |
| usb_debug("error(%d), reg=%x, value=%x\n", ret, reg, val); |
| return ret; |
| } |
| |
| index = (u16) (reg + 2); |
| value = (val & 0xffff0000) >> 16; |
| |
| ret = data->hcif->usb_control_msg(udev, MTKBT_CTRL_TX_EP, request, DEVICE_VENDOR_REQUEST_OUT, |
| value, index, NULL, 0, CONTROL_TIMEOUT_JIFFIES); |
| |
| if (ret < 0) |
| { |
| usb_debug("error(%d), reg=%x, value=%x\n", ret, reg, val); |
| return ret; |
| } |
| if (ret > 0) |
| { |
| ret = 0; |
| } |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_send_wmt_cmd(struct LD_btmtk_usb_data *data, const u8 *cmd, |
| const int cmd_len, const u8 *event, const int event_len, u32 delay, u8 retry) |
| { |
| int ret = -1; |
| BOOL check = FALSE; |
| |
| if (!data || !data->hcif || !data->io_buf || !cmd) { |
| usb_debug("incorrect cmd pointer\n"); |
| return -1; |
| } |
| if (event != NULL && event_len > 0) |
| check = TRUE; |
| |
| /* send WMT command */ |
| ret = data->hcif->usb_control_msg(data->udev, MTKBT_CTRL_TX_EP, 0x01, |
| DEVICE_CLASS_REQUEST_OUT, 0x30, 0x00, (void *)cmd, cmd_len, |
| CONTROL_TIMEOUT_JIFFIES); |
| if (ret < 0) { |
| usb_debug("command send failed(%d)\n", ret); |
| return ret; |
| } |
| |
| if (event_len == -1) { |
| /* If event_len is -1, DO NOT read event, since FW wouldn't feedback */ |
| return 0; |
| } |
| |
| retry_get: |
| MTK_MDELAY(delay); |
| |
| /* check WMT event */ |
| ret = data->hcif->usb_control_msg(data->udev, MTKBT_CTRL_RX_EP, 0x01, |
| DEVICE_VENDOR_REQUEST_IN, 0x30, 0x00, data->io_buf, LD_BT_MAX_EVENT_SIZE, |
| CONTROL_TIMEOUT_JIFFIES); |
| if (ret < 0) { |
| usb_debug("event get failed(%d)\n", ret); |
| if (check == TRUE) return ret; |
| else return 0; |
| } |
| |
| if (check == TRUE) { |
| if (ret >= event_len && memcmp(event, data->io_buf, event_len) == 0) { |
| return ret; |
| } else if (retry > 0) { |
| usb_debug("retry to get event(%d)\n", retry); |
| retry--; |
| goto retry_get; |
| } else { |
| usb_debug("can't get expect event\n"); |
| } |
| } |
| return -1; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_send_hci_cmd(struct LD_btmtk_usb_data *data, const u8 *cmd, |
| const int cmd_len, const u8 *event, const int event_len) |
| { |
| /** @RETURN |
| * length if event compare successfully., |
| * 0 if doesn't check event., |
| * < 0 if error. |
| */ |
| #define USB_CTRL_IO_TIMO 100 |
| #define USB_INTR_MSG_TIMO 2000 |
| int ret = -1; |
| int len = 0; |
| int i = 0; |
| u8 retry = 0; |
| BOOL check = FALSE; |
| |
| if (!data || !data->hcif || !data->io_buf || !cmd) { |
| usb_debug("incorrect cmd pointer\n"); |
| return -1; |
| } |
| if (event != NULL && event_len > 0) |
| check = TRUE; |
| |
| /* send HCI command */ |
| ret = data->hcif->usb_control_msg(data->udev, MTKBT_CTRL_TX_EP, 0, |
| DEVICE_CLASS_REQUEST_OUT, 0, 0, (u8 *)cmd, cmd_len, USB_CTRL_IO_TIMO); |
| if (ret < 0) { |
| usb_debug("send command failed: %d\n", ret); |
| return ret; |
| } |
| |
| if (event_len == -1) { |
| /* If event_len is -1, DO NOT read event, since FW wouldn't feedback */ |
| return 0; |
| } |
| |
| /* check HCI event */ |
| do { |
| ret = data->hcif->usb_interrupt_msg(data->udev, MTKBT_INTR_EP, data->io_buf, |
| LD_BT_MAX_EVENT_SIZE, &len, USB_INTR_MSG_TIMO); |
| if (ret < 0) { |
| usb_debug("event get failed: %d\n", ret); |
| if (check == TRUE) return ret; |
| else return 0; |
| } |
| |
| if (check == TRUE) { |
| if (len >= event_len) { |
| for (i = 0; i < event_len; i++) { |
| if (event[i] != data->io_buf[i]) |
| break; |
| } |
| } else { |
| usb_debug("event length is not match(%d/%d)\n", len, event_len); |
| } |
| if (i != event_len) { |
| usb_debug("got unknown event(%d)\n", len); |
| } else { |
| return len; /* actually read length */ |
| } |
| MTK_MDELAY(10); |
| ++retry; |
| } |
| usb_debug("try get event again\n"); |
| } while (retry < 3); |
| return -1; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_send_hci_suspend_cmd(struct LD_btmtk_usb_data *data) |
| { |
| int ret = -1; |
| /* mtkbt_dev_t *udev = data->udev; */ |
| #if SUPPORT_HISENSE_WoBLE |
| u8 cmd[] = {0xC9, 0xFC, 0x02, 0x01, 0x0D}; // for Hisense WoBLE |
| |
| usb_debug("issue wake up command for Hisense\n"); |
| #else |
| u8 cmd[] = {0xC9, 0xFC, 0x0D, 0x01, 0x0E, 0x00, 0x05, 0x43, |
| 0x52, 0x4B, 0x54, 0x4D, 0x20, 0x04, 0x32, 0x00}; |
| |
| usb_debug("issue wake up command for '0E: MTK WoBLE Ver2'\n"); |
| #endif |
| |
| ret = btmtk_usb_send_hci_cmd(data, cmd, sizeof(cmd), NULL, -1); |
| if (ret < 0) { |
| usb_debug("error(%d)\n", ret); |
| return ret; |
| } |
| usb_debug("send suspend cmd OK\n"); |
| return 0; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_send_hci_reset_cmd(struct LD_btmtk_usb_data *data) |
| { |
| u8 cmd[] = { 0x03, 0x0C, 0x00 }; |
| u8 event[] = { 0x0E, 0x04, 0x01, 0x03, 0x0C, 0x00 }; |
| int ret = -1; |
| |
| ret = btmtk_usb_send_hci_cmd(data, cmd, sizeof(cmd), event, sizeof(event)); |
| if (ret < 0) { |
| usb_debug("failed(%d)\n", ret); |
| } else { |
| usb_debug("OK\n"); |
| } |
| |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_send_hci_set_ce_cmd(struct LD_btmtk_usb_data *data) |
| { |
| u8 cmd[] = { 0xD1, 0xFC, 0x04, 0x0C, 0x07, 0x41, 0x00 }; |
| u8 event[] = { 0x0E, 0x08, 0x01, 0xD1, 0xFC, 0x00 }; |
| int ret = -1; |
| |
| ret = btmtk_usb_send_hci_cmd(data, cmd, sizeof(cmd), event, sizeof(event)); |
| if (ret < 0) { |
| usb_debug("failed(%d)\n", ret); |
| |
| } else if (ret == sizeof(event) + 4) { |
| if (data->io_buf[6] & 0x01) { |
| usb_debug("warning, 0x41070c[0] is 1!\n"); |
| ret = 0; |
| } else { |
| u8 cmd2[11] = { 0xD0, 0xFC, 0x08, 0x0C, 0x07, 0x41, 0x00 }; |
| |
| cmd2[7] = data->io_buf[6] | 0x01; |
| cmd2[8] = data->io_buf[7]; |
| cmd2[9] = data->io_buf[8]; |
| cmd2[10] = data->io_buf[9]; |
| |
| ret = btmtk_usb_send_hci_cmd(data, cmd2, sizeof(cmd2), NULL, 0); |
| if (ret < 0) { |
| usb_debug("write 0x41070C failed(%d)\n", ret); |
| } else { |
| usb_debug("OK"); |
| ret = 0; |
| } |
| } |
| } else { |
| usb_debug("failed, incorrect response length(%d)\n", ret); |
| return -1; |
| } |
| |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_send_check_rom_patch_result_cmd(struct LD_btmtk_usb_data *data) |
| { |
| /* Send HCI Reset */ |
| { |
| int ret = 0; |
| unsigned char buf[8] = { 0 }; |
| buf[0] = 0xD1; |
| buf[1] = 0xFC; |
| buf[2] = 0x04; |
| buf[3] = 0x00; |
| buf[4] = 0xE2; |
| buf[5] = 0x40; |
| buf[6] = 0x00; |
| ret = data->hcif->usb_control_msg(data->udev, MTKBT_CTRL_TX_EP,0x0, DEVICE_CLASS_REQUEST_OUT, |
| 0x00, 0x00, buf, 0x07, 100); |
| if (ret < 0) |
| { |
| usb_debug("error1(%d)\n", ret); |
| return ret; |
| } |
| } |
| /* Get response of HCI reset */ |
| { |
| int ret = 0; |
| unsigned char buf[LD_BT_MAX_EVENT_SIZE] = { 0 }; |
| int actual_length = 0; |
| ret = data->hcif->usb_interrupt_msg(data->udev, MTKBT_INTR_EP, buf, LD_BT_MAX_EVENT_SIZE, |
| &actual_length, 2000); |
| if (ret < 0) |
| { |
| usb_debug("error2(%d)\n", ret); |
| return ret; |
| } |
| usb_debug("Check rom patch result : "); |
| |
| if (buf[6] == 0 && buf[7] == 0 && buf[8] == 0 && buf[9] == 0) |
| { |
| usb_debug("NG\n"); |
| } |
| else |
| { |
| usb_debug("OK\n"); |
| } |
| } |
| return 0; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_switch_iobase(struct LD_btmtk_usb_data *data, int base) |
| { |
| int ret = 0; |
| |
| switch (base) |
| { |
| case SYSCTL: |
| data->w_request = 0x42; |
| data->r_request = 0x47; |
| break; |
| case WLAN: |
| data->w_request = 0x02; |
| data->r_request = 0x07; |
| break; |
| |
| default: |
| return -EINVAL; |
| } |
| |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static void btmtk_usb_cap_init(struct LD_btmtk_usb_data *data) |
| { |
| btmtk_usb_io_read32(data, 0x00, &data->chip_id); |
| if (data->chip_id == 0) |
| btmtk_usb_io_read32_7668(data, 0x80000008, &data->chip_id); |
| |
| //usb_debug("chip id = %x\n", data->chip_id); |
| |
| if (is_mt7630(data) || is_mt7650(data)) { |
| data->need_load_fw = 1; |
| data->need_load_rom_patch = 0; |
| data->fw_header_image = NULL; |
| data->fw_bin_file_name = (unsigned char*)strdup("mtk/mt7650.bin"); |
| data->fw_len = 0; |
| |
| } else if (is_mt7662T(data) || is_mt7632T(data)) { |
| usb_debug("btmtk:This is 7662T chip\n"); |
| data->need_load_fw = 0; |
| data->need_load_rom_patch = 1; |
| data->rom_patch_bin_file_name = os_kzalloc(32, MTK_GFP_ATOMIC); |
| if (!data->rom_patch_bin_file_name) { |
| usb_debug("Can't allocate memory (32)\n"); |
| return; |
| } |
| os_memcpy(data->rom_patch_bin_file_name, "mt7662t_patch_e1_hdr.bin", 24); |
| data->rom_patch_offset = 0xBC000; |
| data->rom_patch_len = 0; |
| |
| } else if (is_mt7632(data) || is_mt7662(data)) { |
| usb_debug("btmtk:This is 7662 chip\n"); |
| data->need_load_fw = 0; |
| data->need_load_rom_patch = 1; |
| data->rom_patch_bin_file_name = os_kzalloc(32, MTK_GFP_ATOMIC); |
| if (!data->rom_patch_bin_file_name) { |
| usb_debug("Can't allocate memory (32)\n"); |
| return; |
| } |
| os_memcpy(data->rom_patch_bin_file_name, "mt7662_patch_e3_hdr.bin", 23); |
| data->rom_patch_offset = 0x90000; |
| data->rom_patch_len = 0; |
| |
| } else if (is_mt7668(data)) { |
| unsigned int chip_ver = 0; |
| |
| data->need_load_fw = 0; |
| data->need_load_rom_patch = 1; |
| data->rom_patch_bin_file_name = os_kzalloc(32, MTK_GFP_ATOMIC); |
| if (!data->rom_patch_bin_file_name) { |
| usb_debug("Can't allocate memory (32)\n"); |
| return; |
| } |
| btmtk_usb_io_read32_7668(data, 0x80000000, &chip_ver); |
| if (chip_ver == 0x8A00) { |
| usb_debug("btmtk:This is 7668 E1 chip\n"); |
| os_memcpy(data->rom_patch_bin_file_name, "mt7668_patch_e1_hdr.bin", 23); |
| } else if (chip_ver == 0x8B10) { |
| usb_debug("btmtk:This is 7668 E2 chip\n"); |
| os_memcpy(data->rom_patch_bin_file_name, "mt7668_patch_e2_hdr.bin", 23); |
| } else { |
| usb_debug("btmtk: Can't recognize version 0x%04X\n", chip_ver); |
| if (data->rom_patch_bin_file_name) os_kfree(data->rom_patch_bin_file_name); |
| } |
| data->chip_id |= chip_ver << 16; |
| data->rom_patch_offset = 0x2000000; |
| data->rom_patch_len = 0; |
| |
| } else { |
| usb_debug("unknow chip(%x)\n", data->chip_id); |
| } |
| } |
| |
| #if CRC_CHECK |
| //--------------------------------------------------------------------------- |
| static u16 checksume16(u8 *pData, int len) |
| { |
| int sum = 0; |
| |
| while (len > 1) |
| { |
| sum += *((u16 *) pData); |
| |
| pData = pData + 2; |
| |
| if (sum & 0x80000000) |
| { |
| sum = (sum & 0xFFFF) + (sum >> 16); |
| } |
| len -= 2; |
| } |
| |
| if (len) |
| sum += *((u8 *) pData); |
| |
| while (sum >> 16) |
| { |
| sum = (sum & 0xFFFF) + (sum >> 16); |
| } |
| |
| return ~sum; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_chk_crc(struct LD_btmtk_usb_data *data, u32 checksum_len) |
| { |
| int ret = 0; |
| mtkbt_dev_t *udev = data->udev; |
| |
| usb_debug("\n"); |
| |
| os_memmove(data->io_buf, &data->rom_patch_offset, 4); |
| os_memmove(&data->io_buf[4], &checksum_len, 4); |
| |
| ret = data->hcif->usb_control_msg(udev, MTKBT_CTRL_TX_EP,0x1, DEVICE_VENDOR_REQUEST_OUT, |
| 0x20, 0x00, data->io_buf, 8, CONTROL_TIMEOUT_JIFFIES); |
| |
| if (ret < 0) |
| { |
| usb_debug("error(%d)\n", ret); |
| } |
| |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static u16 btmtk_usb_get_crc(struct LD_btmtk_usb_data *data) |
| { |
| int ret = 0; |
| mtkbt_dev_t *udev = data->udev; |
| u16 crc, count = 0; |
| |
| usb_debug("\n"); |
| |
| while (1) |
| { |
| ret = |
| data->hcif->usb_control_msg(udev, MTKBT_CTRL_RX_EP, 0x01, DEVICE_VENDOR_REQUEST_IN, |
| 0x21, 0x00, data->io_buf, 2, CONTROL_TIMEOUT_JIFFIES); |
| |
| if (ret < 0) |
| { |
| crc = 0xFFFF; |
| usb_debug("error(%d)\n", ret); |
| } |
| |
| os_memmove(&crc, data->io_buf, 2); |
| |
| crc = le16_to_cpu(crc); |
| |
| if (crc != 0xFFFF) |
| break; |
| |
| MTK_MDELAY(100); |
| |
| if (count++ > 100) |
| { |
| usb_debug("Query CRC over %d times\n", count); |
| break; |
| } |
| } |
| |
| return crc; |
| } |
| #endif /* CRC_CHECK */ |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_send_wmt_reset_cmd(struct LD_btmtk_usb_data *data) |
| { |
| /* reset command */ |
| u8 cmd[] = { 0x6F, 0xFC, 0x05, 0x01, 0x07, 0x01, 0x00, 0x04 }; |
| u8 event[] = { 0xE4, 0x05, 0x02, 0x07, 0x01, 0x00, 0x00 }; |
| int ret = -1; |
| |
| ret = btmtk_usb_send_wmt_cmd(data, cmd, sizeof(cmd), event, sizeof(event), 20, 0); |
| if (ret < 0) { |
| usb_debug("Check reset wmt result : NG\n"); |
| } else { |
| usb_debug("Check reset wmt result : OK\n"); |
| ret = 0; |
| } |
| |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static u16 btmtk_usb_get_rom_patch_result(struct LD_btmtk_usb_data *data) |
| { |
| int ret = 0; |
| |
| ret = data->hcif->usb_control_msg(data->udev, MTKBT_CTRL_RX_EP, 0x01, |
| DEVICE_VENDOR_REQUEST_IN, 0x30, 0x00, data->io_buf, 7, |
| CONTROL_TIMEOUT_JIFFIES); |
| |
| if (ret < 0) |
| { |
| usb_debug("error(%d)\n", ret); |
| } |
| |
| if (data->io_buf[0] == 0xe4 && |
| data->io_buf[1] == 0x05 && |
| data->io_buf[2] == 0x02 && |
| data->io_buf[3] == 0x01 && |
| data->io_buf[4] == 0x01 && |
| data->io_buf[5] == 0x00 && |
| data->io_buf[6] == 0x00) |
| { |
| //usb_debug("Get rom patch result : OK\n"); |
| } |
| else |
| { |
| usb_debug("Get rom patch result : NG\n"); |
| } |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| #define SHOW_FW_DETAILS(s) \ |
| usb_debug("%s = %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c", s, \ |
| tmp_str[0], tmp_str[1], tmp_str[2], tmp_str[3], \ |
| tmp_str[4], tmp_str[5], tmp_str[6], tmp_str[7], \ |
| tmp_str[8], tmp_str[9], tmp_str[10], tmp_str[11], \ |
| tmp_str[12], tmp_str[13], tmp_str[14], tmp_str[15]) |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_load_rom_patch(struct LD_btmtk_usb_data *data) |
| { |
| u32 loop = 0; |
| u32 value; |
| s32 sent_len; |
| int ret = 0; |
| u32 patch_len = 0; |
| u32 cur_len = 0; |
| int real_len = 0; |
| int first_block = 1; |
| unsigned char phase; |
| void *buf; |
| char *pos; |
| unsigned char *tmp_str; |
| |
| //usb_debug("begin\n"); |
| load_patch_protect: |
| btmtk_usb_switch_iobase(data, WLAN); |
| btmtk_usb_io_read32(data, SEMAPHORE_03, &value); |
| loop++; |
| |
| if ((value & 0x01) == 0x00) |
| { |
| if (loop < 1000) |
| { |
| MTK_MDELAY(1); |
| goto load_patch_protect; |
| } |
| else |
| { |
| usb_debug("btmtk_usb_load_rom_patch ERR! Can't get semaphore! Continue\n"); |
| } |
| } |
| |
| btmtk_usb_switch_iobase(data, SYSCTL); |
| |
| btmtk_usb_io_write32(data, 0x1c, 0x30); |
| |
| btmtk_usb_switch_iobase(data, WLAN); |
| |
| /* check ROM patch if upgrade */ |
| if ((MT_REV_GTE(data, mt7662, REV_MT76x2E3)) || (MT_REV_GTE(data, mt7632, REV_MT76x2E3))) |
| { |
| btmtk_usb_io_read32(data, CLOCK_CTL, &value); |
| if ((value & 0x01) == 0x01) |
| { |
| usb_debug("btmtk_usb_load_rom_patch : no need to load rom patch\n"); |
| btmtk_usb_send_hci_reset_cmd(data); |
| goto error; |
| } |
| } |
| else |
| { |
| btmtk_usb_io_read32(data, COM_REG0, &value); |
| if ((value & 0x02) == 0x02) |
| { |
| usb_debug("btmtk_usb_load_rom_patch : no need to load rom patch\n"); |
| btmtk_usb_send_hci_reset_cmd(data); |
| goto error; |
| } |
| } |
| |
| buf = os_kzalloc(UPLOAD_PATCH_UNIT, MTK_GFP_ATOMIC); |
| if (!buf) |
| { |
| ret = -ENOMEM; |
| goto error; |
| } |
| |
| pos = buf; |
| |
| LD_load_code_from_bin(&data->rom_patch, (char *)data->rom_patch_bin_file_name, NULL, |
| data->udev, &data->rom_patch_len); |
| |
| if (!data->rom_patch) |
| { |
| usb_debug("please assign a rom patch(/system/etc/firmware/%s)or(/lib/firmware/%s)\n", |
| data->rom_patch_bin_file_name, |
| data->rom_patch_bin_file_name); |
| ret = -1; |
| goto error; |
| } |
| |
| tmp_str = data->rom_patch; |
| SHOW_FW_DETAILS("FW Version"); |
| SHOW_FW_DETAILS("build Time"); |
| |
| tmp_str = data->rom_patch + 16; |
| usb_debug("platform = %c%c%c%c\n", tmp_str[0], tmp_str[1], tmp_str[2], tmp_str[3]); |
| |
| tmp_str = data->rom_patch + 20; |
| usb_debug("HW/SW version = %c%c%c%c\n", tmp_str[0], tmp_str[1], tmp_str[2], tmp_str[3]); |
| |
| tmp_str = data->rom_patch + 24; |
| usb_debug("Patch version = %c%c%c%c\n", tmp_str[0], tmp_str[1], tmp_str[2], tmp_str[3]); |
| |
| usb_debug("\nloading rom patch...\n"); |
| |
| cur_len = 0x00; |
| patch_len = data->rom_patch_len - PATCH_INFO_SIZE; |
| |
| /* loading rom patch */ |
| while (1) |
| { |
| s32 sent_len_max = UPLOAD_PATCH_UNIT - PATCH_HEADER_SIZE; |
| real_len = 0; |
| sent_len = |
| (patch_len - cur_len) >= sent_len_max ? sent_len_max : (patch_len - cur_len); |
| |
| //usb_debug("patch_len = %d\n", patch_len); |
| //usb_debug("cur_len = %d\n", cur_len); |
| //usb_debug("sent_len = %d\n", sent_len); |
| |
| if (sent_len > 0) |
| { |
| if (first_block == 1) |
| { |
| if (sent_len < sent_len_max) |
| phase = PATCH_PHASE3; |
| else |
| phase = PATCH_PHASE1; |
| first_block = 0; |
| } |
| else if (sent_len == sent_len_max) |
| { |
| if (patch_len - cur_len == sent_len_max) |
| phase = PATCH_PHASE3; |
| else |
| phase = PATCH_PHASE2; |
| } |
| else |
| { |
| phase = PATCH_PHASE3; |
| } |
| |
| /* prepare HCI header */ |
| pos[0] = 0x6F; |
| pos[1] = 0xFC; |
| pos[2] = (sent_len + 5) & 0xFF; |
| pos[3] = ((sent_len + 5) >> 8) & 0xFF; |
| |
| /* prepare WMT header */ |
| pos[4] = 0x01; |
| pos[5] = 0x01; |
| pos[6] = (sent_len + 1) & 0xFF; |
| pos[7] = ((sent_len + 1) >> 8) & 0xFF; |
| |
| pos[8] = phase; |
| |
| os_memcpy(&pos[9], data->rom_patch + PATCH_INFO_SIZE + cur_len, sent_len); |
| |
| //usb_debug("sent_len + PATCH_HEADER_SIZE = %d, phase = %d\n", |
| //sent_len + PATCH_HEADER_SIZE, phase); |
| |
| ret = data->hcif->usb_bulk_msg(data->udev, MTKBT_BULK_TX_EP, buf, sent_len + PATCH_HEADER_SIZE, &real_len, 0); |
| |
| if (ret) |
| { |
| usb_debug("upload rom_patch err: %d\n", ret); |
| goto error; |
| } |
| |
| MTK_MDELAY(1); |
| |
| cur_len += sent_len; |
| |
| } |
| else |
| { |
| usb_debug("loading rom patch... Done\n"); |
| break; |
| } |
| } |
| |
| MTK_MDELAY(20); |
| ret = btmtk_usb_get_rom_patch_result(data); |
| MTK_MDELAY(20); |
| |
| /* Send Checksum request */ |
| #if CRC_CHECK |
| int total_checksum = checksume16(data->rom_patch + PATCH_INFO_SIZE, patch_len); |
| btmtk_usb_chk_crc(data, patch_len); |
| MTK_MDELAY(20); |
| if (total_checksum != btmtk_usb_get_crc(data)) |
| { |
| usb_debug("checksum fail!, local(0x%x) <> fw(0x%x)\n", total_checksum, |
| btmtk_usb_get_crc(data)); |
| ret = -1; |
| goto error; |
| } |
| else |
| { |
| usb_debug("crc match!\n"); |
| } |
| #endif |
| MTK_MDELAY(20); |
| /* send check rom patch result request */ |
| btmtk_usb_send_check_rom_patch_result_cmd(data); |
| MTK_MDELAY(20); |
| /* CHIP_RESET */ |
| ret = btmtk_usb_send_wmt_reset_cmd(data); |
| MTK_MDELAY(20); |
| /* BT_RESET */ |
| btmtk_usb_send_hci_reset_cmd(data); |
| /* for WoBLE/WoW low power */ |
| btmtk_usb_send_hci_set_ce_cmd(data); |
| |
| error: |
| btmtk_usb_io_write32(data, SEMAPHORE_03, 0x1); |
| //usb_debug("end\n"); |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_send_wmt_power_on_cmd_7668(struct LD_btmtk_usb_data *data) |
| { |
| u8 count = 0; /* retry 3 times */ |
| u8 cmd[] = { 0x6F, 0xFC, 0x06, 0x01, 0x06, 0x02, 0x00, 0x00, 0x01 }; |
| u8 event[] = { 0xE4, 0x05, 0x02, 0x06, 0x01, 0x00 }; /* event[6] is key */ |
| int ret = -1; /* if successful, 0 */ |
| |
| do { |
| ret = btmtk_usb_send_wmt_cmd(data, cmd, sizeof(cmd), event, sizeof(event), 100, 10); |
| if (ret < 0) { |
| usb_debug("failed(%d)\n", ret); |
| } else if (ret == sizeof(event) + 1) { |
| switch (data->io_buf[6]) { |
| case 0: /* successful */ |
| usb_debug("OK\n"); |
| ret = 0; |
| break; |
| case 2: /* retry */ |
| usb_debug("Try again\n"); |
| continue; |
| default: |
| usb_debug("Unknown result: %02X\n", data->io_buf[6]); |
| return -1; |
| } |
| } else { |
| usb_debug("failed, incorrect response length(%d)\n", ret); |
| return -1; |
| } |
| } while (++count < 3 && ret > 0); |
| |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_send_hci_tci_set_sleep_cmd_7668(struct LD_btmtk_usb_data *data) |
| { |
| u8 cmd[] = { 0x7A, 0xFC, 0x07, 0x05, 0x40, 0x06, 0x40, 0x06, 0x00, 0x00 }; |
| u8 event[] = { 0x0E, 0x04, 0x01, 0x7A, 0xFC, 0x00 }; |
| int ret = -1; /* if successful, 0 */ |
| |
| ret = btmtk_usb_send_hci_cmd(data, cmd, sizeof(cmd), event, sizeof(event)); |
| if (ret < 0) { |
| usb_debug("failed(%d)\n", ret); |
| } else { |
| usb_debug("OK\n"); |
| ret = 0; |
| } |
| |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_get_vendor_cap(struct LD_btmtk_usb_data *data) |
| { |
| u8 cmd[] = { 0x53, 0xFD, 0x00 }; |
| u8 event[6] = { 0x0E, 0x12, 0x01, 0x53, 0xFD, 0x00, /* ... */ }; |
| int ret = -1; |
| |
| // TODO: should not compare whole event |
| ret = btmtk_usb_send_hci_cmd(data, cmd, sizeof(cmd), event, sizeof(event)); |
| if (ret < 0) { |
| usb_debug("Failed(%d)\n", ret); |
| } else { |
| usb_debug("OK\n"); |
| ret = 0; |
| } |
| |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_send_read_bdaddr(struct LD_btmtk_usb_data *data) |
| { |
| u8 cmd[] = { 0x09, 0x10, 0x00 }; |
| u8 event[] = { 0x0E, 0x0A, 0x01, 0x09, 0x10, 0x00, /* 6 bytes are BDADDR */ }; |
| int ret = -1; |
| |
| ret = btmtk_usb_send_hci_cmd(data, cmd, sizeof(cmd), event, sizeof(event)); |
| if (ret < 0 || ret != 12 /* Event actual length */) { |
| usb_debug("Failed(%d)\n", ret); |
| return ret; |
| } |
| |
| os_memcpy(data->local_addr, data->io_buf + 6, BD_ADDR_LEN); |
| usb_debug("ADDR: %02X-%02X-%02X-%02X-%02X-%02X\n", |
| data->local_addr[5], data->local_addr[4], data->local_addr[3], |
| data->local_addr[2], data->local_addr[1], data->local_addr[0]); |
| ret = 0; |
| |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_set_apcf(struct LD_btmtk_usb_data *data, BOOL bin_file) |
| { |
| int i = 0, ret = -1; |
| // Legacy RC pattern |
| u8 manufacture_data[] = { 0x57, 0xFD, 0x27, 0x06, 0x00, FIDX, |
| 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x43, 0x52, 0x4B, 0x54, 0x4D, /* manufacturer data */ |
| 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, |
| 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; /* mask */ |
| u8 filter_cmd[] = { 0x57, 0xFD, 0x0A, 0x01, 0x00, FIDX, 0x20, 0x00, |
| 0x00, 0x00, 0x01, 0x80, 0x00 }; |
| u8 event[] = { 0x0E, 0x07, 0x01, 0x57, 0xFD, 0x00, /* ... */ }; |
| |
| if (bin_file) { |
| if (data->wake_dev_len) { |
| /* wake_on_ble.conf using 90(0x5A-FIDX) as filter_index */ |
| u8 pos = 0; |
| u8 broadcast_addr[] = { 0x57, 0xFD, 0x0A, 0x02, 0x00, FIDX, |
| 0x55, 0x44, 0x33, 0x22, 0x11, 0x00, // ADDRESS |
| 0x00 }; // 0: Public, 1: Random |
| u8 adv_pattern[] = { 0x57, 0xFD, 0x15, 0x06, 0x00, FIDX, |
| 0x71, 0x01, // VID |
| 0x04, 0x11, // PID |
| 0x00, 0x00, 0x00, 0x00, // IR key code |
| 0x00, // sequence number |
| 0xFF, 0xFF, // mask~ |
| 0xFF, 0xFF, |
| 0x00, 0x00, 0x00, 0x00, |
| 0x00 }; |
| |
| // BDADDR |
| for (i = 0; i < data->wake_dev[1]; i++) { |
| broadcast_addr[11] = data->wake_dev[2 + i * BD_ADDR_LEN + 0]; |
| broadcast_addr[10] = data->wake_dev[2 + i * BD_ADDR_LEN + 1]; |
| broadcast_addr[9] = data->wake_dev[2 + i * BD_ADDR_LEN + 2]; |
| broadcast_addr[8] = data->wake_dev[2 + i * BD_ADDR_LEN + 3]; |
| broadcast_addr[7] = data->wake_dev[2 + i * BD_ADDR_LEN + 4]; |
| broadcast_addr[6] = data->wake_dev[2 + i * BD_ADDR_LEN + 5]; |
| ret = btmtk_usb_send_hci_cmd(data, broadcast_addr, sizeof(broadcast_addr), |
| event, sizeof(event)); |
| if (ret < 0) { |
| usb_debug("Set broadcast address fail\n"); |
| continue; |
| } |
| // mask broadcast address as a filter condition |
| filter_cmd[6] = 0x21; |
| } |
| usb_debug("There are %d broadcast address filter(s) from %s\n", i, WAKE_DEV_RECORD); |
| |
| /** VID/PID in conf is LITTLE endian, but PID in ADV is BIG endian */ |
| pos = 2 + data->wake_dev[1] * 6; |
| for (i = 0; i < data->wake_dev[pos]; i++) { |
| adv_pattern[6] = data->wake_dev[pos + (i * 4) + 1]; |
| adv_pattern[7] = data->wake_dev[pos + (i * 4) + 2]; |
| adv_pattern[9] = data->wake_dev[pos + (i * 4) + 3]; |
| adv_pattern[8] = data->wake_dev[pos + (i * 4) + 4]; |
| ret = btmtk_usb_send_hci_cmd(data, adv_pattern, sizeof(adv_pattern), |
| event, sizeof(event)); |
| if (ret < 0) { |
| usb_debug("Set advertising patten fail\n"); |
| return ret; |
| } |
| } |
| usb_debug("There are %d manufacture data filter(s) from %s\n", i, WAKE_DEV_RECORD); |
| |
| // Filtering parameters |
| ret = btmtk_usb_send_hci_cmd(data, filter_cmd, sizeof(filter_cmd), |
| event, sizeof(event)); |
| if (ret < 0) { |
| usb_debug("Set filtering parm fail\n"); |
| return ret; |
| } |
| |
| // if wake_on_ble.conf exist, no need use default woble_setting.bin |
| } else { |
| // woble_setting.bin |
| usb_debug("Set APCF filter from woble_setting.bin\n"); |
| for (i = 0; i < APCF_SETTING_COUNT; i++) { |
| if (!data->apcf_cmd[i].len) |
| continue; |
| ret = btmtk_usb_send_hci_cmd(data, data->apcf_cmd[i].value, data->apcf_cmd[i].len, |
| event, sizeof(event)); |
| if (ret < 0) { |
| usb_debug("Set apcf_cmd[%d] data fail\n", i); |
| return ret; |
| } |
| } |
| } |
| |
| } else { |
| // Use default |
| usb_debug("Using default APCF filter\n"); |
| os_memcpy(manufacture_data + 9, data->local_addr, BD_ADDR_LEN); |
| ret = btmtk_usb_send_hci_cmd(data, manufacture_data, |
| sizeof(manufacture_data), event, sizeof(event)); |
| if (ret < 0) { |
| usb_debug("Set manufacture data fail\n"); |
| return ret; |
| } |
| |
| ret = btmtk_usb_send_hci_cmd(data, filter_cmd, sizeof(filter_cmd), |
| event, sizeof(event)); |
| if (ret < 0) { |
| usb_debug("Set manufacture data fail\n"); |
| return ret; |
| } |
| } |
| return 0; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static BOOL btmtk_usb_check_need_load_patch_7668(struct LD_btmtk_usb_data *data) |
| { |
| /* TRUE: need load patch., FALSE: do not need */ |
| u8 cmd[] = { 0x6F, 0xFC, 0x05, 0x01, 0x17, 0x01, 0x00, 0x01 }; |
| u8 event[] = { 0xE4, 0x05, 0x02, 0x17, 0x01, 0x00, /* 0x02 */ }; /* event[6] is key */ |
| int ret = -1; |
| |
| ret = btmtk_usb_send_wmt_cmd(data, cmd, sizeof(cmd), event, sizeof(event), 20, 0); |
| /* can't get correct event, need load patch */ |
| if (ret < 0) { |
| usb_debug("check need load patch or not fail(%d)", ret); |
| return TRUE; |
| } |
| |
| if (ret == sizeof(event) + 1 && (data->io_buf[6] == 0x00 || data->io_buf[6] == 0x01)) |
| return FALSE; /* Do not need */ |
| |
| return TRUE; |
| } |
| |
| //--------------------------------------------------------------------------- |
| static int btmtk_usb_load_rom_patch_7668(struct LD_btmtk_usb_data *data) |
| { |
| int ret = 0; |
| int first_block = 1; |
| int real_len = 0; |
| void *buf = NULL; |
| char *tmp_str = NULL; |
| u8 *pos = NULL; |
| u8 phase = 0; |
| u32 cur_len = 0; |
| u32 patch_len = 0; |
| s32 sent_len = 0; |
| |
| //usb_debug("begin\n"); |
| if (btmtk_usb_check_need_load_patch_7668(data) == FALSE) { |
| usb_debug("No need to load rom patch\n"); |
| return btmtk_usb_send_wmt_reset_cmd(data); |
| } |
| |
| buf = os_kzalloc(UPLOAD_PATCH_UNIT, MTK_GFP_ATOMIC); |
| if (!buf) { |
| return -ENOMEM; |
| } |
| |
| pos = buf; |
| LD_load_code_from_bin(&data->rom_patch, (char *)data->rom_patch_bin_file_name, NULL, |
| data->udev, &data->rom_patch_len); |
| if (!data->rom_patch || !data->rom_patch_len) { |
| usb_debug("please assign a rom patch(/system/etc/firmware/%s) or (/lib/firmware/%s)\n", |
| data->rom_patch_bin_file_name, data->rom_patch_bin_file_name); |
| return -1; |
| } |
| |
| tmp_str = (char *)data->rom_patch; |
| SHOW_FW_DETAILS("FW Version"); |
| SHOW_FW_DETAILS("build Time"); |
| |
| tmp_str = (char *)data->rom_patch + 16; |
| usb_debug("platform = %c%c%c%c\n", tmp_str[0], tmp_str[1], tmp_str[2], tmp_str[3]); |
| |
| tmp_str = (char *)data->rom_patch + 20; |
| usb_debug("HW/SW version = %c%c%c%c\n", tmp_str[0], tmp_str[1], tmp_str[2], tmp_str[3]); |
| |
| tmp_str = (char *)data->rom_patch + 24; |
| patch_len = data->rom_patch_len - PATCH_INFO_SIZE; |
| //usb_debug("patch_len = %d\n", patch_len); |
| usb_debug("loading rom patch...\n"); |
| |
| /* loading rom patch */ |
| while (1) { |
| s32 sent_len_max = UPLOAD_PATCH_UNIT - PATCH_HEADER_SIZE; |
| |
| real_len = 0; |
| sent_len = (patch_len - cur_len) >= sent_len_max ? sent_len_max : (patch_len - cur_len); |
| if (sent_len > 0) { |
| if (first_block == 1) { |
| if (sent_len < sent_len_max) |
| phase = PATCH_PHASE3; |
| else |
| phase = PATCH_PHASE1; |
| first_block = 0; |
| } else if (sent_len == sent_len_max) { |
| if (patch_len - cur_len == sent_len_max) |
| phase = PATCH_PHASE3; |
| else |
| phase = PATCH_PHASE2; |
| } else { |
| phase = PATCH_PHASE3; |
| } |
| |
| /* prepare HCI header */ |
| pos[0] = 0x6F; |
| pos[1] = 0xFC; |
| pos[2] = (sent_len + 5) & 0xFF; |
| pos[3] = ((sent_len + 5) >> 8) & 0xFF; |
| |
| /* prepare WMT header */ |
| pos[4] = 0x01; |
| pos[5] = 0x01; |
| pos[6] = (sent_len + 1) & 0xFF; |
| pos[7] = ((sent_len + 1) >> 8) & 0xFF; |
| |
| pos[8] = phase; |
| |
| os_memcpy(&pos[9], data->rom_patch + PATCH_INFO_SIZE + cur_len, sent_len); |
| //usb_debug("sent_len = %d, cur_len = %d, phase = %d\n", sent_len, cur_len, phase); |
| |
| ret = data->hcif->usb_bulk_msg(data->udev, MTKBT_BULK_TX_EP, buf, |
| sent_len + PATCH_HEADER_SIZE, &real_len, 0); |
| if (ret) { |
| usb_debug("upload rom_patch err: %d\n", ret); |
| return -1; |
| } |
| cur_len += sent_len; |
| MTK_MDELAY(1); |
| btmtk_usb_get_rom_patch_result(data); |
| MTK_MDELAY(1); |
| |
| } else { |
| usb_debug("loading rom patch... Done\n"); |
| break; |
| } |
| os_memset(buf, 0, UPLOAD_PATCH_UNIT); |
| } |
| MTK_MDELAY(20); |
| /* CHIP_RESET */ |
| ret = btmtk_usb_send_wmt_reset_cmd(data); |
| MTK_MDELAY(20); |
| |
| //usb_debug("end\n"); |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| void btmtk_usb_woble_setting_parsing(struct LD_btmtk_usb_data *data, woble_setting_type type) |
| { |
| #define ONE_BYTE_HEX_MAX_LEN 8 |
| int i = 0; |
| char *cmd = NULL; |
| char *head = NULL; |
| char *next_cmd = NULL; |
| char prefix[32] = {0}; |
| u8 tmp_len = 0; |
| u8 tmp[128] = {0}; |
| long int set_addr = 0; |
| long int addr_pos = 0; |
| |
| switch (type) { |
| case TYPE_APCF_CMD: |
| cmd = "APCF"; |
| break; |
| default: |
| usb_debug("Incorrect Type\n"); |
| return; |
| } |
| |
| for (i = 0; i < APCF_SETTING_COUNT; ++i) { |
| snprintf(prefix, sizeof(prefix), "%s%02d:", cmd, i); |
| head = strstr((char *)data->woble_setting, prefix); |
| |
| if (head) { |
| head += strlen(prefix); /* move to first numeral */ |
| next_cmd = strstr(head, ":"); // next command start position |
| |
| tmp_len = 0; |
| memset(tmp, 0, sizeof(tmp)); |
| do { |
| tmp[tmp_len++] = strtol(head, &head, 0); |
| |
| // for next one |
| head = strstr(head, "0x"); |
| if (next_cmd && head > next_cmd) |
| break; // command end |
| } while (tmp_len < sizeof(tmp)); |
| |
| if (tmp_len) { |
| int j = 0; // FOR DEBUG |
| |
| /* Save command */ |
| data->apcf_cmd[i].value = os_kzalloc(tmp_len, MTK_GFP_ATOMIC); |
| os_memcpy(data->apcf_cmd[i].value, tmp, tmp_len); |
| data->apcf_cmd[i].len = tmp_len; |
| |
| if (type == TYPE_APCF_CMD) { |
| /* Check need BD address or not */ |
| snprintf(prefix, sizeof(prefix), "%s_ADD_MAC%02d:", cmd, i); |
| head = strstr((char *)data->woble_setting, prefix); |
| head += strlen(prefix); |
| set_addr = strtol(head, &head, 0); |
| |
| if (set_addr == 1) { |
| snprintf(prefix, sizeof(prefix), "%s_ADD_MAC_LOCATION%02d:", cmd, i); |
| head = strstr((char *)data->woble_setting, prefix); |
| head += strlen(prefix); |
| addr_pos = strtol(head, &head, 0); |
| |
| if (addr_pos) |
| os_memcpy(data->apcf_cmd[i].value + addr_pos, |
| data->local_addr, BD_ADDR_LEN); |
| } |
| } |
| // FOR DEBUG |
| usb_debug("Load for APCF settings only\n"); |
| usb_debug("%02X:", i); |
| for (j = 0; j < data->apcf_cmd[i].len; j++) |
| printf(" %02X", data->apcf_cmd[i].value[j]); |
| printf("\n"); |
| } |
| } |
| } |
| } |
| |
| //--------------------------------------------------------------------------- |
| int btmtk_usb_load_woble_setting(struct LD_btmtk_usb_data *data) |
| { |
| int i = 0; |
| BOOL woble_setting_bin = FALSE; |
| BOOL wake_on_ble_conf = FALSE; |
| |
| if (!data) |
| return -EINVAL; |
| |
| /* For woble_setting.bin */ |
| data->woble_setting = NULL; |
| data->woble_setting_len = 0; |
| |
| LD_load_code_from_bin(&data->woble_setting, WOBLE_SETTING_FILE_NAME, NULL, |
| data->udev, &data->woble_setting_len); |
| if (data->woble_setting == NULL || data->woble_setting_len == 0) { |
| usb_debug("Please make sure %s in the /system/etc(lib)/firmware\n", |
| WOBLE_SETTING_FILE_NAME); |
| woble_setting_bin = FALSE; |
| } else { |
| btmtk_usb_woble_setting_parsing(data, TYPE_APCF_CMD); |
| for (i = 0; i < APCF_SETTING_COUNT; i++) |
| if (data->apcf_cmd[i].len) |
| break; |
| if (i == APCF_SETTING_COUNT) { |
| woble_setting_bin = FALSE; |
| if (data->woble_setting) { |
| data->woble_setting_len = 0; |
| os_kfree(data->woble_setting); |
| data->woble_setting = NULL; |
| } |
| } else { |
| woble_setting_bin = TRUE; |
| } |
| } |
| |
| /* For wake_on_ble.conf */ |
| data->wake_dev = NULL; |
| data->wake_dev_len = 0; |
| |
| LD_load_code_from_bin(&data->wake_dev, WAKE_DEV_RECORD, WAKE_DEV_RECORD_PATH, |
| data->udev, &data->wake_dev_len); |
| if (data->wake_dev == NULL || data->wake_dev_len == 0) { |
| usb_debug("There is no DEVICE RECORD for wake-up\n"); |
| wake_on_ble_conf = FALSE; |
| } else { |
| // content check |
| if (data->wake_dev[0] != data->wake_dev_len || data->wake_dev_len < 3) { |
| usb_debug("Incorrect total length on %s\n", WAKE_DEV_RECORD); |
| data->wake_dev_len = 0; |
| os_kfree(data->wake_dev); |
| data->wake_dev = NULL; |
| wake_on_ble_conf = FALSE; |
| } else { |
| wake_on_ble_conf = TRUE; |
| } |
| } |
| |
| if (woble_setting_bin == FALSE && wake_on_ble_conf == FALSE) |
| return -ENOENT; |
| return 0; |
| } |
| |
| //--------------------------------------------------------------------------- |
| int btmtk_usb_set_unify_woble(struct LD_btmtk_usb_data *data) |
| { |
| int ret = -1; |
| // Filter Index: 0x5B |
| /*u8 cmd[] = { 0xC9, 0xFC, 0x1F, 0x01, 0x20, 0x02, 0x00, 0x01, 0x02, 0x01, |
| 0x01, 0x05, 0x10, 0x09, 0x00, 0xC0, 0x00, 0x02, 0x40, FIDX, 0x04, |
| 0x11, 0x12, 0x00, 0x00, 0x02, 0x42, 0x15, 0x02, 0x25, 0x00, 0x02, |
| 0x41, 0x19 };*/ |
| |
| u8 cmd[] = { 0xC9, 0xFC, 0x14, 0x01, 0x20, 0x02, 0x00, 0x01, |
| 0x02, 0x01, 0x00, 0x05, 0x10, 0x01, 0x00, 0x40, 0x06, |
| 0x02, 0x40, 0x5A, 0x02, 0x41, 0x0F }; |
| u8 event[] = { 0xE6, 0x02, 0x08, 0x00 }; |
| |
| usb_debug("%s: APCF filtering index: %d\n", __func__, FIDX); |
| ret = btmtk_usb_send_hci_cmd(data, cmd, sizeof(cmd), event, sizeof(event)); |
| if (ret < 0) |
| usb_debug("Failed(%d)\n", ret); |
| return ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| void LD_btmtk_usb_SetWoble(mtkbt_dev_t *dev) |
| { |
| struct LD_btmtk_usb_data *data = BT_INST(dev)->priv_data; |
| int ret = -1; |
| |
| usb_debug("\n"); |
| if (!data) { |
| usb_debug("btmtk data NULL!\n"); |
| return; |
| } |
| |
| if (is_mt7668(data)) { |
| /* Power on sequence */ |
| btmtk_usb_send_wmt_power_on_cmd_7668(data); |
| btmtk_usb_send_hci_tci_set_sleep_cmd_7668(data); |
| btmtk_usb_send_hci_reset_cmd(data); |
| |
| /* Unify WoBLE flow */ |
| btmtk_usb_get_vendor_cap(data); |
| btmtk_usb_send_read_bdaddr(data); |
| ret = btmtk_usb_load_woble_setting(data); |
| if (ret) { |
| usb_debug("Using lagecy WoBLE setting(%d)!!!\n", ret); |
| btmtk_usb_set_apcf(data, FALSE); |
| } else |
| btmtk_usb_set_apcf(data, TRUE); |
| btmtk_usb_set_unify_woble(data); |
| } else { |
| btmtk_usb_send_hci_suspend_cmd(data); |
| } |
| |
| // Clean & free buffer |
| if (data->woble_setting) { |
| int i = 0; |
| os_kfree(data->woble_setting); |
| data->woble_setting = NULL; |
| data->woble_setting_len = 0; |
| for (i = 0; i < APCF_SETTING_COUNT; i++) { |
| os_kfree(data->apcf_cmd[i].value); |
| data->apcf_cmd[i].len = 0; |
| } |
| } |
| if (data->wake_dev) { |
| os_kfree(data->wake_dev); |
| data->wake_dev = NULL; |
| data->wake_dev_len = 0; |
| } |
| |
| return; |
| } |
| |
| //--------------------------------------------------------------------------- |
| int LD_btmtk_usb_probe(mtkbt_dev_t *dev) |
| { |
| struct LD_btmtk_usb_data *data; |
| int err = 0; |
| |
| usb_debug("=========================================\n"); |
| usb_debug("Mediatek Bluetooth USB driver ver %s\n", LD_VERSION); |
| usb_debug("=========================================\n"); |
| os_memcpy(driver_version, LD_VERSION, sizeof(LD_VERSION)); |
| probe_counter++; |
| isbtready = 0; |
| is_assert = 0; |
| //usb_debug("LD_btmtk_usb_probe begin\n"); |
| usb_debug("probe_counter = %d\n", probe_counter); |
| |
| data = (struct LD_btmtk_usb_data *)os_kzalloc(sizeof(*data), MTK_GFP_ATOMIC); |
| if (!data) { |
| usb_debug("[ERR] end Error 1\n"); |
| return -ENOMEM; |
| } |
| |
| data->hcif = BT_INST(dev)->hci_if; |
| |
| data->cmdreq_type = USB_TYPE_CLASS; |
| |
| data->udev = dev; |
| |
| data->meta_tx = 0; |
| |
| data->io_buf = os_kmalloc(LD_BT_MAX_EVENT_SIZE, MTK_GFP_ATOMIC); |
| |
| btmtk_usb_switch_iobase(data, WLAN); |
| |
| /* clayton: according to the chip id, load f/w or rom patch */ |
| btmtk_usb_cap_init(data); |
| |
| if (data->need_load_rom_patch) { |
| if (is_mt7668(data)) |
| err = btmtk_usb_load_rom_patch_7668(data); |
| else |
| err = btmtk_usb_load_rom_patch(data); |
| //btmtk_usb_send_hci_suspend_cmd(data); |
| if (err < 0) { |
| if (data->io_buf) os_kfree(data->io_buf); |
| if (data->rom_patch_bin_file_name) os_kfree(data->rom_patch_bin_file_name); |
| os_kfree(data); |
| usb_debug("[ERR] end Error 2\n"); |
| return err; |
| } |
| } |
| |
| // Clean & free buffer |
| if (data->rom_patch_bin_file_name) |
| os_kfree(data->rom_patch_bin_file_name); |
| |
| |
| isUsbDisconnet = 0; |
| BT_INST(dev)->priv_data = data; |
| isbtready = 1; |
| |
| //usb_debug("btmtk_usb_probe end\n"); |
| return 0; |
| } |
| |
| //--------------------------------------------------------------------------- |
| void LD_btmtk_usb_disconnect(mtkbt_dev_t *dev) |
| { |
| struct LD_btmtk_usb_data *data = BT_INST(dev)->priv_data; |
| |
| usb_debug("\n"); |
| |
| if (!data) |
| return; |
| |
| isbtready = 0; |
| metaCount = 0; |
| |
| if (data->need_load_rom_patch) |
| os_kfree(data->rom_patch); |
| |
| if (data->need_load_fw) |
| os_kfree(data->fw_image); |
| |
| usb_debug("unregister bt irq\n"); |
| |
| isUsbDisconnet = 1; |
| usb_debug("btmtk: stop all URB\n"); |
| os_kfree(data->io_buf); |
| os_kfree(data); |
| } |
| |
| //--------------------------------------------------------------------------- |
