/* SPDX-License-Identifier: GPL-2.0 */
#include "usb_boot.h"

#define DOWNLOAD_TX_CHN 2
#define DOWNLOAD_RX_CHN 18

static int ackncmp(const char *cs, const char *ct, size_t count)
{
	unsigned char c1, c2;

	while (count) {
		c1 = *cs++;
		c2 = *ct++;
		if (c1 != c2)
			return c1 < c2 ? -1 : 1;
		count--;
	}
	return 0;
}

static int usb_download_sent_command(const char *command,
		unsigned int command_len, const char *ack, unsigned int ack_len)
{
	struct wcn_usb_ep *tx_ep = wcn_usb_store_get_epFRchn(DOWNLOAD_TX_CHN);
	struct wcn_usb_ep *rx_ep = wcn_usb_store_get_epFRchn(DOWNLOAD_RX_CHN);
	int actual_len;
	int ret;
	char *command_temp;
	void *data;
	int data_size = 128;

	if (!tx_ep || !rx_ep) {
		wcn_usb_err("no ep\n");
		return -EIO;
	}

	data = kzalloc(data_size, GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	command_temp = kmalloc(command_len, GFP_KERNEL);
	if (!command_temp) {
		ret = -ENOMEM;
		goto OUT_FREE_DATA;
	}

	memcpy(command_temp, command, command_len);
	/* sent command */
	ret = wcn_usb_msg(tx_ep, command_temp, command_len, &actual_len, 3000);
	if (ret || actual_len != command_len) {
		wcn_usb_err("wcn %s sent msg is error [ret %d actual_len %d command_len %d\n",
				__func__, ret, actual_len, command_len);
		ret = -EIO;
		goto OUT;
	}

	if (ack == NULL)
		goto OUT;

	/* get ack and compare */
	ret = wcn_usb_msg(rx_ep, data, data_size, &actual_len, 3000);
	if (ret || ack_len > actual_len || ackncmp(ack, data, ack_len)) {
		wcn_usb_err("wcn %s ack is not ok\n", __func__);
		print_hex_dump(KERN_DEBUG, "WCN ack", 0, 16, 1,
				data, data_size, 1);
		print_hex_dump(KERN_DEBUG, "WCN command", 0, 16, 1,
				command, command_len, 1);
		ret = -EIO;
		goto OUT;
	}

OUT:
	kfree(command_temp);
OUT_FREE_DATA:
	kfree(data);

	return ret;
}

static unsigned short crc16_xmodem_cal(unsigned char *buf, unsigned int buf_len)
{
	unsigned int i;
	unsigned short crc = 0;

	while (buf_len-- != 0) {
		for (i = 0x80; i != 0; i = i >> 1) {
			if ((crc & 0x8000) != 0) {
				crc = crc << 1;
				crc = crc ^ 0x1021;
			} else {
				crc = crc << 1;
			}

			if ((*buf & i) != 0)
				crc = crc ^ 0x1021;
		}

		buf++;
	}

	return crc;
}

static const char get_version[] = { 0x7E };
static const char get_version_ack[] = {
	0x7E, 0x00, 0x81, 0x00, 0x06, 0x53, 0x50,
	0x52, 0x44, 0x33, 0x00, 0x57, 0x0A, 0x7E};
static const char connect[] = {
	0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E};
static const char common_ack[] = {
	0x7E, 0x00, 0x80, 0x00, 0x00, 0x3B, 0x5A, 0x7E};
static const char end_download[] = {
	0x7E, 0x00, 0x03, 0x00, 0x00, 0x59, 0x50, 0x7E};

unsigned short usb_download_command_replace(char *command, unsigned short len)
{
	unsigned short tail = len - 1;
	unsigned short i;
	unsigned short j;

	/* ho head and no tail */
	for (i = len - 2; i > 0; i--) {
		if (command[i] == 0x7E || command[i] == 0x7D) {
			tail += 1;
			for (j = tail; j > i; j--)
				command[j] = command[j - 1];
			command[i + 1] = 0x50 | (command[i + 1] & 0x0F);
			command[i] = 0x7D;
		}
	}

	return tail + 1;
}

int usb_download_command_start_download(unsigned int addr, unsigned int len)
{
	unsigned short command_len = 16;
	char command[20] = {0x7E,/* head */
		0x00, 0x01, /*command type */
		0x00, 0x08, /*for command data len */
		0x00, 0x00, 0x00, 0x00,/*addr*/
		0x00, 0x00, 0x00, 0x00,/*data len*/
		0x00, 0x00, /*for crc*/
		0x7E /*tail*/};


	*((u32 *)&command[5]) = cpu_to_be32(addr);
	*((u32 *)&command[9]) = cpu_to_be32(len);

	*((u16 *)&command[command_len - 3]) =
		cpu_to_be16(crc16_xmodem_cal(&command[1], command_len - 4));

	command_len = usb_download_command_replace(command, 16);

	return usb_download_sent_command(command, command_len,
			common_ack, sizeof(common_ack));
}

int usb_download_command_exec(unsigned int addr)
{
	unsigned short command_len = 12;
	char command[16] = {0x7E,/* head */
		0x00, 0x04, /*command type */
		0x00, 0x04, /*command len */
		0x00, 0x00, 0x00, 0x00, /*addr*/
		0x00, 0x00, /*for crc*/
		0x7E /*tail*/};

	*((u32 *)&command[5]) = cpu_to_be32(addr);

	*((u16 *)&command[command_len - 3]) =
		cpu_to_be16(crc16_xmodem_cal(&command[1], command_len - 4));

	command_len = usb_download_command_replace(command, 12);

	return usb_download_sent_command(command, command_len,
			common_ack, sizeof(common_ack));
}

#define usb_download_command_get_version()				\
	usb_download_sent_command(get_version, sizeof(get_version),	\
			get_version_ack, sizeof(get_version_ack))
#define usb_download_command_connect()				\
	usb_download_sent_command(connect, sizeof(connect),	\
			common_ack, sizeof(common_ack))
#define usb_download_command_end_download()				\
	usb_download_sent_command(end_download, sizeof(end_download),	\
			common_ack, sizeof(common_ack))

int marlin_get_version(void)
{
	return usb_download_command_get_version();
}

int marlin_connet(void)
{
	return usb_download_command_connect();
}

int marlin_firmware_download_start_usb(void)
{
	int ret;

	ret = usb_download_command_get_version();
	if (ret) {
		wcn_usb_err("%s start command is error\n", __func__);
		return ret;
	}

	ret = usb_download_command_connect();
	if (ret) {
		wcn_usb_err("%s connect command is error\n", __func__);
		return ret;
	}

	return 0;
}

int marlin_firmware_download_exec_usb(unsigned int addr)
{
	int ret;

	ret = usb_download_command_exec(addr);
	if (ret) {
		wcn_usb_err("%s exec command is error\n", __func__);
		return ret;
	}

	return 0;
}

int marlin_firmware_download_usb(unsigned int addr, const void *buf,
		unsigned int len, unsigned int packet_max)
{
	int ret;

	ret = usb_download_command_start_download(addr, len);
	if (ret) {
		wcn_usb_err("start download command is error\n");
		return ret;
	}

	ret = usb_download_sent_command(buf, len,
			common_ack, sizeof(common_ack));
	if (ret) {
		wcn_usb_err("donwload img is error\n");
		return ret;
	}

	ret = usb_download_command_end_download();
	if (ret) {
		wcn_usb_err("end donwload command is error\n");
		return ret;
	}

	return 0;
}

int marlin_firmware_get_chip_id(void *buf, unsigned int buf_size)
{
	int ret;
	unsigned short command_len = 8;
	char command[16] = {0x7E,/* head */
		0x00, 0x08, /*command type */
		0x00, 0x00, /*command len */
		0x00, 0x00, /*for crc*/
		0x7E /*tail*/};
	struct wcn_usb_ep *rx_ep = wcn_usb_store_get_epFRchn(DOWNLOAD_RX_CHN);
	int actual_len;
	char *temp_buf;
#define temp_buf_size 16

	if (!rx_ep) {
		wcn_usb_err("%s no rx_ep\n", __func__);
		return -EIO;
	}

	temp_buf = kzalloc(temp_buf_size, GFP_KERNEL);
	if (!temp_buf)
		return -ENOMEM;

	*((u16 *)&command[command_len - 3]) =
		cpu_to_be16(crc16_xmodem_cal(&command[1], command_len - 4));

	command_len = usb_download_command_replace(command, 8);

	ret = usb_download_sent_command(command, command_len, NULL, 0);
	if (ret) {
		wcn_usb_err("%s send command error\n", __func__);
		kfree(temp_buf);
		return -EIO;
	}

	ret = wcn_usb_msg(rx_ep, temp_buf, temp_buf_size, &actual_len, 3000);
	if (ret) {
		wcn_usb_err("%s get chip id error\n", __func__);
		kfree(temp_buf);
		return ret;
	}

	if (temp_buf[0] != 0x7e || temp_buf[2] != 0x08) {
		wcn_usb_err("%s get chip id error\n", __func__);
		print_hex_dump(KERN_ERR, "WCN ack", 0, 16, 1,
				temp_buf, temp_buf_size, 1);
		kfree(temp_buf);
		return ret;
	}

	memcpy(buf, &temp_buf[5], buf_size);

	kfree(temp_buf);
	return ret;

}


int marlin_dump_from_romcode_usb(unsigned int addr, void *buf, int len)
{
	int ret;
	unsigned short command_len = 16;
	char command[20] = {0x7E,/* head */
		0x00, 0x09, /*command type */
		0x00, 0x08, /*for command data len */
		0x00, 0x00, 0x00, 0x00,/*addr*/
		0x00, 0x00, 0x00, 0x00,/*data len*/
		0x00, 0x00, /*for crc*/
		0x7E /*tail*/};
	struct wcn_usb_ep *rx_ep = wcn_usb_store_get_epFRchn(DOWNLOAD_RX_CHN);
	int actual_len;

	if (!rx_ep) {
		wcn_usb_err("%s no rx_ep\n", __func__);
		return -EIO;
	}

	wcn_usb_info("%s addr is 0x%x len is 0x%x\n", __func__, addr, len);
	*((u32 *)&command[5]) = cpu_to_be32(addr);
	*((u32 *)&command[9]) = cpu_to_be32(len);

	*((u16 *)&command[command_len - 3]) =
		cpu_to_be16(crc16_xmodem_cal(&command[1], command_len - 4));

	command_len = usb_download_command_replace(command, 16);

	ret = usb_download_sent_command(command, command_len, NULL, 0);
	if (ret) {
		wcn_usb_err("%s send command error\n", __func__);
		return -EIO;
	}

	ret = wcn_usb_msg(rx_ep, buf, len, &actual_len, 3000);
	if (ret)
		wcn_usb_err("%s dump memory error\n", __func__);

	return ret;
}

int marlin_dump_read_usb(unsigned int addr, char *buf, int len)
{
	int ret;
	static int first_pac;

	if (first_pac == 0) {
		first_pac = 1;
		marlin_firmware_download_start_usb();
	}

	ret = marlin_dump_from_romcode_usb(addr, buf, len);

	return ret;
}