From 18b70b6f5192ee5363515b57e1f213d0698224ed Mon Sep 17 00:00:00 2001 From: "ziv.xu" Date: Tue, 28 Nov 2023 15:37:14 +0800 Subject: [PATCH 113/116] driver: bluetooth: add aic8800 driver support add aic8800 driver that can support sco profile Signed-off-by: ziv.xu --- .../configs/starfive_visionfive2_defconfig | 3 +- drivers/bluetooth/Kconfig | 4 + drivers/bluetooth/Makefile | 1 + drivers/bluetooth/aic_btusb/Makefile | 80 + drivers/bluetooth/aic_btusb/aic_btusb.c | 5031 +++++++++++++++++ drivers/bluetooth/aic_btusb/aic_btusb.h | 753 +++ .../aic_btusb/aic_btusb_external_featrue.c | 126 + .../aic_btusb/aic_btusb_external_featrue.h | 3 + 8 files changed, 5999 insertions(+), 2 deletions(-) create mode 100644 drivers/bluetooth/aic_btusb/Makefile create mode 100644 drivers/bluetooth/aic_btusb/aic_btusb.c create mode 100644 drivers/bluetooth/aic_btusb/aic_btusb.h create mode 100644 drivers/bluetooth/aic_btusb/aic_btusb_external_featrue.c create mode 100644 drivers/bluetooth/aic_btusb/aic_btusb_external_featrue.h --- a/arch/riscv/configs/starfive_visionfive2_defconfig +++ b/arch/riscv/configs/starfive_visionfive2_defconfig @@ -87,8 +87,7 @@ CONFIG_BT_RFCOMM_TTY=y CONFIG_BT_BNEP=y CONFIG_BT_BNEP_MC_FILTER=y CONFIG_BT_BNEP_PROTO_FILTER=y -CONFIG_BT_HCIBTUSB=m -# CONFIG_BT_HCIBTUSB_BCM is not set +CONFIG_BT_AICUSB=y CONFIG_CFG80211=y CONFIG_MAC80211=y CONFIG_RFKILL=y --- a/drivers/bluetooth/Kconfig +++ b/drivers/bluetooth/Kconfig @@ -478,5 +478,9 @@ config BT_NXPUART Say Y here to compile support for NXP Bluetooth UART device into the kernel, or say M here to compile as a module (btnxpuart). +config BT_AICUSB + tristate "AIC8800 btusb driver" + help + AIC8800 usb dongle bluetooth support driver endmenu --- a/drivers/bluetooth/Makefile +++ b/drivers/bluetooth/Makefile @@ -51,3 +51,4 @@ hci_uart-$(CONFIG_BT_HCIUART_QCA) += hci hci_uart-$(CONFIG_BT_HCIUART_AG6XX) += hci_ag6xx.o hci_uart-$(CONFIG_BT_HCIUART_MRVL) += hci_mrvl.o hci_uart-objs := $(hci_uart-y) +obj-$(CONFIG_BT_AICUSB) += aic_btusb/ --- /dev/null +++ b/drivers/bluetooth/aic_btusb/Makefile @@ -0,0 +1,80 @@ +MODULE_NAME = aic_btusb + +CONFIG_AIC8800_BTUSB_SUPPORT = m +CONFIG_SUPPORT_VENDOR_APCF = n +# Need to set fw path in BOARD_KERNEL_CMDLINE +CONFIG_USE_FW_REQUEST = n + +ifeq ($(CONFIG_SUPPORT_VENDOR_APCF), y) +obj-$(CONFIG_AIC8800_BTUSB_SUPPORT) := $(MODULE_NAME).o aic_btusb_external_featrue.o +else +obj-$(CONFIG_AIC8800_BTUSB_SUPPORT) := $(MODULE_NAME).o +endif + +ccflags-$(CONFIG_SUPPORT_VENDOR_APCF) += -DCONFIG_SUPPORT_VENDOR_APCF +#$(MODULE_NAME)-y := aic_btusb_ioctl.o\ +# aic_btusb.o \ + +ccflags-$(CONFIG_USE_FW_REQUEST) += -DCONFIG_USE_FW_REQUEST + + +# Platform support list +CONFIG_PLATFORM_ROCKCHIP ?= n +CONFIG_PLATFORM_ALLWINNER ?= n +CONFIG_PLATFORM_AMLOGIC ?= n +CONFIG_PLATFORM_UBUNTU ?= y +CONFIG_PLATFORM_ING ?= n + +ifeq ($(CONFIG_PLATFORM_ING), y) +ARCH := mips +KDIR ?= /home/yaya/E/Ingenic/T31/Ingenic-SDK-T31-1.1.5-20220428/opensource/kernel +CROSS_COMPILE := /home/yaya/E/Ingenic/T31/Ingenic-SDK-T31-1.1.5-20220428/resource/toolchain/gcc_472/mips-gcc472-glibc216-32bit/bin/mips-linux-gnu- +endif + +ifeq ($(CONFIG_PLATFORM_ROCKCHIP), y) +ccflags-$(CONFIG_PLATFORM_ROCKCHIP) += -DCONFIG_PLATFORM_ROCKCHIP +#KDIR := /home/yaya/E/Rockchip/3229/Android9/rk3229_android9.0_box/kernel +#ARCH ?= arm +#CROSS_COMPILE ?= /home/yaya/E/Rockchip/3229/Android9/rk3229_android9.0_box/prebuilts/gcc/linux-x86/arm/gcc-linaro-6.3.1-2017.05-x86_64_arm-linux-gnueabihf/bin/arm-linux-gnueabihf- +#KDIR := /home/yaya/E/Rockchip/3229/Android7/RK3229_ANDROID7.1_v1.01_20170914/rk3229_Android7.1_v1.01_xml0914/kernel +#ARCH ?= arm +#CROSS_COMPILE ?= /home/yaya/E/Rockchip/3229/Android7/RK3229_ANDROID7.1_v1.01_20170914/rk3229_Android7.1_v1.01_xml0914/prebuilts/gcc/linux-x86/arm/arm-eabi-4.6/bin/arm-eabi- +ARCH := arm64 +KDIR ?= /home/yaya/E/Rockchip/3566/firefly/Android11.0/Firefly-RK356X_Android11.0_git_20210824/RK356X_Android11.0/kernel +CROSS_COMPILE := /home/yaya/E/Rockchip/3566/firefly/Android11.0/Firefly-RK356X_Android11.0_git_20210824/RK356X_Android11.0/prebuilts/gcc/linux-x86/aarch64/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu- + +endif + +ifeq ($(CONFIG_PLATFORM_ALLWINNER), y) +ccflags-$(CONFIG_PLATFORM_ALLWINNER) += -DCONFIG_PLATFORM_ALLWINNER +KDIR := /home/yaya/E/Allwinner/R818/R818/AndroidQ/lichee/kernel/linux-4.9 +ARCH ?= arm64 +CROSS_COMPILE ?= /home/yaya/E/Allwinner/R818/R818/AndroidQ/lichee/out/gcc-linaro-5.3.1-2016.05-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu- +endif + +ifeq ($(CONFIG_PLATFORM_AMLOGIC), y) + ccflags-$(CONFIG_PLATFORM_AMLOGIC) += -DCONFIG_PLATFORM_AMLOGIC +endif + +ifeq ($(CONFIG_PLATFORM_UBUNTU), y) +ccflags-$(CONFIG_PLATFORM_UBUNTU) += -DCONFIG_PLATFORM_UBUNTU +endif + +all: modules +modules: + make -C $(KDIR) M=$(PWD) ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE) modules + +install: + mkdir -p $(MODDESTDIR) + install -p -m 644 $(MODULE_NAME).ko $(MODDESTDIR)/ + /sbin/depmod -a ${KVER} + echo $(MODULE_NAME) >> /etc/modules-load.d/aic_bt.conf + +uninstall: + rm -rfv $(MODDESTDIR)/$(MODULE_NAME).ko + /sbin/depmod -a ${KVER} + rm -f /etc/modules-load.d/aic_bt.conf + +clean: + rm -rf *.o *.ko *.o.* *.mod.* modules.* Module.* .a* .o* .*.o.* *.mod .tmp* .cache.mk .Module.symvers.cmd .modules.order.cmd + --- /dev/null +++ b/drivers/bluetooth/aic_btusb/aic_btusb.c @@ -0,0 +1,5031 @@ +/* + * + * AicSemi Bluetooth USB driver + * + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "aic_btusb.h" + +#ifdef CONFIG_USE_FW_REQUEST +#include +#endif + +#define AICBT_RELEASE_NAME "202012_ANDROID" +#define VERSION "2.1.0" + +#define SUSPNED_DW_FW 0 + + +static spinlock_t queue_lock; +static spinlock_t dlfw_lock; +static volatile uint16_t dlfw_dis_state = 0; + +/* USB Device ID */ +#define USB_VENDOR_ID_AIC 0xA69C +#define USB_PRODUCT_ID_AIC8801 0x8801 +#define USB_PRODUCT_ID_AIC8800DC 0x88dc +#define USB_PRODUCT_ID_AIC8800D80 0x8d81 + +enum AICWF_IC{ + PRODUCT_ID_AIC8801 = 0, + PRODUCT_ID_AIC8800DC, + PRODUCT_ID_AIC8800DW, + PRODUCT_ID_AIC8800D80 +}; + +u16 g_chipid = PRODUCT_ID_AIC8801; +u8 chip_id = 0; +u8 sub_chip_id = 0; + +struct btusb_data { + struct hci_dev *hdev; + struct usb_device *udev; + struct usb_interface *intf; + struct usb_interface *isoc; + + spinlock_t lock; + + unsigned long flags; + + struct work_struct work; + struct work_struct waker; + + struct usb_anchor tx_anchor; + struct usb_anchor intr_anchor; + struct usb_anchor bulk_anchor; + struct usb_anchor isoc_anchor; + struct usb_anchor deferred; + int tx_in_flight; + spinlock_t txlock; + +#if (CONFIG_BLUEDROID == 0) +#if HCI_VERSION_CODE >= KERNEL_VERSION(3, 18, 0) + spinlock_t rxlock; + struct sk_buff *evt_skb; + struct sk_buff *acl_skb; + struct sk_buff *sco_skb; +#endif +#endif + + struct usb_endpoint_descriptor *intr_ep; + struct usb_endpoint_descriptor *bulk_tx_ep; + struct usb_endpoint_descriptor *bulk_rx_ep; + struct usb_endpoint_descriptor *isoc_tx_ep; + struct usb_endpoint_descriptor *isoc_rx_ep; + + __u8 cmdreq_type; + + unsigned int sco_num; + int isoc_altsetting; + int suspend_count; + uint16_t sco_handle; + +#if (CONFIG_BLUEDROID == 0) +#if HCI_VERSION_CODE >= KERNEL_VERSION(3, 18, 0) + int (*recv_bulk) (struct btusb_data * data, void *buffer, int count); +#endif +#endif + +//#ifdef CONFIG_HAS_EARLYSUSPEND +#if 0 + struct early_suspend early_suspend; +#else + struct notifier_block pm_notifier; + struct notifier_block reboot_notifier; +#endif + firmware_info *fw_info; + +#ifdef CONFIG_SCO_OVER_HCI + AIC_sco_card_t *pSCOSnd; +#endif +}; +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 1) +static bool reset_on_close = 0; +#endif + +#ifdef CONFIG_SCO_OVER_HCI +struct snd_sco_cap_timer { + struct timer_list cap_timer; + struct timer_list play_timer; + struct btusb_data snd_usb_data; + int snd_sco_length; +}; +static struct snd_sco_cap_timer snd_cap_timer; +#endif + + +int bt_support = 0; +module_param(bt_support, int, 0660); + +#ifdef CONFIG_SUPPORT_VENDOR_APCF +int vendor_apcf_sent_done = 0; +#endif + +static inline int check_set_dlfw_state_value(uint16_t change_value) +{ + spin_lock(&dlfw_lock); + if(!dlfw_dis_state) { + dlfw_dis_state = change_value; + } + spin_unlock(&dlfw_lock); + return dlfw_dis_state; +} + +static inline void set_dlfw_state_value(uint16_t change_value) +{ + spin_lock(&dlfw_lock); + dlfw_dis_state = change_value; + spin_unlock(&dlfw_lock); +} + + + + +static void aic_free( struct btusb_data *data) +{ +#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 1) + kfree(data); +#endif + return; +} + +static struct btusb_data *aic_alloc(struct usb_interface *intf) +{ + struct btusb_data *data; +#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 1) + data = kzalloc(sizeof(*data), GFP_KERNEL); +#else + data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL); +#endif + return data; +} + +static void print_acl(struct sk_buff *skb, int direction) +{ +#if PRINT_ACL_DATA + //uint wlength = skb->len; + u16 *handle = (u16 *)(skb->data); + u16 len = *(handle+1); + //u8 *acl_data = (u8 *)(skb->data); + + AICBT_INFO("aic %s: direction %d, handle %04x, len %d", + __func__, direction, *handle, len); +#endif +} + +static void print_sco(struct sk_buff *skb, int direction) +{ +#if PRINT_SCO_DATA + uint wlength = skb->len; + u16 *handle = (u16 *)(skb->data); + u8 len = *(u8 *)(handle+1); + //u8 *sco_data =(u8 *)(skb->data); + + AICBT_INFO("aic %s: direction %d, handle %04x, len %d,wlength %d", + __func__, direction, *handle, len,wlength); +#endif +} + +static void print_error_command(struct sk_buff *skb) +{ + u16 *opcode = (u16*)(skb->data); + u8 *cmd_data = (u8*)(skb->data); + u8 len = *(cmd_data+2); + + printk(" 0x%04x,len:%d,", *opcode, len); +#if CONFIG_BLUEDROID + switch (*opcode) { + case HCI_OP_INQUIRY: + printk("HCI_OP_INQUIRY"); + break; + case HCI_OP_INQUIRY_CANCEL: + printk("HCI_OP_INQUIRY_CANCEL"); + break; + case HCI_OP_EXIT_PERIODIC_INQ: + printk("HCI_OP_EXIT_PERIODIC_INQ"); + break; + case HCI_OP_CREATE_CONN: + printk("HCI_OP_CREATE_CONN"); + break; + case HCI_OP_DISCONNECT: + printk("HCI_OP_DISCONNECT"); + break; + case HCI_OP_CREATE_CONN_CANCEL: + printk("HCI_OP_CREATE_CONN_CANCEL"); + break; + case HCI_OP_ACCEPT_CONN_REQ: + printk("HCI_OP_ACCEPT_CONN_REQ"); + break; + case HCI_OP_REJECT_CONN_REQ: + printk("HCI_OP_REJECT_CONN_REQ"); + break; + case HCI_OP_AUTH_REQUESTED: + printk("HCI_OP_AUTH_REQUESTED"); + break; + case HCI_OP_SET_CONN_ENCRYPT: + printk("HCI_OP_SET_CONN_ENCRYPT"); + break; + case HCI_OP_REMOTE_NAME_REQ: + printk("HCI_OP_REMOTE_NAME_REQ"); + break; + case HCI_OP_READ_REMOTE_FEATURES: + printk("HCI_OP_READ_REMOTE_FEATURES"); + break; + case HCI_OP_SNIFF_MODE: + printk("HCI_OP_SNIFF_MODE"); + break; + case HCI_OP_EXIT_SNIFF_MODE: + printk("HCI_OP_EXIT_SNIFF_MODE"); + break; + case HCI_OP_SWITCH_ROLE: + printk("HCI_OP_SWITCH_ROLE"); + break; + case HCI_OP_SNIFF_SUBRATE: + printk("HCI_OP_SNIFF_SUBRATE"); + break; + case HCI_OP_RESET: + printk("HCI_OP_RESET"); + break; + case HCI_OP_Write_Extended_Inquiry_Response: + printk("HCI_Write_Extended_Inquiry_Response"); + break; + case HCI_OP_Write_Simple_Pairing_Mode: + printk("HCI_OP_Write_Simple_Pairing_Mode"); + break; + case HCI_OP_Read_Buffer_Size: + printk("HCI_OP_Read_Buffer_Size"); + break; + case HCI_OP_Host_Buffer_Size: + printk("HCI_OP_Host_Buffer_Size"); + break; + case HCI_OP_Read_Local_Version_Information: + printk("HCI_OP_Read_Local_Version_Information"); + break; + case HCI_OP_Read_BD_ADDR: + printk("HCI_OP_Read_BD_ADDR"); + break; + case HCI_OP_Read_Local_Supported_Commands: + printk("HCI_OP_Read_Local_Supported_Commands"); + break; + case HCI_OP_Write_Scan_Enable: + printk("HCI_OP_Write_Scan_Enable"); + break; + case HCI_OP_Write_Current_IAC_LAP: + printk("HCI_OP_Write_Current_IAC_LAP"); + break; + case HCI_OP_Write_Inquiry_Scan_Activity: + printk("HCI_OP_Write_Inquiry_Scan_Activity"); + break; + case HCI_OP_Write_Class_of_Device: + printk("HCI_OP_Write_Class_of_Device"); + break; + case HCI_OP_LE_Rand: + printk("HCI_OP_LE_Rand"); + break; + case HCI_OP_LE_Set_Random_Address: + printk("HCI_OP_LE_Set_Random_Address"); + break; + case HCI_OP_LE_Set_Extended_Scan_Enable: + printk("HCI_OP_LE_Set_Extended_Scan_Enable"); + break; + case HCI_OP_LE_Set_Extended_Scan_Parameters: + printk("HCI_OP_LE_Set_Extended_Scan_Parameters"); + break; + case HCI_OP_Set_Event_Filter: + printk("HCI_OP_Set_Event_Filter"); + break; + case HCI_OP_Write_Voice_Setting: + printk("HCI_OP_Write_Voice_Setting"); + break; + case HCI_OP_Change_Local_Name: + printk("HCI_OP_Change_Local_Name"); + break; + case HCI_OP_Read_Local_Name: + printk("HCI_OP_Read_Local_Name"); + break; + case HCI_OP_Wirte_Page_Timeout: + printk("HCI_OP_Wirte_Page_Timeout"); + break; + case HCI_OP_LE_Clear_Resolving_List: + printk("HCI_OP_LE_Clear_Resolving_List"); + break; + case HCI_OP_LE_Set_Addres_Resolution_Enable_Command: + printk("HCI_OP_LE_Set_Addres_Resolution_Enable_Command"); + break; + case HCI_OP_Write_Inquiry_mode: + printk("HCI_OP_Write_Inquiry_mode"); + break; + case HCI_OP_Write_Page_Scan_Type: + printk("HCI_OP_Write_Page_Scan_Type"); + break; + case HCI_OP_Write_Inquiry_Scan_Type: + printk("HCI_OP_Write_Inquiry_Scan_Type"); + break; + case HCI_OP_Delete_Stored_Link_Key: + printk("HCI_OP_Delete_Stored_Link_Key"); + break; + case HCI_OP_LE_Read_Local_Resolvable_Address: + printk("HCI_OP_LE_Read_Local_Resolvable_Address"); + break; + case HCI_OP_LE_Extended_Create_Connection: + printk("HCI_OP_LE_Extended_Create_Connection"); + break; + case HCI_OP_Read_Remote_Version_Information: + printk("HCI_OP_Read_Remote_Version_Information"); + break; + case HCI_OP_LE_Start_Encryption: + printk("HCI_OP_LE_Start_Encryption"); + break; + case HCI_OP_LE_Add_Device_to_Resolving_List: + printk("HCI_OP_LE_Add_Device_to_Resolving_List"); + break; + case HCI_OP_LE_Set_Privacy_Mode: + printk("HCI_OP_LE_Set_Privacy_Mode"); + break; + case HCI_OP_LE_Connection_Update: + printk("HCI_OP_LE_Connection_Update"); + break; + default: + printk("UNKNOW_HCI_COMMAND"); + break; + } +#endif //CONFIG_BLUEDROID +} + +static void print_command(struct sk_buff *skb) +{ +#if PRINT_CMD_EVENT + print_error_command(skb); +#endif +} + + +enum CODEC_TYPE{ + CODEC_CVSD, + CODEC_MSBC, +}; + +static enum CODEC_TYPE codec_type = CODEC_CVSD; +static void set_select_msbc(enum CODEC_TYPE type); +static enum CODEC_TYPE check_select_msbc(void); + + +#if CONFIG_BLUEDROID + +/* Global parameters for bt usb char driver */ +#define BT_CHAR_DEVICE_NAME "aicbt_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 int bt_char_dev_registered; +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 */ +static int bt_reset = 0; + +/* HCI device & lock */ +DEFINE_RWLOCK(hci_dev_lock); +struct hci_dev *ghdev = NULL; + +#ifdef CONFIG_SUPPORT_VENDOR_APCF +static int bypass_event(struct sk_buff *skb) +{ + int ret = 0; + u8 *opcode = (u8*)(skb->data); + //u8 len = *(opcode+1); + u16 sub_opcpde; + + switch(*opcode) { + case HCI_EV_CMD_COMPLETE: + sub_opcpde = ((u16)opcode[3]|(u16)(opcode[4])<<8); + if(sub_opcpde == 0xfd57){ + if(vendor_apcf_sent_done){ + vendor_apcf_sent_done--; + printk("apcf bypass\r\n"); + ret = 1; + } + } + break; + default: + break; + } + return ret; +} +#endif//CONFIG_SUPPORT_VENDOR_APCF +static void print_event(struct sk_buff *skb) +{ +#if PRINT_CMD_EVENT + //uint wlength = skb->len; + //uint icount = 0; + u8 *opcode = (u8*)(skb->data); + //u8 len = *(opcode+1); + + printk("aic %s ", __func__); + switch (*opcode) { + case HCI_EV_INQUIRY_COMPLETE: + printk("HCI_EV_INQUIRY_COMPLETE"); + break; + case HCI_EV_INQUIRY_RESULT: + printk("HCI_EV_INQUIRY_RESULT"); + break; + case HCI_EV_CONN_COMPLETE: + printk("HCI_EV_CONN_COMPLETE"); + break; + case HCI_EV_CONN_REQUEST: + printk("HCI_EV_CONN_REQUEST"); + break; + case HCI_EV_DISCONN_COMPLETE: + printk("HCI_EV_DISCONN_COMPLETE"); + break; + case HCI_EV_AUTH_COMPLETE: + printk("HCI_EV_AUTH_COMPLETE"); + break; + case HCI_EV_REMOTE_NAME: + printk("HCI_EV_REMOTE_NAME"); + break; + case HCI_EV_ENCRYPT_CHANGE: + printk("HCI_EV_ENCRYPT_CHANGE"); + break; + case HCI_EV_CHANGE_LINK_KEY_COMPLETE: + printk("HCI_EV_CHANGE_LINK_KEY_COMPLETE"); + break; + case HCI_EV_REMOTE_FEATURES: + printk("HCI_EV_REMOTE_FEATURES"); + break; + case HCI_EV_REMOTE_VERSION: + printk("HCI_EV_REMOTE_VERSION"); + break; + case HCI_EV_QOS_SETUP_COMPLETE: + printk("HCI_EV_QOS_SETUP_COMPLETE"); + break; + case HCI_EV_CMD_COMPLETE: + printk("HCI_EV_CMD_COMPLETE"); + break; + case HCI_EV_CMD_STATUS: + printk("HCI_EV_CMD_STATUS"); + break; + case HCI_EV_ROLE_CHANGE: + printk("HCI_EV_ROLE_CHANGE"); + break; + case HCI_EV_NUM_COMP_PKTS: + printk("HCI_EV_NUM_COMP_PKTS"); + break; + case HCI_EV_MODE_CHANGE: + printk("HCI_EV_MODE_CHANGE"); + break; + case HCI_EV_PIN_CODE_REQ: + printk("HCI_EV_PIN_CODE_REQ"); + break; + case HCI_EV_LINK_KEY_REQ: + printk("HCI_EV_LINK_KEY_REQ"); + break; + case HCI_EV_LINK_KEY_NOTIFY: + printk("HCI_EV_LINK_KEY_NOTIFY"); + break; + case HCI_EV_CLOCK_OFFSET: + printk("HCI_EV_CLOCK_OFFSET"); + break; + case HCI_EV_PKT_TYPE_CHANGE: + printk("HCI_EV_PKT_TYPE_CHANGE"); + break; + case HCI_EV_PSCAN_REP_MODE: + printk("HCI_EV_PSCAN_REP_MODE"); + break; + case HCI_EV_INQUIRY_RESULT_WITH_RSSI: + printk("HCI_EV_INQUIRY_RESULT_WITH_RSSI"); + break; + case HCI_EV_REMOTE_EXT_FEATURES: + printk("HCI_EV_REMOTE_EXT_FEATURES"); + break; + case HCI_EV_SYNC_CONN_COMPLETE: + printk("HCI_EV_SYNC_CONN_COMPLETE"); + break; + case HCI_EV_SYNC_CONN_CHANGED: + printk("HCI_EV_SYNC_CONN_CHANGED"); + break; + case HCI_EV_SNIFF_SUBRATE: + printk("HCI_EV_SNIFF_SUBRATE"); + break; + case HCI_EV_EXTENDED_INQUIRY_RESULT: + printk("HCI_EV_EXTENDED_INQUIRY_RESULT"); + break; + case HCI_EV_IO_CAPA_REQUEST: + printk("HCI_EV_IO_CAPA_REQUEST"); + break; + case HCI_EV_SIMPLE_PAIR_COMPLETE: + printk("HCI_EV_SIMPLE_PAIR_COMPLETE"); + break; + case HCI_EV_REMOTE_HOST_FEATURES: + printk("HCI_EV_REMOTE_HOST_FEATURES"); + break; + default: + printk("unknow event"); + break; + } + printk("\n"); +#if 0 + printk("%02x,len:%d,", *opcode,len); + for (icount = 2; (icount < wlength) && (icount < 24); icount++) + printk("%02x ", *(opcode+icount)); + printk("\n"); +#endif +#endif +} + +static inline ssize_t usb_put_user(struct sk_buff *skb, + char __user *buf, int count) +{ + char __user *ptr = buf; + int len = min_t(unsigned int, skb->len, count); + + if (copy_to_user(ptr, skb->data, len)) + return -EFAULT; + + return len; +} + +static struct sk_buff *aic_skb_queue[QUEUE_SIZE]; +static int aic_skb_queue_front = 0; +static int aic_skb_queue_rear = 0; + +static void aic_enqueue(struct sk_buff *skb) +{ + spin_lock(&queue_lock); + if (aic_skb_queue_front == (aic_skb_queue_rear + 1) % QUEUE_SIZE) { + /* + * If queue is full, current solution is to drop + * the following entries. + */ + AICBT_WARN("%s: Queue is full, entry will be dropped", __func__); + } else { + aic_skb_queue[aic_skb_queue_rear] = skb; + + aic_skb_queue_rear++; + aic_skb_queue_rear %= QUEUE_SIZE; + + } + spin_unlock(&queue_lock); +} + +static struct sk_buff *aic_dequeue_try(unsigned int deq_len) +{ + struct sk_buff *skb; + struct sk_buff *skb_copy; + + if (aic_skb_queue_front == aic_skb_queue_rear) { + AICBT_WARN("%s: Queue is empty", __func__); + return NULL; + } + + skb = aic_skb_queue[aic_skb_queue_front]; + if (deq_len >= skb->len) { + + aic_skb_queue_front++; + aic_skb_queue_front %= QUEUE_SIZE; + + /* + * Return skb addr to be dequeued, and the caller + * should free the skb eventually. + */ + return skb; + } else { + skb_copy = pskb_copy(skb, GFP_ATOMIC); + skb_pull(skb, deq_len); + /* Return its copy to be freed */ + return skb_copy; + } +} + +static inline int is_queue_empty(void) +{ + return (aic_skb_queue_front == aic_skb_queue_rear) ? 1 : 0; +} + +static void aic_clear_queue(void) +{ + struct sk_buff *skb; + spin_lock(&queue_lock); + while(!is_queue_empty()) { + skb = aic_skb_queue[aic_skb_queue_front]; + aic_skb_queue[aic_skb_queue_front] = NULL; + aic_skb_queue_front++; + aic_skb_queue_front %= QUEUE_SIZE; + if (skb) { + kfree_skb(skb); + } + } + spin_unlock(&queue_lock); +} + +/* + * AicSemi - Integrate from hci_core.c + */ + +/* Get HCI device by index. + * Device is held on return. */ +static struct hci_dev *hci_dev_get(int index) +{ + if (index != 0) + return NULL; + + return ghdev; +} + +/* ---- HCI ioctl helpers ---- */ +static int hci_dev_open(__u16 dev) +{ + struct hci_dev *hdev; + int ret = 0; + + AICBT_DBG("%s: dev %d", __func__, dev); + + hdev = hci_dev_get(dev); + if (!hdev) { + AICBT_ERR("%s: Failed to get hci dev[Null]", __func__); + return -ENODEV; + } + + if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { + ret = -ENODEV; + goto done; + } + + if (test_bit(HCI_UP, &hdev->flags)) { + ret = -EALREADY; + goto done; + } + +done: + return ret; +} + +static int hci_dev_do_close(struct hci_dev *hdev) +{ + if (hdev->flush) + hdev->flush(hdev); + /* After this point our queues are empty + * and no tasks are scheduled. */ + hdev->close(hdev); + /* Clear flags */ + hdev->flags = 0; + return 0; +} + +static int hci_dev_close(__u16 dev) +{ + struct hci_dev *hdev; + int err; + hdev = hci_dev_get(dev); + if (!hdev) { + AICBT_ERR("%s: failed to get hci dev[Null]", __func__); + return -ENODEV; + } + + err = hci_dev_do_close(hdev); + + return err; +} + +#ifdef CONFIG_SCO_OVER_HCI +/* copy data from the URB buffer into the ALSA ring buffer */ +static bool aic_copy_capture_data_to_alsa(struct btusb_data *data, uint8_t* p_data, unsigned int frames) +{ + struct snd_pcm_runtime *runtime; + unsigned int frame_bytes, frames1; + u8 *dest; + AIC_sco_card_t *pSCOSnd = data->pSCOSnd; + + runtime = pSCOSnd->capture.substream->runtime; + frame_bytes = 2; + + dest = runtime->dma_area + pSCOSnd->capture.buffer_pos * frame_bytes; + if (pSCOSnd->capture.buffer_pos + frames <= runtime->buffer_size) { + memcpy(dest, p_data, frames * frame_bytes); + } else { + /* wrap around at end of ring buffer */ + frames1 = runtime->buffer_size - pSCOSnd->capture.buffer_pos; + memcpy(dest, p_data, frames1 * frame_bytes); + memcpy(runtime->dma_area, + p_data + frames1 * frame_bytes, + (frames - frames1) * frame_bytes); + } + + pSCOSnd->capture.buffer_pos += frames; + if (pSCOSnd->capture.buffer_pos >= runtime->buffer_size) { + pSCOSnd->capture.buffer_pos -= runtime->buffer_size; + } + + if((pSCOSnd->capture.buffer_pos%runtime->period_size) == 0) { + snd_pcm_period_elapsed(pSCOSnd->capture.substream); + } + + return false; +} + + +static void hci_send_to_alsa_ringbuffer(struct hci_dev *hdev, struct sk_buff *skb) +{ + struct btusb_data *data = GET_DRV_DATA(hdev); + AIC_sco_card_t *pSCOSnd = data->pSCOSnd; + uint8_t* p_data; + int sco_length = skb->len - HCI_SCO_HDR_SIZE; + u16 *handle = (u16 *) (skb->data); + //u8 errflg = (u8)((*handle & 0x3000) >> 12); + + pSCOSnd->usb_data->sco_handle = (*handle & 0x0fff); + + AICBT_DBG("%s, %x, %x %x\n", __func__,pSCOSnd->usb_data->sco_handle, *handle, errflg); + + if (!hdev) { + AICBT_INFO("%s: Frame for unknown HCI device", __func__); + return; + } + + if (!test_bit(ALSA_CAPTURE_RUNNING, &pSCOSnd->states)) { + AICBT_INFO("%s: ALSA is not running", __func__); + return; + } + snd_cap_timer.snd_sco_length = sco_length; + p_data = (uint8_t *)skb->data + HCI_SCO_HDR_SIZE; + aic_copy_capture_data_to_alsa(data, p_data, sco_length/2); +} + +#endif + +#if CONFIG_BLUEDROID +static struct hci_dev *hci_alloc_dev(void) +{ + struct hci_dev *hdev; + + hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); + if (!hdev) + return NULL; + + return hdev; +} + +/* Free HCI device */ +static void hci_free_dev(struct hci_dev *hdev) +{ + kfree(hdev); +} + +/* Register HCI device */ +static int hci_register_dev(struct hci_dev *hdev) +{ + int i, id; + + AICBT_DBG("%s: %p name %s bus %d", __func__, hdev, hdev->name, hdev->bus); + /* Do not allow HCI_AMP devices to register at index 0, + * so the index can be used as the AMP controller ID. + */ + id = (hdev->dev_type == HCI_BREDR) ? 0 : 1; + + write_lock(&hci_dev_lock); + + sprintf(hdev->name, "hci%d", id); + hdev->id = id; + hdev->flags = 0; + hdev->dev_flags = 0; + mutex_init(&hdev->lock); + + AICBT_DBG("%s: id %d, name %s", __func__, hdev->id, hdev->name); + + + for (i = 0; i < NUM_REASSEMBLY; i++) + hdev->reassembly[i] = NULL; + + memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); + atomic_set(&hdev->promisc, 0); + + if (ghdev) { + write_unlock(&hci_dev_lock); + AICBT_ERR("%s: Hci device has been registered already", __func__); + return -1; + } else + ghdev = hdev; + + write_unlock(&hci_dev_lock); + + return id; +} + +/* Unregister HCI device */ +static void hci_unregister_dev(struct hci_dev *hdev) +{ + int i; + + AICBT_DBG("%s: hdev %p name %s bus %d", __func__, hdev, hdev->name, hdev->bus); + set_bit(HCI_UNREGISTER, &hdev->dev_flags); + + write_lock(&hci_dev_lock); + ghdev = NULL; + write_unlock(&hci_dev_lock); + + hci_dev_do_close(hdev); + for (i = 0; i < NUM_REASSEMBLY; i++) + kfree_skb(hdev->reassembly[i]); +} + +static void hci_send_to_stack(struct hci_dev *hdev, struct sk_buff *skb) +{ + struct sk_buff *aic_skb_copy = NULL; + + //AICBT_DBG("%s", __func__); + + if (!hdev) { + AICBT_ERR("%s: Frame for unknown HCI device", __func__); + return; + } + + if (!test_bit(HCI_RUNNING, &hdev->flags)) { + AICBT_ERR("%s: HCI not running", __func__); + return; + } + + aic_skb_copy = pskb_copy(skb, GFP_ATOMIC); + if (!aic_skb_copy) { + AICBT_ERR("%s: Copy skb error", __func__); + return; + } + + memcpy(skb_push(aic_skb_copy, 1), &bt_cb(skb)->pkt_type, 1); + aic_enqueue(aic_skb_copy); + + /* Make sure bt char device existing before wakeup read queue */ + hdev = hci_dev_get(0); + if (hdev) { + //AICBT_DBG("%s: Try to wakeup read queue", __func__); + AICBT_DBG("%s", __func__); + wake_up_interruptible(&btchr_read_wait); + } + + + return; +} + +/* Receive frame from HCI drivers */ +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))) { + 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); + }else{ +#ifdef CONFIG_SUPPORT_VENDOR_APCF + if(bt_cb(skb)->pkt_type == HCI_EVENT_PKT){ + if(bypass_event(skb)){ + kfree_skb(skb); + return 0; + } + } +#endif //CONFIG_SUPPORT_VENDOR_APCF + hci_send_to_stack(hdev, skb); + } +#else +#ifdef CONFIG_SUPPORT_VENDOR_APCF + if(bt_cb(skb)->pkt_type == HCI_EVENT_PKT){ + if(bypass_event(skb)){ + kfree_skb(skb); + return 0; + } + } +#endif //CONFIG_SUPPORT_VENDOR_APCF + /* Send copy to the sockets */ + hci_send_to_stack(hdev, skb); +#endif + + } + + kfree_skb(skb); + return 0; +} + + + +static int hci_reassembly(struct hci_dev *hdev, int type, void *data, + int count, __u8 index) +{ + int len = 0; + int hlen = 0; + int remain = count; + struct sk_buff *skb; + struct bt_skb_cb *scb; + + //AICBT_DBG("%s", __func__); + + if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || + index >= NUM_REASSEMBLY) + return -EILSEQ; + + skb = hdev->reassembly[index]; + + if (!skb) { + switch (type) { + case HCI_ACLDATA_PKT: + len = HCI_MAX_FRAME_SIZE; + hlen = HCI_ACL_HDR_SIZE; + break; + case HCI_EVENT_PKT: + len = HCI_MAX_EVENT_SIZE; + hlen = HCI_EVENT_HDR_SIZE; + break; + case HCI_SCODATA_PKT: + len = HCI_MAX_SCO_SIZE; + hlen = HCI_SCO_HDR_SIZE; + break; + } + + skb = bt_skb_alloc(len, GFP_ATOMIC); + if (!skb) + return -ENOMEM; + + scb = (void *) skb->cb; + scb->expect = hlen; + scb->pkt_type = type; + + skb->dev = (void *) hdev; + hdev->reassembly[index] = skb; + } + + while (count) { + scb = (void *) skb->cb; + len = min_t(uint, scb->expect, count); + + memcpy(skb_put(skb, len), data, len); + + count -= len; + data += len; + scb->expect -= len; + remain = count; + + switch (type) { + case HCI_EVENT_PKT: + if (skb->len == HCI_EVENT_HDR_SIZE) { + struct hci_event_hdr *h = hci_event_hdr(skb); + scb->expect = h->plen; + + if (skb_tailroom(skb) < scb->expect) { + kfree_skb(skb); + hdev->reassembly[index] = NULL; + return -ENOMEM; + } + } + break; + + case HCI_ACLDATA_PKT: + if (skb->len == HCI_ACL_HDR_SIZE) { + struct hci_acl_hdr *h = hci_acl_hdr(skb); + scb->expect = __le16_to_cpu(h->dlen); + + if (skb_tailroom(skb) < scb->expect) { + kfree_skb(skb); + hdev->reassembly[index] = NULL; + return -ENOMEM; + } + } + break; + + case HCI_SCODATA_PKT: + if (skb->len == HCI_SCO_HDR_SIZE) { + struct hci_sco_hdr *h = hci_sco_hdr(skb); + scb->expect = h->dlen; + + if (skb_tailroom(skb) < scb->expect) { + kfree_skb(skb); + hdev->reassembly[index] = NULL; + return -ENOMEM; + } + } + break; + } + + if (scb->expect == 0) { + /* Complete frame */ + if(HCI_ACLDATA_PKT == type) + print_acl(skb,0); + if(HCI_SCODATA_PKT == type) + print_sco(skb,0); + if(HCI_EVENT_PKT == type) + print_event(skb); + + bt_cb(skb)->pkt_type = type; + hci_recv_frame(skb); + + hdev->reassembly[index] = NULL; + return remain; + } + } + + return remain; +} + +static int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) +{ + int rem = 0; + + if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) + return -EILSEQ; + + while (count) { + rem = hci_reassembly(hdev, type, data, count, type - 1); + if (rem < 0) + return rem; + + data += (count - rem); + count = rem; + } + + return rem; +} +#endif //CONFIG_BLUEDROID + +void hci_hardware_error(void) +{ + struct sk_buff *aic_skb_copy = NULL; + int len = 3; + uint8_t hardware_err_pkt[4] = {HCI_EVENT_PKT, 0x10, 0x01, HCI_VENDOR_USB_DISC_HARDWARE_ERROR}; + + aic_skb_copy = alloc_skb(len, GFP_ATOMIC); + if (!aic_skb_copy) { + AICBT_ERR("%s: Failed to allocate mem", __func__); + return; + } + + memcpy(skb_put(aic_skb_copy, len), hardware_err_pkt, len); + aic_enqueue(aic_skb_copy); + + wake_up_interruptible(&btchr_read_wait); +} + +static int btchr_open(struct inode *inode_p, struct file *file_p) +{ + struct btusb_data *data; + struct hci_dev *hdev; + + AICBT_DBG("%s: BT usb char device is opening", __func__); + /* Not open unless wanna tracing log */ + /* trace_printk("%s: open....\n", __func__); */ + + hdev = hci_dev_get(0); + if (!hdev) { + AICBT_DBG("%s: Failed to get hci dev[NULL]", __func__); + return -ENODEV; + } + data = GET_DRV_DATA(hdev); + + atomic_inc(&hdev->promisc); + /* + * As bt device is not re-opened when hotplugged out, we cannot + * trust on file's private data(may be null) when other file ops + * are invoked. + */ + file_p->private_data = data; + + mutex_lock(&btchr_mutex); + hci_dev_open(0); + mutex_unlock(&btchr_mutex); + + aic_clear_queue(); + return nonseekable_open(inode_p, file_p); +} + +static int btchr_close(struct inode *inode_p, struct file *file_p) +{ + struct btusb_data *data; + struct hci_dev *hdev; + + AICBT_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; + +#if CONFIG_BLUEDROID + /* + * If the upper layer closes bt char interfaces, no reset + * action required even bt device hotplugged out. + */ + 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); + } + + return 0; +} + +static ssize_t btchr_read(struct file *file_p, + char __user *buf_p, + size_t count, + loff_t *pos_p) +{ + struct hci_dev *hdev; + struct sk_buff *skb; + ssize_t ret = 0; + + while (count) { + hdev = hci_dev_get(0); + if (!hdev) { + /* + * Note: Only when BT device hotplugged out, we wil get + * into such situation. In order to keep the upper layer + * stack alive (blocking the read), we should never return + * EFAULT or break the loop. + */ + AICBT_ERR("%s: Failed to get hci dev[Null]", __func__); + } + + ret = wait_event_interruptible(btchr_read_wait, !is_queue_empty()); + if (ret < 0) { + AICBT_ERR("%s: wait event is signaled %d", __func__, (int)ret); + break; + } + + skb = aic_dequeue_try(count); + if (skb) { + ret = usb_put_user(skb, buf_p, count); + if (ret < 0) + AICBT_ERR("%s: Failed to put data to user space", __func__); + kfree_skb(skb); + break; + } + } + + return ret; +} + +#ifdef CONFIG_SUPPORT_VENDOR_APCF +void btchr_external_write(char* buff, int len){ + struct hci_dev *hdev; + struct sk_buff *skb; + int i; + struct btusb_data *data; + + AICBT_INFO("%s \r\n", __func__); + for(i=0;idev = (void *)hdev; + memcpy((__u8 *)skb->data,(__u8 *)buff,len); + skb_put(skb, len); + bt_cb(skb)->pkt_type = *((__u8 *)skb->data); + skb_pull(skb, 1); + data->hdev->send(skb); +} + +EXPORT_SYMBOL(btchr_external_write); +#endif //CONFIG_SUPPORT_VENDOR_APCF + +static ssize_t btchr_write(struct file *file_p, + const char __user *buf_p, + size_t count, + loff_t *pos_p) +{ + struct btusb_data *data = file_p->private_data; + struct hci_dev *hdev; + struct sk_buff *skb; + + //AICBT_DBG("%s: BT usb char device is writing", __func__); + AICBT_DBG("%s", __func__); + + hdev = hci_dev_get(0); + if (!hdev) { + AICBT_WARN("%s: Failed to get hci dev[Null]", __func__); + /* + * Note: we bypass the data from the upper layer if bt device + * is hotplugged out. Fortunatelly, H4 or H5 HCI stack does + * NOT check btchr_write's return value. However, returning + * count instead of EFAULT is preferable. + */ + /* return -EFAULT; */ + return count; + } + + /* Never trust on btusb_data, as bt device may be hotplugged out */ + data = GET_DRV_DATA(hdev); + if (!data) { + AICBT_WARN("%s: Failed to get bt usb driver data[Null]", __func__); + return count; + } + + if (count > HCI_MAX_FRAME_SIZE) + return -EINVAL; + + skb = bt_skb_alloc(count, GFP_ATOMIC); + if (!skb) + return -ENOMEM; + skb_reserve(skb, -1); // Add this line + + if (copy_from_user(skb_put(skb, count), buf_p, count)) { + AICBT_ERR("%s: Failed to get data from user space", __func__); + kfree_skb(skb); + return -EFAULT; + } + + skb->dev = (void *)hdev; + bt_cb(skb)->pkt_type = *((__u8 *)skb->data); + skb_pull(skb, 1); + data->hdev->send(skb); + + return count; +} + +static unsigned int btchr_poll(struct file *file_p, poll_table *wait) +{ + struct btusb_data *data = file_p->private_data; + struct hci_dev *hdev; + + //AICBT_DBG("%s: BT usb char device is polling", __func__); + + if(!bt_char_dev_registered) { + AICBT_ERR("%s: char device has not registered!", __func__); + return POLLERR | POLLHUP; + } + + poll_wait(file_p, &btchr_read_wait, wait); + + hdev = hci_dev_get(0); + if (!hdev) { + AICBT_ERR("%s: Failed to get hci dev[Null]", __func__); + mdelay(URB_CANCELING_DELAY_MS); + return POLLERR | POLLHUP; + return POLLOUT | POLLWRNORM; + } + + /* Never trust on btusb_data, as bt device may be hotplugged out */ + data = GET_DRV_DATA(hdev); + if (!data) { + /* + * When bt device is hotplugged out, btusb_data will + * be freed in disconnect. + */ + AICBT_ERR("%s: Failed to get bt usb driver data[Null]", __func__); + mdelay(URB_CANCELING_DELAY_MS); + return POLLOUT | POLLWRNORM; + } + + if (!is_queue_empty()) + return POLLIN | POLLRDNORM; + + 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) { + return -ENODEV; + } + + if(check_set_dlfw_state_value(1) != 1) { + AICBT_ERR("%s bt controller is disconnecting!", __func__); + return 0; + } + + hdev = hci_dev_get(0); + if(!hdev) { + AICBT_ERR("%s device is NULL!", __func__); + set_dlfw_state_value(0); + return 0; + } + data = GET_DRV_DATA(hdev); + fw_info = data->fw_info; + + AICBT_INFO(" btchr_ioctl DOWN_FW_CFG with Cmd:%d",cmd); + switch (cmd) { + case DOWN_FW_CFG: + AICBT_INFO(" btchr_ioctl DOWN_FW_CFG"); + ret = usb_autopm_get_interface(data->intf); + if (ret < 0){ + goto failed; + } + + //ret = download_patch(fw_info,1); + usb_autopm_put_interface(data->intf); + if(ret < 0){ + AICBT_ERR("%s:Failed in download_patch with ret:%d",__func__,ret); + goto failed; + } + + ret = hdev->open(hdev); + if(ret < 0){ + AICBT_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; + case DWFW_CMPLT: + AICBT_INFO(" btchr_ioctl DWFW_CMPLT"); +#if 1 + case SET_ISO_CFG: + AICBT_INFO("btchr_ioctl SET_ISO_CFG"); + if(copy_from_user(&(hdev->voice_setting), (__u16*)arg, sizeof(__u16))){ + AICBT_INFO(" voice settings err"); + } + //hdev->voice_setting = *(uint16_t*)arg; + AICBT_INFO(" voice settings = %d", hdev->voice_setting); + //return 1; +#endif + case GET_USB_INFO: + //ret = download_patch(fw_info,1); + AICBT_INFO(" btchr_ioctl GET_USB_INFO"); + ret = hdev->open(hdev); + if(ret < 0){ + AICBT_ERR("%s:Failed in hdev->open(hdev):%d",__func__,ret); + //goto done; + } + set_bit(HCI_UP, &hdev->flags); + set_dlfw_state_value(0); + wake_up_interruptible(&bt_dlfw_wait); + return 1; + case RESET_CONTROLLER: + AICBT_INFO(" btchr_ioctl RESET_CONTROLLER"); + //reset_controller(fw_info); + return 1; + default: + AICBT_ERR("%s:Failed with wrong Cmd:%d",__func__,cmd); + goto failed; + } + failed: + set_dlfw_state_value(0); + wake_up_interruptible(&bt_dlfw_wait); + return ret; + +} + +#ifdef CONFIG_PLATFORM_UBUNTU//AIDEN +typedef u32 compat_uptr_t; +static inline void __user *compat_ptr(compat_uptr_t uptr) +{ + return (void __user *)(unsigned long)uptr; +} +#endif + +#ifdef CONFIG_COMPAT +static long compat_btchr_ioctl (struct file *filp, unsigned int cmd, unsigned long arg) +{ + AICBT_DBG("%s: enter",__func__); + return btchr_ioctl(filp, cmd, (unsigned long) compat_ptr(arg)); +} +#endif +static struct file_operations bt_chrdev_ops = { + open : btchr_open, + release : btchr_close, + read : btchr_read, + write : btchr_write, + poll : btchr_poll, + unlocked_ioctl : btchr_ioctl, +#ifdef CONFIG_COMPAT + compat_ioctl : compat_btchr_ioctl, +#endif +}; + +static int btchr_init(void) +{ + int res = 0; + struct device *dev; + + AICBT_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); + + bt_char_class = class_create(THIS_MODULE, BT_CHAR_DEVICE_NAME); + if (IS_ERR(bt_char_class)) { + AICBT_ERR("Failed to create bt char class"); + return PTR_ERR(bt_char_class); + } + + res = alloc_chrdev_region(&bt_devid, 0, 1, BT_CHAR_DEVICE_NAME); + if (res < 0) { + AICBT_ERR("Failed to allocate bt char device"); + goto err_alloc; + } + + dev = device_create(bt_char_class, NULL, bt_devid, NULL, BT_CHAR_DEVICE_NAME); + if (IS_ERR(dev)) { + AICBT_ERR("Failed to create bt char device"); + res = PTR_ERR(dev); + goto err_create; + } + + cdev_init(&bt_char_dev, &bt_chrdev_ops); + res = cdev_add(&bt_char_dev, bt_devid, 1); + if (res < 0) { + AICBT_ERR("Failed to add bt char device"); + goto err_add; + } + + return 0; + +err_add: + device_destroy(bt_char_class, bt_devid); +err_create: + unregister_chrdev_region(bt_devid, 1); +err_alloc: + class_destroy(bt_char_class); + return res; +} + +static void btchr_exit(void) +{ + AICBT_INFO("Unregister usb char device interface for BT driver"); + + device_destroy(bt_char_class, bt_devid); + cdev_del(&bt_char_dev); + unregister_chrdev_region(bt_devid, 1); + class_destroy(bt_char_class); + + return; +} +#endif + +int send_hci_cmd(firmware_info *fw_info) +{ + + int len = 0; + int ret_val = -1; + int i = 0; + + if(g_chipid == PRODUCT_ID_AIC8801 || g_chipid == PRODUCT_ID_AIC8800D80){ + ret_val = usb_bulk_msg(fw_info->udev, fw_info->pipe_out, fw_info->send_pkt, fw_info->pkt_len, + &len, 3000); + if (ret_val || (len != fw_info->pkt_len)) { + AICBT_INFO("Error in send hci cmd = %d," + "len = %d, size = %d", ret_val, len, fw_info->pkt_len); + } + }else if(g_chipid == PRODUCT_ID_AIC8800DC){ + while((ret_val<0)&&(i++<3)) + { + ret_val = usb_control_msg( + fw_info->udev, fw_info->pipe_out, + 0, USB_TYPE_CLASS, 0, 0, + (void *)(fw_info->send_pkt), + fw_info->pkt_len, MSG_TO); + } + + } + return ret_val; + +} + +int rcv_hci_evt(firmware_info *fw_info) +{ + int ret_len = 0, ret_val = 0; + int i; + + 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), RCV_PKT_LEN, + &ret_len, MSG_TO); + if (ret_val >= 0) + break; + } + + if (ret_val < 0) + return ret_val; + + if (CMD_CMP_EVT == fw_info->evt_hdr->evt) { + if (fw_info->cmd_hdr->opcode == fw_info->cmd_cmp->opcode) + return ret_len; + } + } +} + +int set_bt_onoff(firmware_info *fw_info, uint8_t onoff) +{ + int ret_val; + + AICBT_INFO("%s: %s", __func__, onoff != 0 ? "on" : "off"); + + fw_info->cmd_hdr->opcode = cpu_to_le16(BTOFF_OPCODE); + fw_info->cmd_hdr->plen = 1; + fw_info->pkt_len = CMD_HDR_LEN + 1; + fw_info->send_pkt[CMD_HDR_LEN] = onoff; + + ret_val = send_hci_cmd(fw_info); + if (ret_val < 0) { + AICBT_ERR("%s: Failed to send bt %s cmd, errno %d", + __func__, onoff != 0 ? "on" : "off", ret_val); + return ret_val; + } + + ret_val = rcv_hci_evt(fw_info); + if (ret_val < 0) { + AICBT_ERR("%s: Failed to receive bt %s event, errno %d", + __func__, onoff != 0 ? "on" : "off", ret_val); + return ret_val; + } + + return ret_val; +} + +//for 8800DC start +u32 fwcfg_tbl[][2] = { + {0x40200028, 0x0021047e}, + {0x40200024, 0x0000011d}, +}; + +int fw_config(firmware_info* fw_info) +{ + int ret_val = -1; + struct hci_dbg_rd_mem_cmd *rd_cmd; + struct hci_dbg_rd_mem_cmd_evt *evt_para; + int len = 0, i = 0; + struct fw_status *evt_status; + + rd_cmd = (struct hci_dbg_rd_mem_cmd *)(fw_info->req_para); + if (!rd_cmd) + return -ENOMEM; + + rd_cmd->start_addr = 0x40200024; + rd_cmd->type = 32; + rd_cmd->length = 4; + fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VSC_DBG_RD_MEM_CMD); + fw_info->cmd_hdr->plen = sizeof(struct hci_dbg_rd_mem_cmd); + fw_info->pkt_len = CMD_HDR_LEN + sizeof(struct hci_dbg_rd_mem_cmd); + + ret_val = send_hci_cmd(fw_info); + if (ret_val < 0) { + printk("%s: Failed to send hci cmd 0x%04x, errno %d", + __func__, fw_info->cmd_hdr->opcode, ret_val); + return ret_val; + } + + ret_val = rcv_hci_evt(fw_info); + if (ret_val < 0) { + printk("%s: Failed to receive hci event, errno %d", + __func__, ret_val); + return ret_val; + } + + evt_para = (struct hci_dbg_rd_mem_cmd_evt *)(fw_info->rsp_para); + + printk("%s: fw status = 0x%04x, length %d, %x %x %x %x", + __func__, evt_para->status, evt_para->length, + evt_para->data[0], + evt_para->data[1], + evt_para->data[2], + evt_para->data[3]); + + ret_val = evt_para->status; + if (evt_para->status == 0) { + uint16_t rd_data = (evt_para->data[0] | (evt_para->data[1] << 8)); + printk("%s rd_data is %x\n", __func__, rd_data); + if (rd_data == 0x119) { + struct aicbt_patch_table_cmd *patch_table_cmd = (struct aicbt_patch_table_cmd *)(fw_info->req_para); + len = sizeof(fwcfg_tbl) / sizeof(u32) / 2; + patch_table_cmd->patch_num = len; + for (i = 0; i < len; i++) { + memcpy(&patch_table_cmd->patch_table_addr[i], &fwcfg_tbl[i][0], sizeof(uint32_t)); + memcpy(&patch_table_cmd->patch_table_data[i], &fwcfg_tbl[i][1], sizeof(uint32_t)); + printk("%s [%d] data: %08x %08x\n", __func__, i, patch_table_cmd->patch_table_addr[i],patch_table_cmd->patch_table_data[i]); + } + fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VSC_UPDATE_PT_CMD); + fw_info->cmd_hdr->plen = HCI_VSC_UPDATE_PT_SIZE; + fw_info->pkt_len = fw_info->cmd_hdr->plen + 3; + ret_val = send_hci_cmd(fw_info); + if (ret_val < 0) { + AICBT_ERR("%s: rcv_hci_evt err %d", __func__, ret_val); + return ret_val; + } + ret_val = rcv_hci_evt(fw_info); + if (ret_val < 0) { + printk("%s: Failed to receive hci event, errno %d", + __func__, ret_val); + return ret_val; + } + evt_status = (struct fw_status *)fw_info->rsp_para; + ret_val = evt_status->status; + if (0 != evt_status->status) { + ret_val = -1; + } else { + ret_val = 0; + } + + } + } + return ret_val; +} + +int system_config(firmware_info *fw_info) +{ + int ret_val = -1; + struct hci_dbg_rd_mem_cmd *rd_cmd; + struct hci_dbg_rd_mem_cmd_evt *evt_para; + //int len = 0, i = 0; + //struct fw_status *evt_status; + + rd_cmd = (struct hci_dbg_rd_mem_cmd *)(fw_info->req_para); + if (!rd_cmd) + return -ENOMEM; + + rd_cmd->start_addr = 0x40500000; + rd_cmd->type = 32; + rd_cmd->length = 4; + fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VSC_DBG_RD_MEM_CMD); + fw_info->cmd_hdr->plen = sizeof(struct hci_dbg_rd_mem_cmd); + fw_info->pkt_len = CMD_HDR_LEN + sizeof(struct hci_dbg_rd_mem_cmd); + + ret_val = send_hci_cmd(fw_info); + if (ret_val < 0) + { + printk("%s: Failed to send hci cmd 0x%04x, errno %d", + __func__, fw_info->cmd_hdr->opcode, ret_val); + return ret_val; + } + + ret_val = rcv_hci_evt(fw_info); + if (ret_val < 0) + { + printk("%s: Failed to receive hci event, errno %d", + __func__, ret_val); + return ret_val; + } + + evt_para = (struct hci_dbg_rd_mem_cmd_evt *)(fw_info->rsp_para); + + printk("%s: fw status = 0x%04x, length %d, %x %x %x %x", + __func__, evt_para->status, evt_para->length, + evt_para->data[0], + evt_para->data[1], + evt_para->data[2], + evt_para->data[3]); + + ret_val = evt_para->status; + if (evt_para->status == 0) + { + uint32_t rd_data = (evt_para->data[0] | (evt_para->data[1] << 8) | (evt_para->data[2] << 16) | (evt_para->data[3] << 24)); + //printk("%s 0x40500000 rd_data is %x\n", __func__, rd_data); + chip_id = (u8) (rd_data >> 16); + } + + rd_cmd->start_addr = 0x20; + rd_cmd->type = 32; + rd_cmd->length = 4; + fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VSC_DBG_RD_MEM_CMD); + fw_info->cmd_hdr->plen = sizeof(struct hci_dbg_rd_mem_cmd); + fw_info->pkt_len = CMD_HDR_LEN + sizeof(struct hci_dbg_rd_mem_cmd); + + ret_val = send_hci_cmd(fw_info); + if (ret_val < 0) + { + printk("%s: Failed to send hci cmd 0x%04x, errno %d", + __func__, fw_info->cmd_hdr->opcode, ret_val); + return ret_val; + } + + ret_val = rcv_hci_evt(fw_info); + if (ret_val < 0) + { + printk("%s: Failed to receive hci event, errno %d", + __func__, ret_val); + return ret_val; + } + + evt_para = (struct hci_dbg_rd_mem_cmd_evt *)(fw_info->rsp_para); + + printk("%s: fw status = 0x%04x, length %d, %x %x %x %x", + __func__, evt_para->status, evt_para->length, + evt_para->data[0], + evt_para->data[1], + evt_para->data[2], + evt_para->data[3]); + + ret_val = evt_para->status; + if (evt_para->status == 0) + { + uint32_t rd_data = (evt_para->data[0] | (evt_para->data[1] << 8) | (evt_para->data[2] << 16) | (evt_para->data[3] << 24)); + //printk("%s 0x02 rd_data is %x\n", __func__, rd_data); + sub_chip_id = (u8) (rd_data); + } + printk("chip_id = %x, sub_chip_id = %x\n", chip_id, sub_chip_id); + return ret_val; +} + +int check_fw_status(firmware_info* fw_info) +{ + struct fw_status *read_ver_rsp; + int ret_val = -1; + + fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VSC_FW_STATUS_GET_CMD); + fw_info->cmd_hdr->plen = 0; + fw_info->pkt_len = CMD_HDR_LEN; + + ret_val = send_hci_cmd(fw_info); + if (ret_val < 0) { + printk("%s: Failed to send hci cmd 0x%04x, errno %d", + __func__, fw_info->cmd_hdr->opcode, ret_val); + return ret_val; + } + + ret_val = rcv_hci_evt(fw_info); + if (ret_val < 0) { + printk("%s: Failed to receive hci event, errno %d", + __func__, ret_val); + return ret_val; + } + + read_ver_rsp = (struct fw_status *)(fw_info->rsp_para); + + printk("%s: fw status = 0x%04x", + __func__, read_ver_rsp->status); + return read_ver_rsp->status; +} + +int download_data(firmware_info *fw_info, u32 fw_addr, char *filename) +{ + unsigned int i=0; + int size; + u8 *dst=NULL; + int err=0; + struct hci_dbg_wr_mem_cmd *dl_cmd; + int hdr_len = sizeof(__le32) + sizeof(__u8) + sizeof(__u8); + int data_len = HCI_VSC_MEM_WR_SIZE; + int frag_len = data_len + hdr_len; + int ret_val; + int ncmd = 1; + struct fw_status *evt_para; + + /* load aic firmware */ + size = aic_load_firmware(&dst, filename, NULL); + if(size <= 0){ + printk("wrong size of firmware file\n"); + vfree(dst); + dst = NULL; + return -1; + } + + dl_cmd = (struct hci_dbg_wr_mem_cmd *)(fw_info->req_para); + if (!dl_cmd) + return -ENOMEM; + evt_para = (struct fw_status *)fw_info->rsp_para; + + /* Copy the file on the Embedded side */ + printk("### Upload %s firmware, @ = %x size=%d\n", filename, fw_addr, size); + + if (size > HCI_VSC_MEM_WR_SIZE) {// > 1KB data + for (i = 0; i < (size - HCI_VSC_MEM_WR_SIZE); i += HCI_VSC_MEM_WR_SIZE) {//each time write 240 bytes + data_len = HCI_VSC_MEM_WR_SIZE; + frag_len = data_len + hdr_len; + memcpy(dl_cmd->data, dst + i, data_len); + dl_cmd->length = data_len; + dl_cmd->type = 32; + dl_cmd->start_addr = fw_addr + i; + fw_info->cmd_hdr->opcode = cpu_to_le16(DOWNLOAD_OPCODE); + fw_info->cmd_hdr->plen = frag_len; + fw_info->pkt_len = frag_len + 3; + #if 0 + printk("[%d] data_len %d, src %x, dst %x\n", i, data_len, dst + i, fw_addr + i); + printk("%p , %d\n", dl_cmd, fw_info->pkt_len); + print_hex_dump(KERN_ERR,"payload:",DUMP_PREFIX_NONE,16,1,dl_cmd->data,32,false); + /* Send download command */ + print_hex_dump(KERN_ERR,"data:",DUMP_PREFIX_NONE,16,1,fw_info->send_pkt,32,false); + #endif + ret_val = send_hci_cmd(fw_info); + + while (ncmd > 0) { + ret_val = rcv_hci_evt(fw_info); + printk("rcv_hci_evt %d\n", ret_val); + if (ret_val < 0) { + AICBT_ERR("%s: rcv_hci_evt err %d", __func__, ret_val); + goto out; + } else { + AICBT_DBG("%s: Receive acked frag num %d", __func__, evt_para->status); + ncmd--; + } + if (0 != evt_para->status) { + AICBT_ERR("%s: Receive acked frag num %d, err status %d", + __func__, ret_val, evt_para->status); + ret_val = -1; + goto out; + } else { + ret_val = 0; + } + } + ncmd = 1; + } + } + + if (!err && (i < size)) {// <1KB data + data_len = size - i; + frag_len = data_len + hdr_len; + memcpy(dl_cmd->data, dst + i, data_len); + dl_cmd->length = data_len; + dl_cmd->type = 32; + dl_cmd->start_addr = fw_addr + i; + fw_info->cmd_hdr->opcode = cpu_to_le16(DOWNLOAD_OPCODE); + fw_info->cmd_hdr->plen = frag_len; + fw_info->pkt_len = frag_len + 3; + ret_val = send_hci_cmd(fw_info); + //printk("(%d) data_len %d, src %x, dst %x\n", i, data_len, (dst + i), fw_addr + i); + //printk("%p , %d\n", dl_cmd, fw_info->pkt_len); + while (ncmd > 0) { + ret_val = rcv_hci_evt(fw_info); + if (ret_val < 0) { + AICBT_ERR("%s: rcv_hci_evt err %d", __func__, ret_val); + goto out; + } else { + AICBT_DBG("%s: Receive acked frag num %d", __func__, evt_para->status); + ncmd--; + } + if (0 != evt_para->status) { + AICBT_ERR("%s: Receive acked frag num %d, err status %d", + __func__, ret_val, evt_para->status); + ret_val = -1; + goto out; + } else { + ret_val = 0; + } + } + ncmd = 0; + } + +out: + if (dst) { + vfree(dst); + dst = NULL; + } + + printk("fw download complete\n\n"); + return ret_val; + +} + + +struct aicbt_info_t { + uint32_t btmode; + uint32_t btport; + uint32_t uart_baud; + uint32_t uart_flowctrl; + uint32_t lpm_enable; + uint32_t txpwr_lvl; +}; + +struct aicbsp_info_t { + int hwinfo; + uint32_t cpmode; +}; + +enum aicbsp_cpmode_type { + AICBSP_CPMODE_WORK, + AICBSP_CPMODE_TEST, +}; + +/* btmode + * used for force bt mode,if not AICBSP_MODE_NULL + * efuse valid and vendor_info will be invalid, even has beed set valid +*/ +enum aicbt_btmode_type { + AICBT_BTMODE_BT_ONLY_SW = 0x0, // bt only mode with switch + AICBT_BTMODE_BT_WIFI_COMBO, // wifi/bt combo mode + AICBT_BTMODE_BT_ONLY, // bt only mode without switch + AICBT_BTMODE_BT_ONLY_TEST, // bt only test mode + AICBT_BTMODE_BT_WIFI_COMBO_TEST, // wifi/bt combo test mode + AICBT_MODE_NULL = 0xFF, // invalid value +}; + +enum aicbt_btport_type { + AICBT_BTPORT_NULL, + AICBT_BTPORT_MB, + AICBT_BTPORT_UART, +}; + +enum aicbt_uart_baud_type { + AICBT_UART_BAUD_115200 = 115200, + AICBT_UART_BAUD_921600 = 921600, + AICBT_UART_BAUD_1_5M = 1500000, + AICBT_UART_BAUD_3_25M = 3250000, +}; + +enum aicbt_uart_flowctrl_type { + AICBT_UART_FLOWCTRL_DISABLE = 0x0, // uart without flow ctrl + AICBT_UART_FLOWCTRL_ENABLE, // uart with flow ctrl +}; + +#define AICBSP_HWINFO_DEFAULT (-1) +#define AICBSP_CPMODE_DEFAULT AICBSP_CPMODE_WORK +#define AICBT_TXPWR_DFT 0x6F2F + + +#define AICBT_BTMODE_DEFAULT AICBT_BTMODE_BT_WIFI_COMBO +#define AICBT_BTPORT_DEFAULT AICBT_BTPORT_MB +#define AICBT_UART_BAUD_DEFAULT AICBT_UART_BAUD_1_5M +#define AICBT_UART_FC_DEFAULT AICBT_UART_FLOWCTRL_ENABLE +#define AICBT_LPM_ENABLE_DEFAULT 0 +#define AICBT_TXPWR_LVL_DEFAULT AICBT_TXPWR_DFT + +struct aicbsp_info_t aicbsp_info = { + .hwinfo = AICBSP_HWINFO_DEFAULT, + .cpmode = AICBSP_CPMODE_DEFAULT, +}; + +#ifndef CONFIG_USE_FW_REQUEST +#define FW_PATH_MAX 200 + +char aic_fw_path[FW_PATH_MAX]; +#if (CONFIG_BLUEDROID == 0) +static const char* aic_default_fw_path = "/lib/firmware/aic8800DC"; +#else +static const char* aic_default_fw_path = "/vendor/etc/firmware"; +#endif +#endif //CONFIG_USE_FW_REQUEST + +static struct aicbt_info_t aicbt_info = { + .btmode = AICBT_BTMODE_DEFAULT, + .btport = AICBT_BTPORT_DEFAULT, + .uart_baud = AICBT_UART_BAUD_DEFAULT, + .uart_flowctrl = AICBT_UART_FC_DEFAULT, + .lpm_enable = AICBT_LPM_ENABLE_DEFAULT, + .txpwr_lvl = AICBT_TXPWR_LVL_DEFAULT, +}; + +int patch_table_load(firmware_info *fw_info, struct aicbt_patch_table *_head) +{ + struct aicbt_patch_table *head, *p; + int i; + uint32_t *data = NULL; + struct aicbt_patch_table_cmd *patch_table_cmd = (struct aicbt_patch_table_cmd *)(fw_info->req_para); + struct fw_status *evt_para; + int ret_val = 0; + int ncmd = 1; + uint32_t len = 0; + uint32_t tot_len = 0; + head = _head; + for (p = head; p != NULL; p = p->next) { + data = p->data; + if(AICBT_PT_BTMODE == p->type){ + *(data + 1) = aicbsp_info.hwinfo < 0; + *(data + 3) = aicbsp_info.hwinfo; + *(data + 5) = aicbsp_info.cpmode; + + *(data + 7) = aicbt_info.btmode; + *(data + 9) = aicbt_info.btport; + *(data + 11) = aicbt_info.uart_baud; + *(data + 13) = aicbt_info.uart_flowctrl; + *(data + 15) = aicbt_info.lpm_enable; + *(data + 17) = aicbt_info.txpwr_lvl; + + } + if (p->type == AICBT_PT_NULL || p->type == AICBT_PT_PWRON) { + continue; + } + if (p->type == AICBT_PT_VER) { + char *data_s = (char *)p->data; + printk("patch version %s\n", data_s); + continue; + } + if (p->len == 0) { + printk("len is 0\n"); + continue; + } + tot_len = p->len; + while (tot_len) { + if (tot_len > HCI_PT_MAX_LEN) { + len = HCI_PT_MAX_LEN; + } else { + len = tot_len; + } + for (i = 0; i < len; i++) { + patch_table_cmd->patch_num = len; + memcpy(&patch_table_cmd->patch_table_addr[i], data, sizeof(uint32_t)); + memcpy(&patch_table_cmd->patch_table_data[i], data + 1, sizeof(uint32_t)); + printk("[%d] data: %08x %08x\n", i, patch_table_cmd->patch_table_addr[i],patch_table_cmd->patch_table_data[i]); + data += 2; + } + tot_len -= len; + evt_para = (struct fw_status *)fw_info->rsp_para; + //print_hex_dump(KERN_ERR,"data0:",DUMP_PREFIX_NONE,16,1,patch_table_cmd,sizeof(struct aicbt_patch_table_cmd),false); + + //printk("patch num %x %d\n", patch_table_cmd->patch_num, sizeof(struct aicbt_patch_table_cmd)); + fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VSC_UPDATE_PT_CMD); + fw_info->cmd_hdr->plen = HCI_VSC_UPDATE_PT_SIZE; + fw_info->pkt_len = fw_info->cmd_hdr->plen + 3; + AICBT_DBG("patch num 0x%x, plen 0x%x\n", patch_table_cmd->patch_num, fw_info->cmd_hdr->plen ); + //print_hex_dump(KERN_ERR,"patch table:",DUMP_PREFIX_NONE,16,1,fw_info->send_pkt,32,false); + ret_val = send_hci_cmd(fw_info); + while (ncmd > 0) { + ret_val = rcv_hci_evt(fw_info); + if (ret_val < 0) { + AICBT_ERR("%s: rcv_hci_evt err %d", __func__, ret_val); + goto out; + } else { + AICBT_DBG("%s: Receive acked frag num %d", __func__, evt_para->status); + ncmd--; + } + if (0 != evt_para->status) { + AICBT_ERR("%s: Receive acked frag num %d, err status %d", + __func__, ret_val, evt_para->status); + ret_val = -1; + goto out; + } + } + ncmd = 1; + } + } +out: + aicbt_patch_table_free(&head); + return ret_val; +} + +int aic_load_firmware(u8 ** fw_buf, const char *name, struct device *device) +{ + +#ifdef CONFIG_USE_FW_REQUEST + const struct firmware *fw = NULL; + u32 *dst = NULL; + void *buffer=NULL; + int size = 0; + int ret = 0; + + printk("%s: request firmware = %s \n", __func__ ,name); + + + ret = request_firmware(&fw, name, NULL); + + if (ret < 0) { + printk("Load %s fail\n", name); + release_firmware(fw); + return -1; + } + + size = fw->size; + dst = (u32 *)fw->data; + + if (size <= 0) { + printk("wrong size of firmware file\n"); + release_firmware(fw); + return -1; + } + + + buffer = vmalloc(size); + memset(buffer, 0, size); + memcpy(buffer, dst, size); + + *fw_buf = buffer; + + release_firmware(fw); + + return size; + +#else + u8 *buffer=NULL; + char *path=NULL; + struct file *fp=NULL; + int size = 0, len=0; + ssize_t rdlen=0; + + /* get the firmware path */ + path = __getname(); + if (!path){ + *fw_buf=NULL; + return -1; + } + + if (strlen(aic_fw_path) > 0) { + printk("%s: use customer define fw_path\n", __func__); + len = snprintf(path, FW_PATH_MAX, "%s/%s", aic_fw_path, name); + } else { + len = snprintf(path, FW_PATH_MAX, "%s/%s",aic_default_fw_path, name); + } + + if (len >= FW_PATH_MAX) { + printk("%s: %s file's path too long\n", __func__, name); + *fw_buf=NULL; + __putname(path); + return -1; + } + + printk("%s :firmware path = %s \n", __func__ ,path); + + + /* open the firmware file */ + fp=filp_open(path, O_RDONLY, 0); + if(IS_ERR(fp) || (!fp)){ + printk("%s: %s file failed to open\n", __func__, name); + if(IS_ERR(fp)) + printk("is_Err\n"); + if((!fp)) + printk("null\n"); + *fw_buf=NULL; + __putname(path); + fp=NULL; + return -1; + } + + size = i_size_read(file_inode(fp)); + if(size<=0){ + printk("%s: %s file size invalid %d\n", __func__, name, size); + *fw_buf=NULL; + __putname(path); + filp_close(fp,NULL); + fp=NULL; + return -1; +} + + /* start to read from firmware file */ + buffer = vmalloc(size); + memset(buffer, 0, size); + if(!buffer){ + *fw_buf=NULL; + __putname(path); + filp_close(fp,NULL); + fp=NULL; + return -1; + } + + + #if LINUX_VERSION_CODE > KERNEL_VERSION(4, 13, 16) + rdlen = kernel_read(fp, buffer, size, &fp->f_pos); + #else + rdlen = kernel_read(fp, fp->f_pos, buffer, size); + #endif + + if(size != rdlen){ + printk("%s: %s file rdlen invalid %d %d\n", __func__, name, (int)rdlen, size); + *fw_buf=NULL; + __putname(path); + filp_close(fp,NULL); + fp=NULL; + vfree(buffer); + buffer=NULL; + return -1; + } + if(rdlen > 0){ + fp->f_pos += rdlen; + //printk("f_pos=%d\n", (int)fp->f_pos); + } + *fw_buf = buffer; + +#if 0 + MD5Init(&md5); + MD5Update(&md5, (unsigned char *)dst, size); + MD5Final(&md5, decrypt); + + printk(MD5PINRT, MD5(decrypt)); + +#endif + return size; +#endif +} + +int aicbt_patch_table_free(struct aicbt_patch_table **head) +{ + struct aicbt_patch_table *p = *head, *n = NULL; + while (p) { + n = p->next; + kfree(p->name); + kfree(p->data); + kfree(p); + p = n; + } + *head = NULL; + return 0; +} + +int get_patch_addr_from_patch_table(firmware_info *fw_info, char *filename, uint32_t *fw_patch_base_addr) +{ + int size; + int ret = 0; + uint8_t *rawdata=NULL; + uint8_t *p = NULL; + uint32_t *data = NULL; + uint32_t type = 0, len = 0; + int j; + + /* load aic firmware */ + size = aic_load_firmware((u8 **)&rawdata, filename, NULL); + + /* Copy the file on the Embedded side */ + printk("### Upload %s fw_patch_table, size=%d\n", filename, size); + + if (size <= 0) { + printk("wrong size of firmware file\n"); + ret = -1; + goto err; + } + + p = rawdata; + + if (memcmp(p, AICBT_PT_TAG, sizeof(AICBT_PT_TAG) < 16 ? sizeof(AICBT_PT_TAG) : 16)) { + printk("TAG err\n"); + ret = -1; + goto err; + } + p += 16; + + while (p - rawdata < size) { + printk("size = %d p - rawdata = 0x%0lx \r\n", size, p - rawdata); + p += 16; + + type = *(uint32_t *)p; + p += 4; + + len = *(uint32_t *)p; + p += 4; + printk("cur->type %x, len %d\n", type, len); + + if(type >= 1000 ) {//Temp Workaround + len = 0; + }else{ + data = (uint32_t *)p; + if (type == AICBT_PT_NULL) { + *(fw_patch_base_addr) = *(data + 3); + printk("addr found %x\n", *(fw_patch_base_addr)); + for (j = 0; j < len; j++) { + printk("addr %x\n", *(data+j)); + } + break; + } + p += len * 8; + } + } + + vfree(rawdata); + return ret; +err: + //aicbt_patch_table_free(&head); + + if (rawdata){ + vfree(rawdata); + } + return ret; +} + + + +int patch_table_download(firmware_info *fw_info, char *filename) +{ + struct aicbt_patch_table *head = NULL; + struct aicbt_patch_table *new = NULL; + struct aicbt_patch_table *cur = NULL; + int size; + int ret = 0; + uint8_t *rawdata=NULL; + uint8_t *p = NULL; + + /* load aic firmware */ + size = aic_load_firmware((u8 **)&rawdata, filename, NULL); + + /* Copy the file on the Embedded side */ + printk("### Upload %s fw_patch_table, size=%d\n", filename, size); + + if (size <= 0) { + printk("wrong size of firmware file\n"); + ret = -1; + goto err; + } + + p = rawdata; + + if (memcmp(p, AICBT_PT_TAG, sizeof(AICBT_PT_TAG) < 16 ? sizeof(AICBT_PT_TAG) : 16)) { + printk("TAG err\n"); + ret = -1; + goto err; + } + p += 16; + + while (p - rawdata < size) { + printk("size = %d p - rawdata = 0x%0lx \r\n", size, p - rawdata); + new = (struct aicbt_patch_table *)kmalloc(sizeof(struct aicbt_patch_table), GFP_KERNEL); + memset(new, 0, sizeof(struct aicbt_patch_table)); + if (head == NULL) { + head = new; + cur = new; + } else { + cur->next = new; + cur = cur->next; + } + + cur->name = (char *)kmalloc(sizeof(char) * 16, GFP_KERNEL); + memset(cur->name, 0, sizeof(char) * 16); + memcpy(cur->name, p, 16); + p += 16; + + cur->type = *(uint32_t *)p; + p += 4; + + cur->len = *(uint32_t *)p; + p += 4; + printk("cur->type %x, len %d\n", cur->type, cur->len); + + if((cur->type ) >= 1000 ) {//Temp Workaround + cur->len = 0; + }else{ + cur->data = (uint32_t *)kmalloc(sizeof(uint8_t) * cur->len * 8, GFP_KERNEL); + memset(cur->data, 0, sizeof(uint8_t) * cur->len * 8); + memcpy(cur->data, p, cur->len * 8); + p += cur->len * 8; + } + } + + vfree(rawdata); + patch_table_load(fw_info, head); + printk("fw_patch_table download complete\n\n"); + + return ret; +err: + //aicbt_patch_table_free(&head); + + if (rawdata){ + vfree(rawdata); + } + return ret; +} + + +int download_patch(firmware_info *fw_info, int cached) +{ + int ret_val = 0; + + printk("%s: Download fw patch start, cached %d", __func__, cached); + + if (!fw_info) { + printk("%s: No patch entry exists(fw_info %p)", __func__, fw_info); + ret_val = -1; + goto end; + } + + ret_val = fw_config(fw_info); + if (ret_val) { + printk("%s: fw config failed %d", __func__, ret_val); + goto free; + } + + ret_val = system_config(fw_info); + if (ret_val) + { + printk("%s: system config failed %d", __func__, ret_val); + goto free; + } + + /* + * step1: check firmware statis + * step2: download firmware if updated + */ + + + ret_val = check_fw_status(fw_info); + + + if (ret_val) { + #if 0 + ret_val = download_data(fw_info, FW_RAM_ADID_BASE_ADDR, FW_ADID_BASE_NAME); + if (ret_val) { + printk("aic load adid fail %d\n", ret_val); + goto free; + } + #endif + if (sub_chip_id == 0) { + ret_val= download_data(fw_info, FW_RAM_PATCH_BASE_ADDR, FW_PATCH_BASE_NAME); + if (ret_val) { + printk("aic load patch fail %d\n", ret_val); + goto free; + } + + ret_val= patch_table_download(fw_info, FW_PATCH_TABLE_NAME); + if (ret_val) { + printk("aic load patch ftable ail %d\n", ret_val); + goto free; + } + } else if (sub_chip_id == 1) { + uint32_t fw_ram_patch_base_addr = FW_RAM_PATCH_BASE_ADDR; + + ret_val = get_patch_addr_from_patch_table(fw_info, FW_PATCH_TABLE_NAME_U02, &fw_ram_patch_base_addr); + if (ret_val) + { + printk("aic get patch addr fail %d\n", ret_val); + goto free; + } + printk("%s %x\n", __func__, fw_ram_patch_base_addr); + ret_val = download_data(fw_info, fw_ram_patch_base_addr, FW_PATCH_BASE_NAME_U02); + if (ret_val) + { + printk("aic load patch fail %d\n", ret_val); + goto free; + } + + ret_val = patch_table_download(fw_info, FW_PATCH_TABLE_NAME_U02); + if (ret_val) + { + printk("aic load patch ftable ail %d\n", ret_val); + goto free; + } + } else if (sub_chip_id == 2) { + uint32_t fw_ram_patch_base_addr = FW_RAM_PATCH_BASE_ADDR; + + ret_val = get_patch_addr_from_patch_table(fw_info, FW_PATCH_TABLE_NAME_U02H, &fw_ram_patch_base_addr); + if (ret_val) + { + printk("aic get patch addr fail %d\n", ret_val); + goto free; + } + printk("U02H %s %x\n", __func__, fw_ram_patch_base_addr); + ret_val = download_data(fw_info, fw_ram_patch_base_addr, FW_PATCH_BASE_NAME_U02H); + if (ret_val) + { + printk("aic load patch fail %d\n", ret_val); + goto free; + } + + ret_val = patch_table_download(fw_info, FW_PATCH_TABLE_NAME_U02H); + if (ret_val) + { + printk("aic load patch ftable ail %d\n", ret_val); + goto free; + } + } else { + printk("%s unsupported sub_chip_id %x\n", __func__, sub_chip_id); + } + } + +free: + /* Free fw data after download finished */ + kfree(fw_info->fw_data); + fw_info->fw_data = NULL; + +end: + return ret_val; +} + +//for 8800dc end + +firmware_info *firmware_info_init(struct usb_interface *intf) +{ + struct usb_device *udev = interface_to_usbdev(intf); + firmware_info *fw_info; + + AICBT_DBG("%s: start", __func__); + + fw_info = kzalloc(sizeof(*fw_info), GFP_KERNEL); + if (!fw_info) + return NULL; + + fw_info->send_pkt = kzalloc(SEND_PKT_LEN, GFP_KERNEL); + if (!fw_info->send_pkt) { + kfree(fw_info); + return NULL; + } + + fw_info->rcv_pkt = kzalloc(RCV_PKT_LEN, GFP_KERNEL); + if (!fw_info->rcv_pkt) { + kfree(fw_info->send_pkt); + kfree(fw_info); + return NULL; + } + + fw_info->intf = intf; + fw_info->udev = udev; +if(g_chipid == PRODUCT_ID_AIC8801 || g_chipid == PRODUCT_ID_AIC8800D80){ + fw_info->pipe_in = usb_rcvbulkpipe(fw_info->udev, BULK_EP); + fw_info->pipe_out = usb_rcvbulkpipe(fw_info->udev, CTRL_EP); +}else if(g_chipid == PRODUCT_ID_AIC8800DC){ + fw_info->pipe_in = usb_rcvintpipe(fw_info->udev, INTR_EP); + fw_info->pipe_out = usb_sndctrlpipe(fw_info->udev, CTRL_EP); +} + fw_info->cmd_hdr = (struct hci_command_hdr *)(fw_info->send_pkt); + fw_info->evt_hdr = (struct hci_event_hdr *)(fw_info->rcv_pkt); + fw_info->cmd_cmp = (struct hci_ev_cmd_complete *)(fw_info->rcv_pkt + EVT_HDR_LEN); + fw_info->req_para = fw_info->send_pkt + CMD_HDR_LEN; + fw_info->rsp_para = fw_info->rcv_pkt + EVT_HDR_LEN + CMD_CMP_LEN; + +#if BTUSB_RPM + AICBT_INFO("%s: Auto suspend is enabled", __func__); + usb_enable_autosuspend(udev); + pm_runtime_set_autosuspend_delay(&(udev->dev), 2000); +#else + AICBT_INFO("%s: Auto suspend is disabled", __func__); + usb_disable_autosuspend(udev); +#endif + +#if BTUSB_WAKEUP_HOST + device_wakeup_enable(&udev->dev); +#endif + + return fw_info; +} + + +void firmware_info_destroy(struct usb_interface *intf) +{ + firmware_info *fw_info; + struct usb_device *udev; + struct btusb_data *data; + + udev = interface_to_usbdev(intf); + data = usb_get_intfdata(intf); + + fw_info = data->fw_info; + if (!fw_info) + return; + +#if BTUSB_RPM + usb_disable_autosuspend(udev); +#endif + + /* + * In order to reclaim fw data mem, we free fw_data immediately + * after download patch finished instead of here. + */ + kfree(fw_info->rcv_pkt); + kfree(fw_info->send_pkt); + kfree(fw_info); + + +} + +static struct usb_driver btusb_driver; + +static struct usb_device_id btusb_table[] = { + #if 0 + { .match_flags = USB_DEVICE_ID_MATCH_VENDOR | + USB_DEVICE_ID_MATCH_INT_INFO, + .idVendor = 0xa69d, + .bInterfaceClass = 0xe0, + .bInterfaceSubClass = 0x01, + .bInterfaceProtocol = 0x01 }, + #endif + {USB_DEVICE_AND_INTERFACE_INFO(USB_VENDOR_ID_AIC, USB_PRODUCT_ID_AIC8801, 0xe0, 0x01,0x01)}, + {USB_DEVICE_AND_INTERFACE_INFO(USB_VENDOR_ID_AIC, USB_PRODUCT_ID_AIC8800D80, 0xe0, 0x01,0x01)}, + {USB_DEVICE_AND_INTERFACE_INFO(USB_VENDOR_ID_AIC, USB_PRODUCT_ID_AIC8800DC, 0xe0, 0x01,0x01)}, + {} +}; + +MODULE_DEVICE_TABLE(usb, btusb_table); + +static int inc_tx(struct btusb_data *data) +{ + unsigned long flags; + int rv; + + spin_lock_irqsave(&data->txlock, flags); + rv = test_bit(BTUSB_SUSPENDING, &data->flags); + if (!rv) + data->tx_in_flight++; + spin_unlock_irqrestore(&data->txlock, flags); + + return rv; +} + +void check_sco_event(struct urb *urb) +{ + u8* opcode = (u8*)(urb->transfer_buffer); + u8 status; + static uint16_t sco_handle = 0; + uint16_t handle; + u8 air_mode = 0; + struct hci_dev *hdev = urb->context; +#ifdef CONFIG_SCO_OVER_HCI + struct btusb_data *data = GET_DRV_DATA(hdev); + AIC_sco_card_t *pSCOSnd = data->pSCOSnd; +#endif + + switch (*opcode) { + case HCI_EV_SYNC_CONN_COMPLETE: + AICBT_INFO("%s: HCI_EV_SYNC_CONN_COMPLETE(0x%02x)", __func__, *opcode); + status = *(opcode + 2); + sco_handle = *(opcode + 3) | *(opcode + 4) << 8; + air_mode = *(opcode + 18); + printk("%s status:%d,air_mode:%d \r\n", __func__, status,air_mode); + if (status == 0) { + hdev->conn_hash.sco_num++; + hdev->notify(hdev, 0); + //schedule_work(&data->work); + if (air_mode == 0x03) { + set_select_msbc(CODEC_MSBC); + } + } + break; + case HCI_EV_DISCONN_COMPLETE: + AICBT_INFO("%s: HCI_EV_DISCONN_COMPLETE(0x%02x)", __func__, *opcode); + status = *(opcode + 2); + handle = *(opcode + 3) | *(opcode + 4) << 8; + if (status == 0 && sco_handle == handle) { + hdev->conn_hash.sco_num--; + hdev->notify(hdev, 0); + set_select_msbc(CODEC_CVSD); + //schedule_work(&data->work); +#ifdef CONFIG_SCO_OVER_HCI + if (test_bit(ALSA_CAPTURE_RUNNING, &pSCOSnd->states)) { + mod_timer(&snd_cap_timer.cap_timer,jiffies + msecs_to_jiffies(3)); + } +#endif + } + break; + default: + AICBT_DBG("%s: event 0x%02x", __func__, *opcode); + break; + } +} + +#if (CONFIG_BLUEDROID == 0) +#if HCI_VERSION_CODE >= KERNEL_VERSION(3, 18, 0) +static inline void btusb_free_frags(struct btusb_data *data) +{ + unsigned long flags; + + spin_lock_irqsave(&data->rxlock, flags); + + kfree_skb(data->evt_skb); + data->evt_skb = NULL; + + kfree_skb(data->acl_skb); + data->acl_skb = NULL; + + kfree_skb(data->sco_skb); + data->sco_skb = NULL; + + spin_unlock_irqrestore(&data->rxlock, flags); +} + +static int btusb_recv_intr(struct btusb_data *data, void *buffer, int count) +{ + struct sk_buff *skb; + int err = 0; + + spin_lock(&data->rxlock); + skb = data->evt_skb; + //printk("%s count %d\n", __func__, count); + +#if 1 + while (count) { + int len; + + if (!skb) { + skb = bt_skb_alloc(HCI_MAX_EVENT_SIZE, GFP_ATOMIC); + if (!skb) { + err = -ENOMEM; + break; + } + + bt_cb(skb)->pkt_type = HCI_EVENT_PKT; + bt_cb(skb)->expect = HCI_EVENT_HDR_SIZE; + } + + len = min_t(uint, bt_cb(skb)->expect, count); + memcpy(skb_put(skb, len), buffer, len); + + count -= len; + buffer += len; + bt_cb(skb)->expect -= len; + + if (skb->len == HCI_EVENT_HDR_SIZE) { + /* Complete event header */ + bt_cb(skb)->expect = hci_event_hdr(skb)->plen; + + if (skb_tailroom(skb) < bt_cb(skb)->expect) { + kfree_skb(skb); + skb = NULL; + + err = -EILSEQ; + break; + } + } + + if (bt_cb(skb)->expect == 0) { + /* Complete frame */ + hci_recv_frame(data->hdev, skb); + skb = NULL; + } + } +#endif + + data->evt_skb = skb; + spin_unlock(&data->rxlock); + + return err; +} + +static int btusb_recv_bulk(struct btusb_data *data, void *buffer, int count) +{ + struct sk_buff *skb; + int err = 0; + + spin_lock(&data->rxlock); + skb = data->acl_skb; + + while (count) { + int len; + + if (!skb) { + skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC); + if (!skb) { + err = -ENOMEM; + break; + } + + bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; + bt_cb(skb)->expect = HCI_ACL_HDR_SIZE; + } + + len = min_t(uint, bt_cb(skb)->expect, count); + memcpy(skb_put(skb, len), buffer, len); + + count -= len; + buffer += len; + bt_cb(skb)->expect -= len; + + if (skb->len == HCI_ACL_HDR_SIZE) { + __le16 dlen = hci_acl_hdr(skb)->dlen; + + /* Complete ACL header */ + bt_cb(skb)->expect = __le16_to_cpu(dlen); + + if (skb_tailroom(skb) < bt_cb(skb)->expect) { + kfree_skb(skb); + skb = NULL; + + err = -EILSEQ; + break; + } + } + + if (bt_cb(skb)->expect == 0) { + /* Complete frame */ + hci_recv_frame(data->hdev, skb); + skb = NULL; + } + } + + data->acl_skb = skb; + spin_unlock(&data->rxlock); + + return err; +} + +static int btusb_recv_isoc(struct btusb_data *data, void *buffer, int count) +{ + struct sk_buff *skb; + int err = 0; + + spin_lock(&data->rxlock); + skb = data->sco_skb; + + while (count) { + int len; + + if (!skb) { + skb = bt_skb_alloc(HCI_MAX_SCO_SIZE, GFP_ATOMIC); + if (!skb) { + err = -ENOMEM; + break; + } + + bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; + bt_cb(skb)->expect = HCI_SCO_HDR_SIZE; + } + + len = min_t(uint, bt_cb(skb)->expect, count); + memcpy(skb_put(skb, len), buffer, len); + + count -= len; + buffer += len; + bt_cb(skb)->expect -= len; + + if (skb->len == HCI_SCO_HDR_SIZE) { + /* Complete SCO header */ + bt_cb(skb)->expect = hci_sco_hdr(skb)->dlen; + + if (skb_tailroom(skb) < bt_cb(skb)->expect) { + kfree_skb(skb); + skb = NULL; + + err = -EILSEQ; + break; + } + } + + if (bt_cb(skb)->expect == 0) { + /* Complete frame */ + hci_recv_frame(data->hdev, skb); + skb = NULL; + } + } + + data->sco_skb = skb; + spin_unlock(&data->rxlock); + + return err; +} +#endif +#endif // (CONFIG_BLUEDROID == 0) + + +static void btusb_intr_complete(struct urb *urb) +{ + struct hci_dev *hdev = urb->context; + struct btusb_data *data = GET_DRV_DATA(hdev); + int err; + + AICBT_DBG("%s: urb %p status %d count %d ", __func__, + urb, urb->status, urb->actual_length); + + if (!test_bit(HCI_RUNNING, &hdev->flags)) { + printk("%s return \n", __func__); + return; + } + if (urb->status == 0) { + hdev->stat.byte_rx += urb->actual_length; + +#if (CONFIG_BLUEDROID) || (HCI_VERSION_CODE < KERNEL_VERSION(3, 18, 0)) + if (hci_recv_fragment(hdev, HCI_EVENT_PKT, + urb->transfer_buffer, + urb->actual_length) < 0) { + AICBT_ERR("%s: Corrupted event packet", __func__); + hdev->stat.err_rx++; + } +#else + if (btusb_recv_intr(data, urb->transfer_buffer, + urb->actual_length) < 0) { + AICBT_ERR("%s corrupted event packet", hdev->name); + hdev->stat.err_rx++; + } +#endif + +#ifdef CONFIG_SCO_OVER_HCI + check_sco_event(urb); +#endif +#ifdef CONFIG_USB_AIC_UART_SCO_DRIVER + check_sco_event(urb); +#endif + + } + /* Avoid suspend failed when usb_kill_urb */ + else if(urb->status == -ENOENT) { + return; + } + + + if (!test_bit(BTUSB_INTR_RUNNING, &data->flags)) + return; + + usb_mark_last_busy(data->udev); + usb_anchor_urb(urb, &data->intr_anchor); + + err = usb_submit_urb(urb, GFP_ATOMIC); + if (err < 0) { + if (err != -EPERM && err != -ENODEV) + AICBT_ERR("%s: Failed to re-submit urb %p, err %d", + __func__, urb, err); + usb_unanchor_urb(urb); + } +} + +static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags) +{ + struct btusb_data *data = GET_DRV_DATA(hdev); + struct urb *urb; + unsigned char *buf; + unsigned int pipe; + int err, size; + + if (!data->intr_ep) + return -ENODEV; + + urb = usb_alloc_urb(0, mem_flags); + if (!urb) + return -ENOMEM; + + size = le16_to_cpu(data->intr_ep->wMaxPacketSize); + + buf = kmalloc(size, mem_flags); + if (!buf) { + usb_free_urb(urb); + return -ENOMEM; + } + + AICBT_DBG("%s: mMaxPacketSize %d, bEndpointAddress 0x%02x", + __func__, size, data->intr_ep->bEndpointAddress); + + pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress); + + usb_fill_int_urb(urb, data->udev, pipe, buf, size, + btusb_intr_complete, hdev, + data->intr_ep->bInterval); + + urb->transfer_flags |= URB_FREE_BUFFER; + + usb_anchor_urb(urb, &data->intr_anchor); + + err = usb_submit_urb(urb, mem_flags); + if (err < 0) { + AICBT_ERR("%s: Failed to submit urb %p, err %d", + __func__, urb, err); + usb_unanchor_urb(urb); + } + + usb_free_urb(urb); + + return err; +} + +static void btusb_bulk_complete(struct urb *urb) +{ + struct hci_dev *hdev = urb->context; + struct btusb_data *data = GET_DRV_DATA(hdev); + int err; + + AICBT_DBG("%s: urb %p status %d count %d", + __func__, urb, urb->status, urb->actual_length); + + if (!test_bit(HCI_RUNNING, &hdev->flags)) { + printk("%s HCI_RUNNING\n", __func__); + return; + } + if (urb->status == 0) { + hdev->stat.byte_rx += urb->actual_length; + +#if (CONFIG_BLUEDROID) || (HCI_VERSION_CODE < KERNEL_VERSION(3, 18, 0)) + if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT, + urb->transfer_buffer, + urb->actual_length) < 0) { + AICBT_ERR("%s: Corrupted ACL packet", __func__); + hdev->stat.err_rx++; + } +#else + if (data->recv_bulk(data, urb->transfer_buffer, + urb->actual_length) < 0) { + AICBT_ERR("%s Corrupted ACL packet", hdev->name); + hdev->stat.err_rx++; + } +#endif + + } + /* Avoid suspend failed when usb_kill_urb */ + else if(urb->status == -ENOENT) { + printk("%s ENOENT\n", __func__); + return; + } + AICBT_DBG("%s: OUT", __func__); + + if (!test_bit(BTUSB_BULK_RUNNING, &data->flags)) { + printk("%s BTUSB_BULK_RUNNING\n", __func__); + return; + } + usb_anchor_urb(urb, &data->bulk_anchor); + usb_mark_last_busy(data->udev); + + //printk("LIULI bulk submit\n"); + err = usb_submit_urb(urb, GFP_ATOMIC); + if (err < 0) { + /* -EPERM: urb is being killed; + * -ENODEV: device got disconnected */ + if (err != -EPERM && err != -ENODEV) + AICBT_ERR("btusb_bulk_complete %s urb %p failed to resubmit (%d)", + hdev->name, urb, -err); + usb_unanchor_urb(urb); + } +} + +static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags) +{ + struct btusb_data *data = GET_DRV_DATA(hdev); + struct urb *urb; + unsigned char *buf; + unsigned int pipe; + int err, size = HCI_MAX_FRAME_SIZE; + + AICBT_DBG("%s: hdev name %s", __func__, hdev->name); + AICBT_DBG("%s: mMaxPacketSize %d, bEndpointAddress 0x%02x", + __func__, size, data->bulk_rx_ep->bEndpointAddress); + + if (!data->bulk_rx_ep) + return -ENODEV; + + urb = usb_alloc_urb(0, mem_flags); + if (!urb) + return -ENOMEM; + + buf = kmalloc(size, mem_flags); + if (!buf) { + usb_free_urb(urb); + return -ENOMEM; + } + + pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress); + + usb_fill_bulk_urb(urb, data->udev, pipe, + buf, size, btusb_bulk_complete, hdev); + + urb->transfer_flags |= URB_FREE_BUFFER; + + usb_mark_last_busy(data->udev); + usb_anchor_urb(urb, &data->bulk_anchor); + + err = usb_submit_urb(urb, mem_flags); + if (err < 0) { + AICBT_ERR("%s: Failed to submit urb %p, err %d", __func__, urb, err); + usb_unanchor_urb(urb); + } + + usb_free_urb(urb); + + return err; +} + +static void btusb_isoc_complete(struct urb *urb) +{ + struct hci_dev *hdev = urb->context; + struct btusb_data *data = GET_DRV_DATA(hdev); + int i, err; + unsigned int total_length = 0; + + AICBT_DBG("%s: urb %p status %d count %d", + __func__, urb, urb->status, urb->actual_length); + + if (!test_bit(HCI_RUNNING, &hdev->flags)) + return; + + if (urb->status == 0) { + for (i = 0; i < urb->number_of_packets; i++) { + unsigned int offset = urb->iso_frame_desc[i].offset; + unsigned int length = urb->iso_frame_desc[i].actual_length; + //u8 *data = (u8 *)(urb->transfer_buffer + offset); + //AICBT_DBG("%d,%d ,%x,%x,%x s %d.", + //offset, length, data[0], data[1],data[2],urb->iso_frame_desc[i].status); + + if(total_length >= urb->actual_length){ + AICBT_ERR("total_len >= actual_length ,return"); + break; + } + total_length += length; + + if (urb->iso_frame_desc[i].status) + continue; + + hdev->stat.byte_rx += length; + if(length){ +#if (CONFIG_BLUEDROID) || (HCI_VERSION_CODE < KERNEL_VERSION(3, 18, 0)) + if (hci_recv_fragment(hdev, HCI_SCODATA_PKT, + urb->transfer_buffer + offset, + length) < 0) { + AICBT_ERR("%s: Corrupted SCO packet", __func__); + hdev->stat.err_rx++; + } +#else + if (btusb_recv_isoc(data, urb->transfer_buffer + offset, + length) < 0) { + AICBT_ERR("%s corrupted SCO packet", + hdev->name); + hdev->stat.err_rx++; + } +#endif + + } + } + } + /* Avoid suspend failed when usb_kill_urb */ + else if(urb->status == -ENOENT) { + return; + } + + + if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags)) + return; + + usb_anchor_urb(urb, &data->isoc_anchor); + i = 0; +retry: + err = usb_submit_urb(urb, GFP_ATOMIC); + if (err < 0) { + /* -EPERM: urb is being killed; + * -ENODEV: device got disconnected */ + if (err != -EPERM && err != -ENODEV) + AICBT_ERR("%s: Failed to re-sumbit urb %p, retry %d, err %d", + __func__, urb, i, err); + if (i < 10) { + i++; + mdelay(1); + goto retry; + } + + usb_unanchor_urb(urb); + } +} + +static inline void fill_isoc_descriptor(struct urb *urb, int len, int mtu) +{ + int i, offset = 0; + + AICBT_DBG("%s: len %d mtu %d", __func__, len, mtu); + + for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu; + i++, offset += mtu, len -= mtu) { + urb->iso_frame_desc[i].offset = offset; + urb->iso_frame_desc[i].length = mtu; + } + + if (len && i < BTUSB_MAX_ISOC_FRAMES) { + urb->iso_frame_desc[i].offset = offset; + urb->iso_frame_desc[i].length = len; + i++; + } + + urb->number_of_packets = i; +} + +static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags) +{ + struct btusb_data *data = GET_DRV_DATA(hdev); + struct urb *urb; + unsigned char *buf; + unsigned int pipe; + int err, size; + int interval; + + if (!data->isoc_rx_ep) + return -ENODEV; + AICBT_DBG("%s: mMaxPacketSize %d, bEndpointAddress 0x%02x", + __func__, size, data->isoc_rx_ep->bEndpointAddress); + + urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags); + if (!urb) + return -ENOMEM; + + size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) * + BTUSB_MAX_ISOC_FRAMES; + + buf = kmalloc(size, mem_flags); + if (!buf) { + usb_free_urb(urb); + return -ENOMEM; + } + + pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress); + + urb->dev = data->udev; + urb->pipe = pipe; + urb->context = hdev; + urb->complete = btusb_isoc_complete; + if (urb->dev->speed == USB_SPEED_HIGH || urb->dev->speed >= USB_SPEED_SUPER) { + /* make sure interval is within allowed range */ + interval = clamp((int)data->isoc_rx_ep->bInterval, 1, 16); + urb->interval = 1 << (interval - 1); + } else { + urb->interval = data->isoc_rx_ep->bInterval; + } + + AICBT_INFO("urb->interval %d \r\n", urb->interval); + + urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP; + urb->transfer_buffer = buf; + urb->transfer_buffer_length = size; + + fill_isoc_descriptor(urb, size, + le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize)); + + usb_anchor_urb(urb, &data->isoc_anchor); + + err = usb_submit_urb(urb, mem_flags); + if (err < 0) { + AICBT_ERR("%s: Failed to submit urb %p, err %d", __func__, urb, err); + usb_unanchor_urb(urb); + } + + usb_free_urb(urb); + + return err; +} + +static void btusb_tx_complete(struct urb *urb) +{ + struct sk_buff *skb = urb->context; + struct hci_dev *hdev = (struct hci_dev *) skb->dev; + struct btusb_data *data = GET_DRV_DATA(hdev); + + 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++; + +done: + spin_lock(&data->txlock); + data->tx_in_flight--; + spin_unlock(&data->txlock); + + kfree(urb->setup_packet); + + kfree_skb(skb); +} + +static void btusb_isoc_tx_complete(struct urb *urb) +{ + struct sk_buff *skb = urb->context; + struct hci_dev *hdev = (struct hci_dev *) skb->dev; + + AICBT_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 (!urb->status) + hdev->stat.byte_tx += urb->transfer_buffer_length; + else + hdev->stat.err_tx++; + } else + AICBT_ERR("%s: skb 0x%p hdev 0x%p", __func__, skb, hdev); + +done: + kfree(urb->setup_packet); + + kfree_skb(skb); +} + +#if (CONFIG_BLUEDROID == 0) +#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 0, 9) +static int btusb_shutdown(struct hci_dev *hdev) +{ + struct sk_buff *skb; + printk("aic %s\n", __func__); + + skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT); + if (IS_ERR(skb)) { + printk("HCI reset during shutdown failed\n"); + return PTR_ERR(skb); + } + kfree_skb(skb); + + return 0; +} +#endif +#endif //(CONFIG_BLUEDROID == 0) + +static int btusb_open(struct hci_dev *hdev) +{ + struct btusb_data *data = GET_DRV_DATA(hdev); + int err = 0; + + AICBT_INFO("%s: Start", __func__); + + err = usb_autopm_get_interface(data->intf); + if (err < 0) + return err; + + data->intf->needs_remote_wakeup = 1; + +#if (CONFIG_BLUEDROID == 0) + //err = download_patch(data->fw_info,1); + printk(" download_patch %d", err); + if (err < 0) { + goto failed; + } +#endif + + + if (test_and_set_bit(HCI_RUNNING, &hdev->flags)){ + goto done; + } + + if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags)){ + goto done; + } + + err = btusb_submit_intr_urb(hdev, GFP_KERNEL); + if (err < 0) + goto failed; + + err = btusb_submit_bulk_urb(hdev, GFP_KERNEL); + if (err < 0) { + mdelay(URB_CANCELING_DELAY_MS); + usb_kill_anchored_urbs(&data->intr_anchor); + goto failed; + } + + set_bit(BTUSB_BULK_RUNNING, &data->flags); + btusb_submit_bulk_urb(hdev, GFP_KERNEL); + +done: + usb_autopm_put_interface(data->intf); + AICBT_INFO("%s: End", __func__); + return 0; + +failed: + clear_bit(BTUSB_INTR_RUNNING, &data->flags); + clear_bit(HCI_RUNNING, &hdev->flags); + usb_autopm_put_interface(data->intf); + AICBT_ERR("%s: Failed", __func__); + return err; +} + +static void btusb_stop_traffic(struct btusb_data *data) +{ + mdelay(URB_CANCELING_DELAY_MS); + usb_kill_anchored_urbs(&data->intr_anchor); + usb_kill_anchored_urbs(&data->bulk_anchor); + usb_kill_anchored_urbs(&data->isoc_anchor); +} + +static int btusb_close(struct hci_dev *hdev) +{ + struct btusb_data *data = GET_DRV_DATA(hdev); +#if (CONFIG_BLUEDROID) || (HCI_VERSION_CODE < KERNEL_VERSION(4, 1, 0)) + int i; +#endif + int err; + + AICBT_INFO("%s: hci running %lu", __func__, hdev->flags & HCI_RUNNING); + + if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)){ + return 0; + } + + if (!test_and_clear_bit(BTUSB_INTR_RUNNING, &data->flags)){ + return 0; + } + +#if (CONFIG_BLUEDROID) || (HCI_VERSION_CODE < KERNEL_VERSION(4, 1, 0)) + for (i = 0; i < NUM_REASSEMBLY; i++) { + if (hdev->reassembly[i]) { + AICBT_DBG("%s: free ressembly[%d]", __func__, i); + kfree_skb(hdev->reassembly[i]); + hdev->reassembly[i] = NULL; + } + } +#endif + + cancel_work_sync(&data->work); + cancel_work_sync(&data->waker); + + clear_bit(BTUSB_ISOC_RUNNING, &data->flags); + clear_bit(BTUSB_BULK_RUNNING, &data->flags); + clear_bit(BTUSB_INTR_RUNNING, &data->flags); + + btusb_stop_traffic(data); + err = usb_autopm_get_interface(data->intf); + if (err < 0) + goto failed; + + data->intf->needs_remote_wakeup = 0; + usb_autopm_put_interface(data->intf); + +failed: + mdelay(URB_CANCELING_DELAY_MS); + usb_scuttle_anchored_urbs(&data->deferred); + return 0; +} + +static int btusb_flush(struct hci_dev *hdev) +{ + struct btusb_data *data = GET_DRV_DATA(hdev); + + AICBT_DBG("%s", __func__); + + mdelay(URB_CANCELING_DELAY_MS); + usb_kill_anchored_urbs(&data->tx_anchor); + + return 0; +} + +#ifdef CONFIG_SCO_OVER_HCI +static void btusb_isoc_snd_tx_complete(struct urb *urb); + +static int snd_send_sco_frame(struct sk_buff *skb) +{ + struct hci_dev *hdev = (struct hci_dev *) skb->dev; + + struct btusb_data *data = GET_DRV_DATA(hdev); + //struct usb_ctrlrequest *dr; + struct urb *urb; + unsigned int pipe; + int err; + + AICBT_DBG("%s:pkt type %d, packet_len : %d", + __func__,bt_cb(skb)->pkt_type, skb->len); + + if (!hdev && !test_bit(HCI_RUNNING, &hdev->flags)) + return -EBUSY; + + if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1) { + kfree(skb); + return -ENODEV; + } + + urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC); + if (!urb) { + AICBT_ERR("%s: Failed to allocate mem for sco pkts", __func__); + kfree(skb); + return -ENOMEM; + } + + pipe = usb_sndisocpipe(data->udev, data->isoc_tx_ep->bEndpointAddress); + + usb_fill_int_urb(urb, data->udev, pipe, + skb->data, skb->len, btusb_isoc_snd_tx_complete, + skb, data->isoc_tx_ep->bInterval); + + urb->transfer_flags = URB_ISO_ASAP; + + fill_isoc_descriptor(urb, skb->len, + le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize)); + + hdev->stat.sco_tx++; + + usb_anchor_urb(urb, &data->tx_anchor); + + err = usb_submit_urb(urb, GFP_ATOMIC); + if (err < 0) { + AICBT_ERR("%s: Failed to submit urb %p, pkt type %d, err %d", + __func__, urb, bt_cb(skb)->pkt_type, err); + kfree(urb->setup_packet); + usb_unanchor_urb(urb); + } else + usb_mark_last_busy(data->udev); + usb_free_urb(urb); + + return err; + +} + +static bool snd_copy_send_sco_data( AIC_sco_card_t *pSCOSnd) +{ + struct snd_pcm_runtime *runtime = pSCOSnd->playback.substream->runtime; + unsigned int frame_bytes = 2, frames1; + const u8 *source; + + snd_pcm_uframes_t period_size = runtime->period_size; + int i, count; + u8 buffer[period_size * 3]; + int sco_packet_bytes = pSCOSnd->playback.sco_packet_bytes; + struct sk_buff *skb; + + count = frames_to_bytes(runtime, period_size)/sco_packet_bytes; + skb = bt_skb_alloc(((sco_packet_bytes + HCI_SCO_HDR_SIZE) * count), GFP_ATOMIC); + 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; + + AICBT_DBG("%s, buffer_pos:%d sco_handle:%d sco_packet_bytes:%d count:%d", __FUNCTION__, pSCOSnd->playback.buffer_pos, pSCOSnd->usb_data->sco_handle, + sco_packet_bytes, count); + + source = runtime->dma_area + pSCOSnd->playback.buffer_pos * frame_bytes; + + if (pSCOSnd->playback.buffer_pos + period_size <= runtime->buffer_size) { + memcpy(buffer, source, period_size * frame_bytes); + } else { + /* wrap around at end of ring buffer */ + frames1 = runtime->buffer_size - pSCOSnd->playback.buffer_pos; + memcpy(buffer, source, frames1 * frame_bytes); + memcpy(&buffer[frames1 * frame_bytes], + runtime->dma_area, (period_size - frames1) * frame_bytes); + } + + pSCOSnd->playback.buffer_pos += period_size; + if ( pSCOSnd->playback.buffer_pos >= runtime->buffer_size) + pSCOSnd->playback.buffer_pos -= runtime->buffer_size; + + for(i = 0; i < count; i++) { + *((__u16 *)(skb->data + i * (sco_packet_bytes + HCI_SCO_HDR_SIZE))) = pSCOSnd->usb_data->sco_handle; + *((__u8 *)(skb->data + i*(sco_packet_bytes + HCI_SCO_HDR_SIZE) + 2)) = sco_packet_bytes; + memcpy((skb->data + i * (sco_packet_bytes + HCI_SCO_HDR_SIZE) + HCI_SCO_HDR_SIZE), + &buffer[sco_packet_bytes * i], sco_packet_bytes); + } + + if(test_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states)) { + snd_pcm_period_elapsed(pSCOSnd->playback.substream); + } + snd_send_sco_frame(skb); + return true; +} + +static void btusb_isoc_snd_tx_complete(struct urb *urb) +{ + struct sk_buff *skb = urb->context; + struct hci_dev *hdev = (struct hci_dev *) skb->dev; + struct btusb_data *data = GET_DRV_DATA(hdev); + AIC_sco_card_t *pSCOSnd = data->pSCOSnd; + + AICBT_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 (!urb->status) + hdev->stat.byte_tx += urb->transfer_buffer_length; + else + hdev->stat.err_tx++; + } else + AICBT_ERR("%s: skb 0x%p hdev 0x%p", __func__, skb, hdev); + +done: + kfree(urb->setup_packet); + kfree_skb(skb); + if(test_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states)){ + snd_copy_send_sco_data(pSCOSnd); + //schedule_work(&pSCOSnd->send_sco_work); + } +} + +static void playback_work(struct work_struct *work) +{ + AIC_sco_card_t *pSCOSnd = container_of(work, AIC_sco_card_t, send_sco_work); + + snd_copy_send_sco_data(pSCOSnd); +} + +#endif + +#if (CONFIG_BLUEDROID) || (HCI_VERSION_CODE < KERNEL_VERSION(3, 13, 0)) +int btusb_send_frame(struct sk_buff *skb) +{ + struct hci_dev *hdev = (struct hci_dev *) skb->dev; +#else +int btusb_send_frame(struct hci_dev *hdev, struct sk_buff *skb) +{ +#endif + //struct hci_dev *hdev = (struct hci_dev *) skb->dev; + + struct btusb_data *data = GET_DRV_DATA(hdev); + struct usb_ctrlrequest *dr; + struct urb *urb; + unsigned int pipe; + int err = 0; + int retries = 0; + u16 *opcode = NULL; + + AICBT_DBG("%s: hdev %p, btusb data %p, pkt type %d", + __func__, hdev, data, bt_cb(skb)->pkt_type); + + //printk("aic %d %d\r\n", bt_cb(skb)->pkt_type, skb->len); + if (!test_bit(HCI_RUNNING, &hdev->flags)) + return -EBUSY; + +#if (CONFIG_BLUEDROID == 0) +#if HCI_VERSION_CODE >= KERNEL_VERSION(3, 13, 0) + skb->dev = (void *)hdev; +#endif +#endif + + switch (bt_cb(skb)->pkt_type) { + case HCI_COMMAND_PKT: + print_command(skb); + urb = usb_alloc_urb(0, GFP_ATOMIC); + if (!urb) + return -ENOMEM; + + dr = kmalloc(sizeof(*dr), GFP_ATOMIC); + if (!dr) { + usb_free_urb(urb); + return -ENOMEM; + } + + dr->bRequestType = data->cmdreq_type; + dr->bRequest = 0; + dr->wIndex = 0; + dr->wValue = 0; + dr->wLength = __cpu_to_le16(skb->len); + + pipe = usb_sndctrlpipe(data->udev, 0x00); + + usb_fill_control_urb(urb, data->udev, pipe, (void *) dr, + skb->data, skb->len, btusb_tx_complete, skb); + + hdev->stat.cmd_tx++; + break; + + case HCI_ACLDATA_PKT: + if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) { + print_command(skb); + opcode = (u16*)(skb->data); + printk("aic cmd:0x%04x", *opcode); + } else { + print_acl(skb, 1); + } + if (!data->bulk_tx_ep) + return -ENODEV; + + urb = usb_alloc_urb(0, GFP_ATOMIC); + if (!urb) + return -ENOMEM; + + pipe = usb_sndbulkpipe(data->udev, + data->bulk_tx_ep->bEndpointAddress); + + usb_fill_bulk_urb(urb, data->udev, pipe, + skb->data, skb->len, btusb_tx_complete, skb); + + hdev->stat.acl_tx++; + break; + + case HCI_SCODATA_PKT: + print_sco(skb, 1); + if (!data->isoc_tx_ep || SCO_NUM < 1) { + kfree(skb); + return -ENODEV; + } + + urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC); + if (!urb) { + AICBT_ERR("%s: Failed to allocate mem for sco pkts", __func__); + kfree(skb); + return -ENOMEM; + } + + pipe = usb_sndisocpipe(data->udev, data->isoc_tx_ep->bEndpointAddress); + + usb_fill_int_urb(urb, data->udev, pipe, + skb->data, skb->len, btusb_isoc_tx_complete, + skb, data->isoc_tx_ep->bInterval); + + urb->transfer_flags = URB_ISO_ASAP; + + fill_isoc_descriptor(urb, skb->len, + le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize)); + + hdev->stat.sco_tx++; + goto skip_waking; + + default: + return -EILSEQ; + } + + err = inc_tx(data); + if (err) { + usb_anchor_urb(urb, &data->deferred); + schedule_work(&data->waker); + err = 0; + goto done; + } + +skip_waking: + usb_anchor_urb(urb, &data->tx_anchor); +retry: + err = usb_submit_urb(urb, GFP_ATOMIC); + if (err < 0) { + AICBT_ERR("%s: Failed to submit urb %p, pkt type %d, err %d, retries %d", + __func__, urb, bt_cb(skb)->pkt_type, err, retries); + if ((bt_cb(skb)->pkt_type != HCI_SCODATA_PKT) && (retries < 10)) { + mdelay(1); + + if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) + print_error_command(skb); + retries++; + goto retry; + } + kfree(urb->setup_packet); + usb_unanchor_urb(urb); + } else + usb_mark_last_busy(data->udev); + usb_free_urb(urb); + +done: + return err; +} + +#if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 4, 0) +static void btusb_destruct(struct hci_dev *hdev) +{ + struct btusb_data *data = GET_DRV_DATA(hdev); + + AICBT_DBG("%s: name %s", __func__, hdev->name); + + kfree(data); +} +#endif + +static void btusb_notify(struct hci_dev *hdev, unsigned int evt) +{ + struct btusb_data *data = GET_DRV_DATA(hdev); + + AICBT_DBG("%s: name %s, evt %d", __func__, hdev->name, evt); + + if (SCO_NUM != data->sco_num) { + data->sco_num = SCO_NUM; + schedule_work(&data->work); + } +} + +static inline int set_isoc_interface(struct hci_dev *hdev, int altsetting) +{ + struct btusb_data *data = GET_DRV_DATA(hdev); + struct usb_interface *intf = data->isoc; + struct usb_endpoint_descriptor *ep_desc; + int i, err; + + if (!data->isoc) + return -ENODEV; + + err = usb_set_interface(data->udev, 1, altsetting); + if (err < 0) { + AICBT_ERR("%s: Failed to set interface, altsetting %d, err %d", + __func__, altsetting, err); + return err; + } + + data->isoc_altsetting = altsetting; + + data->isoc_tx_ep = NULL; + data->isoc_rx_ep = NULL; + + for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) { + ep_desc = &intf->cur_altsetting->endpoint[i].desc; + + if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) { + data->isoc_tx_ep = ep_desc; + continue; + } + + if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) { + data->isoc_rx_ep = ep_desc; + continue; + } + } + + if (!data->isoc_tx_ep || !data->isoc_rx_ep) { + AICBT_ERR("%s: Invalid SCO descriptors", __func__); + return -ENODEV; + } + + AICBT_ERR("%s: hdev->reassembly implemant\r\n", + __func__); + +#if CONFIG_BLUEDROID + if(hdev->reassembly[HCI_SCODATA_PKT - 1]) { + kfree_skb(hdev->reassembly[HCI_SCODATA_PKT - 1]); + hdev->reassembly[HCI_SCODATA_PKT - 1] = NULL; + } +#endif + return 0; +} + +static void set_select_msbc(enum CODEC_TYPE type) +{ + printk("%s codec type = %d", __func__, (int)type); + codec_type = type; +} + +static enum CODEC_TYPE check_select_msbc(void) +{ + return codec_type; +} + +#ifdef CONFIG_SCO_OVER_HCI +static int check_controller_support_msbc( struct usb_device *udev) +{ + //fix this in the future,when new card support msbc decode and encode + AICBT_INFO("%s:pid = 0x%02x, vid = 0x%02x",__func__,udev->descriptor.idProduct, udev->descriptor.idVendor); + switch (udev->descriptor.idProduct) { + + default: + return 0; + } + return 0; +} +#endif +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; + int err; + int new_alts; +#ifdef CONFIG_SCO_OVER_HCI + AIC_sco_card_t *pSCOSnd = data->pSCOSnd; +#endif + printk("%s data->sco_num:%d \r\n", __func__, data->sco_num); + + if (data->sco_num > 0) { + if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) { + err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf); + if (err < 0) { + clear_bit(BTUSB_ISOC_RUNNING, &data->flags); + mdelay(URB_CANCELING_DELAY_MS); + usb_kill_anchored_urbs(&data->isoc_anchor); + printk("%s usb_kill_anchored_urbs after \r\n", __func__); + return; + } + + set_bit(BTUSB_DID_ISO_RESUME, &data->flags); + } + + hdev->voice_setting = 93; + AICBT_INFO("%s voice settings = 0x%04x", __func__, hdev->voice_setting); + if (!(hdev->voice_setting & 0x0003)) { + if(data->sco_num == 1) + if(check_select_msbc()) { + new_alts = 1; + } else { + new_alts = 2; + } + else { + AICBT_INFO("%s: we don't support mutiple sco link for cvsd", __func__); + return; + } + } else{ + if(check_select_msbc()) { + if(data->sco_num == 1) + new_alts = 1; + else { + AICBT_INFO("%s: we don't support mutiple sco link for msbc", __func__); + return; + } + } else { + new_alts = 2; + } + } + if (data->isoc_altsetting != new_alts) { + + clear_bit(BTUSB_ISOC_RUNNING, &data->flags); + mdelay(URB_CANCELING_DELAY_MS); + usb_kill_anchored_urbs(&data->isoc_anchor); + + printk("%s set_isoc_interface in \r\n", __func__); + if (set_isoc_interface(hdev, new_alts) < 0) + return; + + } + + printk("%s set_isoc_interface out \r\n", __func__); + + if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) { + printk("%s btusb_submit_isoc_urb\r\n", __func__); + if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0) + clear_bit(BTUSB_ISOC_RUNNING, &data->flags); + else + btusb_submit_isoc_urb(hdev, GFP_KERNEL); + } +#ifdef CONFIG_SCO_OVER_HCI + if(test_bit(BTUSB_ISOC_RUNNING, &data->flags)) { + set_bit(USB_CAPTURE_RUNNING, &data->pSCOSnd->states); + set_bit(USB_PLAYBACK_RUNNING, &data->pSCOSnd->states); + } + if (test_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states)) { + schedule_work(&pSCOSnd->send_sco_work); + AICBT_INFO("%s: play_timer restart", __func__); + } +#endif + } else { + clear_bit(BTUSB_ISOC_RUNNING, &data->flags); +#ifdef CONFIG_SCO_OVER_HCI + clear_bit(USB_CAPTURE_RUNNING, &data->pSCOSnd->states); + clear_bit(USB_PLAYBACK_RUNNING, &data->pSCOSnd->states); + //AIC_sco_card_t *pSCOSnd = data->pSCOSnd; + if (test_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states)) { + mod_timer(&snd_cap_timer.play_timer,jiffies + msecs_to_jiffies(30)); + AICBT_INFO("%s: play_timer start", __func__); + } +#endif + mdelay(URB_CANCELING_DELAY_MS); + 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); + } +} + +static void btusb_waker(struct work_struct *work) +{ + struct btusb_data *data = container_of(work, struct btusb_data, waker); + int err; + + AICBT_DBG("%s", __func__); + + err = usb_autopm_get_interface(data->intf); + if (err < 0) + return; + + usb_autopm_put_interface(data->intf); +} + +int bt_pm_notify(struct notifier_block *notifier, ulong pm_event, void *unused) +{ + struct btusb_data *data; + firmware_info *fw_info; + struct usb_device *udev; + + AICBT_INFO("%s: pm event %ld", __func__, pm_event); + + data = container_of(notifier, struct btusb_data, pm_notifier); + fw_info = data->fw_info; + udev = fw_info->udev; + + switch (pm_event) { + case PM_SUSPEND_PREPARE: + case PM_HIBERNATION_PREPARE: +#if 0 + patch_entry->fw_len = load_firmware(fw_info, &patch_entry->fw_cache); + if (patch_entry->fw_len <= 0) { + /* We may encount failure in loading firmware, just give a warning */ + AICBT_WARN("%s: Failed to load firmware", __func__); + } +#endif + if (!device_may_wakeup(&udev->dev)) { +#if (CONFIG_RESET_RESUME || CONFIG_BLUEDROID) + AICBT_INFO("%s:remote wakeup not supported, reset resume supported", __func__); +#else + fw_info->intf->needs_binding = 1; + AICBT_INFO("%s:remote wakeup not supported, binding needed", __func__); +#endif + } + break; + + case PM_POST_SUSPEND: + case PM_POST_HIBERNATION: + case PM_POST_RESTORE: +#if 0 + /* Reclaim fw buffer when bt usb resumed */ + if (patch_entry->fw_len > 0) { + kfree(patch_entry->fw_cache); + patch_entry->fw_cache = NULL; + patch_entry->fw_len = 0; + } +#endif + +#if BTUSB_RPM + usb_disable_autosuspend(udev); + usb_enable_autosuspend(udev); + pm_runtime_set_autosuspend_delay(&(udev->dev), 2000); +#endif + break; + + default: + break; + } + + return NOTIFY_DONE; +} + +int bt_reboot_notify(struct notifier_block *notifier, ulong pm_event, void *unused) +{ + struct btusb_data *data; + firmware_info *fw_info; + struct usb_device *udev; + + AICBT_INFO("%s: pm event %ld", __func__, pm_event); + + data = container_of(notifier, struct btusb_data, reboot_notifier); + fw_info = data->fw_info; + udev = fw_info->udev; + + switch (pm_event) { + case SYS_DOWN: + AICBT_DBG("%s:system down or restart", __func__); + break; + + case SYS_HALT: + case SYS_POWER_OFF: +#if SUSPNED_DW_FW + cancel_work_sync(&data->work); + + btusb_stop_traffic(data); + mdelay(URB_CANCELING_DELAY_MS); + usb_kill_anchored_urbs(&data->tx_anchor); + + + if(fw_info_4_suspend) { + download_suspend_patch(fw_info_4_suspend,1); + } + else + AICBT_ERR("%s: Failed to download suspend fw", __func__); +#endif + +#ifdef SET_WAKEUP_DEVICE + set_wakeup_device_from_conf(fw_info_4_suspend); +#endif + AICBT_DBG("%s:system halt or power off", __func__); + break; + + default: + break; + } + + return NOTIFY_DONE; +} + + +#ifdef CONFIG_SCO_OVER_HCI +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0) +void aic_snd_capture_timeout(ulong data) +#else +void aic_snd_capture_timeout(struct timer_list *t) +#endif +{ + uint8_t null_data[255]; + struct btusb_data *usb_data; + +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0) + usb_data = (struct btusb_data *)data; +#else + usb_data = &snd_cap_timer.snd_usb_data; +#endif + aic_copy_capture_data_to_alsa(usb_data, null_data, snd_cap_timer.snd_sco_length/2); + //printk("%s enter\r\n", __func__); + mod_timer(&snd_cap_timer.cap_timer,jiffies + msecs_to_jiffies(3)); +} + +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0) +void aic_snd_play_timeout(ulong data) +#else +void aic_snd_play_timeout(struct timer_list *t) +#endif +{ + AIC_sco_card_t *pSCOSnd; + struct snd_pcm_runtime *runtime; + snd_pcm_uframes_t period_size; + int count; + struct btusb_data *usb_data; + int sco_packet_bytes; + +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0) + usb_data = (struct btusb_data *)data; +#else + usb_data = &snd_cap_timer.snd_usb_data; +#endif + pSCOSnd = usb_data->pSCOSnd; + + if(test_bit(USB_PLAYBACK_RUNNING, &pSCOSnd->states)) { + return; + } + + if(!test_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states)) { + return; + } + + runtime = pSCOSnd->playback.substream->runtime; + period_size = runtime->period_size; + sco_packet_bytes = pSCOSnd->playback.sco_packet_bytes; + count = frames_to_bytes(runtime, period_size)/sco_packet_bytes; + + pSCOSnd->playback.buffer_pos += period_size; + if ( pSCOSnd->playback.buffer_pos >= runtime->buffer_size) + pSCOSnd->playback.buffer_pos -= runtime->buffer_size; + + if(test_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states)) { + snd_pcm_period_elapsed(pSCOSnd->playback.substream); + } + //AICBT_DBG("%s,play_timer restart buffer_pos:%d sco_handle:%d sco_packet_bytes:%d count:%d", __FUNCTION__, pSCOSnd->playback.buffer_pos, pSCOSnd->usb_data->sco_handle, + //sco_packet_bytes, count); + mod_timer(&snd_cap_timer.play_timer,jiffies + msecs_to_jiffies(3*count)); +} + +static const struct snd_pcm_hardware snd_card_sco_capture_default = +{ + .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_NONINTERLEAVED | + SNDRV_PCM_ACCESS_RW_INTERLEAVED | SNDRV_PCM_INFO_FIFO_IN_FRAMES), + .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8, + .rates = (SNDRV_PCM_RATE_8000), + .rate_min = 8000, + .rate_max = 8000, + .channels_min = 1, + .channels_max = 1, + .buffer_bytes_max = 8 * 768, + .period_bytes_min = 48, + .period_bytes_max = 768, + .periods_min = 1, + .periods_max = 8, + .fifo_size = 8, + +}; + +static int snd_sco_capture_pcm_open(struct snd_pcm_substream * substream) +{ + AIC_sco_card_t *pSCOSnd = substream->private_data; + + AICBT_INFO("%s", __FUNCTION__); + pSCOSnd->capture.substream = substream; + + memcpy(&substream->runtime->hw, &snd_card_sco_capture_default, sizeof(struct snd_pcm_hardware)); + pSCOSnd->capture.buffer_pos = 0; + +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0) + init_timer(&snd_cap_timer.cap_timer); + snd_cap_timer.cap_timer.data = (unsigned long)pSCOSnd->usb_data; + snd_cap_timer.cap_timer.function = aic_snd_capture_timeout; +#else + timer_setup(&snd_cap_timer.cap_timer, aic_snd_capture_timeout, 0); + snd_cap_timer.snd_usb_data = *(pSCOSnd->usb_data); +#endif + + if(check_controller_support_msbc(pSCOSnd->dev)) { + substream->runtime->hw.rates |= SNDRV_PCM_RATE_16000; + substream->runtime->hw.rate_max = 16000; + substream->runtime->hw.period_bytes_min = 96; + substream->runtime->hw.period_bytes_max = 16 * 96; + substream->runtime->hw.buffer_bytes_max = 8 * 16 * 96; + } + set_bit(ALSA_CAPTURE_OPEN, &pSCOSnd->states); + return 0; +} + +static int snd_sco_capture_pcm_close(struct snd_pcm_substream *substream) +{ + AIC_sco_card_t *pSCOSnd = substream->private_data; + + del_timer(&snd_cap_timer.cap_timer); + clear_bit(ALSA_CAPTURE_OPEN, &pSCOSnd->states); + return 0; +} + +static int snd_sco_capture_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) +{ + AICBT_DBG("%s, cmd = %d", __FUNCTION__, cmd); + switch (cmd) + { + default: + return snd_pcm_lib_ioctl(substream, cmd, arg); + } + return 0; +} + +static int snd_sco_capture_pcm_hw_params(struct snd_pcm_substream * substream, struct snd_pcm_hw_params * hw_params) +{ + + int err; + struct snd_pcm_runtime *runtime = substream->runtime; + err = snd_pcm_lib_alloc_vmalloc_buffer(substream, params_buffer_bytes(hw_params)); + AICBT_INFO("%s,err : %d, runtime state : %d", __FUNCTION__, err, runtime->status->state); + return err; +} + +static int snd_sco_capture_pcm_hw_free(struct snd_pcm_substream * substream) +{ + AICBT_DBG("%s", __FUNCTION__); + return snd_pcm_lib_free_vmalloc_buffer(substream);; +} + +static int snd_sco_capture_pcm_prepare(struct snd_pcm_substream *substream) +{ + AIC_sco_card_t *pSCOSnd = substream->private_data; + struct snd_pcm_runtime *runtime = substream->runtime; + + AICBT_INFO("%s %d\n", __FUNCTION__, (int)runtime->period_size); + if (test_bit(DISCONNECTED, &pSCOSnd->states)) + return -ENODEV; + if (!test_bit(USB_CAPTURE_RUNNING, &pSCOSnd->states)) + return -EIO; + + if(runtime->rate == 8000) { + if(pSCOSnd->usb_data->isoc_altsetting != 2) + return -ENOEXEC; + pSCOSnd->capture.sco_packet_bytes = 48; + } + else if(runtime->rate == 16000 && check_controller_support_msbc(pSCOSnd->dev)) { + if(pSCOSnd->usb_data->isoc_altsetting != 4) + return -ENOEXEC; + pSCOSnd->capture.sco_packet_bytes = 96; + } + else if(pSCOSnd->usb_data->isoc_altsetting == 2) { + pSCOSnd->capture.sco_packet_bytes = 48; + } + else if(pSCOSnd->usb_data->isoc_altsetting == 1) { + pSCOSnd->capture.sco_packet_bytes = 24; + } + return 0; +} + +static int snd_sco_capture_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +{ + AIC_sco_card_t *pSCOSnd = substream->private_data; + AICBT_INFO("%s, cmd : %d", __FUNCTION__, cmd); + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + if (!test_bit(USB_CAPTURE_RUNNING, &pSCOSnd->states)) + return -EIO; + set_bit(ALSA_CAPTURE_RUNNING, &pSCOSnd->states); + return 0; + case SNDRV_PCM_TRIGGER_STOP: + clear_bit(ALSA_CAPTURE_RUNNING, &pSCOSnd->states); + return 0; + default: + return -EINVAL; + } +} + +static snd_pcm_uframes_t snd_sco_capture_pcm_pointer(struct snd_pcm_substream *substream) +{ + AIC_sco_card_t *pSCOSnd = substream->private_data; + + return pSCOSnd->capture.buffer_pos; +} + + +static struct snd_pcm_ops snd_sco_capture_pcm_ops = { + .open = snd_sco_capture_pcm_open, + .close = snd_sco_capture_pcm_close, + .ioctl = snd_sco_capture_ioctl, + .hw_params = snd_sco_capture_pcm_hw_params, + .hw_free = snd_sco_capture_pcm_hw_free, + .prepare = snd_sco_capture_pcm_prepare, + .trigger = snd_sco_capture_pcm_trigger, + .pointer = snd_sco_capture_pcm_pointer, +}; + + +static const struct snd_pcm_hardware snd_card_sco_playback_default = +{ + .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_NONINTERLEAVED | + SNDRV_PCM_ACCESS_RW_INTERLEAVED | SNDRV_PCM_INFO_FIFO_IN_FRAMES), + .formats = SNDRV_PCM_FMTBIT_S16_LE, + .rates = (SNDRV_PCM_RATE_8000), + .rate_min = 8000, + .rate_max = 8000, + .channels_min = 1, + .channels_max = 1, + .buffer_bytes_max = 8 * 768, + .period_bytes_min = 48, + .period_bytes_max = 768, + .periods_min = 1, + .periods_max = 8, + .fifo_size = 8, +}; + +static int snd_sco_playback_pcm_open(struct snd_pcm_substream * substream) +{ + AIC_sco_card_t *pSCOSnd = substream->private_data; + int err = 0; + +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0) + init_timer(&snd_cap_timer.play_timer); + snd_cap_timer.play_timer.data = (unsigned long)pSCOSnd->usb_data; + snd_cap_timer.play_timer.function = aic_snd_play_timeout; +#else + timer_setup(&snd_cap_timer.play_timer, aic_snd_play_timeout, 0); + snd_cap_timer.snd_usb_data = *(pSCOSnd->usb_data); +#endif + pSCOSnd->playback.buffer_pos = 0; + + AICBT_INFO("%s, rate : %d", __FUNCTION__, substream->runtime->rate); + memcpy(&substream->runtime->hw, &snd_card_sco_playback_default, sizeof(struct snd_pcm_hardware)); + if(check_controller_support_msbc(pSCOSnd->dev)) { + substream->runtime->hw.rates |= SNDRV_PCM_RATE_16000; + substream->runtime->hw.rate_max = 16000; + substream->runtime->hw.period_bytes_min = 96; + substream->runtime->hw.period_bytes_max = 16 * 96; + substream->runtime->hw.buffer_bytes_max = 8 * 16 * 96; + } + pSCOSnd->playback.substream = substream; + set_bit(ALSA_PLAYBACK_OPEN, &pSCOSnd->states); + + return err; +} + +static int snd_sco_playback_pcm_close(struct snd_pcm_substream *substream) +{ + AIC_sco_card_t *pSCOSnd = substream->private_data; + + del_timer(&snd_cap_timer.play_timer); + AICBT_INFO("%s: play_timer delete", __func__); + clear_bit(ALSA_PLAYBACK_OPEN, &pSCOSnd->states); + cancel_work_sync(&pSCOSnd->send_sco_work); + return 0; +} + +static int snd_sco_playback_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) +{ + AICBT_DBG("%s, cmd : %d", __FUNCTION__, cmd); + switch (cmd) + { + default: + return snd_pcm_lib_ioctl(substream, cmd, arg); + break; + } + return 0; +} + +static int snd_sco_playback_pcm_hw_params(struct snd_pcm_substream * substream, struct snd_pcm_hw_params * hw_params) +{ + int err; + err = snd_pcm_lib_alloc_vmalloc_buffer(substream, params_buffer_bytes(hw_params)); + return err; +} + +static int snd_sco_palyback_pcm_hw_free(struct snd_pcm_substream * substream) +{ + AICBT_DBG("%s", __FUNCTION__); + return snd_pcm_lib_free_vmalloc_buffer(substream); +} + +static int snd_sco_playback_pcm_prepare(struct snd_pcm_substream *substream) +{ + AIC_sco_card_t *pSCOSnd = substream->private_data; + struct snd_pcm_runtime *runtime = substream->runtime; + + AICBT_INFO("%s, bound_rate = %d", __FUNCTION__, runtime->rate); + + if (test_bit(DISCONNECTED, &pSCOSnd->states)) + return -ENODEV; + if (!test_bit(USB_PLAYBACK_RUNNING, &pSCOSnd->states)) + return -EIO; + + if(runtime->rate == 8000) { + if(pSCOSnd->usb_data->isoc_altsetting != 2) + return -ENOEXEC; + pSCOSnd->playback.sco_packet_bytes = 48; + } + else if(runtime->rate == 16000) { + if(pSCOSnd->usb_data->isoc_altsetting != 4) + return -ENOEXEC; + pSCOSnd->playback.sco_packet_bytes = 96; + } + + return 0; +} + +static int snd_sco_playback_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +{ + AIC_sco_card_t *pSCOSnd = substream->private_data; + + AICBT_INFO("%s, cmd = %d", __FUNCTION__, cmd); + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + if (!test_bit(USB_PLAYBACK_RUNNING, &pSCOSnd->states)) + return -EIO; + set_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states); + schedule_work(&pSCOSnd->send_sco_work); +#ifdef CONFIG_SCO_OVER_HCI + if (!test_bit(USB_PLAYBACK_RUNNING, &pSCOSnd->states)) { + AICBT_INFO("%s: play_timer cmd 1 start ", __func__); + mod_timer(&snd_cap_timer.play_timer,jiffies + msecs_to_jiffies(3)); + } +#endif + return 0; + case SNDRV_PCM_TRIGGER_STOP: + clear_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states); + return 0; + default: + return -EINVAL; + } +} + +static snd_pcm_uframes_t snd_sco_playback_pcm_pointer(struct snd_pcm_substream *substream) +{ + AIC_sco_card_t *pSCOSnd = substream->private_data; + + return pSCOSnd->playback.buffer_pos; +} + + +static struct snd_pcm_ops snd_sco_playback_pcm_ops = { + .open = snd_sco_playback_pcm_open, + .close = snd_sco_playback_pcm_close, + .ioctl = snd_sco_playback_ioctl, + .hw_params = snd_sco_playback_pcm_hw_params, + .hw_free = snd_sco_palyback_pcm_hw_free, + .prepare = snd_sco_playback_pcm_prepare, + .trigger = snd_sco_playback_pcm_trigger, + .pointer = snd_sco_playback_pcm_pointer, +}; + + +static AIC_sco_card_t* btusb_snd_init(struct usb_interface *intf, const struct usb_device_id *id, struct btusb_data *data) +{ + struct snd_card *card; + AIC_sco_card_t *pSCOSnd; + int err=0; + AICBT_INFO("%s", __func__); + err = snd_card_new(&intf->dev, + -1, AIC_SCO_ID, THIS_MODULE, + sizeof(AIC_sco_card_t), &card); + if (err < 0) { + AICBT_ERR("%s: sco snd card create fail", __func__); + return NULL; + } + // private data + pSCOSnd = (AIC_sco_card_t *)card->private_data; + pSCOSnd->card = card; + pSCOSnd->dev = interface_to_usbdev(intf); + pSCOSnd->usb_data = data; + + strcpy(card->driver, AIC_SCO_ID); + strcpy(card->shortname, "Aicsemi sco snd"); + sprintf(card->longname, "Aicsemi sco over hci: VID:0x%04x, PID:0x%04x", + id->idVendor, pSCOSnd->dev->descriptor.idProduct); + + err = snd_pcm_new(card, AIC_SCO_ID, 0, 1, 1, &pSCOSnd->pcm); + if (err < 0) { + AICBT_ERR("%s: sco snd card new pcm fail", __func__); + return NULL; + } + pSCOSnd->pcm->private_data = pSCOSnd; + sprintf(pSCOSnd->pcm->name, "sco_pcm:VID:0x%04x, PID:0x%04x", + id->idVendor, pSCOSnd->dev->descriptor.idProduct); + + snd_pcm_set_ops(pSCOSnd->pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sco_playback_pcm_ops); + snd_pcm_set_ops(pSCOSnd->pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sco_capture_pcm_ops); + + err = snd_card_register(card); + if (err < 0) { + AICBT_ERR("%s: sco snd card register card fail", __func__); + return NULL; + } + + spin_lock_init(&pSCOSnd->capture_lock); + spin_lock_init(&pSCOSnd->playback_lock); + INIT_WORK(&pSCOSnd->send_sco_work, playback_work); + return pSCOSnd; +} +#endif + +static int aicwf_usb_chipmatch(u16 vid, u16 pid){ + + if(pid == USB_PRODUCT_ID_AIC8801){ + g_chipid = PRODUCT_ID_AIC8801; + printk("%s USE AIC8801\r\n", __func__); + return 0; + }else if(pid == USB_PRODUCT_ID_AIC8800DC){ + g_chipid = PRODUCT_ID_AIC8800DC; + printk("%s USE AIC8800DC\r\n", __func__); + return 0; + }else if(pid == USB_PRODUCT_ID_AIC8800D80){ + g_chipid = PRODUCT_ID_AIC8800D80; + printk("%s USE AIC8800D80\r\n", __func__); + return 0; + }else{ + return -1; + } +} + + +static int btusb_probe(struct usb_interface *intf, const struct usb_device_id *id) +{ + struct usb_device *udev = interface_to_usbdev(intf); + struct usb_endpoint_descriptor *ep_desc; + u8 endpoint_num; + struct btusb_data *data; + struct hci_dev *hdev; + firmware_info *fw_info; + int i, err=0; + + bt_support = 1; + + AICBT_INFO("%s: usb_interface %p, bInterfaceNumber %d, idVendor 0x%04x, " + "idProduct 0x%04x", __func__, intf, + intf->cur_altsetting->desc.bInterfaceNumber, + id->idVendor, id->idProduct); + + aicwf_usb_chipmatch(id->idVendor, id->idProduct); + + /* interface numbers are hardcoded in the spec */ + if (intf->cur_altsetting->desc.bInterfaceNumber != 0) + return -ENODEV; + + AICBT_DBG("%s: can wakeup = %x, may wakeup = %x", __func__, + device_can_wakeup(&udev->dev), device_may_wakeup(&udev->dev)); + + data = aic_alloc(intf); + if (!data) + return -ENOMEM; + + for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) { + ep_desc = &intf->cur_altsetting->endpoint[i].desc; + + endpoint_num = usb_endpoint_num(ep_desc); + printk("endpoint num %d\n", endpoint_num); + + if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) { + data->intr_ep = ep_desc; + continue; + } + + if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) { + data->bulk_tx_ep = ep_desc; + continue; + } + + if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) { + data->bulk_rx_ep = ep_desc; + continue; + } + } + + if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) { + aic_free(data); + return -ENODEV; + } + + data->cmdreq_type = USB_TYPE_CLASS; + + data->udev = udev; + data->intf = intf; + + dlfw_dis_state = 0; + spin_lock_init(&queue_lock); + spin_lock_init(&dlfw_lock); + spin_lock_init(&data->lock); + + INIT_WORK(&data->work, btusb_work); + INIT_WORK(&data->waker, btusb_waker); + spin_lock_init(&data->txlock); + + init_usb_anchor(&data->tx_anchor); + init_usb_anchor(&data->intr_anchor); + init_usb_anchor(&data->bulk_anchor); + init_usb_anchor(&data->isoc_anchor); + init_usb_anchor(&data->deferred); + +#if (CONFIG_BLUEDROID == 0) +#if HCI_VERSION_CODE >= KERNEL_VERSION(3, 18, 0) + spin_lock_init(&data->rxlock); + data->recv_bulk = btusb_recv_bulk; +#endif +#endif + + + fw_info = firmware_info_init(intf); + if (fw_info) + data->fw_info = fw_info; + else { + AICBT_WARN("%s: Failed to initialize fw info", __func__); + /* Skip download patch */ + goto end; + } + + AICBT_INFO("%s: download begining...", __func__); + +#if CONFIG_BLUEDROID + mutex_lock(&btchr_mutex); +#endif + if(g_chipid == PRODUCT_ID_AIC8800DC){ + err = download_patch(data->fw_info,1); + } + +#if CONFIG_BLUEDROID + mutex_unlock(&btchr_mutex); +#endif + + AICBT_INFO("%s: download ending...", __func__); + if (err < 0) { + return err; + } + + + hdev = hci_alloc_dev(); + if (!hdev) { + aic_free(data); + data = NULL; + return -ENOMEM; + } + + HDEV_BUS = HCI_USB; + + data->hdev = hdev; + + SET_HCIDEV_DEV(hdev, &intf->dev); + + hdev->open = btusb_open; + hdev->close = btusb_close; + hdev->flush = btusb_flush; + hdev->send = btusb_send_frame; + hdev->notify = btusb_notify; +#if (CONFIG_BLUEDROID == 0) +#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 0, 9) + hdev->shutdown = btusb_shutdown; +#endif +#endif //(CONFIG_BLUEDROIF == 0) + +#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 4, 0) + hci_set_drvdata(hdev, data); +#else + hdev->driver_data = data; + hdev->destruct = btusb_destruct; + 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); */ + AICBT_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) { + err = usb_driver_claim_interface(&btusb_driver, + data->isoc, data); + if (err < 0) { + hci_free_dev(hdev); + hdev = NULL; + aic_free(data); + data = NULL; + return err; + } +#ifdef CONFIG_SCO_OVER_HCI + data->pSCOSnd = btusb_snd_init(intf, id, data); +#endif + } + + err = hci_register_dev(hdev); + if (err < 0) { + hci_free_dev(hdev); + hdev = NULL; + aic_free(data); + data = NULL; + return err; + } + + usb_set_intfdata(intf, data); + +//#ifdef CONFIG_HAS_EARLYSUSPEND +#if 0 + data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; + data->early_suspend.suspend = btusb_early_suspend; + data->early_suspend.resume = btusb_late_resume; + register_early_suspend(&data->early_suspend); +#else + data->pm_notifier.notifier_call = bt_pm_notify; + data->reboot_notifier.notifier_call = bt_reboot_notify; + register_pm_notifier(&data->pm_notifier); + register_reboot_notifier(&data->reboot_notifier); +#endif + +#if CONFIG_BLUEDROID + AICBT_INFO("%s: Check bt reset flag %d", __func__, bt_reset); + /* Report hci hardware error after everthing is ready, + * especially hci register is completed. Or, btchr_poll + * will get null hci dev when hotplug in. + */ + if (bt_reset == 1) { + hci_hardware_error(); + bt_reset = 0; + } else + bt_reset = 0; /* Clear and reset it anyway */ +#endif + +end: + return 0; +} + +static void btusb_disconnect(struct usb_interface *intf) +{ + struct btusb_data *data; + struct hci_dev *hdev = NULL; +#if CONFIG_BLUEDROID + wait_event_interruptible(bt_dlfw_wait, (check_set_dlfw_state_value(2) == 2)); +#endif + + bt_support = 0; + + AICBT_INFO("%s: usb_interface %p, bInterfaceNumber %d", + __func__, intf, intf->cur_altsetting->desc.bInterfaceNumber); + + data = usb_get_intfdata(intf); + + if (intf->cur_altsetting->desc.bInterfaceNumber != 0) + return; + + if (data) + hdev = data->hdev; + else { + AICBT_WARN("%s: Failed to get bt usb data[Null]", __func__); + return; + } + +#ifdef CONFIG_SCO_OVER_HCI + if (intf->cur_altsetting->desc.bInterfaceNumber == 0) { + AIC_sco_card_t *pSCOSnd = data->pSCOSnd; + if(!pSCOSnd) { + AICBT_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 + +//#ifdef CONFIG_HAS_EARLYSUSPEND +#if 0 + unregister_early_suspend(&data->early_suspend); +#else + unregister_pm_notifier(&data->pm_notifier); + unregister_reboot_notifier(&data->reboot_notifier); +#endif + + firmware_info_destroy(intf); + +#if CONFIG_BLUEDROID + if (test_bit(HCI_RUNNING, &hdev->flags)) { + AICBT_INFO("%s: Set BT reset flag", __func__); + bt_reset = 1; + } +#endif + + usb_set_intfdata(data->intf, NULL); + + if (data->isoc) + usb_set_intfdata(data->isoc, NULL); + + hci_unregister_dev(hdev); + + if (intf == data->isoc) + usb_driver_release_interface(&btusb_driver, data->intf); + else if (data->isoc) + usb_driver_release_interface(&btusb_driver, data->isoc); + +#if !CONFIG_BLUEDROID +#if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 4, 0) + __hci_dev_put(hdev); +#endif +#endif + + hci_free_dev(hdev); + aic_free(data); + data = NULL; + set_dlfw_state_value(0); +} + +#ifdef CONFIG_PM +static int btusb_suspend(struct usb_interface *intf, pm_message_t message) +{ + struct btusb_data *data = usb_get_intfdata(intf); + //firmware_info *fw_info = data->fw_info; + + AICBT_INFO("%s: event 0x%x, suspend count %d", __func__, + message.event, data->suspend_count); + + if (intf->cur_altsetting->desc.bInterfaceNumber != 0) + return 0; +#if 0 + if (!test_bit(HCI_RUNNING, &data->hdev->flags)) + set_bt_onoff(fw_info, 1); +#endif + if (data->suspend_count++) + return 0; + + spin_lock_irq(&data->txlock); + if (!((message.event & PM_EVENT_AUTO) && data->tx_in_flight)) { + set_bit(BTUSB_SUSPENDING, &data->flags); + spin_unlock_irq(&data->txlock); + } else { + spin_unlock_irq(&data->txlock); + data->suspend_count--; + AICBT_ERR("%s: Failed to enter suspend", __func__); + return -EBUSY; + } + + cancel_work_sync(&data->work); + + btusb_stop_traffic(data); + mdelay(URB_CANCELING_DELAY_MS); + usb_kill_anchored_urbs(&data->tx_anchor); + + return 0; +} + +static void play_deferred(struct btusb_data *data) +{ + struct urb *urb; + int err; + + while ((urb = usb_get_from_anchor(&data->deferred))) { + usb_anchor_urb(urb, &data->tx_anchor); + err = usb_submit_urb(urb, GFP_ATOMIC); + if (err < 0) { + AICBT_ERR("%s: Failed to submit urb %p, err %d", + __func__, urb, err); + kfree(urb->setup_packet); + usb_unanchor_urb(urb); + } else { + usb_mark_last_busy(data->udev); + } + usb_free_urb(urb); + + data->tx_in_flight++; + } + mdelay(URB_CANCELING_DELAY_MS); + usb_scuttle_anchored_urbs(&data->deferred); +} + +static int btusb_resume(struct usb_interface *intf) +{ + struct btusb_data *data = usb_get_intfdata(intf); + struct hci_dev *hdev = data->hdev; + int err = 0; + + AICBT_INFO("%s: Suspend count %d", __func__, data->suspend_count); + + if (intf->cur_altsetting->desc.bInterfaceNumber != 0) + return 0; + + if (--data->suspend_count) + return 0; + + #if 0 + /*check_fw_version to check the status of the BT Controller after USB Resume*/ + err = check_fw_version(fw_info); + if (err !=0) + { + AICBT_INFO("%s: BT Controller Power OFF And Return hci_hardware_error:%d", __func__, err); + hci_hardware_error(); + } + #endif + + AICBT_INFO("%s g_chipid %x\n", __func__, g_chipid); + if(g_chipid == PRODUCT_ID_AIC8800DC){ + if(data->fw_info){ + err = download_patch(data->fw_info,1); + }else{ + AICBT_WARN("%s: Failed to initialize fw info", __func__); + } + } + + #if 1 + if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) { + err = btusb_submit_intr_urb(hdev, GFP_NOIO); + if (err < 0) { + clear_bit(BTUSB_INTR_RUNNING, &data->flags); + goto failed; + } + } + #endif + + if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) { + err = btusb_submit_bulk_urb(hdev, GFP_NOIO); + if (err < 0) { + clear_bit(BTUSB_BULK_RUNNING, &data->flags); + goto failed; + } + + btusb_submit_bulk_urb(hdev, GFP_NOIO); + } + + if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) { + if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0) + clear_bit(BTUSB_ISOC_RUNNING, &data->flags); + else + btusb_submit_isoc_urb(hdev, GFP_NOIO); + } + + spin_lock_irq(&data->txlock); + play_deferred(data); + clear_bit(BTUSB_SUSPENDING, &data->flags); + spin_unlock_irq(&data->txlock); + schedule_work(&data->work); + + return 0; + +failed: + mdelay(URB_CANCELING_DELAY_MS); + usb_scuttle_anchored_urbs(&data->deferred); + spin_lock_irq(&data->txlock); + clear_bit(BTUSB_SUSPENDING, &data->flags); + spin_unlock_irq(&data->txlock); + + return err; +} +#endif + +static struct usb_driver btusb_driver = { + .name = "aic_btusb", + .probe = btusb_probe, + .disconnect = btusb_disconnect, +#ifdef CONFIG_PM + .suspend = btusb_suspend, + .resume = btusb_resume, +#if CONFIG_RESET_RESUME + .reset_resume = btusb_resume, +#endif +#endif + .id_table = btusb_table, + .supports_autosuspend = 1, +#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 7, 1) + .disable_hub_initiated_lpm = 1, +#endif +}; + +static int __init btusb_init(void) +{ + int err; + + AICBT_INFO("AICBT_RELEASE_NAME: %s",AICBT_RELEASE_NAME); + AICBT_INFO("AicSemi Bluetooth USB driver module init, version %s", VERSION); + AICBT_INFO("RELEASE DATE: 2023_0506_1635 \r\n"); +#if CONFIG_BLUEDROID + err = btchr_init(); + if (err < 0) { + /* usb register will go on, even bt char register failed */ + AICBT_ERR("Failed to register usb char device interfaces"); + } else + bt_char_dev_registered = 1; +#endif + err = usb_register(&btusb_driver); + if (err < 0) + AICBT_ERR("Failed to register aic bluetooth USB driver"); + return err; +} + +static void __exit btusb_exit(void) +{ + AICBT_INFO("AicSemi Bluetooth USB driver module exit"); +#if CONFIG_BLUEDROID + if (bt_char_dev_registered > 0) + btchr_exit(); +#endif + usb_deregister(&btusb_driver); +} + +module_init(btusb_init); +module_exit(btusb_exit); + + +module_param(mp_drv_mode, int, 0644); +MODULE_PARM_DESC(mp_drv_mode, "0: NORMAL; 1: MP MODE"); + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 0) +MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver); +#endif + +MODULE_AUTHOR("AicSemi Corporation"); +MODULE_DESCRIPTION("AicSemi Bluetooth USB driver version"); +MODULE_VERSION(VERSION); +MODULE_LICENSE("GPL"); --- /dev/null +++ b/drivers/bluetooth/aic_btusb/aic_btusb.h @@ -0,0 +1,753 @@ +/* + * + * Aic Bluetooth USB driver + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + + +#ifdef CONFIG_PLATFORM_UBUNTU +#define CONFIG_BLUEDROID 0 /* bleuz 0, bluedroid 1 */ +#else +#define CONFIG_BLUEDROID 1 /* bleuz 0, bluedroid 1 */ +#endif + + +//#define CONFIG_SCO_OVER_HCI +#define CONFIG_USB_AIC_UART_SCO_DRIVER + +#ifdef CONFIG_SCO_OVER_HCI +#include +#include +#include +#include +#include + +#define AIC_SCO_ID "snd_sco_aic" +enum { + USB_CAPTURE_RUNNING, + USB_PLAYBACK_RUNNING, + ALSA_CAPTURE_OPEN, + ALSA_PLAYBACK_OPEN, + ALSA_CAPTURE_RUNNING, + ALSA_PLAYBACK_RUNNING, + CAPTURE_URB_COMPLETED, + PLAYBACK_URB_COMPLETED, + DISCONNECTED, +}; + +// AIC sound card +typedef struct AIC_sco_card { + struct snd_card *card; + struct snd_pcm *pcm; + struct usb_device *dev; + struct btusb_data *usb_data; + unsigned long states; + struct aic_sco_stream { + struct snd_pcm_substream *substream; + unsigned int sco_packet_bytes; + snd_pcm_uframes_t buffer_pos; + } capture, playback; + spinlock_t capture_lock; + spinlock_t playback_lock; + struct work_struct send_sco_work; +} AIC_sco_card_t; +#endif +/* Some Android system may use standard Linux kernel, while + * standard Linux may also implement early suspend feature. + * So exclude earysuspend.h from CONFIG_BLUEDROID. + */ +#ifdef CONFIG_HAS_EARLYSUSPEND +#include +#endif + +#if CONFIG_BLUEDROID +#else +#include +#include +#include +#endif + + +/*********************************** +** AicSemi - For aic_btusb driver ** +***********************************/ +#define URB_CANCELING_DELAY_MS 10 +/* when OS suspended, module is still powered,usb is not powered, + * this may set to 1, and must comply with special patch code. + */ +#define CONFIG_RESET_RESUME 1 +#define PRINT_CMD_EVENT 0 +#define PRINT_ACL_DATA 0 +#define PRINT_SCO_DATA 0 + +#define AICBT_DBG_FLAG 0 + +#if AICBT_DBG_FLAG +#define AICBT_DBG(fmt, arg...) printk( "aic_btusb: " fmt "\n" , ## arg) +#else +#define AICBT_DBG(fmt, arg...) +#endif + +#define AICBT_INFO(fmt, arg...) printk("aic_btusb: " fmt "\n" , ## arg) +#define AICBT_WARN(fmt, arg...) printk("aic_btusb: " fmt "\n" , ## arg) +#define AICBT_ERR(fmt, arg...) printk("aic_btusb: " fmt "\n" , ## arg) + + +#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 33) +#define HDEV_BUS hdev->bus +#define USB_RPM 1 +#else +#define HDEV_BUS hdev->type +#define USB_RPM 0 +#endif + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 38) +#define NUM_REASSEMBLY 3 +#endif + +#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 4, 0) +#define GET_DRV_DATA(x) hci_get_drvdata(x) +#else +#define GET_DRV_DATA(x) x->driver_data +#endif + +#define SCO_NUM hdev->conn_hash.sco_num + + +#define BTUSB_RPM (0 * USB_RPM) /* 1 SS enable; 0 SS disable */ +#define BTUSB_WAKEUP_HOST 0 /* 1 enable; 0 disable */ +#define BTUSB_MAX_ISOC_FRAMES 48 +#define BTUSB_INTR_RUNNING 0 +#define BTUSB_BULK_RUNNING 1 +#define BTUSB_ISOC_RUNNING 2 +#define BTUSB_SUSPENDING 3 +#define BTUSB_DID_ISO_RESUME 4 + +#define HCI_VENDOR_USB_DISC_HARDWARE_ERROR 0xFF + +#define HCI_CMD_READ_BD_ADDR 0x1009 +#define HCI_VENDOR_READ_LMP_VERISION 0x1001 +#define HCI_VENDOR_RESET 0x0C03 + +#define DRV_NORMAL_MODE 0 +#define DRV_MP_MODE 1 +int mp_drv_mode = 0; /* 1 Mptool Fw; 0 Normal Fw */ + + +#if CONFIG_BLUEDROID +#define QUEUE_SIZE 500 + +/*************************************** +** AicSemi - Integrate from bluetooth.h ** +*****************************************/ +/* Reserv for core and drivers use */ +#define BT_SKB_RESERVE 8 + +/* BD Address */ +typedef struct { + __u8 b[6]; +} __packed bdaddr_t; + +/* Skb helpers */ +struct bt_skb_cb { + __u8 pkt_type; + __u8 incoming; + __u16 expect; + __u16 tx_seq; + __u8 retries; + __u8 sar; + __u8 force_active; +}; + +#define bt_cb(skb) ((struct bt_skb_cb *)((skb)->cb)) + +static inline struct sk_buff *bt_skb_alloc(unsigned int len, gfp_t how) +{ + struct sk_buff *skb; + + if ((skb = alloc_skb(len + BT_SKB_RESERVE, how))) { + skb_reserve(skb, BT_SKB_RESERVE); + bt_cb(skb)->incoming = 0; + } + return skb; +} +/* AicSemi - Integrate from bluetooth.h end */ + +/*********************************** +** AicSemi - Integrate from hci.h ** +***********************************/ +#define HCI_MAX_ACL_SIZE 1024 +#define HCI_MAX_SCO_SIZE 255 +#define HCI_MAX_EVENT_SIZE 260 +#define HCI_MAX_FRAME_SIZE (HCI_MAX_ACL_SIZE + 4) + +/* HCI bus types */ +#define HCI_VIRTUAL 0 +#define HCI_USB 1 +#define HCI_PCCARD 2 +#define HCI_UART 3 +#define HCI_RS232 4 +#define HCI_PCI 5 +#define HCI_SDIO 6 + +/* HCI controller types */ +#define HCI_BREDR 0x00 +#define HCI_AMP 0x01 + +/* 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_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 */ +#define HCI_COMMAND_PKT 0x01 +#define HCI_ACLDATA_PKT 0x02 +#define HCI_SCODATA_PKT 0x03 +#define HCI_EVENT_PKT 0x04 +#define HCI_VENDOR_PKT 0xff + +#define HCI_MAX_NAME_LENGTH 248 +#define HCI_MAX_EIR_LENGTH 240 + +#define HCI_OP_READ_LOCAL_VERSION 0x1001 +struct hci_rp_read_local_version { + __u8 status; + __u8 hci_ver; + __le16 hci_rev; + __u8 lmp_ver; + __le16 manufacturer; + __le16 lmp_subver; +} __packed; + +#define HCI_EV_CMD_COMPLETE 0x0e +struct hci_ev_cmd_complete { + __u8 ncmd; + __le16 opcode; +} __packed; + +/* ---- HCI Packet structures ---- */ +#define HCI_COMMAND_HDR_SIZE 3 +#define HCI_EVENT_HDR_SIZE 2 +#define HCI_ACL_HDR_SIZE 4 +#define HCI_SCO_HDR_SIZE 3 + +struct hci_command_hdr { + __le16 opcode; /* OCF & OGF */ + __u8 plen; +} __packed; + +struct hci_event_hdr { + __u8 evt; + __u8 plen; +} __packed; + +struct hci_acl_hdr { + __le16 handle; /* Handle & Flags(PB, BC) */ + __le16 dlen; +} __packed; + +struct hci_sco_hdr { + __le16 handle; + __u8 dlen; +} __packed; + +static inline struct hci_event_hdr *hci_event_hdr(const struct sk_buff *skb) +{ + return (struct hci_event_hdr *) skb->data; +} + +static inline struct hci_acl_hdr *hci_acl_hdr(const struct sk_buff *skb) +{ + return (struct hci_acl_hdr *) skb->data; +} + +static inline struct hci_sco_hdr *hci_sco_hdr(const struct sk_buff *skb) +{ + return (struct hci_sco_hdr *) skb->data; +} + +/* ---- HCI Ioctl requests structures ---- */ +struct hci_dev_stats { + __u32 err_rx; + __u32 err_tx; + __u32 cmd_tx; + __u32 evt_rx; + __u32 acl_tx; + __u32 acl_rx; + __u32 sco_tx; + __u32 sco_rx; + __u32 byte_rx; + __u32 byte_tx; +}; +/* AicSemi - Integrate from hci.h end */ + +/***************************************** +** AicSemi - Integrate from hci_core.h ** +*****************************************/ +struct hci_conn_hash { + struct list_head list; + unsigned int acl_num; + unsigned int sco_num; + unsigned int le_num; +}; + +#define HCI_MAX_SHORT_NAME_LENGTH 10 + +#define NUM_REASSEMBLY 4 +struct hci_dev { + struct mutex lock; + + char name[8]; + unsigned long flags; + __u16 id; + __u8 bus; + __u8 dev_type; + + struct sk_buff *reassembly[NUM_REASSEMBLY]; + + struct hci_conn_hash conn_hash; + + struct hci_dev_stats stat; + +#if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 4, 0) + atomic_t refcnt; + struct module *owner; + void *driver_data; +#endif + + atomic_t promisc; + + 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); + int (*send)(struct sk_buff *skb); +#if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 4, 0) + void (*destruct)(struct hci_dev *hdev); +#endif +#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 7, 1) + __u16 voice_setting; +#endif + void (*notify)(struct hci_dev *hdev, unsigned int evt); + int (*ioctl)(struct hci_dev *hdev, unsigned int cmd, unsigned long arg); + u8 *align_data; +}; + +#if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 4, 0) +static inline struct hci_dev *__hci_dev_hold(struct hci_dev *d) +{ + atomic_inc(&d->refcnt); + return d; +} + +static inline void __hci_dev_put(struct hci_dev *d) +{ + if (atomic_dec_and_test(&d->refcnt)) + d->destruct(d); +} +#endif + +static inline void *hci_get_drvdata(struct hci_dev *hdev) +{ + return dev_get_drvdata(&hdev->dev); +} + +static inline void hci_set_drvdata(struct hci_dev *hdev, void *data) +{ + dev_set_drvdata(&hdev->dev, data); +} + +#define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->parent = (pdev)) +/* AicSemi - Integrate from hci_core.h end */ + +/* ----- HCI Commands ---- */ +#define HCI_OP_INQUIRY 0x0401 +#define HCI_OP_INQUIRY_CANCEL 0x0402 +#define HCI_OP_EXIT_PERIODIC_INQ 0x0404 +#define HCI_OP_CREATE_CONN 0x0405 +#define HCI_OP_DISCONNECT 0x0406 +#define HCI_OP_ADD_SCO 0x0407 +#define HCI_OP_CREATE_CONN_CANCEL 0x0408 +#define HCI_OP_ACCEPT_CONN_REQ 0x0409 +#define HCI_OP_REJECT_CONN_REQ 0x040a +#define HCI_OP_LINK_KEY_REPLY 0x040b +#define HCI_OP_LINK_KEY_NEG_REPLY 0x040c +#define HCI_OP_PIN_CODE_REPLY 0x040d +#define HCI_OP_PIN_CODE_NEG_REPLY 0x040e +#define HCI_OP_CHANGE_CONN_PTYPE 0x040f +#define HCI_OP_AUTH_REQUESTED 0x0411 +#define HCI_OP_SET_CONN_ENCRYPT 0x0413 +#define HCI_OP_CHANGE_CONN_LINK_KEY 0x0415 +#define HCI_OP_REMOTE_NAME_REQ 0x0419 +#define HCI_OP_REMOTE_NAME_REQ_CANCEL 0x041a +#define HCI_OP_READ_REMOTE_FEATURES 0x041b +#define HCI_OP_READ_REMOTE_EXT_FEATURES 0x041c +#define HCI_OP_READ_REMOTE_VERSION 0x041d +#define HCI_OP_SETUP_SYNC_CONN 0x0428 +#define HCI_OP_ACCEPT_SYNC_CONN_REQ 0x0429 +#define HCI_OP_REJECT_SYNC_CONN_REQ 0x042a +#define HCI_OP_SNIFF_MODE 0x0803 +#define HCI_OP_EXIT_SNIFF_MODE 0x0804 +#define HCI_OP_ROLE_DISCOVERY 0x0809 +#define HCI_OP_SWITCH_ROLE 0x080b +#define HCI_OP_READ_LINK_POLICY 0x080c +#define HCI_OP_WRITE_LINK_POLICY 0x080d +#define HCI_OP_READ_DEF_LINK_POLICY 0x080e +#define HCI_OP_WRITE_DEF_LINK_POLICY 0x080f +#define HCI_OP_SNIFF_SUBRATE 0x0811 +#define HCI_OP_Write_Link_Policy_Settings 0x080d +#define HCI_OP_SET_EVENT_MASK 0x0c01 +#define HCI_OP_RESET 0x0c03 +#define HCI_OP_SET_EVENT_FLT 0x0c05 +#define HCI_OP_Write_Extended_Inquiry_Response 0x0c52 +#define HCI_OP_Write_Simple_Pairing_Mode 0x0c56 +#define HCI_OP_Read_Buffer_Size 0x1005 +#define HCI_OP_Host_Buffer_Size 0x0c33 +#define HCI_OP_Read_Local_Version_Information 0x1001 +#define HCI_OP_Read_BD_ADDR 0x1009 +#define HCI_OP_Read_Local_Supported_Commands 0x1002 +#define HCI_OP_Write_Scan_Enable 0x0c1a +#define HCI_OP_Write_Current_IAC_LAP 0x0c3a +#define HCI_OP_Write_Inquiry_Scan_Activity 0x0c1e +#define HCI_OP_Write_Class_of_Device 0x0c24 +#define HCI_OP_LE_Rand 0x2018 +#define HCI_OP_LE_Set_Random_Address 0x2005 +#define HCI_OP_LE_Set_Extended_Scan_Enable 0x2042 +#define HCI_OP_LE_Set_Extended_Scan_Parameters 0x2041 +#define HCI_OP_Set_Event_Filter 0x0c05 +#define HCI_OP_Write_Voice_Setting 0x0c26 +#define HCI_OP_Change_Local_Name 0x0c13 +#define HCI_OP_Read_Local_Name 0x0c14 +#define HCI_OP_Wirte_Page_Timeout 0x0c18 +#define HCI_OP_LE_Clear_Resolving_List 0x0c29 +#define HCI_OP_LE_Set_Addres_Resolution_Enable_Command 0x0c2e +#define HCI_OP_Write_Inquiry_mode 0x0c45 +#define HCI_OP_Write_Page_Scan_Type 0x0c47 +#define HCI_OP_Write_Inquiry_Scan_Type 0x0c43 + +#define HCI_OP_Delete_Stored_Link_Key 0x0c12 +#define HCI_OP_LE_Read_Local_Resolvable_Address 0x202d +#define HCI_OP_LE_Extended_Create_Connection 0x2043 +#define HCI_OP_Read_Remote_Version_Information 0x041d +#define HCI_OP_LE_Start_Encryption 0x2019 +#define HCI_OP_LE_Add_Device_to_Resolving_List 0x2027 +#define HCI_OP_LE_Set_Privacy_Mode 0x204e +#define HCI_OP_LE_Connection_Update 0x2013 + +/* ----- HCI events---- */ +#define HCI_OP_DISCONNECT 0x0406 +#define HCI_EV_INQUIRY_COMPLETE 0x01 +#define HCI_EV_INQUIRY_RESULT 0x02 +#define HCI_EV_CONN_COMPLETE 0x03 +#define HCI_EV_CONN_REQUEST 0x04 +#define HCI_EV_DISCONN_COMPLETE 0x05 +#define HCI_EV_AUTH_COMPLETE 0x06 +#define HCI_EV_REMOTE_NAME 0x07 +#define HCI_EV_ENCRYPT_CHANGE 0x08 +#define HCI_EV_CHANGE_LINK_KEY_COMPLETE 0x09 + +#define HCI_EV_REMOTE_FEATURES 0x0b +#define HCI_EV_REMOTE_VERSION 0x0c +#define HCI_EV_QOS_SETUP_COMPLETE 0x0d +#define HCI_EV_CMD_COMPLETE 0x0e +#define HCI_EV_CMD_STATUS 0x0f + +#define HCI_EV_ROLE_CHANGE 0x12 +#define HCI_EV_NUM_COMP_PKTS 0x13 +#define HCI_EV_MODE_CHANGE 0x14 +#define HCI_EV_PIN_CODE_REQ 0x16 +#define HCI_EV_LINK_KEY_REQ 0x17 +#define HCI_EV_LINK_KEY_NOTIFY 0x18 +#define HCI_EV_CLOCK_OFFSET 0x1c +#define HCI_EV_PKT_TYPE_CHANGE 0x1d +#define HCI_EV_PSCAN_REP_MODE 0x20 + +#define HCI_EV_INQUIRY_RESULT_WITH_RSSI 0x22 +#define HCI_EV_REMOTE_EXT_FEATURES 0x23 +#define HCI_EV_SYNC_CONN_COMPLETE 0x2c +#define HCI_EV_SYNC_CONN_CHANGED 0x2d +#define HCI_EV_SNIFF_SUBRATE 0x2e +#define HCI_EV_EXTENDED_INQUIRY_RESULT 0x2f +#define HCI_EV_IO_CAPA_REQUEST 0x31 +#define HCI_EV_SIMPLE_PAIR_COMPLETE 0x36 +#define HCI_EV_REMOTE_HOST_FEATURES 0x3d +#define HCI_EV_LE_Meta 0x3e + +#define CONFIG_MAC_OFFSET_GEN_1_2 (0x3C) //MAC's OFFSET in config/efuse for aic generation 1~2 bluetooth chip +#define CONFIG_MAC_OFFSET_GEN_3PLUS (0x44) //MAC's OFFSET in config/efuse for aic generation 3+ bluetooth chip + + +typedef struct { + uint16_t vid; + uint16_t pid; + uint16_t lmp_sub_default; + uint16_t lmp_sub; + uint16_t eversion; + char *mp_patch_name; + char *patch_name; + char *config_name; + uint8_t *fw_cache; + int fw_len; + uint16_t mac_offset; + uint32_t max_patch_size; +} patch_info; + +//Define ioctl cmd the same as HCIDEVUP in the kernel +#define DOWN_FW_CFG _IOW('E', 176, int) +//#ifdef CONFIG_SCO_OVER_HCI +//#define SET_ISO_CFG _IOW('H', 202, int) +//#else +#define SET_ISO_CFG _IOW('E', 177, int) +//#endif +#define RESET_CONTROLLER _IOW('E', 178, int) +#define DWFW_CMPLT _IOW('E', 179, int) + +#define GET_USB_INFO _IOR('E', 180, int) + +/* for altsettings*/ +#include +#define BDADDR_FILE "/data/misc/bluetooth/bdaddr" +#define FACTORY_BT_BDADDR_STORAGE_LEN 17 +#if 0 +static inline int getmacaddr(uint8_t * vnd_local_bd_addr) +{ + struct file *bdaddr_file; + mm_segment_t oldfs; + char buf[FACTORY_BT_BDADDR_STORAGE_LEN]; + int32_t i = 0; + memset(buf, 0, FACTORY_BT_BDADDR_STORAGE_LEN); + bdaddr_file = filp_open(BDADDR_FILE, O_RDONLY, 0); + if (IS_ERR(bdaddr_file)){ + AICBT_INFO("No Mac Config for BT\n"); + return -1; + } + oldfs = get_fs(); + set_fs(KERNEL_DS); + bdaddr_file->f_op->llseek(bdaddr_file, 0, 0); + bdaddr_file->f_op->read(bdaddr_file, buf, FACTORY_BT_BDADDR_STORAGE_LEN, &bdaddr_file->f_pos); + for (i = 0; i < 6; i++) { + if(buf[3*i]>'9') + { + if(buf[3*i]>'Z') + buf[3*i] -=('a'-'A'); //change a to A + buf[3*i] -= ('A'-'9'-1); + } + if(buf[3*i+1]>'9') + { + if(buf[3*i+1]>'Z') + buf[3*i+1] -=('a'-'A'); //change a to A + buf[3*i+1] -= ('A'-'9'-1); + } + vnd_local_bd_addr[5-i] = ((uint8_t)buf[3*i]-'0')*16 + ((uint8_t)buf[3*i+1]-'0'); + } + set_fs(oldfs); + filp_close(bdaddr_file, NULL); + return 0; +} +#endif + +#endif /* CONFIG_BLUEDROID */ + + +typedef struct { + struct usb_interface *intf; + struct usb_device *udev; + int pipe_in, pipe_out; + uint8_t *send_pkt; + uint8_t *rcv_pkt; + struct hci_command_hdr *cmd_hdr; + struct hci_event_hdr *evt_hdr; + struct hci_ev_cmd_complete *cmd_cmp; + uint8_t *req_para, *rsp_para; + uint8_t *fw_data; + int pkt_len; + int fw_len; +} firmware_info; + +/******************************* +** Reasil patch code +********************************/ +#define CMD_CMP_EVT 0x0e +#define RCV_PKT_LEN 64 +#define SEND_PKT_LEN 300 +#define MSG_TO 1000 +#define PATCH_SEG_MAX 252 +#define DATA_END 0x80 +#define DOWNLOAD_OPCODE 0xfc02 +#define HCI_VSC_UPDATE_PT_CMD 0xFC75 +#define BTOFF_OPCODE 0xfc28 +#define TRUE 1 +#define FALSE 0 +#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 FW_RAM_ADID_BASE_ADDR 0x101788 +#define FW_RAM_PATCH_BASE_ADDR 0x184000 +#define FW_ADID_BASE_NAME "fw_adid_8800dc.bin" +#define FW_PATCH_TABLE_NAME "fw_patch_table_8800dc.bin" +#define FW_PATCH_BASE_NAME "fw_patch_8800dc.bin" +#define FW_PATCH_TABLE_NAME_U02 "fw_patch_table_8800dc_u02.bin" +#define FW_PATCH_BASE_NAME_U02 "fw_patch_8800dc_u02.bin" +#define FW_PATCH_TABLE_NAME_U02H "fw_patch_table_8800dc_u02h.bin" +#define FW_PATCH_BASE_NAME_U02H "fw_patch_8800dc_u02h.bin" +#define AICBT_PT_TAG "AICBT_PT_TAG" + +enum aicbt_patch_table_type { + AICBT_PT_NULL = 0x00, + AICBT_PT_TRAP, + AICBT_PT_B4, + AICBT_PT_BTMODE, + AICBT_PT_PWRON, + AICBT_PT_AF, + AICBT_PT_VER, + AICBT_PT_MAX, +}; + +#define HCI_VSC_FW_STATUS_GET_CMD 0xFC78 + +struct fw_status { + u8 status; +} __packed; + +#define HCI_PATCH_DATA_MAX_LEN 240 +#define HCI_VSC_MEM_WR_SIZE 240 +#define HCI_VSC_MEM_RD_SIZE 128 +#define HCI_VSC_UPDATE_PT_SIZE 249 +#define HCI_PT_MAX_LEN 31 + +#define HCI_VSC_DBG_RD_MEM_CMD 0xFC01 + +struct hci_dbg_rd_mem_cmd { + __le32 start_addr; + __u8 type; + __u8 length; +}__attribute__ ((packed)); + +struct hci_dbg_rd_mem_cmd_evt { + __u8 status; + __u8 length; + __u8 data[HCI_VSC_MEM_RD_SIZE]; +}__attribute__ ((packed)); + +struct long_buffer_tag { + __u8 length; + __u8 data[HCI_VSC_MEM_WR_SIZE]; +}; + +struct hci_dbg_wr_mem_cmd { + __le32 start_addr; + __u8 type; + __u8 length; + __u8 data[HCI_VSC_MEM_WR_SIZE]; +}; + +struct aicbt_patch_table { + char *name; + uint32_t type; + uint32_t *data; + uint32_t len; + struct aicbt_patch_table *next; +}; + +struct aicbt_patch_table_cmd { + uint8_t patch_num; + uint32_t patch_table_addr[31]; + uint32_t patch_table_data[31]; +}__attribute__ ((packed)); + + +enum aic_endpoit { + CTRL_EP = 0, + INTR_EP = 3, + BULK_EP = 1, + ISOC_EP = 4 +}; + +/* #define HCI_VERSION_CODE KERNEL_VERSION(3, 14, 41) */ +#define HCI_VERSION_CODE LINUX_VERSION_CODE + +int aic_load_firmware(u8 ** fw_buf, const char *name, struct device *device); +int aicbt_patch_table_free(struct aicbt_patch_table **head); +int download_patch(firmware_info *fw_info, int cached); + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 38) +#define NUM_REASSEMBLY 3 +#else +#define NUM_REASSEMBLY 4 +#endif + --- /dev/null +++ b/drivers/bluetooth/aic_btusb/aic_btusb_external_featrue.c @@ -0,0 +1,126 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#define IOCTL_CHAR_DEVICE_NAME "aic_btusb_ex_dev" + +#define SET_APCF_PARAMETER _IOR('E', 181, int) + +static dev_t ioctl_devid; /* bt char device number */ +static struct cdev ioctl_char_dev; /* bt character device structure */ +static struct class *ioctl_char_class; /* device class for usb char driver */ + +extern struct file_operations ioctl_chrdev_ops; + +extern void btchr_external_write(char* data, int len); + +static long ioctl_ioctl(struct file *file_p,unsigned int cmd, unsigned long arg) +{ + char data[1024]; + int ret = 0; + + printk("%s enter\r\n", __func__); + memset(data, 0, 1024); + switch(cmd) + { + case SET_APCF_PARAMETER: + printk("set apcf parameter\r\n"); + ret = copy_from_user(data, (int __user *)arg, 1024); + btchr_external_write(&data[1], (int)data[0]); + break; + + default: + printk("unknow cmdr\r\n"); + break; + } + return 0; +} + + +#ifdef CONFIG_COMPAT +static long compat_ioctlchr_ioctl (struct file *filp, unsigned int cmd, unsigned long arg) +{ + return ioctl_ioctl(filp, cmd, (unsigned long) compat_ptr(arg)); +} +#endif + + +struct file_operations ioctl_chrdev_ops = { + unlocked_ioctl : ioctl_ioctl, +#ifdef CONFIG_COMPAT + compat_ioctl : compat_ioctlchr_ioctl, +#endif + +}; + +static int __init init_extenal_ioctl(void){ + int res = 0; + struct device *dev; + + printk("%s enter\r\n", __func__); + + ioctl_char_class = class_create(THIS_MODULE, IOCTL_CHAR_DEVICE_NAME); + if (IS_ERR(ioctl_char_class)) { + printk("Failed to create ioctl char class"); + } + + res = alloc_chrdev_region(&ioctl_devid, 0, 1, IOCTL_CHAR_DEVICE_NAME); + if (res < 0) { + printk("Failed to allocate ioctl char device"); + goto err_alloc; + } + + dev = device_create(ioctl_char_class, NULL, ioctl_devid, NULL, IOCTL_CHAR_DEVICE_NAME); + if (IS_ERR(dev)) { + printk("Failed to create ioctl char device"); + res = PTR_ERR(dev); + goto err_create; + } + + cdev_init(&ioctl_char_dev, &ioctl_chrdev_ops); + res = cdev_add(&ioctl_char_dev, ioctl_devid, 1); + if (res < 0) { + printk("Failed to add ioctl char device"); + goto err_add; + } + + return res; + +err_add: + device_destroy(ioctl_char_class, ioctl_devid); +err_create: + unregister_chrdev_region(ioctl_devid, 1); +err_alloc: + class_destroy(ioctl_char_class); + + return res; + +} +static void __exit deinit_extenal_ioctl(void){ + printk("%s enter\r\n", __func__); + device_destroy(ioctl_char_class, ioctl_devid); + cdev_del(&ioctl_char_dev); + unregister_chrdev_region(ioctl_devid, 1); + class_destroy(ioctl_char_class); + +} + +module_init(init_extenal_ioctl); +module_exit(deinit_extenal_ioctl); + + +MODULE_AUTHOR("AicSemi Corporation"); +MODULE_DESCRIPTION("AicSemi Bluetooth USB driver version"); +MODULE_LICENSE("GPL"); + --- /dev/null +++ b/drivers/bluetooth/aic_btusb/aic_btusb_external_featrue.h @@ -0,0 +1,3 @@ + +void btchr_external_write(char* data, int len); +