1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Hardware monitoring driver for MPS Multi-phase Digital VR Controllers 4 * 5 * Copyright (C) 2020 Nvidia Technologies Ltd. 6 */ 7 8 #include <linux/err.h> 9 #include <linux/i2c.h> 10 #include <linux/init.h> 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include "pmbus.h" 14 15 /* Vendor specific registers. */ 16 #define MP2888_MFR_SYS_CONFIG 0x44 17 #define MP2888_MFR_READ_CS1_2 0x73 18 #define MP2888_MFR_READ_CS3_4 0x74 19 #define MP2888_MFR_READ_CS5_6 0x75 20 #define MP2888_MFR_READ_CS7_8 0x76 21 #define MP2888_MFR_READ_CS9_10 0x77 22 #define MP2888_MFR_VR_CONFIG1 0xe1 23 24 #define MP2888_TOTAL_CURRENT_RESOLUTION BIT(3) 25 #define MP2888_PHASE_CURRENT_RESOLUTION BIT(4) 26 #define MP2888_DRMOS_KCS GENMASK(2, 0) 27 #define MP2888_TEMP_UNIT 10 28 #define MP2888_MAX_PHASE 10 29 30 struct mp2888_data { 31 struct pmbus_driver_info info; 32 int total_curr_resolution; 33 int phase_curr_resolution; 34 int curr_sense_gain; 35 }; 36 37 #define to_mp2888_data(x) container_of(x, struct mp2888_data, info) 38 39 static int mp2888_read_byte_data(struct i2c_client *client, int page, int reg) 40 { 41 switch (reg) { 42 case PMBUS_VOUT_MODE: 43 /* Enforce VOUT direct format. */ 44 return PB_VOUT_MODE_DIRECT; 45 default: 46 return -ENODATA; 47 } 48 } 49 50 static int 51 mp2888_current_sense_gain_and_resolution_get(struct i2c_client *client, struct mp2888_data *data) 52 { 53 int ret; 54 55 /* 56 * Obtain DrMOS current sense gain of power stage from the register 57 * , bits 0-2. The value is selected as below: 58 * 00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A. Other 59 * values are reserved. 60 */ 61 ret = i2c_smbus_read_word_data(client, MP2888_MFR_SYS_CONFIG); 62 if (ret < 0) 63 return ret; 64 65 switch (ret & MP2888_DRMOS_KCS) { 66 case 0: 67 data->curr_sense_gain = 85; 68 break; 69 case 1: 70 data->curr_sense_gain = 97; 71 break; 72 case 2: 73 data->curr_sense_gain = 100; 74 break; 75 case 3: 76 data->curr_sense_gain = 50; 77 break; 78 default: 79 return -EINVAL; 80 } 81 82 /* 83 * Obtain resolution selector for total and phase current report and protection. 84 * 0: original resolution; 1: half resolution (in such case phase current value should 85 * be doubled. 86 */ 87 data->total_curr_resolution = (ret & MP2888_TOTAL_CURRENT_RESOLUTION) >> 3; 88 data->phase_curr_resolution = (ret & MP2888_PHASE_CURRENT_RESOLUTION) >> 4; 89 90 return 0; 91 } 92 93 static int 94 mp2888_read_phase(struct i2c_client *client, struct mp2888_data *data, int page, int phase, u8 reg) 95 { 96 int ret; 97 98 ret = pmbus_read_word_data(client, page, phase, reg); 99 if (ret < 0) 100 return ret; 101 102 if (!((phase + 1) % 2)) 103 ret >>= 8; 104 ret &= 0xff; 105 106 /* 107 * Output value is calculated as: (READ_CSx / 80 – 1.23) / (Kcs * Rcs) 108 * where: 109 * - Kcs is the DrMOS current sense gain of power stage, which is obtained from the 110 * register MP2888_MFR_VR_CONFIG1, bits 13-12 with the following selection of DrMOS 111 * (data->curr_sense_gain): 112 * 00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A. 113 * - Rcs is the internal phase current sense resistor. This parameter depends on hardware 114 * assembly. By default it is set to 1kΩ. In case of different assembly, user should 115 * scale this parameter by dividing it by Rcs. 116 * If phase current resolution bit is set to 1, READ_CSx value should be doubled. 117 * Note, that current phase sensing, providing by the device is not accurate. This is 118 * because sampling of current occurrence of bit weight has a big deviation, especially for 119 * light load. 120 */ 121 ret = DIV_ROUND_CLOSEST(ret * 100 - 9800, data->curr_sense_gain); 122 ret = (data->phase_curr_resolution) ? ret * 2 : ret; 123 /* Scale according to total current resolution. */ 124 ret = (data->total_curr_resolution) ? ret * 8 : ret * 4; 125 return ret; 126 } 127 128 static int 129 mp2888_read_phases(struct i2c_client *client, struct mp2888_data *data, int page, int phase) 130 { 131 int ret; 132 133 switch (phase) { 134 case 0 ... 1: 135 ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS1_2); 136 break; 137 case 2 ... 3: 138 ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS3_4); 139 break; 140 case 4 ... 5: 141 ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS5_6); 142 break; 143 case 6 ... 7: 144 ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS7_8); 145 break; 146 case 8 ... 9: 147 ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS9_10); 148 break; 149 default: 150 return -ENODATA; 151 } 152 return ret; 153 } 154 155 static int mp2888_read_word_data(struct i2c_client *client, int page, int phase, int reg) 156 { 157 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 158 struct mp2888_data *data = to_mp2888_data(info); 159 int ret; 160 161 switch (reg) { 162 case PMBUS_READ_VIN: 163 ret = pmbus_read_word_data(client, page, phase, reg); 164 if (ret <= 0) 165 return ret; 166 167 /* 168 * READ_VIN requires fixup to scale it to linear11 format. Register data format 169 * provides 10 bits for mantissa and 6 bits for exponent. Bits 15:10 are set with 170 * the fixed value 111011b. 171 */ 172 ret = (ret & GENMASK(9, 0)) | ((ret & GENMASK(31, 10)) << 1); 173 break; 174 case PMBUS_OT_WARN_LIMIT: 175 ret = pmbus_read_word_data(client, page, phase, reg); 176 if (ret < 0) 177 return ret; 178 /* 179 * Chip reports limits in degrees C, but the actual temperature in 10th of 180 * degrees C - scaling is needed to match both. 181 */ 182 ret *= MP2888_TEMP_UNIT; 183 break; 184 case PMBUS_READ_IOUT: 185 if (phase != 0xff) 186 return mp2888_read_phases(client, data, page, phase); 187 188 ret = pmbus_read_word_data(client, page, phase, reg); 189 if (ret < 0) 190 return ret; 191 /* 192 * READ_IOUT register has unused bits 15:12 with fixed value 1110b. Clear these 193 * bits and scale with total current resolution. Data is provided in direct format. 194 */ 195 ret &= GENMASK(11, 0); 196 ret = data->total_curr_resolution ? ret * 2 : ret; 197 break; 198 case PMBUS_IOUT_OC_WARN_LIMIT: 199 ret = pmbus_read_word_data(client, page, phase, reg); 200 if (ret < 0) 201 return ret; 202 ret &= GENMASK(9, 0); 203 /* 204 * Chip reports limits with resolution 1A or 2A, if total current resolution bit is 205 * set 1. Actual current is reported with 0.25A or respectively 0.5A resolution. 206 * Scaling is needed to match both. 207 */ 208 ret = data->total_curr_resolution ? ret * 8 : ret * 4; 209 break; 210 case PMBUS_READ_POUT: 211 case PMBUS_READ_PIN: 212 ret = pmbus_read_word_data(client, page, phase, reg); 213 if (ret < 0) 214 return ret; 215 ret = data->total_curr_resolution ? ret * 2 : ret; 216 break; 217 case PMBUS_POUT_OP_WARN_LIMIT: 218 ret = pmbus_read_word_data(client, page, phase, reg); 219 if (ret < 0) 220 return ret; 221 /* 222 * Chip reports limits with resolution 1W or 2W, if total current resolution bit is 223 * set 1. Actual power is reported with 0.5W or 1W respectively resolution. Scaling 224 * is needed to match both. 225 */ 226 ret = data->total_curr_resolution ? ret * 4 : ret * 2; 227 break; 228 /* 229 * The below registers are not implemented by device or implemented not according to the 230 * spec. Skip all of them to avoid exposing non-relevant inputs to sysfs. 231 */ 232 case PMBUS_OT_FAULT_LIMIT: 233 case PMBUS_UT_WARN_LIMIT: 234 case PMBUS_UT_FAULT_LIMIT: 235 case PMBUS_VIN_UV_FAULT_LIMIT: 236 case PMBUS_VOUT_UV_WARN_LIMIT: 237 case PMBUS_VOUT_OV_WARN_LIMIT: 238 case PMBUS_VOUT_UV_FAULT_LIMIT: 239 case PMBUS_VOUT_OV_FAULT_LIMIT: 240 case PMBUS_VIN_OV_WARN_LIMIT: 241 case PMBUS_IOUT_OC_LV_FAULT_LIMIT: 242 case PMBUS_IOUT_OC_FAULT_LIMIT: 243 case PMBUS_POUT_MAX: 244 case PMBUS_IOUT_UC_FAULT_LIMIT: 245 case PMBUS_POUT_OP_FAULT_LIMIT: 246 case PMBUS_PIN_OP_WARN_LIMIT: 247 case PMBUS_MFR_VIN_MIN: 248 case PMBUS_MFR_VOUT_MIN: 249 case PMBUS_MFR_VIN_MAX: 250 case PMBUS_MFR_VOUT_MAX: 251 case PMBUS_MFR_IIN_MAX: 252 case PMBUS_MFR_IOUT_MAX: 253 case PMBUS_MFR_PIN_MAX: 254 case PMBUS_MFR_POUT_MAX: 255 case PMBUS_MFR_MAX_TEMP_1: 256 return -ENXIO; 257 default: 258 return -ENODATA; 259 } 260 261 return ret; 262 } 263 264 static int mp2888_write_word_data(struct i2c_client *client, int page, int reg, u16 word) 265 { 266 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 267 struct mp2888_data *data = to_mp2888_data(info); 268 269 switch (reg) { 270 case PMBUS_OT_WARN_LIMIT: 271 word = DIV_ROUND_CLOSEST(word, MP2888_TEMP_UNIT); 272 /* Drop unused bits 15:8. */ 273 word = clamp_val(word, 0, GENMASK(7, 0)); 274 break; 275 case PMBUS_IOUT_OC_WARN_LIMIT: 276 /* Fix limit according to total curent resolution. */ 277 word = data->total_curr_resolution ? DIV_ROUND_CLOSEST(word, 8) : 278 DIV_ROUND_CLOSEST(word, 4); 279 /* Drop unused bits 15:10. */ 280 word = clamp_val(word, 0, GENMASK(9, 0)); 281 break; 282 case PMBUS_POUT_OP_WARN_LIMIT: 283 /* Fix limit according to total curent resolution. */ 284 word = data->total_curr_resolution ? DIV_ROUND_CLOSEST(word, 4) : 285 DIV_ROUND_CLOSEST(word, 2); 286 /* Drop unused bits 15:10. */ 287 word = clamp_val(word, 0, GENMASK(9, 0)); 288 break; 289 default: 290 return -ENODATA; 291 } 292 return pmbus_write_word_data(client, page, reg, word); 293 } 294 295 static int 296 mp2888_identify_multiphase(struct i2c_client *client, struct mp2888_data *data, 297 struct pmbus_driver_info *info) 298 { 299 int ret; 300 301 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 0); 302 if (ret < 0) 303 return ret; 304 305 /* Identify multiphase number - could be from 1 to 10. */ 306 ret = i2c_smbus_read_word_data(client, MP2888_MFR_VR_CONFIG1); 307 if (ret <= 0) 308 return ret; 309 310 info->phases[0] = ret & GENMASK(3, 0); 311 312 /* 313 * The device provides a total of 10 PWM pins, and can be configured to different phase 314 * count applications for rail. 315 */ 316 if (info->phases[0] > MP2888_MAX_PHASE) 317 return -EINVAL; 318 319 return 0; 320 } 321 322 static struct pmbus_driver_info mp2888_info = { 323 .pages = 1, 324 .format[PSC_VOLTAGE_IN] = linear, 325 .format[PSC_VOLTAGE_OUT] = direct, 326 .format[PSC_TEMPERATURE] = direct, 327 .format[PSC_CURRENT_IN] = linear, 328 .format[PSC_CURRENT_OUT] = direct, 329 .format[PSC_POWER] = direct, 330 .m[PSC_TEMPERATURE] = 1, 331 .R[PSC_TEMPERATURE] = 1, 332 .m[PSC_VOLTAGE_OUT] = 1, 333 .R[PSC_VOLTAGE_OUT] = 3, 334 .m[PSC_CURRENT_OUT] = 4, 335 .m[PSC_POWER] = 1, 336 .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_IOUT | 337 PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | 338 PMBUS_HAVE_POUT | PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT | 339 PMBUS_PHASE_VIRTUAL, 340 .pfunc[0] = PMBUS_HAVE_IOUT, 341 .pfunc[1] = PMBUS_HAVE_IOUT, 342 .pfunc[2] = PMBUS_HAVE_IOUT, 343 .pfunc[3] = PMBUS_HAVE_IOUT, 344 .pfunc[4] = PMBUS_HAVE_IOUT, 345 .pfunc[5] = PMBUS_HAVE_IOUT, 346 .pfunc[6] = PMBUS_HAVE_IOUT, 347 .pfunc[7] = PMBUS_HAVE_IOUT, 348 .pfunc[8] = PMBUS_HAVE_IOUT, 349 .pfunc[9] = PMBUS_HAVE_IOUT, 350 .read_byte_data = mp2888_read_byte_data, 351 .read_word_data = mp2888_read_word_data, 352 .write_word_data = mp2888_write_word_data, 353 }; 354 355 static int mp2888_probe(struct i2c_client *client) 356 { 357 struct pmbus_driver_info *info; 358 struct mp2888_data *data; 359 int ret; 360 361 data = devm_kzalloc(&client->dev, sizeof(struct mp2888_data), GFP_KERNEL); 362 if (!data) 363 return -ENOMEM; 364 365 memcpy(&data->info, &mp2888_info, sizeof(*info)); 366 info = &data->info; 367 368 /* Identify multiphase configuration. */ 369 ret = mp2888_identify_multiphase(client, data, info); 370 if (ret) 371 return ret; 372 373 /* Obtain current sense gain of power stage and current resolution. */ 374 ret = mp2888_current_sense_gain_and_resolution_get(client, data); 375 if (ret) 376 return ret; 377 378 return pmbus_do_probe(client, info); 379 } 380 381 static const struct i2c_device_id mp2888_id[] = { 382 {"mp2888", 0}, 383 {} 384 }; 385 386 MODULE_DEVICE_TABLE(i2c, mp2888_id); 387 388 static const struct of_device_id __maybe_unused mp2888_of_match[] = { 389 {.compatible = "mps,mp2888"}, 390 {} 391 }; 392 MODULE_DEVICE_TABLE(of, mp2888_of_match); 393 394 static struct i2c_driver mp2888_driver = { 395 .driver = { 396 .name = "mp2888", 397 .of_match_table = of_match_ptr(mp2888_of_match), 398 }, 399 .probe_new = mp2888_probe, 400 .id_table = mp2888_id, 401 }; 402 403 module_i2c_driver(mp2888_driver); 404 405 MODULE_AUTHOR("Vadim Pasternak <vadimp@nvidia.com>"); 406 MODULE_DESCRIPTION("PMBus driver for MPS MP2888 device"); 407 MODULE_LICENSE("GPL"); 408 MODULE_IMPORT_NS(PMBUS); 409