From: Alexandru Tachici <[email protected]>
Add PMBus probing driver for the adm1266 Cascadable
Super Sequencer with Margin Control and Fault Recording.
Driver is using the pmbus_core, creating sysfs files
under hwmon for inputs: vh1->vh4 and vp1->vp13.
1. Add PMBus probing driver for inputs vh1->vh4
and vp1->vp13.
2. Add Block Write-Read Process Call command.
A PMBus specific implementation was required because
block write with I2C_SMBUS_PROC_CALL flag allows a
maximum of 32 bytes to be received.
3. This makes adm1266 driver expose GPIOs
to user-space. Currently are read only. Future
developments on the firmware will allow
them to be writable.
4. Add two ioctl commands for issuing GO_COMMAND
and reading the state of the adm1266 sequencer.
5. Blackboxes are 64 bytes of chip state related data
that is generated on faults. Use the nvmem kernel api
to expose the blackbox chip functionality to userspace.
6. Expose BLACKBOX_INFO register through debugfs.
7. Device tree bindings for ADM1266.
Alexandru Tachici (7):
hwmon: pmbus: adm1266: add support
hwmon: pmbus: adm1266: Add Block process call
hwmon: pmbus: adm1266: Add support for GPIOs
hwmon: pmbus: adm1266: Add ioctl commands
hwmon: pmbus: adm1266: read blackbox
hwmon: pmbus: adm1266: debugfs for blackbox info
dt-bindings: hwmon: Add bindings for ADM1266
Changelog v3 -> v4:
- moved pmbus_block_wr (pmbus process call) from pmbus_core.
to adm1266.c and renamed to pmbus_block_xfer
- in pmbus_block_xfer: fixed buffer size bug (from 255 to 257)
- in adm1266_gpio_get_multiple: handle pdios and gpios one at a time
to lower allocated space on stack
- in adm1266_gpio_dbg_show: replaced write_buf with u8 write_cmd var
- in adm1266_gpio_dbg_show: check number of bytes received from device
returned by pmbus_block_xfer.
- now use ioctl to send GO_COMMAND and retrieve current state of adm1266
- split blackbox commit into blackbox nvmem implementation and debugfs
blackbox info debugfs
- create adm1266 debugfs dir under /sys/kernel/debug/pmbus/hwmon for
blackbox_info
Changelog v4 -> v5:
- added WITH Linux-syscall-note to adm1266.h
.../bindings/hwmon/adi,adm1266.yaml | 56 ++
Documentation/hwmon/adm1266.rst | 50 ++
.../userspace-api/ioctl/ioctl-number.rst | 1 +
drivers/hwmon/pmbus/Kconfig | 10 +
drivers/hwmon/pmbus/Makefile | 1 +
drivers/hwmon/pmbus/adm1266.c | 657 ++++++++++++++++++
include/uapi/linux/adm1266.h | 16 +
7 files changed, 791 insertions(+)
create mode 100644 Documentation/devicetree/bindings/hwmon/adi,adm1266.yaml
create mode 100644 Documentation/hwmon/adm1266.rst
create mode 100644 drivers/hwmon/pmbus/adm1266.c
create mode 100644 include/uapi/linux/adm1266.h
--
2.20.1
From: Alexandru Tachici <[email protected]>
Adm1266 exposes 9 GPIOs and 16 PDIOs which are currently read-only. They
are controlled by the internal sequencing engine.
This patch makes adm1266 driver expose GPIOs and PDIOs to user-space
using GPIO provider kernel api.
Signed-off-by: Alexandru Tachici <[email protected]>
---
drivers/hwmon/pmbus/adm1266.c | 233 +++++++++++++++++++++++++++++++++-
1 file changed, 232 insertions(+), 1 deletion(-)
diff --git a/drivers/hwmon/pmbus/adm1266.c b/drivers/hwmon/pmbus/adm1266.c
index 381d89a8569f..76bf2c78e737 100644
--- a/drivers/hwmon/pmbus/adm1266.c
+++ b/drivers/hwmon/pmbus/adm1266.c
@@ -6,8 +6,12 @@
* Copyright 2020 Analog Devices Inc.
*/
+#include <linux/bitfield.h>
#include <linux/crc8.h>
+#include <linux/debugfs.h>
+#include <linux/gpio/driver.h>
#include <linux/i2c.h>
+#include <linux/i2c-smbus.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
@@ -15,10 +19,35 @@
#include "pmbus.h"
+#define ADM1266_PDIO_CONFIG 0xD4
+#define ADM1266_GPIO_CONFIG 0xE1
+#define ADM1266_PDIO_STATUS 0xE9
+#define ADM1266_GPIO_STATUS 0xEA
+
+/* ADM1266 GPIO defines */
+#define ADM1266_GPIO_NR 9
+#define ADM1266_GPIO_FUNCTIONS(x) FIELD_GET(BIT(0), x)
+#define ADM1266_GPIO_INPUT_EN(x) FIELD_GET(BIT(2), x)
+#define ADM1266_GPIO_OUTPUT_EN(x) FIELD_GET(BIT(3), x)
+#define ADM1266_GPIO_OPEN_DRAIN(x) FIELD_GET(BIT(4), x)
+
+/* ADM1266 PDIO defines */
+#define ADM1266_PDIO_NR 16
+#define ADM1266_PDIO_PIN_CFG(x) FIELD_GET(GENMASK(15, 13), x)
+#define ADM1266_PDIO_GLITCH_FILT(x) FIELD_GET(GENMASK(12, 9), x)
+#define ADM1266_PDIO_OUT_CFG(x) FIELD_GET(GENMASK(2, 0), x)
+
#define ADM1266_PMBUS_BLOCK_MAX 255
DECLARE_CRC8_TABLE(pmbus_crc_table);
+struct adm1266_data {
+ struct pmbus_driver_info info;
+ struct gpio_chip gc;
+ const char *gpio_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR];
+ struct i2c_client *client;
+};
+
/* Different from Block Read as it sends data and waits for the slave to
* return a value dependent on that data. The protocol is simply a Write Block
* followed by a Read Block without the Read-Block command field and the
@@ -91,18 +120,220 @@ int pmbus_block_xfer(struct i2c_client *client, u8 cmd, u8 w_len,
return ret;
}
+#ifdef CONFIG_GPIOLIB
+static const unsigned int adm1266_gpio_mapping[ADM1266_GPIO_NR][2] = {
+ {1, 0},
+ {2, 1},
+ {3, 2},
+ {4, 8},
+ {5, 9},
+ {6, 10},
+ {7, 11},
+ {8, 6},
+ {9, 7},
+};
+
+static const char *adm1266_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR] = {
+ "GPIO1", "GPIO2", "GPIO3", "GPIO4", "GPIO5", "GPIO6", "GPIO7", "GPIO8",
+ "GPIO9", "PDIO1", "PDIO2", "PDIO3", "PDIO4", "PDIO5", "PDIO6",
+ "PDIO7", "PDIO8", "PDIO9", "PDIO10", "PDIO11", "PDIO12", "PDIO13",
+ "PDIO14", "PDIO15", "PDIO16",
+};
+
+static int adm1266_gpio_get(struct gpio_chip *chip, unsigned int offset)
+{
+ struct adm1266_data *data = gpiochip_get_data(chip);
+ u8 read_buf[I2C_SMBUS_BLOCK_MAX + 1];
+ unsigned long pins_status;
+ unsigned int pmbus_cmd;
+ int ret;
+
+ if (offset < ADM1266_GPIO_NR)
+ pmbus_cmd = ADM1266_GPIO_STATUS;
+ else
+ pmbus_cmd = ADM1266_PDIO_STATUS;
+
+ ret = i2c_smbus_read_block_data(data->client, pmbus_cmd,
+ read_buf);
+ if (ret < 0)
+ return ret;
+
+ pins_status = read_buf[0] + (read_buf[1] << 8);
+ if (offset < ADM1266_GPIO_NR)
+ return test_bit(adm1266_gpio_mapping[offset][1], &pins_status);
+
+ return test_bit(offset - ADM1266_GPIO_NR, &pins_status);
+}
+
+static int adm1266_gpio_get_multiple(struct gpio_chip *chip,
+ unsigned long *mask,
+ unsigned long *bits)
+{
+ struct adm1266_data *data = gpiochip_get_data(chip);
+ u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 1];
+ unsigned long status;
+ unsigned int gpio_nr;
+ int ret;
+
+ ret = i2c_smbus_read_block_data(data->client, ADM1266_GPIO_STATUS,
+ read_buf);
+ if (ret < 0)
+ return ret;
+
+ status = read_buf[0] + (read_buf[1] << 8);
+
+ *bits = 0;
+ for_each_set_bit(gpio_nr, mask, ADM1266_GPIO_NR) {
+ if (test_bit(adm1266_gpio_mapping[gpio_nr][1], &status))
+ set_bit(gpio_nr, bits);
+ }
+
+ ret = i2c_smbus_read_block_data(data->client, ADM1266_PDIO_STATUS,
+ read_buf);
+ if (ret < 0)
+ return ret;
+
+ status = read_buf[0] + (read_buf[1] << 8);
+
+ *bits = 0;
+ for_each_set_bit_from(gpio_nr, mask,
+ ADM1266_GPIO_NR + ADM1266_PDIO_STATUS) {
+ if (test_bit(gpio_nr - ADM1266_GPIO_NR, &status))
+ set_bit(gpio_nr, bits);
+ }
+
+ return 0;
+}
+
+static void adm1266_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
+{
+ struct adm1266_data *data = gpiochip_get_data(chip);
+ u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 1];
+ unsigned long gpio_config;
+ unsigned long pdio_config;
+ unsigned long pin_cfg;
+ u8 write_cmd;
+ int ret;
+ int i;
+
+ for (i = 0; i < ADM1266_GPIO_NR; i++) {
+ write_cmd = adm1266_gpio_mapping[i][1];
+ ret = pmbus_block_xfer(data->client, ADM1266_GPIO_CONFIG, 1,
+ &write_cmd, read_buf);
+ if (ret != 2)
+ return;
+
+ gpio_config = read_buf[0];
+ seq_puts(s, adm1266_names[i]);
+
+ seq_puts(s, " ( ");
+ if (!ADM1266_GPIO_FUNCTIONS(gpio_config)) {
+ seq_puts(s, "high-Z )\n");
+ continue;
+ }
+ if (ADM1266_GPIO_INPUT_EN(gpio_config))
+ seq_puts(s, "input ");
+ if (ADM1266_GPIO_OUTPUT_EN(gpio_config))
+ seq_puts(s, "output ");
+ if (ADM1266_GPIO_OPEN_DRAIN(gpio_config))
+ seq_puts(s, "open-drain )\n");
+ else
+ seq_puts(s, "push-pull )\n");
+ }
+
+ write_cmd = 0xFF;
+ ret = pmbus_block_xfer(data->client, ADM1266_PDIO_CONFIG, 1, &write_cmd,
+ read_buf);
+ if (ret != 32)
+ return;
+
+ for (i = 0; i < ADM1266_PDIO_NR; i++) {
+ seq_puts(s, adm1266_names[ADM1266_GPIO_NR + i]);
+
+ pdio_config = read_buf[2 * i];
+ pdio_config += (read_buf[2 * i + 1] << 8);
+ pin_cfg = ADM1266_PDIO_PIN_CFG(pdio_config);
+
+ seq_puts(s, " ( ");
+ if (!pin_cfg || pin_cfg > 5) {
+ seq_puts(s, "high-Z )\n");
+ continue;
+ }
+
+ if (pin_cfg & BIT(0))
+ seq_puts(s, "output ");
+
+ if (pin_cfg & BIT(1))
+ seq_puts(s, "input ");
+
+ seq_puts(s, ")\n");
+ }
+}
+
+static int adm1266_config_gpio(struct adm1266_data *data)
+{
+ const char *name = dev_name(&data->client->dev);
+ char *gpio_name;
+ int ret;
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(data->gpio_names); i++) {
+ gpio_name = devm_kasprintf(&data->client->dev, GFP_KERNEL,
+ "adm1266-%x-%s", data->client->addr,
+ adm1266_names[i]);
+ if (!gpio_name)
+ return -ENOMEM;
+
+ data->gpio_names[i] = gpio_name;
+ }
+
+ data->gc.label = name;
+ data->gc.parent = &data->client->dev;
+ data->gc.owner = THIS_MODULE;
+ data->gc.base = -1;
+ data->gc.names = data->gpio_names;
+ data->gc.ngpio = ARRAY_SIZE(data->gpio_names);
+ data->gc.get = adm1266_gpio_get;
+ data->gc.get_multiple = adm1266_gpio_get_multiple;
+ data->gc.dbg_show = adm1266_gpio_dbg_show;
+
+ ret = devm_gpiochip_add_data(&data->client->dev, &data->gc, data);
+ if (ret)
+ dev_err(&data->client->dev, "GPIO registering failed (%d)\n",
+ ret);
+
+ return ret;
+}
+#else
+static int adm1266_config_gpio(struct adm1266_data *data)
+{
+ return 0;
+}
+#endif
+
static int adm1266_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct pmbus_driver_info *info;
+ struct adm1266_data *data;
u32 funcs;
+ int ret;
int i;
- info = devm_kzalloc(&client->dev, sizeof(struct pmbus_driver_info),
+ data = devm_kzalloc(&client->dev, sizeof(struct adm1266_data),
GFP_KERNEL);
+ if (!data)
+ return -ENOMEM;
+
+ data->client = client;
+
+ ret = adm1266_config_gpio(data);
+ if (ret < 0)
+ return ret;
crc8_populate_msb(pmbus_crc_table, 0x7);
+ info = &data->info;
info->pages = 17;
info->format[PSC_VOLTAGE_OUT] = linear;
funcs = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
--
2.20.1
From: Alexandru Tachici <[email protected]>
Add a debugfs file to print information in the
BLACKBOX_INFORMATION register. Contains information
about the number of stored records, logic index and id
of the latest record.
Signed-off-by: Alexandru Tachici <[email protected]>
---
drivers/hwmon/pmbus/adm1266.c | 56 ++++++++++++++++++++++++++++++++++-
1 file changed, 55 insertions(+), 1 deletion(-)
diff --git a/drivers/hwmon/pmbus/adm1266.c b/drivers/hwmon/pmbus/adm1266.c
index b9e92ab1e39a..ea2dc481094b 100644
--- a/drivers/hwmon/pmbus/adm1266.c
+++ b/drivers/hwmon/pmbus/adm1266.c
@@ -60,6 +60,7 @@ struct adm1266_data {
const char *gpio_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR];
struct i2c_client *client;
struct mutex ioctl_mutex; /* lock ioctl access */
+ struct dentry *debugfs_dir;
struct nvmem_config nvmem_config;
struct nvmem_device *nvmem;
u8 *dev_mem;
@@ -406,6 +407,28 @@ static const struct proc_ops adm1266_proc_ops = {
.proc_ioctl = adm1266_ioctl,
};
+static int adm1266_blackbox_information_read(struct seq_file *s, void *pdata)
+{
+ struct device *dev = s->private;
+ struct i2c_client *client = to_i2c_client(dev);
+ u8 read_buf[5];
+ unsigned int latest_id;
+ int ret;
+
+ ret = i2c_smbus_read_block_data(client, ADM1266_BLACKBOX_INFO,
+ read_buf);
+ if (ret < 0)
+ return ret;
+
+ seq_puts(s, "BLACKBOX_INFORMATION:\n");
+ latest_id = read_buf[0] + (read_buf[1] << 8);
+ seq_printf(s, "Black box ID: %u\n", latest_id);
+ seq_printf(s, "Logic index: %u\n", read_buf[2]);
+ seq_printf(s, "Record count: %u\n", read_buf[3]);
+
+ return 0;
+}
+
static int adm1266_init_procfs(struct adm1266_data *data)
{
struct proc_dir_entry *proc_dir;
@@ -423,6 +446,29 @@ static int adm1266_init_procfs(struct adm1266_data *data)
return 0;
}
+static int adm1266_init_debugfs(struct adm1266_data *data)
+{
+ struct dentry *entry;
+ struct dentry *root;
+
+ root = pmbus_get_debugfs_dir(data->client);
+ if (!root)
+ return -ENOENT;
+
+ data->debugfs_dir = debugfs_create_dir(data->client->name, root);
+ if (!data->debugfs_dir)
+ return -ENOENT;
+
+ entry = debugfs_create_devm_seqfile(&data->client->dev,
+ "blackbox_information",
+ data->debugfs_dir,
+ adm1266_blackbox_information_read);
+ if (!entry)
+ return -ENOENT;
+
+ return 0;
+}
+
static int adm1266_nvmem_read_blackbox(struct adm1266_data *data, u8 *buf)
{
u8 read_buf[5];
@@ -571,7 +617,15 @@ static int adm1266_probe(struct i2c_client *client,
for (i = 0; i < info->pages; i++)
info->func[i] = funcs;
- return pmbus_do_probe(client, id, info);
+ ret = pmbus_do_probe(client, id, info);
+ if (ret)
+ return ret;
+
+ ret = adm1266_init_debugfs(data);
+ if (ret)
+ dev_warn(&client->dev, "Failed to register debugfs: %d\n", ret);
+
+ return 0;
}
static const struct of_device_id adm1266_of_match[] = {
--
2.20.1
From: Alexandru Tachici <[email protected]>
Add two ioctl commands for reading the current state
of the adm1266 sequencer and sending commands.
Signed-off-by: Alexandru Tachici <[email protected]>
---
Documentation/hwmon/adm1266.rst | 15 +++
.../userspace-api/ioctl/ioctl-number.rst | 1 +
drivers/hwmon/pmbus/adm1266.c | 97 +++++++++++++++++++
include/uapi/linux/adm1266.h | 16 +++
4 files changed, 129 insertions(+)
create mode 100644 include/uapi/linux/adm1266.h
diff --git a/Documentation/hwmon/adm1266.rst b/Documentation/hwmon/adm1266.rst
index 65662115750c..5dc05808db60 100644
--- a/Documentation/hwmon/adm1266.rst
+++ b/Documentation/hwmon/adm1266.rst
@@ -33,3 +33,18 @@ inX_min Minimum Voltage.
inX_max Maximum voltage.
inX_min_alarm Voltage low alarm.
inX_max_alarm Voltage high alarm.
+
+
+User API
+========
+
+ioctls
+------
+
+ADM1266_SET_GO_COMMAND:
+
+ Issue a GO_COMMAND to the device.
+
+ADM1266_GET_STATUS:
+
+ Returns state of the sequencer.
diff --git a/Documentation/userspace-api/ioctl/ioctl-number.rst b/Documentation/userspace-api/ioctl/ioctl-number.rst
index 59472cd6a11d..df92ca274622 100644
--- a/Documentation/userspace-api/ioctl/ioctl-number.rst
+++ b/Documentation/userspace-api/ioctl/ioctl-number.rst
@@ -348,6 +348,7 @@ Code Seq# Include File Comments
0xCC 00-0F drivers/misc/ibmvmc.h pseries VMC driver
0xCD 01 linux/reiserfs_fs.h
0xCF 02 fs/cifs/ioctl.c
+0xD1 00-0F linux/adm1266.h
0xDB 00-0F drivers/char/mwave/mwavepub.h
0xDD 00-3F ZFCP device driver see drivers/s390/scsi/
<mailto:[email protected]>
diff --git a/drivers/hwmon/pmbus/adm1266.c b/drivers/hwmon/pmbus/adm1266.c
index 76bf2c78e737..0960ead8d96a 100644
--- a/drivers/hwmon/pmbus/adm1266.c
+++ b/drivers/hwmon/pmbus/adm1266.c
@@ -15,11 +15,16 @@
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
+#include <linux/proc_fs.h>
#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/adm1266.h>
#include "pmbus.h"
#define ADM1266_PDIO_CONFIG 0xD4
+#define ADM1266_GO_COMMAND 0xD8
+#define ADM1266_READ_STATE 0xD9
#define ADM1266_GPIO_CONFIG 0xE1
#define ADM1266_PDIO_STATUS 0xE9
#define ADM1266_GPIO_STATUS 0xEA
@@ -46,6 +51,7 @@ struct adm1266_data {
struct gpio_chip gc;
const char *gpio_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR];
struct i2c_client *client;
+ struct mutex ioctl_mutex; /* lock ioctl access */
};
/* Different from Block Read as it sends data and waits for the slave to
@@ -311,6 +317,93 @@ static int adm1266_config_gpio(struct adm1266_data *data)
}
#endif
+static int adm1266_set_go_command_op(struct adm1266_data *data, u8 val)
+{
+ val = FIELD_GET(GENMASK(4, 0), val);
+
+ return i2c_smbus_write_word_data(data->client, ADM1266_GO_COMMAND, val);
+}
+
+static int adm1266_ioctl_unlocked(struct file *fp, unsigned int cmd,
+ unsigned long arg)
+{
+ int __user *argp = (int __user *)arg;
+ struct adm1266_data *data;
+ int val;
+ int ret;
+
+ data = fp->private_data;
+
+ if (!argp)
+ return -EINVAL;
+
+ switch (cmd) {
+ case ADM1266_SET_GO_COMMAND:
+ if (copy_from_user(&val, argp, sizeof(int)))
+ return -EFAULT;
+
+ return adm1266_set_go_command_op(data, val);
+ case ADM1266_GET_STATUS:
+ ret = i2c_smbus_read_word_data(data->client,
+ ADM1266_READ_STATE);
+
+ if (ret < 0)
+ return ret;
+
+ if (copy_to_user(argp, &ret, sizeof(int)))
+ return -EFAULT;
+
+ break;
+ default:
+ return -ENOTTY;
+ }
+
+ return 0;
+}
+
+static long adm1266_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
+{
+ struct adm1266_data *data;
+ long ret;
+
+ data = fp->private_data;
+
+ mutex_lock(&data->ioctl_mutex);
+ ret = adm1266_ioctl_unlocked(fp, cmd, arg);
+ mutex_unlock(&data->ioctl_mutex);
+
+ return ret;
+}
+
+static int adm1266_open(struct inode *inode, struct file *filp)
+{
+ filp->private_data = PDE_DATA(inode);
+
+ return 0;
+}
+
+static const struct proc_ops adm1266_proc_ops = {
+ .proc_open = adm1266_open,
+ .proc_ioctl = adm1266_ioctl,
+};
+
+static int adm1266_init_procfs(struct adm1266_data *data)
+{
+ struct proc_dir_entry *proc_dir;
+ u8 proc_fs_name[32];
+
+ mutex_init(&data->ioctl_mutex);
+
+ snprintf(proc_fs_name, 32, "adm1266-%x", data->client->addr);
+ proc_dir = proc_create_data(proc_fs_name, 0, NULL, &adm1266_proc_ops,
+ data);
+
+ if (!proc_dir)
+ return -EINVAL;
+
+ return 0;
+}
+
static int adm1266_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
@@ -333,6 +426,10 @@ static int adm1266_probe(struct i2c_client *client,
crc8_populate_msb(pmbus_crc_table, 0x7);
+ ret = adm1266_init_procfs(data);
+ if (ret < 0)
+ return ret;
+
info = &data->info;
info->pages = 17;
info->format[PSC_VOLTAGE_OUT] = linear;
diff --git a/include/uapi/linux/adm1266.h b/include/uapi/linux/adm1266.h
new file mode 100644
index 000000000000..535d270ee8c5
--- /dev/null
+++ b/include/uapi/linux/adm1266.h
@@ -0,0 +1,16 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * ADM1266 - Cascadable Super Sequencer with Margin
+ * Control and Fault Recording
+ *
+ * Copyright 2020 Analog Devices Inc.
+ */
+
+#ifndef _LINUX_ADM1266_H
+#define _LINUX_ADM1266_H
+
+/* ADM1266 ioctl commands */
+#define ADM1266_SET_GO_COMMAND _IOW(0xD1, 0x00, int)
+#define ADM1266_GET_STATUS _IOR(0xD1, 0x01, int)
+
+#endif
--
2.20.1
From: Alexandru Tachici <[email protected]>
PmBus devices support Block Write-Block Read Process
Call described in SMBus specification v 2.0 with the
exception that Block writes and reads are permitted to
have up 255 data bytes instead of max 32 bytes (SMBus).
This patch adds Block WR process call support for ADM1266.
Signed-off-by: Alexandru Tachici <[email protected]>
---
drivers/hwmon/pmbus/Kconfig | 1 +
drivers/hwmon/pmbus/adm1266.c | 79 +++++++++++++++++++++++++++++++++++
2 files changed, 80 insertions(+)
diff --git a/drivers/hwmon/pmbus/Kconfig b/drivers/hwmon/pmbus/Kconfig
index da34083e1ffd..c04068b665e6 100644
--- a/drivers/hwmon/pmbus/Kconfig
+++ b/drivers/hwmon/pmbus/Kconfig
@@ -28,6 +28,7 @@ config SENSORS_PMBUS
config SENSORS_ADM1266
tristate "Analog Devices ADM1266 Sequencer"
+ select CRC8
help
If you say yes here you get hardware monitoring support for Analog
Devices ADM1266 Cascadable Super Sequencer.
diff --git a/drivers/hwmon/pmbus/adm1266.c b/drivers/hwmon/pmbus/adm1266.c
index a7ef048a9a5c..381d89a8569f 100644
--- a/drivers/hwmon/pmbus/adm1266.c
+++ b/drivers/hwmon/pmbus/adm1266.c
@@ -6,6 +6,7 @@
* Copyright 2020 Analog Devices Inc.
*/
+#include <linux/crc8.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/kernel.h>
@@ -14,6 +15,82 @@
#include "pmbus.h"
+#define ADM1266_PMBUS_BLOCK_MAX 255
+
+DECLARE_CRC8_TABLE(pmbus_crc_table);
+
+/* Different from Block Read as it sends data and waits for the slave to
+ * return a value dependent on that data. The protocol is simply a Write Block
+ * followed by a Read Block without the Read-Block command field and the
+ * Write-Block STOP bit.
+ */
+int pmbus_block_xfer(struct i2c_client *client, u8 cmd, u8 w_len,
+ u8 *data_w, u8 *data_r)
+{
+ u8 write_buf[ADM1266_PMBUS_BLOCK_MAX + 2];
+ struct i2c_msg msgs[2] = {
+ {
+ .addr = client->addr,
+ .flags = 0,
+ .buf = write_buf,
+ .len = w_len + 2,
+ },
+ {
+ .addr = client->addr,
+ .flags = I2C_M_RD,
+ .len = ADM1266_PMBUS_BLOCK_MAX + 2,
+ }
+ };
+ u8 addr = 0;
+ u8 crc = 0;
+ int ret;
+
+ msgs[0].buf[0] = cmd;
+ msgs[0].buf[1] = w_len;
+ memcpy(&msgs[0].buf[2], data_w, w_len);
+
+ msgs[0].buf = i2c_get_dma_safe_msg_buf(&msgs[0], 1);
+ if (!msgs[0].buf)
+ return -ENOMEM;
+
+ msgs[1].buf = i2c_get_dma_safe_msg_buf(&msgs[1], 1);
+ if (!msgs[1].buf) {
+ i2c_put_dma_safe_msg_buf(msgs[0].buf, &msgs[0], false);
+ return -ENOMEM;
+ }
+
+ ret = i2c_transfer(client->adapter, msgs, 2);
+ if (ret != 2) {
+ ret = -EPROTO;
+ goto cleanup;
+ }
+
+ if (client->flags & I2C_CLIENT_PEC) {
+ addr = i2c_8bit_addr_from_msg(&msgs[0]);
+ crc = crc8(pmbus_crc_table, &addr, 1, crc);
+ crc = crc8(pmbus_crc_table, msgs[0].buf, msgs[0].len, crc);
+
+ addr = i2c_8bit_addr_from_msg(&msgs[1]);
+ crc = crc8(pmbus_crc_table, &addr, 1, crc);
+ crc = crc8(pmbus_crc_table, msgs[1].buf, msgs[1].buf[0] + 1,
+ crc);
+
+ if (crc != msgs[1].buf[msgs[1].buf[0] + 1]) {
+ ret = -EBADMSG;
+ goto cleanup;
+ }
+ }
+
+ memcpy(data_r, &msgs[1].buf[1], msgs[1].buf[0]);
+ ret = msgs[1].buf[0];
+
+cleanup:
+ i2c_put_dma_safe_msg_buf(msgs[0].buf, &msgs[0], true);
+ i2c_put_dma_safe_msg_buf(msgs[1].buf, &msgs[1], true);
+
+ return ret;
+}
+
static int adm1266_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
@@ -24,6 +101,8 @@ static int adm1266_probe(struct i2c_client *client,
info = devm_kzalloc(&client->dev, sizeof(struct pmbus_driver_info),
GFP_KERNEL);
+ crc8_populate_msb(pmbus_crc_table, 0x7);
+
info->pages = 17;
info->format[PSC_VOLTAGE_OUT] = linear;
funcs = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
--
2.20.1
From: Alexandru Tachici <[email protected]>
Add pmbus probing driver for the adm1266 Cascadable
Super Sequencer with Margin Control and Fault Recording.
Driver is using the pmbus_core, creating sysfs files
under hwmon for inputs: vh1->vh4 and vp1->vp13.
Signed-off-by: Alexandru Tachici <[email protected]>
---
Documentation/hwmon/adm1266.rst | 35 +++++++++++++++++++
drivers/hwmon/pmbus/Kconfig | 9 +++++
drivers/hwmon/pmbus/Makefile | 1 +
drivers/hwmon/pmbus/adm1266.c | 62 +++++++++++++++++++++++++++++++++
4 files changed, 107 insertions(+)
create mode 100644 Documentation/hwmon/adm1266.rst
create mode 100644 drivers/hwmon/pmbus/adm1266.c
diff --git a/Documentation/hwmon/adm1266.rst b/Documentation/hwmon/adm1266.rst
new file mode 100644
index 000000000000..65662115750c
--- /dev/null
+++ b/Documentation/hwmon/adm1266.rst
@@ -0,0 +1,35 @@
+Kernel driver adm1266
+=====================
+
+Supported chips:
+ * Analog Devices ADM1266
+ Prefix: 'adm1266'
+ Datasheet: https://www.analog.com/media/en/technical-documentation/data-sheets/ADM1266.pdf
+
+Author: Alexandru Tachici <[email protected]>
+
+
+Description
+-----------
+
+This driver supports hardware monitoring for Analog Devices ADM1266 sequencer.
+
+ADM1266 is a sequencer that features voltage readback from 17 channels via an
+integrated 12 bit SAR ADC, accessed using a PMBus interface.
+
+The driver is a client driver to the core PMBus driver. Please see
+Documentation/hwmon/pmbus for details on PMBus client drivers.
+
+
+Sysfs entries
+-------------
+
+The following attributes are supported. Limits are read-write, history reset
+attributes are write-only, all other attributes are read-only.
+
+inX_label "voutx"
+inX_input Measured voltage.
+inX_min Minimum Voltage.
+inX_max Maximum voltage.
+inX_min_alarm Voltage low alarm.
+inX_max_alarm Voltage high alarm.
diff --git a/drivers/hwmon/pmbus/Kconfig b/drivers/hwmon/pmbus/Kconfig
index a337195b1c39..da34083e1ffd 100644
--- a/drivers/hwmon/pmbus/Kconfig
+++ b/drivers/hwmon/pmbus/Kconfig
@@ -26,6 +26,15 @@ config SENSORS_PMBUS
This driver can also be built as a module. If so, the module will
be called pmbus.
+config SENSORS_ADM1266
+ tristate "Analog Devices ADM1266 Sequencer"
+ help
+ If you say yes here you get hardware monitoring support for Analog
+ Devices ADM1266 Cascadable Super Sequencer.
+
+ This driver can also be built as a module. If so, the module will
+ be called adm1266.
+
config SENSORS_ADM1275
tristate "Analog Devices ADM1275 and compatibles"
help
diff --git a/drivers/hwmon/pmbus/Makefile b/drivers/hwmon/pmbus/Makefile
index c4b15db996ad..da41d22be1c9 100644
--- a/drivers/hwmon/pmbus/Makefile
+++ b/drivers/hwmon/pmbus/Makefile
@@ -5,6 +5,7 @@
obj-$(CONFIG_PMBUS) += pmbus_core.o
obj-$(CONFIG_SENSORS_PMBUS) += pmbus.o
+obj-$(CONFIG_SENSORS_ADM1266) += adm1266.o
obj-$(CONFIG_SENSORS_ADM1275) += adm1275.o
obj-$(CONFIG_SENSORS_BEL_PFE) += bel-pfe.o
obj-$(CONFIG_SENSORS_IBM_CFFPS) += ibm-cffps.o
diff --git a/drivers/hwmon/pmbus/adm1266.c b/drivers/hwmon/pmbus/adm1266.c
new file mode 100644
index 000000000000..a7ef048a9a5c
--- /dev/null
+++ b/drivers/hwmon/pmbus/adm1266.c
@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * ADM1266 - Cascadable Super Sequencer with Margin
+ * Control and Fault Recording
+ *
+ * Copyright 2020 Analog Devices Inc.
+ */
+
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include "pmbus.h"
+
+static int adm1266_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct pmbus_driver_info *info;
+ u32 funcs;
+ int i;
+
+ info = devm_kzalloc(&client->dev, sizeof(struct pmbus_driver_info),
+ GFP_KERNEL);
+
+ info->pages = 17;
+ info->format[PSC_VOLTAGE_OUT] = linear;
+ funcs = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
+ for (i = 0; i < info->pages; i++)
+ info->func[i] = funcs;
+
+ return pmbus_do_probe(client, id, info);
+}
+
+static const struct of_device_id adm1266_of_match[] = {
+ { .compatible = "adi,adm1266" },
+ { }
+};
+MODULE_DEVICE_TABLE(of, adm1266_of_match);
+
+static const struct i2c_device_id adm1266_id[] = {
+ { "adm1266", 0 },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, adm1266_id);
+
+static struct i2c_driver adm1266_driver = {
+ .driver = {
+ .name = "adm1266",
+ .of_match_table = adm1266_of_match,
+ },
+ .probe = adm1266_probe,
+ .remove = pmbus_do_remove,
+ .id_table = adm1266_id,
+};
+
+module_i2c_driver(adm1266_driver);
+
+MODULE_AUTHOR("Alexandru Tachici <[email protected]>");
+MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1266");
+MODULE_LICENSE("GPL v2");
--
2.20.1
On 6/24/20 8:17 AM, [email protected] wrote:
> From: Alexandru Tachici <[email protected]>
>
> Add two ioctl commands for reading the current state
> of the adm1266 sequencer and sending commands.
>
Please note that I am not going to a accept any ioctls for hwmon drivers,
much less unprivileged commands like this.
Guenter
> Signed-off-by: Alexandru Tachici <[email protected]>
> ---
> Documentation/hwmon/adm1266.rst | 15 +++
> .../userspace-api/ioctl/ioctl-number.rst | 1 +
> drivers/hwmon/pmbus/adm1266.c | 97 +++++++++++++++++++
> include/uapi/linux/adm1266.h | 16 +++
> 4 files changed, 129 insertions(+)
> create mode 100644 include/uapi/linux/adm1266.h
>
> diff --git a/Documentation/hwmon/adm1266.rst b/Documentation/hwmon/adm1266.rst
> index 65662115750c..5dc05808db60 100644
> --- a/Documentation/hwmon/adm1266.rst
> +++ b/Documentation/hwmon/adm1266.rst
> @@ -33,3 +33,18 @@ inX_min Minimum Voltage.
> inX_max Maximum voltage.
> inX_min_alarm Voltage low alarm.
> inX_max_alarm Voltage high alarm.
> +
> +
> +User API
> +========
> +
> +ioctls
> +------
> +
> +ADM1266_SET_GO_COMMAND:
> +
> + Issue a GO_COMMAND to the device.
> +
> +ADM1266_GET_STATUS:
> +
> + Returns state of the sequencer.
> diff --git a/Documentation/userspace-api/ioctl/ioctl-number.rst b/Documentation/userspace-api/ioctl/ioctl-number.rst
> index 59472cd6a11d..df92ca274622 100644
> --- a/Documentation/userspace-api/ioctl/ioctl-number.rst
> +++ b/Documentation/userspace-api/ioctl/ioctl-number.rst
> @@ -348,6 +348,7 @@ Code Seq# Include File Comments
> 0xCC 00-0F drivers/misc/ibmvmc.h pseries VMC driver
> 0xCD 01 linux/reiserfs_fs.h
> 0xCF 02 fs/cifs/ioctl.c
> +0xD1 00-0F linux/adm1266.h
> 0xDB 00-0F drivers/char/mwave/mwavepub.h
> 0xDD 00-3F ZFCP device driver see drivers/s390/scsi/
> <mailto:[email protected]>
> diff --git a/drivers/hwmon/pmbus/adm1266.c b/drivers/hwmon/pmbus/adm1266.c
> index 76bf2c78e737..0960ead8d96a 100644
> --- a/drivers/hwmon/pmbus/adm1266.c
> +++ b/drivers/hwmon/pmbus/adm1266.c
> @@ -15,11 +15,16 @@
> #include <linux/init.h>
> #include <linux/kernel.h>
> #include <linux/module.h>
> +#include <linux/proc_fs.h>
> #include <linux/slab.h>
> +#include <linux/uaccess.h>
>
> +#include <linux/adm1266.h>
> #include "pmbus.h"
>
> #define ADM1266_PDIO_CONFIG 0xD4
> +#define ADM1266_GO_COMMAND 0xD8
> +#define ADM1266_READ_STATE 0xD9
> #define ADM1266_GPIO_CONFIG 0xE1
> #define ADM1266_PDIO_STATUS 0xE9
> #define ADM1266_GPIO_STATUS 0xEA
> @@ -46,6 +51,7 @@ struct adm1266_data {
> struct gpio_chip gc;
> const char *gpio_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR];
> struct i2c_client *client;
> + struct mutex ioctl_mutex; /* lock ioctl access */
> };
>
> /* Different from Block Read as it sends data and waits for the slave to
> @@ -311,6 +317,93 @@ static int adm1266_config_gpio(struct adm1266_data *data)
> }
> #endif
>
> +static int adm1266_set_go_command_op(struct adm1266_data *data, u8 val)
> +{
> + val = FIELD_GET(GENMASK(4, 0), val);
> +
> + return i2c_smbus_write_word_data(data->client, ADM1266_GO_COMMAND, val);
> +}
> +
> +static int adm1266_ioctl_unlocked(struct file *fp, unsigned int cmd,
> + unsigned long arg)
> +{
> + int __user *argp = (int __user *)arg;
> + struct adm1266_data *data;
> + int val;
> + int ret;
> +
> + data = fp->private_data;
> +
> + if (!argp)
> + return -EINVAL;
> +
> + switch (cmd) {
> + case ADM1266_SET_GO_COMMAND:
> + if (copy_from_user(&val, argp, sizeof(int)))
> + return -EFAULT;
> +
> + return adm1266_set_go_command_op(data, val);
> + case ADM1266_GET_STATUS:
> + ret = i2c_smbus_read_word_data(data->client,
> + ADM1266_READ_STATE);
> +
> + if (ret < 0)
> + return ret;
> +
> + if (copy_to_user(argp, &ret, sizeof(int)))
> + return -EFAULT;
> +
> + break;
> + default:
> + return -ENOTTY;
> + }
> +
> + return 0;
> +}
> +
> +static long adm1266_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
> +{
> + struct adm1266_data *data;
> + long ret;
> +
> + data = fp->private_data;
> +
> + mutex_lock(&data->ioctl_mutex);
> + ret = adm1266_ioctl_unlocked(fp, cmd, arg);
> + mutex_unlock(&data->ioctl_mutex);
> +
> + return ret;
> +}
> +
> +static int adm1266_open(struct inode *inode, struct file *filp)
> +{
> + filp->private_data = PDE_DATA(inode);
> +
> + return 0;
> +}
> +
> +static const struct proc_ops adm1266_proc_ops = {
> + .proc_open = adm1266_open,
> + .proc_ioctl = adm1266_ioctl,
> +};
> +
> +static int adm1266_init_procfs(struct adm1266_data *data)
> +{
> + struct proc_dir_entry *proc_dir;
> + u8 proc_fs_name[32];
> +
> + mutex_init(&data->ioctl_mutex);
> +
> + snprintf(proc_fs_name, 32, "adm1266-%x", data->client->addr);
> + proc_dir = proc_create_data(proc_fs_name, 0, NULL, &adm1266_proc_ops,
> + data);
> +
> + if (!proc_dir)
> + return -EINVAL;
> +
> + return 0;
> +}
> +
> static int adm1266_probe(struct i2c_client *client,
> const struct i2c_device_id *id)
> {
> @@ -333,6 +426,10 @@ static int adm1266_probe(struct i2c_client *client,
>
> crc8_populate_msb(pmbus_crc_table, 0x7);
>
> + ret = adm1266_init_procfs(data);
> + if (ret < 0)
> + return ret;
> +
> info = &data->info;
> info->pages = 17;
> info->format[PSC_VOLTAGE_OUT] = linear;
> diff --git a/include/uapi/linux/adm1266.h b/include/uapi/linux/adm1266.h
> new file mode 100644
> index 000000000000..535d270ee8c5
> --- /dev/null
> +++ b/include/uapi/linux/adm1266.h
> @@ -0,0 +1,16 @@
> +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
> +/*
> + * ADM1266 - Cascadable Super Sequencer with Margin
> + * Control and Fault Recording
> + *
> + * Copyright 2020 Analog Devices Inc.
> + */
> +
> +#ifndef _LINUX_ADM1266_H
> +#define _LINUX_ADM1266_H
> +
> +/* ADM1266 ioctl commands */
> +#define ADM1266_SET_GO_COMMAND _IOW(0xD1, 0x00, int)
> +#define ADM1266_GET_STATUS _IOR(0xD1, 0x01, int)
> +
> +#endif
>
Hi,
I love your patch! Perhaps something to improve:
[auto build test WARNING on hwmon/hwmon-next]
[also build test WARNING on linux/master robh/for-next linus/master v5.8-rc2 next-20200624]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/alexandru-tachici-analog-com/hwmon-pmbus-adm1266-add-support/20200624-232203
base: https://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging.git hwmon-next
config: mips-allyesconfig (attached as .config)
compiler: mips-linux-gcc (GCC) 9.3.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=mips
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <[email protected]>
All warnings (new ones prefixed by >>):
>> drivers/hwmon/pmbus/adm1266.c:27:5: warning: no previous prototype for 'pmbus_block_xfer' [-Wmissing-prototypes]
27 | int pmbus_block_xfer(struct i2c_client *client, u8 cmd, u8 w_len,
| ^~~~~~~~~~~~~~~~
vim +/pmbus_block_xfer +27 drivers/hwmon/pmbus/adm1266.c
21
22 /* Different from Block Read as it sends data and waits for the slave to
23 * return a value dependent on that data. The protocol is simply a Write Block
24 * followed by a Read Block without the Read-Block command field and the
25 * Write-Block STOP bit.
26 */
> 27 int pmbus_block_xfer(struct i2c_client *client, u8 cmd, u8 w_len,
28 u8 *data_w, u8 *data_r)
29 {
30 u8 write_buf[ADM1266_PMBUS_BLOCK_MAX + 2];
31 struct i2c_msg msgs[2] = {
32 {
33 .addr = client->addr,
34 .flags = 0,
35 .buf = write_buf,
36 .len = w_len + 2,
37 },
38 {
39 .addr = client->addr,
40 .flags = I2C_M_RD,
41 .len = ADM1266_PMBUS_BLOCK_MAX + 2,
42 }
43 };
44 u8 addr = 0;
45 u8 crc = 0;
46 int ret;
47
48 msgs[0].buf[0] = cmd;
49 msgs[0].buf[1] = w_len;
50 memcpy(&msgs[0].buf[2], data_w, w_len);
51
52 msgs[0].buf = i2c_get_dma_safe_msg_buf(&msgs[0], 1);
53 if (!msgs[0].buf)
54 return -ENOMEM;
55
56 msgs[1].buf = i2c_get_dma_safe_msg_buf(&msgs[1], 1);
57 if (!msgs[1].buf) {
58 i2c_put_dma_safe_msg_buf(msgs[0].buf, &msgs[0], false);
59 return -ENOMEM;
60 }
61
62 ret = i2c_transfer(client->adapter, msgs, 2);
63 if (ret != 2) {
64 ret = -EPROTO;
65 goto cleanup;
66 }
67
68 if (client->flags & I2C_CLIENT_PEC) {
69 addr = i2c_8bit_addr_from_msg(&msgs[0]);
70 crc = crc8(pmbus_crc_table, &addr, 1, crc);
71 crc = crc8(pmbus_crc_table, msgs[0].buf, msgs[0].len, crc);
72
73 addr = i2c_8bit_addr_from_msg(&msgs[1]);
74 crc = crc8(pmbus_crc_table, &addr, 1, crc);
75 crc = crc8(pmbus_crc_table, msgs[1].buf, msgs[1].buf[0] + 1,
76 crc);
77
78 if (crc != msgs[1].buf[msgs[1].buf[0] + 1]) {
79 ret = -EBADMSG;
80 goto cleanup;
81 }
82 }
83
84 memcpy(data_r, &msgs[1].buf[1], msgs[1].buf[0]);
85 ret = msgs[1].buf[0];
86
87 cleanup:
88 i2c_put_dma_safe_msg_buf(msgs[0].buf, &msgs[0], true);
89 i2c_put_dma_safe_msg_buf(msgs[1].buf, &msgs[1], true);
90
91 return ret;
92 }
93
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
On Wed, Jun 24, 2020 at 06:17:35PM +0300, [email protected] wrote:
> From: Alexandru Tachici <[email protected]>
>
> Add a debugfs file to print information in the
> BLACKBOX_INFORMATION register. Contains information
> about the number of stored records, logic index and id
> of the latest record.
How is this different to the nvram method implemented in toe previous patch ?
Why do we need both ?
>
> Signed-off-by: Alexandru Tachici <[email protected]>
> ---
> drivers/hwmon/pmbus/adm1266.c | 56 ++++++++++++++++++++++++++++++++++-
> 1 file changed, 55 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/hwmon/pmbus/adm1266.c b/drivers/hwmon/pmbus/adm1266.c
> index b9e92ab1e39a..ea2dc481094b 100644
> --- a/drivers/hwmon/pmbus/adm1266.c
> +++ b/drivers/hwmon/pmbus/adm1266.c
> @@ -60,6 +60,7 @@ struct adm1266_data {
> const char *gpio_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR];
> struct i2c_client *client;
> struct mutex ioctl_mutex; /* lock ioctl access */
> + struct dentry *debugfs_dir;
> struct nvmem_config nvmem_config;
> struct nvmem_device *nvmem;
> u8 *dev_mem;
> @@ -406,6 +407,28 @@ static const struct proc_ops adm1266_proc_ops = {
> .proc_ioctl = adm1266_ioctl,
> };
>
> +static int adm1266_blackbox_information_read(struct seq_file *s, void *pdata)
> +{
> + struct device *dev = s->private;
> + struct i2c_client *client = to_i2c_client(dev);
> + u8 read_buf[5];
> + unsigned int latest_id;
> + int ret;
> +
> + ret = i2c_smbus_read_block_data(client, ADM1266_BLACKBOX_INFO,
> + read_buf);
> + if (ret < 0)
> + return ret;
> +
> + seq_puts(s, "BLACKBOX_INFORMATION:\n");
> + latest_id = read_buf[0] + (read_buf[1] << 8);
> + seq_printf(s, "Black box ID: %u\n", latest_id);
> + seq_printf(s, "Logic index: %u\n", read_buf[2]);
> + seq_printf(s, "Record count: %u\n", read_buf[3]);
> +
> + return 0;
> +}
> +
> static int adm1266_init_procfs(struct adm1266_data *data)
> {
> struct proc_dir_entry *proc_dir;
> @@ -423,6 +446,29 @@ static int adm1266_init_procfs(struct adm1266_data *data)
> return 0;
> }
>
> +static int adm1266_init_debugfs(struct adm1266_data *data)
> +{
> + struct dentry *entry;
> + struct dentry *root;
> +
> + root = pmbus_get_debugfs_dir(data->client);
> + if (!root)
> + return -ENOENT;
> +
> + data->debugfs_dir = debugfs_create_dir(data->client->name, root);
> + if (!data->debugfs_dir)
> + return -ENOENT;
> +
> + entry = debugfs_create_devm_seqfile(&data->client->dev,
> + "blackbox_information",
> + data->debugfs_dir,
> + adm1266_blackbox_information_read);
> + if (!entry)
> + return -ENOENT;
> +
> + return 0;
> +}
> +
> static int adm1266_nvmem_read_blackbox(struct adm1266_data *data, u8 *buf)
> {
> u8 read_buf[5];
> @@ -571,7 +617,15 @@ static int adm1266_probe(struct i2c_client *client,
> for (i = 0; i < info->pages; i++)
> info->func[i] = funcs;
>
> - return pmbus_do_probe(client, id, info);
> + ret = pmbus_do_probe(client, id, info);
> + if (ret)
> + return ret;
> +
> + ret = adm1266_init_debugfs(data);
> + if (ret)
> + dev_warn(&client->dev, "Failed to register debugfs: %d\n", ret);
debugfs functions are supposed to fail silently.
> +
> + return 0;
> }
>
> static const struct of_device_id adm1266_of_match[] = {
Hi,
I love your patch! Perhaps something to improve:
[auto build test WARNING on hwmon/hwmon-next]
[also build test WARNING on linux/master robh/for-next linus/master v5.8-rc2 next-20200624]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/alexandru-tachici-analog-com/hwmon-pmbus-adm1266-add-support/20200624-232203
base: https://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging.git hwmon-next
config: x86_64-allyesconfig (attached as .config)
compiler: clang version 11.0.0 (https://github.com/llvm/llvm-project 1d4c87335d5236ea1f35937e1014980ba961ae34)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# install x86_64 cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <[email protected]>
All warnings (new ones prefixed by >>):
>> drivers/hwmon/pmbus/adm1266.c:27:5: warning: no previous prototype for function 'pmbus_block_xfer' [-Wmissing-prototypes]
int pmbus_block_xfer(struct i2c_client *client, u8 cmd, u8 w_len,
^
drivers/hwmon/pmbus/adm1266.c:27:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
int pmbus_block_xfer(struct i2c_client *client, u8 cmd, u8 w_len,
^
static
1 warning generated.
vim +/pmbus_block_xfer +27 drivers/hwmon/pmbus/adm1266.c
21
22 /* Different from Block Read as it sends data and waits for the slave to
23 * return a value dependent on that data. The protocol is simply a Write Block
24 * followed by a Read Block without the Read-Block command field and the
25 * Write-Block STOP bit.
26 */
> 27 int pmbus_block_xfer(struct i2c_client *client, u8 cmd, u8 w_len,
28 u8 *data_w, u8 *data_r)
29 {
30 u8 write_buf[ADM1266_PMBUS_BLOCK_MAX + 2];
31 struct i2c_msg msgs[2] = {
32 {
33 .addr = client->addr,
34 .flags = 0,
35 .buf = write_buf,
36 .len = w_len + 2,
37 },
38 {
39 .addr = client->addr,
40 .flags = I2C_M_RD,
41 .len = ADM1266_PMBUS_BLOCK_MAX + 2,
42 }
43 };
44 u8 addr = 0;
45 u8 crc = 0;
46 int ret;
47
48 msgs[0].buf[0] = cmd;
49 msgs[0].buf[1] = w_len;
50 memcpy(&msgs[0].buf[2], data_w, w_len);
51
52 msgs[0].buf = i2c_get_dma_safe_msg_buf(&msgs[0], 1);
53 if (!msgs[0].buf)
54 return -ENOMEM;
55
56 msgs[1].buf = i2c_get_dma_safe_msg_buf(&msgs[1], 1);
57 if (!msgs[1].buf) {
58 i2c_put_dma_safe_msg_buf(msgs[0].buf, &msgs[0], false);
59 return -ENOMEM;
60 }
61
62 ret = i2c_transfer(client->adapter, msgs, 2);
63 if (ret != 2) {
64 ret = -EPROTO;
65 goto cleanup;
66 }
67
68 if (client->flags & I2C_CLIENT_PEC) {
69 addr = i2c_8bit_addr_from_msg(&msgs[0]);
70 crc = crc8(pmbus_crc_table, &addr, 1, crc);
71 crc = crc8(pmbus_crc_table, msgs[0].buf, msgs[0].len, crc);
72
73 addr = i2c_8bit_addr_from_msg(&msgs[1]);
74 crc = crc8(pmbus_crc_table, &addr, 1, crc);
75 crc = crc8(pmbus_crc_table, msgs[1].buf, msgs[1].buf[0] + 1,
76 crc);
77
78 if (crc != msgs[1].buf[msgs[1].buf[0] + 1]) {
79 ret = -EBADMSG;
80 goto cleanup;
81 }
82 }
83
84 memcpy(data_r, &msgs[1].buf[1], msgs[1].buf[0]);
85 ret = msgs[1].buf[0];
86
87 cleanup:
88 i2c_put_dma_safe_msg_buf(msgs[0].buf, &msgs[0], true);
89 i2c_put_dma_safe_msg_buf(msgs[1].buf, &msgs[1], true);
90
91 return ret;
92 }
93
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
Signed-off-by: kernel test robot <[email protected]>
---
adm1266.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/drivers/hwmon/pmbus/adm1266.c b/drivers/hwmon/pmbus/adm1266.c
index 381d89a8569f2..1aa3f0a738151 100644
--- a/drivers/hwmon/pmbus/adm1266.c
+++ b/drivers/hwmon/pmbus/adm1266.c
@@ -24,8 +24,8 @@ DECLARE_CRC8_TABLE(pmbus_crc_table);
* followed by a Read Block without the Read-Block command field and the
* Write-Block STOP bit.
*/
-int pmbus_block_xfer(struct i2c_client *client, u8 cmd, u8 w_len,
- u8 *data_w, u8 *data_r)
+static int pmbus_block_xfer(struct i2c_client *client, u8 cmd, u8 w_len,
+ u8 *data_w, u8 *data_r)
{
u8 write_buf[ADM1266_PMBUS_BLOCK_MAX + 2];
struct i2c_msg msgs[2] = {