Update VERSION for v7.2.0-rc4
[qemu.git] / hw / i2c / pmbus_device.c
1 /*
2 * PMBus wrapper over SMBus
3 *
4 * Copyright 2021 Google LLC
5 *
6 * SPDX-License-Identifier: GPL-2.0-or-later
7 */
8
9 #include "qemu/osdep.h"
10 #include <math.h>
11 #include <string.h>
12 #include "hw/i2c/pmbus_device.h"
13 #include "migration/vmstate.h"
14 #include "qemu/module.h"
15 #include "qemu/log.h"
16
17 uint16_t pmbus_data2direct_mode(PMBusCoefficients c, uint32_t value)
18 {
19 /* R is usually negative to fit large readings into 16 bits */
20 uint16_t y = (c.m * value + c.b) * pow(10, c.R);
21 return y;
22 }
23
24 uint32_t pmbus_direct_mode2data(PMBusCoefficients c, uint16_t value)
25 {
26 /* X = (Y * 10^-R - b) / m */
27 uint32_t x = (value / pow(10, c.R) - c.b) / c.m;
28 return x;
29 }
30
31 uint16_t pmbus_data2linear_mode(uint16_t value, int exp)
32 {
33 /* L = D * 2^(-e) */
34 if (exp < 0) {
35 return value << (-exp);
36 }
37 return value >> exp;
38 }
39
40 uint16_t pmbus_linear_mode2data(uint16_t value, int exp)
41 {
42 /* D = L * 2^e */
43 if (exp < 0) {
44 return value >> (-exp);
45 }
46 return value << exp;
47 }
48
49 void pmbus_send(PMBusDevice *pmdev, const uint8_t *data, uint16_t len)
50 {
51 if (pmdev->out_buf_len + len > SMBUS_DATA_MAX_LEN) {
52 qemu_log_mask(LOG_GUEST_ERROR,
53 "PMBus device tried to send too much data");
54 len = 0;
55 }
56
57 for (int i = len - 1; i >= 0; i--) {
58 pmdev->out_buf[i + pmdev->out_buf_len] = data[len - i - 1];
59 }
60 pmdev->out_buf_len += len;
61 }
62
63 /* Internal only, convert unsigned ints to the little endian bus */
64 static void pmbus_send_uint(PMBusDevice *pmdev, uint64_t data, uint8_t size)
65 {
66 uint8_t bytes[8];
67 g_assert(size <= 8);
68
69 for (int i = 0; i < size; i++) {
70 bytes[i] = data & 0xFF;
71 data = data >> 8;
72 }
73 pmbus_send(pmdev, bytes, size);
74 }
75
76 void pmbus_send8(PMBusDevice *pmdev, uint8_t data)
77 {
78 pmbus_send_uint(pmdev, data, 1);
79 }
80
81 void pmbus_send16(PMBusDevice *pmdev, uint16_t data)
82 {
83 pmbus_send_uint(pmdev, data, 2);
84 }
85
86 void pmbus_send32(PMBusDevice *pmdev, uint32_t data)
87 {
88 pmbus_send_uint(pmdev, data, 4);
89 }
90
91 void pmbus_send64(PMBusDevice *pmdev, uint64_t data)
92 {
93 pmbus_send_uint(pmdev, data, 8);
94 }
95
96 void pmbus_send_string(PMBusDevice *pmdev, const char *data)
97 {
98 size_t len = strlen(data);
99 g_assert(len > 0);
100 g_assert(len + pmdev->out_buf_len < SMBUS_DATA_MAX_LEN);
101 pmdev->out_buf[len + pmdev->out_buf_len] = len;
102
103 for (int i = len - 1; i >= 0; i--) {
104 pmdev->out_buf[i + pmdev->out_buf_len] = data[len - 1 - i];
105 }
106 pmdev->out_buf_len += len + 1;
107 }
108
109
110 static uint64_t pmbus_receive_uint(PMBusDevice *pmdev)
111 {
112 uint64_t ret = 0;
113
114 /* Exclude command code from return value */
115 pmdev->in_buf++;
116 pmdev->in_buf_len--;
117
118 for (int i = pmdev->in_buf_len - 1; i >= 0; i--) {
119 ret = ret << 8 | pmdev->in_buf[i];
120 }
121 return ret;
122 }
123
124 uint8_t pmbus_receive8(PMBusDevice *pmdev)
125 {
126 if (pmdev->in_buf_len - 1 != 1) {
127 qemu_log_mask(LOG_GUEST_ERROR,
128 "%s: length mismatch. Expected 1 byte, got %d bytes\n",
129 __func__, pmdev->in_buf_len - 1);
130 }
131 return pmbus_receive_uint(pmdev);
132 }
133
134 uint16_t pmbus_receive16(PMBusDevice *pmdev)
135 {
136 if (pmdev->in_buf_len - 1 != 2) {
137 qemu_log_mask(LOG_GUEST_ERROR,
138 "%s: length mismatch. Expected 2 bytes, got %d bytes\n",
139 __func__, pmdev->in_buf_len - 1);
140 }
141 return pmbus_receive_uint(pmdev);
142 }
143
144 uint32_t pmbus_receive32(PMBusDevice *pmdev)
145 {
146 if (pmdev->in_buf_len - 1 != 4) {
147 qemu_log_mask(LOG_GUEST_ERROR,
148 "%s: length mismatch. Expected 4 bytes, got %d bytes\n",
149 __func__, pmdev->in_buf_len - 1);
150 }
151 return pmbus_receive_uint(pmdev);
152 }
153
154 uint64_t pmbus_receive64(PMBusDevice *pmdev)
155 {
156 if (pmdev->in_buf_len - 1 != 8) {
157 qemu_log_mask(LOG_GUEST_ERROR,
158 "%s: length mismatch. Expected 8 bytes, got %d bytes\n",
159 __func__, pmdev->in_buf_len - 1);
160 }
161 return pmbus_receive_uint(pmdev);
162 }
163
164 static uint8_t pmbus_out_buf_pop(PMBusDevice *pmdev)
165 {
166 if (pmdev->out_buf_len == 0) {
167 qemu_log_mask(LOG_GUEST_ERROR,
168 "%s: tried to read from empty buffer",
169 __func__);
170 return PMBUS_ERR_BYTE;
171 }
172 uint8_t data = pmdev->out_buf[pmdev->out_buf_len - 1];
173 pmdev->out_buf_len--;
174 return data;
175 }
176
177 static void pmbus_quick_cmd(SMBusDevice *smd, uint8_t read)
178 {
179 PMBusDevice *pmdev = PMBUS_DEVICE(smd);
180 PMBusDeviceClass *pmdc = PMBUS_DEVICE_GET_CLASS(pmdev);
181
182 if (pmdc->quick_cmd) {
183 pmdc->quick_cmd(pmdev, read);
184 }
185 }
186
187 static void pmbus_pages_alloc(PMBusDevice *pmdev)
188 {
189 /* some PMBus devices don't use the PAGE command, so they get 1 page */
190 PMBusDeviceClass *k = PMBUS_DEVICE_GET_CLASS(pmdev);
191 if (k->device_num_pages == 0) {
192 k->device_num_pages = 1;
193 }
194 pmdev->num_pages = k->device_num_pages;
195 pmdev->pages = g_new0(PMBusPage, k->device_num_pages);
196 }
197
198 void pmbus_check_limits(PMBusDevice *pmdev)
199 {
200 for (int i = 0; i < pmdev->num_pages; i++) {
201 if ((pmdev->pages[i].operation & PB_OP_ON) == 0) {
202 continue; /* don't check powered off devices */
203 }
204
205 if (pmdev->pages[i].read_vout > pmdev->pages[i].vout_ov_fault_limit) {
206 pmdev->pages[i].status_word |= PB_STATUS_VOUT;
207 pmdev->pages[i].status_vout |= PB_STATUS_VOUT_OV_FAULT;
208 }
209
210 if (pmdev->pages[i].read_vout > pmdev->pages[i].vout_ov_warn_limit) {
211 pmdev->pages[i].status_word |= PB_STATUS_VOUT;
212 pmdev->pages[i].status_vout |= PB_STATUS_VOUT_OV_WARN;
213 }
214
215 if (pmdev->pages[i].read_vout < pmdev->pages[i].vout_uv_warn_limit) {
216 pmdev->pages[i].status_word |= PB_STATUS_VOUT;
217 pmdev->pages[i].status_vout |= PB_STATUS_VOUT_UV_WARN;
218 }
219
220 if (pmdev->pages[i].read_vout < pmdev->pages[i].vout_uv_fault_limit) {
221 pmdev->pages[i].status_word |= PB_STATUS_VOUT;
222 pmdev->pages[i].status_vout |= PB_STATUS_VOUT_UV_FAULT;
223 }
224
225 if (pmdev->pages[i].read_vin > pmdev->pages[i].vin_ov_warn_limit) {
226 pmdev->pages[i].status_word |= PB_STATUS_INPUT;
227 pmdev->pages[i].status_input |= PB_STATUS_INPUT_VIN_OV_WARN;
228 }
229
230 if (pmdev->pages[i].read_vin < pmdev->pages[i].vin_uv_warn_limit) {
231 pmdev->pages[i].status_word |= PB_STATUS_INPUT;
232 pmdev->pages[i].status_input |= PB_STATUS_INPUT_VIN_UV_WARN;
233 }
234
235 if (pmdev->pages[i].read_iout > pmdev->pages[i].iout_oc_warn_limit) {
236 pmdev->pages[i].status_word |= PB_STATUS_IOUT_POUT;
237 pmdev->pages[i].status_iout |= PB_STATUS_IOUT_OC_WARN;
238 }
239
240 if (pmdev->pages[i].read_iout > pmdev->pages[i].iout_oc_fault_limit) {
241 pmdev->pages[i].status_word |= PB_STATUS_IOUT_POUT;
242 pmdev->pages[i].status_iout |= PB_STATUS_IOUT_OC_FAULT;
243 }
244
245 if (pmdev->pages[i].read_pin > pmdev->pages[i].pin_op_warn_limit) {
246 pmdev->pages[i].status_word |= PB_STATUS_INPUT;
247 pmdev->pages[i].status_input |= PB_STATUS_INPUT_PIN_OP_WARN;
248 }
249
250 if (pmdev->pages[i].read_temperature_1
251 > pmdev->pages[i].ot_fault_limit) {
252 pmdev->pages[i].status_word |= PB_STATUS_TEMPERATURE;
253 pmdev->pages[i].status_temperature |= PB_STATUS_OT_FAULT;
254 }
255
256 if (pmdev->pages[i].read_temperature_1
257 > pmdev->pages[i].ot_warn_limit) {
258 pmdev->pages[i].status_word |= PB_STATUS_TEMPERATURE;
259 pmdev->pages[i].status_temperature |= PB_STATUS_OT_WARN;
260 }
261 }
262 }
263
264 void pmbus_idle(PMBusDevice *pmdev)
265 {
266 pmdev->code = PMBUS_IDLE_STATE;
267 }
268
269 /* assert the status_cml error upon receipt of malformed command */
270 static void pmbus_cml_error(PMBusDevice *pmdev)
271 {
272 for (int i = 0; i < pmdev->num_pages; i++) {
273 pmdev->pages[i].status_word |= PMBUS_STATUS_CML;
274 pmdev->pages[i].status_cml |= PB_CML_FAULT_INVALID_CMD;
275 }
276 }
277
278 static uint8_t pmbus_receive_byte(SMBusDevice *smd)
279 {
280 PMBusDevice *pmdev = PMBUS_DEVICE(smd);
281 PMBusDeviceClass *pmdc = PMBUS_DEVICE_GET_CLASS(pmdev);
282 uint8_t ret = PMBUS_ERR_BYTE;
283 uint8_t index;
284
285 if (pmdev->out_buf_len != 0) {
286 ret = pmbus_out_buf_pop(pmdev);
287 return ret;
288 }
289
290 /*
291 * Reading from all pages will return the value from page 0,
292 * means that all subsequent commands are to be applied to all output.
293 */
294 if (pmdev->page == PB_ALL_PAGES) {
295 index = 0;
296 } else if (pmdev->page > pmdev->num_pages - 1) {
297 qemu_log_mask(LOG_GUEST_ERROR,
298 "%s: page %d is out of range\n",
299 __func__, pmdev->page);
300 pmbus_cml_error(pmdev);
301 return PMBUS_ERR_BYTE;
302 } else {
303 index = pmdev->page;
304 }
305
306 switch (pmdev->code) {
307 case PMBUS_PAGE:
308 pmbus_send8(pmdev, pmdev->page);
309 break;
310
311 case PMBUS_OPERATION: /* R/W byte */
312 pmbus_send8(pmdev, pmdev->pages[index].operation);
313 break;
314
315 case PMBUS_ON_OFF_CONFIG: /* R/W byte */
316 pmbus_send8(pmdev, pmdev->pages[index].on_off_config);
317 break;
318
319 case PMBUS_PHASE: /* R/W byte */
320 pmbus_send8(pmdev, pmdev->pages[index].phase);
321 break;
322
323 case PMBUS_WRITE_PROTECT: /* R/W byte */
324 pmbus_send8(pmdev, pmdev->pages[index].write_protect);
325 break;
326
327 case PMBUS_CAPABILITY:
328 pmbus_send8(pmdev, pmdev->capability);
329 if (pmdev->capability & BIT(7)) {
330 qemu_log_mask(LOG_UNIMP,
331 "%s: PEC is enabled but not yet supported.\n",
332 __func__);
333 }
334 break;
335
336 case PMBUS_VOUT_MODE: /* R/W byte */
337 if (pmdev->pages[index].page_flags & PB_HAS_VOUT_MODE) {
338 pmbus_send8(pmdev, pmdev->pages[index].vout_mode);
339 } else {
340 goto passthough;
341 }
342 break;
343
344 case PMBUS_VOUT_COMMAND: /* R/W word */
345 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
346 pmbus_send16(pmdev, pmdev->pages[index].vout_command);
347 } else {
348 goto passthough;
349 }
350 break;
351
352 case PMBUS_VOUT_TRIM: /* R/W word */
353 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
354 pmbus_send16(pmdev, pmdev->pages[index].vout_trim);
355 } else {
356 goto passthough;
357 }
358 break;
359
360 case PMBUS_VOUT_CAL_OFFSET: /* R/W word */
361 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
362 pmbus_send16(pmdev, pmdev->pages[index].vout_cal_offset);
363 } else {
364 goto passthough;
365 }
366 break;
367
368 case PMBUS_VOUT_MAX: /* R/W word */
369 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
370 pmbus_send16(pmdev, pmdev->pages[index].vout_max);
371 } else {
372 goto passthough;
373 }
374 break;
375
376 case PMBUS_VOUT_MARGIN_HIGH: /* R/W word */
377 if (pmdev->pages[index].page_flags & PB_HAS_VOUT_MARGIN) {
378 pmbus_send16(pmdev, pmdev->pages[index].vout_margin_high);
379 } else {
380 goto passthough;
381 }
382 break;
383
384 case PMBUS_VOUT_MARGIN_LOW: /* R/W word */
385 if (pmdev->pages[index].page_flags & PB_HAS_VOUT_MARGIN) {
386 pmbus_send16(pmdev, pmdev->pages[index].vout_margin_low);
387 } else {
388 goto passthough;
389 }
390 break;
391
392 case PMBUS_VOUT_TRANSITION_RATE: /* R/W word */
393 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
394 pmbus_send16(pmdev, pmdev->pages[index].vout_transition_rate);
395 } else {
396 goto passthough;
397 }
398 break;
399
400 case PMBUS_VOUT_DROOP: /* R/W word */
401 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
402 pmbus_send16(pmdev, pmdev->pages[index].vout_droop);
403 } else {
404 goto passthough;
405 }
406 break;
407
408 case PMBUS_VOUT_SCALE_LOOP: /* R/W word */
409 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
410 pmbus_send16(pmdev, pmdev->pages[index].vout_scale_loop);
411 } else {
412 goto passthough;
413 }
414 break;
415
416 case PMBUS_VOUT_SCALE_MONITOR: /* R/W word */
417 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
418 pmbus_send16(pmdev, pmdev->pages[index].vout_scale_monitor);
419 } else {
420 goto passthough;
421 }
422 break;
423
424 case PMBUS_VOUT_MIN: /* R/W word */
425 if (pmdev->pages[index].page_flags & PB_HAS_VOUT_RATING) {
426 pmbus_send16(pmdev, pmdev->pages[index].vout_min);
427 } else {
428 goto passthough;
429 }
430 break;
431
432 /* TODO: implement coefficients support */
433
434 case PMBUS_POUT_MAX: /* R/W word */
435 if (pmdev->pages[index].page_flags & PB_HAS_POUT) {
436 pmbus_send16(pmdev, pmdev->pages[index].pout_max);
437 } else {
438 goto passthough;
439 }
440 break;
441
442 case PMBUS_VIN_ON: /* R/W word */
443 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
444 pmbus_send16(pmdev, pmdev->pages[index].vin_on);
445 } else {
446 goto passthough;
447 }
448 break;
449
450 case PMBUS_VIN_OFF: /* R/W word */
451 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
452 pmbus_send16(pmdev, pmdev->pages[index].vin_off);
453 } else {
454 goto passthough;
455 }
456 break;
457
458 case PMBUS_IOUT_CAL_GAIN: /* R/W word */
459 if (pmdev->pages[index].page_flags & PB_HAS_IOUT_GAIN) {
460 pmbus_send16(pmdev, pmdev->pages[index].iout_cal_gain);
461 } else {
462 goto passthough;
463 }
464 break;
465
466 case PMBUS_VOUT_OV_FAULT_LIMIT: /* R/W word */
467 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
468 pmbus_send16(pmdev, pmdev->pages[index].vout_ov_fault_limit);
469 } else {
470 goto passthough;
471 }
472 break;
473
474 case PMBUS_VOUT_OV_FAULT_RESPONSE: /* R/W byte */
475 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
476 pmbus_send8(pmdev, pmdev->pages[index].vout_ov_fault_response);
477 } else {
478 goto passthough;
479 }
480 break;
481
482 case PMBUS_VOUT_OV_WARN_LIMIT: /* R/W word */
483 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
484 pmbus_send16(pmdev, pmdev->pages[index].vout_ov_warn_limit);
485 } else {
486 goto passthough;
487 }
488 break;
489
490 case PMBUS_VOUT_UV_WARN_LIMIT: /* R/W word */
491 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
492 pmbus_send16(pmdev, pmdev->pages[index].vout_uv_warn_limit);
493 } else {
494 goto passthough;
495 }
496 break;
497
498 case PMBUS_VOUT_UV_FAULT_LIMIT: /* R/W word */
499 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
500 pmbus_send16(pmdev, pmdev->pages[index].vout_uv_fault_limit);
501 } else {
502 goto passthough;
503 }
504 break;
505
506 case PMBUS_VOUT_UV_FAULT_RESPONSE: /* R/W byte */
507 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
508 pmbus_send8(pmdev, pmdev->pages[index].vout_uv_fault_response);
509 } else {
510 goto passthough;
511 }
512 break;
513
514 case PMBUS_IOUT_OC_FAULT_LIMIT: /* R/W word */
515 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
516 pmbus_send16(pmdev, pmdev->pages[index].iout_oc_fault_limit);
517 } else {
518 goto passthough;
519 }
520 break;
521
522 case PMBUS_IOUT_OC_FAULT_RESPONSE: /* R/W byte */
523 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
524 pmbus_send8(pmdev, pmdev->pages[index].iout_oc_fault_response);
525 } else {
526 goto passthough;
527 }
528 break;
529
530 case PMBUS_IOUT_OC_LV_FAULT_LIMIT: /* R/W word */
531 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
532 pmbus_send16(pmdev, pmdev->pages[index].iout_oc_lv_fault_limit);
533 } else {
534 goto passthough;
535 }
536 break;
537
538 case PMBUS_IOUT_OC_LV_FAULT_RESPONSE: /* R/W byte */
539 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
540 pmbus_send8(pmdev, pmdev->pages[index].iout_oc_lv_fault_response);
541 } else {
542 goto passthough;
543 }
544 break;
545
546 case PMBUS_IOUT_OC_WARN_LIMIT: /* R/W word */
547 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
548 pmbus_send16(pmdev, pmdev->pages[index].iout_oc_warn_limit);
549 } else {
550 goto passthough;
551 }
552 break;
553
554 case PMBUS_IOUT_UC_FAULT_LIMIT: /* R/W word */
555 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
556 pmbus_send16(pmdev, pmdev->pages[index].iout_uc_fault_limit);
557 } else {
558 goto passthough;
559 }
560 break;
561
562 case PMBUS_IOUT_UC_FAULT_RESPONSE: /* R/W byte */
563 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
564 pmbus_send8(pmdev, pmdev->pages[index].iout_uc_fault_response);
565 } else {
566 goto passthough;
567 }
568 break;
569
570 case PMBUS_OT_FAULT_LIMIT: /* R/W word */
571 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
572 pmbus_send16(pmdev, pmdev->pages[index].ot_fault_limit);
573 } else {
574 goto passthough;
575 }
576 break;
577
578 case PMBUS_OT_FAULT_RESPONSE: /* R/W byte */
579 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
580 pmbus_send8(pmdev, pmdev->pages[index].ot_fault_response);
581 } else {
582 goto passthough;
583 }
584 break;
585
586 case PMBUS_OT_WARN_LIMIT: /* R/W word */
587 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
588 pmbus_send16(pmdev, pmdev->pages[index].ot_warn_limit);
589 } else {
590 goto passthough;
591 }
592 break;
593
594 case PMBUS_UT_WARN_LIMIT: /* R/W word */
595 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
596 pmbus_send16(pmdev, pmdev->pages[index].ut_warn_limit);
597 } else {
598 goto passthough;
599 }
600 break;
601
602 case PMBUS_UT_FAULT_LIMIT: /* R/W word */
603 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
604 pmbus_send16(pmdev, pmdev->pages[index].ut_fault_limit);
605 } else {
606 goto passthough;
607 }
608 break;
609
610 case PMBUS_UT_FAULT_RESPONSE: /* R/W byte */
611 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
612 pmbus_send8(pmdev, pmdev->pages[index].ut_fault_response);
613 } else {
614 goto passthough;
615 }
616 break;
617
618 case PMBUS_VIN_OV_FAULT_LIMIT: /* R/W word */
619 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
620 pmbus_send16(pmdev, pmdev->pages[index].vin_ov_fault_limit);
621 } else {
622 goto passthough;
623 }
624 break;
625
626 case PMBUS_VIN_OV_FAULT_RESPONSE: /* R/W byte */
627 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
628 pmbus_send8(pmdev, pmdev->pages[index].vin_ov_fault_response);
629 } else {
630 goto passthough;
631 }
632 break;
633
634 case PMBUS_VIN_OV_WARN_LIMIT: /* R/W word */
635 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
636 pmbus_send16(pmdev, pmdev->pages[index].vin_ov_warn_limit);
637 } else {
638 goto passthough;
639 }
640 break;
641
642 case PMBUS_VIN_UV_WARN_LIMIT: /* R/W word */
643 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
644 pmbus_send16(pmdev, pmdev->pages[index].vin_uv_warn_limit);
645 } else {
646 goto passthough;
647 }
648 break;
649
650 case PMBUS_VIN_UV_FAULT_LIMIT: /* R/W word */
651 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
652 pmbus_send16(pmdev, pmdev->pages[index].vin_uv_fault_limit);
653 } else {
654 goto passthough;
655 }
656 break;
657
658 case PMBUS_VIN_UV_FAULT_RESPONSE: /* R/W byte */
659 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
660 pmbus_send8(pmdev, pmdev->pages[index].vin_uv_fault_response);
661 } else {
662 goto passthough;
663 }
664 break;
665
666 case PMBUS_IIN_OC_FAULT_LIMIT: /* R/W word */
667 if (pmdev->pages[index].page_flags & PB_HAS_IIN) {
668 pmbus_send16(pmdev, pmdev->pages[index].iin_oc_fault_limit);
669 } else {
670 goto passthough;
671 }
672 break;
673
674 case PMBUS_IIN_OC_FAULT_RESPONSE: /* R/W byte */
675 if (pmdev->pages[index].page_flags & PB_HAS_IIN) {
676 pmbus_send8(pmdev, pmdev->pages[index].iin_oc_fault_response);
677 } else {
678 goto passthough;
679 }
680 break;
681
682 case PMBUS_IIN_OC_WARN_LIMIT: /* R/W word */
683 if (pmdev->pages[index].page_flags & PB_HAS_IIN) {
684 pmbus_send16(pmdev, pmdev->pages[index].iin_oc_warn_limit);
685 } else {
686 goto passthough;
687 }
688 break;
689
690 case PMBUS_POUT_OP_FAULT_LIMIT: /* R/W word */
691 if (pmdev->pages[index].page_flags & PB_HAS_POUT) {
692 pmbus_send16(pmdev, pmdev->pages[index].pout_op_fault_limit);
693 } else {
694 goto passthough;
695 }
696 break;
697
698 case PMBUS_POUT_OP_FAULT_RESPONSE: /* R/W byte */
699 if (pmdev->pages[index].page_flags & PB_HAS_POUT) {
700 pmbus_send8(pmdev, pmdev->pages[index].pout_op_fault_response);
701 } else {
702 goto passthough;
703 }
704 break;
705
706 case PMBUS_POUT_OP_WARN_LIMIT: /* R/W word */
707 if (pmdev->pages[index].page_flags & PB_HAS_POUT) {
708 pmbus_send16(pmdev, pmdev->pages[index].pout_op_warn_limit);
709 } else {
710 goto passthough;
711 }
712 break;
713
714 case PMBUS_PIN_OP_WARN_LIMIT: /* R/W word */
715 if (pmdev->pages[index].page_flags & PB_HAS_PIN) {
716 pmbus_send16(pmdev, pmdev->pages[index].pin_op_warn_limit);
717 } else {
718 goto passthough;
719 }
720 break;
721
722 case PMBUS_STATUS_BYTE: /* R/W byte */
723 pmbus_send8(pmdev, pmdev->pages[index].status_word & 0xFF);
724 break;
725
726 case PMBUS_STATUS_WORD: /* R/W word */
727 pmbus_send16(pmdev, pmdev->pages[index].status_word);
728 break;
729
730 case PMBUS_STATUS_VOUT: /* R/W byte */
731 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
732 pmbus_send8(pmdev, pmdev->pages[index].status_vout);
733 } else {
734 goto passthough;
735 }
736 break;
737
738 case PMBUS_STATUS_IOUT: /* R/W byte */
739 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
740 pmbus_send8(pmdev, pmdev->pages[index].status_iout);
741 } else {
742 goto passthough;
743 }
744 break;
745
746 case PMBUS_STATUS_INPUT: /* R/W byte */
747 if (pmdev->pages[index].page_flags & PB_HAS_VIN ||
748 pmdev->pages[index].page_flags & PB_HAS_IIN ||
749 pmdev->pages[index].page_flags & PB_HAS_PIN) {
750 pmbus_send8(pmdev, pmdev->pages[index].status_input);
751 } else {
752 goto passthough;
753 }
754 break;
755
756 case PMBUS_STATUS_TEMPERATURE: /* R/W byte */
757 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
758 pmbus_send8(pmdev, pmdev->pages[index].status_temperature);
759 } else {
760 goto passthough;
761 }
762 break;
763
764 case PMBUS_STATUS_CML: /* R/W byte */
765 pmbus_send8(pmdev, pmdev->pages[index].status_cml);
766 break;
767
768 case PMBUS_STATUS_OTHER: /* R/W byte */
769 pmbus_send8(pmdev, pmdev->pages[index].status_other);
770 break;
771
772 case PMBUS_STATUS_MFR_SPECIFIC: /* R/W byte */
773 pmbus_send8(pmdev, pmdev->pages[index].status_mfr_specific);
774 break;
775
776 case PMBUS_READ_EIN: /* Read-Only block 5 bytes */
777 if (pmdev->pages[index].page_flags & PB_HAS_EIN) {
778 pmbus_send(pmdev, pmdev->pages[index].read_ein, 5);
779 } else {
780 goto passthough;
781 }
782 break;
783
784 case PMBUS_READ_EOUT: /* Read-Only block 5 bytes */
785 if (pmdev->pages[index].page_flags & PB_HAS_EOUT) {
786 pmbus_send(pmdev, pmdev->pages[index].read_eout, 5);
787 } else {
788 goto passthough;
789 }
790 break;
791
792 case PMBUS_READ_VIN: /* Read-Only word */
793 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
794 pmbus_send16(pmdev, pmdev->pages[index].read_vin);
795 } else {
796 goto passthough;
797 }
798 break;
799
800 case PMBUS_READ_IIN: /* Read-Only word */
801 if (pmdev->pages[index].page_flags & PB_HAS_IIN) {
802 pmbus_send16(pmdev, pmdev->pages[index].read_iin);
803 } else {
804 goto passthough;
805 }
806 break;
807
808 case PMBUS_READ_VOUT: /* Read-Only word */
809 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
810 pmbus_send16(pmdev, pmdev->pages[index].read_vout);
811 } else {
812 goto passthough;
813 }
814 break;
815
816 case PMBUS_READ_IOUT: /* Read-Only word */
817 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
818 pmbus_send16(pmdev, pmdev->pages[index].read_iout);
819 } else {
820 goto passthough;
821 }
822 break;
823
824 case PMBUS_READ_TEMPERATURE_1: /* Read-Only word */
825 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
826 pmbus_send16(pmdev, pmdev->pages[index].read_temperature_1);
827 } else {
828 goto passthough;
829 }
830 break;
831
832 case PMBUS_READ_TEMPERATURE_2: /* Read-Only word */
833 if (pmdev->pages[index].page_flags & PB_HAS_TEMP2) {
834 pmbus_send16(pmdev, pmdev->pages[index].read_temperature_2);
835 } else {
836 goto passthough;
837 }
838 break;
839
840 case PMBUS_READ_TEMPERATURE_3: /* Read-Only word */
841 if (pmdev->pages[index].page_flags & PB_HAS_TEMP3) {
842 pmbus_send16(pmdev, pmdev->pages[index].read_temperature_3);
843 } else {
844 goto passthough;
845 }
846 break;
847
848 case PMBUS_READ_POUT: /* Read-Only word */
849 if (pmdev->pages[index].page_flags & PB_HAS_POUT) {
850 pmbus_send16(pmdev, pmdev->pages[index].read_pout);
851 } else {
852 goto passthough;
853 }
854 break;
855
856 case PMBUS_READ_PIN: /* Read-Only word */
857 if (pmdev->pages[index].page_flags & PB_HAS_PIN) {
858 pmbus_send16(pmdev, pmdev->pages[index].read_pin);
859 } else {
860 goto passthough;
861 }
862 break;
863
864 case PMBUS_REVISION: /* Read-Only byte */
865 pmbus_send8(pmdev, pmdev->pages[index].revision);
866 break;
867
868 case PMBUS_MFR_ID: /* R/W block */
869 if (pmdev->pages[index].page_flags & PB_HAS_MFR_INFO) {
870 pmbus_send_string(pmdev, pmdev->pages[index].mfr_id);
871 } else {
872 goto passthough;
873 }
874 break;
875
876 case PMBUS_MFR_MODEL: /* R/W block */
877 if (pmdev->pages[index].page_flags & PB_HAS_MFR_INFO) {
878 pmbus_send_string(pmdev, pmdev->pages[index].mfr_model);
879 } else {
880 goto passthough;
881 }
882 break;
883
884 case PMBUS_MFR_REVISION: /* R/W block */
885 if (pmdev->pages[index].page_flags & PB_HAS_MFR_INFO) {
886 pmbus_send_string(pmdev, pmdev->pages[index].mfr_revision);
887 } else {
888 goto passthough;
889 }
890 break;
891
892 case PMBUS_MFR_LOCATION: /* R/W block */
893 if (pmdev->pages[index].page_flags & PB_HAS_MFR_INFO) {
894 pmbus_send_string(pmdev, pmdev->pages[index].mfr_location);
895 } else {
896 goto passthough;
897 }
898 break;
899
900 case PMBUS_MFR_VIN_MIN: /* Read-Only word */
901 if (pmdev->pages[index].page_flags & PB_HAS_VIN_RATING) {
902 pmbus_send16(pmdev, pmdev->pages[index].mfr_vin_min);
903 } else {
904 goto passthough;
905 }
906 break;
907
908 case PMBUS_MFR_VIN_MAX: /* Read-Only word */
909 if (pmdev->pages[index].page_flags & PB_HAS_VIN_RATING) {
910 pmbus_send16(pmdev, pmdev->pages[index].mfr_vin_max);
911 } else {
912 goto passthough;
913 }
914 break;
915
916 case PMBUS_MFR_IIN_MAX: /* Read-Only word */
917 if (pmdev->pages[index].page_flags & PB_HAS_IIN_RATING) {
918 pmbus_send16(pmdev, pmdev->pages[index].mfr_iin_max);
919 } else {
920 goto passthough;
921 }
922 break;
923
924 case PMBUS_MFR_PIN_MAX: /* Read-Only word */
925 if (pmdev->pages[index].page_flags & PB_HAS_PIN_RATING) {
926 pmbus_send16(pmdev, pmdev->pages[index].mfr_pin_max);
927 } else {
928 goto passthough;
929 }
930 break;
931
932 case PMBUS_MFR_VOUT_MIN: /* Read-Only word */
933 if (pmdev->pages[index].page_flags & PB_HAS_VOUT_RATING) {
934 pmbus_send16(pmdev, pmdev->pages[index].mfr_vout_min);
935 } else {
936 goto passthough;
937 }
938 break;
939
940 case PMBUS_MFR_VOUT_MAX: /* Read-Only word */
941 if (pmdev->pages[index].page_flags & PB_HAS_VOUT_RATING) {
942 pmbus_send16(pmdev, pmdev->pages[index].mfr_vout_max);
943 } else {
944 goto passthough;
945 }
946 break;
947
948 case PMBUS_MFR_IOUT_MAX: /* Read-Only word */
949 if (pmdev->pages[index].page_flags & PB_HAS_IOUT_RATING) {
950 pmbus_send16(pmdev, pmdev->pages[index].mfr_iout_max);
951 } else {
952 goto passthough;
953 }
954 break;
955
956 case PMBUS_MFR_POUT_MAX: /* Read-Only word */
957 if (pmdev->pages[index].page_flags & PB_HAS_POUT_RATING) {
958 pmbus_send16(pmdev, pmdev->pages[index].mfr_pout_max);
959 } else {
960 goto passthough;
961 }
962 break;
963
964 case PMBUS_MFR_MAX_TEMP_1: /* R/W word */
965 if (pmdev->pages[index].page_flags & PB_HAS_TEMP_RATING) {
966 pmbus_send16(pmdev, pmdev->pages[index].mfr_max_temp_1);
967 } else {
968 goto passthough;
969 }
970 break;
971
972 case PMBUS_MFR_MAX_TEMP_2: /* R/W word */
973 if (pmdev->pages[index].page_flags & PB_HAS_TEMP_RATING) {
974 pmbus_send16(pmdev, pmdev->pages[index].mfr_max_temp_2);
975 } else {
976 goto passthough;
977 }
978 break;
979
980 case PMBUS_MFR_MAX_TEMP_3: /* R/W word */
981 if (pmdev->pages[index].page_flags & PB_HAS_TEMP_RATING) {
982 pmbus_send16(pmdev, pmdev->pages[index].mfr_max_temp_3);
983 } else {
984 goto passthough;
985 }
986 break;
987
988 case PMBUS_IDLE_STATE:
989 pmbus_send8(pmdev, PMBUS_ERR_BYTE);
990 break;
991
992 case PMBUS_CLEAR_FAULTS: /* Send Byte */
993 case PMBUS_PAGE_PLUS_WRITE: /* Block Write-only */
994 case PMBUS_STORE_DEFAULT_ALL: /* Send Byte */
995 case PMBUS_RESTORE_DEFAULT_ALL: /* Send Byte */
996 case PMBUS_STORE_DEFAULT_CODE: /* Write-only Byte */
997 case PMBUS_RESTORE_DEFAULT_CODE: /* Write-only Byte */
998 case PMBUS_STORE_USER_ALL: /* Send Byte */
999 case PMBUS_RESTORE_USER_ALL: /* Send Byte */
1000 case PMBUS_STORE_USER_CODE: /* Write-only Byte */
1001 case PMBUS_RESTORE_USER_CODE: /* Write-only Byte */
1002 case PMBUS_QUERY: /* Write-Only */
1003 qemu_log_mask(LOG_GUEST_ERROR,
1004 "%s: reading from write only register 0x%02x\n",
1005 __func__, pmdev->code);
1006 break;
1007
1008 passthough:
1009 default:
1010 /* Pass through read request if not handled */
1011 if (pmdc->receive_byte) {
1012 ret = pmdc->receive_byte(pmdev);
1013 }
1014 break;
1015 }
1016
1017 if (pmdev->out_buf_len != 0) {
1018 ret = pmbus_out_buf_pop(pmdev);
1019 return ret;
1020 }
1021
1022 return ret;
1023 }
1024
1025 /*
1026 * PMBus clear faults command applies to all status registers, existing faults
1027 * should separately get re-asserted.
1028 */
1029 static void pmbus_clear_faults(PMBusDevice *pmdev)
1030 {
1031 for (uint8_t i = 0; i < pmdev->num_pages; i++) {
1032 pmdev->pages[i].status_word = 0;
1033 pmdev->pages[i].status_vout = 0;
1034 pmdev->pages[i].status_iout = 0;
1035 pmdev->pages[i].status_input = 0;
1036 pmdev->pages[i].status_temperature = 0;
1037 pmdev->pages[i].status_cml = 0;
1038 pmdev->pages[i].status_other = 0;
1039 pmdev->pages[i].status_mfr_specific = 0;
1040 pmdev->pages[i].status_fans_1_2 = 0;
1041 pmdev->pages[i].status_fans_3_4 = 0;
1042 }
1043
1044 }
1045
1046 /*
1047 * PMBus operation is used to turn On and Off PSUs
1048 * Therefore, default value for the Operation should be PB_OP_ON or 0x80
1049 */
1050 static void pmbus_operation(PMBusDevice *pmdev)
1051 {
1052 uint8_t index = pmdev->page;
1053 if ((pmdev->pages[index].operation & PB_OP_ON) == 0) {
1054 pmdev->pages[index].read_vout = 0;
1055 pmdev->pages[index].read_iout = 0;
1056 pmdev->pages[index].read_pout = 0;
1057 return;
1058 }
1059
1060 if (pmdev->pages[index].operation & (PB_OP_ON | PB_OP_MARGIN_HIGH)) {
1061 pmdev->pages[index].read_vout = pmdev->pages[index].vout_margin_high;
1062 }
1063
1064 if (pmdev->pages[index].operation & (PB_OP_ON | PB_OP_MARGIN_LOW)) {
1065 pmdev->pages[index].read_vout = pmdev->pages[index].vout_margin_low;
1066 }
1067 pmbus_check_limits(pmdev);
1068 }
1069
1070 static int pmbus_write_data(SMBusDevice *smd, uint8_t *buf, uint8_t len)
1071 {
1072 PMBusDevice *pmdev = PMBUS_DEVICE(smd);
1073 PMBusDeviceClass *pmdc = PMBUS_DEVICE_GET_CLASS(pmdev);
1074 int ret = 0;
1075 uint8_t index;
1076
1077 if (len == 0) {
1078 qemu_log_mask(LOG_GUEST_ERROR, "%s: writing empty data\n", __func__);
1079 return PMBUS_ERR_BYTE;
1080 }
1081
1082 if (!pmdev->pages) { /* allocate memory for pages on first use */
1083 pmbus_pages_alloc(pmdev);
1084 }
1085
1086 pmdev->in_buf_len = len;
1087 pmdev->in_buf = buf;
1088
1089 pmdev->code = buf[0]; /* PMBus command code */
1090 if (len == 1) { /* Single length writes are command codes only */
1091 return 0;
1092 }
1093
1094 if (pmdev->code == PMBUS_PAGE) {
1095 pmdev->page = pmbus_receive8(pmdev);
1096 return 0;
1097 }
1098
1099 /* loop through all the pages when 0xFF is received */
1100 if (pmdev->page == PB_ALL_PAGES) {
1101 for (int i = 0; i < pmdev->num_pages; i++) {
1102 pmdev->page = i;
1103 pmbus_write_data(smd, buf, len);
1104 }
1105 pmdev->page = PB_ALL_PAGES;
1106 return 0;
1107 }
1108
1109 if (pmdev->page > pmdev->num_pages - 1) {
1110 qemu_log_mask(LOG_GUEST_ERROR,
1111 "%s: page %u is out of range\n",
1112 __func__, pmdev->page);
1113 pmdev->page = 0; /* undefined behaviour - reset to page 0 */
1114 pmbus_cml_error(pmdev);
1115 return PMBUS_ERR_BYTE;
1116 }
1117
1118 index = pmdev->page;
1119
1120 switch (pmdev->code) {
1121 case PMBUS_OPERATION: /* R/W byte */
1122 pmdev->pages[index].operation = pmbus_receive8(pmdev);
1123 pmbus_operation(pmdev);
1124 break;
1125
1126 case PMBUS_ON_OFF_CONFIG: /* R/W byte */
1127 pmdev->pages[index].on_off_config = pmbus_receive8(pmdev);
1128 break;
1129
1130 case PMBUS_CLEAR_FAULTS: /* Send Byte */
1131 pmbus_clear_faults(pmdev);
1132 break;
1133
1134 case PMBUS_PHASE: /* R/W byte */
1135 pmdev->pages[index].phase = pmbus_receive8(pmdev);
1136 break;
1137
1138 case PMBUS_PAGE_PLUS_WRITE: /* Block Write-only */
1139 case PMBUS_WRITE_PROTECT: /* R/W byte */
1140 pmdev->pages[index].write_protect = pmbus_receive8(pmdev);
1141 break;
1142
1143 case PMBUS_VOUT_MODE: /* R/W byte */
1144 if (pmdev->pages[index].page_flags & PB_HAS_VOUT_MODE) {
1145 pmdev->pages[index].vout_mode = pmbus_receive8(pmdev);
1146 } else {
1147 goto passthrough;
1148 }
1149 break;
1150
1151 case PMBUS_VOUT_COMMAND: /* R/W word */
1152 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1153 pmdev->pages[index].vout_command = pmbus_receive16(pmdev);
1154 } else {
1155 goto passthrough;
1156 }
1157 break;
1158
1159 case PMBUS_VOUT_TRIM: /* R/W word */
1160 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1161 pmdev->pages[index].vout_trim = pmbus_receive16(pmdev);
1162 } else {
1163 goto passthrough;
1164 }
1165 break;
1166
1167 case PMBUS_VOUT_CAL_OFFSET: /* R/W word */
1168 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1169 pmdev->pages[index].vout_cal_offset = pmbus_receive16(pmdev);
1170 } else {
1171 goto passthrough;
1172 }
1173 break;
1174
1175 case PMBUS_VOUT_MAX: /* R/W word */
1176 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1177 pmdev->pages[index].vout_max = pmbus_receive16(pmdev);
1178 } else {
1179 goto passthrough;
1180 }
1181 break;
1182
1183 case PMBUS_VOUT_MARGIN_HIGH: /* R/W word */
1184 if (pmdev->pages[index].page_flags & PB_HAS_VOUT_MARGIN) {
1185 pmdev->pages[index].vout_margin_high = pmbus_receive16(pmdev);
1186 } else {
1187 goto passthrough;
1188 }
1189 break;
1190
1191 case PMBUS_VOUT_MARGIN_LOW: /* R/W word */
1192 if (pmdev->pages[index].page_flags & PB_HAS_VOUT_MARGIN) {
1193 pmdev->pages[index].vout_margin_low = pmbus_receive16(pmdev);
1194 } else {
1195 goto passthrough;
1196 }
1197 break;
1198
1199 case PMBUS_VOUT_TRANSITION_RATE: /* R/W word */
1200 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1201 pmdev->pages[index].vout_transition_rate = pmbus_receive16(pmdev);
1202 } else {
1203 goto passthrough;
1204 }
1205 break;
1206
1207 case PMBUS_VOUT_DROOP: /* R/W word */
1208 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1209 pmdev->pages[index].vout_droop = pmbus_receive16(pmdev);
1210 } else {
1211 goto passthrough;
1212 }
1213 break;
1214
1215 case PMBUS_VOUT_SCALE_LOOP: /* R/W word */
1216 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1217 pmdev->pages[index].vout_scale_loop = pmbus_receive16(pmdev);
1218 } else {
1219 goto passthrough;
1220 }
1221 break;
1222
1223 case PMBUS_VOUT_SCALE_MONITOR: /* R/W word */
1224 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1225 pmdev->pages[index].vout_scale_monitor = pmbus_receive16(pmdev);
1226 } else {
1227 goto passthrough;
1228 }
1229 break;
1230
1231 case PMBUS_VOUT_MIN: /* R/W word */
1232 if (pmdev->pages[index].page_flags & PB_HAS_VOUT_RATING) {
1233 pmdev->pages[index].vout_min = pmbus_receive16(pmdev);
1234 } else {
1235 goto passthrough;
1236 }
1237 break;
1238
1239 case PMBUS_POUT_MAX: /* R/W word */
1240 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1241 pmdev->pages[index].pout_max = pmbus_receive16(pmdev);
1242 } else {
1243 goto passthrough;
1244 }
1245 break;
1246
1247 case PMBUS_VIN_ON: /* R/W word */
1248 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
1249 pmdev->pages[index].vin_on = pmbus_receive16(pmdev);
1250 } else {
1251 goto passthrough;
1252 }
1253 break;
1254
1255 case PMBUS_VIN_OFF: /* R/W word */
1256 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
1257 pmdev->pages[index].vin_off = pmbus_receive16(pmdev);
1258 } else {
1259 goto passthrough;
1260 }
1261 break;
1262
1263 case PMBUS_IOUT_CAL_GAIN: /* R/W word */
1264 if (pmdev->pages[index].page_flags & PB_HAS_IOUT_GAIN) {
1265 pmdev->pages[index].iout_cal_gain = pmbus_receive16(pmdev);
1266 } else {
1267 goto passthrough;
1268 }
1269 break;
1270
1271 case PMBUS_VOUT_OV_FAULT_LIMIT: /* R/W word */
1272 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1273 pmdev->pages[index].vout_ov_fault_limit = pmbus_receive16(pmdev);
1274 } else {
1275 goto passthrough;
1276 }
1277 break;
1278
1279 case PMBUS_VOUT_OV_FAULT_RESPONSE: /* R/W byte */
1280 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1281 pmdev->pages[index].vout_ov_fault_response = pmbus_receive8(pmdev);
1282 } else {
1283 goto passthrough;
1284 }
1285 break;
1286
1287 case PMBUS_VOUT_OV_WARN_LIMIT: /* R/W word */
1288 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1289 pmdev->pages[index].vout_ov_warn_limit = pmbus_receive16(pmdev);
1290 } else {
1291 goto passthrough;
1292 }
1293 break;
1294
1295 case PMBUS_VOUT_UV_WARN_LIMIT: /* R/W word */
1296 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1297 pmdev->pages[index].vout_uv_warn_limit = pmbus_receive16(pmdev);
1298 } else {
1299 goto passthrough;
1300 }
1301 break;
1302
1303 case PMBUS_VOUT_UV_FAULT_LIMIT: /* R/W word */
1304 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1305 pmdev->pages[index].vout_uv_fault_limit = pmbus_receive16(pmdev);
1306 } else {
1307 goto passthrough;
1308 }
1309 break;
1310
1311 case PMBUS_VOUT_UV_FAULT_RESPONSE: /* R/W byte */
1312 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1313 pmdev->pages[index].vout_uv_fault_response = pmbus_receive8(pmdev);
1314 } else {
1315 goto passthrough;
1316 }
1317 break;
1318
1319 case PMBUS_IOUT_OC_FAULT_LIMIT: /* R/W word */
1320 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
1321 pmdev->pages[index].iout_oc_fault_limit = pmbus_receive16(pmdev);
1322 } else {
1323 goto passthrough;
1324 }
1325 break;
1326
1327 case PMBUS_IOUT_OC_FAULT_RESPONSE: /* R/W byte */
1328 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
1329 pmdev->pages[index].iout_oc_fault_response = pmbus_receive8(pmdev);
1330 } else {
1331 goto passthrough;
1332 }
1333 break;
1334
1335 case PMBUS_IOUT_OC_LV_FAULT_LIMIT: /* R/W word */
1336 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
1337 pmdev->pages[index].iout_oc_lv_fault_limit = pmbus_receive16(pmdev);
1338 } else {
1339 goto passthrough;
1340 }
1341 break;
1342
1343 case PMBUS_IOUT_OC_LV_FAULT_RESPONSE: /* R/W byte */
1344 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
1345 pmdev->pages[index].iout_oc_lv_fault_response
1346 = pmbus_receive8(pmdev);
1347 } else {
1348 goto passthrough;
1349 }
1350 break;
1351
1352 case PMBUS_IOUT_OC_WARN_LIMIT: /* R/W word */
1353 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
1354 pmdev->pages[index].iout_oc_warn_limit = pmbus_receive16(pmdev);
1355 } else {
1356 goto passthrough;
1357 }
1358 break;
1359
1360 case PMBUS_IOUT_UC_FAULT_LIMIT: /* R/W word */
1361 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
1362 pmdev->pages[index].iout_uc_fault_limit = pmbus_receive16(pmdev);
1363 } else {
1364 goto passthrough;
1365 }
1366 break;
1367
1368 case PMBUS_IOUT_UC_FAULT_RESPONSE: /* R/W byte */
1369 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
1370 pmdev->pages[index].iout_uc_fault_response = pmbus_receive8(pmdev);
1371 } else {
1372 goto passthrough;
1373 }
1374 break;
1375
1376 case PMBUS_OT_FAULT_LIMIT: /* R/W word */
1377 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
1378 pmdev->pages[index].ot_fault_limit = pmbus_receive16(pmdev);
1379 } else {
1380 goto passthrough;
1381 }
1382 break;
1383
1384 case PMBUS_OT_FAULT_RESPONSE: /* R/W byte */
1385 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
1386 pmdev->pages[index].ot_fault_response = pmbus_receive8(pmdev);
1387 } else {
1388 goto passthrough;
1389 }
1390 break;
1391
1392 case PMBUS_OT_WARN_LIMIT: /* R/W word */
1393 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
1394 pmdev->pages[index].ot_warn_limit = pmbus_receive16(pmdev);
1395 } else {
1396 goto passthrough;
1397 }
1398 break;
1399
1400 case PMBUS_UT_WARN_LIMIT: /* R/W word */
1401 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
1402 pmdev->pages[index].ut_warn_limit = pmbus_receive16(pmdev);
1403 } else {
1404 goto passthrough;
1405 }
1406 break;
1407
1408 case PMBUS_UT_FAULT_LIMIT: /* R/W word */
1409 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
1410 pmdev->pages[index].ut_fault_limit = pmbus_receive16(pmdev);
1411 } else {
1412 goto passthrough;
1413 }
1414 break;
1415
1416 case PMBUS_UT_FAULT_RESPONSE: /* R/W byte */
1417 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
1418 pmdev->pages[index].ut_fault_response = pmbus_receive8(pmdev);
1419 } else {
1420 goto passthrough;
1421 }
1422 break;
1423
1424 case PMBUS_VIN_OV_FAULT_LIMIT: /* R/W word */
1425 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
1426 pmdev->pages[index].vin_ov_fault_limit = pmbus_receive16(pmdev);
1427 } else {
1428 goto passthrough;
1429 }
1430 break;
1431
1432 case PMBUS_VIN_OV_FAULT_RESPONSE: /* R/W byte */
1433 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
1434 pmdev->pages[index].vin_ov_fault_response = pmbus_receive8(pmdev);
1435 } else {
1436 goto passthrough;
1437 }
1438 break;
1439
1440 case PMBUS_VIN_OV_WARN_LIMIT: /* R/W word */
1441 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
1442 pmdev->pages[index].vin_ov_warn_limit = pmbus_receive16(pmdev);
1443 } else {
1444 goto passthrough;
1445 }
1446 break;
1447
1448 case PMBUS_VIN_UV_WARN_LIMIT: /* R/W word */
1449 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
1450 pmdev->pages[index].vin_uv_warn_limit = pmbus_receive16(pmdev);
1451 } else {
1452 goto passthrough;
1453 }
1454 break;
1455
1456 case PMBUS_VIN_UV_FAULT_LIMIT: /* R/W word */
1457 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
1458 pmdev->pages[index].vin_uv_fault_limit = pmbus_receive16(pmdev);
1459 } else {
1460 goto passthrough;
1461 }
1462 break;
1463
1464 case PMBUS_VIN_UV_FAULT_RESPONSE: /* R/W byte */
1465 if (pmdev->pages[index].page_flags & PB_HAS_VIN) {
1466 pmdev->pages[index].vin_uv_fault_response = pmbus_receive8(pmdev);
1467 } else {
1468 goto passthrough;
1469 }
1470 break;
1471
1472 case PMBUS_IIN_OC_FAULT_LIMIT: /* R/W word */
1473 if (pmdev->pages[index].page_flags & PB_HAS_IIN) {
1474 pmdev->pages[index].iin_oc_fault_limit = pmbus_receive16(pmdev);
1475 } else {
1476 goto passthrough;
1477 }
1478 break;
1479
1480 case PMBUS_IIN_OC_FAULT_RESPONSE: /* R/W byte */
1481 if (pmdev->pages[index].page_flags & PB_HAS_IIN) {
1482 pmdev->pages[index].iin_oc_fault_response = pmbus_receive8(pmdev);
1483 } else {
1484 goto passthrough;
1485 }
1486 break;
1487
1488 case PMBUS_IIN_OC_WARN_LIMIT: /* R/W word */
1489 if (pmdev->pages[index].page_flags & PB_HAS_IIN) {
1490 pmdev->pages[index].iin_oc_warn_limit = pmbus_receive16(pmdev);
1491 } else {
1492 goto passthrough;
1493 }
1494 break;
1495
1496 case PMBUS_POUT_OP_FAULT_LIMIT: /* R/W word */
1497 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1498 pmdev->pages[index].pout_op_fault_limit = pmbus_receive16(pmdev);
1499 } else {
1500 goto passthrough;
1501 }
1502 break;
1503
1504 case PMBUS_POUT_OP_FAULT_RESPONSE: /* R/W byte */
1505 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1506 pmdev->pages[index].pout_op_fault_response = pmbus_receive8(pmdev);
1507 } else {
1508 goto passthrough;
1509 }
1510 break;
1511
1512 case PMBUS_POUT_OP_WARN_LIMIT: /* R/W word */
1513 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1514 pmdev->pages[index].pout_op_warn_limit = pmbus_receive16(pmdev);
1515 } else {
1516 goto passthrough;
1517 }
1518 break;
1519
1520 case PMBUS_PIN_OP_WARN_LIMIT: /* R/W word */
1521 if (pmdev->pages[index].page_flags & PB_HAS_PIN) {
1522 pmdev->pages[index].pin_op_warn_limit = pmbus_receive16(pmdev);
1523 } else {
1524 goto passthrough;
1525 }
1526 break;
1527
1528 case PMBUS_STATUS_BYTE: /* R/W byte */
1529 pmdev->pages[index].status_word = pmbus_receive8(pmdev);
1530 break;
1531
1532 case PMBUS_STATUS_WORD: /* R/W word */
1533 pmdev->pages[index].status_word = pmbus_receive16(pmdev);
1534 break;
1535
1536 case PMBUS_STATUS_VOUT: /* R/W byte */
1537 if (pmdev->pages[index].page_flags & PB_HAS_VOUT) {
1538 pmdev->pages[index].status_vout = pmbus_receive8(pmdev);
1539 } else {
1540 goto passthrough;
1541 }
1542 break;
1543
1544 case PMBUS_STATUS_IOUT: /* R/W byte */
1545 if (pmdev->pages[index].page_flags & PB_HAS_IOUT) {
1546 pmdev->pages[index].status_iout = pmbus_receive8(pmdev);
1547 } else {
1548 goto passthrough;
1549 }
1550 break;
1551
1552 case PMBUS_STATUS_INPUT: /* R/W byte */
1553 pmdev->pages[index].status_input = pmbus_receive8(pmdev);
1554 break;
1555
1556 case PMBUS_STATUS_TEMPERATURE: /* R/W byte */
1557 if (pmdev->pages[index].page_flags & PB_HAS_TEMPERATURE) {
1558 pmdev->pages[index].status_temperature = pmbus_receive8(pmdev);
1559 } else {
1560 goto passthrough;
1561 }
1562 break;
1563
1564 case PMBUS_STATUS_CML: /* R/W byte */
1565 pmdev->pages[index].status_cml = pmbus_receive8(pmdev);
1566 break;
1567
1568 case PMBUS_STATUS_OTHER: /* R/W byte */
1569 pmdev->pages[index].status_other = pmbus_receive8(pmdev);
1570 break;
1571
1572 case PMBUS_STATUS_MFR_SPECIFIC: /* R/W byte */
1573 pmdev->pages[index].status_mfr_specific = pmbus_receive8(pmdev);
1574 break;
1575
1576 case PMBUS_PAGE_PLUS_READ: /* Block Read-only */
1577 case PMBUS_CAPABILITY: /* Read-Only byte */
1578 case PMBUS_COEFFICIENTS: /* Read-only block 5 bytes */
1579 case PMBUS_READ_EIN: /* Read-Only block 5 bytes */
1580 case PMBUS_READ_EOUT: /* Read-Only block 5 bytes */
1581 case PMBUS_READ_VIN: /* Read-Only word */
1582 case PMBUS_READ_IIN: /* Read-Only word */
1583 case PMBUS_READ_VCAP: /* Read-Only word */
1584 case PMBUS_READ_VOUT: /* Read-Only word */
1585 case PMBUS_READ_IOUT: /* Read-Only word */
1586 case PMBUS_READ_TEMPERATURE_1: /* Read-Only word */
1587 case PMBUS_READ_TEMPERATURE_2: /* Read-Only word */
1588 case PMBUS_READ_TEMPERATURE_3: /* Read-Only word */
1589 case PMBUS_READ_FAN_SPEED_1: /* Read-Only word */
1590 case PMBUS_READ_FAN_SPEED_2: /* Read-Only word */
1591 case PMBUS_READ_FAN_SPEED_3: /* Read-Only word */
1592 case PMBUS_READ_FAN_SPEED_4: /* Read-Only word */
1593 case PMBUS_READ_DUTY_CYCLE: /* Read-Only word */
1594 case PMBUS_READ_FREQUENCY: /* Read-Only word */
1595 case PMBUS_READ_POUT: /* Read-Only word */
1596 case PMBUS_READ_PIN: /* Read-Only word */
1597 case PMBUS_REVISION: /* Read-Only byte */
1598 case PMBUS_APP_PROFILE_SUPPORT: /* Read-Only block-read */
1599 case PMBUS_MFR_VIN_MIN: /* Read-Only word */
1600 case PMBUS_MFR_VIN_MAX: /* Read-Only word */
1601 case PMBUS_MFR_IIN_MAX: /* Read-Only word */
1602 case PMBUS_MFR_PIN_MAX: /* Read-Only word */
1603 case PMBUS_MFR_VOUT_MIN: /* Read-Only word */
1604 case PMBUS_MFR_VOUT_MAX: /* Read-Only word */
1605 case PMBUS_MFR_IOUT_MAX: /* Read-Only word */
1606 case PMBUS_MFR_POUT_MAX: /* Read-Only word */
1607 case PMBUS_MFR_TAMBIENT_MAX: /* Read-Only word */
1608 case PMBUS_MFR_TAMBIENT_MIN: /* Read-Only word */
1609 case PMBUS_MFR_EFFICIENCY_LL: /* Read-Only block 14 bytes */
1610 case PMBUS_MFR_EFFICIENCY_HL: /* Read-Only block 14 bytes */
1611 case PMBUS_MFR_PIN_ACCURACY: /* Read-Only byte */
1612 case PMBUS_IC_DEVICE_ID: /* Read-Only block-read */
1613 case PMBUS_IC_DEVICE_REV: /* Read-Only block-read */
1614 qemu_log_mask(LOG_GUEST_ERROR,
1615 "%s: writing to read-only register 0x%02x\n",
1616 __func__, pmdev->code);
1617 break;
1618
1619 passthrough:
1620 /* Unimplimented registers get passed to the device */
1621 default:
1622 if (pmdc->write_data) {
1623 ret = pmdc->write_data(pmdev, buf, len);
1624 }
1625 break;
1626 }
1627 pmbus_check_limits(pmdev);
1628 pmdev->in_buf_len = 0;
1629 return ret;
1630 }
1631
1632 int pmbus_page_config(PMBusDevice *pmdev, uint8_t index, uint64_t flags)
1633 {
1634 if (!pmdev->pages) { /* allocate memory for pages on first use */
1635 pmbus_pages_alloc(pmdev);
1636 }
1637
1638 /* The 0xFF page is special for commands applying to all pages */
1639 if (index == PB_ALL_PAGES) {
1640 for (int i = 0; i < pmdev->num_pages; i++) {
1641 pmdev->pages[i].page_flags = flags;
1642 }
1643 return 0;
1644 }
1645
1646 if (index > pmdev->num_pages - 1) {
1647 qemu_log_mask(LOG_GUEST_ERROR,
1648 "%s: index %u is out of range\n",
1649 __func__, index);
1650 return -1;
1651 }
1652
1653 pmdev->pages[index].page_flags = flags;
1654
1655 return 0;
1656 }
1657
1658 /* TODO: include pmbus page info in vmstate */
1659 const VMStateDescription vmstate_pmbus_device = {
1660 .name = TYPE_PMBUS_DEVICE,
1661 .version_id = 0,
1662 .minimum_version_id = 0,
1663 .fields = (VMStateField[]) {
1664 VMSTATE_SMBUS_DEVICE(smb, PMBusDevice),
1665 VMSTATE_UINT8(num_pages, PMBusDevice),
1666 VMSTATE_UINT8(code, PMBusDevice),
1667 VMSTATE_UINT8(page, PMBusDevice),
1668 VMSTATE_UINT8(capability, PMBusDevice),
1669 VMSTATE_END_OF_LIST()
1670 }
1671 };
1672
1673 static void pmbus_device_finalize(Object *obj)
1674 {
1675 PMBusDevice *pmdev = PMBUS_DEVICE(obj);
1676 g_free(pmdev->pages);
1677 }
1678
1679 static void pmbus_device_class_init(ObjectClass *klass, void *data)
1680 {
1681 SMBusDeviceClass *k = SMBUS_DEVICE_CLASS(klass);
1682
1683 k->quick_cmd = pmbus_quick_cmd;
1684 k->write_data = pmbus_write_data;
1685 k->receive_byte = pmbus_receive_byte;
1686 }
1687
1688 static const TypeInfo pmbus_device_type_info = {
1689 .name = TYPE_PMBUS_DEVICE,
1690 .parent = TYPE_SMBUS_DEVICE,
1691 .instance_size = sizeof(PMBusDevice),
1692 .instance_finalize = pmbus_device_finalize,
1693 .abstract = true,
1694 .class_size = sizeof(PMBusDeviceClass),
1695 .class_init = pmbus_device_class_init,
1696 };
1697
1698 static void pmbus_device_register_types(void)
1699 {
1700 type_register_static(&pmbus_device_type_info);
1701 }
1702
1703 type_init(pmbus_device_register_types)