// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Based upon the MaxLinear SDK driver
 *
 * Copyright (C) 2025 Daniel Golle <daniel@makrotopia.org>
 * Copyright (C) 2025 John Crispin <john@phrozen.org>
 * Copyright (C) 2024 MaxLinear Inc.
 */

#include <linux/bitops.h>
#include <linux/bits.h>
#include <linux/crc16.h>
#include <linux/iopoll.h>
#include <linux/limits.h>
#include <linux/unaligned.h>
#include <net/dsa.h>
#include "mxl862xx.h"
#include "mxl862xx-host.h"

#define CTRL_BUSY_MASK			BIT(15)
#define CTRL_CRC_FLAG			BIT(14)

#define LEN_RET_LEN_MASK		GENMASK(9, 0)

#define MXL862XX_MMD_REG_CTRL		0
#define MXL862XX_MMD_REG_LEN_RET	1
#define MXL862XX_MMD_REG_DATA_FIRST	2
#define MXL862XX_MMD_REG_DATA_LAST	95
#define MXL862XX_MMD_REG_DATA_MAX_SIZE \
		(MXL862XX_MMD_REG_DATA_LAST - MXL862XX_MMD_REG_DATA_FIRST + 1)

#define MMD_API_SET_DATA_0		2
#define MMD_API_GET_DATA_0		5
#define MMD_API_RST_DATA		8

#define MXL862XX_SWITCH_RESET		0x9907

static void mxl862xx_crc_err_work_fn(struct work_struct *work)
{
	struct mxl862xx_priv *priv = container_of(work, struct mxl862xx_priv,
						  crc_err_work);
	struct dsa_port *dp;

	rtnl_lock();
	if (!test_bit(MXL862XX_FLAG_WORK_STOPPED, &priv->flags)) {
		dev_warn(&priv->mdiodev->dev,
			 "MDIO CRC error detected, shutting down all ports\n");
		dsa_switch_for_each_cpu_port(dp, priv->ds)
			dev_close(dp->conduit);
	}
	rtnl_unlock();

	clear_bit(MXL862XX_FLAG_CRC_ERR, &priv->flags);
}

/* Firmware CRC error codes (outside normal Zephyr errno range). */
#define MXL862XX_FW_CRC6_ERR		(-1024)
#define MXL862XX_FW_CRC16_ERR		(-1023)

/* 3GPP CRC-6 lookup table (polynomial 0x6F).
 * Matches the firmware's default CRC-6 implementation.
 */
static const u8 mxl862xx_crc6_table[256] = {
	0x00, 0x2f, 0x31, 0x1e, 0x0d, 0x22, 0x3c, 0x13,
	0x1a, 0x35, 0x2b, 0x04, 0x17, 0x38, 0x26, 0x09,
	0x34, 0x1b, 0x05, 0x2a, 0x39, 0x16, 0x08, 0x27,
	0x2e, 0x01, 0x1f, 0x30, 0x23, 0x0c, 0x12, 0x3d,
	0x07, 0x28, 0x36, 0x19, 0x0a, 0x25, 0x3b, 0x14,
	0x1d, 0x32, 0x2c, 0x03, 0x10, 0x3f, 0x21, 0x0e,
	0x33, 0x1c, 0x02, 0x2d, 0x3e, 0x11, 0x0f, 0x20,
	0x29, 0x06, 0x18, 0x37, 0x24, 0x0b, 0x15, 0x3a,
	0x0e, 0x21, 0x3f, 0x10, 0x03, 0x2c, 0x32, 0x1d,
	0x14, 0x3b, 0x25, 0x0a, 0x19, 0x36, 0x28, 0x07,
	0x3a, 0x15, 0x0b, 0x24, 0x37, 0x18, 0x06, 0x29,
	0x20, 0x0f, 0x11, 0x3e, 0x2d, 0x02, 0x1c, 0x33,
	0x09, 0x26, 0x38, 0x17, 0x04, 0x2b, 0x35, 0x1a,
	0x13, 0x3c, 0x22, 0x0d, 0x1e, 0x31, 0x2f, 0x00,
	0x3d, 0x12, 0x0c, 0x23, 0x30, 0x1f, 0x01, 0x2e,
	0x27, 0x08, 0x16, 0x39, 0x2a, 0x05, 0x1b, 0x34,
	0x1c, 0x33, 0x2d, 0x02, 0x11, 0x3e, 0x20, 0x0f,
	0x06, 0x29, 0x37, 0x18, 0x0b, 0x24, 0x3a, 0x15,
	0x28, 0x07, 0x19, 0x36, 0x25, 0x0a, 0x14, 0x3b,
	0x32, 0x1d, 0x03, 0x2c, 0x3f, 0x10, 0x0e, 0x21,
	0x1b, 0x34, 0x2a, 0x05, 0x16, 0x39, 0x27, 0x08,
	0x01, 0x2e, 0x30, 0x1f, 0x0c, 0x23, 0x3d, 0x12,
	0x2f, 0x00, 0x1e, 0x31, 0x22, 0x0d, 0x13, 0x3c,
	0x35, 0x1a, 0x04, 0x2b, 0x38, 0x17, 0x09, 0x26,
	0x12, 0x3d, 0x23, 0x0c, 0x1f, 0x30, 0x2e, 0x01,
	0x08, 0x27, 0x39, 0x16, 0x05, 0x2a, 0x34, 0x1b,
	0x26, 0x09, 0x17, 0x38, 0x2b, 0x04, 0x1a, 0x35,
	0x3c, 0x13, 0x0d, 0x22, 0x31, 0x1e, 0x00, 0x2f,
	0x15, 0x3a, 0x24, 0x0b, 0x18, 0x37, 0x29, 0x06,
	0x0f, 0x20, 0x3e, 0x11, 0x02, 0x2d, 0x33, 0x1c,
	0x21, 0x0e, 0x10, 0x3f, 0x2c, 0x03, 0x1d, 0x32,
	0x3b, 0x14, 0x0a, 0x25, 0x36, 0x19, 0x07, 0x28,
};

/* Compute 3GPP CRC-6 over the ctrl register (16 bits) and the lower
 * 10 bits of the len_ret register. The 26-bit input is packed as
 * { len_ret[9:0], ctrl[15:0] } and processed LSB-first through the
 * lookup table.
 */
static u8 mxl862xx_crc6(u16 ctrl, u16 len_ret)
{
	u32 data = ((u32)(len_ret & LEN_RET_LEN_MASK) << 16) | ctrl;
	u8 crc = 0;
	int i;

	for (i = 0; i < sizeof(data); i++, data >>= 8)
		crc = mxl862xx_crc6_table[(crc << 2) ^ (data & 0xff)] & 0x3f;

	return crc;
}

/* Encode CRC-6 into the ctrl and len_ret registers before writing them
 * to MDIO. The caller must set ctrl = API_ID | CTRL_BUSY_MASK |
 * CTRL_CRC_FLAG, and len_ret = parameter length (bits 0-9 only).
 *
 * After encoding:
 *   ctrl[12:0]     = API ID (unchanged)
 *   ctrl[14:13]    = CRC-6 bits 5-4
 *   ctrl[15]       = busy flag (unchanged)
 *   len_ret[9:0]   = parameter length (unchanged)
 *   len_ret[13:10] = CRC-6 bits 3-0
 *   len_ret[14]    = original ctrl[14] (CRC check flag, forwarded to FW)
 *   len_ret[15]    = original ctrl[13] (magic bit, always 1)
 */
static void mxl862xx_crc6_encode(u16 *pctrl, u16 *plen_ret)
{
	u16 crc, ctrl, len_ret;

	/* Set magic bit before CRC computation */
	*pctrl |= BIT(13);

	crc = mxl862xx_crc6(*pctrl, *plen_ret);

	/* Place CRC MSB (bits 5-4) into ctrl bits 13-14 */
	ctrl = (*pctrl & ~GENMASK(14, 13));
	ctrl |= (crc & 0x30) << 9;

	/* Place CRC LSB (bits 3-0) into len_ret bits 10-13 */
	len_ret = *plen_ret | ((crc & 0x0f) << 10);

	/* Forward ctrl[14] (CRC check flag) to len_ret[14],
	 * and ctrl[13] (magic, always 1) to len_ret[15].
	 */
	len_ret |= (*pctrl & BIT(14)) | ((*pctrl & BIT(13)) << 2);

	*pctrl = ctrl;
	*plen_ret = len_ret;
}

/* Verify CRC-6 on a firmware response and extract the return value.
 *
 * The firmware encodes the return value as a signed 11-bit integer:
 *   - Sign bit (bit 10) in ctrl[14]
 *   - Magnitude (bits 9-0) in len_ret[9:0]
 * These are recoverable after CRC-6 verification by restoring the
 * original ctrl from the auxiliary copies in len_ret[15:14].
 *
 * Return: 0 on CRC match (with *result set), or -EIO on mismatch.
 */
static int mxl862xx_crc6_verify(u16 ctrl, u16 len_ret, int *result)
{
	u16 crc_recv, crc_calc;

	/* Extract the received CRC-6 */
	crc_recv = ((ctrl >> 9) & 0x30) | ((len_ret >> 10) & 0x0f);

	/* Reconstruct the original ctrl for re-computation:
	 *   ctrl[14] = len_ret[14] (sign bit / CRC check flag)
	 *   ctrl[13] = len_ret[15] >> 2 (magic bit)
	 */
	ctrl &= ~GENMASK(14, 13);
	ctrl |= len_ret & BIT(14);
	ctrl |= (len_ret & BIT(15)) >> 2;

	crc_calc = mxl862xx_crc6(ctrl, len_ret);
	if (crc_recv != crc_calc)
		return -EIO;

	/* Extract signed 11-bit return value:
	 *   bit 10 (sign) from ctrl[14], bits 9-0 from len_ret[9:0]
	 */
	*result = sign_extend32((len_ret & LEN_RET_LEN_MASK) |
				((ctrl & CTRL_CRC_FLAG) >> 4), 10);

	return 0;
}

static int mxl862xx_reg_read(struct mxl862xx_priv *priv, u32 addr)
{
	return __mdiodev_c45_read(priv->mdiodev, MDIO_MMD_VEND1, addr);
}

static int mxl862xx_reg_write(struct mxl862xx_priv *priv, u32 addr, u16 data)
{
	return __mdiodev_c45_write(priv->mdiodev, MDIO_MMD_VEND1, addr, data);
}

static int mxl862xx_ctrl_read(struct mxl862xx_priv *priv)
{
	return mxl862xx_reg_read(priv, MXL862XX_MMD_REG_CTRL);
}

static int mxl862xx_busy_wait(struct mxl862xx_priv *priv)
{
	int val;

	return readx_poll_timeout(mxl862xx_ctrl_read, priv, val,
				  !(val & CTRL_BUSY_MASK), 15, 500000);
}

/* Issue a firmware command with CRC-6 protection on the ctrl and len_ret
 * registers, wait for completion, and verify the response CRC-6.
 *
 * Return: firmware result value (>= 0) on success, or negative errno.
 */
static int mxl862xx_issue_cmd(struct mxl862xx_priv *priv, u16 cmd, u16 len)
{
	u16 ctrl_enc, len_enc;
	int ret, fw_result;

	ctrl_enc = cmd | CTRL_BUSY_MASK | CTRL_CRC_FLAG;
	len_enc = len;
	mxl862xx_crc6_encode(&ctrl_enc, &len_enc);

	ret = mxl862xx_reg_write(priv, MXL862XX_MMD_REG_LEN_RET, len_enc);
	if (ret < 0)
		return ret;

	ret = mxl862xx_reg_write(priv, MXL862XX_MMD_REG_CTRL, ctrl_enc);
	if (ret < 0)
		return ret;

	ret = mxl862xx_busy_wait(priv);
	if (ret < 0)
		return ret;

	ret = mxl862xx_reg_read(priv, MXL862XX_MMD_REG_CTRL);
	if (ret < 0)
		return ret;
	ctrl_enc = ret;

	ret = mxl862xx_reg_read(priv, MXL862XX_MMD_REG_LEN_RET);
	if (ret < 0)
		return ret;
	len_enc = ret;

	ret = mxl862xx_crc6_verify(ctrl_enc, len_enc, &fw_result);
	if (ret) {
		if (!test_and_set_bit(MXL862XX_FLAG_CRC_ERR, &priv->flags))
			schedule_work(&priv->crc_err_work);
		return -EIO;
	}

	return fw_result;
}

static int mxl862xx_set_data(struct mxl862xx_priv *priv, u16 words)
{
	u16 cmd;

	cmd = words / MXL862XX_MMD_REG_DATA_MAX_SIZE - 1;
	if (!(cmd < 2))
		return -EINVAL;

	cmd += MMD_API_SET_DATA_0;

	return mxl862xx_issue_cmd(priv, cmd,
				  MXL862XX_MMD_REG_DATA_MAX_SIZE * sizeof(u16));
}

static int mxl862xx_get_data(struct mxl862xx_priv *priv, u16 words)
{
	u16 cmd;

	cmd = words / MXL862XX_MMD_REG_DATA_MAX_SIZE;
	if (!(cmd > 0 && cmd < 3))
		return -EINVAL;

	cmd += MMD_API_GET_DATA_0;

	return mxl862xx_issue_cmd(priv, cmd,
				  MXL862XX_MMD_REG_DATA_MAX_SIZE * sizeof(u16));
}

static int mxl862xx_rst_data(struct mxl862xx_priv *priv)
{
	return mxl862xx_issue_cmd(priv, MMD_API_RST_DATA, 0);
}

/* Minimum number of zero words in the data payload before issuing a
 * RST_DATA command is worthwhile.  RST_DATA costs one full command
 * round-trip (~5 MDIO transactions), so the threshold must offset that.
 */
#define RST_DATA_THRESHOLD	5

static int mxl862xx_send_cmd(struct mxl862xx_priv *priv, u16 cmd, u16 size,
			     bool quiet)
{
	int ret;

	ret = mxl862xx_issue_cmd(priv, cmd, size);

	/* Handle errors returned by the firmware as -EIO.
	 * The firmware is based on Zephyr OS and uses the errors as
	 * defined in errno.h of Zephyr OS. See
	 * https://github.com/zephyrproject-rtos/zephyr/blob/v3.7.0/lib/libc/minimal/include/errno.h
	 *
	 * The firmware signals CRC validation failures with dedicated
	 * error codes outside the normal Zephyr errno range:
	 *   -1024: CRC-6 mismatch on ctrl/len_ret registers
	 *   -1023: CRC-16 mismatch on data payload
	 */
	if (ret < 0) {
		if ((ret == MXL862XX_FW_CRC6_ERR ||
		     ret == MXL862XX_FW_CRC16_ERR) &&
		    !test_and_set_bit(MXL862XX_FLAG_CRC_ERR, &priv->flags))
			schedule_work(&priv->crc_err_work);
		if (!quiet)
			dev_err(&priv->mdiodev->dev,
				"CMD %04x returned error %d\n", cmd, ret);
		return -EIO;
	}

	return ret;
}

int mxl862xx_api_wrap(struct mxl862xx_priv *priv, u16 cmd, void *_data,
		      u16 size, bool read, bool quiet)
{
	__le16 *data = _data;
	bool use_rst = false;
	unsigned int zeros;
	int ret, cmd_ret;
	u16 max, crc, i;

	dev_dbg(&priv->mdiodev->dev, "CMD %04x DATA %*ph\n", cmd, size, data);

	mutex_lock_nested(&priv->mdiodev->bus->mdio_lock, MDIO_MUTEX_NESTED);

	max = (size + 1) / 2;

	ret = mxl862xx_busy_wait(priv);
	if (ret < 0)
		goto out;

	/* If the data contains enough zero words, issue RST_DATA to zero
	 * both the firmware buffer and MMD registers, then skip writing
	 * zero words individually.
	 */
	for (i = 0, zeros = 0; i < size / 2 && zeros < RST_DATA_THRESHOLD; i++)
		if (!get_unaligned_le16(&data[i]))
			zeros++;

	if (zeros < RST_DATA_THRESHOLD && (size & 1) && !*(u8 *)&data[i])
		zeros++;

	if (zeros >= RST_DATA_THRESHOLD) {
		ret = mxl862xx_rst_data(priv);
		if (ret < 0)
			goto out;
		use_rst = true;
	}

	/* Compute CRC-16 over the data payload; written as an extra word
	 * after the data so the firmware can verify the transfer.
	 */
	crc = crc16(0xffff, (const u8 *)data, size);

	for (i = 0; i < max + 1; i++) {
		u16 off = i % MXL862XX_MMD_REG_DATA_MAX_SIZE;
		u16 val;

		if (i && off == 0) {
			/* Send command to set data when every
			 * MXL862XX_MMD_REG_DATA_MAX_SIZE of WORDs are written.
			  */
			ret = mxl862xx_set_data(priv, i);
			if (ret < 0)
				goto out;
		}

		if (i == max) {
			/* Even size: full CRC word.
			 * Odd size: only CRC high byte remains (low byte
			 * was packed into the previous word).
			 */
			val = (size & 1) ? crc >> 8 : crc;
		} else if ((i * 2 + 1) == size) {
			/* Special handling for last BYTE if it's not WORD
			 * aligned to avoid reading beyond the allocated data
			 * structure.  Pack the CRC low byte into the high
			 * byte of this word so it sits at byte offset 'size'
			 * in the firmware's contiguous buffer.
			 */
			val = *(u8 *)&data[i] | ((crc & 0xff) << 8);
		} else {
			val = get_unaligned_le16(&data[i]);
		}

		/* After RST_DATA, skip zero data words as the registers
		 * already contain zeros, but never skip the CRC word at the
		 * final word.
		 */
		if (use_rst && i < max && val == 0)
			continue;

		ret = mxl862xx_reg_write(priv,
					 MXL862XX_MMD_REG_DATA_FIRST + off,
					 val);
		if (ret < 0)
			goto out;
	}

	ret = mxl862xx_send_cmd(priv, cmd, size, quiet);
	if (ret < 0 || !read)
		goto out;

	/* store result of mxl862xx_send_cmd() */
	cmd_ret = ret;

	for (i = 0; i < max + 1; i++) {
		u16 off = i % MXL862XX_MMD_REG_DATA_MAX_SIZE;

		if (i && off == 0) {
			/* Send command to fetch next batch of data when every
			 * MXL862XX_MMD_REG_DATA_MAX_SIZE of WORDs are read.
			  */
			ret = mxl862xx_get_data(priv, i);
			if (ret < 0)
				goto out;
		}

		ret = mxl862xx_reg_read(priv, MXL862XX_MMD_REG_DATA_FIRST + off);
		if (ret < 0)
			goto out;

		if (i == max) {
			/* Even size: full CRC word.
			 * Odd size: only CRC high byte remains (low byte
			 * was in the previous word).
			 */
			if (size & 1)
				crc = (crc & 0x00ff) |
				      (((u16)ret & 0xff) << 8);
			else
				crc = (u16)ret;
		} else if ((i * 2 + 1) == size) {
			/* Special handling for last BYTE if it's not WORD
			 * aligned to avoid writing beyond the allocated data
			 * structure.  The high byte carries the CRC low byte.
			 */
			*(uint8_t *)&data[i] = ret & 0xff;
			crc = (ret >> 8) & 0xff;
		} else {
			put_unaligned_le16((u16)ret, &data[i]);
		}
	}

	if (crc16(0xffff, (const u8 *)data, size) != crc) {
		if (!test_and_set_bit(MXL862XX_FLAG_CRC_ERR, &priv->flags))
			schedule_work(&priv->crc_err_work);
		ret = -EIO;
		goto out;
	}

	/* on success return the result of the mxl862xx_send_cmd() */
	ret = cmd_ret;

	dev_dbg(&priv->mdiodev->dev, "RET %d DATA %*ph\n", ret, size, data);

out:
	mutex_unlock(&priv->mdiodev->bus->mdio_lock);

	return ret;
}

int mxl862xx_reset(struct mxl862xx_priv *priv)
{
	int ret;

	mutex_lock_nested(&priv->mdiodev->bus->mdio_lock, MDIO_MUTEX_NESTED);

	/* Software reset */
	ret = mxl862xx_reg_write(priv, MXL862XX_MMD_REG_LEN_RET, 0);
	if (ret)
		goto out;

	ret = mxl862xx_reg_write(priv, MXL862XX_MMD_REG_CTRL, MXL862XX_SWITCH_RESET);
out:
	mutex_unlock(&priv->mdiodev->bus->mdio_lock);

	return ret;
}

void mxl862xx_host_init(struct mxl862xx_priv *priv)
{
	INIT_WORK(&priv->crc_err_work, mxl862xx_crc_err_work_fn);
}

void mxl862xx_host_shutdown(struct mxl862xx_priv *priv)
{
	cancel_work_sync(&priv->crc_err_work);
}