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/mei.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 */ 171enum 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 */ 198enum 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 */ 216enum 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 */ 228enum 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 */ 240enum 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 */ 252struct 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 */ 265struct 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 */ 279struct 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 */ 295static 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 */ 308static 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 314struct 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 */ 340struct 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 */ 360struct 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 */ 378static 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 */ 390static 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 */ 411struct 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 426struct mei_bus_message { 427 u8 hbm_cmd; 428 u8 data[]; 429} __packed; 430 431/** 432 * struct mei_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 */ 440struct mei_hbm_cl_cmd { 441 u8 hbm_cmd; 442 u8 me_addr; 443 u8 host_addr; 444 u8 data; 445}; 446 447struct hbm_version { 448 u8 minor_version; 449 u8 major_version; 450} __packed; 451 452struct hbm_host_version_request { 453 u8 hbm_cmd; 454 u8 reserved; 455 struct hbm_version host_version; 456} __packed; 457 458struct hbm_host_version_response { 459 u8 hbm_cmd; 460 u8 host_version_supported; 461 struct hbm_version me_max_version; 462} __packed; 463 464struct hbm_host_stop_request { 465 u8 hbm_cmd; 466 u8 reason; 467 u8 reserved[2]; 468} __packed; 469 470struct hbm_host_stop_response { 471 u8 hbm_cmd; 472 u8 reserved[3]; 473} __packed; 474 475struct 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 */ 487enum 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 */ 499struct hbm_host_enum_request { 500 u8 hbm_cmd; 501 u8 flags; 502 u8 reserved[2]; 503} __packed; 504 505struct 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 */ 523struct 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 534struct hbm_props_request { 535 u8 hbm_cmd; 536 u8 me_addr; 537 u8 reserved[2]; 538} __packed; 539 540struct 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 */ 557struct 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 */ 573struct 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 */ 586struct 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 */ 599struct 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 */ 614struct 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 624struct 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 */ 641struct 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 */ 665struct 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 */ 682struct 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 */ 696struct hbm_dma_mem_dscr { 697 u32 addr_hi; 698 u32 addr_lo; 699 u32 size; 700} __packed; 701 702enum { 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 */ 716struct 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 */ 729struct hbm_dma_setup_response { 730 u8 hbm_cmd; 731 u8 status; 732 u8 reserved[2]; 733} __packed; 734 735/** 736 * struct hbm_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 */ 747struct 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 */ 773struct 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 */ 784struct 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 */ 799struct 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 - client dma unmap request 810 * 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 */ 817struct 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 - client dma unmap response 826 * from the firmware to the host 827 * 828 * @hbm_cmd: bus message command header 829 * @status: command status 830 */ 831struct hbm_client_dma_response { 832 u8 hbm_cmd; 833 u8 status; 834} __packed; 835 836#endif 837