drivers/net/wireless/ath/ath11k/coredump.c - manifest_repos/kernel - Git at Google

 // SPDX-License-Identifier: BSD-3-Clause-Clear
 /**
  * Copyright (c) 2020 The Linux Foundation. All rights reserved.
  */

 #include <linux/devcoredump.h>
 #include <linux/platform_device.h>
 #include <linux/dma-direction.h>
 #include <linux/mhi.h>
 #include <linux/pci.h>
 #include <linux/mm.h>
 #include <linux/uuid.h>
 #include <linux/time.h>
 #include "core.h"
 #include "coredump.h"
 #include "pci.h"
 #include "mhi.h"
 #include "debug.h"

 struct ath11k_coredump_segment_info ath11k_coredump_seg_info;
 EXPORT_SYMBOL(ath11k_coredump_seg_info);

 static void ath11k_coredump_update_hdr(struct ath11k_base *ab,
 				       struct ath11k_dump_file_data *file_data,
 				       size_t header_size)
 {
 	struct timespec64 timestamp;

 	strscpy(file_data->df_magic, "ATH11K-FW-DUMP",
 		sizeof(file_data->df_magic));
 	file_data->len = cpu_to_le32(header_size);
 	file_data->version = cpu_to_le32(ATH11K_FW_CRASH_DUMP_VERSION);
 	guid_gen(&file_data->guid);
 	ktime_get_real_ts64(&timestamp);
 	file_data->tv_sec = cpu_to_le64(timestamp.tv_sec);
 	file_data->tv_nsec = cpu_to_le64(timestamp.tv_nsec);
 }

 static void *ath11k_coredump_find_segment(loff_t user_offset,
 					  struct ath11k_dump_segment *segment,
 					  int phnum, size_t *data_left)
 {
 	int i;

 	for (i = 0; i < phnum; i++, segment++) {
 		if (user_offset < segment->len) {
 			*data_left = user_offset;
 			return segment;
 		}
 		user_offset -= segment->len;
 	}

 	*data_left = 0;
 	return NULL;
 }

 static ssize_t ath11k_coredump_read_q6dump(char *buffer, loff_t offset, size_t count,
 				void *data, size_t header_size)
 {
 	struct ath11k_coredump_state *dump_state = data;
 	struct ath11k_dump_segment *segments = dump_state->segments;
 	struct ath11k_dump_segment *seg;
 	void *elfcore = dump_state->header;
 	size_t data_left, copy_size, bytes_left = count;
 	void __iomem *addr;

 	/* Copy the header first */
 	if (offset < header_size) {
 		copy_size = header_size - offset;
 		copy_size = min(copy_size, bytes_left);

 		memcpy(buffer, elfcore + offset, copy_size);
 		offset += copy_size;
 		bytes_left -= copy_size;
 		buffer += copy_size;

 		return copy_size;
 	}

 	while (bytes_left) {
 		seg = ath11k_coredump_find_segment(offset - header_size,
 				    segments, dump_state->num_seg,
 				    &data_left);
 		/* End of segments check */
 		if (!seg) {
 			pr_info("Ramdump complete %lld bytes read\n", offset);
 			return 0;
 		}

 		if (data_left)
 			copy_size = min_t(size_t, bytes_left, data_left);
 		else
 			copy_size = bytes_left;

 		addr = seg->vaddr;
 		addr += data_left;
 		memcpy_fromio(buffer, addr, copy_size);

 		offset += copy_size;
 		buffer += copy_size;
 		bytes_left -= copy_size;
 	}

 	return count - bytes_left;
 }

 static void ath11k_coredump_free_q6dump(void *data)
 {
 	struct ath11k_coredump_state *dump_state = data;

 	complete(&dump_state->dump_done);
 }

 void ath11k_coredump_build_inline(struct ath11k_base *ab,
 				  struct ath11k_dump_segment *segments, int num_seg)
 {
 	struct ath11k_coredump_state *dump_state;
 	struct timespec64 timestamp;
 	struct ath11k_dump_file_data *file_data;
 	size_t header_size;
 	struct ath11k_pci *ar_pci = (struct ath11k_pci *)ab->drv_priv;
 	struct device dev;
 	u8 *buf;

 	header_size = sizeof(struct ath11k_dump_file_data);
 	header_size += num_seg * sizeof(*segments);
 	header_size = PAGE_ALIGN(header_size);
 	buf = vzalloc(header_size);
 	if (!buf)
 		return;

 	ATH11K_MEMORY_STATS_INC(ab, malloc_size, header_size);

 	file_data = (struct ath11k_dump_file_data *)buf;
 	strlcpy(file_data->df_magic, "ATH11K-FW-DUMP",
 	        sizeof(file_data->df_magic));
 	file_data->len = cpu_to_le32(header_size);
 	file_data->version = cpu_to_le32(ATH11K_FW_CRASH_DUMP_VERSION);
 	if (ab->hw_rev == ATH11K_HW_QCN6122) {
 		file_data->chip_id = ab->qmi.target.chip_id;
 		file_data->qrtr_id = ab->qmi.service_ins_id;
 		file_data->bus_id = ab->userpd_id;
 		dev = ab->pdev->dev;
 	} else {
 		file_data->chip_id = ar_pci->dev_id;
 		file_data->qrtr_id = ar_pci->ab->qmi.service_ins_id;
 		file_data->bus_id = pci_domain_nr(ar_pci->pdev->bus);
 		dev = ar_pci->pdev->dev;
 	}
 	if (file_data->bus_id > ATH11K_MAX_PCI_DOMAINS)
 		file_data->bus_id = ATH11K_MAX_PCI_DOMAINS;
 	guid_gen(&file_data->guid);
 	ktime_get_real_ts64(&timestamp);
 	file_data->tv_sec = cpu_to_le64(timestamp.tv_sec);
 	file_data->tv_nsec = cpu_to_le64(timestamp.tv_nsec);
 	file_data->num_seg = num_seg;
 	file_data->seg_size = sizeof(*segments);

 	/* copy segment details to file */
 	buf += offsetof(struct ath11k_dump_file_data, seg);
 	file_data->seg =(struct ath11k_dump_segment *)buf;
 	memcpy(file_data->seg, segments, num_seg * sizeof(*segments));

 	dump_state = vzalloc(sizeof(*dump_state));
 	if(!dump_state) {
 		ATH11K_MEMORY_STATS_DEC(ab, malloc_size, header_size);
 		return;
 	}

 	dump_state->header = file_data;
 	dump_state->num_seg = num_seg;
 	dump_state->segments = segments;
 	init_completion(&dump_state->dump_done);

 	dev_coredumpm(&dev, NULL, dump_state, header_size, GFP_KERNEL,
 		      ath11k_coredump_read_q6dump, ath11k_coredump_free_q6dump);

 	/* Wait until the dump is read and free is called */
 	wait_for_completion(&dump_state->dump_done);
 	ATH11K_MEMORY_STATS_DEC(ab, malloc_size, sizeof(*dump_state));
 	ATH11K_MEMORY_STATS_DEC(ab, malloc_size, header_size);
 	vfree(dump_state);
 	vfree(file_data);
 }

 void ath11k_coredump_download_rddm(struct ath11k_base *ab)
 {
 	struct ath11k_pci *ar_pci = (struct ath11k_pci *)ab->drv_priv;
 	struct mhi_controller *mhi_ctrl = ar_pci->mhi_ctrl;
 	struct image_info *rddm_img, *fw_img;
 	struct ath11k_dump_segment *segment, *seg_info;
 	int i, rem_seg_cnt = 0, len, num_seg, seg_sz, qdss_seg_cnt = 1;

 	ath11k_mhi_coredump(mhi_ctrl, false);

 	rddm_img = mhi_ctrl->rddm_image;
 	fw_img = mhi_ctrl->fbc_image;

 	for (i = 0; i < ab->qmi.mem_seg_count; i++) {
 		if (ab->qmi.target_mem[i].type == HOST_DDR_REGION_TYPE ||
 		    (ab->qmi.target_mem[i].type == CALDB_MEM_REGION_TYPE && ab->enable_cold_boot_cal && ab->hw_params.cold_boot_calib) ||
 			ab->qmi.target_mem[i].type == M3_DUMP_REGION_TYPE)
 			rem_seg_cnt++;
 	}

 	num_seg = fw_img->entries + rddm_img->entries + rem_seg_cnt;
 	if (ab->is_qdss_tracing)
 		num_seg += qdss_seg_cnt;

 	len = num_seg * sizeof(*segment);

 	seg_info = segment = (struct ath11k_dump_segment *)vzalloc(len);
 	if (!seg_info)
 		ath11k_warn(ab, "fail to alloc memory for rddm\n");

 	for (i = 0; i < fw_img->entries ; i++) {
 		seg_sz = fw_img->mhi_buf[i].len;
 		seg_info->len = PAGE_ALIGN(seg_sz);
 		seg_info->addr = fw_img->mhi_buf[i].dma_addr;
 		seg_info->vaddr = fw_img->mhi_buf[i].buf;
 		seg_info->type = ATH11K_FW_CRASH_PAGING_DATA;
 		ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
 			    seg_info->vaddr, seg_info->len, seg_info->type);

 		seg_info++;
 	}

 	for (i = 0; i < rddm_img->entries; i++) {
 		seg_sz = rddm_img->mhi_buf[i].len;
 		seg_info->len = PAGE_ALIGN(seg_sz);
 		seg_info->addr = rddm_img->mhi_buf[i].dma_addr;
 		seg_info->vaddr = rddm_img->mhi_buf[i].buf;
 		ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
 			    seg_info->vaddr, seg_info->len, seg_info->type);
 		seg_info->type = ATH11K_FW_CRASH_RDDM_DATA;
 		ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
 			    seg_info->vaddr, seg_info->len, seg_info->type);
 		seg_info++;
 	}

 	for (i = 0; i < ab->qmi.mem_seg_count; i++) {
 		if (ab->qmi.target_mem[i].type == HOST_DDR_REGION_TYPE ||
 		    ab->qmi.target_mem[i].type == M3_DUMP_REGION_TYPE) {
 			seg_info->len = ab->qmi.target_mem[i].size;
 			seg_info->addr = ab->qmi.target_mem[i].paddr;
 			seg_info->vaddr = ab->qmi.target_mem[i].vaddr;
 			seg_info->type = ATH11K_FW_REMOTE_MEM_DATA;
 			ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
 				    seg_info->vaddr, seg_info->len, seg_info->type);
 			seg_info++;
 		}
 	}

 	if (ab->is_qdss_tracing) {
 		seg_info->len = ab->qmi.qdss_mem[0].size;
 		seg_info->addr = ab->qmi.qdss_mem[0].paddr;
 		seg_info->vaddr = ab->qmi.qdss_mem[0].vaddr;
 		seg_info->type = ATH11K_FW_REMOTE_MEM_DATA;
 		ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
 			    seg_info->vaddr, seg_info->len, seg_info->type);
 		seg_info++;
 	}

 	for (i = 0; i < ab->qmi.mem_seg_count; i++) {
 		if (ab->qmi.target_mem[i].type == CALDB_MEM_REGION_TYPE && ab->enable_cold_boot_cal && ab->hw_params.cold_boot_calib) {
 			seg_info->len = ab->qmi.target_mem[i].size;
 			seg_info->addr = ab->qmi.target_mem[i].paddr;
 			seg_info->vaddr = ab->qmi.target_mem[i].vaddr;
 			seg_info->type = ATH11K_FW_REMOTE_MEM_DATA;
 			ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
 				    seg_info->vaddr, seg_info->len, seg_info->type);
 			seg_info++;
 		}
 	}

 	/* Crash the system once all the stats are dumped */
 	if(!ab->fw_recovery_support) {
 		ath11k_core_dump_bp_stats(ab);
 		ath11k_hal_dump_srng_stats(ab);

 		ath11k_coredump_seg_info.chip_id = ar_pci->dev_id;
 		ath11k_coredump_seg_info.qrtr_id = ar_pci->ab->qmi.service_ins_id;
 		ath11k_coredump_seg_info.bus_id = pci_domain_nr(ar_pci->pdev->bus);
 		ath11k_coredump_seg_info.num_seg = num_seg;
 		ath11k_coredump_seg_info.seg = segment;

 		BUG_ON(1);
 	} else {
 		ath11k_coredump_build_inline(ab, segment, num_seg);
 	}

 	vfree(segment);
 }

 void ath11k_coredump_qdss_dump(struct ath11k_base *ab,
 			       struct ath11k_qmi_event_qdss_trace_save_data *event_data)
 {
 	struct ath11k_dump_segment *segment;
 	struct ath11k_dump_file_data *file_data;
 	size_t header_size;
 	int i, buf_sz, num_seg;
 	u8 *dump;

 	num_seg = event_data->mem_seg_len;
 	header_size = sizeof(*file_data);
 	header_size += num_seg * sizeof(*segment);
 	header_size = PAGE_ALIGN(header_size);
 	buf_sz = header_size + ab->qmi.qdss_mem[0].size;

 	dump = vzalloc(buf_sz);

 	if (!dump) {
 		ath11k_warn(ab, "Failed to allocate memory for qdss dump\n");
 		return;
 	}

 	file_data = (struct ath11k_dump_file_data *)dump;
 	ath11k_coredump_update_hdr(ab, file_data, header_size);

 	file_data->num_seg = cpu_to_le32(num_seg);
 	file_data->seg_size = cpu_to_le32(sizeof(*segment));

 	segment = (struct ath11k_dump_segment *)dump +
 		   offsetof(struct ath11k_dump_file_data, data);

 	for (i = 0; i < num_seg; i++) {
 		segment->len = event_data->mem_seg[i].size;
 		segment->vaddr = ab->qmi.qdss_mem[0].vaddr;
 		segment->addr = ab->qmi.qdss_mem[0].paddr;
 		segment->type = ATH11K_FW_QDSS_DATA;
 		segment++;
 	}

 	memcpy(dump + header_size, ab->qmi.qdss_mem[0].vaddr,
 		   event_data->mem_seg[0].size);

 	dev_coredumpv(ab->dev, dump, buf_sz, GFP_KERNEL);
 }
	// SPDX-License-Identifier: BSD-3-Clause-Clear
	/**
	* Copyright (c) 2020 The Linux Foundation. All rights reserved.
	*/

	#include <linux/devcoredump.h>
	#include <linux/platform_device.h>
	#include <linux/dma-direction.h>
	#include <linux/mhi.h>
	#include <linux/pci.h>
	#include <linux/mm.h>
	#include <linux/uuid.h>
	#include <linux/time.h>
	#include "core.h"
	#include "coredump.h"
	#include "pci.h"
	#include "mhi.h"
	#include "debug.h"

	struct ath11k_coredump_segment_info ath11k_coredump_seg_info;
	EXPORT_SYMBOL(ath11k_coredump_seg_info);

	static void ath11k_coredump_update_hdr(struct ath11k_base *ab,
	struct ath11k_dump_file_data *file_data,
	size_t header_size)
	{
	struct timespec64 timestamp;

	strscpy(file_data->df_magic, "ATH11K-FW-DUMP",
	sizeof(file_data->df_magic));
	file_data->len = cpu_to_le32(header_size);
	file_data->version = cpu_to_le32(ATH11K_FW_CRASH_DUMP_VERSION);
	guid_gen(&file_data->guid);
	ktime_get_real_ts64(&timestamp);
	file_data->tv_sec = cpu_to_le64(timestamp.tv_sec);
	file_data->tv_nsec = cpu_to_le64(timestamp.tv_nsec);
	}

	static void *ath11k_coredump_find_segment(loff_t user_offset,
	struct ath11k_dump_segment *segment,
	int phnum, size_t *data_left)
	{
	int i;

	for (i = 0; i < phnum; i++, segment++) {
	if (user_offset < segment->len) {
	*data_left = user_offset;
	return segment;
	}
	user_offset -= segment->len;
	}

	*data_left = 0;
	return NULL;
	}

	static ssize_t ath11k_coredump_read_q6dump(char *buffer, loff_t offset, size_t count,
	void *data, size_t header_size)
	{
	struct ath11k_coredump_state *dump_state = data;
	struct ath11k_dump_segment *segments = dump_state->segments;
	struct ath11k_dump_segment *seg;
	void *elfcore = dump_state->header;
	size_t data_left, copy_size, bytes_left = count;
	void __iomem *addr;

	/* Copy the header first */
	if (offset < header_size) {
	copy_size = header_size - offset;
	copy_size = min(copy_size, bytes_left);

	memcpy(buffer, elfcore + offset, copy_size);
	offset += copy_size;
	bytes_left -= copy_size;
	buffer += copy_size;

	return copy_size;
	}

	while (bytes_left) {
	seg = ath11k_coredump_find_segment(offset - header_size,
	segments, dump_state->num_seg,
	&data_left);
	/* End of segments check */
	if (!seg) {
	pr_info("Ramdump complete %lld bytes read\n", offset);
	return 0;
	}

	if (data_left)
	copy_size = min_t(size_t, bytes_left, data_left);
	else
	copy_size = bytes_left;

	addr = seg->vaddr;
	addr += data_left;
	memcpy_fromio(buffer, addr, copy_size);

	offset += copy_size;
	buffer += copy_size;
	bytes_left -= copy_size;
	}

	return count - bytes_left;
	}

	static void ath11k_coredump_free_q6dump(void *data)
	{
	struct ath11k_coredump_state *dump_state = data;

	complete(&dump_state->dump_done);
	}

	void ath11k_coredump_build_inline(struct ath11k_base *ab,
	struct ath11k_dump_segment *segments, int num_seg)
	{
	struct ath11k_coredump_state *dump_state;
	struct timespec64 timestamp;
	struct ath11k_dump_file_data *file_data;
	size_t header_size;
	struct ath11k_pci ar_pci = (struct ath11k_pci )ab->drv_priv;
	struct device dev;
	u8 *buf;

	header_size = sizeof(struct ath11k_dump_file_data);
	header_size += num_seg * sizeof(*segments);
	header_size = PAGE_ALIGN(header_size);
	buf = vzalloc(header_size);
	if (!buf)
	return;

	ATH11K_MEMORY_STATS_INC(ab, malloc_size, header_size);

	file_data = (struct ath11k_dump_file_data *)buf;
	strlcpy(file_data->df_magic, "ATH11K-FW-DUMP",
	sizeof(file_data->df_magic));
	file_data->len = cpu_to_le32(header_size);
	file_data->version = cpu_to_le32(ATH11K_FW_CRASH_DUMP_VERSION);
	if (ab->hw_rev == ATH11K_HW_QCN6122) {
	file_data->chip_id = ab->qmi.target.chip_id;
	file_data->qrtr_id = ab->qmi.service_ins_id;
	file_data->bus_id = ab->userpd_id;
	dev = ab->pdev->dev;
	} else {
	file_data->chip_id = ar_pci->dev_id;
	file_data->qrtr_id = ar_pci->ab->qmi.service_ins_id;
	file_data->bus_id = pci_domain_nr(ar_pci->pdev->bus);
	dev = ar_pci->pdev->dev;
	}
	if (file_data->bus_id > ATH11K_MAX_PCI_DOMAINS)
	file_data->bus_id = ATH11K_MAX_PCI_DOMAINS;
	guid_gen(&file_data->guid);
	ktime_get_real_ts64(&timestamp);
	file_data->tv_sec = cpu_to_le64(timestamp.tv_sec);
	file_data->tv_nsec = cpu_to_le64(timestamp.tv_nsec);
	file_data->num_seg = num_seg;
	file_data->seg_size = sizeof(*segments);

	/* copy segment details to file */
	buf += offsetof(struct ath11k_dump_file_data, seg);
	file_data->seg =(struct ath11k_dump_segment *)buf;
	memcpy(file_data->seg, segments, num_seg * sizeof(*segments));

	dump_state = vzalloc(sizeof(*dump_state));
	if(!dump_state) {
	ATH11K_MEMORY_STATS_DEC(ab, malloc_size, header_size);
	return;
	}

	dump_state->header = file_data;
	dump_state->num_seg = num_seg;
	dump_state->segments = segments;
	init_completion(&dump_state->dump_done);

	dev_coredumpm(&dev, NULL, dump_state, header_size, GFP_KERNEL,
	ath11k_coredump_read_q6dump, ath11k_coredump_free_q6dump);

	/* Wait until the dump is read and free is called */
	wait_for_completion(&dump_state->dump_done);
	ATH11K_MEMORY_STATS_DEC(ab, malloc_size, sizeof(*dump_state));
	ATH11K_MEMORY_STATS_DEC(ab, malloc_size, header_size);
	vfree(dump_state);
	vfree(file_data);
	}

	void ath11k_coredump_download_rddm(struct ath11k_base *ab)
	{
	struct ath11k_pci ar_pci = (struct ath11k_pci )ab->drv_priv;
	struct mhi_controller *mhi_ctrl = ar_pci->mhi_ctrl;
	struct image_info rddm_img, fw_img;
	struct ath11k_dump_segment segment, seg_info;
	int i, rem_seg_cnt = 0, len, num_seg, seg_sz, qdss_seg_cnt = 1;

	ath11k_mhi_coredump(mhi_ctrl, false);

	rddm_img = mhi_ctrl->rddm_image;
	fw_img = mhi_ctrl->fbc_image;

	for (i = 0; i < ab->qmi.mem_seg_count; i++) {
	if (ab->qmi.target_mem[i].type == HOST_DDR_REGION_TYPE \|\|
	(ab->qmi.target_mem[i].type == CALDB_MEM_REGION_TYPE && ab->enable_cold_boot_cal && ab->hw_params.cold_boot_calib) \|\|
	ab->qmi.target_mem[i].type == M3_DUMP_REGION_TYPE)
	rem_seg_cnt++;
	}

	num_seg = fw_img->entries + rddm_img->entries + rem_seg_cnt;
	if (ab->is_qdss_tracing)
	num_seg += qdss_seg_cnt;

	len = num_seg * sizeof(*segment);

	seg_info = segment = (struct ath11k_dump_segment *)vzalloc(len);
	if (!seg_info)
	ath11k_warn(ab, "fail to alloc memory for rddm\n");

	for (i = 0; i < fw_img->entries ; i++) {
	seg_sz = fw_img->mhi_buf[i].len;
	seg_info->len = PAGE_ALIGN(seg_sz);
	seg_info->addr = fw_img->mhi_buf[i].dma_addr;
	seg_info->vaddr = fw_img->mhi_buf[i].buf;
	seg_info->type = ATH11K_FW_CRASH_PAGING_DATA;
	ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
	seg_info->vaddr, seg_info->len, seg_info->type);

	seg_info++;
	}

	for (i = 0; i < rddm_img->entries; i++) {
	seg_sz = rddm_img->mhi_buf[i].len;
	seg_info->len = PAGE_ALIGN(seg_sz);
	seg_info->addr = rddm_img->mhi_buf[i].dma_addr;
	seg_info->vaddr = rddm_img->mhi_buf[i].buf;
	ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
	seg_info->vaddr, seg_info->len, seg_info->type);
	seg_info->type = ATH11K_FW_CRASH_RDDM_DATA;
	ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
	seg_info->vaddr, seg_info->len, seg_info->type);
	seg_info++;
	}

	for (i = 0; i < ab->qmi.mem_seg_count; i++) {
	if (ab->qmi.target_mem[i].type == HOST_DDR_REGION_TYPE \|\|
	ab->qmi.target_mem[i].type == M3_DUMP_REGION_TYPE) {
	seg_info->len = ab->qmi.target_mem[i].size;
	seg_info->addr = ab->qmi.target_mem[i].paddr;
	seg_info->vaddr = ab->qmi.target_mem[i].vaddr;
	seg_info->type = ATH11K_FW_REMOTE_MEM_DATA;
	ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
	seg_info->vaddr, seg_info->len, seg_info->type);
	seg_info++;
	}
	}

	if (ab->is_qdss_tracing) {
	seg_info->len = ab->qmi.qdss_mem[0].size;
	seg_info->addr = ab->qmi.qdss_mem[0].paddr;
	seg_info->vaddr = ab->qmi.qdss_mem[0].vaddr;
	seg_info->type = ATH11K_FW_REMOTE_MEM_DATA;
	ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
	seg_info->vaddr, seg_info->len, seg_info->type);
	seg_info++;
	}

	for (i = 0; i < ab->qmi.mem_seg_count; i++) {
	if (ab->qmi.target_mem[i].type == CALDB_MEM_REGION_TYPE && ab->enable_cold_boot_cal && ab->hw_params.cold_boot_calib) {
	seg_info->len = ab->qmi.target_mem[i].size;
	seg_info->addr = ab->qmi.target_mem[i].paddr;
	seg_info->vaddr = ab->qmi.target_mem[i].vaddr;
	seg_info->type = ATH11K_FW_REMOTE_MEM_DATA;
	ath11k_info(ab, "seg vaddr is %px len is 0x%x type %d\n",
	seg_info->vaddr, seg_info->len, seg_info->type);
	seg_info++;
	}
	}

	/* Crash the system once all the stats are dumped */
	if(!ab->fw_recovery_support) {
	ath11k_core_dump_bp_stats(ab);
	ath11k_hal_dump_srng_stats(ab);

	ath11k_coredump_seg_info.chip_id = ar_pci->dev_id;
	ath11k_coredump_seg_info.qrtr_id = ar_pci->ab->qmi.service_ins_id;
	ath11k_coredump_seg_info.bus_id = pci_domain_nr(ar_pci->pdev->bus);
	ath11k_coredump_seg_info.num_seg = num_seg;
	ath11k_coredump_seg_info.seg = segment;

	BUG_ON(1);
	} else {
	ath11k_coredump_build_inline(ab, segment, num_seg);
	}

	vfree(segment);
	}

	void ath11k_coredump_qdss_dump(struct ath11k_base *ab,
	struct ath11k_qmi_event_qdss_trace_save_data *event_data)
	{
	struct ath11k_dump_segment *segment;
	struct ath11k_dump_file_data *file_data;
	size_t header_size;
	int i, buf_sz, num_seg;
	u8 *dump;

	num_seg = event_data->mem_seg_len;
	header_size = sizeof(*file_data);
	header_size += num_seg * sizeof(*segment);
	header_size = PAGE_ALIGN(header_size);
	buf_sz = header_size + ab->qmi.qdss_mem[0].size;

	dump = vzalloc(buf_sz);

	if (!dump) {
	ath11k_warn(ab, "Failed to allocate memory for qdss dump\n");
	return;
	}

	file_data = (struct ath11k_dump_file_data *)dump;
	ath11k_coredump_update_hdr(ab, file_data, header_size);

	file_data->num_seg = cpu_to_le32(num_seg);
	file_data->seg_size = cpu_to_le32(sizeof(*segment));

	segment = (struct ath11k_dump_segment *)dump +
	offsetof(struct ath11k_dump_file_data, data);

	for (i = 0; i < num_seg; i++) {
	segment->len = event_data->mem_seg[i].size;
	segment->vaddr = ab->qmi.qdss_mem[0].vaddr;
	segment->addr = ab->qmi.qdss_mem[0].paddr;
	segment->type = ATH11K_FW_QDSS_DATA;
	segment++;
	}

	memcpy(dump + header_size, ab->qmi.qdss_mem[0].vaddr,
	event_data->mem_seg[0].size);

	dev_coredumpv(ab->dev, dump, buf_sz, GFP_KERNEL);
	}