Skip to content

L
linux
Commit 90c9960e authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files
Options

Staging: hv: coding style cleanups for vmbus_drv.c 

Almost clean.

Cc: Hank Janssen <hjanssen@microsoft.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 689bf406
Hide whitespace changes
Inline Side-by-side
Showing with 405 additions and 541 deletions
drivers/staging/hv/vmbus_drv.c
View file @ 90c9960e
/* /*
*
* Copyright (c) 2009, Microsoft Corporation. * Copyright (c) 2009, Microsoft Corporation.
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
...@@ -18,10 +17,7 @@ ...@@ -18,10 +17,7 @@
* Authors: * Authors:
* Haiyang Zhang <haiyangz@microsoft.com> * Haiyang Zhang <haiyangz@microsoft.com>
* Hank Janssen <hjanssen@microsoft.com> * Hank Janssen <hjanssen@microsoft.com>
*
*/ */
#include <linux/init.h> #include <linux/init.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/device.h> #include <linux/device.h>
...@@ -33,35 +29,27 @@ ...@@ -33,35 +29,27 @@
#include "vmbus.h" #include "vmbus.h"
/* Defines */
/* FIXME! We need to do this dynamically for PIC and APIC system */ /* FIXME! We need to do this dynamically for PIC and APIC system */
#define VMBUS_IRQ 0x5 #define VMBUS_IRQ 0x5
#define VMBUS_IRQ_VECTOR IRQ5_VECTOR #define VMBUS_IRQ_VECTOR IRQ5_VECTOR
/* Data types */
/* Main vmbus driver data structure */ /* Main vmbus driver data structure */
struct vmbus_driver_context { struct vmbus_driver_context {
/* !! These must be the first 2 fields !! */ /* !! These must be the first 2 fields !! */
/* FIXME, this is a bug */
/* The driver field is not used in here. Instead, the bus field is */ /* The driver field is not used in here. Instead, the bus field is */
/* used to represent the driver */ /* used to represent the driver */
struct driver_context drv_ctx; struct driver_context drv_ctx;
struct vmbus_driver drv_obj; struct vmbus_driver drv_obj;
struct bus_type bus; struct bus_type bus;
struct tasklet_struct msg_dpc; struct tasklet_struct msg_dpc;
struct tasklet_struct event_dpc; struct tasklet_struct event_dpc;
/* The bus root device */ /* The bus root device */
struct device_context device_ctx; struct device_context device_ctx;
}; };
/* Static decl */
static int vmbus_match(struct device *device, struct device_driver *driver); static int vmbus_match(struct device *device, struct device_driver *driver);
static int vmbus_probe(struct device *device); static int vmbus_probe(struct device *device);
static int vmbus_remove(struct device *device); static int vmbus_remove(struct device *device);
...@@ -70,40 +58,33 @@ static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env); ...@@ -70,40 +58,33 @@ static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env);
static void vmbus_msg_dpc(unsigned long data); static void vmbus_msg_dpc(unsigned long data);
static void vmbus_event_dpc(unsigned long data); static void vmbus_event_dpc(unsigned long data);
static irqreturn_t vmbus_isr(int irq, void* dev_id); static irqreturn_t vmbus_isr(int irq, void *dev_id);
static void vmbus_device_release(struct device *device); static void vmbus_device_release(struct device *device);
static void vmbus_bus_release(struct device *device); static void vmbus_bus_release(struct device *device);
static struct hv_device *vmbus_child_device_create(struct hv_guid *type, struct hv_guid *instance, void *context); static struct hv_device *vmbus_child_device_create(struct hv_guid *type,
struct hv_guid *instance,
void *context);
static void vmbus_child_device_destroy(struct hv_device *device_obj); static void vmbus_child_device_destroy(struct hv_device *device_obj);
static int vmbus_child_device_register(struct hv_device *root_device_obj, struct hv_device *child_device_obj); static int vmbus_child_device_register(struct hv_device *root_device_obj,
struct hv_device *child_device_obj);
static void vmbus_child_device_unregister(struct hv_device *child_device_obj); static void vmbus_child_device_unregister(struct hv_device *child_device_obj);
static void vmbus_child_device_get_info(struct hv_device *device_obj, struct hv_device_info *device_info); static void vmbus_child_device_get_info(struct hv_device *device_obj,
struct hv_device_info *device_info);
static ssize_t vmbus_show_device_attr(struct device *dev,
struct device_attribute *dev_attr,
char *buf);
/* static ssize_t vmbus_show_class_id(struct device *dev, struct device_attribute *attr, char *buf); */
/* static ssize_t vmbus_show_device_id(struct device *dev, struct device_attribute *attr, char *buf); */
static ssize_t vmbus_show_device_attr(struct device *dev, struct device_attribute *dev_attr, char *buf); unsigned int vmbus_loglevel = (ALL_MODULES << 16 | INFO_LVL);
/* Global */
/* Global logging setting */
/* unsigned int vmbus_loglevel= (((VMBUS | VMBUS_DRV)<<16) | DEBUG_LVL_ENTEREXIT); */
/* unsigned int vmbus_loglevel= (ALL_MODULES << 16 | DEBUG_LVL_ENTEREXIT); */
unsigned int vmbus_loglevel= (ALL_MODULES << 16 | INFO_LVL);
EXPORT_SYMBOL(vmbus_loglevel); EXPORT_SYMBOL(vmbus_loglevel);
/* (ALL_MODULES << 16 | DEBUG_LVL_ENTEREXIT); */
/* (((VMBUS | VMBUS_DRV)<<16) | DEBUG_LVL_ENTEREXIT); */
static int vmbus_irq = VMBUS_IRQ; static int vmbus_irq = VMBUS_IRQ;
/* Setup /proc/sys/bus/vmbus/vmbus_loglevel */
/* Allow usage of sysctl cmd to set the logging level */
/* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */ /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
static struct device_attribute vmbus_device_attrs[] = { static struct device_attribute vmbus_device_attrs[] = {
__ATTR(id, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(id, S_IRUGO, vmbus_show_device_attr, NULL),
__ATTR(state, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(state, S_IRUGO, vmbus_show_device_attr, NULL),
...@@ -134,29 +115,25 @@ static struct device_attribute vmbus_device_attrs[] = { ...@@ -134,29 +115,25 @@ static struct device_attribute vmbus_device_attrs[] = {
}; };
/* The one and only one */ /* The one and only one */
static struct vmbus_driver_context g_vmbus_drv={ static struct vmbus_driver_context g_vmbus_drv = {
.bus.name = "vmbus", .bus.name = "vmbus",
.bus.match = vmbus_match, .bus.match = vmbus_match,
.bus.shutdown = vmbus_shutdown, .bus.shutdown = vmbus_shutdown,
.bus.remove = vmbus_remove, .bus.remove = vmbus_remove,
.bus.probe = vmbus_probe, .bus.probe = vmbus_probe,
.bus.uevent = vmbus_uevent, .bus.uevent = vmbus_uevent,
.bus.dev_attrs = vmbus_device_attrs, .bus.dev_attrs = vmbus_device_attrs,
}; };
/**
/* Routines */ * vmbus_show_device_attr - Show the device attribute in sysfs.
*
* This is invoked when user does a
* "cat /sys/bus/vmbus/devices/<busdevice>/<attr name>"
/*++ */
static ssize_t vmbus_show_device_attr(struct device *dev,
Name: vmbus_show_device_attr() struct device_attribute *dev_attr,
char *buf)
Desc: Show the device attribute in sysfs. This is invoked when user does a "cat /sys/bus/vmbus/devices/<bus device>/<attr name>"
--*/
static ssize_t vmbus_show_device_attr(struct device *dev, struct device_attribute *dev_attr, char *buf)
{ {
struct device_context *device_ctx = device_to_device_context(dev); struct device_context *device_ctx = device_to_device_context(dev);
struct hv_device_info device_info; struct hv_device_info device_info;
...@@ -165,173 +142,119 @@ static ssize_t vmbus_show_device_attr(struct device *dev, struct device_attribut ...@@ -165,173 +142,119 @@ static ssize_t vmbus_show_device_attr(struct device *dev, struct device_attribut
vmbus_child_device_get_info(&device_ctx->device_obj, &device_info); vmbus_child_device_get_info(&device_ctx->device_obj, &device_info);
if (!strcmp(dev_attr->attr.name, "class_id")) if (!strcmp(dev_attr->attr.name, "class_id")) {
{ return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n", "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
device_info.ChannelType.data[3], device_info.ChannelType.data[2], device_info.ChannelType.data[3],
device_info.ChannelType.data[1], device_info.ChannelType.data[0], device_info.ChannelType.data[2],
device_info.ChannelType.data[5], device_info.ChannelType.data[4], device_info.ChannelType.data[1],
device_info.ChannelType.data[7], device_info.ChannelType.data[6], device_info.ChannelType.data[0],
device_info.ChannelType.data[8], device_info.ChannelType.data[9], device_info.ChannelType.data[5],
device_info.ChannelType.data[10], device_info.ChannelType.data[11], device_info.ChannelType.data[4],
device_info.ChannelType.data[12], device_info.ChannelType.data[13], device_info.ChannelType.data[7],
device_info.ChannelType.data[14], device_info.ChannelType.data[15]); device_info.ChannelType.data[6],
device_info.ChannelType.data[8],
} device_info.ChannelType.data[9],
else if (!strcmp(dev_attr->attr.name, "device_id")) device_info.ChannelType.data[10],
{ device_info.ChannelType.data[11],
return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n", device_info.ChannelType.data[12],
device_info.ChannelInstance.data[3], device_info.ChannelInstance.data[2], device_info.ChannelType.data[13],
device_info.ChannelInstance.data[1], device_info.ChannelInstance.data[0], device_info.ChannelType.data[14],
device_info.ChannelInstance.data[5], device_info.ChannelInstance.data[4], device_info.ChannelType.data[15]);
device_info.ChannelInstance.data[7], device_info.ChannelInstance.data[6], } else if (!strcmp(dev_attr->attr.name, "device_id")) {
device_info.ChannelInstance.data[8], device_info.ChannelInstance.data[9], return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
device_info.ChannelInstance.data[10], device_info.ChannelInstance.data[11], "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
device_info.ChannelInstance.data[12], device_info.ChannelInstance.data[13], device_info.ChannelInstance.data[3],
device_info.ChannelInstance.data[14], device_info.ChannelInstance.data[15]); device_info.ChannelInstance.data[2],
} device_info.ChannelInstance.data[1],
else if (!strcmp(dev_attr->attr.name, "state")) device_info.ChannelInstance.data[0],
{ device_info.ChannelInstance.data[5],
device_info.ChannelInstance.data[4],
device_info.ChannelInstance.data[7],
device_info.ChannelInstance.data[6],
device_info.ChannelInstance.data[8],
device_info.ChannelInstance.data[9],
device_info.ChannelInstance.data[10],
device_info.ChannelInstance.data[11],
device_info.ChannelInstance.data[12],
device_info.ChannelInstance.data[13],
device_info.ChannelInstance.data[14],
device_info.ChannelInstance.data[15]);
} else if (!strcmp(dev_attr->attr.name, "state")) {
return sprintf(buf, "%d\n", device_info.ChannelState); return sprintf(buf, "%d\n", device_info.ChannelState);
} } else if (!strcmp(dev_attr->attr.name, "id")) {
else if (!strcmp(dev_attr->attr.name, "id"))
{
return sprintf(buf, "%d\n", device_info.ChannelId); return sprintf(buf, "%d\n", device_info.ChannelId);
} } else if (!strcmp(dev_attr->attr.name, "out_intr_mask")) {
else if (!strcmp(dev_attr->attr.name, "out_intr_mask"))
{
return sprintf(buf, "%d\n", device_info.Outbound.InterruptMask); return sprintf(buf, "%d\n", device_info.Outbound.InterruptMask);
} } else if (!strcmp(dev_attr->attr.name, "out_read_index")) {
else if (!strcmp(dev_attr->attr.name, "out_read_index"))
{
return sprintf(buf, "%d\n", device_info.Outbound.ReadIndex); return sprintf(buf, "%d\n", device_info.Outbound.ReadIndex);
} } else if (!strcmp(dev_attr->attr.name, "out_write_index")) {
else if (!strcmp(dev_attr->attr.name, "out_write_index"))
{
return sprintf(buf, "%d\n", device_info.Outbound.WriteIndex); return sprintf(buf, "%d\n", device_info.Outbound.WriteIndex);
} } else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail")) {
else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail")) return sprintf(buf, "%d\n",
{ device_info.Outbound.BytesAvailToRead);
return sprintf(buf, "%d\n", device_info.Outbound.BytesAvailToRead); } else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail")) {
} return sprintf(buf, "%d\n",
else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail")) device_info.Outbound.BytesAvailToWrite);
{ } else if (!strcmp(dev_attr->attr.name, "in_intr_mask")) {
return sprintf(buf, "%d\n", device_info.Outbound.BytesAvailToWrite);
}
else if (!strcmp(dev_attr->attr.name, "in_intr_mask"))
{
return sprintf(buf, "%d\n", device_info.Inbound.InterruptMask); return sprintf(buf, "%d\n", device_info.Inbound.InterruptMask);
} } else if (!strcmp(dev_attr->attr.name, "in_read_index")) {
else if (!strcmp(dev_attr->attr.name, "in_read_index"))
{
return sprintf(buf, "%d\n", device_info.Inbound.ReadIndex); return sprintf(buf, "%d\n", device_info.Inbound.ReadIndex);
} } else if (!strcmp(dev_attr->attr.name, "in_write_index")) {
else if (!strcmp(dev_attr->attr.name, "in_write_index"))
{
return sprintf(buf, "%d\n", device_info.Inbound.WriteIndex); return sprintf(buf, "%d\n", device_info.Inbound.WriteIndex);
} } else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail")) {
else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail")) return sprintf(buf, "%d\n",
{ device_info.Inbound.BytesAvailToRead);
return sprintf(buf, "%d\n", device_info.Inbound.BytesAvailToRead); } else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail")) {
} return sprintf(buf, "%d\n",
else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail")) device_info.Inbound.BytesAvailToWrite);
{ } else if (!strcmp(dev_attr->attr.name, "monitor_id")) {
return sprintf(buf, "%d\n", device_info.Inbound.BytesAvailToWrite);
}
else if (!strcmp(dev_attr->attr.name, "monitor_id"))
{
return sprintf(buf, "%d\n", device_info.MonitorId); return sprintf(buf, "%d\n", device_info.MonitorId);
} } else if (!strcmp(dev_attr->attr.name, "server_monitor_pending")) {
else if (!strcmp(dev_attr->attr.name, "server_monitor_pending"))
{
return sprintf(buf, "%d\n", device_info.ServerMonitorPending); return sprintf(buf, "%d\n", device_info.ServerMonitorPending);
} } else if (!strcmp(dev_attr->attr.name, "server_monitor_latency")) {
else if (!strcmp(dev_attr->attr.name, "server_monitor_latency"))
{
return sprintf(buf, "%d\n", device_info.ServerMonitorLatency); return sprintf(buf, "%d\n", device_info.ServerMonitorLatency);
} } else if (!strcmp(dev_attr->attr.name, "server_monitor_conn_id")) {
else if (!strcmp(dev_attr->attr.name, "server_monitor_conn_id")) return sprintf(buf, "%d\n",
{ device_info.ServerMonitorConnectionId);
return sprintf(buf, "%d\n", device_info.ServerMonitorConnectionId); } else if (!strcmp(dev_attr->attr.name, "client_monitor_pending")) {
}
else if (!strcmp(dev_attr->attr.name, "client_monitor_pending"))
{
return sprintf(buf, "%d\n", device_info.ClientMonitorPending); return sprintf(buf, "%d\n", device_info.ClientMonitorPending);
} } else if (!strcmp(dev_attr->attr.name, "client_monitor_latency")) {
else if (!strcmp(dev_attr->attr.name, "client_monitor_latency"))
{
return sprintf(buf, "%d\n", device_info.ClientMonitorLatency); return sprintf(buf, "%d\n", device_info.ClientMonitorLatency);
} } else if (!strcmp(dev_attr->attr.name, "client_monitor_conn_id")) {
else if (!strcmp(dev_attr->attr.name, "client_monitor_conn_id")) return sprintf(buf, "%d\n",
{ device_info.ClientMonitorConnectionId);
return sprintf(buf, "%d\n", device_info.ClientMonitorConnectionId); } else {
}
else
{
return 0; return 0;
} }
} }
/*++ /**
* vmbus_bus_init -Main vmbus driver initialization routine.
Name: vmbus_show_class_id() *
* Here, we
Desc: Show the device class id in sysfs * - initialize the vmbus driver context
* - setup various driver entry points
--*/ * - invoke the vmbus hv main init routine
/* static ssize_t vmbus_show_class_id(struct device *dev, struct device_attribute *attr, char *buf) */ * - get the irq resource
/* { */ * - invoke the vmbus to add the vmbus root device
/* struct device_context *device_ctx = device_to_device_context(dev); */ * - setup the vmbus root device
/* return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n", */ * - retrieve the channel offers
/* device_ctx->class_id[3], device_ctx->class_id[2], device_ctx->class_id[1], device_ctx->class_id[0], */ */
/* device_ctx->class_id[5], device_ctx->class_id[4], */
/* device_ctx->class_id[7], device_ctx->class_id[6], */
/* device_ctx->class_id[8], device_ctx->class_id[9], device_ctx->class_id[10], device_ctx->class_id[11], device_ctx->class_id[12], device_ctx->class_id[13], device_ctx->class_id[14], device_ctx->class_id[15]); */
/* } */
/*++
Name: vmbus_show_device_id()
Desc: Show the device instance id in sysfs
--*/
/* static ssize_t vmbus_show_device_id(struct device *dev, struct device_attribute *attr, char *buf) */
/* { */
/* struct device_context *device_ctx = device_to_device_context(dev); */
/* return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n", */
/* device_ctx->device_id[3], device_ctx->device_id[2], device_ctx->device_id[1], device_ctx->device_id[0], */
/* device_ctx->device_id[5], device_ctx->device_id[4], */
/* device_ctx->device_id[7], device_ctx->device_id[6], */
/* device_ctx->device_id[8], device_ctx->device_id[9], device_ctx->device_id[10], device_ctx->device_id[11], device_ctx->device_id[12], device_ctx->device_id[13], device_ctx->device_id[14], device_ctx->device_id[15]); */
/* } */
/*++
Name: vmbus_bus_init()
Desc: Main vmbus driver initialization routine. Here, we
- initialize the vmbus driver context
- setup various driver entry points
- invoke the vmbus hv main init routine
- get the irq resource
- invoke the vmbus to add the vmbus root device
- setup the vmbus root device
- retrieve the channel offers
--*/
static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init) static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init)
{ {
int ret=0; struct vmbus_driver_context *vmbus_drv_ctx = &g_vmbus_drv;
unsigned int vector=0;
struct vmbus_driver_context *vmbus_drv_ctx=&g_vmbus_drv;
struct vmbus_driver *vmbus_drv_obj = &g_vmbus_drv.drv_obj; struct vmbus_driver *vmbus_drv_obj = &g_vmbus_drv.drv_obj;
struct device_context *dev_ctx = &g_vmbus_drv.device_ctx;
struct device_context *dev_ctx=&g_vmbus_drv.device_ctx; int ret;
unsigned int vector;
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
/* Set this up to allow lower layer to callback to add/remove child devices on the bus */ /*
* Set this up to allow lower layer to callback to add/remove child
* devices on the bus
*/
vmbus_drv_obj->OnChildDeviceCreate = vmbus_child_device_create; vmbus_drv_obj->OnChildDeviceCreate = vmbus_child_device_create;
vmbus_drv_obj->OnChildDeviceDestroy = vmbus_child_device_destroy; vmbus_drv_obj->OnChildDeviceDestroy = vmbus_child_device_destroy;
vmbus_drv_obj->OnChildDeviceAdd = vmbus_child_device_register; vmbus_drv_obj->OnChildDeviceAdd = vmbus_child_device_register;
...@@ -339,15 +262,13 @@ static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init) ...@@ -339,15 +262,13 @@ static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init)
/* Call to bus driver to initialize */ /* Call to bus driver to initialize */
ret = pfn_drv_init(&vmbus_drv_obj->Base); ret = pfn_drv_init(&vmbus_drv_obj->Base);
if (ret != 0) if (ret != 0) {
{
DPRINT_ERR(VMBUS_DRV, "Unable to initialize vmbus (%d)", ret); DPRINT_ERR(VMBUS_DRV, "Unable to initialize vmbus (%d)", ret);
goto cleanup; goto cleanup;
} }
/* Sanity checks */ /* Sanity checks */
if (!vmbus_drv_obj->Base.OnDeviceAdd) if (!vmbus_drv_obj->Base.OnDeviceAdd) {
{
DPRINT_ERR(VMBUS_DRV, "OnDeviceAdd() routine not set"); DPRINT_ERR(VMBUS_DRV, "OnDeviceAdd() routine not set");
ret = -1; ret = -1;
goto cleanup; goto cleanup;
...@@ -356,27 +277,25 @@ static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init) ...@@ -356,27 +277,25 @@ static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init)
vmbus_drv_ctx->bus.name = vmbus_drv_obj->Base.name; vmbus_drv_ctx->bus.name = vmbus_drv_obj->Base.name;
/* Initialize the bus context */ /* Initialize the bus context */
tasklet_init(&vmbus_drv_ctx->msg_dpc, vmbus_msg_dpc, (unsigned long)vmbus_drv_obj); tasklet_init(&vmbus_drv_ctx->msg_dpc, vmbus_msg_dpc,
tasklet_init(&vmbus_drv_ctx->event_dpc, vmbus_event_dpc, (unsigned long)vmbus_drv_obj); (unsigned long)vmbus_drv_obj);
tasklet_init(&vmbus_drv_ctx->event_dpc, vmbus_event_dpc,
(unsigned long)vmbus_drv_obj);
/* Now, register the bus driver with LDM */ /* Now, register the bus driver with LDM */
ret = bus_register(&vmbus_drv_ctx->bus); ret = bus_register(&vmbus_drv_ctx->bus);
if (ret) if (ret) {
{
ret = -1; ret = -1;
goto cleanup; goto cleanup;
} }
/* Get the interrupt resource */ /* Get the interrupt resource */
ret = request_irq(vmbus_irq, ret = request_irq(vmbus_irq, vmbus_isr, IRQF_SAMPLE_RANDOM,
vmbus_isr, vmbus_drv_obj->Base.name, NULL);
IRQF_SAMPLE_RANDOM,
vmbus_drv_obj->Base.name,
NULL);
if (ret != 0) if (ret != 0) {
{ DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to request IRQ %d",
DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to request IRQ %d", vmbus_irq); vmbus_irq);
bus_unregister(&vmbus_drv_ctx->bus); bus_unregister(&vmbus_drv_ctx->bus);
...@@ -391,9 +310,9 @@ static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init) ...@@ -391,9 +310,9 @@ static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init)
memset(dev_ctx, 0, sizeof(struct device_context)); memset(dev_ctx, 0, sizeof(struct device_context));
ret = vmbus_drv_obj->Base.OnDeviceAdd(&dev_ctx->device_obj, &vector); ret = vmbus_drv_obj->Base.OnDeviceAdd(&dev_ctx->device_obj, &vector);
if (ret != 0) if (ret != 0) {
{ DPRINT_ERR(VMBUS_DRV,
DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to add vmbus root device"); "ERROR - Unable to add vmbus root device");
free_irq(vmbus_irq, NULL); free_irq(vmbus_irq, NULL);
...@@ -404,21 +323,24 @@ static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init) ...@@ -404,21 +323,24 @@ static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init)
} }
/* strcpy(dev_ctx->device.bus_id, dev_ctx->device_obj.name); */ /* strcpy(dev_ctx->device.bus_id, dev_ctx->device_obj.name); */
dev_set_name(&dev_ctx->device, "vmbus_0_0"); dev_set_name(&dev_ctx->device, "vmbus_0_0");
memcpy(&dev_ctx->class_id, &dev_ctx->device_obj.deviceType, sizeof(struct hv_guid)); memcpy(&dev_ctx->class_id, &dev_ctx->device_obj.deviceType,
memcpy(&dev_ctx->device_id, &dev_ctx->device_obj.deviceInstance, sizeof(struct hv_guid)); sizeof(struct hv_guid));
memcpy(&dev_ctx->device_id, &dev_ctx->device_obj.deviceInstance,
sizeof(struct hv_guid));
/* No need to bind a driver to the root device. */ /* No need to bind a driver to the root device. */
dev_ctx->device.parent = NULL; dev_ctx->device.parent = NULL;
dev_ctx->device.bus = &vmbus_drv_ctx->bus; /* NULL; vmbus_remove() does not get invoked */ /* NULL; vmbus_remove() does not get invoked */
dev_ctx->device.bus = &vmbus_drv_ctx->bus;
/* Setup the device dispatch table */ /* Setup the device dispatch table */
dev_ctx->device.release = vmbus_bus_release; dev_ctx->device.release = vmbus_bus_release;
/* Setup the bus as root device */ /* Setup the bus as root device */
ret = device_register(&dev_ctx->device); ret = device_register(&dev_ctx->device);
if (ret) if (ret) {
{ DPRINT_ERR(VMBUS_DRV,
DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to register vmbus root device"); "ERROR - Unable to register vmbus root device");
free_irq(vmbus_irq, NULL); free_irq(vmbus_irq, NULL);
bus_unregister(&vmbus_drv_ctx->bus); bus_unregister(&vmbus_drv_ctx->bus);
...@@ -436,20 +358,17 @@ static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init) ...@@ -436,20 +358,17 @@ static int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init)
return ret; return ret;
} }
/**
/*++ * vmbus_bus_exit - Terminate the vmbus driver.
*
Name: vmbus_bus_exit() * This routine is opposite of vmbus_bus_init()
*/
Desc: Terminate the vmbus driver. This routine is opposite of vmbus_bus_init()
--*/
static void vmbus_bus_exit(void) static void vmbus_bus_exit(void)
{ {
struct vmbus_driver *vmbus_drv_obj = &g_vmbus_drv.drv_obj; struct vmbus_driver *vmbus_drv_obj = &g_vmbus_drv.drv_obj;
struct vmbus_driver_context *vmbus_drv_ctx=&g_vmbus_drv; struct vmbus_driver_context *vmbus_drv_ctx = &g_vmbus_drv;
struct device_context *dev_ctx=&g_vmbus_drv.device_ctx; struct device_context *dev_ctx = &g_vmbus_drv.device_ctx;
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
...@@ -475,21 +394,18 @@ static void vmbus_bus_exit(void) ...@@ -475,21 +394,18 @@ static void vmbus_bus_exit(void)
return; return;
} }
/*++ /**
* vmbus_child_driver_register - Register a vmbus's child driver
Name: vmbus_child_driver_register() */
int vmbus_child_driver_register(struct driver_context *driver_ctx)
Desc: Register a vmbus's child driver
--*/
int vmbus_child_driver_register(struct driver_context* driver_ctx)
{ {
struct vmbus_driver *vmbus_drv_obj = &g_vmbus_drv.drv_obj; struct vmbus_driver *vmbus_drv_obj = &g_vmbus_drv.drv_obj;
int ret; int ret;
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
DPRINT_INFO(VMBUS_DRV, "child driver (%p) registering - name %s", driver_ctx, driver_ctx->driver.name); DPRINT_INFO(VMBUS_DRV, "child driver (%p) registering - name %s",
driver_ctx, driver_ctx->driver.name);
/* The child driver on this vmbus */ /* The child driver on this vmbus */
driver_ctx->driver.bus = &g_vmbus_drv.bus; driver_ctx->driver.bus = &g_vmbus_drv.bus;
...@@ -502,21 +418,17 @@ int vmbus_child_driver_register(struct driver_context* driver_ctx) ...@@ -502,21 +418,17 @@ int vmbus_child_driver_register(struct driver_context* driver_ctx)
return ret; return ret;
} }
EXPORT_SYMBOL(vmbus_child_driver_register); EXPORT_SYMBOL(vmbus_child_driver_register);
/*++ /**
* vmbus_child_driver_unregister Unregister a vmbus's child driver
Name: vmbus_child_driver_unregister() */
void vmbus_child_driver_unregister(struct driver_context *driver_ctx)
Desc: Unregister a vmbus's child driver
--*/
void vmbus_child_driver_unregister(struct driver_context* driver_ctx)
{ {
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
DPRINT_INFO(VMBUS_DRV, "child driver (%p) unregistering - name %s", driver_ctx, driver_ctx->driver.name); DPRINT_INFO(VMBUS_DRV, "child driver (%p) unregistering - name %s",
driver_ctx, driver_ctx->driver.name);
driver_unregister(&driver_ctx->driver); driver_unregister(&driver_ctx->driver);
...@@ -524,47 +436,37 @@ void vmbus_child_driver_unregister(struct driver_context* driver_ctx) ...@@ -524,47 +436,37 @@ void vmbus_child_driver_unregister(struct driver_context* driver_ctx)
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
} }
EXPORT_SYMBOL(vmbus_child_driver_unregister); EXPORT_SYMBOL(vmbus_child_driver_unregister);
/*++ /**
* vmbus_get_interface - Get the vmbus channel interface.
Name: vmbus_get_interface() *
* This is invoked by child/client driver that sits above vmbus
Desc: Get the vmbus channel interface. This is invoked by child/client driver that sits */
above vmbus
--*/
void vmbus_get_interface(struct vmbus_channel_interface *interface) void vmbus_get_interface(struct vmbus_channel_interface *interface)
{ {
struct vmbus_driver *vmbus_drv_obj = &g_vmbus_drv.drv_obj; struct vmbus_driver *vmbus_drv_obj = &g_vmbus_drv.drv_obj;
vmbus_drv_obj->GetChannelInterface(interface); vmbus_drv_obj->GetChannelInterface(interface);
} }
EXPORT_SYMBOL(vmbus_get_interface); EXPORT_SYMBOL(vmbus_get_interface);
/**
/*++ * vmbus_child_device_get_info - Get the vmbus child device info.
*
Name: vmbus_child_device_get_info() * This is invoked to display various device attributes in sysfs.
*/
Desc: Get the vmbus child device info. This is invoked to display various device attributes in sysfs. static void vmbus_child_device_get_info(struct hv_device *device_obj,
--*/ struct hv_device_info *device_info)
static void vmbus_child_device_get_info(struct hv_device *device_obj, struct hv_device_info *device_info)
{ {
struct vmbus_driver *vmbus_drv_obj = &g_vmbus_drv.drv_obj; struct vmbus_driver *vmbus_drv_obj = &g_vmbus_drv.drv_obj;
vmbus_drv_obj->GetChannelInfo(device_obj, device_info); vmbus_drv_obj->GetChannelInfo(device_obj, device_info);
} }
/**
/*++ * vmbus_child_device_create - Creates and registers a new child device on the vmbus.
*/
Name: vmbus_child_device_create()
Desc: Creates and registers a new child device on the vmbus.
--*/
static struct hv_device *vmbus_child_device_create(struct hv_guid *type, static struct hv_device *vmbus_child_device_create(struct hv_guid *type,
struct hv_guid *instance, struct hv_guid *instance,
void *context) void *context)
...@@ -576,31 +478,38 @@ static struct hv_device *vmbus_child_device_create(struct hv_guid *type, ...@@ -576,31 +478,38 @@ static struct hv_device *vmbus_child_device_create(struct hv_guid *type,
/* Allocate the new child device */ /* Allocate the new child device */
child_device_ctx = kzalloc(sizeof(struct device_context), GFP_KERNEL); child_device_ctx = kzalloc(sizeof(struct device_context), GFP_KERNEL);
if (!child_device_ctx) if (!child_device_ctx) {
{ DPRINT_ERR(VMBUS_DRV,
DPRINT_ERR(VMBUS_DRV, "unable to allocate device_context for child device"); "unable to allocate device_context for child device");
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
return NULL; return NULL;
} }
DPRINT_DBG(VMBUS_DRV, "child device (%p) allocated - " DPRINT_DBG(VMBUS_DRV, "child device (%p) allocated - "
"type {%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}," "type {%02x%02x%02x%02x-%02x%02x-%02x%02x-"
"id {%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}", "%02x%02x%02x%02x%02x%02x%02x%02x},"
"id {%02x%02x%02x%02x-%02x%02x-%02x%02x-"
"%02x%02x%02x%02x%02x%02x%02x%02x}",
&child_device_ctx->device, &child_device_ctx->device,
type->data[3], type->data[2], type->data[1], type->data[0], type->data[3], type->data[2], type->data[1], type->data[0],
type->data[5], type->data[4], type->data[7], type->data[6], type->data[5], type->data[4], type->data[7], type->data[6],
type->data[8], type->data[9], type->data[10], type->data[11], type->data[8], type->data[9], type->data[10], type->data[11],
type->data[12], type->data[13], type->data[14], type->data[15], type->data[12], type->data[13], type->data[14], type->data[15],
instance->data[3], instance->data[2], instance->data[1], instance->data[0], instance->data[3], instance->data[2],
instance->data[5], instance->data[4], instance->data[7], instance->data[6], instance->data[1], instance->data[0],
instance->data[8], instance->data[9], instance->data[10], instance->data[11], instance->data[5], instance->data[4],
instance->data[12], instance->data[13], instance->data[14], instance->data[15]); instance->data[7], instance->data[6],
instance->data[8], instance->data[9],
instance->data[10], instance->data[11],
instance->data[12], instance->data[13],
instance->data[14], instance->data[15]);
child_device_obj = &child_device_ctx->device_obj; child_device_obj = &child_device_ctx->device_obj;
child_device_obj->context = context; child_device_obj->context = context;
memcpy(&child_device_obj->deviceType, &type, sizeof(struct hv_guid)); memcpy(&child_device_obj->deviceType, &type, sizeof(struct hv_guid));
memcpy(&child_device_obj->deviceInstance, &instance, sizeof(struct hv_guid)); memcpy(&child_device_obj->deviceInstance, &instance,
sizeof(struct hv_guid));
memcpy(&child_device_ctx->class_id, &type, sizeof(struct hv_guid)); memcpy(&child_device_ctx->class_id, &type, sizeof(struct hv_guid));
memcpy(&child_device_ctx->device_id, &instance, sizeof(struct hv_guid)); memcpy(&child_device_ctx->device_id, &instance, sizeof(struct hv_guid));
...@@ -610,53 +519,59 @@ static struct hv_device *vmbus_child_device_create(struct hv_guid *type, ...@@ -610,53 +519,59 @@ static struct hv_device *vmbus_child_device_create(struct hv_guid *type,
return child_device_obj; return child_device_obj;
} }
/*++ /**
* vmbus_child_device_register - Register the child device on the specified bus
Name: vmbus_child_device_register() */
static int vmbus_child_device_register(struct hv_device *root_device_obj,
Desc: Register the child device on the specified bus struct hv_device *child_device_obj)
--*/
static int vmbus_child_device_register(struct hv_device *root_device_obj, struct hv_device *child_device_obj)
{ {
int ret=0; int ret = 0;
struct device_context *root_device_ctx = to_device_context(root_device_obj); struct device_context *root_device_ctx =
struct device_context *child_device_ctx = to_device_context(child_device_obj); to_device_context(root_device_obj);
struct device_context *child_device_ctx =
to_device_context(child_device_obj);
static atomic_t device_num = ATOMIC_INIT(0); static atomic_t device_num = ATOMIC_INIT(0);
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
DPRINT_DBG(VMBUS_DRV, "child device (%p) registering", child_device_ctx); DPRINT_DBG(VMBUS_DRV, "child device (%p) registering",
child_device_ctx);
/* Make sure we are not registered already */ /* Make sure we are not registered already */
if (strlen(dev_name(&child_device_ctx->device)) != 0) {
if (strlen(dev_name(&child_device_ctx->device)) != 0) DPRINT_ERR(VMBUS_DRV,
{ "child device (%p) already registered - busid %s",
DPRINT_ERR(VMBUS_DRV, "child device (%p) already registered - busid %s", child_device_ctx, dev_name(&child_device_ctx->device)); child_device_ctx,
dev_name(&child_device_ctx->device));
ret = -1; ret = -1;
goto Cleanup; goto Cleanup;
} }
/* Set the device bus id. Otherwise, device_register()will fail. */ /* Set the device bus id. Otherwise, device_register()will fail. */
dev_set_name(&child_device_ctx->device, "vmbus_0_%d", atomic_inc_return(&device_num)); dev_set_name(&child_device_ctx->device, "vmbus_0_%d",
atomic_inc_return(&device_num));
/* The new device belongs to this bus */ /* The new device belongs to this bus */
child_device_ctx->device.bus = &g_vmbus_drv.bus; /* device->dev.bus; */ child_device_ctx->device.bus = &g_vmbus_drv.bus; /* device->dev.bus; */
child_device_ctx->device.parent = &root_device_ctx->device; child_device_ctx->device.parent = &root_device_ctx->device;
child_device_ctx->device.release = vmbus_device_release; child_device_ctx->device.release = vmbus_device_release;
/* Register with the LDM. This will kick off the driver/device binding...which will */ /*
/* eventually call vmbus_match() and vmbus_probe() */ * Register with the LDM. This will kick off the driver/device
* binding...which will eventually call vmbus_match() and vmbus_probe()
*/
ret = device_register(&child_device_ctx->device); ret = device_register(&child_device_ctx->device);
/* vmbus_probe() error does not get propergate to device_register(). */ /* vmbus_probe() error does not get propergate to device_register(). */
ret = child_device_ctx->probe_error; ret = child_device_ctx->probe_error;
if (ret) if (ret)
DPRINT_ERR(VMBUS_DRV, "unable to register child device (%p)", &child_device_ctx->device); DPRINT_ERR(VMBUS_DRV, "unable to register child device (%p)",
&child_device_ctx->device);
else else
DPRINT_INFO(VMBUS_DRV, "child device (%p) registered", &child_device_ctx->device); DPRINT_INFO(VMBUS_DRV, "child device (%p) registered",
&child_device_ctx->device);
Cleanup: Cleanup:
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
...@@ -664,38 +579,33 @@ static int vmbus_child_device_register(struct hv_device *root_device_obj, struct ...@@ -664,38 +579,33 @@ static int vmbus_child_device_register(struct hv_device *root_device_obj, struct
return ret; return ret;
} }
/*++ /**
* vmbus_child_device_unregister - Remove the specified child device from the vmbus.
Name: vmbus_child_device_unregister() */
Desc: Remove the specified child device from the vmbus.
--*/
static void vmbus_child_device_unregister(struct hv_device *device_obj) static void vmbus_child_device_unregister(struct hv_device *device_obj)
{ {
struct device_context *device_ctx = to_device_context(device_obj); struct device_context *device_ctx = to_device_context(device_obj);
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
DPRINT_INFO(VMBUS_DRV, "unregistering child device (%p)", &device_ctx->device); DPRINT_INFO(VMBUS_DRV, "unregistering child device (%p)",
&device_ctx->device);
/* Kick off the process of unregistering the device. */ /*
/* This will call vmbus_remove() and eventually vmbus_device_release() */ * Kick off the process of unregistering the device.
* This will call vmbus_remove() and eventually vmbus_device_release()
*/
device_unregister(&device_ctx->device); device_unregister(&device_ctx->device);
DPRINT_INFO(VMBUS_DRV, "child device (%p) unregistered", &device_ctx->device); DPRINT_INFO(VMBUS_DRV, "child device (%p) unregistered",
&device_ctx->device);
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
} }
/**
/*++ * vmbus_child_device_destroy - Destroy the specified child device on the vmbus.
*/
Name: vmbus_child_device_destroy()
Desc: Destroy the specified child device on the vmbus.
--*/
static void vmbus_child_device_destroy(struct hv_device *device_obj) static void vmbus_child_device_destroy(struct hv_device *device_obj)
{ {
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
...@@ -703,66 +613,83 @@ static void vmbus_child_device_destroy(struct hv_device *device_obj) ...@@ -703,66 +613,83 @@ static void vmbus_child_device_destroy(struct hv_device *device_obj)
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
} }
/*++ /**
* vmbus_uevent - add uevent for our device
Name: vmbus_uevent() *
* This routine is invoked when a device is added or removed on the vmbus to
Desc: This routine is invoked when a device is added or removed on the vmbus to generate a uevent to udev in the * generate a uevent to udev in the userspace. The udev will then look at its
userspace. The udev will then look at its rule and the uevent generated here to load the appropriate driver * rule and the uevent generated here to load the appropriate driver
*/
--*/
static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env) static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
{ {
struct device_context *device_ctx = device_to_device_context(device); struct device_context *device_ctx = device_to_device_context(device);
int i=0; int i = 0;
int len=0; int len = 0;
int ret; int ret;
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
DPRINT_INFO(VMBUS_DRV, "generating uevent - VMBUS_DEVICE_CLASS_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}", DPRINT_INFO(VMBUS_DRV, "generating uevent - VMBUS_DEVICE_CLASS_GUID={"
device_ctx->class_id.data[3], device_ctx->class_id.data[2], "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
device_ctx->class_id.data[1], device_ctx->class_id.data[0], "%02x%02x%02x%02x%02x%02x%02x%02x}",
device_ctx->class_id.data[5], device_ctx->class_id.data[4], device_ctx->class_id.data[3], device_ctx->class_id.data[2],
device_ctx->class_id.data[7], device_ctx->class_id.data[6], device_ctx->class_id.data[1], device_ctx->class_id.data[0],
device_ctx->class_id.data[8], device_ctx->class_id.data[9], device_ctx->class_id.data[5], device_ctx->class_id.data[4],
device_ctx->class_id.data[10], device_ctx->class_id.data[11], device_ctx->class_id.data[7], device_ctx->class_id.data[6],
device_ctx->class_id.data[12], device_ctx->class_id.data[13], device_ctx->class_id.data[8], device_ctx->class_id.data[9],
device_ctx->class_id.data[14], device_ctx->class_id.data[15]); device_ctx->class_id.data[10],
device_ctx->class_id.data[11],
device_ctx->class_id.data[12],
device_ctx->class_id.data[13],
device_ctx->class_id.data[14],
device_ctx->class_id.data[15]);
env->envp_idx = i; env->envp_idx = i;
env->buflen = len; env->buflen = len;
ret = add_uevent_var(env, ret = add_uevent_var(env, "VMBUS_DEVICE_CLASS_GUID={"
"VMBUS_DEVICE_CLASS_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}", "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
device_ctx->class_id.data[3], device_ctx->class_id.data[2], "%02x%02x%02x%02x%02x%02x%02x%02x}",
device_ctx->class_id.data[1], device_ctx->class_id.data[0], device_ctx->class_id.data[3],
device_ctx->class_id.data[5], device_ctx->class_id.data[4], device_ctx->class_id.data[2],
device_ctx->class_id.data[7], device_ctx->class_id.data[6], device_ctx->class_id.data[1],
device_ctx->class_id.data[8], device_ctx->class_id.data[9], device_ctx->class_id.data[0],
device_ctx->class_id.data[10], device_ctx->class_id.data[11], device_ctx->class_id.data[5],
device_ctx->class_id.data[12], device_ctx->class_id.data[13], device_ctx->class_id.data[4],
device_ctx->class_id.data[14], device_ctx->class_id.data[15]); device_ctx->class_id.data[7],
device_ctx->class_id.data[6],
device_ctx->class_id.data[8],
device_ctx->class_id.data[9],
device_ctx->class_id.data[10],
device_ctx->class_id.data[11],
device_ctx->class_id.data[12],
device_ctx->class_id.data[13],
device_ctx->class_id.data[14],
device_ctx->class_id.data[15]);
if (ret) if (ret)
{
return ret; return ret;
}
ret = add_uevent_var(env,
"VMBUS_DEVICE_DEVICE_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
device_ctx->device_id.data[3], device_ctx->device_id.data[2],
device_ctx->device_id.data[1], device_ctx->device_id.data[0],
device_ctx->device_id.data[5], device_ctx->device_id.data[4],
device_ctx->device_id.data[7], device_ctx->device_id.data[6],
device_ctx->device_id.data[8], device_ctx->device_id.data[9],
device_ctx->device_id.data[10], device_ctx->device_id.data[11],
device_ctx->device_id.data[12], device_ctx->device_id.data[13],
device_ctx->device_id.data[14], device_ctx->device_id.data[15]);
ret = add_uevent_var(env, "VMBUS_DEVICE_DEVICE_GUID={"
"%02x%02x%02x%02x-%02x%02x-%02x%02x-"
"%02x%02x%02x%02x%02x%02x%02x%02x}",
device_ctx->device_id.data[3],
device_ctx->device_id.data[2],
device_ctx->device_id.data[1],
device_ctx->device_id.data[0],
device_ctx->device_id.data[5],
device_ctx->device_id.data[4],
device_ctx->device_id.data[7],
device_ctx->device_id.data[6],
device_ctx->device_id.data[8],
device_ctx->device_id.data[9],
device_ctx->device_id.data[10],
device_ctx->device_id.data[11],
device_ctx->device_id.data[12],
device_ctx->device_id.data[13],
device_ctx->device_id.data[14],
device_ctx->device_id.data[15]);
if (ret) if (ret)
{
return ret; return ret;
}
env->envp[env->envp_idx] = NULL; env->envp[env->envp_idx] = NULL;
...@@ -771,29 +698,32 @@ static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env) ...@@ -771,29 +698,32 @@ static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
return 0; return 0;
} }
/*++ /**
* vmbus_match - Attempt to match the specified device to the specified driver
Name: vmbus_match() */
Desc: Attempt to match the specified device to the specified driver
--*/
static int vmbus_match(struct device *device, struct device_driver *driver) static int vmbus_match(struct device *device, struct device_driver *driver)
{ {
int match=0; int match = 0;
struct driver_context *driver_ctx = driver_to_driver_context(driver); struct driver_context *driver_ctx = driver_to_driver_context(driver);
struct device_context *device_ctx = device_to_device_context(device); struct device_context *device_ctx = device_to_device_context(device);
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
/* We found our driver ? */ /* We found our driver ? */
if (memcmp(&device_ctx->class_id, &driver_ctx->class_id, sizeof(struct hv_guid)) == 0) if (memcmp(&device_ctx->class_id, &driver_ctx->class_id,
{ sizeof(struct hv_guid)) == 0) {
/* !! NOTE: The driver_ctx is not a vmbus_drv_ctx. We typecast it here to access the */ /*
/* struct hv_driver field */ * !! NOTE: The driver_ctx is not a vmbus_drv_ctx. We typecast
struct vmbus_driver_context *vmbus_drv_ctx = (struct vmbus_driver_context*)driver_ctx; * it here to access the struct hv_driver field
*/
struct vmbus_driver_context *vmbus_drv_ctx =
(struct vmbus_driver_context *)driver_ctx;
device_ctx->device_obj.Driver = &vmbus_drv_ctx->drv_obj.Base; device_ctx->device_obj.Driver = &vmbus_drv_ctx->drv_obj.Base;
DPRINT_INFO(VMBUS_DRV, "device object (%p) set to driver object (%p)", &device_ctx->device_obj, device_ctx->device_obj.Driver); DPRINT_INFO(VMBUS_DRV,
"device object (%p) set to driver object (%p)",
&device_ctx->device_obj,
device_ctx->device_obj.Driver);
match = 1; match = 1;
} }
...@@ -803,62 +733,58 @@ static int vmbus_match(struct device *device, struct device_driver *driver) ...@@ -803,62 +733,58 @@ static int vmbus_match(struct device *device, struct device_driver *driver)
return match; return match;
} }
/**
/*++ * vmbus_probe_failed_cb - Callback when a driver probe failed in vmbus_probe()
*
Name: vmbus_probe_failed_cb() * We need a callback because we cannot invoked device_unregister() inside
* vmbus_probe() since vmbus_probe() may be invoked inside device_register()
Desc: Callback when a driver probe failed in vmbus_probe(). We need a callback because * i.e. we cannot call device_unregister() inside device_register()
we cannot invoked device_unregister() inside vmbus_probe() since vmbus_probe() may be */
invoked inside device_register() i.e. we cannot call device_unregister() inside
device_register()
--*/
static void vmbus_probe_failed_cb(struct work_struct *context) static void vmbus_probe_failed_cb(struct work_struct *context)
{ {
struct device_context *device_ctx = (struct device_context*)context; struct device_context *device_ctx = (struct device_context *)context;
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
/* Kick off the process of unregistering the device. */ /*
/* This will call vmbus_remove() and eventually vmbus_device_release() */ * Kick off the process of unregistering the device.
* This will call vmbus_remove() and eventually vmbus_device_release()
*/
device_unregister(&device_ctx->device); device_unregister(&device_ctx->device);
/* put_device(&device_ctx->device); */ /* put_device(&device_ctx->device); */
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
} }
/**
/*++ * vmbus_probe - Add the new vmbus's child device
*/
Name: vmbus_probe()
Desc: Add the new vmbus's child device
--*/
static int vmbus_probe(struct device *child_device) static int vmbus_probe(struct device *child_device)
{ {
int ret=0; int ret = 0;
struct driver_context *driver_ctx = driver_to_driver_context(child_device->driver); struct driver_context *driver_ctx =
struct device_context *device_ctx = device_to_device_context(child_device); driver_to_driver_context(child_device->driver);
struct device_context *device_ctx =
device_to_device_context(child_device);
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
/* Let the specific open-source driver handles the probe if it can */ /* Let the specific open-source driver handles the probe if it can */
if (driver_ctx->probe) if (driver_ctx->probe) {
{
ret = device_ctx->probe_error = driver_ctx->probe(child_device); ret = device_ctx->probe_error = driver_ctx->probe(child_device);
if (ret != 0) if (ret != 0) {
{ DPRINT_ERR(VMBUS_DRV, "probe() failed for device %s "
DPRINT_ERR(VMBUS_DRV, "probe() failed for device %s (%p) on driver %s (%d)...", dev_name(child_device), child_device, child_device->driver->name, ret); "(%p) on driver %s (%d)...",
dev_name(child_device), child_device,
INIT_WORK(&device_ctx->probe_failed_work_item, vmbus_probe_failed_cb); child_device->driver->name, ret);
INIT_WORK(&device_ctx->probe_failed_work_item,
vmbus_probe_failed_cb);
schedule_work(&device_ctx->probe_failed_work_item); schedule_work(&device_ctx->probe_failed_work_item);
} }
} } else {
else DPRINT_ERR(VMBUS_DRV, "probe() method not set for driver - %s",
{ child_device->driver->name);
DPRINT_ERR(VMBUS_DRV, "probe() method not set for driver - %s", child_device->driver->name);
ret = -1; ret = -1;
} }
...@@ -866,61 +792,51 @@ static int vmbus_probe(struct device *child_device) ...@@ -866,61 +792,51 @@ static int vmbus_probe(struct device *child_device)
return ret; return ret;
} }
/**
/*++ * vmbus_remove - Remove a vmbus device
*/
Name: vmbus_remove()
Desc: Remove a vmbus device
--*/
static int vmbus_remove(struct device *child_device) static int vmbus_remove(struct device *child_device)
{ {
int ret=0; int ret;
struct driver_context *driver_ctx; struct driver_context *driver_ctx;
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
/* Special case root bus device */ /* Special case root bus device */
if (child_device->parent == NULL) if (child_device->parent == NULL) {
{ /*
/* No-op since it is statically defined and handle in vmbus_bus_exit() */ * No-op since it is statically defined and handle in
* vmbus_bus_exit()
*/
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
return 0; return 0;
} }
if (child_device->driver) if (child_device->driver) {
{
driver_ctx = driver_to_driver_context(child_device->driver); driver_ctx = driver_to_driver_context(child_device->driver);
/* Let the specific open-source driver handles the removal if it can */ /*
if (driver_ctx->remove) * Let the specific open-source driver handles the removal if
{ * it can
*/
if (driver_ctx->remove) {
ret = driver_ctx->remove(child_device); ret = driver_ctx->remove(child_device);
} } else {
else DPRINT_ERR(VMBUS_DRV,
{ "remove() method not set for driver - %s",
DPRINT_ERR(VMBUS_DRV, "remove() method not set for driver - %s", child_device->driver->name); child_device->driver->name);
ret = -1; ret = -1;
} }
} }
else
{
}
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
return 0; return 0;
} }
/*++ /**
* vmbus_shutdown - Shutdown a vmbus device
Name: vmbus_shutdown() */
Desc: Shutdown a vmbus device
--*/
static void vmbus_shutdown(struct device *child_device) static void vmbus_shutdown(struct device *child_device)
{ {
struct driver_context *driver_ctx; struct driver_context *driver_ctx;
...@@ -928,16 +844,17 @@ static void vmbus_shutdown(struct device *child_device) ...@@ -928,16 +844,17 @@ static void vmbus_shutdown(struct device *child_device)
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
/* Special case root bus device */ /* Special case root bus device */
if (child_device->parent == NULL) if (child_device->parent == NULL) {
{ /*
/* No-op since it is statically defined and handle in vmbus_bus_exit() */ * No-op since it is statically defined and handle in
* vmbus_bus_exit()
*/
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
return; return;
} }
/* The device may not be attached yet */ /* The device may not be attached yet */
if (!child_device->driver) if (!child_device->driver) {
{
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
return; return;
} }
...@@ -946,22 +863,16 @@ static void vmbus_shutdown(struct device *child_device) ...@@ -946,22 +863,16 @@ static void vmbus_shutdown(struct device *child_device)
/* Let the specific open-source driver handles the removal if it can */ /* Let the specific open-source driver handles the removal if it can */
if (driver_ctx->shutdown) if (driver_ctx->shutdown)
{
driver_ctx->shutdown(child_device); driver_ctx->shutdown(child_device);
}
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
return; return;
} }
/*++ /**
* vmbus_bus_release - Final callback release of the vmbus root device
Name: vmbus_bus_release() */
Desc: Final callback release of the vmbus root device
--*/
static void vmbus_bus_release(struct device *device) static void vmbus_bus_release(struct device *device)
{ {
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
...@@ -973,13 +884,9 @@ static void vmbus_bus_release(struct device *device) ...@@ -973,13 +884,9 @@ static void vmbus_bus_release(struct device *device)
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
} }
/*++ /**
* vmbus_device_release - Final callback release of the vmbus child device
Name: vmbus_device_release() */
Desc: Final callback release of the vmbus child device
--*/
static void vmbus_device_release(struct device *device) static void vmbus_device_release(struct device *device)
{ {
struct device_context *device_ctx = device_to_device_context(device); struct device_context *device_ctx = device_to_device_context(device);
...@@ -990,19 +897,14 @@ static void vmbus_device_release(struct device *device) ...@@ -990,19 +897,14 @@ static void vmbus_device_release(struct device *device)
kfree(device_ctx); kfree(device_ctx);
/* !!DO NOT REFERENCE device_ctx anymore at this point!! */ /* !!DO NOT REFERENCE device_ctx anymore at this point!! */
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
return; return;
} }
/*++ /**
* vmbus_msg_dpc - Tasklet routine to handle hypervisor messages
Name: vmbus_msg_dpc() */
Desc: Tasklet routine to handle hypervisor messages
--*/
static void vmbus_msg_dpc(unsigned long data) static void vmbus_msg_dpc(unsigned long data)
{ {
struct vmbus_driver *vmbus_drv_obj = (struct vmbus_driver *)data; struct vmbus_driver *vmbus_drv_obj = (struct vmbus_driver *)data;
...@@ -1017,13 +919,9 @@ static void vmbus_msg_dpc(unsigned long data) ...@@ -1017,13 +919,9 @@ static void vmbus_msg_dpc(unsigned long data)
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
} }
/*++ /**
* vmbus_msg_dpc - Tasklet routine to handle hypervisor events
Name: vmbus_msg_dpc() */
Desc: Tasklet routine to handle hypervisor events
--*/
static void vmbus_event_dpc(unsigned long data) static void vmbus_event_dpc(unsigned long data)
{ {
struct vmbus_driver *vmbus_drv_obj = (struct vmbus_driver *)data; struct vmbus_driver *vmbus_drv_obj = (struct vmbus_driver *)data;
...@@ -1038,17 +936,10 @@ static void vmbus_event_dpc(unsigned long data) ...@@ -1038,17 +936,10 @@ static void vmbus_event_dpc(unsigned long data)
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
} }
/*++ static irqreturn_t vmbus_isr(int irq, void *dev_id)
Name: vmbus_msg_dpc()
Desc: ISR routine
--*/
static irqreturn_t vmbus_isr(int irq, void* dev_id)
{ {
int ret=0;
struct vmbus_driver *vmbus_driver_obj = &g_vmbus_drv.drv_obj; struct vmbus_driver *vmbus_driver_obj = &g_vmbus_drv.drv_obj;
int ret;
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
...@@ -1058,48 +949,31 @@ static irqreturn_t vmbus_isr(int irq, void* dev_id) ...@@ -1058,48 +949,31 @@ static irqreturn_t vmbus_isr(int irq, void* dev_id)
ret = vmbus_driver_obj->OnIsr(&vmbus_driver_obj->Base); ret = vmbus_driver_obj->OnIsr(&vmbus_driver_obj->Base);
/* Schedules a dpc if necessary */ /* Schedules a dpc if necessary */
if (ret > 0) if (ret > 0) {
{ if (test_bit(0, (unsigned long *)&ret))
if (test_bit(0, (unsigned long*)&ret))
{
tasklet_schedule(&g_vmbus_drv.msg_dpc); tasklet_schedule(&g_vmbus_drv.msg_dpc);
}
if (test_bit(1, (unsigned long*)&ret)) if (test_bit(1, (unsigned long *)&ret))
{
tasklet_schedule(&g_vmbus_drv.event_dpc); tasklet_schedule(&g_vmbus_drv.event_dpc);
}
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
return IRQ_HANDLED; return IRQ_HANDLED;
} } else {
else
{
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
return IRQ_NONE; return IRQ_NONE;
} }
} }
MODULE_LICENSE("GPL");
/*++
Name: vmbus_init()
Desc: Main vmbus driver entry routine
--*/
static int __init vmbus_init(void) static int __init vmbus_init(void)
{ {
int ret=0; int ret = 0;
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
DPRINT_INFO(VMBUS_DRV, DPRINT_INFO(VMBUS_DRV,
"Vmbus initializing.... current log level 0x%x (%x,%x)", "Vmbus initializing.... current log level 0x%x (%x,%x)",
vmbus_loglevel, HIWORD(vmbus_loglevel), LOWORD(vmbus_loglevel)); vmbus_loglevel, HIWORD(vmbus_loglevel), LOWORD(vmbus_loglevel));
/* Todo: it is used for loglevel, to be ported to new kernel. */ /* Todo: it is used for loglevel, to be ported to new kernel. */
ret = vmbus_bus_init(VmbusInitialize); ret = vmbus_bus_init(VmbusInitialize);
...@@ -1107,29 +981,19 @@ static int __init vmbus_init(void) ...@@ -1107,29 +981,19 @@ static int __init vmbus_init(void)
return ret; return ret;
} }
/*++
Name: vmbus_init()
Desc: Main vmbus driver exit routine
--*/
static void __exit vmbus_exit(void) static void __exit vmbus_exit(void)
{ {
DPRINT_ENTER(VMBUS_DRV); DPRINT_ENTER(VMBUS_DRV);
vmbus_bus_exit(); vmbus_bus_exit();
/* Todo: it is used for loglevel, to be ported to new kernel. */ /* Todo: it is used for loglevel, to be ported to new kernel. */
DPRINT_EXIT(VMBUS_DRV); DPRINT_EXIT(VMBUS_DRV);
return; return;
} }
MODULE_LICENSE("GPL");
module_param(vmbus_irq, int, S_IRUGO); module_param(vmbus_irq, int, S_IRUGO);
module_param(vmbus_loglevel, int, S_IRUGO); module_param(vmbus_loglevel, int, S_IRUGO);
module_init(vmbus_init); module_init(vmbus_init);
module_exit(vmbus_exit); module_exit(vmbus_exit);
/* eof */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7