| // SPDX-License-Identifier: GPL-2.0-or-later | |
| /* | |
| * Hardware monitoring driver for MPS2856/2857 | |
| * Monolithic Power Systems VR Controllers | |
| * | |
| * Copyright (C) 2023 Quanta Computer lnc. | |
| */ | |
| #include <linux/err.h> | |
| #include <linux/i2c.h> | |
| #include <linux/init.h> | |
| #include <linux/kernel.h> | |
| #include <linux/module.h> | |
| #include <linux/pmbus.h> | |
| #include "pmbus.h" | |
| /* Vendor specific registers. */ | |
| #define MP2856_MFR_VR_MULTI_CONFIG_R1 0x0d | |
| #define MP2856_MFR_VR_MULTI_CONFIG_R2 0x1d | |
| #define MP2856_MUL1_BOOT_SR_R2 0x10 | |
| #define MP2856_VR_ACTIVE BIT(15) | |
| #define MP2856_MFR_VR_CONFIG2 0x5e | |
| #define MP2856_VOUT_MODE BIT(11) | |
| #define MP2856_MFR_VR_CONFIG1 0x68 | |
| #define MP2856_DRMOS_KCS GENMASK(13, 12) | |
| #define MP2856_MFR_READ_CS1_2_R1 0x82 | |
| #define MP2856_MFR_READ_CS3_4_R1 0x83 | |
| #define MP2856_MFR_READ_CS5_6_R1 0x84 | |
| #define MP2856_MFR_READ_CS7_8_R1 0x85 | |
| #define MP2856_MFR_READ_CS9_10_R1 0x86 | |
| #define MP2856_MFR_READ_CS11_12_R1 0x87 | |
| #define MP2856_MFR_READ_CS1_2_R2 0x85 | |
| #define MP2856_MFR_READ_CS3_4_R2 0x86 | |
| #define MP2856_MFR_READ_CS5_6_R2 0x87 | |
| #define MP2856_MAX_PHASE_RAIL1 8 | |
| #define MP2856_MAX_PHASE_RAIL2 4 | |
| #define MP2857_MAX_PHASE_RAIL1 12 | |
| #define MP2857_MAX_PHASE_RAIL2 4 | |
| #define MP2856_PAGE_NUM 2 | |
| enum chips { mp2856, mp2857 }; | |
| static const int mp2856_max_phases[][MP2856_PAGE_NUM] = { | |
| [mp2856] = { MP2856_MAX_PHASE_RAIL1, MP2856_MAX_PHASE_RAIL2 }, | |
| [mp2857] = { MP2857_MAX_PHASE_RAIL1, MP2857_MAX_PHASE_RAIL2 }, | |
| }; | |
| static const struct i2c_device_id mp2856_id[] = { | |
| { .name = "mp2856", .driver_data = mp2856 }, | |
| { .name = "mp2857", .driver_data = mp2857 }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(i2c, mp2856_id); | |
| struct mp2856_data { | |
| struct pmbus_driver_info info; | |
| int vout_format[MP2856_PAGE_NUM]; | |
| int curr_sense_gain[MP2856_PAGE_NUM]; | |
| int max_phases[MP2856_PAGE_NUM]; | |
| }; | |
| #define to_mp2856_data(x) container_of(x, struct mp2856_data, info) | |
| #define MAX_LIN_MANTISSA (1023 * 1000) | |
| #define MIN_LIN_MANTISSA (511 * 1000) | |
| static u16 val2linear11(s64 val) | |
| { | |
| s16 exponent = 0, mantissa; | |
| bool negative = false; | |
| if (val == 0) | |
| return 0; | |
| if (val < 0) { | |
| negative = true; | |
| val = -val; | |
| } | |
| /* Reduce large mantissa until it fits into 10 bit */ | |
| while (val >= MAX_LIN_MANTISSA && exponent < 15) { | |
| exponent++; | |
| val >>= 1; | |
| } | |
| /* Increase small mantissa to improve precision */ | |
| while (val < MIN_LIN_MANTISSA && exponent > -15) { | |
| exponent--; | |
| val <<= 1; | |
| } | |
| /* Convert mantissa from milli-units to units */ | |
| mantissa = clamp_val(DIV_ROUND_CLOSEST_ULL(val, 1000), 0, 0x3ff); | |
| /* restore sign */ | |
| if (negative) | |
| mantissa = -mantissa; | |
| /* Convert to 5 bit exponent, 11 bit mantissa */ | |
| return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800); | |
| } | |
| static int | |
| mp2856_read_word_helper(struct i2c_client *client, int page, int phase, u8 reg, | |
| u16 mask) | |
| { | |
| int ret = pmbus_read_word_data(client, page, phase, reg); | |
| return (ret > 0) ? ret & mask : ret; | |
| } | |
| static int | |
| mp2856_read_vout(struct i2c_client *client, struct mp2856_data *data, int page, | |
| int phase, u8 reg) | |
| { | |
| int ret; | |
| ret = mp2856_read_word_helper(client, page, phase, reg, | |
| GENMASK(9, 0)); | |
| if (ret < 0) | |
| return ret; | |
| /* convert vout result to direct format */ | |
| ret = (data->vout_format[page] == vid) ? | |
| ((ret + 49) * 5) : ((ret * 1000) >> 8); | |
| return ret; | |
| } | |
| static int | |
| mp2856_read_phase(struct i2c_client *client, struct mp2856_data *data, | |
| int page, int phase, u8 reg) | |
| { | |
| int ret; | |
| int val; | |
| ret = pmbus_read_word_data(client, page, phase, reg); | |
| if (ret < 0) | |
| return ret; | |
| if (!((phase + 1) % MP2856_PAGE_NUM)) | |
| ret >>= 8; | |
| ret &= 0xff; | |
| /* | |
| * Output value is calculated as: (READ_CSx * 12.5mV - 1.23V) / (Kcs * Rcs) | |
| */ | |
| val = (ret * 125) - 12300; | |
| return val2linear11(val); | |
| } | |
| static int | |
| mp2856_read_phases(struct i2c_client *client, struct mp2856_data *data, | |
| int page, int phase) | |
| { | |
| int ret; | |
| if (page == 0) { | |
| switch (phase) { | |
| case 0 ... 1: | |
| ret = mp2856_read_phase(client, data, page, phase, | |
| MP2856_MFR_READ_CS1_2_R1); | |
| break; | |
| case 2 ... 3: | |
| ret = mp2856_read_phase(client, data, page, phase, | |
| MP2856_MFR_READ_CS3_4_R1); | |
| break; | |
| case 4 ... 5: | |
| ret = mp2856_read_phase(client, data, page, phase, | |
| MP2856_MFR_READ_CS5_6_R1); | |
| break; | |
| case 6 ... 7: | |
| ret = mp2856_read_phase(client, data, page, phase, | |
| MP2856_MFR_READ_CS7_8_R1); | |
| break; | |
| default: | |
| return -ENODATA; | |
| } | |
| } else { | |
| switch (phase) { | |
| case 0 ... 1: | |
| ret = mp2856_read_phase(client, data, page, phase, | |
| MP2856_MFR_READ_CS1_2_R2); | |
| break; | |
| case 2 ... 3: | |
| ret = mp2856_read_phase(client, data, page, phase, | |
| MP2856_MFR_READ_CS1_2_R2); | |
| break; | |
| default: | |
| return -ENODATA; | |
| } | |
| } | |
| return ret; | |
| } | |
| static int | |
| mp2856_read_word_data(struct i2c_client *client, int page, | |
| int phase, int reg) | |
| { | |
| const struct pmbus_driver_info *info = pmbus_get_driver_info(client); | |
| struct mp2856_data *data = to_mp2856_data(info); | |
| int ret; | |
| switch (reg) { | |
| case PMBUS_READ_VOUT: | |
| ret = mp2856_read_vout(client, data, page, phase, reg); | |
| break; | |
| case PMBUS_READ_IOUT: | |
| if (phase != 0xff) | |
| ret = mp2856_read_phases(client, data, page, phase); | |
| else | |
| ret = pmbus_read_word_data(client, page, phase, reg); | |
| break; | |
| default: | |
| return -ENODATA; | |
| } | |
| return ret; | |
| } | |
| static int | |
| mp2856_read_byte_data(struct i2c_client *client, int page, int reg) | |
| { | |
| switch (reg) { | |
| case PMBUS_VOUT_MODE: | |
| /* Enforce VOUT direct format. */ | |
| return PB_VOUT_MODE_DIRECT; | |
| default: | |
| return -ENODATA; | |
| } | |
| } | |
| static int | |
| mp2856_identify_multiphase(struct i2c_client *client, u8 reg, u8 max_phase, | |
| u16 mask) | |
| { | |
| int ret; | |
| ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2); | |
| if (ret < 0) | |
| return ret; | |
| ret = i2c_smbus_read_word_data(client, reg); | |
| if (ret < 0) | |
| return ret; | |
| ret &= mask; | |
| return (ret >= max_phase) ? max_phase : ret; | |
| } | |
| static int | |
| mp2856_identify_multiphase_rail1(struct i2c_client *client, | |
| struct mp2856_data *data) | |
| { | |
| int ret, i; | |
| ret = mp2856_identify_multiphase(client, MP2856_MFR_VR_MULTI_CONFIG_R1, | |
| MP2856_MAX_PHASE_RAIL1, GENMASK(3, 0)); | |
| if (ret < 0) | |
| return ret; | |
| data->info.phases[0] = (ret > data->max_phases[0]) ? | |
| data->max_phases[0] : ret; | |
| for (i = 0 ; i < data->info.phases[0]; i++) | |
| data->info.pfunc[i] |= PMBUS_HAVE_IOUT; | |
| return 0; | |
| } | |
| static int | |
| mp2856_identify_multiphase_rail2(struct i2c_client *client, | |
| struct mp2856_data *data) | |
| { | |
| int ret, i; | |
| ret = mp2856_identify_multiphase(client, MP2856_MFR_VR_MULTI_CONFIG_R2, | |
| MP2856_MAX_PHASE_RAIL2, GENMASK(2, 0)); | |
| if (ret < 0) | |
| return ret; | |
| data->info.phases[1] = (ret > data->max_phases[1]) ? | |
| data->max_phases[1] : ret; | |
| for (i = 0 ; i < data->info.phases[0]; i++) | |
| data->info.pfunc[i] |= PMBUS_HAVE_IOUT; | |
| return 0; | |
| } | |
| static int | |
| mp2856_current_sense_gain_get(struct i2c_client *client, | |
| struct mp2856_data *data) | |
| { | |
| int i, ret; | |
| /* | |
| * Obtain DrMOS current sense gain of power stage from the register | |
| * MP2856_MFR_VR_CONFIG1, bits 13-12. The value is selected as below: | |
| * 00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A. Other | |
| * values are invalid. | |
| */ | |
| for (i = 0 ; i < data->info.pages; i++) { | |
| ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i); | |
| if (ret < 0) | |
| return ret; | |
| ret = i2c_smbus_read_word_data(client, | |
| MP2856_MFR_VR_CONFIG1); | |
| if (ret < 0) | |
| return ret; | |
| switch ((ret & MP2856_DRMOS_KCS) >> 12) { | |
| case 0: | |
| data->curr_sense_gain[i] = 50; | |
| break; | |
| case 1: | |
| data->curr_sense_gain[i] = 85; | |
| break; | |
| case 2: | |
| data->curr_sense_gain[i] = 97; | |
| break; | |
| default: | |
| data->curr_sense_gain[i] = 100; | |
| break; | |
| } | |
| } | |
| return 0; | |
| } | |
| static int | |
| mp2856_identify_vout_format(struct i2c_client *client, | |
| struct mp2856_data *data) | |
| { | |
| int i, ret; | |
| for (i = 0; i < data->info.pages; i++) { | |
| ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i); | |
| if (ret < 0) | |
| return ret; | |
| ret = i2c_smbus_read_word_data(client, MP2856_MFR_VR_CONFIG2); | |
| if (ret < 0) | |
| return ret; | |
| data->vout_format[i] = (ret & MP2856_VOUT_MODE) ? linear : vid; | |
| } | |
| return 0; | |
| } | |
| static bool | |
| mp2856_is_rail2_active(struct i2c_client *client) | |
| { | |
| int ret; | |
| ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2); | |
| if (ret < 0) | |
| return true; | |
| ret = i2c_smbus_read_word_data(client, MP2856_MUL1_BOOT_SR_R2); | |
| if (ret < 0) | |
| return true; | |
| return (ret & MP2856_VR_ACTIVE) ? true : false; | |
| } | |
| static struct pmbus_driver_info mp2856_info = { | |
| .pages = MP2856_PAGE_NUM, | |
| .format[PSC_VOLTAGE_IN] = linear, | |
| .format[PSC_VOLTAGE_OUT] = direct, | |
| .format[PSC_TEMPERATURE] = linear, | |
| .format[PSC_CURRENT_IN] = linear, | |
| .format[PSC_CURRENT_OUT] = linear, | |
| .format[PSC_POWER] = linear, | |
| .m[PSC_VOLTAGE_OUT] = 1, | |
| .R[PSC_VOLTAGE_OUT] = 3, | |
| .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | | |
| PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | | |
| PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_HAVE_POUT | | |
| PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT, | |
| .func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_IOUT | | |
| PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP, | |
| .read_byte_data = mp2856_read_byte_data, | |
| .read_word_data = mp2856_read_word_data, | |
| }; | |
| static int mp2856_probe(struct i2c_client *client) | |
| { | |
| struct pmbus_driver_info *info; | |
| struct mp2856_data *data; | |
| enum chips chip_id; | |
| int ret; | |
| data = devm_kzalloc(&client->dev, sizeof(struct mp2856_data), | |
| GFP_KERNEL); | |
| if (!data) | |
| return -ENOMEM; | |
| chip_id = (kernel_ulong_t)i2c_get_match_data(client); | |
| memcpy(data->max_phases, mp2856_max_phases[chip_id], | |
| sizeof(data->max_phases)); | |
| memcpy(&data->info, &mp2856_info, sizeof(*info)); | |
| info = &data->info; | |
| /* Identify multiphase configuration. */ | |
| ret = mp2856_identify_multiphase_rail1(client, data); | |
| if (ret < 0) | |
| return ret; | |
| if (mp2856_is_rail2_active(client)) { | |
| ret = mp2856_identify_multiphase_rail2(client, data); | |
| if (ret < 0) | |
| return ret; | |
| } else { | |
| /* rail2 is not active */ | |
| info->pages = 1; | |
| } | |
| /* Obtain current sense gain of power stage. */ | |
| ret = mp2856_current_sense_gain_get(client, data); | |
| if (ret) | |
| return ret; | |
| /* Identify vout format. */ | |
| ret = mp2856_identify_vout_format(client, data); | |
| if (ret) | |
| return ret; | |
| /* set the device to page 0 */ | |
| i2c_smbus_write_byte_data(client, PMBUS_PAGE, 0); | |
| return pmbus_do_probe(client, info); | |
| } | |
| static const struct of_device_id __maybe_unused mp2856_of_match[] = { | |
| {.compatible = "mps,mp2856", .data = (void *)mp2856}, | |
| {.compatible = "mps,mp2857", .data = (void *)mp2857}, | |
| {} | |
| }; | |
| MODULE_DEVICE_TABLE(of, mp2856_of_match); | |
| static struct i2c_driver mp2856_driver = { | |
| .driver = { | |
| .name = "mp2856", | |
| .of_match_table = mp2856_of_match, | |
| }, | |
| .probe = mp2856_probe, | |
| .id_table = mp2856_id, | |
| }; | |
| module_i2c_driver(mp2856_driver); | |
| MODULE_AUTHOR("Peter Yin <peter.yin@quantatw.com>"); | |
| MODULE_DESCRIPTION("PMBus driver for MPS MP2856/MP2857 device"); | |
| MODULE_LICENSE("GPL"); | |
| MODULE_IMPORT_NS("PMBUS"); |