xref: /openbmc/qemu/hw/cxl/cxl-mailbox-utils.c (revision 55339361)
1 /*
2  * CXL Utility library for mailbox interface
3  *
4  * Copyright(C) 2020 Intel Corporation.
5  *
6  * This work is licensed under the terms of the GNU GPL, version 2. See the
7  * COPYING file in the top-level directory.
8  */
9 
10 #include "qemu/osdep.h"
11 #include "hw/pci/msi.h"
12 #include "hw/pci/msix.h"
13 #include "hw/cxl/cxl.h"
14 #include "hw/cxl/cxl_events.h"
15 #include "hw/pci/pci.h"
16 #include "hw/pci-bridge/cxl_upstream_port.h"
17 #include "qemu/cutils.h"
18 #include "qemu/log.h"
19 #include "qemu/units.h"
20 #include "qemu/uuid.h"
21 #include "sysemu/hostmem.h"
22 
23 #define CXL_CAPACITY_MULTIPLIER   (256 * MiB)
24 
25 /*
26  * How to add a new command, example. The command set FOO, with cmd BAR.
27  *  1. Add the command set and cmd to the enum.
28  *     FOO    = 0x7f,
29  *          #define BAR 0
30  *  2. Implement the handler
31  *    static CXLRetCode cmd_foo_bar(struct cxl_cmd *cmd,
32  *                                  CXLDeviceState *cxl_dstate, uint16_t *len)
33  *  3. Add the command to the cxl_cmd_set[][]
34  *    [FOO][BAR] = { "FOO_BAR", cmd_foo_bar, x, y },
35  *  4. Implement your handler
36  *     define_mailbox_handler(FOO_BAR) { ... return CXL_MBOX_SUCCESS; }
37  *
38  *
39  *  Writing the handler:
40  *    The handler will provide the &struct cxl_cmd, the &CXLDeviceState, and the
41  *    in/out length of the payload. The handler is responsible for consuming the
42  *    payload from cmd->payload and operating upon it as necessary. It must then
43  *    fill the output data into cmd->payload (overwriting what was there),
44  *    setting the length, and returning a valid return code.
45  *
46  *  XXX: The handler need not worry about endianness. The payload is read out of
47  *  a register interface that already deals with it.
48  */
49 
50 enum {
51     INFOSTAT    = 0x00,
52         #define IS_IDENTIFY   0x1
53         #define BACKGROUND_OPERATION_STATUS    0x2
54     EVENTS      = 0x01,
55         #define GET_RECORDS   0x0
56         #define CLEAR_RECORDS   0x1
57         #define GET_INTERRUPT_POLICY   0x2
58         #define SET_INTERRUPT_POLICY   0x3
59     FIRMWARE_UPDATE = 0x02,
60         #define GET_INFO      0x0
61     TIMESTAMP   = 0x03,
62         #define GET           0x0
63         #define SET           0x1
64     LOGS        = 0x04,
65         #define GET_SUPPORTED 0x0
66         #define GET_LOG       0x1
67     IDENTIFY    = 0x40,
68         #define MEMORY_DEVICE 0x0
69     CCLS        = 0x41,
70         #define GET_PARTITION_INFO     0x0
71         #define GET_LSA       0x2
72         #define SET_LSA       0x3
73     SANITIZE    = 0x44,
74         #define OVERWRITE     0x0
75         #define SECURE_ERASE  0x1
76     PERSISTENT_MEM = 0x45,
77         #define GET_SECURITY_STATE     0x0
78     MEDIA_AND_POISON = 0x43,
79         #define GET_POISON_LIST        0x0
80         #define INJECT_POISON          0x1
81         #define CLEAR_POISON           0x2
82     PHYSICAL_SWITCH = 0x51,
83         #define IDENTIFY_SWITCH_DEVICE      0x0
84         #define GET_PHYSICAL_PORT_STATE     0x1
85     TUNNEL = 0x53,
86         #define MANAGEMENT_COMMAND     0x0
87 };
88 
89 /* CCI Message Format CXL r3.0 Figure 7-19 */
90 typedef struct CXLCCIMessage {
91     uint8_t category;
92 #define CXL_CCI_CAT_REQ 0
93 #define CXL_CCI_CAT_RSP 1
94     uint8_t tag;
95     uint8_t resv1;
96     uint8_t command;
97     uint8_t command_set;
98     uint8_t pl_length[3];
99     uint16_t rc;
100     uint16_t vendor_specific;
101     uint8_t payload[];
102 } QEMU_PACKED CXLCCIMessage;
103 
104 /* This command is only defined to an MLD FM Owned LD or an MHD */
105 static CXLRetCode cmd_tunnel_management_cmd(const struct cxl_cmd *cmd,
106                                             uint8_t *payload_in,
107                                             size_t len_in,
108                                             uint8_t *payload_out,
109                                             size_t *len_out,
110                                             CXLCCI *cci)
111 {
112     PCIDevice *tunnel_target;
113     CXLCCI *target_cci;
114     struct {
115         uint8_t port_or_ld_id;
116         uint8_t target_type;
117         uint16_t size;
118         CXLCCIMessage ccimessage;
119     } QEMU_PACKED *in;
120     struct {
121         uint16_t resp_len;
122         uint8_t resv[2];
123         CXLCCIMessage ccimessage;
124     } QEMU_PACKED *out;
125     size_t pl_length, length_out;
126     bool bg_started;
127     int rc;
128 
129     if (cmd->in < sizeof(*in)) {
130         return CXL_MBOX_INVALID_INPUT;
131     }
132     in = (void *)payload_in;
133     out = (void *)payload_out;
134 
135     /* Enough room for minimum sized message - no payload */
136     if (in->size < sizeof(in->ccimessage)) {
137         return CXL_MBOX_INVALID_PAYLOAD_LENGTH;
138     }
139     /* Length of input payload should be in->size + a wrapping tunnel header */
140     if (in->size != len_in - offsetof(typeof(*out), ccimessage)) {
141         return CXL_MBOX_INVALID_PAYLOAD_LENGTH;
142     }
143     if (in->ccimessage.category != CXL_CCI_CAT_REQ) {
144         return CXL_MBOX_INVALID_INPUT;
145     }
146 
147     if (in->target_type != 0) {
148         qemu_log_mask(LOG_UNIMP,
149                       "Tunneled Command sent to non existent FM-LD");
150         return CXL_MBOX_INVALID_INPUT;
151     }
152 
153     /*
154      * Target of a tunnel unfortunately depends on type of CCI readint
155      * the message.
156      * If in a switch, then it's the port number.
157      * If in an MLD it is the ld number.
158      * If in an MHD target type indicate where we are going.
159      */
160     if (object_dynamic_cast(OBJECT(cci->d), TYPE_CXL_TYPE3)) {
161         CXLType3Dev *ct3d = CXL_TYPE3(cci->d);
162         if (in->port_or_ld_id != 0) {
163             /* Only pretending to have one for now! */
164             return CXL_MBOX_INVALID_INPUT;
165         }
166         target_cci = &ct3d->ld0_cci;
167     } else if (object_dynamic_cast(OBJECT(cci->d), TYPE_CXL_USP)) {
168         CXLUpstreamPort *usp = CXL_USP(cci->d);
169 
170         tunnel_target = pcie_find_port_by_pn(&PCI_BRIDGE(usp)->sec_bus,
171                                              in->port_or_ld_id);
172         if (!tunnel_target) {
173             return CXL_MBOX_INVALID_INPUT;
174         }
175         tunnel_target =
176             pci_bridge_get_sec_bus(PCI_BRIDGE(tunnel_target))->devices[0];
177         if (!tunnel_target) {
178             return CXL_MBOX_INVALID_INPUT;
179         }
180         if (object_dynamic_cast(OBJECT(tunnel_target), TYPE_CXL_TYPE3)) {
181             CXLType3Dev *ct3d = CXL_TYPE3(tunnel_target);
182             /* Tunneled VDMs always land on FM Owned LD */
183             target_cci = &ct3d->vdm_fm_owned_ld_mctp_cci;
184         } else {
185             return CXL_MBOX_INVALID_INPUT;
186         }
187     } else {
188         return CXL_MBOX_INVALID_INPUT;
189     }
190 
191     pl_length = in->ccimessage.pl_length[2] << 16 |
192         in->ccimessage.pl_length[1] << 8 | in->ccimessage.pl_length[0];
193     rc = cxl_process_cci_message(target_cci,
194                                  in->ccimessage.command_set,
195                                  in->ccimessage.command,
196                                  pl_length, in->ccimessage.payload,
197                                  &length_out, out->ccimessage.payload,
198                                  &bg_started);
199     /* Payload should be in place. Rest of CCI header and needs filling */
200     out->resp_len = length_out + sizeof(CXLCCIMessage);
201     st24_le_p(out->ccimessage.pl_length, length_out);
202     out->ccimessage.rc = rc;
203     out->ccimessage.category = CXL_CCI_CAT_RSP;
204     out->ccimessage.command = in->ccimessage.command;
205     out->ccimessage.command_set = in->ccimessage.command_set;
206     out->ccimessage.tag = in->ccimessage.tag;
207     *len_out = length_out + sizeof(*out);
208 
209     return CXL_MBOX_SUCCESS;
210 }
211 
212 static CXLRetCode cmd_events_get_records(const struct cxl_cmd *cmd,
213                                          uint8_t *payload_in, size_t len_in,
214                                          uint8_t *payload_out, size_t *len_out,
215                                          CXLCCI *cci)
216 {
217     CXLDeviceState *cxlds = &CXL_TYPE3(cci->d)->cxl_dstate;
218     CXLGetEventPayload *pl;
219     uint8_t log_type;
220     int max_recs;
221 
222     if (cmd->in < sizeof(log_type)) {
223         return CXL_MBOX_INVALID_INPUT;
224     }
225 
226     log_type = payload_in[0];
227 
228     pl = (CXLGetEventPayload *)payload_out;
229     memset(pl, 0, sizeof(*pl));
230 
231     max_recs = (cxlds->payload_size - CXL_EVENT_PAYLOAD_HDR_SIZE) /
232                 CXL_EVENT_RECORD_SIZE;
233     if (max_recs > 0xFFFF) {
234         max_recs = 0xFFFF;
235     }
236 
237     return cxl_event_get_records(cxlds, pl, log_type, max_recs, len_out);
238 }
239 
240 static CXLRetCode cmd_events_clear_records(const struct cxl_cmd *cmd,
241                                            uint8_t *payload_in,
242                                            size_t len_in,
243                                            uint8_t *payload_out,
244                                            size_t *len_out,
245                                            CXLCCI *cci)
246 {
247     CXLDeviceState *cxlds = &CXL_TYPE3(cci->d)->cxl_dstate;
248     CXLClearEventPayload *pl;
249 
250     pl = (CXLClearEventPayload *)payload_in;
251     *len_out = 0;
252     return cxl_event_clear_records(cxlds, pl);
253 }
254 
255 static CXLRetCode cmd_events_get_interrupt_policy(const struct cxl_cmd *cmd,
256                                                   uint8_t *payload_in,
257                                                   size_t len_in,
258                                                   uint8_t *payload_out,
259                                                   size_t *len_out,
260                                                   CXLCCI *cci)
261 {
262     CXLDeviceState *cxlds = &CXL_TYPE3(cci->d)->cxl_dstate;
263     CXLEventInterruptPolicy *policy;
264     CXLEventLog *log;
265 
266     policy = (CXLEventInterruptPolicy *)payload_out;
267     memset(policy, 0, sizeof(*policy));
268 
269     log = &cxlds->event_logs[CXL_EVENT_TYPE_INFO];
270     if (log->irq_enabled) {
271         policy->info_settings = CXL_EVENT_INT_SETTING(log->irq_vec);
272     }
273 
274     log = &cxlds->event_logs[CXL_EVENT_TYPE_WARN];
275     if (log->irq_enabled) {
276         policy->warn_settings = CXL_EVENT_INT_SETTING(log->irq_vec);
277     }
278 
279     log = &cxlds->event_logs[CXL_EVENT_TYPE_FAIL];
280     if (log->irq_enabled) {
281         policy->failure_settings = CXL_EVENT_INT_SETTING(log->irq_vec);
282     }
283 
284     log = &cxlds->event_logs[CXL_EVENT_TYPE_FATAL];
285     if (log->irq_enabled) {
286         policy->fatal_settings = CXL_EVENT_INT_SETTING(log->irq_vec);
287     }
288 
289     log = &cxlds->event_logs[CXL_EVENT_TYPE_DYNAMIC_CAP];
290     if (log->irq_enabled) {
291         /* Dynamic Capacity borrows the same vector as info */
292         policy->dyn_cap_settings = CXL_INT_MSI_MSIX;
293     }
294 
295     *len_out = sizeof(*policy);
296     return CXL_MBOX_SUCCESS;
297 }
298 
299 static CXLRetCode cmd_events_set_interrupt_policy(const struct cxl_cmd *cmd,
300                                                   uint8_t *payload_in,
301                                                   size_t len_in,
302                                                   uint8_t *payload_out,
303                                                   size_t *len_out,
304                                                   CXLCCI *cci)
305 {
306     CXLDeviceState *cxlds = &CXL_TYPE3(cci->d)->cxl_dstate;
307     CXLEventInterruptPolicy *policy;
308     CXLEventLog *log;
309 
310     if (len_in < CXL_EVENT_INT_SETTING_MIN_LEN) {
311         return CXL_MBOX_INVALID_PAYLOAD_LENGTH;
312     }
313 
314     policy = (CXLEventInterruptPolicy *)payload_in;
315 
316     log = &cxlds->event_logs[CXL_EVENT_TYPE_INFO];
317     log->irq_enabled = (policy->info_settings & CXL_EVENT_INT_MODE_MASK) ==
318                         CXL_INT_MSI_MSIX;
319 
320     log = &cxlds->event_logs[CXL_EVENT_TYPE_WARN];
321     log->irq_enabled = (policy->warn_settings & CXL_EVENT_INT_MODE_MASK) ==
322                         CXL_INT_MSI_MSIX;
323 
324     log = &cxlds->event_logs[CXL_EVENT_TYPE_FAIL];
325     log->irq_enabled = (policy->failure_settings & CXL_EVENT_INT_MODE_MASK) ==
326                         CXL_INT_MSI_MSIX;
327 
328     log = &cxlds->event_logs[CXL_EVENT_TYPE_FATAL];
329     log->irq_enabled = (policy->fatal_settings & CXL_EVENT_INT_MODE_MASK) ==
330                         CXL_INT_MSI_MSIX;
331 
332     /* DCD is optional */
333     if (len_in < sizeof(*policy)) {
334         return CXL_MBOX_SUCCESS;
335     }
336 
337     log = &cxlds->event_logs[CXL_EVENT_TYPE_DYNAMIC_CAP];
338     log->irq_enabled = (policy->dyn_cap_settings & CXL_EVENT_INT_MODE_MASK) ==
339                         CXL_INT_MSI_MSIX;
340 
341     *len_out = 0;
342     return CXL_MBOX_SUCCESS;
343 }
344 
345 /* CXL r3.0 section 8.2.9.1.1: Identify (Opcode 0001h) */
346 static CXLRetCode cmd_infostat_identify(const struct cxl_cmd *cmd,
347                                         uint8_t *payload_in,
348                                         size_t len_in,
349                                         uint8_t *payload_out,
350                                         size_t *len_out,
351                                         CXLCCI *cci)
352 {
353     PCIDeviceClass *class = PCI_DEVICE_GET_CLASS(cci->d);
354     struct {
355         uint16_t pcie_vid;
356         uint16_t pcie_did;
357         uint16_t pcie_subsys_vid;
358         uint16_t pcie_subsys_id;
359         uint64_t sn;
360     uint8_t max_message_size;
361         uint8_t component_type;
362     } QEMU_PACKED *is_identify;
363     QEMU_BUILD_BUG_ON(sizeof(*is_identify) != 18);
364 
365     is_identify = (void *)payload_out;
366     memset(is_identify, 0, sizeof(*is_identify));
367     is_identify->pcie_vid = class->vendor_id;
368     is_identify->pcie_did = class->device_id;
369     if (object_dynamic_cast(OBJECT(cci->d), TYPE_CXL_USP)) {
370         is_identify->sn = CXL_USP(cci->d)->sn;
371         /* Subsystem info not defined for a USP */
372         is_identify->pcie_subsys_vid = 0;
373         is_identify->pcie_subsys_id = 0;
374         is_identify->component_type = 0x0; /* Switch */
375     } else if (object_dynamic_cast(OBJECT(cci->d), TYPE_CXL_TYPE3)) {
376         PCIDevice *pci_dev = PCI_DEVICE(cci->d);
377 
378         is_identify->sn = CXL_TYPE3(cci->d)->sn;
379         /*
380          * We can't always use class->subsystem_vendor_id as
381          * it is not set if the defaults are used.
382          */
383         is_identify->pcie_subsys_vid =
384             pci_get_word(pci_dev->config + PCI_SUBSYSTEM_VENDOR_ID);
385         is_identify->pcie_subsys_id =
386             pci_get_word(pci_dev->config + PCI_SUBSYSTEM_ID);
387         is_identify->component_type = 0x3; /* Type 3 */
388     }
389 
390     /* TODO: Allow this to vary across different CCIs */
391     is_identify->max_message_size = 9; /* 512 bytes - MCTP_CXL_MAILBOX_BYTES */
392     *len_out = sizeof(*is_identify);
393     return CXL_MBOX_SUCCESS;
394 }
395 
396 static void cxl_set_dsp_active_bm(PCIBus *b, PCIDevice *d,
397                                   void *private)
398 {
399     uint8_t *bm = private;
400     if (object_dynamic_cast(OBJECT(d), TYPE_CXL_DSP)) {
401         uint8_t port = PCIE_PORT(d)->port;
402         bm[port / 8] |= 1 << (port % 8);
403     }
404 }
405 
406 /* CXL r3 8.2.9.1.1 */
407 static CXLRetCode cmd_identify_switch_device(const struct cxl_cmd *cmd,
408                                              uint8_t *payload_in,
409                                              size_t len_in,
410                                              uint8_t *payload_out,
411                                              size_t *len_out,
412                                              CXLCCI *cci)
413 {
414     PCIEPort *usp = PCIE_PORT(cci->d);
415     PCIBus *bus = &PCI_BRIDGE(cci->d)->sec_bus;
416     int num_phys_ports = pcie_count_ds_ports(bus);
417 
418     struct cxl_fmapi_ident_switch_dev_resp_pl {
419         uint8_t ingress_port_id;
420         uint8_t rsvd;
421         uint8_t num_physical_ports;
422         uint8_t num_vcss;
423         uint8_t active_port_bitmask[0x20];
424         uint8_t active_vcs_bitmask[0x20];
425         uint16_t total_vppbs;
426         uint16_t bound_vppbs;
427         uint8_t num_hdm_decoders_per_usp;
428     } QEMU_PACKED *out;
429     QEMU_BUILD_BUG_ON(sizeof(*out) != 0x49);
430 
431     out = (struct cxl_fmapi_ident_switch_dev_resp_pl *)payload_out;
432     *out = (struct cxl_fmapi_ident_switch_dev_resp_pl) {
433         .num_physical_ports = num_phys_ports + 1, /* 1 USP */
434         .num_vcss = 1, /* Not yet support multiple VCS - potentially tricky */
435         .active_vcs_bitmask[0] = 0x1,
436         .total_vppbs = num_phys_ports + 1,
437         .bound_vppbs = num_phys_ports + 1,
438         .num_hdm_decoders_per_usp = 4,
439     };
440 
441     /* Depends on the CCI type */
442     if (object_dynamic_cast(OBJECT(cci->intf), TYPE_PCIE_PORT)) {
443         out->ingress_port_id = PCIE_PORT(cci->intf)->port;
444     } else {
445         /* MCTP? */
446         out->ingress_port_id = 0;
447     }
448 
449     pci_for_each_device_under_bus(bus, cxl_set_dsp_active_bm,
450                                   out->active_port_bitmask);
451     out->active_port_bitmask[usp->port / 8] |= (1 << usp->port % 8);
452 
453     *len_out = sizeof(*out);
454 
455     return CXL_MBOX_SUCCESS;
456 }
457 
458 /* CXL r3.0 Section 7.6.7.1.2: Get Physical Port State (Opcode 5101h) */
459 static CXLRetCode cmd_get_physical_port_state(const struct cxl_cmd *cmd,
460                                               uint8_t *payload_in,
461                                               size_t len_in,
462                                               uint8_t *payload_out,
463                                               size_t *len_out,
464                                               CXLCCI *cci)
465 {
466     /* CXL r3.0 Table 7-18: Get Physical Port State Request Payload */
467     struct cxl_fmapi_get_phys_port_state_req_pl {
468         uint8_t num_ports;
469         uint8_t ports[];
470     } QEMU_PACKED *in;
471 
472     /*
473      * CXL r3.0 Table 7-20: Get Physical Port State Port Information Block
474      * Format
475      */
476     struct cxl_fmapi_port_state_info_block {
477         uint8_t port_id;
478         uint8_t config_state;
479         uint8_t connected_device_cxl_version;
480         uint8_t rsv1;
481         uint8_t connected_device_type;
482         uint8_t port_cxl_version_bitmask;
483         uint8_t max_link_width;
484         uint8_t negotiated_link_width;
485         uint8_t supported_link_speeds_vector;
486         uint8_t max_link_speed;
487         uint8_t current_link_speed;
488         uint8_t ltssm_state;
489         uint8_t first_lane_num;
490         uint16_t link_state;
491         uint8_t supported_ld_count;
492     } QEMU_PACKED;
493 
494     /* CXL r3.0 Table 7-19: Get Physical Port State Response Payload */
495     struct cxl_fmapi_get_phys_port_state_resp_pl {
496         uint8_t num_ports;
497         uint8_t rsv1[3];
498         struct cxl_fmapi_port_state_info_block ports[];
499     } QEMU_PACKED *out;
500     PCIBus *bus = &PCI_BRIDGE(cci->d)->sec_bus;
501     PCIEPort *usp = PCIE_PORT(cci->d);
502     size_t pl_size;
503     int i;
504 
505     in = (struct cxl_fmapi_get_phys_port_state_req_pl *)payload_in;
506     out = (struct cxl_fmapi_get_phys_port_state_resp_pl *)payload_out;
507 
508     /* Check if what was requested can fit */
509     if (sizeof(*out) + sizeof(*out->ports) * in->num_ports > cci->payload_max) {
510         return CXL_MBOX_INVALID_INPUT;
511     }
512 
513     /* For success there should be a match for each requested */
514     out->num_ports = in->num_ports;
515 
516     for (i = 0; i < in->num_ports; i++) {
517         struct cxl_fmapi_port_state_info_block *port;
518         /* First try to match on downstream port */
519         PCIDevice *port_dev;
520         uint16_t lnkcap, lnkcap2, lnksta;
521 
522         port = &out->ports[i];
523 
524         port_dev = pcie_find_port_by_pn(bus, in->ports[i]);
525         if (port_dev) { /* DSP */
526             PCIDevice *ds_dev = pci_bridge_get_sec_bus(PCI_BRIDGE(port_dev))
527                 ->devices[0];
528             port->config_state = 3;
529             if (ds_dev) {
530                 if (object_dynamic_cast(OBJECT(ds_dev), TYPE_CXL_TYPE3)) {
531                     port->connected_device_type = 5; /* Assume MLD for now */
532                 } else {
533                     port->connected_device_type = 1;
534                 }
535             } else {
536                 port->connected_device_type = 0;
537             }
538             port->supported_ld_count = 3;
539         } else if (usp->port == in->ports[i]) { /* USP */
540             port_dev = PCI_DEVICE(usp);
541             port->config_state = 4;
542             port->connected_device_type = 0;
543         } else {
544             return CXL_MBOX_INVALID_INPUT;
545         }
546 
547         port->port_id = in->ports[i];
548         /* Information on status of this port in lnksta, lnkcap */
549         if (!port_dev->exp.exp_cap) {
550             return CXL_MBOX_INTERNAL_ERROR;
551         }
552         lnksta = port_dev->config_read(port_dev,
553                                        port_dev->exp.exp_cap + PCI_EXP_LNKSTA,
554                                        sizeof(lnksta));
555         lnkcap = port_dev->config_read(port_dev,
556                                        port_dev->exp.exp_cap + PCI_EXP_LNKCAP,
557                                        sizeof(lnkcap));
558         lnkcap2 = port_dev->config_read(port_dev,
559                                         port_dev->exp.exp_cap + PCI_EXP_LNKCAP2,
560                                         sizeof(lnkcap2));
561 
562         port->max_link_width = (lnkcap & PCI_EXP_LNKCAP_MLW) >> 4;
563         port->negotiated_link_width = (lnksta & PCI_EXP_LNKSTA_NLW) >> 4;
564         /* No definition for SLS field in linux/pci_regs.h */
565         port->supported_link_speeds_vector = (lnkcap2 & 0xFE) >> 1;
566         port->max_link_speed = lnkcap & PCI_EXP_LNKCAP_SLS;
567         port->current_link_speed = lnksta & PCI_EXP_LNKSTA_CLS;
568         /* TODO: Track down if we can get the rest of the info */
569         port->ltssm_state = 0x7;
570         port->first_lane_num = 0;
571         port->link_state = 0;
572         port->port_cxl_version_bitmask = 0x2;
573         port->connected_device_cxl_version = 0x2;
574     }
575 
576     pl_size = sizeof(*out) + sizeof(*out->ports) * in->num_ports;
577     *len_out = pl_size;
578 
579     return CXL_MBOX_SUCCESS;
580 }
581 
582 /* CXL r3.0 8.2.9.1.2 */
583 static CXLRetCode cmd_infostat_bg_op_sts(const struct cxl_cmd *cmd,
584                                          uint8_t *payload_in,
585                                          size_t len_in,
586                                          uint8_t *payload_out,
587                                          size_t *len_out,
588                                          CXLCCI *cci)
589 {
590     struct {
591         uint8_t status;
592         uint8_t rsvd;
593         uint16_t opcode;
594         uint16_t returncode;
595         uint16_t vendor_ext_status;
596     } QEMU_PACKED *bg_op_status;
597     QEMU_BUILD_BUG_ON(sizeof(*bg_op_status) != 8);
598 
599     bg_op_status = (void *)payload_out;
600     memset(bg_op_status, 0, sizeof(*bg_op_status));
601     bg_op_status->status = cci->bg.complete_pct << 1;
602     if (cci->bg.runtime > 0) {
603         bg_op_status->status |= 1U << 0;
604     }
605     bg_op_status->opcode = cci->bg.opcode;
606     bg_op_status->returncode = cci->bg.ret_code;
607     *len_out = sizeof(*bg_op_status);
608 
609     return CXL_MBOX_SUCCESS;
610 }
611 
612 /* 8.2.9.2.1 */
613 static CXLRetCode cmd_firmware_update_get_info(const struct cxl_cmd *cmd,
614                                                uint8_t *payload_in,
615                                                size_t len,
616                                                uint8_t *payload_out,
617                                                size_t *len_out,
618                                                CXLCCI *cci)
619 {
620     CXLDeviceState *cxl_dstate = &CXL_TYPE3(cci->d)->cxl_dstate;
621     struct {
622         uint8_t slots_supported;
623         uint8_t slot_info;
624         uint8_t caps;
625         uint8_t rsvd[0xd];
626         char fw_rev1[0x10];
627         char fw_rev2[0x10];
628         char fw_rev3[0x10];
629         char fw_rev4[0x10];
630     } QEMU_PACKED *fw_info;
631     QEMU_BUILD_BUG_ON(sizeof(*fw_info) != 0x50);
632 
633     if ((cxl_dstate->vmem_size < CXL_CAPACITY_MULTIPLIER) ||
634         (cxl_dstate->pmem_size < CXL_CAPACITY_MULTIPLIER)) {
635         return CXL_MBOX_INTERNAL_ERROR;
636     }
637 
638     fw_info = (void *)payload_out;
639     memset(fw_info, 0, sizeof(*fw_info));
640 
641     fw_info->slots_supported = 2;
642     fw_info->slot_info = BIT(0) | BIT(3);
643     fw_info->caps = 0;
644     pstrcpy(fw_info->fw_rev1, sizeof(fw_info->fw_rev1), "BWFW VERSION 0");
645 
646     *len_out = sizeof(*fw_info);
647     return CXL_MBOX_SUCCESS;
648 }
649 
650 /* 8.2.9.3.1 */
651 static CXLRetCode cmd_timestamp_get(const struct cxl_cmd *cmd,
652                                     uint8_t *payload_in,
653                                     size_t len_in,
654                                     uint8_t *payload_out,
655                                     size_t *len_out,
656                                     CXLCCI *cci)
657 {
658     CXLDeviceState *cxl_dstate = &CXL_TYPE3(cci->d)->cxl_dstate;
659     uint64_t final_time = cxl_device_get_timestamp(cxl_dstate);
660 
661     stq_le_p(payload_out, final_time);
662     *len_out = 8;
663 
664     return CXL_MBOX_SUCCESS;
665 }
666 
667 /* 8.2.9.3.2 */
668 static CXLRetCode cmd_timestamp_set(const struct cxl_cmd *cmd,
669                                     uint8_t *payload_in,
670                                     size_t len_in,
671                                     uint8_t *payload_out,
672                                     size_t *len_out,
673                                     CXLCCI *cci)
674 {
675     CXLDeviceState *cxl_dstate = &CXL_TYPE3(cci->d)->cxl_dstate;
676 
677     cxl_dstate->timestamp.set = true;
678     cxl_dstate->timestamp.last_set = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
679 
680     cxl_dstate->timestamp.host_set = le64_to_cpu(*(uint64_t *)payload_in);
681 
682     *len_out = 0;
683     return CXL_MBOX_SUCCESS;
684 }
685 
686 /* CXL 3.0 8.2.9.5.2.1 Command Effects Log (CEL) */
687 static const QemuUUID cel_uuid = {
688     .data = UUID(0x0da9c0b5, 0xbf41, 0x4b78, 0x8f, 0x79,
689                  0x96, 0xb1, 0x62, 0x3b, 0x3f, 0x17)
690 };
691 
692 /* 8.2.9.4.1 */
693 static CXLRetCode cmd_logs_get_supported(const struct cxl_cmd *cmd,
694                                          uint8_t *payload_in,
695                                          size_t len_in,
696                                          uint8_t *payload_out,
697                                          size_t *len_out,
698                                          CXLCCI *cci)
699 {
700     struct {
701         uint16_t entries;
702         uint8_t rsvd[6];
703         struct {
704             QemuUUID uuid;
705             uint32_t size;
706         } log_entries[1];
707     } QEMU_PACKED *supported_logs = (void *)payload_out;
708     QEMU_BUILD_BUG_ON(sizeof(*supported_logs) != 0x1c);
709 
710     supported_logs->entries = 1;
711     supported_logs->log_entries[0].uuid = cel_uuid;
712     supported_logs->log_entries[0].size = 4 * cci->cel_size;
713 
714     *len_out = sizeof(*supported_logs);
715     return CXL_MBOX_SUCCESS;
716 }
717 
718 /* 8.2.9.4.2 */
719 static CXLRetCode cmd_logs_get_log(const struct cxl_cmd *cmd,
720                                    uint8_t *payload_in,
721                                    size_t len_in,
722                                    uint8_t *payload_out,
723                                    size_t *len_out,
724                                    CXLCCI *cci)
725 {
726     struct {
727         QemuUUID uuid;
728         uint32_t offset;
729         uint32_t length;
730     } QEMU_PACKED QEMU_ALIGNED(16) *get_log;
731 
732     get_log = (void *)payload_in;
733 
734     /*
735      * 8.2.9.4.2
736      *   The device shall return Invalid Parameter if the Offset or Length
737      *   fields attempt to access beyond the size of the log as reported by Get
738      *   Supported Logs.
739      *
740      * XXX: Spec is wrong, "Invalid Parameter" isn't a thing.
741      * XXX: Spec doesn't address incorrect UUID incorrectness.
742      *
743      * The CEL buffer is large enough to fit all commands in the emulation, so
744      * the only possible failure would be if the mailbox itself isn't big
745      * enough.
746      */
747     if (get_log->offset + get_log->length > cci->payload_max) {
748         return CXL_MBOX_INVALID_INPUT;
749     }
750 
751     if (!qemu_uuid_is_equal(&get_log->uuid, &cel_uuid)) {
752         return CXL_MBOX_UNSUPPORTED;
753     }
754 
755     /* Store off everything to local variables so we can wipe out the payload */
756     *len_out = get_log->length;
757 
758     memmove(payload_out, cci->cel_log + get_log->offset, get_log->length);
759 
760     return CXL_MBOX_SUCCESS;
761 }
762 
763 /* 8.2.9.5.1.1 */
764 static CXLRetCode cmd_identify_memory_device(const struct cxl_cmd *cmd,
765                                              uint8_t *payload_in,
766                                              size_t len_in,
767                                              uint8_t *payload_out,
768                                              size_t *len_out,
769                                              CXLCCI *cci)
770 {
771     struct {
772         char fw_revision[0x10];
773         uint64_t total_capacity;
774         uint64_t volatile_capacity;
775         uint64_t persistent_capacity;
776         uint64_t partition_align;
777         uint16_t info_event_log_size;
778         uint16_t warning_event_log_size;
779         uint16_t failure_event_log_size;
780         uint16_t fatal_event_log_size;
781         uint32_t lsa_size;
782         uint8_t poison_list_max_mer[3];
783         uint16_t inject_poison_limit;
784         uint8_t poison_caps;
785         uint8_t qos_telemetry_caps;
786     } QEMU_PACKED *id;
787     QEMU_BUILD_BUG_ON(sizeof(*id) != 0x43);
788     CXLType3Dev *ct3d = CXL_TYPE3(cci->d);
789     CXLType3Class *cvc = CXL_TYPE3_GET_CLASS(ct3d);
790     CXLDeviceState *cxl_dstate = &ct3d->cxl_dstate;
791 
792     if ((!QEMU_IS_ALIGNED(cxl_dstate->vmem_size, CXL_CAPACITY_MULTIPLIER)) ||
793         (!QEMU_IS_ALIGNED(cxl_dstate->pmem_size, CXL_CAPACITY_MULTIPLIER))) {
794         return CXL_MBOX_INTERNAL_ERROR;
795     }
796 
797     id = (void *)payload_out;
798     memset(id, 0, sizeof(*id));
799 
800     snprintf(id->fw_revision, 0x10, "BWFW VERSION %02d", 0);
801 
802     stq_le_p(&id->total_capacity,
803              cxl_dstate->mem_size / CXL_CAPACITY_MULTIPLIER);
804     stq_le_p(&id->persistent_capacity,
805              cxl_dstate->pmem_size / CXL_CAPACITY_MULTIPLIER);
806     stq_le_p(&id->volatile_capacity,
807              cxl_dstate->vmem_size / CXL_CAPACITY_MULTIPLIER);
808     stl_le_p(&id->lsa_size, cvc->get_lsa_size(ct3d));
809     /* 256 poison records */
810     st24_le_p(id->poison_list_max_mer, 256);
811     /* No limit - so limited by main poison record limit */
812     stw_le_p(&id->inject_poison_limit, 0);
813 
814     *len_out = sizeof(*id);
815     return CXL_MBOX_SUCCESS;
816 }
817 
818 static CXLRetCode cmd_ccls_get_partition_info(const struct cxl_cmd *cmd,
819                                               uint8_t *payload_in,
820                                               size_t len_in,
821                                               uint8_t *payload_out,
822                                               size_t *len_out,
823                                               CXLCCI *cci)
824 {
825     CXLDeviceState *cxl_dstate = &CXL_TYPE3(cci->d)->cxl_dstate;
826     struct {
827         uint64_t active_vmem;
828         uint64_t active_pmem;
829         uint64_t next_vmem;
830         uint64_t next_pmem;
831     } QEMU_PACKED *part_info = (void *)payload_out;
832     QEMU_BUILD_BUG_ON(sizeof(*part_info) != 0x20);
833 
834     if ((!QEMU_IS_ALIGNED(cxl_dstate->vmem_size, CXL_CAPACITY_MULTIPLIER)) ||
835         (!QEMU_IS_ALIGNED(cxl_dstate->pmem_size, CXL_CAPACITY_MULTIPLIER))) {
836         return CXL_MBOX_INTERNAL_ERROR;
837     }
838 
839     stq_le_p(&part_info->active_vmem,
840              cxl_dstate->vmem_size / CXL_CAPACITY_MULTIPLIER);
841     /*
842      * When both next_vmem and next_pmem are 0, there is no pending change to
843      * partitioning.
844      */
845     stq_le_p(&part_info->next_vmem, 0);
846     stq_le_p(&part_info->active_pmem,
847              cxl_dstate->pmem_size / CXL_CAPACITY_MULTIPLIER);
848     stq_le_p(&part_info->next_pmem, 0);
849 
850     *len_out = sizeof(*part_info);
851     return CXL_MBOX_SUCCESS;
852 }
853 
854 static CXLRetCode cmd_ccls_get_lsa(const struct cxl_cmd *cmd,
855                                    uint8_t *payload_in,
856                                    size_t len_in,
857                                    uint8_t *payload_out,
858                                    size_t *len_out,
859                                    CXLCCI *cci)
860 {
861     struct {
862         uint32_t offset;
863         uint32_t length;
864     } QEMU_PACKED *get_lsa;
865     CXLType3Dev *ct3d = CXL_TYPE3(cci->d);
866     CXLType3Class *cvc = CXL_TYPE3_GET_CLASS(ct3d);
867     uint32_t offset, length;
868 
869     get_lsa = (void *)payload_in;
870     offset = get_lsa->offset;
871     length = get_lsa->length;
872 
873     if (offset + length > cvc->get_lsa_size(ct3d)) {
874         *len_out = 0;
875         return CXL_MBOX_INVALID_INPUT;
876     }
877 
878     *len_out = cvc->get_lsa(ct3d, payload_out, length, offset);
879     return CXL_MBOX_SUCCESS;
880 }
881 
882 static CXLRetCode cmd_ccls_set_lsa(const struct cxl_cmd *cmd,
883                                    uint8_t *payload_in,
884                                    size_t len_in,
885                                    uint8_t *payload_out,
886                                    size_t *len_out,
887                                    CXLCCI *cci)
888 {
889     struct set_lsa_pl {
890         uint32_t offset;
891         uint32_t rsvd;
892         uint8_t data[];
893     } QEMU_PACKED;
894     struct set_lsa_pl *set_lsa_payload = (void *)payload_in;
895     CXLType3Dev *ct3d = CXL_TYPE3(cci->d);
896     CXLType3Class *cvc = CXL_TYPE3_GET_CLASS(ct3d);
897     const size_t hdr_len = offsetof(struct set_lsa_pl, data);
898 
899     *len_out = 0;
900     if (!len_in) {
901         return CXL_MBOX_SUCCESS;
902     }
903 
904     if (set_lsa_payload->offset + len_in > cvc->get_lsa_size(ct3d) + hdr_len) {
905         return CXL_MBOX_INVALID_INPUT;
906     }
907     len_in -= hdr_len;
908 
909     cvc->set_lsa(ct3d, set_lsa_payload->data, len_in, set_lsa_payload->offset);
910     return CXL_MBOX_SUCCESS;
911 }
912 
913 /* Perform the actual device zeroing */
914 static void __do_sanitization(CXLType3Dev *ct3d)
915 {
916     MemoryRegion *mr;
917 
918     if (ct3d->hostvmem) {
919         mr = host_memory_backend_get_memory(ct3d->hostvmem);
920         if (mr) {
921             void *hostmem = memory_region_get_ram_ptr(mr);
922             memset(hostmem, 0, memory_region_size(mr));
923         }
924     }
925 
926     if (ct3d->hostpmem) {
927         mr = host_memory_backend_get_memory(ct3d->hostpmem);
928         if (mr) {
929             void *hostmem = memory_region_get_ram_ptr(mr);
930             memset(hostmem, 0, memory_region_size(mr));
931         }
932     }
933     if (ct3d->lsa) {
934         mr = host_memory_backend_get_memory(ct3d->lsa);
935         if (mr) {
936             void *lsa = memory_region_get_ram_ptr(mr);
937             memset(lsa, 0, memory_region_size(mr));
938         }
939     }
940 }
941 
942 /*
943  * CXL 3.0 spec section 8.2.9.8.5.1 - Sanitize.
944  *
945  * Once the Sanitize command has started successfully, the device shall be
946  * placed in the media disabled state. If the command fails or is interrupted
947  * by a reset or power failure, it shall remain in the media disabled state
948  * until a successful Sanitize command has been completed. During this state:
949  *
950  * 1. Memory writes to the device will have no effect, and all memory reads
951  * will return random values (no user data returned, even for locations that
952  * the failed Sanitize operation didn’t sanitize yet).
953  *
954  * 2. Mailbox commands shall still be processed in the disabled state, except
955  * that commands that access Sanitized areas shall fail with the Media Disabled
956  * error code.
957  */
958 static CXLRetCode cmd_sanitize_overwrite(const struct cxl_cmd *cmd,
959                                          uint8_t *payload_in,
960                                          size_t len_in,
961                                          uint8_t *payload_out,
962                                          size_t *len_out,
963                                          CXLCCI *cci)
964 {
965     CXLType3Dev *ct3d = CXL_TYPE3(cci->d);
966     uint64_t total_mem; /* in Mb */
967     int secs;
968 
969     total_mem = (ct3d->cxl_dstate.vmem_size + ct3d->cxl_dstate.pmem_size) >> 20;
970     if (total_mem <= 512) {
971         secs = 4;
972     } else if (total_mem <= 1024) {
973         secs = 8;
974     } else if (total_mem <= 2 * 1024) {
975         secs = 15;
976     } else if (total_mem <= 4 * 1024) {
977         secs = 30;
978     } else if (total_mem <= 8 * 1024) {
979         secs = 60;
980     } else if (total_mem <= 16 * 1024) {
981         secs = 2 * 60;
982     } else if (total_mem <= 32 * 1024) {
983         secs = 4 * 60;
984     } else if (total_mem <= 64 * 1024) {
985         secs = 8 * 60;
986     } else if (total_mem <= 128 * 1024) {
987         secs = 15 * 60;
988     } else if (total_mem <= 256 * 1024) {
989         secs = 30 * 60;
990     } else if (total_mem <= 512 * 1024) {
991         secs = 60 * 60;
992     } else if (total_mem <= 1024 * 1024) {
993         secs = 120 * 60;
994     } else {
995         secs = 240 * 60; /* max 4 hrs */
996     }
997 
998     /* EBUSY other bg cmds as of now */
999     cci->bg.runtime = secs * 1000UL;
1000     *len_out = 0;
1001 
1002     cxl_dev_disable_media(&ct3d->cxl_dstate);
1003 
1004     if (secs > 2) {
1005         /* sanitize when done */
1006         return CXL_MBOX_BG_STARTED;
1007     } else {
1008         __do_sanitization(ct3d);
1009         cxl_dev_enable_media(&ct3d->cxl_dstate);
1010 
1011         return CXL_MBOX_SUCCESS;
1012     }
1013 }
1014 
1015 static CXLRetCode cmd_get_security_state(const struct cxl_cmd *cmd,
1016                                          uint8_t *payload_in,
1017                                          size_t len_in,
1018                                          uint8_t *payload_out,
1019                                          size_t *len_out,
1020                                          CXLCCI *cci)
1021 {
1022     uint32_t *state = (uint32_t *)payload_out;
1023 
1024     *state = 0;
1025     *len_out = 4;
1026     return CXL_MBOX_SUCCESS;
1027 }
1028 /*
1029  * This is very inefficient, but good enough for now!
1030  * Also the payload will always fit, so no need to handle the MORE flag and
1031  * make this stateful. We may want to allow longer poison lists to aid
1032  * testing that kernel functionality.
1033  */
1034 static CXLRetCode cmd_media_get_poison_list(const struct cxl_cmd *cmd,
1035                                             uint8_t *payload_in,
1036                                             size_t len_in,
1037                                             uint8_t *payload_out,
1038                                             size_t *len_out,
1039                                             CXLCCI *cci)
1040 {
1041     struct get_poison_list_pl {
1042         uint64_t pa;
1043         uint64_t length;
1044     } QEMU_PACKED;
1045 
1046     struct get_poison_list_out_pl {
1047         uint8_t flags;
1048         uint8_t rsvd1;
1049         uint64_t overflow_timestamp;
1050         uint16_t count;
1051         uint8_t rsvd2[0x14];
1052         struct {
1053             uint64_t addr;
1054             uint32_t length;
1055             uint32_t resv;
1056         } QEMU_PACKED records[];
1057     } QEMU_PACKED;
1058 
1059     struct get_poison_list_pl *in = (void *)payload_in;
1060     struct get_poison_list_out_pl *out = (void *)payload_out;
1061     CXLType3Dev *ct3d = CXL_TYPE3(cci->d);
1062     uint16_t record_count = 0, i = 0;
1063     uint64_t query_start, query_length;
1064     CXLPoisonList *poison_list = &ct3d->poison_list;
1065     CXLPoison *ent;
1066     uint16_t out_pl_len;
1067 
1068     query_start = ldq_le_p(&in->pa);
1069     /* 64 byte alignment required */
1070     if (query_start & 0x3f) {
1071         return CXL_MBOX_INVALID_INPUT;
1072     }
1073     query_length = ldq_le_p(&in->length) * CXL_CACHE_LINE_SIZE;
1074 
1075     QLIST_FOREACH(ent, poison_list, node) {
1076         /* Check for no overlap */
1077         if (ent->start >= query_start + query_length ||
1078             ent->start + ent->length <= query_start) {
1079             continue;
1080         }
1081         record_count++;
1082     }
1083     out_pl_len = sizeof(*out) + record_count * sizeof(out->records[0]);
1084     assert(out_pl_len <= CXL_MAILBOX_MAX_PAYLOAD_SIZE);
1085 
1086     memset(out, 0, out_pl_len);
1087     QLIST_FOREACH(ent, poison_list, node) {
1088         uint64_t start, stop;
1089 
1090         /* Check for no overlap */
1091         if (ent->start >= query_start + query_length ||
1092             ent->start + ent->length <= query_start) {
1093             continue;
1094         }
1095 
1096         /* Deal with overlap */
1097         start = MAX(ROUND_DOWN(ent->start, 64ull), query_start);
1098         stop = MIN(ROUND_DOWN(ent->start, 64ull) + ent->length,
1099                    query_start + query_length);
1100         stq_le_p(&out->records[i].addr, start | (ent->type & 0x7));
1101         stl_le_p(&out->records[i].length, (stop - start) / CXL_CACHE_LINE_SIZE);
1102         i++;
1103     }
1104     if (ct3d->poison_list_overflowed) {
1105         out->flags = (1 << 1);
1106         stq_le_p(&out->overflow_timestamp, ct3d->poison_list_overflow_ts);
1107     }
1108     stw_le_p(&out->count, record_count);
1109     *len_out = out_pl_len;
1110     return CXL_MBOX_SUCCESS;
1111 }
1112 
1113 static CXLRetCode cmd_media_inject_poison(const struct cxl_cmd *cmd,
1114                                           uint8_t *payload_in,
1115                                           size_t len_in,
1116                                           uint8_t *payload_out,
1117                                           size_t *len_out,
1118                                           CXLCCI *cci)
1119 {
1120     CXLType3Dev *ct3d = CXL_TYPE3(cci->d);
1121     CXLPoisonList *poison_list = &ct3d->poison_list;
1122     CXLPoison *ent;
1123     struct inject_poison_pl {
1124         uint64_t dpa;
1125     };
1126     struct inject_poison_pl *in = (void *)payload_in;
1127     uint64_t dpa = ldq_le_p(&in->dpa);
1128     CXLPoison *p;
1129 
1130     QLIST_FOREACH(ent, poison_list, node) {
1131         if (dpa >= ent->start &&
1132             dpa + CXL_CACHE_LINE_SIZE <= ent->start + ent->length) {
1133             return CXL_MBOX_SUCCESS;
1134         }
1135     }
1136 
1137     if (ct3d->poison_list_cnt == CXL_POISON_LIST_LIMIT) {
1138         return CXL_MBOX_INJECT_POISON_LIMIT;
1139     }
1140     p = g_new0(CXLPoison, 1);
1141 
1142     p->length = CXL_CACHE_LINE_SIZE;
1143     p->start = dpa;
1144     p->type = CXL_POISON_TYPE_INJECTED;
1145 
1146     /*
1147      * Possible todo: Merge with existing entry if next to it and if same type
1148      */
1149     QLIST_INSERT_HEAD(poison_list, p, node);
1150     ct3d->poison_list_cnt++;
1151     *len_out = 0;
1152 
1153     return CXL_MBOX_SUCCESS;
1154 }
1155 
1156 static CXLRetCode cmd_media_clear_poison(const struct cxl_cmd *cmd,
1157                                          uint8_t *payload_in,
1158                                          size_t len_in,
1159                                          uint8_t *payload_out,
1160                                          size_t *len_out,
1161                                          CXLCCI *cci)
1162 {
1163     CXLType3Dev *ct3d = CXL_TYPE3(cci->d);
1164     CXLDeviceState *cxl_dstate = &ct3d->cxl_dstate;
1165     CXLPoisonList *poison_list = &ct3d->poison_list;
1166     CXLType3Class *cvc = CXL_TYPE3_GET_CLASS(ct3d);
1167     struct clear_poison_pl {
1168         uint64_t dpa;
1169         uint8_t data[64];
1170     };
1171     CXLPoison *ent;
1172     uint64_t dpa;
1173 
1174     struct clear_poison_pl *in = (void *)payload_in;
1175 
1176     dpa = ldq_le_p(&in->dpa);
1177     if (dpa + CXL_CACHE_LINE_SIZE > cxl_dstate->mem_size) {
1178         return CXL_MBOX_INVALID_PA;
1179     }
1180 
1181     /* Clearing a region with no poison is not an error so always do so */
1182     if (cvc->set_cacheline) {
1183         if (!cvc->set_cacheline(ct3d, dpa, in->data)) {
1184             return CXL_MBOX_INTERNAL_ERROR;
1185         }
1186     }
1187 
1188     QLIST_FOREACH(ent, poison_list, node) {
1189         /*
1190          * Test for contained in entry. Simpler than general case
1191          * as clearing 64 bytes and entries 64 byte aligned
1192          */
1193         if ((dpa >= ent->start) && (dpa < ent->start + ent->length)) {
1194             break;
1195         }
1196     }
1197     if (!ent) {
1198         return CXL_MBOX_SUCCESS;
1199     }
1200 
1201     QLIST_REMOVE(ent, node);
1202     ct3d->poison_list_cnt--;
1203 
1204     if (dpa > ent->start) {
1205         CXLPoison *frag;
1206         /* Cannot overflow as replacing existing entry */
1207 
1208         frag = g_new0(CXLPoison, 1);
1209 
1210         frag->start = ent->start;
1211         frag->length = dpa - ent->start;
1212         frag->type = ent->type;
1213 
1214         QLIST_INSERT_HEAD(poison_list, frag, node);
1215         ct3d->poison_list_cnt++;
1216     }
1217 
1218     if (dpa + CXL_CACHE_LINE_SIZE < ent->start + ent->length) {
1219         CXLPoison *frag;
1220 
1221         if (ct3d->poison_list_cnt == CXL_POISON_LIST_LIMIT) {
1222             cxl_set_poison_list_overflowed(ct3d);
1223         } else {
1224             frag = g_new0(CXLPoison, 1);
1225 
1226             frag->start = dpa + CXL_CACHE_LINE_SIZE;
1227             frag->length = ent->start + ent->length - frag->start;
1228             frag->type = ent->type;
1229             QLIST_INSERT_HEAD(poison_list, frag, node);
1230             ct3d->poison_list_cnt++;
1231         }
1232     }
1233     /* Any fragments have been added, free original entry */
1234     g_free(ent);
1235     *len_out = 0;
1236 
1237     return CXL_MBOX_SUCCESS;
1238 }
1239 
1240 #define IMMEDIATE_CONFIG_CHANGE (1 << 1)
1241 #define IMMEDIATE_DATA_CHANGE (1 << 2)
1242 #define IMMEDIATE_POLICY_CHANGE (1 << 3)
1243 #define IMMEDIATE_LOG_CHANGE (1 << 4)
1244 #define SECURITY_STATE_CHANGE (1 << 5)
1245 #define BACKGROUND_OPERATION (1 << 6)
1246 
1247 static const struct cxl_cmd cxl_cmd_set[256][256] = {
1248     [EVENTS][GET_RECORDS] = { "EVENTS_GET_RECORDS",
1249         cmd_events_get_records, 1, 0 },
1250     [EVENTS][CLEAR_RECORDS] = { "EVENTS_CLEAR_RECORDS",
1251         cmd_events_clear_records, ~0, IMMEDIATE_LOG_CHANGE },
1252     [EVENTS][GET_INTERRUPT_POLICY] = { "EVENTS_GET_INTERRUPT_POLICY",
1253                                       cmd_events_get_interrupt_policy, 0, 0 },
1254     [EVENTS][SET_INTERRUPT_POLICY] = { "EVENTS_SET_INTERRUPT_POLICY",
1255                                       cmd_events_set_interrupt_policy,
1256                                       ~0, IMMEDIATE_CONFIG_CHANGE },
1257     [FIRMWARE_UPDATE][GET_INFO] = { "FIRMWARE_UPDATE_GET_INFO",
1258         cmd_firmware_update_get_info, 0, 0 },
1259     [TIMESTAMP][GET] = { "TIMESTAMP_GET", cmd_timestamp_get, 0, 0 },
1260     [TIMESTAMP][SET] = { "TIMESTAMP_SET", cmd_timestamp_set,
1261                          8, IMMEDIATE_POLICY_CHANGE },
1262     [LOGS][GET_SUPPORTED] = { "LOGS_GET_SUPPORTED", cmd_logs_get_supported,
1263                               0, 0 },
1264     [LOGS][GET_LOG] = { "LOGS_GET_LOG", cmd_logs_get_log, 0x18, 0 },
1265     [IDENTIFY][MEMORY_DEVICE] = { "IDENTIFY_MEMORY_DEVICE",
1266         cmd_identify_memory_device, 0, 0 },
1267     [CCLS][GET_PARTITION_INFO] = { "CCLS_GET_PARTITION_INFO",
1268         cmd_ccls_get_partition_info, 0, 0 },
1269     [CCLS][GET_LSA] = { "CCLS_GET_LSA", cmd_ccls_get_lsa, 8, 0 },
1270     [CCLS][SET_LSA] = { "CCLS_SET_LSA", cmd_ccls_set_lsa,
1271         ~0, IMMEDIATE_CONFIG_CHANGE | IMMEDIATE_DATA_CHANGE },
1272     [SANITIZE][OVERWRITE] = { "SANITIZE_OVERWRITE", cmd_sanitize_overwrite, 0,
1273         IMMEDIATE_DATA_CHANGE | SECURITY_STATE_CHANGE | BACKGROUND_OPERATION },
1274     [PERSISTENT_MEM][GET_SECURITY_STATE] = { "GET_SECURITY_STATE",
1275         cmd_get_security_state, 0, 0 },
1276     [MEDIA_AND_POISON][GET_POISON_LIST] = { "MEDIA_AND_POISON_GET_POISON_LIST",
1277         cmd_media_get_poison_list, 16, 0 },
1278     [MEDIA_AND_POISON][INJECT_POISON] = { "MEDIA_AND_POISON_INJECT_POISON",
1279         cmd_media_inject_poison, 8, 0 },
1280     [MEDIA_AND_POISON][CLEAR_POISON] = { "MEDIA_AND_POISON_CLEAR_POISON",
1281         cmd_media_clear_poison, 72, 0 },
1282 };
1283 
1284 static const struct cxl_cmd cxl_cmd_set_sw[256][256] = {
1285     [INFOSTAT][IS_IDENTIFY] = { "IDENTIFY", cmd_infostat_identify, 0, 0 },
1286     [INFOSTAT][BACKGROUND_OPERATION_STATUS] = { "BACKGROUND_OPERATION_STATUS",
1287         cmd_infostat_bg_op_sts, 0, 0 },
1288     [TIMESTAMP][GET] = { "TIMESTAMP_GET", cmd_timestamp_get, 0, 0 },
1289     [TIMESTAMP][SET] = { "TIMESTAMP_SET", cmd_timestamp_set, 0,
1290                          IMMEDIATE_POLICY_CHANGE },
1291     [LOGS][GET_SUPPORTED] = { "LOGS_GET_SUPPORTED", cmd_logs_get_supported, 0,
1292                               0 },
1293     [LOGS][GET_LOG] = { "LOGS_GET_LOG", cmd_logs_get_log, 0x18, 0 },
1294     [PHYSICAL_SWITCH][IDENTIFY_SWITCH_DEVICE] = { "IDENTIFY_SWITCH_DEVICE",
1295         cmd_identify_switch_device, 0, 0 },
1296     [PHYSICAL_SWITCH][GET_PHYSICAL_PORT_STATE] = { "SWITCH_PHYSICAL_PORT_STATS",
1297         cmd_get_physical_port_state, ~0, 0 },
1298     [TUNNEL][MANAGEMENT_COMMAND] = { "TUNNEL_MANAGEMENT_COMMAND",
1299                                      cmd_tunnel_management_cmd, ~0, 0 },
1300 };
1301 
1302 /*
1303  * While the command is executing in the background, the device should
1304  * update the percentage complete in the Background Command Status Register
1305  * at least once per second.
1306  */
1307 
1308 #define CXL_MBOX_BG_UPDATE_FREQ 1000UL
1309 
1310 int cxl_process_cci_message(CXLCCI *cci, uint8_t set, uint8_t cmd,
1311                             size_t len_in, uint8_t *pl_in, size_t *len_out,
1312                             uint8_t *pl_out, bool *bg_started)
1313 {
1314     int ret;
1315     const struct cxl_cmd *cxl_cmd;
1316     opcode_handler h;
1317 
1318     *len_out = 0;
1319     cxl_cmd = &cci->cxl_cmd_set[set][cmd];
1320     h = cxl_cmd->handler;
1321     if (!h) {
1322         qemu_log_mask(LOG_UNIMP, "Command %04xh not implemented\n",
1323                       set << 8 | cmd);
1324         return CXL_MBOX_UNSUPPORTED;
1325     }
1326 
1327     if (len_in != cxl_cmd->in && cxl_cmd->in != ~0) {
1328         return CXL_MBOX_INVALID_PAYLOAD_LENGTH;
1329     }
1330 
1331     /* Only one bg command at a time */
1332     if ((cxl_cmd->effect & BACKGROUND_OPERATION) &&
1333         cci->bg.runtime > 0) {
1334         return CXL_MBOX_BUSY;
1335     }
1336 
1337     /* forbid any selected commands while overwriting */
1338     if (sanitize_running(cci)) {
1339         if (h == cmd_events_get_records ||
1340             h == cmd_ccls_get_partition_info ||
1341             h == cmd_ccls_set_lsa ||
1342             h == cmd_ccls_get_lsa ||
1343             h == cmd_logs_get_log ||
1344             h == cmd_media_get_poison_list ||
1345             h == cmd_media_inject_poison ||
1346             h == cmd_media_clear_poison ||
1347             h == cmd_sanitize_overwrite) {
1348             return CXL_MBOX_MEDIA_DISABLED;
1349         }
1350     }
1351 
1352     ret = (*h)(cxl_cmd, pl_in, len_in, pl_out, len_out, cci);
1353     if ((cxl_cmd->effect & BACKGROUND_OPERATION) &&
1354         ret == CXL_MBOX_BG_STARTED) {
1355         *bg_started = true;
1356     } else {
1357         *bg_started = false;
1358     }
1359 
1360     /* Set bg and the return code */
1361     if (*bg_started) {
1362         uint64_t now;
1363 
1364         cci->bg.opcode = (set << 8) | cmd;
1365 
1366         cci->bg.complete_pct = 0;
1367         cci->bg.ret_code = 0;
1368 
1369         now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL);
1370         cci->bg.starttime = now;
1371         timer_mod(cci->bg.timer, now + CXL_MBOX_BG_UPDATE_FREQ);
1372     }
1373 
1374     return ret;
1375 }
1376 
1377 static void bg_timercb(void *opaque)
1378 {
1379     CXLCCI *cci = opaque;
1380     uint64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL);
1381     uint64_t total_time = cci->bg.starttime + cci->bg.runtime;
1382 
1383     assert(cci->bg.runtime > 0);
1384 
1385     if (now >= total_time) { /* we are done */
1386         uint16_t ret = CXL_MBOX_SUCCESS;
1387 
1388         cci->bg.complete_pct = 100;
1389         cci->bg.ret_code = ret;
1390         if (ret == CXL_MBOX_SUCCESS) {
1391             switch (cci->bg.opcode) {
1392             case 0x4400: /* sanitize */
1393             {
1394                 CXLType3Dev *ct3d = CXL_TYPE3(cci->d);
1395 
1396                 __do_sanitization(ct3d);
1397                 cxl_dev_enable_media(&ct3d->cxl_dstate);
1398             }
1399             break;
1400             case 0x4304: /* TODO: scan media */
1401                 break;
1402             default:
1403                 __builtin_unreachable();
1404                 break;
1405             }
1406         }
1407 
1408         qemu_log("Background command %04xh finished: %s\n",
1409                  cci->bg.opcode,
1410                  ret == CXL_MBOX_SUCCESS ? "success" : "aborted");
1411     } else {
1412         /* estimate only */
1413         cci->bg.complete_pct = 100 * now / total_time;
1414         timer_mod(cci->bg.timer, now + CXL_MBOX_BG_UPDATE_FREQ);
1415     }
1416 
1417     if (cci->bg.complete_pct == 100) {
1418         /* TODO: generalize to switch CCI */
1419         CXLType3Dev *ct3d = CXL_TYPE3(cci->d);
1420         CXLDeviceState *cxl_dstate = &ct3d->cxl_dstate;
1421         PCIDevice *pdev = PCI_DEVICE(cci->d);
1422 
1423         cci->bg.starttime = 0;
1424         /* registers are updated, allow new bg-capable cmds */
1425         cci->bg.runtime = 0;
1426 
1427         if (msix_enabled(pdev)) {
1428             msix_notify(pdev, cxl_dstate->mbox_msi_n);
1429         } else if (msi_enabled(pdev)) {
1430             msi_notify(pdev, cxl_dstate->mbox_msi_n);
1431         }
1432     }
1433 }
1434 
1435 void cxl_init_cci(CXLCCI *cci, size_t payload_max)
1436 {
1437     cci->payload_max = payload_max;
1438     for (int set = 0; set < 256; set++) {
1439         for (int cmd = 0; cmd < 256; cmd++) {
1440             if (cci->cxl_cmd_set[set][cmd].handler) {
1441                 const struct cxl_cmd *c = &cci->cxl_cmd_set[set][cmd];
1442                 struct cel_log *log =
1443                     &cci->cel_log[cci->cel_size];
1444 
1445                 log->opcode = (set << 8) | cmd;
1446                 log->effect = c->effect;
1447                 cci->cel_size++;
1448             }
1449         }
1450     }
1451     cci->bg.complete_pct = 0;
1452     cci->bg.starttime = 0;
1453     cci->bg.runtime = 0;
1454     cci->bg.timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
1455                                  bg_timercb, cci);
1456 }
1457 
1458 void cxl_initialize_mailbox_swcci(CXLCCI *cci, DeviceState *intf,
1459                                   DeviceState *d, size_t payload_max)
1460 {
1461     cci->cxl_cmd_set = cxl_cmd_set_sw;
1462     cci->d = d;
1463     cci->intf = intf;
1464     cxl_init_cci(cci, payload_max);
1465 }
1466 
1467 void cxl_initialize_mailbox_t3(CXLCCI *cci, DeviceState *d, size_t payload_max)
1468 {
1469     cci->cxl_cmd_set = cxl_cmd_set;
1470     cci->d = d;
1471 
1472     /* No separation for PCI MB as protocol handled in PCI device */
1473     cci->intf = d;
1474     cxl_init_cci(cci, payload_max);
1475 }
1476 
1477 static const struct cxl_cmd cxl_cmd_set_t3_ld[256][256] = {
1478     [INFOSTAT][IS_IDENTIFY] = { "IDENTIFY", cmd_infostat_identify, 0, 0 },
1479     [LOGS][GET_SUPPORTED] = { "LOGS_GET_SUPPORTED", cmd_logs_get_supported, 0,
1480                               0 },
1481     [LOGS][GET_LOG] = { "LOGS_GET_LOG", cmd_logs_get_log, 0x18, 0 },
1482 };
1483 
1484 void cxl_initialize_t3_ld_cci(CXLCCI *cci, DeviceState *d, DeviceState *intf,
1485                                size_t payload_max)
1486 {
1487     cci->cxl_cmd_set = cxl_cmd_set_t3_ld;
1488     cci->d = d;
1489     cci->intf = intf;
1490     cxl_init_cci(cci, payload_max);
1491 }
1492 
1493 static const struct cxl_cmd cxl_cmd_set_t3_fm_owned_ld_mctp[256][256] = {
1494     [INFOSTAT][IS_IDENTIFY] = { "IDENTIFY", cmd_infostat_identify, 0,  0},
1495     [LOGS][GET_SUPPORTED] = { "LOGS_GET_SUPPORTED", cmd_logs_get_supported, 0,
1496                               0 },
1497     [LOGS][GET_LOG] = { "LOGS_GET_LOG", cmd_logs_get_log, 0x18, 0 },
1498     [TIMESTAMP][GET] = { "TIMESTAMP_GET", cmd_timestamp_get, 0, 0 },
1499     [TUNNEL][MANAGEMENT_COMMAND] = { "TUNNEL_MANAGEMENT_COMMAND",
1500                                      cmd_tunnel_management_cmd, ~0, 0 },
1501 };
1502 
1503 void cxl_initialize_t3_fm_owned_ld_mctpcci(CXLCCI *cci, DeviceState *d,
1504                                            DeviceState *intf,
1505                                            size_t payload_max)
1506 {
1507     cci->cxl_cmd_set = cxl_cmd_set_t3_fm_owned_ld_mctp;
1508     cci->d = d;
1509     cci->intf = intf;
1510     cxl_init_cci(cci, payload_max);
1511 }
1512