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 - 8.5µA/A, 01b - 9.7µA/A, 1b - 10µA/A, 11b - 5µ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 * 200 - 19600, data->curr_sense_gain); 122 /* Scale according to total current resolution. */ 123 ret = (data->total_curr_resolution) ? ret * 2 : ret; 124 return ret; 125 } 126 127 static int 128 mp2888_read_phases(struct i2c_client *client, struct mp2888_data *data, int page, int phase) 129 { 130 int ret; 131 132 switch (phase) { 133 case 0 ... 1: 134 ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS1_2); 135 break; 136 case 2 ... 3: 137 ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS3_4); 138 break; 139 case 4 ... 5: 140 ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS5_6); 141 break; 142 case 6 ... 7: 143 ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS7_8); 144 break; 145 case 8 ... 9: 146 ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS9_10); 147 break; 148 default: 149 return -ENODATA; 150 } 151 return ret; 152 } 153 154 static int mp2888_read_word_data(struct i2c_client *client, int page, int phase, int reg) 155 { 156 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 157 struct mp2888_data *data = to_mp2888_data(info); 158 int ret; 159 160 switch (reg) { 161 case PMBUS_READ_VIN: 162 ret = pmbus_read_word_data(client, page, phase, reg); 163 if (ret <= 0) 164 return ret; 165 166 /* 167 * READ_VIN requires fixup to scale it to linear11 format. Register data format 168 * provides 10 bits for mantissa and 6 bits for exponent. Bits 15:10 are set with 169 * the fixed value 111011b. 170 */ 171 ret = (ret & GENMASK(9, 0)) | ((ret & GENMASK(31, 10)) << 1); 172 break; 173 case PMBUS_OT_WARN_LIMIT: 174 ret = pmbus_read_word_data(client, page, phase, reg); 175 if (ret < 0) 176 return ret; 177 /* 178 * Chip reports limits in degrees C, but the actual temperature in 10th of 179 * degrees C - scaling is needed to match both. 180 */ 181 ret *= MP2888_TEMP_UNIT; 182 break; 183 case PMBUS_READ_IOUT: 184 if (phase != 0xff) 185 return mp2888_read_phases(client, data, page, phase); 186 187 ret = pmbus_read_word_data(client, page, phase, reg); 188 if (ret < 0) 189 return ret; 190 /* 191 * READ_IOUT register has unused bits 15:12 with fixed value 1110b. Clear these 192 * bits and scale with total current resolution. Data is provided in direct format. 193 */ 194 ret &= GENMASK(11, 0); 195 ret = data->total_curr_resolution ? ret * 2 : ret; 196 break; 197 case PMBUS_IOUT_OC_WARN_LIMIT: 198 ret = pmbus_read_word_data(client, page, phase, reg); 199 if (ret < 0) 200 return ret; 201 ret &= GENMASK(9, 0); 202 /* 203 * Chip reports limits with resolution 1A or 2A, if total current resolution bit is 204 * set 1. Actual current is reported with 0.25A or respectively 0.5A resolution. 205 * Scaling is needed to match both. 206 */ 207 ret = data->total_curr_resolution ? ret * 8 : ret * 4; 208 break; 209 case PMBUS_READ_POUT: 210 case PMBUS_READ_PIN: 211 ret = pmbus_read_word_data(client, page, phase, reg); 212 if (ret < 0) 213 return ret; 214 ret = data->total_curr_resolution ? ret : DIV_ROUND_CLOSEST(ret, 2); 215 break; 216 case PMBUS_POUT_OP_WARN_LIMIT: 217 ret = pmbus_read_word_data(client, page, phase, reg); 218 if (ret < 0) 219 return ret; 220 /* 221 * Chip reports limits with resolution 1W or 2W, if total current resolution bit is 222 * set 1. Actual power is reported with 0.5W or 1W respectively resolution. Scaling 223 * is needed to match both. 224 */ 225 ret = data->total_curr_resolution ? ret * 2 : ret; 226 break; 227 /* 228 * The below registers are not implemented by device or implemented not according to the 229 * spec. Skip all of them to avoid exposing non-relevant inputs to sysfs. 230 */ 231 case PMBUS_OT_FAULT_LIMIT: 232 case PMBUS_UT_WARN_LIMIT: 233 case PMBUS_UT_FAULT_LIMIT: 234 case PMBUS_VIN_UV_FAULT_LIMIT: 235 case PMBUS_VOUT_UV_WARN_LIMIT: 236 case PMBUS_VOUT_OV_WARN_LIMIT: 237 case PMBUS_VOUT_UV_FAULT_LIMIT: 238 case PMBUS_VOUT_OV_FAULT_LIMIT: 239 case PMBUS_VIN_OV_WARN_LIMIT: 240 case PMBUS_IOUT_OC_LV_FAULT_LIMIT: 241 case PMBUS_IOUT_OC_FAULT_LIMIT: 242 case PMBUS_POUT_MAX: 243 case PMBUS_IOUT_UC_FAULT_LIMIT: 244 case PMBUS_POUT_OP_FAULT_LIMIT: 245 case PMBUS_PIN_OP_WARN_LIMIT: 246 case PMBUS_MFR_VIN_MIN: 247 case PMBUS_MFR_VOUT_MIN: 248 case PMBUS_MFR_VIN_MAX: 249 case PMBUS_MFR_VOUT_MAX: 250 case PMBUS_MFR_IIN_MAX: 251 case PMBUS_MFR_IOUT_MAX: 252 case PMBUS_MFR_PIN_MAX: 253 case PMBUS_MFR_POUT_MAX: 254 case PMBUS_MFR_MAX_TEMP_1: 255 return -ENXIO; 256 default: 257 return -ENODATA; 258 } 259 260 return ret; 261 } 262 263 static int mp2888_write_word_data(struct i2c_client *client, int page, int reg, u16 word) 264 { 265 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 266 struct mp2888_data *data = to_mp2888_data(info); 267 268 switch (reg) { 269 case PMBUS_OT_WARN_LIMIT: 270 word = DIV_ROUND_CLOSEST(word, MP2888_TEMP_UNIT); 271 /* Drop unused bits 15:8. */ 272 word = clamp_val(word, 0, GENMASK(7, 0)); 273 break; 274 case PMBUS_IOUT_OC_WARN_LIMIT: 275 /* Fix limit according to total curent resolution. */ 276 word = data->total_curr_resolution ? DIV_ROUND_CLOSEST(word, 8) : 277 DIV_ROUND_CLOSEST(word, 4); 278 /* Drop unused bits 15:10. */ 279 word = clamp_val(word, 0, GENMASK(9, 0)); 280 break; 281 case PMBUS_POUT_OP_WARN_LIMIT: 282 /* Fix limit according to total curent resolution. */ 283 word = data->total_curr_resolution ? DIV_ROUND_CLOSEST(word, 4) : 284 DIV_ROUND_CLOSEST(word, 2); 285 /* Drop unused bits 15:10. */ 286 word = clamp_val(word, 0, GENMASK(9, 0)); 287 break; 288 default: 289 return -ENODATA; 290 } 291 return pmbus_write_word_data(client, page, reg, word); 292 } 293 294 static int 295 mp2888_identify_multiphase(struct i2c_client *client, struct mp2888_data *data, 296 struct pmbus_driver_info *info) 297 { 298 int ret; 299 300 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 0); 301 if (ret < 0) 302 return ret; 303 304 /* Identify multiphase number - could be from 1 to 10. */ 305 ret = i2c_smbus_read_word_data(client, MP2888_MFR_VR_CONFIG1); 306 if (ret <= 0) 307 return ret; 308 309 info->phases[0] = ret & GENMASK(3, 0); 310 311 /* 312 * The device provides a total of 10 PWM pins, and can be configured to different phase 313 * count applications for rail. 314 */ 315 if (info->phases[0] > MP2888_MAX_PHASE) 316 return -EINVAL; 317 318 return 0; 319 } 320 321 static struct pmbus_driver_info mp2888_info = { 322 .pages = 1, 323 .format[PSC_VOLTAGE_IN] = linear, 324 .format[PSC_VOLTAGE_OUT] = direct, 325 .format[PSC_TEMPERATURE] = direct, 326 .format[PSC_CURRENT_IN] = linear, 327 .format[PSC_CURRENT_OUT] = direct, 328 .format[PSC_POWER] = direct, 329 .m[PSC_TEMPERATURE] = 1, 330 .R[PSC_TEMPERATURE] = 1, 331 .m[PSC_VOLTAGE_OUT] = 1, 332 .R[PSC_VOLTAGE_OUT] = 3, 333 .m[PSC_CURRENT_OUT] = 4, 334 .m[PSC_POWER] = 1, 335 .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_IOUT | 336 PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | 337 PMBUS_HAVE_POUT | PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT | 338 PMBUS_PHASE_VIRTUAL, 339 .pfunc[0] = PMBUS_HAVE_IOUT, 340 .pfunc[1] = PMBUS_HAVE_IOUT, 341 .pfunc[2] = PMBUS_HAVE_IOUT, 342 .pfunc[3] = PMBUS_HAVE_IOUT, 343 .pfunc[4] = PMBUS_HAVE_IOUT, 344 .pfunc[5] = PMBUS_HAVE_IOUT, 345 .pfunc[6] = PMBUS_HAVE_IOUT, 346 .pfunc[7] = PMBUS_HAVE_IOUT, 347 .pfunc[8] = PMBUS_HAVE_IOUT, 348 .pfunc[9] = PMBUS_HAVE_IOUT, 349 .read_byte_data = mp2888_read_byte_data, 350 .read_word_data = mp2888_read_word_data, 351 .write_word_data = mp2888_write_word_data, 352 }; 353 354 static int mp2888_probe(struct i2c_client *client) 355 { 356 struct pmbus_driver_info *info; 357 struct mp2888_data *data; 358 int ret; 359 360 data = devm_kzalloc(&client->dev, sizeof(struct mp2888_data), GFP_KERNEL); 361 if (!data) 362 return -ENOMEM; 363 364 memcpy(&data->info, &mp2888_info, sizeof(*info)); 365 info = &data->info; 366 367 /* Identify multiphase configuration. */ 368 ret = mp2888_identify_multiphase(client, data, info); 369 if (ret) 370 return ret; 371 372 /* Obtain current sense gain of power stage and current resolution. */ 373 ret = mp2888_current_sense_gain_and_resolution_get(client, data); 374 if (ret) 375 return ret; 376 377 return pmbus_do_probe(client, info); 378 } 379 380 static const struct i2c_device_id mp2888_id[] = { 381 {"mp2888", 0}, 382 {} 383 }; 384 385 MODULE_DEVICE_TABLE(i2c, mp2888_id); 386 387 static const struct of_device_id __maybe_unused mp2888_of_match[] = { 388 {.compatible = "mps,mp2888"}, 389 {} 390 }; 391 MODULE_DEVICE_TABLE(of, mp2888_of_match); 392 393 static struct i2c_driver mp2888_driver = { 394 .driver = { 395 .name = "mp2888", 396 .of_match_table = of_match_ptr(mp2888_of_match), 397 }, 398 .probe = mp2888_probe, 399 .id_table = mp2888_id, 400 }; 401 402 module_i2c_driver(mp2888_driver); 403 404 MODULE_AUTHOR("Vadim Pasternak <vadimp@nvidia.com>"); 405 MODULE_DESCRIPTION("PMBus driver for MPS MP2888 device"); 406 MODULE_LICENSE("GPL"); 407 MODULE_IMPORT_NS(PMBUS); 408