[PATCH 3/6] Staging: hv: Cleanup hyperv_device variable names

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Cleanup the names of variables that refer to the
hyperv_device abstraction.


Signed-off-by: K. Y. Srinivasan <kys@xxxxxxxxxxxxx>
Signed-off-by: K. Y. Srinivasan <kys@xxxxxxxxxxxxx>
Signed-off-by: Haiyang Zhang <haiyangz@xxxxxxxxxxxxx>
Signed-off-by: Hank Janssen <hjanssen@xxxxxxxxxxxxx>

---
 drivers/staging/hv/blkvsc_drv.c  |   12 ++--
 drivers/staging/hv/netvsc.c      |    4 +-
 drivers/staging/hv/netvsc_drv.c  |   36 ++++----
 drivers/staging/hv/storvsc_drv.c |   44 +++++-----
 drivers/staging/hv/vmbus_drv.c   |  164 +++++++++++++++++++-------------------
 5 files changed, 130 insertions(+), 130 deletions(-)

diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 58ab0e8..305a665 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -95,7 +95,7 @@ struct blkvsc_request {
 /* Per device structure */
 struct block_device_context {
 	/* point back to our device context */
-	struct hyperv_device *device_ctx;
+	struct hyperv_device *device_obj;
 	struct kmem_cache *request_pool;
 	spinlock_t lock;
 	struct gendisk *gd;
@@ -298,7 +298,7 @@ static int blkvsc_probe(struct device *device)
 		goto Cleanup;
 	}
 
-	blkdev->device_ctx = device_obj;
+	blkdev->device_obj = device_obj;
 	/* this identified the device 0 or 1 */
 	blkdev->target = device_info.target_id;
 	/* this identified the ide ctrl 0 or 1 */
@@ -367,7 +367,7 @@ static int blkvsc_probe(struct device *device)
 		blkdev->gd->first_minor = 0;
 	blkdev->gd->fops = &block_ops;
 	blkdev->gd->private_data = blkdev;
-	blkdev->gd->driverfs_dev = &(blkdev->device_ctx->device);
+	blkdev->gd->driverfs_dev = &(blkdev->device_obj->device);
 	sprintf(blkdev->gd->disk_name, "hd%c", 'a' + devnum);
 
 	blkvsc_do_inquiry(blkdev);
@@ -848,9 +848,9 @@ static int blkvsc_submit_request(struct blkvsc_request *blkvsc_req,
 			void (*request_completion)(struct hv_storvsc_request *))
 {
 	struct block_device_context *blkdev = blkvsc_req->dev;
-	struct hyperv_device *device_ctx = blkdev->device_ctx;
+	struct hyperv_device *device_obj = blkdev->device_obj;
 	struct driver_context *driver_ctx =
-			driver_to_driver_context(device_ctx->device.driver);
+			driver_to_driver_context(device_obj->device.driver);
 	struct blkvsc_driver_context *blkvsc_drv_ctx =
 			(struct blkvsc_driver_context *)driver_ctx;
 	struct storvsc_driver_object *storvsc_drv_obj =
@@ -895,7 +895,7 @@ static int blkvsc_submit_request(struct blkvsc_request *blkvsc_req,
 	storvsc_req->sense_buffer = blkvsc_req->sense_buffer;
 	storvsc_req->sense_buffer_size = SCSI_SENSE_BUFFERSIZE;
 
-	ret = storvsc_drv_obj->on_io_request(blkdev->device_ctx,
+	ret = storvsc_drv_obj->on_io_request(blkdev->device_obj,
 					   &blkvsc_req->request);
 	if (ret == 0)
 		blkdev->num_outstanding_reqs++;
diff --git a/drivers/staging/hv/netvsc.c b/drivers/staging/hv/netvsc.c
index 7841cae..7cf6999 100644
--- a/drivers/staging/hv/netvsc.c
+++ b/drivers/staging/hv/netvsc.c
@@ -44,8 +44,8 @@ static const struct hv_guid netvsc_device_type = {
 	}
 };
 
-static int netvsc_device_add(struct hyperv_device *device,
-			void *additional_info);
+static int
+netvsc_device_add(struct hyperv_device *device, void *additional_info);
 
 static int netvsc_device_remove(struct hyperv_device *device);
 
diff --git a/drivers/staging/hv/netvsc_drv.c b/drivers/staging/hv/netvsc_drv.c
index 31cbbab..fc4eb9b 100644
--- a/drivers/staging/hv/netvsc_drv.c
+++ b/drivers/staging/hv/netvsc_drv.c
@@ -44,7 +44,7 @@
 
 struct net_device_context {
 	/* point back to our device context */
-	struct hyperv_device *device_ctx;
+	struct hyperv_device *device_obj;
 	unsigned long avail;
 };
 
@@ -75,8 +75,8 @@ static void netvsc_set_multicast_list(struct net_device *net)
 
 static int netvsc_open(struct net_device *net)
 {
-	struct net_device_context *net_device_ctx = netdev_priv(net);
-	struct hyperv_device *device_obj = net_device_ctx->device_ctx;
+	struct net_device_context *net_device_obj = netdev_priv(net);
+	struct hyperv_device *device_obj = net_device_obj->device_obj;
 	int ret = 0;
 
 	if (netif_carrier_ok(net)) {
@@ -98,8 +98,8 @@ static int netvsc_open(struct net_device *net)
 
 static int netvsc_close(struct net_device *net)
 {
-	struct net_device_context *net_device_ctx = netdev_priv(net);
-	struct hyperv_device *device_obj = net_device_ctx->device_ctx;
+	struct net_device_context *net_device_obj = netdev_priv(net);
+	struct hyperv_device *device_obj = net_device_obj->device_obj;
 	int ret;
 
 	netif_stop_queue(net);
@@ -121,22 +121,22 @@ static void netvsc_xmit_completion(void *context)
 
 	if (skb) {
 		struct net_device *net = skb->dev;
-		struct net_device_context *net_device_ctx = netdev_priv(net);
+		struct net_device_context *net_device_obj = netdev_priv(net);
 		unsigned int num_pages = skb_shinfo(skb)->nr_frags + 2;
 
 		dev_kfree_skb_any(skb);
 
-		net_device_ctx->avail += num_pages;
-		if (net_device_ctx->avail >= PACKET_PAGES_HIWATER)
+		net_device_obj->avail += num_pages;
+		if (net_device_obj->avail >= PACKET_PAGES_HIWATER)
  			netif_wake_queue(net);
 	}
 }
 
 static int netvsc_start_xmit(struct sk_buff *skb, struct net_device *net)
 {
-	struct net_device_context *net_device_ctx = netdev_priv(net);
+	struct net_device_context *net_device_obj = netdev_priv(net);
 	struct driver_context *driver_ctx =
-	    driver_to_driver_context(net_device_ctx->device_ctx->device.driver);
+	    driver_to_driver_context(net_device_obj->device_obj->device.driver);
 	struct netvsc_driver_context *net_drv_ctx =
 		(struct netvsc_driver_context *)driver_ctx;
 	struct netvsc_driver *net_drv_obj = &net_drv_ctx->drv_obj;
@@ -149,7 +149,7 @@ static int netvsc_start_xmit(struct sk_buff *skb, struct net_device *net)
 
 	/* Add 1 for skb->data and additional one for RNDIS */
 	num_pages = skb_shinfo(skb)->nr_frags + 1 + 1;
-	if (num_pages > net_device_ctx->avail)
+	if (num_pages > net_device_obj->avail)
 		return NETDEV_TX_BUSY;
 
 	/* Allocate a netvsc packet based on # of frags. */
@@ -198,7 +198,7 @@ static int netvsc_start_xmit(struct sk_buff *skb, struct net_device *net)
 	packet->completion.send.send_completion_ctx = packet;
 	packet->completion.send.send_completion_tid = (unsigned long)skb;
 
-	ret = net_drv_obj->send(net_device_ctx->device_ctx,
+	ret = net_drv_obj->send(net_device_obj->device_obj,
 				  packet);
 	if (ret == 0) {
 		net->stats.tx_bytes += skb->len;
@@ -208,8 +208,8 @@ static int netvsc_start_xmit(struct sk_buff *skb, struct net_device *net)
 			   net->stats.tx_packets,
 			   net->stats.tx_bytes);
 
-		net_device_ctx->avail -= num_pages;
-		if (net_device_ctx->avail < PACKET_PAGES_LOWATER)
+		net_device_obj->avail -= num_pages;
+		if (net_device_obj->avail < PACKET_PAGES_LOWATER)
 			netif_stop_queue(net);
 	} else {
 		/* we are shutting down or bus overloaded, just drop packet */
@@ -345,7 +345,7 @@ static int netvsc_probe(struct device *device)
 	struct netvsc_driver *net_drv_obj = &net_drv_ctx->drv_obj;
 	struct hyperv_device *device_obj = device_to_hyperv_device(device);
 	struct net_device *net = NULL;
-	struct net_device_context *net_device_ctx;
+	struct net_device_context *net_device_obj;
 	struct netvsc_device_info device_info;
 	int ret;
 
@@ -359,9 +359,9 @@ static int netvsc_probe(struct device *device)
 	/* Set initial state */
 	netif_carrier_off(net);
 
-	net_device_ctx = netdev_priv(net);
-	net_device_ctx->device_ctx = device_obj;
-	net_device_ctx->avail = ring_size;
+	net_device_obj = netdev_priv(net);
+	net_device_obj->device_obj = device_obj;
+	net_device_obj->avail = ring_size;
 	dev_set_drvdata(device, net);
 
 	/* Notify the netvsc driver of the new device */
diff --git a/drivers/staging/hv/storvsc_drv.c b/drivers/staging/hv/storvsc_drv.c
index 2b9a097..c094578 100644
--- a/drivers/staging/hv/storvsc_drv.c
+++ b/drivers/staging/hv/storvsc_drv.c
@@ -43,7 +43,7 @@ struct host_device_context {
 	/* must be 1st field
 	 * FIXME this is a bug */
 	/* point back to our device context */
-	struct hyperv_device *device_ctx;
+	struct hyperv_device *device_obj;
 	struct kmem_cache *request_pool;
 	unsigned int port;
 	unsigned char path;
@@ -247,7 +247,7 @@ static int storvsc_probe(struct device *device)
 	memset(host_device_ctx, 0, sizeof(struct host_device_context));
 
 	host_device_ctx->port = host->host_no;
-	host_device_ctx->device_ctx = device_obj;
+	host_device_ctx->device_obj = device_obj;
 
 	host_device_ctx->request_pool =
 				kmem_cache_create(dev_name(&device_obj->device),
@@ -271,7 +271,7 @@ static int storvsc_probe(struct device *device)
 		return -1;
 	}
 
-	/* host_device_ctx->port = device_info.PortNumber; */
+	/* host_hyperv_dev->port = device_info.PortNumber; */
 	host_device_ctx->path = device_info.path_id;
 	host_device_ctx->target = device_info.target_id;
 
@@ -312,7 +312,7 @@ static int storvsc_remove(struct device *device)
 			&storvsc_drv_ctx->drv_obj;
 	struct hyperv_device *device_obj = device_to_hyperv_device(device);
 	struct Scsi_Host *host = dev_get_drvdata(device);
-	struct host_device_context *host_device_ctx =
+	struct host_device_context *host_device_obj =
 			(struct host_device_context *)host->hostdata;
 
 
@@ -330,9 +330,9 @@ static int storvsc_remove(struct device *device)
 			   ret);
 	}
 
-	if (host_device_ctx->request_pool) {
-		kmem_cache_destroy(host_device_ctx->request_pool);
-		host_device_ctx->request_pool = NULL;
+	if (host_device_obj->request_pool) {
+		kmem_cache_destroy(host_device_obj->request_pool);
+		host_device_obj->request_pool = NULL;
 	}
 
 	DPRINT_INFO(STORVSC, "removing host adapter (%p)...", host);
@@ -351,7 +351,7 @@ static void storvsc_commmand_completion(struct hv_storvsc_request *request)
 	struct storvsc_cmd_request *cmd_request =
 		(struct storvsc_cmd_request *)request->context;
 	struct scsi_cmnd *scmnd = cmd_request->cmd;
-	struct host_device_context *host_device_ctx =
+	struct host_device_context *host_device_obj =
 		(struct host_device_context *)scmnd->device->host->hostdata;
 	void (*scsi_done_fn)(struct scsi_cmnd *);
 	struct scsi_sense_hdr sense_hdr;
@@ -394,7 +394,7 @@ static void storvsc_commmand_completion(struct hv_storvsc_request *request)
 	/* !!DO NOT MODIFY the scmnd after this call */
 	scsi_done_fn(scmnd);
 
-	kmem_cache_free(host_device_ctx->request_pool, cmd_request);
+	kmem_cache_free(host_device_obj->request_pool, cmd_request);
 }
 
 static int do_bounce_buffer(struct scatterlist *sgl, unsigned int sg_count)
@@ -598,11 +598,11 @@ static int storvsc_queuecommand_lck(struct scsi_cmnd *scmnd,
 				void (*done)(struct scsi_cmnd *))
 {
 	int ret;
-	struct host_device_context *host_device_ctx =
+	struct host_device_context *host_device_obj =
 		(struct host_device_context *)scmnd->device->host->hostdata;
-	struct hyperv_device *device_ctx = host_device_ctx->device_ctx;
+	struct hyperv_device *device_obj = host_device_obj->device_obj;
 	struct driver_context *driver_ctx =
-		driver_to_driver_context(device_ctx->device.driver);
+		driver_to_driver_context(device_obj->device.driver);
 	struct storvsc_driver_context *storvsc_drv_ctx =
 		(struct storvsc_driver_context *)driver_ctx;
 	struct storvsc_driver_object *storvsc_drv_obj =
@@ -639,7 +639,7 @@ static int storvsc_queuecommand_lck(struct scsi_cmnd *scmnd,
 
 	request_size = sizeof(struct storvsc_cmd_request);
 
-	cmd_request = kmem_cache_alloc(host_device_ctx->request_pool,
+	cmd_request = kmem_cache_alloc(host_device_obj->request_pool,
 				       GFP_ATOMIC);
 	if (!cmd_request) {
 		DPRINT_ERR(STORVSC_DRV, "scmnd (%p) - unable to allocate "
@@ -679,7 +679,7 @@ static int storvsc_queuecommand_lck(struct scsi_cmnd *scmnd,
 	request->context = cmd_request;/* scmnd; */
 
 	/* request->PortId = scmnd->device->channel; */
-	request->host = host_device_ctx->port;
+	request->host = host_device_obj->port;
 	request->bus = scmnd->device->channel;
 	request->target_id = scmnd->device->id;
 	request->lun_id = scmnd->device->lun;
@@ -712,7 +712,7 @@ static int storvsc_queuecommand_lck(struct scsi_cmnd *scmnd,
 
 				scmnd->scsi_done = NULL;
 				scmnd->host_scribble = NULL;
-				kmem_cache_free(host_device_ctx->request_pool,
+				kmem_cache_free(host_device_obj->request_pool,
 						cmd_request);
 
 				return SCSI_MLQUEUE_HOST_BUSY;
@@ -751,7 +751,7 @@ static int storvsc_queuecommand_lck(struct scsi_cmnd *scmnd,
 
 retry_request:
 	/* Invokes the vsc to start an IO */
-	ret = storvsc_drv_obj->on_io_request(device_ctx,
+	ret = storvsc_drv_obj->on_io_request(device_obj,
 					   &cmd_request->request);
 	if (ret == -1) {
 		/* no more space */
@@ -771,7 +771,7 @@ retry_request:
 					      cmd_request->bounce_sgl_count);
 		}
 
-		kmem_cache_free(host_device_ctx->request_pool, cmd_request);
+		kmem_cache_free(host_device_obj->request_pool, cmd_request);
 
 		scmnd->scsi_done = NULL;
 		scmnd->host_scribble = NULL;
@@ -836,20 +836,20 @@ static int storvsc_device_configure(struct scsi_device *sdevice)
 static int storvsc_host_reset_handler(struct scsi_cmnd *scmnd)
 {
 	int ret;
-	struct host_device_context *host_device_ctx =
+	struct host_device_context *host_device_obj =
 		(struct host_device_context *)scmnd->device->host->hostdata;
-	struct hyperv_device *device_ctx = host_device_ctx->device_ctx;
+	struct hyperv_device *device_obj = host_device_obj->device_obj;
 
 	DPRINT_INFO(STORVSC_DRV, "sdev (%p) dev obj (%p) - host resetting...",
-		    scmnd->device, device_ctx);
+		    scmnd->device, device_obj);
 
 	/* Invokes the vsc to reset the host/bus */
-	ret = stor_vsc_on_host_reset(device_ctx);
+	ret = stor_vsc_on_host_reset(device_obj);
 	if (ret != 0)
 		return ret;
 
 	DPRINT_INFO(STORVSC_DRV, "sdev (%p) dev obj (%p) - host reseted",
-		    scmnd->device, device_ctx);
+		    scmnd->device, device_obj);
 
 	return ret;
 }
diff --git a/drivers/staging/hv/vmbus_drv.c b/drivers/staging/hv/vmbus_drv.c
index 38152df..a385bd2 100644
--- a/drivers/staging/hv/vmbus_drv.c
+++ b/drivers/staging/hv/vmbus_drv.c
@@ -54,7 +54,7 @@ struct vmbus_driver_context {
 	struct tasklet_struct event_dpc;
 
 	/* The bus root device */
-	struct hyperv_device device_ctx;
+	struct hyperv_device device_obj;
 };
 
 static int vmbus_match(struct device *device, struct device_driver *driver);
@@ -354,12 +354,12 @@ static ssize_t vmbus_show_device_attr(struct device *dev,
 				      struct device_attribute *dev_attr,
 				      char *buf)
 {
-	struct hyperv_device *device_ctx = device_to_hyperv_device(dev);
+	struct hyperv_device *device_obj = device_to_hyperv_device(dev);
 	struct hyperv_device_info device_info;
 
 	memset(&device_info, 0, sizeof(struct hyperv_device_info));
 
-	get_channel_info(device_ctx, &device_info);
+	get_channel_info(device_obj, &device_info);
 
 	if (!strcmp(dev_attr->attr.name, "class_id")) {
 		return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
@@ -464,7 +464,7 @@ static int vmbus_bus_init(void)
 {
 	struct vmbus_driver_context *vmbus_drv_ctx = &vmbus_drv;
 	struct hv_driver *driver = &vmbus_drv.drv_obj;
-	struct hyperv_device *dev_ctx = &vmbus_drv.device_ctx;
+	struct hyperv_device *dev = &vmbus_drv.device_obj;
 	int ret;
 	unsigned int vector;
 
@@ -535,9 +535,9 @@ static int vmbus_bus_init(void)
 	DPRINT_INFO(VMBUS_DRV, "irq 0x%x vector 0x%x", vmbus_irq, vector);
 
 	/* Call to bus driver to add the root device */
-	memset(dev_ctx, 0, sizeof(struct hyperv_device));
+	memset(dev, 0, sizeof(struct hyperv_device));
 
-	ret = driver->dev_add(dev_ctx, &vector);
+	ret = driver->dev_add(dev, &vector);
 	if (ret != 0) {
 		DPRINT_ERR(VMBUS_DRV,
 			   "ERROR - Unable to add vmbus root device");
@@ -549,19 +549,19 @@ static int vmbus_bus_init(void)
 		ret = -1;
 		goto cleanup;
 	}
-	/* strcpy(dev_ctx->device.bus_id, dev_ctx->device_obj.name); */
-	dev_set_name(&dev_ctx->device, "vmbus_0_0");
+	/* strcpy(dev->device.bus_id, dev->device_obj.name); */
+	dev_set_name(&dev->device, "vmbus_0_0");
 
 	/* No need to bind a driver to the root device. */
-	dev_ctx->device.parent = NULL;
+	dev->device.parent = NULL;
 	/* NULL; vmbus_remove() does not get invoked */
-	dev_ctx->device.bus = &vmbus_drv_ctx->bus;
+	dev->device.bus = &vmbus_drv_ctx->bus;
 
 	/* Setup the device dispatch table */
-	dev_ctx->device.release = vmbus_bus_release;
+	dev->device.release = vmbus_bus_release;
 
 	/* Setup the bus as root device */
-	ret = device_register(&dev_ctx->device);
+	ret = device_register(&dev->device);
 	if (ret) {
 		DPRINT_ERR(VMBUS_DRV,
 			   "ERROR - Unable to register vmbus root device");
@@ -590,17 +590,17 @@ static void vmbus_bus_exit(void)
 	struct hv_driver *driver = &vmbus_drv.drv_obj;
 	struct vmbus_driver_context *vmbus_drv_ctx = &vmbus_drv;
 
-	struct hyperv_device *dev_ctx = &vmbus_drv.device_ctx;
+	struct hyperv_device *dev = &vmbus_drv.device_obj;
 
 	/* Remove the root device */
 	if (driver->dev_rm)
-		driver->dev_rm(dev_ctx);
+		driver->dev_rm(dev);
 
 	if (driver->cleanup)
 		driver->cleanup(driver);
 
 	/* Unregister the root bus device */
-	device_unregister(&dev_ctx->device);
+	device_unregister(&dev->device);
 
 	bus_unregister(&vmbus_drv_ctx->bus);
 
@@ -671,11 +671,11 @@ struct hyperv_device *vmbus_child_device_create(struct hv_guid *type,
 					    struct hv_guid *instance,
 					    struct vmbus_channel *channel)
 {
-	struct hyperv_device *child_device_ctx;
+	struct hyperv_device *child_device_obj;
 
 	/* Allocate the new child device */
-	child_device_ctx = kzalloc(sizeof(struct hyperv_device), GFP_KERNEL);
-	if (!child_device_ctx) {
+	child_device_obj = kzalloc(sizeof(struct hyperv_device), GFP_KERNEL);
+	if (!child_device_obj) {
 		DPRINT_ERR(VMBUS_DRV,
 			"unable to allocate device_context for child device");
 		return NULL;
@@ -686,7 +686,7 @@ struct hyperv_device *vmbus_child_device_create(struct hv_guid *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}",
-		&child_device_ctx->device,
+		&child_device_obj->device,
 		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[8], type->data[9], type->data[10], type->data[11],
@@ -700,12 +700,12 @@ struct hyperv_device *vmbus_child_device_create(struct hv_guid *type,
 		instance->data[12], instance->data[13],
 		instance->data[14], instance->data[15]);
 
-	child_device_ctx->channel = channel;
+	child_device_obj->channel = channel;
 
-	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_obj->class_id, type, sizeof(struct hv_guid));
+	memcpy(&child_device_obj->device_id, instance, sizeof(struct hv_guid));
 
-	return child_device_ctx;
+	return child_device_obj;
 }
 
 /*
@@ -777,43 +777,43 @@ void vmbus_child_device_unregister(struct hyperv_device *device_obj)
  */
 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
 {
-	struct hyperv_device *device_ctx = device_to_hyperv_device(device);
+	struct hyperv_device *device_obj = device_to_hyperv_device(device);
 	int ret;
 
 	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}",
-		    device_ctx->class_id.data[3], device_ctx->class_id.data[2],
-		    device_ctx->class_id.data[1], device_ctx->class_id.data[0],
-		    device_ctx->class_id.data[5], device_ctx->class_id.data[4],
-		    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]);
+		    device_obj->class_id.data[3], device_obj->class_id.data[2],
+		    device_obj->class_id.data[1], device_obj->class_id.data[0],
+		    device_obj->class_id.data[5], device_obj->class_id.data[4],
+		    device_obj->class_id.data[7], device_obj->class_id.data[6],
+		    device_obj->class_id.data[8], device_obj->class_id.data[9],
+		    device_obj->class_id.data[10],
+		    device_obj->class_id.data[11],
+		    device_obj->class_id.data[12],
+		    device_obj->class_id.data[13],
+		    device_obj->class_id.data[14],
+		    device_obj->class_id.data[15]);
 
 	ret = add_uevent_var(env, "VMBUS_DEVICE_CLASS_GUID={"
 			     "%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],
-			     device_ctx->class_id.data[1],
-			     device_ctx->class_id.data[0],
-			     device_ctx->class_id.data[5],
-			     device_ctx->class_id.data[4],
-			     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]);
+			     device_obj->class_id.data[3],
+			     device_obj->class_id.data[2],
+			     device_obj->class_id.data[1],
+			     device_obj->class_id.data[0],
+			     device_obj->class_id.data[5],
+			     device_obj->class_id.data[4],
+			     device_obj->class_id.data[7],
+			     device_obj->class_id.data[6],
+			     device_obj->class_id.data[8],
+			     device_obj->class_id.data[9],
+			     device_obj->class_id.data[10],
+			     device_obj->class_id.data[11],
+			     device_obj->class_id.data[12],
+			     device_obj->class_id.data[13],
+			     device_obj->class_id.data[14],
+			     device_obj->class_id.data[15]);
 
 	if (ret)
 		return ret;
@@ -821,22 +821,22 @@ static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
 	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]);
+			     device_obj->device_id.data[3],
+			     device_obj->device_id.data[2],
+			     device_obj->device_id.data[1],
+			     device_obj->device_id.data[0],
+			     device_obj->device_id.data[5],
+			     device_obj->device_id.data[4],
+			     device_obj->device_id.data[7],
+			     device_obj->device_id.data[6],
+			     device_obj->device_id.data[8],
+			     device_obj->device_id.data[9],
+			     device_obj->device_id.data[10],
+			     device_obj->device_id.data[11],
+			     device_obj->device_id.data[12],
+			     device_obj->device_id.data[13],
+			     device_obj->device_id.data[14],
+			     device_obj->device_id.data[15]);
 	if (ret)
 		return ret;
 
@@ -850,10 +850,10 @@ static int vmbus_match(struct device *device, struct device_driver *driver)
 {
 	int match = 0;
 	struct driver_context *driver_ctx = driver_to_driver_context(driver);
-	struct hyperv_device *device_ctx = device_to_hyperv_device(device);
+	struct hyperv_device *device_obj = device_to_hyperv_device(device);
 
 	/* We found our driver ? */
-	if (memcmp(&device_ctx->class_id, &driver_ctx->class_id,
+	if (memcmp(&device_obj->class_id, &driver_ctx->class_id,
 		   sizeof(struct hv_guid)) == 0) {
 		/*
 		 * !! NOTE: The driver_ctx is not a vmbus_drv_ctx. We typecast
@@ -862,11 +862,11 @@ static int vmbus_match(struct device *device, struct device_driver *driver)
 		struct vmbus_driver_context *vmbus_drv_ctx =
 			(struct vmbus_driver_context *)driver_ctx;
 
-		device_ctx->drv = &vmbus_drv_ctx->drv_obj;
+		device_obj->drv = &vmbus_drv_ctx->drv_obj;
 		DPRINT_INFO(VMBUS_DRV,
 			    "device object (%p) set to driver object (%p)",
-			    &device_ctx,
-			    device_ctx->drv);
+			    &device_obj,
+			    device_obj->drv);
 
 		match = 1;
 	}
@@ -882,15 +882,15 @@ static int vmbus_match(struct device *device, struct device_driver *driver)
  */
 static void vmbus_probe_failed_cb(struct work_struct *context)
 {
-	struct hyperv_device *device_ctx = (struct hyperv_device *)context;
+	struct hyperv_device *device_obj = (struct hyperv_device *)context;
 
 	/*
 	 * 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_obj->device);
 
-	/* put_device(&device_ctx->device); */
+	/* put_device(&device_obj->device); */
 }
 
 /*
@@ -901,21 +901,21 @@ static int vmbus_probe(struct device *child_device)
 	int ret = 0;
 	struct driver_context *driver_ctx =
 			driver_to_driver_context(child_device->driver);
-	struct hyperv_device *device_ctx =
+	struct hyperv_device *device_obj =
 			device_to_hyperv_device(child_device);
 
 	/* Let the specific open-source driver handles the probe if it can */
 	if (driver_ctx->probe) {
-		ret = device_ctx->probe_error = driver_ctx->probe(child_device);
+		ret = device_obj->probe_error = driver_ctx->probe(child_device);
 		if (ret != 0) {
 			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);
 
-			INIT_WORK(&device_ctx->probe_failed_work_item,
+			INIT_WORK(&device_obj->probe_failed_work_item,
 				  vmbus_probe_failed_cb);
-			schedule_work(&device_ctx->probe_failed_work_item);
+			schedule_work(&device_obj->probe_failed_work_item);
 		}
 	} else {
 		DPRINT_ERR(VMBUS_DRV, "probe() method not set for driver - %s",
@@ -1008,11 +1008,11 @@ static void vmbus_bus_release(struct device *device)
  */
 static void vmbus_device_release(struct device *device)
 {
-	struct hyperv_device *device_ctx = device_to_hyperv_device(device);
+	struct hyperv_device *device_obj = device_to_hyperv_device(device);
 
-	kfree(device_ctx);
+	kfree(device_obj);
 
-	/* !!DO NOT REFERENCE device_ctx anymore at this point!! */
+	/* !!DO NOT REFERENCE device_obj anymore at this point!! */
 }
 
 /*
-- 
1.5.5.6

_______________________________________________
devel mailing list
devel@xxxxxxxxxxxxxxxxxxxxxx
http://driverdev.linuxdriverproject.org/mailman/listinfo/devel


[Index of Archives]     [Linux Driver Backports]     [DMA Engine]     [Linux GPIO]     [Linux SPI]     [Video for Linux]     [Linux USB Devel]     [Linux Coverity]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [Yosemite Backpacking]
  Powered by Linux