drivers/misc/mei/hw.h

   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