Vadim Pasternak | e4db771 | 2021-05-11 08:56:18 +0300 | [diff] [blame] | 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); |