// 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/bits.h>
#include <linux/iopoll.h>
#include <linux/limits.h>
#include <net/dsa.h>
#include "mxl862xx.h"
#include "mxl862xx-host.h"

#define CTRL_BUSY_MASK                  BIT(15)

#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 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);
}

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

        ret = mxl862xx_reg_write(priv, MXL862XX_MMD_REG_LEN_RET,
                                 MXL862XX_MMD_REG_DATA_MAX_SIZE * sizeof(u16));
        if (ret < 0)
                return ret;

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

        cmd += MMD_API_SET_DATA_0;
        ret = mxl862xx_reg_write(priv, MXL862XX_MMD_REG_CTRL,
                                 cmd | CTRL_BUSY_MASK);
        if (ret < 0)
                return ret;

        return mxl862xx_busy_wait(priv);
}

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

        ret = mxl862xx_reg_write(priv, MXL862XX_MMD_REG_LEN_RET,
                                 MXL862XX_MMD_REG_DATA_MAX_SIZE * sizeof(u16));
        if (ret < 0)
                return ret;

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

        cmd += MMD_API_GET_DATA_0;
        ret = mxl862xx_reg_write(priv, MXL862XX_MMD_REG_CTRL,
                                 cmd | CTRL_BUSY_MASK);
        if (ret < 0)
                return ret;

        return mxl862xx_busy_wait(priv);
}

static int mxl862xx_firmware_return(int ret)
{
        /* Only 16-bit values are valid. */
        if (WARN_ON(ret & GENMASK(31, 16)))
                return -EINVAL;

        /* Interpret value as signed 16-bit integer. */
        return (s16)ret;
}

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

        ret = mxl862xx_reg_write(priv, MXL862XX_MMD_REG_LEN_RET, size);
        if (ret)
                return ret;

        ret = mxl862xx_reg_write(priv, MXL862XX_MMD_REG_CTRL,
                                 cmd | CTRL_BUSY_MASK);
        if (ret)
                return ret;

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

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

        /* 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
         */
        ret = mxl862xx_firmware_return(ret);
        if (ret < 0) {
                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;
        int ret, cmd_ret;
        u16 max, 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;

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

                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;
                }

                ret = mxl862xx_reg_write(priv, MXL862XX_MMD_REG_DATA_FIRST + off,
                                         le16_to_cpu(data[i]));
                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; 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 * 2 + 1) == size) {
                        /* Special handling for last BYTE if it's not WORD
                         * aligned to avoid writing beyond the allocated data
                         * structure.
                         */
                        *(uint8_t *)&data[i] = ret & 0xff;
                } else {
                        data[i] = cpu_to_le16((u16)ret);
                }
        }

        /* 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;
}