nhu/kernel_a52xq
Watch
1
Fork
You've already forked kernel_a52xq
 0
mirror of https://github.com/a52xq-dev/kernel.git synced 2026-10-18 21:58:11 +07:00
Code Issues Projects Releases Wiki Activity

drivers: visorbus: move driver out of staging

Browse source 
Move the visorbus driver out of staging (drivers/staging/unisys/visorbus)
and to drivers/visorbus. Modify the configuration and makefiles so they
now reference the new location. The s-Par header file visorbus.h that is
referenced by all s-Par drivers, is being moved into include/linux.

Signed-off-by: David Kershner <david.kershner@unisys.com>
Reviewed-by: Tim Sell <timothy.sell@unisys.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
David Kershner 2017-12-07 12:11:07 -05:00 • committed by Greg Kroah-Hartman
commit 93d3ad90c2
18 changed files with 15 additions and 17 deletions
Download patch file Download diff file Expand all files Collapse all files

2
MAINTAINERS
View file

@ -14006,6 +14006,8 @@ UNISYS S-PAR DRIVERS
M: David Kershner <david.kershner@unisys.com>
L: sparmaintainer@unisys.com (Unisys internal)
S: Supported
F: include/linux/visorbus.h
F: drivers/visorbus/
F: drivers/staging/unisys/
UNIVERSAL FLASH STORAGE HOST CONTROLLER DRIVER

2
drivers/Kconfig
View file

@ -211,4 +211,6 @@ source "drivers/mux/Kconfig"
source "drivers/opp/Kconfig"
source "drivers/visorbus/Kconfig"
endmenu

1
drivers/Makefile
View file

@ -184,3 +184,4 @@ obj-$(CONFIG_FPGA) += fpga/
obj-$(CONFIG_FSI) += fsi/
obj-$(CONFIG_TEE) += tee/
obj-$(CONFIG_MULTIPLEXER) += mux/
obj-$(CONFIG_UNISYS_VISORBUS) += visorbus/

1
drivers/staging/unisys/Kconfig
View file

@ -8,7 +8,6 @@ menuconfig UNISYSSPAR
if UNISYSSPAR
source "drivers/staging/unisys/visorbus/Kconfig"
source "drivers/staging/unisys/visornic/Kconfig"
source "drivers/staging/unisys/visorinput/Kconfig"
source "drivers/staging/unisys/visorhba/Kconfig"

1
drivers/staging/unisys/Makefile
View file

@ -1,7 +1,6 @@
#
# Makefile for Unisys SPAR drivers
#
obj-$(CONFIG_UNISYS_VISORBUS) += visorbus/
obj-$(CONFIG_UNISYS_VISORNIC) += visornic/
obj-$(CONFIG_UNISYS_VISORINPUT) += visorinput/
obj-$(CONFIG_UNISYS_VISORHBA) += visorhba/

3
drivers/staging/unisys/include/iochannel.h
View file

@ -33,8 +33,7 @@
#include <linux/uuid.h>
#include <linux/skbuff.h>
#include "visorbus.h"
#include <linux/visorbus.h>
/*
* Must increment these whenever you insert or delete fields within this channel

2
drivers/staging/unisys/visorhba/visorhba_main.c
View file

@ -9,12 +9,12 @@
#include <linux/idr.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/visorbus.h>
#include <scsi/scsi.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include "visorbus.h"
#include "iochannel.h"
/* The Send and Receive Buffers of the IO Queue may both be full */

2
drivers/staging/unisys/visorinput/visorinput.c
View file

@ -16,8 +16,8 @@
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/uuid.h>
#include <linux/visorbus.h>
#include "visorbus.h"
#include "ultrainputreport.h"
/* Keyboard channel {c73416d0-b0b8-44af-b304-9d2ae99f1b3d} */

2
drivers/staging/unisys/visornic/visornic_main.c
View file

@ -16,8 +16,8 @@
#include <linux/kthread.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
#include <linux/visorbus.h>
#include "visorbus.h"
#include "iochannel.h"
#define VISORNIC_INFINITE_RSP_WAIT 0

14
drivers/visorbus/Kconfig Normal file
View file

@ -0,0 +1,14 @@
#
# Unisys visorbus configuration
#
config UNISYS_VISORBUS
tristate "Unisys visorbus driver"
depends on X86_64 && ACPI
---help---
The visorbus driver is a virtualized bus for the Unisys s-Par firmware.
Virtualized devices allow Linux guests on a system to share disks and
network cards that do not have SR-IOV support, and to be accessed using
the partition desktop application. The visorbus driver is required to
discover devices on an s-Par guest, and must be present for any other
s-Par guest driver to function correctly.

10
drivers/visorbus/Makefile Normal file
View file

@ -0,0 +1,10 @@
# SPDX-License-Identifier: GPL-2.0
#
# Makefile for Unisys visorbus
#
obj-$(CONFIG_UNISYS_VISORBUS) += visorbus.o
visorbus-y := visorbus_main.o
visorbus-y += visorchannel.o
visorbus-y += visorchipset.o

650
drivers/visorbus/controlvmchannel.h Normal file
View file

@ -0,0 +1,650 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2010 - 2015 UNISYS CORPORATION
* All rights reserved.
*/
#ifndef __CONTROLVMCHANNEL_H__
#define __CONTROLVMCHANNEL_H__
#include <linux/uuid.h>
#include <linux/visorbus.h>
/* {2B3C2D10-7EF5-4ad8-B966-3448B7386B3D} */
#define VISOR_CONTROLVM_CHANNEL_GUID \
GUID_INIT(0x2b3c2d10, 0x7ef5, 0x4ad8, \
0xb9, 0x66, 0x34, 0x48, 0xb7, 0x38, 0x6b, 0x3d)
#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 VISOR_CONTROLVM_CHANNEL_VERSIONID 1
/* 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 visor_segment_state
* @enabled: May enter other states.
* @active: Assigned to active partition.
* @alive: Configure message sent to service/server.
* @revoked: Similar to partition state ShuttingDown.
* @allocated: Memory (device/port number) has been selected by Command.
* @known: Has been introduced to the service/guest partition.
* @ready: Service/Guest partition has responded to introduction.
* @operating: Resource is configured and operating.
* @reserved: Natural alignment.
*
* Note: Don't use high bit unless we need to switch to ushort which is
* non-compliant.
*/
struct visor_segment_state {
u16 enabled:1;
u16 active:1;
u16 alive:1;
u16 revoked:1;
u16 allocated:1;
u16 known:1;
u16 ready:1;
u16 operating:1;
u16 reserved:8;
} __packed;
static const struct visor_segment_state segment_state_running = {
1, 1, 1, 0, 1, 1, 1, 1
};
static const struct visor_segment_state segment_state_paused = {
1, 1, 1, 0, 1, 1, 1, 0
};
static const struct visor_segment_state segment_state_standby = {
1, 1, 0, 0, 1, 1, 1, 0
};
/*
* enum controlvm_id
* @CONTROLVM_INVALID:
* @CONTROLVM_BUS_CREATE: CP --> SP, GP.
* @CONTROLVM_BUS_DESTROY: CP --> SP, GP.
* @CONTROLVM_BUS_CONFIGURE: CP --> SP.
* @CONTROLVM_BUS_CHANGESTATE: CP --> SP, GP.
* @CONTROLVM_BUS_CHANGESTATE_EVENT: SP, GP --> CP.
* @CONTROLVM_DEVICE_CREATE: CP --> SP, GP.
* @CONTROLVM_DEVICE_DESTROY: CP --> SP, GP.
* @CONTROLVM_DEVICE_CONFIGURE: CP --> SP.
* @CONTROLVM_DEVICE_CHANGESTATE: CP --> SP, GP.
* @CONTROLVM_DEVICE_CHANGESTATE_EVENT: SP, GP --> CP.
* @CONTROLVM_DEVICE_RECONFIGURE: CP --> Boot.
* @CONTROLVM_CHIPSET_INIT: CP --> SP, GP.
* @CONTROLVM_CHIPSET_STOP: CP --> SP, GP.
* @CONTROLVM_CHIPSET_READY: CP --> SP.
* @CONTROLVM_CHIPSET_SELFTEST: CP --> SP.
*
* 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,
CONTROLVM_BUS_DESTROY = 0x102,
CONTROLVM_BUS_CONFIGURE = 0x104,
CONTROLVM_BUS_CHANGESTATE = 0x105,
CONTROLVM_BUS_CHANGESTATE_EVENT = 0x106,
/* DEVICE commands required Parameter: BusNumber, DeviceNumber */
CONTROLVM_DEVICE_CREATE = 0x201,
CONTROLVM_DEVICE_DESTROY = 0x202,
CONTROLVM_DEVICE_CONFIGURE = 0x203,
CONTROLVM_DEVICE_CHANGESTATE = 0x204,
CONTROLVM_DEVICE_CHANGESTATE_EVENT = 0x205,
CONTROLVM_DEVICE_RECONFIGURE = 0x206,
/* CHIPSET commands */
CONTROLVM_CHIPSET_INIT = 0x301,
CONTROLVM_CHIPSET_STOP = 0x302,
CONTROLVM_CHIPSET_READY = 0x304,
CONTROLVM_CHIPSET_SELFTEST = 0x305,
};
/*
* struct irq_info
* @reserved1: Natural alignment purposes
* @recv_irq_handle: 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.
* @recv_irq_vector: Specifies interrupt vector. It, interrupt pin, and shared
* are used to connect to the corresponding interrupt.
* Used by IOPart-GP only.
* @recv_irq_shared: 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.
* @reserved: Natural alignment purposes
*/
struct irq_info {
u64 reserved1;
u64 recv_irq_handle;
u32 recv_irq_vector;
u8 recv_irq_shared;
u8 reserved[3];
} __packed;
/*
* struct efi_visor_indication
* @boot_to_fw_ui: Stop in UEFI UI
* @clear_nvram: Clear NVRAM
* @clear_cmos: Clear CMOS
* @boot_to_tool: Run install tool
* @reserved: Natural alignment
*/
struct efi_visor_indication {
u64 boot_to_fw_ui:1;
u64 clear_nvram:1;
u64 clear_cmos:1;
u64 boot_to_tool:1;
/* Remaining bits are available */
u64 reserved:60;
} __packed;
enum visor_chipset_feature {
VISOR_CHIPSET_FEATURE_REPLY = 0x00000001,
VISOR_CHIPSET_FEATURE_PARA_HOTPLUG = 0x00000002,
};
/*
* struct controlvm_message_header
* @id: See CONTROLVM_ID.
* @message_size: Includes size of this struct + size of message.
* @segment_index: Index of segment containing Vm message/information.
* @completion_status: Error status code or result of message completion.
* @struct flags:
* @failed: =1 in a response to signify failure.
* @response_expected: =1 in all messages that expect a response.
* @server: =1 in all bus & device-related messages where the
* message receiver is to act as the bus or device
* server.
* @test_message: =1 for testing use only (Control and Command
* ignore this).
* @partial_completion: =1 if there are forthcoming responses/acks
* associated with this message.
* @preserve: =1 this is to let us know to preserve channel
* contents.
* @writer_in_diag: =1 the DiagWriter is active in the Diagnostic
* Partition.
* @reserve: Natural alignment.
* @reserved: Natural alignment.
* @message_handle: Identifies the particular message instance.
* @payload_vm_offset: Offset of payload area from start of this instance.
* @payload_max_bytes: Maximum bytes allocated in payload area of ControlVm
* segment.
* @payload_bytes: Actual number of bytes of payload area to copy between
* IO/Command. If non-zero, there is a payload to copy.
*
* 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;
/*
* For requests, indicates the message type. For responses, indicates
* the type of message we are responding to.
*/
u32 message_size;
u32 segment_index;
u32 completion_status;
struct {
u32 failed:1;
u32 response_expected:1;
u32 server:1;
u32 test_message:1;
u32 partial_completion:1;
u32 preserve:1;
u32 writer_in_diag:1;
u32 reserve:25;
} __packed flags;
u32 reserved;
u64 message_handle;
u64 payload_vm_offset;
u32 payload_max_bytes;
u32 payload_bytes;
} __packed;
/*
* struct controlvm_packet_device_create - For CONTROLVM_DEVICE_CREATE
* @bus_no: Bus # (0..n-1) from the msg receiver's end.
* @dev_no: Bus-relative (0..n-1) device number.
* @channel_addr: Guest physical address of the channel, which can be
* dereferenced by the receiver of this ControlVm command.
* @channel_bytes: Specifies size of the channel in bytes.
* @data_type_uuid: Specifies format of data in channel.
* @dev_inst_uuid: Instance guid for the device.
* @irq_info intr: Specifies interrupt information.
*/
struct controlvm_packet_device_create {
u32 bus_no;
u32 dev_no;
u64 channel_addr;
u64 channel_bytes;
guid_t data_type_guid;
guid_t dev_inst_guid;
struct irq_info intr;
} __packed;
/*
* struct controlvm_packet_device_configure - For CONTROLVM_DEVICE_CONFIGURE
* @bus_no: Bus number (0..n-1) from the msg receiver's perspective.
* @dev_no: Bus-relative (0..n-1) device number.
*/
struct controlvm_packet_device_configure {
u32 bus_no;
u32 dev_no;
} __packed;
/* Total 128 bytes */
struct controlvm_message_device_create {
struct controlvm_message_header header;
struct controlvm_packet_device_create packet;
} __packed;
/* Total 56 bytes */
struct controlvm_message_device_configure {
struct controlvm_message_header header;
struct controlvm_packet_device_configure packet;
} __packed;
/*
* struct controlvm_message_packet - This is the format for a message in any
* ControlVm queue.
* @struct create_bus: For CONTROLVM_BUS_CREATE.
* @bus_no: Bus # (0..n-1) from the msg receiver's perspective.
* @dev_count: Indicates the max number of devices on this bus.
* @channel_addr: Guest physical address of the channel, which can be
* dereferenced by the receiver of this ControlVM
* command.
* @channel_bytes: Size of the channel.
* @bus_data_type_uuid: Indicates format of data in bus channel.
* @bus_inst_uuid: Instance uuid for the bus.
*
* @struct destroy_bus: For CONTROLVM_BUS_DESTROY.
* @bus_no: Bus # (0..n-1) from the msg receiver's perspective.
* @reserved: Natural alignment purposes.
*
* @struct configure_bus: For CONTROLVM_BUS_CONFIGURE.
* @bus_no: Bus # (0..n-1) from the receiver's perspective.
* @reserved1: For alignment purposes.
* @guest_handle: This is used to convert guest physical address to
* physical address.
* @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.
*
* @struct create_device: For CONTROLVM_DEVICE_CREATE.
*
* @struct destroy_device: For CONTROLVM_DEVICE_DESTROY.
* @bus_no: Bus # (0..n-1) from the msg receiver's perspective.
* @dev_no: Bus-relative (0..n-1) device number.
*
* @struct configure_device: For CONTROLVM_DEVICE_CONFIGURE.
*
* @struct reconfigure_device: For CONTROLVM_DEVICE_RECONFIGURE.
* @bus_no: Bus # (0..n-1) from the msg receiver's perspective.
* @dev_no: Bus-relative (0..n-1) device number.
*
* @struct bus_change_state: For CONTROLVM_BUS_CHANGESTATE.
* @bus_no:
* @struct state:
* @reserved: Natural alignment purposes.
*
* @struct device_change_state: For CONTROLVM_DEVICE_CHANGESTATE.
* @bus_no:
* @dev_no:
* @struct state:
* @struct flags:
* @phys_device: =1 if message is for a physical device.
* @reserved: Natural alignment.
* @reserved1: Natural alignment.
* @reserved: Natural alignment purposes.
*
* @struct device_change_state_event: For CONTROLVM_DEVICE_CHANGESTATE_EVENT.
* @bus_no:
* @dev_no:
* @struct state:
* @reserved: Natural alignment purposes.
*
* @struct init_chipset: For CONTROLVM_CHIPSET_INIT.
* @bus_count: Indicates the max number of busses.
* @switch_count: Indicates the max number of switches.
* @enum features:
* @platform_number:
*
* @struct chipset_selftest: For CONTROLVM_CHIPSET_SELFTEST.
* @options: Reserved.
* @test: Bit 0 set to run embedded selftest.
*
* @addr: A physical address of something, that can be dereferenced by the
* receiver of this ControlVm command.
*
* @handle: A handle of something (depends on command id).
*/
struct controlvm_message_packet {
union {
struct {
u32 bus_no;
u32 dev_count;
u64 channel_addr;
u64 channel_bytes;
guid_t bus_data_type_guid;
guid_t bus_inst_guid;
} __packed create_bus;
struct {
u32 bus_no;
u32 reserved;
} __packed destroy_bus;
struct {
u32 bus_no;
u32 reserved1;
u64 guest_handle;
u64 recv_bus_irq_handle;
} __packed configure_bus;
struct controlvm_packet_device_create create_device;
struct {
u32 bus_no;
u32 dev_no;
} __packed destroy_device;
struct controlvm_packet_device_configure configure_device;
struct {
u32 bus_no;
u32 dev_no;
} __packed reconfigure_device;
struct {
u32 bus_no;
struct visor_segment_state state;
u8 reserved[2];
} __packed bus_change_state;
struct {
u32 bus_no;
u32 dev_no;
struct visor_segment_state state;
struct {
u32 phys_device:1;
u32 reserved:31;
u32 reserved1;
} __packed flags;
u8 reserved[2];
} __packed device_change_state;
struct {
u32 bus_no;
u32 dev_no;
struct visor_segment_state state;
u8 reserved[6];
} __packed device_change_state_event;
struct {
u32 bus_count;
u32 switch_count;
enum visor_chipset_feature features;
u32 platform_number;
} __packed init_chipset;
struct {
u32 options;
u32 test;
} __packed chipset_selftest;
u64 addr;
u64 handle;
};
} __packed;
/* All messages in any ControlVm queue have this layout. */
struct controlvm_message {
struct controlvm_message_header hdr;
struct controlvm_message_packet cmd;
} __packed;
/*
* struct visor_controlvm_channel
* @struct header:
* @gp_controlvm: Guest phys addr of this channel.
* @gp_partition_tables: Guest phys addr of partition tables.
* @gp_diag_guest: Guest phys addr of diagnostic channel.
* @gp_boot_romdisk: Guest phys addr of (read* only) Boot
* ROM disk.
* @gp_boot_ramdisk: Guest phys addr of writable Boot RAM
* disk.
* @gp_acpi_table: Guest phys addr of acpi table.
* @gp_control_channel: Guest phys addr of control channel.
* @gp_diag_romdisk: Guest phys addr of diagnostic ROM disk.
* @gp_nvram: Guest phys addr of NVRAM channel.
* @request_payload_offset: Offset to request payload area.
* @event_payload_offset: Offset to event payload area.
* @request_payload_bytes: Bytes available in request payload area.
* @event_payload_bytes: Bytes available in event payload area.
* @control_channel_bytes:
* @nvram_channel_bytes: Bytes in PartitionNvram segment.
* @message_bytes: sizeof(CONTROLVM_MESSAGE).
* @message_count: CONTROLVM_MESSAGE_MAX.
* @gp_smbios_table: Guest phys addr of SMBIOS tables.
* @gp_physical_smbios_table: Guest phys addr of SMBIOS table.
* @gp_reserved: VISOR_MAX_GUESTS_PER_SERVICE.
* @virtual_guest_firmware_image_base: Guest physical address of EFI firmware
* image base.
* @virtual_guest_firmware_entry_point: Guest physical address of EFI firmware
* entry point.
* @virtual_guest_firmware_image_size: Guest EFI firmware image size.
* @virtual_guest_firmware_boot_base: GPA = 1MB where EFI firmware image is
* copied to.
* @virtual_guest_image_base:
* @virtual_guest_image_size:
* @prototype_control_channel_offset:
* @virtual_guest_partition_handle:
* @restore_action: Restore Action field to restore the
* guest partition.
* @dump_action: For Windows guests it shows if the
* visordisk is in dump mode.
* @nvram_fail_count:
* @saved_crash_message_count: = CONTROLVM_CRASHMSG_MAX.
* @saved_crash_message_offset: Offset to request payload area needed
* for crash dump.
* @installation_error: Type of error encountered during
* installation.
* @installation_text_id: Id of string to display.
* @installation_remaining_steps: Number of remaining installation steps
* (for progress bars).
* @tool_action: VISOR_TOOL_ACTIONS Installation Action
* field.
* @reserved: Alignment.
* @struct efi_visor_ind:
* @sp_reserved:
* @reserved2: Force signals to begin on 128-byte
* cache line.
* @struct request_queue: Guest partition uses this queue to send
* requests to Control.
* @struct response_queue: Control uses this queue to respond to
* service or guest partition request.
* @struct event_queue: Control uses this queue to send events
* to guest partition.
* @struct event_ack_queue: Service or guest partition uses this
* queue to ack Control events.
* @struct request_msg: Request fixed-size message pool -
* does not include payload.
* @struct response_msg: Response fixed-size message pool -
* does not include payload.
* @struct event_msg: Event fixed-size message pool -
* does not include payload.
* @struct event_ack_msg: Ack fixed-size message pool -
* does not include payload.
* @struct saved_crash_msg: Message stored during IOVM creation to
* be reused after crash.
*/
struct visor_controlvm_channel {
struct channel_header header;
u64 gp_controlvm;
u64 gp_partition_tables;
u64 gp_diag_guest;
u64 gp_boot_romdisk;
u64 gp_boot_ramdisk;
u64 gp_acpi_table;
u64 gp_control_channel;
u64 gp_diag_romdisk;
u64 gp_nvram;
u64 request_payload_offset;
u64 event_payload_offset;
u32 request_payload_bytes;
u32 event_payload_bytes;
u32 control_channel_bytes;
u32 nvram_channel_bytes;
u32 message_bytes;
u32 message_count;
u64 gp_smbios_table;
u64 gp_physical_smbios_table;
char gp_reserved[2688];
u64 virtual_guest_firmware_image_base;
u64 virtual_guest_firmware_entry_point;
u64 virtual_guest_firmware_image_size;
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;
u16 restore_action;
u16 dump_action;
u16 nvram_fail_count;
u16 saved_crash_message_count;
u32 saved_crash_message_offset;
u32 installation_error;
u32 installation_text_id;
u16 installation_remaining_steps;
u8 tool_action;
u8 reserved;
struct efi_visor_indication efi_visor_ind;
u32 sp_reserved;
u8 reserved2[28];
struct signal_queue_header request_queue;
struct signal_queue_header response_queue;
struct signal_queue_header event_queue;
struct signal_queue_header event_ack_queue;
struct controlvm_message request_msg[CONTROLVM_MESSAGE_MAX];
struct controlvm_message response_msg[CONTROLVM_MESSAGE_MAX];
struct controlvm_message event_msg[CONTROLVM_MESSAGE_MAX];
struct controlvm_message event_ack_msg[CONTROLVM_MESSAGE_MAX];
struct controlvm_message saved_crash_msg[CONTROLVM_CRASHMSG_MAX];
} __packed;
/*
* struct visor_controlvm_parameters_header
*
* 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 visor_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;
guid_t id;
u32 revision;
/* Natural alignment */
u32 reserved;
} __packed;
/* General Errors------------------------------------------------------[0-99] */
#define CONTROLVM_RESP_SUCCESS 0
#define CONTROLVM_RESP_ALREADY_DONE 1
#define CONTROLVM_RESP_IOREMAP_FAILED 2
#define CONTROLVM_RESP_KMALLOC_FAILED 3
#define CONTROLVM_RESP_ID_UNKNOWN 4
#define CONTROLVM_RESP_ID_INVALID_FOR_CLIENT 5
/* CONTROLVM_INIT_CHIPSET-------------------------------------------[100-199] */
#define CONTROLVM_RESP_CLIENT_SWITCHCOUNT_NONZERO 100
#define CONTROLVM_RESP_EXPECTED_CHIPSET_INIT 101
/* Maximum Limit----------------------------------------------------[200-299] */
/* BUS_CREATE */
#define CONTROLVM_RESP_ERROR_MAX_BUSES 201
/* DEVICE_CREATE */
#define CONTROLVM_RESP_ERROR_MAX_DEVICES 202
/* Payload and Parameter Related------------------------------------[400-499] */
/* SWITCH_ATTACHEXTPORT, DEVICE_CONFIGURE */
#define CONTROLVM_RESP_PAYLOAD_INVALID 400
/* Multiple */
#define CONTROLVM_RESP_INITIATOR_PARAMETER_INVALID 401
/* DEVICE_CONFIGURE */
#define CONTROLVM_RESP_TARGET_PARAMETER_INVALID 402
/* DEVICE_CONFIGURE */
#define CONTROLVM_RESP_CLIENT_PARAMETER_INVALID 403
/* Specified[Packet Structure] Value--------------------------------[500-599] */
/* SWITCH_ATTACHINTPORT */
/* BUS_CONFIGURE, DEVICE_CREATE, DEVICE_CONFIG, DEVICE_DESTROY */
#define CONTROLVM_RESP_BUS_INVALID 500
/* SWITCH_ATTACHINTPORT*/
/* DEVICE_CREATE, DEVICE_CONFIGURE, DEVICE_DESTROY */
#define CONTROLVM_RESP_DEVICE_INVALID 501
/* DEVICE_CREATE, DEVICE_CONFIGURE */
#define CONTROLVM_RESP_CHANNEL_INVALID 502
/* Partition Driver Callback Interface------------------------------[600-699] */
/* BUS_CREATE, BUS_DESTROY, DEVICE_CREATE, DEVICE_DESTROY */
#define CONTROLVM_RESP_VIRTPCI_DRIVER_FAILURE 604
/* Unable to invoke VIRTPCI callback. VIRTPCI Callback returned error. */
/* BUS_CREATE, BUS_DESTROY, DEVICE_CREATE, DEVICE_DESTROY */
#define CONTROLVM_RESP_VIRTPCI_DRIVER_CALLBACK_ERROR 605
/* Generic device callback returned error. */
/* SWITCH_ATTACHEXTPORT, SWITCH_DETACHEXTPORT, DEVICE_CONFIGURE */
#define CONTROLVM_RESP_GENERIC_DRIVER_CALLBACK_ERROR 606
/* Bus Related------------------------------------------------------[700-799] */
/* BUS_DESTROY */
#define CONTROLVM_RESP_ERROR_BUS_DEVICE_ATTACHED 700
/* Channel Related--------------------------------------------------[800-899] */
/* GET_CHANNELINFO, DEVICE_DESTROY */
#define CONTROLVM_RESP_CHANNEL_TYPE_UNKNOWN 800
/* DEVICE_CREATE */
#define CONTROLVM_RESP_CHANNEL_SIZE_TOO_SMALL 801
/* Chipset Shutdown Related---------------------------------------[1000-1099] */
#define CONTROLVM_RESP_CHIPSET_SHUTDOWN_FAILED 1000
#define CONTROLVM_RESP_CHIPSET_SHUTDOWN_ALREADY_ACTIVE 1001
/* Chipset Stop Related-------------------------------------------[1100-1199] */
#define CONTROLVM_RESP_CHIPSET_STOP_FAILED_BUS 1100
#define CONTROLVM_RESP_CHIPSET_STOP_FAILED_SWITCH 1101
/* Device Related-------------------------------------------------[1400-1499] */
#define CONTROLVM_RESP_DEVICE_UDEV_TIMEOUT 1400
/* __CONTROLVMCHANNEL_H__ */
#endif

95
drivers/visorbus/vbuschannel.h Normal file
View file

@ -0,0 +1,95 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2010 - 2015 UNISYS CORPORATION
* All rights reserved.
*/
#ifndef __VBUSCHANNEL_H__
#define __VBUSCHANNEL_H__
/*
* The vbus channel is the channel area provided via the BUS_CREATE controlvm
* message for each virtual bus. This channel area is provided to both server
* and client ends of the bus. The channel header area is initialized by
* the server, and the remaining information is filled in by the client.
* We currently use this for the client to provide various information about
* the client devices and client drivers for the server end to see.
*/
#include <linux/uuid.h>
#include <linux/visorbus.h>
/* {193b331b-c58f-11da-95a9-00e08161165f} */
#define VISOR_VBUS_CHANNEL_GUID \
GUID_INIT(0x193b331b, 0xc58f, 0x11da, \
0x95, 0xa9, 0x0, 0xe0, 0x81, 0x61, 0x16, 0x5f)
/*
* 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 VISOR_VBUS_CHANNEL_VERSIONID 1
/*
* struct visor_vbus_deviceinfo
* @devtype: Short string identifying the device type.
* @drvname: Driver .sys file name.
* @infostrs: Kernel vversion.
* @reserved: Pad size to 256 bytes.
*
* An array of this struct is present in the channel area for each vbus. It is
* filled in by the client side to provide info about the device and driver from
* the client's perspective.
*/
struct visor_vbus_deviceinfo {
u8 devtype[16];
u8 drvname[16];
u8 infostrs[96];
u8 reserved[128];
} __packed;
/*
* struct visor_vbus_headerinfo
* @struct_bytes: Size of this struct in bytes.
* @device_info_struct_bytes: Size of VISOR_VBUS_DEVICEINFO.
* @dev_info_count: Num of items in DevInfo member. This is the
* allocated size.
* @chp_info_offset: Byte offset from beginning of this struct to the
* ChpInfo struct.
* @bus_info_offset: Byte offset from beginning of this struct to the
* BusInfo struct.
* @dev_info_offset: Byte offset from beginning of this struct to the
* DevInfo array.
* @reserved: Natural alignment.
*/
struct visor_vbus_headerinfo {
u32 struct_bytes;
u32 device_info_struct_bytes;
u32 dev_info_count;
u32 chp_info_offset;
u32 bus_info_offset;
u32 dev_info_offset;
u8 reserved[104];
} __packed;
/*
* struct visor_vbus_channel
* @channel_header: Initialized by server.
* @hdr_info: Initialized by server.
* @chp_info: Describes client chipset device and driver.
* @bus_info: Describes client bus device and driver.
* @dev_info: Describes client device and driver for each device on the
* bus.
*/
struct visor_vbus_channel {
struct channel_header channel_header;
struct visor_vbus_headerinfo hdr_info;
struct visor_vbus_deviceinfo chp_info;
struct visor_vbus_deviceinfo bus_info;
struct visor_vbus_deviceinfo dev_info[0];
} __packed;
#endif

1234
drivers/visorbus/visorbus_main.c Normal file
View file

File diff suppressed because it is too large Load diff

48
drivers/visorbus/visorbus_private.h Normal file
View file

@ -0,0 +1,48 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2010 - 2015 UNISYS CORPORATION
* All rights reserved.
*/
#ifndef __VISORBUS_PRIVATE_H__
#define __VISORBUS_PRIVATE_H__
#include <linux/uuid.h>
#include <linux/utsname.h>
#include <linux/visorbus.h>
#include "controlvmchannel.h"
#include "vbuschannel.h"
struct visor_device *visorbus_get_device_by_id(u32 bus_no, u32 dev_no,
struct visor_device *from);
int visorbus_create_instance(struct visor_device *dev);
void visorbus_remove_instance(struct visor_device *bus_info);
int create_visor_device(struct visor_device *dev_info);
void remove_visor_device(struct visor_device *dev_info);
int visorchipset_device_pause(struct visor_device *dev_info);
int visorchipset_device_resume(struct visor_device *dev_info);
void visorbus_response(struct visor_device *p, int response, int controlvm_id);
void visorbus_device_changestate_response(struct visor_device *p, int response,
struct visor_segment_state state);
int visorbus_init(void);
void visorbus_exit(void);
/* visorchannel access functions */
struct visorchannel *visorchannel_create(u64 physaddr, gfp_t gfp,
const guid_t *guid, bool needs_lock);
void visorchannel_destroy(struct visorchannel *channel);
int visorchannel_read(struct visorchannel *channel, ulong offset,
void *dest, ulong nbytes);
int visorchannel_write(struct visorchannel *channel, ulong offset,
void *dest, ulong nbytes);
u64 visorchannel_get_physaddr(struct visorchannel *channel);
ulong visorchannel_get_nbytes(struct visorchannel *channel);
char *visorchannel_id(struct visorchannel *channel, char *s);
char *visorchannel_zoneid(struct visorchannel *channel, char *s);
u64 visorchannel_get_clientpartition(struct visorchannel *channel);
int visorchannel_set_clientpartition(struct visorchannel *channel,
u64 partition_handle);
char *visorchannel_guid_id(const guid_t *guid, char *s);
void *visorchannel_get_header(struct visorchannel *channel);
#endif

434
drivers/visorbus/visorchannel.c Normal file
View file

@ -0,0 +1,434 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2010 - 2015 UNISYS CORPORATION
* All rights reserved.
*/
/*
* This provides s-Par channel communication primitives, which are
* independent of the mechanism used to access the channel data.
*/
#include <linux/uuid.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/visorbus.h>
#include "visorbus_private.h"
#include "controlvmchannel.h"
#define VISOR_DRV_NAME "visorchannel"
#define VISOR_CONSOLEVIDEO_CHANNEL_GUID \
GUID_INIT(0x3cd6e705, 0xd6a2, 0x4aa5, \
0xad, 0x5c, 0x7b, 0x8, 0x88, 0x9d, 0xff, 0xe2)
static const guid_t visor_video_guid = VISOR_CONSOLEVIDEO_CHANNEL_GUID;
struct visorchannel {
u64 physaddr;
ulong nbytes;
void *mapped;
bool requested;
struct channel_header chan_hdr;
guid_t guid;
/*
* channel creator knows if more than one thread will be inserting or
* removing
*/
bool needs_lock;
/* protect head writes in chan_hdr */
spinlock_t insert_lock;
/* protect tail writes in chan_hdr */
spinlock_t remove_lock;
guid_t type;
guid_t inst;
};
void visorchannel_destroy(struct visorchannel *channel)
{
if (!channel)
return;
if (channel->mapped) {
memunmap(channel->mapped);
if (channel->requested)
release_mem_region(channel->physaddr, channel->nbytes);
}
kfree(channel);
}
u64 visorchannel_get_physaddr(struct visorchannel *channel)
{
return channel->physaddr;
}
ulong visorchannel_get_nbytes(struct visorchannel *channel)
{
return channel->nbytes;
}
char *visorchannel_guid_id(const guid_t *guid, char *s)
{
sprintf(s, "%pUL", guid);
return s;
}
char *visorchannel_id(struct visorchannel *channel, char *s)
{
return visorchannel_guid_id(&channel->guid, s);
}
char *visorchannel_zoneid(struct visorchannel *channel, char *s)
{
return visorchannel_guid_id(&channel->chan_hdr.zone_guid, s);
}
u64 visorchannel_get_clientpartition(struct visorchannel *channel)
{
return channel->chan_hdr.partition_handle;
}
int visorchannel_set_clientpartition(struct visorchannel *channel,
u64 partition_handle)
{
channel->chan_hdr.partition_handle = partition_handle;
return 0;
}
/**
* visorchannel_get_guid() - queries the GUID of the designated channel
* @channel: the channel to query
*
* Return: the GUID of the provided channel
*/
const guid_t *visorchannel_get_guid(struct visorchannel *channel)
{
return &channel->guid;
}
EXPORT_SYMBOL_GPL(visorchannel_get_guid);
int visorchannel_read(struct visorchannel *channel, ulong offset, void *dest,
ulong nbytes)
{
if (offset + nbytes > channel->nbytes)
return -EIO;
memcpy(dest, channel->mapped + offset, nbytes);
return 0;
}
int visorchannel_write(struct visorchannel *channel, ulong offset, void *dest,
ulong nbytes)
{
size_t chdr_size = sizeof(struct channel_header);
size_t copy_size;
if (offset + nbytes > channel->nbytes)
return -EIO;
if (offset < chdr_size) {
copy_size = min(chdr_size - offset, nbytes);
memcpy(((char *)(&channel->chan_hdr)) + offset,
dest, copy_size);
}
memcpy(channel->mapped + offset, dest, nbytes);
return 0;
}
void *visorchannel_get_header(struct visorchannel *channel)
{
return &channel->chan_hdr;
}
/*
* Return offset of a specific SIGNAL_QUEUE_HEADER from the beginning of a
* channel header
*/
static int sig_queue_offset(struct channel_header *chan_hdr, int q)
{
return ((chan_hdr)->ch_space_offset +
((q) * sizeof(struct signal_queue_header)));
}
/*
* Return offset of a specific queue entry (data) from the beginning of a
* channel header
*/
static int sig_data_offset(struct channel_header *chan_hdr, int q,
struct signal_queue_header *sig_hdr, int slot)
{
return (sig_queue_offset(chan_hdr, q) + sig_hdr->sig_base_offset +
(slot * sig_hdr->signal_size));
}
/*
* Write the contents of a specific field within a SIGNAL_QUEUE_HEADER back into
* host memory
*/
#define SIG_WRITE_FIELD(channel, queue, sig_hdr, FIELD) \
visorchannel_write(channel, \
sig_queue_offset(&channel->chan_hdr, queue) + \
offsetof(struct signal_queue_header, FIELD), \
&((sig_hdr)->FIELD), \
sizeof((sig_hdr)->FIELD))
static int sig_read_header(struct visorchannel *channel, u32 queue,
struct signal_queue_header *sig_hdr)
{
if (channel->chan_hdr.ch_space_offset < sizeof(struct channel_header))
return -EINVAL;
/* Read the appropriate SIGNAL_QUEUE_HEADER into local memory. */
return visorchannel_read(channel,
sig_queue_offset(&channel->chan_hdr, queue),
sig_hdr, sizeof(struct signal_queue_header));
}
static int sig_read_data(struct visorchannel *channel, u32 queue,
struct signal_queue_header *sig_hdr, u32 slot,
void *data)
{
int signal_data_offset = sig_data_offset(&channel->chan_hdr, queue,
sig_hdr, slot);
return visorchannel_read(channel, signal_data_offset,
data, sig_hdr->signal_size);
}
static int sig_write_data(struct visorchannel *channel, u32 queue,
struct signal_queue_header *sig_hdr, u32 slot,
void *data)
{
int signal_data_offset = sig_data_offset(&channel->chan_hdr, queue,
sig_hdr, slot);
return visorchannel_write(channel, signal_data_offset,
data, sig_hdr->signal_size);
}
static int signalremove_inner(struct visorchannel *channel, u32 queue,
void *msg)
{
struct signal_queue_header sig_hdr;
int error;
error = sig_read_header(channel, queue, &sig_hdr);
if (error)
return error;
/* No signals to remove; have caller try again. */
if (sig_hdr.head == sig_hdr.tail)
return -EAGAIN;
sig_hdr.tail = (sig_hdr.tail + 1) % sig_hdr.max_slots;
error = sig_read_data(channel, queue, &sig_hdr, sig_hdr.tail, msg);
if (error)
return error;
sig_hdr.num_received++;
/*
* For each data field in SIGNAL_QUEUE_HEADER that was modified, update
* host memory. Required for channel sync.
*/
mb();
error = SIG_WRITE_FIELD(channel, queue, &sig_hdr, tail);
if (error)
return error;
error = SIG_WRITE_FIELD(channel, queue, &sig_hdr, num_received);
if (error)
return error;
return 0;
}
/**
* visorchannel_signalremove() - removes a message from the designated
* channel/queue
* @channel: the channel the message will be removed from
* @queue: the queue the message will be removed from
* @msg: the message to remove
*
* Return: integer error code indicating the status of the removal
*/
int visorchannel_signalremove(struct visorchannel *channel, u32 queue,
void *msg)
{
int rc;
unsigned long flags;
if (channel->needs_lock) {
spin_lock_irqsave(&channel->remove_lock, flags);
rc = signalremove_inner(channel, queue, msg);
spin_unlock_irqrestore(&channel->remove_lock, flags);
} else {
rc = signalremove_inner(channel, queue, msg);
}
return rc;
}
EXPORT_SYMBOL_GPL(visorchannel_signalremove);
static bool queue_empty(struct visorchannel *channel, u32 queue)
{
struct signal_queue_header sig_hdr;
if (sig_read_header(channel, queue, &sig_hdr))
return true;
return (sig_hdr.head == sig_hdr.tail);
}
/**
* visorchannel_signalempty() - checks if the designated channel/queue contains
* any messages
* @channel: the channel to query
* @queue: the queue in the channel to query
*
* Return: boolean indicating whether any messages in the designated
* channel/queue are present
*/
bool visorchannel_signalempty(struct visorchannel *channel, u32 queue)
{
bool rc;
unsigned long flags;
if (!channel->needs_lock)
return queue_empty(channel, queue);
spin_lock_irqsave(&channel->remove_lock, flags);
rc = queue_empty(channel, queue);
spin_unlock_irqrestore(&channel->remove_lock, flags);
return rc;
}
EXPORT_SYMBOL_GPL(visorchannel_signalempty);
static int signalinsert_inner(struct visorchannel *channel, u32 queue,
void *msg)
{
struct signal_queue_header sig_hdr;
int err;
err = sig_read_header(channel, queue, &sig_hdr);
if (err)
return err;
sig_hdr.head = (sig_hdr.head + 1) % sig_hdr.max_slots;
if (sig_hdr.head == sig_hdr.tail) {
sig_hdr.num_overflows++;
err = SIG_WRITE_FIELD(channel, queue, &sig_hdr, num_overflows);
if (err)
return err;
return -EIO;
}
err = sig_write_data(channel, queue, &sig_hdr, sig_hdr.head, msg);
if (err)
return err;
sig_hdr.num_sent++;
/*
* For each data field in SIGNAL_QUEUE_HEADER that was modified, update
* host memory. Required for channel sync.
*/
mb();
err = SIG_WRITE_FIELD(channel, queue, &sig_hdr, head);
if (err)
return err;
err = SIG_WRITE_FIELD(channel, queue, &sig_hdr, num_sent);
if (err)
return err;
return 0;
}
/*
* visorchannel_create() - creates the struct visorchannel abstraction for a
* data area in memory, but does NOT modify this data
* area
* @physaddr: physical address of start of channel
* @gfp: gfp_t to use when allocating memory for the data struct
* @guid: GUID that identifies channel type;
* @needs_lock: must specify true if you have multiple threads of execution
* that will be calling visorchannel methods of this
* visorchannel at the same time
*
* Return: pointer to visorchannel that was created if successful,
* otherwise NULL
*/
struct visorchannel *visorchannel_create(u64 physaddr, gfp_t gfp,
const guid_t *guid, bool needs_lock)
{
struct visorchannel *channel;
int err;
size_t size = sizeof(struct channel_header);
if (physaddr == 0)
return NULL;
channel = kzalloc(sizeof(*channel), gfp);
if (!channel)
return NULL;
channel->needs_lock = needs_lock;
spin_lock_init(&channel->insert_lock);
spin_lock_init(&channel->remove_lock);
/*
* Video driver constains the efi framebuffer so it will get a conflict
* resource when requesting its full mem region. Since we are only
* using the efi framebuffer for video we can ignore this. Remember that
* we haven't requested it so we don't try to release later on.
*/
channel->requested = request_mem_region(physaddr, size, VISOR_DRV_NAME);
if (!channel->requested && !guid_equal(guid, &visor_video_guid))
/* we only care about errors if this is not the video channel */
goto err_destroy_channel;
channel->mapped = memremap(physaddr, size, MEMREMAP_WB);
if (!channel->mapped) {
release_mem_region(physaddr, size);
goto err_destroy_channel;
}
channel->physaddr = physaddr;
channel->nbytes = size;
err = visorchannel_read(channel, 0, &channel->chan_hdr, size);
if (err)
goto err_destroy_channel;
size = (ulong)channel->chan_hdr.size;
memunmap(channel->mapped);
if (channel->requested)
release_mem_region(channel->physaddr, channel->nbytes);
channel->mapped = NULL;
channel->requested = request_mem_region(channel->physaddr, size,
VISOR_DRV_NAME);
if (!channel->requested && !guid_equal(guid, &visor_video_guid))
/* we only care about errors if this is not the video channel */
goto err_destroy_channel;
channel->mapped = memremap(channel->physaddr, size, MEMREMAP_WB);
if (!channel->mapped) {
release_mem_region(channel->physaddr, size);
goto err_destroy_channel;
}
channel->nbytes = size;
guid_copy(&channel->guid, guid);
return channel;
err_destroy_channel:
visorchannel_destroy(channel);
return NULL;
}
/**
* visorchannel_signalinsert() - inserts a message into the designated
* channel/queue
* @channel: the channel the message will be added to
* @queue: the queue the message will be added to
* @msg: the message to insert
*
* Return: integer error code indicating the status of the insertion
*/
int visorchannel_signalinsert(struct visorchannel *channel, u32 queue,
void *msg)
{
int rc;
unsigned long flags;
if (channel->needs_lock) {
spin_lock_irqsave(&channel->insert_lock, flags);
rc = signalinsert_inner(channel, queue, msg);
spin_unlock_irqrestore(&channel->insert_lock, flags);
} else {
rc = signalinsert_inner(channel, queue, msg);
}
return rc;
}
EXPORT_SYMBOL_GPL(visorchannel_signalinsert);

1686
drivers/visorbus/visorchipset.c Normal file
View file

File diff suppressed because it is too large Load diff

344
include/linux/visorbus.h Normal file
View file

@ -0,0 +1,344 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2010 - 2013 UNISYS CORPORATION
* All rights reserved.
*/
/*
* This header file is to be included by other kernel mode components that
* implement a particular kind of visor_device. Each of these other kernel
* mode components is called a visor device driver. Refer to visortemplate
* for a minimal sample visor device driver.
*
* There should be nothing in this file that is private to the visorbus
* bus implementation itself.
*/
#ifndef __VISORBUS_H__
#define __VISORBUS_H__
#include <linux/device.h>
#define VISOR_CHANNEL_SIGNATURE ('L' << 24 | 'N' << 16 | 'C' << 8 | 'E')
/*
* enum channel_serverstate
* @CHANNELSRV_UNINITIALIZED: Channel is in an undefined state.
* @CHANNELSRV_READY: Channel has been initialized by server.
*/
enum channel_serverstate {
CHANNELSRV_UNINITIALIZED = 0,
CHANNELSRV_READY = 1
};
/*
* enum channel_clientstate
* @CHANNELCLI_DETACHED:
* @CHANNELCLI_DISABLED: Client can see channel but is NOT allowed to use it
* unless given TBD* explicit request
* (should actually be < DETACHED).
* @CHANNELCLI_ATTACHING: Legacy EFI client request for EFI server to attach.
* @CHANNELCLI_ATTACHED: Idle, but client may want to use channel any time.
* @CHANNELCLI_BUSY: Client either wants to use or is using channel.
* @CHANNELCLI_OWNED: "No worries" state - client can access channel
* anytime.
*/
enum channel_clientstate {
CHANNELCLI_DETACHED = 0,
CHANNELCLI_DISABLED = 1,
CHANNELCLI_ATTACHING = 2,
CHANNELCLI_ATTACHED = 3,
CHANNELCLI_BUSY = 4,
CHANNELCLI_OWNED = 5
};
/*
* Values for VISOR_CHANNEL_PROTOCOL.Features: This define exists so that
* a guest can look at the FeatureFlags in the io channel, and configure the
* driver to use interrupts or not based on this setting. All feature bits for
* all channels should be defined here. The io channel feature bits are defined
* below.
*/
#define VISOR_DRIVER_ENABLES_INTS (0x1ULL << 1)
#define VISOR_CHANNEL_IS_POLLING (0x1ULL << 3)
#define VISOR_IOVM_OK_DRIVER_DISABLING_INTS (0x1ULL << 4)
#define VISOR_DRIVER_DISABLES_INTS (0x1ULL << 5)
#define VISOR_DRIVER_ENHANCED_RCVBUF_CHECKING (0x1ULL << 6)
/*
* struct channel_header - Common Channel Header
* @signature: Signature.
* @legacy_state: DEPRECATED - being replaced by.
* @header_size: sizeof(struct channel_header).
* @size: Total size of this channel in bytes.
* @features: Flags to modify behavior.
* @chtype: Channel type: data, bus, control, etc..
* @partition_handle: ID of guest partition.
* @handle: Device number of this channel in client.
* @ch_space_offset: Offset in bytes to channel specific area.
* @version_id: Struct channel_header Version ID.
* @partition_index: Index of guest partition.
* @zone_uuid: Guid of Channel's zone.
* @cli_str_offset: Offset from channel header to null-terminated
* ClientString (0 if ClientString not present).
* @cli_state_boot: CHANNEL_CLIENTSTATE of pre-boot EFI client of this
* channel.
* @cmd_state_cli: CHANNEL_COMMANDSTATE (overloaded in Windows drivers, see
* ServerStateUp, ServerStateDown, etc).
* @cli_state_os: CHANNEL_CLIENTSTATE of Guest OS client of this channel.
* @ch_characteristic: CHANNEL_CHARACTERISTIC_<xxx>.
* @cmd_state_srv: CHANNEL_COMMANDSTATE (overloaded in Windows drivers, see
* ServerStateUp, ServerStateDown, etc).
* @srv_state: CHANNEL_SERVERSTATE.
* @cli_error_boot: Bits to indicate err states for boot clients, so err
* messages can be throttled.
* @cli_error_os: Bits to indicate err states for OS clients, so err
* messages can be throttled.
* @filler: Pad out to 128 byte cacheline.
* @recover_channel: Please add all new single-byte values below here.
*/
struct channel_header {
u64 signature;
u32 legacy_state;
/* SrvState, CliStateBoot, and CliStateOS below */
u32 header_size;
u64 size;
u64 features;
guid_t chtype;
u64 partition_handle;
u64 handle;
u64 ch_space_offset;
u32 version_id;
u32 partition_index;
guid_t zone_guid;
u32 cli_str_offset;
u32 cli_state_boot;
u32 cmd_state_cli;
u32 cli_state_os;
u32 ch_characteristic;
u32 cmd_state_srv;
u32 srv_state;
u8 cli_error_boot;
u8 cli_error_os;
u8 filler[1];
u8 recover_channel;
} __packed;
#define VISOR_CHANNEL_ENABLE_INTS (0x1ULL << 0)
/*
* struct signal_queue_header - Subheader for the Signal Type variation of the
* Common Channel.
* @version: SIGNAL_QUEUE_HEADER Version ID.
* @chtype: Queue type: storage, network.
* @size: Total size of this queue in bytes.
* @sig_base_offset: Offset to signal queue area.
* @features: Flags to modify behavior.
* @num_sent: Total # of signals placed in this queue.
* @num_overflows: Total # of inserts failed due to full queue.
* @signal_size: Total size of a signal for this queue.
* @max_slots: Max # of slots in queue, 1 slot is always empty.
* @max_signals: Max # of signals in queue (MaxSignalSlots-1).
* @head: Queue head signal #.
* @num_received: Total # of signals removed from this queue.
* @tail: Queue tail signal.
* @reserved1: Reserved field.
* @reserved2: Reserved field.
* @client_queue:
* @num_irq_received: Total # of Interrupts received. This is incremented by the
* ISR in the guest windows driver.
* @num_empty: Number of times that visor_signal_remove is called and
* returned Empty Status.
* @errorflags: Error bits set during SignalReinit to denote trouble with
* client's fields.
* @filler: Pad out to 64 byte cacheline.
*/
struct signal_queue_header {
/* 1st cache line */
u32 version;
u32 chtype;
u64 size;
u64 sig_base_offset;
u64 features;
u64 num_sent;
u64 num_overflows;
u32 signal_size;
u32 max_slots;
u32 max_signals;
u32 head;
/* 2nd cache line */
u64 num_received;
u32 tail;
u32 reserved1;
u64 reserved2;
u64 client_queue;
u64 num_irq_received;
u64 num_empty;
u32 errorflags;
u8 filler[12];
} __packed;
/* VISORCHANNEL Guids */
/* {414815ed-c58c-11da-95a9-00e08161165f} */
#define VISOR_VHBA_CHANNEL_GUID \
GUID_INIT(0x414815ed, 0xc58c, 0x11da, \
0x95, 0xa9, 0x0, 0xe0, 0x81, 0x61, 0x16, 0x5f)
#define VISOR_VHBA_CHANNEL_GUID_STR \
"414815ed-c58c-11da-95a9-00e08161165f"
struct visorchipset_state {
u32 created:1;
u32 attached:1;
u32 configured:1;
u32 running:1;
/* Remaining bits in this 32-bit word are reserved. */
};
/**
* struct visor_device - A device type for things "plugged" into the visorbus
* bus
* @visorchannel: Points to the channel that the device is
* associated with.
* @channel_type_guid: Identifies the channel type to the bus driver.
* @device: Device struct meant for use by the bus driver
* only.
* @list_all: Used by the bus driver to enumerate devices.
* @timer: Timer fired periodically to do interrupt-type
* activity.
* @being_removed: Indicates that the device is being removed from
* the bus. Private bus driver use only.
* @visordriver_callback_lock: Used by the bus driver to lock when adding and
* removing devices.
* @pausing: Indicates that a change towards a paused state.
* is in progress. Only modified by the bus driver.
* @resuming: Indicates that a change towards a running state
* is in progress. Only modified by the bus driver.
* @chipset_bus_no: Private field used by the bus driver.
* @chipset_dev_no: Private field used the bus driver.
* @state: Used to indicate the current state of the
* device.
* @inst: Unique GUID for this instance of the device.
* @name: Name of the device.
* @pending_msg_hdr: For private use by bus driver to respond to
* hypervisor requests.
* @vbus_hdr_info: A pointer to header info. Private use by bus
* driver.
* @partition_guid: Indicates client partion id. This should be the
* same across all visor_devices in the current
* guest. Private use by bus driver only.
*/
struct visor_device {
struct visorchannel *visorchannel;
guid_t channel_type_guid;
/* These fields are for private use by the bus driver only. */
struct device device;
struct list_head list_all;
struct timer_list timer;
bool timer_active;
bool being_removed;
struct mutex visordriver_callback_lock; /* synchronize probe/remove */
bool pausing;
bool resuming;
u32 chipset_bus_no;
u32 chipset_dev_no;
struct visorchipset_state state;
guid_t inst;
u8 *name;
struct controlvm_message_header *pending_msg_hdr;
void *vbus_hdr_info;
guid_t partition_guid;
struct dentry *debugfs_dir;
struct dentry *debugfs_bus_info;
};
#define to_visor_device(x) container_of(x, struct visor_device, device)
typedef void (*visorbus_state_complete_func) (struct visor_device *dev,
int status);
/*
* This struct describes a specific visor channel, by providing its GUID, name,
* and sizes.
*/
struct visor_channeltype_descriptor {
const guid_t guid;
const char *name;
u64 min_bytes;
u32 version;
};
/**
* struct visor_driver - Information provided by each visor driver when it
* registers with the visorbus driver
* @name: Name of the visor driver.
* @owner: The module owner.
* @channel_types: Types of channels handled by this driver, ending with
* a zero GUID. Our specialized BUS.match() method knows
* about this list, and uses it to determine whether this
* driver will in fact handle a new device that it has
* detected.
* @probe: Called when a new device comes online, by our probe()
* function specified by driver.probe() (triggered
* ultimately by some call to driver_register(),
* bus_add_driver(), or driver_attach()).
* @remove: Called when a new device is removed, by our remove()
* function specified by driver.remove() (triggered
* ultimately by some call to device_release_driver()).
* @channel_interrupt: Called periodically, whenever there is a possiblity
* that "something interesting" may have happened to the
* channel.
* @pause: Called to initiate a change of the device's state. If
* the return valu`e is < 0, there was an error and the
* state transition will NOT occur. If the return value
* is >= 0, then the state transition was INITIATED
* successfully, and complete_func() will be called (or
* was just called) with the final status when either the
* state transition fails or completes successfully.
* @resume: Behaves similar to pause.
* @driver: Private reference to the device driver. For use by bus
* driver only.
*/
struct visor_driver {
const char *name;
struct module *owner;
struct visor_channeltype_descriptor *channel_types;
int (*probe)(struct visor_device *dev);
void (*remove)(struct visor_device *dev);
void (*channel_interrupt)(struct visor_device *dev);
int (*pause)(struct visor_device *dev,
visorbus_state_complete_func complete_func);
int (*resume)(struct visor_device *dev,
visorbus_state_complete_func complete_func);
/* These fields are for private use by the bus driver only. */
struct device_driver driver;
};
#define to_visor_driver(x) (container_of(x, struct visor_driver, driver))
int visor_check_channel(struct channel_header *ch, struct device *dev,
const guid_t *expected_uuid, char *chname,
u64 expected_min_bytes, u32 expected_version,
u64 expected_signature);
int visorbus_register_visor_driver(struct visor_driver *drv);
void visorbus_unregister_visor_driver(struct visor_driver *drv);
int visorbus_read_channel(struct visor_device *dev,
unsigned long offset, void *dest,
unsigned long nbytes);
int visorbus_write_channel(struct visor_device *dev,
unsigned long offset, void *src,
unsigned long nbytes);
int visorbus_enable_channel_interrupts(struct visor_device *dev);
void visorbus_disable_channel_interrupts(struct visor_device *dev);
int visorchannel_signalremove(struct visorchannel *channel, u32 queue,
void *msg);
int visorchannel_signalinsert(struct visorchannel *channel, u32 queue,
void *msg);
bool visorchannel_signalempty(struct visorchannel *channel, u32 queue);
const guid_t *visorchannel_get_guid(struct visorchannel *channel);
#define BUS_ROOT_DEVICE UINT_MAX
struct visor_device *visorbus_get_device_by_id(u32 bus_no, u32 dev_no,
struct visor_device *from);
#endif