1 /* SPDX-License-Identifier: MIT */ 2 /* 3 * Copyright © 2023 Intel Corporation 4 */ 5 6 #ifndef _ABI_GUC_ACTIONS_SRIOV_ABI_H 7 #define _ABI_GUC_ACTIONS_SRIOV_ABI_H 8 9 #include "guc_communication_ctb_abi.h" 10 11 /** 12 * DOC: GUC2PF_RELAY_FROM_VF 13 * 14 * This message is used by the GuC firmware to forward a VF2PF `Relay Message`_ 15 * received from the Virtual Function (VF) driver to this Physical Function (PF) 16 * driver. 17 * 18 * This message is always sent as `CTB HXG Message`_. 19 * 20 * +---+-------+--------------------------------------------------------------+ 21 * | | Bits | Description | 22 * +===+=======+==============================================================+ 23 * | 0 | 31 | ORIGIN = GUC_HXG_ORIGIN_GUC_ | 24 * | +-------+--------------------------------------------------------------+ 25 * | | 30:28 | TYPE = GUC_HXG_TYPE_EVENT_ | 26 * | +-------+--------------------------------------------------------------+ 27 * | | 27:16 | MBZ | 28 * | +-------+--------------------------------------------------------------+ 29 * | | 15:0 | ACTION = _`XE_GUC_ACTION_GUC2PF_RELAY_FROM_VF` = 0x5100 | 30 * +---+-------+--------------------------------------------------------------+ 31 * | 1 | 31:0 | **VFID** - source VF identifier | 32 * +---+-------+--------------------------------------------------------------+ 33 * | 2 | 31:0 | **RELAY_ID** - VF/PF message ID | 34 * +---+-------+-----------------+--------------------------------------------+ 35 * | 3 | 31:0 | **RELAY_DATA1** | | 36 * +---+-------+-----------------+ | 37 * |...| | | [Embedded `Relay Message`_] | 38 * +---+-------+-----------------+ | 39 * | n | 31:0 | **RELAY_DATAx** | | 40 * +---+-------+-----------------+--------------------------------------------+ 41 */ 42 #define XE_GUC_ACTION_GUC2PF_RELAY_FROM_VF 0x5100 43 44 #define GUC2PF_RELAY_FROM_VF_EVENT_MSG_MIN_LEN (GUC_HXG_EVENT_MSG_MIN_LEN + 2u) 45 #define GUC2PF_RELAY_FROM_VF_EVENT_MSG_MAX_LEN \ 46 (GUC2PF_RELAY_FROM_VF_EVENT_MSG_MIN_LEN + GUC_RELAY_MSG_MAX_LEN) 47 #define GUC2PF_RELAY_FROM_VF_EVENT_MSG_0_MBZ GUC_HXG_EVENT_MSG_0_DATA0 48 #define GUC2PF_RELAY_FROM_VF_EVENT_MSG_1_VFID GUC_HXG_EVENT_MSG_n_DATAn 49 #define GUC2PF_RELAY_FROM_VF_EVENT_MSG_2_RELAY_ID GUC_HXG_EVENT_MSG_n_DATAn 50 #define GUC2PF_RELAY_FROM_VF_EVENT_MSG_3_RELAY_DATA1 GUC_HXG_EVENT_MSG_n_DATAn 51 #define GUC2PF_RELAY_FROM_VF_EVENT_MSG_n_RELAY_DATAx GUC_HXG_EVENT_MSG_n_DATAn 52 #define GUC2PF_RELAY_FROM_VF_EVENT_MSG_NUM_RELAY_DATA GUC_RELAY_MSG_MAX_LEN 53 54 /** 55 * DOC: PF2GUC_RELAY_TO_VF 56 * 57 * This H2G message is used by the Physical Function (PF) driver to send embedded 58 * VF2PF `Relay Message`_ to the VF. 59 * 60 * This action message must be sent over CTB as `CTB HXG Message`_. 61 * 62 * +---+-------+--------------------------------------------------------------+ 63 * | | Bits | Description | 64 * +===+=======+==============================================================+ 65 * | 0 | 31 | ORIGIN = GUC_HXG_ORIGIN_HOST_ | 66 * | +-------+--------------------------------------------------------------+ 67 * | | 30:28 | TYPE = `GUC_HXG_TYPE_FAST_REQUEST`_ | 68 * | +-------+--------------------------------------------------------------+ 69 * | | 27:16 | MBZ | 70 * | +-------+--------------------------------------------------------------+ 71 * | | 15:0 | ACTION = _`XE_GUC_ACTION_PF2GUC_RELAY_TO_VF` = 0x5101 | 72 * +---+-------+--------------------------------------------------------------+ 73 * | 1 | 31:0 | **VFID** - target VF identifier | 74 * +---+-------+--------------------------------------------------------------+ 75 * | 2 | 31:0 | **RELAY_ID** - VF/PF message ID | 76 * +---+-------+-----------------+--------------------------------------------+ 77 * | 3 | 31:0 | **RELAY_DATA1** | | 78 * +---+-------+-----------------+ | 79 * |...| | | [Embedded `Relay Message`_] | 80 * +---+-------+-----------------+ | 81 * | n | 31:0 | **RELAY_DATAx** | | 82 * +---+-------+-----------------+--------------------------------------------+ 83 */ 84 #define XE_GUC_ACTION_PF2GUC_RELAY_TO_VF 0x5101 85 86 #define PF2GUC_RELAY_TO_VF_REQUEST_MSG_MIN_LEN (GUC_HXG_REQUEST_MSG_MIN_LEN + 2u) 87 #define PF2GUC_RELAY_TO_VF_REQUEST_MSG_MAX_LEN \ 88 (PF2GUC_RELAY_TO_VF_REQUEST_MSG_MIN_LEN + GUC_RELAY_MSG_MAX_LEN) 89 #define PF2GUC_RELAY_TO_VF_REQUEST_MSG_0_MBZ GUC_HXG_REQUEST_MSG_0_DATA0 90 #define PF2GUC_RELAY_TO_VF_REQUEST_MSG_1_VFID GUC_HXG_REQUEST_MSG_n_DATAn 91 #define PF2GUC_RELAY_TO_VF_REQUEST_MSG_2_RELAY_ID GUC_HXG_REQUEST_MSG_n_DATAn 92 #define PF2GUC_RELAY_TO_VF_REQUEST_MSG_3_RELAY_DATA1 GUC_HXG_REQUEST_MSG_n_DATAn 93 #define PF2GUC_RELAY_TO_VF_REQUEST_MSG_n_RELAY_DATAx GUC_HXG_REQUEST_MSG_n_DATAn 94 #define PF2GUC_RELAY_TO_VF_REQUEST_MSG_NUM_RELAY_DATA GUC_RELAY_MSG_MAX_LEN 95 96 /** 97 * DOC: GUC2VF_RELAY_FROM_PF 98 * 99 * This message is used by the GuC firmware to deliver `Relay Message`_ from the 100 * Physical Function (PF) driver to this Virtual Function (VF) driver. 101 * See `GuC Relay Communication`_ for details. 102 * 103 * This message is always sent over CTB. 104 * 105 * +---+-------+--------------------------------------------------------------+ 106 * | | Bits | Description | 107 * +===+=======+==============================================================+ 108 * | 0 | 31 | ORIGIN = GUC_HXG_ORIGIN_GUC_ | 109 * | +-------+--------------------------------------------------------------+ 110 * | | 30:28 | TYPE = GUC_HXG_TYPE_EVENT_ | 111 * | +-------+--------------------------------------------------------------+ 112 * | | 27:16 | MBZ | 113 * | +-------+--------------------------------------------------------------+ 114 * | | 15:0 | ACTION = _`XE_GUC_ACTION_GUC2VF_RELAY_FROM_PF` = 0x5102 | 115 * +---+-------+--------------------------------------------------------------+ 116 * | 1 | 31:0 | **RELAY_ID** - VF/PF message ID | 117 * +---+-------+-----------------+--------------------------------------------+ 118 * | 2 | 31:0 | **RELAY_DATA1** | | 119 * +---+-------+-----------------+ | 120 * |...| | | [Embedded `Relay Message`_] | 121 * +---+-------+-----------------+ | 122 * | n | 31:0 | **RELAY_DATAx** | | 123 * +---+-------+-----------------+--------------------------------------------+ 124 */ 125 #define XE_GUC_ACTION_GUC2VF_RELAY_FROM_PF 0x5102 126 127 #define GUC2VF_RELAY_FROM_PF_EVENT_MSG_MIN_LEN (GUC_HXG_EVENT_MSG_MIN_LEN + 1u) 128 #define GUC2VF_RELAY_FROM_PF_EVENT_MSG_MAX_LEN \ 129 (GUC2VF_RELAY_FROM_PF_EVENT_MSG_MIN_LEN + GUC_RELAY_MSG_MAX_LEN) 130 #define GUC2VF_RELAY_FROM_PF_EVENT_MSG_0_MBZ GUC_HXG_EVENT_MSG_0_DATA0 131 #define GUC2VF_RELAY_FROM_PF_EVENT_MSG_1_RELAY_ID GUC_HXG_EVENT_MSG_n_DATAn 132 #define GUC2VF_RELAY_FROM_PF_EVENT_MSG_n_RELAY_DATAx GUC_HXG_EVENT_MSG_n_DATAn 133 #define GUC2VF_RELAY_FROM_PF_EVENT_MSG_NUM_RELAY_DATA GUC_RELAY_MSG_MAX_LEN 134 135 /** 136 * DOC: VF2GUC_RELAY_TO_PF 137 * 138 * This message is used by the Virtual Function (VF) drivers to communicate with 139 * the Physical Function (PF) driver and send `Relay Message`_ to the PF driver. 140 * See `GuC Relay Communication`_ for details. 141 * 142 * This message must be sent over CTB. 143 * 144 * +---+-------+--------------------------------------------------------------+ 145 * | | Bits | Description | 146 * +===+=======+==============================================================+ 147 * | 0 | 31 | ORIGIN = GUC_HXG_ORIGIN_HOST_ | 148 * | +-------+--------------------------------------------------------------+ 149 * | | 30:28 | TYPE = GUC_HXG_TYPE_REQUEST_ or GUC_HXG_TYPE_FAST_REQUEST_ | 150 * | +-------+--------------------------------------------------------------+ 151 * | | 27:16 | MBZ | 152 * | +-------+--------------------------------------------------------------+ 153 * | | 15:0 | ACTION = _`XE_GUC_ACTION_VF2GUC_RELAY_TO_PF` = 0x5103 | 154 * +---+-------+--------------------------------------------------------------+ 155 * | 1 | 31:0 | **RELAY_ID** - VF/PF message ID | 156 * +---+-------+-----------------+--------------------------------------------+ 157 * | 2 | 31:0 | **RELAY_DATA1** | | 158 * +---+-------+-----------------+ | 159 * |...| | | [Embedded `Relay Message`_] | 160 * +---+-------+-----------------+ | 161 * | n | 31:0 | **RELAY_DATAx** | | 162 * +---+-------+-----------------+--------------------------------------------+ 163 */ 164 #define XE_GUC_ACTION_VF2GUC_RELAY_TO_PF 0x5103 165 166 #define VF2GUC_RELAY_TO_PF_REQUEST_MSG_MIN_LEN (GUC_HXG_REQUEST_MSG_MIN_LEN + 1u) 167 #define VF2GUC_RELAY_TO_PF_REQUEST_MSG_MAX_LEN \ 168 (VF2GUC_RELAY_TO_PF_REQUEST_MSG_MIN_LEN + GUC_RELAY_MSG_MAX_LEN) 169 #define VF2GUC_RELAY_TO_PF_REQUEST_MSG_0_MBZ GUC_HXG_REQUEST_MSG_0_DATA0 170 #define VF2GUC_RELAY_TO_PF_REQUEST_MSG_1_RELAY_ID GUC_HXG_REQUEST_MSG_n_DATAn 171 #define VF2GUC_RELAY_TO_PF_REQUEST_MSG_n_RELAY_DATAx GUC_HXG_REQUEST_MSG_n_DATAn 172 #define VF2GUC_RELAY_TO_PF_REQUEST_MSG_NUM_RELAY_DATA GUC_RELAY_MSG_MAX_LEN 173 174 /** 175 * DOC: GUC2PF_VF_STATE_NOTIFY 176 * 177 * The GUC2PF_VF_STATE_NOTIFY message is used by the GuC to notify PF about change 178 * of the VF state. 179 * 180 * This G2H message is sent as `CTB HXG Message`_. 181 * 182 * +---+-------+--------------------------------------------------------------+ 183 * | | Bits | Description | 184 * +===+=======+==============================================================+ 185 * | 0 | 31 | ORIGIN = GUC_HXG_ORIGIN_GUC_ | 186 * | +-------+--------------------------------------------------------------+ 187 * | | 30:28 | TYPE = GUC_HXG_TYPE_EVENT_ | 188 * | +-------+--------------------------------------------------------------+ 189 * | | 27:16 | DATA0 = MBZ | 190 * | +-------+--------------------------------------------------------------+ 191 * | | 15:0 | ACTION = _`GUC_ACTION_GUC2PF_VF_STATE_NOTIFY` = 0x5106 | 192 * +---+-------+--------------------------------------------------------------+ 193 * | 1 | 31:0 | DATA1 = **VFID** - VF identifier | 194 * +---+-------+--------------------------------------------------------------+ 195 * | 2 | 31:0 | DATA2 = **EVENT** - notification event: | 196 * | | | | 197 * | | | - _`GUC_PF_NOTIFY_VF_ENABLE` = 1 (only if VFID = 0) | 198 * | | | - _`GUC_PF_NOTIFY_VF_FLR` = 1 | 199 * | | | - _`GUC_PF_NOTIFY_VF_FLR_DONE` = 2 | 200 * | | | - _`GUC_PF_NOTIFY_VF_PAUSE_DONE` = 3 | 201 * | | | - _`GUC_PF_NOTIFY_VF_FIXUP_DONE` = 4 | 202 * +---+-------+--------------------------------------------------------------+ 203 */ 204 #define GUC_ACTION_GUC2PF_VF_STATE_NOTIFY 0x5106u 205 206 #define GUC2PF_VF_STATE_NOTIFY_EVENT_MSG_LEN (GUC_HXG_EVENT_MSG_MIN_LEN + 2u) 207 #define GUC2PF_VF_STATE_NOTIFY_EVENT_MSG_0_MBZ GUC_HXG_EVENT_MSG_0_DATA0 208 #define GUC2PF_VF_STATE_NOTIFY_EVENT_MSG_1_VFID GUC_HXG_EVENT_MSG_n_DATAn 209 #define GUC2PF_VF_STATE_NOTIFY_EVENT_MSG_2_EVENT GUC_HXG_EVENT_MSG_n_DATAn 210 #define GUC_PF_NOTIFY_VF_ENABLE 1u 211 #define GUC_PF_NOTIFY_VF_FLR 1u 212 #define GUC_PF_NOTIFY_VF_FLR_DONE 2u 213 #define GUC_PF_NOTIFY_VF_PAUSE_DONE 3u 214 #define GUC_PF_NOTIFY_VF_FIXUP_DONE 4u 215 216 /** 217 * DOC: PF2GUC_UPDATE_VGT_POLICY 218 * 219 * This message is used by the PF to set `GuC VGT Policy KLVs`_. 220 * 221 * This message must be sent as `CTB HXG Message`_. 222 * 223 * +---+-------+--------------------------------------------------------------+ 224 * | | Bits | Description | 225 * +===+=======+==============================================================+ 226 * | 0 | 31 | ORIGIN = GUC_HXG_ORIGIN_HOST_ | 227 * | +-------+--------------------------------------------------------------+ 228 * | | 30:28 | TYPE = GUC_HXG_TYPE_REQUEST_ | 229 * | +-------+--------------------------------------------------------------+ 230 * | | 27:16 | MBZ | 231 * | +-------+--------------------------------------------------------------+ 232 * | | 15:0 | ACTION = _`GUC_ACTION_PF2GUC_UPDATE_VGT_POLICY` = 0x5502 | 233 * +---+-------+--------------------------------------------------------------+ 234 * | 1 | 31:0 | **CFG_ADDR_LO** - dword aligned GGTT offset that | 235 * | | | represents the start of `GuC VGT Policy KLVs`_ list. | 236 * +---+-------+--------------------------------------------------------------+ 237 * | 2 | 31:0 | **CFG_ADDR_HI** - upper 32 bits of above offset. | 238 * +---+-------+--------------------------------------------------------------+ 239 * | 3 | 31:0 | **CFG_SIZE** - size (in dwords) of the config buffer | 240 * +---+-------+--------------------------------------------------------------+ 241 * 242 * +---+-------+--------------------------------------------------------------+ 243 * | | Bits | Description | 244 * +===+=======+==============================================================+ 245 * | 0 | 31 | ORIGIN = GUC_HXG_ORIGIN_GUC_ | 246 * | +-------+--------------------------------------------------------------+ 247 * | | 30:28 | TYPE = GUC_HXG_TYPE_RESPONSE_SUCCESS_ | 248 * | +-------+--------------------------------------------------------------+ 249 * | | 27:0 | **COUNT** - number of KLVs successfully applied | 250 * +---+-------+--------------------------------------------------------------+ 251 */ 252 #define GUC_ACTION_PF2GUC_UPDATE_VGT_POLICY 0x5502u 253 254 #define PF2GUC_UPDATE_VGT_POLICY_REQUEST_MSG_LEN (GUC_HXG_REQUEST_MSG_MIN_LEN + 3u) 255 #define PF2GUC_UPDATE_VGT_POLICY_REQUEST_MSG_0_MBZ GUC_HXG_REQUEST_MSG_0_DATA0 256 #define PF2GUC_UPDATE_VGT_POLICY_REQUEST_MSG_1_CFG_ADDR_LO GUC_HXG_REQUEST_MSG_n_DATAn 257 #define PF2GUC_UPDATE_VGT_POLICY_REQUEST_MSG_2_CFG_ADDR_HI GUC_HXG_REQUEST_MSG_n_DATAn 258 #define PF2GUC_UPDATE_VGT_POLICY_REQUEST_MSG_3_CFG_SIZE GUC_HXG_REQUEST_MSG_n_DATAn 259 260 #define PF2GUC_UPDATE_VGT_POLICY_RESPONSE_MSG_LEN GUC_HXG_RESPONSE_MSG_MIN_LEN 261 #define PF2GUC_UPDATE_VGT_POLICY_RESPONSE_MSG_0_COUNT GUC_HXG_RESPONSE_MSG_0_DATA0 262 263 /** 264 * DOC: PF2GUC_UPDATE_VF_CFG 265 * 266 * The `PF2GUC_UPDATE_VF_CFG`_ message is used by PF to provision single VF in GuC. 267 * 268 * This message must be sent as `CTB HXG Message`_. 269 * 270 * +---+-------+--------------------------------------------------------------+ 271 * | | Bits | Description | 272 * +===+=======+==============================================================+ 273 * | 0 | 31 | ORIGIN = GUC_HXG_ORIGIN_HOST_ | 274 * | +-------+--------------------------------------------------------------+ 275 * | | 30:28 | TYPE = GUC_HXG_TYPE_REQUEST_ | 276 * | +-------+--------------------------------------------------------------+ 277 * | | 27:16 | MBZ | 278 * | +-------+--------------------------------------------------------------+ 279 * | | 15:0 | ACTION = _`GUC_ACTION_PF2GUC_UPDATE_VF_CFG` = 0x5503 | 280 * +---+-------+--------------------------------------------------------------+ 281 * | 1 | 31:0 | **VFID** - identifier of the VF that the KLV | 282 * | | | configurations are being applied to | 283 * +---+-------+--------------------------------------------------------------+ 284 * | 2 | 31:0 | **CFG_ADDR_LO** - dword aligned GGTT offset that represents | 285 * | | | the start of a list of virtualization related KLV configs | 286 * | | | that are to be applied to the VF. | 287 * | | | If this parameter is zero, the list is not parsed. | 288 * | | | If full configs address parameter is zero and configs_size is| 289 * | | | zero associated VF config shall be reset to its default state| 290 * +---+-------+--------------------------------------------------------------+ 291 * | 3 | 31:0 | **CFG_ADDR_HI** - upper 32 bits of configs address. | 292 * +---+-------+--------------------------------------------------------------+ 293 * | 4 | 31:0 | **CFG_SIZE** - size (in dwords) of the config buffer | 294 * +---+-------+--------------------------------------------------------------+ 295 * 296 * +---+-------+--------------------------------------------------------------+ 297 * | | Bits | Description | 298 * +===+=======+==============================================================+ 299 * | 0 | 31 | ORIGIN = GUC_HXG_ORIGIN_GUC_ | 300 * | +-------+--------------------------------------------------------------+ 301 * | | 30:28 | TYPE = GUC_HXG_TYPE_RESPONSE_SUCCESS_ | 302 * | +-------+--------------------------------------------------------------+ 303 * | | 27:0 | **COUNT** - number of KLVs successfully applied | 304 * +---+-------+--------------------------------------------------------------+ 305 */ 306 #define GUC_ACTION_PF2GUC_UPDATE_VF_CFG 0x5503u 307 308 #define PF2GUC_UPDATE_VF_CFG_REQUEST_MSG_LEN (GUC_HXG_REQUEST_MSG_MIN_LEN + 4u) 309 #define PF2GUC_UPDATE_VF_CFG_REQUEST_MSG_0_MBZ GUC_HXG_REQUEST_MSG_0_DATA0 310 #define PF2GUC_UPDATE_VF_CFG_REQUEST_MSG_1_VFID GUC_HXG_REQUEST_MSG_n_DATAn 311 #define PF2GUC_UPDATE_VF_CFG_REQUEST_MSG_2_CFG_ADDR_LO GUC_HXG_REQUEST_MSG_n_DATAn 312 #define PF2GUC_UPDATE_VF_CFG_REQUEST_MSG_3_CFG_ADDR_HI GUC_HXG_REQUEST_MSG_n_DATAn 313 #define PF2GUC_UPDATE_VF_CFG_REQUEST_MSG_4_CFG_SIZE GUC_HXG_REQUEST_MSG_n_DATAn 314 315 #define PF2GUC_UPDATE_VF_CFG_RESPONSE_MSG_LEN GUC_HXG_RESPONSE_MSG_MIN_LEN 316 #define PF2GUC_UPDATE_VF_CFG_RESPONSE_MSG_0_COUNT GUC_HXG_RESPONSE_MSG_0_DATA0 317 318 /** 319 * DOC: PF2GUC_VF_CONTROL 320 * 321 * The PF2GUC_VF_CONTROL message is used by the PF to trigger VF state change 322 * maintained by the GuC. 323 * 324 * This H2G message must be sent as `CTB HXG Message`_. 325 * 326 * +---+-------+--------------------------------------------------------------+ 327 * | | Bits | Description | 328 * +===+=======+==============================================================+ 329 * | 0 | 31 | ORIGIN = GUC_HXG_ORIGIN_HOST_ | 330 * | +-------+--------------------------------------------------------------+ 331 * | | 30:28 | TYPE = GUC_HXG_TYPE_REQUEST_ | 332 * | +-------+--------------------------------------------------------------+ 333 * | | 27:16 | DATA0 = MBZ | 334 * | +-------+--------------------------------------------------------------+ 335 * | | 15:0 | ACTION = _`GUC_ACTION_PF2GUC_VF_CONTROL_CMD` = 0x5506 | 336 * +---+-------+--------------------------------------------------------------+ 337 * | 1 | 31:0 | DATA1 = **VFID** - VF identifier | 338 * +---+-------+--------------------------------------------------------------+ 339 * | 2 | 31:0 | DATA2 = **COMMAND** - control command: | 340 * | | | | 341 * | | | - _`GUC_PF_TRIGGER_VF_PAUSE` = 1 | 342 * | | | - _`GUC_PF_TRIGGER_VF_RESUME` = 2 | 343 * | | | - _`GUC_PF_TRIGGER_VF_STOP` = 3 | 344 * | | | - _`GUC_PF_TRIGGER_VF_FLR_START` = 4 | 345 * | | | - _`GUC_PF_TRIGGER_VF_FLR_FINISH` = 5 | 346 * +---+-------+--------------------------------------------------------------+ 347 * 348 * +---+-------+--------------------------------------------------------------+ 349 * | | Bits | Description | 350 * +===+=======+==============================================================+ 351 * | 0 | 31 | ORIGIN = GUC_HXG_ORIGIN_GUC_ | 352 * | +-------+--------------------------------------------------------------+ 353 * | | 30:28 | TYPE = GUC_HXG_TYPE_RESPONSE_SUCCESS_ | 354 * | +-------+--------------------------------------------------------------+ 355 * | | 27:0 | DATA0 = MBZ | 356 * +---+-------+--------------------------------------------------------------+ 357 */ 358 #define GUC_ACTION_PF2GUC_VF_CONTROL 0x5506u 359 360 #define PF2GUC_VF_CONTROL_REQUEST_MSG_LEN (GUC_HXG_EVENT_MSG_MIN_LEN + 2u) 361 #define PF2GUC_VF_CONTROL_REQUEST_MSG_0_MBZ GUC_HXG_EVENT_MSG_0_DATA0 362 #define PF2GUC_VF_CONTROL_REQUEST_MSG_1_VFID GUC_HXG_EVENT_MSG_n_DATAn 363 #define PF2GUC_VF_CONTROL_REQUEST_MSG_2_COMMAND GUC_HXG_EVENT_MSG_n_DATAn 364 #define GUC_PF_TRIGGER_VF_PAUSE 1u 365 #define GUC_PF_TRIGGER_VF_RESUME 2u 366 #define GUC_PF_TRIGGER_VF_STOP 3u 367 #define GUC_PF_TRIGGER_VF_FLR_START 4u 368 #define GUC_PF_TRIGGER_VF_FLR_FINISH 5u 369 370 #endif 371