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