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