#include <linux/bitfield.h>
#include <linux/bitops.h>
#include <linux/cleanup.h>
#include <linux/debugfs.h>
#include <linux/err.h>
#include <linux/hwmon.h>
#include <linux/i2c.h>
#include <linux/iopoll.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/seq_file.h>
#include <linux/types.h>
#include <linux/unaligned.h>
#define KB9002_DEV_NAME "kb9002"
#define KB9002_CC_FW_READ_PRIME 0x82
#define KB9002_CC_FW_READ_DATA 0x81
#define KB9002_CC_HW_READ_PRIME 0x8a
#define KB9002_CC_HW_READ_DATA 0x89
#define KB9002_FW_REG_VID 0x0004
#define KB9002_FW_REG_FW_VERSION 0x0500
#define KB9002_FW_REG_TEMP_MAXIMUM 0x0550
#define KB9002_VID_MASK GENMASK(31, 16)
#define KB9002_VID_KANDOU 0x1e6f
#define KB9002_HW_REG_FW_BOOT_STATUS 0xe0090008
#define KB9002_FW_BOOT_STATUS_OK_MSB 0xe8
#define KB9002_HW_REG_REVID 0x00480004
#define KB9002_HW_REG_HOST_IF 0x00480008
#define KB9002_HOST_IF_SMBUS BIT(1)
#define KB9002_REVID_MASK GENMASK(7, 0)
#define KB9002_REVID_B0 0x10
#define KB9002_REVID_B1 0x11
#define KB9002_REVID_READ_RETRIES 16
#define KB9002_TEMP_FRAC_BITS 16
#define KB9002_ABS_ZERO_MILLI_C (-273150)
#define KB9002_FW_READY_POLL_US (25 * USEC_PER_MSEC)
#define KB9002_FW_READY_TIMEOUT_US (2 * USEC_PER_SEC)
struct kb9002_data {
struct i2c_client *client;
struct device *hwmon_dev;
};
static int kb9002_i2c_read(struct i2c_client *client, u32 reg, u32 *val)
{
u8 addr[4];
u8 rbuf[4];
struct i2c_msg msgs[2] = {
{
.addr = client->addr,
.flags = 0,
.len = sizeof(addr),
.buf = addr,
},
{
.addr = client->addr,
.flags = I2C_M_RD,
.len = sizeof(rbuf),
.buf = rbuf,
},
};
int ret;
put_unaligned_be32(reg, addr);
ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
if (ret < 0)
return ret;
if (ret != ARRAY_SIZE(msgs))
return -EIO;
*val = get_unaligned_be32(rbuf);
return 0;
}
static int kb9002_i2c_write(struct i2c_client *client, u32 reg, u32 val)
{
u8 buf[8];
struct i2c_msg msg = {
.addr = client->addr,
.flags = 0,
.len = sizeof(buf),
.buf = buf,
};
int ret;
put_unaligned_be32(reg, &buf[0]);
put_unaligned_be32(val, &buf[4]);
ret = i2c_transfer(client->adapter, &msg, 1);
if (ret < 0)
return ret;
if (ret != 1)
return -EIO;
return 0;
}
static int kb9002_read_revid(struct i2c_client *client, u32 *revid)
{
u8 dummy;
int ret;
int i;
for (i = 0; i < KB9002_REVID_READ_RETRIES; i++) {
ret = kb9002_i2c_read(client, KB9002_HW_REG_REVID, revid);
if (ret)
return ret;
if ((*revid >> 24) != 0xff)
return 0;
i2c_master_recv(client, &dummy, 1);
}
return -EIO;
}
static int kb9002_fw_read(struct kb9002_data *data, u16 reg, u32 *val)
{
struct i2c_client *client = data->client;
u8 addr[2];
u8 rbuf[I2C_SMBUS_BLOCK_MAX];
int ret;
put_unaligned_le16(reg, addr);
ret = i2c_smbus_write_block_data(client, KB9002_CC_FW_READ_PRIME,
sizeof(addr), addr);
if (ret < 0)
return ret;
ret = i2c_smbus_read_block_data(client, KB9002_CC_FW_READ_DATA, rbuf);
if (ret < 0)
return ret;
if (ret < (int)(sizeof(addr) + sizeof(*val)))
return -EIO;
*val = get_unaligned_le32(&rbuf[sizeof(addr)]);
return 0;
}
static int kb9002_smbus_hw_read(struct kb9002_data *data, u32 reg, u32 *val)
{
struct i2c_client *client = data->client;
u8 addr[4];
u8 rbuf[I2C_SMBUS_BLOCK_MAX];
int ret;
put_unaligned_le32(reg, addr);
ret = i2c_smbus_write_block_data(client, KB9002_CC_HW_READ_PRIME,
sizeof(addr), addr);
if (ret < 0)
return ret;
ret = i2c_smbus_read_block_data(client, KB9002_CC_HW_READ_DATA, rbuf);
if (ret < 0)
return ret;
if (ret < (int)(sizeof(addr) + sizeof(*val)))
return -EIO;
*val = get_unaligned_le32(&rbuf[sizeof(addr)]);
return 0;
}
static int kb9002_enable_smbus_target(struct kb9002_data *data)
{
struct i2c_client *client = data->client;
u32 revid;
u32 val;
int op_ret;
int ret;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
return dev_err_probe(&client->dev, -ENODEV,
"raw I2C required to switch to SMBus mode\n");
ret = kb9002_read_revid(client, &revid);
if (ret)
return dev_err_probe(&client->dev, ret,
"revision ID read failed\n");
switch (FIELD_GET(KB9002_REVID_MASK, revid)) {
case KB9002_REVID_B0:
case KB9002_REVID_B1:
break;
default:
return dev_err_probe(&client->dev, -ENODEV,
"unsupported revision ID 0x%08x\n", revid);
}
ret = kb9002_i2c_read(client, KB9002_HW_REG_HOST_IF, &val);
if (ret)
return dev_err_probe(&client->dev, ret,
"host interface read failed\n");
val |= KB9002_HOST_IF_SMBUS;
ret = kb9002_i2c_write(client, KB9002_HW_REG_HOST_IF, val);
if (ret)
return dev_err_probe(&client->dev, ret,
"host interface write failed\n");
ret = read_poll_timeout(kb9002_fw_read, op_ret, op_ret == 0,
KB9002_FW_READY_POLL_US,
KB9002_FW_READY_TIMEOUT_US, true,
data, KB9002_FW_REG_VID, &val);
if (ret)
return dev_err_probe(&client->dev, ret,
"firmware not responding over SMBus\n");
return 0;
}
static long kb9002_temp_to_milli_c(u32 raw)
{
s64 milli_k = ((s64)raw * 1000) >> KB9002_TEMP_FRAC_BITS;
return (long)milli_k + KB9002_ABS_ZERO_MILLI_C;
}
static int kb9002_read_temp(struct kb9002_data *data, long *val)
{
u32 raw;
int ret;
ret = kb9002_fw_read(data, KB9002_FW_REG_TEMP_MAXIMUM, &raw);
if (ret)
return ret;
*val = kb9002_temp_to_milli_c(raw);
return 0;
}
static umode_t kb9002_is_visible(const void *drvdata,
enum hwmon_sensor_types type,
u32 attr, int channel)
{
return 0444;
}
static int kb9002_read(struct device *dev, enum hwmon_sensor_types type,
u32 attr, int channel, long *val)
{
struct kb9002_data *data = dev_get_drvdata(dev);
if (type == hwmon_temp && attr == hwmon_temp_input)
return kb9002_read_temp(data, val);
return -EOPNOTSUPP;
}
static const struct hwmon_ops kb9002_hwmon_ops = {
.is_visible = kb9002_is_visible,
.read = kb9002_read,
};
static const struct hwmon_channel_info * const kb9002_hwmon_info[] = {
HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT),
NULL,
};
static const struct hwmon_chip_info kb9002_chip_info = {
.ops = &kb9002_hwmon_ops,
.info = kb9002_hwmon_info,
};
static int kb9002_fw_version_show(struct seq_file *s, void *unused)
{
struct kb9002_data *data = s->private;
u32 ver;
int ret;
guard(hwmon_lock)(data->hwmon_dev);
ret = kb9002_fw_read(data, KB9002_FW_REG_FW_VERSION, &ver);
if (ret)
return ret;
seq_printf(s, "%u.%02u.%02u.%u\n",
(ver >> 24) & 0xff, (ver >> 16) & 0xff,
(ver >> 8) & 0xff, (ver >> 0) & 0xff);
return 0;
}
DEFINE_SHOW_ATTRIBUTE(kb9002_fw_version);
static int kb9002_fw_load_status_show(struct seq_file *s, void *unused)
{
struct kb9002_data *data = s->private;
u32 status;
int ret;
guard(hwmon_lock)(data->hwmon_dev);
ret = kb9002_smbus_hw_read(data, KB9002_HW_REG_FW_BOOT_STATUS, &status);
if (ret)
return ret;
seq_printf(s, "%s\n",
(status >> 24) == KB9002_FW_BOOT_STATUS_OK_MSB ?
"normal" : "abnormal");
return 0;
}
DEFINE_SHOW_ATTRIBUTE(kb9002_fw_load_status);
static void kb9002_debugfs_init(struct kb9002_data *data)
{
struct dentry *dir = data->client->debugfs;
debugfs_create_file("fw_ver", 0444, dir, data,
&kb9002_fw_version_fops);
debugfs_create_file("fw_load_status", 0444, dir, data,
&kb9002_fw_load_status_fops);
}
static int kb9002_probe(struct i2c_client *client)
{
struct device *dev = &client->dev;
struct kb9002_data *data;
struct device *hwmon_dev;
u32 vid;
int ret;
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_BLOCK_DATA |
I2C_FUNC_SMBUS_PEC))
return -ENODEV;
data = devm_kzalloc_obj(dev, *data);
if (!data)
return -ENOMEM;
data->client = client;
client->flags |= I2C_CLIENT_PEC;
i2c_set_clientdata(client, data);
ret = kb9002_fw_read(data, KB9002_FW_REG_VID, &vid);
if (ret) {
dev_dbg(dev, "SMBus probe failed (%d), trying raw-I2C host-interface switch\n",
ret);
ret = kb9002_enable_smbus_target(data);
if (ret)
return ret;
ret = kb9002_fw_read(data, KB9002_FW_REG_VID, &vid);
if (ret)
return dev_err_probe(dev, ret,
"VID read failed after host-interface switch\n");
}
if (FIELD_GET(KB9002_VID_MASK, vid) != KB9002_VID_KANDOU)
return dev_err_probe(dev, -ENODEV,
"unexpected VID 0x%08x\n", vid);
hwmon_dev = devm_hwmon_device_register_with_info(dev, KB9002_DEV_NAME,
data,
&kb9002_chip_info,
NULL);
if (IS_ERR(hwmon_dev))
return PTR_ERR(hwmon_dev);
data->hwmon_dev = hwmon_dev;
kb9002_debugfs_init(data);
return 0;
}
static const struct i2c_device_id kb9002_id[] = {
{ .name = KB9002_DEV_NAME },
{ }
};
MODULE_DEVICE_TABLE(i2c, kb9002_id);
static const struct of_device_id kb9002_of_match[] = {
{ .compatible = "kandou,kb9002" },
{ }
};
MODULE_DEVICE_TABLE(of, kb9002_of_match);
static struct i2c_driver kb9002_driver = {
.driver = {
.name = KB9002_DEV_NAME,
.of_match_table = kb9002_of_match,
},
.probe = kb9002_probe,
.id_table = kb9002_id,
};
module_i2c_driver(kb9002_driver);
MODULE_AUTHOR("Andy Chung <andy.chung@amd.com>");
MODULE_DESCRIPTION("Kandou KB9002 PCIe retimer hwmon driver");
MODULE_LICENSE("GPL"