#include "sv6621s_mem_map.h"
#include "skw_log_to_file.h"

struct memory_segment {
	const char 	*name;
	uint32_t 	address;
	uint32_t 	size;
};

struct memory_segment cp_mem_seg[] = {
	{ "CODE", 	CODE_MEM_BASE_ADDR, CODE_MEM_SIZE},
	{ "DATA", 	DATA_MEM_BASE_ADDR, DATA_MEM_SIZE},
	{ "AHBR", 	AHB_REG_BASE_ADDR, AHB_REG_SIZE},
	{ "PPBM", 	UMEM_MEM_BASE_ADDR, UMEM_MEM_SIZE},
	{ "SMEM", 	SMEM_MEM_BASE_ADDR, SMEM_MEM_SIZE},
	{ "WFRF", 	0x40140000, 0x4000},
	{ "CSCB", 	0xE000E000, 0x1000},
	{ "WREG", 	WREG_MEM_BASE_ADDR, WREG_MEM_SIZE},
	{ "PHYR", 	PHYR_MEM_BASE_ADDR, PHYR_MEM_SIZE},
	{ "SDIO", 	SDIO_MEM_BASE_ADDR, SDIO_MEM_SIZE},
	{ "BTRG", 	BTDM_MEM_BASE_ADDR, BTDM_MEM_SIZE},
	{ "BTEM", 	BTEM_MEM_BASE_ADDR, BTEM_MEM_SIZE},
	{ "BTGB", 	BTGB_MEM_BASE_ADDR, BTGB_MEM_SIZE},
	{ "BTRF", 	BTRF_MEM_BASE_ADDR, BTRF_MEM_SIZE},
	{ "RFTOP", 	RFTOP_MEM_BASE_ADDR, RFTOP_MEM_SIZE},
	{ "RCLK", 	RCLK_MEM_BASE_ADDR, RCLK_MEM_SIZE},
	{ "BBPLL", 	BBPLL_MEM_BASE_ADDR, BBPLL_MEM_SIZE}

};
static uint32_t skw_checksum(void *data, int data_len)
{
	uint32_t *d32 = data;
	uint32_t checksum=0;
	int i;

	data_len = data_len >> 2;
	for (i=0; i<data_len; i++)
		checksum += d32[i];
	return checksum;
}
int skw_dump_memory_into_buffer(struct ucom_dev *ucom, char *buffer, int length)
{
	struct memory_segment *mem_sg = &cp_mem_seg[0];
	int offset=0;
	uint16_t seq, packet_len;
	uint32_t sg_size;
	char *read_buf;
	uint8_t sg_count;
	int ret = 0;

	if (!ucom || !ucom->pdata ||
	    !ucom->pdata->skw_dump_mem)
		return 0;
	sg_count = sizeof(cp_mem_seg)/sizeof(cp_mem_seg[0]);
	if (sg_count==0)
		return 0;
	packet_len = 0x800;
	read_buf = kmalloc(packet_len, GFP_KERNEL);
	if (read_buf==NULL)
		return 0;
	buffer[offset] = sg_count; //save total segment count
	offset++;

	do {
		uint32_t source_addr;
		sg_size = mem_sg->size;

		memcpy(&buffer[offset], mem_sg->name, 5); //save segment name
		offset += 5;
		memcpy(&buffer[offset], &mem_sg->address, 4); //save segment base addrss
		offset += 4;
		memcpy(&buffer[offset], &mem_sg->size, 4); //save segment size
		offset += 4;
		memcpy(&buffer[offset], &packet_len, 2); //save segment size
		offset += 2;
		skwlog_log("%s %s:%d 0x%x 0x%x\n", __func__, mem_sg->name,
			offset, mem_sg->address, mem_sg->size);
		seq = 0;
		source_addr = mem_sg->address;
		do {
			int read_len;
			uint32_t sum;

			memcpy(&buffer[offset], &seq, 2); //save segment size
			seq++;
			offset += 2;

			if (sg_size > packet_len)
				read_len = packet_len;
			else
				read_len = sg_size;
			ret = ucom->pdata->skw_dump_mem(source_addr,(void *)read_buf,read_len);
			if (ret != 0) {
				skwlog_err("%s dump memory fail :%d \n", __func__, ret);
				break;
			}
			source_addr += read_len;
			memcpy(buffer+offset, read_buf, read_len); //save packet payload 
			offset += read_len;

			sum = skw_checksum(read_buf, read_len);
			memcpy (buffer+offset, &sum, 4); //save checksum
			offset += 4;

			sg_size -= read_len;
		} while (sg_size);
		mem_sg++;
		sg_count--;
	} while (sg_count && (!ret));
	kfree(read_buf);
	return offset;
}

static int skw_ucom_dump_from_buffer(char __user *buf, size_t count, loff_t *pos)
{
	int len;
	int ret;

	len = 0;
	ret = 0;
	if (dump_log_size) {
		if (*pos + count < dump_log_size)
			len = count;
		else if (*pos < dump_log_size)
			len = dump_log_size - *pos;
		if (len)
			ret = copy_to_user(buf, &dump_memory_buffer[*pos], len);
		if (ret ==0)
			ret = len;
	} else if (*pos == 0){
		char assert_info[32]={0};
		sprintf(assert_info,"modem_status=%d\n", cp_exception_sts);
		ret = copy_to_user(buf, assert_info, strlen(assert_info));
		len = strlen(assert_info);
	}
	*pos = *pos+len;
	if (len==0)
		skwboot_log("dump_log_size: %d offset %d count %d %p ret=%d\n", dump_log_size, (int)*pos, (int)count, dump_memory_buffer, ret);
	return ret;
}

static int user_dump_open(struct inode *ip, struct file *fp)
{
	if (dump_buffer_size)
		return 0;
	return 0;
}

static ssize_t user_dump_read(struct file *fp, char __user *buf, size_t count, loff_t *pos)
{
	ssize_t ret = skw_ucom_dump_from_buffer(buf, count, pos);
	if (ret == 0)
		dump_log_size = 0;
	return ret;

}
static int user_dump_release(struct inode *ip, struct file *fp)
{
	return 0;
}

static ssize_t user_dump_write(struct file *fp, const char __user *buf, size_t count, loff_t *pos)
{
	return 0;
}
static long user_dump_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
{
	return 0;
}
static const struct file_operations skw_dump_ops = {
	.owner	= THIS_MODULE,
	.open	= user_dump_open,
	.read	= user_dump_read,
	.write	= user_dump_write,
	.unlocked_ioctl = user_dump_ioctl,
	.release= user_dump_release,
};
static int bt_state_event_notifier(struct notifier_block *nb, unsigned long action, void *data)
{
	struct ucom_dev *ucom = container_of(nb, struct ucom_dev, notifier);
	//int status = cp_exception_sts;
	switch(action)
	{
		case DEVICE_ASSERT_EVENT:
		{
			skwboot_log("BT BSPASSERT EVENT received!!!!\n");
			cp_exception_sts = 1;
			ucom = ucoms[log_portno];
			if (dump_log_size){
				skwboot_log(" dump done ,mem size: %d\n", dump_log_size);
				return NOTIFY_OK;
			}
			if (!dump_memory_buffer && !atomic_read(&ucom->open) && SKW_DUMP_BUFFER_SIZE!=0)
				dump_memory_buffer = kzalloc(SKW_DUMP_BUFFER_SIZE, GFP_KERNEL);
			if(ucom->pdata && ucom->pdata->dump_modem_memory) {
				dump_log_size = 0;
				if (dump_memory_buffer) {
					dump_buffer_size = SKW_DUMP_BUFFER_SIZE;
					ucom->pdata->dump_modem_memory(dump_memory_buffer,
							dump_buffer_size, &dump_log_size);
				}
			} else if (dump_memory_buffer) {
				dump_buffer_size = SKW_DUMP_BUFFER_SIZE;
				if (!atomic_read(&ucom->open))
					dump_log_size = skw_dump_memory_into_buffer(ucom, dump_memory_buffer,dump_buffer_size);
            }

		}
		break;
		case DEVICE_BSPREADY_EVENT:
		{
			cp_exception_sts = 0;
			skwboot_log("BT BSPREADY EVENT Comming in !!!!\n");
		}
		break;
		case DEVICE_DUMPDONE_EVENT:
		{
			cp_exception_sts = 2;
			skwboot_log("BT DUMPDONE EVENT Comming in !!!!\n");
		}
		break;
		case DEVICE_BLOCKED_EVENT:
		{
			cp_exception_sts = 3;
			skwboot_log("BT BLOCKED EVENT Comming in !!!!\n");
			if (dump_log_size){
				skwboot_log(" dump done ,mem size: %d\n", dump_log_size);
				return NOTIFY_OK;
			}
			if (!dump_memory_buffer)
				dump_memory_buffer = kzalloc(SKW_DUMP_BUFFER_SIZE, GFP_KERNEL);
			if (dump_memory_buffer) {
				dump_buffer_size = SKW_DUMP_BUFFER_SIZE;
				dump_log_size = skw_dump_memory_into_buffer(ucom, dump_memory_buffer,dump_buffer_size);
			}
		}
		break;
		case DEVICE_DISCONNECT_EVENT:
		{
			cp_exception_sts = action;
		}
		break;
		default:
		break;

	}
	return NOTIFY_OK;
}

static int skw_bt_state_event_init(struct ucom_dev *ucom)
{
	int ret = 0;
	int devno;
	if (ucom->pdata->modem_register_notify && ucom->notifier.notifier_call == NULL) {
		ucom->notifier.notifier_call = bt_state_event_notifier;
		ucom->pdata->modem_register_notify(&ucom->notifier);
	}
	ret =__register_chrdev(skw_major, UCOM_PORTNO_MAX+1, 1,
                                          "SKWDUMP", &skw_dump_ops);

	devno = MKDEV(skw_major, UCOM_PORTNO_MAX+1);
	if (ret==0)
		device_create(skw_com_class, NULL, devno, NULL, "%s", "SKWDUMP");
	skwlog_log("%s enter  ret=%d\n",__func__, ret);
	return ret;
}

static int skw_bt_state_event_deinit(struct ucom_dev *ucom)
{
	int ret = 0;
	int devno;
	if(ucom) {
		if((ucom->notifier.notifier_call)){
			skwboot_log("%s :%d release the notifier \n", __func__,__LINE__);
			ucom->notifier.notifier_call = NULL;
			ucom->pdata->modem_unregister_notify(&ucom->notifier);
		}
		devno = MKDEV(skw_major, UCOM_PORTNO_MAX+1);
		__unregister_chrdev(skw_major, MINOR(devno), 1,  "SKWDUMP");
		device_destroy(skw_com_class, devno);
	}
	return ret;
}