1 /* 2 * Analog Devices ADM1272 High Voltage Positive Hot Swap Controller and Digital 3 * Power Monitor with PMBus 4 * 5 * Copyright 2021 Google LLC 6 * 7 * SPDX-License-Identifier: GPL-2.0-or-later 8 */ 9 10 #include "qemu/osdep.h" 11 #include <string.h> 12 #include "hw/i2c/pmbus_device.h" 13 #include "hw/irq.h" 14 #include "migration/vmstate.h" 15 #include "qapi/error.h" 16 #include "qapi/visitor.h" 17 #include "qemu/log.h" 18 #include "qemu/module.h" 19 20 #define TYPE_ADM1272 "adm1272" 21 #define ADM1272(obj) OBJECT_CHECK(ADM1272State, (obj), TYPE_ADM1272) 22 23 #define ADM1272_RESTART_TIME 0xCC 24 #define ADM1272_MFR_PEAK_IOUT 0xD0 25 #define ADM1272_MFR_PEAK_VIN 0xD1 26 #define ADM1272_MFR_PEAK_VOUT 0xD2 27 #define ADM1272_MFR_PMON_CONTROL 0xD3 28 #define ADM1272_MFR_PMON_CONFIG 0xD4 29 #define ADM1272_MFR_ALERT1_CONFIG 0xD5 30 #define ADM1272_MFR_ALERT2_CONFIG 0xD6 31 #define ADM1272_MFR_PEAK_TEMPERATURE 0xD7 32 #define ADM1272_MFR_DEVICE_CONFIG 0xD8 33 #define ADM1272_MFR_POWER_CYCLE 0xD9 34 #define ADM1272_MFR_PEAK_PIN 0xDA 35 #define ADM1272_MFR_READ_PIN_EXT 0xDB 36 #define ADM1272_MFR_READ_EIN_EXT 0xDC 37 38 #define ADM1272_HYSTERESIS_LOW 0xF2 39 #define ADM1272_HYSTERESIS_HIGH 0xF3 40 #define ADM1272_STATUS_HYSTERESIS 0xF4 41 #define ADM1272_STATUS_GPIO 0xF5 42 #define ADM1272_STRT_UP_IOUT_LIM 0xF6 43 44 /* Defaults */ 45 #define ADM1272_OPERATION_DEFAULT 0x80 46 #define ADM1272_CAPABILITY_DEFAULT 0xB0 47 #define ADM1272_CAPABILITY_NO_PEC 0x30 48 #define ADM1272_DIRECT_MODE 0x40 49 #define ADM1272_HIGH_LIMIT_DEFAULT 0x0FFF 50 #define ADM1272_PIN_OP_DEFAULT 0x7FFF 51 #define ADM1272_PMBUS_REVISION_DEFAULT 0x22 52 #define ADM1272_MFR_ID_DEFAULT "ADI" 53 #define ADM1272_MODEL_DEFAULT "ADM1272-A1" 54 #define ADM1272_MFR_DEFAULT_REVISION "25" 55 #define ADM1272_DEFAULT_DATE "160301" 56 #define ADM1272_RESTART_TIME_DEFAULT 0x64 57 #define ADM1272_PMON_CONTROL_DEFAULT 0x1 58 #define ADM1272_PMON_CONFIG_DEFAULT 0x3F35 59 #define ADM1272_DEVICE_CONFIG_DEFAULT 0x8 60 #define ADM1272_HYSTERESIS_HIGH_DEFAULT 0xFFFF 61 #define ADM1272_STRT_UP_IOUT_LIM_DEFAULT 0x000F 62 #define ADM1272_VOLT_DEFAULT 12000 63 #define ADM1272_IOUT_DEFAULT 25000 64 #define ADM1272_PWR_DEFAULT 300 /* 12V 25A */ 65 #define ADM1272_SHUNT 300 /* micro-ohms */ 66 #define ADM1272_VOLTAGE_COEFF_DEFAULT 1 67 #define ADM1272_CURRENT_COEFF_DEFAULT 3 68 #define ADM1272_PWR_COEFF_DEFAULT 7 69 #define ADM1272_IOUT_OFFSET 0x5000 70 #define ADM1272_IOUT_OFFSET 0x5000 71 72 73 typedef struct ADM1272State { 74 PMBusDevice parent; 75 76 uint64_t ein_ext; 77 uint32_t pin_ext; 78 uint8_t restart_time; 79 80 uint16_t peak_vin; 81 uint16_t peak_vout; 82 uint16_t peak_iout; 83 uint16_t peak_temperature; 84 uint16_t peak_pin; 85 86 uint8_t pmon_control; 87 uint16_t pmon_config; 88 uint16_t alert1_config; 89 uint16_t alert2_config; 90 uint16_t device_config; 91 92 uint16_t hysteresis_low; 93 uint16_t hysteresis_high; 94 uint8_t status_hysteresis; 95 uint8_t status_gpio; 96 97 uint16_t strt_up_iout_lim; 98 99 } ADM1272State; 100 101 static const PMBusCoefficients adm1272_coefficients[] = { 102 [0] = { 6770, 0, -2 }, /* voltage, vrange 60V */ 103 [1] = { 4062, 0, -2 }, /* voltage, vrange 100V */ 104 [2] = { 1326, 20480, -1 }, /* current, vsense range 15mV */ 105 [3] = { 663, 20480, -1 }, /* current, vsense range 30mV */ 106 [4] = { 3512, 0, -2 }, /* power, vrange 60V, irange 15mV */ 107 [5] = { 21071, 0, -3 }, /* power, vrange 100V, irange 15mV */ 108 [6] = { 17561, 0, -3 }, /* power, vrange 60V, irange 30mV */ 109 [7] = { 10535, 0, -3 }, /* power, vrange 100V, irange 30mV */ 110 [8] = { 42, 31871, -1 }, /* temperature */ 111 }; 112 113 static void adm1272_check_limits(ADM1272State *s) 114 { 115 PMBusDevice *pmdev = PMBUS_DEVICE(s); 116 117 pmbus_check_limits(pmdev); 118 119 if (pmdev->pages[0].read_vout > s->peak_vout) { 120 s->peak_vout = pmdev->pages[0].read_vout; 121 } 122 123 if (pmdev->pages[0].read_vin > s->peak_vin) { 124 s->peak_vin = pmdev->pages[0].read_vin; 125 } 126 127 if (pmdev->pages[0].read_iout > s->peak_iout) { 128 s->peak_iout = pmdev->pages[0].read_iout; 129 } 130 131 if (pmdev->pages[0].read_temperature_1 > s->peak_temperature) { 132 s->peak_temperature = pmdev->pages[0].read_temperature_1; 133 } 134 135 if (pmdev->pages[0].read_pin > s->peak_pin) { 136 s->peak_pin = pmdev->pages[0].read_pin; 137 } 138 } 139 140 static uint16_t adm1272_millivolts_to_direct(uint32_t value) 141 { 142 PMBusCoefficients c = adm1272_coefficients[ADM1272_VOLTAGE_COEFF_DEFAULT]; 143 c.b = c.b * 1000; 144 c.R = c.R - 3; 145 return pmbus_data2direct_mode(c, value); 146 } 147 148 static uint32_t adm1272_direct_to_millivolts(uint16_t value) 149 { 150 PMBusCoefficients c = adm1272_coefficients[ADM1272_VOLTAGE_COEFF_DEFAULT]; 151 c.b = c.b * 1000; 152 c.R = c.R - 3; 153 return pmbus_direct_mode2data(c, value); 154 } 155 156 static uint16_t adm1272_milliamps_to_direct(uint32_t value) 157 { 158 PMBusCoefficients c = adm1272_coefficients[ADM1272_CURRENT_COEFF_DEFAULT]; 159 /* Y = (m * r_sense * x - b) * 10^R */ 160 c.m = c.m * ADM1272_SHUNT / 1000; /* micro-ohms */ 161 c.b = c.b * 1000; 162 c.R = c.R - 3; 163 return pmbus_data2direct_mode(c, value); 164 } 165 166 static uint32_t adm1272_direct_to_milliamps(uint16_t value) 167 { 168 PMBusCoefficients c = adm1272_coefficients[ADM1272_CURRENT_COEFF_DEFAULT]; 169 c.m = c.m * ADM1272_SHUNT / 1000; 170 c.b = c.b * 1000; 171 c.R = c.R - 3; 172 return pmbus_direct_mode2data(c, value); 173 } 174 175 static uint16_t adm1272_watts_to_direct(uint32_t value) 176 { 177 PMBusCoefficients c = adm1272_coefficients[ADM1272_PWR_COEFF_DEFAULT]; 178 c.m = c.m * ADM1272_SHUNT / 1000; 179 return pmbus_data2direct_mode(c, value); 180 } 181 182 static uint32_t adm1272_direct_to_watts(uint16_t value) 183 { 184 PMBusCoefficients c = adm1272_coefficients[ADM1272_PWR_COEFF_DEFAULT]; 185 c.m = c.m * ADM1272_SHUNT / 1000; 186 return pmbus_direct_mode2data(c, value); 187 } 188 189 static void adm1272_exit_reset(Object *obj) 190 { 191 ADM1272State *s = ADM1272(obj); 192 PMBusDevice *pmdev = PMBUS_DEVICE(obj); 193 194 pmdev->page = 0; 195 pmdev->pages[0].operation = ADM1272_OPERATION_DEFAULT; 196 197 198 pmdev->capability = ADM1272_CAPABILITY_NO_PEC; 199 pmdev->pages[0].revision = ADM1272_PMBUS_REVISION_DEFAULT; 200 pmdev->pages[0].vout_mode = ADM1272_DIRECT_MODE; 201 pmdev->pages[0].vout_ov_warn_limit = ADM1272_HIGH_LIMIT_DEFAULT; 202 pmdev->pages[0].vout_uv_warn_limit = 0; 203 pmdev->pages[0].iout_oc_warn_limit = ADM1272_HIGH_LIMIT_DEFAULT; 204 pmdev->pages[0].ot_fault_limit = ADM1272_HIGH_LIMIT_DEFAULT; 205 pmdev->pages[0].ot_warn_limit = ADM1272_HIGH_LIMIT_DEFAULT; 206 pmdev->pages[0].vin_ov_warn_limit = ADM1272_HIGH_LIMIT_DEFAULT; 207 pmdev->pages[0].vin_uv_warn_limit = 0; 208 pmdev->pages[0].pin_op_warn_limit = ADM1272_PIN_OP_DEFAULT; 209 210 pmdev->pages[0].status_word = 0; 211 pmdev->pages[0].status_vout = 0; 212 pmdev->pages[0].status_iout = 0; 213 pmdev->pages[0].status_input = 0; 214 pmdev->pages[0].status_temperature = 0; 215 pmdev->pages[0].status_mfr_specific = 0; 216 217 pmdev->pages[0].read_vin 218 = adm1272_millivolts_to_direct(ADM1272_VOLT_DEFAULT); 219 pmdev->pages[0].read_vout 220 = adm1272_millivolts_to_direct(ADM1272_VOLT_DEFAULT); 221 pmdev->pages[0].read_iout 222 = adm1272_milliamps_to_direct(ADM1272_IOUT_DEFAULT); 223 pmdev->pages[0].read_temperature_1 = 0; 224 pmdev->pages[0].read_pin = adm1272_watts_to_direct(ADM1272_PWR_DEFAULT); 225 pmdev->pages[0].revision = ADM1272_PMBUS_REVISION_DEFAULT; 226 pmdev->pages[0].mfr_id = ADM1272_MFR_ID_DEFAULT; 227 pmdev->pages[0].mfr_model = ADM1272_MODEL_DEFAULT; 228 pmdev->pages[0].mfr_revision = ADM1272_MFR_DEFAULT_REVISION; 229 pmdev->pages[0].mfr_date = ADM1272_DEFAULT_DATE; 230 231 s->pin_ext = 0; 232 s->ein_ext = 0; 233 s->restart_time = ADM1272_RESTART_TIME_DEFAULT; 234 235 s->peak_vin = 0; 236 s->peak_vout = 0; 237 s->peak_iout = 0; 238 s->peak_temperature = 0; 239 s->peak_pin = 0; 240 241 s->pmon_control = ADM1272_PMON_CONTROL_DEFAULT; 242 s->pmon_config = ADM1272_PMON_CONFIG_DEFAULT; 243 s->alert1_config = 0; 244 s->alert2_config = 0; 245 s->device_config = ADM1272_DEVICE_CONFIG_DEFAULT; 246 247 s->hysteresis_low = 0; 248 s->hysteresis_high = ADM1272_HYSTERESIS_HIGH_DEFAULT; 249 s->status_hysteresis = 0; 250 s->status_gpio = 0; 251 252 s->strt_up_iout_lim = ADM1272_STRT_UP_IOUT_LIM_DEFAULT; 253 } 254 255 static uint8_t adm1272_read_byte(PMBusDevice *pmdev) 256 { 257 ADM1272State *s = ADM1272(pmdev); 258 259 switch (pmdev->code) { 260 case ADM1272_RESTART_TIME: 261 pmbus_send8(pmdev, s->restart_time); 262 break; 263 264 case ADM1272_MFR_PEAK_IOUT: 265 pmbus_send16(pmdev, s->peak_iout); 266 break; 267 268 case ADM1272_MFR_PEAK_VIN: 269 pmbus_send16(pmdev, s->peak_vin); 270 break; 271 272 case ADM1272_MFR_PEAK_VOUT: 273 pmbus_send16(pmdev, s->peak_vout); 274 break; 275 276 case ADM1272_MFR_PMON_CONTROL: 277 pmbus_send8(pmdev, s->pmon_control); 278 break; 279 280 case ADM1272_MFR_PMON_CONFIG: 281 pmbus_send16(pmdev, s->pmon_config); 282 break; 283 284 case ADM1272_MFR_ALERT1_CONFIG: 285 pmbus_send16(pmdev, s->alert1_config); 286 break; 287 288 case ADM1272_MFR_ALERT2_CONFIG: 289 pmbus_send16(pmdev, s->alert2_config); 290 break; 291 292 case ADM1272_MFR_PEAK_TEMPERATURE: 293 pmbus_send16(pmdev, s->peak_temperature); 294 break; 295 296 case ADM1272_MFR_DEVICE_CONFIG: 297 pmbus_send16(pmdev, s->device_config); 298 break; 299 300 case ADM1272_MFR_PEAK_PIN: 301 pmbus_send16(pmdev, s->peak_pin); 302 break; 303 304 case ADM1272_MFR_READ_PIN_EXT: 305 pmbus_send32(pmdev, s->pin_ext); 306 break; 307 308 case ADM1272_MFR_READ_EIN_EXT: 309 pmbus_send64(pmdev, s->ein_ext); 310 break; 311 312 case ADM1272_HYSTERESIS_LOW: 313 pmbus_send16(pmdev, s->hysteresis_low); 314 break; 315 316 case ADM1272_HYSTERESIS_HIGH: 317 pmbus_send16(pmdev, s->hysteresis_high); 318 break; 319 320 case ADM1272_STATUS_HYSTERESIS: 321 pmbus_send16(pmdev, s->status_hysteresis); 322 break; 323 324 case ADM1272_STATUS_GPIO: 325 pmbus_send16(pmdev, s->status_gpio); 326 break; 327 328 case ADM1272_STRT_UP_IOUT_LIM: 329 pmbus_send16(pmdev, s->strt_up_iout_lim); 330 break; 331 332 default: 333 qemu_log_mask(LOG_GUEST_ERROR, 334 "%s: reading from unsupported register: 0x%02x\n", 335 __func__, pmdev->code); 336 return 0xFF; 337 break; 338 } 339 340 return 0; 341 } 342 343 static int adm1272_write_data(PMBusDevice *pmdev, const uint8_t *buf, 344 uint8_t len) 345 { 346 ADM1272State *s = ADM1272(pmdev); 347 348 if (len == 0) { 349 qemu_log_mask(LOG_GUEST_ERROR, "%s: writing empty data\n", __func__); 350 return -1; 351 } 352 353 pmdev->code = buf[0]; /* PMBus command code */ 354 355 if (len == 1) { 356 return 0; 357 } 358 359 /* Exclude command code from buffer */ 360 buf++; 361 len--; 362 363 switch (pmdev->code) { 364 365 case ADM1272_RESTART_TIME: 366 s->restart_time = pmbus_receive8(pmdev); 367 break; 368 369 case ADM1272_MFR_PMON_CONTROL: 370 s->pmon_control = pmbus_receive8(pmdev); 371 break; 372 373 case ADM1272_MFR_PMON_CONFIG: 374 s->pmon_config = pmbus_receive16(pmdev); 375 break; 376 377 case ADM1272_MFR_ALERT1_CONFIG: 378 s->alert1_config = pmbus_receive16(pmdev); 379 break; 380 381 case ADM1272_MFR_ALERT2_CONFIG: 382 s->alert2_config = pmbus_receive16(pmdev); 383 break; 384 385 case ADM1272_MFR_DEVICE_CONFIG: 386 s->device_config = pmbus_receive16(pmdev); 387 break; 388 389 case ADM1272_MFR_POWER_CYCLE: 390 adm1272_exit_reset((Object *)s); 391 break; 392 393 case ADM1272_HYSTERESIS_LOW: 394 s->hysteresis_low = pmbus_receive16(pmdev); 395 break; 396 397 case ADM1272_HYSTERESIS_HIGH: 398 s->hysteresis_high = pmbus_receive16(pmdev); 399 break; 400 401 case ADM1272_STRT_UP_IOUT_LIM: 402 s->strt_up_iout_lim = pmbus_receive16(pmdev); 403 adm1272_check_limits(s); 404 break; 405 406 default: 407 qemu_log_mask(LOG_GUEST_ERROR, 408 "%s: writing to unsupported register: 0x%02x\n", 409 __func__, pmdev->code); 410 break; 411 } 412 return 0; 413 } 414 415 static void adm1272_get(Object *obj, Visitor *v, const char *name, void *opaque, 416 Error **errp) 417 { 418 uint16_t value; 419 420 if (strcmp(name, "vin") == 0 || strcmp(name, "vout") == 0) { 421 value = adm1272_direct_to_millivolts(*(uint16_t *)opaque); 422 } else if (strcmp(name, "iout") == 0) { 423 value = adm1272_direct_to_milliamps(*(uint16_t *)opaque); 424 } else if (strcmp(name, "pin") == 0) { 425 value = adm1272_direct_to_watts(*(uint16_t *)opaque); 426 } else { 427 value = *(uint16_t *)opaque; 428 } 429 430 visit_type_uint16(v, name, &value, errp); 431 } 432 433 static void adm1272_set(Object *obj, Visitor *v, const char *name, void *opaque, 434 Error **errp) 435 { 436 ADM1272State *s = ADM1272(obj); 437 uint16_t *internal = opaque; 438 uint16_t value; 439 440 if (!visit_type_uint16(v, name, &value, errp)) { 441 return; 442 } 443 444 if (strcmp(name, "vin") == 0 || strcmp(name, "vout") == 0) { 445 *internal = adm1272_millivolts_to_direct(value); 446 } else if (strcmp(name, "iout") == 0) { 447 *internal = adm1272_milliamps_to_direct(value); 448 } else if (strcmp(name, "pin") == 0) { 449 *internal = adm1272_watts_to_direct(value); 450 } else { 451 *internal = value; 452 } 453 454 adm1272_check_limits(s); 455 } 456 457 static const VMStateDescription vmstate_adm1272 = { 458 .name = "ADM1272", 459 .version_id = 0, 460 .minimum_version_id = 0, 461 .fields = (VMStateField[]){ 462 VMSTATE_PMBUS_DEVICE(parent, ADM1272State), 463 VMSTATE_UINT64(ein_ext, ADM1272State), 464 VMSTATE_UINT32(pin_ext, ADM1272State), 465 VMSTATE_UINT8(restart_time, ADM1272State), 466 467 VMSTATE_UINT16(peak_vin, ADM1272State), 468 VMSTATE_UINT16(peak_vout, ADM1272State), 469 VMSTATE_UINT16(peak_iout, ADM1272State), 470 VMSTATE_UINT16(peak_temperature, ADM1272State), 471 VMSTATE_UINT16(peak_pin, ADM1272State), 472 473 VMSTATE_UINT8(pmon_control, ADM1272State), 474 VMSTATE_UINT16(pmon_config, ADM1272State), 475 VMSTATE_UINT16(alert1_config, ADM1272State), 476 VMSTATE_UINT16(alert2_config, ADM1272State), 477 VMSTATE_UINT16(device_config, ADM1272State), 478 479 VMSTATE_UINT16(hysteresis_low, ADM1272State), 480 VMSTATE_UINT16(hysteresis_high, ADM1272State), 481 VMSTATE_UINT8(status_hysteresis, ADM1272State), 482 VMSTATE_UINT8(status_gpio, ADM1272State), 483 484 VMSTATE_UINT16(strt_up_iout_lim, ADM1272State), 485 VMSTATE_END_OF_LIST() 486 } 487 }; 488 489 static void adm1272_init(Object *obj) 490 { 491 PMBusDevice *pmdev = PMBUS_DEVICE(obj); 492 uint64_t flags = PB_HAS_VOUT_MODE | PB_HAS_VOUT | PB_HAS_VIN | PB_HAS_IOUT | 493 PB_HAS_PIN | PB_HAS_TEMPERATURE | PB_HAS_MFR_INFO; 494 495 pmbus_page_config(pmdev, 0, flags); 496 497 object_property_add(obj, "vin", "uint16", 498 adm1272_get, 499 adm1272_set, NULL, &pmdev->pages[0].read_vin); 500 501 object_property_add(obj, "vout", "uint16", 502 adm1272_get, 503 adm1272_set, NULL, &pmdev->pages[0].read_vout); 504 505 object_property_add(obj, "iout", "uint16", 506 adm1272_get, 507 adm1272_set, NULL, &pmdev->pages[0].read_iout); 508 509 object_property_add(obj, "pin", "uint16", 510 adm1272_get, 511 adm1272_set, NULL, &pmdev->pages[0].read_pin); 512 513 } 514 515 static void adm1272_class_init(ObjectClass *klass, void *data) 516 { 517 ResettableClass *rc = RESETTABLE_CLASS(klass); 518 DeviceClass *dc = DEVICE_CLASS(klass); 519 PMBusDeviceClass *k = PMBUS_DEVICE_CLASS(klass); 520 521 dc->desc = "Analog Devices ADM1272 Hot Swap controller"; 522 dc->vmsd = &vmstate_adm1272; 523 k->write_data = adm1272_write_data; 524 k->receive_byte = adm1272_read_byte; 525 k->device_num_pages = 1; 526 527 rc->phases.exit = adm1272_exit_reset; 528 } 529 530 static const TypeInfo adm1272_info = { 531 .name = TYPE_ADM1272, 532 .parent = TYPE_PMBUS_DEVICE, 533 .instance_size = sizeof(ADM1272State), 534 .instance_init = adm1272_init, 535 .class_init = adm1272_class_init, 536 }; 537 538 static void adm1272_register_types(void) 539 { 540 type_register_static(&adm1272_info); 541 } 542 543 type_init(adm1272_register_types) 544