include/linux/pds/pds_adminq.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /* Copyright(c) 2023 Advanced Micro Devices, Inc */
   3
   4 #ifndef _PDS_CORE_ADMINQ_H_
   5 #define _PDS_CORE_ADMINQ_H_
   6
   7 #define PDSC_ADMINQ_MAX_POLL_INTERVAL   256
   8
   9 enum pds_core_adminq_flags {
  10         PDS_AQ_FLAG_FASTPOLL    = BIT(1),       /* completion poll at 1ms */
  11 };
  12
  13 /*
  14  * enum pds_core_adminq_opcode - AdminQ command opcodes
  15  * These commands are only processed on AdminQ, not available in devcmd
  16  */
  17 enum pds_core_adminq_opcode {
  18         PDS_AQ_CMD_NOP                  = 0,
  19
  20         /* Client control */
  21         PDS_AQ_CMD_CLIENT_REG           = 6,
  22         PDS_AQ_CMD_CLIENT_UNREG         = 7,
  23         PDS_AQ_CMD_CLIENT_CMD           = 8,
  24
  25         /* LIF commands */
  26         PDS_AQ_CMD_LIF_IDENTIFY         = 20,
  27         PDS_AQ_CMD_LIF_INIT             = 21,
  28         PDS_AQ_CMD_LIF_RESET            = 22,
  29         PDS_AQ_CMD_LIF_GETATTR          = 23,
  30         PDS_AQ_CMD_LIF_SETATTR          = 24,
  31         PDS_AQ_CMD_LIF_SETPHC           = 25,
  32
  33         PDS_AQ_CMD_RX_MODE_SET          = 30,
  34         PDS_AQ_CMD_RX_FILTER_ADD        = 31,
  35         PDS_AQ_CMD_RX_FILTER_DEL        = 32,
  36
  37         /* Queue commands */
  38         PDS_AQ_CMD_Q_IDENTIFY           = 39,
  39         PDS_AQ_CMD_Q_INIT               = 40,
  40         PDS_AQ_CMD_Q_CONTROL            = 41,
  41
  42         /* SR/IOV commands */
  43         PDS_AQ_CMD_VF_GETATTR           = 60,
  44         PDS_AQ_CMD_VF_SETATTR           = 61,
  45 };
  46
  47 /*
  48  * enum pds_core_notifyq_opcode - NotifyQ event codes
  49  */
  50 enum pds_core_notifyq_opcode {
  51         PDS_EVENT_LINK_CHANGE           = 1,
  52         PDS_EVENT_RESET                 = 2,
  53         PDS_EVENT_XCVR                  = 5,
  54         PDS_EVENT_CLIENT                = 6,
  55 };
  56
  57 #define PDS_COMP_COLOR_MASK  0x80
  58
  59 /**
  60  * struct pds_core_notifyq_event - Generic event reporting structure
  61  * @eid:   event number
  62  * @ecode: event code
  63  *
  64  * This is the generic event report struct from which the other
  65  * actual events will be formed.
  66  */
  67 struct pds_core_notifyq_event {
  68         __le64 eid;
  69         __le16 ecode;
  70 };
  71
  72 /**
  73  * struct pds_core_link_change_event - Link change event notification
  74  * @eid:                event number
  75  * @ecode:              event code = PDS_EVENT_LINK_CHANGE
  76  * @link_status:        link up/down, with error bits
  77  * @link_speed:         speed of the network link
  78  *
  79  * Sent when the network link state changes between UP and DOWN
  80  */
  81 struct pds_core_link_change_event {
  82         __le64 eid;
  83         __le16 ecode;
  84         __le16 link_status;
  85         __le32 link_speed;      /* units of 1Mbps: e.g. 10000 = 10Gbps */
  86 };
  87
  88 /**
  89  * struct pds_core_reset_event - Reset event notification
  90  * @eid:                event number
  91  * @ecode:              event code = PDS_EVENT_RESET
  92  * @reset_code:         reset type
  93  * @state:              0=pending, 1=complete, 2=error
  94  *
  95  * Sent when the NIC or some subsystem is going to be or
  96  * has been reset.
  97  */
  98 struct pds_core_reset_event {
  99         __le64 eid;
 100         __le16 ecode;
 101         u8     reset_code;
 102         u8     state;
 103 };
 104
 105 /**
 106  * struct pds_core_client_event - Client event notification
 107  * @eid:                event number
 108  * @ecode:              event code = PDS_EVENT_CLIENT
 109  * @client_id:          client to sent event to
 110  * @client_event:       wrapped event struct for the client
 111  *
 112  * Sent when an event needs to be passed on to a client
 113  */
 114 struct pds_core_client_event {
 115         __le64 eid;
 116         __le16 ecode;
 117         __le16 client_id;
 118         u8     client_event[54];
 119 };
 120
 121 /**
 122  * struct pds_core_notifyq_cmd - Placeholder for building qcq
 123  * @data:      anonymous field for building the qcq
 124  */
 125 struct pds_core_notifyq_cmd {
 126         __le32 data;    /* Not used but needed for qcq structure */
 127 };
 128
 129 /*
 130  * union pds_core_notifyq_comp - Overlay of notifyq event structures
 131  */
 132 union pds_core_notifyq_comp {
 133         struct {
 134                 __le64 eid;
 135                 __le16 ecode;
 136         };
 137         struct pds_core_notifyq_event     event;
 138         struct pds_core_link_change_event link_change;
 139         struct pds_core_reset_event       reset;
 140         u8     data[64];
 141 };
 142
 143 #define PDS_DEVNAME_LEN         32
 144 /**
 145  * struct pds_core_client_reg_cmd - Register a new client with DSC
 146  * @opcode:         opcode PDS_AQ_CMD_CLIENT_REG
 147  * @rsvd:           word boundary padding
 148  * @devname:        text name of client device
 149  * @vif_type:       what type of device (enum pds_core_vif_types)
 150  *
 151  * Tell the DSC of the new client, and receive a client_id from DSC.
 152  */
 153 struct pds_core_client_reg_cmd {
 154         u8     opcode;
 155         u8     rsvd[3];
 156         char   devname[PDS_DEVNAME_LEN];
 157         u8     vif_type;
 158 };
 159
 160 /**
 161  * struct pds_core_client_reg_comp - Client registration completion
 162  * @status:     Status of the command (enum pdc_core_status_code)
 163  * @rsvd:       Word boundary padding
 164  * @comp_index: Index in the descriptor ring for which this is the completion
 165  * @client_id:  New id assigned by DSC
 166  * @rsvd1:      Word boundary padding
 167  * @color:      Color bit
 168  */
 169 struct pds_core_client_reg_comp {
 170         u8     status;
 171         u8     rsvd;
 172         __le16 comp_index;
 173         __le16 client_id;
 174         u8     rsvd1[9];
 175         u8     color;
 176 };
 177
 178 /**
 179  * struct pds_core_client_unreg_cmd - Unregister a client from DSC
 180  * @opcode:     opcode PDS_AQ_CMD_CLIENT_UNREG
 181  * @rsvd:       word boundary padding
 182  * @client_id:  id of client being removed
 183  *
 184  * Tell the DSC this client is going away and remove its context
 185  * This uses the generic completion.
 186  */
 187 struct pds_core_client_unreg_cmd {
 188         u8     opcode;
 189         u8     rsvd;
 190         __le16 client_id;
 191 };
 192
 193 /**
 194  * struct pds_core_client_request_cmd - Pass along a wrapped client AdminQ cmd
 195  * @opcode:     opcode PDS_AQ_CMD_CLIENT_CMD
 196  * @rsvd:       word boundary padding
 197  * @client_id:  id of client being removed
 198  * @client_cmd: the wrapped client command
 199  *
 200  * Proxy post an adminq command for the client.
 201  * This uses the generic completion.
 202  */
 203 struct pds_core_client_request_cmd {
 204         u8     opcode;
 205         u8     rsvd;
 206         __le16 client_id;
 207         u8     client_cmd[60];
 208 };
 209
 210 #define PDS_CORE_MAX_FRAGS              16
 211
 212 #define PDS_CORE_QCQ_F_INITED           BIT(0)
 213 #define PDS_CORE_QCQ_F_SG               BIT(1)
 214 #define PDS_CORE_QCQ_F_INTR             BIT(2)
 215 #define PDS_CORE_QCQ_F_TX_STATS         BIT(3)
 216 #define PDS_CORE_QCQ_F_RX_STATS         BIT(4)
 217 #define PDS_CORE_QCQ_F_NOTIFYQ          BIT(5)
 218 #define PDS_CORE_QCQ_F_CMB_RINGS        BIT(6)
 219 #define PDS_CORE_QCQ_F_CORE             BIT(7)
 220
 221 enum pds_core_lif_type {
 222         PDS_CORE_LIF_TYPE_DEFAULT = 0,
 223 };
 224
 225 #define PDS_CORE_IFNAMSIZ               16
 226
 227 /**
 228  * enum pds_core_logical_qtype - Logical Queue Types
 229  * @PDS_CORE_QTYPE_ADMINQ:    Administrative Queue
 230  * @PDS_CORE_QTYPE_NOTIFYQ:   Notify Queue
 231  * @PDS_CORE_QTYPE_RXQ:       Receive Queue
 232  * @PDS_CORE_QTYPE_TXQ:       Transmit Queue
 233  * @PDS_CORE_QTYPE_EQ:        Event Queue
 234  * @PDS_CORE_QTYPE_MAX:       Max queue type supported
 235  */
 236 enum pds_core_logical_qtype {
 237         PDS_CORE_QTYPE_ADMINQ  = 0,
 238         PDS_CORE_QTYPE_NOTIFYQ = 1,
 239         PDS_CORE_QTYPE_RXQ     = 2,
 240         PDS_CORE_QTYPE_TXQ     = 3,
 241         PDS_CORE_QTYPE_EQ      = 4,
 242
 243         PDS_CORE_QTYPE_MAX     = 16   /* don't change - used in struct size */
 244 };
 245
 246 /**
 247  * union pds_core_lif_config - LIF configuration
 248  * @state:          LIF state (enum pds_core_lif_state)
 249  * @rsvd:           Word boundary padding
 250  * @name:           LIF name
 251  * @rsvd2:          Word boundary padding
 252  * @features:       LIF features active (enum pds_core_hw_features)
 253  * @queue_count:    Queue counts per queue-type
 254  * @words:          Full union buffer size
 255  */
 256 union pds_core_lif_config {
 257         struct {
 258                 u8     state;
 259                 u8     rsvd[3];
 260                 char   name[PDS_CORE_IFNAMSIZ];
 261                 u8     rsvd2[12];
 262                 __le64 features;
 263                 __le32 queue_count[PDS_CORE_QTYPE_MAX];
 264         } __packed;
 265         __le32 words[64];
 266 };
 267
 268 /**
 269  * struct pds_core_lif_status - LIF status register
 270  * @eid:             most recent NotifyQ event id
 271  * @rsvd:            full struct size
 272  */
 273 struct pds_core_lif_status {
 274         __le64 eid;
 275         u8     rsvd[56];
 276 };
 277
 278 /**
 279  * struct pds_core_lif_info - LIF info structure
 280  * @config:     LIF configuration structure
 281  * @status:     LIF status structure
 282  */
 283 struct pds_core_lif_info {
 284         union pds_core_lif_config config;
 285         struct pds_core_lif_status status;
 286 };
 287
 288 /**
 289  * struct pds_core_lif_identity - LIF identity information (type-specific)
 290  * @features:           LIF features (see enum pds_core_hw_features)
 291  * @version:            Identify structure version
 292  * @hw_index:           LIF hardware index
 293  * @rsvd:               Word boundary padding
 294  * @max_nb_sessions:    Maximum number of sessions supported
 295  * @rsvd2:              buffer padding
 296  * @config:             LIF config struct with features, q counts
 297  */
 298 struct pds_core_lif_identity {
 299         __le64 features;
 300         u8     version;
 301         u8     hw_index;
 302         u8     rsvd[2];
 303         __le32 max_nb_sessions;
 304         u8     rsvd2[120];
 305         union pds_core_lif_config config;
 306 };
 307
 308 /**
 309  * struct pds_core_lif_identify_cmd - Get LIF identity info command
 310  * @opcode:     Opcode PDS_AQ_CMD_LIF_IDENTIFY
 311  * @type:       LIF type (enum pds_core_lif_type)
 312  * @client_id:  Client identifier
 313  * @ver:        Version of identify returned by device
 314  * @rsvd:       Word boundary padding
 315  * @ident_pa:   DMA address to receive identity info
 316  *
 317  * Firmware will copy LIF identity data (struct pds_core_lif_identity)
 318  * into the buffer address given.
 319  */
 320 struct pds_core_lif_identify_cmd {
 321         u8     opcode;
 322         u8     type;
 323         __le16 client_id;
 324         u8     ver;
 325         u8     rsvd[3];
 326         __le64 ident_pa;
 327 };
 328
 329 /**
 330  * struct pds_core_lif_identify_comp - LIF identify command completion
 331  * @status:     Status of the command (enum pds_core_status_code)
 332  * @ver:        Version of identify returned by device
 333  * @bytes:      Bytes copied into the buffer
 334  * @rsvd:       Word boundary padding
 335  * @color:      Color bit
 336  */
 337 struct pds_core_lif_identify_comp {
 338         u8     status;
 339         u8     ver;
 340         __le16 bytes;
 341         u8     rsvd[11];
 342         u8     color;
 343 };
 344
 345 /**
 346  * struct pds_core_lif_init_cmd - LIF init command
 347  * @opcode:     Opcode PDS_AQ_CMD_LIF_INIT
 348  * @type:       LIF type (enum pds_core_lif_type)
 349  * @client_id:  Client identifier
 350  * @rsvd:       Word boundary padding
 351  * @info_pa:    Destination address for LIF info (struct pds_core_lif_info)
 352  */
 353 struct pds_core_lif_init_cmd {
 354         u8     opcode;
 355         u8     type;
 356         __le16 client_id;
 357         __le32 rsvd;
 358         __le64 info_pa;
 359 };
 360
 361 /**
 362  * struct pds_core_lif_init_comp - LIF init command completion
 363  * @status:     Status of the command (enum pds_core_status_code)
 364  * @rsvd:       Word boundary padding
 365  * @hw_index:   Hardware index of the initialized LIF
 366  * @rsvd1:      Word boundary padding
 367  * @color:      Color bit
 368  */
 369 struct pds_core_lif_init_comp {
 370         u8 status;
 371         u8 rsvd;
 372         __le16 hw_index;
 373         u8     rsvd1[11];
 374         u8     color;
 375 };
 376
 377 /**
 378  * struct pds_core_lif_reset_cmd - LIF reset command
 379  * Will reset only the specified LIF.
 380  * @opcode:     Opcode PDS_AQ_CMD_LIF_RESET
 381  * @rsvd:       Word boundary padding
 382  * @client_id:  Client identifier
 383  */
 384 struct pds_core_lif_reset_cmd {
 385         u8     opcode;
 386         u8     rsvd;
 387         __le16 client_id;
 388 };
 389
 390 /**
 391  * enum pds_core_lif_attr - List of LIF attributes
 392  * @PDS_CORE_LIF_ATTR_STATE:            LIF state attribute
 393  * @PDS_CORE_LIF_ATTR_NAME:             LIF name attribute
 394  * @PDS_CORE_LIF_ATTR_FEATURES:         LIF features attribute
 395  * @PDS_CORE_LIF_ATTR_STATS_CTRL:       LIF statistics control attribute
 396  */
 397 enum pds_core_lif_attr {
 398         PDS_CORE_LIF_ATTR_STATE         = 0,
 399         PDS_CORE_LIF_ATTR_NAME          = 1,
 400         PDS_CORE_LIF_ATTR_FEATURES      = 4,
 401         PDS_CORE_LIF_ATTR_STATS_CTRL    = 6,
 402 };
 403
 404 /**
 405  * struct pds_core_lif_setattr_cmd - Set LIF attributes on the NIC
 406  * @opcode:     Opcode PDS_AQ_CMD_LIF_SETATTR
 407  * @attr:       Attribute type (enum pds_core_lif_attr)
 408  * @client_id:  Client identifier
 409  * @state:      LIF state (enum pds_core_lif_state)
 410  * @name:       The name string, 0 terminated
 411  * @features:   Features (enum pds_core_hw_features)
 412  * @stats_ctl:  Stats control commands (enum pds_core_stats_ctl_cmd)
 413  * @rsvd:       Command Buffer padding
 414  */
 415 struct pds_core_lif_setattr_cmd {
 416         u8     opcode;
 417         u8     attr;
 418         __le16 client_id;
 419         union {
 420                 u8      state;
 421                 char    name[PDS_CORE_IFNAMSIZ];
 422                 __le64  features;
 423                 u8      stats_ctl;
 424                 u8      rsvd[60];
 425         } __packed;
 426 };
 427
 428 /**
 429  * struct pds_core_lif_setattr_comp - LIF set attr command completion
 430  * @status:     Status of the command (enum pds_core_status_code)
 431  * @rsvd:       Word boundary padding
 432  * @comp_index: Index in the descriptor ring for which this is the completion
 433  * @features:   Features (enum pds_core_hw_features)
 434  * @rsvd2:      Word boundary padding
 435  * @color:      Color bit
 436  */
 437 struct pds_core_lif_setattr_comp {
 438         u8     status;
 439         u8     rsvd;
 440         __le16 comp_index;
 441         union {
 442                 __le64  features;
 443                 u8      rsvd2[11];
 444         } __packed;
 445         u8     color;
 446 };
 447
 448 /**
 449  * struct pds_core_lif_getattr_cmd - Get LIF attributes from the NIC
 450  * @opcode:     Opcode PDS_AQ_CMD_LIF_GETATTR
 451  * @attr:       Attribute type (enum pds_core_lif_attr)
 452  * @client_id:  Client identifier
 453  */
 454 struct pds_core_lif_getattr_cmd {
 455         u8     opcode;
 456         u8     attr;
 457         __le16 client_id;
 458 };
 459
 460 /**
 461  * struct pds_core_lif_getattr_comp - LIF get attr command completion
 462  * @status:     Status of the command (enum pds_core_status_code)
 463  * @rsvd:       Word boundary padding
 464  * @comp_index: Index in the descriptor ring for which this is the completion
 465  * @state:      LIF state (enum pds_core_lif_state)
 466  * @name:       LIF name string, 0 terminated
 467  * @features:   Features (enum pds_core_hw_features)
 468  * @rsvd2:      Word boundary padding
 469  * @color:      Color bit
 470  */
 471 struct pds_core_lif_getattr_comp {
 472         u8     status;
 473         u8     rsvd;
 474         __le16 comp_index;
 475         union {
 476                 u8      state;
 477                 __le64  features;
 478                 u8      rsvd2[11];
 479         } __packed;
 480         u8     color;
 481 };
 482
 483 /**
 484  * union pds_core_q_identity - Queue identity information
 485  * @version:    Queue type version that can be used with FW
 486  * @supported:  Bitfield of queue versions, first bit = ver 0
 487  * @rsvd:       Word boundary padding
 488  * @features:   Queue features
 489  * @desc_sz:    Descriptor size
 490  * @comp_sz:    Completion descriptor size
 491  * @rsvd2:      Word boundary padding
 492  */
 493 struct pds_core_q_identity {
 494         u8      version;
 495         u8      supported;
 496         u8      rsvd[6];
 497 #define PDS_CORE_QIDENT_F_CQ    0x01    /* queue has completion ring */
 498         __le64  features;
 499         __le16  desc_sz;
 500         __le16  comp_sz;
 501         u8      rsvd2[6];
 502 };
 503
 504 /**
 505  * struct pds_core_q_identify_cmd - queue identify command
 506  * @opcode:     Opcode PDS_AQ_CMD_Q_IDENTIFY
 507  * @type:       Logical queue type (enum pds_core_logical_qtype)
 508  * @client_id:  Client identifier
 509  * @ver:        Highest queue type version that the driver supports
 510  * @rsvd:       Word boundary padding
 511  * @ident_pa:   DMA address to receive the data (struct pds_core_q_identity)
 512  */
 513 struct pds_core_q_identify_cmd {
 514         u8     opcode;
 515         u8     type;
 516         __le16 client_id;
 517         u8     ver;
 518         u8     rsvd[3];
 519         __le64 ident_pa;
 520 };
 521
 522 /**
 523  * struct pds_core_q_identify_comp - queue identify command completion
 524  * @status:     Status of the command (enum pds_core_status_code)
 525  * @rsvd:       Word boundary padding
 526  * @comp_index: Index in the descriptor ring for which this is the completion
 527  * @ver:        Queue type version that can be used with FW
 528  * @rsvd1:      Word boundary padding
 529  * @color:      Color bit
 530  */
 531 struct pds_core_q_identify_comp {
 532         u8     status;
 533         u8     rsvd;
 534         __le16 comp_index;
 535         u8     ver;
 536         u8     rsvd1[10];
 537         u8     color;
 538 };
 539
 540 /**
 541  * struct pds_core_q_init_cmd - Queue init command
 542  * @opcode:       Opcode PDS_AQ_CMD_Q_INIT
 543  * @type:         Logical queue type
 544  * @client_id:    Client identifier
 545  * @ver:          Queue type version
 546  * @rsvd:         Word boundary padding
 547  * @index:        (LIF, qtype) relative admin queue index
 548  * @intr_index:   Interrupt control register index, or Event queue index
 549  * @pid:          Process ID
 550  * @flags:
 551  *    IRQ:        Interrupt requested on completion
 552  *    ENA:        Enable the queue.  If ENA=0 the queue is initialized
 553  *                but remains disabled, to be later enabled with the
 554  *                Queue Enable command. If ENA=1, then queue is
 555  *                initialized and then enabled.
 556  * @cos:          Class of service for this queue
 557  * @ring_size:    Queue ring size, encoded as a log2(size), in
 558  *                number of descriptors.  The actual ring size is
 559  *                (1 << ring_size).  For example, to select a ring size
 560  *                of 64 descriptors write ring_size = 6. The minimum
 561  *                ring_size value is 2 for a ring of 4 descriptors.
 562  *                The maximum ring_size value is 12 for a ring of 4k
 563  *                descriptors. Values of ring_size <2 and >12 are
 564  *                reserved.
 565  * @ring_base:    Queue ring base address
 566  * @cq_ring_base: Completion queue ring base address
 567  */
 568 struct pds_core_q_init_cmd {
 569         u8     opcode;
 570         u8     type;
 571         __le16 client_id;
 572         u8     ver;
 573         u8     rsvd[3];
 574         __le32 index;
 575         __le16 pid;
 576         __le16 intr_index;
 577         __le16 flags;
 578 #define PDS_CORE_QINIT_F_IRQ    0x01    /* Request interrupt on completion */
 579 #define PDS_CORE_QINIT_F_ENA    0x02    /* Enable the queue */
 580         u8     cos;
 581 #define PDS_CORE_QSIZE_MIN_LG2  2
 582 #define PDS_CORE_QSIZE_MAX_LG2  12
 583         u8     ring_size;
 584         __le64 ring_base;
 585         __le64 cq_ring_base;
 586 } __packed;
 587
 588 /**
 589  * struct pds_core_q_init_comp - Queue init command completion
 590  * @status:     Status of the command (enum pds_core_status_code)
 591  * @rsvd:       Word boundary padding
 592  * @comp_index: Index in the descriptor ring for which this is the completion
 593  * @hw_index:   Hardware Queue ID
 594  * @hw_type:    Hardware Queue type
 595  * @rsvd2:      Word boundary padding
 596  * @color:      Color
 597  */
 598 struct pds_core_q_init_comp {
 599         u8     status;
 600         u8     rsvd;
 601         __le16 comp_index;
 602         __le32 hw_index;
 603         u8     hw_type;
 604         u8     rsvd2[6];
 605         u8     color;
 606 };
 607
 608 /*
 609  * enum pds_vdpa_cmd_opcode - vDPA Device commands
 610  */
 611 enum pds_vdpa_cmd_opcode {
 612         PDS_VDPA_CMD_INIT               = 48,
 613         PDS_VDPA_CMD_IDENT              = 49,
 614         PDS_VDPA_CMD_RESET              = 51,
 615         PDS_VDPA_CMD_VQ_RESET           = 52,
 616         PDS_VDPA_CMD_VQ_INIT            = 53,
 617         PDS_VDPA_CMD_STATUS_UPDATE      = 54,
 618         PDS_VDPA_CMD_SET_FEATURES       = 55,
 619         PDS_VDPA_CMD_SET_ATTR           = 56,
 620 };
 621
 622 /**
 623  * struct pds_vdpa_cmd - generic command
 624  * @opcode:     Opcode
 625  * @vdpa_index: Index for vdpa subdevice
 626  * @vf_id:      VF id
 627  */
 628 struct pds_vdpa_cmd {
 629         u8     opcode;
 630         u8     vdpa_index;
 631         __le16 vf_id;
 632 };
 633
 634 /**
 635  * struct pds_vdpa_init_cmd - INIT command
 636  * @opcode:     Opcode PDS_VDPA_CMD_INIT
 637  * @vdpa_index: Index for vdpa subdevice
 638  * @vf_id:      VF id
 639  */
 640 struct pds_vdpa_init_cmd {
 641         u8     opcode;
 642         u8     vdpa_index;
 643         __le16 vf_id;
 644 };
 645
 646 /**
 647  * struct pds_vdpa_ident - vDPA identification data
 648  * @hw_features:        vDPA features supported by device
 649  * @max_vqs:            max queues available (2 queues for a single queuepair)
 650  * @max_qlen:           log(2) of maximum number of descriptors
 651  * @min_qlen:           log(2) of minimum number of descriptors
 652  *
 653  * This struct is used in a DMA block that is set up for the PDS_VDPA_CMD_IDENT
 654  * transaction.  Set up the DMA block and send the address in the IDENT cmd
 655  * data, the DSC will write the ident information, then we can remove the DMA
 656  * block after reading the answer.  If the completion status is 0, then there
 657  * is valid information, else there was an error and the data should be invalid.
 658  */
 659 struct pds_vdpa_ident {
 660         __le64 hw_features;
 661         __le16 max_vqs;
 662         __le16 max_qlen;
 663         __le16 min_qlen;
 664 };
 665
 666 /**
 667  * struct pds_vdpa_ident_cmd - IDENT command
 668  * @opcode:     Opcode PDS_VDPA_CMD_IDENT
 669  * @rsvd:       Word boundary padding
 670  * @vf_id:      VF id
 671  * @len:        length of ident info DMA space
 672  * @ident_pa:   address for DMA of ident info (struct pds_vdpa_ident)
 673  *                      only used for this transaction, then forgotten by DSC
 674  */
 675 struct pds_vdpa_ident_cmd {
 676         u8     opcode;
 677         u8     rsvd;
 678         __le16 vf_id;
 679         __le32 len;
 680         __le64 ident_pa;
 681 };
 682
 683 /**
 684  * struct pds_vdpa_status_cmd - STATUS_UPDATE command
 685  * @opcode:     Opcode PDS_VDPA_CMD_STATUS_UPDATE
 686  * @vdpa_index: Index for vdpa subdevice
 687  * @vf_id:      VF id
 688  * @status:     new status bits
 689  */
 690 struct pds_vdpa_status_cmd {
 691         u8     opcode;
 692         u8     vdpa_index;
 693         __le16 vf_id;
 694         u8     status;
 695 };
 696
 697 /**
 698  * enum pds_vdpa_attr - List of VDPA device attributes
 699  * @PDS_VDPA_ATTR_MAC:          MAC address
 700  * @PDS_VDPA_ATTR_MAX_VQ_PAIRS: Max virtqueue pairs
 701  */
 702 enum pds_vdpa_attr {
 703         PDS_VDPA_ATTR_MAC          = 1,
 704         PDS_VDPA_ATTR_MAX_VQ_PAIRS = 2,
 705 };
 706
 707 /**
 708  * struct pds_vdpa_setattr_cmd - SET_ATTR command
 709  * @opcode:             Opcode PDS_VDPA_CMD_SET_ATTR
 710  * @vdpa_index:         Index for vdpa subdevice
 711  * @vf_id:              VF id
 712  * @attr:               attribute to be changed (enum pds_vdpa_attr)
 713  * @pad:                Word boundary padding
 714  * @mac:                new mac address to be assigned as vdpa device address
 715  * @max_vq_pairs:       new limit of virtqueue pairs
 716  */
 717 struct pds_vdpa_setattr_cmd {
 718         u8     opcode;
 719         u8     vdpa_index;
 720         __le16 vf_id;
 721         u8     attr;
 722         u8     pad[3];
 723         union {
 724                 u8 mac[6];
 725                 __le16 max_vq_pairs;
 726         } __packed;
 727 };
 728
 729 /**
 730  * struct pds_vdpa_vq_init_cmd - queue init command
 731  * @opcode: Opcode PDS_VDPA_CMD_VQ_INIT
 732  * @vdpa_index: Index for vdpa subdevice
 733  * @vf_id:      VF id
 734  * @qid:        Queue id (bit0 clear = rx, bit0 set = tx, qid=N is ctrlq)
 735  * @len:        log(2) of max descriptor count
 736  * @desc_addr:  DMA address of descriptor area
 737  * @avail_addr: DMA address of available descriptors (aka driver area)
 738  * @used_addr:  DMA address of used descriptors (aka device area)
 739  * @intr_index: interrupt index
 740  * @avail_index:        initial device position in available ring
 741  * @used_index: initial device position in used ring
 742  */
 743 struct pds_vdpa_vq_init_cmd {
 744         u8     opcode;
 745         u8     vdpa_index;
 746         __le16 vf_id;
 747         __le16 qid;
 748         __le16 len;
 749         __le64 desc_addr;
 750         __le64 avail_addr;
 751         __le64 used_addr;
 752         __le16 intr_index;
 753         __le16 avail_index;
 754         __le16 used_index;
 755 };
 756
 757 /**
 758  * struct pds_vdpa_vq_init_comp - queue init completion
 759  * @status:     Status of the command (enum pds_core_status_code)
 760  * @hw_qtype:   HW queue type, used in doorbell selection
 761  * @hw_qindex:  HW queue index, used in doorbell selection
 762  * @rsvd:       Word boundary padding
 763  * @color:      Color bit
 764  */
 765 struct pds_vdpa_vq_init_comp {
 766         u8     status;
 767         u8     hw_qtype;
 768         __le16 hw_qindex;
 769         u8     rsvd[11];
 770         u8     color;
 771 };
 772
 773 /**
 774  * struct pds_vdpa_vq_reset_cmd - queue reset command
 775  * @opcode:     Opcode PDS_VDPA_CMD_VQ_RESET
 776  * @vdpa_index: Index for vdpa subdevice
 777  * @vf_id:      VF id
 778  * @qid:        Queue id
 779  */
 780 struct pds_vdpa_vq_reset_cmd {
 781         u8     opcode;
 782         u8     vdpa_index;
 783         __le16 vf_id;
 784         __le16 qid;
 785 };
 786
 787 /**
 788  * struct pds_vdpa_vq_reset_comp - queue reset completion
 789  * @status:     Status of the command (enum pds_core_status_code)
 790  * @rsvd0:      Word boundary padding
 791  * @avail_index:        current device position in available ring
 792  * @used_index: current device position in used ring
 793  * @rsvd:       Word boundary padding
 794  * @color:      Color bit
 795  */
 796 struct pds_vdpa_vq_reset_comp {
 797         u8     status;
 798         u8     rsvd0;
 799         __le16 avail_index;
 800         __le16 used_index;
 801         u8     rsvd[9];
 802         u8     color;
 803 };
 804
 805 /**
 806  * struct pds_vdpa_set_features_cmd - set hw features
 807  * @opcode: Opcode PDS_VDPA_CMD_SET_FEATURES
 808  * @vdpa_index: Index for vdpa subdevice
 809  * @vf_id:      VF id
 810  * @rsvd:       Word boundary padding
 811  * @features:   Feature bit mask
 812  */
 813 struct pds_vdpa_set_features_cmd {
 814         u8     opcode;
 815         u8     vdpa_index;
 816         __le16 vf_id;
 817         __le32 rsvd;
 818         __le64 features;
 819 };
 820
 821 #define PDS_LM_DEVICE_STATE_LENGTH              65536
 822 #define PDS_LM_CHECK_DEVICE_STATE_LENGTH(X) \
 823                         PDS_CORE_SIZE_CHECK(union, PDS_LM_DEVICE_STATE_LENGTH, X)
 824
 825 /*
 826  * enum pds_lm_cmd_opcode - Live Migration Device commands
 827  */
 828 enum pds_lm_cmd_opcode {
 829         PDS_LM_CMD_HOST_VF_STATUS  = 1,
 830
 831         /* Device state commands */
 832         PDS_LM_CMD_STATE_SIZE      = 16,
 833         PDS_LM_CMD_SUSPEND         = 18,
 834         PDS_LM_CMD_SUSPEND_STATUS  = 19,
 835         PDS_LM_CMD_RESUME          = 20,
 836         PDS_LM_CMD_SAVE            = 21,
 837         PDS_LM_CMD_RESTORE         = 22,
 838
 839         /* Dirty page tracking commands */
 840         PDS_LM_CMD_DIRTY_STATUS    = 32,
 841         PDS_LM_CMD_DIRTY_ENABLE    = 33,
 842         PDS_LM_CMD_DIRTY_DISABLE   = 34,
 843         PDS_LM_CMD_DIRTY_READ_SEQ  = 35,
 844         PDS_LM_CMD_DIRTY_WRITE_ACK = 36,
 845 };
 846
 847 /**
 848  * struct pds_lm_cmd - generic command
 849  * @opcode:     Opcode
 850  * @rsvd:       Word boundary padding
 851  * @vf_id:      VF id
 852  * @rsvd2:      Structure padding to 60 Bytes
 853  */
 854 struct pds_lm_cmd {
 855         u8     opcode;
 856         u8     rsvd;
 857         __le16 vf_id;
 858         u8     rsvd2[56];
 859 };
 860
 861 /**
 862  * struct pds_lm_state_size_cmd - STATE_SIZE command
 863  * @opcode:     Opcode
 864  * @rsvd:       Word boundary padding
 865  * @vf_id:      VF id
 866  */
 867 struct pds_lm_state_size_cmd {
 868         u8     opcode;
 869         u8     rsvd;
 870         __le16 vf_id;
 871 };
 872
 873 /**
 874  * struct pds_lm_state_size_comp - STATE_SIZE command completion
 875  * @status:             Status of the command (enum pds_core_status_code)
 876  * @rsvd:               Word boundary padding
 877  * @comp_index:         Index in the desc ring for which this is the completion
 878  * @size:               Size of the device state
 879  * @rsvd2:              Word boundary padding
 880  * @color:              Color bit
 881  */
 882 struct pds_lm_state_size_comp {
 883         u8     status;
 884         u8     rsvd;
 885         __le16 comp_index;
 886         union {
 887                 __le64 size;
 888                 u8     rsvd2[11];
 889         } __packed;
 890         u8     color;
 891 };
 892
 893 enum pds_lm_suspend_resume_type {
 894         PDS_LM_SUSPEND_RESUME_TYPE_FULL = 0,
 895         PDS_LM_SUSPEND_RESUME_TYPE_P2P = 1,
 896 };
 897
 898 /**
 899  * struct pds_lm_suspend_cmd - SUSPEND command
 900  * @opcode:     Opcode PDS_LM_CMD_SUSPEND
 901  * @rsvd:       Word boundary padding
 902  * @vf_id:      VF id
 903  * @type:       Type of suspend (enum pds_lm_suspend_resume_type)
 904  */
 905 struct pds_lm_suspend_cmd {
 906         u8     opcode;
 907         u8     rsvd;
 908         __le16 vf_id;
 909         u8     type;
 910 };
 911
 912 /**
 913  * struct pds_lm_suspend_status_cmd - SUSPEND status command
 914  * @opcode:     Opcode PDS_AQ_CMD_LM_SUSPEND_STATUS
 915  * @rsvd:       Word boundary padding
 916  * @vf_id:      VF id
 917  * @type:       Type of suspend (enum pds_lm_suspend_resume_type)
 918  */
 919 struct pds_lm_suspend_status_cmd {
 920         u8 opcode;
 921         u8 rsvd;
 922         __le16 vf_id;
 923         u8 type;
 924 };
 925
 926 /**
 927  * struct pds_lm_resume_cmd - RESUME command
 928  * @opcode:     Opcode PDS_LM_CMD_RESUME
 929  * @rsvd:       Word boundary padding
 930  * @vf_id:      VF id
 931  * @type:       Type of resume (enum pds_lm_suspend_resume_type)
 932  */
 933 struct pds_lm_resume_cmd {
 934         u8     opcode;
 935         u8     rsvd;
 936         __le16 vf_id;
 937         u8     type;
 938 };
 939
 940 /**
 941  * struct pds_lm_sg_elem - Transmit scatter-gather (SG) descriptor element
 942  * @addr:       DMA address of SG element data buffer
 943  * @len:        Length of SG element data buffer, in bytes
 944  * @rsvd:       Word boundary padding
 945  */
 946 struct pds_lm_sg_elem {
 947         __le64 addr;
 948         __le32 len;
 949         __le16 rsvd[2];
 950 };
 951
 952 /**
 953  * struct pds_lm_save_cmd - SAVE command
 954  * @opcode:     Opcode PDS_LM_CMD_SAVE
 955  * @rsvd:       Word boundary padding
 956  * @vf_id:      VF id
 957  * @rsvd2:      Word boundary padding
 958  * @sgl_addr:   IOVA address of the SGL to dma the device state
 959  * @num_sge:    Total number of SG elements
 960  */
 961 struct pds_lm_save_cmd {
 962         u8     opcode;
 963         u8     rsvd;
 964         __le16 vf_id;
 965         u8     rsvd2[4];
 966         __le64 sgl_addr;
 967         __le32 num_sge;
 968 } __packed;
 969
 970 /**
 971  * struct pds_lm_restore_cmd - RESTORE command
 972  * @opcode:     Opcode PDS_LM_CMD_RESTORE
 973  * @rsvd:       Word boundary padding
 974  * @vf_id:      VF id
 975  * @rsvd2:      Word boundary padding
 976  * @sgl_addr:   IOVA address of the SGL to dma the device state
 977  * @num_sge:    Total number of SG elements
 978  */
 979 struct pds_lm_restore_cmd {
 980         u8     opcode;
 981         u8     rsvd;
 982         __le16 vf_id;
 983         u8     rsvd2[4];
 984         __le64 sgl_addr;
 985         __le32 num_sge;
 986 } __packed;
 987
 988 /**
 989  * union pds_lm_dev_state - device state information
 990  * @words:      Device state words
 991  */
 992 union pds_lm_dev_state {
 993         __le32 words[PDS_LM_DEVICE_STATE_LENGTH / sizeof(__le32)];
 994 };
 995
 996 enum pds_lm_host_vf_status {
 997         PDS_LM_STA_NONE = 0,
 998         PDS_LM_STA_IN_PROGRESS,
 999         PDS_LM_STA_MAX,
1000 };
1001
1002 /**
1003  * struct pds_lm_dirty_region_info - Memory region info for STATUS and ENABLE
1004  * @dma_base:           Base address of the DMA-contiguous memory region
1005  * @page_count:         Number of pages in the memory region
1006  * @page_size_log2:     Log2 page size in the memory region
1007  * @rsvd:               Word boundary padding
1008  */
1009 struct pds_lm_dirty_region_info {
1010         __le64 dma_base;
1011         __le32 page_count;
1012         u8     page_size_log2;
1013         u8     rsvd[3];
1014 };
1015
1016 /**
1017  * struct pds_lm_dirty_status_cmd - DIRTY_STATUS command
1018  * @opcode:             Opcode PDS_LM_CMD_DIRTY_STATUS
1019  * @rsvd:               Word boundary padding
1020  * @vf_id:              VF id
1021  * @max_regions:        Capacity of the region info buffer
1022  * @rsvd2:              Word boundary padding
1023  * @regions_dma:        DMA address of the region info buffer
1024  *
1025  * The minimum of max_regions (from the command) and num_regions (from the
1026  * completion) of struct pds_lm_dirty_region_info will be written to
1027  * regions_dma.
1028  *
1029  * The max_regions may be zero, in which case regions_dma is ignored.  In that
1030  * case, the completion will only report the maximum number of regions
1031  * supported by the device, and the number of regions currently enabled.
1032  */
1033 struct pds_lm_dirty_status_cmd {
1034         u8     opcode;
1035         u8     rsvd;
1036         __le16 vf_id;
1037         u8     max_regions;
1038         u8     rsvd2[3];
1039         __le64 regions_dma;
1040 } __packed;
1041
1042 /**
1043  * enum pds_lm_dirty_bmp_type - Type of dirty page bitmap
1044  * @PDS_LM_DIRTY_BMP_TYPE_NONE: No bitmap / disabled
1045  * @PDS_LM_DIRTY_BMP_TYPE_SEQ_ACK: Seq/Ack bitmap representation
1046  */
1047 enum pds_lm_dirty_bmp_type {
1048         PDS_LM_DIRTY_BMP_TYPE_NONE     = 0,
1049         PDS_LM_DIRTY_BMP_TYPE_SEQ_ACK  = 1,
1050 };
1051
1052 /**
1053  * struct pds_lm_dirty_status_comp - STATUS command completion
1054  * @status:             Status of the command (enum pds_core_status_code)
1055  * @rsvd:               Word boundary padding
1056  * @comp_index:         Index in the desc ring for which this is the completion
1057  * @max_regions:        Maximum number of regions supported by the device
1058  * @num_regions:        Number of regions currently enabled
1059  * @bmp_type:           Type of dirty bitmap representation
1060  * @rsvd2:              Word boundary padding
1061  * @bmp_type_mask:      Mask of supported bitmap types, bit index per type
1062  * @rsvd3:              Word boundary padding
1063  * @color:              Color bit
1064  *
1065  * This completion descriptor is used for STATUS, ENABLE, and DISABLE.
1066  */
1067 struct pds_lm_dirty_status_comp {
1068         u8     status;
1069         u8     rsvd;
1070         __le16 comp_index;
1071         u8     max_regions;
1072         u8     num_regions;
1073         u8     bmp_type;
1074         u8     rsvd2;
1075         __le32 bmp_type_mask;
1076         u8     rsvd3[3];
1077         u8     color;
1078 };
1079
1080 /**
1081  * struct pds_lm_dirty_enable_cmd - DIRTY_ENABLE command
1082  * @opcode:             Opcode PDS_LM_CMD_DIRTY_ENABLE
1083  * @rsvd:               Word boundary padding
1084  * @vf_id:              VF id
1085  * @bmp_type:           Type of dirty bitmap representation
1086  * @num_regions:        Number of entries in the region info buffer
1087  * @rsvd2:              Word boundary padding
1088  * @regions_dma:        DMA address of the region info buffer
1089  *
1090  * The num_regions must be nonzero, and less than or equal to the maximum
1091  * number of regions supported by the device.
1092  *
1093  * The memory regions should not overlap.
1094  *
1095  * The information should be initialized by the driver.  The device may modify
1096  * the information on successful completion, such as by size-aligning the
1097  * number of pages in a region.
1098  *
1099  * The modified number of pages will be greater than or equal to the page count
1100  * given in the enable command, and at least as coarsly aligned as the given
1101  * value.  For example, the count might be aligned to a multiple of 64, but
1102  * if the value is already a multiple of 128 or higher, it will not change.
1103  * If the driver requires its own minimum alignment of the number of pages, the
1104  * driver should account for that already in the region info of this command.
1105  *
1106  * This command uses struct pds_lm_dirty_status_comp for its completion.
1107  */
1108 struct pds_lm_dirty_enable_cmd {
1109         u8     opcode;
1110         u8     rsvd;
1111         __le16 vf_id;
1112         u8     bmp_type;
1113         u8     num_regions;
1114         u8     rsvd2[2];
1115         __le64 regions_dma;
1116 } __packed;
1117
1118 /**
1119  * struct pds_lm_dirty_disable_cmd - DIRTY_DISABLE command
1120  * @opcode:     Opcode PDS_LM_CMD_DIRTY_DISABLE
1121  * @rsvd:       Word boundary padding
1122  * @vf_id:      VF id
1123  *
1124  * Dirty page tracking will be disabled.  This may be called in any state, as
1125  * long as dirty page tracking is supported by the device, to ensure that dirty
1126  * page tracking is disabled.
1127  *
1128  * This command uses struct pds_lm_dirty_status_comp for its completion.  On
1129  * success, num_regions will be zero.
1130  */
1131 struct pds_lm_dirty_disable_cmd {
1132         u8     opcode;
1133         u8     rsvd;
1134         __le16 vf_id;
1135 };
1136
1137 /**
1138  * struct pds_lm_dirty_seq_ack_cmd - DIRTY_READ_SEQ or _WRITE_ACK command
1139  * @opcode:     Opcode PDS_LM_CMD_DIRTY_[READ_SEQ|WRITE_ACK]
1140  * @rsvd:       Word boundary padding
1141  * @vf_id:      VF id
1142  * @off_bytes:  Byte offset in the bitmap
1143  * @len_bytes:  Number of bytes to transfer
1144  * @num_sge:    Number of DMA scatter gather elements
1145  * @rsvd2:      Word boundary padding
1146  * @sgl_addr:   DMA address of scatter gather list
1147  *
1148  * Read bytes from the SEQ bitmap, or write bytes into the ACK bitmap.
1149  *
1150  * This command treats the entire bitmap as a byte buffer.  It does not
1151  * distinguish between guest memory regions.  The driver should refer to the
1152  * number of pages in each region, according to PDS_LM_CMD_DIRTY_STATUS, to
1153  * determine the region boundaries in the bitmap.  Each region will be
1154  * represented by exactly the number of bits as the page count for that region,
1155  * immediately following the last bit of the previous region.
1156  */
1157 struct pds_lm_dirty_seq_ack_cmd {
1158         u8     opcode;
1159         u8     rsvd;
1160         __le16 vf_id;
1161         __le32 off_bytes;
1162         __le32 len_bytes;
1163         __le16 num_sge;
1164         u8     rsvd2[2];
1165         __le64 sgl_addr;
1166 } __packed;
1167
1168 /**
1169  * struct pds_lm_host_vf_status_cmd - HOST_VF_STATUS command
1170  * @opcode:     Opcode PDS_LM_CMD_HOST_VF_STATUS
1171  * @rsvd:       Word boundary padding
1172  * @vf_id:      VF id
1173  * @status:     Current LM status of host VF driver (enum pds_lm_host_status)
1174  */
1175 struct pds_lm_host_vf_status_cmd {
1176         u8     opcode;
1177         u8     rsvd;
1178         __le16 vf_id;
1179         u8     status;
1180 };
1181
1182 union pds_core_adminq_cmd {
1183         u8     opcode;
1184         u8     bytes[64];
1185
1186         struct pds_core_client_reg_cmd     client_reg;
1187         struct pds_core_client_unreg_cmd   client_unreg;
1188         struct pds_core_client_request_cmd client_request;
1189
1190         struct pds_core_lif_identify_cmd  lif_ident;
1191         struct pds_core_lif_init_cmd      lif_init;
1192         struct pds_core_lif_reset_cmd     lif_reset;
1193         struct pds_core_lif_setattr_cmd   lif_setattr;
1194         struct pds_core_lif_getattr_cmd   lif_getattr;
1195
1196         struct pds_core_q_identify_cmd    q_ident;
1197         struct pds_core_q_init_cmd        q_init;
1198
1199         struct pds_vdpa_cmd               vdpa;
1200         struct pds_vdpa_init_cmd          vdpa_init;
1201         struct pds_vdpa_ident_cmd         vdpa_ident;
1202         struct pds_vdpa_status_cmd        vdpa_status;
1203         struct pds_vdpa_setattr_cmd       vdpa_setattr;
1204         struct pds_vdpa_set_features_cmd  vdpa_set_features;
1205         struct pds_vdpa_vq_init_cmd       vdpa_vq_init;
1206         struct pds_vdpa_vq_reset_cmd      vdpa_vq_reset;
1207
1208         struct pds_lm_suspend_cmd         lm_suspend;
1209         struct pds_lm_suspend_status_cmd  lm_suspend_status;
1210         struct pds_lm_resume_cmd          lm_resume;
1211         struct pds_lm_state_size_cmd      lm_state_size;
1212         struct pds_lm_save_cmd            lm_save;
1213         struct pds_lm_restore_cmd         lm_restore;
1214         struct pds_lm_host_vf_status_cmd  lm_host_vf_status;
1215         struct pds_lm_dirty_status_cmd    lm_dirty_status;
1216         struct pds_lm_dirty_enable_cmd    lm_dirty_enable;
1217         struct pds_lm_dirty_disable_cmd   lm_dirty_disable;
1218         struct pds_lm_dirty_seq_ack_cmd   lm_dirty_seq_ack;
1219 };
1220
1221 union pds_core_adminq_comp {
1222         struct {
1223                 u8     status;
1224                 u8     rsvd;
1225                 __le16 comp_index;
1226                 u8     rsvd2[11];
1227                 u8     color;
1228         };
1229         u32    words[4];
1230
1231         struct pds_core_client_reg_comp   client_reg;
1232
1233         struct pds_core_lif_identify_comp lif_ident;
1234         struct pds_core_lif_init_comp     lif_init;
1235         struct pds_core_lif_setattr_comp  lif_setattr;
1236         struct pds_core_lif_getattr_comp  lif_getattr;
1237
1238         struct pds_core_q_identify_comp   q_ident;
1239         struct pds_core_q_init_comp       q_init;
1240
1241         struct pds_vdpa_vq_init_comp      vdpa_vq_init;
1242         struct pds_vdpa_vq_reset_comp     vdpa_vq_reset;
1243
1244         struct pds_lm_state_size_comp     lm_state_size;
1245         struct pds_lm_dirty_status_comp   lm_dirty_status;
1246 };
1247
1248 #ifndef __CHECKER__
1249 static_assert(sizeof(union pds_core_adminq_cmd) == 64);
1250 static_assert(sizeof(union pds_core_adminq_comp) == 16);
1251 static_assert(sizeof(union pds_core_notifyq_comp) == 64);
1252 #endif /* __CHECKER__ */
1253
1254 /* The color bit is a 'done' bit for the completion descriptors
1255  * where the meaning alternates between '1' and '0' for alternating
1256  * passes through the completion descriptor ring.
1257  */
1258 static inline bool pdsc_color_match(u8 color, bool done_color)
1259 {
1260         return (!!(color & PDS_COMP_COLOR_MASK)) == done_color;
1261 }
1262
1263 struct pdsc;
1264 int pdsc_adminq_post(struct pdsc *pdsc,
1265                      union pds_core_adminq_cmd *cmd,
1266                      union pds_core_adminq_comp *comp,
1267                      bool fast_poll);
1268
1269 #endif /* _PDS_CORE_ADMINQ_H_ */