diff --git a/arch/arm64/configs/lubancat2_android11_defconfig b/arch/arm64/configs/lubancat2_android11_defconfig index 02984d45b8eb..9ebe881be12a 100644 --- a/arch/arm64/configs/lubancat2_android11_defconfig +++ b/arch/arm64/configs/lubancat2_android11_defconfig @@ -268,6 +268,7 @@ CONFIG_BLK_DEV_LOOP_MIN_COUNT=16 CONFIG_BLK_DEV_RAM=y CONFIG_BLK_DEV_RAM_SIZE=8192 CONFIG_BLK_DEV_NVME=y +CONFIG_BT_HCIBTUSB=y CONFIG_BT_HCIBFUSB=y CONFIG_BT_HCIVHCI=y CONFIG_BT_MRVL=y diff --git a/drivers/bluetooth/Kconfig b/drivers/bluetooth/Kconfig index 845b0314ce3a..389229887603 100644 --- a/drivers/bluetooth/Kconfig +++ b/drivers/bluetooth/Kconfig @@ -209,6 +209,13 @@ config BT_HCIUART_RTL Say Y here to compile support for Realtek protocol. +config BT_RTKBTUSB + tristate "RTK HCI USB driver" + depends on USB + default y + help + RTK Bluetooth HCI USB driver + config BT_HCIUART_QCA bool "Qualcomm Atheros protocol support" depends on BT_HCIUART diff --git a/drivers/bluetooth/Makefile b/drivers/bluetooth/Makefile index b7e393cfc1e3..071eac6c875a 100644 --- a/drivers/bluetooth/Makefile +++ b/drivers/bluetooth/Makefile @@ -3,6 +3,13 @@ # Makefile for the Linux Bluetooth HCI device drivers. # +EXTRA_CFLAGS += -Wno-unused-value +EXTRA_CFLAGS += -Wno-unused-label +EXTRA_CFLAGS += -Wno-unused-parameter +EXTRA_CFLAGS += -Wno-unused-function +EXTRA_CFLAGS += -Wno-unused +EXTRA_CFLAGS += -Wno-uninitialized + obj-$(CONFIG_BT_HCIVHCI) += hci_vhci.o obj-$(CONFIG_BT_HCIUART) += hci_uart.o obj-$(CONFIG_BT_HCIBCM203X) += bcm203x.o @@ -25,6 +32,7 @@ obj-$(CONFIG_BT_QCOMSMD) += btqcomsmd.o obj-$(CONFIG_BT_BCM) += btbcm.o obj-$(CONFIG_BT_RTL) += btrtl.o obj-$(CONFIG_BT_QCA) += btqca.o +obj-$(CONFIG_BT_RTKBTUSB) += rtk_btusb.o obj-$(CONFIG_BT_HCIUART_NOKIA) += hci_nokia.o diff --git a/drivers/bluetooth/rtk_btusb.c b/drivers/bluetooth/rtk_btusb.c index 5db188416009..6a41ed3b0aa6 100644 --- a/drivers/bluetooth/rtk_btusb.c +++ b/drivers/bluetooth/rtk_btusb.c @@ -37,24 +37,29 @@ #include #include +#ifdef CONFIG_COMPAT +#include +#endif #include "rtk_btusb.h" -#define RTKBT_RELEASE_NAME "20180702_BT_ANDROID_8.1" -#define VERSION "4.1.5" +#define RTKBT_RELEASE_NAME "20230221_BT_ANDROID_11.0" +#define VERSION "5.2.1" #define SUSPNED_DW_FW 0 #define SET_WAKEUP_DEVICE 0 +#define TV_FW_CONFIG 1 static spinlock_t queue_lock; -static spinlock_t dlfw_lock; -static volatile uint16_t dlfw_dis_state = 0; +static spinlock_t running_flag_lock; +static volatile uint16_t driver_state = 0; #if SUSPNED_DW_FW static firmware_info *fw_info_4_suspend = NULL; #endif static uint32_t usb_info; +static uint16_t iso_min_conn_handle = 0x1b; static patch_info fw_patch_table[] = { /* { vid, pid, lmp_sub_default, lmp_sub, everion, mp_fw_name, fw_name, config_name, fw_cache, fw_len, mac_offset } */ @@ -94,6 +99,10 @@ static patch_info fw_patch_table[] = { { 0x0BDA, 0xB761, 0x8761, 0, 0, "mp_rtl8761a_fw", "rtl8761au_fw", "rtl8761a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8761AUV only */ { 0x0BDA, 0x8761, 0x8761, 0, 0, "mp_rtl8761a_fw", "rtl8761au8192ee_fw", "rtl8761a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8761AU + 8192EE for LI */ { 0x0BDA, 0x8A60, 0x8761, 0, 0, "mp_rtl8761a_fw", "rtl8761au8812ae_fw", "rtl8761a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8761AU + 8812AE */ +{ 0x0BDA, 0x8771, 0x8761, 0, 0, "mp_rtl8761b_fw", "rtl8761b_fw", "rtl8761b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_40K}, /* RTL8761BU */ +{ 0x0BDA, 0xB771, 0x8761, 0, 0, "mp_rtl8761b_fw", "rtl8761b_fw", "rtl8761b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_40K}, /* RTL8761BU */ +{ 0x0BDA, 0xa725, 0x8761, 0, 0, "mp_rtl8725a_fw", "rtl8725a_fw", "rtl8725a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_40K}, /* RTL8725AU */ +{ 0x0BDA, 0xa72A, 0x8761, 0, 0, "mp_rtl8725a_fw", "rtl8725a_fw", "rtl8725a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_40K}, /* RTL8725AU BT only */ { 0x0BDA, 0x8821, 0x8821, 0, 0, "mp_rtl8821a_fw", "rtl8821a_fw", "rtl8821a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8821AE */ { 0x0BDA, 0x0821, 0x8821, 0, 0, "mp_rtl8821a_fw", "rtl8821a_fw", "rtl8821a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8821AE */ @@ -103,21 +112,91 @@ static patch_info fw_patch_table[] = { { 0x13D3, 0x3461, 0x8821, 0, 0, "mp_rtl8821a_fw", "rtl8821a_fw", "rtl8821a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8821AE */ { 0x13D3, 0x3462, 0x8821, 0, 0, "mp_rtl8821a_fw", "rtl8821a_fw", "rtl8821a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8821AE */ -{ 0x0BDA, 0xB822, 0x8822, 0, 0, "mp_rtl8822b_fw", "rtl8822b_fw", "rtl8822b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_24K}, /* RTL8822BE */ -{ 0x0BDA, 0xB82C, 0x8822, 0, 0, "mp_rtl8822b_fw", "rtl8822b_fw", "rtl8822b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_24K}, /* RTL8822BU */ -{ 0x0BDA, 0xB023, 0x8822, 0, 0, "mp_rtl8822b_fw", "rtl8822b_fw", "rtl8822b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_24K}, /* RTL8822BE */ +{ 0x0BDA, 0xB822, 0x8822, 0, 0, "mp_rtl8822b_fw", "rtl8822b_fw", "rtl8822b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_25K}, /* RTL8822BE */ +{ 0x0BDA, 0xB82C, 0x8822, 0, 0, "mp_rtl8822b_fw", "rtl8822b_fw", "rtl8822b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_25K}, /* RTL8822BU */ +{ 0x0BDA, 0xB81D, 0x8822, 0, 0, "mp_rtl8822b_fw", "rtl8822b_fw", "rtl8822b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_25K}, /* RTL8822BU BT only */ +{ 0x0BDA, 0xB82E, 0x8822, 0, 0, "mp_rtl8822b_fw", "rtl8822b_fw", "rtl8822b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_25K}, /* RTL8822BU-VN */ +{ 0x0BDA, 0xB023, 0x8822, 0, 0, "mp_rtl8822b_fw", "rtl8822b_fw", "rtl8822b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_25K}, /* RTL8822BE */ { 0x0BDA, 0xB703, 0x8703, 0, 0, "mp_rtl8723c_fw", "rtl8723c_fw", "rtl8723c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_24K}, /* RTL8723CU */ +{ 0x0BDA, 0xC82C, 0x8822, 0, 0, "mp_rtl8822c_fw", "rtl8822c_fw", "rtl8822c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_40K}, /* RTL8822CU */ +{ 0x0BDA, 0xC82E, 0x8822, 0, 0, "mp_rtl8822c_fw", "rtl8822c_fw", "rtl8822c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_40K}, /* RTL8822CU-VN */ +{ 0x0BDA, 0xC81D, 0x8822, 0, 0, "mp_rtl8822c_fw", "rtl8822c_fw", "rtl8822c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_40K}, /* RTL8822CU BT only */ +{ 0x0BDA, 0xC82F, 0x8822, 0, 0, "mp_rtl8822c_fw", "rtl8822c_fw", "rtl8822c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_40K}, /* RTL8822CE-VS */ +{ 0x0BDA, 0xC822, 0x8822, 0, 0, "mp_rtl8822c_fw", "rtl8822c_fw", "rtl8822c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_40K}, /* RTL8822CE */ +{ 0x0BDA, 0xB00C, 0x8822, 0, 0, "mp_rtl8822c_fw", "rtl8822c_fw", "rtl8822c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_40K}, /* RTL8822CE */ +{ 0x0BDA, 0xA82A, 0x8822, 0, 0, "mp_rtl8822e_8822c_fw", "rtl8822e_8822c_fw", "rtl8822e_8822c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_145K}, /* RTL8822EU */ +{ 0x0BDA, 0xA82B, 0x8822, 0, 0, "mp_rtl8822e_8822c_fw", "rtl8822e_8822c_fw", "rtl8822e_8822c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_145K}, /* RTL8822EU */ +{ 0x0BDA, 0xA822, 0x8822, 0, 0, "mp_rtl8822e_8822c_fw", "rtl8822e_8822c_fw", "rtl8822e_8822c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_145K}, /* RTL8822EU */ +{ 0x0BDA, 0xE822, 0x8822, 0, 0, "mp_rtl8822e_8822c_fw", "rtl8822e_8822c_fw", "rtl8822e_8822c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_145K}, /* RTL8822EU */ /* todo: RTL8703BU */ { 0x0BDA, 0xD723, 0x8723, 0, 0, "mp_rtl8723d_fw", "rtl8723d_fw", "rtl8723d_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8723DU */ +{ 0x0BDA, 0xD72A, 0x8723, 0, 0, "mp_rtl8723d_fw", "rtl8723d_fw", "rtl8723d_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8723DU BT only */ { 0x0BDA, 0xD720, 0x8723, 0, 0, "mp_rtl8723d_fw", "rtl8723d_fw", "rtl8723d_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8723DE */ +{ 0x0BDA, 0xB733, 0x8723, 0, 0, "mp_rtl8733b_8723f_fw", "rtl8733b_8723f_fw", "rtl8733b_8723f_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_49_2K}, /* RTL8723FU */ +{ 0x0BDA, 0xB73A, 0x8723, 0, 0, "mp_rtl8733b_8723f_fw", "rtl8733b_8723f_fw", "rtl8733b_8723f_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_49_2K}, /* RTL8723FU */ +{ 0x0BDA, 0xF72B, 0x8723, 0, 0, "mp_rtl8733b_8723f_fw", "rtl8733b_8723f_fw", "rtl8733b_8723f_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_49_2K}, /* RTL8723FU */ { 0x0BDA, 0xB820, 0x8821, 0, 0, "mp_rtl8821c_fw", "rtl8821c_fw", "rtl8821c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8821CU */ { 0x0BDA, 0xC820, 0x8821, 0, 0, "mp_rtl8821c_fw", "rtl8821c_fw", "rtl8821c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8821CU */ +{ 0x0BDA, 0xC82A, 0x8821, 0, 0, "mp_rtl8821c_fw", "rtl8821c_fw", "rtl8821c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8821CU BT only */ { 0x0BDA, 0xC821, 0x8821, 0, 0, "mp_rtl8821c_fw", "rtl8821c_fw", "rtl8821c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8821CE */ -/* todo: RTL8703CU */ +{ 0x13D3, 0x3529, 0x8821, 0, 0, "mp_rtl8821c_fw", "rtl8821c_fw", "rtl8821c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8821CE */ +{ 0x13D3, 0x3532, 0x8821, 0, 0, "mp_rtl8821c_fw", "rtl8821c_fw", "rtl8821c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8821CE */ +{ 0x13D3, 0x3533, 0x8821, 0, 0, "mp_rtl8821c_fw", "rtl8821c_fw", "rtl8821c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8821CE */ +{ 0x13D3, 0x3552, 0x8821, 0, 0, "mp_rtl8821c_fw", "rtl8821c_fw", "rtl8821c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8821CE */ + +/* todo: RTL8851B */ +{ 0x0BDA, 0xB851, 0x8851, 0, 0, "mp_rtl8851b_fw", "rtl8851b_fw", "rtl8851b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_65_2K}, /*RTL8851B */ +//RTL8852A +{ 0x0BDA, 0x885A, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x0BDA, 0x8852, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AE */ +{ 0x0BDA, 0xA852, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x0BDA, 0x2852, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x0BDA, 0x385A, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x0BDA, 0x3852, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x0BDA, 0x1852, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x0BDA, 0x4852, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x04CA, 0x4006, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x13D3, 0x3561, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x13D3, 0x3562, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x0BDA, 0x588A, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x0BDA, 0x589A, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x0BDA, 0x590A, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x1358, 0xC125, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x0BDA, 0xE852, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x0CB8, 0xC549, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x1358, 0xC127, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x13D3, 0x3565, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x13D3, 0x3566, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +{ 0x04C5, 0x165C, 0x8852, 0, 0, "mp_rtl8852au_fw", "rtl8852au_fw", "rtl8852au_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_69_2K}, /*RTL8852AU */ +//RTL8852B +{ 0x0BDA, 0x024C, 0x8852, 0, 0, "mp_rtl8852bu_fw", "rtl8852bu_fw", "rtl8852bu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_65_2K}, /*RTL8852B */ +{ 0x0BDA, 0xA85B, 0x8852, 0, 0, "mp_rtl8852bu_fw", "rtl8852bu_fw", "rtl8852bu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_65_2K}, /*RTL8852B */ +{ 0x0BDA, 0xB85B, 0x8852, 0, 0, "mp_rtl8852bu_fw", "rtl8852bu_fw", "rtl8852bu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_65_2K}, /*RTL8852B */ +{ 0x0BDA, 0x4853, 0x8852, 0, 0, "mp_rtl8852bu_fw", "rtl8852bu_fw", "rtl8852bu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_65_2K}, /*RTL8852B */ +{ 0x13D3, 0x3570, 0x8852, 0, 0, "mp_rtl8852bu_fw", "rtl8852bu_fw", "rtl8852bu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_65_2K}, /*RTL8852B */ +//RTL8852c +{ 0x0BDA, 0xC85A, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x0BDA, 0xC85D, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x0BDA, 0x885C, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852CU */ +{ 0x0BDA, 0x5852, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x0BDA, 0xC85C, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x0BDA, 0x886C, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x0BDA, 0x887C, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x04CA, 0x4007, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x0BDA, 0xC801, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x0BDA, 0xC802, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x0BDA, 0xC803, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x04C5, 0x1675, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x0CB8, 0xC558, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x13D3, 0x3587, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +{ 0x13D3, 0x3586, 0x8852, 0, 0, "mp_rtl8852cu_fw", "rtl8852cu_fw", "rtl8852cu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_78K}, /*RTL8852C */ +//RTL8852BP +{ 0x0BDA, 0xA85C, 0x8852, 0, 0, "mp_rtl8852bpu_fw", "rtl8852bpu_fw", "rtl8852bpu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_65_2K}, /*RTL8852BP */ +{ 0x0BDA, 0xA850, 0x8852, 0, 0, "mp_rtl8852bpu_fw", "rtl8852bpu_fw", "rtl8852bpu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_4PLUS, MAX_PATCH_SIZE_65_2K}, /*RTL8852BPE */ /* NOTE: must append patch entries above the null entry */ -{ 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, 0, 0 } +{ 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, 0, 0, 0 } }; struct btusb_data { @@ -166,30 +245,51 @@ struct btusb_data { RTK_sco_card_t *pSCOSnd; #endif }; -#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 1) -static bool reset_on_close = 0; -#endif int download_patch(firmware_info *fw_info, int cached); int reset_controller(firmware_info* fw_info); -static inline int check_set_dlfw_state_value(uint16_t change_value) + +/******************************************************** +** this function first check the value, if true then set value +** +*********************************************************/ +static inline bool check_set_driver_state_value(uint16_t check_value, uint16_t change_value) { - int state; - spin_lock(&dlfw_lock); - if(!dlfw_dis_state) { - dlfw_dis_state = change_value; + bool res; + spin_lock(&running_flag_lock); + if((driver_state & check_value) != check_value) { + res = false; } - state = dlfw_dis_state; - spin_unlock(&dlfw_lock); + else { + driver_state |= change_value; + res = true; + } + spin_unlock(&running_flag_lock); + return res; +} + +static inline uint16_t get_driver_state_value(void) +{ + uint16_t state; + spin_lock(&running_flag_lock); + state = driver_state; + spin_unlock(&running_flag_lock); return state; } -static inline void set_dlfw_state_value(uint16_t change_value) +static inline void clear_driver_state(uint16_t clear_value) { - spin_lock(&dlfw_lock); - dlfw_dis_state = change_value; - spin_unlock(&dlfw_lock); + spin_lock(&running_flag_lock); + driver_state &= (~clear_value); + spin_unlock(&running_flag_lock); +} + +static inline void set_driver_state_value(uint16_t change_value) +{ + spin_lock(&running_flag_lock); + driver_state |= change_value; + spin_unlock(&running_flag_lock); } #if SUSPNED_DW_FW @@ -245,6 +345,19 @@ static void print_sco(struct sk_buff *skb, int direction) #endif } +static void print_iso(struct sk_buff *skb, int direction) +{ +#if PRINT_ISO_DATA + uint wlength = skb->len; + u16 *handle = (u16 *)(skb->data); + u16 len = *(handle+1); + u8 *acl_data = (u8 *)(skb->data); + + RTK_INFO("%s: direction %d, handle %04x, len %d", + __func__, direction, *handle, len); +#endif +} + static void print_error_command(struct sk_buff *skb) { uint wlength = skb->len; @@ -329,11 +442,9 @@ static void print_command(struct sk_buff *skb) #if CONFIG_BLUEDROID /* Global parameters for bt usb char driver */ #define BT_CHAR_DEVICE_NAME "rtkbt_dev" -struct mutex btchr_mutex; static struct sk_buff_head btchr_readq; static wait_queue_head_t btchr_read_wait; -static wait_queue_head_t bt_dlfw_wait; -static bool bt_char_dev_registered; +static wait_queue_head_t bt_drv_state_wait; static dev_t bt_devid; /* bt char device number */ static struct cdev bt_char_dev; /* bt character device structure */ static struct class *bt_char_class; /* device class for usb char driver */ @@ -476,7 +587,8 @@ static int rtk_skb_queue_rear = 0; static void rtk_enqueue(struct sk_buff *skb) { - spin_lock(&queue_lock); + unsigned long flags; + spin_lock_irqsave(&queue_lock, flags); if (rtk_skb_queue_front == (rtk_skb_queue_rear + 1) % QUEUE_SIZE) { /* * If queue is full, current solution is to drop @@ -490,7 +602,7 @@ static void rtk_enqueue(struct sk_buff *skb) rtk_skb_queue_rear %= QUEUE_SIZE; } - spin_unlock(&queue_lock); + spin_unlock_irqrestore(&queue_lock, flags); } static struct sk_buff *rtk_dequeue_try(unsigned int deq_len) @@ -530,7 +642,8 @@ static inline int is_queue_empty(void) static void rtk_clear_queue(void) { struct sk_buff *skb; - spin_lock(&queue_lock); + unsigned long flags; + spin_lock_irqsave(&queue_lock, flags); while(!is_queue_empty()) { skb = rtk_skb_queue[rtk_skb_queue_front]; rtk_skb_queue[rtk_skb_queue_front] = NULL; @@ -540,7 +653,7 @@ static void rtk_clear_queue(void) kfree_skb(skb); } } - spin_unlock(&queue_lock); + spin_unlock_irqrestore(&queue_lock, flags); } /* @@ -571,7 +684,7 @@ static int hci_dev_open(__u16 dev) return -ENODEV; } - if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { + if (test_bit(HCI_UNREGISTER, &hdev->flags)) { ret = -ENODEV; goto done; } @@ -580,14 +693,6 @@ static int hci_dev_open(__u16 dev) ret = -EALREADY; goto done; } -/* - ret = hdev->open(hdev); - if(ret < 0){ - RTKBT_ERR("%s:Failed in hdev->open(hdev):%d",__func__,ret); - goto done; - } - set_bit(HCI_UP, &hdev->flags); -*/ done: return ret; @@ -602,6 +707,7 @@ static int hci_dev_do_close(struct hci_dev *hdev) hdev->close(hdev); /* Clear flags */ hdev->flags = 0; + memset(&hdev->conn_hash, 0, sizeof(struct hci_conn_hash)); return 0; } @@ -653,7 +759,6 @@ static int hci_register_dev(struct hci_dev *hdev) sprintf(hdev->name, "hci%d", id); hdev->id = id; hdev->flags = 0; - hdev->dev_flags = 0; mutex_init(&hdev->lock); RTKBT_DBG("%s: id %d, name %s", __func__, hdev->id, hdev->name); @@ -683,7 +788,7 @@ static void hci_unregister_dev(struct hci_dev *hdev) int i; RTKBT_DBG("%s: hdev %p name %s bus %d", __func__, hdev, hdev->name, hdev->bus); - set_bit(HCI_UNREGISTER, &hdev->dev_flags); + set_bit(HCI_UNREGISTER, &hdev->flags); write_lock(&hci_dev_lock); ghdev = NULL; @@ -741,11 +846,6 @@ static void hci_send_to_alsa_ringbuffer(struct hci_dev *hdev, struct sk_buff *sk RTKBT_DBG("%s", __func__); - if (!hdev) { - RTKBT_ERR("%s: Frame for unknown HCI device", __func__); - return; - } - if (!test_bit(ALSA_CAPTURE_RUNNING, &pSCOSnd->states)) { //RTKBT_WARN("%s: ALSA is not running", __func__); return; @@ -797,8 +897,36 @@ static int hci_recv_frame(struct sk_buff *skb) { struct hci_dev *hdev = (struct hci_dev *) skb->dev; - if (!hdev || - (!test_bit(HCI_UP, &hdev->flags) && !test_bit(HCI_INIT, &hdev->flags))) { + if (!hdev || !test_bit(HCI_UP, &hdev->flags)) { + kfree_skb(skb); + return -ENXIO; + } + + /* Incomming skb */ + bt_cb(skb)->incoming = 1; + + /* Time stamp */ + __net_timestamp(skb); + + if (atomic_read(&hdev->promisc)) { +#ifdef CONFIG_SCO_OVER_HCI + if(bt_cb(skb)->pkt_type == HCI_SCODATA_PKT) + hci_send_to_alsa_ringbuffer(hdev, skb); +#endif + /* Send copy to the sockets */ + hci_send_to_stack(hdev, skb); + } + + kfree_skb(skb); + return 0; +} + +/* Receive frame from HCI drivers */ +static int hci_recv_sco_frame(struct sk_buff *skb) +{ + struct hci_dev *hdev = (struct hci_dev *) skb->dev; + + if (!hdev || !test_bit(HCI_UP, &hdev->flags)) { kfree_skb(skb); return -ENXIO; } @@ -833,7 +961,7 @@ static int hci_reassembly(struct hci_dev *hdev, int type, void *data, RTKBT_DBG("%s", __func__); - if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || + if ((type < HCI_ACLDATA_PKT || type > HCI_ISODATA_PKT) || index >= NUM_REASSEMBLY) return -EILSEQ; @@ -853,6 +981,10 @@ static int hci_reassembly(struct hci_dev *hdev, int type, void *data, len = HCI_MAX_SCO_SIZE; hlen = HCI_SCO_HDR_SIZE; break; + case HCI_ISODATA_PKT: + len = HCI_MAX_FRAME_SIZE; + hlen = HCI_ISO_HDR_SIZE; + break; } skb = bt_skb_alloc(len, GFP_ATOMIC); @@ -865,6 +997,7 @@ static int hci_reassembly(struct hci_dev *hdev, int type, void *data, skb->dev = (void *) hdev; hdev->reassembly[index] = skb; + } while (count) { @@ -878,6 +1011,22 @@ static int hci_reassembly(struct hci_dev *hdev, int type, void *data, scb->expect -= len; remain = count; + // workaroud for ISO over ACL USB EndPoint + if(type == HCI_ACLDATA_PKT) + { + if (skb->len == HCI_ACL_HDR_SIZE) { + struct hci_acl_hdr *h = hci_acl_hdr(skb); + + __u16 handle = __le16_to_cpu(h->handle)&0xfff; + //RTKBT_ERR("%s: Frame for unknown HCI device: %04x -> %04x ", __func__, h->handle, handle); + if(handle >= iso_min_conn_handle) + { + type = HCI_ISODATA_PKT; + scb->pkt_type = type; + } + } + } + switch (type) { case HCI_EVENT_PKT: if (skb->len == HCI_EVENT_HDR_SIZE) { @@ -917,6 +1066,19 @@ static int hci_reassembly(struct hci_dev *hdev, int type, void *data, } } break; + + case HCI_ISODATA_PKT: + if (skb->len == HCI_ISO_HDR_SIZE) { + struct hci_iso_hdr *h = hci_iso_hdr(skb); + scb->expect = __le16_to_cpu(h->dlen) & 0x3fff; + + if (skb_tailroom(skb) < scb->expect) { + kfree_skb(skb); + hdev->reassembly[index] = NULL; + return -ENOMEM; + } + } + break; } if (scb->expect == 0) { @@ -927,9 +1089,15 @@ static int hci_reassembly(struct hci_dev *hdev, int type, void *data, print_sco(skb,0); if(HCI_EVENT_PKT == type) print_event(skb); + if(HCI_ISODATA_PKT == type) + print_iso(skb,0); bt_cb(skb)->pkt_type = type; - hci_recv_frame(skb); + if(type == HCI_SCODATA_PKT) { + hci_recv_sco_frame(skb); + } + else + hci_recv_frame(skb); hdev->reassembly[index] = NULL; return remain; @@ -943,7 +1111,7 @@ static int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int cou { int rem = 0; - if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) + if (type < HCI_ACLDATA_PKT || type > HCI_ISODATA_PKT) return -EILSEQ; while (count) { @@ -961,7 +1129,7 @@ static int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int cou void hci_hardware_error(void) { struct sk_buff *rtk_skb_copy = NULL; - int len = 3; + int len = 4; uint8_t hardware_err_pkt[4] = {HCI_EVENT_PKT, 0x10, 0x01, HCI_VENDOR_USB_DISC_HARDWARE_ERROR}; rtk_skb_copy = alloc_skb(len, GFP_ATOMIC); @@ -980,16 +1148,24 @@ static int btchr_open(struct inode *inode_p, struct file *file_p) { struct btusb_data *data; struct hci_dev *hdev; + struct sk_buff *skb; + int i; RTKBT_INFO("%s: BT usb char device is opening", __func__); - /* Not open unless wanna tracing log */ - /* trace_printk("%s: open....\n", __func__); */ + + if(!check_set_driver_state_value(DEVICE_PROBED, CHAR_OPENED)) { + RTKBT_ERR("%s: Device not probed", __func__); + return -ENODEV; + } + hdev = hci_dev_get(0); if (!hdev) { RTKBT_ERR("%s: Failed to get hci dev[NULL]", __func__); return -ENODEV; } + + set_bit(HCI_UP, &hdev->flags); data = GET_DRV_DATA(hdev); atomic_inc(&hdev->promisc); @@ -1000,11 +1176,15 @@ static int btchr_open(struct inode *inode_p, struct file *file_p) */ file_p->private_data = data; - mutex_lock(&btchr_mutex); hci_dev_open(0); - mutex_unlock(&btchr_mutex); - rtk_clear_queue(); + for(i = 0; i < NUM_REASSEMBLY; i++) { + skb = hdev->reassembly[i]; + if(skb) { + hdev->reassembly[i] = NULL; + kfree_skb(skb); + } + } return nonseekable_open(inode_p, file_p); } @@ -1014,8 +1194,6 @@ static int btchr_close(struct inode *inode_p, struct file *file_p) struct hci_dev *hdev; RTKBT_INFO("%s: BT usb char device is closing", __func__); - /* Not open unless wanna tracing log */ - /* trace_printk("%s: close....\n", __func__); */ data = file_p->private_data; file_p->private_data = NULL; @@ -1028,14 +1206,19 @@ static int btchr_close(struct inode *inode_p, struct file *file_p) bt_reset = 0; #endif + hdev = hci_dev_get(0); if (hdev) { atomic_set(&hdev->promisc, 0); - mutex_lock(&btchr_mutex); hci_dev_close(0); - mutex_unlock(&btchr_mutex); + clear_bit(HCI_UP, &hdev->flags); } + clear_driver_state(CHAR_OPENED); + //if the state is not probed, the driver may be in the disconnecting state + //and waitting for signal to wake up + if((get_driver_state_value() & DEVICE_PROBED) == 0) + wake_up_interruptible(&bt_drv_state_wait); return 0; } @@ -1046,7 +1229,7 @@ static ssize_t btchr_read(struct file *file_p, { struct hci_dev *hdev; struct sk_buff *skb; - ssize_t ret = 0; + int ret = 0; RTKBT_DBG("%s: BT usb char device is reading", __func__); @@ -1064,7 +1247,7 @@ static ssize_t btchr_read(struct file *file_p, ret = wait_event_interruptible(btchr_read_wait, !is_queue_empty()); if (ret < 0) { - RTKBT_ERR("%s: wait event is signaled %d", __func__, (int)ret); + RTKBT_ERR("%s: wait event is signaled %d", __func__, ret); break; } @@ -1092,6 +1275,11 @@ static ssize_t btchr_write(struct file *file_p, RTKBT_DBG("%s: BT usb char device is writing", __func__); + if((get_driver_state_value() & DEVICE_PROBED) == 0) { + RTKBT_ERR("%s: Device not probed", __func__); + return POLLERR | POLLHUP; + } + hdev = hci_dev_get(0); if (!hdev) { RTKBT_WARN("%s: Failed to get hci dev[Null]", __func__); @@ -1141,8 +1329,9 @@ static unsigned int btchr_poll(struct file *file_p, poll_table *wait) RTKBT_DBG("%s: BT usb char device is polling", __func__); - if(!bt_char_dev_registered) { - RTKBT_ERR("%s: char device has not registered!", __func__); + if((get_driver_state_value() & DRIVER_ON) == 0 || + (get_driver_state_value() & DEVICE_PROBED) == 0) { + RTKBT_ERR("%s: Device not probed", __func__); return POLLERR | POLLHUP; } @@ -1172,31 +1361,28 @@ static unsigned int btchr_poll(struct file *file_p, poll_table *wait) return POLLOUT | POLLWRNORM; } + static long btchr_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg){ int ret = 0; struct hci_dev *hdev; struct btusb_data *data; firmware_info *fw_info; - if(!bt_char_dev_registered) { + if((get_driver_state_value() & DRIVER_ON) == 0 || + (get_driver_state_value() & DEVICE_PROBED) == 0) { + RTKBT_ERR("%s bt controller is disconnect!", __func__); return -ENODEV; } - if(check_set_dlfw_state_value(1) != 1) { - RTKBT_ERR("%s bt controller is disconnecting!", __func__); - return 0; - } - hdev = hci_dev_get(0); if(!hdev) { RTKBT_ERR("%s device is NULL!", __func__); - set_dlfw_state_value(0); return 0; } data = GET_DRV_DATA(hdev); fw_info = data->fw_info; - RTKBT_INFO(" btchr_ioctl DOWN_FW_CFG with Cmd:%d",cmd); + RTKBT_INFO(" btchr_ioctl with Cmd:%d",cmd); switch (cmd) { case DOWN_FW_CFG: ret = usb_autopm_get_interface(data->intf); @@ -1216,40 +1402,67 @@ static long btchr_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg RTKBT_ERR("%s:Failed in hdev->open(hdev):%d",__func__,ret); goto failed; } - set_bit(HCI_UP, &hdev->flags); - set_dlfw_state_value(0); - wake_up_interruptible(&bt_dlfw_wait); - return 1; + ret = 1; + break; + +#ifdef CONFIG_SCO_OVER_HCI + case SET_ISO_CFG: + if(get_user(hdev->voice_setting, (__u16 __user*)arg)) { + ret = -EFAULT; + } + RTKBT_INFO(" voice settings = 0x%04x", hdev->voice_setting); + break; +#endif + case GET_USB_INFO: ret = hdev->open(hdev); if(ret < 0){ RTKBT_ERR("%s:Failed in hdev->open(hdev):%d",__func__,ret); //goto done; } - set_bit(HCI_UP, &hdev->flags); - return usb_info; + put_user(usb_info, (__u32 __user*)arg); + ret = 1; + break; case RESET_CONTROLLER: reset_controller(fw_info); - return 1; + ret = 1; + break; -#ifdef CONFIG_SCO_OVER_HCI - case SET_ISO_CFG: - hdev->voice_setting = *(__u16 *)arg; - RTKBT_INFO(" voice settings = 0x%04x", hdev->voice_setting); - return 1; -#endif + case DWFW_CMPLT: + { + uint16_t lmp_sub = 0; + if(get_user(lmp_sub, (__u16 __user*)arg)) { + ret = -EFAULT; + } + else if(lmp_sub != 0) { + fw_info->patch_entry->lmp_sub = lmp_sub; + } + RTKBT_INFO("%s lmp_sub = 0x%x, patch_entry->lmp_sub = 0x%x", __func__, + lmp_sub, fw_info->patch_entry->lmp_sub); + } + break; + + case SET_ISO_MIN_HANDLE: + if(get_user(iso_min_conn_handle, (__u16 __user*)arg)) { + ret = -EFAULT; + } + RTKBT_INFO("%s iso_min_conn_handle = 0x%02x", __func__, iso_min_conn_handle); + break; default: RTKBT_ERR("%s:Failed with wrong Cmd:%d",__func__,cmd); goto failed; } - failed: - set_dlfw_state_value(0); - wake_up_interruptible(&bt_dlfw_wait); +failed: return ret; } - +#ifdef CONFIG_COMPAT +static long compat_btchr_ioctl (struct file *filp, unsigned int cmd, unsigned long arg) +{ + return btchr_ioctl(filp, cmd, (unsigned long) compat_ptr(arg)); +} +#endif static struct file_operations bt_chrdev_ops = { open : btchr_open, @@ -1258,6 +1471,9 @@ static struct file_operations bt_chrdev_ops = { write : btchr_write, poll : btchr_poll, unlocked_ioctl : btchr_ioctl, +#ifdef CONFIG_COMPAT + compat_ioctl : compat_btchr_ioctl, +#endif }; static int btchr_init(void) @@ -1266,16 +1482,9 @@ static int btchr_init(void) struct device *dev; RTKBT_INFO("Register usb char device interface for BT driver"); - /* - * btchr mutex is used to sync between - * 1) downloading patch and opening bt char driver - * 2) the file operations of bt char driver - */ - mutex_init(&btchr_mutex); - skb_queue_head_init(&btchr_readq); init_waitqueue_head(&btchr_read_wait); - init_waitqueue_head(&bt_dlfw_wait); + init_waitqueue_head(&bt_drv_state_wait); bt_char_class = class_create(THIS_MODULE, BT_CHAR_DEVICE_NAME); if (IS_ERR(bt_char_class)) { @@ -1390,13 +1599,6 @@ int set_bt_onoff(firmware_info *fw_info, uint8_t onoff) return ret_val; } - ret_val = rcv_hci_evt(fw_info); - if (ret_val < 0) { - RTKBT_ERR("%s: Failed to receive bt %s event, errno %d", - __func__, onoff != 0 ? "on" : "off", ret_val); - return ret_val; - } - return ret_val; } @@ -1428,6 +1630,7 @@ static patch_info *get_fw_table_entry(struct usb_device* udev) static patch_info *get_suspend_fw_table_entry(struct usb_device* udev) { patch_info *patch_entry = fw_patch_table; + patch_info *patch_entry_real = NULL; uint16_t vid = le16_to_cpu(udev->descriptor.idVendor); uint16_t pid = le16_to_cpu(udev->descriptor.idProduct); uint32_t entry_size = sizeof(fw_patch_table) / sizeof(fw_patch_table[0]); @@ -1444,8 +1647,11 @@ static patch_info *get_suspend_fw_table_entry(struct usb_device* udev) RTKBT_ERR("%s: No fw table entry found", __func__); return NULL; } - - return patch_entry; + patch_entry_real = kmalloc(sizeof(fw_patch_table[0]), GFP_KERNEL); + if(!patch_entry_real) + return NULL; + memcpy(patch_entry_real, patch_entry, sizeof(fw_patch_table[0])); + return patch_entry_real; } #endif @@ -1518,11 +1724,13 @@ int reset_controller(firmware_info* fw_info) * 0: no need to download fw patch * <0: failed to check lmp version */ -int check_fw_version(firmware_info* fw_info) +int check_fw_version(firmware_info* fw_info, bool resume_check) { struct hci_rp_read_local_version *read_ver_rsp; patch_info *patch_entry = NULL; - int ret_val = -1; + int ret_val = -1, i, ret_len = 0; + struct sk_buff *rtk_skb_copy = NULL; + unsigned char pkt_type = HCI_EVENT_PKT; fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_OP_READ_LOCAL_VERSION); fw_info->cmd_hdr->plen = 0; @@ -1535,11 +1743,40 @@ int check_fw_version(firmware_info* fw_info) return ret_val; } - ret_val = rcv_hci_evt(fw_info); - if (ret_val < 0) { - RTKBT_ERR("%s: Failed to receive hci event, errno %d", + while (1) { + for(i = 0; i < 5; i++) { + ret_val = usb_interrupt_msg( + fw_info->udev, fw_info->pipe_in, + (void *)(fw_info->rcv_pkt), PKT_LEN, + &ret_len, MSG_TO); + if (ret_val >= 0) + break; + } + + if (ret_val < 0) { + RTKBT_ERR("%s: Failed to receive hci event, errno %d", __func__, ret_val); - return ret_val; + return ret_val; + } + + if ((CMD_CMP_EVT == fw_info->evt_hdr->evt) && + (fw_info->cmd_hdr->opcode == fw_info->cmd_cmp->opcode)) { + break; + } + else if(resume_check) { + rtk_skb_copy = bt_skb_alloc((ret_len), GFP_ATOMIC); + if (!rtk_skb_copy) { + RTKBT_ERR("%s: Failed to allocate mem", __func__); + return 2; + } + + memcpy(skb_put(rtk_skb_copy, ret_len), fw_info->rcv_pkt, ret_len); + memcpy(skb_push(rtk_skb_copy, 1), &pkt_type, 1); + rtk_enqueue(rtk_skb_copy); + + rtk_skb_copy = NULL; + wake_up_interruptible(&btchr_read_wait); + } } patch_entry = fw_info->patch_entry; @@ -1635,6 +1872,55 @@ int reset_channel(firmware_info* fw_info) return ret_val; } + +//sometimes the controller is in warm resume,and still send message to host +//we should reset controller and clean the hardware buffer +bool reset_and_clean_hw_buffer(firmware_info* fw_info) +{ + int ret_val, i; + int ret_len = 0; + bool event_recv = false; + + if (!fw_info) + return -ENODEV; + + fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VENDOR_RESET); + fw_info->cmd_hdr->plen = 0; + fw_info->pkt_len = CMD_HDR_LEN; + + ret_val = send_hci_cmd(fw_info); + if (ret_val < 0) { + RTKBT_ERR("%s: Failed to send hci cmd 0x%04x, errno %d", + __func__, fw_info->cmd_hdr->opcode, ret_val); + return ret_val; + } + + //we need to clean the hardware buffer + while (1) { + ret_val = usb_interrupt_msg( + fw_info->udev, fw_info->pipe_in, + (void *)(fw_info->rcv_pkt), PKT_LEN, + &ret_len, (MSG_TO/4)); + + if(ret_val >= 0) { + if(event_recv) { + RTKBT_INFO("%s: clear hardware event", __func__); + continue; + } + } + else { + return event_recv; + } + + if (CMD_CMP_EVT == fw_info->evt_hdr->evt) { + if (fw_info->cmd_hdr->opcode == fw_info->cmd_cmp->opcode) { + event_recv = true; + } + } + } + return ret_val; +} + int read_localversion(firmware_info* fw_info) { struct rtk_localversion_evt *ever_evt; @@ -1751,7 +2037,7 @@ void rtk_update_altsettings(patch_info *patch_entry, const unsigned char* org_co if (config->data_len != org_config_len - sizeof(struct rtk_bt_vendor_config)) { - RTKBT_ERR("rtk_update_altsettings: config len(%x) is not right(%x)", config->data_len, org_config_len-(int)sizeof(struct rtk_bt_vendor_config)); + //RTKBT_ERR("rtk_update_altsettings: config len(%x) is not right(%x)", config->data_len, org_config_len-sizeof(struct rtk_bt_vendor_config)); return; } @@ -1915,7 +2201,8 @@ int load_firmware(firmware_info *fw_info, uint8_t **buff) *(patch_lmp.data+k) = *(temp-2-k); RTKBT_DBG("data = 0x%x", *(patch_lmp.data+k)); } - } + }else + goto fw_fail; RTKBT_DBG("%s: opcode = 0x%x, length = 0x%x, data = 0x%x", __func__, patch_lmp.opcode, patch_lmp.length, *(patch_lmp.data)); break; @@ -1923,17 +2210,17 @@ int load_firmware(firmware_info *fw_info, uint8_t **buff) temp -= *(temp-1) + 2; } while (*temp != 0xFF); + if(!patch_lmp.data) goto fw_fail; + if (lmp_version != project_id[*(patch_lmp.data)]) { RTKBT_ERR("%s: Default lmp_version 0x%04x, project_id[%d] 0x%04x " "-> not match", __func__, lmp_version, *(patch_lmp.data),project_id[*(patch_lmp.data)]); - if (patch_lmp.data) - kfree(patch_lmp.data); + kfree(patch_lmp.data); need_download_fw = 0; } else { RTKBT_INFO("%s: Default lmp_version 0x%04x, project_id[%d] 0x%04x " "-> match", __func__, lmp_version, *(patch_lmp.data), project_id[*(patch_lmp.data)]); - if (patch_lmp.data) - kfree(patch_lmp.data); + kfree(patch_lmp.data); if (memcmp(epatch_buf, RTK_EPATCH_SIGNATURE, 8)) { RTKBT_ERR("%s: Check signature error", __func__); need_download_fw = 0; @@ -1950,7 +2237,6 @@ int load_firmware(firmware_info *fw_info, uint8_t **buff) p_epatch_entry = get_fw_patch_entry(epatch_info, patch_entry->eversion); if (p_epatch_entry == NULL) { RTKBT_WARN("%s: Failed to get fw patch entry", __func__); - ret_val = -1; goto fw_fail ; } @@ -1960,6 +2246,7 @@ int load_firmware(firmware_info *fw_info, uint8_t **buff) if (!(buf = kzalloc(buf_len, GFP_KERNEL))) { RTKBT_ERR("%s: Can't alloc memory for fw&config", __func__); buf_len = -1; + kfree(p_epatch_entry); } else { memcpy(buf, &epatch_buf[p_epatch_entry->start_offset], p_epatch_entry->patch_length); memcpy(&buf[p_epatch_entry->patch_length-4], &epatch_info->fw_version, 4); @@ -1969,7 +2256,7 @@ int load_firmware(firmware_info *fw_info, uint8_t **buff) RTKBT_INFO("%s: vfree(epatch_buf)", __func__); epatch_buf = NULL; - if (config_len) + if (config_len && buf) memcpy(&buf[buf_len - config_len], config_file_buf, config_len); } } @@ -1987,9 +2274,120 @@ int load_firmware(firmware_info *fw_info, uint8_t **buff) return buf_len; fw_fail: + if(epatch_buf) + vfree(epatch_buf); + ret_val = -1; return ret_val; } +void load_firmware_info(firmware_info *fw_info) +{ + const struct firmware *fw, *cfg; + struct usb_device *udev; + patch_info *patch_entry; + char *fw_name; + int ret_val; + + int buf_len = -1; + uint8_t *epatch_buf = NULL; + + struct rtk_epatch *epatch_info = NULL; + struct rtk_extension_entry patch_lmp = {0}; + uint16_t lmp_version; + RTKBT_DBG("%s: start", __func__); + + udev = fw_info->udev; + patch_entry = fw_info->patch_entry; + lmp_version = patch_entry->lmp_sub_default; + + if(DRV_MP_MODE == mp_drv_mode){ + fw_name = patch_entry->mp_patch_name; + } else { + fw_name = patch_entry->patch_name; + } + + RTKBT_INFO("%s: Default lmp version = 0x%04x, fw file name[%s]", __func__, lmp_version, fw_name); + + ret_val = request_firmware(&fw, fw_name, &udev->dev); + if (ret_val < 0) + goto fw_fail; + else { + epatch_buf = vmalloc(fw->size); + RTKBT_INFO("%s: epatch_buf = vmalloc(fw->size, GFP_KERNEL)", __func__); + if (!epatch_buf) { + release_firmware(fw); + goto fw_fail; + } + memcpy(epatch_buf, fw->data, fw->size); + buf_len = fw->size; + release_firmware(fw); + } + + ret_val = reset_and_clean_hw_buffer(fw_info); + + if (lmp_version != ROM_LMP_8723a) { + RTKBT_DBG("%s: Not 8723a -> use new style patch", __func__); + ret_val = get_eversion(fw_info); + if (ret_val < 0) { + RTKBT_ERR("%s: Failed to get eversion, errno %d", __func__, ret_val); + goto fw_fail; + } + RTKBT_DBG("%s: Get eversion =%d", __func__, patch_entry->eversion); + if (memcmp(epatch_buf + buf_len - 4 , EXTENSION_SECTION_SIGNATURE, 4)) { + RTKBT_ERR("%s: Failed to check extension section signature", __func__); + } else { + uint8_t *temp; + temp = epatch_buf + buf_len - 5; + do { + if (*temp == 0x00) { + patch_lmp.opcode = *temp; + patch_lmp.length = *(temp-1); + if ((patch_lmp.data = vmalloc(patch_lmp.length))) { + int k; + for (k = 0; k < patch_lmp.length; k++) { + *(patch_lmp.data+k) = *(temp-2-k); + RTKBT_DBG("data = 0x%x", *(patch_lmp.data+k)); + } + }else + goto fw_fail; + RTKBT_DBG("%s: opcode = 0x%x, length = 0x%x, data = 0x%x", __func__, + patch_lmp.opcode, patch_lmp.length, *(patch_lmp.data)); + break; + } + temp -= *(temp-1) + 2; + } while (*temp != 0xFF); + + if(!patch_lmp.data) goto fw_fail; + + if (lmp_version != project_id[*(patch_lmp.data)]) { + RTKBT_ERR("%s: Default lmp_version 0x%04x, project_id[%d] 0x%04x " + "-> not match", __func__, lmp_version, *(patch_lmp.data),project_id[*(patch_lmp.data)]); + } else { + RTKBT_INFO("%s: Default lmp_version 0x%04x, project_id[%d] 0x%04x " + "-> match", __func__, lmp_version, *(patch_lmp.data), project_id[*(patch_lmp.data)]); + if (memcmp(epatch_buf, RTK_EPATCH_SIGNATURE, 8)) { + RTKBT_ERR("%s: Check signature error", __func__); + } else { + epatch_info = (struct rtk_epatch*)epatch_buf; + patch_entry->lmp_sub = (uint16_t)epatch_info->fw_version; + + RTKBT_DBG("%s: lmp version 0x%04x, fw_version 0x%x, " + "number_of_total_patch %d", __func__, + patch_entry->lmp_sub, epatch_info->fw_version, + epatch_info->number_of_total_patch); + } + } + } + } + + RTKBT_DBG("%s: done", __func__); +fw_fail: + if(epatch_buf) + vfree(epatch_buf); + if (patch_lmp.data) + vfree(patch_lmp.data); +} + #if SUSPNED_DW_FW static int load_suspend_firmware(firmware_info *fw_info, uint8_t **buff) { @@ -2006,7 +2404,6 @@ static int load_suspend_firmware(firmware_info *fw_info, uint8_t **buff) uint8_t *epatch_buf = NULL; struct rtk_epatch *epatch_info = NULL; - uint8_t need_download_fw = 1; struct rtk_extension_entry patch_lmp = {0}; struct rtk_epatch_entry *p_epatch_entry = NULL; uint16_t lmp_version; @@ -2025,12 +2422,17 @@ static int load_suspend_firmware(firmware_info *fw_info, uint8_t **buff) if (ret_val < 0) config_len = 0; else { - config_file_buf = vmalloc(cfg->size); - RTKBT_INFO("%s: epatch_buf = vmalloc(cfg->size)", __func__); - if (!config_file_buf) - return -ENOMEM; - memcpy(config_file_buf, cfg->data, cfg->size); - config_len = cfg->size; + int i; + rtk_update_altsettings(patch_entry, cfg->data, cfg->size, &config_file_buf, &config_len); + + RTKBT_INFO("Final Config len=%08x:\n", config_len); + for(i=0;i<=config_len;i+=0x10) + { + RTKBT_INFO("%08x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", i, \ + config_file_buf[i], config_file_buf[i+1], config_file_buf[i+2], config_file_buf[i+3], config_file_buf[i+4], config_file_buf[i+5], config_file_buf[i+6], config_file_buf[i+7], \ + config_file_buf[i+8], config_file_buf[i+9], config_file_buf[i+10], config_file_buf[i+11], config_file_buf[i+12], config_file_buf[i+13], config_file_buf[i+14], config_file_buf[i+15]); + } + release_firmware(cfg); } @@ -2062,7 +2464,7 @@ static int load_suspend_firmware(firmware_info *fw_info, uint8_t **buff) RTKBT_DBG("%s: Get eversion =%d", __func__, patch_entry->eversion); if (memcmp(epatch_buf + buf_len - config_len - 4 , EXTENSION_SECTION_SIGNATURE, 4)) { RTKBT_ERR("%s: Failed to check extension section signature", __func__); - need_download_fw = 0; + goto fw_fail; } else { uint8_t *temp; temp = epatch_buf+buf_len-config_len - 5; @@ -2076,7 +2478,9 @@ static int load_suspend_firmware(firmware_info *fw_info, uint8_t **buff) *(patch_lmp.data+k) = *(temp-2-k); RTKBT_DBG("data = 0x%x", *(patch_lmp.data+k)); } - } + }else + goto fw_fail; + RTKBT_DBG("%s: opcode = 0x%x, length = 0x%x, data = 0x%x", __func__, patch_lmp.opcode, patch_lmp.length, *(patch_lmp.data)); break; @@ -2084,20 +2488,20 @@ static int load_suspend_firmware(firmware_info *fw_info, uint8_t **buff) temp -= *(temp-1) + 2; } while (*temp != 0xFF); + if(!patch_lmp.data) goto fw_fail; + if (lmp_version != project_id[*(patch_lmp.data)]) { RTKBT_ERR("%s: Default lmp_version 0x%04x, project_id[%d] 0x%04x " "-> not match", __func__, lmp_version, *(patch_lmp.data),project_id[*(patch_lmp.data)]); - if (patch_lmp.data) - kfree(patch_lmp.data); - need_download_fw = 0; + kfree(patch_lmp.data); + goto fw_fail; } else { RTKBT_INFO("%s: Default lmp_version 0x%04x, project_id[%d] 0x%04x " "-> match", __func__, lmp_version, *(patch_lmp.data), project_id[*(patch_lmp.data)]); - if (patch_lmp.data) - kfree(patch_lmp.data); + kfree(patch_lmp.data); if (memcmp(epatch_buf, RTK_EPATCH_SIGNATURE, 8)) { RTKBT_ERR("%s: Check signature error", __func__); - need_download_fw = 0; + goto fw_fail; } else { epatch_info = (struct rtk_epatch*)epatch_buf; patch_entry->lmp_sub = (uint16_t)epatch_info->fw_version; @@ -2111,7 +2515,6 @@ static int load_suspend_firmware(firmware_info *fw_info, uint8_t **buff) p_epatch_entry = get_fw_patch_entry(epatch_info, patch_entry->eversion); if (p_epatch_entry == NULL) { RTKBT_WARN("%s: Failed to get fw patch entry", __func__); - ret_val = -1; goto fw_fail ; } @@ -2121,6 +2524,8 @@ static int load_suspend_firmware(firmware_info *fw_info, uint8_t **buff) if (!(buf = kzalloc(buf_len, GFP_KERNEL))) { RTKBT_ERR("%s: Can't alloc memory for fw&config", __func__); buf_len = -1; + kfree(p_epatch_entry); + goto fw_fail ; } else { memcpy(buf, &epatch_buf[p_epatch_entry->start_offset], p_epatch_entry->patch_length); memcpy(&buf[p_epatch_entry->patch_length-4], &epatch_info->fw_version, 4); @@ -2130,22 +2535,16 @@ static int load_suspend_firmware(firmware_info *fw_info, uint8_t **buff) RTKBT_INFO("%s: vfree(epatch_buf)", __func__); epatch_buf = NULL; - if (config_len) + if (config_len && buf) memcpy(&buf[buf_len - config_len], config_file_buf, config_len); } } } - if (config_file_buf){ - vfree(config_file_buf); - config_file_buf = NULL; - RTKBT_INFO("%s: vfree(config_file_buf)", __func__); - } - RTKBT_INFO("%s: fw%s exists, config file%s exists", __func__, (buf_len > 0) ? "" : " not", (config_len > 0) ? "":" not"); - if (buf && buf_len > 0 && need_download_fw) + if (buf && buf_len > 0) *buff = buf; RTKBT_DBG("%s: done", __func__); @@ -2153,11 +2552,9 @@ static int load_suspend_firmware(firmware_info *fw_info, uint8_t **buff) return buf_len; fw_fail: - if (config_file_buf){ - vfree(config_file_buf); - config_file_buf = NULL; - } - RTKBT_INFO("%s: fw_fail vfree(config_file_buf)", __func__); + if(epatch_buf) + vfree(epatch_buf); + ret_val = -1; return ret_val; } #endif @@ -2362,7 +2759,7 @@ int download_patch(firmware_info *fw_info, int cached) goto free; } - ret_val = check_fw_version(fw_info); + ret_val = check_fw_version(fw_info, false); if (2 == ret_val) { RTKBT_ERR("%s: Cold reset bt chip only download", __func__); @@ -2403,13 +2800,13 @@ static int download_suspend_patch(firmware_info *fw_info, int cached) /*check the length of fw to be download*/ RTKBT_DBG("%s:Check RTK_PATCH_LENGTH fw_info->fw_len:%d", __func__,fw_info->fw_len); - if (fw_info->fw_len > RTK_PATCH_LENGTH_MAX || fw_info->fw_len == 0) { - RTKBT_ERR("%s: Total length of fw&config larger than allowed 24K or no fw len:%d", __func__, fw_info->fw_len); + if (fw_info->fw_len > fw_info->patch_entry->max_patch_size || fw_info->fw_len == 0) { + RTKBT_ERR("%s: Total length of fw&config(%08x) larger than max_patch_size 0x%08x", __func__, fw_info->fw_len, fw_info->patch_entry->max_patch_size); ret_val = -1; goto free; } - ret_val = check_fw_version(fw_info); + ret_val = check_fw_version(fw_info, false); if (2 == ret_val) { RTKBT_ERR("%s: Cold reset bt chip only download", __func__); @@ -2614,8 +3011,9 @@ void firmware_info_destroy(struct usb_interface *intf) kfree(fw_info_4_suspend->rcv_pkt); kfree(fw_info_4_suspend->send_pkt); + kfree(fw_info_4_suspend->patch_entry); kfree(fw_info_4_suspend); - fw_info_4_suspend = NULL; + fw_info_4_suspend = NULL; #endif } @@ -2887,7 +3285,7 @@ static void btusb_isoc_complete(struct urb *urb) RTKBT_DBG("%s: urb %p status %d count %d", __func__, urb, urb->status, urb->actual_length); - if (!test_bit(HCI_RUNNING, &hdev->flags)) + if (!test_bit(HCI_RUNNING, &hdev->flags) || !test_bit(BTUSB_ISOC_RUNNING, &data->flags)) return; if (urb->status == 0) { @@ -2913,10 +3311,6 @@ static void btusb_isoc_complete(struct urb *urb) return; } - - if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags)) - return; - usb_anchor_urb(urb, &data->isoc_anchor); i = 0; retry: @@ -3042,16 +3436,13 @@ static void btusb_isoc_tx_complete(struct urb *urb) RTKBT_DBG("%s: urb %p status %d count %d", __func__, urb, urb->status, urb->actual_length); - if (skb && hdev) { - if (!test_bit(HCI_RUNNING, &hdev->flags)) - goto done; + if (!test_bit(HCI_RUNNING, &hdev->flags)) + goto done; - if (!urb->status) - hdev->stat.byte_tx += urb->transfer_buffer_length; - else - hdev->stat.err_tx++; - } else - RTKBT_ERR("%s: skb 0x%p hdev 0x%p", __func__, skb, hdev); + if (!urb->status) + hdev->stat.byte_tx += urb->transfer_buffer_length; + else + hdev->stat.err_tx++; done: kfree(urb->setup_packet); @@ -3062,16 +3453,30 @@ done: static int btusb_open(struct hci_dev *hdev) { struct btusb_data *data = GET_DRV_DATA(hdev); - int err = 0; + int i, err = 0; + firmware_info *fw_info = data->fw_info; + reset_and_clean_hw_buffer(fw_info); RTKBT_INFO("%s: Start, PM usage count %d", __func__, - atomic_read(&(data->intf->pm_usage_cnt))); +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 9, 0) + atomic_read(&data->intf->pm_usage_cnt) +#else + 0 +#endif + ); err = usb_autopm_get_interface(data->intf); if (err < 0) return err; data->intf->needs_remote_wakeup = 1; + for (i = 0; i < NUM_REASSEMBLY; i++) { + if (hdev->reassembly[i]) { + RTKBT_DBG("%s: free ressembly[%d]", __func__, i); + kfree_skb(hdev->reassembly[i]); + hdev->reassembly[i] = NULL; + } + } if (test_and_set_bit(HCI_RUNNING, &hdev->flags)) goto done; @@ -3095,16 +3500,28 @@ static int btusb_open(struct hci_dev *hdev) done: usb_autopm_put_interface(data->intf); + RTKBT_INFO("%s: End, PM usage count %d", __func__, - atomic_read(&(data->intf->pm_usage_cnt))); +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 9, 0) + atomic_read(&data->intf->pm_usage_cnt) +#else + 0 +#endif + ); return 0; failed: clear_bit(BTUSB_INTR_RUNNING, &data->flags); clear_bit(HCI_RUNNING, &hdev->flags); usb_autopm_put_interface(data->intf); + RTKBT_ERR("%s: Failed, PM usage count %d", __func__, - atomic_read(&(data->intf->pm_usage_cnt))); +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 9, 0) + atomic_read(&data->intf->pm_usage_cnt) +#else + 0 +#endif + ); return err; } @@ -3119,21 +3536,13 @@ static void btusb_stop_traffic(struct btusb_data *data) static int btusb_close(struct hci_dev *hdev) { struct btusb_data *data = GET_DRV_DATA(hdev); - int i, err; + int err; RTKBT_INFO("%s: hci running %lu", __func__, hdev->flags & HCI_RUNNING); if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) return 0; - for (i = 0; i < NUM_REASSEMBLY; i++) { - if (hdev->reassembly[i]) { - RTKBT_DBG("%s: free ressembly[%d]", __func__, i); - kfree_skb(hdev->reassembly[i]); - hdev->reassembly[i] = NULL; - } - } - cancel_work_sync(&data->work); cancel_work_sync(&data->waker); @@ -3183,7 +3592,7 @@ static int snd_send_sco_frame(struct sk_buff *skb) RTKBT_DBG("%s:pkt type %d, packet_len : %d", __func__,bt_cb(skb)->pkt_type, skb->len); - if (!hdev && !test_bit(HCI_RUNNING, &hdev->flags)) + if (!test_bit(HCI_RUNNING, &hdev->flags)) return -EBUSY; if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1) { @@ -3241,11 +3650,12 @@ static bool snd_copy_send_sco_data( RTK_sco_card_t *pSCOSnd) count = frames_to_bytes(runtime, period_size)/sco_packet_bytes; skb = bt_skb_alloc(((sco_packet_bytes + HCI_SCO_HDR_SIZE) * count), GFP_ATOMIC); + if(!skb) + return false; skb->dev = (void *)hci_dev_get(0); bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; skb_put(skb, ((sco_packet_bytes + HCI_SCO_HDR_SIZE) * count)); - if(!skb) - return false; + RTKBT_DBG("%s, buffer_pos: %d", __FUNCTION__, pSCOSnd->playback.buffer_pos); @@ -3289,24 +3699,22 @@ static void btusb_isoc_snd_tx_complete(struct urb *urb) RTKBT_DBG("%s: status %d count %d", __func__,urb->status, urb->actual_length); - if (skb && hdev) { - if (!test_bit(HCI_RUNNING, &hdev->flags)) - goto done; + if (!test_bit(HCI_RUNNING, &hdev->flags)) + goto done; - if (!urb->status) - hdev->stat.byte_tx += urb->transfer_buffer_length; - else - hdev->stat.err_tx++; - } else - RTKBT_ERR("%s: skb 0x%p hdev 0x%p", __func__, skb, hdev); + if (!urb->status) + hdev->stat.byte_tx += urb->transfer_buffer_length; + else + hdev->stat.err_tx++; done: - kfree(urb->setup_packet); - kfree_skb(skb); - if(test_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states)){ + + if(pSCOSnd && test_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states)){ snd_copy_send_sco_data(pSCOSnd); //schedule_work(&pSCOSnd->send_sco_work); } + kfree(urb->setup_packet); + kfree_skb(skb); } static void playback_work(struct work_struct *work) @@ -3335,8 +3743,6 @@ static int btusb_send_frame(struct sk_buff *skb) if (!test_bit(HCI_RUNNING, &hdev->flags)) return -EBUSY; - - switch (bt_cb(skb)->pkt_type) { case HCI_COMMAND_PKT: print_command(skb); @@ -3363,7 +3769,7 @@ static int btusb_send_frame(struct sk_buff *skb) hdev->stat.cmd_tx++; break; - + case HCI_ISODATA_PKT: case HCI_ACLDATA_PKT: print_acl(skb, 1); if (!data->bulk_tx_ep) @@ -3532,6 +3938,7 @@ static void btusb_work(struct work_struct *work) { struct btusb_data *data = container_of(work, struct btusb_data, work); struct hci_dev *hdev = data->hdev; + struct sk_buff *skb; int err; int new_alts; @@ -3574,6 +3981,11 @@ static void btusb_work(struct work_struct *work) mdelay(URB_CANCELING_DELAY_MS); usb_kill_anchored_urbs(&data->isoc_anchor); + if(hdev->reassembly[HCI_SCODATA_PKT - 1]) { + skb = hdev->reassembly[HCI_SCODATA_PKT - 1]; + hdev->reassembly[HCI_SCODATA_PKT - 1] = NULL; + kfree_skb(skb); + } if (set_isoc_interface(hdev, new_alts) < 0) return; } @@ -3600,6 +4012,7 @@ static void btusb_work(struct work_struct *work) usb_kill_anchored_urbs(&data->isoc_anchor); set_isoc_interface(hdev, 0); + if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags)) usb_autopm_put_interface(data->isoc ? data->isoc : data->intf); } @@ -3611,7 +4024,12 @@ static void btusb_waker(struct work_struct *work) int err; RTKBT_DBG("%s: PM usage count %d", __func__, - atomic_read(&data->intf->pm_usage_cnt)); +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 9, 0) + atomic_read(&data->intf->pm_usage_cnt) +#else + 0 +#endif + ); err = usb_autopm_get_interface(data->intf); if (err < 0) @@ -4082,6 +4500,7 @@ static RTK_sco_card_t* btusb_snd_init(struct usb_interface *intf, const struct u err = snd_pcm_new(card, RTK_SCO_ID, 0, 1, 1, &pSCOSnd->pcm); if (err < 0) { RTKBT_ERR("%s: sco snd card new pcm fail", __func__); + snd_card_free(card); return NULL; } pSCOSnd->pcm->private_data = pSCOSnd; @@ -4094,6 +4513,7 @@ static RTK_sco_card_t* btusb_snd_init(struct usb_interface *intf, const struct u err = snd_card_register(card); if (err < 0) { RTKBT_ERR("%s: sco snd card register card fail", __func__); + snd_card_free(card); return NULL; } @@ -4102,6 +4522,17 @@ static RTK_sco_card_t* btusb_snd_init(struct usb_interface *intf, const struct u INIT_WORK(&pSCOSnd->send_sco_work, playback_work); return pSCOSnd; } + +static void btusb_snd_remove(RTK_sco_card_t *pSCOSnd) +{ + if(!pSCOSnd) { + RTKBT_ERR("%s: sco private data is null", __func__); + return; + } + set_bit(DISCONNECTED, &pSCOSnd->states); + snd_card_disconnect(pSCOSnd->card); + snd_card_free_when_closed(pSCOSnd->card); +} #endif static int btusb_probe(struct usb_interface *intf, const struct usb_device_id *id) @@ -4158,9 +4589,8 @@ static int btusb_probe(struct usb_interface *intf, const struct usb_device_id *i data->udev = udev; data->intf = intf; - dlfw_dis_state = 0; spin_lock_init(&queue_lock); - spin_lock_init(&dlfw_lock); + spin_lock_init(&running_flag_lock); spin_lock_init(&data->lock); INIT_WORK(&data->work, btusb_work); @@ -4209,13 +4639,6 @@ static int btusb_probe(struct usb_interface *intf, const struct usb_device_id *i hdev->owner = THIS_MODULE; #endif -#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 1) - if (!reset_on_close){ - /* set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks); */ - RTKBT_DBG("%s: Set HCI_QUIRK_RESET_ON_CLOSE", __func__); - } -#endif - /* Interface numbers are hardcoded in the specification */ data->isoc = usb_ifnum_to_if(data->udev, 1); if (data->isoc) { @@ -4270,7 +4693,10 @@ static int btusb_probe(struct usb_interface *intf, const struct usb_device_id *i bt_reset = 0; /* Clear and reset it anyway */ #endif + load_firmware_info(fw_info); + end: + set_driver_state_value(DEVICE_PROBED); return 0; } @@ -4282,7 +4708,11 @@ static void btusb_disconnect(struct usb_interface *intf) if (intf->cur_altsetting->desc.bInterfaceNumber != 0) return; - wait_event_interruptible(bt_dlfw_wait, (check_set_dlfw_state_value(2) == 2)); + clear_driver_state(DEVICE_PROBED); + if((get_driver_state_value() & CHAR_OPENED) == CHAR_OPENED) + wake_up_interruptible(&btchr_read_wait); + + wait_event_interruptible(bt_drv_state_wait, ((get_driver_state_value() & CHAR_OPENED) == 0)); RTKBT_INFO("%s: usb_interface %p, bInterfaceNumber %d", __func__, intf, intf->cur_altsetting->desc.bInterfaceNumber); @@ -4299,13 +4729,7 @@ static void btusb_disconnect(struct usb_interface *intf) #ifdef CONFIG_SCO_OVER_HCI if (intf->cur_altsetting->desc.bInterfaceNumber == 0) { RTK_sco_card_t *pSCOSnd = data->pSCOSnd; - if(!pSCOSnd) { - RTKBT_ERR("%s: sco private data is null", __func__); - return; - } - set_bit(DISCONNECTED, &pSCOSnd->states); - snd_card_disconnect(pSCOSnd->card); - snd_card_free_when_closed(pSCOSnd->card); + btusb_snd_remove(pSCOSnd); } #endif @@ -4347,7 +4771,7 @@ static void btusb_disconnect(struct usb_interface *intf) hci_free_dev(hdev); rtk_free(data); data = NULL; - set_dlfw_state_value(0); + set_driver_state_value(0); } #ifdef CONFIG_PM @@ -4362,8 +4786,12 @@ static int btusb_suspend(struct usb_interface *intf, pm_message_t message) if (intf->cur_altsetting->desc.bInterfaceNumber != 0) return 0; +#if TV_FW_CONFIG +#else if (!test_bit(HCI_RUNNING, &data->hdev->flags)) set_bt_onoff(fw_info, 1); +#endif + if (data->suspend_count++) return 0; @@ -4440,13 +4868,14 @@ static int btusb_resume(struct usb_interface *intf) return 0; /*check_fw_version to check the status of the BT Controller after USB Resume*/ - err = check_fw_version(fw_info); +/* + err = check_fw_version(fw_info, true); if (err !=0) { RTKBT_INFO("%s: BT Controller Power OFF And Return hci_hardware_error:%d", __func__, err); hci_hardware_error(); } - +*/ if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) { err = btusb_submit_intr_urb(hdev, GFP_NOIO); @@ -4516,13 +4945,15 @@ static int __init btusb_init(void) RTKBT_INFO("RTKBT_RELEASE_NAME: %s",RTKBT_RELEASE_NAME); RTKBT_INFO("Realtek Bluetooth USB driver module init, version %s", VERSION); + driver_state = 0; #if CONFIG_BLUEDROID err = btchr_init(); if (err < 0) { /* usb register will go on, even bt char register failed */ RTKBT_ERR("Failed to register usb char device interfaces"); - } else - bt_char_dev_registered = true; + } + else + driver_state |= DRIVER_ON; #endif err = usb_register(&btusb_driver); if (err < 0) @@ -4535,16 +4966,14 @@ static void __exit btusb_exit(void) struct hci_dev *hdev; RTKBT_INFO("Realtek Bluetooth USB driver module exit"); #if CONFIG_BLUEDROID + clear_driver_state(DRIVER_ON); hdev = hci_dev_get(0); - if (bt_char_dev_registered) { - bt_char_dev_registered = false; - while(hdev && atomic_read(&hdev->promisc)) { - RTKBT_ERR("%s: rtkbt driver is being removed, but application is still running!", __func__); - RTKBT_ERR("%s: wait bt application to stop, or the driver can't be removed", __func__); - mdelay(100); - } - btchr_exit(); + while(hdev && atomic_read(&hdev->promisc)) { + RTKBT_ERR("%s: rtkbt driver is being removed, but application is still running!", __func__); + RTKBT_ERR("%s: wait bt application to stop, or the driver can't be removed", __func__); + mdelay(100); } + btchr_exit(); #endif usb_deregister(&btusb_driver); } diff --git a/drivers/bluetooth/rtk_btusb.h b/drivers/bluetooth/rtk_btusb.h index 7f6222ebba59..cc19576455d3 100644 --- a/drivers/bluetooth/rtk_btusb.h +++ b/drivers/bluetooth/rtk_btusb.h @@ -102,6 +102,7 @@ typedef struct RTK_sco_card { #define PRINT_CMD_EVENT 0 #define PRINT_ACL_DATA 0 #define PRINT_SCO_DATA 0 +#define PRINT_ISO_DATA 0 #define RTKBT_DBG_FLAG 0 @@ -165,6 +166,7 @@ int mp_drv_mode = 0; /* 1 Mptool Fw; 0 Normal Fw */ #define ROM_LMP_8723b 0x8723 #define ROM_LMP_8821a 0X8821 #define ROM_LMP_8761a 0X8761 +#define ROM_LMP_8761b 0X8761 #define ROM_LMP_8703a 0x8723 #define ROM_LMP_8763a 0x8763 #define ROM_LMP_8703b 0x8703 @@ -172,6 +174,20 @@ int mp_drv_mode = 0; /* 1 Mptool Fw; 0 Normal Fw */ #define ROM_LMP_8822b 0x8822 #define ROM_LMP_8723d 0x8723 #define ROM_LMP_8821c 0x8821 +#define ROM_LMP_8822c 0x8822 +#define ROM_LMP_8852a 0x8852 +#define ROM_LMP_8723f 0x8723 +#define ROM_LMP_8852b 0x8852 +#define ROM_LMP_8763c 0x8763 +#define ROM_LMP_8773b 0x8773 +#define ROM_LMP_8762a 0x8762 +#define ROM_LMP_8762b 0x8762 +#define ROM_LMP_8852c 0x8852 +#define ROM_LMP_8851a 0x8852 +#define ROM_LMP_8852bp 0x8852 +#define ROM_LMP_8851b 0x8851 +#define ROM_LMP_8822e 0x8822 + /* signature: Realtek */ const uint8_t RTK_EPATCH_SIGNATURE[8] = {0x52,0x65,0x61,0x6C,0x74,0x65,0x63,0x68}; @@ -190,7 +206,32 @@ uint16_t project_id[] = { ROM_LMP_8822b, ROM_LMP_8723d, ROM_LMP_8821c, - ROM_LMP_NONE + ROM_LMP_NONE, + ROM_LMP_NONE, + ROM_LMP_8822c, //0x0d + ROM_LMP_8761b, + ROM_LMP_NONE, + ROM_LMP_NONE, //0x10 + ROM_LMP_NONE, + ROM_LMP_8852a, //0x12 + ROM_LMP_8723f, + ROM_LMP_8852b, + ROM_LMP_8763c, //bbpro2 + ROM_LMP_8773b, //bblite + ROM_LMP_8762a, //bee + ROM_LMP_8762b, //bee2 + ROM_LMP_8852c, + ROM_LMP_NONE, + ROM_LMP_NONE, + ROM_LMP_NONE, + ROM_LMP_NONE, + ROM_LMP_NONE, + ROM_LMP_NONE, + ROM_LMP_NONE, + ROM_LMP_8822e, + ROM_LMP_8852bp,//34 8852bp + ROM_LMP_8851a, + ROM_LMP_8851b }; struct rtk_eversion_evt { uint8_t status; @@ -308,45 +349,16 @@ static inline struct sk_buff *bt_skb_alloc(unsigned int len, gfp_t how) #define HCI_BREDR 0x00 #define HCI_AMP 0x01 +#define DRIVER_ON 1 +#define DEVICE_PROBED 2 +#define CHAR_OPENED 4 +#define CHAR_DLFW 8 + /* HCI device flags */ enum { - HCI_UP, - HCI_INIT, - HCI_RUNNING, - - HCI_PSCAN, - HCI_ISCAN, - HCI_AUTH, - HCI_ENCRYPT, - HCI_INQUIRY, - - HCI_RAW, - - HCI_RESET, -}; - -/* - * BR/EDR and/or LE controller flags: the flags defined here should represent - * states from the controller. - */ -enum { - HCI_SETUP, - HCI_AUTO_OFF, - HCI_MGMT, - HCI_PAIRABLE, - HCI_SERVICE_CACHE, - HCI_LINK_KEYS, - HCI_DEBUG_KEYS, + HCI_UP, //if char device is opened set this flag, clear flag when close + HCI_RUNNING, //if usb transport has opened set this flag, clear flag when close HCI_UNREGISTER, - - HCI_LE_SCAN, - HCI_SSP_ENABLED, - HCI_HS_ENABLED, - HCI_LE_ENABLED, - HCI_CONNECTABLE, - HCI_DISCOVERABLE, - HCI_LINK_SECURITY, - HCI_PENDING_CLASS, }; /* HCI data types */ @@ -354,6 +366,7 @@ enum { #define HCI_ACLDATA_PKT 0x02 #define HCI_SCODATA_PKT 0x03 #define HCI_EVENT_PKT 0x04 +#define HCI_ISODATA_PKT 0x05 #define HCI_VENDOR_PKT 0xff #define HCI_MAX_NAME_LENGTH 248 @@ -380,6 +393,7 @@ struct hci_ev_cmd_complete { #define HCI_EVENT_HDR_SIZE 2 #define HCI_ACL_HDR_SIZE 4 #define HCI_SCO_HDR_SIZE 3 +#define HCI_ISO_HDR_SIZE 4 struct hci_command_hdr { __le16 opcode; /* OCF & OGF */ @@ -401,6 +415,11 @@ struct hci_sco_hdr { __u8 dlen; } __packed; +struct hci_iso_hdr { + __le16 handle; /* Handle & Flags(PB, BC) */ + __le16 dlen; +} __packed; + static inline struct hci_event_hdr *hci_event_hdr(const struct sk_buff *skb) { return (struct hci_event_hdr *) skb->data; @@ -416,6 +435,11 @@ static inline struct hci_sco_hdr *hci_sco_hdr(const struct sk_buff *skb) return (struct hci_sco_hdr *) skb->data; } +static inline struct hci_iso_hdr *hci_iso_hdr(const struct sk_buff *skb) +{ + return (struct hci_iso_hdr *) skb->data; +} + /* ---- HCI Ioctl requests structures ---- */ struct hci_dev_stats { __u32 err_rx; @@ -470,8 +494,6 @@ struct hci_dev { struct device *parent; struct device dev; - unsigned long dev_flags; - int (*open)(struct hci_dev *hdev); int (*close)(struct hci_dev *hdev); int (*flush)(struct hci_dev *hdev); @@ -591,6 +613,7 @@ static inline void hci_set_drvdata(struct hci_dev *hdev, void *data) #define CONFIG_MAC_OFFSET_GEN_1_2 (0x3C) //MAC's OFFSET in config/efuse for realtek generation 1~2 bluetooth chip #define CONFIG_MAC_OFFSET_GEN_3PLUS (0x44) //MAC's OFFSET in config/efuse for rtk generation 3+ bluetooth chip +#define CONFIG_MAC_OFFSET_GEN_4PLUS (0x30) //MAC's OFFSET in config/efuse for rtk generation 4+ bluetooth chip /******************************* ** Reasil patch code @@ -607,8 +630,15 @@ static inline void hci_set_drvdata(struct hci_dev *hdev, void *data) #define CMD_HDR_LEN sizeof(struct hci_command_hdr) #define EVT_HDR_LEN sizeof(struct hci_event_hdr) #define CMD_CMP_LEN sizeof(struct hci_ev_cmd_complete) -#define MAX_PATCH_SIZE_24K (1024*24) -#define MAX_PATCH_SIZE_40K (1024*40) + +#define MAX_PATCH_SIZE_24K (1024*24 + 529) //24K +#define MAX_PATCH_SIZE_25K (1024*25 + 529) //25K for rtl8822b +#define MAX_PATCH_SIZE_40K (1024*40 + 529) //40K +#define MAX_PATCH_SIZE_49_2K (0xC4CF + 529) //49.2K 8723f +#define MAX_PATCH_SIZE_69_2K (0x114D0 + 529) //69.2K 8852a +#define MAX_PATCH_SIZE_65_2K (0x104D0 + 529) //65.2K 8852b +#define MAX_PATCH_SIZE_78K (1024*78 + 529) //78K 8852c +#define MAX_PATCH_SIZE_145K (0x24620) //145K 8822E enum rtk_endpoit { CTRL_EP = 0, @@ -659,14 +689,15 @@ typedef struct { } __attribute__((packed)) download_rp; - -//Define ioctl cmd the same as HCIDEVUP in the kernel -#define DOWN_FW_CFG _IOW('H', 201, int) +#define DOWN_FW_CFG _IOW('E', 176, int) #ifdef CONFIG_SCO_OVER_HCI -#define SET_ISO_CFG _IOW('H', 202, int) +#define SET_ISO_CFG _IOW('E', 177, int) #endif -#define GET_USB_INFO _IOW('H', 203, int) -#define RESET_CONTROLLER _IOW('H', 204, int) +#define RESET_CONTROLLER _IOW('E', 178, int) +#define DWFW_CMPLT _IOW('E', 179, int) + +#define GET_USB_INFO _IOR('E', 180, int) +#define SET_ISO_MIN_HANDLE _IOR('E', 181, int) /* for altsettings*/ #include @@ -675,6 +706,7 @@ typedef struct { static inline int getmacaddr(uint8_t * vnd_local_bd_addr) { +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 14, 14) struct file *bdaddr_file; mm_segment_t oldfs; char buf[FACTORY_BT_BDADDR_STORAGE_LEN]; @@ -710,6 +742,7 @@ static inline int getmacaddr(uint8_t * vnd_local_bd_addr) } return 0; } +#endif return -1; } diff --git a/include/linux/usb.h b/include/linux/usb.h index 75d7cc50b47f..0e7e18849804 100644 --- a/include/linux/usb.h +++ b/include/linux/usb.h @@ -258,6 +258,7 @@ struct usb_interface { struct device dev; /* interface specific device info */ struct device *usb_dev; struct work_struct reset_ws; /* for resets in atomic context */ + atomic_t pm_usage_cnt; ANDROID_KABI_RESERVE(1); ANDROID_KABI_RESERVE(2);