qcacld: Move FW ramdump code to ol_fw.c (Rome USB)

1. When receive firmware crash assertion, call firmware event handler
   and pass error code.
2. Move ramdump code to ol_fw.c
3. Depend on gEnableFwSelfRecovery in INI to decide
   if trigger kernel panic.
4. Remove USB_FW_CRASH_RAM_DUMP becasue we have the option to control
   in INI already.

Change-Id: I19fcad3884c924a4facb695c2f4c751305bf712e
CRs-Fixed: 701179

12 files changed, 186 insertions, 134 deletions

diff --git a/CORE/SERVICES/BMI/ol_fw.c b/CORE/SERVICES/BMI/ol_fw.c
index cc9e62a70237..085fec3bff33 100644
--- a/CORE/SERVICES/BMI/ol_fw.c
+++ b/CORE/SERVICES/BMI/ol_fw.c
@@ -55,6 +55,7 @@
 #endif
 
 static struct hash_fw fw_hash;
+#include "qwlan_version.h"
 
 #ifdef HIF_PCI
 static u_int32_t refclk_speed_to_hz[] = {
@@ -961,6 +962,124 @@ void ol_schedule_fw_indication_work(struct ol_softc *scn)
 }
 #endif
 
+#ifdef HIF_USB
+/* Save memory addresses where we save FW ram dump, and then we could obtain
+ * them by symbol table. */
+A_UINT32 fw_stack_addr;
+void *fw_ram_seg_addr[FW_RAM_SEG_CNT];
+
+/* ol_ramdump_handler is to receive information of firmware crash dump, and
+ * save it in host memory. It consists of 5 parts: registers, call stack,
+ * DRAM dump, IRAM dump, and AXI dump, and they are reported to host in order.
+ *
+ * registers: wrapped in a USB packet by starting as FW_ASSERT_PATTERN and
+ *            60 registers.
+ * call stack: wrapped in multiple USB packets, and each of them starts as
+ *             FW_REG_PATTERN and contains multiple double-words. The tail
+ *             of the last packet is FW_REG_END_PATTERN.
+ * DRAM dump: wrapped in multiple USB pakcets, and each of them start as
+ *            FW_RAMDUMP_PATTERN and contains multiple double-wors. The tail
+ *            of the last packet is FW_RAMDUMP_END_PATTERN;
+ * IRAM dump and AXI dump are with the same format as DRAM dump.
+ */
+void ol_ramdump_handler(struct ol_softc *scn)
+{
+	A_UINT32 *reg, pattern, i, start_addr = 0;
+	A_UINT32 MSPId = 0, mSPId = 0, SIId = 0, CRMId = 0, len;
+	A_UINT8 *data;
+	A_UINT8 str_buf[128];
+	A_UINT8 *ram_ptr = NULL;
+	A_UINT32 remaining;
+	char *fw_ram_seg_name[FW_RAM_SEG_CNT] = {"DRAM", "IRAM", "AXI"};
+
+	data = scn->hif_sc->fw_data;
+	len = scn->hif_sc->fw_data_len;
+	pattern = *((A_UINT32 *) data);
+
+	if (pattern == FW_ASSERT_PATTERN) {
+		MSPId = (scn->target_fw_version & 0xf0000000) >> 28;
+		mSPId = (scn->target_fw_version & 0xf000000) >> 24;
+		SIId = (scn->target_fw_version & 0xf00000) >> 20;
+		CRMId = scn->target_fw_version & 0x7fff;
+		pr_err("Firmware crash detected...\n");
+		pr_err("Host SW version: %s\n", QWLAN_VERSIONSTR);
+		pr_err("FW version: %d.%d.%d.%d", MSPId, mSPId, SIId, CRMId);
+		reg = (A_UINT32 *) (data + 4);
+		print_hex_dump(KERN_DEBUG, " ", DUMP_PREFIX_OFFSET, 16, 4, reg,
+				min_t(A_UINT32, len - 4, FW_REG_DUMP_CNT),
+				false);
+		scn->fw_ram_dumping = 0;
+	}
+	else if (pattern == FW_REG_PATTERN) {
+		reg = (A_UINT32 *) (data + 4);
+		start_addr = *reg++;
+		if (scn->fw_ram_dumping == 0) {
+			pr_err("Firmware stack dump:");
+			scn->fw_ram_dumping = 1;
+			fw_stack_addr = start_addr;
+		}
+		remaining = len - 8;
+		/* len is in byte, but it's printed in double-word. */
+		for (i = 0; i < (len - 8); i += 16) {
+			if ((*reg == FW_REG_END_PATTERN) && (i == len - 12)) {
+				scn->fw_ram_dumping = 0;
+				pr_err("Stack start address = %#08x\n",
+					fw_stack_addr);
+				break;
+			}
+			hex_dump_to_buffer(reg, remaining, 16, 4, str_buf,
+						sizeof(str_buf), false);
+			pr_err("%#08x: %s\n", start_addr + i, str_buf);
+			remaining -= 16;
+			reg += 4;
+		}
+	}
+	else if ((!scn->enableFwSelfRecovery)&&
+			((pattern & FW_RAMDUMP_PATTERN_MASK) ==
+						FW_RAMDUMP_PATTERN)) {
+		VOS_ASSERT(scn->ramdump_index < FW_RAM_SEG_CNT);
+		i = scn->ramdump_index;
+		reg = (A_UINT32 *) (data + 4);
+		if (scn->fw_ram_dumping == 0) {
+			scn->fw_ram_dumping = 1;
+			pr_err("Firmware %s dump:\n", fw_ram_seg_name[i]);
+			scn->ramdump[i] = kmalloc(sizeof(struct fw_ramdump) +
+							FW_RAMDUMP_SEG_SIZE,
+							GFP_KERNEL);
+			if (!scn->ramdump[i]) {
+				pr_err("Fail to allocate memory for ram dump");
+				VOS_BUG(0);
+			}
+			fw_ram_seg_addr[i] = scn->ramdump[i];
+			pr_err("FW %s start addr = %#08x\n",
+				fw_ram_seg_name[i], *reg);
+			pr_err("Memory addr for %s = %#08x\n",
+				fw_ram_seg_name[i],
+				(A_UINT32) scn->ramdump[i]);
+			(scn->ramdump[i])->start_addr = *reg;
+			(scn->ramdump[i])->length = 0;
+			(scn->ramdump[i])->mem =
+				(A_UINT8 *) (scn->ramdump[i] + 1);
+		}
+		reg++;
+		ram_ptr = (scn->ramdump[i])->mem + (scn->ramdump[i])->length;
+		(scn->ramdump[i])->length += (len - 8);
+		memcpy(ram_ptr, (A_UINT8 *) reg, len - 8);
+
+		if (pattern == FW_RAMDUMP_END_PATTERN) {
+			pr_err("%s memory size = %d\n", fw_ram_seg_name[i],
+					(scn->ramdump[i])->length);
+			if (i == (FW_RAM_SEG_CNT - 1)) {
+				VOS_BUG(0);
+			}
+
+			scn->ramdump_index++;
+			scn->fw_ram_dumping = 0;
+		}
+	}
+}
+#endif
+
 #define REGISTER_DUMP_LEN_MAX   60
 #define REG_DUMP_COUNT		60
 
@@ -982,6 +1101,15 @@ void ol_target_failure(void *instance, A_STATUS status)
 	int ret;
 #endif
 
+#ifdef HIF_USB
+	/* Currently, only firmware crash triggers ol_target_failure.
+	   In case, we need to dump RAM data. */
+	if (status == A_USB_ERROR) {
+		ol_ramdump_handler(scn);
+		return;
+	}
+#endif
+
 	if (OL_TRGET_STATUS_RESET == scn->target_status) {
 		printk("Target is already asserted, ignore!\n");
 		return;
diff --git a/CORE/SERVICES/COMMON/athdefs.h b/CORE/SERVICES/COMMON/athdefs.h
index 5b3500f7dabe..11ce362e3f85 100644
--- a/CORE/SERVICES/COMMON/athdefs.h
+++ b/CORE/SERVICES/COMMON/athdefs.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012, 2014 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -82,6 +82,7 @@ ter (typically in callback) */
     A_PHY_ERROR,                /* RX PHY error */
     A_CONSUMED,                 /* Object was consumed */
     A_CLONE,                    /* The buffer is cloned */
+    A_USB_ERROR,                /* Rome USB Target error */
 } A_STATUS;
 
 #define A_SUCCESS(x)        (x == A_OK)
diff --git a/CORE/SERVICES/COMMON/hif_msg_based.h b/CORE/SERVICES/COMMON/hif_msg_based.h
index c156ea6e9755..74028eaeefdb 100644
--- a/CORE/SERVICES/COMMON/hif_msg_based.h
+++ b/CORE/SERVICES/COMMON/hif_msg_based.h
@@ -48,7 +48,7 @@ typedef struct {
 	A_STATUS (*rxCompletionHandler)(void *Context, adf_nbuf_t wbuf,
 					u_int8_t pipeID);
 	void     (*txResourceAvailHandler)(void *context, u_int8_t pipe);
-	void     (*fwEventHandler)(void *context);
+	void     (*fwEventHandler)(void *context, A_STATUS status);
 } MSG_BASED_HIF_CALLBACKS;
 
 int HIF_deregister(void);
diff --git a/CORE/SERVICES/COMMON/ol_if_athvar.h b/CORE/SERVICES/COMMON/ol_if_athvar.h
index f4ff6ae63830..8b9408e8896e 100644
--- a/CORE/SERVICES/COMMON/ol_if_athvar.h
+++ b/CORE/SERVICES/COMMON/ol_if_athvar.h
@@ -113,6 +113,36 @@ struct ol_ath_stats {
     int ce_ring_delta_fail_count;
 };
 
+#ifdef HIF_USB
+/* Magic patterns for FW to report crash information (Rome USB) */
+#define FW_ASSERT_PATTERN       0x0000c600
+#define FW_REG_PATTERN          0x0000d600
+#define FW_REG_END_PATTERN      0x0000e600
+#define FW_RAMDUMP_PATTERN      0x0000f600
+#define FW_RAMDUMP_END_PATTERN  0x0000f601
+#define FW_RAMDUMP_PATTERN_MASK 0xfffffff0
+
+#define FW_REG_DUMP_CNT       60
+
+/* FW RAM segments (Rome USB) */
+enum {
+    FW_RAM_SEG_DRAM,
+    FW_RAM_SEG_IRAM,
+    FW_RAM_SEG_AXI,
+    FW_RAM_SEG_CNT
+};
+
+/* Allocate 384K memory to save each segment of ram dump */
+#define FW_RAMDUMP_SEG_SIZE     393216
+
+/* structure to save RAM dump information */
+struct fw_ramdump {
+    A_UINT32 start_addr;
+    A_UINT32 length;
+    A_UINT8 *mem;
+};
+#endif
+
 struct ol_softc {
     /*
      * handle for code that uses the osdep.h version of OS
@@ -200,6 +230,13 @@ struct ol_softc {
     bool                    enablefwlog;        /* enable fwlog */
     /* enable FW self-recovery for Rome USB */
     bool                    enableFwSelfRecovery;
+#ifdef HIF_USB
+    /* structure to save FW RAM dump (Rome USB) */
+    struct fw_ramdump       *ramdump[FW_RAM_SEG_CNT];
+    A_UINT8                 ramdump_index;
+    bool                    fw_ram_dumping;
+#endif
+
     bool                    enablesinglebinary; /* Use single binary for FW */
     HAL_REG_CAPABILITIES hal_reg_capabilities;
     struct ol_regdmn *ol_regdmn_handle;
diff --git a/CORE/SERVICES/HIF/PCIe/hif_pci.c b/CORE/SERVICES/HIF/PCIe/hif_pci.c
index c1cbb4aa7cdd..342a56919346 100644
--- a/CORE/SERVICES/HIF/PCIe/hif_pci.c
+++ b/CORE/SERVICES/HIF/PCIe/hif_pci.c
@@ -716,7 +716,7 @@ hif_completion_thread(struct HIF_CE_state *hif_state)
              * another while we process the first.
              */
             atomic_set(&hif_state->fw_event_pending, 0);
-            msg_callbacks->fwEventHandler(msg_callbacks->Context);
+            msg_callbacks->fwEventHandler(msg_callbacks->Context, A_ERROR);
         }
 
         if (hif_state->sc->ol_sc->target_status == OL_TRGET_STATUS_RESET)
diff --git a/CORE/SERVICES/HIF/USB/hif_usb_internal.h b/CORE/SERVICES/HIF/USB/hif_usb_internal.h
index f50af97b43ed..e59c01345704 100644
--- a/CORE/SERVICES/HIF/USB/hif_usb_internal.h
+++ b/CORE/SERVICES/HIF/USB/hif_usb_internal.h
@@ -164,26 +164,4 @@ extern void usb_hif_resume(struct usb_interface *interface);
 A_STATUS HIFDiagWriteWARMRESET(struct usb_interface *interface,
 			       A_UINT32 address, A_UINT32 data);
 
-#define FW_ASSERT_PATTERN       0x0000c600
-#define FW_REG_PATTERN          0x0000d600
-#define FW_REG_END_PATTERN      0x0000e600
-#define FW_RAMDUMP_PATTERN      0x0000f600
-#define FW_RAMDUMP_END_PATTERN  0x0000f601
-#define FW_RAMDUMP_PATTERN_MASK 0xfffffff0
-
-enum {
-	FW_RAM_SEG_DRAM,
-	FW_RAM_SEG_IRAM,
-	FW_RAM_SEG_AXI,
-	FW_RAM_SEG_CNT
-};
-
-/* Allocate 384K memory to save each segment of ram dump */
-#define FW_RAMDUMP_SEG_SIZE     393216
-
-struct fw_ramdump {
-	A_UINT32 start_addr;
-	A_UINT32 length;
-	A_UINT8 *mem;
-};
 #endif
diff --git a/CORE/SERVICES/HIF/USB/if_usb.h b/CORE/SERVICES/HIF/USB/if_usb.h
index a197f6238b2f..cfdf4e76c8f2 100644
--- a/CORE/SERVICES/HIF/USB/if_usb.h
+++ b/CORE/SERVICES/HIF/USB/if_usb.h
@@ -57,6 +57,7 @@
 #include <athdefs.h>
 #include "osapi_linux.h"
 #include "hif.h"
+
 struct hif_usb_softc {
 	/* For efficiency, should be first in struct */
 	struct device *dev;
@@ -80,6 +81,8 @@ struct hif_usb_softc {
 	int hdd_removed;
 	int hdd_removed_processing;
 	int hdd_removed_wait_cnt;
+	u8 *fw_data;
+	u32 fw_data_len;
 };
 #if defined(CONFIG_ATH_PROCFS_DIAG_SUPPORT)
 int athdiag_procfs_init(void *scn);
diff --git a/CORE/SERVICES/HIF/USB/usbdrv.c b/CORE/SERVICES/HIF/USB/usbdrv.c
index d61f1232e4e6..453739ddddd6 100644
--- a/CORE/SERVICES/HIF/USB/usbdrv.c
+++ b/CORE/SERVICES/HIF/USB/usbdrv.c
@@ -978,114 +978,19 @@ A_STATUS usb_hif_submit_ctrl_in(HIF_DEVICE_USB *device,
                                 (x == FW_REG_PATTERN) || \
                                 ((x & FW_RAMDUMP_PATTERN_MASK) == FW_RAMDUMP_PATTERN))?1:0
 
-void fw_crash_dump(HIF_DEVICE_USB *device, A_UINT8 *data, A_UINT32 len)
-{
-	A_UINT32 *reg, pattern, i, start_addr = 0, stack_addr = 0;
-	A_UINT32 MSPId = 0, mSPId = 0, SIId = 0, CRMId = 0;
-	static A_UINT8 dumping = 0;
-#ifdef USB_FW_CRASH_RAM_DUMP
-	A_UINT8 *ram_ptr = NULL;
-	static struct fw_ramdump *ramdump[FW_RAM_SEG_CNT];
-	static A_UINT8 ramdump_index = 0;
-	static char *fw_ram_seg_name[FW_RAM_SEG_CNT] = {"DRAM", "IRAM", "AXI"};
-#endif
-
-	pattern = *((A_UINT32 *) data);
-
-	if (pattern == FW_ASSERT_PATTERN) {
-		MSPId = (device->sc->ol_sc->target_fw_version & 0xf0000000) >> 28;
-		mSPId = (device->sc->ol_sc->target_fw_version & 0xf000000) >> 24;
-		SIId = (device->sc->ol_sc->target_fw_version & 0xf00000) >> 20;
-		CRMId = device->sc->ol_sc->target_fw_version & 0x7fff;
-		AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("Firmware crash detected...\n"));
-		AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("Host SW version: %s\n", QWLAN_VERSIONSTR));
-		AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("FW version: %d.%d.%d.%d", MSPId, mSPId, SIId, CRMId));
-		reg = (A_UINT32 *) (data+4);
-		for (i = 0; i < 60; reg++, i++ ) {
-			if (i%4 == 0) {
-				AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("\n"));
-				AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("%2d: ", i));
-			}
-			AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("0x%08x ", *reg));
-		}
-		AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("\n"));
-	} else if (pattern == FW_REG_PATTERN) {
-		reg = (A_UINT32 *) (data+4);
-		start_addr = *reg++;
-		if (dumping == 0) {
-			AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("Firmware stack dump:"));
-			dumping = 1;
-			stack_addr = start_addr;
-		}
-		for (i = 0; i < (len>>2)-2; reg++, i++ ) {
-			if (*reg == FW_REG_END_PATTERN && (i == (len>>2)-3)) {
-				dumping = 0;
-				AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
-					("\nStack start address = 0x%08X\n", stack_addr));
-				break;
-			}
-			if (i%4 == 0) {
-				AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("\n"));
-				AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("0x%08X: ", start_addr + (i << 2)));
-			}
-			AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("0x%08X ", *reg));
-		}
-#ifdef USB_FW_CRASH_RAM_DUMP
-	} else if ((pattern & FW_RAMDUMP_PATTERN_MASK) == FW_RAMDUMP_PATTERN) {
-		ASSERT(ramdump_index < FW_RAM_SEG_CNT);
-		i = ramdump_index;
-		reg = (A_UINT32 *) (data+4);
-
-		if (dumping == 0) {
-			AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("Firmware %s dump:\n", fw_ram_seg_name[i]));
-			dumping = 1;
-			ramdump[i] = kmalloc(sizeof(struct fw_ramdump)+FW_RAMDUMP_SEG_SIZE, GFP_KERNEL);
-			if (!ramdump[i]) {
-				AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
-						("Failed to allocate memory for ram dump"));
-				VOS_BUG(0);
-			}
-			AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("FW %s start addr = 0x%08X\n",
-					fw_ram_seg_name[i], *reg));
-			AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("Memory addr for %s = 0x%08X\n",
-					fw_ram_seg_name[i], (A_UINT32) ramdump[i]));
-			(ramdump[i])->start_addr = *reg;
-			(ramdump[i])->length = 0;
-			(ramdump[i])->mem = (A_UINT8 *) (ramdump[i] + 1);
-		}
-
-		reg++;
-		ram_ptr = (ramdump[i])->mem + (ramdump[i])->length;
-		(ramdump[i])->length += (len - 8);
-		memcpy(ram_ptr, (A_UINT8 *) reg, len-8);
-
-		if (pattern == FW_RAMDUMP_END_PATTERN) {
-
-			AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
-					("%s memory size = %d\n",
-						fw_ram_seg_name[i], (ramdump[i])->length));
-			if (i == (FW_RAM_SEG_CNT - 1)) {
-				VOS_BUG(0);
-			}
-
-			dumping = 0;
-			ramdump_index++;
-		}
-#endif   /* USB_FW_CRASH_RAM_DUMP */
-	}
-}
-
 void usb_hif_io_comp_work(struct work_struct *work)
 {
 	HIF_USB_PIPE *pipe = container_of(work, HIF_USB_PIPE, io_complete_work);
 	adf_nbuf_t buf;
 	HIF_DEVICE_USB *device;
 	HTC_FRAME_HDR *HtcHdr;
+	struct hif_usb_softc *sc;
 	A_UINT8 *data;
 	A_UINT32 len;
 
 	AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+%s\n", __func__));
 	device = pipe->device;
+	sc = device->sc;
 
 	while ((buf = skb_dequeue(&pipe->io_comp_queue))) {
 		a_mem_trace(buf);
@@ -1113,7 +1018,10 @@ void usb_hif_io_comp_work(struct work_struct *work)
 			adf_nbuf_peek_header(buf, &data, &len);
 
 			if (IS_FW_CRASH_DUMP(*((A_UINT32 *) data))) {
-				fw_crash_dump(device, data, len);
+				sc->fw_data = data;
+				sc->fw_data_len = len;
+				device->htcCallbacks.fwEventHandler(
+					device->htcCallbacks.Context, A_USB_ERROR);
 				dev_kfree_skb(buf);
 			} else {
 				device->htcCallbacks.rxCompletionHandler(
diff --git a/CORE/SERVICES/HIF/sdio/hif_sdio_recv.c b/CORE/SERVICES/HIF/sdio/hif_sdio_recv.c
index 210b4143ca93..bb42930a1855 100644
--- a/CORE/SERVICES/HIF/sdio/hif_sdio_recv.c
+++ b/CORE/SERVICES/HIF/sdio/hif_sdio_recv.c
@@ -1039,9 +1039,10 @@ static A_STATUS HIFDevServiceCPUInterrupt(HIF_SDIO_DEVICE *pDev)
 
     /* The Interrupt sent to the Host is generated via bit0 of CPU INT register*/
     if (cpu_int_status & 0x1){
-        if(pDev && pDev->hif_callbacks.fwEventHandler)
-        //this calls into HTC which propagates this to ol_target_failure()
-        pDev->hif_callbacks.fwEventHandler(pDev->hif_callbacks.Context);
+        if (pDev && pDev->hif_callbacks.fwEventHandler)
+            /* It calls into HTC which propagates this to ol_target_failure() */
+            pDev->hif_callbacks.fwEventHandler(pDev->hif_callbacks.Context,
+                                               A_ERROR);
     }
     else
     AR_DEBUG_PRINTF( ATH_DEBUG_ERROR,
diff --git a/CORE/SERVICES/HTC/htc_internal.h b/CORE/SERVICES/HTC/htc_internal.h
index 3e3412f457c6..4ea6113a6da7 100644
--- a/CORE/SERVICES/HTC/htc_internal.h
+++ b/CORE/SERVICES/HTC/htc_internal.h
@@ -229,7 +229,7 @@ void        HTCProcessCreditRpt(HTC_TARGET        *target,
                                 HTC_CREDIT_REPORT *pRpt,
                                 int                NumEntries,
                                 HTC_ENDPOINT_ID    FromEndpoint);
-void        HTCFwEventHandler(void *context);
+void        HTCFwEventHandler(void *context, A_STATUS status);
 void        HTCSendCompleteCheckCleanup(void *context);
 
 
diff --git a/CORE/SERVICES/HTC/htc_services.c b/CORE/SERVICES/HTC/htc_services.c
index 74749b9b25d1..bcf966ee3a17 100644
--- a/CORE/SERVICES/HTC/htc_services.c
+++ b/CORE/SERVICES/HTC/htc_services.c
@@ -311,17 +311,14 @@ void HTCSetCreditDistribution(HTC_HANDLE               HTCHandle,
 }
 
 
-void HTCFwEventHandler(void *context)
+void HTCFwEventHandler(void *context, A_STATUS status)
 {
     HTC_TARGET      *target = (HTC_TARGET *)context;
     HTC_INIT_INFO   *initInfo = &target->HTCInitInfo;
 
-    /*
-     * Currently, there's only one event type (Target Failure);
-     * there's no need to discriminate between event types.
-     */
+    /* check if target failure handler exists and pass error code to it. */
     if (target->HTCInitInfo.TargetFailure != NULL) {
-        initInfo->TargetFailure(initInfo->pContext, A_ERROR);
+        initInfo->TargetFailure(initInfo->pContext, status);
     }
 }
 
diff --git a/Kbuild b/Kbuild
index a65546c2286d..c8d457d9a3d8 100644
--- a/Kbuild
+++ b/Kbuild
@@ -1017,7 +1017,6 @@ CDEFINES += -DCONFIG_ATH_PROCFS_DIAG_SUPPORT
 CDEFINES += -DQCA_SUPPORT_OL_RX_REORDER_TIMEOUT
 CDEFINES += -DCONFIG_ATH_PCIE_MAX_PERF=0 -DCONFIG_ATH_PCIE_AWAKE_WHILE_DRIVER_LOAD=0 -DCONFIG_DISABLE_CDC_MAX_PERF_WAR=0
 CDEFINES += -DQCA_TX_HTT2_SUPPORT
-CDEFINES += -DUSB_FW_CRASH_RAM_DUMP
 endif
 
 # enable the MAC Address auto-generation feature