From: Troy Tan <troy_...@realsil.com.cn> This patch adds the routines used for all antenna configurations.
Signed-off-by: Troy Tan <troy_...@realsil.com.cn> Signed-off-by: Larry Finger <larry.fin...@lwfinger.net> --- .../wireless/rtlwifi/btcoexist/halbtc8812a_ext.c | 921 +++++++++++++++++++++ .../wireless/rtlwifi/btcoexist/halbtc8812a_ext.h | 359 ++++++++ 2 files changed, 1280 insertions(+) create mode 100644 drivers/net/wireless/rtlwifi/btcoexist/halbtc8812a_ext.c create mode 100644 drivers/net/wireless/rtlwifi/btcoexist/halbtc8812a_ext.h diff --git a/drivers/net/wireless/rtlwifi/btcoexist/halbtc8812a_ext.c b/drivers/net/wireless/rtlwifi/btcoexist/halbtc8812a_ext.c new file mode 100644 index 0000000..4a324b4 --- /dev/null +++ b/drivers/net/wireless/rtlwifi/btcoexist/halbtc8812a_ext.c @@ -0,0 +1,921 @@ +/****************************************************************************** + * + * Copyright(c) 2009-2012 Realtek Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * The full GNU General Public License is included in this distribution in the + * file called LICENSE. + * + * Contact Information: + * wlanfae <wlan...@realtek.com> + * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park, + * Hsinchu 300, Taiwan. + * + * Larry Finger <larry.fin...@lwfinger.net> + * + *****************************************************************************/ + +#include "halbt_precomp.h" +#include "halbtc8812a_ext.h" + +/*global for socket TRX, it is actually rtlpriv*/ +static struct rtl_priv *pbtcoexadapter; + +static void *safe_memcpy(void *dest, const void *src, u32 n, u32 max_len) +{ + if (n > max_len) { + memcpy(dest, src, max_len); + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "critical error in memcpy!\n"); + } else { + /*ok case*/ + memcpy(dest, src, n); + } + return NULL; +} + +static void btinfo_evt_dump(struct btinfo_8761au *info) +{ + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "cid:0x%02x, len:%u\n", info->cid, info->len); + + if (info->len > 2) + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "byte2:%s%s%s%s%s%s%s%s\n", + info->connection ? "connection " : "", + info->scoe_sco ? "scoe_sco " : "", + info->inq_page ? "inq_page " : "", + info->acl_busy ? "acl_busy " : "", + info->sco_busy ? "sco_busy " : "", + info->hid ? "hid " : "", + info->a2dp ? "a2dp " : "", + info->ftp ? "ftp" : ""); + + if (info->len > 3) + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "retry_cnt:%u\n", info->retry_cnt); + + if (info->len > 4) + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, "rssi:%u\n", + info->rssi); + + if (info->len > 5) + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, "byte5:%s%s\n", + info->esco_sco ? "eSCO_SCO " : "", + info->master_slave ? "Master_Slave " : ""); +} + +static void rtl_btcoex_btinfo_cmd(struct rtl_priv *rtlpriv, u8 *buf, + u16 buf_len) +{ + struct btinfo_8761au *info = (struct btinfo_8761au *)buf; + u8 cmd_idx; + u8 len; + + cmd_idx = info->cid; + + if (info->len > buf_len-2) { + WARN_ON(1); + len = buf_len-2; + } else { + len = info->len; + } + + btinfo_evt_dump(info); + + /* transform BT-FW btinfo to WiFI-FW C2H format and notify */ + if (cmd_idx == BTINFO_WIFI_FETCH) { + buf[1] = 0; + } else if (cmd_idx == BTINFO_BT_AUTO_RPT) { + buf[1] = 2; + } else if (0x01 == cmd_idx || 0x02 == cmd_idx) { + /* troy, it should run here */ + buf[1] = buf[0]; + } + + rtlpriv->btcoexist.btc_ops->btc_btinfo_notify(rtlpriv, &buf[1], len+1); +} + +static u8 rtl_send_comp_ev_to_bt(struct rtl_priv *rtlpriv, + enum HCI_EXTENSION_COMMANDS BT_RELATED_CMD, + enum HCI_STATUS status) +{ + struct rtl_hci_event *hci_event; + u8 local_buf[6] = ""; + u8 len = 0, tx_event_length = 0; + u8 *ret_par; + u8 *event_data = NULL; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "#LEVEL_END, rtl_send_comp_ev_to_bt\n"); + + hci_event = (struct rtl_hci_event *)(&local_buf[0]); + event_data = hci_event->data; + hci_event->event_code = HCI_EVENT_COMMAND_COMPLETE; + *event_data = 0x1; + *(event_data + 1) = HCIOPCODELOW(BT_RELATED_CMD, OGF_EXTENSION); + *(event_data + 2) = HCIOPCODEHIGHT(BT_RELATED_CMD, OGF_EXTENSION); + + len = len + 3; + ret_par = &hci_event->data[len]; + ret_par[0] = status; + len++; + hci_event->length = len; + /* total tx event length + event_code length + sizeof(length) */ + tx_event_length = hci_event->length + 2; + rtl_btcoex_dump_tx_msg((u8 *)hci_event, tx_event_length, + "rtl_send_comp_ev_to_bt"); + status = rtl_btcoex_sendmsgbysocket(rtlpriv, (u8 *)hci_event, + tx_event_length, false); + return status; +} + +static u8 rtl_btcoex_parse_BT_info_notify_cmd(struct rtl_priv *rtlpriv, + u8 *pcmd, u16 cmdlen) +{ + u8 curpollenable = pcmd[0]; + u8 curpolltime = pcmd[1]; + u8 btinforeason = pcmd[2]; + u8 btinfolen = pcmd[3]; + u8 btinfo[BT_INFO_LENGTH]; + enum HCI_STATUS status = HCI_STATUS_SUCCESS; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, "%s\n", __func__); + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "current Poll Enable: %d, currrent Poll Time: %d\n", + curpollenable, curpolltime); + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "BT Info reason: %d, BT Info length: %d\n", + btinforeason, btinfolen); + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", + pcmd[4], pcmd[5], pcmd[6], pcmd[7], pcmd[8], + pcmd[9], pcmd[10], pcmd[11]); + + memset(btinfo, 0, BT_INFO_LENGTH); + + if (BT_INFO_LENGTH != btinfolen) { + status = HCI_STATUS_INVALID_HCI_CMD_PARA_VALUE; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "Error BT Info Length: %d\n", btinfolen); + } else { + if (0x1 == btinforeason || 0x2 == btinforeason) { + safe_memcpy(btinfo, &pcmd[4], btinfolen, + BT_INFO_LENGTH); + btinfo[0] = btinforeason; + rtl_btcoex_btinfo_cmd(rtlpriv, btinfo, btinfolen); + } else { + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "Other BT info reason\n"); + } + } + + return rtl_send_comp_ev_to_bt(rtlpriv, HCI_BT_INFO_NOTIFY, status); +} + +static u8 rtl_btcoex_parse_BT_patch_ver_info_cmd(struct rtl_priv *rtlpriv, + u8 *pcmd, u16 cmdlen) +{ + enum HCI_STATUS status = HCI_STATUS_SUCCESS; + u16 btpatchver = 0x0, bthciver = 0x0; + + bthciver = pcmd[0] | pcmd[1]<<8; + btpatchver = pcmd[2] | pcmd[3]<<8; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "%s, cmd:%02x %02x %02x %02x\n", + __func__, pcmd[0], pcmd[1], pcmd[2], pcmd[3]); + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "%s, HCI Ver:%d, Patch Ver:%d\n", + __func__, bthciver, btpatchver); + rtlpriv->btcoexist.btc_ops->btc_set_bt_patch_version(bthciver, + btpatchver); + + return rtl_send_comp_ev_to_bt(rtlpriv, HCI_BT_PATCH_VERSION_NOTIFY, + status); +} + +static u8 rtl_btcoex_parse_HCI_Ver_notify_cmd(struct rtl_priv *rtlpriv, + u8 *pcmd, u16 cmdlen) +{ + enum HCI_STATUS status = HCI_STATUS_SUCCESS; + u16 hciver = pcmd[0] | pcmd[1] << 8; + struct bt_coex_info *pcoex_info = &rtlpriv->coex_info; + struct bt_mgnt *bt_mgnt = &pcoex_info->btmgnt; + + bt_mgnt->ext_config.hci_ext_ver = hciver; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, "%s, HCI Version: %d\n", + __func__, bt_mgnt->ext_config.hci_ext_ver); + if (bt_mgnt->ext_config.hci_ext_ver < 4) { + status = HCI_STATUS_INVALID_HCI_CMD_PARA_VALUE; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "%s, Version = %d, HCI Version must be < 4\n", + __func__, bt_mgnt->ext_config.hci_ext_ver); + + } else { + rtlpriv->btcoexist.btc_ops->btc_set_hci_version(hciver); + } + + return rtl_send_comp_ev_to_bt(rtlpriv, HCI_EXTENSION_VERSION_NOTIFY, + status); +} + +static u8 rtl_btcoex_parse_WIFI_scan_notify_cmd(struct rtl_priv *rtlpriv, + u8 *pcmd, u16 cmdlen) +{ + struct bt_coex_info *pcoex_info = &rtlpriv->coex_info; + struct bt_mgnt *bt_mgnt = &pcoex_info->btmgnt; + enum HCI_STATUS status = HCI_STATUS_SUCCESS; + + bt_mgnt->ext_config.enable_wifi_scan_notify = pcmd[0]; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "%s, enable_wifi_scan_notify: %d\n", __func__, + bt_mgnt->ext_config.enable_wifi_scan_notify); + + return rtl_send_comp_ev_to_bt(rtlpriv, HCI_ENABLE_WIFI_SCAN_NOTIFY, + status); +} + +static u8 rtl_btcoex_parse_HCI_link_status_notify_cmd(struct rtl_priv *rtlpriv, + u8 *pcmd, u16 cmdlen) +{ + enum HCI_STATUS status = HCI_STATUS_SUCCESS; + struct bt_coex_info *pcoex_info = &rtlpriv->coex_info; + struct bt_mgnt *bt_mgnt = &pcoex_info->btmgnt; + u8 i, num_of_handle = 0; + u16 connect_handle; + u8 bt_profile, bt_corespec, link_role; + u8 *ptriple; + + bt_mgnt->support_profile = false; + + bt_mgnt->ext_config.number_of_acl = 0; + bt_mgnt->ext_config.number_of_sco = 0; + + num_of_handle = pcmd[0]; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, "num_of_handle = 0x%x\n", + num_of_handle); + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, "hci_extension_ver = %d\n", + bt_mgnt->ext_config.hci_ext_ver); + + ptriple = &pcmd[1]; + for (i = 0; i < num_of_handle; i++) { + if (bt_mgnt->ext_config.hci_ext_ver < 1) { + connect_handle = *((u8 *)&ptriple[0]); + bt_profile = ptriple[2]; + bt_corespec = ptriple[3]; + if (BT_PROFILE_SCO == bt_profile) { + bt_mgnt->ext_config.number_of_sco++; + } else { + bt_mgnt->ext_config.number_of_acl++; + bt_mgnt->ext_config.acl_link[i].connect_handle = + connect_handle; + bt_mgnt->ext_config.acl_link[i].bt_profile = + bt_profile; + bt_mgnt->ext_config.acl_link[i].bt_corespec = + bt_corespec; + } + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "Connection_Handle =0x%x, bt_profile =%d, BTSpec =%d\n", + connect_handle, bt_profile, bt_corespec); + ptriple += 4; + } else if (bt_mgnt->ext_config.hci_ext_ver >= 1) { + connect_handle = *((u16 *)&ptriple[0]); + bt_profile = ptriple[2]; + bt_corespec = ptriple[3]; + link_role = ptriple[4]; + if (BT_PROFILE_SCO == bt_profile) { + bt_mgnt->ext_config.number_of_sco++; + } else { + bt_mgnt->ext_config.number_of_acl++; + bt_mgnt->ext_config.acl_link[i].connect_handle = + connect_handle; + bt_mgnt->ext_config.acl_link[i].bt_profile = + bt_profile; + bt_mgnt->ext_config.acl_link[i].bt_corespec = + bt_corespec; + bt_mgnt->ext_config.acl_link[i].link_role = + link_role; + } + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "Connection_Handle =0x%x, bt_profile =%d, BTSpec =%d, link_role =%d\n", + connect_handle, bt_profile, bt_corespec, + link_role); + + ptriple += 5; + } + } + rtlpriv->btcoexist.btc_ops->btc_stack_update_profile_info(); + return rtl_send_comp_ev_to_bt(rtlpriv, HCI_LINK_STATUS_NOTIFY, status); +} + +static u8 rtl_btcoex_parse_HCI_BT_coex_notify_cmd(struct rtl_priv *rtlpriv, + u8 *pcmd, u16 cmdlen) +{ + enum HCI_STATUS status = HCI_STATUS_SUCCESS; + + return rtl_send_comp_ev_to_bt(rtlpriv, HCI_BT_COEX_NOTIFY, status); +} + +static u8 rtl_btcoex_parse_HCI_BT_operation_notify_cmd(struct rtl_priv *rtlpriv, + u8 *pcmd, u16 cmdlen) +{ + enum HCI_STATUS status = HCI_STATUS_SUCCESS; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "%s, OP code: %d\n", __func__, pcmd[0]); + + switch (pcmd[0]) { + case HCI_BT_OP_NONE: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "[bt operation] : Operation None!!\n"); + break; + case HCI_BT_OP_INQUIRY_START: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "[bt operation] : Inquiry start!!\n"); + break; + case HCI_BT_OP_INQUIRY_FINISH: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "[bt operation] : Inquiry finished!!\n"); + break; + case HCI_BT_OP_PAGING_START: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "[bt operation] : Paging is started!!\n"); + break; + case HCI_BT_OP_PAGING_SUCCESS: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "[bt operation] : Paging complete successfully!!\n"); + break; + case HCI_BT_OP_PAGING_UNSUCCESS: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "[bt operation] : Paging complete unsuccessfully!!\n"); + break; + case HCI_BT_OP_PAIRING_START: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "[bt operation] : Pairing start!!\n"); + break; + case HCI_BT_OP_PAIRING_FINISH: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "[bt operation] : Pairing finished!!\n"); + break; + case HCI_BT_OP_BT_DEV_ENABLE: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "[bt operation] : BT Device is enabled!!\n"); + break; + case HCI_BT_OP_BT_DEV_DISABLE: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "[bt operation] : BT Device is disabled!!\n"); + break; + default: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "[bt operation] : Unknown, error!!\n"); + break; + } + + return rtl_send_comp_ev_to_bt(rtlpriv, HCI_BT_OPERATION_NOTIFY, status); +} + +static u8 rtl_btcoex_parse_BT_AFH_MAP_notify_cmd(struct rtl_priv *rtlpriv, + u8 *pcmd, u16 cmdlen) +{ + enum HCI_STATUS status = HCI_STATUS_SUCCESS; + + return rtl_send_comp_ev_to_bt(rtlpriv, HCI_BT_AFH_MAP_NOTIFY, status); +} + +static u8 rtl_btcoex_parse_BT_register_val_notify_cmd(struct rtl_priv *rtlpriv, + u8 *pcmd, u16 cmdlen) +{ + enum HCI_STATUS status = HCI_STATUS_SUCCESS; + + return rtl_send_comp_ev_to_bt(rtlpriv, HCI_BT_REGISTER_VALUE_NOTIFY, + status); +} + +static u8 rtl_btcoex_parse_HCI_BT_abnormal_notify_cmd(struct rtl_priv *rtlpriv, + u8 *pcmd, u16 cmdlen) +{ + enum HCI_STATUS status = HCI_STATUS_SUCCESS; + + return rtl_send_comp_ev_to_bt(rtlpriv, HCI_BT_ABNORMAL_NOTIFY, status); +} + +static u8 rtl_btcoex_parse_HCI_query_RF_status_cmd(struct rtl_priv *rtlpriv, + u8 *pcmd, u16 cmdlen) +{ + enum HCI_STATUS status = HCI_STATUS_SUCCESS; + + return rtl_send_comp_ev_to_bt(rtlpriv, HCI_QUERY_RF_STATUS, status); +} + +/***************************************** +* HCI cmd format : +*| 15 - 0 | +*| OPcode (OCF|OGF<<10) | +*| 15 - 8 |7 - 0 | +*|Cmd para |Cmd para Length | +*|Cmd para...... | +******************************************/ + +/* bit 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */ +/* | OCF | OGF | */ +static void rtl_btcoex_parse_hci_extend_cmd(struct rtl_priv *rtlpriv, u8 *pcmd, + u16 len, const u16 hci_OCF) +{ + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, "#LEVEL2,"); + switch (hci_OCF) { + case HCI_EXTENSION_VERSION_NOTIFY: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "HCI_EXTENSION_VERSION_NOTIFY\n#LEVEL3,"); + rtl_btcoex_parse_HCI_Ver_notify_cmd(rtlpriv, pcmd, len); + break; + case HCI_LINK_STATUS_NOTIFY: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "HCI_LINK_STATUS_NOTIFY#LEVEL3\n"); + rtl_btcoex_parse_HCI_link_status_notify_cmd(rtlpriv, pcmd, len); + break; + case HCI_BT_OPERATION_NOTIFY: + /* only for 8723a 2ant*/ + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "HCI_BT_OPERATION_NOTIFY\n#LEVEL3,"); + rtl_btcoex_parse_HCI_BT_operation_notify_cmd(rtlpriv, + pcmd, len); + break; + case HCI_ENABLE_WIFI_SCAN_NOTIFY: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "HCI_ENABLE_WIFI_SCAN_NOTIFY\n#LEVEL3,"); + rtl_btcoex_parse_WIFI_scan_notify_cmd(rtlpriv, pcmd, len); + break; + case HCI_QUERY_RF_STATUS: + /* only for 8723b 2ant */ + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "HCI_QUERY_RF_STATUS\n#LEVEL3,"); + rtl_btcoex_parse_HCI_query_RF_status_cmd(rtlpriv, pcmd, len); + break; + case HCI_BT_ABNORMAL_NOTIFY: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "HCI_BT_ABNORMAL_NOTIFY\n#LEVEL3,"); + rtl_btcoex_parse_HCI_BT_abnormal_notify_cmd(rtlpriv, pcmd, len); + break; + case HCI_BT_INFO_NOTIFY: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "HCI_BT_INFO_NOTIFY\n#LEVEL3,"); + rtl_btcoex_parse_BT_info_notify_cmd(rtlpriv, pcmd, len); + break; + case HCI_BT_COEX_NOTIFY: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "HCI_BT_COEX_NOTIFY\n#LEVEL3,"); + rtl_btcoex_parse_HCI_BT_coex_notify_cmd(rtlpriv, pcmd, len); + break; + case HCI_BT_PATCH_VERSION_NOTIFY: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "HCI_BT_PATCH_VERSION_NOTIFY\n#LEVEL3,"); + rtl_btcoex_parse_BT_patch_ver_info_cmd(rtlpriv, pcmd, len); + break; + case HCI_BT_AFH_MAP_NOTIFY: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "HCI_BT_AFH_MAP_NOTIFY\n#LEVEL3,"); + rtl_btcoex_parse_BT_AFH_MAP_notify_cmd(rtlpriv, pcmd, len); + break; + case HCI_BT_REGISTER_VALUE_NOTIFY: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "HCI_BT_REGISTER_VALUE_NOTIFY\n#LEVEL3,"); + rtl_btcoex_parse_BT_register_val_notify_cmd(rtlpriv, pcmd, len); + break; + default: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "ERROR!!! Unknown OCF: %x\n", hci_OCF); + break; + } +} + +static void rtl_btcoex_parse_hci_cmd(struct rtl_priv *rtlpriv, u8 *pcmd, + u16 len) +{ + u16 opcode = pcmd[0] | pcmd[1]<<8; + u16 hci_OGF = HCI_OGF(opcode); + u16 hci_OCF = HCI_OCF(opcode); + u8 cmdlen = len - 3; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "#LEVEL1, OGF: %x, OCF: %x\n", hci_OGF, hci_OCF); + + switch (hci_OGF) { + case OGF_EXTENSION: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "#LEVEL1, HCI_EXTENSION_CMD_OGF\n"); + rtl_btcoex_parse_hci_extend_cmd(rtlpriv, &pcmd[3], cmdlen, + hci_OCF); + break; + default: + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "#LEVEL1, Other OGF: %x\n", hci_OGF); + break; + } +} + +static u16 rtl_btcoex_parse_recv_data(u8 *msg, u8 msg_size) +{ + u8 *cmp_msg1 = attend_ack; + u8 *cmp_msg2 = leave_ack; + u8 *cmp_msg3 = bt_leave; + u8 *cmp_msg4 = invite_req; + u8 *cmp_msg5 = attend_req; + u8 *cmp_msg6 = invite_rsp; + u8 res = OTHER; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "\n>>>>>>>>>>>>>>>>>>>>>>>BT_TO_WIFI"); + + if (memcmp(cmp_msg1, msg, msg_size) == 0) { + res = RX_ATTEND_ACK; + } else if (memcmp(cmp_msg2, msg, msg_size) == 0) { + res = RX_LEAVE_ACK; + } else if (memcmp(cmp_msg3, msg, msg_size) == 0) { + res = RX_BT_LEAVE; + } else if (memcmp(cmp_msg4, msg, msg_size) == 0) { + res = RX_INVITE_REQ; + } else if (memcmp(cmp_msg5, msg, msg_size) == 0) { + res = RX_ATTEND_REQ; + } else if (memcmp(cmp_msg6, msg, msg_size) == 0) { + res = RX_INVITE_RSP; + } else { + res = OTHER; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, ", other_cmd!\n"); + } + + if (OTHER != res) + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + ", base_cmd:%s\n", msg); + return res; +} + +static void rtl_btcoex_recvmsg_int(struct sock *sk_in) +{ + struct rtl_priv *rtlpriv = pbtcoexadapter; + struct bt_coex_info *pcoex_info = &rtlpriv->coex_info; + + pcoex_info->sk_store = sk_in; + queue_delayed_work(pbtcoexadapter->works.rtl_wq, + &rtlpriv->works.socket_wq, 0); +} + +static void rtl_btcoex_recvmsgbysocket(void *data) +{ + struct rtl_priv *rtlpriv = pbtcoexadapter; + struct bt_coex_info *pcoex_info = &rtlpriv->coex_info; + struct sock *sk = pcoex_info->sk_store; + struct sk_buff *skb = NULL; + u8 *recv_data; + u32 len = 0; + u16 recv_length = 0; + u16 parse_res = 0; + + recv_data = kzalloc(RECV_DATA_MAX_LEN, GFP_ATOMIC); + if (!recv_data) + return; + if (!sk) { + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "critical error when receive socket data!\n"); + return; + } + len = skb_queue_len(&sk->sk_receive_queue); + while (len > 0) { + skb = skb_dequeue(&sk->sk_receive_queue); + + /* important: cut the udp header from skb->data! + * header length is 8 byte + */ + recv_length = skb->len-8; + memset(recv_data, 0, RECV_DATA_MAX_LEN); + safe_memcpy(recv_data, skb->data+8, recv_length, + RECV_DATA_MAX_LEN); + + parse_res = rtl_btcoex_parse_recv_data(recv_data, recv_length); + if (RX_ATTEND_ACK == parse_res) { /* attend ack */ + pcoex_info->bt_attend = true; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "RX_ATTEND_ACK!, sock_open:%d, bt_attend:%d\n", + pcoex_info->sock_open, + pcoex_info->bt_attend); + } + if (RX_ATTEND_REQ == parse_res) { /* attend req from BT */ + pcoex_info->bt_attend = true; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "RX_BT_ATTEND_REQ!, sock_open:%d, bt_attend:%d\n", + pcoex_info->sock_open, + pcoex_info->bt_attend); + rtl_btcoex_sendmsgbysocket(pbtcoexadapter, attend_ack, + sizeof(attend_ack), false); + } + if (RX_INVITE_REQ == parse_res) { /* attend req from BT */ + pcoex_info->bt_attend = true; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "RX_INVITE_REQ!, sock_open:%d, bt_attend:%d\n", + pcoex_info->sock_open, + pcoex_info->bt_attend); + rtl_btcoex_sendmsgbysocket(pbtcoexadapter, invite_rsp, + sizeof(invite_rsp), false); + } + if (RX_INVITE_RSP == parse_res) { + /* attend req from BT */ + pcoex_info->bt_attend = true; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "RX_INVITE_RSP!, sock_open:%d, bt_attend:%d\n", + pcoex_info->sock_open, + pcoex_info->bt_attend); + } else if (RX_LEAVE_ACK == parse_res) { + /* mean BT know wifi will leave */ + pcoex_info->bt_attend = false; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "RX_LEAVE_ACK!, sock_open:%d, bt_attend:%d\n", + pcoex_info->sock_open, + pcoex_info->bt_attend); + } else if (RX_BT_LEAVE == parse_res) { /* BT leave */ + rtl_btcoex_sendmsgbysocket(pbtcoexadapter, leave_ack, + sizeof(leave_ack), + false); /* no ack */ + pcoex_info->bt_attend = false; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "RX_BT_LEAVE!sock_open:%d, bt_attend:%d\n", + pcoex_info->sock_open, + pcoex_info->bt_attend); + } else { /*todo: check if recv data are really hci cmds*/ + if (pcoex_info->bt_attend) + rtl_btcoex_parse_hci_cmd(pbtcoexadapter, + recv_data, + recv_length); + } + len--; + kfree_skb(skb); + /*never do a sleep in this context!*/ + } + kfree(recv_data); +} + +u8 rtl_btcoex_sendmsgbysocket(struct rtl_priv *rtlpriv, u8 *msg, u8 msg_size, + bool force) +{ + struct msghdr udpmsg; + struct iovec iov; + struct bt_coex_info *pcoex_info = &rtlpriv->coex_info; + u8 error; + mm_segment_t oldfs; + + if (!force) { + if (!pcoex_info->bt_attend) { + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "TX Blocked: WiFi-BT disconnected\n"); + return _FAIL; + } + } + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "<<<<<<<<<<<<<<<<<<<<<<<<WIFI_TO_BT, msg:%s\n", msg); + + iov.iov_base = (void __user *)msg; + iov.iov_len = msg_size; + udpmsg.msg_name = &pcoex_info->bt_addr; + udpmsg.msg_namelen = sizeof(struct sockaddr_in); + udpmsg.msg_control = NULL; + udpmsg.msg_controllen = 0; + udpmsg.msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; + udpmsg.msg_flags = 0; + oldfs = get_fs(); + set_fs(KERNEL_DS); + error = sock_sendmsg(pcoex_info->udpsock, &udpmsg, msg_size); + set_fs(oldfs); + if (error < 0) { + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "Error when sendimg msg, error:%d\n", error); + return _FAIL; + } + return _SUCCESS; +} + +static u8 rtl_btcoex_create_kernel_socket(struct rtl_priv *rtlpriv, + u8 is_invite) +{ + struct bt_coex_info *pcoex_info = &rtlpriv->coex_info; + s8 kernel_socket_err; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "%s CONNECT_PORT %d\n", __func__, CONNECT_PORT); + + if (!pcoex_info) { + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, "coex_info: NULL\n"); + return _FAIL; + } + + kernel_socket_err = sock_create(PF_INET, SOCK_DGRAM, 0, + &pcoex_info->udpsock); + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "binding socket, err = %d\n", kernel_socket_err); + + if (kernel_socket_err < 0) { + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "Error during creation of socket error:%d\n", + kernel_socket_err); + return _FAIL; + } + memset(&pcoex_info->sin, 0, sizeof(pcoex_info->sin)); + pcoex_info->sin.sin_family = AF_INET; + pcoex_info->sin.sin_port = htons(CONNECT_PORT); + pcoex_info->sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + + memset(&pcoex_info->bt_addr, 0, sizeof(pcoex_info->bt_addr)); + pcoex_info->bt_addr.sin_family = AF_INET; + pcoex_info->bt_addr.sin_port = htons(CONNECT_PORT_BT); + pcoex_info->bt_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + + pcoex_info->sk_store = NULL; + + kernel_socket_err = + pcoex_info->udpsock->ops->bind(pcoex_info->udpsock, + (struct sockaddr *)&pcoex_info->sin, + sizeof(pcoex_info->sin)); + if (kernel_socket_err == 0) { + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "binding socket success\n"); + pcoex_info->udpsock->sk->sk_data_ready = + rtl_btcoex_recvmsg_int; + pcoex_info->sock_open |= KERNEL_SOCKET_OK; + pcoex_info->bt_attend = false; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "WIFI sending attend_req\n"); + rtl_btcoex_sendmsgbysocket(rtlpriv, attend_req, + sizeof(attend_req), true); + return _SUCCESS; + } + pcoex_info->bt_attend = false; + sock_release(pcoex_info->udpsock); + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "Error binding socket: %d\n", + kernel_socket_err); + return _FAIL; +} + +static void rtl_btcoex_close_kernel_socket(struct rtl_priv *rtlpriv) +{ + struct bt_coex_info *pcoex_info = &rtlpriv->coex_info; + + if (pcoex_info->sock_open & KERNEL_SOCKET_OK) { + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "release kernel socket\n"); + cancel_delayed_work(&rtlpriv->works.socket_wq); + + sock_release(pcoex_info->udpsock); + pcoex_info->sock_open &= ~(KERNEL_SOCKET_OK); + if (pcoex_info->bt_attend) + pcoex_info->bt_attend = false; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "sock_open:%d, bt_attend:%d\n", + pcoex_info->sock_open, pcoex_info->bt_attend); + } +} + +void rtl_btcoex_init_socket(struct rtl_priv *rtlpriv) +{ + struct bt_coex_info *pcoex_info = &rtlpriv->coex_info; + u8 is_invite = false; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "8812AE:init socket with 8761AU\n"); + + INIT_DELAYED_WORK(&rtlpriv->works.socket_wq, + (void *)rtl_btcoex_recvmsgbysocket); + + if (!pcoex_info->is_exist) { + memset(pcoex_info, 0, sizeof(struct bt_coex_info)); + pbtcoexadapter = rtlpriv; + rtl_btcoex_create_kernel_socket(rtlpriv, is_invite); + pcoex_info->is_exist = true; + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "set coex_info->is_exist: %d\n", + pcoex_info->is_exist); + } +} + +void rtl_btcoex_close_socket(struct rtl_priv *rtlpriv) +{ + struct bt_coex_info *pcoex_info = &rtlpriv->coex_info; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "set coex_info->is_exist: %d\n", pcoex_info->is_exist); + if (pcoex_info->is_exist) { + pcoex_info->is_exist = false; + if (pcoex_info->bt_attend) {/*inform BT wifi leave*/ + rtl_btcoex_sendmsgbysocket(rtlpriv, wifi_leave, + sizeof(wifi_leave), false); + msleep(50); + } + rtl_btcoex_close_kernel_socket(rtlpriv); + pbtcoexadapter = NULL; + } +} + +void rtl_btcoex_dump_tx_msg(u8 *tx_msg, u8 len, u8 *msg_name) +{ +} + +void rtl_btcoex_sendeventextbtcoexcontrol(struct rtl_priv *rtlpriv, + u8 needdbgrsp, u8 datalen, + void *pdata) +{ + u8 len = 0, tx_event_length = 0; + u8 local_buf[32] = ""; + u8 *ret_par; + u8 opcode = 0; + u8 *pinbuf = (u8 *)pdata; + struct rtl_hci_event *hci_event; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "#LEVEL_WIFI_ACTIVE, SendEventExtBtCoexControl\n"); + opcode = pinbuf[0]; + + hci_event = (struct rtl_hci_event *)(&local_buf[0]); + + hci_event->event_code = HCI_EVENT_EXTENSION_RTK; + /* extension event code */ + hci_event->data[0] = HCI_EVENT_EXT_BT_COEX_CONTROL; + len++; + ret_par = hci_event->data + len; + memcpy(&ret_par[0], pdata, datalen); /*maybe not safe here*/ + len += datalen; + hci_event->length = len; + /* total tx event length + event_code length + sizeof(length) */ + tx_event_length = hci_event->length + 2; + rtl_btcoex_dump_tx_msg((u8 *)hci_event, tx_event_length, + "BT COEX CONTROL"); + rtl_btcoex_sendmsgbysocket(rtlpriv, (u8 *)hci_event, tx_event_length, + false); +} + +void rtl_btcoex_sendeventextbtinfocontrol(struct rtl_priv *rtlpriv, u8 datalen, + void *pdata) +{ + struct rtl_hci_event *hci_event; + struct bt_coex_info *pcoex_info = &rtlpriv->coex_info; + struct bt_mgnt *bt_mgnt = &pcoex_info->btmgnt; + u8 *ret_par; + u8 len = 0, tx_event_length = 0; + u8 local_buf[32] = ""; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "#LEVEL_WIFI_ACTIVE, SendEventExtBtInfoControl\n"); + + if (bt_mgnt->ext_config.hci_ext_ver < 4) { /* no support */ + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_CRITICAL, + "ERROR: hci_extension_ver = %d, oonly versions < 4 supported\n", + bt_mgnt->ext_config.hci_ext_ver); + return; + } + hci_event = (struct rtl_hci_event *)(&local_buf[0]); + hci_event->event_code = HCI_EVENT_EXTENSION_RTK; + hci_event->data[0] = HCI_EVENT_EXT_BT_INFO_CONTROL; + len++; + ret_par = hci_event->data + len; + + memcpy(&ret_par[0], pdata, datalen);/*maybe not safe here*/ + len += datalen; + hci_event->length = len; + /* total tx event length + event_code length + sizeof(length) */ + tx_event_length = hci_event->length + 2; + rtl_btcoex_dump_tx_msg((u8 *)hci_event, tx_event_length, + "BT INFO CONTROL"); + rtl_btcoex_sendmsgbysocket(rtlpriv, (u8 *)hci_event, tx_event_length, + false); +} + +void rtl_btcoex_sendscannotify(struct rtl_priv *rtlpriv, u8 scantype) +{ + struct rtl_hci_event *hci_event; + u8 tx_event_length = 0; + u8 local_buf[7] = ""; + u8 *event_data = NULL; + + BTC_PRINT(BTC_MSG_SOCKET, SOCKET_NORMAL, + "#LEVEL_WIFI_ACTIVE, SendScanNotify\n"); + + hci_event = (struct rtl_hci_event *)(&local_buf[0]); + hci_event->event_code = HCI_EVENT_EXTENSION_RTK; + event_data = hci_event->data; + *(event_data) = HCI_EVENT_EXT_WIFI_SCAN_NOTIFY; + *(event_data + 1) = scantype; + hci_event->length = 2; + /* total tx event length + event_code length + sizeof(length) */ + tx_event_length = hci_event->length + 2; + rtl_btcoex_dump_tx_msg((u8 *)hci_event, tx_event_length, + "WIFI SCAN OPERATION"); + rtl_btcoex_sendmsgbysocket(rtlpriv, (u8 *)hci_event, tx_event_length, + false); +} diff --git a/drivers/net/wireless/rtlwifi/btcoexist/halbtc8812a_ext.h b/drivers/net/wireless/rtlwifi/btcoexist/halbtc8812a_ext.h new file mode 100644 index 0000000..8f750c9 --- /dev/null +++ b/drivers/net/wireless/rtlwifi/btcoexist/halbtc8812a_ext.h @@ -0,0 +1,359 @@ +#ifndef __8812A_EXT_H__ +#define __8812A_EXT_H__ + +/* for socket */ +#include <net/sock.h> +#include <net/tcp.h> +#include <linux/udp.h> +#include <linux/in.h> +#include <linux/netlink.h> + +#define _FAIL 0 +#define _SUCCESS 1 +#define BT_INFO_LENGTH 8 +#define RECV_DATA_MAX_LEN 255 +#define BTINFO_WIFI_FETCH 0x23 +#define BTINFO_BT_AUTO_RPT 0x27 + +#define CONNECT_PORT 30000 +#define CONNECT_PORT_BT 30001 +#define KERNEL_SOCKET_OK 0x01 + +#define OTHER 0 +#define RX_ATTEND_ACK 1 +#define RX_LEAVE_ACK 2 +#define RX_BT_LEAVE 3 +#define RX_INVITE_REQ 4 +#define RX_ATTEND_REQ 5 +#define RX_INVITE_RSP 6 + +#define invite_req "INVITE_REQ" +#define invite_rsp "INVITE_RSP" +#define attend_req "ATTEND_REQ" +#define attend_ack "ATTEND_ACK" +#define wifi_leave "WIFI_LEAVE" +#define leave_ack "LEAVE_ACK" +#define bt_leave "BT_LEAVE" + +#define BT_INFO_NOTIFY_CMD 0x0106 +#define BT_INFO_LEN 8 + +struct hci_link_info { + u16 connect_handle; + u8 incoming_traffic_mode; + u8 outgoing_traffic_mode; + u8 bt_profile; + u8 bt_corespec; + s8 bt_RSSI; + u8 traffic_profile; + u8 link_role; +}; + +#define MAX_BT_ACL_LINK_NUM 8 + +struct hci_ext_config { + struct hci_link_info acl_link[MAX_BT_ACL_LINK_NUM]; + u8 bt_operation_code; + u16 current_connect_handle; + u8 current_incoming_traffic_mode; + u8 current_outgoing_traffic_mode; + + u8 number_of_acl; + u8 number_of_sco; + u8 current_bt_status; + u16 hci_ext_ver; + bool enable_wifi_scan_notify; +}; + +struct hci_phy_link_bss_info { + u16 bdcap; /* capability information */ +}; + +enum BT_CONNECT_TYPE { + BT_CONNECT_AUTH_REQ = 0x00, + BT_CONNECT_AUTH_RSP = 0x01, + BT_CONNECT_ASOC_REQ = 0x02, + BT_CONNECT_ASOC_RSP = 0x03, + BT_DISCONNECT = 0x04 +}; + +struct rtl_hci_event { + u8 event_code; + u8 length; /* total cmd length = extension event length+1 + * (extension event code length) + */ + u8 data[1]; /* byte1 is extension event code */ +}; + +struct btinfo_8761au { + u8 cid; + u8 len; + + u8 connection:1; + u8 scoe_sco:1; + u8 inq_page:1; + u8 acl_busy:1; + u8 sco_busy:1; + u8 hid:1; + u8 a2dp:1; + u8 ftp:1; + + u8 retry_cnt:4; + u8 rsvd_34:1; + u8 page:1; + u8 trx_mask:1; + u8 sniff_attempt:1; + + u8 rssi; + + u8 a2dp_rate:1; + u8 re_init:1; + u8 max_power:1; + u8 en_ignore_wlan_act:1; + u8 tx_power_low:1; + u8 tx_power_high:1; + u8 esco_sco:1; + u8 master_slave:1; + + u8 acl_trx_tp_low; + u8 acl_trx_tp_high; +}; + +#define HCIOPCODE(_OCF, _OGF) ((_OGF)<<10|(_OCF)) +#define HCIOPCODELOW(_OCF, _OGF) (u8)(HCIOPCODE(_OCF, _OGF)&0x00ff) +#define HCIOPCODEHIGHT(_OCF, _OGF) (u8)(HCIOPCODE(_OCF, _OGF)>>8) +#define HCI_OGF(__opcode) (unsigned char)((0xFC00 & (__opcode)) >> 10) +#define HCI_OCF(__opcode) (0x3FF & (__opcode)) + +enum HCI_STATUS { + /* Success */ + HCI_STATUS_SUCCESS = 0x00, + /* Unknown HCI Command */ + HCI_STATUS_UNKNOW_HCI_CMD = 0x01, + /* Unknown Connection Identifier */ + HCI_STATUS_UNKNOW_CONNECT_ID = 0X02, + /* Hardware Failure */ + HCI_STATUS_HW_FAIL = 0X03, + /* Page Timeout */ + HCI_STATUS_PAGE_TIMEOUT = 0X04, + /* Authentication Failure */ + HCI_STATUS_AUTH_FAIL = 0X05, + /* PIN or Key Missing */ + HCI_STATUS_PIN_OR_KEY_MISSING = 0X06, + /* Memory Capacity Exceeded */ + HCI_STATUS_MEM_CAP_EXCEED = 0X07, + /* Connection Timeout */ + HCI_STATUS_CONNECT_TIMEOUT = 0X08, + /* Connection Limit Exceeded */ + HCI_STATUS_CONNECT_LIMIT = 0X09, + /* Synchronous Connection Limit To A Device Exceeded */ + HCI_STATUS_SYN_CONNECT_LIMIT = 0X0a, + /* ACL Connection Already Exists */ + HCI_STATUS_ACL_CONNECT_EXISTS = 0X0b, + /* Command Disallowed */ + HCI_STATUS_CMD_DISALLOW = 0X0c, + /* Connection Rejected due to Limited Resources */ + HCI_STATUS_CONNECT_RJT_LIMIT_RESOURCE = 0X0d, + /* Connection Rejected Due To Security Reasons */ + HCI_STATUS_CONNECT_RJT_SEC_REASON = 0X0e, + /* Connection Rejected due to Unacceptable BD_ADDR */ + HCI_STATUS_CONNECT_RJT_UNACCEPT_BD_ADDR = 0X0f, + /* Connection Accept Timeout Exceeded */ + HCI_STATUS_CONNECT_ACCEPT_TIMEOUT = 0X10, + /* Unsupported Feature or Parameter Value */ + HCI_STATUS_UNSUPPORT_FEATURE_PARA_VALUE = 0X11, + /* Invalid HCI Command Parameters */ + HCI_STATUS_INVALID_HCI_CMD_PARA_VALUE = 0X12, + /* Remote User Terminated Connection */ + HCI_STATUS_REMOTE_USER_TERMINATE_CONNECT = 0X13, + /* Remote Device Terminated Connection due to Low Resources */ + HCI_STATUS_REMOTE_DEV_TERMINATE_LOW_RESOURCE = 0X14, + /* Remote Device Terminated Connection due to Power Off */ + HCI_STATUS_REMOTE_DEV_TERMINATE_CONNECT_POWER_OFF = 0X15, + /* Connection Terminated By Local Host */ + HCI_STATUS_CONNECT_TERMINATE_LOCAL_HOST = 0X16, + /* Repeated Attempts */ + HCI_STATUS_REPEATE_ATTEMPT = 0X17, + /* Pairing Not Allowed */ + HCI_STATUS_PAIR_NOT_ALLOW = 0X18, + /* Unknown LMP PDU */ + HCI_STATUS_UNKNOW_LMP_PDU = 0X19, + /* Unsupported Remote Feature / Unsupported LMP Feature */ + HCI_STATUS_UNSUPPORT_REMOTE_LMP_FEATURE = 0X1a, + /* SCO Offset Rejected */ + HCI_STATUS_SOC_OFFSET_REJECT = 0X1b, + /* SCO Interval Rejected */ + HCI_STATUS_SOC_INTERVAL_REJECT = 0X1c, + /* SCO Air Mode Rejected */ + HCI_STATUS_SOC_AIR_MODE_REJECT = 0X1d, + /* Invalid LMP Parameters */ + HCI_STATUS_INVALID_LMP_PARA = 0X1e, + /* Unspecified Error */ + HCI_STATUS_UNSPECIFIC_ERROR = 0X1f, + /* Unsupported LMP Parameter Value */ + HCI_STATUS_UNSUPPORT_LMP_PARA_VALUE = 0X20, + /* Role Change Not Allowed */ + HCI_STATUS_ROLE_CHANGE_NOT_ALLOW = 0X21, + /* LMP Response Timeout */ + HCI_STATUS_LMP_RESPONSE_TIMEOUT = 0X22, + /* LMP Error Transaction Collision */ + HCI_STATUS_LMP_ERROR_TRANSACTION_COLLISION = 0X23, + /* LMP PDU Not Allowed */ + HCI_STATUS_LMP_PDU_NOT_ALLOW = 0X24, + /* Encryption Mode Not Acceptable */ + HCI_STATUS_ENCRYPTION_MODE_NOT_ALLOW = 0X25, + /* Link Key Can Not be Changed */ + HCI_STATUS_LINK_KEY_CAN_NOT_CHANGE = 0X26, + /* Requested QoS Not Supported */ + HCI_STATUS_REQUEST_QOS_NOT_SUPPORT = 0X27, + /* Instant Passed */ + HCI_STATUS_INSTANT_PASSED = 0X28, + /* Pairing With Unit Key Not Supported */ + HCI_STATUS_PAIRING_UNIT_KEY_NOT_SUPPORT = 0X29, + /* Different Transaction Collision */ + HCI_STATUS_DIFFERENT_TRANSACTION_COLLISION = 0X2a, + /* Reserved */ + HCI_STATUS_RESERVE_1 = 0X2b, + /* QoS Unacceptable Parameter */ + HCI_STATUS_QOS_UNACCEPT_PARA = 0X2c, + /* QoS Rejected */ + HCI_STATUS_QOS_REJECT = 0X2d, + /* Channel Classification Not Supported */ + HCI_STATUS_CHNL_CLASSIFICATION_NOT_SUPPORT = 0X2e, + /* Insufficient Security */ + HCI_STATUS_INSUFFICIENT_SECURITY = 0X2f, + /* Parameter Out Of Mandatory Range */ + HCI_STATUS_PARA_OUT_OF_RANGE = 0x30, + /* Reserved */ + HCI_STATUS_RESERVE_2 = 0X31, + /* Role Switch Pending */ + HCI_STATUS_ROLE_SWITCH_PENDING = 0X32, + /* Reserved */ + HCI_STATUS_RESERVE_3 = 0X33, + /* Reserved Slot Violation */ + HCI_STATUS_RESERVE_SOLT_VIOLATION = 0X34, + /* Role Switch Failed */ + HCI_STATUS_ROLE_SWITCH_FAIL = 0X35, + /* Extended Inquiry Response Too Large */ + HCI_STATUS_EXTEND_INQUIRY_RSP_TOO_LARGE = 0X36, + /* Secure Simple Pairing Not Supported By Host. */ + HCI_STATUS_SEC_SIMPLE_PAIRING_NOT_SUPPORT = 0X37, + /* Host Busy - Pairing */ + HCI_STATUS_HOST_BUSY_PAIRING = 0X38, + /* Connection Rejected due to No Suitable Channel Found */ + HCI_STATUS_CONNECT_REJ_NOT_SUIT_CHNL_FOUND = 0X39, + /* CONTROLLER BUSY */ + HCI_STATUS_CONTROLLER_BUSY = 0X3a +}; + +#define HCI_EVENT_COMMAND_COMPLETE 0x0e + +#define OGF_EXTENSION 0X3f + +enum HCI_EXTENSION_COMMANDS { + HCI_SET_ACL_LINK_DATA_FLOW_MODE = 0x0010, + HCI_SET_ACL_LINK_STATUS = 0x0020, + HCI_SET_SCO_LINK_STATUS = 0x0030, + HCI_SET_RSSI_VALUE = 0x0040, + HCI_SET_CURRENT_BLUETOOTH_STATUS = 0x0041, + + /* The following is for RTK8723 */ + HCI_EXTENSION_VERSION_NOTIFY = 0x0100, + HCI_LINK_STATUS_NOTIFY = 0x0101, + HCI_BT_OPERATION_NOTIFY = 0x0102, + HCI_ENABLE_WIFI_SCAN_NOTIFY = 0x0103, + HCI_QUERY_RF_STATUS = 0x0104, + HCI_BT_ABNORMAL_NOTIFY = 0x0105, + HCI_BT_INFO_NOTIFY = 0x0106, + HCI_BT_COEX_NOTIFY = 0x0107, + HCI_BT_PATCH_VERSION_NOTIFY = 0x0108, + HCI_BT_AFH_MAP_NOTIFY = 0x0109, + HCI_BT_REGISTER_VALUE_NOTIFY = 0x010a, + + /* The following is for IVT */ + HCI_WIFI_CURRENT_CHANNEL = 0x0300, + HCI_WIFI_CURRENT_BANDWIDTH = 0x0301, + HCI_WIFI_CONNECTION_STATUS = 0x0302 +}; + +#define HCI_EVENT_EXTENSION_RTK 0xfe +enum RTW_HCI_EXT_EVENT { + HCI_EVENT_EXT_WIFI_SCAN_NOTIFY = 0x01, + HCI_EVENT_EXT_WIFI_RF_STATUS_NOTIFY = 0x02, + HCI_EVENT_EXT_BT_INFO_CONTROL = 0x03, + HCI_EVENT_EXT_BT_COEX_CONTROL = 0x04 +}; + +enum BT_TRAFFIC_MODE { + /* Best Effort. Default. for HCRP, PAN, SDP, RFCOMM-based + * profiles like FTP, OPP, SPP, DUN, etc. + */ + BT_MOTOR_EXT_BE = 0x00, + /* Guaranteed Latency. This is used e.g. for HID and AVRCP. */ + BT_MOTOR_EXT_GUL = 0x01, + /* Guaranteed Bandwidth. */ + BT_MOTOR_EXT_GUB = 0X02, + /* Guaranteed Latency and Bandwidth. for A2DP and VDP. */ + BT_MOTOR_EXT_GULB = 0X03 +}; + +enum BT_TRAFFIC_MODE_PROFILE { + BT_PROFILE_NONE, + BT_PROFILE_A2DP, + BT_PROFILE_PAN, + BT_PROFILE_HID, + BT_PROFILE_SCO +}; + +struct bt_mgnt { + bool bt_connect_in_progress; + bool loglink_in_progress; + bool phylink_in_progress; + bool phylink_in_progress_start_ll; + u8 bt_current_phy_link_handle; + u16 bt_current_log_link_handle; + u8 current_connect_entry_num; + u8 disconnect_entry_num; + u8 current_bt_connection_cnt; + enum BT_CONNECT_TYPE bt_current_connect_type; + enum BT_CONNECT_TYPE bt_receive_connect_pkt; + u8 bt_auth_count; + u8 bt_asoc_count; + bool start_send_supervision_pkt; + bool bt_operation_on; + bool bt_need_amp_status_chg; + bool joiner_need_send_auth; + struct hci_phy_link_bss_info bss_desc; + struct hci_ext_config ext_config; + bool need_notify_amp_no_cap; + bool create_support_qos; + bool support_profile; + u8 bt_hannel; + bool check_chnl_is_suit; + bool bt_scan; + bool bt_logo_rest; + bool rf_status_notified; + bool bt_rsved_page_download; +}; + +#define SOCK_STORE_MAX 10 +struct bt_coex_info { + /* For Kernel Socket */ + struct socket *udpsock; + struct sockaddr_in sin; + struct sockaddr_in bt_addr; + struct sock *sk_store;/*back up socket for UDP RX int*/ + u32 pid; + /* store which socket is OK */ + u8 sock_open; + u8 bt_attend; + u8 is_exist; /* socket exist */ + struct bt_mgnt btmgnt; +}; + +#define PACKET_NORMAL 0 +#define PACKET_DHCP 1 +#define PACKET_ARP 2 +#define PACKET_EAPOL 3 + +#endif -- 2.1.2 -- To unsubscribe from this list: send the line "unsubscribe linux-wireless" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html