Commit ca623ad3 authored by Haiyang Zhang's avatar Haiyang Zhang Committed by Greg Kroah-Hartman
Browse files

staging: hv: Convert camel cased struct fields in vmbus_api.h to lower cases 



Signed-off-by: default avatarHaiyang Zhang <haiyangz@microsoft.com>
Signed-off-by: default avatarHank Janssen <hjanssen@microsoft.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 646f1ea3

drivers/staging/hv/blkvsc.c

+10 −10
Original line number Diff line number Diff line
@@ -51,13 +51,13 @@ static int blk_vsc_on_device_add(struct hv_device *device, void *additional_info 
	 * id. For IDE devices, the device instance id is formatted as

	 * <bus id> * - <device id> - 8899 - 000000000000.

	 */

	device_info->path_id = device->deviceInstance.data[3] << 24 |

			     device->deviceInstance.data[2] << 16 |

			     device->deviceInstance.data[1] << 8  |

			     device->deviceInstance.data[0];

	device_info->path_id = device->dev_instance.data[3] << 24 |

			     device->dev_instance.data[2] << 16 |

			     device->dev_instance.data[1] << 8  |

			     device->dev_instance.data[0];



	device_info->target_id = device->deviceInstance.data[5] << 8 |

			       device->deviceInstance.data[4];

	device_info->target_id = device->dev_instance.data[5] << 8 |

			       device->dev_instance.data[4];



	return ret;

}
@@ -73,7 +73,7 @@ int blk_vsc_initialize(struct hv_driver *driver) 
	/* ASSERT(stor_driver->RingBufferSize >= (PAGE_SIZE << 1)); */



	driver->name = g_blk_driver_name;

	memcpy(&driver->deviceType, &g_blk_device_type, sizeof(struct hv_guid));

	memcpy(&driver->dev_type, &g_blk_device_type, sizeof(struct hv_guid));



	stor_driver->request_ext_size = sizeof(struct storvsc_request_extension);
@@ -93,9 +93,9 @@ int blk_vsc_initialize(struct hv_driver *driver) 
		    stor_driver->max_outstanding_req_per_channel);



	/* Setup the dispatch table */

	stor_driver->base.OnDeviceAdd = blk_vsc_on_device_add;

	stor_driver->base.OnDeviceRemove = stor_vsc_on_device_remove;

	stor_driver->base.OnCleanup = stor_vsc_on_cleanup;

	stor_driver->base.dev_add = blk_vsc_on_device_add;

	stor_driver->base.dev_rm = stor_vsc_on_device_remove;

	stor_driver->base.cleanup = stor_vsc_on_cleanup;

	stor_driver->on_io_request = stor_vsc_on_io_request;



	return ret;

drivers/staging/hv/blkvsc_drv.c

+28 −28
Original line number Diff line number Diff line
@@ -183,7 +183,7 @@ static int blkvsc_drv_init(int (*drv_init)(struct hv_driver *drv)) 
	drv_init(&storvsc_drv_obj->base);



	drv_ctx->driver.name = storvsc_drv_obj->base.name;

	memcpy(&drv_ctx->class_id, &storvsc_drv_obj->base.deviceType,

	memcpy(&drv_ctx->class_id, &storvsc_drv_obj->base.dev_type,

	       sizeof(struct hv_guid));



	drv_ctx->probe = blkvsc_probe;
@@ -230,8 +230,8 @@ static void blkvsc_drv_exit(void) 
		device_unregister(current_dev);

	}



	if (storvsc_drv_obj->base.OnCleanup)

		storvsc_drv_obj->base.OnCleanup(&storvsc_drv_obj->base);

	if (storvsc_drv_obj->base.cleanup)

		storvsc_drv_obj->base.cleanup(&storvsc_drv_obj->base);



	vmbus_child_driver_unregister(drv_ctx);
@@ -262,7 +262,7 @@ static int blkvsc_probe(struct device *device) 


	DPRINT_DBG(BLKVSC_DRV, "blkvsc_probe - enter");



	if (!storvsc_drv_obj->base.OnDeviceAdd) {

	if (!storvsc_drv_obj->base.dev_add) {

		DPRINT_ERR(BLKVSC_DRV, "OnDeviceAdd() not set");

		ret = -1;

		goto Cleanup;
@@ -293,7 +293,7 @@ static int blkvsc_probe(struct device *device) 




	/* Call to the vsc driver to add the device */

	ret = storvsc_drv_obj->base.OnDeviceAdd(device_obj, &device_info);

	ret = storvsc_drv_obj->base.dev_add(device_obj, &device_info);

	if (ret != 0) {

		DPRINT_ERR(BLKVSC_DRV, "unable to add blkvsc device");

		goto Cleanup;
@@ -391,7 +391,7 @@ static int blkvsc_probe(struct device *device) 
	return ret;



Remove:

	storvsc_drv_obj->base.OnDeviceRemove(device_obj);

	storvsc_drv_obj->base.dev_rm(device_obj);



Cleanup:

	if (blkdev) {
@@ -459,9 +459,9 @@ static int blkvsc_do_flush(struct block_device_context *blkdev) 
	blkvsc_req->req = NULL;

	blkvsc_req->write = 0;



	blkvsc_req->request.data_buffer.PfnArray[0] = 0;

	blkvsc_req->request.data_buffer.Offset = 0;

	blkvsc_req->request.data_buffer.Length = 0;

	blkvsc_req->request.data_buffer.pfn_array[0] = 0;

	blkvsc_req->request.data_buffer.offset = 0;

	blkvsc_req->request.data_buffer.len = 0;



	blkvsc_req->cmnd[0] = SYNCHRONIZE_CACHE;

	blkvsc_req->cmd_len = 10;
@@ -506,9 +506,9 @@ static int blkvsc_do_inquiry(struct block_device_context *blkdev) 
	blkvsc_req->req = NULL;

	blkvsc_req->write = 0;



	blkvsc_req->request.data_buffer.PfnArray[0] = page_to_pfn(page_buf);

	blkvsc_req->request.data_buffer.Offset = 0;

	blkvsc_req->request.data_buffer.Length = 64;

	blkvsc_req->request.data_buffer.pfn_array[0] = page_to_pfn(page_buf);

	blkvsc_req->request.data_buffer.offset = 0;

	blkvsc_req->request.data_buffer.len = 64;



	blkvsc_req->cmnd[0] = INQUIRY;

	blkvsc_req->cmnd[1] = 0x1;		/* Get product data */
@@ -593,9 +593,9 @@ static int blkvsc_do_read_capacity(struct block_device_context *blkdev) 
	blkvsc_req->req = NULL;

	blkvsc_req->write = 0;



	blkvsc_req->request.data_buffer.PfnArray[0] = page_to_pfn(page_buf);

	blkvsc_req->request.data_buffer.Offset = 0;

	blkvsc_req->request.data_buffer.Length = 8;

	blkvsc_req->request.data_buffer.pfn_array[0] = page_to_pfn(page_buf);

	blkvsc_req->request.data_buffer.offset = 0;

	blkvsc_req->request.data_buffer.len = 8;



	blkvsc_req->cmnd[0] = READ_CAPACITY;

	blkvsc_req->cmd_len = 16;
@@ -670,9 +670,9 @@ static int blkvsc_do_read_capacity16(struct block_device_context *blkdev) 
	blkvsc_req->req = NULL;

	blkvsc_req->write = 0;



	blkvsc_req->request.data_buffer.PfnArray[0] = page_to_pfn(page_buf);

	blkvsc_req->request.data_buffer.Offset = 0;

	blkvsc_req->request.data_buffer.Length = 12;

	blkvsc_req->request.data_buffer.pfn_array[0] = page_to_pfn(page_buf);

	blkvsc_req->request.data_buffer.offset = 0;

	blkvsc_req->request.data_buffer.len = 12;



	blkvsc_req->cmnd[0] = 0x9E; /* READ_CAPACITY16; */

	blkvsc_req->cmd_len = 16;
@@ -741,14 +741,14 @@ static int blkvsc_remove(struct device *device) 


	DPRINT_DBG(BLKVSC_DRV, "blkvsc_remove()\n");



	if (!storvsc_drv_obj->base.OnDeviceRemove)

	if (!storvsc_drv_obj->base.dev_rm)

		return -1;



	/*

	 * Call to the vsc driver to let it know that the device is being

	 * removed

	 */

	ret = storvsc_drv_obj->base.OnDeviceRemove(device_obj);

	ret = storvsc_drv_obj->base.dev_rm(device_obj);

	if (ret != 0) {

		/* TODO: */

		DPRINT_ERR(BLKVSC_DRV,
@@ -865,10 +865,10 @@ static int blkvsc_submit_request(struct blkvsc_request *blkvsc_req, 
		   (blkvsc_req->write) ? "WRITE" : "READ",

		   (unsigned long) blkvsc_req->sector_start,

		   blkvsc_req->sector_count,

		   blkvsc_req->request.data_buffer.Offset,

		   blkvsc_req->request.data_buffer.Length);

		   blkvsc_req->request.data_buffer.offset,

		   blkvsc_req->request.data_buffer.len);

#if 0

	for (i = 0; i < (blkvsc_req->request.data_buffer.Length >> 12); i++) {

	for (i = 0; i < (blkvsc_req->request.data_buffer.len >> 12); i++) {

		DPRINT_DBG(BLKVSC_DRV, "blkvsc_submit_request() - "

			   "req %p pfn[%d] %llx\n",

			   blkvsc_req, i,
@@ -992,9 +992,9 @@ static int blkvsc_do_request(struct block_device_context *blkdev, 


					blkvsc_req->dev = blkdev;

					blkvsc_req->req = req;

					blkvsc_req->request.data_buffer.Offset

					blkvsc_req->request.data_buffer.offset

						= bvec->bv_offset;

					blkvsc_req->request.data_buffer.Length

					blkvsc_req->request.data_buffer.len

						= 0;



					/* Add to the group */
@@ -1010,9 +1010,9 @@ static int blkvsc_do_request(struct block_device_context *blkdev, 


				/* Add the curr bvec/segment to the curr blkvsc_req */

				blkvsc_req->request.data_buffer.

					PfnArray[databuf_idx]

					pfn_array[databuf_idx]

						= page_to_pfn(bvec->bv_page);

				blkvsc_req->request.data_buffer.Length

				blkvsc_req->request.data_buffer.len

					+= bvec->bv_len;



				prev_bvec = bvec;
@@ -1115,7 +1115,7 @@ static void blkvsc_request_completion(struct hv_storvsc_request *request) 
		   (blkvsc_req->write) ? "WRITE" : "READ",

		   (unsigned long)blkvsc_req->sector_start,

		   blkvsc_req->sector_count,

		   blkvsc_req->request.data_buffer.Length,

		   blkvsc_req->request.data_buffer.len,

		   blkvsc_req->group->outstanding,

		   blkdev->num_outstanding_reqs);

drivers/staging/hv/channel.c

+10 −10
Original line number Diff line number Diff line
@@ -806,9 +806,9 @@ int vmbus_sendpacket_pagebuffer(struct vmbus_channel *channel, 
	desc.rangecount = pagecount;



	for (i = 0; i < pagecount; i++) {

		desc.range[i].Length = pagebuffers[i].Length;

		desc.range[i].Offset = pagebuffers[i].Offset;

		desc.range[i].Pfn	 = pagebuffers[i].Pfn;

		desc.range[i].len = pagebuffers[i].len;

		desc.range[i].offset = pagebuffers[i].offset;

		desc.range[i].pfn	 = pagebuffers[i].pfn;

	}



	sg_init_table(bufferlist, 3);
@@ -842,14 +842,14 @@ int vmbus_sendpacket_multipagebuffer(struct vmbus_channel *channel, 
	u32 packetlen_aligned;

	struct scatterlist bufferlist[3];

	u64 aligned_data = 0;

	u32 pfncount = NUM_PAGES_SPANNED(multi_pagebuffer->Offset,

					 multi_pagebuffer->Length);

	u32 pfncount = NUM_PAGES_SPANNED(multi_pagebuffer->offset,

					 multi_pagebuffer->len);



	dump_vmbus_channel(channel);



	DPRINT_DBG(VMBUS, "data buffer - offset %u len %u pfn count %u",

		multi_pagebuffer->Offset,

		multi_pagebuffer->Length, pfncount);

		multi_pagebuffer->offset,

		multi_pagebuffer->len, pfncount);



	if ((pfncount < 0) || (pfncount > MAX_MULTIPAGE_BUFFER_COUNT))

		return -EINVAL;
@@ -874,10 +874,10 @@ int vmbus_sendpacket_multipagebuffer(struct vmbus_channel *channel, 
	desc.transactionid = requestid;

	desc.rangecount = 1;



	desc.range.Length = multi_pagebuffer->Length;

	desc.range.Offset = multi_pagebuffer->Offset;

	desc.range.len = multi_pagebuffer->len;

	desc.range.offset = multi_pagebuffer->offset;



	memcpy(desc.range.PfnArray, multi_pagebuffer->PfnArray,

	memcpy(desc.range.pfn_array, multi_pagebuffer->pfn_array,

	       pfncount * sizeof(u64));



	sg_init_table(bufferlist, 3);

drivers/staging/hv/channel_mgmt.c

+1 −1
Original line number Diff line number Diff line
@@ -864,7 +864,7 @@ void vmbus_release_unattached_channels(void) 
		if (channel == start)

			break;



		if (!channel->device_obj->Driver) {

		if (!channel->device_obj->drv) {

			list_del(&channel->listentry);

			DPRINT_INFO(VMBUS,

				    "Releasing unattached device object %p",

drivers/staging/hv/netvsc.c

+29 −29
Original line number Diff line number Diff line
@@ -86,7 +86,7 @@ static struct netvsc_device *alloc_net_device(struct hv_device *device) 
	atomic_cmpxchg(&net_device->refcnt, 0, 2);



	net_device->dev = device;

	device->Extension = net_device;

	device->ext = net_device;



	return net_device;

}
@@ -94,7 +94,7 @@ static struct netvsc_device *alloc_net_device(struct hv_device *device) 
static void free_net_device(struct netvsc_device *device)

{

	WARN_ON(atomic_read(&device->refcnt) == 0);

	device->dev->Extension = NULL;

	device->dev->ext = NULL;

	kfree(device);

}
@@ -104,7 +104,7 @@ static struct netvsc_device *get_outbound_net_device(struct hv_device *device) 
{

	struct netvsc_device *net_device;



	net_device = device->Extension;

	net_device = device->ext;

	if (net_device && atomic_read(&net_device->refcnt) > 1)

		atomic_inc(&net_device->refcnt);

	else
@@ -118,7 +118,7 @@ static struct netvsc_device *get_inbound_net_device(struct hv_device *device) 
{

	struct netvsc_device *net_device;



	net_device = device->Extension;

	net_device = device->ext;

	if (net_device && atomic_read(&net_device->refcnt))

		atomic_inc(&net_device->refcnt);

	else
@@ -131,7 +131,7 @@ static void put_net_device(struct hv_device *device) 
{

	struct netvsc_device *net_device;



	net_device = device->Extension;

	net_device = device->ext;

	/* ASSERT(netDevice); */



	atomic_dec(&net_device->refcnt);
@@ -142,7 +142,7 @@ static struct netvsc_device *release_outbound_net_device( 
{

	struct netvsc_device *net_device;



	net_device = device->Extension;

	net_device = device->ext;

	if (net_device == NULL)

		return NULL;
@@ -158,7 +158,7 @@ static struct netvsc_device *release_inbound_net_device( 
{

	struct netvsc_device *net_device;



	net_device = device->Extension;

	net_device = device->ext;

	if (net_device == NULL)

		return NULL;
@@ -166,7 +166,7 @@ static struct netvsc_device *release_inbound_net_device( 
	while (atomic_cmpxchg(&net_device->refcnt, 1, 0) != 1)

		udelay(100);



	device->Extension = NULL;

	device->ext = NULL;

	return net_device;

}
@@ -188,7 +188,7 @@ int netvsc_initialize(struct hv_driver *drv) 
	/* ASSERT(driver->RingBufferSize >= (PAGE_SIZE << 1)); */



	drv->name = driver_name;

	memcpy(&drv->deviceType, &netvsc_device_type, sizeof(struct hv_guid));

	memcpy(&drv->dev_type, &netvsc_device_type, sizeof(struct hv_guid));



	/* Make sure it is set by the caller */

	/* FIXME: These probably should still be tested in some way */
@@ -196,9 +196,9 @@ int netvsc_initialize(struct hv_driver *drv) 
	/* ASSERT(driver->OnLinkStatusChanged); */



	/* Setup the dispatch table */

	driver->base.OnDeviceAdd	= netvsc_device_add;

	driver->base.OnDeviceRemove	= netvsc_device_remove;

	driver->base.OnCleanup		= netvsc_cleanup;

	driver->base.dev_add	= netvsc_device_add;

	driver->base.dev_rm	= netvsc_device_remove;

	driver->base.cleanup		= netvsc_cleanup;



	driver->send			= netvsc_send;
@@ -708,7 +708,7 @@ static int netvsc_device_add(struct hv_device *device, void *additional_info) 
	struct netvsc_device *net_device;

	struct hv_netvsc_packet *packet, *pos;

	struct netvsc_driver *net_driver =

				(struct netvsc_driver *)device->Driver;

				(struct netvsc_driver *)device->drv;



	net_device = alloc_net_device(device);

	if (!net_device) {
@@ -806,7 +806,7 @@ static int netvsc_device_remove(struct hv_device *device) 
	struct hv_netvsc_packet *netvsc_packet, *pos;



	DPRINT_INFO(NETVSC, "Disabling outbound traffic on net device (%p)...",

		    device->Extension);

		    device->ext);



	/* Stop outbound traffic ie sends and receives completions */

	net_device = release_outbound_net_device(device);
@@ -827,7 +827,7 @@ static int netvsc_device_remove(struct hv_device *device) 
	NetVscDisconnectFromVsp(net_device);



	DPRINT_INFO(NETVSC, "Disabling inbound traffic on net device (%p)...",

		    device->Extension);

		    device->ext);



	/* Stop inbound traffic ie receives and sends completions */

	net_device = release_inbound_net_device(device);
@@ -1101,42 +1101,42 @@ static void netvsc_receive(struct hv_device *device, 
		/* 	vmxferpagePacket->Ranges[i].ByteCount < */

		/* 	netDevice->ReceiveBufferSize); */



		netvsc_packet->page_buf[0].Length =

		netvsc_packet->page_buf[0].len =

					vmxferpage_packet->Ranges[i].ByteCount;



		start = virt_to_phys((void *)((unsigned long)net_device->

		recv_buf + vmxferpage_packet->Ranges[i].ByteOffset));



		netvsc_packet->page_buf[0].Pfn = start >> PAGE_SHIFT;

		netvsc_packet->page_buf[0].pfn = start >> PAGE_SHIFT;

		end_virtual = (unsigned long)net_device->recv_buf

		    + vmxferpage_packet->Ranges[i].ByteOffset

		    + vmxferpage_packet->Ranges[i].ByteCount - 1;

		end = virt_to_phys((void *)end_virtual);



		/* Calculate the page relative offset */

		netvsc_packet->page_buf[0].Offset =

		netvsc_packet->page_buf[0].offset =

			vmxferpage_packet->Ranges[i].ByteOffset &

			(PAGE_SIZE - 1);

		if ((end >> PAGE_SHIFT) != (start >> PAGE_SHIFT)) {

			/* Handle frame across multiple pages: */

			netvsc_packet->page_buf[0].Length =

				(netvsc_packet->page_buf[0].Pfn <<

			netvsc_packet->page_buf[0].len =

				(netvsc_packet->page_buf[0].pfn <<

				 PAGE_SHIFT)

				+ PAGE_SIZE - start;

			bytes_remain = netvsc_packet->total_data_buflen -

					netvsc_packet->page_buf[0].Length;

					netvsc_packet->page_buf[0].len;

			for (j = 1; j < NETVSC_PACKET_MAXPAGE; j++) {

				netvsc_packet->page_buf[j].Offset = 0;

				netvsc_packet->page_buf[j].offset = 0;

				if (bytes_remain <= PAGE_SIZE) {

					netvsc_packet->page_buf[j].Length =

					netvsc_packet->page_buf[j].len =

						bytes_remain;

					bytes_remain = 0;

				} else {

					netvsc_packet->page_buf[j].Length =

					netvsc_packet->page_buf[j].len =

						PAGE_SIZE;

					bytes_remain -= PAGE_SIZE;

				}

				netvsc_packet->page_buf[j].Pfn =

				netvsc_packet->page_buf[j].pfn =

				    virt_to_phys((void *)(end_virtual -

						bytes_remain)) >> PAGE_SHIFT;

				netvsc_packet->page_buf_cnt++;
@@ -1149,12 +1149,12 @@ static void netvsc_receive(struct hv_device *device, 
			   "(pfn %llx, offset %u, len %u)", i,

			   vmxferpage_packet->Ranges[i].ByteOffset,

			   vmxferpage_packet->Ranges[i].ByteCount,

			   netvsc_packet->page_buf[0].Pfn,

			   netvsc_packet->page_buf[0].Offset,

			   netvsc_packet->page_buf[0].Length);

			   netvsc_packet->page_buf[0].pfn,

			   netvsc_packet->page_buf[0].offset,

			   netvsc_packet->page_buf[0].len);



		/* Pass it to the upper layer */

		((struct netvsc_driver *)device->Driver)->

		((struct netvsc_driver *)device->drv)->

			recv_cb(device, netvsc_packet);



		netvsc_receive_completion(netvsc_packet->