// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2025 Liebherr-Electronics and Drives GmbH
 */
#include <linux/module.h>
#include <linux/regmap.h>

#include <linux/phy/phy.h>
#include <linux/spi/spi.h>

#define TJA1145_MODE_CTRL               0x01
#define TJA1145_MODE_CTRL_MC            GENMASK(2, 0)
#define TJA1145_MODE_CTRL_STBY          BIT(2)
#define TJA1145_MODE_CTRL_NORMAL        TJA1145_MODE_CTRL_MC

#define TJA1145_CAN_CTRL                0x20
#define TJA1145_CAN_CTRL_CMC            GENMASK(1, 0)
#define TJA1145_CAN_CTRL_ACTIVE         BIT(1)

#define TJA1145_IDENT                   0x7e
#define TJA1145_IDENT_TJA1145T          0x70

#define TJA1145_SPI_READ_BIT            BIT(0)
#define TJA1145T_MAX_BITRATE            1000000

static int tja1145_phy_power_on(struct phy *phy)
{
        struct regmap *map = phy_get_drvdata(phy);
        int ret;

        /*
         * Switch operating mode to normal which is the active operating mode.
         * In this mode, the device is fully operational.
         */
        ret = regmap_update_bits(map, TJA1145_MODE_CTRL, TJA1145_MODE_CTRL_MC,
                                 TJA1145_MODE_CTRL_NORMAL);
        if (ret)
                return ret;

        /*
         * Switch to CAN operating mode active where the PHY can transmit and
         * receive data.
         */
        return regmap_update_bits(map, TJA1145_CAN_CTRL, TJA1145_CAN_CTRL_CMC,
                                  TJA1145_CAN_CTRL_ACTIVE);
}

static int tja1145_phy_power_off(struct phy *phy)
{
        struct regmap *map = phy_get_drvdata(phy);

        /*
         * Switch to operating mode standby, the PHY is unable to transmit or
         * receive data in standby mode.
         */
        return regmap_update_bits(map, TJA1145_MODE_CTRL, TJA1145_MODE_CTRL_MC,
                                  TJA1145_MODE_CTRL_STBY);
}

static const struct phy_ops tja1145_phy_ops = {
        .power_on = tja1145_phy_power_on,
        .power_off = tja1145_phy_power_off,
        .owner = THIS_MODULE,
};

static const struct regmap_range tja1145_wr_holes_ranges[] = {
        regmap_reg_range(0x00, 0x00),
        regmap_reg_range(0x02, 0x03),
        regmap_reg_range(0x05, 0x05),
        regmap_reg_range(0x0b, 0x1f),
        regmap_reg_range(0x21, 0x22),
        regmap_reg_range(0x24, 0x25),
        regmap_reg_range(0x30, 0x4b),
        regmap_reg_range(0x4d, 0x60),
        regmap_reg_range(0x62, 0x62),
        regmap_reg_range(0x65, 0x67),
        regmap_reg_range(0x70, 0xff),
};

static const struct regmap_access_table tja1145_wr_table = {
        .no_ranges = tja1145_wr_holes_ranges,
        .n_no_ranges = ARRAY_SIZE(tja1145_wr_holes_ranges),
};

static const struct regmap_range tja1145_rd_holes_ranges[] = {
        regmap_reg_range(0x00, 0x00),
        regmap_reg_range(0x02, 0x02),
        regmap_reg_range(0x05, 0x05),
        regmap_reg_range(0x0b, 0x1f),
        regmap_reg_range(0x21, 0x21),
        regmap_reg_range(0x24, 0x25),
        regmap_reg_range(0x30, 0x4a),
        regmap_reg_range(0x4d, 0x5f),
        regmap_reg_range(0x62, 0x62),
        regmap_reg_range(0x65, 0x67),
        regmap_reg_range(0x70, 0x7d),
        regmap_reg_range(0x7f, 0xff),
};

static const struct regmap_access_table tja1145_rd_table = {
        .no_ranges = tja1145_rd_holes_ranges,
        .n_no_ranges = ARRAY_SIZE(tja1145_rd_holes_ranges),
};

static const struct regmap_config tja1145_regmap_config = {
        .reg_bits = 8,
        .reg_shift = -1,
        .val_bits = 8,
        .wr_table = &tja1145_wr_table,
        .rd_table = &tja1145_rd_table,
        .read_flag_mask = TJA1145_SPI_READ_BIT,
        .max_register = TJA1145_IDENT,
};

static int tja1145_check_ident(struct device *dev, struct regmap *map)
{
        unsigned int val;
        int ret;

        ret = regmap_read(map, TJA1145_IDENT, &val);
        if (ret)
                return ret;

        if (val != TJA1145_IDENT_TJA1145T) {
                dev_err(dev, "Expected device id: 0x%02x, got: 0x%02x\n",
                        TJA1145_IDENT_TJA1145T, val);
                return -ENODEV;
        }

        return 0;
}

static int tja1145_probe(struct spi_device *spi)
{
        struct phy_provider *phy_provider;
        struct device *dev = &spi->dev;
        struct regmap *map;
        struct phy *phy;
        int ret;

        map = devm_regmap_init_spi(spi, &tja1145_regmap_config);
        if (IS_ERR(map))
                return dev_err_probe(dev, PTR_ERR(map), "failed to init regmap\n");

        ret = tja1145_check_ident(dev, map);
        if (ret)
                return dev_err_probe(dev, ret, "failed to identify device\n");

        phy = devm_phy_create(dev, dev->of_node, &tja1145_phy_ops);
        if (IS_ERR(phy))
                return dev_err_probe(dev, PTR_ERR(phy), "failed to create PHY\n");

        phy->attrs.max_link_rate = TJA1145T_MAX_BITRATE;
        phy_set_drvdata(phy, map);
        phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate);

        return PTR_ERR_OR_ZERO(phy_provider);
}

static const struct spi_device_id tja1145_spi_id[] = {
        { "tja1145" },
        { }
};
MODULE_DEVICE_TABLE(spi, tja1145_spi_id);

static const struct of_device_id tja1145_of_match[] = {
        { .compatible = "nxp,tja1145" },
        { }
};
MODULE_DEVICE_TABLE(of, tja1145_of_match);

static struct spi_driver tja1145_driver = {
        .driver = {
                .name = "tja1145",
                .of_match_table = tja1145_of_match,
        },
        .probe = tja1145_probe,
        .id_table = tja1145_spi_id,
};
module_spi_driver(tja1145_driver);

MODULE_DESCRIPTION("NXP TJA1145 CAN transceiver PHY driver");
MODULE_AUTHOR("Dimitri Fedrau <dimitri.fedrau@liebherr.com>");
MODULE_LICENSE("GPL");