[net-next-2.6.git] / drivers / staging / hv / Hv.c

/*
 *
 * Copyright (c) 2009, Microsoft Corporation.
 *
 * 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 it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place - Suite 330, Boston, MA 02111-1307 USA.
 *
 * Authors:
 *   Haiyang Zhang <haiyangz@microsoft.com>
 *   Hank Janssen  <hjanssen@microsoft.com>
 *
 */


#include "include/logging.h"
#include "VmbusPrivate.h"

//
// Globals
//

// The one and only
HV_CONTEXT gHvContext={
	.SynICInitialized = FALSE,
	.HypercallPage = NULL,
	.SignalEventParam = NULL,
	.SignalEventBuffer = NULL,
};


/*++

Name:
	HvQueryHypervisorPresence()

Description:
	Query the cpuid for presense of windows hypervisor

--*/
static int
HvQueryHypervisorPresence (
    void
    )
{
    unsigned int eax;
    unsigned int ebx;
    unsigned int ecx;
    unsigned int edx;
    unsigned int op;

    eax = 0;
    ebx = 0;
    ecx = 0;
    edx = 0;
    op = HvCpuIdFunctionVersionAndFeatures;
    do_cpuid(op, &eax, &ebx, &ecx, &edx);

	return (ecx & HV_PRESENT_BIT);
}


/*++

Name:
	HvQueryHypervisorInfo()

Description:
	Get version info of the windows hypervisor

--*/
static int
HvQueryHypervisorInfo (
    void
    )
{
    unsigned int eax;
    unsigned int ebx;
    unsigned int ecx;
    unsigned int edx;
    unsigned int maxLeaf;
    unsigned int op;

    //
    // Its assumed that this is called after confirming that Viridian is present.
    // Query id and revision.
    //

    eax = 0;
    ebx = 0;
    ecx = 0;
    edx = 0;
    op = HvCpuIdFunctionHvVendorAndMaxFunction;
    do_cpuid(op, &eax, &ebx, &ecx, &edx);

    DPRINT_INFO(VMBUS, "Vendor ID: %c%c%c%c%c%c%c%c%c%c%c%c",
           (ebx & 0xFF),
           ((ebx >> 8) & 0xFF),
           ((ebx >> 16) & 0xFF),
           ((ebx >> 24) & 0xFF),
           (ecx & 0xFF),
           ((ecx >> 8) & 0xFF),
           ((ecx >> 16) & 0xFF),
           ((ecx >> 24) & 0xFF),
           (edx & 0xFF),
           ((edx >> 8) & 0xFF),
           ((edx >> 16) & 0xFF),
           ((edx >> 24) & 0xFF));

    maxLeaf = eax;
    eax = 0;
    ebx = 0;
    ecx = 0;
    edx = 0;
    op = HvCpuIdFunctionHvInterface;
    do_cpuid(op, &eax, &ebx, &ecx, &edx);

    DPRINT_INFO(VMBUS, "Interface ID: %c%c%c%c",
           (eax & 0xFF),
           ((eax >> 8) & 0xFF),
           ((eax >> 16) & 0xFF),
           ((eax >> 24) & 0xFF));

	 if (maxLeaf >= HvCpuIdFunctionMsHvVersion) {
        eax = 0;
        ebx = 0;
        ecx = 0;
        edx = 0;
        op = HvCpuIdFunctionMsHvVersion;
        do_cpuid(op, &eax, &ebx, &ecx, &edx);
        DPRINT_INFO(VMBUS, "OS Build:%d-%d.%d-%d-%d.%d",
               eax,
               ebx >> 16,
               ebx & 0xFFFF,
               ecx,
               edx >> 24,
               edx & 0xFFFFFF);
    }
    return maxLeaf;
}


/*++

Name:
	HvDoHypercall()

Description:
	Invoke the specified hypercall

--*/
static UINT64
HvDoHypercall (
    UINT64  Control,
    void*   Input,
    void*   Output
    )
{
#ifdef CONFIG_X86_64
    UINT64 hvStatus=0;
    UINT64 inputAddress = (Input)? GetPhysicalAddress(Input) : 0;
	UINT64 outputAddress = (Output)? GetPhysicalAddress(Output) : 0;
    volatile void* hypercallPage = gHvContext.HypercallPage;

    DPRINT_DBG(VMBUS, "Hypercall <control %llx input phys %llx virt %p output phys %llx virt %p hypercall %p>",
		Control,
		inputAddress,
		Input,
		outputAddress,
		Output,
		hypercallPage);

	__asm__ __volatile__ ("mov %0, %%r8" : : "r" (outputAddress):  "r8");
	__asm__ __volatile__ ("call *%3" : "=a"(hvStatus): "c" (Control), "d" (inputAddress), "m" (hypercallPage));

    DPRINT_DBG(VMBUS, "Hypercall <return %llx>",  hvStatus);

    return hvStatus;

#else

    UINT32 controlHi = Control >> 32;
    UINT32 controlLo = Control & 0xFFFFFFFF;
    UINT32 hvStatusHi = 1;
    UINT32 hvStatusLo = 1;
    UINT64 inputAddress = (Input) ? GetPhysicalAddress(Input) : 0;
    UINT32 inputAddressHi = inputAddress >> 32;
    UINT32 inputAddressLo = inputAddress & 0xFFFFFFFF;
	UINT64 outputAddress = (Output) ?GetPhysicalAddress(Output) : 0;
    UINT32 outputAddressHi = outputAddress >> 32;
    UINT32 outputAddressLo = outputAddress & 0xFFFFFFFF;
    volatile void* hypercallPage = gHvContext.HypercallPage;

    DPRINT_DBG(VMBUS, "Hypercall <control %llx input %p output %p>",
		Control,
		Input,
		Output);

	__asm__ __volatile__ ("call *%8" : "=d"(hvStatusHi), "=a"(hvStatusLo) : "d" (controlHi), "a" (controlLo), "b" (inputAddressHi), "c" (inputAddressLo), "D"(outputAddressHi), "S"(outputAddressLo), "m" (hypercallPage));


    DPRINT_DBG(VMBUS, "Hypercall <return %llx>",  hvStatusLo | ((UINT64)hvStatusHi << 32));

    return (hvStatusLo | ((UINT64)hvStatusHi << 32));
#endif // x86_64
}

/*++

Name:
	HvInit()

Description:
	Main initialization routine. This routine must be called
	before any other routines in here are called

--*/
static int
HvInit (
    void
    )
{
	int ret=0;
    int maxLeaf;
	HV_X64_MSR_HYPERCALL_CONTENTS hypercallMsr;
	void* virtAddr=0;
	ULONG_PTR physAddr=0;

	DPRINT_ENTER(VMBUS);

	memset(gHvContext.synICEventPage, 0, sizeof(HANDLE)*MAX_NUM_CPUS);
	memset(gHvContext.synICMessagePage, 0, sizeof(HANDLE)*MAX_NUM_CPUS);

	if (!HvQueryHypervisorPresence())
	{
		DPRINT_ERR(VMBUS, "No Windows hypervisor detected!!");
		goto Cleanup;
	}

	DPRINT_INFO(VMBUS, "Windows hypervisor detected! Retrieving more info...");

    maxLeaf = HvQueryHypervisorInfo();
    //HvQueryHypervisorFeatures(maxLeaf);

	// Determine if we are running on xenlinux (ie x2v shim) or native linux
	gHvContext.GuestId = ReadMsr(HV_X64_MSR_GUEST_OS_ID);

	if (gHvContext.GuestId == 0)
	{
		// Write our OS info
		WriteMsr(HV_X64_MSR_GUEST_OS_ID, HV_LINUX_GUEST_ID);

		gHvContext.GuestId = HV_LINUX_GUEST_ID;
	}

	// See if the hypercall page is already set
	hypercallMsr.AsUINT64 = ReadMsr(HV_X64_MSR_HYPERCALL);

	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
	{
		// Allocate the hypercall page memory
		//virtAddr = PageAlloc(1);
		virtAddr = VirtualAllocExec(PAGE_SIZE);

		if (!virtAddr)
		{
			DPRINT_ERR(VMBUS, "unable to allocate hypercall page!!");
			goto Cleanup;
		}

		hypercallMsr.Enable = 1;
		//hypercallMsr.GuestPhysicalAddress = Logical2PhysicalAddr(virtAddr) >> PAGE_SHIFT;
		hypercallMsr.GuestPhysicalAddress = Virtual2Physical(virtAddr) >> PAGE_SHIFT;
		WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);

        // Confirm that hypercall page did get setup.
		hypercallMsr.AsUINT64 = 0;
		hypercallMsr.AsUINT64 = ReadMsr(HV_X64_MSR_HYPERCALL);

		if (!hypercallMsr.Enable)
		{
			DPRINT_ERR(VMBUS, "unable to set hypercall page!!");
			goto Cleanup;
		}

		gHvContext.HypercallPage = virtAddr;
	}
	else
	{
		DPRINT_ERR(VMBUS, "Unknown guest id (0x%llx)!!", gHvContext.GuestId);
		goto Cleanup;
	}

    DPRINT_INFO(VMBUS, "Hypercall page VA=0x%08x, PA=0x%08x",
               (unsigned long)gHvContext.HypercallPage,
               (unsigned long)hypercallMsr.GuestPhysicalAddress << PAGE_SHIFT);

	// Setup the global signal event param for the signal event hypercall
	gHvContext.SignalEventBuffer = MemAlloc(sizeof(HV_INPUT_SIGNAL_EVENT_BUFFER));
	if (!gHvContext.SignalEventBuffer)
	{
		goto Cleanup;
	}

	gHvContext.SignalEventParam = (PHV_INPUT_SIGNAL_EVENT)(ALIGN_UP((ULONG_PTR)gHvContext.SignalEventBuffer, HV_HYPERCALL_PARAM_ALIGN));
	gHvContext.SignalEventParam->ConnectionId.AsUINT32 = 0;
	gHvContext.SignalEventParam->ConnectionId.u.Id = VMBUS_EVENT_CONNECTION_ID;
	gHvContext.SignalEventParam->FlagNumber = 0;
	gHvContext.SignalEventParam->RsvdZ = 0;

    //DPRINT_DBG(VMBUS, "My id %llu", HvGetCurrentPartitionId());

	DPRINT_EXIT(VMBUS);

    return ret;

Cleanup:
	if (virtAddr)
	{
		if (hypercallMsr.Enable)
		{
			hypercallMsr.AsUINT64 = 0;
			WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
		}

		VirtualFree(virtAddr);
	}
	ret = -1;
	DPRINT_EXIT(VMBUS);

	return ret;
}


/*++

Name:
	HvCleanup()

Description:
	Cleanup routine. This routine is called normally during driver unloading or exiting.

--*/
void
HvCleanup (
    void
    )
{
	HV_X64_MSR_HYPERCALL_CONTENTS hypercallMsr;

	DPRINT_ENTER(VMBUS);

	if (gHvContext.SignalEventBuffer)
	{
		MemFree(gHvContext.SignalEventBuffer);
		gHvContext.SignalEventBuffer = NULL;
		gHvContext.SignalEventParam = NULL;
	}

	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
	{
		if (gHvContext.HypercallPage)
		{
			hypercallMsr.AsUINT64 = 0;
			WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
			VirtualFree(gHvContext.HypercallPage);
			gHvContext.HypercallPage = NULL;
		}
	}

	DPRINT_EXIT(VMBUS);

}


/*++

Name:
	HvPostMessage()

Description:
	Post a message using the hypervisor message IPC. This
	involves a hypercall.

--*/
HV_STATUS
HvPostMessage(
	HV_CONNECTION_ID connectionId,
	HV_MESSAGE_TYPE  messageType,
	void *            payload,
	SIZE_T           payloadSize
	)
{
	struct alignedInput {
		UINT64					alignment8;
		HV_INPUT_POST_MESSAGE	msg;
	};

	PHV_INPUT_POST_MESSAGE alignedMsg;
	HV_STATUS status;
	ULONG_PTR addr;

	if (payloadSize > HV_MESSAGE_PAYLOAD_BYTE_COUNT)
	{
		return -1;
	}

	addr = (ULONG_PTR)MemAllocAtomic(sizeof(struct alignedInput));

	if (!addr)
	{
		return -1;
	}

	alignedMsg = (PHV_INPUT_POST_MESSAGE)(ALIGN_UP(addr, HV_HYPERCALL_PARAM_ALIGN));

	alignedMsg->ConnectionId = connectionId;
	alignedMsg->MessageType = messageType;
	alignedMsg->PayloadSize = payloadSize;
	memcpy((void*)alignedMsg->Payload, payload, payloadSize);

	status = HvDoHypercall(HvCallPostMessage, alignedMsg, 0) & 0xFFFF;

	MemFree((void*)addr);

	return status;
}


/*++

Name:
	HvSignalEvent()

Description:
	Signal an event on the specified connection using the hypervisor event IPC. This
	involves a hypercall.

--*/
HV_STATUS
HvSignalEvent(
	)
{
	HV_STATUS status;

	status = HvDoHypercall(HvCallSignalEvent, gHvContext.SignalEventParam, 0) & 0xFFFF;

	return status;
}


/*++

Name:
	HvSynicInit()

Description:
	Initialize the Synthethic Interrupt Controller. If it is already initialized by
	another entity (ie x2v shim), we need to retrieve the initialized message and event pages.
	Otherwise, we create and initialize the message and event pages.

--*/
int
HvSynicInit (
	UINT32 irqVector
	)
{
	UINT64			version;
	HV_SYNIC_SIMP	simp;
	HV_SYNIC_SIEFP	siefp;
    HV_SYNIC_SINT	sharedSint;
	HV_SYNIC_SCONTROL sctrl;
	UINT64			guestID;
	int ret=0;

	DPRINT_ENTER(VMBUS);

	if (!gHvContext.HypercallPage)
	{
		DPRINT_EXIT(VMBUS);
		return ret;
	}

	// Check the version
	version = ReadMsr(HV_X64_MSR_SVERSION);

	DPRINT_INFO(VMBUS, "SynIC version: %llx", version);

	// TODO: Handle SMP
	if (gHvContext.GuestId == HV_XENLINUX_GUEST_ID)
	{
		DPRINT_INFO(VMBUS, "Skipping SIMP and SIEFP setup since it is already set.");

		simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
		siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);

		DPRINT_DBG(VMBUS, "Simp: %llx, Sifep: %llx", simp.AsUINT64, siefp.AsUINT64);

		// Determine if we are running on xenlinux (ie x2v shim) or native linux
		guestID = ReadMsr(HV_X64_MSR_GUEST_OS_ID);

		if (guestID == HV_LINUX_GUEST_ID)
		{
			gHvContext.synICMessagePage[0] = GetVirtualAddress(simp.BaseSimpGpa << PAGE_SHIFT);
			gHvContext.synICEventPage[0] = GetVirtualAddress(siefp.BaseSiefpGpa << PAGE_SHIFT);
		}
		else
		{
			DPRINT_ERR(VMBUS, "unknown guest id!!");
			goto Cleanup;
		}
		DPRINT_DBG(VMBUS, "MAPPED: Simp: %p, Sifep: %p", gHvContext.synICMessagePage[0], gHvContext.synICEventPage[0]);
	}
	else
	{
		gHvContext.synICMessagePage[0] = PageAlloc(1);
		if (gHvContext.synICMessagePage[0] == NULL)
		{
			DPRINT_ERR(VMBUS, "unable to allocate SYNIC message page!!");
			goto Cleanup;
		}

		gHvContext.synICEventPage[0] = PageAlloc(1);
		if (gHvContext.synICEventPage[0] == NULL)
		{
			DPRINT_ERR(VMBUS, "unable to allocate SYNIC event page!!");
			goto Cleanup;
		}

		//
		// Setup the Synic's message page
		//
		simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
		simp.SimpEnabled = 1;
		simp.BaseSimpGpa = GetPhysicalAddress(gHvContext.synICMessagePage[0]) >> PAGE_SHIFT;

		DPRINT_DBG(VMBUS, "HV_X64_MSR_SIMP msr set to: %llx", simp.AsUINT64);

		WriteMsr(HV_X64_MSR_SIMP, simp.AsUINT64);

		//
		// Setup the Synic's event page
		//
		siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);
		siefp.SiefpEnabled = 1;
		siefp.BaseSiefpGpa = GetPhysicalAddress(gHvContext.synICEventPage[0]) >> PAGE_SHIFT;

		DPRINT_DBG(VMBUS, "HV_X64_MSR_SIEFP msr set to: %llx", siefp.AsUINT64);

		WriteMsr(HV_X64_MSR_SIEFP, siefp.AsUINT64);
	}
	//
    // Setup the interception SINT.
    //
	//WriteMsr((HV_X64_MSR_SINT0 + HV_SYNIC_INTERCEPTION_SINT_INDEX),
    //             interceptionSint.AsUINT64);

    //
    // Setup the shared SINT.
    //
	sharedSint.AsUINT64 = ReadMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT);

	sharedSint.AsUINT64 = 0;
    sharedSint.Vector = irqVector; //HV_SHARED_SINT_IDT_VECTOR + 0x20;
    sharedSint.Masked = FALSE;
    sharedSint.AutoEoi = TRUE;

	DPRINT_DBG(VMBUS, "HV_X64_MSR_SINT1 msr set to: %llx", sharedSint.AsUINT64);

	WriteMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);

	// Enable the global synic bit
	sctrl.AsUINT64 = ReadMsr(HV_X64_MSR_SCONTROL);
	sctrl.Enable = 1;

    WriteMsr(HV_X64_MSR_SCONTROL, sctrl.AsUINT64);

	gHvContext.SynICInitialized = TRUE;

	DPRINT_EXIT(VMBUS);

	return ret;

Cleanup:
	ret = -1;

	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
	{
		if (gHvContext.synICEventPage[0])
		{
			PageFree(gHvContext.synICEventPage[0],1);
		}

		if (gHvContext.synICMessagePage[0])
		{
			PageFree(gHvContext.synICMessagePage[0], 1);
		}
	}

	DPRINT_EXIT(VMBUS);

	return ret;

}

/*++

Name:
	HvSynicCleanup()

Description:
	Cleanup routine for HvSynicInit().

--*/
void
HvSynicCleanup(
	void
	)
{
    HV_SYNIC_SINT	sharedSint;
	HV_SYNIC_SIMP	simp;
	HV_SYNIC_SIEFP	siefp;

	DPRINT_ENTER(VMBUS);

	if (!gHvContext.SynICInitialized)
	{
		DPRINT_EXIT(VMBUS);
		return;
	}

	sharedSint.AsUINT64 = ReadMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT);

	sharedSint.Masked = 1;

	// Disable the interrupt
    WriteMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);

	// Disable and free the resources only if we are running as native linux
	// since in xenlinux, we are sharing the resources with the x2v shim
	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
	{
		simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
		simp.SimpEnabled = 0;
		simp.BaseSimpGpa = 0;

		WriteMsr(HV_X64_MSR_SIMP, simp.AsUINT64);

		siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);
		siefp.SiefpEnabled = 0;
		siefp.BaseSiefpGpa = 0;

		WriteMsr(HV_X64_MSR_SIEFP, siefp.AsUINT64);

		PageFree(gHvContext.synICMessagePage[0], 1);
		PageFree(gHvContext.synICEventPage[0], 1);
	}

	DPRINT_EXIT(VMBUS);
}


// eof
Commit	Line	Data
3e7ee490 HJ	1	/*
	2	*
	3	* Copyright (c) 2009, Microsoft Corporation.
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms and conditions of the GNU General Public License,
	7	* version 2, as published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along with
	15	* this program; if not, write to the Free Software Foundation, Inc., 59 Temple
	16	* Place - Suite 330, Boston, MA 02111-1307 USA.
	17	*
	18	* Authors:
	19	* Haiyang Zhang <haiyangz@microsoft.com>
	20	* Hank Janssen <hjanssen@microsoft.com>
	21	*
	22	*/
	23
	24
09d50ff8	25	#include "include/logging.h"
3e7ee490 HJ	26	#include "VmbusPrivate.h"
	27
	28	//
	29	// Globals
	30	//
	31
	32	// The one and only
	33	HV_CONTEXT gHvContext={
	34	.SynICInitialized = FALSE,
	35	.HypercallPage = NULL,
	36	.SignalEventParam = NULL,
	37	.SignalEventBuffer = NULL,
	38	};
	39
	40
	41	/*++
	42
	43	Name:
	44	HvQueryHypervisorPresence()
	45
	46	Description:
	47	Query the cpuid for presense of windows hypervisor
	48
	49	--*/
	50	static int
	51	HvQueryHypervisorPresence (
	52	void
	53	)
	54	{
	55	unsigned int eax;
	56	unsigned int ebx;
	57	unsigned int ecx;
	58	unsigned int edx;
	59	unsigned int op;
	60
	61	eax = 0;
	62	ebx = 0;
	63	ecx = 0;
	64	edx = 0;
	65	op = HvCpuIdFunctionVersionAndFeatures;
	66	do_cpuid(op, &eax, &ebx, &ecx, &edx);
	67
	68	return (ecx & HV_PRESENT_BIT);
	69	}
	70
	71
	72	/*++
	73
	74	Name:
	75	HvQueryHypervisorInfo()
	76
	77	Description:
	78	Get version info of the windows hypervisor
	79
	80	--*/
	81	static int
	82	HvQueryHypervisorInfo (
	83	void
	84	)
	85	{
	86	unsigned int eax;
	87	unsigned int ebx;
	88	unsigned int ecx;
	89	unsigned int edx;
90	unsigned int maxLeaf;
91	unsigned int op;
92
93	//
94	// Its assumed that this is called after confirming that Viridian is present.
95	// Query id and revision.
96	//
97
98	eax = 0;
99	ebx = 0;
100	ecx = 0;
101	edx = 0;
102	op = HvCpuIdFunctionHvVendorAndMaxFunction;
103	do_cpuid(op, &eax, &ebx, &ecx, &edx);
104
105	DPRINT_INFO(VMBUS, "Vendor ID: %c%c%c%c%c%c%c%c%c%c%c%c",
106	(ebx & 0xFF),
107	((ebx >> 8) & 0xFF),
108	((ebx >> 16) & 0xFF),
109	((ebx >> 24) & 0xFF),
110	(ecx & 0xFF),
111	((ecx >> 8) & 0xFF),
112	((ecx >> 16) & 0xFF),
113	((ecx >> 24) & 0xFF),
114	(edx & 0xFF),
115	((edx >> 8) & 0xFF),
116	((edx >> 16) & 0xFF),
117	((edx >> 24) & 0xFF));
118
119	maxLeaf = eax;
120	eax = 0;
121	ebx = 0;
122	ecx = 0;
123	edx = 0;
124	op = HvCpuIdFunctionHvInterface;
125	do_cpuid(op, &eax, &ebx, &ecx, &edx);
126
127	DPRINT_INFO(VMBUS, "Interface ID: %c%c%c%c",
128	(eax & 0xFF),
129	((eax >> 8) & 0xFF),
130	((eax >> 16) & 0xFF),
131	((eax >> 24) & 0xFF));
132
133	if (maxLeaf >= HvCpuIdFunctionMsHvVersion) {
134	eax = 0;
135	ebx = 0;
136	ecx = 0;
137	edx = 0;
138	op = HvCpuIdFunctionMsHvVersion;
139	do_cpuid(op, &eax, &ebx, &ecx, &edx);
140	DPRINT_INFO(VMBUS, "OS Build:%d-%d.%d-%d-%d.%d",
141	eax,
142	ebx >> 16,
143	ebx & 0xFFFF,
144	ecx,
145	edx >> 24,
146	edx & 0xFFFFFF);
147	}
148	return maxLeaf;
149	}
150
151
152	/*++
153
154	Name:
155	HvDoHypercall()
156
157	Description:
158	Invoke the specified hypercall
159
160	--*/
161	static UINT64
162	HvDoHypercall (
163	UINT64 Control,
164	void* Input,
165	void* Output
166	)
167	{
530cf207	168	#ifdef CONFIG_X86_64
3e7ee490 HJ	169	UINT64 hvStatus=0;
	170	UINT64 inputAddress = (Input)? GetPhysicalAddress(Input) : 0;
	171	UINT64 outputAddress = (Output)? GetPhysicalAddress(Output) : 0;
	172	volatile void* hypercallPage = gHvContext.HypercallPage;
	173
	174	DPRINT_DBG(VMBUS, "Hypercall <control %llx input phys %llx virt %p output phys %llx virt %p hypercall %p>",
	175	Control,
	176	inputAddress,
	177	Input,
	178	outputAddress,
	179	Output,
	180	hypercallPage);
	181
	182	__asm__ __volatile__ ("mov %0, %%r8" : : "r" (outputAddress): "r8");
	183	__asm__ __volatile__ ("call *%3" : "=a"(hvStatus): "c" (Control), "d" (inputAddress), "m" (hypercallPage));
	184
	185	DPRINT_DBG(VMBUS, "Hypercall <return %llx>", hvStatus);
	186
	187	return hvStatus;
	188
	189	#else
	190
	191	UINT32 controlHi = Control >> 32;
	192	UINT32 controlLo = Control & 0xFFFFFFFF;
	193	UINT32 hvStatusHi = 1;
	194	UINT32 hvStatusLo = 1;
	195	UINT64 inputAddress = (Input) ? GetPhysicalAddress(Input) : 0;
	196	UINT32 inputAddressHi = inputAddress >> 32;
	197	UINT32 inputAddressLo = inputAddress & 0xFFFFFFFF;
	198	UINT64 outputAddress = (Output) ?GetPhysicalAddress(Output) : 0;
	199	UINT32 outputAddressHi = outputAddress >> 32;
	200	UINT32 outputAddressLo = outputAddress & 0xFFFFFFFF;
	201	volatile void* hypercallPage = gHvContext.HypercallPage;
	202
	203	DPRINT_DBG(VMBUS, "Hypercall <control %llx input %p output %p>",
	204	Control,
	205	Input,
	206	Output);
	207
	208	__asm__ __volatile__ ("call *%8" : "=d"(hvStatusHi), "=a"(hvStatusLo) : "d" (controlHi), "a" (controlLo), "b" (inputAddressHi), "c" (inputAddressLo), "D"(outputAddressHi), "S"(outputAddressLo), "m" (hypercallPage));
	209
	210
	211	DPRINT_DBG(VMBUS, "Hypercall <return %llx>", hvStatusLo \| ((UINT64)hvStatusHi << 32));
	212
	213	return (hvStatusLo \| ((UINT64)hvStatusHi << 32));
	214	#endif // x86_64
	215	}
	216
	217	/*++
	218
	219	Name:
	220	HvInit()
	221
	222	Description:
	223	Main initialization routine. This routine must be called
	224	before any other routines in here are called
	225
	226	--*/
	227	static int
	228	HvInit (
	229	void
	230	)
	231	{
	232	int ret=0;
233	int maxLeaf;
234	HV_X64_MSR_HYPERCALL_CONTENTS hypercallMsr;
235	void* virtAddr=0;
236	ULONG_PTR physAddr=0;
237
238	DPRINT_ENTER(VMBUS);
239
240	memset(gHvContext.synICEventPage, 0, sizeof(HANDLE)*MAX_NUM_CPUS);
241	memset(gHvContext.synICMessagePage, 0, sizeof(HANDLE)*MAX_NUM_CPUS);
242
243	if (!HvQueryHypervisorPresence())
244	{
245	DPRINT_ERR(VMBUS, "No Windows hypervisor detected!!");
246	goto Cleanup;
247	}
248
249	DPRINT_INFO(VMBUS, "Windows hypervisor detected! Retrieving more info...");
250
251	maxLeaf = HvQueryHypervisorInfo();
252	//HvQueryHypervisorFeatures(maxLeaf);
253
254	// Determine if we are running on xenlinux (ie x2v shim) or native linux
255	gHvContext.GuestId = ReadMsr(HV_X64_MSR_GUEST_OS_ID);
256
257	if (gHvContext.GuestId == 0)
258	{
259	// Write our OS info
260	WriteMsr(HV_X64_MSR_GUEST_OS_ID, HV_LINUX_GUEST_ID);
261
262	gHvContext.GuestId = HV_LINUX_GUEST_ID;
263	}
264
265	// See if the hypercall page is already set
266	hypercallMsr.AsUINT64 = ReadMsr(HV_X64_MSR_HYPERCALL);
267
268	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
269	{
270	// Allocate the hypercall page memory
271	//virtAddr = PageAlloc(1);
272	virtAddr = VirtualAllocExec(PAGE_SIZE);
273
274	if (!virtAddr)
275	{
276	DPRINT_ERR(VMBUS, "unable to allocate hypercall page!!");
277	goto Cleanup;
278	}
279
280	hypercallMsr.Enable = 1;
281	//hypercallMsr.GuestPhysicalAddress = Logical2PhysicalAddr(virtAddr) >> PAGE_SHIFT;
282	hypercallMsr.GuestPhysicalAddress = Virtual2Physical(virtAddr) >> PAGE_SHIFT;
283	WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
284
285	// Confirm that hypercall page did get setup.
286	hypercallMsr.AsUINT64 = 0;
287	hypercallMsr.AsUINT64 = ReadMsr(HV_X64_MSR_HYPERCALL);
288
289	if (!hypercallMsr.Enable)
290	{
291	DPRINT_ERR(VMBUS, "unable to set hypercall page!!");
292	goto Cleanup;
293	}
294
295	gHvContext.HypercallPage = virtAddr;
296	}
297	else
298	{
299	DPRINT_ERR(VMBUS, "Unknown guest id (0x%llx)!!", gHvContext.GuestId);
300	goto Cleanup;
301	}
302
303	DPRINT_INFO(VMBUS, "Hypercall page VA=0x%08x, PA=0x%08x",
304	(unsigned long)gHvContext.HypercallPage,
305	(unsigned long)hypercallMsr.GuestPhysicalAddress << PAGE_SHIFT);
306
307	// Setup the global signal event param for the signal event hypercall
308	gHvContext.SignalEventBuffer = MemAlloc(sizeof(HV_INPUT_SIGNAL_EVENT_BUFFER));
309	if (!gHvContext.SignalEventBuffer)
310	{
311	goto Cleanup;
312	}
313
314	gHvContext.SignalEventParam = (PHV_INPUT_SIGNAL_EVENT)(ALIGN_UP((ULONG_PTR)gHvContext.SignalEventBuffer, HV_HYPERCALL_PARAM_ALIGN));
315	gHvContext.SignalEventParam->ConnectionId.AsUINT32 = 0;
316	gHvContext.SignalEventParam->ConnectionId.u.Id = VMBUS_EVENT_CONNECTION_ID;
317	gHvContext.SignalEventParam->FlagNumber = 0;
318	gHvContext.SignalEventParam->RsvdZ = 0;
319
320	//DPRINT_DBG(VMBUS, "My id %llu", HvGetCurrentPartitionId());
321
322	DPRINT_EXIT(VMBUS);
323
324	return ret;
325
326	Cleanup:
327	if (virtAddr)
328	{
329	if (hypercallMsr.Enable)
330	{
331	hypercallMsr.AsUINT64 = 0;
332	WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
333	}
334
335	VirtualFree(virtAddr);
336	}
337	ret = -1;
338	DPRINT_EXIT(VMBUS);
339
340	return ret;
341	}
342
343
344	/*++
345
346	Name:
347	HvCleanup()
348
349	Description:
350	Cleanup routine. This routine is called normally during driver unloading or exiting.
351
352	--*/
353	void
354	HvCleanup (
355	void
356	)
357	{
358	HV_X64_MSR_HYPERCALL_CONTENTS hypercallMsr;
359
360	DPRINT_ENTER(VMBUS);
361
362	if (gHvContext.SignalEventBuffer)
363	{
364	MemFree(gHvContext.SignalEventBuffer);
365	gHvContext.SignalEventBuffer = NULL;
366	gHvContext.SignalEventParam = NULL;
367	}
368
369	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
370	{
371	if (gHvContext.HypercallPage)
372	{
373	hypercallMsr.AsUINT64 = 0;
374	WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
375	VirtualFree(gHvContext.HypercallPage);
376	gHvContext.HypercallPage = NULL;
377	}
378	}
379
380	DPRINT_EXIT(VMBUS);
381
382	}
383
384
385	/*++
386
387	Name:
388	HvPostMessage()
389
390	Description:
391	Post a message using the hypervisor message IPC. This
392	involves a hypercall.
393
394	--*/
395	HV_STATUS
396	HvPostMessage(
397	HV_CONNECTION_ID connectionId,
398	HV_MESSAGE_TYPE messageType,
8282c400	399	void * payload,
3e7ee490 HJ	400	SIZE_T payloadSize
	401	)
	402	{
	403	struct alignedInput {
	404	UINT64 alignment8;
	405	HV_INPUT_POST_MESSAGE msg;
	406	};
	407
	408	PHV_INPUT_POST_MESSAGE alignedMsg;
	409	HV_STATUS status;
	410	ULONG_PTR addr;
	411
	412	if (payloadSize > HV_MESSAGE_PAYLOAD_BYTE_COUNT)
	413	{
	414	return -1;
	415	}
	416
	417	addr = (ULONG_PTR)MemAllocAtomic(sizeof(struct alignedInput));
	418
	419	if (!addr)
	420	{
	421	return -1;
	422	}
	423
	424	alignedMsg = (PHV_INPUT_POST_MESSAGE)(ALIGN_UP(addr, HV_HYPERCALL_PARAM_ALIGN));
	425
	426	alignedMsg->ConnectionId = connectionId;
	427	alignedMsg->MessageType = messageType;
	428	alignedMsg->PayloadSize = payloadSize;
	429	memcpy((void*)alignedMsg->Payload, payload, payloadSize);
	430
	431	status = HvDoHypercall(HvCallPostMessage, alignedMsg, 0) & 0xFFFF;
	432
	433	MemFree((void*)addr);
	434
	435	return status;
	436	}
	437
	438
	439	/*++
	440
	441	Name:
	442	HvSignalEvent()
	443
	444	Description:
	445	Signal an event on the specified connection using the hypervisor event IPC. This
	446	involves a hypercall.
	447
	448	--*/
	449	HV_STATUS
	450	HvSignalEvent(
	451	)
	452	{
	453	HV_STATUS status;
	454
	455	status = HvDoHypercall(HvCallSignalEvent, gHvContext.SignalEventParam, 0) & 0xFFFF;
	456
	457	return status;
	458	}
	459
	460
	461	/*++
	462
	463	Name:
464	HvSynicInit()
465
466	Description:
467	Initialize the Synthethic Interrupt Controller. If it is already initialized by
468	another entity (ie x2v shim), we need to retrieve the initialized message and event pages.
469	Otherwise, we create and initialize the message and event pages.
470
471	--*/
472	int
473	HvSynicInit (
474	UINT32 irqVector
475	)
476	{
477	UINT64 version;
478	HV_SYNIC_SIMP simp;
479	HV_SYNIC_SIEFP siefp;
480	HV_SYNIC_SINT sharedSint;
481	HV_SYNIC_SCONTROL sctrl;
482	UINT64 guestID;
483	int ret=0;
484
485	DPRINT_ENTER(VMBUS);
486
487	if (!gHvContext.HypercallPage)
488	{
489	DPRINT_EXIT(VMBUS);
490	return ret;
491	}
492
493	// Check the version
494	version = ReadMsr(HV_X64_MSR_SVERSION);
495
496	DPRINT_INFO(VMBUS, "SynIC version: %llx", version);
497
498	// TODO: Handle SMP
499	if (gHvContext.GuestId == HV_XENLINUX_GUEST_ID)
500	{
501	DPRINT_INFO(VMBUS, "Skipping SIMP and SIEFP setup since it is already set.");
502
503	simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
504	siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);
505
506	DPRINT_DBG(VMBUS, "Simp: %llx, Sifep: %llx", simp.AsUINT64, siefp.AsUINT64);
507
508	// Determine if we are running on xenlinux (ie x2v shim) or native linux
509	guestID = ReadMsr(HV_X64_MSR_GUEST_OS_ID);
510
511	if (guestID == HV_LINUX_GUEST_ID)
512	{
513	gHvContext.synICMessagePage[0] = GetVirtualAddress(simp.BaseSimpGpa << PAGE_SHIFT);
514	gHvContext.synICEventPage[0] = GetVirtualAddress(siefp.BaseSiefpGpa << PAGE_SHIFT);
515	}
516	else
517	{
518	DPRINT_ERR(VMBUS, "unknown guest id!!");
519	goto Cleanup;
520	}
521	DPRINT_DBG(VMBUS, "MAPPED: Simp: %p, Sifep: %p", gHvContext.synICMessagePage[0], gHvContext.synICEventPage[0]);
522	}
523	else
524	{
525	gHvContext.synICMessagePage[0] = PageAlloc(1);
526	if (gHvContext.synICMessagePage[0] == NULL)
527	{
528	DPRINT_ERR(VMBUS, "unable to allocate SYNIC message page!!");
529	goto Cleanup;
530	}
531
532	gHvContext.synICEventPage[0] = PageAlloc(1);
533	if (gHvContext.synICEventPage[0] == NULL)
534	{
535	DPRINT_ERR(VMBUS, "unable to allocate SYNIC event page!!");
536	goto Cleanup;
537	}
538
539	//
540	// Setup the Synic's message page
541	//
542	simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
543	simp.SimpEnabled = 1;
544	simp.BaseSimpGpa = GetPhysicalAddress(gHvContext.synICMessagePage[0]) >> PAGE_SHIFT;
545
546	DPRINT_DBG(VMBUS, "HV_X64_MSR_SIMP msr set to: %llx", simp.AsUINT64);
547
548	WriteMsr(HV_X64_MSR_SIMP, simp.AsUINT64);
549
550	//
551	// Setup the Synic's event page
552	//
553	siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);
554	siefp.SiefpEnabled = 1;
555	siefp.BaseSiefpGpa = GetPhysicalAddress(gHvContext.synICEventPage[0]) >> PAGE_SHIFT;
556
557	DPRINT_DBG(VMBUS, "HV_X64_MSR_SIEFP msr set to: %llx", siefp.AsUINT64);
558
559	WriteMsr(HV_X64_MSR_SIEFP, siefp.AsUINT64);
560	}
561	//
562	// Setup the interception SINT.
563	//
564	//WriteMsr((HV_X64_MSR_SINT0 + HV_SYNIC_INTERCEPTION_SINT_INDEX),
565	// interceptionSint.AsUINT64);
566
567	//
568	// Setup the shared SINT.
569	//
570	sharedSint.AsUINT64 = ReadMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT);
571
572	sharedSint.AsUINT64 = 0;
573	sharedSint.Vector = irqVector; //HV_SHARED_SINT_IDT_VECTOR + 0x20;
574	sharedSint.Masked = FALSE;
575	sharedSint.AutoEoi = TRUE;
576
577	DPRINT_DBG(VMBUS, "HV_X64_MSR_SINT1 msr set to: %llx", sharedSint.AsUINT64);
578
579	WriteMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);
580
581	// Enable the global synic bit
582	sctrl.AsUINT64 = ReadMsr(HV_X64_MSR_SCONTROL);
583	sctrl.Enable = 1;
584
585	WriteMsr(HV_X64_MSR_SCONTROL, sctrl.AsUINT64);
586
587	gHvContext.SynICInitialized = TRUE;
588
589	DPRINT_EXIT(VMBUS);
590
591	return ret;
592
593	Cleanup:
594	ret = -1;
595
596	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
597	{
598	if (gHvContext.synICEventPage[0])
599	{
600	PageFree(gHvContext.synICEventPage[0],1);
601	}
602
603	if (gHvContext.synICMessagePage[0])
604	{
605	PageFree(gHvContext.synICMessagePage[0], 1);
606	}
607	}
608
609	DPRINT_EXIT(VMBUS);
610
611	return ret;
612
613	}
614
615	/*++
616
617	Name:
618	HvSynicCleanup()
619
620	Description:
621	Cleanup routine for HvSynicInit().
622
623	--*/
e20f683b	624	void
3e7ee490	625	HvSynicCleanup(
e20f683b	626	void
3e7ee490 HJ	627	)
	628	{
	629	HV_SYNIC_SINT sharedSint;
	630	HV_SYNIC_SIMP simp;
	631	HV_SYNIC_SIEFP siefp;
	632
	633	DPRINT_ENTER(VMBUS);
	634
	635	if (!gHvContext.SynICInitialized)
	636	{
	637	DPRINT_EXIT(VMBUS);
	638	return;
	639	}
	640
	641	sharedSint.AsUINT64 = ReadMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT);
	642
	643	sharedSint.Masked = 1;
	644
	645	// Disable the interrupt
	646	WriteMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);
	647
	648	// Disable and free the resources only if we are running as native linux
	649	// since in xenlinux, we are sharing the resources with the x2v shim
	650	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
	651	{
	652	simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
	653	simp.SimpEnabled = 0;
	654	simp.BaseSimpGpa = 0;
	655
	656	WriteMsr(HV_X64_MSR_SIMP, simp.AsUINT64);
	657
	658	siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);
	659	siefp.SiefpEnabled = 0;
	660	siefp.BaseSiefpGpa = 0;
	661
	662	WriteMsr(HV_X64_MSR_SIEFP, siefp.AsUINT64);
	663
	664	PageFree(gHvContext.synICMessagePage[0], 1);
	665	PageFree(gHvContext.synICEventPage[0], 1);
	666	}
	667
	668	DPRINT_EXIT(VMBUS);
	669	}
	670
	671
	672	// eof