| // SPDX-License-Identifier: GPL-2.0-or-later | |
| /* | |
| * Hardware monitoring driver for Analog Devices MAX16545/MAX16550 and | |
| * Volterra VT7505 PMBus controllers. | |
| * | |
| * Copyright 2026 Hewlett Packard Enterprise Development LP | |
| */ | |
| #include <linux/bitfield.h> | |
| #include <linux/i2c.h> | |
| #include <linux/kernel.h> | |
| #include <linux/module.h> | |
| #include <linux/of.h> | |
| #include <linux/pmbus.h> | |
| #include "pmbus.h" | |
| #define VT7505_MFR_CONFIG 0xd0 | |
| #define VT7505_CFG_OCP_S_FILT_MASK GENMASK(15, 14) | |
| #define VT7505_MFR_PEAK_VIN 0xd1 | |
| #define VT7505_MFR_PEAK_IOUT 0xd2 | |
| #define VT7505_MFR_PEAK_PIN 0xd3 | |
| #define VT7505_MFR_PEAK_TEMP 0xd4 | |
| #define VT7505_MFR_CLEAR_PEAKS 0xd5 | |
| #define VT7505_MFR_PEAK_VOUT 0xfd | |
| #define VT7505_RLOAD_DEFAULT 4750 | |
| /* Largest RLOAD for which coeff * rload / 1000 still fits in s32. */ | |
| #define VT7505_RLOAD_MAX 283383959U | |
| struct vt7505_chip_data { | |
| int temp_m; | |
| int temp_b; | |
| bool has_ocp_filter; | |
| }; | |
| static const struct vt7505_chip_data max16545_data = { | |
| .temp_m = 205, | |
| .temp_b = 6545, | |
| }; | |
| static const struct vt7505_chip_data max16550_data = { | |
| .temp_m = 199, | |
| .temp_b = 7046, | |
| .has_ocp_filter = true, | |
| }; | |
| static const struct vt7505_chip_data vt7505_data = { | |
| .temp_m = 205, | |
| .temp_b = 6545, | |
| .has_ocp_filter = true, | |
| }; | |
| static int vt7505_read_word_data(struct i2c_client *client, int page, | |
| int phase, int reg) | |
| { | |
| switch (reg) { | |
| case PMBUS_VIRT_READ_VIN_MAX: | |
| return pmbus_read_word_data(client, page, phase, | |
| VT7505_MFR_PEAK_VIN); | |
| case PMBUS_VIRT_READ_IOUT_MAX: | |
| return pmbus_read_word_data(client, page, phase, | |
| VT7505_MFR_PEAK_IOUT); | |
| case PMBUS_VIRT_READ_PIN_MAX: | |
| return pmbus_read_word_data(client, page, phase, | |
| VT7505_MFR_PEAK_PIN); | |
| case PMBUS_VIRT_READ_TEMP_MAX: | |
| return pmbus_read_word_data(client, page, phase, | |
| VT7505_MFR_PEAK_TEMP); | |
| case PMBUS_VIRT_READ_VOUT_MAX: | |
| return pmbus_read_word_data(client, page, phase, | |
| VT7505_MFR_PEAK_VOUT); | |
| case PMBUS_VIRT_RESET_VIN_HISTORY: | |
| case PMBUS_VIRT_RESET_IOUT_HISTORY: | |
| case PMBUS_VIRT_RESET_PIN_HISTORY: | |
| case PMBUS_VIRT_RESET_TEMP_HISTORY: | |
| case PMBUS_VIRT_RESET_VOUT_HISTORY: | |
| return 0; | |
| default: | |
| return -ENODATA; | |
| } | |
| } | |
| static int vt7505_write_word_data(struct i2c_client *client, int page, | |
| int reg, u16 word) | |
| { | |
| switch (reg) { | |
| /* | |
| * A single reset command clears all peak values. CLEAR_PEAKS is a | |
| * send-byte command; the device NAKs a word or byte-data write to it. | |
| */ | |
| case PMBUS_VIRT_RESET_VIN_HISTORY: | |
| case PMBUS_VIRT_RESET_IOUT_HISTORY: | |
| case PMBUS_VIRT_RESET_PIN_HISTORY: | |
| case PMBUS_VIRT_RESET_TEMP_HISTORY: | |
| case PMBUS_VIRT_RESET_VOUT_HISTORY: | |
| return pmbus_write_byte(client, page, | |
| VT7505_MFR_CLEAR_PEAKS); | |
| default: | |
| return -ENODATA; | |
| } | |
| } | |
| /* | |
| * None of these controllers implement the standard PMBus WRITE_PROTECT | |
| * (0x10) register, so tell the core not to access it. | |
| */ | |
| static struct pmbus_platform_data vt7505_pdata = { | |
| .flags = PMBUS_NO_WRITE_PROTECT, | |
| }; | |
| static int vt7505_set_ocp_filter(struct i2c_client *client) | |
| { | |
| u32 ocp_us; | |
| u8 field; | |
| int ret; | |
| u16 word; | |
| if (of_property_read_u32(client->dev.of_node, "adi,ocp-severe-filter-us", | |
| &ocp_us)) | |
| return 0; | |
| switch (ocp_us) { | |
| case 0: | |
| field = 0; | |
| break; | |
| case 1: | |
| field = 1; | |
| break; | |
| case 2: | |
| field = 2; | |
| break; | |
| case 10: | |
| field = 3; | |
| break; | |
| default: | |
| return dev_err_probe(&client->dev, -EINVAL, | |
| "invalid adi,ocp-severe-filter-us value %u\n", | |
| ocp_us); | |
| } | |
| ret = i2c_smbus_read_word_data(client, VT7505_MFR_CONFIG); | |
| if (ret < 0) | |
| return dev_err_probe(&client->dev, ret, | |
| "failed to read MFR_CONFIG\n"); | |
| word = ret & ~VT7505_CFG_OCP_S_FILT_MASK; | |
| word |= FIELD_PREP(VT7505_CFG_OCP_S_FILT_MASK, field); | |
| ret = i2c_smbus_write_word_data(client, VT7505_MFR_CONFIG, word); | |
| if (ret < 0) | |
| return dev_err_probe(&client->dev, ret, | |
| "failed to write MFR_CONFIG\n"); | |
| return 0; | |
| } | |
| static void vt7505_set_m(int *m, u32 rload) | |
| { | |
| u64 val = (u64)*m * rload; | |
| /* rload is range-checked in probe, so the result fits in int. */ | |
| *m = DIV_ROUND_CLOSEST_ULL(val, 1000); | |
| } | |
| static int vt7505_probe(struct i2c_client *client) | |
| { | |
| struct device *dev = &client->dev; | |
| const struct vt7505_chip_data *chip; | |
| struct pmbus_driver_info *info; | |
| u32 rload; | |
| int ret; | |
| chip = i2c_get_match_data(client); | |
| if (!chip) | |
| return -ENODEV; | |
| info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL); | |
| if (!info) | |
| return -ENOMEM; | |
| dev->platform_data = &vt7505_pdata; | |
| /* | |
| * The m coefficient used in the direct-format current and power | |
| * calculations depends on RLOAD, the external current-report resistor | |
| * connected between the ILOAD pin and ground. Use the default value if | |
| * none is specified. | |
| */ | |
| if (of_property_read_u32(dev->of_node, "adi,rload-ohms", &rload)) | |
| rload = VT7505_RLOAD_DEFAULT; | |
| if (!rload || rload > VT7505_RLOAD_MAX) | |
| return dev_err_probe(dev, -EINVAL, | |
| "adi,rload-ohms must be 1-%u\n", | |
| VT7505_RLOAD_MAX); | |
| info->pages = 1; | |
| info->read_word_data = vt7505_read_word_data; | |
| info->write_word_data = vt7505_write_word_data; | |
| info->format[PSC_VOLTAGE_IN] = direct; | |
| info->format[PSC_VOLTAGE_OUT] = direct; | |
| info->format[PSC_CURRENT_IN] = direct; | |
| info->format[PSC_CURRENT_OUT] = direct; | |
| info->format[PSC_POWER] = direct; | |
| info->format[PSC_TEMPERATURE] = direct; | |
| /* | |
| * Direct data format coefficients from the device datasheet ("PMBus | |
| * Equation Parameters"). The current and power m coefficients scale | |
| * with RLOAD; vt7505_set_m() applies the 1/1000 factor below, giving | |
| * m = 3.824 * RLOAD for current and 0.895 * RLOAD for power. The | |
| * temperature coefficients are chip specific (see the chip data). | |
| */ | |
| info->m[PSC_VOLTAGE_IN] = 7578; | |
| info->R[PSC_VOLTAGE_IN] = -2; | |
| info->m[PSC_VOLTAGE_OUT] = 7578; | |
| info->R[PSC_VOLTAGE_OUT] = -2; | |
| info->m[PSC_CURRENT_IN] = 3824; | |
| info->b[PSC_CURRENT_IN] = -4300; | |
| info->R[PSC_CURRENT_IN] = -3; | |
| info->m[PSC_CURRENT_OUT] = 3824; | |
| info->b[PSC_CURRENT_OUT] = -4300; | |
| info->R[PSC_CURRENT_OUT] = -3; | |
| info->m[PSC_POWER] = 895; | |
| info->b[PSC_POWER] = -9100; | |
| info->R[PSC_POWER] = -2; | |
| vt7505_set_m(&info->m[PSC_CURRENT_IN], rload); | |
| vt7505_set_m(&info->m[PSC_CURRENT_OUT], rload); | |
| vt7505_set_m(&info->m[PSC_POWER], rload); | |
| info->m[PSC_TEMPERATURE] = chip->temp_m; | |
| info->b[PSC_TEMPERATURE] = chip->temp_b; | |
| info->R[PSC_TEMPERATURE] = -2; | |
| info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT | | |
| PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | | |
| PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | | |
| PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | | |
| PMBUS_HAVE_IIN | PMBUS_HAVE_PIN; | |
| /* | |
| * The severe OCP deglitch filter is programmable on the MAX16550 and | |
| * the VT7505, but fixed on the MAX16545. | |
| */ | |
| if (chip->has_ocp_filter) { | |
| ret = vt7505_set_ocp_filter(client); | |
| if (ret) | |
| return ret; | |
| } | |
| return pmbus_do_probe(client, info); | |
| } | |
| static const struct i2c_device_id vt7505_id[] = { | |
| { .name = "max16545", .driver_data = (kernel_ulong_t)&max16545_data }, | |
| { .name = "max16550", .driver_data = (kernel_ulong_t)&max16550_data }, | |
| { .name = "vt7505", .driver_data = (kernel_ulong_t)&vt7505_data }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(i2c, vt7505_id); | |
| static const struct of_device_id vt7505_of_match[] = { | |
| { .compatible = "adi,max16545", .data = &max16545_data }, | |
| { .compatible = "adi,max16550", .data = &max16550_data }, | |
| { .compatible = "adi,vt7505", .data = &vt7505_data }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(of, vt7505_of_match); | |
| static struct i2c_driver vt7505_driver = { | |
| .driver = { | |
| .name = "vt7505", | |
| .of_match_table = vt7505_of_match, | |
| }, | |
| .probe = vt7505_probe, | |
| .id_table = vt7505_id, | |
| }; | |
| module_i2c_driver(vt7505_driver); | |
| MODULE_AUTHOR("Georgi Vlaev <gvlaev@juniper.net>"); | |
| MODULE_DESCRIPTION("PMBus driver for Analog Devices MAX16545/MAX16550 and Volterra VT7505"); | |
| MODULE_LICENSE("GPL"); | |
| MODULE_IMPORT_NS("PMBUS"); |