diff --git a/btmtk_config.h b/btmtk_config.h
index 00a9266..51081fa 100644
--- a/btmtk_config.h
+++ b/btmtk_config.h
@@ -63,5 +63,11 @@
 #define SUPPORT_LEGACY_WOBLE 0
 #define BT_RC_VENDOR_DEFAULT 1
 #define BT_RC_VENDOR_S0 0
+#define SUPPORT_EINT 0
+
+#if SUPPORT_EINT
+#define WAIT_POWERKEY_TIMEOUT 5000
+#endif
+
 
 #endif /* __BTMTK_CONFIG_H__ */
diff --git a/btmtk_define.h b/btmtk_define.h
index 3c34a9e..79e3e9a 100644
--- a/btmtk_define.h
+++ b/btmtk_define.h
@@ -117,6 +117,7 @@
 /**
  * Log file path & name, the default path is /sdcard
  */
+#define PRINT_DUMP_COUNT		20
 #define SYSLOG_FNAME			"bt_sys_log"
 #define FWDUMP_FNAME			"bt_fw_dump"
 #ifdef BTMTK_LOG_PATH
@@ -205,5 +206,9 @@
 #define MAX_BIN_FILE_NAME_LEN 32
 
 
+/**
+ *  Firmware version size
+ */
+#define FW_VERSION_BUF_SIZE 15	/* 14 bytes for firmware version + 1 bytes for '0' */
 
 #endif /* __BTMTK_DEFINE_H__ */
diff --git a/btmtk_drv.h b/btmtk_drv.h
index ff47547..e8feb8e 100644
--- a/btmtk_drv.h
+++ b/btmtk_drv.h
@@ -93,6 +93,8 @@
 	u32 int_count;
 	struct sk_buff_head tx_queue;
 	struct sk_buff_head fops_queue;
+	struct sk_buff_head fwlog_fops_queue;
+	struct sk_buff_head fwlog_tx_queue;
 	u8 fops_mode;
 	u8 psmode;
 	u8 ps_state;
diff --git a/btmtk_main.c b/btmtk_main.c
index f805367..a75206f 100644
--- a/btmtk_main.c
+++ b/btmtk_main.c
@@ -67,13 +67,13 @@
 	int ret = 0;
 	u32 sdio_header_len = 0;
 
-	pr_debug("%s skb->len %d\n", __func__, skb->len);
-
 	if (!skb) {
 		pr_warn("%s skb is NULL return -EINVAL\n", __func__);
 		return -EINVAL;
 	}
 
+	pr_debug("%s skb->len %d\n", __func__, skb->len);
+
 	if (!skb->data) {
 		pr_warn("%s skb->data is NULL return -EINVAL\n", __func__);
 		return -EINVAL;
@@ -106,6 +106,7 @@
 
 	skb_queue_head_init(&priv->adapter->tx_queue);
 	skb_queue_head_init(&priv->adapter->fops_queue);
+	skb_queue_head_init(&priv->adapter->fwlog_fops_queue);
 	priv->adapter->ps_state = PS_AWAKE;
 
 	buf_size = ALIGN_SZ(SDIO_BLOCK_SIZE, BTSDIO_DMA_ALIGN);
diff --git a/btmtk_sdio.c b/btmtk_sdio.c
index 3f98a3c..ad3e466 100644
--- a/btmtk_sdio.c
+++ b/btmtk_sdio.c
@@ -32,9 +32,21 @@
 #include <linux/kallsyms.h>
 #include <linux/device.h>
 
+/* Define for proce node */
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+
 #include "btmtk_define.h"
 #include "btmtk_drv.h"
 #include "btmtk_sdio.h"
+
+#if SUPPORT_EINT
+/* Used for WoBLE on EINT */
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_irq.h>
+#endif
+
 #ifdef BT_SUPPORT_PMU_EN_CTRL
 #include "mt7668_wmt.h"
 #endif
@@ -81,7 +93,16 @@
 const u8 READ_ADDRESS_EVENT[] = { 0x0e, 0x0a, 0x01, 0x09, 0x10, 0x00 };
 
 static struct ring_buffer metabuffer;
+static struct ring_buffer fwlog_metabuffer;
 u8 probe_ready;
+/* record firmware version */
+static char fw_version_str[FW_VERSION_BUF_SIZE];
+static struct proc_dir_entry *g_proc_dir;
+
+/** read_write for proc */
+static int btmtk_proc_show(struct seq_file *m, void *v);
+static int btmtk_proc_open(struct inode *inode, struct  file *file);
+static void btmtk_proc_create_new_entry(void);
 
 static char fw_dump_file_name[FW_DUMP_FILE_NAME_SIZE] = {0};
 static char event_need_compare[EVENT_COMPARE_SIZE] = {0};
@@ -89,8 +110,6 @@
 static char event_compare_status;
 /*add special header in the beginning of even, stack won't recognize these event*/
 
-struct _OSAL_UNSLEEPABLE_LOCK_ event_compare_status_lock;
-struct _OSAL_UNSLEEPABLE_LOCK_ tx_function_lock;
 
 
 
@@ -113,6 +132,12 @@
 	static int	fw_dump_file;
 #endif
 
+const struct file_operations BT_proc_fops = {
+	.open = btmtk_proc_open,
+	.read = seq_read,
+	.release = single_release,
+};
+
 static const struct btmtk_sdio_card_reg btmtk_reg_6630 = {
 	.cfg = 0x03,
 	.host_int_mask = 0x04,
@@ -234,12 +259,10 @@
 unsigned char *txbuf;
 static unsigned char *rxbuf;
 static unsigned char *userbuf;
+static unsigned char *userbuf_fwlog;
 static u32 rx_length;
 static struct btmtk_sdio_card *g_card;
 
-/*
- * add in include/linux/mmc/sdio_ids.h
- */
 #define SDIO_VENDOR_ID_MEDIATEK 0x037A
 
 static const struct sdio_device_id btmtk_sdio_ids[] = {
@@ -1417,8 +1440,6 @@
 	u8 MultiBluckCount = 0;
 	u8 redundant = 0;
 
-	//lock_unsleepable_lock(&tx_function_lock);
-
 	if (payload != txbuf) {
 		memset(txbuf, 0, MTK_TXDATA_SIZE);
 		memcpy(txbuf, payload, nb);
@@ -1426,7 +1447,6 @@
 
 	if (!card || !card->func) {
 		pr_err("card or function is NULL!\n");
-		//unlock_unsleepable_lock(&tx_function_lock);
 		return -EINVAL;
 	}
 
@@ -1461,7 +1481,6 @@
 
 exit:
 
-	//unlock_unsleepable_lock(&tx_function_lock);
 	return ret;
 }
 
@@ -1676,6 +1695,8 @@
 {
 	u32 ret = 0;
 	u32 push_in_data_len = 0;
+	u32 MultiBluckCount = 0;
+	u32 redundant = 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};
@@ -1707,9 +1728,15 @@
 
 	memcpy(mtk_tx_data+push_in_data_len, data, len);
 	push_in_data_len += len;
+	memcpy(txbuf, mtk_tx_data, push_in_data_len);
+
+	MultiBluckCount = push_in_data_len/4;
+	redundant = push_in_data_len % 4;
+	if (redundant)
+		push_in_data_len = (MultiBluckCount+1)*4;
 
 	sdio_claim_host(g_card->func);
-	ret = sdio_writesb(g_card->func, CTDR, mtk_tx_data, push_in_data_len);
+	ret = sdio_writesb(g_card->func, CTDR, txbuf, push_in_data_len);
 	sdio_release_host(g_card->func);
 
 	pr_info("%s retrun  0x%0x\n", __func__, ret);
@@ -1850,6 +1877,39 @@
 
 	pr_debug("%s patch_status %d\n", __func__, patch_status);
 
+	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;
+		}
+	}
+	memset(fw_version_str, 0, FW_VERSION_BUF_SIZE);
+	memcpy(fw_version_str, fw_firmware->data, FW_VERSION_BUF_SIZE - 1);
+
 	if (patch_status == PATCH_IS_DOWNLOAD_BT_OTHER ||
 			patch_status == PATCH_READY) {
 		pr_info("%s patch is ready no need load patch again\n",
@@ -1887,40 +1947,10 @@
 
 		ret = btmtk_sdio_set_sleep();
 		btmtk_sdio_set_write_clear();
+		release_firmware(fw_firmware);
 		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;
 
@@ -1954,6 +1984,7 @@
 	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],
@@ -2098,11 +2129,13 @@
 	int ret = 0;
 	struct sk_buff *skb = NULL;
 	struct sk_buff *fops_skb = NULL;
+	struct sk_buff *fwlog_fops_skb = NULL;
 	u32 type;
 	u32 fourbalignment_len = 0;
 	u32 dump_len = 0;
 	char *core_dump_end = NULL;
 	int i = 0;
+	static int print_dump_data_counter;
 
 #if SUPPORT_FW_DUMP
 	fw_is_coredump_end_packet = false;
@@ -2112,6 +2145,13 @@
 					+ rxbuf[SDIO_HEADER_LEN+2];
 			pr_notice("%s get dump length %d\n",
 				__func__, dump_len);
+
+			if (print_dump_data_counter < PRINT_DUMP_COUNT) {
+			    print_dump_data_counter++;
+			    pr_warn("%s : dump %d %s\n",
+			        __func__, print_dump_data_counter, &rxbuf[SDIO_HEADER_LEN+9]);
+			}
+
 			if (rxbuf[SDIO_HEADER_LEN+5] == 0x6F &&
 					rxbuf[SDIO_HEADER_LEN+6] == 0xFC) {
 
@@ -2137,27 +2177,30 @@
 							fw_dump_file_name,
 							O_RDWR | O_CREAT,
 							0644);
-					if (fw_dump_file) {
+					print_dump_data_counter = 0;
+					if (!(IS_ERR(fw_dump_file))) {
 						current_fwdump_file_number =
 							probe_counter;
 						pr_warn("%s : open file %s success\n",
 							__func__,
 							fw_dump_file_name);
-					} else
+					} else {
 						pr_warn("%s : open file %s fail\n",
 							__func__,
 							fw_dump_file_name);
+						fw_dump_file = NULL;
+					}
 				/* #endif */
 				}
 				#endif
 				fw_dump_total_read_size += dump_len;
 
 				#if SAVE_FW_DUMP_IN_KERNEL
-				if (fw_dump_file->f_op == NULL)
+				if (fw_dump_file && fw_dump_file->f_op == NULL)
 					pr_warn("%s : fw_dump_file->f_op is NULL\n",
 								__func__);
 
-				if (fw_dump_file->f_op->write == NULL)
+				if (fw_dump_file && fw_dump_file->f_op->write == NULL)
 					pr_warn("%s : fw_dump_file->f_op->write is NULL\n",
 								__func__);
 
@@ -2166,12 +2209,29 @@
 					&& fw_dump_file->f_op
 					&& fw_dump_file->f_op->write)
 					fw_dump_file->f_op->write(fw_dump_file,
-						&rxbuf[SDIO_HEADER_LEN+10],
+						&rxbuf[SDIO_HEADER_LEN+9],
 						dump_len,
 						&fw_dump_file->f_pos);
 
 				#endif
 
+				/* This is coredump data, save coredump data to picus_queue */
+				pr_debug("%s : Receive coredump data, move data to fwlog queue for picus", __func__);
+				buf_len = rx_length-(MTK_SDIO_PACKET_HEADER_SIZE+1);
+				lock_unsleepable_lock(&(fwlog_metabuffer.spin_lock));
+				fwlog_fops_skb = bt_skb_alloc(buf_len, GFP_ATOMIC);
+				memcpy(&fwlog_fops_skb->data[0], &rxbuf[MTK_SDIO_PACKET_HEADER_SIZE+5], buf_len);
+				fwlog_fops_skb->len = buf_len;
+				skb_queue_tail(&g_priv->adapter->fwlog_fops_queue, fwlog_fops_skb);
+				pr_debug("%s fwlog_fops_skb length = %d, buf_len = %d\n",
+					__func__, fwlog_fops_skb->len, buf_len);
+				if (skb_queue_empty(&g_priv->adapter->fwlog_fops_queue))
+					pr_warn("%s fwlog_fops_queue is empty empty\n", __func__);
+
+				kfree_skb(skb);
+				wake_up_interruptible(&fw_log_inq);
+				unlock_unsleepable_lock(&(fwlog_metabuffer.spin_lock));
+
 				if (dump_len >= sizeof(FW_DUMP_END_EVENT)) {
 					core_dump_end = strstr(
 						&rxbuf[SDIO_HEADER_LEN+10],
@@ -2190,6 +2250,31 @@
 FW_DONE:
 #endif
 
+	/*receive picus data to fwlog_queue*/
+	if (rx_length > (SDIO_HEADER_LEN+8)) {
+		dump_len = (rxbuf[SDIO_HEADER_LEN+1]&0x0F) * 256 + rxbuf[SDIO_HEADER_LEN+2];
+		pr_debug("%s This is debug log data, length = %d", __func__, dump_len);
+		if (rxbuf[SDIO_HEADER_LEN+1] == 0xFF && rxbuf[SDIO_HEADER_LEN+3] == 0x50) {
+			/* picus header is 0x50 */
+			pr_debug("%s : This is picus data", __func__);
+			buf_len = rx_length-(MTK_SDIO_PACKET_HEADER_SIZE+1);
+			lock_unsleepable_lock(&(fwlog_metabuffer.spin_lock));
+			fwlog_fops_skb = bt_skb_alloc(buf_len, GFP_ATOMIC);
+			memcpy(&fwlog_fops_skb->data[0], &rxbuf[MTK_SDIO_PACKET_HEADER_SIZE+1], buf_len);
+			fwlog_fops_skb->len = buf_len;
+			skb_queue_tail(&g_priv->adapter->fwlog_fops_queue, fwlog_fops_skb);
+			pr_debug("%s fwlog_fops_skb length = %d, buf_len = %d\n",
+				__func__, fwlog_fops_skb->len, buf_len);
+			if (skb_queue_empty(&g_priv->adapter->fwlog_fops_queue))
+				pr_warn("%s fwlog_fops_queue is empty empty\n", __func__);
+
+			kfree_skb(skb);
+			wake_up_interruptible(&fw_log_inq);
+			unlock_unsleepable_lock(&(fwlog_metabuffer.spin_lock));
+			goto exit;
+		}
+	}
+
 	type = rxbuf[MTK_SDIO_PACKET_HEADER_SIZE];
 
 	btmtk_print_buffer_conent(rxbuf, rx_length);
@@ -2245,16 +2330,21 @@
 			g_card->bdaddr[0], g_card->bdaddr[1], g_card->bdaddr[2],
 			g_card->bdaddr[3], g_card->bdaddr[4], g_card->bdaddr[5]);
 
-			//event_compare_status = BTMTK_SDIO_EVENT_COMPARE_STATE_COMPARE_SUCCESS;
+			/*
+			 * event_compare_status =
+			 * BTMTK_SDIO_EVENT_COMPARE_STATE_COMPARE_SUCCESS;
+			 */
 		} else
 			pr_debug("%s READ_ADDRESS_EVENT compare fail buf_len %d\n", __func__, buf_len);
 	}
 
-	lock_unsleepable_lock(&(metabuffer.spin_lock));
-	if ((!fw_is_doing_coredump) &
+
+	if ((!fw_is_doing_coredump) &&
 			(!fw_is_coredump_end_packet)) {
 		if (event_compare_status == BTMTK_SDIO_EVENT_COMPARE_STATE_NEED_COMPARE) {
 			/*compare with tx hci cmd*/
+			pr_debug("%s buf_len %d, event_need_compare_len %d\n",
+				__func__, buf_len, event_need_compare_len);
 			if (buf_len >= event_need_compare_len) {
 				if (memcmp(skb->data, event_need_compare, event_need_compare_len) == 0) {
 					event_compare_status = BTMTK_SDIO_EVENT_COMPARE_STATE_COMPARE_SUCCESS;
@@ -2272,16 +2362,18 @@
 		memcpy(fops_skb->data, skb->data, buf_len);
 
 		fops_skb->len = buf_len;
+		lock_unsleepable_lock(&(metabuffer.spin_lock));
 		skb_queue_tail(&g_priv->adapter->fops_queue, fops_skb);
 		if (skb_queue_empty(&g_priv->adapter->fops_queue))
 			pr_info("%s fops_queue is empty\n", __func__);
+		unlock_unsleepable_lock(&(metabuffer.spin_lock));
 
 		kfree_skb(skb);
-		unlock_unsleepable_lock(&(metabuffer.spin_lock));
+
 		wake_up_interruptible(&inq);
 		goto exit;
 	}
-	unlock_unsleepable_lock(&(metabuffer.spin_lock));
+
 
 exit:
 	if (ret) {
@@ -2328,14 +2420,12 @@
 		ret = btmtk_sdio_recv_rx_data();
 
 	if (ret == 0) {
-		lock_unsleepable_lock(&event_compare_status_lock);
 		while (rx_length > (MTK_SDIO_PACKET_HEADER_SIZE)) {
 			btmtk_sdio_card_to_host(priv, NULL, -1, 0);
 			u32rxdatacount++;
 			pr_debug("%s u32rxdatacount %d\n",
 				__func__, u32rxdatacount);
 		}
-		unlock_unsleepable_lock(&event_compare_status_lock);
 	}
 
 	btmtk_sdio_enable_interrupt(1);
@@ -2601,17 +2691,19 @@
 }
 
 static int btmtk_sdio_push_data_to_metabuffer(
+						struct ring_buffer *metabuffer,
 						char *data,
 						int len,
-						u8 type)
+						u8 type,
+						bool use_type)
 {
 	int remainLen = 0;
 
-	if (metabuffer.write_p >= metabuffer.read_p)
-		remainLen = metabuffer.write_p - metabuffer.read_p;
+	if (metabuffer->write_p >= metabuffer->read_p)
+		remainLen = metabuffer->write_p - metabuffer->read_p;
 	else
 		remainLen = META_BUFFER_SIZE -
-			(metabuffer.read_p - metabuffer.write_p);
+			(metabuffer->read_p - metabuffer->write_p);
 
 	if ((remainLen + 1 + len) >= META_BUFFER_SIZE) {
 		pr_warn("%s copy copyLen %d > META_BUFFER_SIZE(%d), push back to queue\n",
@@ -2621,73 +2713,128 @@
 		return -1;
 	}
 
-	metabuffer.buffer[metabuffer.write_p] = type;
-	metabuffer.write_p++;
-	if (metabuffer.write_p >= META_BUFFER_SIZE)
-		metabuffer.write_p = 0;
+	if (use_type) {
+		metabuffer->buffer[metabuffer->write_p] = type;
+		metabuffer->write_p++;
+	}
+	if (metabuffer->write_p >= META_BUFFER_SIZE)
+		metabuffer->write_p = 0;
 
-	if (metabuffer.write_p + len <= META_BUFFER_SIZE)
-		memcpy(&metabuffer.buffer[metabuffer.write_p],
+	if (metabuffer->write_p + len <= META_BUFFER_SIZE)
+		memcpy(&metabuffer->buffer[metabuffer->write_p],
 			data,
 			len);
 	else {
-		memcpy(&metabuffer.buffer[metabuffer.write_p],
+		memcpy(&metabuffer->buffer[metabuffer->write_p],
 			data,
-			META_BUFFER_SIZE - metabuffer.write_p);
-		memcpy(metabuffer.buffer,
-			&data[META_BUFFER_SIZE - metabuffer.write_p],
-			len - (META_BUFFER_SIZE - metabuffer.write_p));
+			META_BUFFER_SIZE - metabuffer->write_p);
+		memcpy(metabuffer->buffer,
+			&data[META_BUFFER_SIZE - metabuffer->write_p],
+			len - (META_BUFFER_SIZE - metabuffer->write_p));
 	}
 
-	metabuffer.write_p += len;
-	if (metabuffer.write_p >= META_BUFFER_SIZE)
-		metabuffer.write_p -= META_BUFFER_SIZE;
+	metabuffer->write_p += len;
+	if (metabuffer->write_p >= META_BUFFER_SIZE)
+		metabuffer->write_p -= META_BUFFER_SIZE;
 
 	remainLen += (1 + len);
 	return 0;
 }
 
 static int btmtk_sdio_pull_data_from_metabuffer(
+						struct ring_buffer *metabuffer,
 						char __user *buf,
 						size_t count)
 {
 	int copyLen = 0;
 	unsigned long ret = 0;
 
-	if (metabuffer.write_p >= metabuffer.read_p)
-		copyLen = metabuffer.write_p - metabuffer.read_p;
+	if (metabuffer->write_p >= metabuffer->read_p)
+		copyLen = metabuffer->write_p - metabuffer->read_p;
 	else
 		copyLen = META_BUFFER_SIZE -
-			(metabuffer.read_p - metabuffer.write_p);
+			(metabuffer->read_p - metabuffer->write_p);
 
 	if (copyLen > count)
 		copyLen = count;
 
-	if (metabuffer.read_p + copyLen <= META_BUFFER_SIZE)
+	if (metabuffer->read_p + copyLen <= META_BUFFER_SIZE)
 		ret = copy_to_user(buf,
-				&metabuffer.buffer[metabuffer.read_p],
+				&metabuffer->buffer[metabuffer->read_p],
 				copyLen);
 	else {
 		ret = copy_to_user(buf,
-				&metabuffer.buffer[metabuffer.read_p],
-				META_BUFFER_SIZE - metabuffer.read_p);
+				&metabuffer->buffer[metabuffer->read_p],
+				META_BUFFER_SIZE - metabuffer->read_p);
 		if (!ret)
 			ret = copy_to_user(
-				&buf[META_BUFFER_SIZE - metabuffer.read_p],
-				metabuffer.buffer,
-				copyLen - (META_BUFFER_SIZE-metabuffer.read_p));
+				&buf[META_BUFFER_SIZE - metabuffer->read_p],
+				metabuffer->buffer,
+				copyLen - (META_BUFFER_SIZE-metabuffer->read_p));
 	}
 
 	if (ret)
 		pr_warn("%s copy to user fail, ret %d\n", __func__, (int)ret);
 
-	metabuffer.read_p += (copyLen - ret);
-	if (metabuffer.read_p >= META_BUFFER_SIZE)
-		metabuffer.read_p -= META_BUFFER_SIZE;
+	metabuffer->read_p += (copyLen - ret);
+	if (metabuffer->read_p >= META_BUFFER_SIZE)
+		metabuffer->read_p -= META_BUFFER_SIZE;
 
 	return (copyLen - ret);
 }
+#if SUPPORT_EINT
+static irqreturn_t btmtk_sdio_woble_isr(int irq, void *dev)
+{
+	struct btmtk_sdio_card *data = (struct btmtk_sdio_card *)dev;
+	unsigned long wait_powerkey_time = 0;
 
+	pr_info("%s begin\n", __func__);
+	disable_irq_nosync(data->wobt_irq);
+	atomic_dec(&(data->irq_enable_count));
+	pr_info("%s:disable BT IRQ\n", __func__);
+	pr_info("%s:call wake lock\n", __func__);
+	wait_powerkey_time = msecs_to_jiffies(WAIT_POWERKEY_TIMEOUT);
+	wake_lock_timeout(&data->eint_wlock, wait_powerkey_time);/*10s*/
+	pr_info("%s end\n", __func__);
+	return IRQ_HANDLED;
+}
+
+static int btmtk_sdio_RegisterBTIrq(struct btmtk_sdio_card *data)
+{
+	struct device_node *eint_node = NULL;
+	int interrupts[2];
+
+	eint_node = of_find_compatible_node(NULL, NULL, "mediatek,mt7668_bt_ctrl");
+	pr_info("%s begin\n", __func__);
+	if (eint_node) {
+		pr_info("%s Get mt76xx_bt_ctrl compatible node\n", __func__);
+		data->wobt_irq = irq_of_parse_and_map(eint_node, 0);
+		pr_info("%s wobt_irq number:%d", __func__, data->wobt_irq);
+		if (data->wobt_irq) {
+			of_property_read_u32_array(eint_node, "interrupts",
+						   interrupts, ARRAY_SIZE(interrupts));
+			data->wobt_irqlevel = interrupts[1];
+			if (request_irq(data->wobt_irq, btmtk_sdio_woble_isr,
+					data->wobt_irqlevel, "mt7668_bt_ctrl-eint", data))
+				pr_info("%s WOBTIRQ LINE NOT AVAILABLE!!\n", __func__);
+			else {
+				pr_info("%s disable BT IRQ\n", __func__);
+				disable_irq_nosync(data->wobt_irq);
+			}
+
+		} else
+			pr_info("%s can't find mt76xx_bt_ctrl irq\n", __func__);
+
+	} else {
+		data->wobt_irq = 0;
+		pr_info("%s can't find mt76xx_bt_ctrl compatible node\n", __func__);
+	}
+
+
+	pr_info("btmtk:%s: end\n", __func__);
+	return 0;
+}
+#endif
 static int btmtk_sdio_probe(struct sdio_func *func,
 					const struct sdio_device_id *id)
 {
@@ -2716,6 +2863,10 @@
 	card->func = func;
 	g_card = card;
 
+#if SUPPORT_EINT
+	btmtk_sdio_RegisterBTIrq(card);
+#endif
+
 	if (id->driver_data) {
 		card->helper = data->helper;
 		card->firmware = data->firmware;
@@ -2758,8 +2909,7 @@
 	btmtk_sdio_set_i2s();
 	/* Move from btmtk_fops_open() */
 	spin_lock_init(&(metabuffer.spin_lock.lock));
-	spin_lock_init(&(event_compare_status_lock.lock));
-	spin_lock_init(&(tx_function_lock.lock));
+	spin_lock_init(&(fwlog_metabuffer.spin_lock.lock));
 	pr_debug("%s spin_lock_init end\n", __func__);
 
 	priv = btmtk_add_card(card);
@@ -2811,6 +2961,14 @@
 			g_card);
 	}
 
+#if (SUPPORT_UNIFY_WOBLE & SUPPORT_ANDROID)
+	wake_lock_init(&g_card->woble_wlock, WAKE_LOCK_SUSPEND, "btevent_woble");
+#endif
+
+#if SUPPORT_EINT
+	wake_lock_init(&g_card->eint_wlock, WAKE_LOCK_SUSPEND, "btevent_eint");
+#endif
+
 	pr_info("%s normal end\n", __func__);
 	probe_ready = true;
 	return 0;
@@ -2889,6 +3047,11 @@
 	bt_cb(skb)->pkt_type = cmd_type;
 	memcpy(&skb->data[0], cmd, cmd_len);
 	skb->len = cmd_len;
+	if (event) {
+		event_compare_status = BTMTK_SDIO_EVENT_COMPARE_STATE_NEED_COMPARE;
+		memcpy(event_need_compare, event, event_len);
+		event_need_compare_len = event_len;
+	}
 	skb_queue_tail(&g_priv->adapter->tx_queue, skb);
 	wake_up_interruptible(&g_priv->main_thread.wait_q);
 
@@ -2901,18 +3064,14 @@
 		return -1;
 	}
 
-	memcpy(event_need_compare, event, event_len);
-	event_need_compare_len = event_len;
-
 	start_time = jiffies;
-	// check HCI event
+	/* check HCI event */
 	comp_event_timo = jiffies + msecs_to_jiffies(total_timeout);
 	ret = -1;
-	event_compare_status = BTMTK_SDIO_EVENT_COMPARE_STATE_NEED_COMPARE;
-
 	pr_debug("%s event_need_compare_len %d\n", __func__, event_need_compare_len);
+	pr_debug("%s event_compare_status %d\n", __func__, event_compare_status);
 	do {
-		//check if event_compare_success
+		/* check if event_compare_success */
 		if (event_compare_status == BTMTK_SDIO_EVENT_COMPARE_STATE_COMPARE_SUCCESS) {
 			pr_debug("%s compare success\n", __func__);
 			ret = 0;
@@ -3112,8 +3271,8 @@
 		0x02, 0x40, 0x5A, 0x02, 0x41, 0x0F };
 	/*u8 status[] = { 0x0F, 0x04, 0x00, 0x01, 0xC9, 0xFC };*/
 	u8 comp_event[] = { 0xE6, 0x02, 0x08, 0x00 };
-	pr_debug("%s: begin", __func__);
 
+	pr_debug("%s: begin", __func__);
 
 	ret = btmtk_sdio_send_hci_cmd(HCI_COMMAND_PKT, cmd,
 				sizeof(cmd),
@@ -3121,7 +3280,7 @@
 	if (ret)
 		pr_err("%s: comp_event return error(%d)", __func__, ret);
 
-    return ret;
+	return ret;
 }
 /**
  * Set APCF manufacturer data and filter parameter
@@ -3144,10 +3303,9 @@
 				pr_err("%s: radio off error", __func__);
 				return ret;
 			}
-		}
-		else
+		} else
 			pr_info("%s: woble_setting_radio_off length is %d", __func__,
-		        g_card->woble_setting_radio_off[0].length);
+				g_card->woble_setting_radio_off[0].length);
 	} else {/* use default */
 		pr_info("%s: use default radio off cmd", __func__);
 		ret = btmtk_sdio_send_unify_woble_suspend_default_cmd();
@@ -3221,7 +3379,8 @@
 	u8 event[] = { 0x0e, 0x07, 0x01, 0x57, 0xfd, 0x00, 0x01, /* 00, 63 */ };
 
 	pr_debug("%s", __func__);
-	ret = btmtk_sdio_send_hci_cmd(HCI_COMMAND_PKT, cmd, sizeof(cmd), event, sizeof(event), WOBLE_COMP_EVENT_TIMO, 1);
+	ret = btmtk_sdio_send_hci_cmd(HCI_COMMAND_PKT, cmd, sizeof(cmd),
+		event, sizeof(event), WOBLE_COMP_EVENT_TIMO, 1);
 
 	if (ret < 0)
 		pr_err("%s: Got error %d", __func__, ret);
@@ -3286,6 +3445,7 @@
 
 	return ret;
 }
+
 static int btmtk_sdio_send_apcf_reserved(void)
 {
 	int ret = -1;
@@ -3329,6 +3489,17 @@
 	else
 		btmtk_sdio_handle_entering_WoBLE_state();
 
+#if SUPPORT_EINT
+	if (g_card->wobt_irq != 0 && atomic_read(&(g_card->irq_enable_count)) == 0) {
+		pr_info("%s:enable BT IRQ:%d\n", __func__, g_card->wobt_irq);
+		irq_set_irq_wake(g_card->wobt_irq, 1);
+		enable_irq(g_card->wobt_irq);
+		atomic_inc(&(g_card->irq_enable_count));
+	} else
+		pr_info("%s:irq_enable count:%d\n", __func__, atomic_read(&(g_card->irq_enable_count)));
+#endif
+
+
 	if (func) {
 		pm_flags = sdio_get_host_pm_caps(func);
 		pr_debug("%s: suspend: PM flags = 0x%x\n",
@@ -3336,7 +3507,7 @@
 		if (!(pm_flags & MMC_PM_KEEP_POWER)) {
 			pr_err("%s: cannot remain alive while suspended\n",
 				sdio_func_id(func));
-			//return -EINVAL;
+			return -EINVAL;
 		}
 	} else {
 		pr_err("sdio_func is not specified\n");
@@ -3345,9 +3516,9 @@
 
 	ret = btmtk_sdio_set_own_back(FW_OWN);
 	if (ret)
-	    pr_err("%s set fw own fail\n", __func__);
-        pr_notice("%s return 0 directly\n", __func__);
-	return 0;//sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
+		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)
@@ -3361,16 +3532,23 @@
 
 	g_card->suspend_count--;
 	if (g_card->suspend_count) {
-		pr_warn("%s: data->suspend_count %d, return 0", __func__, g_card->suspend_count);
+		pr_info("%s: data->suspend_count %d, return 0", __func__, g_card->suspend_count);
 		return 0;
 	}
-
+#if SUPPORT_EINT
+	if (g_card->wobt_irq != 0 && atomic_read(&(g_card->irq_enable_count)) == 1) {
+		pr_info("%s:disable BT IRQ:%d\n", __func__, g_card->wobt_irq);
+		atomic_dec(&(g_card->irq_enable_count));
+		disable_irq_nosync(g_card->wobt_irq);
+	} else
+		pr_info("%s:irq_enable count:%d\n", __func__, atomic_read(&(g_card->irq_enable_count)));
+#endif
 	ret = btmtk_sdio_handle_leaving_WoBLE_state();
 
 	if (ret)
 		pr_err("%s: btmtk_sdio_handle_leaving_WoBLE_state return fail  %d", __func__, ret);
 
-	pr_info("%s begin return 0, do nothing\n", __func__);
+	pr_info("%s end\n", __func__);
 	return 0;
 }
 
@@ -3423,10 +3601,7 @@
 
 	metabuffer.read_p = 0;
 	metabuffer.write_p = 0;
-#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;
@@ -3480,6 +3655,7 @@
 	static u8 waiting_for_hci_without_packet_type; /* INITIALISED_STATIC: do not initialise statics to 0 */
 	static u8 hci_packet_type = 0xff;
 	u32 copy_size = 0;
+	unsigned long c_result = 0;
 
 	if (!probe_ready) {
 		pr_err("%s probe_ready is %d return\n",
@@ -3513,8 +3689,13 @@
 			pr_info("%d %02X", i, buf[i]);
 	}
 #endif
+	memset(userbuf, 0, MTK_TXDATA_SIZE);
+	c_result = copy_from_user(userbuf, buf, count);
 
-	copy_from_user(userbuf, buf, count);
+	if (c_result != 0) {
+		pr_err("%s copy_from_user failed!\n", __func__);
+		return -EFAULT;
+	}
 
 	if (userbuf[0] == 0x7) {
 		/* write CR */
@@ -3560,7 +3741,7 @@
 		if (waiting_for_hci_without_packet_type == 1 && count == 1) {
 			pr_warn("%s: Waiting for hci_without_packet_type, but receive data count is 1!", __func__);
 			pr_warn("%s: Treat this packet as packet_type", __func__);
-			retval = memcpy(&hci_packet_type, &userbuf[0], 1);
+			memcpy(&hci_packet_type, &userbuf[0], 1);
 			waiting_for_hci_without_packet_type = 1;
 			retval = 1;
 			goto OUT;
@@ -3568,7 +3749,7 @@
 
 		if (waiting_for_hci_without_packet_type == 0) {
 			if (count == 1) {
-				retval = memcpy(&hci_packet_type, &userbuf[0], 1);
+				memcpy(&hci_packet_type, &userbuf[0], 1);
 				waiting_for_hci_without_packet_type = 1;
 				retval = 1;
 				goto OUT;
@@ -3696,8 +3877,8 @@
 #endif
 		btmtk_print_buffer_conent(skb->data, skb->len);
 
-		if (btmtk_sdio_push_data_to_metabuffer(skb->data,
-				skb->len, bt_cb(skb)->pkt_type) < 0) {
+		if (btmtk_sdio_push_data_to_metabuffer(&metabuffer, skb->data,
+				skb->len, bt_cb(skb)->pkt_type, true) < 0) {
 			skb_queue_head(&g_priv->adapter->fops_queue, skb);
 			break;
 		}
@@ -3705,11 +3886,10 @@
 	} while (!skb_queue_empty(&g_priv->adapter->fops_queue));
 	unlock_unsleepable_lock(&(metabuffer.spin_lock));
 
-	return btmtk_sdio_pull_data_from_metabuffer(buf, count);
+	return btmtk_sdio_pull_data_from_metabuffer(&metabuffer, buf, count);
 
 OUT:
 	return copyLen;
-
 }
 
 static int btmtk_fops_fasync(int fd, struct file *file, int on)
@@ -3789,15 +3969,64 @@
 			size_t count,
 			loff_t *f_pos)
 {
-	int copyLen = 0;
+	struct sk_buff *skb = NULL;
+
+	if (!probe_ready) {
+		pr_err("%s probe_ready is %d return\n",
+			__func__, probe_ready);
+		return -EFAULT;
+	}
 
 	if (g_priv == NULL) {
-		pr_err("%s: ERROR, g_data is NULL!\n", __func__);
+		pr_info("%s g_priv is NULL\n", __func__);
+		return -EFAULT;
+	}
+
+	if (g_priv->adapter->fops_mode == 0) {
+		pr_info("%s fops_mode is 0\n", __func__);
+		return -EFAULT;
+	}
+
+	lock_unsleepable_lock(&(fwlog_metabuffer.spin_lock));
+	if (skb_queue_empty(&g_priv->adapter->fwlog_fops_queue)) {
+		/* if (filp->f_flags & O_NONBLOCK) { */
+		if (fwlog_metabuffer.write_p == fwlog_metabuffer.read_p) {
+			unlock_unsleepable_lock(&(fwlog_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;
 	}
 
-	pr_info("%s: OK\n", __func__);
-	return copyLen;
+	do {
+		skb = skb_dequeue(&g_priv->adapter->fwlog_fops_queue);
+		if (skb == NULL) {
+			pr_debug("%s skb=NULL break\n", __func__);
+			break;
+		}
+#if 0
+		pr_debug("%s pkt_type %d metabuffer.buffer %d",
+			__func__, bt_cb(skb)->pkt_type,
+			metabuffer.buffer[copyLen]);
+#endif
+		btmtk_print_buffer_conent(skb->data, skb->len);
+
+		if (btmtk_sdio_push_data_to_metabuffer(&fwlog_metabuffer, skb->data,
+				skb->len, bt_cb(skb)->pkt_type, false) < 0) {
+			skb_queue_head(&g_priv->adapter->fwlog_fops_queue, skb);
+			break;
+		}
+		kfree_skb(skb);
+	} while (!skb_queue_empty(&g_priv->adapter->fwlog_fops_queue));
+	unlock_unsleepable_lock(&(fwlog_metabuffer.spin_lock));
+
+	return btmtk_sdio_pull_data_from_metabuffer(&fwlog_metabuffer, buf, count);
 }
 
 static ssize_t btmtk_fops_writefwlog(
@@ -3809,9 +4038,18 @@
 	u8 *i_fwlog_buf = kmalloc(HCI_MAX_COMMAND_BUF_SIZE, GFP_KERNEL);
 	u8 *o_fwlog_buf = kmalloc(HCI_MAX_COMMAND_SIZE, GFP_KERNEL);
 	const char *val_param = NULL;
+	unsigned long c_result = 0;
 
 	memset(i_fwlog_buf, 0, HCI_MAX_COMMAND_BUF_SIZE);
 	memset(o_fwlog_buf, 0, HCI_MAX_COMMAND_SIZE);
+	memset(userbuf_fwlog, 0, MTK_TXDATA_SIZE);
+
+	c_result = copy_from_user(userbuf_fwlog, buf, count);
+
+	if (c_result != 0) {
+		pr_err("%s copy_from_user failed!\n", __func__);
+		return -EFAULT;
+	}
 
 	btmtk_sdio_set_own_back(DRIVER_OWN);
 
@@ -3826,12 +4064,12 @@
 	}
 
 	for (i = 0; i < count; i++) {
-		if (buf[i] != '=') {
-			i_fwlog_buf[i] = buf[i];
+		if (userbuf_fwlog[i] != '=') {
+			i_fwlog_buf[i] = userbuf_fwlog[i];
 			pr_debug("%s: tag_param %02x\n",
 				__func__, i_fwlog_buf[i]);
 		} else {
-			val_param = &buf[i+1];
+			val_param = &userbuf_fwlog[i+1];
 			if (strcmp(i_fwlog_buf, "log_lvl") == 0) {
 				pr_info("%s: btmtk_log_lvl = %d\n",
 					__func__, val_param[0] - 48);
@@ -3847,7 +4085,7 @@
 		/* 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];
+		val_param = &userbuf_fwlog[0];
 	}
 	length = strlen(val_param);
 
@@ -3919,11 +4157,33 @@
 {
 	unsigned int mask = 0;
 
+	if (!probe_ready) {
+		pr_err("%s probe_ready is %d return\n",
+			__func__, probe_ready);
+		return mask;
+	}
+
 	if (g_priv == NULL) {
-		pr_err("%s: ERROR, g_data is NULL!\n", __func__);
+		pr_err("%s g_priv is NULL\n", __func__);
 		return -ENODEV;
 	}
 
+	if (fwlog_metabuffer.write_p != fwlog_metabuffer.read_p)
+		mask |= (POLLIN | POLLRDNORM);
+
+	if (skb_queue_empty(&g_priv->adapter->fwlog_fops_queue)) {
+		poll_wait(file, &fw_log_inq, wait);
+
+		if (!skb_queue_empty(&g_priv->adapter->fwlog_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;
 }
 
@@ -3942,6 +4202,36 @@
 	return retval;
 }
 
+/*============================================================================*/
+/* Interface Functions : Proc */
+/*============================================================================*/
+#define __________________________________________Interface_Function_for_Proc
+static int btmtk_proc_show(struct seq_file *m, void *v)
+{
+	seq_printf(m, "%s\n", fw_version_str);
+	return 0;
+}
+
+static int btmtk_proc_open(struct inode *inode, struct  file *file)
+{
+	return single_open(file, btmtk_proc_show, NULL);
+}
+
+void btmtk_proc_create_new_entry(void)
+{
+	struct proc_dir_entry *proc_show_entry;
+
+	pr_info("proc initialized");
+
+	g_proc_dir = proc_mkdir("stpbt", 0);
+	if (g_proc_dir == 0) {
+		pr_info("Unable to creat dir");
+		return;
+	}
+	proc_show_entry =  proc_create("bt_fw_version", 0644, g_proc_dir, &BT_proc_fops);
+}
+
+
 static int BTMTK_major;
 static int BT_majorfwlog;
 static struct cdev BTMTK_cdev;
@@ -4005,6 +4295,7 @@
 	fw_dump_end_checking_task_should_stop = 0;
 	fw_is_doing_coredump = 0;
 
+	btmtk_proc_create_new_entry();
 
 	ret = alloc_chrdev_region(&devID, 0, 1, "BT_chrdev");
 	if (ret) {
@@ -4099,6 +4390,14 @@
 	dev_t devIDfwlog = g_devIDfwlog;
 
 	pr_info("%s\n", __func__);
+
+	if (g_proc_dir != NULL) {
+		remove_proc_entry("bt_fw_version", g_proc_dir);
+		remove_proc_entry("stpbt", NULL);
+		g_proc_dir = NULL;
+		pr_info("proc device node and folder removed!!");
+	}
+
 	if (g_card) {
 		pr_info("%s 1\n", __func__);
 		if (g_card->woble_setting_file_name) {
@@ -4161,6 +4460,11 @@
 		memset(userbuf, 0, MTK_TXDATA_SIZE);
 	}
 
+	if (userbuf_fwlog == NULL) {
+		userbuf_fwlog = kmalloc(MTK_TXDATA_SIZE, GFP_ATOMIC);
+		memset(userbuf_fwlog, 0, MTK_TXDATA_SIZE);
+	}
+
 	return 0;
 }
 
@@ -4172,6 +4476,8 @@
 
 	kfree(userbuf);
 
+	kfree(userbuf_fwlog);
+
 	kfree(fw_dump_ptr);
 
 	return 0;
diff --git a/btmtk_sdio.h b/btmtk_sdio.h
index e3ea7db..6674d95 100644
--- a/btmtk_sdio.h
+++ b/btmtk_sdio.h
@@ -14,9 +14,12 @@
 #ifndef _BTMTK_SDIO_H_
 #define _BTMTK_SDIO_H_
 #include "btmtk_config.h"
+#if ((SUPPORT_UNIFY_WOBLE & SUPPORT_ANDROID) || SUPPORT_EINT)
+#include <linux/wakelock.h>
+#endif
 
 
-#define VERSION "v0.0.0.41_2017122701"
+#define VERSION "v0.0.0.51_2018031901_YOCTO"
 
 #define SDIO_HEADER_LEN                 4
 
@@ -171,6 +174,17 @@
 #if (SUPPORT_UNIFY_WOBLE & SUPPORT_ANDROID)
 	struct					wake_lock woble_wlock;
 #endif
+
+#if SUPPORT_EINT
+	struct					wake_lock eint_wlock;
+#endif
+
+#if SUPPORT_EINT
+	/* WoBLE */
+	unsigned int wobt_irq;
+	int wobt_irqlevel;
+	atomic_t irq_enable_count;
+#endif
 };
 struct btmtk_sdio_device {
 	const char *helper;
@@ -323,3 +337,4 @@
 
 
 #endif
+