/*
 * Copyright (C) 2017 Spreadtrum Communications Inc.
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */

#include <linux/delay.h>
#include <linux/file.h>
#include <linux/fs.h>
#ifdef CONFIG_SC2342_INTEG
#include <linux/gnss.h>
#endif
#include <linux/kthread.h>
#include <linux/printk.h>
#ifdef CONFIG_WCN_SIPC
#include <linux/sipc.h>
#endif
#include <linux/slab.h>
#include <linux/syscalls.h>
#include <linux/unistd.h>
#include <linux/wait.h>
#include <marlin_platform.h>
#include <wcn_bus.h>

#include "gnss_common.h"
#include "gnss_dump.h"
#include "mdbg_type.h"
#include "wcn_glb.h"
#include "wcn_glb_reg.h"

#define GNSSDUMP_INFO(format, arg...) pr_info("gnss_dump: " format, ## arg)
#define GNSSDUMP_ERR(format, arg...) pr_err("gnss_dump: " format, ## arg)

static struct file *gnss_dump_file;
static	loff_t pos;
#define GNSS_MEMDUMP_PATH			"/data/vendor/gnss/gnssdump.mem"

#ifndef CONFIG_SC2342_INTEG
struct gnss_mem_dump {
	uint address;
	uint length;
};

/* dump cp firmware firstly, wait for next adding */
static struct gnss_mem_dump gnss_marlin3_dump[] = {
#ifndef CONFIG_CHECK_DRIVER_BY_CHIPID
	{GNSS_CP_START_ADDR, GNSS_FIRMWARE_MAX_SIZE}, /* gnss firmware code */
#else
	{0,0},
#endif
	{GNSS_DRAM_ADDR, GNSS_DRAM_SIZE}, /* gnss dram */
	{GNSS_TE_MEM, GNSS_TE_MEM_SIZE}, /* gnss te mem */
	{GNSS_BASE_AON_APB, GNSS_BASE_AON_APB_SIZE}, /* aon apb */
	{CTL_BASE_AON_CLOCK, CTL_BASE_AON_CLOCK_SIZE}, /* aon clock */
};
#else
struct regmap_dump {
	int regmap_type;
	uint reg;
};
/* for sharkle ap reg dump, this order format can't change, just do it */
static struct regmap_dump gnss_sharkle_ap_reg[] = {
	{REGMAP_PMU_APB, 0x00cc}, /* REG_PMU_APB_SLEEP_CTRL */
	{REGMAP_PMU_APB, 0x00d4}, /* REG_PMU_APB_SLEEP_STATUS */
	{REGMAP_AON_APB, 0x057c}, /* REG_AON_APB_WCN_SYS_CFG2 */
	{REGMAP_AON_APB, 0x0578}, /* REG_AON_APB_WCN_SYS_CFG1 */
	{REGMAP_TYPE_NR, (AON_CLK_CORE + CGM_WCN_SHARKLE_CFG)}, /* clk */
	{REGMAP_PMU_APB, 0x0100}, /* REG_PMU_APB_PD_WCN_SYS_CFG */
	{REGMAP_PMU_APB, 0x0104}, /* REG_PMU_APB_PD_WIFI_WRAP_CFG */
	{REGMAP_PMU_APB, 0x0108}, /* REG_PMU_APB_PD_GNSS_WRAP_CFG */
};

/* for pike2 ap reg dump, this order format can't change, just do it */
static struct regmap_dump gnss_pike2_ap_reg[] = {
	{REGMAP_PMU_APB, 0x00cc}, /* REG_PMU_APB_SLEEP_CTRL */
	{REGMAP_PMU_APB, 0x00d4}, /* REG_PMU_APB_SLEEP_STATUS */
	{REGMAP_PMU_APB, 0x0338}, /* REG_PMU_APB_WCN_SYS_CFG_STATUS */
	{REGMAP_AON_APB, 0x00d8}, /* REG_AON_APB_WCN_CONFIG0 */
	{REGMAP_TYPE_NR, (AON_CLK_CORE + CGM_WCN_PIKE2_CFG)}, /* clk */
	{REGMAP_PMU_APB, 0x0050}, /* REG_PMU_APB_PD_WCN_TOP_CFG */
	{REGMAP_PMU_APB, 0x0054}, /* REG_PMU_APB_PD_WCN_WIFI_CFG */
	{REGMAP_PMU_APB, 0x0058}, /* REG_PMU_APB_PD_WCN_GNSS_CFG */
};


/* for sharkl3 ap reg dump, this order format can't change, just do it */
static struct regmap_dump gnss_sharkl3_ap_reg[] = {
	{REGMAP_PMU_APB, 0x00cc}, /* REG_PMU_APB_SLEEP_CTRL */
	{REGMAP_PMU_APB, 0x00d4}, /* REG_PMU_APB_SLEEP_STATUS */
	{REGMAP_AON_APB, 0x057c}, /* REG_AON_APB_WCN_SYS_CFG2 */
	{REGMAP_AON_APB, 0x0578}, /* REG_AON_APB_WCN_SYS_CFG1 */
	{REGMAP_TYPE_NR, (AON_CLK_CORE + CGM_WCN_SHARKLE_CFG)}, /* clk */
	{REGMAP_PMU_APB, 0x0100}, /* REG_PMU_APB_PD_WCN_SYS_CFG */
	{REGMAP_PMU_APB, 0x0104}, /* REG_PMU_APB_PD_WIFI_WRAP_CFG */
	{REGMAP_PMU_APB, 0x0108}, /* REG_PMU_APB_PD_GNSS_WRAP_CFG */
};
#define GNSS_DUMP_REG_NUMBER 8
static char gnss_dump_level; /* 0: default, all, 1: only data, pmu, aon */

#endif


static int wcn_chmod(char *path, char *mode)
{
	int result = 0;
	char cmd_path[] = "/system/bin/chmod";
	char *cmd_argv[] = {cmd_path, mode, path, NULL};
	char *cmd_envp[] = {"HOME=/", "PATH=/sbin:/bin:/system/bin", NULL};

	result = call_usermodehelper(cmd_path, cmd_argv, cmd_envp,
		UMH_WAIT_PROC);

	return result;
}

static int gnss_creat_gnss_dump_file(void)
{
	gnss_dump_file = filp_open(GNSS_MEMDUMP_PATH,
		O_RDWR | O_CREAT | O_TRUNC, 0666);
	GNSSDUMP_INFO("gnss_creat_gnss_dump_file entry\n");
	if (IS_ERR(gnss_dump_file)) {
		GNSSDUMP_ERR("%s error is %p\n",
			__func__, gnss_dump_file);
		return -1;
	}
	if (wcn_chmod(GNSS_MEMDUMP_PATH, "0666") != 0)
		GNSSDUMP_ERR("%s chmod	error\n", __func__);

	return 0;
}

#ifdef CONFIG_SC2342_INTEG
static void gnss_write_data_to_phy_addr(phys_addr_t phy_addr,
					      void *src_data, u32 size)
{
	void *virt_addr;

	GNSSDUMP_INFO("gnss_write_data_to_phy_addr entry\n");
	virt_addr = shmem_ram_vmap_nocache(phy_addr, size);
	if (virt_addr) {
		memcpy(virt_addr, src_data, size);
		shmem_ram_unmap(virt_addr);
	} else
		GNSSDUMP_ERR("%s shmem_ram_vmap_nocache fail\n", __func__);
}

static void gnss_read_data_from_phy_addr(phys_addr_t phy_addr,
					  void *tar_data, u32 size)
{
	void *virt_addr;

	GNSSDUMP_INFO("gnss_read_data_from_phy_addr\n");
	virt_addr = shmem_ram_vmap_nocache(phy_addr, size);
	if (virt_addr) {
		memcpy(tar_data, virt_addr, size);
		shmem_ram_unmap(virt_addr);
	} else
		GNSSDUMP_ERR("%s shmem_ram_vmap_nocache fail\n", __func__);
}

static void gnss_hold_cpu(void)
{
	struct regmap *regmap;
	u32 value;
	phys_addr_t base_addr;
	int i = 0;

	GNSSDUMP_INFO("gnss_hold_cpu entry\n");
	if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKL3)
		regmap = wcn_get_gnss_regmap(REGMAP_WCN_REG);
	else
		regmap = wcn_get_gnss_regmap(REGMAP_ANLG_WRAP_WCN);
	wcn_regmap_read(regmap, 0X20, &value);
	value |= 1 << 2;
	wcn_regmap_raw_write_bit(regmap, 0X20, value);

	wcn_regmap_read(regmap, 0X24, &value);
	value |= 1 << 3;
	wcn_regmap_raw_write_bit(regmap, 0X24, value);

	value = GNSS_CACHE_FLAG_VALUE;
	base_addr = wcn_get_gnss_base_addr();
	gnss_write_data_to_phy_addr(base_addr + GNSS_CACHE_FLAG_ADDR,
		(void *)&value, 4);

	value = 0;
	wcn_regmap_raw_write_bit(regmap, 0X20, value);
	wcn_regmap_raw_write_bit(regmap, 0X24, value);
	while (i < 3) {
		gnss_read_data_from_phy_addr(base_addr + GNSS_CACHE_FLAG_ADDR,
			(void *)&value, 4);
		if (value == GNSS_CACHE_END_VALUE)
			break;
		i++;
		msleep(50);
	}
	if (value != GNSS_CACHE_END_VALUE)
		GNSSDUMP_ERR("%s gnss cache failed value %d\n", __func__,
			value);

	msleep(200);
}

static int gnss_dump_cp_register_data(u32 addr, u32 len)
{
	struct regmap *regmap;
	u32 i;
	u8 *buf = NULL;
	u8 *ptr = NULL;
	long int ret;
	void  *iram_buffer = NULL;
	mm_segment_t fs;

	GNSSDUMP_INFO(" start dump cp register!addr:%x,len:%d\n", addr, len);
	buf = kzalloc(len, GFP_KERNEL);
	if (!buf) {
		GNSSDUMP_ERR("%s kzalloc buf error\n", __func__);
		return -ENOMEM;
	}

	if (IS_ERR(gnss_dump_file)) {
		gnss_dump_file = filp_open(GNSS_MEMDUMP_PATH,
			O_RDWR | O_CREAT | O_APPEND, 0666);
		if (IS_ERR(gnss_dump_file)) {
			GNSSDUMP_ERR("%s  open file mem error\n", __func__);
			kfree(buf);
			return PTR_ERR(gnss_dump_file);
		}
	}

	iram_buffer = vmalloc(len);
	if (!iram_buffer) {
		GNSSDUMP_ERR("%s vmalloc iram_buffer error\n", __func__);
		kfree(buf);
		return -ENOMEM;
	}
	memset(iram_buffer, 0, len);

	/* can't op cp reg when level is 1, just record 0 to buffer */
	if (gnss_dump_level == 0) {
		if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKL3)
			regmap = wcn_get_gnss_regmap(REGMAP_WCN_REG);
		else
			regmap = wcn_get_gnss_regmap(REGMAP_ANLG_WRAP_WCN);
		wcn_regmap_raw_write_bit(regmap, ANLG_WCN_WRITE_ADDR, addr);
		for (i = 0; i < len / 4; i++) {
			ptr = buf + i * 4;
			wcn_regmap_read(regmap, ANLG_WCN_READ_ADDR, (u32 *)ptr);
		}
		memcpy(iram_buffer, buf, len);
	}
	fs = get_fs();
	set_fs(KERNEL_DS);
	pos = gnss_dump_file->f_pos;
	ret = vfs_write(gnss_dump_file, iram_buffer, len, &pos);
	gnss_dump_file->f_pos = pos;
	kfree(buf);
	vfree(iram_buffer);
	set_fs(fs);
	if (ret != len) {
		GNSSDUMP_ERR("gnss_dump_cp_register_data failed  size is %ld\n",
			ret);
		return -1;
	}
	GNSSDUMP_INFO("gnss_dump_cp_register_data finish  size is  %ld\n",
		ret);

	return ret;
}


static int gnss_dump_ap_register(void)
{
	struct regmap *regmap;
	u32 value[GNSS_DUMP_REG_NUMBER + 1] = {0}; /* [0]board+ [..]reg */
	u32 i = 0;
	mm_segment_t fs;
	u32 len = 0;
	u8 *ptr = NULL;
	int ret;
	void  *apreg_buffer = NULL;
	struct regmap_dump *gnss_ap_reg = NULL;

	GNSSDUMP_INFO("%s ap reg data\n", __func__);
	if (IS_ERR(gnss_dump_file)) {
		gnss_dump_file = filp_open(GNSS_MEMDUMP_PATH,
			O_RDWR | O_CREAT | O_APPEND, 0666);
		if (IS_ERR(gnss_dump_file)) {
			GNSSDUMP_ERR("%s open file mem error\n", __func__);
			return -1;
		}
	}

	if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKLE) {
		gnss_ap_reg = gnss_sharkle_ap_reg;
		len = (GNSS_DUMP_REG_NUMBER + 1) * sizeof(u32);
	} else if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_PIKE2) {
		gnss_ap_reg = gnss_pike2_ap_reg;
		len = (GNSS_DUMP_REG_NUMBER + 1) * sizeof(u32);
	} else {
		gnss_ap_reg = gnss_sharkl3_ap_reg;
		len = (GNSS_DUMP_REG_NUMBER + 1) * sizeof(u32);
	}

	apreg_buffer = vmalloc(len);
	if (!apreg_buffer)
		return -2;

	ptr = (u8 *)&value[0];
	if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKLE)
		value[0] = 0xF1;
	else if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_PIKE2)
		value[0] = 0xF2;
	else
		value[0] = 0xF3;

	for (i = 0; i < GNSS_DUMP_REG_NUMBER; i++) {
		if ((gnss_ap_reg + i)->regmap_type == REGMAP_TYPE_NR) {
			gnss_read_data_from_phy_addr((gnss_ap_reg + i)->reg,
				&value[i+1], 4);
		} else {
			regmap =
			wcn_get_gnss_regmap((gnss_ap_reg + i)->regmap_type);
			wcn_regmap_read(regmap, (gnss_ap_reg + i)->reg,
				&value[i+1]);
		}
	}
	memset(apreg_buffer, 0, len);
	memcpy(apreg_buffer, ptr, len);
	fs = get_fs();
	set_fs(KERNEL_DS);
	pos = gnss_dump_file->f_pos;
	ret = vfs_write(gnss_dump_file, apreg_buffer, len, &pos);
	gnss_dump_file->f_pos = pos;
	vfree(apreg_buffer);
	set_fs(fs);
	if (ret != len)
		GNSSDUMP_ERR("%s not write completely,ret is 0x%x\n", __func__,
			ret);

	return 0;
}

static void gnss_dump_cp_register(void)
{
	u32 count;

	count = gnss_dump_cp_register_data(DUMP_REG_GNSS_APB_CTRL_ADDR,
			DUMP_REG_GNSS_APB_CTRL_LEN);
	GNSSDUMP_INFO("gnss dump gnss_apb_ctrl_reg %u ok!\n", count);

	count = gnss_dump_cp_register_data(DUMP_REG_GNSS_AHB_CTRL_ADDR,
			DUMP_REG_GNSS_AHB_CTRL_LEN);
	GNSSDUMP_INFO("gnss dump manu_clk_ctrl_reg %u ok!\n", count);

	count = gnss_dump_cp_register_data(DUMP_COM_SYS_CTRL_ADDR,
			DUMP_COM_SYS_CTRL_LEN);
	GNSSDUMP_INFO("gnss dump com_sys_ctrl_reg %u ok!\n", count);

	count = gnss_dump_cp_register_data(DUMP_WCN_CP_CLK_CORE_ADDR,
			DUMP_WCN_CP_CLK_LEN);
	GNSSDUMP_INFO("gnss dump manu_clk_ctrl_reg %u ok!\n", count);
}

static void gnss_dump_register(void)
{
	gnss_dump_ap_register();
	gnss_dump_cp_register();
	GNSSDUMP_INFO("gnss dump register ok!\n");
}

static void gnss_dump_iram(void)
{
	u32 count;

	count = gnss_dump_cp_register_data(GNSS_DUMP_IRAM_START_ADDR,
			GNSS_CP_IRAM_DATA_NUM * 4);
	GNSSDUMP_INFO("gnss dump iram %u ok!\n", count);
}

static int gnss_dump_share_memory(u32 len)
{
	void *virt_addr;
	phys_addr_t base_addr;
	long int ret;
	mm_segment_t fs;
	void  *ddr_buffer = NULL;

	if (len == 0)
		return -1;
	GNSSDUMP_INFO("gnss_dump_share_memory\n");
	fs = get_fs();
	set_fs(KERNEL_DS);
	base_addr = wcn_get_gnss_base_addr();
	virt_addr = shmem_ram_vmap_nocache(base_addr, len);
	if (!virt_addr) {
		GNSSDUMP_ERR(" %s shmem_ram_vmap_nocache fail\n", __func__);
		return -1;
	}

	if (IS_ERR(gnss_dump_file)) {
		gnss_dump_file = filp_open(GNSS_MEMDUMP_PATH,
			O_RDWR | O_CREAT | O_APPEND, 0666);
		if (IS_ERR(gnss_dump_file)) {
			GNSSDUMP_ERR("%s open file mem error\n", __func__);
			return PTR_ERR(gnss_dump_file);
		}
	}

	ddr_buffer = vmalloc(len);
	if (!ddr_buffer) {
		GNSSDUMP_ERR(" %s vmalloc ddr_buffer fail\n", __func__);
		return -1;
	}
	memset(ddr_buffer, 0, len);
	memcpy(ddr_buffer, virt_addr, len);
	pos = gnss_dump_file->f_pos;
	ret = vfs_write(gnss_dump_file, ddr_buffer, len, &pos);
	gnss_dump_file->f_pos = pos;
	shmem_ram_unmap(virt_addr);
	set_fs(fs);
	vfree(ddr_buffer);
	if (ret != len) {
		GNSSDUMP_ERR("%s dump ddr error,data len is %ld\n", __func__,
			ret);
		return -1;
	}

	GNSSDUMP_INFO("gnss dump share memory  size = %ld\n", ret);

	return 0;
}

static int gnss_integrated_dump_mem(void)
{
	int ret = 0;

	GNSSDUMP_INFO("gnss_dump_mem entry\n");
	gnss_hold_cpu();
	ret = gnss_creat_gnss_dump_file();
	if (ret == -1) {
		GNSSDUMP_ERR("%s create mem dump file  error\n", __func__);
		return -1;
	}
	ret = gnss_dump_share_memory(GNSS_SHARE_MEMORY_SIZE);
	gnss_dump_iram();
	gnss_dump_register();
	if (gnss_dump_file != NULL)
		filp_close(gnss_dump_file, NULL);

	return ret;
}

#else
static int gnss_ext_hold_cpu(void)
{
	uint temp = 0;
	int ret = 0;

	GNSSDUMP_INFO("%s entry\n", __func__);
	temp = BIT_GNSS_APB_MCU_AP_RST_SOFT;
	ret = sprdwcn_bus_reg_write(REG_GNSS_APB_MCU_AP_RST + GNSS_SET_OFFSET,
		&temp, 4);
	if (ret < 0) {
		GNSSDUMP_ERR("%s write reset reg error:%d\n", __func__, ret);
		return ret;
	}
	temp = GNSS_ARCH_EB_REG_BYPASS;
	ret = sprdwcn_bus_reg_write(GNSS_ARCH_EB_REG + GNSS_SET_OFFSET,
				    &temp, 4);
	if (ret < 0)
		GNSSDUMP_ERR("%s write bypass reg error:%d\n", __func__, ret);

	return ret;
}

static int gnss_ext_dump_data(unsigned int start_addr, int len)
{
	u8 *buf = NULL;
	int ret = 0, count = 0, trans = 0;
	mm_segment_t fs;

	GNSSDUMP_INFO("%s, addr:%x,len:%d\n", __func__, start_addr, len);
	buf = kzalloc(DUMP_PACKET_SIZE, GFP_KERNEL);
	if (!buf) {
		GNSSDUMP_ERR("%s kzalloc buf error\n", __func__);
		return -ENOMEM;
	}

	if (IS_ERR(gnss_dump_file)) {
		gnss_dump_file = filp_open(GNSS_MEMDUMP_PATH,
			O_RDWR | O_CREAT | O_APPEND, 0666);
		if (IS_ERR(gnss_dump_file)) {
			GNSSDUMP_ERR("%s  open file mem error\n", __func__);
			kfree(buf);
			return PTR_ERR(gnss_dump_file);
		}
	}
	fs = get_fs();
	set_fs(KERNEL_DS);
	while (count < len) {
		trans = (len - count) > DUMP_PACKET_SIZE ?
				 DUMP_PACKET_SIZE : (len - count);
		ret = sprdwcn_bus_direct_read(start_addr + count, buf, trans);
		if (ret < 0) {
			GNSSDUMP_ERR("%s read error:%d\n", __func__, ret);
			goto dump_data_done;
		}
		count += trans;
		pos = gnss_dump_file->f_pos;
		ret = vfs_write(gnss_dump_file, buf, trans, &pos);
		gnss_dump_file->f_pos = pos;
		if (ret != trans) {
			GNSSDUMP_ERR("%s failed size is %d, ret %d\n", __func__,
				      len, ret);
			goto dump_data_done;
		}
	}
	GNSSDUMP_INFO("%s finish %d\n", __func__, len);
	ret = 0;

dump_data_done:
	kfree(buf);
	set_fs(fs);
	return ret;
}

static int gnss_ext_dump_mem(void)
{
	int ret = 0;
	int i = 0;

	GNSSDUMP_INFO("%s entry\n", __func__);
// #ifdef CONFIG_CHECK_DRIVER_BY_CHIPID
	/*update the two address after get chip type*/
	gnss_marlin3_dump[0].address = GNSS_CP_START_ADDR;
	gnss_marlin3_dump[0].length = GNSS_FIRMWARE_MAX_SIZE;
// #endif
	gnss_ext_hold_cpu();
	ret = gnss_creat_gnss_dump_file();
	if (ret == -1) {
		GNSSDUMP_ERR("%s create file error\n", __func__);
		return -1;
	}
	for (i = 0; i < ARRAY_SIZE(gnss_marlin3_dump); i++)
		if (gnss_ext_dump_data(gnss_marlin3_dump[i].address,
			gnss_marlin3_dump[i].length)) {
			GNSSDUMP_ERR("%s dumpdata i %d error\n", __func__, i);
			break;
		}
	if (gnss_dump_file != NULL)
		filp_close(gnss_dump_file, NULL);
	return ret;
}
#endif

int gnss_dump_mem(char flag)
{
#ifdef CONFIG_SC2342_INTEG
	gnss_dump_level = flag;
	return gnss_integrated_dump_mem();
#else
	return gnss_ext_dump_mem();
#endif
}