Merge tag 'pull-target-arm-20220809' of https://git.linaro.org/people/pmaydell/qemu...
[qemu.git] / hw / ppc / vof.c
1 /*
2 * QEMU PowerPC Virtual Open Firmware.
3 *
4 * This implements client interface from OpenFirmware IEEE1275 on the QEMU
5 * side to leave only a very basic firmware in the VM.
6 *
7 * Copyright (c) 2021 IBM Corporation.
8 *
9 * SPDX-License-Identifier: GPL-2.0-or-later
10 */
11
12 #include "qemu/osdep.h"
13 #include "qemu/timer.h"
14 #include "qemu/range.h"
15 #include "qemu/units.h"
16 #include "qemu/log.h"
17 #include "qapi/error.h"
18 #include "exec/address-spaces.h"
19 #include "hw/ppc/vof.h"
20 #include "hw/ppc/fdt.h"
21 #include "sysemu/runstate.h"
22 #include "qom/qom-qobject.h"
23 #include "trace.h"
24
25 #include <libfdt.h>
26
27 /*
28 * OF 1275 "nextprop" description suggests is it 32 bytes max but
29 * LoPAPR defines "ibm,query-interrupt-source-number" which is 33 chars long.
30 */
31 #define OF_PROPNAME_LEN_MAX 64
32
33 #define VOF_MAX_PATH 256
34 #define VOF_MAX_SETPROPLEN 2048
35 #define VOF_MAX_METHODLEN 256
36 #define VOF_MAX_FORTHCODE 256
37 #define VOF_VTY_BUF_SIZE 256
38
39 typedef struct {
40 uint64_t start;
41 uint64_t size;
42 } OfClaimed;
43
44 typedef struct {
45 char *path; /* the path used to open the instance */
46 uint32_t phandle;
47 } OfInstance;
48
49 static int readstr(hwaddr pa, char *buf, int size)
50 {
51 if (VOF_MEM_READ(pa, buf, size) != MEMTX_OK) {
52 return -1;
53 }
54 if (strnlen(buf, size) == size) {
55 buf[size - 1] = '\0';
56 trace_vof_error_str_truncated(buf, size);
57 return -1;
58 }
59 return 0;
60 }
61
62 static bool cmpservice(const char *s, unsigned nargs, unsigned nret,
63 const char *s1, unsigned nargscheck, unsigned nretcheck)
64 {
65 if (strcmp(s, s1)) {
66 return false;
67 }
68 if ((nargscheck && (nargs != nargscheck)) ||
69 (nretcheck && (nret != nretcheck))) {
70 trace_vof_error_param(s, nargscheck, nretcheck, nargs, nret);
71 return false;
72 }
73
74 return true;
75 }
76
77 static void prop_format(char *tval, int tlen, const void *prop, int len)
78 {
79 int i;
80 const unsigned char *c;
81 char *t;
82 const char bin[] = "...";
83
84 for (i = 0, c = prop; i < len; ++i, ++c) {
85 if (*c == '\0' && i == len - 1) {
86 strncpy(tval, prop, tlen - 1);
87 return;
88 }
89 if (*c < 0x20 || *c >= 0x80) {
90 break;
91 }
92 }
93
94 for (i = 0, c = prop, t = tval; i < len; ++i, ++c) {
95 if (t >= tval + tlen - sizeof(bin) - 1 - 2 - 1) {
96 strcpy(t, bin);
97 return;
98 }
99 if (i && i % 4 == 0 && i != len - 1) {
100 strcat(t, " ");
101 ++t;
102 }
103 t += sprintf(t, "%02X", *c & 0xFF);
104 }
105 }
106
107 static int get_path(const void *fdt, int offset, char *buf, int len)
108 {
109 int ret;
110
111 ret = fdt_get_path(fdt, offset, buf, len - 1);
112 if (ret < 0) {
113 return ret;
114 }
115
116 buf[len - 1] = '\0';
117
118 return strlen(buf) + 1;
119 }
120
121 static int phandle_to_path(const void *fdt, uint32_t ph, char *buf, int len)
122 {
123 int ret;
124
125 ret = fdt_node_offset_by_phandle(fdt, ph);
126 if (ret < 0) {
127 return ret;
128 }
129
130 return get_path(fdt, ret, buf, len);
131 }
132
133 static int path_offset(const void *fdt, const char *path)
134 {
135 g_autofree char *p = NULL;
136 char *at;
137
138 /*
139 * https://www.devicetree.org/open-firmware/bindings/ppc/release/ppc-2_1.html#HDR16
140 *
141 * "Conversion from numeric representation to text representation shall use
142 * the lower case forms of the hexadecimal digits in the range a..f,
143 * suppressing leading zeros".
144 */
145 p = g_strdup(path);
146 for (at = strchr(p, '@'); at && *at; ) {
147 if (*at == '/') {
148 at = strchr(at, '@');
149 } else {
150 *at = tolower(*at);
151 ++at;
152 }
153 }
154
155 return fdt_path_offset(fdt, p);
156 }
157
158 static uint32_t vof_finddevice(const void *fdt, uint32_t nodeaddr)
159 {
160 char fullnode[VOF_MAX_PATH];
161 uint32_t ret = PROM_ERROR;
162 int offset;
163
164 if (readstr(nodeaddr, fullnode, sizeof(fullnode))) {
165 return (uint32_t) ret;
166 }
167
168 offset = path_offset(fdt, fullnode);
169 if (offset >= 0) {
170 ret = fdt_get_phandle(fdt, offset);
171 }
172 trace_vof_finddevice(fullnode, ret);
173 return ret;
174 }
175
176 static const void *getprop(const void *fdt, int nodeoff, const char *propname,
177 int *proplen, bool *write0)
178 {
179 const char *unit, *prop;
180 const void *ret = fdt_getprop(fdt, nodeoff, propname, proplen);
181
182 if (ret) {
183 if (write0) {
184 *write0 = false;
185 }
186 return ret;
187 }
188
189 if (strcmp(propname, "name")) {
190 return NULL;
191 }
192 /*
193 * We return a value for "name" from path if queried but property does not
194 * exist. @proplen does not include the unit part in this case.
195 */
196 prop = fdt_get_name(fdt, nodeoff, proplen);
197 if (!prop) {
198 *proplen = 0;
199 return NULL;
200 }
201
202 unit = memchr(prop, '@', *proplen);
203 if (unit) {
204 *proplen = unit - prop;
205 }
206 *proplen += 1;
207
208 /*
209 * Since it might be cut at "@" and there will be no trailing zero
210 * in the prop buffer, tell the caller to write zero at the end.
211 */
212 if (write0) {
213 *write0 = true;
214 }
215 return prop;
216 }
217
218 static uint32_t vof_getprop(const void *fdt, uint32_t nodeph, uint32_t pname,
219 uint32_t valaddr, uint32_t vallen)
220 {
221 char propname[OF_PROPNAME_LEN_MAX + 1];
222 uint32_t ret = 0;
223 int proplen = 0;
224 const void *prop;
225 char trval[64] = "";
226 int nodeoff = fdt_node_offset_by_phandle(fdt, nodeph);
227 bool write0;
228
229 if (nodeoff < 0) {
230 return PROM_ERROR;
231 }
232 if (readstr(pname, propname, sizeof(propname))) {
233 return PROM_ERROR;
234 }
235 prop = getprop(fdt, nodeoff, propname, &proplen, &write0);
236 if (prop) {
237 const char zero = 0;
238 int cb = MIN(proplen, vallen);
239
240 if (VOF_MEM_WRITE(valaddr, prop, cb) != MEMTX_OK ||
241 /* if that was "name" with a unit address, overwrite '@' with '0' */
242 (write0 &&
243 cb == proplen &&
244 VOF_MEM_WRITE(valaddr + cb - 1, &zero, 1) != MEMTX_OK)) {
245 ret = PROM_ERROR;
246 } else {
247 /*
248 * OF1275 says:
249 * "Size is either the actual size of the property, or -1 if name
250 * does not exist", hence returning proplen instead of cb.
251 */
252 ret = proplen;
253 /* Do not format a value if tracepoint is silent, for performance */
254 if (trace_event_get_state(TRACE_VOF_GETPROP) &&
255 qemu_loglevel_mask(LOG_TRACE)) {
256 prop_format(trval, sizeof(trval), prop, ret);
257 }
258 }
259 } else {
260 ret = PROM_ERROR;
261 }
262 trace_vof_getprop(nodeph, propname, ret, trval);
263
264 return ret;
265 }
266
267 static uint32_t vof_getproplen(const void *fdt, uint32_t nodeph, uint32_t pname)
268 {
269 char propname[OF_PROPNAME_LEN_MAX + 1];
270 uint32_t ret = 0;
271 int proplen = 0;
272 const void *prop;
273 int nodeoff = fdt_node_offset_by_phandle(fdt, nodeph);
274
275 if (nodeoff < 0) {
276 return PROM_ERROR;
277 }
278 if (readstr(pname, propname, sizeof(propname))) {
279 return PROM_ERROR;
280 }
281 prop = getprop(fdt, nodeoff, propname, &proplen, NULL);
282 if (prop) {
283 ret = proplen;
284 } else {
285 ret = PROM_ERROR;
286 }
287 trace_vof_getproplen(nodeph, propname, ret);
288
289 return ret;
290 }
291
292 static uint32_t vof_setprop(MachineState *ms, void *fdt, Vof *vof,
293 uint32_t nodeph, uint32_t pname,
294 uint32_t valaddr, uint32_t vallen)
295 {
296 char propname[OF_PROPNAME_LEN_MAX + 1] = "";
297 uint32_t ret = PROM_ERROR;
298 int offset, rc;
299 char trval[64] = "";
300 char nodepath[VOF_MAX_PATH] = "";
301 Object *vmo = object_dynamic_cast(OBJECT(ms), TYPE_VOF_MACHINE_IF);
302 VofMachineIfClass *vmc;
303 g_autofree char *val = NULL;
304
305 if (vallen > VOF_MAX_SETPROPLEN) {
306 goto trace_exit;
307 }
308 if (readstr(pname, propname, sizeof(propname))) {
309 goto trace_exit;
310 }
311 offset = fdt_node_offset_by_phandle(fdt, nodeph);
312 if (offset < 0) {
313 goto trace_exit;
314 }
315 rc = get_path(fdt, offset, nodepath, sizeof(nodepath));
316 if (rc <= 0) {
317 goto trace_exit;
318 }
319
320 val = g_malloc0(vallen);
321 if (VOF_MEM_READ(valaddr, val, vallen) != MEMTX_OK) {
322 goto trace_exit;
323 }
324
325 if (!vmo) {
326 goto trace_exit;
327 }
328
329 vmc = VOF_MACHINE_GET_CLASS(vmo);
330 if (!vmc->setprop || !vmc->setprop(ms, nodepath, propname, val, vallen)) {
331 goto trace_exit;
332 }
333
334 rc = fdt_setprop(fdt, offset, propname, val, vallen);
335 if (rc) {
336 goto trace_exit;
337 }
338
339 if (trace_event_get_state(TRACE_VOF_SETPROP) &&
340 qemu_loglevel_mask(LOG_TRACE)) {
341 prop_format(trval, sizeof(trval), val, vallen);
342 }
343 ret = vallen;
344
345 trace_exit:
346 trace_vof_setprop(nodeph, propname, trval, vallen, ret);
347
348 return ret;
349 }
350
351 static uint32_t vof_nextprop(const void *fdt, uint32_t phandle,
352 uint32_t prevaddr, uint32_t nameaddr)
353 {
354 int offset, nodeoff = fdt_node_offset_by_phandle(fdt, phandle);
355 char prev[OF_PROPNAME_LEN_MAX + 1];
356 const char *tmp;
357
358 if (readstr(prevaddr, prev, sizeof(prev))) {
359 return PROM_ERROR;
360 }
361
362 fdt_for_each_property_offset(offset, fdt, nodeoff) {
363 if (!fdt_getprop_by_offset(fdt, offset, &tmp, NULL)) {
364 return 0;
365 }
366 if (prev[0] == '\0' || strcmp(prev, tmp) == 0) {
367 if (prev[0] != '\0') {
368 offset = fdt_next_property_offset(fdt, offset);
369 if (offset < 0) {
370 return 0;
371 }
372 }
373 if (!fdt_getprop_by_offset(fdt, offset, &tmp, NULL)) {
374 return 0;
375 }
376
377 if (VOF_MEM_WRITE(nameaddr, tmp, strlen(tmp) + 1) != MEMTX_OK) {
378 return PROM_ERROR;
379 }
380 return 1;
381 }
382 }
383
384 return 0;
385 }
386
387 static uint32_t vof_peer(const void *fdt, uint32_t phandle)
388 {
389 uint32_t ret = 0;
390 int rc;
391
392 if (phandle == 0) {
393 rc = fdt_path_offset(fdt, "/");
394 } else {
395 rc = fdt_next_subnode(fdt, fdt_node_offset_by_phandle(fdt, phandle));
396 }
397
398 if (rc >= 0) {
399 ret = fdt_get_phandle(fdt, rc);
400 }
401
402 return ret;
403 }
404
405 static uint32_t vof_child(const void *fdt, uint32_t phandle)
406 {
407 uint32_t ret = 0;
408 int rc = fdt_first_subnode(fdt, fdt_node_offset_by_phandle(fdt, phandle));
409
410 if (rc >= 0) {
411 ret = fdt_get_phandle(fdt, rc);
412 }
413
414 return ret;
415 }
416
417 static uint32_t vof_parent(const void *fdt, uint32_t phandle)
418 {
419 uint32_t ret = 0;
420 int rc = fdt_parent_offset(fdt, fdt_node_offset_by_phandle(fdt, phandle));
421
422 if (rc >= 0) {
423 ret = fdt_get_phandle(fdt, rc);
424 }
425
426 return ret;
427 }
428
429 static uint32_t vof_do_open(void *fdt, Vof *vof, int offset, const char *path)
430 {
431 uint32_t ret = PROM_ERROR;
432 OfInstance *inst = NULL;
433
434 if (vof->of_instance_last == 0xFFFFFFFF) {
435 /* We do not recycle ihandles yet */
436 goto trace_exit;
437 }
438
439 inst = g_new0(OfInstance, 1);
440 inst->phandle = fdt_get_phandle(fdt, offset);
441 g_assert(inst->phandle);
442 ++vof->of_instance_last;
443
444 inst->path = g_strdup(path);
445 g_hash_table_insert(vof->of_instances,
446 GINT_TO_POINTER(vof->of_instance_last),
447 inst);
448 ret = vof->of_instance_last;
449
450 trace_exit:
451 trace_vof_open(path, inst ? inst->phandle : 0, ret);
452
453 return ret;
454 }
455
456 uint32_t vof_client_open_store(void *fdt, Vof *vof, const char *nodename,
457 const char *prop, const char *path)
458 {
459 int offset, node = fdt_path_offset(fdt, nodename);
460 uint32_t inst;
461
462 offset = fdt_path_offset(fdt, path);
463 if (offset < 0) {
464 trace_vof_error_unknown_path(path);
465 return PROM_ERROR;
466 }
467
468 inst = vof_do_open(fdt, vof, offset, path);
469
470 return fdt_setprop_cell(fdt, node, prop, inst) >= 0 ? 0 : PROM_ERROR;
471 }
472
473 static uint32_t vof_open(void *fdt, Vof *vof, uint32_t pathaddr)
474 {
475 char path[VOF_MAX_PATH];
476 int offset;
477
478 if (readstr(pathaddr, path, sizeof(path))) {
479 return PROM_ERROR;
480 }
481
482 offset = path_offset(fdt, path);
483 if (offset < 0) {
484 trace_vof_error_unknown_path(path);
485 return PROM_ERROR;
486 }
487
488 return vof_do_open(fdt, vof, offset, path);
489 }
490
491 static void vof_close(Vof *vof, uint32_t ihandle)
492 {
493 if (!g_hash_table_remove(vof->of_instances, GINT_TO_POINTER(ihandle))) {
494 trace_vof_error_unknown_ihandle_close(ihandle);
495 }
496 }
497
498 static uint32_t vof_instance_to_package(Vof *vof, uint32_t ihandle)
499 {
500 gpointer instp = g_hash_table_lookup(vof->of_instances,
501 GINT_TO_POINTER(ihandle));
502 uint32_t ret = PROM_ERROR;
503
504 if (instp) {
505 ret = ((OfInstance *)instp)->phandle;
506 }
507 trace_vof_instance_to_package(ihandle, ret);
508
509 return ret;
510 }
511
512 static uint32_t vof_package_to_path(const void *fdt, uint32_t phandle,
513 uint32_t buf, uint32_t len)
514 {
515 int rc;
516 char tmp[VOF_MAX_PATH] = "";
517
518 rc = phandle_to_path(fdt, phandle, tmp, sizeof(tmp));
519 if (rc > 0) {
520 if (VOF_MEM_WRITE(buf, tmp, rc) != MEMTX_OK) {
521 rc = -1;
522 }
523 }
524
525 trace_vof_package_to_path(phandle, tmp, rc);
526
527 return rc > 0 ? (uint32_t)rc : PROM_ERROR;
528 }
529
530 static uint32_t vof_instance_to_path(void *fdt, Vof *vof, uint32_t ihandle,
531 uint32_t buf, uint32_t len)
532 {
533 int rc = -1;
534 uint32_t phandle = vof_instance_to_package(vof, ihandle);
535 char tmp[VOF_MAX_PATH] = "";
536
537 if (phandle != -1) {
538 rc = phandle_to_path(fdt, phandle, tmp, sizeof(tmp));
539 if (rc > 0) {
540 if (VOF_MEM_WRITE(buf, tmp, rc) != MEMTX_OK) {
541 rc = -1;
542 }
543 }
544 }
545 trace_vof_instance_to_path(ihandle, phandle, tmp, rc);
546
547 return rc > 0 ? (uint32_t)rc : PROM_ERROR;
548 }
549
550 static uint32_t vof_write(Vof *vof, uint32_t ihandle, uint32_t buf,
551 uint32_t len)
552 {
553 char tmp[VOF_VTY_BUF_SIZE];
554 unsigned cb;
555 OfInstance *inst = (OfInstance *)
556 g_hash_table_lookup(vof->of_instances, GINT_TO_POINTER(ihandle));
557
558 if (!inst) {
559 trace_vof_error_write(ihandle);
560 return PROM_ERROR;
561 }
562
563 for ( ; len > 0; len -= cb) {
564 cb = MIN(len, sizeof(tmp) - 1);
565 if (VOF_MEM_READ(buf, tmp, cb) != MEMTX_OK) {
566 return PROM_ERROR;
567 }
568
569 /* FIXME: there is no backend(s) yet so just call a trace */
570 if (trace_event_get_state(TRACE_VOF_WRITE) &&
571 qemu_loglevel_mask(LOG_TRACE)) {
572 tmp[cb] = '\0';
573 trace_vof_write(ihandle, cb, tmp);
574 }
575 }
576
577 return len;
578 }
579
580 static void vof_claimed_dump(GArray *claimed)
581 {
582 int i;
583 OfClaimed c;
584
585 if (trace_event_get_state(TRACE_VOF_CLAIMED) &&
586 qemu_loglevel_mask(LOG_TRACE)) {
587
588 for (i = 0; i < claimed->len; ++i) {
589 c = g_array_index(claimed, OfClaimed, i);
590 trace_vof_claimed(c.start, c.start + c.size, c.size);
591 }
592 }
593 }
594
595 static bool vof_claim_avail(GArray *claimed, uint64_t virt, uint64_t size)
596 {
597 int i;
598 OfClaimed c;
599
600 for (i = 0; i < claimed->len; ++i) {
601 c = g_array_index(claimed, OfClaimed, i);
602 if (ranges_overlap(c.start, c.size, virt, size)) {
603 return false;
604 }
605 }
606
607 return true;
608 }
609
610 static void vof_claim_add(GArray *claimed, uint64_t virt, uint64_t size)
611 {
612 OfClaimed newclaim;
613
614 newclaim.start = virt;
615 newclaim.size = size;
616 g_array_append_val(claimed, newclaim);
617 }
618
619 static gint of_claimed_compare_func(gconstpointer a, gconstpointer b)
620 {
621 return ((OfClaimed *)a)->start - ((OfClaimed *)b)->start;
622 }
623
624 static void vof_dt_memory_available(void *fdt, GArray *claimed, uint64_t base)
625 {
626 int i, n, offset, proplen = 0, sc, ac;
627 target_ulong mem0_end;
628 const uint8_t *mem0_reg;
629 g_autofree uint8_t *avail = NULL;
630 uint8_t *availcur;
631
632 if (!fdt || !claimed) {
633 return;
634 }
635
636 offset = fdt_path_offset(fdt, "/");
637 _FDT(offset);
638 ac = fdt_address_cells(fdt, offset);
639 g_assert(ac == 1 || ac == 2);
640 sc = fdt_size_cells(fdt, offset);
641 g_assert(sc == 1 || sc == 2);
642
643 offset = fdt_path_offset(fdt, "/memory@0");
644 _FDT(offset);
645
646 mem0_reg = fdt_getprop(fdt, offset, "reg", &proplen);
647 g_assert(mem0_reg && proplen == sizeof(uint32_t) * (ac + sc));
648 if (sc == 2) {
649 mem0_end = be64_to_cpu(*(uint64_t *)(mem0_reg + sizeof(uint32_t) * ac));
650 } else {
651 mem0_end = be32_to_cpu(*(uint32_t *)(mem0_reg + sizeof(uint32_t) * ac));
652 }
653
654 g_array_sort(claimed, of_claimed_compare_func);
655 vof_claimed_dump(claimed);
656
657 /*
658 * VOF resides in the first page so we do not need to check if there is
659 * available memory before the first claimed block
660 */
661 g_assert(claimed->len && (g_array_index(claimed, OfClaimed, 0).start == 0));
662
663 avail = g_malloc0(sizeof(uint32_t) * (ac + sc) * claimed->len);
664 for (i = 0, n = 0, availcur = avail; i < claimed->len; ++i) {
665 OfClaimed c = g_array_index(claimed, OfClaimed, i);
666 uint64_t start, size;
667
668 start = c.start + c.size;
669 if (i < claimed->len - 1) {
670 OfClaimed cn = g_array_index(claimed, OfClaimed, i + 1);
671
672 size = cn.start - start;
673 } else {
674 size = mem0_end - start;
675 }
676
677 if (ac == 2) {
678 *(uint64_t *) availcur = cpu_to_be64(start);
679 } else {
680 *(uint32_t *) availcur = cpu_to_be32(start);
681 }
682 availcur += sizeof(uint32_t) * ac;
683 if (sc == 2) {
684 *(uint64_t *) availcur = cpu_to_be64(size);
685 } else {
686 *(uint32_t *) availcur = cpu_to_be32(size);
687 }
688 availcur += sizeof(uint32_t) * sc;
689
690 if (size) {
691 trace_vof_avail(c.start + c.size, c.start + c.size + size, size);
692 ++n;
693 }
694 }
695 _FDT((fdt_setprop(fdt, offset, "available", avail, availcur - avail)));
696 }
697
698 /*
699 * OF1275:
700 * "Allocates size bytes of memory. If align is zero, the allocated range
701 * begins at the virtual address virt. Otherwise, an aligned address is
702 * automatically chosen and the input argument virt is ignored".
703 *
704 * In other words, exactly one of @virt and @align is non-zero.
705 */
706 uint64_t vof_claim(Vof *vof, uint64_t virt, uint64_t size,
707 uint64_t align)
708 {
709 uint64_t ret;
710
711 if (size == 0) {
712 ret = -1;
713 } else if (align == 0) {
714 if (!vof_claim_avail(vof->claimed, virt, size)) {
715 ret = -1;
716 } else {
717 ret = virt;
718 }
719 } else {
720 vof->claimed_base = QEMU_ALIGN_UP(vof->claimed_base, align);
721 while (1) {
722 if (vof->claimed_base >= vof->top_addr) {
723 error_report("Out of RMA memory for the OF client");
724 return -1;
725 }
726 if (vof_claim_avail(vof->claimed, vof->claimed_base, size)) {
727 break;
728 }
729 vof->claimed_base += size;
730 }
731 ret = vof->claimed_base;
732 }
733
734 if (ret != -1) {
735 vof->claimed_base = MAX(vof->claimed_base, ret + size);
736 vof_claim_add(vof->claimed, ret, size);
737 }
738 trace_vof_claim(virt, size, align, ret);
739
740 return ret;
741 }
742
743 static uint32_t vof_release(Vof *vof, uint64_t virt, uint64_t size)
744 {
745 uint32_t ret = PROM_ERROR;
746 int i;
747 GArray *claimed = vof->claimed;
748 OfClaimed c;
749
750 for (i = 0; i < claimed->len; ++i) {
751 c = g_array_index(claimed, OfClaimed, i);
752 if (c.start == virt && c.size == size) {
753 g_array_remove_index(claimed, i);
754 ret = 0;
755 break;
756 }
757 }
758
759 trace_vof_release(virt, size, ret);
760
761 return ret;
762 }
763
764 static void vof_instantiate_rtas(Error **errp)
765 {
766 error_setg(errp, "The firmware should have instantiated RTAS");
767 }
768
769 static uint32_t vof_call_method(MachineState *ms, Vof *vof, uint32_t methodaddr,
770 uint32_t ihandle, uint32_t param1,
771 uint32_t param2, uint32_t param3,
772 uint32_t param4, uint32_t *ret2)
773 {
774 uint32_t ret = PROM_ERROR;
775 char method[VOF_MAX_METHODLEN] = "";
776 OfInstance *inst;
777
778 if (!ihandle) {
779 goto trace_exit;
780 }
781
782 inst = (OfInstance *)g_hash_table_lookup(vof->of_instances,
783 GINT_TO_POINTER(ihandle));
784 if (!inst) {
785 goto trace_exit;
786 }
787
788 if (readstr(methodaddr, method, sizeof(method))) {
789 goto trace_exit;
790 }
791
792 if (strcmp(inst->path, "/") == 0) {
793 if (strcmp(method, "ibm,client-architecture-support") == 0) {
794 Object *vmo = object_dynamic_cast(OBJECT(ms), TYPE_VOF_MACHINE_IF);
795
796 if (vmo) {
797 VofMachineIfClass *vmc = VOF_MACHINE_GET_CLASS(vmo);
798
799 g_assert(vmc->client_architecture_support);
800 ret = (uint32_t)vmc->client_architecture_support(ms, first_cpu,
801 param1);
802 }
803
804 *ret2 = 0;
805 }
806 } else if (strcmp(inst->path, "/rtas") == 0) {
807 if (strcmp(method, "instantiate-rtas") == 0) {
808 vof_instantiate_rtas(&error_fatal);
809 ret = 0;
810 *ret2 = param1; /* rtas-base */
811 }
812 } else {
813 trace_vof_error_unknown_method(method);
814 }
815
816 trace_exit:
817 trace_vof_method(ihandle, method, param1, ret, *ret2);
818
819 return ret;
820 }
821
822 static uint32_t vof_call_interpret(uint32_t cmdaddr, uint32_t param1,
823 uint32_t param2, uint32_t *ret2)
824 {
825 uint32_t ret = PROM_ERROR;
826 char cmd[VOF_MAX_FORTHCODE] = "";
827
828 /* No interpret implemented so just call a trace */
829 readstr(cmdaddr, cmd, sizeof(cmd));
830 trace_vof_interpret(cmd, param1, param2, ret, *ret2);
831
832 return ret;
833 }
834
835 static void vof_quiesce(MachineState *ms, void *fdt, Vof *vof)
836 {
837 Object *vmo = object_dynamic_cast(OBJECT(ms), TYPE_VOF_MACHINE_IF);
838 /* After "quiesce", no change is expected to the FDT, pack FDT to ensure */
839 int rc = fdt_pack(fdt);
840
841 assert(rc == 0);
842
843 if (vmo) {
844 VofMachineIfClass *vmc = VOF_MACHINE_GET_CLASS(vmo);
845
846 if (vmc->quiesce) {
847 vmc->quiesce(ms);
848 }
849 }
850
851 vof_claimed_dump(vof->claimed);
852 }
853
854 static uint32_t vof_client_handle(MachineState *ms, void *fdt, Vof *vof,
855 const char *service,
856 uint32_t *args, unsigned nargs,
857 uint32_t *rets, unsigned nrets)
858 {
859 uint32_t ret = 0;
860
861 /* @nrets includes the value which this function returns */
862 #define cmpserv(s, a, r) \
863 cmpservice(service, nargs, nrets, (s), (a), (r))
864
865 if (cmpserv("finddevice", 1, 1)) {
866 ret = vof_finddevice(fdt, args[0]);
867 } else if (cmpserv("getprop", 4, 1)) {
868 ret = vof_getprop(fdt, args[0], args[1], args[2], args[3]);
869 } else if (cmpserv("getproplen", 2, 1)) {
870 ret = vof_getproplen(fdt, args[0], args[1]);
871 } else if (cmpserv("setprop", 4, 1)) {
872 ret = vof_setprop(ms, fdt, vof, args[0], args[1], args[2], args[3]);
873 } else if (cmpserv("nextprop", 3, 1)) {
874 ret = vof_nextprop(fdt, args[0], args[1], args[2]);
875 } else if (cmpserv("peer", 1, 1)) {
876 ret = vof_peer(fdt, args[0]);
877 } else if (cmpserv("child", 1, 1)) {
878 ret = vof_child(fdt, args[0]);
879 } else if (cmpserv("parent", 1, 1)) {
880 ret = vof_parent(fdt, args[0]);
881 } else if (cmpserv("open", 1, 1)) {
882 ret = vof_open(fdt, vof, args[0]);
883 } else if (cmpserv("close", 1, 0)) {
884 vof_close(vof, args[0]);
885 } else if (cmpserv("instance-to-package", 1, 1)) {
886 ret = vof_instance_to_package(vof, args[0]);
887 } else if (cmpserv("package-to-path", 3, 1)) {
888 ret = vof_package_to_path(fdt, args[0], args[1], args[2]);
889 } else if (cmpserv("instance-to-path", 3, 1)) {
890 ret = vof_instance_to_path(fdt, vof, args[0], args[1], args[2]);
891 } else if (cmpserv("write", 3, 1)) {
892 ret = vof_write(vof, args[0], args[1], args[2]);
893 } else if (cmpserv("claim", 3, 1)) {
894 uint64_t ret64 = vof_claim(vof, args[0], args[1], args[2]);
895
896 if (ret64 < 0x100000000UL) {
897 vof_dt_memory_available(fdt, vof->claimed, vof->claimed_base);
898 ret = (uint32_t)ret64;
899 } else {
900 if (ret64 != -1) {
901 vof_release(vof, ret, args[1]);
902 }
903 ret = PROM_ERROR;
904 }
905 } else if (cmpserv("release", 2, 0)) {
906 ret = vof_release(vof, args[0], args[1]);
907 if (ret != PROM_ERROR) {
908 vof_dt_memory_available(fdt, vof->claimed, vof->claimed_base);
909 }
910 } else if (cmpserv("call-method", 0, 0)) {
911 ret = vof_call_method(ms, vof, args[0], args[1], args[2], args[3],
912 args[4], args[5], rets);
913 } else if (cmpserv("interpret", 0, 0)) {
914 ret = vof_call_interpret(args[0], args[1], args[2], rets);
915 } else if (cmpserv("milliseconds", 0, 1)) {
916 ret = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL);
917 } else if (cmpserv("quiesce", 0, 0)) {
918 vof_quiesce(ms, fdt, vof);
919 } else if (cmpserv("exit", 0, 0)) {
920 error_report("Stopped as the VM requested \"exit\"");
921 vm_stop(RUN_STATE_PAUSED);
922 } else {
923 trace_vof_error_unknown_service(service, nargs, nrets);
924 ret = -1;
925 }
926
927 #undef cmpserv
928
929 return ret;
930 }
931
932 /* Defined as Big Endian */
933 struct prom_args {
934 uint32_t service;
935 uint32_t nargs;
936 uint32_t nret;
937 uint32_t args[10];
938 } QEMU_PACKED;
939
940 int vof_client_call(MachineState *ms, Vof *vof, void *fdt,
941 target_ulong args_real)
942 {
943 struct prom_args args_be;
944 uint32_t args[ARRAY_SIZE(args_be.args)];
945 uint32_t rets[ARRAY_SIZE(args_be.args)] = { 0 }, ret;
946 char service[64];
947 unsigned nargs, nret, i;
948
949 if (VOF_MEM_READ(args_real, &args_be, sizeof(args_be)) != MEMTX_OK) {
950 return -EINVAL;
951 }
952 nargs = be32_to_cpu(args_be.nargs);
953 if (nargs >= ARRAY_SIZE(args_be.args)) {
954 return -EINVAL;
955 }
956
957 if (VOF_MEM_READ(be32_to_cpu(args_be.service), service, sizeof(service)) !=
958 MEMTX_OK) {
959 return -EINVAL;
960 }
961 if (strnlen(service, sizeof(service)) == sizeof(service)) {
962 /* Too long service name */
963 return -EINVAL;
964 }
965
966 for (i = 0; i < nargs; ++i) {
967 args[i] = be32_to_cpu(args_be.args[i]);
968 }
969
970 nret = be32_to_cpu(args_be.nret);
971 if (nret > ARRAY_SIZE(args_be.args) - nargs) {
972 return -EINVAL;
973 }
974 ret = vof_client_handle(ms, fdt, vof, service, args, nargs, rets, nret);
975 if (!nret) {
976 return 0;
977 }
978
979 /* @nrets includes the value which this function returns */
980 args_be.args[nargs] = cpu_to_be32(ret);
981 for (i = 1; i < nret; ++i) {
982 args_be.args[nargs + i] = cpu_to_be32(rets[i - 1]);
983 }
984
985 if (VOF_MEM_WRITE(args_real + offsetof(struct prom_args, args[nargs]),
986 args_be.args + nargs, sizeof(args_be.args[0]) * nret) !=
987 MEMTX_OK) {
988 return -EINVAL;
989 }
990
991 return 0;
992 }
993
994 static void vof_instance_free(gpointer data)
995 {
996 OfInstance *inst = (OfInstance *)data;
997
998 g_free(inst->path);
999 g_free(inst);
1000 }
1001
1002 void vof_init(Vof *vof, uint64_t top_addr, Error **errp)
1003 {
1004 vof_cleanup(vof);
1005
1006 vof->of_instances = g_hash_table_new_full(g_direct_hash, g_direct_equal,
1007 NULL, vof_instance_free);
1008 vof->claimed = g_array_new(false, false, sizeof(OfClaimed));
1009
1010 /* Keep allocations in 32bit as CLI ABI can only return cells==32bit */
1011 vof->top_addr = MIN(top_addr, 4 * GiB);
1012 if (vof_claim(vof, 0, vof->fw_size, 0) == -1) {
1013 error_setg(errp, "Memory for firmware is in use");
1014 }
1015 }
1016
1017 void vof_cleanup(Vof *vof)
1018 {
1019 if (vof->claimed) {
1020 g_array_unref(vof->claimed);
1021 }
1022 if (vof->of_instances) {
1023 g_hash_table_unref(vof->of_instances);
1024 }
1025 vof->claimed = NULL;
1026 vof->of_instances = NULL;
1027 }
1028
1029 void vof_build_dt(void *fdt, Vof *vof)
1030 {
1031 uint32_t phandle = fdt_get_max_phandle(fdt);
1032 int offset, proplen = 0;
1033 const void *prop;
1034
1035 /* Assign phandles to nodes without predefined phandles (like XICS/XIVE) */
1036 for (offset = fdt_next_node(fdt, -1, NULL);
1037 offset >= 0;
1038 offset = fdt_next_node(fdt, offset, NULL)) {
1039 prop = fdt_getprop(fdt, offset, "phandle", &proplen);
1040 if (prop) {
1041 continue;
1042 }
1043 ++phandle;
1044 _FDT(fdt_setprop_cell(fdt, offset, "phandle", phandle));
1045 }
1046
1047 vof_dt_memory_available(fdt, vof->claimed, vof->claimed_base);
1048 }
1049
1050 static const TypeInfo vof_machine_if_info = {
1051 .name = TYPE_VOF_MACHINE_IF,
1052 .parent = TYPE_INTERFACE,
1053 .class_size = sizeof(VofMachineIfClass),
1054 };
1055
1056 static void vof_machine_if_register_types(void)
1057 {
1058 type_register_static(&vof_machine_if_info);
1059 }
1060 type_init(vof_machine_if_register_types)