[deliverable/linux.git] / drivers / staging / hv / Vmbus.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 <linux/kernel.h>
#include <linux/mm.h>
#include "osd.h"
#include "logging.h"
#include "VersionInfo.h"
#include "VmbusPrivate.h"

static const char *gDriverName = "vmbus";

/*
 * Windows vmbus does not defined this.
 * We defined this to be consistent with other devices
 */
/* {c5295816-f63a-4d5f-8d1a-4daf999ca185} */
static const struct hv_guid gVmbusDeviceType = {
	.data = {
		0x16, 0x58, 0x29, 0xc5, 0x3a, 0xf6, 0x5f, 0x4d,
		0x8d, 0x1a, 0x4d, 0xaf, 0x99, 0x9c, 0xa1, 0x85
	}
};

/* {ac3760fc-9adf-40aa-9427-a70ed6de95c5} */
static const struct hv_guid gVmbusDeviceId = {
	.data = {
		0xfc, 0x60, 0x37, 0xac, 0xdf, 0x9a, 0xaa, 0x40,
		0x94, 0x27, 0xa7, 0x0e, 0xd6, 0xde, 0x95, 0xc5
	}
};

static struct hv_driver *gDriver; /* vmbus driver object */
static struct hv_device *gDevice; /* vmbus root device */

/**
 * VmbusGetChannelOffers - Retrieve the channel offers from the parent partition
 */
static void VmbusGetChannelOffers(void)
{
	DPRINT_ENTER(VMBUS);
	VmbusChannelRequestOffers();
	DPRINT_EXIT(VMBUS);
}

/**
 * VmbusGetChannelInterface - Get the channel interface
 */
static void VmbusGetChannelInterface(struct vmbus_channel_interface *Interface)
{
	GetChannelInterface(Interface);
}

/**
 * VmbusGetChannelInfo - Get the device info for the specified device object
 */
static void VmbusGetChannelInfo(struct hv_device *DeviceObject,
				struct hv_device_info *DeviceInfo)
{
	GetChannelInfo(DeviceObject, DeviceInfo);
}

/**
 * VmbusCreateChildDevice - Creates the child device on the bus that represents the channel offer
 */
struct hv_device *VmbusChildDeviceCreate(struct hv_guid *DeviceType,
					 struct hv_guid *DeviceInstance,
					 void *Context)
{
	struct vmbus_driver *vmbusDriver = (struct vmbus_driver *)gDriver;

	return vmbusDriver->OnChildDeviceCreate(DeviceType, DeviceInstance,
						Context);
}

/**
 * VmbusChildDeviceAdd - Registers the child device with the vmbus
 */
int VmbusChildDeviceAdd(struct hv_device *ChildDevice)
{
	struct vmbus_driver *vmbusDriver = (struct vmbus_driver *)gDriver;

	return vmbusDriver->OnChildDeviceAdd(gDevice, ChildDevice);
}

/**
 * VmbusChildDeviceRemove Unregisters the child device from the vmbus
 */
void VmbusChildDeviceRemove(struct hv_device *ChildDevice)
{
	struct vmbus_driver *vmbusDriver = (struct vmbus_driver *)gDriver;

	vmbusDriver->OnChildDeviceRemove(ChildDevice);
}

/**
 * VmbusOnDeviceAdd - Callback when the root bus device is added
 */
static int VmbusOnDeviceAdd(struct hv_device *dev, void *AdditionalInfo)
{
	u32 *irqvector = AdditionalInfo;
	int ret;

	DPRINT_ENTER(VMBUS);

	gDevice = dev;

	memcpy(&gDevice->deviceType, &gVmbusDeviceType, sizeof(struct hv_guid));
	memcpy(&gDevice->deviceInstance, &gVmbusDeviceId,
	       sizeof(struct hv_guid));

	/* strcpy(dev->name, "vmbus"); */
	/* SynIC setup... */
	on_each_cpu(HvSynicInit, (void *)irqvector, 1);

	/* Connect to VMBus in the root partition */
	ret = VmbusConnect();

	/* VmbusSendEvent(device->localPortId+1); */
	DPRINT_EXIT(VMBUS);

	return ret;
}

/**
 * VmbusOnDeviceRemove - Callback when the root bus device is removed
 */
static int VmbusOnDeviceRemove(struct hv_device *dev)
{
	int ret = 0;

	DPRINT_ENTER(VMBUS);
	VmbusChannelReleaseUnattachedChannels();
	VmbusDisconnect();
	on_each_cpu(HvSynicCleanup, NULL, 1);
	DPRINT_EXIT(VMBUS);

	return ret;
}

/**
 * VmbusOnCleanup - Perform any cleanup when the driver is removed
 */
static void VmbusOnCleanup(struct hv_driver *drv)
{
	/* struct vmbus_driver *driver = (struct vmbus_driver *)drv; */

	DPRINT_ENTER(VMBUS);
	HvCleanup();
	DPRINT_EXIT(VMBUS);
}

/**
 * VmbusOnMsgDPC - DPC routine to handle messages from the hypervisior
 */
static void VmbusOnMsgDPC(struct hv_driver *drv)
{
	int cpu = smp_processor_id();
	void *page_addr = gHvContext.synICMessagePage[cpu];
	struct hv_message *msg = (struct hv_message *)page_addr +
				  VMBUS_MESSAGE_SINT;
	struct hv_message *copied;

	while (1) {
		if (msg->Header.MessageType == HvMessageTypeNone) {
			/* no msg */
			break;
		} else {
			copied = kmalloc(sizeof(*copied), GFP_ATOMIC);
			if (copied == NULL)
				continue;

			memcpy(copied, msg, sizeof(*copied));
			osd_schedule_callback(gVmbusConnection.WorkQueue,
					      VmbusOnChannelMessage,
					      (void *)copied);
		}

		msg->Header.MessageType = HvMessageTypeNone;

		/*
		 * Make sure the write to MessageType (ie set to
		 * HvMessageTypeNone) happens before we read the
		 * MessagePending and EOMing. Otherwise, the EOMing
		 * will not deliver any more messages since there is
		 * no empty slot
		 */
		mb();

		if (msg->Header.MessageFlags.MessagePending) {
			/*
			 * This will cause message queue rescan to
			 * possibly deliver another msg from the
			 * hypervisor
			 */
			wrmsrl(HV_X64_MSR_EOM, 0);
		}
	}
}

/**
 * VmbusOnEventDPC - DPC routine to handle events from the hypervisior
 */
static void VmbusOnEventDPC(struct hv_driver *drv)
{
	/* TODO: Process any events */
	VmbusOnEvents();
}

/**
 * VmbusOnISR - ISR routine
 */
static int VmbusOnISR(struct hv_driver *drv)
{
	int ret = 0;
	int cpu = smp_processor_id();
	void *page_addr;
	struct hv_message *msg;
	union hv_synic_event_flags *event;

	page_addr = gHvContext.synICMessagePage[cpu];
	msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;

	DPRINT_ENTER(VMBUS);

	/* Check if there are actual msgs to be process */
	if (msg->Header.MessageType != HvMessageTypeNone) {
		DPRINT_DBG(VMBUS, "received msg type %d size %d",
				msg->Header.MessageType,
				msg->Header.PayloadSize);
		ret |= 0x1;
	}

	/* TODO: Check if there are events to be process */
	page_addr = gHvContext.synICEventPage[cpu];
	event = (union hv_synic_event_flags *)page_addr + VMBUS_MESSAGE_SINT;

	/* Since we are a child, we only need to check bit 0 */
	if (test_and_clear_bit(0, (unsigned long *) &event->Flags32[0])) {
		DPRINT_DBG(VMBUS, "received event %d", event->Flags32[0]);
		ret |= 0x2;
	}

	DPRINT_EXIT(VMBUS);
	return ret;
}

/**
 * VmbusInitialize - Main entry point
 */
int VmbusInitialize(struct hv_driver *drv)
{
	struct vmbus_driver *driver = (struct vmbus_driver *)drv;
	int ret;

	DPRINT_ENTER(VMBUS);

	DPRINT_INFO(VMBUS, "+++++++ Build Date=%s %s +++++++",
			VersionDate, VersionTime);
	DPRINT_INFO(VMBUS, "+++++++ Build Description=%s +++++++",
			VersionDesc);
	DPRINT_INFO(VMBUS, "+++++++ Vmbus supported version = %d +++++++",
			VMBUS_REVISION_NUMBER);
	DPRINT_INFO(VMBUS, "+++++++ Vmbus using SINT %d +++++++",
			VMBUS_MESSAGE_SINT);
	DPRINT_DBG(VMBUS, "sizeof(VMBUS_CHANNEL_PACKET_PAGE_BUFFER)=%zd, "
			"sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER)=%zd",
			sizeof(struct VMBUS_CHANNEL_PACKET_PAGE_BUFFER),
			sizeof(struct VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER));

	drv->name = gDriverName;
	memcpy(&drv->deviceType, &gVmbusDeviceType, sizeof(struct hv_guid));

	/* Setup dispatch table */
	driver->Base.OnDeviceAdd	= VmbusOnDeviceAdd;
	driver->Base.OnDeviceRemove	= VmbusOnDeviceRemove;
	driver->Base.OnCleanup		= VmbusOnCleanup;
	driver->OnIsr			= VmbusOnISR;
	driver->OnMsgDpc		= VmbusOnMsgDPC;
	driver->OnEventDpc		= VmbusOnEventDPC;
	driver->GetChannelOffers	= VmbusGetChannelOffers;
	driver->GetChannelInterface	= VmbusGetChannelInterface;
	driver->GetChannelInfo		= VmbusGetChannelInfo;

	/* Hypervisor initialization...setup hypercall page..etc */
	ret = HvInit();
	if (ret != 0)
		DPRINT_ERR(VMBUS, "Unable to initialize the hypervisor - 0x%x",
				ret);
	gDriver = drv;

	DPRINT_EXIT(VMBUS);

	return ret;
}
Commit	Line	Data
	1	/*
	2	* Copyright (c) 2009, Microsoft Corporation.
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms and conditions of the GNU General Public License,
	6	* version 2, as published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	11	* more details.
	12	*
	13	* You should have received a copy of the GNU General Public License along with
	14	* this program; if not, write to the Free Software Foundation, Inc., 59 Temple
	15	* Place - Suite 330, Boston, MA 02111-1307 USA.
	16	*
	17	* Authors:
	18	* Haiyang Zhang <haiyangz@microsoft.com>
	19	* Hank Janssen <hjanssen@microsoft.com>
	20	*
	21	*/
	22	#include <linux/kernel.h>
	23	#include <linux/mm.h>
	24	#include "osd.h"
	25	#include "logging.h"
	26	#include "VersionInfo.h"
	27	#include "VmbusPrivate.h"
	28
	29	static const char *gDriverName = "vmbus";
	30
	31	/*
	32	* Windows vmbus does not defined this.
	33	* We defined this to be consistent with other devices
	34	*/
	35	/* {c5295816-f63a-4d5f-8d1a-4daf999ca185} */
	36	static const struct hv_guid gVmbusDeviceType = {
	37	.data = {
	38	0x16, 0x58, 0x29, 0xc5, 0x3a, 0xf6, 0x5f, 0x4d,
	39	0x8d, 0x1a, 0x4d, 0xaf, 0x99, 0x9c, 0xa1, 0x85
	40	}
	41	};
	42
	43	/* {ac3760fc-9adf-40aa-9427-a70ed6de95c5} */
	44	static const struct hv_guid gVmbusDeviceId = {
	45	.data = {
	46	0xfc, 0x60, 0x37, 0xac, 0xdf, 0x9a, 0xaa, 0x40,
	47	0x94, 0x27, 0xa7, 0x0e, 0xd6, 0xde, 0x95, 0xc5
	48	}
	49	};
	50
	51	static struct hv_driver gDriver; / vmbus driver object */
	52	static struct hv_device gDevice; / vmbus root device */
	53
	54	/**
	55	* VmbusGetChannelOffers - Retrieve the channel offers from the parent partition
	56	*/
	57	static void VmbusGetChannelOffers(void)
	58	{
	59	DPRINT_ENTER(VMBUS);
	60	VmbusChannelRequestOffers();
	61	DPRINT_EXIT(VMBUS);
	62	}
	63
	64	/**
	65	* VmbusGetChannelInterface - Get the channel interface
	66	*/
	67	static void VmbusGetChannelInterface(struct vmbus_channel_interface *Interface)
	68	{
	69	GetChannelInterface(Interface);
	70	}
	71
	72	/**
	73	* VmbusGetChannelInfo - Get the device info for the specified device object
	74	*/
	75	static void VmbusGetChannelInfo(struct hv_device *DeviceObject,
	76	struct hv_device_info *DeviceInfo)
	77	{
	78	GetChannelInfo(DeviceObject, DeviceInfo);
	79	}
	80
	81	/**
	82	* VmbusCreateChildDevice - Creates the child device on the bus that represents the channel offer
	83	*/
	84	struct hv_device VmbusChildDeviceCreate(struct hv_guid DeviceType,
	85	struct hv_guid *DeviceInstance,
	86	void *Context)
	87	{
	88	struct vmbus_driver vmbusDriver = (struct vmbus_driver )gDriver;
	89
	90	return vmbusDriver->OnChildDeviceCreate(DeviceType, DeviceInstance,
	91	Context);
	92	}
	93
	94	/**
	95	* VmbusChildDeviceAdd - Registers the child device with the vmbus
	96	*/
	97	int VmbusChildDeviceAdd(struct hv_device *ChildDevice)
	98	{
	99	struct vmbus_driver vmbusDriver = (struct vmbus_driver )gDriver;
	100
	101	return vmbusDriver->OnChildDeviceAdd(gDevice, ChildDevice);
	102	}
	103
	104	/**
	105	* VmbusChildDeviceRemove Unregisters the child device from the vmbus
	106	*/
	107	void VmbusChildDeviceRemove(struct hv_device *ChildDevice)
	108	{
	109	struct vmbus_driver vmbusDriver = (struct vmbus_driver )gDriver;
	110
	111	vmbusDriver->OnChildDeviceRemove(ChildDevice);
	112	}
	113
	114	/**
	115	* VmbusOnDeviceAdd - Callback when the root bus device is added
	116	*/
	117	static int VmbusOnDeviceAdd(struct hv_device dev, void AdditionalInfo)
	118	{
	119	u32 *irqvector = AdditionalInfo;
	120	int ret;
	121
	122	DPRINT_ENTER(VMBUS);
	123
	124	gDevice = dev;
	125
	126	memcpy(&gDevice->deviceType, &gVmbusDeviceType, sizeof(struct hv_guid));
	127	memcpy(&gDevice->deviceInstance, &gVmbusDeviceId,
	128	sizeof(struct hv_guid));
	129
	130	/* strcpy(dev->name, "vmbus"); */
	131	/* SynIC setup... */
	132	on_each_cpu(HvSynicInit, (void *)irqvector, 1);
	133
	134	/* Connect to VMBus in the root partition */
	135	ret = VmbusConnect();
	136
	137	/* VmbusSendEvent(device->localPortId+1); */
	138	DPRINT_EXIT(VMBUS);
	139
	140	return ret;
	141	}
	142
	143	/**
	144	* VmbusOnDeviceRemove - Callback when the root bus device is removed
	145	*/
	146	static int VmbusOnDeviceRemove(struct hv_device *dev)
	147	{
	148	int ret = 0;
	149
	150	DPRINT_ENTER(VMBUS);
	151	VmbusChannelReleaseUnattachedChannels();
	152	VmbusDisconnect();
	153	on_each_cpu(HvSynicCleanup, NULL, 1);
	154	DPRINT_EXIT(VMBUS);
	155
	156	return ret;
	157	}
	158
	159	/**
	160	* VmbusOnCleanup - Perform any cleanup when the driver is removed
	161	*/
	162	static void VmbusOnCleanup(struct hv_driver *drv)
	163	{
	164	/* struct vmbus_driver driver = (struct vmbus_driver )drv; */
	165
	166	DPRINT_ENTER(VMBUS);
	167	HvCleanup();
	168	DPRINT_EXIT(VMBUS);
	169	}
	170
	171	/**
	172	* VmbusOnMsgDPC - DPC routine to handle messages from the hypervisior
	173	*/
	174	static void VmbusOnMsgDPC(struct hv_driver *drv)
	175	{
	176	int cpu = smp_processor_id();
	177	void *page_addr = gHvContext.synICMessagePage[cpu];
	178	struct hv_message msg = (struct hv_message )page_addr +
	179	VMBUS_MESSAGE_SINT;
	180	struct hv_message *copied;
	181
	182	while (1) {
	183	if (msg->Header.MessageType == HvMessageTypeNone) {
	184	/* no msg */
	185	break;
	186	} else {
	187	copied = kmalloc(sizeof(*copied), GFP_ATOMIC);
	188	if (copied == NULL)
	189	continue;
	190
	191	memcpy(copied, msg, sizeof(*copied));
	192	osd_schedule_callback(gVmbusConnection.WorkQueue,
	193	VmbusOnChannelMessage,
	194	(void *)copied);
	195	}
	196
	197	msg->Header.MessageType = HvMessageTypeNone;
	198
	199	/*
	200	* Make sure the write to MessageType (ie set to
	201	* HvMessageTypeNone) happens before we read the
	202	* MessagePending and EOMing. Otherwise, the EOMing
	203	* will not deliver any more messages since there is
	204	* no empty slot
	205	*/
	206	mb();
	207
	208	if (msg->Header.MessageFlags.MessagePending) {
	209	/*
	210	* This will cause message queue rescan to
	211	* possibly deliver another msg from the
	212	* hypervisor
	213	*/
	214	wrmsrl(HV_X64_MSR_EOM, 0);
	215	}
	216	}
	217	}
	218
	219	/**
	220	* VmbusOnEventDPC - DPC routine to handle events from the hypervisior
	221	*/
	222	static void VmbusOnEventDPC(struct hv_driver *drv)
	223	{
	224	/* TODO: Process any events */
	225	VmbusOnEvents();
	226	}
	227
	228	/**
	229	* VmbusOnISR - ISR routine
	230	*/
	231	static int VmbusOnISR(struct hv_driver *drv)
	232	{
	233	int ret = 0;
	234	int cpu = smp_processor_id();
	235	void *page_addr;
	236	struct hv_message *msg;
	237	union hv_synic_event_flags *event;
	238
	239	page_addr = gHvContext.synICMessagePage[cpu];
	240	msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
	241
	242	DPRINT_ENTER(VMBUS);
	243
	244	/* Check if there are actual msgs to be process */
	245	if (msg->Header.MessageType != HvMessageTypeNone) {
	246	DPRINT_DBG(VMBUS, "received msg type %d size %d",
	247	msg->Header.MessageType,
	248	msg->Header.PayloadSize);
	249	ret \|= 0x1;
	250	}
	251
	252	/* TODO: Check if there are events to be process */
	253	page_addr = gHvContext.synICEventPage[cpu];
	254	event = (union hv_synic_event_flags *)page_addr + VMBUS_MESSAGE_SINT;
	255
	256	/* Since we are a child, we only need to check bit 0 */
	257	if (test_and_clear_bit(0, (unsigned long *) &event->Flags32[0])) {
	258	DPRINT_DBG(VMBUS, "received event %d", event->Flags32[0]);
	259	ret \|= 0x2;
	260	}
	261
	262	DPRINT_EXIT(VMBUS);
	263	return ret;
	264	}
	265
	266	/**
	267	* VmbusInitialize - Main entry point
	268	*/
	269	int VmbusInitialize(struct hv_driver *drv)
	270	{
	271	struct vmbus_driver driver = (struct vmbus_driver )drv;
	272	int ret;
	273
	274	DPRINT_ENTER(VMBUS);
	275
	276	DPRINT_INFO(VMBUS, "+++++++ Build Date=%s %s +++++++",
	277	VersionDate, VersionTime);
	278	DPRINT_INFO(VMBUS, "+++++++ Build Description=%s +++++++",
	279	VersionDesc);
	280	DPRINT_INFO(VMBUS, "+++++++ Vmbus supported version = %d +++++++",
	281	VMBUS_REVISION_NUMBER);
	282	DPRINT_INFO(VMBUS, "+++++++ Vmbus using SINT %d +++++++",
	283	VMBUS_MESSAGE_SINT);
	284	DPRINT_DBG(VMBUS, "sizeof(VMBUS_CHANNEL_PACKET_PAGE_BUFFER)=%zd, "
	285	"sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER)=%zd",
	286	sizeof(struct VMBUS_CHANNEL_PACKET_PAGE_BUFFER),
	287	sizeof(struct VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER));
	288
	289	drv->name = gDriverName;
	290	memcpy(&drv->deviceType, &gVmbusDeviceType, sizeof(struct hv_guid));
	291
	292	/* Setup dispatch table */
	293	driver->Base.OnDeviceAdd = VmbusOnDeviceAdd;
	294	driver->Base.OnDeviceRemove = VmbusOnDeviceRemove;
	295	driver->Base.OnCleanup = VmbusOnCleanup;
	296	driver->OnIsr = VmbusOnISR;
	297	driver->OnMsgDpc = VmbusOnMsgDPC;
	298	driver->OnEventDpc = VmbusOnEventDPC;
	299	driver->GetChannelOffers = VmbusGetChannelOffers;
	300	driver->GetChannelInterface = VmbusGetChannelInterface;
	301	driver->GetChannelInfo = VmbusGetChannelInfo;
	302
	303	/* Hypervisor initialization...setup hypercall page..etc */
	304	ret = HvInit();
	305	if (ret != 0)
	306	DPRINT_ERR(VMBUS, "Unable to initialize the hypervisor - 0x%x",
	307	ret);
	308	gDriver = drv;
	309
	310	DPRINT_EXIT(VMBUS);
	311
	312	return ret;
	313	}