qemu

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 "hw/i2c/pmbus_device.h"
12
#include "hw/irq.h"
13
#include "migration/vmstate.h"
14
#include "qapi/error.h"
15
#include "qapi/visitor.h"
16
#include "qemu/log.h"
17
#include "qemu/module.h"
18

19
#define TYPE_ADM1272 "adm1272"
20
#define ADM1272(obj) OBJECT_CHECK(ADM1272State, (obj), TYPE_ADM1272)
21

22
#define ADM1272_RESTART_TIME            0xCC
23
#define ADM1272_MFR_PEAK_IOUT           0xD0
24
#define ADM1272_MFR_PEAK_VIN            0xD1
25
#define ADM1272_MFR_PEAK_VOUT           0xD2
26
#define ADM1272_MFR_PMON_CONTROL        0xD3
27
#define ADM1272_MFR_PMON_CONFIG         0xD4
28
#define ADM1272_MFR_ALERT1_CONFIG       0xD5
29
#define ADM1272_MFR_ALERT2_CONFIG       0xD6
30
#define ADM1272_MFR_PEAK_TEMPERATURE    0xD7
31
#define ADM1272_MFR_DEVICE_CONFIG       0xD8
32
#define ADM1272_MFR_POWER_CYCLE         0xD9
33
#define ADM1272_MFR_PEAK_PIN            0xDA
34
#define ADM1272_MFR_READ_PIN_EXT        0xDB
35
#define ADM1272_MFR_READ_EIN_EXT        0xDC
36

37
#define ADM1272_HYSTERESIS_LOW          0xF2
38
#define ADM1272_HYSTERESIS_HIGH         0xF3
39
#define ADM1272_STATUS_HYSTERESIS       0xF4
40
#define ADM1272_STATUS_GPIO             0xF5
41
#define ADM1272_STRT_UP_IOUT_LIM        0xF6
42

43
/* Defaults */
44
#define ADM1272_OPERATION_DEFAULT       0x80
45
#define ADM1272_CAPABILITY_DEFAULT      0xB0
46
#define ADM1272_CAPABILITY_NO_PEC       0x30
47
#define ADM1272_DIRECT_MODE             0x40
48
#define ADM1272_HIGH_LIMIT_DEFAULT      0x0FFF
49
#define ADM1272_PIN_OP_DEFAULT          0x7FFF
50
#define ADM1272_PMBUS_REVISION_DEFAULT  0x22
51
#define ADM1272_MFR_ID_DEFAULT          "ADI"
52
#define ADM1272_MODEL_DEFAULT           "ADM1272-A1"
53
#define ADM1272_MFR_DEFAULT_REVISION    "25"
54
#define ADM1272_DEFAULT_DATE            "160301"
55
#define ADM1272_RESTART_TIME_DEFAULT    0x64
56
#define ADM1272_PMON_CONTROL_DEFAULT    0x1
57
#define ADM1272_PMON_CONFIG_DEFAULT     0x3F35
58
#define ADM1272_DEVICE_CONFIG_DEFAULT   0x8
59
#define ADM1272_HYSTERESIS_HIGH_DEFAULT     0xFFFF
60
#define ADM1272_STRT_UP_IOUT_LIM_DEFAULT    0x000F
61
#define ADM1272_VOLT_DEFAULT            12000
62
#define ADM1272_IOUT_DEFAULT            25000
63
#define ADM1272_PWR_DEFAULT             300  /* 12V 25A */
64
#define ADM1272_SHUNT                   300 /* micro-ohms */
65
#define ADM1272_VOLTAGE_COEFF_DEFAULT   1
66
#define ADM1272_CURRENT_COEFF_DEFAULT   3
67
#define ADM1272_PWR_COEFF_DEFAULT       7
68
#define ADM1272_IOUT_OFFSET             0x5000
69
#define ADM1272_IOUT_OFFSET             0x5000
70

71

72
typedef struct ADM1272State {
73
    PMBusDevice parent;
74

75
    uint64_t ein_ext;
76
    uint32_t pin_ext;
77
    uint8_t restart_time;
78

79
    uint16_t peak_vin;
80
    uint16_t peak_vout;
81
    uint16_t peak_iout;
82
    uint16_t peak_temperature;
83
    uint16_t peak_pin;
84

85
    uint8_t pmon_control;
86
    uint16_t pmon_config;
87
    uint16_t alert1_config;
88
    uint16_t alert2_config;
89
    uint16_t device_config;
90

91
    uint16_t hysteresis_low;
92
    uint16_t hysteresis_high;
93
    uint8_t status_hysteresis;
94
    uint8_t status_gpio;
95

96
    uint16_t strt_up_iout_lim;
97

98
} ADM1272State;
99

100
static const PMBusCoefficients adm1272_coefficients[] = {
101
    [0] = { 6770, 0, -2 },        /* voltage, vrange 60V */
102
    [1] = { 4062, 0, -2 },        /* voltage, vrange 100V */
103
    [2] = { 1326, 20480, -1 },    /* current, vsense range 15mV */
104
    [3] = { 663, 20480, -1 },     /* current, vsense range 30mV */
105
    [4] = { 3512, 0, -2 },        /* power, vrange 60V, irange 15mV */
106
    [5] = { 21071, 0, -3 },       /* power, vrange 100V, irange 15mV */
107
    [6] = { 17561, 0, -3 },       /* power, vrange 60V, irange 30mV */
108
    [7] = { 10535, 0, -3 },       /* power, vrange 100V, irange 30mV */
109
    [8] = { 42, 31871, -1 },      /* temperature */
110
};
111

112
static void adm1272_check_limits(ADM1272State *s)
113
{
114
    PMBusDevice *pmdev = PMBUS_DEVICE(s);
115

116
    pmbus_check_limits(pmdev);
117

118
    if (pmdev->pages[0].read_vout > s->peak_vout) {
119
        s->peak_vout = pmdev->pages[0].read_vout;
120
    }
121

122
    if (pmdev->pages[0].read_vin > s->peak_vin) {
123
        s->peak_vin = pmdev->pages[0].read_vin;
124
    }
125

126
    if (pmdev->pages[0].read_iout > s->peak_iout) {
127
        s->peak_iout = pmdev->pages[0].read_iout;
128
    }
129

130
    if (pmdev->pages[0].read_temperature_1 > s->peak_temperature) {
131
        s->peak_temperature = pmdev->pages[0].read_temperature_1;
132
    }
133

134
    if (pmdev->pages[0].read_pin > s->peak_pin) {
135
        s->peak_pin = pmdev->pages[0].read_pin;
136
    }
137
}
138

139
static uint16_t adm1272_millivolts_to_direct(uint32_t value)
140
{
141
    PMBusCoefficients c = adm1272_coefficients[ADM1272_VOLTAGE_COEFF_DEFAULT];
142
    c.b = c.b * 1000;
143
    c.R = c.R - 3;
144
    return pmbus_data2direct_mode(c, value);
145
}
146

147
static uint32_t adm1272_direct_to_millivolts(uint16_t value)
148
{
149
    PMBusCoefficients c = adm1272_coefficients[ADM1272_VOLTAGE_COEFF_DEFAULT];
150
    c.b = c.b * 1000;
151
    c.R = c.R - 3;
152
    return pmbus_direct_mode2data(c, value);
153
}
154

155
static uint16_t adm1272_milliamps_to_direct(uint32_t value)
156
{
157
    PMBusCoefficients c = adm1272_coefficients[ADM1272_CURRENT_COEFF_DEFAULT];
158
    /* Y = (m * r_sense * x - b) * 10^R */
159
    c.m = c.m * ADM1272_SHUNT / 1000; /* micro-ohms */
160
    c.b = c.b * 1000;
161
    c.R = c.R - 3;
162
    return pmbus_data2direct_mode(c, value);
163
}
164

165
static uint32_t adm1272_direct_to_milliamps(uint16_t value)
166
{
167
    PMBusCoefficients c = adm1272_coefficients[ADM1272_CURRENT_COEFF_DEFAULT];
168
    c.m = c.m * ADM1272_SHUNT / 1000;
169
    c.b = c.b * 1000;
170
    c.R = c.R - 3;
171
    return pmbus_direct_mode2data(c, value);
172
}
173

174
static uint16_t adm1272_watts_to_direct(uint32_t value)
175
{
176
    PMBusCoefficients c = adm1272_coefficients[ADM1272_PWR_COEFF_DEFAULT];
177
    c.m = c.m * ADM1272_SHUNT / 1000;
178
    return pmbus_data2direct_mode(c, value);
179
}
180

181
static uint32_t adm1272_direct_to_watts(uint16_t value)
182
{
183
    PMBusCoefficients c = adm1272_coefficients[ADM1272_PWR_COEFF_DEFAULT];
184
    c.m = c.m * ADM1272_SHUNT / 1000;
185
    return pmbus_direct_mode2data(c, value);
186
}
187

188
static void adm1272_exit_reset(Object *obj, ResetType type)
189
{
190
    ADM1272State *s = ADM1272(obj);
191
    PMBusDevice *pmdev = PMBUS_DEVICE(obj);
192

193
    pmdev->page = 0;
194
    pmdev->pages[0].operation = ADM1272_OPERATION_DEFAULT;
195

196

197
    pmdev->capability = ADM1272_CAPABILITY_NO_PEC;
198
    pmdev->pages[0].revision = ADM1272_PMBUS_REVISION_DEFAULT;
199
    pmdev->pages[0].vout_mode = ADM1272_DIRECT_MODE;
200
    pmdev->pages[0].vout_ov_warn_limit = ADM1272_HIGH_LIMIT_DEFAULT;
201
    pmdev->pages[0].vout_uv_warn_limit = 0;
202
    pmdev->pages[0].iout_oc_warn_limit = ADM1272_HIGH_LIMIT_DEFAULT;
203
    pmdev->pages[0].ot_fault_limit = ADM1272_HIGH_LIMIT_DEFAULT;
204
    pmdev->pages[0].ot_warn_limit = ADM1272_HIGH_LIMIT_DEFAULT;
205
    pmdev->pages[0].vin_ov_warn_limit = ADM1272_HIGH_LIMIT_DEFAULT;
206
    pmdev->pages[0].vin_uv_warn_limit = 0;
207
    pmdev->pages[0].pin_op_warn_limit = ADM1272_PIN_OP_DEFAULT;
208

209
    pmdev->pages[0].status_word = 0;
210
    pmdev->pages[0].status_vout = 0;
211
    pmdev->pages[0].status_iout = 0;
212
    pmdev->pages[0].status_input = 0;
213
    pmdev->pages[0].status_temperature = 0;
214
    pmdev->pages[0].status_mfr_specific = 0;
215

216
    pmdev->pages[0].read_vin
217
        = adm1272_millivolts_to_direct(ADM1272_VOLT_DEFAULT);
218
    pmdev->pages[0].read_vout
219
        = adm1272_millivolts_to_direct(ADM1272_VOLT_DEFAULT);
220
    pmdev->pages[0].read_iout
221
        = adm1272_milliamps_to_direct(ADM1272_IOUT_DEFAULT);
222
    pmdev->pages[0].read_temperature_1 = 0;
223
    pmdev->pages[0].read_pin = adm1272_watts_to_direct(ADM1272_PWR_DEFAULT);
224
    pmdev->pages[0].revision = ADM1272_PMBUS_REVISION_DEFAULT;
225
    pmdev->pages[0].mfr_id = ADM1272_MFR_ID_DEFAULT;
226
    pmdev->pages[0].mfr_model = ADM1272_MODEL_DEFAULT;
227
    pmdev->pages[0].mfr_revision = ADM1272_MFR_DEFAULT_REVISION;
228
    pmdev->pages[0].mfr_date = ADM1272_DEFAULT_DATE;
229

230
    s->pin_ext = 0;
231
    s->ein_ext = 0;
232
    s->restart_time = ADM1272_RESTART_TIME_DEFAULT;
233

234
    s->peak_vin = 0;
235
    s->peak_vout = 0;
236
    s->peak_iout = 0;
237
    s->peak_temperature = 0;
238
    s->peak_pin = 0;
239

240
    s->pmon_control = ADM1272_PMON_CONTROL_DEFAULT;
241
    s->pmon_config = ADM1272_PMON_CONFIG_DEFAULT;
242
    s->alert1_config = 0;
243
    s->alert2_config = 0;
244
    s->device_config = ADM1272_DEVICE_CONFIG_DEFAULT;
245

246
    s->hysteresis_low = 0;
247
    s->hysteresis_high = ADM1272_HYSTERESIS_HIGH_DEFAULT;
248
    s->status_hysteresis = 0;
249
    s->status_gpio = 0;
250

251
    s->strt_up_iout_lim = ADM1272_STRT_UP_IOUT_LIM_DEFAULT;
252
}
253

254
static uint8_t adm1272_read_byte(PMBusDevice *pmdev)
255
{
256
    ADM1272State *s = ADM1272(pmdev);
257

258
    switch (pmdev->code) {
259
    case ADM1272_RESTART_TIME:
260
        pmbus_send8(pmdev, s->restart_time);
261
        break;
262

263
    case ADM1272_MFR_PEAK_IOUT:
264
        pmbus_send16(pmdev, s->peak_iout);
265
        break;
266

267
    case ADM1272_MFR_PEAK_VIN:
268
        pmbus_send16(pmdev, s->peak_vin);
269
        break;
270

271
    case ADM1272_MFR_PEAK_VOUT:
272
        pmbus_send16(pmdev, s->peak_vout);
273
        break;
274

275
    case ADM1272_MFR_PMON_CONTROL:
276
        pmbus_send8(pmdev, s->pmon_control);
277
        break;
278

279
    case ADM1272_MFR_PMON_CONFIG:
280
        pmbus_send16(pmdev, s->pmon_config);
281
        break;
282

283
    case ADM1272_MFR_ALERT1_CONFIG:
284
        pmbus_send16(pmdev, s->alert1_config);
285
        break;
286

287
    case ADM1272_MFR_ALERT2_CONFIG:
288
        pmbus_send16(pmdev, s->alert2_config);
289
        break;
290

291
    case ADM1272_MFR_PEAK_TEMPERATURE:
292
        pmbus_send16(pmdev, s->peak_temperature);
293
        break;
294

295
    case ADM1272_MFR_DEVICE_CONFIG:
296
        pmbus_send16(pmdev, s->device_config);
297
        break;
298

299
    case ADM1272_MFR_PEAK_PIN:
300
        pmbus_send16(pmdev, s->peak_pin);
301
        break;
302

303
    case ADM1272_MFR_READ_PIN_EXT:
304
        pmbus_send32(pmdev, s->pin_ext);
305
        break;
306

307
    case ADM1272_MFR_READ_EIN_EXT:
308
        pmbus_send64(pmdev, s->ein_ext);
309
        break;
310

311
    case ADM1272_HYSTERESIS_LOW:
312
        pmbus_send16(pmdev, s->hysteresis_low);
313
        break;
314

315
    case ADM1272_HYSTERESIS_HIGH:
316
        pmbus_send16(pmdev, s->hysteresis_high);
317
        break;
318

319
    case ADM1272_STATUS_HYSTERESIS:
320
        pmbus_send16(pmdev, s->status_hysteresis);
321
        break;
322

323
    case ADM1272_STATUS_GPIO:
324
        pmbus_send16(pmdev, s->status_gpio);
325
        break;
326

327
    case ADM1272_STRT_UP_IOUT_LIM:
328
        pmbus_send16(pmdev, s->strt_up_iout_lim);
329
        break;
330

331
    default:
332
        qemu_log_mask(LOG_GUEST_ERROR,
333
                      "%s: reading from unsupported register: 0x%02x\n",
334
                      __func__, pmdev->code);
335
        return 0xFF;
336
        break;
337
    }
338

339
    return 0;
340
}
341

342
static int adm1272_write_data(PMBusDevice *pmdev, const uint8_t *buf,
343
                              uint8_t len)
344
{
345
    ADM1272State *s = ADM1272(pmdev);
346

347
    if (len == 0) {
348
        qemu_log_mask(LOG_GUEST_ERROR, "%s: writing empty data\n", __func__);
349
        return -1;
350
    }
351

352
    pmdev->code = buf[0]; /* PMBus command code */
353

354
    if (len == 1) {
355
        return 0;
356
    }
357

358
    /* Exclude command code from buffer */
359
    buf++;
360
    len--;
361

362
    switch (pmdev->code) {
363

364
    case ADM1272_RESTART_TIME:
365
        s->restart_time = pmbus_receive8(pmdev);
366
        break;
367

368
    case ADM1272_MFR_PMON_CONTROL:
369
        s->pmon_control = pmbus_receive8(pmdev);
370
        break;
371

372
    case ADM1272_MFR_PMON_CONFIG:
373
        s->pmon_config = pmbus_receive16(pmdev);
374
        break;
375

376
    case ADM1272_MFR_ALERT1_CONFIG:
377
        s->alert1_config = pmbus_receive16(pmdev);
378
        break;
379

380
    case ADM1272_MFR_ALERT2_CONFIG:
381
        s->alert2_config = pmbus_receive16(pmdev);
382
        break;
383

384
    case ADM1272_MFR_DEVICE_CONFIG:
385
        s->device_config = pmbus_receive16(pmdev);
386
        break;
387

388
    case ADM1272_MFR_POWER_CYCLE:
389
        device_cold_reset(DEVICE(s));
390
        break;
391

392
    case ADM1272_HYSTERESIS_LOW:
393
        s->hysteresis_low = pmbus_receive16(pmdev);
394
        break;
395

396
    case ADM1272_HYSTERESIS_HIGH:
397
        s->hysteresis_high = pmbus_receive16(pmdev);
398
        break;
399

400
    case ADM1272_STRT_UP_IOUT_LIM:
401
        s->strt_up_iout_lim = pmbus_receive16(pmdev);
402
        adm1272_check_limits(s);
403
        break;
404

405
    default:
406
        qemu_log_mask(LOG_GUEST_ERROR,
407
                      "%s: writing to unsupported register: 0x%02x\n",
408
                      __func__, pmdev->code);
409
        break;
410
    }
411
    return 0;
412
}
413

414
static void adm1272_get(Object *obj, Visitor *v, const char *name, void *opaque,
415
                        Error **errp)
416
{
417
    uint16_t value;
418

419
    if (strcmp(name, "vin") == 0 || strcmp(name, "vout") == 0) {
420
        value = adm1272_direct_to_millivolts(*(uint16_t *)opaque);
421
    } else if (strcmp(name, "iout") == 0) {
422
        value = adm1272_direct_to_milliamps(*(uint16_t *)opaque);
423
    } else if (strcmp(name, "pin") == 0) {
424
        value = adm1272_direct_to_watts(*(uint16_t *)opaque);
425
    } else {
426
        value = *(uint16_t *)opaque;
427
    }
428

429
    visit_type_uint16(v, name, &value, errp);
430
}
431

432
static void adm1272_set(Object *obj, Visitor *v, const char *name, void *opaque,
433
                        Error **errp)
434
{
435
    ADM1272State *s = ADM1272(obj);
436
    uint16_t *internal = opaque;
437
    uint16_t value;
438

439
    if (!visit_type_uint16(v, name, &value, errp)) {
440
        return;
441
    }
442

443
    if (strcmp(name, "vin") == 0 || strcmp(name, "vout") == 0) {
444
        *internal = adm1272_millivolts_to_direct(value);
445
    } else if (strcmp(name, "iout") == 0) {
446
        *internal = adm1272_milliamps_to_direct(value);
447
    } else if (strcmp(name, "pin") == 0) {
448
        *internal = adm1272_watts_to_direct(value);
449
    } else {
450
        *internal = value;
451
    }
452

453
    adm1272_check_limits(s);
454
}
455

456
static const VMStateDescription vmstate_adm1272 = {
457
    .name = "ADM1272",
458
    .version_id = 0,
459
    .minimum_version_id = 0,
460
    .fields = (const VMStateField[]){
461
        VMSTATE_PMBUS_DEVICE(parent, ADM1272State),
462
        VMSTATE_UINT64(ein_ext, ADM1272State),
463
        VMSTATE_UINT32(pin_ext, ADM1272State),
464
        VMSTATE_UINT8(restart_time, ADM1272State),
465

466
        VMSTATE_UINT16(peak_vin, ADM1272State),
467
        VMSTATE_UINT16(peak_vout, ADM1272State),
468
        VMSTATE_UINT16(peak_iout, ADM1272State),
469
        VMSTATE_UINT16(peak_temperature, ADM1272State),
470
        VMSTATE_UINT16(peak_pin, ADM1272State),
471

472
        VMSTATE_UINT8(pmon_control, ADM1272State),
473
        VMSTATE_UINT16(pmon_config, ADM1272State),
474
        VMSTATE_UINT16(alert1_config, ADM1272State),
475
        VMSTATE_UINT16(alert2_config, ADM1272State),
476
        VMSTATE_UINT16(device_config, ADM1272State),
477

478
        VMSTATE_UINT16(hysteresis_low, ADM1272State),
479
        VMSTATE_UINT16(hysteresis_high, ADM1272State),
480
        VMSTATE_UINT8(status_hysteresis, ADM1272State),
481
        VMSTATE_UINT8(status_gpio, ADM1272State),
482

483
        VMSTATE_UINT16(strt_up_iout_lim, ADM1272State),
484
        VMSTATE_END_OF_LIST()
485
    }
486
};
487

488
static void adm1272_init(Object *obj)
489
{
490
    PMBusDevice *pmdev = PMBUS_DEVICE(obj);
491
    uint64_t flags = PB_HAS_VOUT_MODE | PB_HAS_VOUT | PB_HAS_VIN | PB_HAS_IOUT |
492
                     PB_HAS_PIN | PB_HAS_TEMPERATURE | PB_HAS_MFR_INFO;
493

494
    pmbus_page_config(pmdev, 0, flags);
495

496
    object_property_add(obj, "vin", "uint16",
497
                        adm1272_get,
498
                        adm1272_set, NULL, &pmdev->pages[0].read_vin);
499

500
    object_property_add(obj, "vout", "uint16",
501
                        adm1272_get,
502
                        adm1272_set, NULL, &pmdev->pages[0].read_vout);
503

504
    object_property_add(obj, "iout", "uint16",
505
                        adm1272_get,
506
                        adm1272_set, NULL, &pmdev->pages[0].read_iout);
507

508
    object_property_add(obj, "pin", "uint16",
509
                        adm1272_get,
510
                        adm1272_set, NULL, &pmdev->pages[0].read_pin);
511

512
}
513

514
static void adm1272_class_init(ObjectClass *klass, void *data)
515
{
516
    ResettableClass *rc = RESETTABLE_CLASS(klass);
517
    DeviceClass *dc = DEVICE_CLASS(klass);
518
    PMBusDeviceClass *k = PMBUS_DEVICE_CLASS(klass);
519

520
    dc->desc = "Analog Devices ADM1272 Hot Swap controller";
521
    dc->vmsd = &vmstate_adm1272;
522
    k->write_data = adm1272_write_data;
523
    k->receive_byte = adm1272_read_byte;
524
    k->device_num_pages = 1;
525

526
    rc->phases.exit = adm1272_exit_reset;
527
}
528

529
static const TypeInfo adm1272_info = {
530
    .name = TYPE_ADM1272,
531
    .parent = TYPE_PMBUS_DEVICE,
532
    .instance_size = sizeof(ADM1272State),
533
    .instance_init = adm1272_init,
534
    .class_init = adm1272_class_init,
535
};
536

537
static void adm1272_register_types(void)
538
{
539
    type_register_static(&adm1272_info);
540
}
541

542
type_init(adm1272_register_types)
543