#include <linux/auxiliary_bus.h>
#include <linux/bitfield.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/slab.h>
#include "tsi-core.h"
#define SBTSI_REG_CONFIG 0x03 /* RO */
#define SBTSI_CONFIG_EXT_RANGE_SHIFT 2
#define SBTSI_CONFIG_READ_ORDER_SHIFT 5
static void sbtsi_adev_release(struct device *dev)
{
kfree(to_auxiliary_dev(dev));
}
static void sbtsi_unregister_hwmon_adev(void *_adev)
{
struct auxiliary_device *adev = _adev;
auxiliary_device_delete(adev);
auxiliary_device_uninit(adev);
}
static void sbtsi_misc_unregister(void *arg)
{
struct sbtsi_data *data = arg;
misc_deregister(&data->sbtsi_misc_dev);
guard(sbtsi)(data);
data->detached = true;
}
static void sbtsi_driver_unref(void *arg)
{
struct sbtsi_data *data = arg;
kref_put(&data->kref, sbtsi_data_release);
}
static int sbtsi_create_hwmon_adev(struct device *dev, u8 dev_addr)
{
struct auxiliary_device *adev;
int ret;
adev = kzalloc_obj(*adev);
if (!adev)
return -ENOMEM;
adev->name = AMD_SBTSI_AUX_HWMON;
adev->id = dev_addr;
adev->dev.parent = dev;
adev->dev.release = sbtsi_adev_release;
ret = auxiliary_device_init(adev);
if (ret) {
kfree(adev);
return ret;
}
ret = __auxiliary_device_add(adev, AMD_SBTSI_ADEV);
if (ret) {
auxiliary_device_uninit(adev);
return ret;
}
return devm_add_action_or_reset(dev, sbtsi_unregister_hwmon_adev, adev);
}
static int sbtsi_probe_common(struct device *dev, struct sbtsi_data *data)
{
u8 val;
int err;
mutex_init(&data->lock);
kref_init(&data->kref);
err = devm_add_action_or_reset(dev, sbtsi_driver_unref, data);
if (err)
return err;
err = sbtsi_xfer(data, SBTSI_REG_CONFIG, &val, true);
if (err)
return err;
data->ext_range_mode = FIELD_GET(BIT(SBTSI_CONFIG_EXT_RANGE_SHIFT), val);
data->read_order = FIELD_GET(BIT(SBTSI_CONFIG_READ_ORDER_SHIFT), val);
dev_set_drvdata(dev, data);
err = sbtsi_create_hwmon_adev(dev, data->dev_addr);
if (err < 0)
return err;
err = create_misc_tsi_device(data, dev);
if (err)
return err;
return devm_add_action_or_reset(dev, sbtsi_misc_unregister, data);
}
static int sbtsi_i2c_probe(struct i2c_client *client)
{
struct device *dev = &client->dev;
struct sbtsi_data *data;
data = kzalloc_obj(*data);
if (!data)
return -ENOMEM;
data->is_i3c = false;
data->client = client;
data->dev_addr = client->addr;
return sbtsi_probe_common(dev, data);
}
static const struct i2c_device_id sbtsi_id[] = {
{ .name = "sbtsi" },
{ }
};
MODULE_DEVICE_TABLE(i2c, sbtsi_id);
static const struct of_device_id __maybe_unused sbtsi_of_match[] = {
{
.compatible = "amd,sbtsi",
},
{ },
};
MODULE_DEVICE_TABLE(of, sbtsi_of_match);
static struct i2c_driver sbtsi_driver = {
.driver = {
.name = "sbtsi-i2c",
.of_match_table = of_match_ptr(sbtsi_of_match),
},
.probe = sbtsi_i2c_probe,
.id_table = sbtsi_id,
};
static int sbtsi_i3c_probe(struct i3c_device *i3cdev)
{
struct device *dev = i3cdev_to_dev(i3cdev);
struct i3c_device_info devinfo;
struct sbtsi_i3c_priv *i3c_priv;
struct sbtsi_data *data;
i3c_device_get_info(i3cdev, &devinfo);
if (I3C_PID_INSTANCE_ID(devinfo.pid) != 0)
return -ENXIO;
i3c_priv = kzalloc_obj(*i3c_priv);
if (!i3c_priv)
return -ENOMEM;
data = &i3c_priv->data;
data->i3cdev = i3cdev;
data->is_i3c = true;
data->dev_addr = devinfo.dyn_addr;
return sbtsi_probe_common(dev, data);
}
static const struct i3c_device_id sbtsi_i3c_id[] = {
I3C_DEVICE_EXTRA_INFO(0x112, 0x0, 0x1, NULL),
I3C_DEVICE_EXTRA_INFO(0x0, 0x0, 0x118, NULL),
I3C_DEVICE_EXTRA_INFO(0x0, 0x100, 0x118, NULL),
I3C_DEVICE_EXTRA_INFO(0x112, 0x0, 0x119, NULL),
I3C_DEVICE_EXTRA_INFO(0x112, 0x100, 0x119, NULL),
{}
};
MODULE_DEVICE_TABLE(i3c, sbtsi_i3c_id);
static struct i3c_driver sbtsi_i3c_driver = {
.driver = {
.name = "sbtsi-i3c",
},
.probe = sbtsi_i3c_probe,
.id_table = sbtsi_i3c_id,
};
module_i3c_i2c_driver(sbtsi_i3c_driver, &sbtsi_driver);
MODULE_DESCRIPTION("AMD SB-TSI I2C/I3C core driver");
MODULE_LICENSE("GPL"