drivers/hwmon/pmbus/max16601.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Hardware monitoring driver for Maxim MAX16508, MAX16600, MAX16601,
   4  * and MAX16602.
   5  *
   6  * Implementation notes:
   7  *
   8  * This chip series supports two rails, VCORE and VSA. Telemetry information
   9  * for the two rails is reported in two subsequent I2C addresses. The driver
  10  * instantiates a dummy I2C client at the second I2C address to report
  11  * information for the VSA rail in a single instance of the driver.
  12  * Telemetry for the VSA rail is reported to the PMBus core in PMBus page 2.
  13  *
  14  * The chip reports input current using two separate methods. The input current
  15  * reported with the standard READ_IIN command is derived from the output
  16  * current. The first method is reported to the PMBus core with PMBus page 0,
  17  * the second method is reported with PMBus page 1.
  18  *
  19  * The chip supports reading per-phase temperatures and per-phase input/output
  20  * currents for VCORE. Telemetry is reported in vendor specific registers.
  21  * The driver translates the vendor specific register values to PMBus standard
  22  * register values and reports per-phase information in PMBus page 0.
  23  *
  24  * Copyright 2019, 2020 Google LLC.
  25  */
  26
  27 #include <linux/bits.h>
  28 #include <linux/i2c.h>
  29 #include <linux/init.h>
  30 #include <linux/kernel.h>
  31 #include <linux/module.h>
  32
  33 #include "pmbus.h"
  34
  35 enum chips { max16508, max16600, max16601, max16602 };
  36
  37 #define REG_DEFAULT_NUM_POP     0xc4
  38 #define REG_SETPT_DVID          0xd1
  39 #define  DAC_10MV_MODE          BIT(4)
  40 #define REG_IOUT_AVG_PK         0xee
  41 #define REG_IIN_SENSOR          0xf1
  42 #define REG_TOTAL_INPUT_POWER   0xf2
  43 #define REG_PHASE_ID            0xf3
  44 #define  CORE_RAIL_INDICATOR    BIT(7)
  45 #define REG_PHASE_REPORTING     0xf4
  46
  47 #define MAX16601_NUM_PHASES     8
  48
  49 struct max16601_data {
  50         enum chips id;
  51         struct pmbus_driver_info info;
  52         struct i2c_client *vsa;
  53         int iout_avg_pkg;
  54 };
  55
  56 #define to_max16601_data(x) container_of(x, struct max16601_data, info)
  57
  58 static int max16601_read_byte(struct i2c_client *client, int page, int reg)
  59 {
  60         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
  61         struct max16601_data *data = to_max16601_data(info);
  62
  63         if (page > 0) {
  64                 if (page == 2)  /* VSA */
  65                         return i2c_smbus_read_byte_data(data->vsa, reg);
  66                 return -EOPNOTSUPP;
  67         }
  68         return -ENODATA;
  69 }
  70
  71 static int max16601_read_word(struct i2c_client *client, int page, int phase,
  72                               int reg)
  73 {
  74         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
  75         struct max16601_data *data = to_max16601_data(info);
  76         u8 buf[I2C_SMBUS_BLOCK_MAX + 1];
  77         int ret;
  78
  79         switch (page) {
  80         case 0:         /* VCORE */
  81                 if (phase == 0xff)
  82                         return -ENODATA;
  83                 switch (reg) {
  84                 case PMBUS_READ_IIN:
  85                 case PMBUS_READ_IOUT:
  86                 case PMBUS_READ_TEMPERATURE_1:
  87                         ret = i2c_smbus_write_byte_data(client, REG_PHASE_ID,
  88                                                         phase);
  89                         if (ret)
  90                                 return ret;
  91                         ret = i2c_smbus_read_block_data(client,
  92                                                         REG_PHASE_REPORTING,
  93                                                         buf);
  94                         if (ret < 0)
  95                                 return ret;
  96                         if (ret < 6)
  97                                 return -EIO;
  98                         switch (reg) {
  99                         case PMBUS_READ_TEMPERATURE_1:
 100                                 return buf[1] << 8 | buf[0];
 101                         case PMBUS_READ_IOUT:
 102                                 return buf[3] << 8 | buf[2];
 103                         case PMBUS_READ_IIN:
 104                                 return buf[5] << 8 | buf[4];
 105                         default:
 106                                 break;
 107                         }
 108                 }
 109                 return -EOPNOTSUPP;
 110         case 1:         /* VCORE, read IIN/PIN from sensor element */
 111                 switch (reg) {
 112                 case PMBUS_READ_IIN:
 113                         return i2c_smbus_read_word_data(client, REG_IIN_SENSOR);
 114                 case PMBUS_READ_PIN:
 115                         return i2c_smbus_read_word_data(client,
 116                                                         REG_TOTAL_INPUT_POWER);
 117                 default:
 118                         break;
 119                 }
 120                 return -EOPNOTSUPP;
 121         case 2:         /* VSA */
 122                 switch (reg) {
 123                 case PMBUS_VIRT_READ_IOUT_MAX:
 124                         ret = i2c_smbus_read_word_data(data->vsa,
 125                                                        REG_IOUT_AVG_PK);
 126                         if (ret < 0)
 127                                 return ret;
 128                         if (sign_extend32(ret, 10) >
 129                             sign_extend32(data->iout_avg_pkg, 10))
 130                                 data->iout_avg_pkg = ret;
 131                         return data->iout_avg_pkg;
 132                 case PMBUS_VIRT_RESET_IOUT_HISTORY:
 133                         return 0;
 134                 case PMBUS_IOUT_OC_FAULT_LIMIT:
 135                 case PMBUS_IOUT_OC_WARN_LIMIT:
 136                 case PMBUS_OT_FAULT_LIMIT:
 137                 case PMBUS_OT_WARN_LIMIT:
 138                 case PMBUS_READ_IIN:
 139                 case PMBUS_READ_IOUT:
 140                 case PMBUS_READ_TEMPERATURE_1:
 141                 case PMBUS_STATUS_WORD:
 142                         return i2c_smbus_read_word_data(data->vsa, reg);
 143                 default:
 144                         return -EOPNOTSUPP;
 145                 }
 146         default:
 147                 return -EOPNOTSUPP;
 148         }
 149 }
 150
 151 static int max16601_write_byte(struct i2c_client *client, int page, u8 reg)
 152 {
 153         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 154         struct max16601_data *data = to_max16601_data(info);
 155
 156         if (page == 2) {
 157                 if (reg == PMBUS_CLEAR_FAULTS)
 158                         return i2c_smbus_write_byte(data->vsa, reg);
 159                 return -EOPNOTSUPP;
 160         }
 161         return -ENODATA;
 162 }
 163
 164 static int max16601_write_word(struct i2c_client *client, int page, int reg,
 165                                u16 value)
 166 {
 167         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 168         struct max16601_data *data = to_max16601_data(info);
 169
 170         switch (page) {
 171         case 0:         /* VCORE */
 172                 return -ENODATA;
 173         case 1:         /* VCORE IIN/PIN from sensor element */
 174         default:
 175                 return -EOPNOTSUPP;
 176         case 2:         /* VSA */
 177                 switch (reg) {
 178                 case PMBUS_VIRT_RESET_IOUT_HISTORY:
 179                         data->iout_avg_pkg = 0xfc00;
 180                         return 0;
 181                 case PMBUS_IOUT_OC_FAULT_LIMIT:
 182                 case PMBUS_IOUT_OC_WARN_LIMIT:
 183                 case PMBUS_OT_FAULT_LIMIT:
 184                 case PMBUS_OT_WARN_LIMIT:
 185                         return i2c_smbus_write_word_data(data->vsa, reg, value);
 186                 default:
 187                         return -EOPNOTSUPP;
 188                 }
 189         }
 190 }
 191
 192 static int max16601_identify(struct i2c_client *client,
 193                              struct pmbus_driver_info *info)
 194 {
 195         struct max16601_data *data = to_max16601_data(info);
 196         int reg;
 197
 198         reg = i2c_smbus_read_byte_data(client, REG_SETPT_DVID);
 199         if (reg < 0)
 200                 return reg;
 201         if (reg & DAC_10MV_MODE)
 202                 info->vrm_version[0] = vr13;
 203         else
 204                 info->vrm_version[0] = vr12;
 205
 206         if (data->id != max16600 && data->id != max16601 && data->id != max16602)
 207                 return 0;
 208
 209         reg = i2c_smbus_read_byte_data(client, REG_DEFAULT_NUM_POP);
 210         if (reg < 0)
 211                 return reg;
 212
 213         /*
 214          * If REG_DEFAULT_NUM_POP returns 0, we don't know how many phases
 215          * are populated. Stick with the default in that case.
 216          */
 217         reg &= 0x0f;
 218         if (reg && reg <= MAX16601_NUM_PHASES)
 219                 info->phases[0] = reg;
 220
 221         return 0;
 222 }
 223
 224 static struct pmbus_driver_info max16601_info = {
 225         .pages = 3,
 226         .format[PSC_VOLTAGE_IN] = linear,
 227         .format[PSC_VOLTAGE_OUT] = vid,
 228         .format[PSC_CURRENT_IN] = linear,
 229         .format[PSC_CURRENT_OUT] = linear,
 230         .format[PSC_TEMPERATURE] = linear,
 231         .format[PSC_POWER] = linear,
 232         .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN | PMBUS_HAVE_PIN |
 233                 PMBUS_HAVE_STATUS_INPUT |
 234                 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
 235                 PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
 236                 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP |
 237                 PMBUS_HAVE_POUT | PMBUS_PAGE_VIRTUAL | PMBUS_PHASE_VIRTUAL,
 238         .func[1] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN | PMBUS_PAGE_VIRTUAL,
 239         .func[2] = PMBUS_HAVE_IIN | PMBUS_HAVE_STATUS_INPUT |
 240                 PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
 241                 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_PAGE_VIRTUAL,
 242         .phases[0] = MAX16601_NUM_PHASES,
 243         .pfunc[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
 244         .pfunc[1] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
 245         .pfunc[2] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
 246         .pfunc[3] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
 247         .pfunc[4] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
 248         .pfunc[5] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
 249         .pfunc[6] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
 250         .pfunc[7] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
 251         .identify = max16601_identify,
 252         .read_byte_data = max16601_read_byte,
 253         .read_word_data = max16601_read_word,
 254         .write_byte = max16601_write_byte,
 255         .write_word_data = max16601_write_word,
 256 };
 257
 258 static void max16601_remove(void *_data)
 259 {
 260         struct max16601_data *data = _data;
 261
 262         i2c_unregister_device(data->vsa);
 263 }
 264
 265 static const struct i2c_device_id max16601_id[] = {
 266         {"max16508", max16508},
 267         {"max16600", max16600},
 268         {"max16601", max16601},
 269         {"max16602", max16602},
 270         {}
 271 };
 272 MODULE_DEVICE_TABLE(i2c, max16601_id);
 273
 274 static int max16601_get_id(struct i2c_client *client)
 275 {
 276         struct device *dev = &client->dev;
 277         u8 buf[I2C_SMBUS_BLOCK_MAX + 1];
 278         enum chips id;
 279         int ret;
 280
 281         ret = i2c_smbus_read_block_data(client, PMBUS_IC_DEVICE_ID, buf);
 282         if (ret < 0 || ret < 11)
 283                 return -ENODEV;
 284
 285         /*
 286          * PMBUS_IC_DEVICE_ID is expected to return MAX1660[012]y.xx",
 287          * "MAX16500y.xx".cdxxcccccccccc, or "MAX16508y.xx".
 288          */
 289         if (!strncmp(buf, "MAX16500", 8) || !strncmp(buf, "MAX16508", 8)) {
 290                 id = max16508;
 291         } else if (!strncmp(buf, "MAX16600", 8)) {
 292                 id = max16600;
 293         } else if (!strncmp(buf, "MAX16601", 8)) {
 294                 id = max16601;
 295         } else if (!strncmp(buf, "MAX16602", 8)) {
 296                 id = max16602;
 297         } else {
 298                 buf[ret] = '\0';
 299                 dev_err(dev, "Unsupported chip '%s'\n", buf);
 300                 return -ENODEV;
 301         }
 302         return id;
 303 }
 304
 305 static int max16601_probe(struct i2c_client *client)
 306 {
 307         struct device *dev = &client->dev;
 308         const struct i2c_device_id *id;
 309         struct max16601_data *data;
 310         int ret, chip_id;
 311
 312         if (!i2c_check_functionality(client->adapter,
 313                                      I2C_FUNC_SMBUS_READ_BYTE_DATA |
 314                                      I2C_FUNC_SMBUS_READ_BLOCK_DATA))
 315                 return -ENODEV;
 316
 317         chip_id = max16601_get_id(client);
 318         if (chip_id < 0)
 319                 return chip_id;
 320
 321         id = i2c_match_id(max16601_id, client);
 322         if (chip_id != id->driver_data)
 323                 dev_warn(&client->dev,
 324                          "Device mismatch: Configured %s (%d), detected %d\n",
 325                          id->name, (int) id->driver_data, chip_id);
 326
 327         ret = i2c_smbus_read_byte_data(client, REG_PHASE_ID);
 328         if (ret < 0)
 329                 return ret;
 330         if (!(ret & CORE_RAIL_INDICATOR)) {
 331                 dev_err(dev,
 332                         "Driver must be instantiated on CORE rail I2C address\n");
 333                 return -ENODEV;
 334         }
 335
 336         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 337         if (!data)
 338                 return -ENOMEM;
 339
 340         data->id = chip_id;
 341         data->iout_avg_pkg = 0xfc00;
 342         data->vsa = i2c_new_dummy_device(client->adapter, client->addr + 1);
 343         if (IS_ERR(data->vsa)) {
 344                 dev_err(dev, "Failed to register VSA client\n");
 345                 return PTR_ERR(data->vsa);
 346         }
 347         ret = devm_add_action_or_reset(dev, max16601_remove, data);
 348         if (ret)
 349                 return ret;
 350
 351         data->info = max16601_info;
 352
 353         return pmbus_do_probe(client, &data->info);
 354 }
 355
 356 static struct i2c_driver max16601_driver = {
 357         .driver = {
 358                    .name = "max16601",
 359                    },
 360         .probe = max16601_probe,
 361         .id_table = max16601_id,
 362 };
 363
 364 module_i2c_driver(max16601_driver);
 365
 366 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
 367 MODULE_DESCRIPTION("PMBus driver for Maxim MAX16601");
 368 MODULE_LICENSE("GPL v2");
 369 MODULE_IMPORT_NS("PMBUS");