// SPDX-License-Identifier: GPL-2.0
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <termios.h>
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <stdint.h>
#include <string.h>
#include <endian.h>
#include <byteswap.h>
#include <netinet/in.h>
#include <ctype.h>
#include <poll.h>
#include <sys/timerfd.h>
#include <sys/epoll.h>
#include "hciattach.h"
#include "hciattach_h4.h"

extern struct rtb_struct rtb_cfg;

static int start_xfer_wait(int fd, uint8_t *cmd, uint16_t len, uint32_t msec,
			   int retry, uint8_t *resp, uint16_t *resp_len)
{
	uint8_t buf[64];
	int result;
	int state = 1;
	int count = 0;
	int params_len;
	struct pollfd p[2];
	uint16_t opcode;

	if (fd == -1 || !cmd || len < 4) {
		RS_ERR("%s: invalid parameter", __func__);
		return -1;
	}

	opcode = ((uint16_t)cmd[2] << 8) + cmd[1];

start_xfer:
	result = write(fd, cmd, len);
	if (result != len) {
		RS_ERR("%s: Write cmd %04x error, %s", __func__, opcode,
		       strerror(errno));
		return -1;
	}

start_recv:
	memset(buf, 0, sizeof(buf));
	memset(p, 0, sizeof(p));
	state = 1;
	count = 0;
	p[0].fd = fd;
	p[0].events = POLLERR | POLLHUP | POLLIN;
	for (;;) {
		p[0].revents = 0;
		result = poll(p, 1, msec);
		if (result < 0) {
			RS_ERR("Poll call error, %s", strerror(errno));
			result = -1;
			break;
		}

		if (result == 0) {
			RS_WARN("%s: Timeout", __func__);
			if (retry <= 0) {
				RS_ERR("%s: Transfer exhausted", __func__);
				tcflush(fd, TCIOFLUSH);
				exit(EXIT_FAILURE);
			}
			retry--;
			goto start_xfer;
		}

		if (p[0].revents & (POLLERR | POLLHUP)) {
			RS_ERR("POLLERR or POLLUP happens, %s",
			       strerror(errno));
			result = -1;
			break;
		}

		if (state == 1) {
			result = read(p[0].fd, buf, 1);
			if (result == -1 || result != 1) {
				RS_ERR("%s: Read pkt type error, %s", __func__,
				       strerror(errno));
				result = -1;
				break;
			}
			if (result == 1 && buf[0] == 0x04) {
				count = 1;
				state = 2;
			}
		} else if (state == 2) {
			result = read(p[0].fd, buf + count, 2);
			if (result == -1 || result != 2) {
				RS_ERR("%s: Read pkt header error, %s",
				       __func__, strerror(errno));
				break;
			}
			count += result;
			state = 3;
			params_len = buf[2];
			if (params_len + 3 > sizeof(buf)) {
				result = -1;
				RS_ERR("%s: hci event too long", __func__);
				break;
			}
		} else if (state == 3) {
			result = read(p[0].fd, buf + count, params_len);
			if (result == -1) {
				RS_ERR("%s: Read pkt payload error, %s",
				       __func__, strerror(errno));
				break;
			}
			count += result;
			params_len -= result;
			if (!params_len)
				break;
		}
	}

	if (result >= 0) {
		if (buf[1] == 0x0e) {
			uint16_t tmp_opcode;

			tmp_opcode = (uint16_t)buf[4] | buf[5] << 8;
			if (tmp_opcode == opcode) {
				RS_INFO("Cmd complete event for cmd %04x",
					opcode);
				/* Status is not zero indicating command not
				 * succeeded */
				if (buf[6])
					return -1;
				if (!resp)
					return 0;
				if (*resp_len > count)
					*resp_len = count;
				memcpy(resp, buf, *resp_len);
				return 0;
			} else {
				RS_WARN("Unexpected cmd complete event, %04x",
					tmp_opcode);
				return -1;
			}
		} else {
			RS_INFO("%s: Unexpected hci event packet", __func__);
			util_hexdump(buf, count);
			/* Continue receiving */
		}
		goto start_recv;
	}

	return result;
}

int h4_download_patch(int fd, int index, uint8_t *data, int len)
{
	uint8_t buf[257];
	uint16_t total_len;
	int result;
	uint8_t resp[8];
	uint16_t rlen = sizeof(resp);

	RS_DBG("fd: %d, index: %d, len: %d", fd, index, len);

	if (data)
		memcpy(&buf[5], data, len);
	buf[0] = 0x01;
	buf[1] = 0x20;
	buf[2] = 0xfc;
	buf[3] = len + 1;
	buf[4] = (uint8_t)index;
	total_len = len + 5;

	result = start_xfer_wait(fd, buf, total_len, 1000, 0, resp, &rlen);
	if (result < 0) {
		RS_ERR("Transfer patch failed, index %d", index);
		return -1;
	}

	if (rlen != 8) {
		RS_ERR("%s: Unexpected length %u", __func__, rlen);
		return -1;
	}

	return resp[7];
}

int h4_vendor_change_speed(int fd, uint32_t baudrate)
{
	int res;
	uint8_t cmd[8] = { 0 };

	cmd[0] = 1;
	cmd[1] = 0x17;
	cmd[2] = 0xfc;
	cmd[3] = 4;

	baudrate = cpu_to_le32(baudrate);
#ifdef BAUDRATE_4BYTES
	memcpy((uint16_t *) & cmd[4], &baudrate, 4);
#else
	memcpy((uint16_t *) & cmd[4], &baudrate, 2);
	cmd[6] = 0;
	cmd[7] = 0;
#endif

	/* TODO: Wait for a while for device to up, just h4 need it */
	sleep(1);

	RS_DBG("baudrate in change speed command: 0x%02x 0x%02x 0x%02x 0x%02x",
	       cmd[4], cmd[5], cmd[6], cmd[7]);

	res = start_xfer_wait(fd, cmd, 8, 1000, 0, NULL, 0);
	if (res < 0)
		RS_ERR("Change Controller baud failed");

	return res;
}

int h4_hci_reset(int fd)
{
	int result;
	uint8_t cmd[4] = { 0x01, 0x03, 0x0c, 0x00};

	RS_INFO("%s: Issue hci reset cmd", __func__);

	result = start_xfer_wait(fd, cmd, sizeof(cmd), 1000, 0, NULL, 0);
	if (result < 0) {
		RS_ERR("%s: Failed to send reset cmd", __func__);
		return -1;
	}

	return 0;
}

int h4_read_local_ver(int fd)
{
	uint8_t cmd[4] = { 0x01, 0x01, 0x10, 0x00 };
	uint8_t resp[16];
	uint16_t len = sizeof(resp);
	int result;

	result = start_xfer_wait(fd, cmd, sizeof(cmd), 1000, 0,
				 resp, &len);
	if (result < 0) {
		RS_ERR("HCI Read local version info error");
		return -1;
	}

	if (len != 15) {
		RS_ERR("%s: Unexpected length %u", __func__, len);
		return -1;
	}
	rtb_cfg.hci_ver = resp[7];
	rtb_cfg.hci_rev = (uint32_t)resp[9] << 8 | resp[8];
	rtb_cfg.lmp_subver = (uint32_t)resp[14] << 8 | resp[13];
	RS_INFO("hci ver %02x, hci_rev %04x, lmp_subver %04x",
		rtb_cfg.hci_ver, rtb_cfg.hci_rev, rtb_cfg.lmp_subver);
	return 0;
}

int h4_vendor_read_rom_ver(int fd)
{
	uint8_t cmd[4] = { 0x01, 0x6d, 0xfc, 0x00 };
	uint8_t resp[16];
	uint16_t len = sizeof(resp);
	int result;

	result = start_xfer_wait(fd, cmd, sizeof(cmd), 1000, 0,
				 resp, &len);
	if (result < 0) {
		RS_ERR("HCI Read local version info error");
		return -1;
	}

	if (len != 8) {
		RS_ERR("%s: Unexpected length %u", __func__, len);
		return -1;
	}
	rtb_cfg.eversion = resp[7];
	RS_INFO("eversion %02x", rtb_cfg.eversion);
	return 0;
}