hwmon/pmbus/max16601.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Hardware monitoring driver for Maxim MAX16508, MAX16601 and MAX16602.
0004  *
0005  * Implementation notes:
0006  *
0007  * This chip series supports two rails, VCORE and VSA. Telemetry information
0008  * for the two rails is reported in two subsequent I2C addresses. The driver
0009  * instantiates a dummy I2C client at the second I2C address to report
0010  * information for the VSA rail in a single instance of the driver.
0011  * Telemetry for the VSA rail is reported to the PMBus core in PMBus page 2.
0012  *
0013  * The chip reports input current using two separate methods. The input current
0014  * reported with the standard READ_IIN command is derived from the output
0015  * current. The first method is reported to the PMBus core with PMBus page 0,
0016  * the second method is reported with PMBus page 1.
0017  *
0018  * The chip supports reading per-phase temperatures and per-phase input/output
0019  * currents for VCORE. Telemetry is reported in vendor specific registers.
0020  * The driver translates the vendor specific register values to PMBus standard
0021  * register values and reports per-phase information in PMBus page 0.
0022  *
0023  * Copyright 2019, 2020 Google LLC.
0024  */
0025
0026 #include <linux/bits.h>
0027 #include <linux/i2c.h>
0028 #include <linux/init.h>
0029 #include <linux/kernel.h>
0030 #include <linux/module.h>
0031
0032 #include "pmbus.h"
0033
0034 enum chips { max16508, max16601, max16602 };
0035
0036 #define REG_DEFAULT_NUM_POP 0xc4
0037 #define REG_SETPT_DVID      0xd1
0038 #define  DAC_10MV_MODE      BIT(4)
0039 #define REG_IOUT_AVG_PK     0xee
0040 #define REG_IIN_SENSOR      0xf1
0041 #define REG_TOTAL_INPUT_POWER   0xf2
0042 #define REG_PHASE_ID        0xf3
0043 #define  CORE_RAIL_INDICATOR    BIT(7)
0044 #define REG_PHASE_REPORTING 0xf4
0045
0046 #define MAX16601_NUM_PHASES 8
0047
0048 struct max16601_data {
0049     enum chips id;
0050     struct pmbus_driver_info info;
0051     struct i2c_client *vsa;
0052     int iout_avg_pkg;
0053 };
0054
0055 #define to_max16601_data(x) container_of(x, struct max16601_data, info)
0056
0057 static int max16601_read_byte(struct i2c_client *client, int page, int reg)
0058 {
0059     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0060     struct max16601_data *data = to_max16601_data(info);
0061
0062     if (page > 0) {
0063         if (page == 2)  /* VSA */
0064             return i2c_smbus_read_byte_data(data->vsa, reg);
0065         return -EOPNOTSUPP;
0066     }
0067     return -ENODATA;
0068 }
0069
0070 static int max16601_read_word(struct i2c_client *client, int page, int phase,
0071                   int reg)
0072 {
0073     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0074     struct max16601_data *data = to_max16601_data(info);
0075     u8 buf[I2C_SMBUS_BLOCK_MAX + 1];
0076     int ret;
0077
0078     switch (page) {
0079     case 0:     /* VCORE */
0080         if (phase == 0xff)
0081             return -ENODATA;
0082         switch (reg) {
0083         case PMBUS_READ_IIN:
0084         case PMBUS_READ_IOUT:
0085         case PMBUS_READ_TEMPERATURE_1:
0086             ret = i2c_smbus_write_byte_data(client, REG_PHASE_ID,
0087                             phase);
0088             if (ret)
0089                 return ret;
0090             ret = i2c_smbus_read_block_data(client,
0091                             REG_PHASE_REPORTING,
0092                             buf);
0093             if (ret < 0)
0094                 return ret;
0095             if (ret < 6)
0096                 return -EIO;
0097             switch (reg) {
0098             case PMBUS_READ_TEMPERATURE_1:
0099                 return buf[1] << 8 | buf[0];
0100             case PMBUS_READ_IOUT:
0101                 return buf[3] << 8 | buf[2];
0102             case PMBUS_READ_IIN:
0103                 return buf[5] << 8 | buf[4];
0104             default:
0105                 break;
0106             }
0107         }
0108         return -EOPNOTSUPP;
0109     case 1:     /* VCORE, read IIN/PIN from sensor element */
0110         switch (reg) {
0111         case PMBUS_READ_IIN:
0112             return i2c_smbus_read_word_data(client, REG_IIN_SENSOR);
0113         case PMBUS_READ_PIN:
0114             return i2c_smbus_read_word_data(client,
0115                             REG_TOTAL_INPUT_POWER);
0116         default:
0117             break;
0118         }
0119         return -EOPNOTSUPP;
0120     case 2:     /* VSA */
0121         switch (reg) {
0122         case PMBUS_VIRT_READ_IOUT_MAX:
0123             ret = i2c_smbus_read_word_data(data->vsa,
0124                                REG_IOUT_AVG_PK);
0125             if (ret < 0)
0126                 return ret;
0127             if (sign_extend32(ret, 10) >
0128                 sign_extend32(data->iout_avg_pkg, 10))
0129                 data->iout_avg_pkg = ret;
0130             return data->iout_avg_pkg;
0131         case PMBUS_VIRT_RESET_IOUT_HISTORY:
0132             return 0;
0133         case PMBUS_IOUT_OC_FAULT_LIMIT:
0134         case PMBUS_IOUT_OC_WARN_LIMIT:
0135         case PMBUS_OT_FAULT_LIMIT:
0136         case PMBUS_OT_WARN_LIMIT:
0137         case PMBUS_READ_IIN:
0138         case PMBUS_READ_IOUT:
0139         case PMBUS_READ_TEMPERATURE_1:
0140         case PMBUS_STATUS_WORD:
0141             return i2c_smbus_read_word_data(data->vsa, reg);
0142         default:
0143             return -EOPNOTSUPP;
0144         }
0145     default:
0146         return -EOPNOTSUPP;
0147     }
0148 }
0149
0150 static int max16601_write_byte(struct i2c_client *client, int page, u8 reg)
0151 {
0152     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0153     struct max16601_data *data = to_max16601_data(info);
0154
0155     if (page == 2) {
0156         if (reg == PMBUS_CLEAR_FAULTS)
0157             return i2c_smbus_write_byte(data->vsa, reg);
0158         return -EOPNOTSUPP;
0159     }
0160     return -ENODATA;
0161 }
0162
0163 static int max16601_write_word(struct i2c_client *client, int page, int reg,
0164                    u16 value)
0165 {
0166     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0167     struct max16601_data *data = to_max16601_data(info);
0168
0169     switch (page) {
0170     case 0:     /* VCORE */
0171         return -ENODATA;
0172     case 1:     /* VCORE IIN/PIN from sensor element */
0173     default:
0174         return -EOPNOTSUPP;
0175     case 2:     /* VSA */
0176         switch (reg) {
0177         case PMBUS_VIRT_RESET_IOUT_HISTORY:
0178             data->iout_avg_pkg = 0xfc00;
0179             return 0;
0180         case PMBUS_IOUT_OC_FAULT_LIMIT:
0181         case PMBUS_IOUT_OC_WARN_LIMIT:
0182         case PMBUS_OT_FAULT_LIMIT:
0183         case PMBUS_OT_WARN_LIMIT:
0184             return i2c_smbus_write_word_data(data->vsa, reg, value);
0185         default:
0186             return -EOPNOTSUPP;
0187         }
0188     }
0189 }
0190
0191 static int max16601_identify(struct i2c_client *client,
0192                  struct pmbus_driver_info *info)
0193 {
0194     struct max16601_data *data = to_max16601_data(info);
0195     int reg;
0196
0197     reg = i2c_smbus_read_byte_data(client, REG_SETPT_DVID);
0198     if (reg < 0)
0199         return reg;
0200     if (reg & DAC_10MV_MODE)
0201         info->vrm_version[0] = vr13;
0202     else
0203         info->vrm_version[0] = vr12;
0204
0205     if (data->id != max16601 && data->id != max16602)
0206         return 0;
0207
0208     reg = i2c_smbus_read_byte_data(client, REG_DEFAULT_NUM_POP);
0209     if (reg < 0)
0210         return reg;
0211
0212     /*
0213      * If REG_DEFAULT_NUM_POP returns 0, we don't know how many phases
0214      * are populated. Stick with the default in that case.
0215      */
0216     reg &= 0x0f;
0217     if (reg && reg <= MAX16601_NUM_PHASES)
0218         info->phases[0] = reg;
0219
0220     return 0;
0221 }
0222
0223 static struct pmbus_driver_info max16601_info = {
0224     .pages = 3,
0225     .format[PSC_VOLTAGE_IN] = linear,
0226     .format[PSC_VOLTAGE_OUT] = vid,
0227     .format[PSC_CURRENT_IN] = linear,
0228     .format[PSC_CURRENT_OUT] = linear,
0229     .format[PSC_TEMPERATURE] = linear,
0230     .format[PSC_POWER] = linear,
0231     .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN | PMBUS_HAVE_PIN |
0232         PMBUS_HAVE_STATUS_INPUT |
0233         PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
0234         PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
0235         PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP |
0236         PMBUS_HAVE_POUT | PMBUS_PAGE_VIRTUAL | PMBUS_PHASE_VIRTUAL,
0237     .func[1] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN | PMBUS_PAGE_VIRTUAL,
0238     .func[2] = PMBUS_HAVE_IIN | PMBUS_HAVE_STATUS_INPUT |
0239         PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
0240         PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_PAGE_VIRTUAL,
0241     .phases[0] = MAX16601_NUM_PHASES,
0242     .pfunc[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
0243     .pfunc[1] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
0244     .pfunc[2] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
0245     .pfunc[3] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
0246     .pfunc[4] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
0247     .pfunc[5] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
0248     .pfunc[6] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
0249     .pfunc[7] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
0250     .identify = max16601_identify,
0251     .read_byte_data = max16601_read_byte,
0252     .read_word_data = max16601_read_word,
0253     .write_byte = max16601_write_byte,
0254     .write_word_data = max16601_write_word,
0255 };
0256
0257 static void max16601_remove(void *_data)
0258 {
0259     struct max16601_data *data = _data;
0260
0261     i2c_unregister_device(data->vsa);
0262 }
0263
0264 static const struct i2c_device_id max16601_id[] = {
0265     {"max16508", max16508},
0266     {"max16601", max16601},
0267     {"max16602", max16602},
0268     {}
0269 };
0270 MODULE_DEVICE_TABLE(i2c, max16601_id);
0271
0272 static int max16601_get_id(struct i2c_client *client)
0273 {
0274     struct device *dev = &client->dev;
0275     u8 buf[I2C_SMBUS_BLOCK_MAX + 1];
0276     enum chips id;
0277     int ret;
0278
0279     ret = i2c_smbus_read_block_data(client, PMBUS_IC_DEVICE_ID, buf);
0280     if (ret < 0 || ret < 11)
0281         return -ENODEV;
0282
0283     /*
0284      * PMBUS_IC_DEVICE_ID is expected to return "MAX16601y.xx" or
0285      * MAX16602y.xx or "MAX16500y.xx".cdxxcccccccccc
0286      */
0287     if (!strncmp(buf, "MAX16500", 8)) {
0288         id = max16508;
0289     } else if (!strncmp(buf, "MAX16601", 8)) {
0290         id = max16601;
0291     } else if (!strncmp(buf, "MAX16602", 8)) {
0292         id = max16602;
0293     } else {
0294         buf[ret] = '\0';
0295         dev_err(dev, "Unsupported chip '%s'\n", buf);
0296         return -ENODEV;
0297     }
0298     return id;
0299 }
0300
0301 static int max16601_probe(struct i2c_client *client)
0302 {
0303     struct device *dev = &client->dev;
0304     const struct i2c_device_id *id;
0305     struct max16601_data *data;
0306     int ret, chip_id;
0307
0308     if (!i2c_check_functionality(client->adapter,
0309                      I2C_FUNC_SMBUS_READ_BYTE_DATA |
0310                      I2C_FUNC_SMBUS_READ_BLOCK_DATA))
0311         return -ENODEV;
0312
0313     chip_id = max16601_get_id(client);
0314     if (chip_id < 0)
0315         return chip_id;
0316
0317     id = i2c_match_id(max16601_id, client);
0318     if (chip_id != id->driver_data)
0319         dev_warn(&client->dev,
0320              "Device mismatch: Configured %s (%d), detected %d\n",
0321              id->name, (int) id->driver_data, chip_id);
0322
0323     ret = i2c_smbus_read_byte_data(client, REG_PHASE_ID);
0324     if (ret < 0)
0325         return ret;
0326     if (!(ret & CORE_RAIL_INDICATOR)) {
0327         dev_err(dev,
0328             "Driver must be instantiated on CORE rail I2C address\n");
0329         return -ENODEV;
0330     }
0331
0332     data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
0333     if (!data)
0334         return -ENOMEM;
0335
0336     data->id = chip_id;
0337     data->iout_avg_pkg = 0xfc00;
0338     data->vsa = i2c_new_dummy_device(client->adapter, client->addr + 1);
0339     if (IS_ERR(data->vsa)) {
0340         dev_err(dev, "Failed to register VSA client\n");
0341         return PTR_ERR(data->vsa);
0342     }
0343     ret = devm_add_action_or_reset(dev, max16601_remove, data);
0344     if (ret)
0345         return ret;
0346
0347     data->info = max16601_info;
0348
0349     return pmbus_do_probe(client, &data->info);
0350 }
0351
0352 static struct i2c_driver max16601_driver = {
0353     .driver = {
0354            .name = "max16601",
0355            },
0356     .probe_new = max16601_probe,
0357     .id_table = max16601_id,
0358 };
0359
0360 module_i2c_driver(max16601_driver);
0361
0362 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
0363 MODULE_DESCRIPTION("PMBus driver for Maxim MAX16601");
0364 MODULE_LICENSE("GPL v2");
0365 MODULE_IMPORT_NS(PMBUS);