[Description]
1.Update for kernel coding style
2.Remove print function
3.Move metabuffer lock_init from btmtk_fops_open() to btmtk_sdio_probe()
CR-Id:ALPS02870048
diff --git a/btmtk_drv.h b/btmtk_drv.h
index 59a9866..ff11539 100644
--- a/btmtk_drv.h
+++ b/btmtk_drv.h
@@ -1,219 +1,219 @@
- /*
- * Mediatek Bluetooth driver: global definitions & declarations
- *
- * Copyright (C) 2015, Mediatek International Ltd.
- *
- * This software file (the "File") is distributed by Mediatek International
- * Ltd. under the terms of the GNU General Public License Version 2, June 1991
- * (the "License"). You may use, redistribute and/or modify this File in
- * accordance with the terms and conditions of the License, a copy of which
- * is available by writing to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
- * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
- *
- *
- * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
- * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
- * this warranty disclaimer.
- *
- */
+/*
+ * Mediatek Bluetooth driver: global definitions & declarations
+ *
+ * Copyright (C) 2017, Mediatek International Ltd.
+ *
+ * This software file (the "File") is distributed by Mediatek International
+ * Ltd. under the terms of the GNU General Public License Version 2, June 1991
+ * (the "License"). You may use, redistribute and/or modify this File in
+ * accordance with the terms and conditions of the License, a copy of which
+ * is available by writing to the Free Software Foundation, Inc.,
+ * On the worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ *
+ *
+ * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
+ * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
+ * this warranty disclaimer.
+ *
+ */
- #include <linux/kthread.h>
- #include <linux/bitops.h>
- #include <linux/slab.h>
- #include <net/bluetooth/bluetooth.h>
+#ifndef _BTMTK_DRV_H_
+#define _BTMTK_DRV_H_
- #define SAVE_FW_DUMP_IN_KERNEL 1
+#include <linux/kthread.h>
+#include <linux/bitops.h>
+#include <linux/slab.h>
+#include <net/bluetooth/bluetooth.h>
- #define SUPPORT_FW_DUMP 1
- #define BTM_HEADER_LEN 5
- #define BTM_UPLD_SIZE 2312
+#define SAVE_FW_DUMP_IN_KERNEL 1
- #define MTK_TXDATA_SIZE 2000
- #define MTK_RXDATA_SIZE 2000
+#define SUPPORT_FW_DUMP 1
+#define BTM_HEADER_LEN 5
+#define BTM_UPLD_SIZE 2312
- /* Time to wait until Host Sleep state change in millisecond */
- #define WAIT_UNTIL_HS_STATE_CHANGED msecs_to_jiffies(5000)
- /* Time to wait for command response in millisecond */
- #define WAIT_UNTIL_CMD_RESP msecs_to_jiffies(5000)
+#define MTK_TXDATA_SIZE 2000
+#define MTK_RXDATA_SIZE 2000
- enum rdwr_status {
- RDWR_STATUS_SUCCESS = 0,
- RDWR_STATUS_FAILURE = 1,
- RDWR_STATUS_DONE = 2
- };
+/* Time to wait until Host Sleep state change in millisecond */
+#define WAIT_UNTIL_HS_STATE_CHANGED msecs_to_jiffies(5000)
+/* Time to wait for command response in millisecond */
+#define WAIT_UNTIL_CMD_RESP msecs_to_jiffies(5000)
- #define FW_DUMP_MAX_NAME_LEN 8
- #define FW_DUMP_HOST_READY 0xEE
- #define FW_DUMP_DONE 0xFF
- #define FW_DUMP_READ_DONE 0xFE
+enum rdwr_status {
+ RDWR_STATUS_SUCCESS = 0,
+ RDWR_STATUS_FAILURE = 1,
+ RDWR_STATUS_DONE = 2
+};
- struct memory_type_mapping {
- u8 mem_name[FW_DUMP_MAX_NAME_LEN];
- u8 *mem_ptr;
- u32 mem_size;
- u8 done_flag;
- };
+#define FW_DUMP_MAX_NAME_LEN 8
+#define FW_DUMP_HOST_READY 0xEE
+#define FW_DUMP_DONE 0xFF
+#define FW_DUMP_READ_DONE 0xFE
- struct btmtk_thread {
- struct task_struct *task;
- wait_queue_head_t wait_q;
- void *priv;
- };
+struct memory_type_mapping {
+ u8 mem_name[FW_DUMP_MAX_NAME_LEN];
+ u8 *mem_ptr;
+ u32 mem_size;
+ u8 done_flag;
+};
- struct btmtk_device {
- void *card;
- //struct hci_dev *hcidev;
+struct btmtk_thread {
+ struct task_struct *task;
+ wait_queue_head_t wait_q;
+ void *priv;
+};
- u8 dev_type;
+struct btmtk_device {
+ void *card;
+ /* struct hci_dev *hcidev; */
- u8 tx_dnld_rdy;
+ u8 dev_type;
- u8 psmode;
- u8 pscmd;
- u8 hsmode;
- u8 hscmd;
+ u8 tx_dnld_rdy;
- /* Low byte is gap, high byte is GPIO */
- u16 gpio_gap;
+ u8 psmode;
+ u8 pscmd;
+ u8 hsmode;
+ u8 hscmd;
- u8 hscfgcmd;
- u8 sendcmdflag;
- };
+ /* Low byte is gap, high byte is GPIO */
+ u16 gpio_gap;
- struct btmtk_adapter {
- void *hw_regs_buf;
- u8 *hw_regs;
- u32 int_count;
- struct sk_buff_head tx_queue;
- struct sk_buff_head fops_queue;
- u8 fops_mode;
- u8 psmode;
- u8 ps_state;
- u8 hs_state;
- u8 wakeup_tries;
- wait_queue_head_t cmd_wait_q;
- wait_queue_head_t event_hs_wait_q;
- u8 cmd_complete;
- bool is_suspended;
- };
+ u8 hscfgcmd;
+ u8 sendcmdflag;
+};
- struct btmtk_private {
- struct btmtk_device btmtk_dev;
- struct btmtk_adapter *adapter;
- struct btmtk_thread main_thread;
- int (*hw_host_to_card)(struct btmtk_private *priv,
- u8 *payload, u16 nb);
+struct btmtk_adapter {
+ void *hw_regs_buf;
+ u8 *hw_regs;
+ u32 int_count;
+ struct sk_buff_head tx_queue;
+ struct sk_buff_head fops_queue;
+ u8 fops_mode;
+ u8 psmode;
+ u8 ps_state;
+ u8 hs_state;
+ u8 wakeup_tries;
+ wait_queue_head_t cmd_wait_q;
+ wait_queue_head_t event_hs_wait_q;
+ u8 cmd_complete;
+ bool is_suspended;
+};
- int (*hw_set_own_back)(int owntype);
- int (*hw_process_int_status)(struct btmtk_private *priv);
- void (*firmware_dump)(struct btmtk_private *priv);
- spinlock_t driver_lock; /* spinlock used by driver */
- #ifdef CONFIG_DEBUG_FS
- void *debugfs_data;
- #endif
- bool surprise_removed;
-#if SUPPORT_FW_DUMP
- struct semaphore fw_dump_semaphore;
- struct task_struct *fw_dump_tsk;
- struct task_struct *fw_dump_end_check_tsk;
+struct btmtk_private {
+ struct btmtk_device btmtk_dev;
+ struct btmtk_adapter *adapter;
+ struct btmtk_thread main_thread;
+ int (*hw_host_to_card)(struct btmtk_private *priv,
+ u8 *payload, u16 nb);
+
+ int (*hw_set_own_back)(int owntype);
+ int (*hw_process_int_status)(struct btmtk_private *priv);
+ void (*firmware_dump)(struct btmtk_private *priv);
+ spinlock_t driver_lock; /* spinlock used by driver */
+#ifdef CONFIG_DEBUG_FS
+ void *debugfs_data;
#endif
- };
+ bool surprise_removed;
+#if SUPPORT_FW_DUMP
+ struct semaphore fw_dump_semaphore;
+ struct task_struct *fw_dump_tsk;
+ struct task_struct *fw_dump_end_check_tsk;
+#endif
+};
- #define MTK_VENDOR_PKT 0xFE
+#define MTK_VENDOR_PKT 0xFE
- /* Vendor specific Bluetooth commands */
- #define BT_CMD_PSCAN_WIN_REPORT_ENABLE 0xFC03
- #define BT_CMD_ROUTE_SCO_TO_HOST 0xFC1D
- #define BT_CMD_SET_BDADDR 0xFC22
- #define BT_CMD_AUTO_SLEEP_MODE 0xFC23
- #define BT_CMD_HOST_SLEEP_CONFIG 0xFC59
- #define BT_CMD_HOST_SLEEP_ENABLE 0xFC5A
- #define BT_CMD_MODULE_CFG_REQ 0xFC5B
- #define BT_CMD_LOAD_CONFIG_DATA 0xFC61
+/* Vendor specific Bluetooth commands */
+#define BT_CMD_PSCAN_WIN_REPORT_ENABLE 0xFC03
+#define BT_CMD_ROUTE_SCO_TO_HOST 0xFC1D
+#define BT_CMD_SET_BDADDR 0xFC22
+#define BT_CMD_AUTO_SLEEP_MODE 0xFC23
+#define BT_CMD_HOST_SLEEP_CONFIG 0xFC59
+#define BT_CMD_HOST_SLEEP_ENABLE 0xFC5A
+#define BT_CMD_MODULE_CFG_REQ 0xFC5B
+#define BT_CMD_LOAD_CONFIG_DATA 0xFC61
- /* Sub-commands: Module Bringup/Shutdown Request/Response */
- #define MODULE_BRINGUP_REQ 0xF1
- #define MODULE_BROUGHT_UP 0x00
- #define MODULE_ALREADY_UP 0x0C
+/* Sub-commands: Module Bringup/Shutdown Request/Response */
+#define MODULE_BRINGUP_REQ 0xF1
+#define MODULE_BROUGHT_UP 0x00
+#define MODULE_ALREADY_UP 0x0C
- #define MODULE_SHUTDOWN_REQ 0xF2
+#define MODULE_SHUTDOWN_REQ 0xF2
- /* Vendor specific Bluetooth events */
- #define BT_EVENT_AUTO_SLEEP_MODE 0x23
- #define BT_EVENT_HOST_SLEEP_CONFIG 0x59
- #define BT_EVENT_HOST_SLEEP_ENABLE 0x5A
- #define BT_EVENT_MODULE_CFG_REQ 0x5B
- #define BT_EVENT_POWER_STATE 0x20
+/* Vendor specific Bluetooth events */
+#define BT_EVENT_AUTO_SLEEP_MODE 0x23
+#define BT_EVENT_HOST_SLEEP_CONFIG 0x59
+#define BT_EVENT_HOST_SLEEP_ENABLE 0x5A
+#define BT_EVENT_MODULE_CFG_REQ 0x5B
+#define BT_EVENT_POWER_STATE 0x20
- /* Bluetooth Power States */
- #define BT_PS_ENABLE 0x02
- #define BT_PS_DISABLE 0x03
- #define BT_PS_SLEEP 0x01
+/* Bluetooth Power States */
+#define BT_PS_ENABLE 0x02
+#define BT_PS_DISABLE 0x03
+#define BT_PS_SLEEP 0x01
- /* Host Sleep states */
- #define HS_ACTIVATED 0x01
- #define HS_DEACTIVATED 0x00
+/* Host Sleep states */
+#define HS_ACTIVATED 0x01
+#define HS_DEACTIVATED 0x00
- /* Power Save modes */
- #define PS_SLEEP 0x01
- #define PS_AWAKE 0x00
+/* Power Save modes */
+#define PS_SLEEP 0x01
+#define PS_AWAKE 0x00
- #define BT_CAL_HDR_LEN 4
- #define BT_CAL_DATA_SIZE 28
+#define BT_CAL_HDR_LEN 4
+#define BT_CAL_DATA_SIZE 28
+#define FW_DUMP_BUF_SIZE (1024*512)
- #define FW_DUMP_BUF_SIZE (1024*512)
+#define FW_DUMP_FILE_NAME_SIZE 64
- #define FW_DUMP_FILE_NAME_SIZE 64
-
- //#define SAVE_FW_DUMP_IN_KERNEL 1
+/* #define SAVE_FW_DUMP_IN_KERNEL 1 */
/* stpbt device node */
#define BT_NODE "stpbt"
#define BT_DRIVER_NAME "BT_chrdev"
- struct btmtk_event {
- u8 ec; /* event counter */
- u8 length;
- u8 data[4];
- } __packed;
+struct btmtk_event {
+ u8 ec; /* event counter */
+ u8 length;
+ u8 data[4];
+} __packed;
- /* Prototype of global function */
+/* Prototype of global function */
- struct btmtk_private *btmtk_add_card(void *card);
- int btmtk_remove_card(struct btmtk_private *priv);
+struct btmtk_private *btmtk_add_card(void *card);
+int btmtk_remove_card(struct btmtk_private *priv);
- void btmtk_interrupt(struct btmtk_private *priv);
+void btmtk_interrupt(struct btmtk_private *priv);
- bool btmtk_check_evtpkt(struct btmtk_private *priv, struct sk_buff *skb);
- int btmtk_process_event(struct btmtk_private *priv, struct sk_buff *skb);
+bool btmtk_check_evtpkt(struct btmtk_private *priv, struct sk_buff *skb);
+int btmtk_process_event(struct btmtk_private *priv, struct sk_buff *skb);
- int btmtk_send_module_cfg_cmd(struct btmtk_private *priv, u8 subcmd);
- int btmtk_pscan_window_reporting(struct btmtk_private *priv, u8 subcmd);
- int btmtk_send_hscfg_cmd(struct btmtk_private *priv);
- int btmtk_enable_ps(struct btmtk_private *priv);
- int btmtk_prepare_command(struct btmtk_private *priv);
- int btmtk_enable_hs(struct btmtk_private *priv);
- void btmtk_firmware_dump(struct btmtk_private *priv);
-
+int btmtk_send_module_cfg_cmd(struct btmtk_private *priv, u8 subcmd);
+int btmtk_pscan_window_reporting(struct btmtk_private *priv, u8 subcmd);
+int btmtk_send_hscfg_cmd(struct btmtk_private *priv);
+int btmtk_enable_ps(struct btmtk_private *priv);
+int btmtk_prepare_command(struct btmtk_private *priv);
+int btmtk_enable_hs(struct btmtk_private *priv);
+void btmtk_firmware_dump(struct btmtk_private *priv);
#define META_BUFFER_SIZE (1024*50)
-typedef struct _OSAL_UNSLEEPABLE_LOCK_ {
+struct _OSAL_UNSLEEPABLE_LOCK_ {
spinlock_t lock;
unsigned long flag;
-} OSAL_UNSLEEPABLE_LOCK, *P_OSAL_UNSLEEPABLE_LOCK;
+};
-typedef struct {
- OSAL_UNSLEEPABLE_LOCK spin_lock;
+struct ring_buffer {
+ struct _OSAL_UNSLEEPABLE_LOCK_ spin_lock;
u8 buffer[META_BUFFER_SIZE]; /* MTKSTP_BUFFER_SIZE:1024 */
u32 read_p; /* indicate the current read index */
u32 write_p; /* indicate the current write index */
-} ring_buffer_struct;
+};
- #ifdef CONFIG_DEBUG_FS
+#ifdef CONFIG_DEBUG_FS
#define FIXED_STPBT_MAJOR_DEV_ID 111
@@ -221,24 +221,7 @@
#define FW_DUMP_FILE_NAME "/tmp/log"
#define FW_DUMP_END_EVENT "coredump end"
-#define BTMTK_LOG_LEVEL_ERROR 1
-#define BTMTK_LOG_LEVEL_WARNING 2
-#define BTMTK_LOG_LEVEL_INFO 3
-#define BTMTK_LOG_LEVEL_DEBUG 4
-
-#define BTMTK_LOG_LEVEL_DEFAULT BTMTK_LOG_LEVEL_INFO /* default setting */
-extern u8 btmtk_log_lvl;
-
-#define BTMTK_ERR(fmt, ...) \
- do {if (btmtk_log_lvl >= BTMTK_LOG_LEVEL_ERROR) pr_warn("btmtk_err: "fmt"\n", ##__VA_ARGS__); } while (0)
-#define BTMTK_WARN(fmt, ...) \
- do {if (btmtk_log_lvl >= BTMTK_LOG_LEVEL_WARNING) pr_warn("btmtk_warn: "fmt"\n", ##__VA_ARGS__); } while (0)
-#define BTMTK_INFO(fmt, ...) \
- do {if (btmtk_log_lvl >= BTMTK_LOG_LEVEL_INFO) pr_warn("btmtk_info: "fmt"\n", ##__VA_ARGS__); } while (0)
-#define BTMTK_DBG(fmt, ...) \
- do {if (btmtk_log_lvl >= BTMTK_LOG_LEVEL_DEBUG) pr_warn("btmtk_debug: "fmt"\n", ##__VA_ARGS__); } while (0)
-
-
+#endif
#endif
diff --git a/btmtk_main.c b/btmtk_main.c
index bf659d8..5a85061 100644
--- a/btmtk_main.c
+++ b/btmtk_main.c
@@ -1,22 +1,21 @@
-/**
+/*
* Mediatek Bluetooth driver
*
- * Copyright (C) 2009, Mediatek International Ltd.
+ * Copyright (C) 2017, Mediatek International Ltd.
*
* This software file (the "File") is distributed by Mediatek International
* Ltd. under the terms of the GNU General Public License Version 2, June 1991
* (the "License"). You may use, redistribute and/or modify this File in
* accordance with the terms and conditions of the License, a copy of which
* is available by writing to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
- * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ * On the worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
*
*
* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
* IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
* this warranty disclaimer.
- **/
+ */
#include <linux/version.h>
#include <linux/module.h>
#include <linux/of.h>
@@ -26,33 +25,6 @@
#include "btmtk_drv.h"
#include "btmtk_sdio.h"
-
-
-
-/*
-* extern unsigned char probe_counter;
-* extern unsigned char *txbuf;
-*/
-
-extern u8 probe_ready;
-
-
-/*
-* int fw_dump_buffer_full = 0;
-* int fw_dump_total_read_size = 0;
-* int fw_dump_total_write_size = 0;
-* int fw_dump_buffer_used_size = 0;
-* int fw_dump_task_should_stop = 0;
-* u8 *fw_dump_ptr = NULL;
-* u8 *fw_dump_read_ptr = NULL;
-* u8 *fw_dump_write_ptr = NULL;
-* struct timeval fw_dump_last_write_time;
-* int fw_dump_end_checking_task_should_stop = 0;
-
-* static volatile int is_assert = 0;
-*/
-
-
/*
* This function is called by interface specific interrupt handler.
* It updates Power Save & Host Sleep states, and wakes up the main
@@ -60,113 +32,112 @@
*/
void btmtk_interrupt(struct btmtk_private *priv)
{
- priv->adapter->ps_state = PS_AWAKE;
+ priv->adapter->ps_state = PS_AWAKE;
- priv->adapter->wakeup_tries = 0;
+ priv->adapter->wakeup_tries = 0;
- priv->adapter->int_count++;
+ priv->adapter->int_count++;
- wake_up_interruptible(&priv->main_thread.wait_q);
+ wake_up_interruptible(&priv->main_thread.wait_q);
}
EXPORT_SYMBOL_GPL(btmtk_interrupt);
int btmtk_enable_hs(struct btmtk_private *priv)
{
- struct btmtk_adapter *adapter = priv->adapter;
- int ret = 0;
+ struct btmtk_adapter *adapter = priv->adapter;
+ int ret = 0;
- BTMTK_INFO("%s begin\n", __func__);
+ pr_info("%s begin\n", __func__);
- ret = wait_event_interruptible_timeout(adapter->event_hs_wait_q,
- adapter->hs_state,
- msecs_to_jiffies(WAIT_UNTIL_HS_STATE_CHANGED));
- if (ret < 0) {
- BTMTK_ERR("event_hs_wait_q terminated (%d): %d,%d,%d",
- ret, adapter->hs_state, adapter->ps_state,
- adapter->wakeup_tries);
+ ret = wait_event_interruptible_timeout(adapter->event_hs_wait_q,
+ adapter->hs_state,
+ msecs_to_jiffies(WAIT_UNTIL_HS_STATE_CHANGED));
+ if (ret < 0) {
+ pr_err("event_hs_wait_q terminated (%d): %d,%d,%d\n",
+ ret, adapter->hs_state, adapter->ps_state,
+ adapter->wakeup_tries);
- } else {
- BTMTK_DBG("host sleep enabled: %d,%d,%d", adapter->hs_state,
- adapter->ps_state, adapter->wakeup_tries);
- ret = 0;
- }
+ } else {
+ pr_debug("host sleep enabled: %d,%d,%d\n", adapter->hs_state,
+ adapter->ps_state, adapter->wakeup_tries);
+ ret = 0;
+ }
- return ret;
+ return ret;
}
EXPORT_SYMBOL_GPL(btmtk_enable_hs);
static int btmtk_tx_pkt(struct btmtk_private *priv, struct sk_buff *skb)
{
- int ret = 0;
- u32 sdio_header_len = 0;
+ int ret = 0;
+ u32 sdio_header_len = 0;
- BTMTK_DBG("%s skb->len %d", __func__, skb->len);
+ pr_debug("%s skb->len %d\n", __func__, skb->len);
- if (!skb) {
- BTMTK_WARN("%s skb is NULL return -EINVAL", __func__);
- return -EINVAL;
- }
+ if (!skb) {
+ pr_warn("%s skb is NULL return -EINVAL\n", __func__);
+ return -EINVAL;
+ }
- if (!skb->data) {
- BTMTK_WARN("%s skb->data is NULL return -EINVAL", __func__);
- return -EINVAL;
- }
+ if (!skb->data) {
+ pr_warn("%s skb->data is NULL return -EINVAL\n", __func__);
+ return -EINVAL;
+ }
- if (!skb->len || ((skb->len + BTM_HEADER_LEN) > BTM_UPLD_SIZE)) {
- BTMTK_WARN("Tx Error: Bad skb length %d : %d",
- skb->len, BTM_UPLD_SIZE);
- return -EINVAL;
- }
+ if (!skb->len || ((skb->len + BTM_HEADER_LEN) > BTM_UPLD_SIZE)) {
+ pr_warn("Tx Error: Bad skb length %d : %d\n",
+ skb->len, BTM_UPLD_SIZE);
+ return -EINVAL;
+ }
+ sdio_header_len = skb->len + BTM_HEADER_LEN;
+ memset(txbuf, 0, MTK_TXDATA_SIZE);
+ txbuf[0] = (sdio_header_len & 0x0000ff);
+ txbuf[1] = (sdio_header_len & 0x00ff00) >> 8;
+ txbuf[2] = 0;
+ txbuf[3] = 0;
+ txbuf[4] = bt_cb(skb)->pkt_type;
+ memcpy(&txbuf[5], &skb->data[0], skb->len);
+ if (priv->hw_host_to_card)
+ ret = priv->hw_host_to_card(priv, txbuf, sdio_header_len);
- sdio_header_len = skb->len + BTM_HEADER_LEN;
- memset(txbuf, 0, MTK_TXDATA_SIZE);
- txbuf[0] = (sdio_header_len & 0x0000ff);
- txbuf[1] = (sdio_header_len & 0x00ff00) >> 8;
- txbuf[2] = 0;
- txbuf[3] = 0;
- txbuf[4] = bt_cb(skb)->pkt_type;
- memcpy(&txbuf[5], &skb->data[0], skb->len);
- if (priv->hw_host_to_card)
- ret = priv->hw_host_to_card(priv, txbuf, sdio_header_len);
-
- BTMTK_DBG("%s end", __func__);
- return ret;
+ pr_debug("%s end\n", __func__);
+ return ret;
}
static void btmtk_init_adapter(struct btmtk_private *priv)
{
- int buf_size;
+ int buf_size;
- skb_queue_head_init(&priv->adapter->tx_queue);
- skb_queue_head_init(&priv->adapter->fops_queue);
- priv->adapter->ps_state = PS_AWAKE;
+ skb_queue_head_init(&priv->adapter->tx_queue);
+ skb_queue_head_init(&priv->adapter->fops_queue);
+ priv->adapter->ps_state = PS_AWAKE;
- buf_size = ALIGN_SZ(SDIO_BLOCK_SIZE, BTSDIO_DMA_ALIGN);
- priv->adapter->hw_regs_buf = kzalloc(buf_size, GFP_KERNEL);
- if (!priv->adapter->hw_regs_buf) {
- priv->adapter->hw_regs = NULL;
- BTMTK_ERR("Unable to allocate buffer for hw_regs.");
- } else {
- priv->adapter->hw_regs =
- (u8 *)ALIGN_ADDR(priv->adapter->hw_regs_buf,
- BTSDIO_DMA_ALIGN);
- BTMTK_DBG("hw_regs_buf=%p hw_regs=%p",
- priv->adapter->hw_regs_buf, priv->adapter->hw_regs);
- }
+ buf_size = ALIGN_SZ(SDIO_BLOCK_SIZE, BTSDIO_DMA_ALIGN);
+ priv->adapter->hw_regs_buf = kzalloc(buf_size, GFP_KERNEL);
+ if (!priv->adapter->hw_regs_buf) {
+ priv->adapter->hw_regs = NULL;
+ pr_err("Unable to allocate buffer for hw_regs.\n");
+ } else {
+ priv->adapter->hw_regs =
+ (u8 *)ALIGN_ADDR(priv->adapter->hw_regs_buf,
+ BTSDIO_DMA_ALIGN);
+ pr_debug("hw_regs_buf=%p hw_regs=%p\n",
+ priv->adapter->hw_regs_buf, priv->adapter->hw_regs);
+ }
- init_waitqueue_head(&priv->adapter->cmd_wait_q);
- init_waitqueue_head(&priv->adapter->event_hs_wait_q);
+ init_waitqueue_head(&priv->adapter->cmd_wait_q);
+ init_waitqueue_head(&priv->adapter->event_hs_wait_q);
}
static void btmtk_free_adapter(struct btmtk_private *priv)
{
- skb_queue_purge(&priv->adapter->tx_queue);
+ skb_queue_purge(&priv->adapter->tx_queue);
- kfree(priv->adapter->hw_regs_buf);
- kfree(priv->adapter);
+ kfree(priv->adapter->hw_regs_buf);
+ kfree(priv->adapter);
- priv->adapter = NULL;
+ priv->adapter = NULL;
}
/*
@@ -176,205 +147,196 @@
static int btmtk_service_main_thread(void *data)
{
- struct btmtk_thread *thread = data;
- struct btmtk_private *priv = thread->priv;
- struct btmtk_adapter *adapter = NULL;
- wait_queue_t wait;
- struct sk_buff *skb;
- int ret = 0;
- int i = 0;
- ulong flags;
+ struct btmtk_thread *thread = data;
+ struct btmtk_private *priv = thread->priv;
+ struct btmtk_adapter *adapter = NULL;
+ wait_queue_t wait;
+ struct sk_buff *skb;
+ int ret = 0;
+ int i = 0;
+ ulong flags;
- BTMTK_WARN("main_thread begin 50");
- //mdelay(50);
-
- for(i=0;i<=1000;i++){
- if (kthread_should_stop()) {
- BTMTK_WARN("main_thread: break from main thread for probe_ready");
- break;
- }
+ pr_warn("main_thread begin 50\n");
+ /* mdelay(50); */
- if (probe_ready) {
- break;
- } else {
- BTMTK_WARN("%s probe_ready %d delay 10ms",__func__,probe_ready);
- mdelay(10);
- }
+ for (i = 0; i <= 1000; i++) {
+ if (kthread_should_stop()) {
+ pr_warn("main_thread: break from main thread for probe_ready\n");
+ break;
+ }
- if(i==1000){
- BTMTK_WARN("%s probe_ready %d i = %d try too many times return",__func__,probe_ready,i);
- return 0;
- }
- }
+ if (probe_ready)
+ break;
- if(priv->adapter)
- adapter = priv->adapter;
- else {
- BTMTK_ERR("%s priv->adapter is NULL return",__func__);
- return 0;
- }
+ pr_warn("%s probe_ready %d delay 10ms~15ms\n",
+ __func__, probe_ready);
+ usleep_range(10*1000, 15*1000);
- init_waitqueue_entry(&wait, current);
- for (;;) {
- add_wait_queue(&thread->wait_q, &wait);
- set_current_state(TASK_INTERRUPTIBLE);
- if (kthread_should_stop()) {
- BTMTK_WARN("main_thread: break from main thread");
- break;
- }
+ if (i == 1000) {
+ pr_warn("%s probe_ready %d i = %d try too many times return\n",
+ __func__, probe_ready, i);
+ return 0;
+ }
+ }
- if (adapter->wakeup_tries ||
- ((!adapter->int_count) &&
- (!priv->btmtk_dev.tx_dnld_rdy ||
- skb_queue_empty(&adapter->tx_queue)))) {
- BTMTK_DBG("main_thread is sleeping...");
- schedule();
- }
+ if (priv->adapter)
+ adapter = priv->adapter;
+ else {
+ pr_err("%s priv->adapter is NULL return\n", __func__);
+ return 0;
+ }
- set_current_state(TASK_RUNNING);
+ init_waitqueue_entry(&wait, current);
+ for (;;) {
+ add_wait_queue(&thread->wait_q, &wait);
+ set_current_state(TASK_INTERRUPTIBLE);
+ if (kthread_should_stop()) {
+ pr_warn("main_thread: break from main thread\n");
+ break;
+ }
- remove_wait_queue(&thread->wait_q, &wait);
+ if (adapter->wakeup_tries ||
+ ((!adapter->int_count) &&
+ (!priv->btmtk_dev.tx_dnld_rdy ||
+ skb_queue_empty(&adapter->tx_queue)))) {
+ pr_debug("main_thread is sleeping...\n");
+ schedule();
+ }
- if (kthread_should_stop()) {
- BTMTK_WARN("main_thread: break after wake up");
- break;
- }
+ set_current_state(TASK_RUNNING);
- ret = priv->hw_set_own_back(DRIVER_OWN);
- if (ret) {
- BTMTK_ERR("%s set driver own return fail", __func__);
- break;
- }
+ remove_wait_queue(&thread->wait_q, &wait);
- spin_lock_irqsave(&priv->driver_lock, flags);
- if (adapter->int_count) {
- BTMTK_DBG("%s go int\n", __func__);
- adapter->int_count = 0;
- spin_unlock_irqrestore(&priv->driver_lock, flags);
- priv->hw_process_int_status(priv);
- } else if (adapter->ps_state == PS_SLEEP &&
- !skb_queue_empty(&adapter->tx_queue)) {
- BTMTK_DBG("%s go vender, todo\n", __func__);
- spin_unlock_irqrestore(&priv->driver_lock, flags);
- adapter->wakeup_tries++;
- continue;
- } else {
- BTMTK_DBG("%s go tx\n", __func__);
- spin_unlock_irqrestore(&priv->driver_lock, flags);
- }
+ if (kthread_should_stop()) {
+ pr_warn("main_thread: break after wake up\n");
+ break;
+ }
- if (adapter->ps_state == PS_SLEEP) {
- BTMTK_DBG("%s ps_state == PS_SLEEP, continue\n", __func__);
- continue;
- }
+ ret = priv->hw_set_own_back(DRIVER_OWN);
+ if (ret) {
+ pr_err("%s set driver own return fail\n", __func__);
+ break;
+ }
- if (!priv->btmtk_dev.tx_dnld_rdy) {
- BTMTK_DBG("%s tx_dnld_rdy == 0, continue\n", __func__);
- continue;
- }
+ spin_lock_irqsave(&priv->driver_lock, flags);
+ if (adapter->int_count) {
+ pr_debug("%s go int\n", __func__);
+ adapter->int_count = 0;
+ spin_unlock_irqrestore(&priv->driver_lock, flags);
+ priv->hw_process_int_status(priv);
+ } else if (adapter->ps_state == PS_SLEEP &&
+ !skb_queue_empty(&adapter->tx_queue)) {
+ pr_debug("%s go vender, todo\n", __func__);
+ spin_unlock_irqrestore(&priv->driver_lock, flags);
+ adapter->wakeup_tries++;
+ continue;
+ } else {
+ pr_debug("%s go tx\n", __func__);
+ spin_unlock_irqrestore(&priv->driver_lock, flags);
+ }
- spin_lock_irqsave(&priv->driver_lock, flags);
- skb = skb_dequeue(&adapter->tx_queue);
- spin_unlock_irqrestore(&priv->driver_lock, flags);
+ if (adapter->ps_state == PS_SLEEP) {
+ pr_debug("%s ps_state == PS_SLEEP, continue\n",
+ __func__);
+ continue;
+ }
- if (skb) {
- if (skb->len < 16)
- btmtk_print_buffer_conent(skb->data, skb->len);
- else
- btmtk_print_buffer_conent(skb->data, 16);
+ if (!priv->btmtk_dev.tx_dnld_rdy) {
+ pr_debug("%s tx_dnld_rdy == 0, continue\n", __func__);
+ continue;
+ }
- btmtk_tx_pkt(priv, skb);
+ spin_lock_irqsave(&priv->driver_lock, flags);
+ skb = skb_dequeue(&adapter->tx_queue);
+ spin_unlock_irqrestore(&priv->driver_lock, flags);
- if (skb) {
- BTMTK_DBG("%s after btmtk_tx_pkt kfree_skb", __func__);
- kfree_skb(skb);
- }
- }
+ if (skb) {
+ if (skb->len < 16)
+ btmtk_print_buffer_conent(skb->data, skb->len);
+ else
+ btmtk_print_buffer_conent(skb->data, 16);
+
+ btmtk_tx_pkt(priv, skb);
+
+ if (skb) {
+ pr_debug("%s after btmtk_tx_pkt kfree_skb\n",
+ __func__);
+ kfree_skb(skb);
+ }
+ }
- if (skb_queue_empty(&adapter->tx_queue)) {
- ret = priv->hw_set_own_back(FW_OWN);
- if (ret) {
- BTMTK_ERR("%s set fw own return fail", __func__);
- break;
- }
- }
-
-
- }
- BTMTK_INFO("%s end\n", __func__);
- return 0;
+ if (skb_queue_empty(&adapter->tx_queue)) {
+ ret = priv->hw_set_own_back(FW_OWN);
+ if (ret) {
+ pr_err("%s set fw own return fail\n",
+ __func__);
+ break;
+ }
+ }
+ }
+ pr_info("%s end\n", __func__);
+ return 0;
}
-
-
struct btmtk_private *btmtk_add_card(void *card)
{
- struct btmtk_private *priv;
+ struct btmtk_private *priv;
- BTMTK_INFO("%s begin", __func__);
- priv = kzalloc(sizeof(*priv), GFP_KERNEL);
- if (!priv) {
- BTMTK_ERR("Can not allocate priv");
- goto err_priv;
- }
+ pr_info("%s begin\n", __func__);
+ priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ goto err_priv;
- priv->adapter = kzalloc(sizeof(*priv->adapter), GFP_KERNEL);
- if (!priv->adapter) {
- BTMTK_ERR("Allocate buffer for btmtk_adapter failed!");
- goto err_adapter;
- }
+ priv->adapter = kzalloc(sizeof(*priv->adapter), GFP_KERNEL);
+ if (!priv->adapter)
+ goto err_adapter;
- btmtk_init_adapter(priv);
+ btmtk_init_adapter(priv);
- BTMTK_INFO("Starting kthread...");
- priv->main_thread.priv = priv;
- spin_lock_init(&priv->driver_lock);
+ pr_info("Starting kthread...\n");
+ priv->main_thread.priv = priv;
+ spin_lock_init(&priv->driver_lock);
- init_waitqueue_head(&priv->main_thread.wait_q);
- priv->main_thread.task = kthread_run(btmtk_service_main_thread,
- &priv->main_thread, "btmtk_main_service");
- if (IS_ERR(priv->main_thread.task))
- goto err_thread;
+ init_waitqueue_head(&priv->main_thread.wait_q);
+ priv->main_thread.task = kthread_run(btmtk_service_main_thread,
+ &priv->main_thread, "btmtk_main_service");
+ if (IS_ERR(priv->main_thread.task))
+ goto err_thread;
- priv->btmtk_dev.card = card;
- priv->btmtk_dev.tx_dnld_rdy = true;
+ priv->btmtk_dev.card = card;
+ priv->btmtk_dev.tx_dnld_rdy = true;
- return priv;
+ return priv;
err_thread:
- btmtk_free_adapter(priv);
+ btmtk_free_adapter(priv);
err_adapter:
- kfree(priv);
+ kfree(priv);
err_priv:
- return NULL;
+ return NULL;
}
EXPORT_SYMBOL_GPL(btmtk_add_card);
int btmtk_remove_card(struct btmtk_private *priv)
{
+ pr_info("%s begin\n", __func__);
-
- BTMTK_INFO("%s begin\n", __func__);
-
-
- BTMTK_INFO("%s stop main_thread\n", __func__);
-
- if(!PTR_ERR(priv->main_thread.task))
- kthread_stop(priv->main_thread.task);
-
- BTMTK_INFO("%s stop main_thread done\n", __func__);
+ pr_info("%s stop main_thread\n", __func__);
+ if (!PTR_ERR(priv->main_thread.task))
+ kthread_stop(priv->main_thread.task);
+ pr_info("%s stop main_thread done\n", __func__);
#ifdef CONFIG_DEBUG_FS
- /*btmtk_debugfs_remove(hdev);*/
+ /*btmtk_debugfs_remove(hdev);*/
#endif
- btmtk_free_adapter(priv);
+ btmtk_free_adapter(priv);
- kfree(priv);
+ kfree(priv);
- return 0;
+ return 0;
}
EXPORT_SYMBOL_GPL(btmtk_remove_card);
diff --git a/btmtk_sdio.c b/btmtk_sdio.c
index ab81b8d..94151ae 100644
--- a/btmtk_sdio.c
+++ b/btmtk_sdio.c
@@ -1,21 +1,20 @@
-/**
+/*
* Mediatek BT-over-SDIO driver: SDIO interface related functions.
- * Copyright (C) 2009, Mediatek International Ltd.
+ * Copyright (C) 2017, Mediatek International Ltd.
*
* This software file (the "File") is distributed by Mediatek International
* Ltd. under the terms of the GNU General Public License Version 2, June 1991
* (the "License"). You may use, redistribute and/or modify this File in
* accordance with the terms and conditions of the License, a copy of which
* is available by writing to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
- * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ * On the worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
*
*
* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
* IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
* this warranty disclaimer.
- **/
+ */
#include <linux/version.h>
#include <linux/firmware.h>
#include <linux/slab.h>
@@ -40,7 +39,6 @@
#include "btmtk_drv.h"
#include "btmtk_sdio.h"
-u8 btmtk_log_lvl = BTMTK_LOG_LEVEL_DEFAULT;
static dev_t g_devIDfwlog;
static struct class *pBTClass;
static struct device *pBTDev;
@@ -82,7 +80,7 @@
#define STR_COREDUMP_END "coredump end\n\n"
-static ring_buffer_struct metabuffer;
+static struct ring_buffer metabuffer;
u8 probe_ready;
static char fw_dump_file_name[FW_DUMP_FILE_NAME_SIZE] = {0};
@@ -100,122 +98,122 @@
int fw_is_coredump_end_packet;
#if SAVE_FW_DUMP_IN_KERNEL
- static struct file *fw_dump_file;
+ static struct file *fw_dump_file;
#else
- static int fw_dump_file;
+ static int fw_dump_file;
#endif
static const struct btmtk_sdio_card_reg btmtk_reg_6630 = {
- .cfg = 0x03,
- .host_int_mask = 0x04,
- .host_intstatus = 0x05,
- .card_status = 0x20,
- .sq_read_base_addr_a0 = 0x10,
- .sq_read_base_addr_a1 = 0x11,
- .card_fw_status0 = 0x40,
- .card_fw_status1 = 0x41,
- .card_rx_len = 0x42,
- .card_rx_unit = 0x43,
- .io_port_0 = 0x00,
- .io_port_1 = 0x01,
- .io_port_2 = 0x02,
- .int_read_to_clear = false,
- .func_num = 2,
+ .cfg = 0x03,
+ .host_int_mask = 0x04,
+ .host_intstatus = 0x05,
+ .card_status = 0x20,
+ .sq_read_base_addr_a0 = 0x10,
+ .sq_read_base_addr_a1 = 0x11,
+ .card_fw_status0 = 0x40,
+ .card_fw_status1 = 0x41,
+ .card_rx_len = 0x42,
+ .card_rx_unit = 0x43,
+ .io_port_0 = 0x00,
+ .io_port_1 = 0x01,
+ .io_port_2 = 0x02,
+ .int_read_to_clear = false,
+ .func_num = 2,
};
static const struct btmtk_sdio_card_reg btmtk_reg_6632 = {
- .cfg = 0x03,
- .host_int_mask = 0x04,
- .host_intstatus = 0x05,
- .card_status = 0x20,
- .sq_read_base_addr_a0 = 0x10,
- .sq_read_base_addr_a1 = 0x11,
- .card_fw_status0 = 0x40,
- .card_fw_status1 = 0x41,
- .card_rx_len = 0x42,
- .card_rx_unit = 0x43,
- .io_port_0 = 0x00,
- .io_port_1 = 0x01,
- .io_port_2 = 0x02,
- .int_read_to_clear = false,
- .func_num = 2,
+ .cfg = 0x03,
+ .host_int_mask = 0x04,
+ .host_intstatus = 0x05,
+ .card_status = 0x20,
+ .sq_read_base_addr_a0 = 0x10,
+ .sq_read_base_addr_a1 = 0x11,
+ .card_fw_status0 = 0x40,
+ .card_fw_status1 = 0x41,
+ .card_rx_len = 0x42,
+ .card_rx_unit = 0x43,
+ .io_port_0 = 0x00,
+ .io_port_1 = 0x01,
+ .io_port_2 = 0x02,
+ .int_read_to_clear = false,
+ .func_num = 2,
};
static const struct btmtk_sdio_card_reg btmtk_reg_7668 = {
- .cfg = 0x03,
- .host_int_mask = 0x04,
- .host_intstatus = 0x05,
- .card_status = 0x20,
- .sq_read_base_addr_a0 = 0x10,
- .sq_read_base_addr_a1 = 0x11,
- .card_fw_status0 = 0x40,
- .card_fw_status1 = 0x41,
- .card_rx_len = 0x42,
- .card_rx_unit = 0x43,
- .io_port_0 = 0x00,
- .io_port_1 = 0x01,
- .io_port_2 = 0x02,
- .int_read_to_clear = false,
- .func_num = 2,
+ .cfg = 0x03,
+ .host_int_mask = 0x04,
+ .host_intstatus = 0x05,
+ .card_status = 0x20,
+ .sq_read_base_addr_a0 = 0x10,
+ .sq_read_base_addr_a1 = 0x11,
+ .card_fw_status0 = 0x40,
+ .card_fw_status1 = 0x41,
+ .card_rx_len = 0x42,
+ .card_rx_unit = 0x43,
+ .io_port_0 = 0x00,
+ .io_port_1 = 0x01,
+ .io_port_2 = 0x02,
+ .int_read_to_clear = false,
+ .func_num = 2,
};
static const struct btmtk_sdio_card_reg btmtk_reg_7666 = {
- .cfg = 0x03,
- .host_int_mask = 0x04,
- .host_intstatus = 0x05,
- .card_status = 0x20,
- .sq_read_base_addr_a0 = 0x10,
- .sq_read_base_addr_a1 = 0x11,
- .card_fw_status0 = 0x40,
- .card_fw_status1 = 0x41,
- .card_rx_len = 0x42,
- .card_rx_unit = 0x43,
- .io_port_0 = 0x00,
- .io_port_1 = 0x01,
- .io_port_2 = 0x02,
- .int_read_to_clear = false,
- .func_num = 2,
+ .cfg = 0x03,
+ .host_int_mask = 0x04,
+ .host_intstatus = 0x05,
+ .card_status = 0x20,
+ .sq_read_base_addr_a0 = 0x10,
+ .sq_read_base_addr_a1 = 0x11,
+ .card_fw_status0 = 0x40,
+ .card_fw_status1 = 0x41,
+ .card_rx_len = 0x42,
+ .card_rx_unit = 0x43,
+ .io_port_0 = 0x00,
+ .io_port_1 = 0x01,
+ .io_port_2 = 0x02,
+ .int_read_to_clear = false,
+ .func_num = 2,
};
static const struct btmtk_sdio_device btmtk_sdio_6630 = {
- .helper = "mtmk/sd8688_helper.bin",
- .firmware = "mt6632_patch_e1_hdr.bin",
- .reg = &btmtk_reg_6630,
- .support_pscan_win_report = false,
- .sd_blksz_fw_dl = 64,
- .supports_fw_dump = false,
+ .helper = "mtmk/sd8688_helper.bin",
+ .firmware = "mt6632_patch_e1_hdr.bin",
+ .reg = &btmtk_reg_6630,
+ .support_pscan_win_report = false,
+ .sd_blksz_fw_dl = 64,
+ .supports_fw_dump = false,
};
static const struct btmtk_sdio_device btmtk_sdio_6632 = {
- .helper = "mtmk/sd8688_helper.bin",
- .firmware = "mt6632_patch_e1_hdr.bin",
- .reg = &btmtk_reg_6632,
- .support_pscan_win_report = false,
- .sd_blksz_fw_dl = 64,
- .supports_fw_dump = false,
+ .helper = "mtmk/sd8688_helper.bin",
+ .firmware = "mt6632_patch_e1_hdr.bin",
+ .reg = &btmtk_reg_6632,
+ .support_pscan_win_report = false,
+ .sd_blksz_fw_dl = 64,
+ .supports_fw_dump = false,
};
static const struct btmtk_sdio_device btmtk_sdio_7668 = {
- .helper = "mtmk/sd8688_helper.bin",
+ .helper = "mtmk/sd8688_helper.bin",
#if CFG_THREE_IN_ONE_FIRMWARE
- .firmware = "MT7668_FW",
+ .firmware = "MT7668_FW",
#else
- .firmware = "mt7668_patch_e1_hdr.bin",
- .firmware1 = "mt7668_patch_e2_hdr.bin",
+ .firmware = "mt7668_patch_e1_hdr.bin",
+ .firmware1 = "mt7668_patch_e2_hdr.bin",
#endif
- .reg = &btmtk_reg_7668,
- .support_pscan_win_report = false,
- .sd_blksz_fw_dl = 64,
- .supports_fw_dump = false,
+ .reg = &btmtk_reg_7668,
+ .support_pscan_win_report = false,
+ .sd_blksz_fw_dl = 64,
+ .supports_fw_dump = false,
};
static const struct btmtk_sdio_device btmtk_sdio_7666 = {
- .helper = "mtmk/sd8688_helper.bin",
- .firmware = "mt7668_patch_e1_hdr.bin",
- .reg = &btmtk_reg_7666,
- .support_pscan_win_report = false,
- .sd_blksz_fw_dl = 64,
- .supports_fw_dump = false,
+ .helper = "mtmk/sd8688_helper.bin",
+ .firmware = "mt7668_patch_e1_hdr.bin",
+ .reg = &btmtk_reg_7666,
+ .support_pscan_win_report = false,
+ .sd_blksz_fw_dl = 64,
+ .supports_fw_dump = false,
};
@@ -230,478 +228,507 @@
#define SDIO_VENDOR_ID_MEDIATEK 0x037A
static const struct sdio_device_id btmtk_sdio_ids[] = {
- /* Mediatek SD8688 Bluetooth device */
- { SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, 0x6630),
- .driver_data = (unsigned long) &btmtk_sdio_6630 },
+ /* Mediatek SD8688 Bluetooth device */
+ { SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, 0x6630),
+ .driver_data = (unsigned long) &btmtk_sdio_6630 },
- { SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, 0x6632),
- .driver_data = (unsigned long) &btmtk_sdio_6632 },
+ { SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, 0x6632),
+ .driver_data = (unsigned long) &btmtk_sdio_6632 },
- { SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, 0x7668),
- .driver_data = (unsigned long) &btmtk_sdio_7668 },
+ { SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, 0x7668),
+ .driver_data = (unsigned long) &btmtk_sdio_7668 },
- { SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, 0x7666),
- .driver_data = (unsigned long) &btmtk_sdio_7666 },
+ { SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, 0x7666),
+ .driver_data = (unsigned long) &btmtk_sdio_7666 },
- { } /* Terminating entry */
+ { } /* Terminating entry */
};
MODULE_DEVICE_TABLE(sdio, btmtk_sdio_ids);
-u32 lock_unsleepable_lock(P_OSAL_UNSLEEPABLE_LOCK pUSL)
+u32 lock_unsleepable_lock(struct _OSAL_UNSLEEPABLE_LOCK_ *pUSL)
{
- spin_lock_irqsave(&(pUSL->lock), pUSL->flag);
- return 0;
+ spin_lock_irqsave(&(pUSL->lock), pUSL->flag);
+ return 0;
}
-u32 unlock_unsleepable_lock(P_OSAL_UNSLEEPABLE_LOCK pUSL)
+u32 unlock_unsleepable_lock(struct _OSAL_UNSLEEPABLE_LOCK_ *pUSL)
{
- spin_unlock_irqrestore(&(pUSL->lock), pUSL->flag);
- return 0;
+ spin_unlock_irqrestore(&(pUSL->lock), pUSL->flag);
+ return 0;
}
static int btmtk_sdio_readb(u32 offset, u32 *val)
{
- u32 ret = 0;
+ u32 ret = 0;
- if (g_card->func == NULL) {
- BTMTK_ERR("%s g_card->func is NULL", __func__);
- return -EIO;
- }
- sdio_claim_host(g_card->func);
- *val = sdio_readb(g_card->func, offset, &ret);
- sdio_release_host(g_card->func);
- return ret;
+ if (g_card->func == NULL) {
+ pr_err("%s g_card->func is NULL\n", __func__);
+ return -EIO;
+ }
+ sdio_claim_host(g_card->func);
+ *val = sdio_readb(g_card->func, offset, &ret);
+ sdio_release_host(g_card->func);
+ return ret;
}
static int btmtk_sdio_writel(u32 offset, u32 val)
{
- u32 ret = 0;
+ u32 ret = 0;
- if (g_card->func == NULL) {
- BTMTK_ERR("%s g_card->func is NULL", __func__);
- return -EIO;
- }
- sdio_claim_host(g_card->func);
- sdio_writel(g_card->func, val, offset, &ret);
- sdio_release_host(g_card->func);
- return ret;
+ if (g_card->func == NULL) {
+ pr_err("%s g_card->func is NULL\n", __func__);
+ return -EIO;
+ }
+ sdio_claim_host(g_card->func);
+ sdio_writel(g_card->func, val, offset, &ret);
+ sdio_release_host(g_card->func);
+ return ret;
}
static int btmtk_sdio_readl(u32 offset, u32 *val)
{
- u32 ret = 0;
+ u32 ret = 0;
- if (g_card->func == NULL) {
- BTMTK_ERR("g_card->func is NULL");
- return -EIO;
- }
- sdio_claim_host(g_card->func);
- *val = sdio_readl(g_card->func, offset, &ret);
- sdio_release_host(g_card->func);
- return ret;
+ if (g_card->func == NULL) {
+ pr_err("g_card->func is NULL\n");
+ return -EIO;
+ }
+ sdio_claim_host(g_card->func);
+ *val = sdio_readl(g_card->func, offset, &ret);
+ sdio_release_host(g_card->func);
+ return ret;
}
+
struct sk_buff *btmtk_create_send_data(struct sk_buff *skb)
{
- struct sk_buff *queue_skb = NULL;
- u32 sdio_header_len = skb->len + BTM_HEADER_LEN;
+ struct sk_buff *queue_skb = NULL;
+ u32 sdio_header_len = skb->len + BTM_HEADER_LEN;
- if (skb_headroom(skb) < (BTM_HEADER_LEN)) {
- queue_skb = bt_skb_alloc(sdio_header_len, GFP_ATOMIC);
- if (queue_skb == NULL) {
- BTMTK_ERR("bt_skb_alloc fail return");
- return 0;
- }
+ if (skb_headroom(skb) < (BTM_HEADER_LEN)) {
+ queue_skb = bt_skb_alloc(sdio_header_len, GFP_ATOMIC);
+ if (queue_skb == NULL) {
+ pr_err("bt_skb_alloc fail return\n");
+ return 0;
+ }
- queue_skb->data[0] = (sdio_header_len & 0x0000ff);
- queue_skb->data[1] = (sdio_header_len & 0x00ff00) >> 8;
- queue_skb->data[2] = 0;
- queue_skb->data[3] = 0;
- queue_skb->data[4] = bt_cb(skb)->pkt_type;
- queue_skb->len = sdio_header_len;
- memcpy(&queue_skb->data[5], &skb->data[0], skb->len);
- kfree_skb(skb);
- } else {
- queue_skb = skb;
- skb_push(queue_skb, BTM_HEADER_LEN);
- queue_skb->data[0] = (sdio_header_len & 0x0000ff);
- queue_skb->data[1] = (sdio_header_len & 0x00ff00) >> 8;
- queue_skb->data[2] = 0;
- queue_skb->data[3] = 0;
- queue_skb->data[4] = bt_cb(skb)->pkt_type;
- }
+ queue_skb->data[0] = (sdio_header_len & 0x0000ff);
+ queue_skb->data[1] = (sdio_header_len & 0x00ff00) >> 8;
+ queue_skb->data[2] = 0;
+ queue_skb->data[3] = 0;
+ queue_skb->data[4] = bt_cb(skb)->pkt_type;
+ queue_skb->len = sdio_header_len;
+ memcpy(&queue_skb->data[5], &skb->data[0], skb->len);
+ kfree_skb(skb);
+ } else {
+ queue_skb = skb;
+ skb_push(queue_skb, BTM_HEADER_LEN);
+ queue_skb->data[0] = (sdio_header_len & 0x0000ff);
+ queue_skb->data[1] = (sdio_header_len & 0x00ff00) >> 8;
+ queue_skb->data[2] = 0;
+ queue_skb->data[3] = 0;
+ queue_skb->data[4] = bt_cb(skb)->pkt_type;
+ }
- BTMTK_INFO("%s end", __func__);
- return queue_skb;
+ pr_info("%s end\n", __func__);
+ return queue_skb;
}
+
static int btmtk_sdio_set_own_back(int owntype)
{
- /*Set driver own*/
- int ret = 0;
- u32 u32LoopCount = 0;
- u32 u32ReadCRValue = 0;
- u32 ownValue = 0;
- u32 set_checkretry = 30;
+ /*Set driver own*/
+ int ret = 0;
+ u32 u32LoopCount = 0;
+ u32 u32ReadCRValue = 0;
+ u32 ownValue = 0;
+ u32 set_checkretry = 30;
- BTMTK_DBG("%s owntype %d", __func__, owntype);
+ pr_debug("%s owntype %d\n", __func__, owntype);
- if(user_rmmod)
- set_checkretry = 1;
+ if (user_rmmod)
+ set_checkretry = 1;
- ret = btmtk_sdio_readl(CHLPCR, &u32ReadCRValue);
+ ret = btmtk_sdio_readl(CHLPCR, &u32ReadCRValue);
- BTMTK_DBG("%s btmtk_sdio_readl CHLPCR done", __func__);
- if (owntype == DRIVER_OWN) {
- if ((u32ReadCRValue&0x100) == 0x100) {
- BTMTK_DBG("%s already driver own 0x%0x, return\n", __func__, u32ReadCRValue);
- return ret;
- }
-
- } else if (owntype == FW_OWN) {
- if ((u32ReadCRValue&0x100) == 0) {
- BTMTK_DBG("%s already FW own 0x%0x, return\n", __func__, u32ReadCRValue);
- return ret;
- }
-
- }
-
+ pr_debug("%s btmtk_sdio_readl CHLPCR done\n", __func__);
+ if (owntype == DRIVER_OWN) {
+ if ((u32ReadCRValue&0x100) == 0x100) {
+ pr_debug("%s already driver own 0x%0x, return\n",
+ __func__, u32ReadCRValue);
+ return ret;
+ }
+ } else if (owntype == FW_OWN) {
+ if ((u32ReadCRValue&0x100) == 0) {
+ pr_debug("%s already FW own 0x%0x, return\n",
+ __func__, u32ReadCRValue);
+ return ret;
+ }
+ }
setretry:
- if (owntype == DRIVER_OWN)
- ownValue = 0x00000200;
- else
- ownValue = 0x00000100;
+ if (owntype == DRIVER_OWN)
+ ownValue = 0x00000200;
+ else
+ ownValue = 0x00000100;
- BTMTK_DBG("%s write CHLPCR 0x%x", __func__, ownValue);
- ret = btmtk_sdio_writel(CHLPCR, ownValue);
- if (ret) {
- ret = -EINVAL;
- goto done;
- }
- BTMTK_DBG("%s write CHLPCR 0x%x done", __func__, ownValue);
+ pr_debug("%s write CHLPCR 0x%x\n", __func__, ownValue);
+ ret = btmtk_sdio_writel(CHLPCR, ownValue);
+ if (ret) {
+ ret = -EINVAL;
+ goto done;
+ }
+ pr_debug("%s write CHLPCR 0x%x done\n", __func__, ownValue);
- u32LoopCount = 200;
+ u32LoopCount = 200;
- if (owntype == DRIVER_OWN) {
- do {
- udelay(1);
- ret = btmtk_sdio_readl(CHLPCR, &u32ReadCRValue);
- u32LoopCount--;
- BTMTK_DBG("%s DRIVER_OWN btmtk_sdio_readl CHLPCR 0x%x ", __func__, u32ReadCRValue);
- } while ((u32LoopCount > 0) && ((u32ReadCRValue&0x100) != 0x100));
+ if (owntype == DRIVER_OWN) {
+ do {
+ udelay(1);
+ ret = btmtk_sdio_readl(CHLPCR, &u32ReadCRValue);
+ u32LoopCount--;
+ pr_debug("%s DRIVER_OWN btmtk_sdio_readl CHLPCR 0x%x\n",
+ __func__, u32ReadCRValue);
+ } while ((u32LoopCount > 0) &&
+ ((u32ReadCRValue&0x100) != 0x100));
- if ((u32LoopCount == 0) && (0x100 != (u32ReadCRValue&0x100)) && (set_checkretry > 0)) {
- BTMTK_WARN("%s retry set_check driver own, CHLPCR 0x%x", __func__,u32ReadCRValue);
- set_checkretry--;
- mdelay(20);
- goto setretry;
- }
- } else {
- do {
- udelay(1);
- ret = btmtk_sdio_readl(CHLPCR, &u32ReadCRValue);
- u32LoopCount--;
- BTMTK_DBG("%s FW_OWN btmtk_sdio_readl CHLPCR 0x%x ", __func__, u32ReadCRValue);
- } while ((u32LoopCount > 0) && ((u32ReadCRValue&0x100) != 0));
+ if ((u32LoopCount == 0) && (0x100 != (u32ReadCRValue&0x100))
+ && (set_checkretry > 0)) {
+ pr_warn("%s retry set_check driver own, CHLPCR 0x%x\n",
+ __func__, u32ReadCRValue);
+ set_checkretry--;
+ mdelay(20);
+ goto setretry;
+ }
+ } else {
+ do {
+ udelay(1);
+ ret = btmtk_sdio_readl(CHLPCR, &u32ReadCRValue);
+ u32LoopCount--;
+ pr_debug("%s FW_OWN btmtk_sdio_readl CHLPCR 0x%x\n",
+ __func__, u32ReadCRValue);
+ } while ((u32LoopCount > 0) && ((u32ReadCRValue&0x100) != 0));
- if ((u32LoopCount == 0) && ((u32ReadCRValue&0x100) != 0) && (set_checkretry > 0)) {
- BTMTK_WARN("%s retry set_check FW own, CHLPCR 0x%x", __func__,u32ReadCRValue);
- set_checkretry--;
- goto setretry;
- }
- }
+ if ((u32LoopCount == 0) &&
+ ((u32ReadCRValue&0x100) != 0) &&
+ (set_checkretry > 0)) {
+ pr_warn("%s retry set_check FW own, CHLPCR 0x%x\n",
+ __func__, u32ReadCRValue);
+ set_checkretry--;
+ goto setretry;
+ }
+ }
- BTMTK_DBG("%s CHLPCR(0x%x), is 0x%x\n", __func__, CHLPCR, u32ReadCRValue);
+ pr_debug("%s CHLPCR(0x%x), is 0x%x\n",
+ __func__, CHLPCR, u32ReadCRValue);
- if (owntype == DRIVER_OWN) {
- if ((u32ReadCRValue&0x100) == 0x100)
- BTMTK_DBG("%s check %04x, is 0x100 driver own success\n", __func__, CHLPCR);
- else {
- BTMTK_DBG("%s check %04x, is %x shuld be 0x100\n", __func__, CHLPCR, u32ReadCRValue);
- ret = EINVAL;
- goto done;
- }
- } else {
- if (0x0 == (u32ReadCRValue&0x100))
- BTMTK_DBG("%s check %04x, bit 8 is 0 FW own success\n", __func__, CHLPCR);
- else{
- BTMTK_DBG("%s bit 8 should be 0, %04x bit 8 is %04x\n", __func__, u32ReadCRValue, (u32ReadCRValue&0x100));
- ret = EINVAL;
- goto done;
- }
- }
-
-
+ if (owntype == DRIVER_OWN) {
+ if ((u32ReadCRValue&0x100) == 0x100)
+ pr_debug("%s check %04x, is 0x100 driver own success\n",
+ __func__, CHLPCR);
+ else {
+ pr_debug("%s check %04x, is %x shuld be 0x100\n",
+ __func__, CHLPCR, u32ReadCRValue);
+ ret = EINVAL;
+ goto done;
+ }
+ } else {
+ if (0x0 == (u32ReadCRValue&0x100))
+ pr_debug("%s check %04x, bit 8 is 0 FW own success\n",
+ __func__, CHLPCR);
+ else{
+ pr_debug("%s bit 8 should be 0, %04x bit 8 is %04x\n",
+ __func__, u32ReadCRValue,
+ (u32ReadCRValue&0x100));
+ ret = EINVAL;
+ goto done;
+ }
+ }
done:
+ if (owntype == DRIVER_OWN) {
+ if (ret)
+ pr_err("%s set driver own fail\n", __func__);
+ else
+ pr_debug("%s set driver own success\n", __func__);
+ } else if (owntype == FW_OWN) {
+ if (ret)
+ pr_err("%s set FW own fail\n", __func__);
+ else
+ pr_debug("%s set FW own success\n", __func__);
+ } else
+ pr_err("%s unknown type %d\n", __func__, owntype);
- if (owntype == DRIVER_OWN) {
- if (ret)
- BTMTK_ERR("%s set driver own fail\n", __func__);
- else
- BTMTK_DBG("%s set driver own success\n", __func__);
- } else if (owntype == FW_OWN) {
- if (ret)
- BTMTK_ERR("%s set FW own fail\n", __func__);
- else
- BTMTK_DBG("%s set FW own success\n", __func__);
-
- } else
- BTMTK_ERR("%s unknow type %d\n", __func__, owntype);
-
-
- return ret;
+ return ret;
}
+
static int btmtk_sdio_enable_interrupt(int enable)
{
- u32 ret = 0;
- u32 cr_value = 0;
+ u32 ret = 0;
+ u32 cr_value = 0;
- if (enable)
- cr_value |= C_FW_INT_EN_SET;
- else
- cr_value |= C_FW_INT_EN_CLEAR;
+ if (enable)
+ cr_value |= C_FW_INT_EN_SET;
+ else
+ cr_value |= C_FW_INT_EN_CLEAR;
- ret = btmtk_sdio_writel(CHLPCR, cr_value);
- BTMTK_DBG("%s enable %d write CHLPCR 0x%08x\n", __func__, enable, cr_value);
+ ret = btmtk_sdio_writel(CHLPCR, cr_value);
+ pr_debug("%s enable %d write CHLPCR 0x%08x\n",
+ __func__, enable, cr_value);
- return ret;
+ return ret;
}
static int btmtk_sdio_get_rx_unit(struct btmtk_sdio_card *card)
{
- u8 reg;
- int ret;
+ u8 reg;
+ int ret;
- reg = sdio_readb(card->func, card->reg->card_rx_unit, &ret);
- if (!ret)
- card->rx_unit = reg;
+ reg = sdio_readb(card->func, card->reg->card_rx_unit, &ret);
+ if (!ret)
+ card->rx_unit = reg;
- return ret;
+ return ret;
}
-static int btmtk_sdio_enable_host_int_mask(struct btmtk_sdio_card *card,
- u8 mask)
+static int btmtk_sdio_enable_host_int_mask(
+ struct btmtk_sdio_card *card,
+ u8 mask)
{
- int ret;
+ int ret;
- sdio_writeb(card->func, mask, card->reg->host_int_mask, &ret);
- if (ret) {
- BTMTK_ERR("Unable to enable the host interrupt!");
- ret = -EIO;
- }
+ sdio_writeb(card->func, mask, card->reg->host_int_mask, &ret);
+ if (ret) {
+ pr_err("Unable to enable the host interrupt!\n");
+ ret = -EIO;
+ }
- return ret;
+ return ret;
}
-static int btmtk_sdio_disable_host_int_mask(struct btmtk_sdio_card *card,
- u8 mask)
+static int btmtk_sdio_disable_host_int_mask(
+ struct btmtk_sdio_card *card,
+ u8 mask)
{
- u8 host_int_mask;
- int ret;
+ u8 host_int_mask;
+ int ret;
- host_int_mask = sdio_readb(card->func, card->reg->host_int_mask, &ret);
- if (ret)
- return -EIO;
+ host_int_mask = sdio_readb(card->func, card->reg->host_int_mask, &ret);
+ if (ret)
+ return -EIO;
- host_int_mask &= ~mask;
+ host_int_mask &= ~mask;
- sdio_writeb(card->func, host_int_mask, card->reg->host_int_mask, &ret);
- if (ret < 0) {
- BTMTK_ERR("Unable to disable the host interrupt!");
- return -EIO;
- }
+ sdio_writeb(card->func, host_int_mask, card->reg->host_int_mask, &ret);
+ if (ret < 0) {
+ pr_err("Unable to disable the host interrupt!\n");
+ return -EIO;
+ }
- return 0;
+ return 0;
}
/*for debug*/
int btmtk_print_buffer_conent(u8 *buf, u32 Datalen)
{
- int i = 0;
- int print_finish = 0;
- /*Print out txbuf data for debug*/
- for (i = 0; i <= (Datalen-1); i += 16) {
- if ((i+16) <= Datalen) {
- BTMTK_DBG("%s: %02X%02X%02X%02X%02X %02X%02X%02X%02X%02X %02X%02X%02X%02X%02X %02X\n", __func__,
- buf[i], buf[i+1], buf[i+2], buf[i+3], buf[i+4],
- buf[i+5], buf[i+6], buf[i+7], buf[i+8], buf[i+9],
- buf[i+10], buf[i+11], buf[i+12], buf[i+13], buf[i+14],
- buf[i+15]);
- } else {
- for (; i < (Datalen); i++)
- BTMTK_DBG("%s: %02X\n", __func__, buf[i]);
+ int i = 0;
+ int print_finish = 0;
+ /*Print out txbuf data for debug*/
+ for (i = 0; i <= (Datalen-1); i += 16) {
+ if ((i+16) <= Datalen) {
+ pr_debug("%s: %02X%02X%02X%02X%02X %02X%02X%02X%02X%02X %02X%02X%02X%02X%02X %02X\n",
+ __func__,
+ buf[i], buf[i+1], buf[i+2], buf[i+3], buf[i+4],
+ buf[i+5], buf[i+6], buf[i+7], buf[i+8], buf[i+9],
+ buf[i+10], buf[i+11], buf[i+12], buf[i+13], buf[i+14],
+ buf[i+15]);
+ } else {
+ for (; i < (Datalen); i++)
+ pr_debug("%s: %02X\n", __func__, buf[i]);
- print_finish = 1;
- }
+ print_finish = 1;
+ }
- if (print_finish)
- break;
-
- }
- return 0;
+ if (print_finish)
+ break;
+ }
+ return 0;
}
static int btmtk_sdio_send_tx_data(u8 *buffer, int tx_data_len)
{
- int ret = 0;
- u8 MultiBluckCount = 0;
- u8 redundant = 0;
+ int ret = 0;
+ u8 MultiBluckCount = 0;
+ u8 redundant = 0;
- MultiBluckCount = tx_data_len/SDIO_BLOCK_SIZE;
- redundant = tx_data_len % SDIO_BLOCK_SIZE;
+ MultiBluckCount = tx_data_len/SDIO_BLOCK_SIZE;
+ redundant = tx_data_len % SDIO_BLOCK_SIZE;
- if (redundant)
- tx_data_len = (MultiBluckCount+1)*SDIO_BLOCK_SIZE;
+ if (redundant)
+ tx_data_len = (MultiBluckCount+1)*SDIO_BLOCK_SIZE;
- sdio_claim_host(g_card->func);
- ret = sdio_writesb(g_card->func, CTDR, buffer, tx_data_len);
- sdio_release_host(g_card->func);
+ sdio_claim_host(g_card->func);
+ ret = sdio_writesb(g_card->func, CTDR, buffer, tx_data_len);
+ sdio_release_host(g_card->func);
- return ret;
+ return ret;
}
static int btmtk_sdio_recv_rx_data(void)
{
- int ret = 0;
- u32 u32ReadCRValue = 0;
- int retry_count = 5;
- u32 sdio_header_length = 0;
- memset(rxbuf, 0, MTK_RXDATA_SIZE);
+ int ret = 0;
+ u32 u32ReadCRValue = 0;
+ int retry_count = 5;
+ u32 sdio_header_length = 0;
- do {
- ret = btmtk_sdio_readl(CHISR, &u32ReadCRValue);
- BTMTK_DBG("%s: loop Get CHISR 0x%08X\n", __func__, u32ReadCRValue);
- rx_length = (u32ReadCRValue & RX_PKT_LEN) >> 16;
- if (rx_length == 0xFFFF) {
- BTMTK_WARN("%s: 0xFFFF==rx_length, error return -EIO\n", __func__);
- ret = -EIO;
- break;
- }
+ memset(rxbuf, 0, MTK_RXDATA_SIZE);
- if ((RX_DONE&u32ReadCRValue) && rx_length) {
- BTMTK_DBG("%s: u32ReadCRValue = %08X\n", __func__, u32ReadCRValue);
- u32ReadCRValue &= 0xFFFB;
- ret = btmtk_sdio_writel(CHISR, u32ReadCRValue);
- BTMTK_DBG("%s: write = %08X\n", __func__, u32ReadCRValue);
+ do {
+ ret = btmtk_sdio_readl(CHISR, &u32ReadCRValue);
+ pr_debug("%s: loop Get CHISR 0x%08X\n",
+ __func__, u32ReadCRValue);
+ rx_length = (u32ReadCRValue & RX_PKT_LEN) >> 16;
+ if (rx_length == 0xFFFF) {
+ pr_warn("%s: 0xFFFF==rx_length, error return -EIO\n",
+ __func__);
+ ret = -EIO;
+ break;
+ }
+
+ if ((RX_DONE&u32ReadCRValue) && rx_length) {
+ pr_debug("%s: u32ReadCRValue = %08X\n",
+ __func__, u32ReadCRValue);
+ u32ReadCRValue &= 0xFFFB;
+ ret = btmtk_sdio_writel(CHISR, u32ReadCRValue);
+ pr_debug("%s: write = %08X\n",
+ __func__, u32ReadCRValue);
- sdio_claim_host(g_card->func);
- ret = sdio_readsb(g_card->func, rxbuf, CRDR, rx_length);
- sdio_release_host(g_card->func);
- sdio_header_length = (rxbuf[1] << 8);
- sdio_header_length |= rxbuf[0];
+ sdio_claim_host(g_card->func);
+ ret = sdio_readsb(g_card->func, rxbuf, CRDR, rx_length);
+ sdio_release_host(g_card->func);
+ sdio_header_length = (rxbuf[1] << 8);
+ sdio_header_length |= rxbuf[0];
- if(sdio_header_length != rx_length){
- BTMTK_ERR("%s sdio header length %d, rx_length %d mismatch",__func__,sdio_header_length,rx_length);
- break;
- }
+ if (sdio_header_length != rx_length) {
+ pr_err("%s sdio header length %d, rx_length %d mismatch\n",
+ __func__, sdio_header_length,
+ rx_length);
+ break;
+ }
- if (sdio_header_length == 0) {
- BTMTK_WARN("%s: get sdio_header_length = %d\n", __func__, sdio_header_length);
- continue;
- }
+ if (sdio_header_length == 0) {
+ pr_warn("%s: get sdio_header_length = %d\n",
+ __func__, sdio_header_length);
+ continue;
+ }
+ break;
+ }
- break;
- }
+ retry_count--;
+ if (retry_count <= 0) {
+ pr_warn("%s: retry_count = %d,timeout\n",
+ __func__, retry_count);
+ ret = -EIO;
+ break;
+ }
+ /* msleep(1); */
+ mdelay(3);
+ pr_debug("%s: retry_count = %d,wait\n", __func__, retry_count);
- retry_count--;
- if (retry_count <= 0) {
- BTMTK_WARN("%s: retry_count = %d,timeout\n", __func__, retry_count);
- ret = -EIO;
- break;
- }
+ if (ret)
+ break;
+ } while (1);
-/*
-* msleep(1);
-*/
- mdelay(3);
- BTMTK_DBG("%s: retry_count = %d,wait\n", __func__, retry_count);
+ if (ret)
+ return -EIO;
- if (ret)
- break;
-
- } while (1);
-
-
-
- if (ret)
- return -EIO;
-
-
-
-
-
- return ret;
+ return ret;
}
static int btmtk_sdio_send_wmt_reset(void)
{
- int ret = 0;
- u8 wmt_event[8] = {4, 0xE4, 5, 2, 7, 1, 0, 0};
- u8 mtksdio_packet_header[MTK_SDIO_PACKET_HEADER_SIZE] = {0};
- u8 mtksdio_wmt_reset[9] = {1, 0x6F, 0xFC, 5, 1, 7, 1, 0, 4};
+ int ret = 0;
+ u8 wmt_event[8] = {4, 0xE4, 5, 2, 7, 1, 0, 0};
+ u8 mtksdio_packet_header[MTK_SDIO_PACKET_HEADER_SIZE] = {0};
+ u8 mtksdio_wmt_reset[9] = {1, 0x6F, 0xFC, 5, 1, 7, 1, 0, 4};
- BTMTK_INFO("%s:\n", __func__);
- mtksdio_packet_header[0] = sizeof(mtksdio_packet_header) + sizeof(mtksdio_wmt_reset);
+ pr_info("%s:\n", __func__);
+ mtksdio_packet_header[0] = sizeof(mtksdio_packet_header) +
+ sizeof(mtksdio_wmt_reset);
- memcpy(txbuf, mtksdio_packet_header, MTK_SDIO_PACKET_HEADER_SIZE);
- memcpy(txbuf+MTK_SDIO_PACKET_HEADER_SIZE, mtksdio_wmt_reset, sizeof(mtksdio_wmt_reset));
+ memcpy(txbuf, mtksdio_packet_header, MTK_SDIO_PACKET_HEADER_SIZE);
+ memcpy(txbuf+MTK_SDIO_PACKET_HEADER_SIZE, mtksdio_wmt_reset,
+ sizeof(mtksdio_wmt_reset));
- btmtk_sdio_send_tx_data(txbuf, MTK_SDIO_PACKET_HEADER_SIZE+sizeof(mtksdio_wmt_reset));
- btmtk_sdio_recv_rx_data();
+ btmtk_sdio_send_tx_data(txbuf,
+ MTK_SDIO_PACKET_HEADER_SIZE+sizeof(mtksdio_wmt_reset));
+ btmtk_sdio_recv_rx_data();
- /*compare rx data is wmt reset correct response or not*/
- if (memcmp(wmt_event, rxbuf+MTK_SDIO_PACKET_HEADER_SIZE, sizeof(wmt_event)) != 0) {
- ret = -EIO;
- BTMTK_WARN("%s: fail\n", __func__);
- }
+ /*compare rx data is wmt reset correct response or not*/
+ if (memcmp(wmt_event, rxbuf+MTK_SDIO_PACKET_HEADER_SIZE,
+ sizeof(wmt_event)) != 0) {
+ ret = -EIO;
+ pr_warn("%s: fail\n", __func__);
+ }
- return ret;
+ return ret;
}
static u32 btmtk_sdio_bt_memRegister_read(u32 cr)
{
int retrytime = 300;
u32 result = 0;
- u8 wmt_event[15] = {0x04,0xE4,0x10,0x02,0x08,0x0C/*0x1C*/,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x80 };
- //msleep(1000);
+ u8 wmt_event[15] = {0x04, 0xE4, 0x10, 0x02,
+ 0x08, 0x0C/*0x1C*/, 0x00, 0x00,
+ 0x00, 0x00, 0x01, 0x00,
+ 0x00, 0x00, 0x80};
+ /* msleep(1000); */
u8 mtksdio_packet_header[MTK_SDIO_PACKET_HEADER_SIZE] = {0};
- u8 mtksdio_wmt_cmd[16] = {0x1,0x6F,0xFC,0x0C,0x01,0x08,0x08,0x00,0x02,0x01,0x00,0x01,0x00,0x00,0x00,0x00};
- mtksdio_packet_header[0] = sizeof(mtksdio_packet_header) + sizeof(mtksdio_wmt_cmd);
- BTMTK_INFO("%s: read cr %x\n",__func__,cr);
+ u8 mtksdio_wmt_cmd[16] = {0x1, 0x6F, 0xFC, 0x0C,
+ 0x01, 0x08, 0x08, 0x00,
+ 0x02, 0x01, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x00};
+ mtksdio_packet_header[0] = sizeof(mtksdio_packet_header)
+ + sizeof(mtksdio_wmt_cmd);
+ pr_info("%s: read cr %x\n", __func__, cr);
- memcpy(&mtksdio_wmt_cmd[12],&cr,sizeof(cr));
+ memcpy(&mtksdio_wmt_cmd[12], &cr, sizeof(cr));
- memcpy(txbuf,mtksdio_packet_header,MTK_SDIO_PACKET_HEADER_SIZE);
- memcpy(txbuf+MTK_SDIO_PACKET_HEADER_SIZE,mtksdio_wmt_cmd,sizeof(mtksdio_wmt_cmd));
+ memcpy(txbuf, mtksdio_packet_header, MTK_SDIO_PACKET_HEADER_SIZE);
+ memcpy(txbuf + MTK_SDIO_PACKET_HEADER_SIZE, mtksdio_wmt_cmd,
+ sizeof(mtksdio_wmt_cmd));
- btmtk_sdio_send_tx_data(txbuf,MTK_SDIO_PACKET_HEADER_SIZE+sizeof(mtksdio_wmt_cmd));
- btmtk_print_buffer_conent(txbuf,MTK_SDIO_PACKET_HEADER_SIZE+sizeof(mtksdio_wmt_cmd));
+ btmtk_sdio_send_tx_data(txbuf,
+ MTK_SDIO_PACKET_HEADER_SIZE + sizeof(mtksdio_wmt_cmd));
+ btmtk_print_buffer_conent(txbuf,
+ MTK_SDIO_PACKET_HEADER_SIZE + sizeof(mtksdio_wmt_cmd));
- do{
- msleep(10);
- btmtk_sdio_recv_rx_data();
- retrytime--;
- if(retrytime<=0)
+ do {
+ usleep_range(10*1000, 15*1000);
+ btmtk_sdio_recv_rx_data();
+ retrytime--;
+ if (retrytime <= 0)
break;
- BTMTK_INFO("%s: retrytime %d\n",__func__,retrytime);
- }while(!rxbuf[0]);
+ pr_info("%s: retrytime %d\n", __func__, retrytime);
+ } while (!rxbuf[0]);
- btmtk_print_buffer_conent(rxbuf,rx_length);
+ btmtk_print_buffer_conent(rxbuf, rx_length);
/*compare rx data is wmt reset correct response or not*/
- /*if(0!=memcmp(wmt_event,rxbuf+MTK_SDIO_PACKET_HEADER_SIZE,sizeof(wmt_event))){
+ /*if(0!=memcmp(wmt_event,
+ rxbuf+MTK_SDIO_PACKET_HEADER_SIZE,
+ sizeof(wmt_event))){
ret = -EIO;
- BTMTK_INFO("%s: fail\n",__func__);
+ pr_info("%s: fail\n",__func__);
}*/
- memcpy(&result,rxbuf+MTK_SDIO_PACKET_HEADER_SIZE+sizeof(wmt_event),sizeof(result));
- BTMTK_INFO("%s: ger cr 0x%x value 0x%x\n",__func__,cr,result);
+ memcpy(&result, rxbuf+MTK_SDIO_PACKET_HEADER_SIZE + sizeof(wmt_event),
+ sizeof(result));
+ pr_info("%s: ger cr 0x%x value 0x%x\n", __func__, cr, result);
return result;
}
@@ -710,160 +737,177 @@
*/
static int btmtk_sdio_bt_set_power(u8 onoff)
{
- int ret = 0;
- int retrytime = 60;
- u8 wmt_event[8] = {4, 0xE4, 5, 2, 6, 1, 0, 0};
- u8 mtksdio_packet_header[MTK_SDIO_PACKET_HEADER_SIZE] = {0};
- u8 mtksdio_wmt_cmd[10] = {1, 0x6F, 0xFC, 6, 1, 6, 2, 0, 0, 1};
- if (onoff==0)
- retrytime = 3;
+ int ret = 0;
+ int retrytime = 60;
+ u8 wmt_event[8] = {4, 0xE4, 5, 2, 6, 1, 0, 0};
+ u8 mtksdio_packet_header[MTK_SDIO_PACKET_HEADER_SIZE] = {0};
+ u8 mtksdio_wmt_cmd[10] = {1, 0x6F, 0xFC, 6, 1, 6, 2, 0, 0, 1};
- mtksdio_packet_header[0] = sizeof(mtksdio_packet_header) + sizeof(mtksdio_wmt_cmd);
- BTMTK_INFO("%s: onoff %d\n", __func__, onoff);
+ if (onoff == 0)
+ retrytime = 3;
- mtksdio_wmt_cmd[9] = onoff;
+ mtksdio_packet_header[0] =
+ sizeof(mtksdio_packet_header) + sizeof(mtksdio_wmt_cmd);
+ pr_info("%s: onoff %d\n", __func__, onoff);
- memcpy(txbuf, mtksdio_packet_header, MTK_SDIO_PACKET_HEADER_SIZE);
- memcpy(txbuf+MTK_SDIO_PACKET_HEADER_SIZE, mtksdio_wmt_cmd, sizeof(mtksdio_wmt_cmd));
+ mtksdio_wmt_cmd[9] = onoff;
- btmtk_sdio_send_tx_data(txbuf, MTK_SDIO_PACKET_HEADER_SIZE+sizeof(mtksdio_wmt_cmd));
+ memcpy(txbuf, mtksdio_packet_header, MTK_SDIO_PACKET_HEADER_SIZE);
+ memcpy(txbuf+MTK_SDIO_PACKET_HEADER_SIZE, mtksdio_wmt_cmd,
+ sizeof(mtksdio_wmt_cmd));
+
+ btmtk_sdio_send_tx_data(txbuf,
+ MTK_SDIO_PACKET_HEADER_SIZE+sizeof(mtksdio_wmt_cmd));
+
+ do {
+ msleep(100);
+ btmtk_sdio_recv_rx_data();
+ retrytime--;
+ if (retrytime <= 0)
+ break;
+
+ if (retrytime < 40)
+ pr_warn("%s: retry over 2s, retrytime %d\n",
+ __func__, retrytime);
+
+ pr_info("%s: retrytime %d\n", __func__, retrytime);
+ } while (!rxbuf[0]);
- do {
- msleep(100);
- btmtk_sdio_recv_rx_data();
- retrytime--;
- if (retrytime <= 0)
- break;
+ /*compare rx data is wmt reset correct response or not*/
+ if (memcmp(wmt_event, rxbuf+MTK_SDIO_PACKET_HEADER_SIZE, sizeof(wmt_event))
+ != 0) {
+ ret = -EIO;
+ pr_info("%s: fail\n", __func__);
+ }
- if (retrytime < 40)
- BTMTK_WARN("%s: retry over 2s, retrytime %d\n", __func__, retrytime);
-
- BTMTK_INFO("%s: retrytime %d\n", __func__, retrytime);
- } while (!rxbuf[0]);
-
-
- /*compare rx data is wmt reset correct response or not*/
- if (memcmp(wmt_event, rxbuf+MTK_SDIO_PACKET_HEADER_SIZE, sizeof(wmt_event)) != 0) {
- ret = -EIO;
- BTMTK_INFO("%s: fail\n", __func__);
- }
-
- return ret;
+ return ret;
}
/*
* 1:on , 0:off
*/
static int btmtk_sdio_set_sleep(void)
{
- int ret = 0;
- u8 wmt_event[8] = {4, 0xE, 4, 1, 0x7A, 0xFC, 0};
- u8 mtksdio_packet_header[MTK_SDIO_PACKET_HEADER_SIZE] = {0};
- u8 mtksdio_wmt_cmd[11] = {1, 0x7A, 0xFC, 7, /*3:sdio, 5:usb*/03,
- /*host non sleep duration*/0x80, 0x02, /*host non sleep duration*/0x80, 0x02, 0x0, 0x00};
+ int ret = 0;
+ u8 wmt_event[8] = {4, 0xE, 4, 1, 0x7A, 0xFC, 0};
+ u8 mtksdio_packet_header[MTK_SDIO_PACKET_HEADER_SIZE] = {0};
+ u8 mtksdio_wmt_cmd[11] = {1, 0x7A, 0xFC, 7,
+ /*3:sdio, 5:usb*/03,
+ /*host non sleep duration*/0x80, 0x02,
+ /*host non sleep duration*/0x80, 0x02, 0x0, 0x00};
- mtksdio_packet_header[0] = sizeof(mtksdio_packet_header) + sizeof(mtksdio_wmt_cmd);
- BTMTK_INFO("%s begin\n", __func__);
+ mtksdio_packet_header[0] =
+ sizeof(mtksdio_packet_header) + sizeof(mtksdio_wmt_cmd);
+ pr_info("%s begin\n", __func__);
- memcpy(txbuf, mtksdio_packet_header, MTK_SDIO_PACKET_HEADER_SIZE);
- memcpy(txbuf+MTK_SDIO_PACKET_HEADER_SIZE, mtksdio_wmt_cmd, sizeof(mtksdio_wmt_cmd));
+ memcpy(txbuf, mtksdio_packet_header, MTK_SDIO_PACKET_HEADER_SIZE);
+ memcpy(txbuf+MTK_SDIO_PACKET_HEADER_SIZE, mtksdio_wmt_cmd,
+ sizeof(mtksdio_wmt_cmd));
- btmtk_sdio_send_tx_data(txbuf, MTK_SDIO_PACKET_HEADER_SIZE+sizeof(mtksdio_wmt_cmd));
- btmtk_sdio_recv_rx_data();
- btmtk_print_buffer_conent(rxbuf, rx_length);
- /*compare rx data is wmt reset correct response or not*/
- if (memcmp(wmt_event, rxbuf+MTK_SDIO_PACKET_HEADER_SIZE, sizeof(wmt_event)) != 0) {
- ret = -EIO;
- BTMTK_INFO("%s: fail\n", __func__);
- }
+ btmtk_sdio_send_tx_data(txbuf,
+ MTK_SDIO_PACKET_HEADER_SIZE+sizeof(mtksdio_wmt_cmd));
+ btmtk_sdio_recv_rx_data();
+ btmtk_print_buffer_conent(rxbuf, rx_length);
+ /*compare rx data is wmt reset correct response or not*/
+ if (memcmp(wmt_event, rxbuf+MTK_SDIO_PACKET_HEADER_SIZE, sizeof(wmt_event))
+ != 0) {
+ ret = -EIO;
+ pr_info("%s: fail\n", __func__);
+ }
- return ret;
+ return ret;
}
static int btmtk_send_rom_patch(u8 *fwbuf, u32 fwlen, int mode)
{
- int ret = 0;
- u8 mtksdio_packet_header[MTK_SDIO_PACKET_HEADER_SIZE] = {0};
- int stp_len = 0;
- u8 mtkdata_header[MTKDATA_HEADER_SIZE] = {0};
+ int ret = 0;
+ u8 mtksdio_packet_header[MTK_SDIO_PACKET_HEADER_SIZE] = {0};
+ int stp_len = 0;
+ u8 mtkdata_header[MTKDATA_HEADER_SIZE] = {0};
- int copy_len = 0;
- int Datalen = fwlen;
- u32 u32ReadCRValue = 0;
+ int copy_len = 0;
+ int Datalen = fwlen;
+ u32 u32ReadCRValue = 0;
- BTMTK_DBG("%s fwlen %d, mode = %d", __func__, fwlen, mode);
- if (fwlen < Datalen) {
- BTMTK_ERR("%s file size = %d,is not corect", __func__, fwlen);
- return -ENOENT;
- }
+ pr_debug("%s fwlen %d, mode = %d\n", __func__, fwlen, mode);
+ if (fwlen < Datalen) {
+ pr_err("%s file size = %d,is not corect\n", __func__, fwlen);
+ return -ENOENT;
+ }
- stp_len = Datalen + MTKDATA_HEADER_SIZE;
+ stp_len = Datalen + MTKDATA_HEADER_SIZE;
- mtkdata_header[0] = 0x2;/*ACL data*/
- mtkdata_header[1] = 0x6F;
- mtkdata_header[2] = 0xFC;
+ mtkdata_header[0] = 0x2;/*ACL data*/
+ mtkdata_header[1] = 0x6F;
+ mtkdata_header[2] = 0xFC;
- mtkdata_header[3] = ((Datalen+4+1)&0x00FF);
- mtkdata_header[4] = ((Datalen+4+1)&0xFF00)>>8;
+ mtkdata_header[3] = ((Datalen+4+1)&0x00FF);
+ mtkdata_header[4] = ((Datalen+4+1)&0xFF00)>>8;
- mtkdata_header[5] = 0x1;
- mtkdata_header[6] = 0x1;
+ mtkdata_header[5] = 0x1;
+ mtkdata_header[6] = 0x1;
- mtkdata_header[7] = ((Datalen+1)&0x00FF);
- mtkdata_header[8] = ((Datalen+1)&0xFF00)>>8;
+ mtkdata_header[7] = ((Datalen+1)&0x00FF);
+ mtkdata_header[8] = ((Datalen+1)&0xFF00)>>8;
- mtkdata_header[9] = mode;
+ mtkdata_header[9] = mode;
/*
* 0 and 1 is packet length, include MTKSTP_HEADER_SIZE
*/
- mtksdio_packet_header[0] = (Datalen+4+MTKSTP_HEADER_SIZE+6)&0xFF;
- mtksdio_packet_header[1] = ((Datalen+4+MTKSTP_HEADER_SIZE+6)&0xFF00)>>8;
- mtksdio_packet_header[2] = 0;
- mtksdio_packet_header[3] = 0;
+ mtksdio_packet_header[0] =
+ (Datalen+4+MTKSTP_HEADER_SIZE+6)&0xFF;
+ mtksdio_packet_header[1] =
+ ((Datalen+4+MTKSTP_HEADER_SIZE+6)&0xFF00)>>8;
+ mtksdio_packet_header[2] = 0;
+ mtksdio_packet_header[3] = 0;
/*
-*mtksdio_packet_header[2] and mtksdio_packet_header[3] are reserved
+*mtksdio_packet_header[2] and mtksdio_packet_header[3]
+*are reserved
*/
- BTMTK_DBG("%s result %02x %02x\n", __func__
- , ((Datalen+4+MTKSTP_HEADER_SIZE+6)&0xFF00)>>8
- , (Datalen+4+MTKSTP_HEADER_SIZE+6));
+ pr_debug("%s result %02x %02x\n", __func__,
+ ((Datalen+4+MTKSTP_HEADER_SIZE+6)&0xFF00)>>8,
+ (Datalen+4+MTKSTP_HEADER_SIZE+6));
- memcpy(txbuf+copy_len, mtksdio_packet_header, MTK_SDIO_PACKET_HEADER_SIZE);
- copy_len += MTK_SDIO_PACKET_HEADER_SIZE;
+ memcpy(txbuf+copy_len, mtksdio_packet_header,
+ MTK_SDIO_PACKET_HEADER_SIZE);
+ copy_len += MTK_SDIO_PACKET_HEADER_SIZE;
- memcpy(txbuf+copy_len, mtkdata_header, MTKDATA_HEADER_SIZE);
- copy_len += MTKDATA_HEADER_SIZE;
+ memcpy(txbuf+copy_len, mtkdata_header, MTKDATA_HEADER_SIZE);
+ copy_len += MTKDATA_HEADER_SIZE;
+
+ memcpy(txbuf+copy_len, fwbuf, Datalen);
+ copy_len += Datalen;
+
+ pr_debug("%s txbuf %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
+ __func__,
+ txbuf[0], txbuf[1], txbuf[2], txbuf[3], txbuf[4],
+ txbuf[5], txbuf[6], txbuf[7], txbuf[8], txbuf[9]);
+ ret = btmtk_sdio_readl(CHIER, &u32ReadCRValue);
+ pr_debug("%s: CHIER u32ReadCRValue %x, ret %d\n",
+ __func__, u32ReadCRValue, ret);
- memcpy(txbuf+copy_len, fwbuf, Datalen);
- copy_len += Datalen;
+ ret = btmtk_sdio_readl(CHLPCR, &u32ReadCRValue);
+ pr_debug("%s: CHLPCR u32ReadCRValue %x, ret %d\n",
+ __func__, u32ReadCRValue, ret);
- BTMTK_DBG("%s txbuf %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n", __func__,
- txbuf[0], txbuf[1], txbuf[2], txbuf[3], txbuf[4],
- txbuf[5], txbuf[6], txbuf[7], txbuf[8], txbuf[9]);
+ ret = btmtk_sdio_readl(CHISR, &u32ReadCRValue);
+ pr_debug("%s: 0CHISR u32ReadCRValue %x, ret %d\n",
+ __func__, u32ReadCRValue, ret);
+ ret = btmtk_sdio_readl(CHISR, &u32ReadCRValue);
+ pr_debug("%s: 00CHISR u32ReadCRValue %x, ret %d\n",
+ __func__, u32ReadCRValue, ret);
+ btmtk_sdio_send_tx_data(txbuf, copy_len);
- ret = btmtk_sdio_readl(CHIER, &u32ReadCRValue);
- BTMTK_DBG("%s: CHIER u32ReadCRValue %x, ret %d\n", __func__, u32ReadCRValue, ret);
+ ret = btmtk_sdio_recv_rx_data();
- ret = btmtk_sdio_readl(CHLPCR, &u32ReadCRValue);
- BTMTK_DBG("%s: CHLPCR u32ReadCRValue %x, ret %d\n", __func__, u32ReadCRValue, ret);
-
- ret = btmtk_sdio_readl(CHISR, &u32ReadCRValue);
- BTMTK_DBG("%s: 0CHISR u32ReadCRValue %x, ret %d\n", __func__, u32ReadCRValue, ret);
- ret = btmtk_sdio_readl(CHISR, &u32ReadCRValue);
- BTMTK_DBG("%s: 00CHISR u32ReadCRValue %x, ret %d\n", __func__, u32ReadCRValue, ret);
-
- btmtk_sdio_send_tx_data(txbuf, copy_len);
-
-
- ret = btmtk_sdio_recv_rx_data();
-
- return ret;
+ return ret;
}
@@ -878,41 +922,46 @@
*/
static int btmtk_sdio_send_wohci(u8 type, u32 len, u8 *data)
{
- u32 ret = 0;
- u32 push_in_data_len = 0;
- u8 mtk_wmt_header[MTKWMT_HEADER_SIZE] = {0};
- u8 mtksdio_packet_header[MTK_SDIO_PACKET_HEADER_SIZE] = {0};
- u8 mtk_tx_data[512] = {0};
+ u32 ret = 0;
+ u32 push_in_data_len = 0;
+ u8 mtk_wmt_header[MTKWMT_HEADER_SIZE] = {0};
+ u8 mtksdio_packet_header[MTK_SDIO_PACKET_HEADER_SIZE] = {0};
+ u8 mtk_tx_data[512] = {0};
- mtk_wmt_header[0] = type;
- mtk_wmt_header[1] = 0x6F;
- mtk_wmt_header[2] = 0xFC;
- mtk_wmt_header[3] = len;
+ mtk_wmt_header[0] = type;
+ mtk_wmt_header[1] = 0x6F;
+ mtk_wmt_header[2] = 0xFC;
+ mtk_wmt_header[3] = len;
- mtksdio_packet_header[0] = (len+MTKWMT_HEADER_SIZE+MTK_SDIO_PACKET_HEADER_SIZE)&0xFF;
- mtksdio_packet_header[1] = ((len+MTKWMT_HEADER_SIZE+MTK_SDIO_PACKET_HEADER_SIZE)&0xFF00)>>8;
- mtksdio_packet_header[2] = 0;
- mtksdio_packet_header[3] = 0;
+ mtksdio_packet_header[0] =
+ (len+MTKWMT_HEADER_SIZE+MTK_SDIO_PACKET_HEADER_SIZE)&0xFF;
+ mtksdio_packet_header[1] =
+ ((len+MTKWMT_HEADER_SIZE+MTK_SDIO_PACKET_HEADER_SIZE)&0xFF00)
+ >>8;
+ mtksdio_packet_header[2] = 0;
+ mtksdio_packet_header[3] = 0;
/*
-* mtksdio_packet_header[2] and mtksdio_packet_header[3] are reserved
+* mtksdio_packet_header[2] and mtksdio_packet_header[3]
+* are reserved
*/
- memcpy(mtk_tx_data, mtksdio_packet_header, sizeof(mtksdio_packet_header));
- push_in_data_len += sizeof(mtksdio_packet_header);
+ memcpy(mtk_tx_data, mtksdio_packet_header,
+ sizeof(mtksdio_packet_header));
+ push_in_data_len += sizeof(mtksdio_packet_header);
- memcpy(mtk_tx_data+push_in_data_len, mtk_wmt_header, sizeof(mtk_wmt_header));
- push_in_data_len += sizeof(mtk_wmt_header);
+ memcpy(mtk_tx_data+push_in_data_len, mtk_wmt_header,
+ sizeof(mtk_wmt_header));
+ push_in_data_len += sizeof(mtk_wmt_header);
- memcpy(mtk_tx_data+push_in_data_len, data, len);
- push_in_data_len += len;
+ memcpy(mtk_tx_data+push_in_data_len, data, len);
+ push_in_data_len += len;
- sdio_claim_host(g_card->func);
- ret = sdio_writesb(g_card->func, CTDR, mtk_tx_data, push_in_data_len);
- sdio_release_host(g_card->func);
+ sdio_claim_host(g_card->func);
+ ret = sdio_writesb(g_card->func, CTDR, mtk_tx_data, push_in_data_len);
+ sdio_release_host(g_card->func);
-
- BTMTK_INFO("%s retrun 0x%0x\n", __func__, ret);
- return ret;
+ pr_info("%s retrun 0x%0x\n", __func__, ret);
+ return ret;
}
/*
* data event:
@@ -928,1223 +977,1218 @@
*/
static int btmtk_sdio_need_load_rom_patch(void)
{
- u32 ret = 0;
- u8 cmd[] = {0x1, 0x17, 0x1, 0x0, 0x1};
- u8 event[] = {0x2, 0x17, 0x1, 0x0};
+ u32 ret = 0;
+ u8 cmd[] = {0x1, 0x17, 0x1, 0x0, 0x1};
+ u8 event[] = {0x2, 0x17, 0x1, 0x0};
- do {
- ret = btmtk_sdio_send_wohci(HCI_COMMAND_PKT, sizeof(cmd), cmd);
+ do {
+ ret = btmtk_sdio_send_wohci(HCI_COMMAND_PKT, sizeof(cmd), cmd);
- if (ret) {
- BTMTK_ERR("%s btmtk_sdio_send_wohci return fail ret %d", __func__, ret);
- break;
- }
+ if (ret) {
+ pr_err("%s btmtk_sdio_send_wohci return fail ret %d\n",
+ __func__, ret);
+ break;
+ }
- ret = btmtk_sdio_recv_rx_data();
- if (ret)
- break;
+ ret = btmtk_sdio_recv_rx_data();
+ if (ret)
+ break;
- if (rx_length == 12) {
- if (memcmp(rxbuf+7, event, sizeof(event)) == 0)
- return rxbuf[11];
- else{
- BTMTK_ERR("%s receive event content is not correct, print receive data\n", __func__);
- btmtk_print_buffer_conent(rxbuf, rx_length);
- }
- }
+ if (rx_length == 12) {
+ if (memcmp(rxbuf+7, event, sizeof(event)) == 0)
+ return rxbuf[11];
- } while (0);
+ pr_err("%s receive event content is not correct, print receive data\n",
+ __func__);
+ btmtk_print_buffer_conent(rxbuf, rx_length);
+ }
+ } while (0);
- return ret;
+ return ret;
}
static int btmtk_sdio_set_write_clear(void)
{
- u32 u32ReadCRValue = 0;
- u32 ret = 0;
+ u32 u32ReadCRValue = 0;
+ u32 ret = 0;
- ret = btmtk_sdio_readl(CHCR, &u32ReadCRValue);
- if (ret) {
- BTMTK_ERR("%s read CHCR error\n", __func__);
- ret = EINVAL;
- return ret;
- }
+ ret = btmtk_sdio_readl(CHCR, &u32ReadCRValue);
+ if (ret) {
+ pr_err("%s read CHCR error\n", __func__);
+ ret = EINVAL;
+ return ret;
+ }
- u32ReadCRValue |= 0x00000002;
- btmtk_sdio_writel(CHCR, u32ReadCRValue);
- BTMTK_INFO("%s write CHCR 0x%08X\n", __func__, u32ReadCRValue);
- ret = btmtk_sdio_readl(CHCR, &u32ReadCRValue);
- BTMTK_INFO("%s read CHCR 0x%08X\n", __func__, u32ReadCRValue);
- if (u32ReadCRValue&0x00000002)
- BTMTK_INFO("%s write clear\n", __func__);
- else
- BTMTK_INFO("%s read clear\n", __func__);
+ u32ReadCRValue |= 0x00000002;
+ btmtk_sdio_writel(CHCR, u32ReadCRValue);
+ pr_info("%s write CHCR 0x%08X\n", __func__, u32ReadCRValue);
+ ret = btmtk_sdio_readl(CHCR, &u32ReadCRValue);
+ pr_info("%s read CHCR 0x%08X\n", __func__, u32ReadCRValue);
+ if (u32ReadCRValue&0x00000002)
+ pr_info("%s write clear\n", __func__);
+ else
+ pr_info("%s read clear\n", __func__);
-
- return ret;
+ return ret;
}
-static int btmtk_sdio_download_rom_patch(struct btmtk_sdio_card *card)
+static int btmtk_sdio_download_rom_patch(
+ struct btmtk_sdio_card *card)
{
- const struct firmware *fw_firmware = NULL;
- const u8 *firmware = NULL;
- int firmwarelen, ret = 0;
- void *tmpfwbuf = NULL;
- u8 *fwbuf;
- P_PATCH_HEADER patchHdr;
- u8 *cDateTime = NULL;
- u16 u2HwVer = 0;
- u16 u2SwVer = 0;
- u32 u4PatchVer = 0;
- u32 uhwversion = 0;
+ const struct firmware *fw_firmware = NULL;
+ const u8 *firmware = NULL;
+ int firmwarelen, ret = 0;
+ void *tmpfwbuf = NULL;
+ u8 *fwbuf;
+ struct _PATCH_HEADER *patchHdr;
+ u8 *cDateTime = NULL;
+ u16 u2HwVer = 0;
+ u16 u2SwVer = 0;
+ u32 u4PatchVer = 0;
+ u32 uhwversion = 0;
- u32 u32ReadCRValue = 0;
+ u32 u32ReadCRValue = 0;
- int RedundantSize = 0;
- u32 bufferOffset = 0;
- u8 patch_status = 0;
+ int RedundantSize = 0;
+ u32 bufferOffset = 0;
+ u8 patch_status = 0;
- ret = btmtk_sdio_set_own_back(DRIVER_OWN);
+ ret = btmtk_sdio_set_own_back(DRIVER_OWN);
- if (ret)
- return ret;
+ if (ret)
+ return ret;
- patch_status = btmtk_sdio_need_load_rom_patch();
+ patch_status = btmtk_sdio_need_load_rom_patch();
- BTMTK_DBG("%s patch_status %d\n", __func__, patch_status);
+ pr_debug("%s patch_status %d\n", __func__, patch_status);
- if (PATCH_IS_DOWNLOAD_BT_OTHER == patch_status || PATCH_READY == patch_status) {
- BTMTK_INFO("%s patch is ready no need load patch again\n", __func__);
+ if (PATCH_IS_DOWNLOAD_BT_OTHER == patch_status ||
+ PATCH_READY == patch_status) {
+ pr_info("%s patch is ready no need load patch again\n",
+ __func__);
- ret = btmtk_sdio_readl(0, &u32ReadCRValue);
- BTMTK_INFO("%s read chipid = %x\n", __func__, u32ReadCRValue);
+ ret = btmtk_sdio_readl(0, &u32ReadCRValue);
+ pr_info("%s read chipid = %x\n", __func__, u32ReadCRValue);
- /*Set interrupt output*/
- ret = btmtk_sdio_writel(CHIER, FIRMWARE_INT|TX_FIFO_OVERFLOW |
- FW_INT_IND_INDICATOR | TX_COMPLETE_COUNT |
- TX_UNDER_THOLD | TX_EMPTY | RX_DONE);
+ /*Set interrupt output*/
+ ret = btmtk_sdio_writel(CHIER, FIRMWARE_INT|TX_FIFO_OVERFLOW |
+ FW_INT_IND_INDICATOR | TX_COMPLETE_COUNT |
+ TX_UNDER_THOLD | TX_EMPTY | RX_DONE);
- if (ret) {
- BTMTK_ERR("Set interrupt output fail(%d)\n", ret);
- ret = -EIO;
- }
+ if (ret) {
+ pr_err("Set interrupt output fail(%d)\n", ret);
+ ret = -EIO;
+ }
+
+ /*enable interrupt output*/
+ ret = btmtk_sdio_writel(CHLPCR, C_FW_INT_EN_SET);
+ if (ret) {
+ pr_err("enable interrupt output fail(%d)\n", ret);
+ ret = -EIO;
+ goto done;
+ }
+
+ ret = btmtk_sdio_bt_set_power(1);
+ if (ret)
+ return ret;
+
+ ret = btmtk_sdio_set_sleep();
+ btmtk_sdio_set_write_clear();
+ return ret;
+ }
+
+ uhwversion = btmtk_sdio_bt_memRegister_read(HW_VERSION);
+ pr_info("%s uhwversion 0x%x\n", __func__, uhwversion);
+
+ if (uhwversion == 0x8A00) {
+ pr_info("%s request_firmware(firmware name %s)\n",
+ __func__, card->firmware);
+ ret = request_firmware(&fw_firmware, card->firmware,
+ &card->func->dev);
+
+ if ((ret < 0) || !fw_firmware) {
+ pr_err("request_firmware(firmware name %s) failed, error code = %d\n",
+ card->firmware,
+ ret);
+ ret = -ENOENT;
+ goto done;
+ }
+ } else {
+ pr_info("%s request_firmware(firmware name %s)\n",
+ __func__, card->firmware1);
+ ret = request_firmware(&fw_firmware,
+ card->firmware1,
+ &card->func->dev);
+
+ if ((ret < 0) || !fw_firmware) {
+ pr_err("request_firmware(firmware name %s) failed, error code = %d\n",
+ card->firmware1, ret);
+ ret = -ENOENT;
+ goto done;
+ }
+ }
+
+ firmware = fw_firmware->data;
+ firmwarelen = fw_firmware->size;
+
+ pr_debug("Downloading FW image (%d bytes)\n", firmwarelen);
+
+ tmpfwbuf = kzalloc(firmwarelen, GFP_KERNEL);
+
+ if (!tmpfwbuf) {
+ ret = -ENOMEM;
+ goto done;
+ }
+
+ /* Ensure aligned firmware buffer */
+ memcpy(tmpfwbuf, firmware, firmwarelen);
+ fwbuf = tmpfwbuf;
+
+ /*Display rom patch info*/
+ patchHdr = (struct _PATCH_HEADER *)fwbuf;
+ cDateTime = patchHdr->ucDateTime;
+ u2HwVer = patchHdr->u2HwVer;
+ u2SwVer = patchHdr->u2SwVer;
+ u4PatchVer = patchHdr->u4PatchVer;
+
+ pr_debug("=====================================\n");
+ pr_info("===============Patch Info============\n");
+ pr_info("Built Time = %s\n", cDateTime);
+ pr_info("Hw Ver = 0x%x\n",
+ ((u2HwVer & 0x00ff) << 8) | ((u2HwVer & 0xff00) >> 8));
+ pr_info("Sw Ver = 0x%x\n",
+ ((u2SwVer & 0x00ff) << 8) | ((u2SwVer & 0xff00) >> 8));
+ pr_info("Patch Ver = 0x%04x\n",
+ ((u4PatchVer & 0xff000000) >> 24) |
+ ((u4PatchVer & 0x00ff0000) >> 16));
+ pr_info("Platform = %c%c%c%c\n",
+ patchHdr->ucPlatform[0],
+ patchHdr->ucPlatform[1],
+ patchHdr->ucPlatform[2],
+ patchHdr->ucPlatform[3]);
+ pr_info("Patch start addr = %02x\n", patchHdr->u2PatchStartAddr);
+ pr_info("=====================================\n");
+
+ fwbuf += sizeof(struct _PATCH_HEADER);
+ pr_debug("%s PATCH_HEADER size %zd\n", __func__, sizeof(struct _PATCH_HEADER));
+ firmwarelen -= sizeof(struct _PATCH_HEADER);
+
+ ret = btmtk_sdio_readl(0, &u32ReadCRValue);
+ pr_info("%s read chipid = %x\n", __func__, u32ReadCRValue);
+
+ /*Set interrupt output*/
+ ret = btmtk_sdio_writel(CHIER, FIRMWARE_INT|TX_FIFO_OVERFLOW |
+ FW_INT_IND_INDICATOR | TX_COMPLETE_COUNT |
+ TX_UNDER_THOLD | TX_EMPTY | RX_DONE);
+
+ if (ret) {
+ pr_err("Set interrupt output fail(%d)\n", ret);
+ ret = -EIO;
+ goto done;
+ }
+
+ /*enable interrupt output*/
+ ret = btmtk_sdio_writel(CHLPCR, C_FW_INT_EN_SET);
+
+ if (ret) {
+ pr_err("enable interrupt output fail(%d)\n", ret);
+ ret = -EIO;
+ goto done;
+ }
+
+ RedundantSize = firmwarelen;
+ pr_debug("%s firmwarelen %d\n", __func__, firmwarelen);
+
+ do {
+ bufferOffset = firmwarelen - RedundantSize;
+
+ if (RedundantSize == firmwarelen &&
+ PATCH_DOWNLOAD_SIZE <= RedundantSize)
+ ret = btmtk_send_rom_patch(fwbuf+bufferOffset,
+ PATCH_DOWNLOAD_SIZE, SDIO_PATCH_DOWNLOAD_FIRST);
+ else if (RedundantSize == firmwarelen)
+ ret = btmtk_send_rom_patch(fwbuf+bufferOffset,
+ RedundantSize, SDIO_PATCH_DOWNLOAD_FIRST);
+ else if (RedundantSize < PATCH_DOWNLOAD_SIZE) {
+ ret = btmtk_send_rom_patch(fwbuf+bufferOffset,
+ RedundantSize, SDIO_PATCH_DOWNLOAD_END);
+ pr_debug("%s patch downoad last patch part\n",
+ __func__);
+ } else
+ ret = btmtk_send_rom_patch(fwbuf+bufferOffset,
+ PATCH_DOWNLOAD_SIZE, SDIO_PATCH_DOWNLOAD_CON);
+
+ RedundantSize -= PATCH_DOWNLOAD_SIZE;
+
+ if (ret) {
+ pr_err("%s btmtk_send_rom_patch fail\n", __func__);
+ goto done;
+ }
+ pr_debug("%s RedundantSize %d\n", __func__, RedundantSize);
+ if (RedundantSize <= 0) {
+ pr_debug("%s patch downoad finish\n", __func__);
+ break;
+ }
+ } while (1);
+
+ btmtk_sdio_set_write_clear();
+
+ if (btmtk_sdio_need_load_rom_patch() == PATCH_READY)
+ pr_info("%s patch is ready\n", __func__);
- /*enable interrupt output*/
- ret = btmtk_sdio_writel(CHLPCR, C_FW_INT_EN_SET);
+ ret = btmtk_sdio_send_wmt_reset();
+
+ if (ret)
+ goto done;
+ ret = btmtk_sdio_bt_set_power(1);
- if (ret) {
- BTMTK_ERR("enable interrupt output fail(%d)\n", ret);
- ret = -EIO;
- goto done;
- }
+ if (ret) {
+ ret = EINVAL;
+ goto done;
+ }
- ret = btmtk_sdio_bt_set_power(1);
- if (ret)
- return ret;
-
- ret = btmtk_sdio_set_sleep();
- btmtk_sdio_set_write_clear();
- return ret;
- }
-
- uhwversion = btmtk_sdio_bt_memRegister_read(HW_VERSION);
- BTMTK_INFO("%s uhwversion 0x%x\n",__func__,uhwversion);
-
- if (uhwversion == 0x8A00){
- BTMTK_INFO("%s request_firmware(firmware name %s)\n",__func__,card->firmware);
- ret = request_firmware(&fw_firmware, card->firmware,
- &card->func->dev);
-
- if ((ret < 0) || !fw_firmware) {
- BTMTK_ERR("request_firmware(firmware name %s) failed, error code = %d",
- card->firmware,
- ret);
- ret = -ENOENT;
- goto done;
- }
- }
- else {
- BTMTK_INFO("%s request_firmware(firmware name %s)\n",__func__,card->firmware1);
- ret = request_firmware(&fw_firmware, card->firmware1,
- &card->func->dev);
-
- if ((ret < 0) || !fw_firmware) {
- BTMTK_ERR("request_firmware(firmware name %s) failed, error code = %d",
- card->firmware1,
- ret);
- ret = -ENOENT;
- goto done;
- }
- }
-
-
- firmware = fw_firmware->data;
- firmwarelen = fw_firmware->size;
-
- BTMTK_DBG("Downloading FW image (%d bytes)", firmwarelen);
-
- tmpfwbuf = kzalloc(firmwarelen, GFP_KERNEL);
-
- if (!tmpfwbuf) {
- BTMTK_ERR("%s Unable to allocate buffer for firmware. Terminating download"
- , __func__);
- ret = -ENOMEM;
- goto done;
- }
-
- /* Ensure aligned firmware buffer */
- memcpy(tmpfwbuf, firmware, firmwarelen);
- fwbuf = tmpfwbuf;
-
- /*Display rom patch info*/
- patchHdr = (P_PATCH_HEADER)fwbuf;
- cDateTime = patchHdr->ucDateTime;
- u2HwVer = patchHdr->u2HwVer;
- u2SwVer = patchHdr->u2SwVer;
- u4PatchVer = patchHdr->u4PatchVer;
-
- BTMTK_DBG("=====================================\n");
- BTMTK_INFO("===============Patch Info============\n");
- BTMTK_INFO("Built Time = %s\n", cDateTime);
- BTMTK_INFO("Hw Ver = 0x%x\n",
- ((u2HwVer & 0x00ff) << 8) | ((u2HwVer & 0xff00) >> 8));
- BTMTK_INFO("Sw Ver = 0x%x\n",
- ((u2SwVer & 0x00ff) << 8) | ((u2SwVer & 0xff00) >> 8));
- BTMTK_INFO("Patch Ver = 0x%04x\n",
- ((u4PatchVer & 0xff000000) >> 24) | ((u4PatchVer & 0x00ff0000) >>
- 16));
- BTMTK_INFO("Platform = %c%c%c%c\n", patchHdr->ucPlatform[0],
- patchHdr->ucPlatform[1], patchHdr->ucPlatform[2], patchHdr->ucPlatform[3]);
- BTMTK_INFO("Patch start addr = %02x\n", patchHdr->u2PatchStartAddr);
- BTMTK_INFO("=====================================\n");
-
-
- fwbuf += sizeof(PATCH_HEADER);
- BTMTK_DBG("%s PATCH_HEADER size %zd\n", __func__, sizeof(PATCH_HEADER));
- firmwarelen -= sizeof(PATCH_HEADER);
-
-
-
- ret = btmtk_sdio_readl(0, &u32ReadCRValue);
- BTMTK_INFO("%s read chipid = %x\n", __func__, u32ReadCRValue);
-
- /*Set interrupt output*/
- ret = btmtk_sdio_writel(CHIER, FIRMWARE_INT|TX_FIFO_OVERFLOW |
- FW_INT_IND_INDICATOR | TX_COMPLETE_COUNT |
- TX_UNDER_THOLD | TX_EMPTY | RX_DONE);
-
- if (ret) {
- BTMTK_ERR("Set interrupt output fail(%d)\n", ret);
- ret = -EIO;
- goto done;
- }
-
- /*enable interrupt output*/
- ret = btmtk_sdio_writel(CHLPCR, C_FW_INT_EN_SET);
-
-
-
- if (ret) {
- BTMTK_ERR("enable interrupt output fail(%d)\n", ret);
- ret = -EIO;
- goto done;
- }
-
- RedundantSize = firmwarelen;
- BTMTK_DBG("%s firmwarelen %d\n", __func__, firmwarelen);
-
-
- do {
- bufferOffset = firmwarelen - RedundantSize;
-
- if (RedundantSize == firmwarelen && PATCH_DOWNLOAD_SIZE <= RedundantSize)
- ret = btmtk_send_rom_patch(fwbuf+bufferOffset, PATCH_DOWNLOAD_SIZE, SDIO_PATCH_DOWNLOAD_FIRST);
- else if (RedundantSize == firmwarelen)
- ret = btmtk_send_rom_patch(fwbuf+bufferOffset, RedundantSize, SDIO_PATCH_DOWNLOAD_FIRST);
- else if (RedundantSize < PATCH_DOWNLOAD_SIZE) {
- ret = btmtk_send_rom_patch(fwbuf+bufferOffset, RedundantSize, SDIO_PATCH_DOWNLOAD_END);
- BTMTK_DBG("%s patch downoad last patch part\n", __func__);
- } else
- ret = btmtk_send_rom_patch(fwbuf+bufferOffset, PATCH_DOWNLOAD_SIZE, SDIO_PATCH_DOWNLOAD_CON);
-
- RedundantSize -= PATCH_DOWNLOAD_SIZE;
-
- if (ret) {
- BTMTK_ERR("%s btmtk_send_rom_patch fail\n", __func__);
- goto done;
- }
- BTMTK_DBG("%s RedundantSize %d", __func__, RedundantSize);
- if (RedundantSize <= 0) {
- BTMTK_DBG("%s patch downoad finish\n", __func__);
- break;
- }
-
- } while (1);
-
- btmtk_sdio_set_write_clear();
-
-
- if (btmtk_sdio_need_load_rom_patch() == PATCH_READY)
- BTMTK_INFO("%s patch is ready\n", __func__);
-
-
- ret = btmtk_sdio_send_wmt_reset();
-
- if (ret)
- goto done;
-
-
- ret = btmtk_sdio_bt_set_power(1);
-
- if (ret){
- ret = EINVAL;
- goto done;
- }
-
- ret = btmtk_sdio_set_sleep();
-
+ ret = btmtk_sdio_set_sleep();
done:
- kfree(tmpfwbuf);
- release_firmware(fw_firmware);
+ kfree(tmpfwbuf);
+ release_firmware(fw_firmware);
+ if (!ret)
+ pr_info("%s success\n", __func__);
+ else
+ pr_info("%s fail\n", __func__);
-
-
- if (!ret)
- BTMTK_INFO("%s success\n", __func__);
- else
- BTMTK_INFO("%s fail\n", __func__);
-
-
- return ret;
+ return ret;
}
+static void btmtk_sdio_for_code_style(void)
+{
+ pr_info("%s vfs_fsync\n", __func__);
+
+#if SAVE_FW_DUMP_IN_KERNEL
+ if (fw_dump_file)
+ vfs_fsync(fw_dump_file, 0);
+#endif
+
+ if (fw_dump_file) {
+ pr_info("%s : close file %s\n",
+ __func__, fw_dump_file_name);
+#if SAVE_FW_DUMP_IN_KERNEL
+ filp_close(fw_dump_file, NULL);
+/* #endif */
+ fw_dump_file = NULL;
+#endif
+ fw_is_doing_coredump = false;
+ fw_is_coredump_end_packet = true;
+ } else {
+ fw_is_doing_coredump = false;
+ pr_info("%s : fw_dump_file is NULL can't close file %s\n",
+ __func__, fw_dump_file_name);
+ }
+}
static int btmtk_sdio_card_to_host(struct btmtk_private *priv)
{
- u16 buf_len = 0;
- int ret = 0, num_blocks = 0, blksz = 0;
- struct sk_buff *skb = NULL;
- struct sk_buff *fops_skb = NULL;
- u32 type;
- u8 *payload = NULL;
- u32 fourbalignment_len = 0;
- struct btmtk_sdio_card *card = priv->btmtk_dev.card;
- u32 dump_len = 0;
- char *core_dump_end = NULL;
+ u16 buf_len = 0;
+ int ret = 0, num_blocks = 0, blksz = 0;
+ struct sk_buff *skb = NULL;
+ struct sk_buff *fops_skb = NULL;
+ u32 type;
+ u8 *payload = NULL;
+ u32 fourbalignment_len = 0;
+ struct btmtk_sdio_card *card = priv->btmtk_dev.card;
+ u32 dump_len = 0;
+ char *core_dump_end = NULL;
- if (!card || !card->func) {
- BTMTK_ERR("card or function or is NULL!");
- ret = -EINVAL;
- goto exit;
- }
+ if (!card || !card->func) {
+ pr_err("card or function or is NULL!\n");
+ ret = -EINVAL;
+ goto exit;
+ }
#if SUPPORT_FW_DUMP
- fw_is_coredump_end_packet = false;
- if (rx_length > (SDIO_HEADER_LEN+8)) {
- if (rxbuf[SDIO_HEADER_LEN] == 0x80) {
- dump_len = (rxbuf[SDIO_HEADER_LEN+1]&0x0F)*256 + rxbuf[SDIO_HEADER_LEN+2];
- BTMTK_WARN("%s get dump length %d", __func__, dump_len);
- if (rxbuf[SDIO_HEADER_LEN+5] == 0x6F && rxbuf[SDIO_HEADER_LEN+6] == 0xFC) {
+ fw_is_coredump_end_packet = false;
+ if (rx_length > (SDIO_HEADER_LEN+8)) {
+ if (rxbuf[SDIO_HEADER_LEN] == 0x80) {
+ dump_len = (rxbuf[SDIO_HEADER_LEN+1]&0x0F)*256
+ + rxbuf[SDIO_HEADER_LEN+2];
+ pr_warn("%s get dump length %d\n", __func__, dump_len);
+ if (rxbuf[SDIO_HEADER_LEN+5] == 0x6F &&
+ rxbuf[SDIO_HEADER_LEN+6] == 0xFC) {
- fw_is_doing_coredump = true;
+ fw_is_doing_coredump = true;
- #if SAVE_FW_DUMP_IN_KERNEL
- if ((fw_dump_total_read_size == 0) && (fw_dump_file == NULL)) {
- if(current_fwdump_file_number == probe_counter)
- goto FW_DONE;
- //#if SAVE_FW_DUMP_IN_KERNEL
- memset(fw_dump_file_name, 0, sizeof(fw_dump_file_name));
- snprintf(fw_dump_file_name, sizeof(fw_dump_file_name),
- FW_DUMP_FILE_NAME"_%d", probe_counter);
- BTMTK_WARN("%s : open file %s\n", __func__, fw_dump_file_name);
- fw_dump_file = filp_open(fw_dump_file_name, O_RDWR | O_CREAT, 0644);
- if (fw_dump_file){
- current_fwdump_file_number = probe_counter;
- BTMTK_WARN("%s : open file %s success\n", __func__, fw_dump_file_name);
- }
- else
- BTMTK_WARN("%s : open file %s fail\n", __func__, fw_dump_file_name);
- //#endif
+ #if SAVE_FW_DUMP_IN_KERNEL
+ if ((fw_dump_total_read_size == 0)
+ && (fw_dump_file == NULL)) {
+ if (current_fwdump_file_number
+ == probe_counter)
+ goto FW_DONE;
+ /* #if SAVE_FW_DUMP_IN_KERNEL */
+ memset(fw_dump_file_name, 0,
+ sizeof(fw_dump_file_name));
+ snprintf(fw_dump_file_name,
+ sizeof(fw_dump_file_name),
+ FW_DUMP_FILE_NAME"_%d",
+ probe_counter);
+ pr_warn("%s : open file %s\n",
+ __func__,
+ fw_dump_file_name);
+ fw_dump_file = filp_open(
+ fw_dump_file_name,
+ O_RDWR | O_CREAT,
+ 0644);
+ if (fw_dump_file) {
+ current_fwdump_file_number =
+ probe_counter;
+ pr_warn("%s : open file %s success\n",
+ __func__,
+ fw_dump_file_name);
+ } else
+ pr_warn("%s : open file %s fail\n",
+ __func__,
+ fw_dump_file_name);
+ /* #endif */
+ }
+ #endif
+ fw_dump_total_read_size += dump_len;
- }
- #endif
- fw_dump_total_read_size += dump_len;
+ #if SAVE_FW_DUMP_IN_KERNEL
+ if (fw_dump_file->f_op == NULL)
+ pr_warn("%s : fw_dump_file->f_op is NULL\n",
+ __func__);
- #if SAVE_FW_DUMP_IN_KERNEL
- if (fw_dump_file->f_op == NULL)
- BTMTK_WARN("%s : fw_dump_file->f_op is NULL\n", __func__);
-
- if (fw_dump_file->f_op->write == NULL)
- BTMTK_WARN("%s : fw_dump_file->f_op->write is NULL\n", __func__);
+ if (fw_dump_file->f_op->write == NULL)
+ pr_warn("%s : fw_dump_file->f_op->write is NULL\n",
+ __func__);
- if ((dump_len > 0) && fw_dump_file)
- fw_dump_file->f_op->write(fw_dump_file, &rxbuf[SDIO_HEADER_LEN+10], dump_len, &fw_dump_file->f_pos);
+ if ((dump_len > 0) && fw_dump_file)
+ fw_dump_file->f_op->write(fw_dump_file,
+ &rxbuf[SDIO_HEADER_LEN+10],
+ dump_len,
+ &fw_dump_file->f_pos);
- #endif
+ #endif
- if (dump_len >= sizeof(FW_DUMP_END_EVENT)) {
- core_dump_end = strstr(&rxbuf[SDIO_HEADER_LEN+10], FW_DUMP_END_EVENT);
- BTMTK_WARN("%s : core_dump_end %d\n", __func__, SDIO_HEADER_LEN);
- if (core_dump_end) {
- BTMTK_INFO("%s vfs_fsync ", __func__);
-
- #if SAVE_FW_DUMP_IN_KERNEL
- if(fw_dump_file)
- vfs_fsync(fw_dump_file, 0);
- #endif
-
- if (fw_dump_file) {
- BTMTK_INFO("%s : close file %s\n", __func__, fw_dump_file_name);
- #if SAVE_FW_DUMP_IN_KERNEL
- filp_close(fw_dump_file, NULL);
- //#endif
- fw_dump_file = NULL;
- #endif
- fw_is_doing_coredump = false;
- fw_is_coredump_end_packet = true;
- } else{
- fw_is_doing_coredump = false;
- BTMTK_INFO("%s : fw_dump_file is NULL can't close file %s", __func__, fw_dump_file_name);
- }
- }
-
- }
-
- }
-
- }
- }
+ if (dump_len >= sizeof(FW_DUMP_END_EVENT)) {
+ core_dump_end = strstr(
+ &rxbuf[SDIO_HEADER_LEN+10],
+ FW_DUMP_END_EVENT);
+ pr_warn("%s : core_dump_end %d\n",
+ __func__, SDIO_HEADER_LEN);
+ if (core_dump_end)
+ btmtk_sdio_for_code_style();
+ }
+ }
+ }
+ }
#endif
#if SAVE_FW_DUMP_IN_KERNEL
FW_DONE:
#endif
- type = rxbuf[MTK_SDIO_PACKET_HEADER_SIZE];
+ type = rxbuf[MTK_SDIO_PACKET_HEADER_SIZE];
+ btmtk_print_buffer_conent(rxbuf, rx_length);
- btmtk_print_buffer_conent(rxbuf, rx_length);
+ /* Read the length of data to be transferred , not include pkt type*/
+ buf_len = rx_length-(MTK_SDIO_PACKET_HEADER_SIZE+1);
- /* Read the length of data to be transferred , not include pkt type*/
- buf_len = rx_length-(MTK_SDIO_PACKET_HEADER_SIZE+1);
+ pr_debug("buf_len : %d\n", buf_len);
+ if (rx_length <= SDIO_HEADER_LEN) {
+ pr_warn("invalid packet length: %d\n", buf_len);
+ ret = -EINVAL;
+ goto exit;
+ }
+ /* Allocate buffer */
+ /* rx_length = num_blocks * blksz + BTSDIO_DMA_ALIGN*/
+ skb = bt_skb_alloc(rx_length, GFP_ATOMIC);
+ if (skb == NULL) {
+ pr_warn("No free skb\n");
+ ret = -ENOMEM;
+ goto exit;
+ }
- BTMTK_DBG("buf_len : %d", buf_len);
- if (rx_length <= SDIO_HEADER_LEN) {
- BTMTK_WARN("invalid packet length: %d", buf_len);
- ret = -EINVAL;
- goto exit;
- }
+ payload = rxbuf;
+ pr_debug("%s rx_length %d,buf_len %d\n", __func__, rx_length, buf_len);
- /* Allocate buffer */
- skb = bt_skb_alloc(rx_length/*num_blocks * blksz + BTSDIO_DMA_ALIGN*/, GFP_ATOMIC);
- if (skb == NULL) {
- BTMTK_WARN("No free skb");
- ret = -ENOMEM;
- goto exit;
- }
+ memcpy(skb->data, &rxbuf[MTK_SDIO_PACKET_HEADER_SIZE+1], buf_len);
- payload = rxbuf;
- BTMTK_DBG("%s rx_length %d,buf_len %d", __func__, rx_length, buf_len);
+ switch (type) {
+ case HCI_ACLDATA_PKT:
+ pr_debug("%s data[2] 0x%02x, data[3] 0x%02x\n",
+ __func__, skb->data[2], skb->data[3]);
+ buf_len = skb->data[2] + skb->data[3]*256 + 4;
+ pr_debug("%s acl buf_len %d\n", __func__, buf_len);
+ break;
+ case HCI_SCODATA_PKT:
+ buf_len = skb->data[3] + 3;
+ break;
+ case HCI_EVENT_PKT:
+ buf_len = skb->data[1] + 2;
+ break;
+ }
- memcpy(skb->data, &rxbuf[MTK_SDIO_PACKET_HEADER_SIZE+1], buf_len);
+ lock_unsleepable_lock(&(metabuffer.spin_lock));
+ if (priv->adapter->fops_mode &
+ (!fw_is_doing_coredump) &
+ (!fw_is_coredump_end_packet)) {
+ fops_skb = bt_skb_alloc(buf_len, GFP_ATOMIC);
+ bt_cb(fops_skb)->pkt_type = type;
+ memcpy(fops_skb->data, skb->data, buf_len);
+ fops_skb->len = buf_len;
+ skb_queue_tail(&g_priv->adapter->fops_queue, fops_skb);
+ pr_debug("%s push fops_queue\n", __func__);
+ if (skb_queue_empty(&g_priv->adapter->fops_queue))
+ pr_info("%s fops_queue is empty\n", __func__);
- switch (type) {
- case HCI_ACLDATA_PKT:
- BTMTK_DBG("%s data[2] 0x%02x, data[3] 0x%02x\n", __func__, skb->data[2], skb->data[3]);
- buf_len = skb->data[2] + skb->data[3]*256 + 4;
- BTMTK_DBG("%s acl buf_len %d\n", __func__, buf_len);
- break;
- case HCI_SCODATA_PKT:
- buf_len = skb->data[3] + 3;
- break;
- case HCI_EVENT_PKT:
- buf_len = skb->data[1] + 2;
- break;
- }
+ kfree_skb(skb);
+ unlock_unsleepable_lock(&(metabuffer.spin_lock));
+ pr_debug("%s call inq wake up\n", __func__);
+ wake_up_interruptible(&inq);
+ goto exit;
+ }
+ unlock_unsleepable_lock(&(metabuffer.spin_lock));
- lock_unsleepable_lock(&(metabuffer.spin_lock));
- if (priv->adapter->fops_mode & (!fw_is_doing_coredump) & (!fw_is_coredump_end_packet)) {
- fops_skb = bt_skb_alloc(buf_len, GFP_ATOMIC);
- bt_cb(fops_skb)->pkt_type = type;
- memcpy(fops_skb->data, skb->data, buf_len);
- fops_skb->len = buf_len;
- skb_queue_tail(&g_priv->adapter->fops_queue, fops_skb);
- BTMTK_DBG("%s push fops_queue\n", __func__);
- if (skb_queue_empty(&g_priv->adapter->fops_queue))
- BTMTK_INFO("%s fops_queue is empty\n", __func__);
+ switch (type) {
+ case HCI_ACLDATA_PKT:
+ case HCI_SCODATA_PKT:
+ case HCI_EVENT_PKT:
+ bt_cb(skb)->pkt_type = type;
+ skb_put(skb, buf_len);
+ break;
- kfree_skb(skb);
- unlock_unsleepable_lock(&(metabuffer.spin_lock));
- BTMTK_DBG("%s call inq wake up\n", __func__);
- wake_up_interruptible(&inq);
- goto exit;
- }
- unlock_unsleepable_lock(&(metabuffer.spin_lock));
+ case MTK_VENDOR_PKT:
+ pr_warn("%s, MTK_VENDOR_PKT no handle now, break\n", __func__);
+ kfree_skb(skb);
+ break;
- switch (type) {
- case HCI_ACLDATA_PKT:
- case HCI_SCODATA_PKT:
- case HCI_EVENT_PKT:
- bt_cb(skb)->pkt_type = type;
-
- skb_put(skb, buf_len);
-
- break;
-
- case MTK_VENDOR_PKT:
- BTMTK_WARN("%s, MTK_VENDOR_PKT no handle now, break\n", __func__);
- kfree_skb(skb);
- break;
-
- bt_cb(skb)->pkt_type = HCI_VENDOR_PKT;
- skb_put(skb, buf_len);
- skb_pull(skb, SDIO_HEADER_LEN);
-
+ bt_cb(skb)->pkt_type = HCI_VENDOR_PKT;
+ skb_put(skb, buf_len);
+ skb_pull(skb, SDIO_HEADER_LEN);
/*
* if kernel < 3, 11, 0, should use hci_recv_frame(skb);
*/
- break;
+ break;
- default:
- BTMTK_WARN("Unknown packet type:%d", type);
- BTMTK_WARN("hex: %*ph", blksz * num_blocks, payload);
+ default:
+ pr_warn("Unknown packet type:%d\n", type);
+ pr_warn("hex: %*ph\n", blksz * num_blocks, payload);
- kfree_skb(skb);
- skb = NULL;
- break;
- }
+ kfree_skb(skb);
+ skb = NULL;
+ break;
+ }
exit:
- if (ret) {
- BTMTK_DBG("%s fail free skb\n", __func__);
- kfree_skb(skb);
- }
+ if (ret) {
+ pr_debug("%s fail free skb\n", __func__);
+ kfree_skb(skb);
+ }
- buf_len += 1;
- if (buf_len%4)
- fourbalignment_len = buf_len + 4 - buf_len%4;
- else
- fourbalignment_len = buf_len;
+ buf_len += 1;
+ if (buf_len%4)
+ fourbalignment_len = buf_len + 4 - buf_len%4;
+ else
+ fourbalignment_len = buf_len;
- rx_length -= fourbalignment_len;
+ rx_length -= fourbalignment_len;
- if (rx_length > (MTK_SDIO_PACKET_HEADER_SIZE)) {
- memcpy(&rxbuf[MTK_SDIO_PACKET_HEADER_SIZE],
- &rxbuf[MTK_SDIO_PACKET_HEADER_SIZE+fourbalignment_len],
- rx_length-MTK_SDIO_PACKET_HEADER_SIZE);
- }
+ if (rx_length > (MTK_SDIO_PACKET_HEADER_SIZE)) {
+ memcpy(&rxbuf[MTK_SDIO_PACKET_HEADER_SIZE],
+ &rxbuf[MTK_SDIO_PACKET_HEADER_SIZE+fourbalignment_len],
+ rx_length-MTK_SDIO_PACKET_HEADER_SIZE);
+ }
- BTMTK_DBG("%s ret %d, rx_length, %d,fourbalignment_len %d <--\n", __func__, ret, rx_length, fourbalignment_len);
+ pr_debug("%s ret %d, rx_length, %d,fourbalignment_len %d <--\n", __func__, ret, rx_length, fourbalignment_len);
- return ret;
+ return ret;
}
-static int btmtk_sdio_process_int_status(struct btmtk_private *priv)
+static int btmtk_sdio_process_int_status(
+ struct btmtk_private *priv)
{
- int ret = 0;
- u32 u32rxdatacount = 0;
- u32 u32ReadCRValue = 0;
+ int ret = 0;
+ u32 u32rxdatacount = 0;
+ u32 u32ReadCRValue = 0;
- ret = btmtk_sdio_readl(CHISR, &u32ReadCRValue);
- BTMTK_DBG("%s check TX_EMPTY CHISR 0x%08x\n", __func__, u32ReadCRValue);
- if (TX_EMPTY&u32ReadCRValue) {
- ret = btmtk_sdio_writel(CHISR, (TX_EMPTY | TX_COMPLETE_COUNT));
- priv->btmtk_dev.tx_dnld_rdy = true;
- BTMTK_DBG("%s set tx_dnld_rdy 1\n", __func__);
- }
+ ret = btmtk_sdio_readl(CHISR, &u32ReadCRValue);
+ pr_debug("%s check TX_EMPTY CHISR 0x%08x\n", __func__, u32ReadCRValue);
+ if (TX_EMPTY&u32ReadCRValue) {
+ ret = btmtk_sdio_writel(CHISR, (TX_EMPTY | TX_COMPLETE_COUNT));
+ priv->btmtk_dev.tx_dnld_rdy = true;
+ pr_debug("%s set tx_dnld_rdy 1\n", __func__);
+ }
- if (RX_DONE&u32ReadCRValue)
- ret = btmtk_sdio_recv_rx_data();
+ if (RX_DONE&u32ReadCRValue)
+ ret = btmtk_sdio_recv_rx_data();
+ if (ret == 0)
+ while (rx_length > (MTK_SDIO_PACKET_HEADER_SIZE)) {
+ btmtk_sdio_card_to_host(priv);
+ u32rxdatacount++;
+ pr_debug("%s u32rxdatacount %d\n",
+ __func__, u32rxdatacount);
+ }
- if (ret == 0)
- while (rx_length > (MTK_SDIO_PACKET_HEADER_SIZE)) {
- btmtk_sdio_card_to_host(priv);
- u32rxdatacount++;
- BTMTK_DBG("%s u32rxdatacount %d\n", __func__, u32rxdatacount);
- }
+ btmtk_sdio_enable_interrupt(1);
- btmtk_sdio_enable_interrupt(1);
-
- return 0;
+ return 0;
}
-
static void btmtk_sdio_interrupt(struct sdio_func *func)
{
- struct btmtk_private *priv;
- struct btmtk_sdio_card *card;
+ struct btmtk_private *priv;
+ struct btmtk_sdio_card *card;
+
+ card = sdio_get_drvdata(func);
+
+ if (!card)
+ return;
- card = sdio_get_drvdata(func);
+ if (!card->priv)
+ return;
- if (!card)
- return;
+ priv = card->priv;
+ btmtk_sdio_enable_interrupt(0);
-
- if (!card->priv)
- return;
-
- priv = card->priv;
- btmtk_sdio_enable_interrupt(0);
-
-
- btmtk_interrupt(priv);
-
- return;
+ btmtk_interrupt(priv);
}
static int btmtk_sdio_register_dev(struct btmtk_sdio_card *card)
{
- struct sdio_func *func;
- u32 u32ReadCRValue = 0;
- u8 reg;
- int ret = 0;
+ struct sdio_func *func;
+ u32 u32ReadCRValue = 0;
+ u8 reg;
+ int ret = 0;
- if (!card || !card->func) {
- BTMTK_ERR("Error: card or function is NULL!");
- ret = -EINVAL;
- goto failed;
- }
+ if (!card || !card->func) {
+ pr_err("Error: card or function is NULL!\n");
+ ret = -EINVAL;
+ goto failed;
+ }
- func = card->func;
+ func = card->func;
- sdio_claim_host(func);
+ sdio_claim_host(func);
- ret = sdio_enable_func(func);
- if (ret) {
- BTMTK_ERR("sdio_enable_func() failed: ret=%d", ret);
- ret = -EIO;
- goto release_host;
- }
+ ret = sdio_enable_func(func);
+ if (ret) {
+ pr_err("sdio_enable_func() failed: ret=%d\n", ret);
+ ret = -EIO;
+ goto release_host;
+ }
+ btmtk_sdio_readb(SDIO_CCCR_IENx, &u32ReadCRValue);
+ pr_info("before claim irq read SDIO_CCCR_IENx %x, func num %d\n",
+ u32ReadCRValue, func->num);
- btmtk_sdio_readb(SDIO_CCCR_IENx, &u32ReadCRValue);
- BTMTK_INFO("before claim irq read SDIO_CCCR_IENx %x, func num %d\n", u32ReadCRValue, func->num);
+ ret = sdio_claim_irq(func, btmtk_sdio_interrupt);
+ if (ret) {
+ pr_err("sdio_claim_irq failed: ret=%d\n", ret);
+ ret = -EIO;
+ goto disable_func;
+ }
+ pr_info("sdio_claim_irq success: ret=%d\n", ret);
+ btmtk_sdio_readb(SDIO_CCCR_IENx, &u32ReadCRValue);
+ pr_info("after claim irq read SDIO_CCCR_IENx %x\n", u32ReadCRValue);
- ret = sdio_claim_irq(func, btmtk_sdio_interrupt);
- if (ret) {
- BTMTK_ERR("sdio_claim_irq failed: ret=%d", ret);
- ret = -EIO;
- goto disable_func;
- }
- BTMTK_INFO("sdio_claim_irq success: ret=%d", ret);
+ ret = sdio_set_block_size(card->func, SDIO_BLOCK_SIZE);
+ if (ret) {
+ pr_err("cannot set SDIO block size\n");
+ ret = -EIO;
+ goto release_irq;
+ }
- btmtk_sdio_readb(SDIO_CCCR_IENx, &u32ReadCRValue);
- BTMTK_INFO("after claim irq read SDIO_CCCR_IENx %x\n", u32ReadCRValue);
+ reg = sdio_readb(func, card->reg->io_port_0, &ret);
+ if (ret < 0) {
+ ret = -EIO;
+ goto release_irq;
+ }
- ret = sdio_set_block_size(card->func, SDIO_BLOCK_SIZE);
- if (ret) {
- BTMTK_ERR("cannot set SDIO block size");
- ret = -EIO;
- goto release_irq;
- }
+ card->ioport = reg;
- reg = sdio_readb(func, card->reg->io_port_0, &ret);
- if (ret < 0) {
- ret = -EIO;
- goto release_irq;
- }
+ reg = sdio_readb(func, card->reg->io_port_1, &ret);
+ if (ret < 0) {
+ ret = -EIO;
+ goto release_irq;
+ }
- card->ioport = reg;
+ card->ioport |= (reg << 8);
- reg = sdio_readb(func, card->reg->io_port_1, &ret);
- if (ret < 0) {
- ret = -EIO;
- goto release_irq;
- }
+ reg = sdio_readb(func, card->reg->io_port_2, &ret);
+ if (ret < 0) {
+ ret = -EIO;
+ goto release_irq;
+ }
- card->ioport |= (reg << 8);
+ card->ioport |= (reg << 16);
- reg = sdio_readb(func, card->reg->io_port_2, &ret);
- if (ret < 0) {
- ret = -EIO;
- goto release_irq;
- }
+ pr_info("SDIO FUNC%d IO port: 0x%x\n", func->num, card->ioport);
- card->ioport |= (reg << 16);
+ if (card->reg->int_read_to_clear) {
+ reg = sdio_readb(func, card->reg->host_int_rsr, &ret);
+ if (ret < 0) {
+ ret = -EIO;
+ goto release_irq;
+ }
+ sdio_writeb(func, reg | 0x3f, card->reg->host_int_rsr, &ret);
+ if (ret < 0) {
+ ret = -EIO;
+ goto release_irq;
+ }
- BTMTK_INFO("SDIO FUNC%d IO port: 0x%x", func->num, card->ioport);
+ reg = sdio_readb(func, card->reg->card_misc_cfg, &ret);
+ if (ret < 0) {
+ ret = -EIO;
+ goto release_irq;
+ }
+ sdio_writeb(func, reg | 0x10, card->reg->card_misc_cfg, &ret);
+ if (ret < 0) {
+ ret = -EIO;
+ goto release_irq;
+ }
+ }
- if (card->reg->int_read_to_clear) {
- reg = sdio_readb(func, card->reg->host_int_rsr, &ret);
- if (ret < 0) {
- ret = -EIO;
- goto release_irq;
- }
- sdio_writeb(func, reg | 0x3f, card->reg->host_int_rsr, &ret);
- if (ret < 0) {
- ret = -EIO;
- goto release_irq;
- }
+ sdio_set_drvdata(func, card);
- reg = sdio_readb(func, card->reg->card_misc_cfg, &ret);
- if (ret < 0) {
- ret = -EIO;
- goto release_irq;
- }
- sdio_writeb(func, reg | 0x10, card->reg->card_misc_cfg, &ret);
- if (ret < 0) {
- ret = -EIO;
- goto release_irq;
- }
- }
+ sdio_release_host(func);
- sdio_set_drvdata(func, card);
-
- sdio_release_host(func);
-
- return 0;
+ return 0;
release_irq:
- sdio_release_irq(func);
+ sdio_release_irq(func);
disable_func:
- sdio_disable_func(func);
+ sdio_disable_func(func);
release_host:
- sdio_release_host(func);
+ sdio_release_host(func);
failed:
- BTMTK_INFO("%s fail\n", __func__);
- return ret;
+ pr_info("%s fail\n", __func__);
+ return ret;
}
static int btmtk_sdio_unregister_dev(struct btmtk_sdio_card *card)
{
- if (card && card->func) {
- sdio_claim_host(card->func);
- sdio_release_irq(card->func);
- sdio_disable_func(card->func);
- sdio_release_host(card->func);
- sdio_set_drvdata(card->func, NULL);
- }
+ if (card && card->func) {
+ sdio_claim_host(card->func);
+ sdio_release_irq(card->func);
+ sdio_disable_func(card->func);
+ sdio_release_host(card->func);
+ sdio_set_drvdata(card->func, NULL);
+ }
- return 0;
+ return 0;
}
static int btmtk_sdio_enable_host_int(struct btmtk_sdio_card *card)
{
- int ret;
- u32 read_data = 0;
+ int ret;
+ u32 read_data = 0;
- if (!card || !card->func)
- return -EINVAL;
+ if (!card || !card->func)
+ return -EINVAL;
- sdio_claim_host(card->func);
+ sdio_claim_host(card->func);
- ret = btmtk_sdio_enable_host_int_mask(card, HIM_ENABLE);
+ ret = btmtk_sdio_enable_host_int_mask(card, HIM_ENABLE);
- btmtk_sdio_get_rx_unit(card);
+ btmtk_sdio_get_rx_unit(card);
-if (0) {
- typedef int (*fp_sdio_hook)(struct mmc_host *host, unsigned int width);
- fp_sdio_hook func_sdio_hook = (fp_sdio_hook) kallsyms_lookup_name("mmc_set_bus_width");
- unsigned char data = 0;
+ if (0) {
+ typedef int (*fp_sdio_hook)(struct mmc_host *host,
+ unsigned int width);
+ fp_sdio_hook func_sdio_hook =
+ (fp_sdio_hook)kallsyms_lookup_name("mmc_set_bus_width");
+ unsigned char data = 0;
- data = sdio_f0_readb(card->func, SDIO_CCCR_IF, &ret);
- if (ret)
- BTMTK_INFO("%s sdio_f0_readb ret %d\n", __func__, ret);
+ data = sdio_f0_readb(card->func, SDIO_CCCR_IF, &ret);
+ if (ret)
+ pr_info("%s sdio_f0_readb ret %d\n", __func__, ret);
- BTMTK_INFO("%s sdio_f0_readb data 0x%X!\n", __func__, data);
+ pr_info("%s sdio_f0_readb data 0x%X!\n", __func__, data);
- data &= ~SDIO_BUS_WIDTH_MASK;
- data |= SDIO_BUS_ASYNC_INT;
- card->func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
+ data &= ~SDIO_BUS_WIDTH_MASK;
+ data |= SDIO_BUS_ASYNC_INT;
+ card->func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
- sdio_f0_writeb(card->func, data, SDIO_CCCR_IF, &ret);
- if (ret)
- BTMTK_INFO("%s sdio_f0_writeb ret %d\n", __func__, ret);
+ sdio_f0_writeb(card->func, data, SDIO_CCCR_IF, &ret);
+ if (ret)
+ pr_info("%s sdio_f0_writeb ret %d\n", __func__, ret);
- BTMTK_INFO("%s func_sdio_hook at 0x%p!\n", __func__, func_sdio_hook);
- if (func_sdio_hook)
- func_sdio_hook(card->func->card->host, MMC_BUS_WIDTH_1);
+ pr_info("%s func_sdio_hook at 0x%p!\n",
+ __func__, func_sdio_hook);
+ if (func_sdio_hook)
+ func_sdio_hook(card->func->card->host, MMC_BUS_WIDTH_1);
+ data = sdio_f0_readb(card->func, SDIO_CCCR_IF, &ret);
+ if (ret)
+ pr_info("%s sdio_f0_readb 2 ret %d\n",
+ __func__, ret);
- data = sdio_f0_readb(card->func, SDIO_CCCR_IF, &ret);
- if (ret)
- BTMTK_INFO("%s sdio_f0_readb 2 ret %d\n", __func__, ret);
+ pr_info("%s sdio_f0_readb2 data 0x%X\n", __func__, data);
+ }
-
- BTMTK_INFO("%s sdio_f0_readb2 data 0x%X\n", __func__, data);
-}
-
- sdio_release_host(card->func);
-
+ sdio_release_host(card->func);
/*
-* workaround for some platfrom no host clock sometimes
+* workaround for some platform no host clock sometimes
*/
- btmtk_sdio_readl(CSDIOCSR, &read_data);
- BTMTK_INFO("%s read CSDIOCSR is 0x%X\n", __func__, read_data);
- read_data |= 0x4;
- btmtk_sdio_writel(CSDIOCSR, read_data);
- BTMTK_INFO("%s write CSDIOCSR is 0x%X\n", __func__, read_data);
+ btmtk_sdio_readl(CSDIOCSR, &read_data);
+ pr_info("%s read CSDIOCSR is 0x%X\n", __func__, read_data);
+ read_data |= 0x4;
+ btmtk_sdio_writel(CSDIOCSR, read_data);
+ pr_info("%s write CSDIOCSR is 0x%X\n", __func__, read_data);
-
-
- return ret;
+ return ret;
}
static int btmtk_sdio_disable_host_int(struct btmtk_sdio_card *card)
{
- int ret;
+ int ret;
- if (!card || !card->func)
- return -EINVAL;
+ if (!card || !card->func)
+ return -EINVAL;
- sdio_claim_host(card->func);
+ sdio_claim_host(card->func);
- ret = btmtk_sdio_disable_host_int_mask(card, HIM_DISABLE);
+ ret = btmtk_sdio_disable_host_int_mask(card, HIM_DISABLE);
- sdio_release_host(card->func);
+ sdio_release_host(card->func);
- return ret;
+ return ret;
}
static int btmtk_sdio_host_to_card(struct btmtk_private *priv,
- u8 *payload, u16 nb)
+ u8 *payload, u16 nb)
{
- struct btmtk_sdio_card *card = priv->btmtk_dev.card;
- int ret = 0;
- int i = 0;
- u8 MultiBluckCount = 0;
- u8 redundant = 0;
- if (payload != txbuf){
- memset(txbuf,0,MTK_TXDATA_SIZE);
- memcpy(txbuf,payload,nb);
- }
+ struct btmtk_sdio_card *card = priv->btmtk_dev.card;
+ int ret = 0;
+ int i = 0;
+ u8 MultiBluckCount = 0;
+ u8 redundant = 0;
+ if (payload != txbuf) {
+ memset(txbuf, 0, MTK_TXDATA_SIZE);
+ memcpy(txbuf, payload, nb);
+ }
- if (!card || !card->func) {
- BTMTK_ERR("card or function is NULL!");
- return -EINVAL;
- }
+ if (!card || !card->func) {
+ pr_err("card or function is NULL!\n");
+ return -EINVAL;
+ }
- MultiBluckCount = nb/SDIO_BLOCK_SIZE;
- redundant = nb % SDIO_BLOCK_SIZE;
+ MultiBluckCount = nb/SDIO_BLOCK_SIZE;
+ redundant = nb % SDIO_BLOCK_SIZE;
- if (redundant)
- nb = (MultiBluckCount+1)*SDIO_BLOCK_SIZE;
+ if (redundant)
+ nb = (MultiBluckCount+1)*SDIO_BLOCK_SIZE;
+ if (nb < 16)
+ btmtk_print_buffer_conent(txbuf, nb);
+ else
+ btmtk_print_buffer_conent(txbuf, 16);
-
+ do {
+ /* Transfer data to card */
+ sdio_claim_host(card->func);
+ ret = sdio_writesb(card->func, CTDR, txbuf, nb);
+ sdio_release_host(card->func);
+ if (ret < 0) {
+ i++;
+ pr_err("i=%d writesb failed: %d\n", i, ret);
+ pr_err("hex: %*ph\n", nb, txbuf);
+ ret = -EIO;
+ if (i > MAX_WRITE_IOMEM_RETRY)
+ goto exit;
+ }
+ } while (ret);
- if (nb < 16)
- btmtk_print_buffer_conent(txbuf, nb);
- else
- btmtk_print_buffer_conent(txbuf, 16);
+ if (priv)
+ priv->btmtk_dev.tx_dnld_rdy = false;
- do {
- /* Transfer data to card */
- sdio_claim_host(card->func);
- ret = sdio_writesb(card->func, CTDR, txbuf,
- nb);
- sdio_release_host(card->func);
- if (ret < 0) {
- i++;
- BTMTK_ERR("i=%d writesb failed: %d", i, ret);
- BTMTK_ERR("hex: %*ph", nb, txbuf);
- ret = -EIO;
- if (i > MAX_WRITE_IOMEM_RETRY)
- goto exit;
- }
- } while (ret);
+exit:
+ return ret;
+}
- if (priv)
- priv->btmtk_dev.tx_dnld_rdy = false;
+static int btmtk_sdio_download_fw(struct btmtk_sdio_card *card)
+{
+ int ret;
- exit:
-
+ pr_info("%s begin\n", __func__);
+ if (!card || !card->func) {
+ pr_err("card or function is NULL!\n");
+ return -EINVAL;
+ }
+ sdio_claim_host(card->func);
- return ret;
- }
+ if (btmtk_sdio_download_rom_patch(card)) {
+ pr_err("Failed to download firmware!\n");
+ ret = -EIO;
+ goto done;
+ }
- static int btmtk_sdio_download_fw(struct btmtk_sdio_card *card)
- {
- int ret;
+ /*
+ * winner or not, with this test the FW synchronizes
+ * when the
+ * module can continue its initialization
+ */
+ sdio_release_host(card->func);
- BTMTK_INFO("%s begin", __func__);
- if (!card || !card->func) {
- BTMTK_ERR("card or function is NULL!");
- return -EINVAL;
- }
+ return 0;
+done:
+ sdio_release_host(card->func);
+ return ret;
+}
+static int btmtk_sdio_probe(struct sdio_func *func,
+ const struct sdio_device_id *id)
+{
+ int ret = 0;
+ struct btmtk_private *priv = NULL;
+ struct btmtk_sdio_card *card = NULL;
+ struct btmtk_sdio_device *data = (void *) id->driver_data;
+ u32 u32ReadCRValue = 0;
+ probe_counter++;
+ pr_info("%s Mediatek Bluetooth driver Version=%s\n",
+ __func__, VERSION);
+ pr_info("vendor=0x%x, device=0x%x, class=%d, fn=%d, support func_num %d\n",
+ id->vendor, id->device, id->class,
+ func->num, data->reg->func_num);
- sdio_claim_host(card->func);
+ if (func->num != data->reg->func_num) {
+ pr_info("func num is not match\n");
+ return -ENODEV;
+ }
- if (btmtk_sdio_download_rom_patch(card)) {
- BTMTK_ERR("Failed to download firmware!");
- ret = -EIO;
- goto done;
- }
+ card = devm_kzalloc(&func->dev, sizeof(*card), GFP_KERNEL);
+ if (!card)
+ return -ENOMEM;
- /*
- * winner or not, with this test the FW synchronizes when the
- * module can continue its initialization
- */
- sdio_release_host(card->func);
+ card->func = func;
+ g_card = card;
- return 0;
+ if (id->driver_data) {
+ card->helper = data->helper;
+ card->firmware = data->firmware;
+ card->firmware1 = data->firmware1;
+ card->reg = data->reg;
+ card->sd_blksz_fw_dl = data->sd_blksz_fw_dl;
+ card->support_pscan_win_report = data->support_pscan_win_report;
+ card->supports_fw_dump = data->supports_fw_dump;
+ }
- done:
- sdio_release_host(card->func);
- return ret;
- }
+ pr_info("%s func device %X\n", __func__, card->func->device);
+ pr_info("%s Call btmtk_sdio_register_dev\n", __func__);
+ if (btmtk_sdio_register_dev(card) < 0) {
+ pr_err("Failed to register BT device!\n");
+ return -ENODEV;
+ }
- static int btmtk_sdio_probe(struct sdio_func *func,
- const struct sdio_device_id *id)
- {
- int ret = 0;
- struct btmtk_private *priv = NULL;
- struct btmtk_sdio_card *card = NULL;
- struct btmtk_sdio_device *data = (void *) id->driver_data;
- u32 u32ReadCRValue = 0;
+ pr_info("%s btmtk_sdio_register_dev success\n", __func__);
- probe_counter++;
- BTMTK_INFO("%s Mediatek Bluetooth driver Version=%s", __func__, VERSION);
- BTMTK_INFO("vendor=0x%x, device=0x%x, class=%d, fn=%d, support func_num %d",
- id->vendor, id->device, id->class, func->num, data->reg->func_num);
+ /* Disable the interrupts on the card */
+ btmtk_sdio_enable_host_int(card);
+ pr_info("call btmtk_sdio_enable_host_int done\n");
+ if (btmtk_sdio_download_fw(card)) {
+ pr_err("Downloading firmware failed!\n");
+ ret = -ENODEV;
+ goto unreg_dev;
+ }
- if (func->num != data->reg->func_num) {
- BTMTK_INFO("func num is not match");
- return -ENODEV;
- }
+ /* Move from btmtk_fops_open() */
+ spin_lock_init(&(metabuffer.spin_lock.lock));
+ pr_info("%s spin_lock_init end\n", __func__);
+ priv = btmtk_add_card(card);
+ if (!priv) {
+ pr_err("Initializing card failed!\n");
+ ret = -ENODEV;
+ goto unreg_dev;
+ }
+ pr_info("btmtk_add_card success\n");
+ card->priv = priv;
+ pr_info("assign priv done\n");
+ /* Initialize the interface specific function pointers */
+ priv->hw_host_to_card = btmtk_sdio_host_to_card;
+ priv->hw_process_int_status = btmtk_sdio_process_int_status;
+ priv->hw_set_own_back = btmtk_sdio_set_own_back;
- card = devm_kzalloc(&func->dev, sizeof(*card), GFP_KERNEL);
- if (!card)
- return -ENOMEM;
+ g_priv = priv;
+ if (!fw_dump_ptr)
+ fw_dump_ptr = kmalloc(FW_DUMP_BUF_SIZE, GFP_ATOMIC);
- card->func = func;
- g_card = card;
+ if (!fw_dump_ptr) {
+ ret = -ENODEV;
+ return ret;
+ }
- if (id->driver_data) {
+ memset(&metabuffer.buffer, 0, META_BUFFER_SIZE);
+ memset(fw_dump_ptr, 0, FW_DUMP_BUF_SIZE);
- card->helper = data->helper;
- card->firmware = data->firmware;
- card->firmware1 = data->firmware1;
- card->reg = data->reg;
- card->sd_blksz_fw_dl = data->sd_blksz_fw_dl;
- card->support_pscan_win_report = data->support_pscan_win_report;
- card->supports_fw_dump = data->supports_fw_dump;
- }
-
- BTMTK_INFO("%s func device %X\n", __func__, card->func->device);
- BTMTK_INFO("%s Call btmtk_sdio_register_dev\n", __func__);
- if (btmtk_sdio_register_dev(card) < 0) {
- BTMTK_ERR("Failed to register BT device!");
- return -ENODEV;
- } else
- BTMTK_INFO("%s btmtk_sdio_register_dev success\n", __func__);
-
-
- /* Disable the interrupts on the card */
- btmtk_sdio_enable_host_int(card);
- BTMTK_INFO("call btmtk_sdio_enable_host_int done");
- if (btmtk_sdio_download_fw(card)) {
- BTMTK_ERR("Downloading firmware failed!");
- ret = -ENODEV;
- goto unreg_dev;
- }
-
-
-
-
-
- priv = btmtk_add_card(card);
- if (!priv) {
- BTMTK_ERR("Initializing card failed!");
- ret = -ENODEV;
- goto unreg_dev;
- }
- BTMTK_INFO("btmtk_add_card success");
- card->priv = priv;
- BTMTK_INFO("assign priv done");
- /* Initialize the interface specific function pointers */
- priv->hw_host_to_card = btmtk_sdio_host_to_card;
- priv->hw_process_int_status = btmtk_sdio_process_int_status;
- priv->hw_set_own_back = btmtk_sdio_set_own_back;
-
- g_priv = priv;
- if (fw_dump_ptr == NULL)
- fw_dump_ptr = kmalloc(FW_DUMP_BUF_SIZE, GFP_ATOMIC);
-
-
- if (fw_dump_ptr == NULL) {
- BTMTK_ERR("%s : alloc fw_dump_ptr fail\n", __func__);
- ret = -ENODEV;
- return ret;
- }
-
- memset(&metabuffer.buffer, 0, META_BUFFER_SIZE);
- memset(fw_dump_ptr, 0, FW_DUMP_BUF_SIZE);
- fw_dump_task_should_stop = 0;
+ fw_dump_task_should_stop = 0;
#if SAVE_FW_DUMP_IN_KERNEL
- fw_dump_file = NULL;
+ fw_dump_file = NULL;
#endif
- fw_dump_read_ptr = fw_dump_ptr;
- fw_dump_write_ptr = fw_dump_ptr;
- fw_dump_total_read_size = 0;
- fw_dump_total_write_size = 0;
- fw_dump_buffer_used_size = 0;
- fw_dump_buffer_full = 0;
+ fw_dump_read_ptr = fw_dump_ptr;
+ fw_dump_write_ptr = fw_dump_ptr;
+ fw_dump_total_read_size = 0;
+ fw_dump_total_write_size = 0;
+ fw_dump_buffer_used_size = 0;
+ fw_dump_buffer_full = 0;
- ret = btmtk_sdio_readl(CHLPCR, &u32ReadCRValue);
- BTMTK_INFO("%s read CHLPCR (0x%08X)\n", __func__, u32ReadCRValue);
- BTMTK_INFO("%s normal end\n", __func__);
- probe_ready = true;
- return 0;
+ ret = btmtk_sdio_readl(CHLPCR, &u32ReadCRValue);
+ pr_info("%s read CHLPCR (0x%08X)\n", __func__, u32ReadCRValue);
+ pr_info("%s normal end\n", __func__);
+ probe_ready = true;
+ return 0;
- unreg_dev:
- btmtk_sdio_unregister_dev(card);
+unreg_dev:
+ btmtk_sdio_unregister_dev(card);
- BTMTK_ERR("%s fail end\n", __func__);
- return ret;
- }
+ pr_err("%s fail end\n", __func__);
+ return ret;
+}
- static void btmtk_sdio_remove(struct sdio_func *func)
- {
- struct btmtk_sdio_card *card;
+static void btmtk_sdio_remove(struct sdio_func *func)
+{
+ struct btmtk_sdio_card *card;
- BTMTK_INFO("%s begin user_rmmod %d\n", __func__,user_rmmod);
- probe_ready = false;
+ pr_info("%s begin user_rmmod %d\n", __func__, user_rmmod);
+ probe_ready = false;
- if (func) {
- card = sdio_get_drvdata(func);
- if (card) {
- /* Send SHUTDOWN command & disable interrupt
- * if user removes the module.
- */
- if (user_rmmod) {
- BTMTK_INFO("%s begin user_rmmod %d in user mode\n", __func__,user_rmmod);
- btmtk_sdio_set_own_back(DRIVER_OWN);
- btmtk_sdio_enable_interrupt(0);
- btmtk_sdio_bt_set_power(0);
- btmtk_sdio_set_own_back(FW_OWN);
+ if (func) {
+ card = sdio_get_drvdata(func);
+ if (card) {
+ /* Send SHUTDOWN command & disable interrupt
+ * if user removes the module.
+ */
+ if (user_rmmod) {
+ pr_info("%s begin user_rmmod %d in user mode\n",
+ __func__, user_rmmod);
+ btmtk_sdio_set_own_back(DRIVER_OWN);
+ btmtk_sdio_enable_interrupt(0);
+ btmtk_sdio_bt_set_power(0);
+ btmtk_sdio_set_own_back(FW_OWN);
- btmtk_sdio_disable_host_int(card);
- }
- BTMTK_DBG("unregester dev");
- card->priv->surprise_removed = true;
- btmtk_sdio_unregister_dev(card);
- btmtk_remove_card(card->priv);
-
-
-
- }
- }
- BTMTK_INFO("%s end\n", __func__);
- }
-
+ btmtk_sdio_disable_host_int(card);
+ }
+ pr_debug("unregester dev\n");
+ card->priv->surprise_removed = true;
+ btmtk_sdio_unregister_dev(card);
+ btmtk_remove_card(card->priv);
+ }
+ }
+ pr_info("%s end\n", __func__);
+}
/*
cmd_type:
-#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_COMMAND_PKT 0x01
+#define HCI_ACLDATA_PKT 0x02
+#define HCI_SCODATA_PKT 0x03
+#define HCI_EVENT_PKT 0x04
+#define HCI_VENDOR_PKT 0xff
*/
- static int btmtk_sdio_send_cmd(u8 cmd_type,u8* cmd,int cmd_len)
- {
- u8 ret = 0;
- u32 sdio_header_len = 0;
- u8 *send_data = NULL;
- u32 send_data_len = cmd_len + BTM_HEADER_LEN;
- if(cmd_len==0){
- BTMTK_ERR("%s cmd_len (%d) error return\n", __func__,cmd_len);
- return -EINVAL;
- }
+static int btmtk_sdio_send_cmd(u8 cmd_type, u8 *cmd, int cmd_len)
+{
+ u8 ret = 0;
+ u32 sdio_header_len = 0;
+ u8 *send_data = NULL;
+ u32 send_data_len = cmd_len + BTM_HEADER_LEN;
- send_data = kmalloc(send_data_len, GFP_KERNEL);
- sdio_header_len = send_data_len;
- memset(send_data, 0, send_data_len);
- send_data[0] = (sdio_header_len & 0x0000ff);
- send_data[1] = (sdio_header_len & 0x00ff00) >> 8;
- send_data[2] = 0;
- send_data[3] = 0;
- send_data[4] = cmd_type ;
- memcpy(&send_data[BTM_HEADER_LEN], &cmd[0], cmd_len);
+ if (cmd_len == 0) {
+ pr_err("%s cmd_len (%d) error return\n", __func__, cmd_len);
+ return -EINVAL;
+ }
- ret = btmtk_sdio_host_to_card(g_priv, send_data, send_data_len);
- kfree(send_data);
- return ret;
- }
- static int btmtk_sdio_send_woble_cmd(void)
- {
- u8 ret = 0;
- u8 cmd[] = { 0xC9, 0xFC, 0x0D, 0x01, 0x0E, 0x00, 0x05, 0x43,
- 0x52, 0x4B, 0x54, 0x4D, 0x20, 0x04, 0x32, 0x00 };
+ send_data = kmalloc(send_data_len, GFP_KERNEL);
+ sdio_header_len = send_data_len;
+ memset(send_data, 0, send_data_len);
+ send_data[0] = (sdio_header_len & 0x0000ff);
+ send_data[1] = (sdio_header_len & 0x00ff00) >> 8;
+ send_data[2] = 0;
+ send_data[3] = 0;
+ send_data[4] = cmd_type;
+ memcpy(&send_data[BTM_HEADER_LEN], &cmd[0], cmd_len);
+ ret = btmtk_sdio_host_to_card(g_priv, send_data, send_data_len);
+ kfree(send_data);
+ return ret;
+}
+static int btmtk_sdio_send_woble_cmd(void)
+{
+ u8 ret = 0;
+ u8 cmd[] = { 0xC9, 0xFC, 0x0D, 0x01, 0x0E, 0x00, 0x05, 0x43,
+ 0x52, 0x4B, 0x54, 0x4D, 0x20, 0x04, 0x32, 0x00};
- ret = btmtk_sdio_send_cmd(HCI_COMMAND_PKT,cmd,sizeof(cmd));
- BTMTK_INFO("%s return %d\n", __func__,ret);
- return ret;
- }
+ ret = btmtk_sdio_send_cmd(HCI_COMMAND_PKT, cmd, sizeof(cmd));
+ pr_info("%s return %d\n", __func__, ret);
+ return ret;
+}
- static int btmtk_sdio_suspend(struct device *dev)
- {
- struct sdio_func *func = dev_to_sdio_func(dev);
- u8 ret = 0;
- mmc_pm_flag_t pm_flags;
- ret = btmtk_sdio_set_own_back(DRIVER_OWN);
- if(ret)
- BTMTK_ERR("%s set driver own fail",__func__);
+static int btmtk_sdio_suspend(struct device *dev)
+{
+ struct sdio_func *func = dev_to_sdio_func(dev);
+ u8 ret = 0;
+ mmc_pm_flag_t pm_flags;
- ret = btmtk_sdio_send_woble_cmd();
- if(ret)
- BTMTK_ERR("%s set woble cmd fail",__func__);
+ ret = btmtk_sdio_set_own_back(DRIVER_OWN);
+ if (ret)
+ pr_err("%s set driver own fail\n", __func__);
+ ret = btmtk_sdio_send_woble_cmd();
+ if (ret)
+ pr_err("%s set woble cmd fail\n", __func__);
- need_reset_stack = 1;
- BTMTK_ERR("%s set reset_stack 1\n", __func__);
- if (func) {
- pm_flags = sdio_get_host_pm_caps(func);
- BTMTK_DBG("%s: suspend: PM flags = 0x%x", sdio_func_id(func),
- pm_flags);
- if (!(pm_flags & MMC_PM_KEEP_POWER)) {
- BTMTK_ERR("%s: cannot remain alive while suspended",
- sdio_func_id(func));
- return -EINVAL;
- }
- } else {
- BTMTK_ERR("sdio_func is not specified");
- return 0;
- }
- ret = btmtk_sdio_set_own_back(FW_OWN);
- if(ret)
- BTMTK_ERR("%s set fw own fail",__func__);
- return sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
- }
+ need_reset_stack = 1;
+ pr_err("%s set reset_stack 1\n", __func__);
+ if (func) {
+ pm_flags = sdio_get_host_pm_caps(func);
+ pr_debug("%s: suspend: PM flags = 0x%x\n",
+ sdio_func_id(func), pm_flags);
+ if (!(pm_flags & MMC_PM_KEEP_POWER)) {
+ pr_err("%s: cannot remain alive while suspended\n",
+ sdio_func_id(func));
+ return -EINVAL;
+ }
+ } else {
+ pr_err("sdio_func is not specified\n");
+ return 0;
+ }
+ ret = btmtk_sdio_set_own_back(FW_OWN);
+ if (ret)
+ pr_err("%s set fw own fail\n", __func__);
+ return sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
+}
- static int btmtk_sdio_resume(struct device *dev)
- {
- BTMTK_INFO("%s begin return 0, do nothing", __func__);
- return 0;
- }
+static int btmtk_sdio_resume(struct device *dev)
+{
+ pr_info("%s begin return 0, do nothing\n", __func__);
+ return 0;
+}
- static const struct dev_pm_ops btmtk_sdio_pm_ops = {
- .suspend = btmtk_sdio_suspend,
- .resume = btmtk_sdio_resume,
- };
+static const struct dev_pm_ops btmtk_sdio_pm_ops = {
+ .suspend = btmtk_sdio_suspend,
+ .resume = btmtk_sdio_resume,
+};
- static struct sdio_driver bt_mtk_sdio = {
- .name = "btmtk_sdio",
- .id_table = btmtk_sdio_ids,
- .probe = btmtk_sdio_probe,
- .remove = btmtk_sdio_remove,
- .drv = {
- .owner = THIS_MODULE,
- .pm = &btmtk_sdio_pm_ops,
- }
- };
+static struct sdio_driver bt_mtk_sdio = {
+ .name = "btmtk_sdio",
+ .id_table = btmtk_sdio_ids,
+ .probe = btmtk_sdio_probe,
+ .remove = btmtk_sdio_remove,
+ .drv = {
+ .owner = THIS_MODULE,
+ .pm = &btmtk_sdio_pm_ops,
+ }
+};
static int btmtk_fops_open(struct inode *inode, struct file *file)
{
- BTMTK_INFO("%s begin", __func__);
+ pr_info("%s begin\n", __func__);
- if (!probe_ready) {
- BTMTK_ERR("%s probe_ready is %d return", __func__,probe_ready);
- return -EFAULT;
- }
+ if (!probe_ready) {
+ pr_err("%s probe_ready is %d return\n", __func__, probe_ready);
+ return -EFAULT;
+ }
- spin_lock_init(&(metabuffer.spin_lock.lock));
- BTMTK_INFO("%s spin_lock_init end", __func__);
- if (g_priv == NULL) {
- BTMTK_ERR("%s g_priv is NULL", __func__);
- return -ENOENT;
- }
+#if 0 /* Move to btmtk_sdio_probe() */
+ spin_lock_init(&(metabuffer.spin_lock.lock));
+ pr_info("%s spin_lock_init end\n", __func__);
+#endif
+ if (g_priv == NULL) {
+ pr_err("%s g_priv is NULL\n", __func__);
+ return -ENOENT;
+ }
- if (g_priv->adapter == NULL) {
- BTMTK_ERR("%s g_priv->adapter is NULL", __func__);
- return -ENOENT;
- }
+ if (g_priv->adapter == NULL) {
+ pr_err("%s g_priv->adapter is NULL\n", __func__);
+ return -ENOENT;
+ }
- if (g_priv)
- g_priv->adapter->fops_mode = true;
+ if (g_priv)
+ g_priv->adapter->fops_mode = true;
- BTMTK_INFO("%s fops_mode=%d end", __func__, g_priv->adapter->fops_mode);
- return 0;
+ pr_info("%s fops_mode=%d end\n", __func__, g_priv->adapter->fops_mode);
+ return 0;
}
static int btmtk_fops_close(struct inode *inode, struct file *file)
{
- struct sk_buff *skb = NULL;
+ struct sk_buff *skb = NULL;
- BTMTK_INFO("%s begin", __func__);
+ pr_info("%s begin\n", __func__);
- if (!probe_ready) {
- BTMTK_ERR("%s probe_ready is %d return", __func__,probe_ready);
- return -EFAULT;
- }
+ if (!probe_ready) {
+ pr_err("%s probe_ready is %d return\n", __func__, probe_ready);
+ return -EFAULT;
+ }
- spin_lock_init(&(metabuffer.spin_lock.lock));
- if (g_priv)
- g_priv->adapter->fops_mode = false;
+ spin_lock_init(&(metabuffer.spin_lock.lock));
+ if (g_priv)
+ g_priv->adapter->fops_mode = false;
- lock_unsleepable_lock(&(metabuffer.spin_lock));
+ lock_unsleepable_lock(&(metabuffer.spin_lock));
+ if (!skb_queue_empty(&g_priv->adapter->fops_queue)) {
+ pr_info("%s clean data in fops_queue\n", __func__);
+ do {
+ skb = skb_dequeue(&g_priv->adapter->fops_queue);
+ if (skb == NULL) {
+ pr_info("%s skb=NULL error break\n", __func__);
+ break;
+ }
- if (!skb_queue_empty(&g_priv->adapter->fops_queue)) {
- BTMTK_INFO("%s clean data in fops_queue", __func__);
- do {
- skb = skb_dequeue(&g_priv->adapter->fops_queue);
- if (skb == NULL) {
- BTMTK_INFO("%s skb=NULL error break", __func__);
- break;
- }
+ kfree_skb(skb);
+ } while (!skb_queue_empty(&g_priv->adapter->fops_queue));
+ }
+ unlock_unsleepable_lock(&(metabuffer.spin_lock));
- kfree_skb(skb);
- } while (!skb_queue_empty(&g_priv->adapter->fops_queue));
-
- }
-
-
- unlock_unsleepable_lock(&(metabuffer.spin_lock));
-
- BTMTK_INFO("%s fops_mode=%d end", __func__, g_priv->adapter->fops_mode);
- return 0;
+ pr_info("%s fops_mode=%d end\n", __func__, g_priv->adapter->fops_mode);
+ return 0;
}
-ssize_t btmtk_fops_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
+ssize_t btmtk_fops_write(struct file *filp, const char __user *buf,
+ size_t count, loff_t *f_pos)
{
- int retval = 0;
- struct sk_buff *skb = NULL;
- u32 crAddr = 0, crValue = 0, crMask = 0;
- /*int i = 0;*/
+ int retval = 0;
+ struct sk_buff *skb = NULL;
+ u32 crAddr = 0, crValue = 0, crMask = 0;
+ /*int i = 0;*/
- if (!probe_ready) {
- BTMTK_ERR("%s probe_ready is %d return", __func__,probe_ready);
- return -EFAULT;
- }
+ if (!probe_ready) {
+ pr_err("%s probe_ready is %d return\n", __func__, probe_ready);
+ return -EFAULT;
+ }
- if (g_priv == NULL) {
- BTMTK_INFO("%s g_priv is NULL", __func__);
- return -EFAULT;
- }
+ if (g_priv == NULL) {
+ pr_info("%s g_priv is NULL\n", __func__);
+ return -EFAULT;
+ }
- if (g_priv->adapter->fops_mode == 0) {
- BTMTK_INFO("%s fops_mode is 0", __func__);
- return -EFAULT;
- }
+ if (g_priv->adapter->fops_mode == 0) {
+ pr_info("%s fops_mode is 0\n", __func__);
+ return -EFAULT;
+ }
-
- /*BTMTK_INFO("%s : (%d) %02X %02X %02X %02X %02X %02X %02X %02X\n", __func__, (int)count,
+ /*pr_info("%s : (%d) %02X %02X %02X %02X "
+ %"02X %02X %02X %02X\n",
+ __func__, (int)count,
buf[0],
buf[1],
buf[2],
@@ -2154,231 +2198,255 @@
buf[6],
buf[7]);*/
- /*
- BTMTK_INFO("%s print write data", __func__);
- if (count > 10)
- BTMTK_INFO(" %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7],buf[8],buf[9]);
- else {
- for(i=0;i<count;i++)
- BTMTK_INFO("%d %02X",i,buf[i]);
- }*/
+ /*
+ pr_info("%s print write data", __func__);
+ if (count > 10)
+ pr_info(" %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
+ buf[0],buf[1],buf[2],buf[3],buf[4],
+ buf[5],buf[6],buf[7],buf[8],buf[9]);
+ else {
+ for(i=0;i<count;i++)
+ pr_info("%d %02X",i,buf[i]);
+ }*/
- if (buf[0] == 0x7) {
-/*
-* write CR
-*/
- if (count < 15) {
- BTMTK_INFO("%s count=%zd less than 15, error", __func__, count);
- return -EFAULT;
- }
+ if (buf[0] == 0x7) {
+ /*
+ * write CR
+ */
+ if (count < 15) {
+ pr_info("%s count=%zd less than 15, error\n",
+ __func__, count);
+ return -EFAULT;
+ }
- crAddr = (buf[3]&0xff) + ((buf[4]&0xff)<<8) + ((buf[5]&0xff)<<16) + ((buf[6]&0xff)<<24);
- crValue = (buf[7]&0xff) + ((buf[8]&0xff)<<8) + ((buf[9]&0xff)<<16) + ((buf[10]&0xff)<<24);
- crMask = (buf[11]&0xff) + ((buf[12]&0xff)<<8) + ((buf[13]&0xff)<<16) + ((buf[14]&0xff)<<24);
+ crAddr = (buf[3]&0xff) + ((buf[4]&0xff)<<8)
+ + ((buf[5]&0xff)<<16) + ((buf[6]&0xff)<<24);
+ crValue = (buf[7]&0xff) + ((buf[8]&0xff)<<8)
+ + ((buf[9]&0xff)<<16) + ((buf[10]&0xff)<<24);
+ crMask = (buf[11]&0xff) + ((buf[12]&0xff)<<8)
+ + ((buf[13]&0xff)<<16) + ((buf[14]&0xff)<<24);
- BTMTK_INFO("%s crAddr=0x%08x crValue=0x%08x crMask=0x%08x", __func__, crAddr, crValue, crMask);
- crValue &= crMask;
+ pr_info("%s crAddr=0x%08x crValue=0x%08x crMask=0x%08x\n",
+ __func__, crAddr, crValue, crMask);
+ crValue &= crMask;
+ pr_info("%s write crAddr=0x%08x crValue=0x%08x\n", __func__,
+ crAddr, crValue);
+ btmtk_sdio_writel(crAddr, crValue);
+ retval = count;
+ } else if (buf[0] == 0x8) {
+ /*
+ * read CR
+ */
+ if (count < 16) {
+ pr_info("%s count=%zd less than 15, error\n",
+ __func__, count);
+ return -EFAULT;
+ }
- BTMTK_INFO("%s write crAddr=0x%08x crValue=0x%08x", __func__, crAddr, crValue);
- btmtk_sdio_writel(crAddr, crValue);
- retval = count;
- } else if (buf[0] == 0x8) {
-/*
-* read CR
-*/
- if (count < 16) {
- BTMTK_INFO("%s count=%zd less than 15, error", __func__, count);
- return -EFAULT;
- }
+ crAddr = (buf[3]&0xff) + ((buf[4]&0xff)<<8) +
+ ((buf[5]&0xff)<<16) + ((buf[6]&0xff)<<24);
+ crMask = (buf[11]&0xff) + ((buf[12]&0xff)<<8) +
+ ((buf[13]&0xff)<<16) + ((buf[14]&0xff)<<24);
- crAddr = (buf[3]&0xff) + ((buf[4]&0xff)<<8) + ((buf[5]&0xff)<<16) + ((buf[6]&0xff)<<24);
- crMask = (buf[11]&0xff) + ((buf[12]&0xff)<<8) + ((buf[13]&0xff)<<16) + ((buf[14]&0xff)<<24);
+ btmtk_sdio_readl(crAddr, &crValue);
+ pr_info("%s read crAddr=0x%08x crValue=0x%08x crMask=0x%08x\n",
+ __func__, crAddr, crValue, crMask);
+ retval = count;
+ } else {
+ skb = bt_skb_alloc(count-1, GFP_ATOMIC);
+ bt_cb(skb)->pkt_type = buf[0];
+ memcpy(&skb->data[0], &buf[1], count-1);
+ skb->len = count-1;
+ skb_queue_tail(&g_priv->adapter->tx_queue, skb);
+ wake_up_interruptible(&g_priv->main_thread.wait_q);
- btmtk_sdio_readl(crAddr, &crValue);
- BTMTK_INFO("%s read crAddr=0x%08x crValue=0x%08x crMask=0x%08x", __func__, crAddr, crValue, crMask);
- retval = count;
- } else {
-
- skb = bt_skb_alloc(count-1, GFP_ATOMIC);
- bt_cb(skb)->pkt_type = buf[0];
- memcpy(&skb->data[0], &buf[1], count-1);
- skb->len = count-1;
- skb_queue_tail(&g_priv->adapter->tx_queue, skb);
- wake_up_interruptible(&g_priv->main_thread.wait_q);
-
- retval = count;
- }
- BTMTK_DBG("%s end", __func__);
- return retval;
+ retval = count;
+ }
+ pr_debug("%s end\n", __func__);
+ return retval;
}
-ssize_t btmtk_fops_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
+ssize_t btmtk_fops_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *f_pos)
{
- int copyLen = 0;
- struct sk_buff *skb = NULL;
- unsigned long ret = 0;
+ int copyLen = 0;
+ struct sk_buff *skb = NULL;
+ unsigned long ret = 0;
- if (!probe_ready) {
- BTMTK_ERR("%s probe_ready is %d return", __func__,probe_ready);
- return -EFAULT;
- }
+ if (!probe_ready) {
+ pr_err("%s probe_ready is %d return\n", __func__, probe_ready);
+ return -EFAULT;
+ }
- if (g_priv == NULL) {
- BTMTK_INFO("%s g_priv is NULL", __func__);
- return -EFAULT;
- }
+ if (g_priv == NULL) {
+ pr_info("%s g_priv is NULL\n", __func__);
+ return -EFAULT;
+ }
- if (g_priv->adapter->fops_mode == 0) {
- BTMTK_INFO("%s fops_mode is 0", __func__);
- return -EFAULT;
- }
+ if (g_priv->adapter->fops_mode == 0) {
+ pr_info("%s fops_mode is 0\n", __func__);
+ return -EFAULT;
+ }
- lock_unsleepable_lock(&(metabuffer.spin_lock));
+ lock_unsleepable_lock(&(metabuffer.spin_lock));
+ if (skb_queue_empty(&g_priv->adapter->fops_queue)) {
+ if (filp->f_flags & O_NONBLOCK) {
+ unlock_unsleepable_lock(&(metabuffer.spin_lock));
+ return 0;
+ }
+ }
- if (skb_queue_empty(&g_priv->adapter->fops_queue)) {
- if (filp->f_flags & O_NONBLOCK) {
- unlock_unsleepable_lock(&(metabuffer.spin_lock));
- return 0;
- }
- }
+ if (need_reset_stack == 1) {
+ kill_fasync(&fasync, SIGIO, POLL_IN);
+ need_reset_stack = 0;
+ pr_info("%s Call kill_fasync and set reset_stack 0\n",
+ __func__);
+ return -ENODEV;
+ }
- if (need_reset_stack == 1){
- kill_fasync(&fasync, SIGIO, POLL_IN);
- need_reset_stack = 0;
- BTMTK_INFO("%s Call kill_fasync and set reset_stack 0", __func__);
- return -ENODEV;
- }
+ do {
+ skb = skb_dequeue(&g_priv->adapter->fops_queue);
+ if (skb == NULL) {
+ pr_info("%s skb=NULL error break\n", __func__);
+ break;
+ }
+ /* pr_debug("%s pkt_type %d metabuffer.buffer %d",
+ __func__, bt_cb(skb)->pkt_type,
+ metabuffer.buffer[copyLen]); */
+ btmtk_print_buffer_conent(skb->data, skb->len);
- do {
- skb = skb_dequeue(&g_priv->adapter->fops_queue);
- if (skb == NULL) {
- BTMTK_INFO("%s skb=NULL error break", __func__);
- break;
- }
- //BTMTK_DBG("%s pkt_type %d metabuffer.buffer %d", __func__, bt_cb(skb)->pkt_type, metabuffer.buffer[copyLen]);
- btmtk_print_buffer_conent(skb->data, skb->len);
+ if (((copyLen + 1 + skb->len) > META_BUFFER_SIZE) ||
+ ((copyLen + 1 + skb->len) > count)) {
+ pr_err("%s copy copyLen %d > META_BUFFER_SIZE(%d), push back to queue\n",
+ __func__,
+ (copyLen + 1 + skb->len),
+ META_BUFFER_SIZE);
+ skb_queue_head(&g_priv->adapter->fops_queue,
+ skb);
+ break;
+ }
- if (((copyLen + 1 + skb->len) > META_BUFFER_SIZE) || ((copyLen + 1 + skb->len) > count)) {
- BTMTK_ERR("%s copy copyLen %d > META_BUFFER_SIZE(%d), push back to queue", __func__,
- (copyLen + 1 + skb->len), META_BUFFER_SIZE);
- skb_queue_head(&g_priv->adapter->fops_queue, skb);
- break;
- }
+ metabuffer.buffer[copyLen] = bt_cb(skb)->pkt_type;
+ copyLen++;
- metabuffer.buffer[copyLen] = bt_cb(skb)->pkt_type;
- copyLen++;
+ memcpy(&metabuffer.buffer[copyLen], skb->data, skb->len);
+ copyLen += skb->len;
- memcpy(&metabuffer.buffer[copyLen], skb->data, skb->len);
- copyLen += skb->len;
+ kfree_skb(skb);
+ } while (!skb_queue_empty(&g_priv->adapter->fops_queue));
+ unlock_unsleepable_lock(&(metabuffer.spin_lock));
- kfree_skb(skb);
+ ret = copy_to_user(buf, metabuffer.buffer, copyLen);
+ if (ret) {
+ pr_err("%s copy to user fail, ret %d\n", __func__, (int)ret);
+ copyLen = (copyLen - ret);
+ } /* else {
+ pr_info("%s : (%d) %02X %02X %02X %02X "
+ "%02X %02X %02X %02X\n",
+ __func__, copyLen,
+ metabuffer.buffer[0],
+ metabuffer.buffer[1],
+ metabuffer.buffer[2],
+ metabuffer.buffer[3],
+ metabuffer.buffer[4],
+ metabuffer.buffer[5],
+ metabuffer.buffer[6],
+ metabuffer.buffer[7]);
+ }*/
- } while (!skb_queue_empty(&g_priv->adapter->fops_queue));
- unlock_unsleepable_lock(&(metabuffer.spin_lock));
-
-
- ret = copy_to_user(buf, metabuffer.buffer, copyLen);
- if (ret) {
- BTMTK_ERR("%s copy to user fail, ret %d", __func__, (int)ret);
- copyLen = (copyLen - ret);
- }/* else {
- BTMTK_INFO("%s : (%d) %02X %02X %02X %02X %02X %02X %02X %02X\n", __func__, copyLen,
- metabuffer.buffer[0],
- metabuffer.buffer[1],
- metabuffer.buffer[2],
- metabuffer.buffer[3],
- metabuffer.buffer[4],
- metabuffer.buffer[5],
- metabuffer.buffer[6],
- metabuffer.buffer[7]);
- }*/
-
- //BTMTK_DBG("%s copyLen %d", __func__, copyLen);
- return copyLen;
+ /* pr_debug("%s copyLen %d", __func__, copyLen);*/
+ return copyLen;
}
static int btmtk_fops_fasync(int fd, struct file *file, int on)
{
- BTMTK_INFO("%s: fd = 0x%X, flag = 0x%X", __func__, fd, on);
+ pr_info("%s: fd = 0x%X, flag = 0x%X\n", __func__, fd, on);
return fasync_helper(fd, file, on, &fasync);
}
unsigned int btmtk_fops_poll(struct file *filp, poll_table *wait)
{
- unsigned int mask = 0;
+ unsigned int mask = 0;
- if (!probe_ready) {
- BTMTK_ERR("%s probe_ready is %d return", __func__,probe_ready);
- return mask;
- }
-
- if (g_priv == NULL) {
- BTMTK_ERR("%s g_priv is NULL", __func__);
- return -ENODEV;
- }
-
- if (skb_queue_empty(&g_priv->adapter->fops_queue)) {
- poll_wait(filp, &inq, wait);
-
- if (!skb_queue_empty(&g_priv->adapter->fops_queue)) {
- mask |= (POLLIN | POLLRDNORM);
- //BTMTK_INFO("%s poll done\n", __func__);
+ if (!probe_ready) {
+ pr_err("%s probe_ready is %d return\n", __func__, probe_ready);
+ return mask;
}
- } else
- mask |= (POLLIN | POLLRDNORM);
- mask |= (POLLOUT | POLLWRNORM);
-
- //BTMTK_INFO("%s poll mask 0x%x\n", __func__,mask);
- return mask;
-}
-
-long btmtk_fops_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
-{
- u32 retval = 0;
-
- return retval;
-}
-
-static int btmtk_fops_openfwlog(struct inode *inode, struct file *file)
-{
if (g_priv == NULL) {
- BTMTK_ERR("%s: ERROR, g_data is NULL!", __func__);
+ pr_err("%s g_priv is NULL\n", __func__);
return -ENODEV;
}
- BTMTK_INFO("%s: OK", __func__);
- return 0;
+ if (skb_queue_empty(&g_priv->adapter->fops_queue)) {
+ poll_wait(filp, &inq, wait);
+
+ if (!skb_queue_empty(&g_priv->adapter->fops_queue)) {
+ mask |= (POLLIN | POLLRDNORM);
+ /* pr_info("%s poll done\n", __func__); */
+ }
+ } else
+ mask |= (POLLIN | POLLRDNORM);
+
+ mask |= (POLLOUT | POLLWRNORM);
+
+ /* pr_info("%s poll mask 0x%x\n", __func__,mask); */
+ return mask;
}
-static int btmtk_fops_closefwlog(struct inode *inode, struct file *file)
+long btmtk_fops_unlocked_ioctl(struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ u32 retval = 0;
+
+ return retval;
+}
+
+static int btmtk_fops_openfwlog(struct inode *inode,
+ struct file *file)
{
if (g_priv == NULL) {
- BTMTK_ERR("%s: ERROR, g_data is NULL!", __func__);
+ pr_err("%s: ERROR, g_data is NULL!\n", __func__);
return -ENODEV;
}
- BTMTK_INFO("%s: OK", __func__);
+ pr_info("%s: OK\n", __func__);
return 0;
}
-static ssize_t btmtk_fops_readfwlog(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
+static int btmtk_fops_closefwlog(struct inode *inode,
+ struct file *file)
+{
+ if (g_priv == NULL) {
+ pr_err("%s: ERROR, g_data is NULL!\n", __func__);
+ return -ENODEV;
+ }
+
+ pr_info("%s: OK\n", __func__);
+ return 0;
+}
+
+static ssize_t btmtk_fops_readfwlog(struct file *filp,
+ char __user *buf,
+ size_t count,
+ loff_t *f_pos)
{
int copyLen = 0;
if (g_priv == NULL) {
- BTMTK_ERR("%s: ERROR, g_data is NULL!", __func__);
+ pr_err("%s: ERROR, g_data is NULL!\n", __func__);
return -ENODEV;
}
- BTMTK_INFO("%s: OK", __func__);
+ pr_info("%s: OK\n", __func__);
return copyLen;
}
-static ssize_t btmtk_fops_writefwlog(struct file *filp, const char __user *buf,
- size_t count, loff_t *f_pos)
+static ssize_t btmtk_fops_writefwlog(
+ struct file *filp, const char __user *buf,
+ size_t count, loff_t *f_pos)
{
struct sk_buff *skb = NULL;
int length = 0, i, j = 0;
@@ -2389,33 +2457,35 @@
memset(i_fwlog_buf, 0, HCI_MAX_COMMAND_BUF_SIZE);
memset(o_fwlog_buf, 0, HCI_MAX_COMMAND_SIZE);
-
if (g_priv == NULL) {
- BTMTK_INFO("%s g_priv is NULL", __func__);
+ pr_info("%s g_priv is NULL\n", __func__);
goto exit;
}
if (count > HCI_MAX_COMMAND_BUF_SIZE) {
- BTMTK_ERR("%s: your command is larger than maximum length, count = %zd\n", __func__, count);
+ pr_err("%s: your command is larger than maximum length, count = %zd\n",
+ __func__, count);
goto exit;
}
for (i = 0; i < count; i++) {
- if (buf[i] != '=' ) {
+ if (buf[i] != '=') {
i_fwlog_buf[i] = buf[i];
- BTMTK_DBG("%s: tag_param %02x", __func__, i_fwlog_buf[i]);
- }
- else {
+ pr_debug("%s: tag_param %02x\n",
+ __func__, i_fwlog_buf[i]);
+ } else {
val_param = &buf[i+1];
if (strcmp(i_fwlog_buf, "log_lvl") == 0) {
- BTMTK_INFO("%s: btmtk_log_lvl = %d", __func__, val_param[0] - 48);
- btmtk_log_lvl = val_param[0] - 48;
+ pr_info("%s: btmtk_log_lvl = %d\n",
+ __func__, val_param[0] - 48);
+ /* btmtk_log_lvl = val_param[0] - 48; */
}
goto exit;
}
}
if (i == count) {
- /* hci input command format : echo 01 be fc 01 05 > /dev/stpbtfwlog */
+ /* hci input command format : */
+ /* echo 01 be fc 01 05 > /dev/stpbtfwlog */
/* We take the data from index three to end. */
val_param = &buf[0];
}
@@ -2426,16 +2496,17 @@
u8 temp_str[3] = { 0 };
long res = 0;
- if (val_param[i] == ' ' || val_param[i] == '\t' || val_param[i] == '\r' || val_param[i] == '\n')
+ if (val_param[i] == ' ' || val_param[i] == '\t'
+ || val_param[i] == '\r' || val_param[i] == '\n')
continue;
if ((val_param[i] == '0' && val_param[i + 1] == 'x')
- || (val_param[0] == '0' && val_param[i + 1] == 'X')) {
+ || (val_param[0] == '0' && val_param[i + 1] == 'X')) {
i++;
continue;
}
if (!(val_param[i] >= '0' && val_param[i] <= '9')
- && !(val_param[i] >= 'A' && val_param[i] <= 'F')
- && !(val_param[i] >= 'a' && val_param[i] <= 'f')) {
+ && !(val_param[i] >= 'A' && val_param[i] <= 'F')
+ && !(val_param[i] >= 'a' && val_param[i] <= 'f')) {
break;
}
temp_str[0] = *(val_param+i);
@@ -2446,63 +2517,65 @@
}
length = j;
-
-
/* Receive command from stpbtfwlog, then Sent hci command to controller */
- BTMTK_DBG("%s: hci buff is %02x%02x%02x%02x%02x ", __func__, o_fwlog_buf[0]
- , o_fwlog_buf[1], o_fwlog_buf[2], o_fwlog_buf[3], o_fwlog_buf[4]);
+ pr_debug("%s: hci buff is %02x%02x%02x%02x%02x\n",
+ __func__, o_fwlog_buf[0], o_fwlog_buf[1],
+ o_fwlog_buf[2], o_fwlog_buf[3], o_fwlog_buf[4]);
/* check HCI command length */
if (length > HCI_MAX_COMMAND_SIZE) {
- BTMTK_ERR("%s: your command is larger than maximum length, length = %d\n", __func__, length);
+ pr_err("%s: your command is larger than maximum length, length = %d\n",
+ __func__, length);
goto exit;
}
- BTMTK_DBG("%s: hci buff is %02x%02x%02x%02x%02x ", __func__, o_fwlog_buf[0]
- , o_fwlog_buf[1], o_fwlog_buf[2], o_fwlog_buf[3], o_fwlog_buf[4]);
+ pr_debug("%s: hci buff is %02x%02x%02x%02x%02x\n",
+ __func__, o_fwlog_buf[0], o_fwlog_buf[1],
+ o_fwlog_buf[2], o_fwlog_buf[3], o_fwlog_buf[4]);
/* Receive command from stpbtfwlog, then Sent hci command to Stack */
skb = bt_skb_alloc(length - 1, GFP_ATOMIC);
bt_cb(skb)->pkt_type = o_fwlog_buf[0];
- memcpy(&skb->data[0],&o_fwlog_buf[1],length - 1);
+ memcpy(&skb->data[0], &o_fwlog_buf[1], length - 1);
skb->len = length - 1;
skb_queue_tail(&g_priv->adapter->tx_queue, skb);
wake_up_interruptible(&g_priv->main_thread.wait_q);
- BTMTK_INFO("%s write end", __func__);
+ pr_info("%s write end\n", __func__);
exit:
- BTMTK_INFO("%s exit, length = %d", __func__, length);
+ pr_info("%s exit, length = %d\n", __func__, length);
kfree(i_fwlog_buf);
kfree(o_fwlog_buf);
return count;
}
-static unsigned int btmtk_fops_pollfwlog(struct file *file, poll_table *wait)
+static unsigned int btmtk_fops_pollfwlog(
+ struct file *file, poll_table *wait)
{
unsigned int mask = 0;
- if (g_priv== NULL) {
- BTMTK_ERR("%s: ERROR, g_data is NULL!", __func__);
+ if (g_priv == NULL) {
+ pr_err("%s: ERROR, g_data is NULL!\n", __func__);
return -ENODEV;
}
return mask;
}
-static long btmtk_fops_unlocked_ioctlfwlog(struct file *filp, unsigned int cmd,
- unsigned long arg)
+static long btmtk_fops_unlocked_ioctlfwlog(
+ struct file *filp, unsigned int cmd,
+ unsigned long arg)
{
int retval = 0;
- BTMTK_INFO("%s: ->", __func__);
+ pr_info("%s: ->\n", __func__);
if (g_priv == NULL) {
- BTMTK_ERR("%s: ERROR, g_data is NULL!", __func__);
+ pr_err("%s: ERROR, g_data is NULL!\n", __func__);
return -ENODEV;
}
return retval;
}
-
static int BTMTK_major;
static int BT_majorfwlog;
static struct cdev BTMTK_cdev;
@@ -2511,23 +2584,22 @@
static wait_queue_head_t inq;
const struct file_operations BTMTK_fops = {
- .open = btmtk_fops_open,
- .release = btmtk_fops_close,
- .read = btmtk_fops_read,
- .write = btmtk_fops_write,
- .poll = btmtk_fops_poll,
- .unlocked_ioctl = btmtk_fops_unlocked_ioctl,
- .fasync = btmtk_fops_fasync
+ .open = btmtk_fops_open,
+ .release = btmtk_fops_close,
+ .read = btmtk_fops_read,
+ .write = btmtk_fops_write,
+ .poll = btmtk_fops_poll,
+ .unlocked_ioctl = btmtk_fops_unlocked_ioctl,
+ .fasync = btmtk_fops_fasync
};
-
const struct file_operations BT_fopsfwlog = {
- .open = btmtk_fops_openfwlog,
- .release = btmtk_fops_closefwlog,
- .read = btmtk_fops_readfwlog,
- .write = btmtk_fops_writefwlog,
- .poll = btmtk_fops_pollfwlog,
- .unlocked_ioctl = btmtk_fops_unlocked_ioctlfwlog
+ .open = btmtk_fops_openfwlog,
+ .release = btmtk_fops_closefwlog,
+ .read = btmtk_fops_readfwlog,
+ .write = btmtk_fops_writefwlog,
+ .poll = btmtk_fops_pollfwlog,
+ .unlocked_ioctl = btmtk_fops_unlocked_ioctlfwlog
};
@@ -2540,7 +2612,7 @@
int major = 0;
int majorfwlog = 0;
- BTMTK_INFO("BTMTK_init\n");
+ pr_info("BTMTK_init\n");
g_card = NULL;
txbuf = NULL;
@@ -2554,7 +2626,6 @@
#endif
g_priv = NULL;
-
fw_dump_buffer_full = 0;
fw_dump_total_read_size = 0;
fw_dump_total_write_size = 0;
@@ -2570,20 +2641,20 @@
ret = alloc_chrdev_region(&devID, 0, 1, "BT_chrdev");
if (ret) {
- BTMTK_ERR("fail to allocate chrdev\n");
+ pr_err("fail to allocate chrdev\n");
return ret;
}
ret = alloc_chrdev_region(&devIDfwlog, 0, 1, "BT_chrdevfwlog");
if (ret) {
- BTMTK_ERR("fail to allocate chrdev");
+ pr_err("fail to allocate chrdev\n");
return ret;
}
BTMTK_major = major = MAJOR(devID);
- BTMTK_INFO("major number:%d", BTMTK_major);
+ pr_info("major number:%d\n", BTMTK_major);
BT_majorfwlog = majorfwlog = MAJOR(devIDfwlog);
- BTMTK_INFO("BT_majorfwlog number: %d", BT_majorfwlog);
+ pr_info("BT_majorfwlog number: %d\n", BT_majorfwlog);
cdev_init(&BTMTK_cdev, &BTMTK_fops);
BTMTK_cdev.owner = THIS_MODULE;
@@ -2591,39 +2662,46 @@
cdev_init(&BT_cdevfwlog, &BT_fopsfwlog);
BT_cdevfwlog.owner = THIS_MODULE;
- cdevErr = cdev_add(&BTMTK_cdev, devID, BTMTK_devs);
- if (cdevErr)
- goto error;
+ cdevErr = cdev_add(&BTMTK_cdev, devID, BTMTK_devs);
+ if (cdevErr)
+ goto error;
cdevErr = cdev_add(&BT_cdevfwlog, devIDfwlog, 1);
if (cdevErr)
goto error;
- BTMTK_INFO("%s driver(major %d) installed.\n", "BT_chrdev", BTMTK_major);
- BTMTK_INFO("%s driver(major %d) installed.\n", "BT_chrdevfwlog", BT_majorfwlog);
+ pr_info("%s driver(major %d) installed.\n",
+ "BT_chrdev", BTMTK_major);
+ pr_info("%s driver(major %d) installed.\n",
+ "BT_chrdevfwlog", BT_majorfwlog);
pBTClass = class_create(THIS_MODULE, "BT_chrdev");
if (IS_ERR(pBTClass)) {
- BTMTK_ERR("class create fail, error code(%ld)\n", PTR_ERR(pBTClass));
+ pr_err("class create fail, error code(%ld)\n",
+ PTR_ERR(pBTClass));
goto err1;
}
pBTDev = device_create(pBTClass, NULL, devID, NULL, BT_NODE);
if (IS_ERR(pBTDev)) {
- BTMTK_ERR("device create fail, error code(%ld)\n", PTR_ERR(pBTDev));
+ pr_err("device create fail, error code(%ld)\n",
+ PTR_ERR(pBTDev));
goto err2;
}
- pBTDevfwlog = device_create(pBTClass, NULL, devIDfwlog, NULL, "stpbtfwlog");
+ pBTDevfwlog = device_create(pBTClass, NULL,
+ devIDfwlog, NULL, "stpbtfwlog");
if (IS_ERR(pBTDevfwlog)) {
- BTMTK_ERR("device(stpbtfwlog) create fail, error code(%ld)", PTR_ERR(pBTDevfwlog));
+ pr_err("device(stpbtfwlog) create fail, error code(%ld)\n",
+ PTR_ERR(pBTDevfwlog));
goto err2;
}
- BTMTK_INFO("%s: BT_major %d, BT_majorfwlog %d", __func__, BTMTK_major, BT_majorfwlog);
- BTMTK_INFO("%s: devID %d, devIDfwlog %d", __func__, devID, devIDfwlog);
+ pr_info("%s: BT_major %d, BT_majorfwlog %d\n",
+ __func__, BTMTK_major, BT_majorfwlog);
+ pr_info("%s: devID %d, devIDfwlog %d\n", __func__, devID, devIDfwlog);
- // init wait queue
+ /* init wait queue */
g_devIDfwlog = devIDfwlog;
init_waitqueue_head(&(fw_log_inq));
init_waitqueue_head(&(inq));
@@ -2653,10 +2731,10 @@
dev_t dev = MKDEV(BTMTK_major, 0);
dev_t devIDfwlog = g_devIDfwlog;
- BTMTK_INFO("BTMTK_exit\n");
+ pr_info("BTMTK_exit\n");
- if(pBTDevfwlog){
- device_destroy(pBTClass,devIDfwlog);
+ if (pBTDevfwlog) {
+ device_destroy(pBTClass, devIDfwlog);
pBTDevfwlog = NULL;
}
@@ -2672,50 +2750,49 @@
cdev_del(&BTMTK_cdev);
unregister_chrdev_region(dev, 1);
- BTMTK_INFO("%s driver removed.\n", BT_DRIVER_NAME);
+ pr_info("%s driver removed.\n", BT_DRIVER_NAME);
}
- static int __init btmtk_sdio_init_module(void)
+static int __init btmtk_sdio_init_module(void)
{
- BTMTK_init();
+ BTMTK_init();
- if (txbuf == NULL) {
- txbuf = kmalloc(MTK_TXDATA_SIZE, GFP_ATOMIC);
- memset(txbuf, 0, MTK_TXDATA_SIZE);
- }
+ if (txbuf == NULL) {
+ txbuf = kmalloc(MTK_TXDATA_SIZE, GFP_ATOMIC);
+ memset(txbuf, 0, MTK_TXDATA_SIZE);
+ }
- if (rxbuf == NULL) {
- rxbuf = kmalloc(MTK_RXDATA_SIZE, GFP_ATOMIC);
- memset(rxbuf, 0, MTK_RXDATA_SIZE);
- }
+ if (rxbuf == NULL) {
+ rxbuf = kmalloc(MTK_RXDATA_SIZE, GFP_ATOMIC);
+ memset(rxbuf, 0, MTK_RXDATA_SIZE);
+ }
+ if (sdio_register_driver(&bt_mtk_sdio) != 0) {
+ pr_err("SDIO Driver Registration Failed\n");
+ return -ENODEV;
+ }
- if (sdio_register_driver(&bt_mtk_sdio) != 0) {
- BTMTK_ERR("SDIO Driver Registration Failed");
- return -ENODEV;
- } else
- BTMTK_INFO("SDIO Driver Registration Success");
+ pr_info("SDIO Driver Registration Success\n");
- /* Clear the flag in case user removes the card. */
- user_rmmod = 0;
+ /* Clear the flag in case user removes the card. */
+ user_rmmod = 0;
- return 0;
- }
+ return 0;
+}
- static void __exit btmtk_sdio_exit_module(void)
- {
- /* Set the flag as user is removing this module. */
- user_rmmod = 1;
+static void __exit btmtk_sdio_exit_module(void)
+{
+ /* Set the flag as user is removing this module. */
+ user_rmmod = 1;
- BTMTK_exit();
+ BTMTK_exit();
- sdio_unregister_driver(&bt_mtk_sdio);
+ sdio_unregister_driver(&bt_mtk_sdio);
- kfree(txbuf);
+ kfree(txbuf);
- kfree(rxbuf);
+ kfree(rxbuf);
+}
- }
-
- module_init(btmtk_sdio_init_module);
- module_exit(btmtk_sdio_exit_module);
+module_init(btmtk_sdio_init_module);
+module_exit(btmtk_sdio_exit_module);
diff --git a/btmtk_sdio.h b/btmtk_sdio.h
index 0eb02a0..e821518 100644
--- a/btmtk_sdio.h
+++ b/btmtk_sdio.h
@@ -1,15 +1,14 @@
-/**
+/*
* Mediatek BT-over-SDIO driver: SDIO interface related definitions
*
- * Copyright (C) 2015, Mediatek International Ltd.
+ * Copyright (C) 2017, Mediatek International Ltd.
*
* This software file (the "File") is distributed by Mediatek International
* Ltd. under the terms of the GNU General Public License Version 2, June 1991
* (the "License"). You may use, redistribute and/or modify this File in
* accordance with the terms and conditions of the License, a copy of which
* is available by writing to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
- * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ * On the worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
*
*
* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
@@ -17,9 +16,12 @@
* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
* this warranty disclaimer.
*
- **/
+ */
-#define VERSION "v0.0.0.27"
+#ifndef _BTMTK_SDIO_H_
+#define _BTMTK_SDIO_H_
+
+#define VERSION "v0.0.0.28"
#define SDIO_HEADER_LEN 4
@@ -41,12 +43,12 @@
#define MRVDRV_SIZE_OF_CMD_BUFFER (2 * 1024)
#define MRVDRV_BT_RX_PACKET_BUFFER_SIZE \
- (HCI_MAX_FRAME_SIZE + FW_EXTRA_LEN)
+ (HCI_MAX_FRAME_SIZE + FW_EXTRA_LEN)
#define ALLOC_BUF_SIZE (((max_t (int, MRVDRV_BT_RX_PACKET_BUFFER_SIZE, \
- MRVDRV_SIZE_OF_CMD_BUFFER) + SDIO_HEADER_LEN \
- + SDIO_BLOCK_SIZE - 1) / SDIO_BLOCK_SIZE) \
- * SDIO_BLOCK_SIZE)
+ MRVDRV_SIZE_OF_CMD_BUFFER) + SDIO_HEADER_LEN \
+ + SDIO_BLOCK_SIZE - 1) / SDIO_BLOCK_SIZE) \
+ * SDIO_BLOCK_SIZE)
/* The number of times to try when polling for status */
#define MAX_POLL_TRIES 100
@@ -73,82 +75,83 @@
#if CFG_THREE_IN_ONE_FIRMWARE
#define BUILD_SIGN(ch0, ch1, ch2, ch3) \
- ((unsigned int)(unsigned char)(ch0) | ((unsigned int)(unsigned char)(ch1) << 8) | \
- ((unsigned int)(unsigned char)(ch2) << 16) | ((unsigned int)(unsigned char)(ch3) << 24))
+ ((unsigned int)(unsigned char)(ch0) | \
+ ((unsigned int)(unsigned char)(ch1) << 8) | \
+ ((unsigned int)(unsigned char)(ch2) << 16) | \
+ ((unsigned int)(unsigned char)(ch3) << 24))
#define MTK_WIFI_SIGNATURE BUILD_SIGN('M', 'T', 'K', 'W')
#define FW_TYPE_PATCH 2
-typedef struct _FW_SECTION_T {
- unsigned int u4FwType;
- unsigned int u4Offset;
- unsigned int u4Length;
-} FW_SECTION_T, *P_FW_SECTION_T;
+struct _FW_SECTION_T {
+ unsigned int u4FwType;
+ unsigned int u4Offset;
+ unsigned int u4Length;
+};
-typedef struct _FIRMWARE_HEADER_T {
- unsigned int u4Signature;
- unsigned int u4CRC;
- unsigned int u4NumOfEntries;
- unsigned int u4Reserved;
- FW_SECTION_T arSection[];
-} FIRMWARE_HEADER_T, *P_FIRMWARE_HEADER_T;
+struct _FIRMWARE_HEADER_T {
+ unsigned int u4Signature;
+ unsigned int u4CRC;
+ unsigned int u4NumOfEntries;
+ unsigned int u4Reserved;
+ struct _FW_SECTION_T arSection[];
+};
#endif
struct btmtk_sdio_card_reg {
- u8 cfg;
- u8 host_int_mask;
- u8 host_intstatus;
- u8 card_status;
- u8 sq_read_base_addr_a0;
- u8 sq_read_base_addr_a1;
- u8 card_revision;
- u8 card_fw_status0;
- u8 card_fw_status1;
- u8 card_rx_len;
- u8 card_rx_unit;
- u8 io_port_0;
- u8 io_port_1;
- u8 io_port_2;
- bool int_read_to_clear;
- u8 host_int_rsr;
- u8 card_misc_cfg;
- u8 fw_dump_ctrl;
- u8 fw_dump_start;
- u8 fw_dump_end;
- u8 func_num;
+ u8 cfg;
+ u8 host_int_mask;
+ u8 host_intstatus;
+ u8 card_status;
+ u8 sq_read_base_addr_a0;
+ u8 sq_read_base_addr_a1;
+ u8 card_revision;
+ u8 card_fw_status0;
+ u8 card_fw_status1;
+ u8 card_rx_len;
+ u8 card_rx_unit;
+ u8 io_port_0;
+ u8 io_port_1;
+ u8 io_port_2;
+ bool int_read_to_clear;
+ u8 host_int_rsr;
+ u8 card_misc_cfg;
+ u8 fw_dump_ctrl;
+ u8 fw_dump_start;
+ u8 fw_dump_end;
+ u8 func_num;
};
struct btmtk_sdio_card {
- struct sdio_func *func;
- u32 ioport;
- const char *helper;
- const char *firmware;
- const char *firmware1;
- const struct btmtk_sdio_card_reg *reg;
- bool support_pscan_win_report;
- bool supports_fw_dump;
- u16 sd_blksz_fw_dl;
- u8 rx_unit;
- struct btmtk_private *priv;
+ struct sdio_func *func;
+ u32 ioport;
+ const char *helper;
+ const char *firmware;
+ const char *firmware1;
+ const struct btmtk_sdio_card_reg *reg;
+ bool support_pscan_win_report;
+ bool supports_fw_dump;
+ u16 sd_blksz_fw_dl;
+ u8 rx_unit;
+ struct btmtk_private *priv;
};
-
struct btmtk_sdio_device {
- const char *helper;
- const char *firmware;
- const char *firmware1;
- const struct btmtk_sdio_card_reg *reg;
- const bool support_pscan_win_report;
- u16 sd_blksz_fw_dl;
- bool supports_fw_dump;
+ const char *helper;
+ const char *firmware;
+ const char *firmware1;
+ const struct btmtk_sdio_card_reg *reg;
+ const bool support_pscan_win_report;
+ u16 sd_blksz_fw_dl;
+ bool supports_fw_dump;
};
#pragma pack(1)
-typedef struct _PATCH_HEADER {
- u8 ucDateTime[16];
- u8 ucPlatform[4];
- u16 u2HwVer;
- u16 u2SwVer;
- u32 u4PatchVer;
- u16 u2PatchStartAddr;/*Patch ram start address*/
-} PATCH_HEADER, *P_PATCH_HEADER;
+struct _PATCH_HEADER {
+ u8 ucDateTime[16];
+ u8 ucPlatform[4];
+ u16 u2HwVer;
+ u16 u2SwVer;
+ u32 u4PatchVer;
+ u16 u2PatchStartAddr;/*Patch ram start address*/
+};
#pragma pack()
#define HW_VERSION 0x80000000
@@ -225,16 +228,20 @@
/* Macros for Data Alignment : size */
#define ALIGN_SZ(p, a) \
- (((p) + ((a) - 1)) & ~((a) - 1))
+ (((p) + ((a) - 1)) & ~((a) - 1))
/* Macros for Data Alignment : address */
#define ALIGN_ADDR(p, a) \
- ((((unsigned long)(p)) + (((unsigned long)(a)) - 1)) & \
- ~(((unsigned long)(a)) - 1))
+ ((((unsigned long)(p)) + (((unsigned long)(a)) - 1)) & \
+ ~(((unsigned long)(a)) - 1))
struct sk_buff *btmtk_create_send_data(struct sk_buff *skb);
int btmtk_print_buffer_conent(u8 *buf, u32 Datalen);
-u32 lock_unsleepable_lock(P_OSAL_UNSLEEPABLE_LOCK pUSL);
-u32 unlock_unsleepable_lock(P_OSAL_UNSLEEPABLE_LOCK pUSL);
+u32 lock_unsleepable_lock(struct _OSAL_UNSLEEPABLE_LOCK_ *pUSL);
+u32 unlock_unsleepable_lock(struct _OSAL_UNSLEEPABLE_LOCK_ *pUSL);
extern unsigned char probe_counter;
extern unsigned char *txbuf;
+extern u8 probe_ready;
+
+#endif
+
