// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/*
 * Copyright (c) 2025 Robert Bosch GmbH.
 */
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/regmap.h>

#include "smi330.h"

#define SMI330_NUM_DUMMY_BYTES 2
#define SMI330_I2C_MAX_RX_BUFFER_SIZE \
        (SMI330_NUM_DUMMY_BYTES + SMI330_SCAN_LEN * sizeof(s16))

struct smi330_i2c_priv {
        struct i2c_client *i2c;
        u8 rx_buffer[SMI330_I2C_MAX_RX_BUFFER_SIZE];
};

static int smi330_regmap_i2c_read(void *context, const void *reg_buf,
                                  size_t reg_size, void *val_buf,
                                  size_t val_size)
{
        struct smi330_i2c_priv *priv = context;
        int ret;

        if (SMI330_NUM_DUMMY_BYTES + val_size > SMI330_I2C_MAX_RX_BUFFER_SIZE)
                return -EINVAL;

        /*
         * SMI330 I2C read frame:
         * <Slave address[6:0], RnW> <x, Register address[6:0]>
         * <Slave address[6:0], RnW> <Dummy[7:0]> <Dummy[7:0]> <Data_0[7:0]> <Data_1[15:8]>...
         *                                                     <Data_N[7:0]> <Data_N[15:8]>
         * Remark: Slave address is not considered part of the frame in the following definitions
         */
        struct i2c_msg msgs[] = {
                {
                        .addr = priv->i2c->addr,
                        .flags = priv->i2c->flags,
                        .len = reg_size,
                        .buf = (u8 *)reg_buf,
                },
                {
                        .addr = priv->i2c->addr,
                        .flags = priv->i2c->flags | I2C_M_RD,
                        .len = SMI330_NUM_DUMMY_BYTES + val_size,
                        .buf = priv->rx_buffer,
                },
        };

        ret = i2c_transfer(priv->i2c->adapter, msgs, ARRAY_SIZE(msgs));
        if (ret < 0)
                return ret;

        memcpy(val_buf, priv->rx_buffer + SMI330_NUM_DUMMY_BYTES, val_size);

        return 0;
}

static int smi330_regmap_i2c_write(void *context, const void *data,
                                   size_t count)
{
        struct smi330_i2c_priv *priv = context;
        u8 reg;

        /*
         * SMI330 I2C write frame:
         * <Slave address[6:0], RnW> <x, Register address[6:0]> <Data_0[7:0]> <Data_1[15:8]>...
         *                                                      <Data_N[7:0]> <Data_N[15:8]>
         * Remark: Slave address is not considered part of the frame in the following definitions
         */
        reg = *(u8 *)data;
        return i2c_smbus_write_i2c_block_data(priv->i2c, reg,
                                              count - sizeof(u8),
                                              data + sizeof(u8));
}

static const struct regmap_bus smi330_regmap_bus = {
        .read = smi330_regmap_i2c_read,
        .write = smi330_regmap_i2c_write,
};

static int smi330_i2c_probe(struct i2c_client *i2c)
{
        struct device *dev = &i2c->dev;
        struct smi330_i2c_priv *priv;
        struct regmap *regmap;

        priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;

        priv->i2c = i2c;
        regmap = devm_regmap_init(dev, &smi330_regmap_bus, priv,
                                  &smi330_regmap_config);
        if (IS_ERR(regmap))
                return dev_err_probe(dev, PTR_ERR(regmap),
                                     "Failed to initialize I2C Regmap\n");

        return smi330_core_probe(dev, regmap);
}

static const struct i2c_device_id smi330_i2c_device_id[] = {
        { .name = "smi330" },
        { }
};
MODULE_DEVICE_TABLE(i2c, smi330_i2c_device_id);

static const struct of_device_id smi330_of_match[] = {
        { .compatible = "bosch,smi330" },
        { }
};
MODULE_DEVICE_TABLE(of, smi330_of_match);

static struct i2c_driver smi330_i2c_driver = {
        .probe = smi330_i2c_probe,
        .id_table = smi330_i2c_device_id,
        .driver = {
                .of_match_table = smi330_of_match,
                .name = "smi330_i2c",
        },
};
module_i2c_driver(smi330_i2c_driver);

MODULE_AUTHOR("Stefan Gutmann <stefan.gutmann@de.bosch.com>");
MODULE_AUTHOR("Roman Huber <roman.huber@de.bosch.com>");
MODULE_AUTHOR("Filip Andrei <Andrei.Filip@ro.bosch.com>");
MODULE_AUTHOR("Drimbarean Avram Andrei <Avram-Andrei.Drimbarean@ro.bosch.com>");
MODULE_DESCRIPTION("Bosch SMI330 I2C driver");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_IMPORT_NS("IIO_SMI330");