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/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  */
 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  */
 251 struct mei_ext_hdr {
 252         u8 type;
 253         u8 length;
 254 } __packed;
 255
 256 /**
 257  * struct mei_ext_meta_hdr - extend header meta data
 258  * @count: number of headers
 259  * @size: total size of the extended header list excluding meta header
 260  * @reserved: reserved
 261  * @hdrs: extended headers TLV list
 262  */
 263 struct mei_ext_meta_hdr {
 264         u8 count;
 265         u8 size;
 266         u8 reserved[2];
 267         u8 hdrs[];
 268 } __packed;
 269
 270 /**
 271  * struct mei_ext_hdr_vtag - extend header for vtag
 272  *
 273  * @hdr: standard extend header
 274  * @vtag: virtual tag
 275  * @reserved: reserved
 276  */
 277 struct mei_ext_hdr_vtag {
 278         struct mei_ext_hdr hdr;
 279         u8 vtag;
 280         u8 reserved;
 281 } __packed;
 282
 283 /*
 284  * Extended header iterator functions
 285  */
 286 /**
 287  * mei_ext_begin - extended header iterator begin
 288  *
 289  * @meta: meta header of the extended header list
 290  *
 291  * Return: The first extended header
 292  */
 293 static inline struct mei_ext_hdr *mei_ext_begin(struct mei_ext_meta_hdr *meta)
 294 {
 295         return (struct mei_ext_hdr *)meta->hdrs;
 296 }
 297
 298 /**
 299  * mei_ext_last - check if the ext is the last one in the TLV list
 300  *
 301  * @meta: meta header of the extended header list
 302  * @ext: a meta header on the list
 303  *
 304  * Return: true if ext is the last header on the list
 305  */
 306 static inline bool mei_ext_last(struct mei_ext_meta_hdr *meta,
 307                                 struct mei_ext_hdr *ext)
 308 {
 309         return (u8 *)ext >= (u8 *)meta + sizeof(*meta) + (meta->size * 4);
 310 }
 311
 312 struct mei_gsc_sgl {
 313         u32 low;
 314         u32 high;
 315         u32 length;
 316 } __packed;
 317
 318 #define GSC_HECI_MSG_KERNEL 0
 319 #define GSC_HECI_MSG_USER   1
 320
 321 #define GSC_ADDRESS_TYPE_GTT   0
 322 #define GSC_ADDRESS_TYPE_PPGTT 1
 323 #define GSC_ADDRESS_TYPE_PHYSICAL_CONTINUOUS 2 /* max of 64K */
 324 #define GSC_ADDRESS_TYPE_PHYSICAL_SGL 3
 325
 326 /**
 327  * struct mei_ext_hdr_gsc_h2f - extended header: gsc host to firmware interface
 328  *
 329  * @hdr: extended header
 330  * @client_id: GSC_HECI_MSG_KERNEL or GSC_HECI_MSG_USER
 331  * @addr_type: GSC_ADDRESS_TYPE_{GTT, PPGTT, PHYSICAL_CONTINUOUS, PHYSICAL_SGL}
 332  * @fence_id: synchronization marker
 333  * @input_address_count: number of input sgl buffers
 334  * @output_address_count: number of output sgl buffers
 335  * @reserved: reserved
 336  * @sgl: sg list
 337  */
 338 struct mei_ext_hdr_gsc_h2f {
 339         struct mei_ext_hdr hdr;
 340         u8                 client_id;
 341         u8                 addr_type;
 342         u32                fence_id;
 343         u8                 input_address_count;
 344         u8                 output_address_count;
 345         u8                 reserved[2];
 346         struct mei_gsc_sgl sgl[];
 347 } __packed;
 348
 349 /**
 350  * struct mei_ext_hdr_gsc_f2h - gsc firmware to host interface
 351  *
 352  * @hdr: extended header
 353  * @client_id: GSC_HECI_MSG_KERNEL or GSC_HECI_MSG_USER
 354  * @reserved: reserved
 355  * @fence_id: synchronization marker
 356  * @written: number of bytes written to firmware
 357  */
 358 struct mei_ext_hdr_gsc_f2h {
 359         struct mei_ext_hdr hdr;
 360         u8                 client_id;
 361         u8                 reserved;
 362         u32                fence_id;
 363         u32                written;
 364 } __packed;
 365
 366 /**
 367  * mei_ext_next - following extended header on the TLV list
 368  *
 369  * @ext: current extend header
 370  *
 371  * Context: The function does not check for the overflows,
 372  *          one should call mei_ext_last before.
 373  *
 374  * Return: The following extend header after @ext
 375  */
 376 static inline struct mei_ext_hdr *mei_ext_next(struct mei_ext_hdr *ext)
 377 {
 378         return (struct mei_ext_hdr *)((u8 *)ext + (ext->length * 4));
 379 }
 380
 381 /**
 382  * mei_ext_hdr_len - get ext header length in bytes
 383  *
 384  * @ext: extend header
 385  *
 386  * Return: extend header length in bytes
 387  */
 388 static inline u32 mei_ext_hdr_len(const struct mei_ext_hdr *ext)
 389 {
 390         if (!ext)
 391                 return 0;
 392
 393         return ext->length * sizeof(u32);
 394 }
 395
 396 /**
 397  * struct mei_msg_hdr - MEI BUS Interface Section
 398  *
 399  * @me_addr: device address
 400  * @host_addr: host address
 401  * @length: message length
 402  * @reserved: reserved
 403  * @extended: message has extended header
 404  * @dma_ring: message is on dma ring
 405  * @internal: message is internal
 406  * @msg_complete: last packet of the message
 407  * @extension: extension of the header
 408  */
 409 struct mei_msg_hdr {
 410         u32 me_addr:8;
 411         u32 host_addr:8;
 412         u32 length:9;
 413         u32 reserved:3;
 414         u32 extended:1;
 415         u32 dma_ring:1;
 416         u32 internal:1;
 417         u32 msg_complete:1;
 418         u32 extension[];
 419 } __packed;
 420
 421 /* The length is up to 9 bits */
 422 #define MEI_MSG_MAX_LEN_MASK GENMASK(9, 0)
 423
 424 struct mei_bus_message {
 425         u8 hbm_cmd;
 426         u8 data[];
 427 } __packed;
 428
 429 /**
 430  * struct mei_hbm_cl_cmd - client specific host bus command
 431  *      CONNECT, DISCONNECT, and FlOW CONTROL
 432  *
 433  * @hbm_cmd: bus message command header
 434  * @me_addr: address of the client in ME
 435  * @host_addr: address of the client in the driver
 436  * @data: generic data
 437  */
 438 struct mei_hbm_cl_cmd {
 439         u8 hbm_cmd;
 440         u8 me_addr;
 441         u8 host_addr;
 442         u8 data;
 443 };
 444
 445 struct hbm_version {
 446         u8 minor_version;
 447         u8 major_version;
 448 } __packed;
 449
 450 struct hbm_host_version_request {
 451         u8 hbm_cmd;
 452         u8 reserved;
 453         struct hbm_version host_version;
 454 } __packed;
 455
 456 struct hbm_host_version_response {
 457         u8 hbm_cmd;
 458         u8 host_version_supported;
 459         struct hbm_version me_max_version;
 460 } __packed;
 461
 462 struct hbm_host_stop_request {
 463         u8 hbm_cmd;
 464         u8 reason;
 465         u8 reserved[2];
 466 } __packed;
 467
 468 struct hbm_host_stop_response {
 469         u8 hbm_cmd;
 470         u8 reserved[3];
 471 } __packed;
 472
 473 struct hbm_me_stop_request {
 474         u8 hbm_cmd;
 475         u8 reason;
 476         u8 reserved[2];
 477 } __packed;
 478
 479 /**
 480  * enum hbm_host_enum_flags - enumeration request flags (HBM version >= 2.0)
 481  *
 482  * @MEI_HBM_ENUM_F_ALLOW_ADD: allow dynamic clients add
 483  * @MEI_HBM_ENUM_F_IMMEDIATE_ENUM: allow FW to send answer immediately
 484  */
 485 enum hbm_host_enum_flags {
 486         MEI_HBM_ENUM_F_ALLOW_ADD = BIT(0),
 487         MEI_HBM_ENUM_F_IMMEDIATE_ENUM = BIT(1),
 488 };
 489
 490 /**
 491  * struct hbm_host_enum_request - enumeration request from host to fw
 492  *
 493  * @hbm_cmd : bus message command header
 494  * @flags   : request flags
 495  * @reserved: reserved
 496  */
 497 struct hbm_host_enum_request {
 498         u8 hbm_cmd;
 499         u8 flags;
 500         u8 reserved[2];
 501 } __packed;
 502
 503 struct hbm_host_enum_response {
 504         u8 hbm_cmd;
 505         u8 reserved[3];
 506         u8 valid_addresses[32];
 507 } __packed;
 508
 509 /**
 510  * struct mei_client_properties - mei client properties
 511  *
 512  * @protocol_name: guid of the client
 513  * @protocol_version: client protocol version
 514  * @max_number_of_connections: number of possible connections.
 515  * @fixed_address: fixed me address (0 if the client is dynamic)
 516  * @single_recv_buf: 1 if all connections share a single receive buffer.
 517  * @vt_supported: the client support vtag
 518  * @reserved: reserved
 519  * @max_msg_length: MTU of the client
 520  */
 521 struct mei_client_properties {
 522         uuid_le protocol_name;
 523         u8 protocol_version;
 524         u8 max_number_of_connections;
 525         u8 fixed_address;
 526         u8 single_recv_buf:1;
 527         u8 vt_supported:1;
 528         u8 reserved:6;
 529         u32 max_msg_length;
 530 } __packed;
 531
 532 struct hbm_props_request {
 533         u8 hbm_cmd;
 534         u8 me_addr;
 535         u8 reserved[2];
 536 } __packed;
 537
 538 struct hbm_props_response {
 539         u8 hbm_cmd;
 540         u8 me_addr;
 541         u8 status;
 542         u8 reserved;
 543         struct mei_client_properties client_properties;
 544 } __packed;
 545
 546 /**
 547  * struct hbm_add_client_request - request to add a client
 548  *     might be sent by fw after enumeration has already completed
 549  *
 550  * @hbm_cmd: bus message command header
 551  * @me_addr: address of the client in ME
 552  * @reserved: reserved
 553  * @client_properties: client properties
 554  */
 555 struct hbm_add_client_request {
 556         u8 hbm_cmd;
 557         u8 me_addr;
 558         u8 reserved[2];
 559         struct mei_client_properties client_properties;
 560 } __packed;
 561
 562 /**
 563  * struct hbm_add_client_response - response to add a client
 564  *     sent by the host to report client addition status to fw
 565  *
 566  * @hbm_cmd: bus message command header
 567  * @me_addr: address of the client in ME
 568  * @status: if HBMS_SUCCESS then the client can now accept connections.
 569  * @reserved: reserved
 570  */
 571 struct hbm_add_client_response {
 572         u8 hbm_cmd;
 573         u8 me_addr;
 574         u8 status;
 575         u8 reserved;
 576 } __packed;
 577
 578 /**
 579  * struct hbm_power_gate - power gate request/response
 580  *
 581  * @hbm_cmd: bus message command header
 582  * @reserved: reserved
 583  */
 584 struct hbm_power_gate {
 585         u8 hbm_cmd;
 586         u8 reserved[3];
 587 } __packed;
 588
 589 /**
 590  * struct hbm_client_connect_request - connect/disconnect request
 591  *
 592  * @hbm_cmd: bus message command header
 593  * @me_addr: address of the client in ME
 594  * @host_addr: address of the client in the driver
 595  * @reserved: reserved
 596  */
 597 struct hbm_client_connect_request {
 598         u8 hbm_cmd;
 599         u8 me_addr;
 600         u8 host_addr;
 601         u8 reserved;
 602 } __packed;
 603
 604 /**
 605  * struct hbm_client_connect_response - connect/disconnect response
 606  *
 607  * @hbm_cmd: bus message command header
 608  * @me_addr: address of the client in ME
 609  * @host_addr: address of the client in the driver
 610  * @status: status of the request
 611  */
 612 struct hbm_client_connect_response {
 613         u8 hbm_cmd;
 614         u8 me_addr;
 615         u8 host_addr;
 616         u8 status;
 617 } __packed;
 618
 619
 620 #define MEI_FC_MESSAGE_RESERVED_LENGTH           5
 621
 622 struct hbm_flow_control {
 623         u8 hbm_cmd;
 624         u8 me_addr;
 625         u8 host_addr;
 626         u8 reserved[MEI_FC_MESSAGE_RESERVED_LENGTH];
 627 } __packed;
 628
 629 #define MEI_HBM_NOTIFICATION_START 1
 630 #define MEI_HBM_NOTIFICATION_STOP  0
 631 /**
 632  * struct hbm_notification_request - start/stop notification request
 633  *
 634  * @hbm_cmd: bus message command header
 635  * @me_addr: address of the client in ME
 636  * @host_addr: address of the client in the driver
 637  * @start:  start = 1 or stop = 0 asynchronous notifications
 638  */
 639 struct hbm_notification_request {
 640         u8 hbm_cmd;
 641         u8 me_addr;
 642         u8 host_addr;
 643         u8 start;
 644 } __packed;
 645
 646 /**
 647  * struct hbm_notification_response - start/stop notification response
 648  *
 649  * @hbm_cmd: bus message command header
 650  * @me_addr: address of the client in ME
 651  * @host_addr: - address of the client in the driver
 652  * @status: (mei_hbm_status) response status for the request
 653  *  - MEI_HBMS_SUCCESS: successful stop/start
 654  *  - MEI_HBMS_CLIENT_NOT_FOUND: if the connection could not be found.
 655  *  - MEI_HBMS_ALREADY_STARTED: for start requests for a previously
 656  *                         started notification.
 657  *  - MEI_HBMS_NOT_STARTED: for stop request for a connected client for whom
 658  *                         asynchronous notifications are currently disabled.
 659  *
 660  * @start:  start = 1 or stop = 0 asynchronous notifications
 661  * @reserved: reserved
 662  */
 663 struct hbm_notification_response {
 664         u8 hbm_cmd;
 665         u8 me_addr;
 666         u8 host_addr;
 667         u8 status;
 668         u8 start;
 669         u8 reserved[3];
 670 } __packed;
 671
 672 /**
 673  * struct hbm_notification - notification event
 674  *
 675  * @hbm_cmd: bus message command header
 676  * @me_addr:  address of the client in ME
 677  * @host_addr:  address of the client in the driver
 678  * @reserved: reserved for alignment
 679  */
 680 struct hbm_notification {
 681         u8 hbm_cmd;
 682         u8 me_addr;
 683         u8 host_addr;
 684         u8 reserved;
 685 } __packed;
 686
 687 /**
 688  * struct hbm_dma_mem_dscr - dma ring
 689  *
 690  * @addr_hi: the high 32bits of 64 bit address
 691  * @addr_lo: the low  32bits of 64 bit address
 692  * @size   : size in bytes (must be power of 2)
 693  */
 694 struct hbm_dma_mem_dscr {
 695         u32 addr_hi;
 696         u32 addr_lo;
 697         u32 size;
 698 } __packed;
 699
 700 enum {
 701         DMA_DSCR_HOST = 0,
 702         DMA_DSCR_DEVICE = 1,
 703         DMA_DSCR_CTRL = 2,
 704         DMA_DSCR_NUM,
 705 };
 706
 707 /**
 708  * struct hbm_dma_setup_request - dma setup request
 709  *
 710  * @hbm_cmd: bus message command header
 711  * @reserved: reserved for alignment
 712  * @dma_dscr: dma descriptor for HOST, DEVICE, and CTRL
 713  */
 714 struct hbm_dma_setup_request {
 715         u8 hbm_cmd;
 716         u8 reserved[3];
 717         struct hbm_dma_mem_dscr dma_dscr[DMA_DSCR_NUM];
 718 } __packed;
 719
 720 /**
 721  * struct hbm_dma_setup_response - dma setup response
 722  *
 723  * @hbm_cmd: bus message command header
 724  * @status: 0 on success; otherwise DMA setup failed.
 725  * @reserved: reserved for alignment
 726  */
 727 struct hbm_dma_setup_response {
 728         u8 hbm_cmd;
 729         u8 status;
 730         u8 reserved[2];
 731 } __packed;
 732
 733 /**
 734  * struct hbm_dma_ring_ctrl - dma ring control block
 735  *
 736  * @hbuf_wr_idx: host circular buffer write index in slots
 737  * @reserved1: reserved for alignment
 738  * @hbuf_rd_idx: host circular buffer read index in slots
 739  * @reserved2: reserved for alignment
 740  * @dbuf_wr_idx: device circular buffer write index in slots
 741  * @reserved3: reserved for alignment
 742  * @dbuf_rd_idx: device circular buffer read index in slots
 743  * @reserved4: reserved for alignment
 744  */
 745 struct hbm_dma_ring_ctrl {
 746         u32 hbuf_wr_idx;
 747         u32 reserved1;
 748         u32 hbuf_rd_idx;
 749         u32 reserved2;
 750         u32 dbuf_wr_idx;
 751         u32 reserved3;
 752         u32 dbuf_rd_idx;
 753         u32 reserved4;
 754 } __packed;
 755
 756 /* virtual tag supported */
 757 #define HBM_CAP_VT BIT(0)
 758
 759 /* gsc extended header support */
 760 #define HBM_CAP_GSC BIT(1)
 761
 762 /* client dma supported */
 763 #define HBM_CAP_CD BIT(2)
 764
 765 /**
 766  * struct hbm_capability_request - capability request from host to fw
 767  *
 768  * @hbm_cmd : bus message command header
 769  * @capability_requested: bitmask of capabilities requested by host
 770  */
 771 struct hbm_capability_request {
 772         u8 hbm_cmd;
 773         u8 capability_requested[3];
 774 } __packed;
 775
 776 /**
 777  * struct hbm_capability_response - capability response from fw to host
 778  *
 779  * @hbm_cmd : bus message command header
 780  * @capability_granted: bitmask of capabilities granted by FW
 781  */
 782 struct hbm_capability_response {
 783         u8 hbm_cmd;
 784         u8 capability_granted[3];
 785 } __packed;
 786
 787 /**
 788  * struct hbm_client_dma_map_request - client dma map request from host to fw
 789  *
 790  * @hbm_cmd: bus message command header
 791  * @client_buffer_id: client buffer id
 792  * @reserved: reserved
 793  * @address_lsb: DMA address LSB
 794  * @address_msb: DMA address MSB
 795  * @size: DMA size
 796  */
 797 struct hbm_client_dma_map_request {
 798         u8 hbm_cmd;
 799         u8 client_buffer_id;
 800         u8 reserved[2];
 801         u32 address_lsb;
 802         u32 address_msb;
 803         u32 size;
 804 } __packed;
 805
 806 /**
 807  * struct hbm_client_dma_unmap_request - client dma unmap request
 808  *        from the host to the firmware
 809  *
 810  * @hbm_cmd: bus message command header
 811  * @status: unmap status
 812  * @client_buffer_id: client buffer id
 813  * @reserved: reserved
 814  */
 815 struct hbm_client_dma_unmap_request {
 816         u8 hbm_cmd;
 817         u8 status;
 818         u8 client_buffer_id;
 819         u8 reserved;
 820 } __packed;
 821
 822 /**
 823  * struct hbm_client_dma_response - client dma unmap response
 824  *        from the firmware to the host
 825  *
 826  * @hbm_cmd: bus message command header
 827  * @status: command status
 828  */
 829 struct hbm_client_dma_response {
 830         u8 hbm_cmd;
 831         u8 status;
 832 } __packed;
 833
 834 #endif