2 * CXL Utility library for mailbox interface
4 * Copyright(C) 2020 Intel Corporation.
6 * This work is licensed under the terms of the GNU GPL, version 2. See the
7 * COPYING file in the top-level directory.
10 #include "qemu/osdep.h"
11 #include "hw/cxl/cxl.h"
12 #include "hw/pci/pci.h"
13 #include "qemu/cutils.h"
15 #include "qemu/units.h"
16 #include "qemu/uuid.h"
18 #define CXL_CAPACITY_MULTIPLIER (256 * MiB)
21 * How to add a new command, example. The command set FOO, with cmd BAR.
22 * 1. Add the command set and cmd to the enum.
25 * 2. Implement the handler
26 * static ret_code cmd_foo_bar(struct cxl_cmd *cmd,
27 * CXLDeviceState *cxl_dstate, uint16_t *len)
28 * 3. Add the command to the cxl_cmd_set[][]
29 * [FOO][BAR] = { "FOO_BAR", cmd_foo_bar, x, y },
30 * 4. Implement your handler
31 * define_mailbox_handler(FOO_BAR) { ... return CXL_MBOX_SUCCESS; }
34 * Writing the handler:
35 * The handler will provide the &struct cxl_cmd, the &CXLDeviceState, and the
36 * in/out length of the payload. The handler is responsible for consuming the
37 * payload from cmd->payload and operating upon it as necessary. It must then
38 * fill the output data into cmd->payload (overwriting what was there),
39 * setting the length, and returning a valid return code.
41 * XXX: The handler need not worry about endianess. The payload is read out of
42 * a register interface that already deals with it.
47 #define GET_RECORDS 0x0
48 #define CLEAR_RECORDS 0x1
49 #define GET_INTERRUPT_POLICY 0x2
50 #define SET_INTERRUPT_POLICY 0x3
51 FIRMWARE_UPDATE
= 0x02,
57 #define GET_SUPPORTED 0x0
60 #define MEMORY_DEVICE 0x0
62 #define GET_PARTITION_INFO 0x0
67 /* 8.2.8.4.5.1 Command Return Codes */
69 CXL_MBOX_SUCCESS
= 0x0,
70 CXL_MBOX_BG_STARTED
= 0x1,
71 CXL_MBOX_INVALID_INPUT
= 0x2,
72 CXL_MBOX_UNSUPPORTED
= 0x3,
73 CXL_MBOX_INTERNAL_ERROR
= 0x4,
74 CXL_MBOX_RETRY_REQUIRED
= 0x5,
76 CXL_MBOX_MEDIA_DISABLED
= 0x7,
77 CXL_MBOX_FW_XFER_IN_PROGRESS
= 0x8,
78 CXL_MBOX_FW_XFER_OUT_OF_ORDER
= 0x9,
79 CXL_MBOX_FW_AUTH_FAILED
= 0xa,
80 CXL_MBOX_FW_INVALID_SLOT
= 0xb,
81 CXL_MBOX_FW_ROLLEDBACK
= 0xc,
82 CXL_MBOX_FW_REST_REQD
= 0xd,
83 CXL_MBOX_INVALID_HANDLE
= 0xe,
84 CXL_MBOX_INVALID_PA
= 0xf,
85 CXL_MBOX_INJECT_POISON_LIMIT
= 0x10,
86 CXL_MBOX_PERMANENT_MEDIA_FAILURE
= 0x11,
87 CXL_MBOX_ABORTED
= 0x12,
88 CXL_MBOX_INVALID_SECURITY_STATE
= 0x13,
89 CXL_MBOX_INCORRECT_PASSPHRASE
= 0x14,
90 CXL_MBOX_UNSUPPORTED_MAILBOX
= 0x15,
91 CXL_MBOX_INVALID_PAYLOAD_LENGTH
= 0x16,
96 typedef ret_code (*opcode_handler
)(struct cxl_cmd
*cmd
,
97 CXLDeviceState
*cxl_dstate
, uint16_t *len
);
100 opcode_handler handler
;
102 uint16_t effect
; /* Reported in CEL */
106 #define DEFINE_MAILBOX_HANDLER_ZEROED(name, size) \
107 uint16_t __zero##name = size; \
108 static ret_code cmd_##name(struct cxl_cmd *cmd, \
109 CXLDeviceState *cxl_dstate, uint16_t *len) \
111 *len = __zero##name; \
112 memset(cmd->payload, 0, *len); \
113 return CXL_MBOX_SUCCESS; \
115 #define DEFINE_MAILBOX_HANDLER_NOP(name) \
116 static ret_code cmd_##name(struct cxl_cmd *cmd, \
117 CXLDeviceState *cxl_dstate, uint16_t *len) \
119 return CXL_MBOX_SUCCESS; \
122 DEFINE_MAILBOX_HANDLER_ZEROED(events_get_records
, 0x20);
123 DEFINE_MAILBOX_HANDLER_NOP(events_clear_records
);
124 DEFINE_MAILBOX_HANDLER_ZEROED(events_get_interrupt_policy
, 4);
125 DEFINE_MAILBOX_HANDLER_NOP(events_set_interrupt_policy
);
128 static ret_code
cmd_firmware_update_get_info(struct cxl_cmd
*cmd
,
129 CXLDeviceState
*cxl_dstate
,
133 uint8_t slots_supported
;
141 } QEMU_PACKED
*fw_info
;
142 QEMU_BUILD_BUG_ON(sizeof(*fw_info
) != 0x50);
144 if (cxl_dstate
->pmem_size
< CXL_CAPACITY_MULTIPLIER
) {
145 return CXL_MBOX_INTERNAL_ERROR
;
148 fw_info
= (void *)cmd
->payload
;
149 memset(fw_info
, 0, sizeof(*fw_info
));
151 fw_info
->slots_supported
= 2;
152 fw_info
->slot_info
= BIT(0) | BIT(3);
154 pstrcpy(fw_info
->fw_rev1
, sizeof(fw_info
->fw_rev1
), "BWFW VERSION 0");
156 *len
= sizeof(*fw_info
);
157 return CXL_MBOX_SUCCESS
;
161 static ret_code
cmd_timestamp_get(struct cxl_cmd
*cmd
,
162 CXLDeviceState
*cxl_dstate
,
165 uint64_t time
, delta
;
166 uint64_t final_time
= 0;
168 if (cxl_dstate
->timestamp
.set
) {
169 /* First find the delta from the last time the host set the time. */
170 time
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
171 delta
= time
- cxl_dstate
->timestamp
.last_set
;
172 final_time
= cxl_dstate
->timestamp
.host_set
+ delta
;
175 /* Then adjust the actual time */
176 stq_le_p(cmd
->payload
, final_time
);
179 return CXL_MBOX_SUCCESS
;
183 static ret_code
cmd_timestamp_set(struct cxl_cmd
*cmd
,
184 CXLDeviceState
*cxl_dstate
,
187 cxl_dstate
->timestamp
.set
= true;
188 cxl_dstate
->timestamp
.last_set
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
190 cxl_dstate
->timestamp
.host_set
= le64_to_cpu(*(uint64_t *)cmd
->payload
);
193 return CXL_MBOX_SUCCESS
;
196 /* CXL 3.0 8.2.9.5.2.1 Command Effects Log (CEL) */
197 static const QemuUUID cel_uuid
= {
198 .data
= UUID(0x0da9c0b5, 0xbf41, 0x4b78, 0x8f, 0x79,
199 0x96, 0xb1, 0x62, 0x3b, 0x3f, 0x17)
203 static ret_code
cmd_logs_get_supported(struct cxl_cmd
*cmd
,
204 CXLDeviceState
*cxl_dstate
,
214 } QEMU_PACKED
*supported_logs
= (void *)cmd
->payload
;
215 QEMU_BUILD_BUG_ON(sizeof(*supported_logs
) != 0x1c);
217 supported_logs
->entries
= 1;
218 supported_logs
->log_entries
[0].uuid
= cel_uuid
;
219 supported_logs
->log_entries
[0].size
= 4 * cxl_dstate
->cel_size
;
221 *len
= sizeof(*supported_logs
);
222 return CXL_MBOX_SUCCESS
;
226 static ret_code
cmd_logs_get_log(struct cxl_cmd
*cmd
,
227 CXLDeviceState
*cxl_dstate
,
234 } QEMU_PACKED
QEMU_ALIGNED(16) *get_log
= (void *)cmd
->payload
;
238 * The device shall return Invalid Parameter if the Offset or Length
239 * fields attempt to access beyond the size of the log as reported by Get
242 * XXX: Spec is wrong, "Invalid Parameter" isn't a thing.
243 * XXX: Spec doesn't address incorrect UUID incorrectness.
245 * The CEL buffer is large enough to fit all commands in the emulation, so
246 * the only possible failure would be if the mailbox itself isn't big
249 if (get_log
->offset
+ get_log
->length
> cxl_dstate
->payload_size
) {
250 return CXL_MBOX_INVALID_INPUT
;
253 if (!qemu_uuid_is_equal(&get_log
->uuid
, &cel_uuid
)) {
254 return CXL_MBOX_UNSUPPORTED
;
257 /* Store off everything to local variables so we can wipe out the payload */
258 *len
= get_log
->length
;
260 memmove(cmd
->payload
, cxl_dstate
->cel_log
+ get_log
->offset
,
263 return CXL_MBOX_SUCCESS
;
267 static ret_code
cmd_identify_memory_device(struct cxl_cmd
*cmd
,
268 CXLDeviceState
*cxl_dstate
,
272 char fw_revision
[0x10];
273 uint64_t total_capacity
;
274 uint64_t volatile_capacity
;
275 uint64_t persistent_capacity
;
276 uint64_t partition_align
;
277 uint16_t info_event_log_size
;
278 uint16_t warning_event_log_size
;
279 uint16_t failure_event_log_size
;
280 uint16_t fatal_event_log_size
;
282 uint8_t poison_list_max_mer
[3];
283 uint16_t inject_poison_limit
;
285 uint8_t qos_telemetry_caps
;
287 QEMU_BUILD_BUG_ON(sizeof(*id
) != 0x43);
289 CXLType3Dev
*ct3d
= container_of(cxl_dstate
, CXLType3Dev
, cxl_dstate
);
290 CXLType3Class
*cvc
= CXL_TYPE3_GET_CLASS(ct3d
);
291 uint64_t size
= cxl_dstate
->pmem_size
;
293 if (!QEMU_IS_ALIGNED(size
, CXL_CAPACITY_MULTIPLIER
)) {
294 return CXL_MBOX_INTERNAL_ERROR
;
297 id
= (void *)cmd
->payload
;
298 memset(id
, 0, sizeof(*id
));
301 snprintf(id
->fw_revision
, 0x10, "BWFW VERSION %02d", 0);
303 id
->total_capacity
= size
/ CXL_CAPACITY_MULTIPLIER
;
304 id
->persistent_capacity
= size
/ CXL_CAPACITY_MULTIPLIER
;
305 id
->lsa_size
= cvc
->get_lsa_size(ct3d
);
308 return CXL_MBOX_SUCCESS
;
311 static ret_code
cmd_ccls_get_partition_info(struct cxl_cmd
*cmd
,
312 CXLDeviceState
*cxl_dstate
,
316 uint64_t active_vmem
;
317 uint64_t active_pmem
;
320 } QEMU_PACKED
*part_info
= (void *)cmd
->payload
;
321 QEMU_BUILD_BUG_ON(sizeof(*part_info
) != 0x20);
322 uint64_t size
= cxl_dstate
->pmem_size
;
324 if (!QEMU_IS_ALIGNED(size
, CXL_CAPACITY_MULTIPLIER
)) {
325 return CXL_MBOX_INTERNAL_ERROR
;
329 part_info
->active_vmem
= 0;
330 part_info
->next_vmem
= 0;
331 part_info
->active_pmem
= size
/ CXL_CAPACITY_MULTIPLIER
;
332 part_info
->next_pmem
= 0;
334 *len
= sizeof(*part_info
);
335 return CXL_MBOX_SUCCESS
;
338 static ret_code
cmd_ccls_get_lsa(struct cxl_cmd
*cmd
,
339 CXLDeviceState
*cxl_dstate
,
345 } QEMU_PACKED
*get_lsa
;
346 CXLType3Dev
*ct3d
= container_of(cxl_dstate
, CXLType3Dev
, cxl_dstate
);
347 CXLType3Class
*cvc
= CXL_TYPE3_GET_CLASS(ct3d
);
348 uint32_t offset
, length
;
350 get_lsa
= (void *)cmd
->payload
;
351 offset
= get_lsa
->offset
;
352 length
= get_lsa
->length
;
354 if (offset
+ length
> cvc
->get_lsa_size(ct3d
)) {
356 return CXL_MBOX_INVALID_INPUT
;
359 *len
= cvc
->get_lsa(ct3d
, get_lsa
, length
, offset
);
360 return CXL_MBOX_SUCCESS
;
363 static ret_code
cmd_ccls_set_lsa(struct cxl_cmd
*cmd
,
364 CXLDeviceState
*cxl_dstate
,
372 struct set_lsa_pl
*set_lsa_payload
= (void *)cmd
->payload
;
373 CXLType3Dev
*ct3d
= container_of(cxl_dstate
, CXLType3Dev
, cxl_dstate
);
374 CXLType3Class
*cvc
= CXL_TYPE3_GET_CLASS(ct3d
);
375 const size_t hdr_len
= offsetof(struct set_lsa_pl
, data
);
376 uint16_t plen
= *len
;
380 return CXL_MBOX_SUCCESS
;
383 if (set_lsa_payload
->offset
+ plen
> cvc
->get_lsa_size(ct3d
) + hdr_len
) {
384 return CXL_MBOX_INVALID_INPUT
;
388 cvc
->set_lsa(ct3d
, set_lsa_payload
->data
, plen
, set_lsa_payload
->offset
);
389 return CXL_MBOX_SUCCESS
;
392 #define IMMEDIATE_CONFIG_CHANGE (1 << 1)
393 #define IMMEDIATE_DATA_CHANGE (1 << 2)
394 #define IMMEDIATE_POLICY_CHANGE (1 << 3)
395 #define IMMEDIATE_LOG_CHANGE (1 << 4)
397 static struct cxl_cmd cxl_cmd_set
[256][256] = {
398 [EVENTS
][GET_RECORDS
] = { "EVENTS_GET_RECORDS",
399 cmd_events_get_records
, 1, 0 },
400 [EVENTS
][CLEAR_RECORDS
] = { "EVENTS_CLEAR_RECORDS",
401 cmd_events_clear_records
, ~0, IMMEDIATE_LOG_CHANGE
},
402 [EVENTS
][GET_INTERRUPT_POLICY
] = { "EVENTS_GET_INTERRUPT_POLICY",
403 cmd_events_get_interrupt_policy
, 0, 0 },
404 [EVENTS
][SET_INTERRUPT_POLICY
] = { "EVENTS_SET_INTERRUPT_POLICY",
405 cmd_events_set_interrupt_policy
, 4, IMMEDIATE_CONFIG_CHANGE
},
406 [FIRMWARE_UPDATE
][GET_INFO
] = { "FIRMWARE_UPDATE_GET_INFO",
407 cmd_firmware_update_get_info
, 0, 0 },
408 [TIMESTAMP
][GET
] = { "TIMESTAMP_GET", cmd_timestamp_get
, 0, 0 },
409 [TIMESTAMP
][SET
] = { "TIMESTAMP_SET", cmd_timestamp_set
, 8, IMMEDIATE_POLICY_CHANGE
},
410 [LOGS
][GET_SUPPORTED
] = { "LOGS_GET_SUPPORTED", cmd_logs_get_supported
, 0, 0 },
411 [LOGS
][GET_LOG
] = { "LOGS_GET_LOG", cmd_logs_get_log
, 0x18, 0 },
412 [IDENTIFY
][MEMORY_DEVICE
] = { "IDENTIFY_MEMORY_DEVICE",
413 cmd_identify_memory_device
, 0, 0 },
414 [CCLS
][GET_PARTITION_INFO
] = { "CCLS_GET_PARTITION_INFO",
415 cmd_ccls_get_partition_info
, 0, 0 },
416 [CCLS
][GET_LSA
] = { "CCLS_GET_LSA", cmd_ccls_get_lsa
, 8, 0 },
417 [CCLS
][SET_LSA
] = { "CCLS_SET_LSA", cmd_ccls_set_lsa
,
418 ~0, IMMEDIATE_CONFIG_CHANGE
| IMMEDIATE_DATA_CHANGE
},
421 void cxl_process_mailbox(CXLDeviceState
*cxl_dstate
)
423 uint16_t ret
= CXL_MBOX_SUCCESS
;
424 struct cxl_cmd
*cxl_cmd
;
427 uint64_t command_reg
= cxl_dstate
->mbox_reg_state64
[R_CXL_DEV_MAILBOX_CMD
];
429 uint8_t set
= FIELD_EX64(command_reg
, CXL_DEV_MAILBOX_CMD
, COMMAND_SET
);
430 uint8_t cmd
= FIELD_EX64(command_reg
, CXL_DEV_MAILBOX_CMD
, COMMAND
);
431 uint16_t len
= FIELD_EX64(command_reg
, CXL_DEV_MAILBOX_CMD
, LENGTH
);
432 cxl_cmd
= &cxl_cmd_set
[set
][cmd
];
433 h
= cxl_cmd
->handler
;
435 if (len
== cxl_cmd
->in
|| cxl_cmd
->in
== ~0) {
436 cxl_cmd
->payload
= cxl_dstate
->mbox_reg_state
+
437 A_CXL_DEV_CMD_PAYLOAD
;
438 ret
= (*h
)(cxl_cmd
, cxl_dstate
, &len
);
439 assert(len
<= cxl_dstate
->payload_size
);
441 ret
= CXL_MBOX_INVALID_PAYLOAD_LENGTH
;
444 qemu_log_mask(LOG_UNIMP
, "Command %04xh not implemented\n",
446 ret
= CXL_MBOX_UNSUPPORTED
;
449 /* Set the return code */
450 status_reg
= FIELD_DP64(0, CXL_DEV_MAILBOX_STS
, ERRNO
, ret
);
452 /* Set the return length */
453 command_reg
= FIELD_DP64(command_reg
, CXL_DEV_MAILBOX_CMD
, COMMAND_SET
, 0);
454 command_reg
= FIELD_DP64(command_reg
, CXL_DEV_MAILBOX_CMD
, COMMAND
, 0);
455 command_reg
= FIELD_DP64(command_reg
, CXL_DEV_MAILBOX_CMD
, LENGTH
, len
);
457 cxl_dstate
->mbox_reg_state64
[R_CXL_DEV_MAILBOX_CMD
] = command_reg
;
458 cxl_dstate
->mbox_reg_state64
[R_CXL_DEV_MAILBOX_STS
] = status_reg
;
460 /* Tell the host we're done */
461 ARRAY_FIELD_DP32(cxl_dstate
->mbox_reg_state32
, CXL_DEV_MAILBOX_CTRL
,
465 void cxl_initialize_mailbox(CXLDeviceState
*cxl_dstate
)
467 for (int set
= 0; set
< 256; set
++) {
468 for (int cmd
= 0; cmd
< 256; cmd
++) {
469 if (cxl_cmd_set
[set
][cmd
].handler
) {
470 struct cxl_cmd
*c
= &cxl_cmd_set
[set
][cmd
];
471 struct cel_log
*log
=
472 &cxl_dstate
->cel_log
[cxl_dstate
->cel_size
];
474 log
->opcode
= (set
<< 8) | cmd
;
475 log
->effect
= c
->effect
;
476 cxl_dstate
->cel_size
++;