1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Copyright (c) 2003-2020, Intel Corporation. All rights reserved
4 * Intel Management Engine Interface (Intel MEI) Linux driver
5 */
6
7 #ifndef _MEI_HW_TYPES_H_
8 #define _MEI_HW_TYPES_H_
9
10 #include <linux/uuid.h>
11
12 /*
13 * Timeouts in Seconds
14 */
15 #define MEI_HW_READY_TIMEOUT 2 /* Timeout on ready message */
16 #define MEI_CONNECT_TIMEOUT 3 /* HPS: at least 2 seconds */
17
18 #define MEI_CL_CONNECT_TIMEOUT 15 /* HPS: Client Connect Timeout */
19 #define MEI_CLIENTS_INIT_TIMEOUT 15 /* HPS: Clients Enumeration Timeout */
20
21 #define MEI_PGI_TIMEOUT 1 /* PG Isolation time response 1 sec */
22 #define MEI_D0I3_TIMEOUT 5 /* D0i3 set/unset max response time */
23 #define MEI_HBM_TIMEOUT 1 /* 1 second */
24
25 /*
26 * FW page size for DMA allocations
27 */
28 #define MEI_FW_PAGE_SIZE 4096UL
29
30 /*
31 * MEI Version
32 */
33 #define HBM_MINOR_VERSION 2
34 #define HBM_MAJOR_VERSION 2
35
36 /*
37 * MEI version with PGI support
38 */
39 #define HBM_MINOR_VERSION_PGI 1
40 #define HBM_MAJOR_VERSION_PGI 1
41
42 /*
43 * MEI version with Dynamic clients support
44 */
45 #define HBM_MINOR_VERSION_DC 0
46 #define HBM_MAJOR_VERSION_DC 2
47
48 /*
49 * MEI version with immediate reply to enum request support
50 */
51 #define HBM_MINOR_VERSION_IE 0
52 #define HBM_MAJOR_VERSION_IE 2
53
54 /*
55 * MEI version with disconnect on connection timeout support
56 */
57 #define HBM_MINOR_VERSION_DOT 0
58 #define HBM_MAJOR_VERSION_DOT 2
59
60 /*
61 * MEI version with notification support
62 */
63 #define HBM_MINOR_VERSION_EV 0
64 #define HBM_MAJOR_VERSION_EV 2
65
66 /*
67 * MEI version with fixed address client support
68 */
69 #define HBM_MINOR_VERSION_FA 0
70 #define HBM_MAJOR_VERSION_FA 2
71
72 /*
73 * MEI version with OS ver message support
74 */
75 #define HBM_MINOR_VERSION_OS 0
76 #define HBM_MAJOR_VERSION_OS 2
77
78 /*
79 * MEI version with dma ring support
80 */
81 #define HBM_MINOR_VERSION_DR 1
82 #define HBM_MAJOR_VERSION_DR 2
83
84 /*
85 * MEI version with vm tag support
86 */
87 #define HBM_MINOR_VERSION_VT 2
88 #define HBM_MAJOR_VERSION_VT 2
89
90 /*
91 * MEI version with capabilities message support
92 */
93 #define HBM_MINOR_VERSION_CAP 2
94 #define HBM_MAJOR_VERSION_CAP 2
95
96 /*
97 * MEI version with client DMA support
98 */
99 #define HBM_MINOR_VERSION_CD 2
100 #define HBM_MAJOR_VERSION_CD 2
101
102 /* Host bus message command opcode */
103 #define MEI_HBM_CMD_OP_MSK 0x7f
104 /* Host bus message command RESPONSE */
105 #define MEI_HBM_CMD_RES_MSK 0x80
106
107 /*
108 * MEI Bus Message Command IDs
109 */
110 #define HOST_START_REQ_CMD 0x01
111 #define HOST_START_RES_CMD 0x81
112
113 #define HOST_STOP_REQ_CMD 0x02
114 #define HOST_STOP_RES_CMD 0x82
115
116 #define ME_STOP_REQ_CMD 0x03
117
118 #define HOST_ENUM_REQ_CMD 0x04
119 #define HOST_ENUM_RES_CMD 0x84
120
121 #define HOST_CLIENT_PROPERTIES_REQ_CMD 0x05
122 #define HOST_CLIENT_PROPERTIES_RES_CMD 0x85
123
124 #define CLIENT_CONNECT_REQ_CMD 0x06
125 #define CLIENT_CONNECT_RES_CMD 0x86
126
127 #define CLIENT_DISCONNECT_REQ_CMD 0x07
128 #define CLIENT_DISCONNECT_RES_CMD 0x87
129
130 #define MEI_FLOW_CONTROL_CMD 0x08
131
132 #define MEI_PG_ISOLATION_ENTRY_REQ_CMD 0x0a
133 #define MEI_PG_ISOLATION_ENTRY_RES_CMD 0x8a
134 #define MEI_PG_ISOLATION_EXIT_REQ_CMD 0x0b
135 #define MEI_PG_ISOLATION_EXIT_RES_CMD 0x8b
136
137 #define MEI_HBM_ADD_CLIENT_REQ_CMD 0x0f
138 #define MEI_HBM_ADD_CLIENT_RES_CMD 0x8f
139
140 #define MEI_HBM_NOTIFY_REQ_CMD 0x10
141 #define MEI_HBM_NOTIFY_RES_CMD 0x90
142 #define MEI_HBM_NOTIFICATION_CMD 0x11
143
144 #define MEI_HBM_DMA_SETUP_REQ_CMD 0x12
145 #define MEI_HBM_DMA_SETUP_RES_CMD 0x92
146
147 #define MEI_HBM_CAPABILITIES_REQ_CMD 0x13
148 #define MEI_HBM_CAPABILITIES_RES_CMD 0x93
149
150 #define MEI_HBM_CLIENT_DMA_MAP_REQ_CMD 0x14
151 #define MEI_HBM_CLIENT_DMA_MAP_RES_CMD 0x94
152
153 #define MEI_HBM_CLIENT_DMA_UNMAP_REQ_CMD 0x15
154 #define MEI_HBM_CLIENT_DMA_UNMAP_RES_CMD 0x95
155
156 /*
157 * MEI Stop Reason
158 * used by hbm_host_stop_request.reason
159 */
160 enum mei_stop_reason_types {
161 DRIVER_STOP_REQUEST = 0x00,
162 DEVICE_D1_ENTRY = 0x01,
163 DEVICE_D2_ENTRY = 0x02,
164 DEVICE_D3_ENTRY = 0x03,
165 SYSTEM_S1_ENTRY = 0x04,
166 SYSTEM_S2_ENTRY = 0x05,
167 SYSTEM_S3_ENTRY = 0x06,
168 SYSTEM_S4_ENTRY = 0x07,
169 SYSTEM_S5_ENTRY = 0x08
170 };
171
172
173 /**
174 * enum mei_hbm_status - mei host bus messages return values
175 *
176 * @MEI_HBMS_SUCCESS : status success
177 * @MEI_HBMS_CLIENT_NOT_FOUND : client not found
178 * @MEI_HBMS_ALREADY_EXISTS : connection already established
179 * @MEI_HBMS_REJECTED : connection is rejected
180 * @MEI_HBMS_INVALID_PARAMETER : invalid parameter
181 * @MEI_HBMS_NOT_ALLOWED : operation not allowed
182 * @MEI_HBMS_ALREADY_STARTED : system is already started
183 * @MEI_HBMS_NOT_STARTED : system not started
184 *
185 * @MEI_HBMS_MAX : sentinel
186 */
187 enum mei_hbm_status {
188 MEI_HBMS_SUCCESS = 0,
189 MEI_HBMS_CLIENT_NOT_FOUND = 1,
190 MEI_HBMS_ALREADY_EXISTS = 2,
191 MEI_HBMS_REJECTED = 3,
192 MEI_HBMS_INVALID_PARAMETER = 4,
193 MEI_HBMS_NOT_ALLOWED = 5,
194 MEI_HBMS_ALREADY_STARTED = 6,
195 MEI_HBMS_NOT_STARTED = 7,
196
197 MEI_HBMS_MAX
198 };
199
200
201 /*
202 * Client Connect Status
203 * used by hbm_client_connect_response.status
204 */
205 enum mei_cl_connect_status {
206 MEI_CL_CONN_SUCCESS = MEI_HBMS_SUCCESS,
207 MEI_CL_CONN_NOT_FOUND = MEI_HBMS_CLIENT_NOT_FOUND,
208 MEI_CL_CONN_ALREADY_STARTED = MEI_HBMS_ALREADY_EXISTS,
209 MEI_CL_CONN_OUT_OF_RESOURCES = MEI_HBMS_REJECTED,
210 MEI_CL_CONN_MESSAGE_SMALL = MEI_HBMS_INVALID_PARAMETER,
211 MEI_CL_CONN_NOT_ALLOWED = MEI_HBMS_NOT_ALLOWED,
212 };
213
214 /*
215 * Client Disconnect Status
216 */
217 enum mei_cl_disconnect_status {
218 MEI_CL_DISCONN_SUCCESS = MEI_HBMS_SUCCESS
219 };
220
221 /**
222 * enum mei_ext_hdr_type - extended header type used in
223 * extended header TLV
224 *
225 * @MEI_EXT_HDR_NONE: sentinel
226 * @MEI_EXT_HDR_VTAG: vtag header
227 */
228 enum mei_ext_hdr_type {
229 MEI_EXT_HDR_NONE = 0,
230 MEI_EXT_HDR_VTAG = 1,
231 };
232
233 /**
234 * struct mei_ext_hdr - extend header descriptor (TLV)
235 * @type: enum mei_ext_hdr_type
236 * @length: length excluding descriptor
237 * @ext_payload: payload of the specific extended header
238 * @hdr: place holder for actual header
239 */
240 struct mei_ext_hdr {
241 u8 type;
242 u8 length;
243 u8 data[];
244 } __packed;
245
246 /**
247 * struct mei_ext_meta_hdr - extend header meta data
248 * @count: number of headers
249 * @size: total size of the extended header list excluding meta header
250 * @reserved: reserved
251 * @hdrs: extended headers TLV list
252 */
253 struct mei_ext_meta_hdr {
254 u8 count;
255 u8 size;
256 u8 reserved[2];
257 u8 hdrs[];
258 } __packed;
259
260 /**
261 * struct mei_ext_hdr_vtag - extend header for vtag
262 *
263 * @hdr: standard extend header
264 * @vtag: virtual tag
265 * @reserved: reserved
266 */
267 struct mei_ext_hdr_vtag {
268 struct mei_ext_hdr hdr;
269 u8 vtag;
270 u8 reserved;
271 } __packed;
272
273 /*
274 * Extended header iterator functions
275 */
276 /**
277 * mei_ext_hdr - extended header iterator begin
278 *
279 * @meta: meta header of the extended header list
280 *
281 * Return:
282 * The first extended header
283 */
mei_ext_begin(struct mei_ext_meta_hdr * meta)284 static inline struct mei_ext_hdr *mei_ext_begin(struct mei_ext_meta_hdr *meta)
285 {
286 return (struct mei_ext_hdr *)meta->hdrs;
287 }
288
289 /**
290 * mei_ext_last - check if the ext is the last one in the TLV list
291 *
292 * @meta: meta header of the extended header list
293 * @ext: a meta header on the list
294 *
295 * Return: true if ext is the last header on the list
296 */
mei_ext_last(struct mei_ext_meta_hdr * meta,struct mei_ext_hdr * ext)297 static inline bool mei_ext_last(struct mei_ext_meta_hdr *meta,
298 struct mei_ext_hdr *ext)
299 {
300 return (u8 *)ext >= (u8 *)meta + sizeof(*meta) + (meta->size * 4);
301 }
302
303 /**
304 * mei_ext_next - following extended header on the TLV list
305 *
306 * @ext: current extend header
307 *
308 * Context: The function does not check for the overflows,
309 * one should call mei_ext_last before.
310 *
311 * Return: The following extend header after @ext
312 */
mei_ext_next(struct mei_ext_hdr * ext)313 static inline struct mei_ext_hdr *mei_ext_next(struct mei_ext_hdr *ext)
314 {
315 return (struct mei_ext_hdr *)((u8 *)ext + (ext->length * 4));
316 }
317
318 /**
319 * struct mei_msg_hdr - MEI BUS Interface Section
320 *
321 * @me_addr: device address
322 * @host_addr: host address
323 * @length: message length
324 * @reserved: reserved
325 * @extended: message has extended header
326 * @dma_ring: message is on dma ring
327 * @internal: message is internal
328 * @msg_complete: last packet of the message
329 * @extension: extension of the header
330 */
331 struct mei_msg_hdr {
332 u32 me_addr:8;
333 u32 host_addr:8;
334 u32 length:9;
335 u32 reserved:3;
336 u32 extended:1;
337 u32 dma_ring:1;
338 u32 internal:1;
339 u32 msg_complete:1;
340 u32 extension[];
341 } __packed;
342
343 /* The length is up to 9 bits */
344 #define MEI_MSG_MAX_LEN_MASK GENMASK(9, 0)
345
346 struct mei_bus_message {
347 u8 hbm_cmd;
348 u8 data[];
349 } __packed;
350
351 /**
352 * struct hbm_cl_cmd - client specific host bus command
353 * CONNECT, DISCONNECT, and FlOW CONTROL
354 *
355 * @hbm_cmd: bus message command header
356 * @me_addr: address of the client in ME
357 * @host_addr: address of the client in the driver
358 * @data: generic data
359 */
360 struct mei_hbm_cl_cmd {
361 u8 hbm_cmd;
362 u8 me_addr;
363 u8 host_addr;
364 u8 data;
365 };
366
367 struct hbm_version {
368 u8 minor_version;
369 u8 major_version;
370 } __packed;
371
372 struct hbm_host_version_request {
373 u8 hbm_cmd;
374 u8 reserved;
375 struct hbm_version host_version;
376 } __packed;
377
378 struct hbm_host_version_response {
379 u8 hbm_cmd;
380 u8 host_version_supported;
381 struct hbm_version me_max_version;
382 } __packed;
383
384 struct hbm_host_stop_request {
385 u8 hbm_cmd;
386 u8 reason;
387 u8 reserved[2];
388 } __packed;
389
390 struct hbm_host_stop_response {
391 u8 hbm_cmd;
392 u8 reserved[3];
393 } __packed;
394
395 struct hbm_me_stop_request {
396 u8 hbm_cmd;
397 u8 reason;
398 u8 reserved[2];
399 } __packed;
400
401 /**
402 * enum hbm_host_enum_flags - enumeration request flags (HBM version >= 2.0)
403 *
404 * @MEI_HBM_ENUM_F_ALLOW_ADD: allow dynamic clients add
405 * @MEI_HBM_ENUM_F_IMMEDIATE_ENUM: allow FW to send answer immediately
406 */
407 enum hbm_host_enum_flags {
408 MEI_HBM_ENUM_F_ALLOW_ADD = BIT(0),
409 MEI_HBM_ENUM_F_IMMEDIATE_ENUM = BIT(1),
410 };
411
412 /**
413 * struct hbm_host_enum_request - enumeration request from host to fw
414 *
415 * @hbm_cmd : bus message command header
416 * @flags : request flags
417 * @reserved: reserved
418 */
419 struct hbm_host_enum_request {
420 u8 hbm_cmd;
421 u8 flags;
422 u8 reserved[2];
423 } __packed;
424
425 struct hbm_host_enum_response {
426 u8 hbm_cmd;
427 u8 reserved[3];
428 u8 valid_addresses[32];
429 } __packed;
430
431 /**
432 * struct mei_client_properties - mei client properties
433 *
434 * @protocol_name: guid of the client
435 * @protocol_version: client protocol version
436 * @max_number_of_connections: number of possible connections.
437 * @fixed_address: fixed me address (0 if the client is dynamic)
438 * @single_recv_buf: 1 if all connections share a single receive buffer.
439 * @vt_supported: the client support vtag
440 * @reserved: reserved
441 * @max_msg_length: MTU of the client
442 */
443 struct mei_client_properties {
444 uuid_le protocol_name;
445 u8 protocol_version;
446 u8 max_number_of_connections;
447 u8 fixed_address;
448 u8 single_recv_buf:1;
449 u8 vt_supported:1;
450 u8 reserved:6;
451 u32 max_msg_length;
452 } __packed;
453
454 struct hbm_props_request {
455 u8 hbm_cmd;
456 u8 me_addr;
457 u8 reserved[2];
458 } __packed;
459
460 struct hbm_props_response {
461 u8 hbm_cmd;
462 u8 me_addr;
463 u8 status;
464 u8 reserved;
465 struct mei_client_properties client_properties;
466 } __packed;
467
468 /**
469 * struct hbm_add_client_request - request to add a client
470 * might be sent by fw after enumeration has already completed
471 *
472 * @hbm_cmd: bus message command header
473 * @me_addr: address of the client in ME
474 * @reserved: reserved
475 * @client_properties: client properties
476 */
477 struct hbm_add_client_request {
478 u8 hbm_cmd;
479 u8 me_addr;
480 u8 reserved[2];
481 struct mei_client_properties client_properties;
482 } __packed;
483
484 /**
485 * struct hbm_add_client_response - response to add a client
486 * sent by the host to report client addition status to fw
487 *
488 * @hbm_cmd: bus message command header
489 * @me_addr: address of the client in ME
490 * @status: if HBMS_SUCCESS then the client can now accept connections.
491 * @reserved: reserved
492 */
493 struct hbm_add_client_response {
494 u8 hbm_cmd;
495 u8 me_addr;
496 u8 status;
497 u8 reserved;
498 } __packed;
499
500 /**
501 * struct hbm_power_gate - power gate request/response
502 *
503 * @hbm_cmd: bus message command header
504 * @reserved: reserved
505 */
506 struct hbm_power_gate {
507 u8 hbm_cmd;
508 u8 reserved[3];
509 } __packed;
510
511 /**
512 * struct hbm_client_connect_request - connect/disconnect request
513 *
514 * @hbm_cmd: bus message command header
515 * @me_addr: address of the client in ME
516 * @host_addr: address of the client in the driver
517 * @reserved: reserved
518 */
519 struct hbm_client_connect_request {
520 u8 hbm_cmd;
521 u8 me_addr;
522 u8 host_addr;
523 u8 reserved;
524 } __packed;
525
526 /**
527 * struct hbm_client_connect_response - connect/disconnect response
528 *
529 * @hbm_cmd: bus message command header
530 * @me_addr: address of the client in ME
531 * @host_addr: address of the client in the driver
532 * @status: status of the request
533 */
534 struct hbm_client_connect_response {
535 u8 hbm_cmd;
536 u8 me_addr;
537 u8 host_addr;
538 u8 status;
539 } __packed;
540
541
542 #define MEI_FC_MESSAGE_RESERVED_LENGTH 5
543
544 struct hbm_flow_control {
545 u8 hbm_cmd;
546 u8 me_addr;
547 u8 host_addr;
548 u8 reserved[MEI_FC_MESSAGE_RESERVED_LENGTH];
549 } __packed;
550
551 #define MEI_HBM_NOTIFICATION_START 1
552 #define MEI_HBM_NOTIFICATION_STOP 0
553 /**
554 * struct hbm_notification_request - start/stop notification request
555 *
556 * @hbm_cmd: bus message command header
557 * @me_addr: address of the client in ME
558 * @host_addr: address of the client in the driver
559 * @start: start = 1 or stop = 0 asynchronous notifications
560 */
561 struct hbm_notification_request {
562 u8 hbm_cmd;
563 u8 me_addr;
564 u8 host_addr;
565 u8 start;
566 } __packed;
567
568 /**
569 * struct hbm_notification_response - start/stop notification response
570 *
571 * @hbm_cmd: bus message command header
572 * @me_addr: address of the client in ME
573 * @host_addr: - address of the client in the driver
574 * @status: (mei_hbm_status) response status for the request
575 * - MEI_HBMS_SUCCESS: successful stop/start
576 * - MEI_HBMS_CLIENT_NOT_FOUND: if the connection could not be found.
577 * - MEI_HBMS_ALREADY_STARTED: for start requests for a previously
578 * started notification.
579 * - MEI_HBMS_NOT_STARTED: for stop request for a connected client for whom
580 * asynchronous notifications are currently disabled.
581 *
582 * @start: start = 1 or stop = 0 asynchronous notifications
583 * @reserved: reserved
584 */
585 struct hbm_notification_response {
586 u8 hbm_cmd;
587 u8 me_addr;
588 u8 host_addr;
589 u8 status;
590 u8 start;
591 u8 reserved[3];
592 } __packed;
593
594 /**
595 * struct hbm_notification - notification event
596 *
597 * @hbm_cmd: bus message command header
598 * @me_addr: address of the client in ME
599 * @host_addr: address of the client in the driver
600 * @reserved: reserved for alignment
601 */
602 struct hbm_notification {
603 u8 hbm_cmd;
604 u8 me_addr;
605 u8 host_addr;
606 u8 reserved;
607 } __packed;
608
609 /**
610 * struct hbm_dma_mem_dscr - dma ring
611 *
612 * @addr_hi: the high 32bits of 64 bit address
613 * @addr_lo: the low 32bits of 64 bit address
614 * @size : size in bytes (must be power of 2)
615 */
616 struct hbm_dma_mem_dscr {
617 u32 addr_hi;
618 u32 addr_lo;
619 u32 size;
620 } __packed;
621
622 enum {
623 DMA_DSCR_HOST = 0,
624 DMA_DSCR_DEVICE = 1,
625 DMA_DSCR_CTRL = 2,
626 DMA_DSCR_NUM,
627 };
628
629 /**
630 * struct hbm_dma_setup_request - dma setup request
631 *
632 * @hbm_cmd: bus message command header
633 * @reserved: reserved for alignment
634 * @dma_dscr: dma descriptor for HOST, DEVICE, and CTRL
635 */
636 struct hbm_dma_setup_request {
637 u8 hbm_cmd;
638 u8 reserved[3];
639 struct hbm_dma_mem_dscr dma_dscr[DMA_DSCR_NUM];
640 } __packed;
641
642 /**
643 * struct hbm_dma_setup_response - dma setup response
644 *
645 * @hbm_cmd: bus message command header
646 * @status: 0 on success; otherwise DMA setup failed.
647 * @reserved: reserved for alignment
648 */
649 struct hbm_dma_setup_response {
650 u8 hbm_cmd;
651 u8 status;
652 u8 reserved[2];
653 } __packed;
654
655 /**
656 * struct mei_dma_ring_ctrl - dma ring control block
657 *
658 * @hbuf_wr_idx: host circular buffer write index in slots
659 * @reserved1: reserved for alignment
660 * @hbuf_rd_idx: host circular buffer read index in slots
661 * @reserved2: reserved for alignment
662 * @dbuf_wr_idx: device circular buffer write index in slots
663 * @reserved3: reserved for alignment
664 * @dbuf_rd_idx: device circular buffer read index in slots
665 * @reserved4: reserved for alignment
666 */
667 struct hbm_dma_ring_ctrl {
668 u32 hbuf_wr_idx;
669 u32 reserved1;
670 u32 hbuf_rd_idx;
671 u32 reserved2;
672 u32 dbuf_wr_idx;
673 u32 reserved3;
674 u32 dbuf_rd_idx;
675 u32 reserved4;
676 } __packed;
677
678 /* virtual tag supported */
679 #define HBM_CAP_VT BIT(0)
680 /* client dma supported */
681 #define HBM_CAP_CD BIT(2)
682
683 /**
684 * struct hbm_capability_request - capability request from host to fw
685 *
686 * @hbm_cmd : bus message command header
687 * @capability_requested: bitmask of capabilities requested by host
688 */
689 struct hbm_capability_request {
690 u8 hbm_cmd;
691 u8 capability_requested[3];
692 } __packed;
693
694 /**
695 * struct hbm_capability_response - capability response from fw to host
696 *
697 * @hbm_cmd : bus message command header
698 * @capability_granted: bitmask of capabilities granted by FW
699 */
700 struct hbm_capability_response {
701 u8 hbm_cmd;
702 u8 capability_granted[3];
703 } __packed;
704
705 /**
706 * struct hbm_client_dma_map_request - client dma map request from host to fw
707 *
708 * @hbm_cmd: bus message command header
709 * @client_buffer_id: client buffer id
710 * @reserved: reserved
711 * @address_lsb: DMA address LSB
712 * @address_msb: DMA address MSB
713 * @size: DMA size
714 */
715 struct hbm_client_dma_map_request {
716 u8 hbm_cmd;
717 u8 client_buffer_id;
718 u8 reserved[2];
719 u32 address_lsb;
720 u32 address_msb;
721 u32 size;
722 } __packed;
723
724 /**
725 * struct hbm_client_dma_unmap_request
726 * client dma unmap request from the host to the firmware
727 *
728 * @hbm_cmd: bus message command header
729 * @status: unmap status
730 * @client_buffer_id: client buffer id
731 * @reserved: reserved
732 */
733 struct hbm_client_dma_unmap_request {
734 u8 hbm_cmd;
735 u8 status;
736 u8 client_buffer_id;
737 u8 reserved;
738 } __packed;
739
740 /**
741 * struct hbm_client_dma_response
742 * client dma unmap response from the firmware to the host
743 *
744 * @hbm_cmd: bus message command header
745 * @status: command status
746 */
747 struct hbm_client_dma_response {
748 u8 hbm_cmd;
749 u8 status;
750 } __packed;
751
752 #endif
753