1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include "qemu/osdep.h"
29#include "qapi/error.h"
30#include "cpu.h"
31#include "sysemu/device_tree.h"
32#include "sysemu/runstate.h"
33
34#include "hw/ppc/fdt.h"
35#include "hw/ppc/spapr.h"
36#include "hw/ppc/spapr_vio.h"
37#include "hw/pci/pci.h"
38#include "hw/irq.h"
39#include "hw/pci-host/spapr.h"
40#include "hw/ppc/spapr_drc.h"
41#include "qemu/help_option.h"
42#include "qemu/bcd.h"
43#include "hw/ppc/spapr_ovec.h"
44#include <libfdt.h>
45
46#define RTAS_LOG_VERSION_MASK 0xff000000
47#define RTAS_LOG_VERSION_6 0x06000000
48#define RTAS_LOG_SEVERITY_MASK 0x00e00000
49#define RTAS_LOG_SEVERITY_ALREADY_REPORTED 0x00c00000
50#define RTAS_LOG_SEVERITY_FATAL 0x00a00000
51#define RTAS_LOG_SEVERITY_ERROR 0x00800000
52#define RTAS_LOG_SEVERITY_ERROR_SYNC 0x00600000
53#define RTAS_LOG_SEVERITY_WARNING 0x00400000
54#define RTAS_LOG_SEVERITY_EVENT 0x00200000
55#define RTAS_LOG_SEVERITY_NO_ERROR 0x00000000
56#define RTAS_LOG_DISPOSITION_MASK 0x00180000
57#define RTAS_LOG_DISPOSITION_FULLY_RECOVERED 0x00000000
58#define RTAS_LOG_DISPOSITION_LIMITED_RECOVERY 0x00080000
59#define RTAS_LOG_DISPOSITION_NOT_RECOVERED 0x00100000
60#define RTAS_LOG_OPTIONAL_PART_PRESENT 0x00040000
61#define RTAS_LOG_INITIATOR_MASK 0x0000f000
62#define RTAS_LOG_INITIATOR_UNKNOWN 0x00000000
63#define RTAS_LOG_INITIATOR_CPU 0x00001000
64#define RTAS_LOG_INITIATOR_PCI 0x00002000
65#define RTAS_LOG_INITIATOR_MEMORY 0x00004000
66#define RTAS_LOG_INITIATOR_HOTPLUG 0x00006000
67#define RTAS_LOG_TARGET_MASK 0x00000f00
68#define RTAS_LOG_TARGET_UNKNOWN 0x00000000
69#define RTAS_LOG_TARGET_CPU 0x00000100
70#define RTAS_LOG_TARGET_PCI 0x00000200
71#define RTAS_LOG_TARGET_MEMORY 0x00000400
72#define RTAS_LOG_TARGET_HOTPLUG 0x00000600
73#define RTAS_LOG_TYPE_MASK 0x000000ff
74#define RTAS_LOG_TYPE_OTHER 0x00000000
75#define RTAS_LOG_TYPE_RETRY 0x00000001
76#define RTAS_LOG_TYPE_TCE_ERR 0x00000002
77#define RTAS_LOG_TYPE_INTERN_DEV_FAIL 0x00000003
78#define RTAS_LOG_TYPE_TIMEOUT 0x00000004
79#define RTAS_LOG_TYPE_DATA_PARITY 0x00000005
80#define RTAS_LOG_TYPE_ADDR_PARITY 0x00000006
81#define RTAS_LOG_TYPE_CACHE_PARITY 0x00000007
82#define RTAS_LOG_TYPE_ADDR_INVALID 0x00000008
83#define RTAS_LOG_TYPE_ECC_UNCORR 0x00000009
84#define RTAS_LOG_TYPE_ECC_CORR 0x0000000a
85#define RTAS_LOG_TYPE_EPOW 0x00000040
86#define RTAS_LOG_TYPE_HOTPLUG 0x000000e5
87
88struct rtas_error_log {
89 uint32_t summary;
90 uint32_t extended_length;
91} QEMU_PACKED;
92
93struct rtas_event_log_v6 {
94 uint8_t b0;
95#define RTAS_LOG_V6_B0_VALID 0x80
96#define RTAS_LOG_V6_B0_UNRECOVERABLE_ERROR 0x40
97#define RTAS_LOG_V6_B0_RECOVERABLE_ERROR 0x20
98#define RTAS_LOG_V6_B0_DEGRADED_OPERATION 0x10
99#define RTAS_LOG_V6_B0_PREDICTIVE_ERROR 0x08
100#define RTAS_LOG_V6_B0_NEW_LOG 0x04
101#define RTAS_LOG_V6_B0_BIGENDIAN 0x02
102 uint8_t _resv1;
103 uint8_t b2;
104#define RTAS_LOG_V6_B2_POWERPC_FORMAT 0x80
105#define RTAS_LOG_V6_B2_LOG_FORMAT_MASK 0x0f
106#define RTAS_LOG_V6_B2_LOG_FORMAT_PLATFORM_EVENT 0x0e
107 uint8_t _resv2[9];
108 uint32_t company;
109#define RTAS_LOG_V6_COMPANY_IBM 0x49424d00
110} QEMU_PACKED;
111
112struct rtas_event_log_v6_section_header {
113 uint16_t section_id;
114 uint16_t section_length;
115 uint8_t section_version;
116 uint8_t section_subtype;
117 uint16_t creator_component_id;
118} QEMU_PACKED;
119
120struct rtas_event_log_v6_maina {
121#define RTAS_LOG_V6_SECTION_ID_MAINA 0x5048
122 struct rtas_event_log_v6_section_header hdr;
123 uint32_t creation_date;
124 uint32_t creation_time;
125 uint8_t _platform1[8];
126 char creator_id;
127 uint8_t _resv1[2];
128 uint8_t section_count;
129 uint8_t _resv2[4];
130 uint8_t _platform2[8];
131 uint32_t plid;
132 uint8_t _platform3[4];
133} QEMU_PACKED;
134
135struct rtas_event_log_v6_mainb {
136#define RTAS_LOG_V6_SECTION_ID_MAINB 0x5548
137 struct rtas_event_log_v6_section_header hdr;
138 uint8_t subsystem_id;
139 uint8_t _platform1;
140 uint8_t event_severity;
141 uint8_t event_subtype;
142 uint8_t _platform2[4];
143 uint8_t _resv1[2];
144 uint16_t action_flags;
145 uint8_t _resv2[4];
146} QEMU_PACKED;
147
148struct rtas_event_log_v6_epow {
149#define RTAS_LOG_V6_SECTION_ID_EPOW 0x4550
150 struct rtas_event_log_v6_section_header hdr;
151 uint8_t sensor_value;
152#define RTAS_LOG_V6_EPOW_ACTION_RESET 0
153#define RTAS_LOG_V6_EPOW_ACTION_WARN_COOLING 1
154#define RTAS_LOG_V6_EPOW_ACTION_WARN_POWER 2
155#define RTAS_LOG_V6_EPOW_ACTION_SYSTEM_SHUTDOWN 3
156#define RTAS_LOG_V6_EPOW_ACTION_SYSTEM_HALT 4
157#define RTAS_LOG_V6_EPOW_ACTION_MAIN_ENCLOSURE 5
158#define RTAS_LOG_V6_EPOW_ACTION_POWER_OFF 7
159 uint8_t event_modifier;
160#define RTAS_LOG_V6_EPOW_MODIFIER_NORMAL 1
161#define RTAS_LOG_V6_EPOW_MODIFIER_ON_UPS 2
162#define RTAS_LOG_V6_EPOW_MODIFIER_CRITICAL 3
163#define RTAS_LOG_V6_EPOW_MODIFIER_TEMPERATURE 4
164 uint8_t extended_modifier;
165#define RTAS_LOG_V6_EPOW_XMODIFIER_SYSTEM_WIDE 0
166#define RTAS_LOG_V6_EPOW_XMODIFIER_PARTITION_SPECIFIC 1
167 uint8_t _resv;
168 uint64_t reason_code;
169} QEMU_PACKED;
170
171struct epow_extended_log {
172 struct rtas_event_log_v6 v6hdr;
173 struct rtas_event_log_v6_maina maina;
174 struct rtas_event_log_v6_mainb mainb;
175 struct rtas_event_log_v6_epow epow;
176} QEMU_PACKED;
177
178union drc_identifier {
179 uint32_t index;
180 uint32_t count;
181 struct {
182 uint32_t count;
183 uint32_t index;
184 } count_indexed;
185 char name[1];
186} QEMU_PACKED;
187
188struct rtas_event_log_v6_hp {
189#define RTAS_LOG_V6_SECTION_ID_HOTPLUG 0x4850
190 struct rtas_event_log_v6_section_header hdr;
191 uint8_t hotplug_type;
192#define RTAS_LOG_V6_HP_TYPE_CPU 1
193#define RTAS_LOG_V6_HP_TYPE_MEMORY 2
194#define RTAS_LOG_V6_HP_TYPE_SLOT 3
195#define RTAS_LOG_V6_HP_TYPE_PHB 4
196#define RTAS_LOG_V6_HP_TYPE_PCI 5
197 uint8_t hotplug_action;
198#define RTAS_LOG_V6_HP_ACTION_ADD 1
199#define RTAS_LOG_V6_HP_ACTION_REMOVE 2
200 uint8_t hotplug_identifier;
201#define RTAS_LOG_V6_HP_ID_DRC_NAME 1
202#define RTAS_LOG_V6_HP_ID_DRC_INDEX 2
203#define RTAS_LOG_V6_HP_ID_DRC_COUNT 3
204#define RTAS_LOG_V6_HP_ID_DRC_COUNT_INDEXED 4
205 uint8_t reserved;
206 union drc_identifier drc_id;
207} QEMU_PACKED;
208
209struct hp_extended_log {
210 struct rtas_event_log_v6 v6hdr;
211 struct rtas_event_log_v6_maina maina;
212 struct rtas_event_log_v6_mainb mainb;
213 struct rtas_event_log_v6_hp hp;
214} QEMU_PACKED;
215
216typedef enum EventClass {
217 EVENT_CLASS_INTERNAL_ERRORS = 0,
218 EVENT_CLASS_EPOW = 1,
219 EVENT_CLASS_RESERVED = 2,
220 EVENT_CLASS_HOT_PLUG = 3,
221 EVENT_CLASS_IO = 4,
222 EVENT_CLASS_MAX
223} EventClassIndex;
224#define EVENT_CLASS_MASK(index) (1 << (31 - index))
225
226static const char * const event_names[EVENT_CLASS_MAX] = {
227 [EVENT_CLASS_INTERNAL_ERRORS] = "internal-errors",
228 [EVENT_CLASS_EPOW] = "epow-events",
229 [EVENT_CLASS_HOT_PLUG] = "hot-plug-events",
230 [EVENT_CLASS_IO] = "ibm,io-events",
231};
232
233struct SpaprEventSource {
234 int irq;
235 uint32_t mask;
236 bool enabled;
237};
238
239static SpaprEventSource *spapr_event_sources_new(void)
240{
241 return g_new0(SpaprEventSource, EVENT_CLASS_MAX);
242}
243
244static void spapr_event_sources_register(SpaprEventSource *event_sources,
245 EventClassIndex index, int irq)
246{
247
248 g_assert(event_sources);
249 g_assert(!event_sources[index].enabled);
250 event_sources[index].irq = irq;
251 event_sources[index].mask = EVENT_CLASS_MASK(index);
252 event_sources[index].enabled = true;
253}
254
255static const SpaprEventSource *
256spapr_event_sources_get_source(SpaprEventSource *event_sources,
257 EventClassIndex index)
258{
259 g_assert(index < EVENT_CLASS_MAX);
260 g_assert(event_sources);
261
262 return &event_sources[index];
263}
264
265void spapr_dt_events(SpaprMachineState *spapr, void *fdt)
266{
267 uint32_t irq_ranges[EVENT_CLASS_MAX * 2];
268 int i, count = 0, event_sources;
269 SpaprEventSource *events = spapr->event_sources;
270
271 g_assert(events);
272
273 _FDT(event_sources = fdt_add_subnode(fdt, 0, "event-sources"));
274
275 for (i = 0, count = 0; i < EVENT_CLASS_MAX; i++) {
276 int node_offset;
277 uint32_t interrupts[2];
278 const SpaprEventSource *source =
279 spapr_event_sources_get_source(events, i);
280 const char *source_name = event_names[i];
281
282 if (!source->enabled) {
283 continue;
284 }
285
286 spapr_dt_irq(interrupts, source->irq, false);
287
288 _FDT(node_offset = fdt_add_subnode(fdt, event_sources, source_name));
289 _FDT(fdt_setprop(fdt, node_offset, "interrupts", interrupts,
290 sizeof(interrupts)));
291
292 irq_ranges[count++] = interrupts[0];
293 irq_ranges[count++] = cpu_to_be32(1);
294 }
295
296 _FDT((fdt_setprop(fdt, event_sources, "interrupt-controller", NULL, 0)));
297 _FDT((fdt_setprop_cell(fdt, event_sources, "#interrupt-cells", 2)));
298 _FDT((fdt_setprop(fdt, event_sources, "interrupt-ranges",
299 irq_ranges, count * sizeof(uint32_t))));
300}
301
302static const SpaprEventSource *
303rtas_event_log_to_source(SpaprMachineState *spapr, int log_type)
304{
305 const SpaprEventSource *source;
306
307 g_assert(spapr->event_sources);
308
309 switch (log_type) {
310 case RTAS_LOG_TYPE_HOTPLUG:
311 source = spapr_event_sources_get_source(spapr->event_sources,
312 EVENT_CLASS_HOT_PLUG);
313 if (spapr_ovec_test(spapr->ov5_cas, OV5_HP_EVT)) {
314 g_assert(source->enabled);
315 break;
316 }
317
318 case RTAS_LOG_TYPE_EPOW:
319 source = spapr_event_sources_get_source(spapr->event_sources,
320 EVENT_CLASS_EPOW);
321 break;
322 default:
323 source = NULL;
324 }
325
326 return source;
327}
328
329static int rtas_event_log_to_irq(SpaprMachineState *spapr, int log_type)
330{
331 const SpaprEventSource *source;
332
333 source = rtas_event_log_to_source(spapr, log_type);
334 g_assert(source);
335 g_assert(source->enabled);
336
337 return source->irq;
338}
339
340static uint32_t spapr_event_log_entry_type(SpaprEventLogEntry *entry)
341{
342 return entry->summary & RTAS_LOG_TYPE_MASK;
343}
344
345static void rtas_event_log_queue(SpaprMachineState *spapr,
346 SpaprEventLogEntry *entry)
347{
348 QTAILQ_INSERT_TAIL(&spapr->pending_events, entry, next);
349}
350
351static SpaprEventLogEntry *rtas_event_log_dequeue(SpaprMachineState *spapr,
352 uint32_t event_mask)
353{
354 SpaprEventLogEntry *entry = NULL;
355
356 QTAILQ_FOREACH(entry, &spapr->pending_events, next) {
357 const SpaprEventSource *source =
358 rtas_event_log_to_source(spapr,
359 spapr_event_log_entry_type(entry));
360
361 g_assert(source);
362 if (source->mask & event_mask) {
363 break;
364 }
365 }
366
367 if (entry) {
368 QTAILQ_REMOVE(&spapr->pending_events, entry, next);
369 }
370
371 return entry;
372}
373
374static bool rtas_event_log_contains(uint32_t event_mask)
375{
376 SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
377 SpaprEventLogEntry *entry = NULL;
378
379 QTAILQ_FOREACH(entry, &spapr->pending_events, next) {
380 const SpaprEventSource *source =
381 rtas_event_log_to_source(spapr,
382 spapr_event_log_entry_type(entry));
383
384 if (source->mask & event_mask) {
385 return true;
386 }
387 }
388
389 return false;
390}
391
392static uint32_t next_plid;
393
394static void spapr_init_v6hdr(struct rtas_event_log_v6 *v6hdr)
395{
396 v6hdr->b0 = RTAS_LOG_V6_B0_VALID | RTAS_LOG_V6_B0_NEW_LOG
397 | RTAS_LOG_V6_B0_BIGENDIAN;
398 v6hdr->b2 = RTAS_LOG_V6_B2_POWERPC_FORMAT
399 | RTAS_LOG_V6_B2_LOG_FORMAT_PLATFORM_EVENT;
400 v6hdr->company = cpu_to_be32(RTAS_LOG_V6_COMPANY_IBM);
401}
402
403static void spapr_init_maina(struct rtas_event_log_v6_maina *maina,
404 int section_count)
405{
406 SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
407 struct tm tm;
408 int year;
409
410 maina->hdr.section_id = cpu_to_be16(RTAS_LOG_V6_SECTION_ID_MAINA);
411 maina->hdr.section_length = cpu_to_be16(sizeof(*maina));
412
413 spapr_rtc_read(&spapr->rtc, &tm, NULL);
414 year = tm.tm_year + 1900;
415 maina->creation_date = cpu_to_be32((to_bcd(year / 100) << 24)
416 | (to_bcd(year % 100) << 16)
417 | (to_bcd(tm.tm_mon + 1) << 8)
418 | to_bcd(tm.tm_mday));
419 maina->creation_time = cpu_to_be32((to_bcd(tm.tm_hour) << 24)
420 | (to_bcd(tm.tm_min) << 16)
421 | (to_bcd(tm.tm_sec) << 8));
422 maina->creator_id = 'H';
423 maina->section_count = section_count;
424 maina->plid = next_plid++;
425}
426
427static void spapr_powerdown_req(Notifier *n, void *opaque)
428{
429 SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
430 SpaprEventLogEntry *entry;
431 struct rtas_event_log_v6 *v6hdr;
432 struct rtas_event_log_v6_maina *maina;
433 struct rtas_event_log_v6_mainb *mainb;
434 struct rtas_event_log_v6_epow *epow;
435 struct epow_extended_log *new_epow;
436
437 entry = g_new(SpaprEventLogEntry, 1);
438 new_epow = g_malloc0(sizeof(*new_epow));
439 entry->extended_log = new_epow;
440
441 v6hdr = &new_epow->v6hdr;
442 maina = &new_epow->maina;
443 mainb = &new_epow->mainb;
444 epow = &new_epow->epow;
445
446 entry->summary = RTAS_LOG_VERSION_6
447 | RTAS_LOG_SEVERITY_EVENT
448 | RTAS_LOG_DISPOSITION_NOT_RECOVERED
449 | RTAS_LOG_OPTIONAL_PART_PRESENT
450 | RTAS_LOG_TYPE_EPOW;
451 entry->extended_length = sizeof(*new_epow);
452
453 spapr_init_v6hdr(v6hdr);
454 spapr_init_maina(maina, 3 );
455
456 mainb->hdr.section_id = cpu_to_be16(RTAS_LOG_V6_SECTION_ID_MAINB);
457 mainb->hdr.section_length = cpu_to_be16(sizeof(*mainb));
458
459 mainb->subsystem_id = 0xa0;
460 mainb->event_severity = 0x00;
461 mainb->event_subtype = 0xd0;
462
463 epow->hdr.section_id = cpu_to_be16(RTAS_LOG_V6_SECTION_ID_EPOW);
464 epow->hdr.section_length = cpu_to_be16(sizeof(*epow));
465 epow->hdr.section_version = 2;
466
467 epow->sensor_value = RTAS_LOG_V6_EPOW_ACTION_SYSTEM_SHUTDOWN;
468 epow->event_modifier = RTAS_LOG_V6_EPOW_MODIFIER_NORMAL;
469 epow->extended_modifier = RTAS_LOG_V6_EPOW_XMODIFIER_PARTITION_SPECIFIC;
470
471 rtas_event_log_queue(spapr, entry);
472
473 qemu_irq_pulse(spapr_qirq(spapr,
474 rtas_event_log_to_irq(spapr, RTAS_LOG_TYPE_EPOW)));
475}
476
477static void spapr_hotplug_req_event(uint8_t hp_id, uint8_t hp_action,
478 SpaprDrcType drc_type,
479 union drc_identifier *drc_id)
480{
481 SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
482 SpaprEventLogEntry *entry;
483 struct hp_extended_log *new_hp;
484 struct rtas_event_log_v6 *v6hdr;
485 struct rtas_event_log_v6_maina *maina;
486 struct rtas_event_log_v6_mainb *mainb;
487 struct rtas_event_log_v6_hp *hp;
488
489 entry = g_new(SpaprEventLogEntry, 1);
490 new_hp = g_malloc0(sizeof(struct hp_extended_log));
491 entry->extended_log = new_hp;
492
493 v6hdr = &new_hp->v6hdr;
494 maina = &new_hp->maina;
495 mainb = &new_hp->mainb;
496 hp = &new_hp->hp;
497
498 entry->summary = RTAS_LOG_VERSION_6
499 | RTAS_LOG_SEVERITY_EVENT
500 | RTAS_LOG_DISPOSITION_NOT_RECOVERED
501 | RTAS_LOG_OPTIONAL_PART_PRESENT
502 | RTAS_LOG_INITIATOR_HOTPLUG
503 | RTAS_LOG_TYPE_HOTPLUG;
504 entry->extended_length = sizeof(*new_hp);
505
506 spapr_init_v6hdr(v6hdr);
507 spapr_init_maina(maina, 3 );
508
509 mainb->hdr.section_id = cpu_to_be16(RTAS_LOG_V6_SECTION_ID_MAINB);
510 mainb->hdr.section_length = cpu_to_be16(sizeof(*mainb));
511 mainb->subsystem_id = 0x80;
512 mainb->event_severity = 0x00;
513 mainb->event_subtype = 0x00;
514
515 hp->hdr.section_id = cpu_to_be16(RTAS_LOG_V6_SECTION_ID_HOTPLUG);
516 hp->hdr.section_length = cpu_to_be16(sizeof(*hp));
517 hp->hdr.section_version = 1;
518 hp->hotplug_action = hp_action;
519 hp->hotplug_identifier = hp_id;
520
521 switch (drc_type) {
522 case SPAPR_DR_CONNECTOR_TYPE_PCI:
523 hp->hotplug_type = RTAS_LOG_V6_HP_TYPE_PCI;
524 break;
525 case SPAPR_DR_CONNECTOR_TYPE_LMB:
526 hp->hotplug_type = RTAS_LOG_V6_HP_TYPE_MEMORY;
527 break;
528 case SPAPR_DR_CONNECTOR_TYPE_CPU:
529 hp->hotplug_type = RTAS_LOG_V6_HP_TYPE_CPU;
530 break;
531 case SPAPR_DR_CONNECTOR_TYPE_PHB:
532 hp->hotplug_type = RTAS_LOG_V6_HP_TYPE_PHB;
533 break;
534 default:
535
536
537
538 g_assert(false);
539 return;
540 }
541
542 if (hp_id == RTAS_LOG_V6_HP_ID_DRC_COUNT) {
543 hp->drc_id.count = cpu_to_be32(drc_id->count);
544 } else if (hp_id == RTAS_LOG_V6_HP_ID_DRC_INDEX) {
545 hp->drc_id.index = cpu_to_be32(drc_id->index);
546 } else if (hp_id == RTAS_LOG_V6_HP_ID_DRC_COUNT_INDEXED) {
547
548
549
550 g_assert(spapr_ovec_test(spapr->ov5_cas, OV5_HP_EVT));
551 hp->drc_id.count_indexed.count =
552 cpu_to_be32(drc_id->count_indexed.count);
553 hp->drc_id.count_indexed.index =
554 cpu_to_be32(drc_id->count_indexed.index);
555 }
556
557 rtas_event_log_queue(spapr, entry);
558
559 qemu_irq_pulse(spapr_qirq(spapr,
560 rtas_event_log_to_irq(spapr, RTAS_LOG_TYPE_HOTPLUG)));
561}
562
563void spapr_hotplug_req_add_by_index(SpaprDrc *drc)
564{
565 SpaprDrcType drc_type = spapr_drc_type(drc);
566 union drc_identifier drc_id;
567
568 drc_id.index = spapr_drc_index(drc);
569 spapr_hotplug_req_event(RTAS_LOG_V6_HP_ID_DRC_INDEX,
570 RTAS_LOG_V6_HP_ACTION_ADD, drc_type, &drc_id);
571}
572
573void spapr_hotplug_req_remove_by_index(SpaprDrc *drc)
574{
575 SpaprDrcType drc_type = spapr_drc_type(drc);
576 union drc_identifier drc_id;
577
578 drc_id.index = spapr_drc_index(drc);
579 spapr_hotplug_req_event(RTAS_LOG_V6_HP_ID_DRC_INDEX,
580 RTAS_LOG_V6_HP_ACTION_REMOVE, drc_type, &drc_id);
581}
582
583void spapr_hotplug_req_add_by_count(SpaprDrcType drc_type,
584 uint32_t count)
585{
586 union drc_identifier drc_id;
587
588 drc_id.count = count;
589 spapr_hotplug_req_event(RTAS_LOG_V6_HP_ID_DRC_COUNT,
590 RTAS_LOG_V6_HP_ACTION_ADD, drc_type, &drc_id);
591}
592
593void spapr_hotplug_req_remove_by_count(SpaprDrcType drc_type,
594 uint32_t count)
595{
596 union drc_identifier drc_id;
597
598 drc_id.count = count;
599 spapr_hotplug_req_event(RTAS_LOG_V6_HP_ID_DRC_COUNT,
600 RTAS_LOG_V6_HP_ACTION_REMOVE, drc_type, &drc_id);
601}
602
603void spapr_hotplug_req_add_by_count_indexed(SpaprDrcType drc_type,
604 uint32_t count, uint32_t index)
605{
606 union drc_identifier drc_id;
607
608 drc_id.count_indexed.count = count;
609 drc_id.count_indexed.index = index;
610 spapr_hotplug_req_event(RTAS_LOG_V6_HP_ID_DRC_COUNT_INDEXED,
611 RTAS_LOG_V6_HP_ACTION_ADD, drc_type, &drc_id);
612}
613
614void spapr_hotplug_req_remove_by_count_indexed(SpaprDrcType drc_type,
615 uint32_t count, uint32_t index)
616{
617 union drc_identifier drc_id;
618
619 drc_id.count_indexed.count = count;
620 drc_id.count_indexed.index = index;
621 spapr_hotplug_req_event(RTAS_LOG_V6_HP_ID_DRC_COUNT_INDEXED,
622 RTAS_LOG_V6_HP_ACTION_REMOVE, drc_type, &drc_id);
623}
624
625static void check_exception(PowerPCCPU *cpu, SpaprMachineState *spapr,
626 uint32_t token, uint32_t nargs,
627 target_ulong args,
628 uint32_t nret, target_ulong rets)
629{
630 uint32_t mask, buf, len, event_len;
631 uint64_t xinfo;
632 SpaprEventLogEntry *event;
633 struct rtas_error_log header;
634 int i;
635
636 if ((nargs < 6) || (nargs > 7) || nret != 1) {
637 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
638 return;
639 }
640
641 xinfo = rtas_ld(args, 1);
642 mask = rtas_ld(args, 2);
643 buf = rtas_ld(args, 4);
644 len = rtas_ld(args, 5);
645 if (nargs == 7) {
646 xinfo |= (uint64_t)rtas_ld(args, 6) << 32;
647 }
648
649 event = rtas_event_log_dequeue(spapr, mask);
650 if (!event) {
651 goto out_no_events;
652 }
653
654 event_len = event->extended_length + sizeof(header);
655
656 if (event_len < len) {
657 len = event_len;
658 }
659
660 header.summary = cpu_to_be32(event->summary);
661 header.extended_length = cpu_to_be32(event->extended_length);
662 cpu_physical_memory_write(buf, &header, sizeof(header));
663 cpu_physical_memory_write(buf + sizeof(header), event->extended_log,
664 event->extended_length);
665 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
666 g_free(event->extended_log);
667 g_free(event);
668
669
670
671
672
673
674 for (i = 0; i < EVENT_CLASS_MAX; i++) {
675 if (rtas_event_log_contains(EVENT_CLASS_MASK(i))) {
676 const SpaprEventSource *source =
677 spapr_event_sources_get_source(spapr->event_sources, i);
678
679 g_assert(source->enabled);
680 qemu_irq_pulse(spapr_qirq(spapr, source->irq));
681 }
682 }
683
684 return;
685
686out_no_events:
687 rtas_st(rets, 0, RTAS_OUT_NO_ERRORS_FOUND);
688}
689
690static void event_scan(PowerPCCPU *cpu, SpaprMachineState *spapr,
691 uint32_t token, uint32_t nargs,
692 target_ulong args,
693 uint32_t nret, target_ulong rets)
694{
695 if (nargs != 4 || nret != 1) {
696 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
697 return;
698 }
699 rtas_st(rets, 0, RTAS_OUT_NO_ERRORS_FOUND);
700}
701
702void spapr_clear_pending_events(SpaprMachineState *spapr)
703{
704 SpaprEventLogEntry *entry = NULL, *next_entry;
705
706 QTAILQ_FOREACH_SAFE(entry, &spapr->pending_events, next, next_entry) {
707 QTAILQ_REMOVE(&spapr->pending_events, entry, next);
708 g_free(entry->extended_log);
709 g_free(entry);
710 }
711}
712
713void spapr_events_init(SpaprMachineState *spapr)
714{
715 int epow_irq = SPAPR_IRQ_EPOW;
716
717 if (SPAPR_MACHINE_GET_CLASS(spapr)->legacy_irq_allocation) {
718 epow_irq = spapr_irq_findone(spapr, &error_fatal);
719 }
720
721 spapr_irq_claim(spapr, epow_irq, false, &error_fatal);
722
723 QTAILQ_INIT(&spapr->pending_events);
724
725 spapr->event_sources = spapr_event_sources_new();
726
727 spapr_event_sources_register(spapr->event_sources, EVENT_CLASS_EPOW,
728 epow_irq);
729
730
731
732
733
734
735
736
737
738 if (spapr->use_hotplug_event_source) {
739 int hp_irq = SPAPR_IRQ_HOTPLUG;
740
741 if (SPAPR_MACHINE_GET_CLASS(spapr)->legacy_irq_allocation) {
742 hp_irq = spapr_irq_findone(spapr, &error_fatal);
743 }
744
745 spapr_irq_claim(spapr, hp_irq, false, &error_fatal);
746
747 spapr_event_sources_register(spapr->event_sources, EVENT_CLASS_HOT_PLUG,
748 hp_irq);
749 }
750
751 spapr->epow_notifier.notify = spapr_powerdown_req;
752 qemu_register_powerdown_notifier(&spapr->epow_notifier);
753 spapr_rtas_register(RTAS_CHECK_EXCEPTION, "check-exception",
754 check_exception);
755 spapr_rtas_register(RTAS_EVENT_SCAN, "event-scan", event_scan);
756}
757
