staging: unisys: remove remaining utility headers

/* uisqueue.h

 *

 * Copyright (C) 2010 - 2013 UNISYS CORPORATION

 * All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or (at

 * your option) any later version.

 *

 * 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.

 */

/*

 * Unisys IO Virtualization header NOTE: This file contains only Linux

 * specific structs.  All OS-independent structs are in iochannel.h.xx

 */

#ifndef __UISQUEUE_H__

#define __UISQUEUE_H__

#include "linux/version.h"

#include "iochannel.h"

#include <linux/atomic.h>

#include <linux/semaphore.h>

#include <linux/uuid.h>

#include "controlvmchannel.h"

#include "controlvmcompletionstatus.h"

struct uisqueue_info {

	struct channel_header __iomem *chan;

	/* channel containing queues in which scsi commands &

	 * responses are queued

	 */

	u64 packets_sent;

	u64 packets_received;

	u64 interrupts_sent;

	u64 interrupts_received;

	u64 max_not_empty_cnt;

	u64 total_wakeup_cnt;

	u64 non_empty_wakeup_cnt;

	struct {

		struct signal_queue_header reserved1;	/*  */

		struct signal_queue_header reserved2;	/*  */

	} safe_uis_queue;

	unsigned int (*send_int_if_needed)(struct uisqueue_info *info,

					   unsigned int whichcqueue,

					   unsigned char issue_irq_if_empty,

					   u64 irq_handle,

					   unsigned char io_termination);

};

/* uisqueue_put_cmdrsp_with_lock_client queues a commmand or response

 * to the specified queue, at the tail if the queue is full but

 * oktowait == 0, then it return 0 indicating failure.  otherwise it

 * wait for the queue to become non-full. If command is queued, return

 * 1 for success.

 */

#define DONT_ISSUE_INTERRUPT 0

#define ISSUE_INTERRUPT		 1

#define DONT_WAIT			 0

#define OK_TO_WAIT			 1

#define UISLIB_LOCK_PREFIX \

		".section .smp_locks,\"a\"\n"   \

		_ASM_ALIGN "\n"                 \

		_ASM_PTR "661f\n" /* address */ \

		".previous\n"                   \

		"661:\n\tlock; "

unsigned long long uisqueue_interlocked_or(unsigned long long __iomem *tgt,

					   unsigned long long set);

unsigned long long uisqueue_interlocked_and(unsigned long long __iomem *tgt,

					    unsigned long long set);

int uisqueue_put_cmdrsp_with_lock_client(struct uisqueue_info *queueinfo,

					 struct uiscmdrsp *cmdrsp,

					 unsigned int queue,

					 void *insertlock,

					 unsigned char issue_irq_if_empty,

					 u64 irq_handle,

					 char oktowait,

					 u8 *channel_id);

/* uisqueue_get_cmdrsp gets the cmdrsp entry at the head of the queue

 * and copies it to the area pointed by cmdrsp param.

 * returns 0 if queue is empty, 1 otherwise

 */

int

uisqueue_get_cmdrsp(struct uisqueue_info *queueinfo, void *cmdrsp,

		    unsigned int queue);

#define MAX_NAME_SIZE_UISQUEUE 64

struct extport_info {

	u8 valid:1;

	/* if 1, indicates this extport slot is occupied

	 * if 0, indicates that extport slot is unoccupied */

	u32 num_devs_using;

	/* When extport is added, this is set to 0.  For exports

	* located in NETWORK switches:

	* Each time a VNIC, i.e., intport, is added to the switch this

	* is used to assign a pref_pnic for the VNIC and when assigned

	* to a VNIC this counter is incremented. When a VNIC is

	* deleted, the extport corresponding to the VNIC's pref_pnic

	* is located and its num_devs_using is decremented. For VNICs,

	* num_devs_using is basically used to load-balance transmit

	* traffic from VNICs.

	*/

	struct switch_info *swtch;

	struct pci_id pci_id;

	char name[MAX_NAME_SIZE_UISQUEUE];

	union {

		struct vhba_wwnn wwnn;

		unsigned char macaddr[MAX_MACADDR_LEN];

	};

};

struct device_info {

	void __iomem *chanptr;

	u64 channel_addr;

	u64 channel_bytes;

	uuid_le channel_uuid;

	uuid_le instance_uuid;

	struct irq_info intr;

	struct switch_info *swtch;

	char devid[30];		/* "vbus<busno>:dev<devno>" */

	u16 polling;

	struct semaphore interrupt_callback_lock;

	u32 bus_no;

	u32 dev_no;

	int (*interrupt)(void *);

	void *interrupt_context;

	void *private_data;

	struct list_head list_polling_device_channels;

	unsigned long long moved_to_tail_cnt;

	unsigned long long first_busy_cnt;

	unsigned long long last_on_list_cnt;

};

enum switch_type {

	RECOVERY_LAN = 1,

	IB_LAN = 2

};

struct bus_info {

	u32 bus_no, device_count;

	struct device_info **device;

	u64 guest_handle, recv_bus_irq_handle;

	uuid_le bus_inst_uuid;

	struct ultra_vbus_channel_protocol __iomem *bus_channel;

	int bus_channel_bytes;

	struct proc_dir_entry *proc_dir;	/* proc/uislib/vbus/<x> */

	struct proc_dir_entry *proc_info;	/* proc/uislib/vbus/<x>/info */

	char name[25];

	char partition_name[99];

	struct bus_info *next;

	u8 local_vnic;		/* 1 if local vnic created internally

				 * by IOVM; 0 otherwise... */

};

struct sn_list_entry {

	struct uisscsi_dest pdest;	/* scsi bus, target, lun for

					 * phys disk */

	u8 sernum[MAX_SERIAL_NUM];	/* serial num of physical

					 * disk.. The length is always

					 * MAX_SERIAL_NUM, padded with

					 * spaces */

	struct sn_list_entry *next;

};

/*

 * IO messages sent to UisnicControlChanFunc & UissdControlChanFunc by

 * code that processes the ControlVm channel messages.

 */

enum iopart_msg_type {

	IOPART_ADD_VNIC,

	IOPART_DEL_VNIC,

	IOPART_DEL_ALL_VNICS,

	IOPART_ADD_VHBA,

	IOPART_ADD_VDISK,

	IOPART_DEL_VHBA,

	IOPART_DEL_VDISK,

	IOPART_DEL_ALL_VDISKS_FOR_VHBA,

	IOPART_DEL_ALL_VHBAS,

	IOPART_ATTACH_PHBA,

	IOPART_DETACH_PHBA,	/* 10 */

	IOPART_ATTACH_PNIC,

	IOPART_DETACH_PNIC,

	IOPART_DETACH_VHBA,

	IOPART_DETACH_VNIC,

	IOPART_PAUSE_VDISK,

	IOPART_RESUME_VDISK,

	IOPART_ADD_DEVICE,	/* add generic device */

	IOPART_DEL_DEVICE,	/* del generic device */

};

struct add_virt_iopart {

	void *chanptr;		/* pointer to data channel */

	u64 guest_handle;	/* used to convert guest physical

				 * address to real physical address

				 * for DMA, for ex. */

	u64 recv_bus_irq_handle;	/* used to register to receive

					 * bus level interrupts. */

	struct irq_info intr;	/* contains recv & send

					 * interrupt info */

	/* recvInterruptHandle is used to register to receive

	* interrupts on the data channel. Used by GuestLinux/Windows

	* IO drivers to connect to interrupt.  sendInterruptHandle is

	* used by IOPart drivers as parameter to

	* Issue_VMCALL_IO_QUEUE_TRANSITION to interrupt thread in

	* guest linux/windows IO drivers when data channel queue for

	* vhba/vnic goes from EMPTY to NON-EMPTY. */

	struct switch_info *swtch;	/* pointer to the virtual

					 * switch to which the vnic is

					 * connected */

	u8 use_g2g_copy;	/* Used to determine if a virtual HBA

				 * needs to use G2G copy. */

	u8 filler[7];

	u32 bus_no;

	u32 dev_no;

	char *params;

	ulong params_bytes;

};

struct add_vdisk_iopart {

	void *chanptr;		      /* pointer to data channel */

	int implicit;

	struct uisscsi_dest vdest;    /* scsi bus, target, lun for virt disk */

	struct uisscsi_dest pdest;    /* scsi bus, target, lun for phys disk */

	u8 sernum[MAX_SERIAL_NUM];    /* serial num of physical disk */

	u32 serlen;		      /* length of serial num */

};

struct del_vdisk_iopart {

	void *chanptr;		     /* pointer to data channel */

	struct uisscsi_dest vdest;   /* scsi bus, target, lun for virt disk */

};

struct del_virt_iopart {

	void *chanptr;		     /* pointer to data channel */

};

struct det_virt_iopart {	     /* detach internal port */

	void *chanptr;		     /* pointer to data channel */

	struct switch_info *swtch;

};

struct paures_vdisk_iopart {

	void *chanptr;		     /* pointer to data channel */

	struct uisscsi_dest vdest;   /* scsi bus, target, lun for virt disk */

};

struct add_switch_iopart {	     /* add switch */

	struct switch_info *swtch;

	char *params;

	ulong params_bytes;

};

struct del_switch_iopart {	     /* destroy switch */

	struct switch_info *swtch;

};

struct io_msgs {

	enum iopart_msg_type msgtype;

	/* additional params needed by some messages */

	union {

		struct add_virt_iopart add_vhba;

		struct add_virt_iopart add_vnic;

		struct add_vdisk_iopart add_vdisk;

		struct del_virt_iopart del_vhba;

		struct del_virt_iopart del_vnic;

		struct det_virt_iopart det_vhba;

		struct det_virt_iopart det_vnic;

		struct del_vdisk_iopart del_vdisk;

		struct del_virt_iopart del_all_vdisks_for_vhba;

		struct add_virt_iopart add_device;

		struct del_virt_iopart del_device;

		struct det_virt_iopart det_intport;

		struct add_switch_iopart add_switch;

		struct del_switch_iopart del_switch;

		struct extport_info *ext_port;	/* for attach or detach

						 * pnic/generic delete all

						 * vhbas/allvnics need no

						 * parameters */

		struct paures_vdisk_iopart paures_vdisk;

	};

};

/*

* Guest messages sent to VirtControlChanFunc by code that processes

* the ControlVm channel messages.

*/

enum guestpart_msg_type {

	GUEST_ADD_VBUS,

	GUEST_ADD_VHBA,

	GUEST_ADD_VNIC,

	GUEST_DEL_VBUS,

	GUEST_DEL_VHBA,

	GUEST_DEL_VNIC,

	GUEST_DEL_ALL_VHBAS,

	GUEST_DEL_ALL_VNICS,

	GUEST_DEL_ALL_VBUSES,	/* deletes all vhbas & vnics on all

				 * buses and deletes all buses */

	GUEST_PAUSE_VHBA,

	GUEST_PAUSE_VNIC,

	GUEST_RESUME_VHBA,

	GUEST_RESUME_VNIC

};

struct add_vbus_guestpart {

	void __iomem *chanptr;		/* pointer to data channel for bus -

					 * NOT YET USED */

	u32 bus_no;		/* bus number to be created/deleted */

	u32 dev_count;	/* max num of devices on bus */

	uuid_le bus_uuid;	/* indicates type of bus */

	uuid_le instance_uuid;	/* instance guid for device */

};

struct del_vbus_guestpart {

	u32 bus_no;		/* bus number to be deleted */

	/* once we start using the bus's channel, add can dump busNo

	* into the channel header and then delete will need only one

	* parameter, chanptr. */

};

struct add_virt_guestpart {

	void __iomem *chanptr;		/* pointer to data channel */

	u32 bus_no;		/* bus number for the operation */

	u32 device_no;		/* number of device on the bus */

	uuid_le instance_uuid;	/* instance guid for device */

	struct irq_info intr;	/* recv/send interrupt info */

	/* recvInterruptHandle contains info needed in order to

	 * register to receive interrupts on the data channel.

	 * sendInterruptHandle contains handle which is provided to

	 * monitor VMCALL that will cause an interrupt to be generated

	 * for the other end.

	 */

};

struct pause_virt_guestpart {

	void __iomem *chanptr;		/* pointer to data channel */

};

struct resume_virt_guestpart {

	void __iomem *chanptr;		/* pointer to data channel */

};

struct del_virt_guestpart {

	void __iomem *chanptr;		/* pointer to data channel */

};

struct init_chipset_guestpart {

	u32 bus_count;		/* indicates the max number of busses */

	u32 switch_count;	/* indicates the max number of switches */

};

struct guest_msgs {

	enum guestpart_msg_type msgtype;

	/* additional params needed by messages */

	union {

		struct add_vbus_guestpart add_vbus;

		struct add_virt_guestpart add_vhba;

		struct add_virt_guestpart add_vnic;

		struct pause_virt_guestpart pause_vhba;

		struct pause_virt_guestpart pause_vnic;

		struct resume_virt_guestpart resume_vhba;

		struct resume_virt_guestpart resume_vnic;

		struct del_vbus_guestpart del_vbus;

		struct del_virt_guestpart del_vhba;

		struct del_virt_guestpart del_vnic;

		struct del_vbus_guestpart del_all_vhbas;

		struct del_vbus_guestpart del_all_vnics;

		/* del_all_vbuses needs no parameters */

	};

	struct init_chipset_guestpart init_chipset;

};

#endif				/* __UISQUEUE_H__ */

/* uisthread.h

 *

 * Copyright (C) 2010 - 2013 UNISYS CORPORATION

 * All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or (at

 * your option) any later version.

 *

 * 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.

 */

/*****************************************************************************/

/* Unisys thread utilities header                                            */

/*****************************************************************************/

#ifndef __UISTHREAD_H__

#define __UISTHREAD_H__

#include "linux/completion.h"

struct uisthread_info {

	struct task_struct *task;

	int id;

	struct completion has_stopped;

};

/* returns 0 for failure, 1 for success */

int uisthread_start(

	struct uisthread_info *thrinfo,

	int (*threadfn)(void *),

	void *thrcontext,

	char *name);

void uisthread_stop(struct uisthread_info *thrinfo);

#endif /* __UISTHREAD_H__ */

/* uisutils.h

 *

 * Copyright (C) 2010 - 2013 UNISYS CORPORATION

 * All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or (at

 * your option) any later version.

 *

 * 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.

 */

/*

 * Unisys Virtual HBA utilities header

 */

#ifndef __UISUTILS__H__

#define __UISUTILS__H__

#include <linux/string.h>

#include <linux/io.h>

#include <linux/sched.h>

#include <linux/gfp.h>

#include <linux/uuid.h>

#include <linux/if_ether.h>

#include "vmcallinterface.h"

#include "channel.h"

#include "uisthread.h"

#include "uisqueue.h"

#include "vbusdeviceinfo.h"

#include <linux/atomic.h>

/* This is the MAGIC number stuffed by virthba in host->this_id. Used to

 * identify virtual hbas.

 */

#define UIS_MAGIC_VHBA 707

/* global function pointers that act as callback functions into

 * uisnicmod, uissdmod, and virtpcimod

 */

extern int (*uisnic_control_chan_func)(struct io_msgs *);

extern int (*uissd_control_chan_func)(struct io_msgs *);

extern int (*virt_control_chan_func)(struct guest_msgs *);

/* Return values of above callback functions: */

#define CCF_ERROR        0	/* completed and failed */

#define CCF_OK           1	/* completed successfully */

#define CCF_PENDING      2	/* operation still pending */

extern atomic_t uisutils_registered_services;

struct req_handler_info {

	uuid_le switch_uuid;

	int (*controlfunc)(struct io_msgs *);

	unsigned long min_channel_bytes;

	int (*server_channel_ok)(unsigned long channel_bytes);

	int (*server_channel_init)(void *x, unsigned char *client_str,

				   u32 client_str_len, u64 bytes);

	char switch_type_name[99];

	struct list_head list_link;	/* links into ReqHandlerInfo_list */

};

struct req_handler_info *req_handler_find(uuid_le switch_uuid);

#define uislib_ioremap_cache(addr, size) \

	dbg_ioremap_cache(addr, size, __FILE__, __LINE__)

static inline void __iomem *

dbg_ioremap_cache(u64 addr, unsigned long size, char *file, int line)

{

	void __iomem *new;

	new = ioremap_cache(addr, size);

	return new;

}

#define uislib_ioremap(addr, size) dbg_ioremap(addr, size, __FILE__, __LINE__)

static inline void *

dbg_ioremap(u64 addr, unsigned long size, char *file, int line)

{

	void *new;

	new = ioremap(addr, size);

	return new;

}

#define uislib_iounmap(addr) dbg_iounmap(addr, __FILE__, __LINE__)

static inline void

dbg_iounmap(void __iomem *addr, char *file, int line)

{

	iounmap(addr);

}

#define PROC_READ_BUFFER_SIZE 131072	/* size of the buffer to allocate to

					 * hold all of /proc/XXX/info */

int uisutil_add_proc_line_ex(int *total, char **buffer, int *buffer_remaining,

			     char *format, ...);

int uisctrl_register_req_handler(int type, void *fptr,

			struct ultra_vbus_deviceinfo *chipset_driver_info);

unsigned char *util_map_virt(struct phys_info *sg);

void util_unmap_virt(struct phys_info *sg);

unsigned char *util_map_virt_atomic(struct phys_info *sg);

void util_unmap_virt_atomic(void *buf);

int uislib_client_inject_add_bus(u32 bus_no, uuid_le inst_uuid,

				 u64 channel_addr, ulong n_channel_bytes);

int  uislib_client_inject_del_bus(u32 bus_no);

int uislib_client_inject_add_vhba(u32 bus_no, u32 dev_no,

				  u64 phys_chan_addr, u32 chan_bytes,

				  int is_test_addr, uuid_le inst_uuid,

				  struct irq_info *intr);

int  uislib_client_inject_pause_vhba(u32 bus_no, u32 dev_no);

int  uislib_client_inject_resume_vhba(u32 bus_no, u32 dev_no);

int uislib_client_inject_del_vhba(u32 bus_no, u32 dev_no);

int uislib_client_inject_add_vnic(u32 bus_no, u32 dev_no,

				  u64 phys_chan_addr, u32 chan_bytes,

				  int is_test_addr, uuid_le inst_uuid,

				  struct irq_info *intr);

int uislib_client_inject_pause_vnic(u32 bus_no, u32 dev_no);

int uislib_client_inject_resume_vnic(u32 bus_no, u32 dev_no);

int uislib_client_inject_del_vnic(u32 bus_no, u32 dev_no);

#ifdef STORAGE_CHANNEL

u64 uislib_storage_channel(int client_id);

#endif

int uislib_get_owned_pdest(struct uisscsi_dest *pdest);

int uislib_send_event(enum controlvm_id id,

		      struct controlvm_message_packet *event);

/* structure used by vhba & vnic to keep track of queue & thread info */

struct chaninfo {

	struct uisqueue_info *queueinfo;

	/* this specifies the queue structures for a channel */

	/* ALLOCATED BY THE OTHER END - WE JUST GET A POINTER TO THE MEMORY */

	spinlock_t insertlock;

	/* currently used only in virtnic when sending data to uisnic */

	/* to synchronize the inserts into the signal queue */

	struct uisthread_info threadinfo;

	/* this specifies the thread structures used by the thread that */

	/* handles this channel */

};

/* this is the wait code for all the threads - it is used to get

* something from a queue choices: wait_for_completion_interruptible,

* _timeout, interruptible_timeout

*/

#define UIS_THREAD_WAIT_MSEC(x) { \

	set_current_state(TASK_INTERRUPTIBLE); \

	schedule_timeout(msecs_to_jiffies(x)); \

}

#define UIS_THREAD_WAIT_USEC(x) { \

	set_current_state(TASK_INTERRUPTIBLE); \

	schedule_timeout(usecs_to_jiffies(x)); \

}

#define UIS_THREAD_WAIT UIS_THREAD_WAIT_MSEC(5)

#define UIS_THREAD_WAIT_SEC(x) { \

	set_current_state(TASK_INTERRUPTIBLE); \

	schedule_timeout((x)*HZ); \

}

/* This is a hack until we fix IOVM to initialize the channel header

 * correctly at DEVICE_CREATE time, INSTEAD OF waiting until

 * DEVICE_CONFIGURE time.

 */

static inline void

wait_for_valid_guid(uuid_le __iomem *guid)

{

	uuid_le tmpguid;

	while (1) {

		memcpy_fromio((void *)&tmpguid,

			      (void __iomem *)guid, sizeof(uuid_le));

		if (uuid_le_cmp(tmpguid, NULL_UUID_LE) != 0)

			break;

		UIS_THREAD_WAIT_SEC(5);

	}

}

static inline unsigned int

issue_vmcall_io_controlvm_addr(u64 *control_addr, u32 *control_bytes)

{

	struct vmcall_io_controlvm_addr_params params;

	int result = VMCALL_SUCCESS;

	u64 physaddr;

	physaddr = virt_to_phys(&params);

	ISSUE_IO_VMCALL(VMCALL_IO_CONTROLVM_ADDR, physaddr, result);

	if (VMCALL_SUCCESSFUL(result)) {

		*control_addr = params.address;

		*control_bytes = params.channel_bytes;

	}

	return result;

}

static inline unsigned int issue_vmcall_io_diag_addr(u64 *diag_channel_addr)

{

	struct vmcall_io_diag_addr_params params;

	int result = VMCALL_SUCCESS;

	u64 physaddr;

	physaddr = virt_to_phys(&params);

	ISSUE_IO_VMCALL(VMCALL_IO_DIAG_ADDR, physaddr, result);

	if (VMCALL_SUCCESSFUL(result))

		*diag_channel_addr = params.address;

	return result;

}

static inline unsigned int issue_vmcall_io_visorserial_addr(u64 *channel_addr)

{

	struct vmcall_io_visorserial_addr_params params;

	int result = VMCALL_SUCCESS;

	u64 physaddr;

	physaddr = virt_to_phys(&params);

	ISSUE_IO_VMCALL(VMCALL_IO_VISORSERIAL_ADDR, physaddr, result);

	if (VMCALL_SUCCESSFUL(result))

		*channel_addr = params.address;

	return result;

}

static inline s64 issue_vmcall_query_guest_virtual_time_offset(void)

{

	u64 result = VMCALL_SUCCESS;

	u64 physaddr = 0;

	ISSUE_IO_VMCALL(VMCALL_QUERY_GUEST_VIRTUAL_TIME_OFFSET, physaddr,

			result);

	return result;

}

struct log_info_t {

	unsigned long long last_cycles;

	unsigned long long delta_sum[64];

	unsigned long long delta_cnt[64];

	unsigned long long max_delta[64];

	unsigned long long min_delta[64];

};

static inline int issue_vmcall_update_physical_time(u64 adjustment)

{

	int result = VMCALL_SUCCESS;

	ISSUE_IO_VMCALL(VMCALL_UPDATE_PHYSICAL_TIME, adjustment, result);

	return result;

}

static inline unsigned int issue_vmcall_channel_mismatch(const char *chname,

			      const char *item_name, u32 line_no,

			      const char *path_n_fn)

{

	struct vmcall_channel_version_mismatch_params params;

	int result = VMCALL_SUCCESS;

	u64 physaddr;

	char *last_slash = NULL;

	strlcpy(params.chname, chname, sizeof(params.chname));

	strlcpy(params.item_name, item_name, sizeof(params.item_name));

	params.line_no = line_no;

	last_slash = strrchr(path_n_fn, '/');

	if (last_slash != NULL) {

		last_slash++;

		strlcpy(params.file_name, last_slash, sizeof(params.file_name));

	} else

		strlcpy(params.file_name,

			"Cannot determine source filename",

			sizeof(params.file_name));

	physaddr = virt_to_phys(&params);

	ISSUE_IO_VMCALL(VMCALL_CHANNEL_VERSION_MISMATCH, physaddr, result);

	return result;

}

#define UIS_DAEMONIZE(nam)

void uislib_enable_channel_interrupts(u32 bus_no, u32 dev_no,

				      int (*interrupt)(void *),

				      void *interrupt_context);

void uislib_disable_channel_interrupts(u32 bus_no, u32 dev_no);

void uislib_force_channel_interrupt(u32 bus_no, u32 dev_no);

#endif /* __UISUTILS__H__ */

#include <linux/uuid.h>

#include <linux/crash_dump.h>

#include "channel_guid.h"

#include "controlvmchannel.h"

#include "controlvmcompletionstatus.h"

#include "guestlinuxdebug.h"

#include "periodic_work.h"

#include "uisutils.h"

#include "version.h"

#include "visorbus.h"

#include "visorbus_private.h"

#include "vmcallinterface.h"

#define CURRENT_FILE_PC VISOR_CHIPSET_PC_visorchipset_main_c

	return true;

}

static inline unsigned int

issue_vmcall_io_controlvm_addr(u64 *control_addr, u32 *control_bytes)

{

	struct vmcall_io_controlvm_addr_params params;

	int result = VMCALL_SUCCESS;

	u64 physaddr;

	physaddr = virt_to_phys(&params);

	ISSUE_IO_VMCALL(VMCALL_IO_CONTROLVM_ADDR, physaddr, result);

	if (VMCALL_SUCCESSFUL(result)) {

		*control_addr = params.address;

		*control_bytes = params.channel_bytes;

	}

	return result;

}

static u64 controlvm_get_channel_address(void)

{

	u64 addr = 0;

	return 0;

}

static inline s64 issue_vmcall_query_guest_virtual_time_offset(void)

{

	u64 result = VMCALL_SUCCESS;

	u64 physaddr = 0;