| /* Copyright (C) 2010 - 2015 UNISYS CORPORATION |
| * All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms and conditions of the GNU General Public License, |
| * version 2, as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or |
| * NON INFRINGEMENT. See the GNU General Public License for more |
| * details. |
| */ |
| |
| #ifndef __CONTROLVMCHANNEL_H__ |
| #define __CONTROLVMCHANNEL_H__ |
| |
| #include <linux/uuid.h> |
| #include "channel.h" |
| |
| /* {2B3C2D10-7EF5-4ad8-B966-3448B7386B3D} */ |
| #define SPAR_CONTROLVM_CHANNEL_PROTOCOL_UUID \ |
| UUID_LE(0x2b3c2d10, 0x7ef5, 0x4ad8, \ |
| 0xb9, 0x66, 0x34, 0x48, 0xb7, 0x38, 0x6b, 0x3d) |
| |
| #define ULTRA_CONTROLVM_CHANNEL_PROTOCOL_SIGNATURE \ |
| ULTRA_CHANNEL_PROTOCOL_SIGNATURE |
| #define CONTROLVM_MESSAGE_MAX 64 |
| |
| /* Must increment this whenever you insert or delete fields within |
| * this channel struct. Also increment whenever you change the meaning |
| * of fields within this channel struct so as to break pre-existing |
| * software. Note that you can usually add fields to the END of the |
| * channel struct withOUT needing to increment this. |
| */ |
| #define ULTRA_CONTROLVM_CHANNEL_PROTOCOL_VERSIONID 1 |
| |
| #define SPAR_CONTROLVM_CHANNEL_OK_CLIENT(ch) \ |
| spar_check_channel_client(ch, \ |
| SPAR_CONTROLVM_CHANNEL_PROTOCOL_UUID, \ |
| "controlvm", \ |
| sizeof(struct spar_controlvm_channel_protocol), \ |
| ULTRA_CONTROLVM_CHANNEL_PROTOCOL_VERSIONID, \ |
| ULTRA_CONTROLVM_CHANNEL_PROTOCOL_SIGNATURE) |
| |
| #define MAX_SERIAL_NUM 32 |
| |
| /* Defines for various channel queues */ |
| #define CONTROLVM_QUEUE_REQUEST 0 |
| #define CONTROLVM_QUEUE_RESPONSE 1 |
| #define CONTROLVM_QUEUE_EVENT 2 |
| #define CONTROLVM_QUEUE_ACK 3 |
| |
| /* Max num of messages stored during IOVM creation to be reused after crash */ |
| #define CONTROLVM_CRASHMSG_MAX 2 |
| |
| struct spar_segment_state { |
| /* Bit 0: May enter other states */ |
| u16 enabled:1; |
| /* Bit 1: Assigned to active partition */ |
| u16 active:1; |
| /* Bit 2: Configure message sent to service/server */ |
| u16 alive:1; |
| /* Bit 3: similar to partition state ShuttingDown */ |
| u16 revoked:1; |
| /* Bit 4: memory (device/port number) has been selected by Command */ |
| u16 allocated:1; |
| /* Bit 5: has been introduced to the service/guest partition */ |
| u16 known:1; |
| /* Bit 6: service/Guest partition has responded to introduction */ |
| u16 ready:1; |
| /* Bit 7: resource is configured and operating */ |
| u16 operating:1; |
| /* Note: don't use high bit unless we need to switch to ushort |
| * which is non-compliant |
| */ |
| }; |
| |
| static const struct spar_segment_state segment_state_running = { |
| 1, 1, 1, 0, 1, 1, 1, 1 |
| }; |
| |
| static const struct spar_segment_state segment_state_paused = { |
| 1, 1, 1, 0, 1, 1, 1, 0 |
| }; |
| |
| static const struct spar_segment_state segment_state_standby = { |
| 1, 1, 0, 0, 1, 1, 1, 0 |
| }; |
| |
| /* Ids for commands that may appear in either queue of a ControlVm channel. |
| * |
| * Commands that are initiated by the command partition (CP), by an IO or |
| * console service partition (SP), or by a guest partition (GP)are: |
| * - issued on the RequestQueue queue (q #0) in the ControlVm channel |
| * - responded to on the ResponseQueue queue (q #1) in the ControlVm channel |
| * |
| * Events that are initiated by an IO or console service partition (SP) or |
| * by a guest partition (GP) are: |
| * - issued on the EventQueue queue (q #2) in the ControlVm channel |
| * - responded to on the EventAckQueue queue (q #3) in the ControlVm channel |
| */ |
| enum controlvm_id { |
| CONTROLVM_INVALID = 0, |
| /* SWITCH commands required Parameter: SwitchNumber */ |
| /* BUS commands required Parameter: BusNumber */ |
| CONTROLVM_BUS_CREATE = 0x101, /* CP --> SP, GP */ |
| CONTROLVM_BUS_DESTROY = 0x102, /* CP --> SP, GP */ |
| CONTROLVM_BUS_CONFIGURE = 0x104, /* CP --> SP */ |
| CONTROLVM_BUS_CHANGESTATE = 0x105, /* CP --> SP, GP */ |
| CONTROLVM_BUS_CHANGESTATE_EVENT = 0x106, /* SP, GP --> CP */ |
| /* DEVICE commands required Parameter: BusNumber, DeviceNumber */ |
| |
| CONTROLVM_DEVICE_CREATE = 0x201, /* CP --> SP, GP */ |
| CONTROLVM_DEVICE_DESTROY = 0x202, /* CP --> SP, GP */ |
| CONTROLVM_DEVICE_CONFIGURE = 0x203, /* CP --> SP */ |
| CONTROLVM_DEVICE_CHANGESTATE = 0x204, /* CP --> SP, GP */ |
| CONTROLVM_DEVICE_CHANGESTATE_EVENT = 0x205, /* SP, GP --> CP */ |
| CONTROLVM_DEVICE_RECONFIGURE = 0x206, /* CP --> Boot */ |
| /* CHIPSET commands */ |
| CONTROLVM_CHIPSET_INIT = 0x301, /* CP --> SP, GP */ |
| CONTROLVM_CHIPSET_STOP = 0x302, /* CP --> SP, GP */ |
| CONTROLVM_CHIPSET_READY = 0x304, /* CP --> SP */ |
| CONTROLVM_CHIPSET_SELFTEST = 0x305, /* CP --> SP */ |
| |
| }; |
| |
| struct irq_info { |
| u64 reserved1; |
| |
| /* specifies interrupt handle. It is used to retrieve the |
| * corresponding interrupt pin from Monitor; and the |
| * interrupt pin is used to connect to the corresponding |
| * interrupt. Used by IOPart-GP only. |
| */ |
| u64 recv_irq_handle; |
| |
| /* specifies interrupt vector. It, interrupt pin, and shared are |
| * used to connect to the corresponding interrupt. Used by |
| * IOPart-GP only. |
| */ |
| u32 recv_irq_vector; |
| |
| /* specifies if the recvInterrupt is shared. It, interrupt pin |
| * and vector are used to connect to 0 = not shared; 1 = shared. |
| * the corresponding interrupt. Used by IOPart-GP only. |
| */ |
| u8 recv_irq_shared; |
| u8 reserved[3]; /* Natural alignment purposes */ |
| }; |
| |
| struct pci_id { |
| u16 domain; |
| u8 bus; |
| u8 slot; |
| u8 func; |
| u8 reserved[3]; /* Natural alignment purposes */ |
| }; |
| |
| struct efi_spar_indication { |
| u64 boot_to_fw_ui:1; /* Bit 0: Stop in uefi ui */ |
| u64 clear_nvram:1; /* Bit 1: Clear NVRAM */ |
| u64 clear_cmos:1; /* Bit 2: Clear CMOS */ |
| u64 boot_to_tool:1; /* Bit 3: Run install tool */ |
| /* remaining bits are available */ |
| }; |
| |
| enum ultra_chipset_feature { |
| ULTRA_CHIPSET_FEATURE_REPLY = 0x00000001, |
| ULTRA_CHIPSET_FEATURE_PARA_HOTPLUG = 0x00000002, |
| }; |
| |
| /* This is the common structure that is at the beginning of every |
| * ControlVm message (both commands and responses) in any ControlVm |
| * queue. Commands are easily distinguished from responses by |
| * looking at the flags.response field. |
| */ |
| struct controlvm_message_header { |
| u32 id; /* See CONTROLVM_ID. */ |
| /* For requests, indicates the message type. */ |
| /* For responses, indicates the type of message we are responding to. */ |
| |
| /* Includes size of this struct + size of message */ |
| u32 message_size; |
| /* Index of segment containing Vm message/information */ |
| u32 segment_index; |
| /* Error status code or result of message completion */ |
| u32 completion_status; |
| struct { |
| /* =1 in a response to signify failure */ |
| u32 failed:1; |
| /* =1 in all messages that expect a response */ |
| u32 response_expected:1; |
| /* =1 in all bus & device-related messages where the message |
| * receiver is to act as the bus or device server |
| */ |
| u32 server:1; |
| /* =1 for testing use only (Control and Command ignore this */ |
| u32 test_message:1; |
| /* =1 if there are forthcoming responses/acks associated |
| * with this message |
| */ |
| u32 partial_completion:1; |
| /* =1 this is to let us know to preserve channel contents */ |
| u32 preserve:1; |
| /* =1 the DiagWriter is active in the Diagnostic Partition */ |
| u32 writer_in_diag:1; |
| } flags; |
| /* Natural alignment */ |
| u32 reserved; |
| /* Identifies the particular message instance */ |
| u64 message_handle; |
| /* request instances with the corresponding response instance. */ |
| /* Offset of payload area from start of this instance */ |
| u64 payload_vm_offset; |
| /* Maximum bytes allocated in payload area of ControlVm segment */ |
| u32 payload_max_bytes; |
| /* Actual number of bytes of payload area to copy between IO/Command */ |
| u32 payload_bytes; |
| /* if non-zero, there is a payload to copy. */ |
| }; |
| |
| struct controlvm_packet_device_create { |
| u32 bus_no; /* bus # (0..n-1) from the msg receiver's end */ |
| u32 dev_no; /* bus-relative (0..n-1) device number */ |
| /* Guest physical address of the channel, which can be dereferenced by |
| * the receiver of this ControlVm command |
| */ |
| u64 channel_addr; |
| u64 channel_bytes; /* specifies size of the channel in bytes */ |
| uuid_le data_type_uuid; /* specifies format of data in channel */ |
| uuid_le dev_inst_uuid; /* instance guid for the device */ |
| struct irq_info intr; /* specifies interrupt information */ |
| }; /* for CONTROLVM_DEVICE_CREATE */ |
| |
| struct controlvm_packet_device_configure { |
| /* bus # (0..n-1) from the msg receiver's perspective */ |
| u32 bus_no; |
| /* Control uses header SegmentIndex field to access bus number... */ |
| u32 dev_no; /* bus-relative (0..n-1) device number */ |
| } ; /* for CONTROLVM_DEVICE_CONFIGURE */ |
| |
| struct controlvm_message_device_create { |
| struct controlvm_message_header header; |
| struct controlvm_packet_device_create packet; |
| }; /* total 128 bytes */ |
| |
| struct controlvm_message_device_configure { |
| struct controlvm_message_header header; |
| struct controlvm_packet_device_configure packet; |
| }; /* total 56 bytes */ |
| |
| /* This is the format for a message in any ControlVm queue. */ |
| struct controlvm_message_packet { |
| union { |
| struct { |
| /* bus # (0..n-1) from the msg receiver's perspective */ |
| u32 bus_no; |
| /* indicates the max number of devices on this bus */ |
| u32 dev_count; |
| /* Guest physical address of the channel, which can be |
| * dereferenced by the receiver of this ControlVm command |
| */ |
| u64 channel_addr; |
| u64 channel_bytes; /* size of the channel */ |
| /* indicates format of data in bus channel*/ |
| uuid_le bus_data_type_uuid; |
| uuid_le bus_inst_uuid; /* instance uuid for the bus */ |
| } create_bus; /* for CONTROLVM_BUS_CREATE */ |
| struct { |
| /* bus # (0..n-1) from the msg receiver's perspective */ |
| u32 bus_no; |
| u32 reserved; /* Natural alignment purposes */ |
| } destroy_bus; /* for CONTROLVM_BUS_DESTROY */ |
| struct { |
| /* bus # (0..n-1) from the receiver's perspective */ |
| u32 bus_no; |
| u32 reserved1; /* for alignment purposes */ |
| /* This is used to convert guest physical address to physical address */ |
| u64 guest_handle; |
| u64 recv_bus_irq_handle; |
| /* specifies interrupt info. It is used by SP |
| * to register to receive interrupts from the |
| * CP. This interrupt is used for bus level |
| * notifications. The corresponding |
| * sendBusInterruptHandle is kept in CP. |
| */ |
| } configure_bus; /* for CONTROLVM_BUS_CONFIGURE */ |
| /* for CONTROLVM_DEVICE_CREATE */ |
| struct controlvm_packet_device_create create_device; |
| struct { |
| /* bus # (0..n-1) from the msg receiver's perspective */ |
| u32 bus_no; |
| u32 dev_no; /* bus-relative (0..n-1) device # */ |
| } destroy_device; /* for CONTROLVM_DEVICE_DESTROY */ |
| /* for CONTROLVM_DEVICE_CONFIGURE */ |
| struct controlvm_packet_device_configure configure_device; |
| struct { |
| /* bus # (0..n-1) from the msg receiver's perspective */ |
| u32 bus_no; |
| u32 dev_no; /* bus-relative (0..n-1) device # */ |
| } reconfigure_device; /* for CONTROLVM_DEVICE_RECONFIGURE */ |
| struct { |
| u32 bus_no; |
| struct spar_segment_state state; |
| u8 reserved[2]; /* Natural alignment purposes */ |
| } bus_change_state; /* for CONTROLVM_BUS_CHANGESTATE */ |
| struct { |
| u32 bus_no; |
| u32 dev_no; |
| struct spar_segment_state state; |
| struct { |
| /* =1 if message is for a physical device */ |
| u32 phys_device:1; |
| } flags; |
| u8 reserved[2]; /* Natural alignment purposes */ |
| } device_change_state; /* for CONTROLVM_DEVICE_CHANGESTATE */ |
| struct { |
| u32 bus_no; |
| u32 dev_no; |
| struct spar_segment_state state; |
| u8 reserved[6]; /* Natural alignment purposes */ |
| } device_change_state_event; |
| /* for CONTROLVM_DEVICE_CHANGESTATE_EVENT */ |
| struct { |
| /* indicates the max number of busses */ |
| u32 bus_count; |
| /* indicates the max number of switches */ |
| u32 switch_count; |
| enum ultra_chipset_feature features; |
| u32 platform_number; /* Platform Number */ |
| } init_chipset; /* for CONTROLVM_CHIPSET_INIT */ |
| struct { |
| u32 options; /* reserved */ |
| u32 test; /* bit 0 set to run embedded selftest */ |
| } chipset_selftest; /* for CONTROLVM_CHIPSET_SELFTEST */ |
| /* a physical address of something, that can be dereferenced |
| * by the receiver of this ControlVm command |
| */ |
| u64 addr; |
| /* a handle of something (depends on command id) */ |
| u64 handle; |
| }; |
| }; |
| |
| /* All messages in any ControlVm queue have this layout. */ |
| struct controlvm_message { |
| struct controlvm_message_header hdr; |
| struct controlvm_message_packet cmd; |
| }; |
| |
| struct spar_controlvm_channel_protocol { |
| struct channel_header header; |
| u64 gp_controlvm; /* guest phys addr of this channel */ |
| u64 gp_partition_tables;/* guest phys addr of partition tables */ |
| u64 gp_diag_guest; /* guest phys addr of diagnostic channel */ |
| u64 gp_boot_romdisk;/* guest phys addr of (read* only) Boot ROM disk */ |
| u64 gp_boot_ramdisk;/* guest phys addr of writable Boot RAM disk */ |
| u64 gp_acpi_table; /* guest phys addr of acpi table */ |
| u64 gp_control_channel;/* guest phys addr of control channel */ |
| u64 gp_diag_romdisk;/* guest phys addr of diagnostic ROM disk */ |
| u64 gp_nvram; /* guest phys addr of NVRAM channel */ |
| u64 request_payload_offset; /* Offset to request payload area */ |
| u64 event_payload_offset; /* Offset to event payload area */ |
| /* Bytes available in request payload area */ |
| u32 request_payload_bytes; |
| u32 event_payload_bytes;/* Bytes available in event payload area */ |
| u32 control_channel_bytes; |
| u32 nvram_channel_bytes; /* Bytes in PartitionNvram segment */ |
| u32 message_bytes; /* sizeof(CONTROLVM_MESSAGE) */ |
| u32 message_count; /* CONTROLVM_MESSAGE_MAX */ |
| u64 gp_smbios_table; /* guest phys addr of SMBIOS tables */ |
| u64 gp_physical_smbios_table; /* guest phys addr of SMBIOS table */ |
| /* ULTRA_MAX_GUESTS_PER_SERVICE */ |
| char gp_reserved[2688]; |
| |
| /* guest physical address of EFI firmware image base */ |
| u64 virtual_guest_firmware_image_base; |
| |
| /* guest physical address of EFI firmware entry point */ |
| u64 virtual_guest_firmware_entry_point; |
| |
| /* guest EFI firmware image size */ |
| u64 virtual_guest_firmware_image_size; |
| |
| /* GPA = 1MB where EFI firmware image is copied to */ |
| u64 virtual_guest_firmware_boot_base; |
| u64 virtual_guest_image_base; |
| u64 virtual_guest_image_size; |
| u64 prototype_control_channel_offset; |
| u64 virtual_guest_partition_handle; |
| /* Restore Action field to restore the guest partition */ |
| u16 restore_action; |
| /* For Windows guests it shows if the visordisk is in dump mode */ |
| u16 dump_action; |
| u16 nvram_fail_count; |
| u16 saved_crash_message_count; /* = CONTROLVM_CRASHMSG_MAX */ |
| /* Offset to request payload area needed for crash dump */ |
| u32 saved_crash_message_offset; |
| /* Type of error encountered during installation */ |
| u32 installation_error; |
| u32 installation_text_id; /* Id of string to display */ |
| /* Number of remaining installation steps (for progress bars) */ |
| u16 installation_remaining_steps; |
| /* ULTRA_TOOL_ACTIONS Installation Action field */ |
| u8 tool_action; |
| u8 reserved; /* alignment */ |
| struct efi_spar_indication efi_spar_ind; |
| struct efi_spar_indication efi_spar_ind_supported; |
| u32 sp_reserved; |
| /* Force signals to begin on 128-byte cache line */ |
| u8 reserved2[28]; |
| /* guest partition uses this queue to send requests to Control */ |
| struct signal_queue_header request_queue; |
| /* Control uses this queue to respond to service or guest |
| * partition requests |
| */ |
| struct signal_queue_header response_queue; |
| /* Control uses this queue to send events to guest partition */ |
| struct signal_queue_header event_queue; |
| /* Service or guest partition uses this queue to ack Control events */ |
| struct signal_queue_header event_ack_queue; |
| /* Request fixed-size message pool - does not include payload */ |
| struct controlvm_message request_msg[CONTROLVM_MESSAGE_MAX]; |
| |
| /* Response fixed-size message pool - does not include payload */ |
| struct controlvm_message response_msg[CONTROLVM_MESSAGE_MAX]; |
| |
| /* Event fixed-size message pool - does not include payload */ |
| struct controlvm_message event_msg[CONTROLVM_MESSAGE_MAX]; |
| |
| /* Ack fixed-size message pool - does not include payload */ |
| struct controlvm_message event_ack_msg[CONTROLVM_MESSAGE_MAX]; |
| |
| /* Message stored during IOVM creation to be reused after crash */ |
| struct controlvm_message saved_crash_msg[CONTROLVM_CRASHMSG_MAX]; |
| }; |
| |
| /* Offsets for VM channel attributes */ |
| #define VM_CH_REQ_QUEUE_OFFSET \ |
| offsetof(struct spar_controlvm_channel_protocol, request_queue) |
| #define VM_CH_RESP_QUEUE_OFFSET \ |
| offsetof(struct spar_controlvm_channel_protocol, response_queue) |
| #define VM_CH_EVENT_QUEUE_OFFSET \ |
| offsetof(struct spar_controlvm_channel_protocol, event_queue) |
| #define VM_CH_ACK_QUEUE_OFFSET \ |
| offsetof(struct spar_controlvm_channel_protocol, event_ack_queue) |
| #define VM_CH_REQ_MSG_OFFSET \ |
| offsetof(struct spar_controlvm_channel_protocol, request_msg) |
| #define VM_CH_RESP_MSG_OFFSET \ |
| offsetof(struct spar_controlvm_channel_protocol, response_msg) |
| #define VM_CH_EVENT_MSG_OFFSET \ |
| offsetof(struct spar_controlvm_channel_protocol, event_msg) |
| #define VM_CH_ACK_MSG_OFFSET \ |
| offsetof(struct spar_controlvm_channel_protocol, event_ack_msg) |
| #define VM_CH_CRASH_MSG_OFFSET \ |
| offsetof(struct spar_controlvm_channel_protocol, saved_crash_msg) |
| |
| /* The following header will be located at the beginning of PayloadVmOffset for |
| * various ControlVm commands. The receiver of a ControlVm command with a |
| * PayloadVmOffset will dereference this address and then use connection_offset, |
| * initiator_offset, and target_offset to get the location of UTF-8 formatted |
| * strings that can be parsed to obtain command-specific information. The value |
| * of total_length should equal PayloadBytes. The format of the strings at |
| * PayloadVmOffset will take different forms depending on the message. |
| */ |
| struct spar_controlvm_parameters_header { |
| u32 total_length; |
| u32 header_length; |
| u32 connection_offset; |
| u32 connection_length; |
| u32 initiator_offset; |
| u32 initiator_length; |
| u32 target_offset; |
| u32 target_length; |
| u32 client_offset; |
| u32 client_length; |
| u32 name_offset; |
| u32 name_length; |
| uuid_le id; |
| u32 revision; |
| u32 reserved; /* Natural alignment */ |
| }; |
| |
| /* General Errors------------------------------------------------------[0-99] */ |
| #define CONTROLVM_RESP_SUCCESS 0 |
| #define CONTROLVM_RESP_ERROR_ALREADY_DONE 1 |
| #define CONTROLVM_RESP_ERROR_IOREMAP_FAILED 2 |
| #define CONTROLVM_RESP_ERROR_KMALLOC_FAILED 3 |
| #define CONTROLVM_RESP_ERROR_MESSAGE_ID_UNKNOWN 4 |
| #define CONTROLVM_RESP_ERROR_MESSAGE_ID_INVALID_FOR_CLIENT 5 |
| |
| /* CONTROLVM_INIT_CHIPSET-------------------------------------------[100-199] */ |
| #define CONTROLVM_RESP_ERROR_CLIENT_SWITCHCOUNT_NONZERO 100 |
| #define CONTROLVM_RESP_ERROR_EXPECTED_CHIPSET_INIT 101 |
| |
| /* Maximum Limit----------------------------------------------------[200-299] */ |
| #define CONTROLVM_RESP_ERROR_MAX_BUSES 201 /* BUS_CREATE */ |
| #define CONTROLVM_RESP_ERROR_MAX_DEVICES 202 /* DEVICE_CREATE */ |
| /* Payload and Parameter Related------------------------------------[400-499] */ |
| #define CONTROLVM_RESP_ERROR_PAYLOAD_INVALID 400 /* SWITCH_ATTACHEXTPORT, |
| * DEVICE_CONFIGURE |
| */ |
| #define CONTROLVM_RESP_ERROR_INITIATOR_PARAMETER_INVALID 401 /* Multiple */ |
| #define CONTROLVM_RESP_ERROR_TARGET_PARAMETER_INVALID 402 /* DEVICE_CONFIGURE */ |
| #define CONTROLVM_RESP_ERROR_CLIENT_PARAMETER_INVALID 403 /* DEVICE_CONFIGURE */ |
| /* Specified[Packet Structure] Value-------------------------------[500-599] */ |
| #define CONTROLVM_RESP_ERROR_BUS_INVALID 500 /* SWITCH_ATTACHINTPORT, |
| * BUS_CONFIGURE, |
| * DEVICE_CREATE, |
| * DEVICE_CONFIG |
| * DEVICE_DESTROY |
| */ |
| #define CONTROLVM_RESP_ERROR_DEVICE_INVALID 501 /* SWITCH_ATTACHINTPORT */ |
| /* DEVICE_CREATE, |
| * DEVICE_CONFIGURE, |
| * DEVICE_DESTROY |
| */ |
| #define CONTROLVM_RESP_ERROR_CHANNEL_INVALID 502 /* DEVICE_CREATE, |
| * DEVICE_CONFIGURE |
| */ |
| /* Partition Driver Callback Interface----------------------[600-699] */ |
| #define CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_FAILURE 604 /* BUS_CREATE, |
| * BUS_DESTROY, |
| * DEVICE_CREATE, |
| * DEVICE_DESTROY |
| */ |
| /* Unable to invoke VIRTPCI callback */ |
| #define CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_CALLBACK_ERROR 605 |
| /* BUS_CREATE, |
| * BUS_DESTROY, |
| * DEVICE_CREATE, |
| * DEVICE_DESTROY |
| */ |
| /* VIRTPCI Callback returned error */ |
| #define CONTROLVM_RESP_ERROR_GENERIC_DRIVER_CALLBACK_ERROR 606 |
| /* SWITCH_ATTACHEXTPORT, |
| * SWITCH_DETACHEXTPORT |
| * DEVICE_CONFIGURE |
| */ |
| |
| /* generic device callback returned error */ |
| /* Bus Related------------------------------------------------------[700-799] */ |
| #define CONTROLVM_RESP_ERROR_BUS_DEVICE_ATTACHED 700 /* BUS_DESTROY */ |
| /* Channel Related--------------------------------------------------[800-899] */ |
| #define CONTROLVM_RESP_ERROR_CHANNEL_TYPE_UNKNOWN 800 /* GET_CHANNELINFO, |
| * DEVICE_DESTROY |
| */ |
| #define CONTROLVM_RESP_ERROR_CHANNEL_SIZE_TOO_SMALL 801 /* DEVICE_CREATE */ |
| /* Chipset Shutdown Related---------------------------------------[1000-1099] */ |
| #define CONTROLVM_RESP_ERROR_CHIPSET_SHUTDOWN_FAILED 1000 |
| #define CONTROLVM_RESP_ERROR_CHIPSET_SHUTDOWN_ALREADY_ACTIVE 1001 |
| |
| /* Chipset Stop Related-------------------------------------------[1100-1199] */ |
| #define CONTROLVM_RESP_ERROR_CHIPSET_STOP_FAILED_BUS 1100 |
| #define CONTROLVM_RESP_ERROR_CHIPSET_STOP_FAILED_SWITCH 1101 |
| |
| /* Device Related-------------------------------------------------[1400-1499] */ |
| #define CONTROLVM_RESP_ERROR_DEVICE_UDEV_TIMEOUT 1400 |
| |
| #endif /* __CONTROLVMCHANNEL_H__ */ |
