Re: [PATCH 2/8] staging: hv: Convert camel case struct fields in storvsc_api.h to lowercase

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

 



Greg,

My new KVP patches are ready to go. Should I wait for Hank's patches to be checked in before I send the KVP patches?

Regards

K. Y
>>> On 12/6/2010 at  3:26 PM, in message
<1291667211-1865-2-git-send-email-hjanssen@xxxxxxxxxxxxx>, Hank Janssen
<hjanssen@xxxxxxxxxxxxx> wrote: 
> From: Hank Janssen <hjanssen@xxxxxxxxxxxxx> 
> 
> Convert camel case struct fields in vstorage.h to lowercase
> 
> Signed-off-by: Abhishek Kane <v-abkane@xxxxxxxxxxxxx>
> Signed-off-by: Haiyang Zhang <haiyangz@xxxxxxxxxxxxx>
> Signed-off-by: Hank Janssen <hjanssen@xxxxxxxxxxxxx>
> 
> ---
>  drivers/staging/hv/blkvsc.c      |   20 +++---
>  drivers/staging/hv/blkvsc_drv.c  |  115 ++++++++++++++++++++------------------
>  drivers/staging/hv/storvsc.c     |   67 +++++++++++-----------
>  drivers/staging/hv/storvsc_api.h |   50 ++++++++--------
>  drivers/staging/hv/storvsc_drv.c |   91 +++++++++++++++---------------
>  5 files changed, 175 insertions(+), 168 deletions(-)
> 
> diff --git a/drivers/staging/hv/blkvsc.c b/drivers/staging/hv/blkvsc.c
> index d5b0abd..9ac04c3 100644
> --- a/drivers/staging/hv/blkvsc.c
> +++ b/drivers/staging/hv/blkvsc.c
> @@ -51,12 +51,12 @@ static int BlkVscOnDeviceAdd(struct hv_device *Device, 
> void *AdditionalInfo)
>  	 * id. For IDE devices, the device instance id is formatted as
>  	 * <bus id> * - <device id> - 8899 - 000000000000.
>  	 */
> -	deviceInfo->PathId = Device->deviceInstance.data[3] << 24 |
> +	deviceInfo->path_id = Device->deviceInstance.data[3] << 24 |
>  			     Device->deviceInstance.data[2] << 16 |
>  			     Device->deviceInstance.data[1] << 8  |
>  			     Device->deviceInstance.data[0];
>  
> -	deviceInfo->TargetId = Device->deviceInstance.data[5] << 8 |
> +	deviceInfo->target_id = Device->deviceInstance.data[5] << 8 |
>  			       Device->deviceInstance.data[4];
>  
>  	return ret;
> @@ -75,7 +75,7 @@ int BlkVscInitialize(struct hv_driver *Driver)
>  	Driver->name = gBlkDriverName;
>  	memcpy(&Driver->deviceType, &gBlkVscDeviceType, sizeof(struct hv_guid));
>  
> -	storDriver->RequestExtSize = sizeof(struct storvsc_request_extension);
> +	storDriver->request_ext_size = sizeof(struct storvsc_request_extension);
>  
>  	/*
>  	 * Divide the ring buffer data size (which is 1 page less than the ring
> @@ -83,20 +83,20 @@ int BlkVscInitialize(struct hv_driver *Driver)
>  	 * by the max request size (which is
>  	 * vmbus_channel_packet_multipage_buffer + struct vstor_packet + u64)
>  	 */
> -	storDriver->MaxOutstandingRequestsPerChannel =
> -		((storDriver->RingBufferSize - PAGE_SIZE) /
> +	storDriver->max_outstanding_req_per_channel =
> +		((storDriver->ring_buffer_size - PAGE_SIZE) /
>  		  ALIGN_UP(MAX_MULTIPAGE_BUFFER_PACKET +
>  			   sizeof(struct vstor_packet) + sizeof(u64),
>  			   sizeof(u64)));
>  
>  	DPRINT_INFO(BLKVSC, "max io outstd %u",
> -		    storDriver->MaxOutstandingRequestsPerChannel);
> +		    storDriver->max_outstanding_req_per_channel);
>  
>  	/* Setup the dispatch table */
> -	storDriver->Base.OnDeviceAdd = BlkVscOnDeviceAdd;
> -	storDriver->Base.OnDeviceRemove = StorVscOnDeviceRemove;
> -	storDriver->Base.OnCleanup = StorVscOnCleanup;
> -	storDriver->OnIORequest	= StorVscOnIORequest;
> +	storDriver->base.OnDeviceAdd = BlkVscOnDeviceAdd;
> +	storDriver->base.OnDeviceRemove = StorVscOnDeviceRemove;
> +	storDriver->base.OnCleanup = StorVscOnCleanup;
> +	storDriver->on_io_request = StorVscOnIORequest;
>  
>  	return ret;
>  }
> diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
> index 3f81ca5..d65d69e 100644
> --- a/drivers/staging/hv/blkvsc_drv.c
> +++ b/drivers/staging/hv/blkvsc_drv.c
> @@ -177,13 +177,13 @@ static int blkvsc_drv_init(int (*drv_init)(struct 
> hv_driver *drv))
>  	struct driver_context *drv_ctx = &g_blkvsc_drv.drv_ctx;
>  	int ret;
>  
> -	storvsc_drv_obj->RingBufferSize = blkvsc_ringbuffer_size;
> +	storvsc_drv_obj->ring_buffer_size = blkvsc_ringbuffer_size;
>  
>  	/* Callback to client driver to complete the initialization */
> -	drv_init(&storvsc_drv_obj->Base);
> +	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,
> +	drv_ctx->driver.name = storvsc_drv_obj->base.name;
> +	memcpy(&drv_ctx->class_id, &storvsc_drv_obj->base.deviceType,
>  	       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.OnCleanup)
> +		storvsc_drv_obj->base.OnCleanup(&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.OnDeviceAdd) {
>  		DPRINT_ERR(BLKVSC_DRV, "OnDeviceAdd() not set");
>  		ret = -1;
>  		goto Cleanup;
> @@ -284,7 +284,7 @@ static int blkvsc_probe(struct device *device)
>  
>  	blkdev->request_pool = kmem_cache_create(dev_name(&device_ctx->device),
>  					sizeof(struct blkvsc_request) +
> -					storvsc_drv_obj->RequestExtSize, 0,
> +					storvsc_drv_obj->request_ext_size, 0,
>  					SLAB_HWCACHE_ALIGN, NULL);
>  	if (!blkdev->request_pool) {
>  		ret = -ENOMEM;
> @@ -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.OnDeviceAdd(device_obj, &device_info);
>  	if (ret != 0) {
>  		DPRINT_ERR(BLKVSC_DRV, "unable to add blkvsc device");
>  		goto Cleanup;
> @@ -301,9 +301,9 @@ static int blkvsc_probe(struct device *device)
>  
>  	blkdev->device_ctx = device_ctx;
>  	/* this identified the device 0 or 1 */
> -	blkdev->target = device_info.TargetId;
> +	blkdev->target = device_info.target_id;
>  	/* this identified the ide ctrl 0 or 1 */
> -	blkdev->path = device_info.PathId;
> +	blkdev->path = device_info.path_id;
>  
>  	dev_set_drvdata(device, blkdev);
>  
> @@ -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.OnDeviceRemove(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.DataBuffer.PfnArray[0] = 0;
> -	blkvsc_req->request.DataBuffer.Offset = 0;
> -	blkvsc_req->request.DataBuffer.Length = 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->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.DataBuffer.PfnArray[0] = page_to_pfn(page_buf);
> -	blkvsc_req->request.DataBuffer.Offset = 0;
> -	blkvsc_req->request.DataBuffer.Length = 64;
> +	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->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.DataBuffer.PfnArray[0] = page_to_pfn(page_buf);
> -	blkvsc_req->request.DataBuffer.Offset = 0;
> -	blkvsc_req->request.DataBuffer.Length = 8;
> +	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->cmnd[0] = READ_CAPACITY;
>  	blkvsc_req->cmd_len = 16;
> @@ -614,7 +614,7 @@ static int blkvsc_do_read_capacity(struct 
> block_device_context *blkdev)
>  	wait_event_interruptible(blkvsc_req->wevent, blkvsc_req->cond);
>  
>  	/* check error */
> -	if (blkvsc_req->request.Status) {
> +	if (blkvsc_req->request.status) {
>  		scsi_normalize_sense(blkvsc_req->sense_buffer,
>  				     SCSI_SENSE_BUFFERSIZE, &sense_hdr);
>  
> @@ -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.DataBuffer.PfnArray[0] = page_to_pfn(page_buf);
> -	blkvsc_req->request.DataBuffer.Offset = 0;
> -	blkvsc_req->request.DataBuffer.Length = 12;
> +	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->cmnd[0] = 0x9E; /* READ_CAPACITY16; */
>  	blkvsc_req->cmd_len = 16;
> @@ -691,7 +691,7 @@ static int blkvsc_do_read_capacity16(struct 
> block_device_context *blkdev)
>  	wait_event_interruptible(blkvsc_req->wevent, blkvsc_req->cond);
>  
>  	/* check error */
> -	if (blkvsc_req->request.Status) {
> +	if (blkvsc_req->request.status) {
>  		scsi_normalize_sense(blkvsc_req->sense_buffer,
>  				     SCSI_SENSE_BUFFERSIZE, &sense_hdr);
>  		if (sense_hdr.asc == 0x3A) {
> @@ -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.OnDeviceRemove)
>  		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.OnDeviceRemove(device_obj);
>  	if (ret != 0) {
>  		/* TODO: */
>  		DPRINT_ERR(BLKVSC_DRV,
> @@ -865,38 +865,38 @@ 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.DataBuffer.Offset,
> -		   blkvsc_req->request.DataBuffer.Length);
> +		   blkvsc_req->request.data_buffer.Offset,
> +		   blkvsc_req->request.data_buffer.Length);
>  #if 0
> -	for (i = 0; i < (blkvsc_req->request.DataBuffer.Length >> 12); i++) {
> +	for (i = 0; i < (blkvsc_req->request.data_buffer.Length >> 12); i++) {
>  		DPRINT_DBG(BLKVSC_DRV, "blkvsc_submit_request() - "
>  			   "req %p pfn[%d] %llx\n",
>  			   blkvsc_req, i,
> -			   blkvsc_req->request.DataBuffer.PfnArray[i]);
> +			   blkvsc_req->request.data_buffer.PfnArray[i]);
>  	}
>  #endif
>  
>  	storvsc_req = &blkvsc_req->request;
> -	storvsc_req->Extension = (void *)((unsigned long)blkvsc_req +
> +	storvsc_req->extension = (void *)((unsigned long)blkvsc_req +
>  					  sizeof(struct blkvsc_request));
>  
> -	storvsc_req->Type = blkvsc_req->write ? WRITE_TYPE : READ_TYPE;
> +	storvsc_req->type = blkvsc_req->write ? WRITE_TYPE : READ_TYPE;
>  
> -	storvsc_req->OnIOCompletion = request_completion;
> -	storvsc_req->Context = blkvsc_req;
> +	storvsc_req->on_io_completion = request_completion;
> +	storvsc_req->context = blkvsc_req;
>  
> -	storvsc_req->Host = blkdev->port;
> -	storvsc_req->Bus = blkdev->path;
> -	storvsc_req->TargetId = blkdev->target;
> -	storvsc_req->LunId = 0;	 /* this is not really used at all */
> +	storvsc_req->host = blkdev->port;
> +	storvsc_req->bus = blkdev->path;
> +	storvsc_req->target_id = blkdev->target;
> +	storvsc_req->lun_id = 0;	 /* this is not really used at all */
>  
> -	storvsc_req->CdbLen = blkvsc_req->cmd_len;
> -	storvsc_req->Cdb = blkvsc_req->cmnd;
> +	storvsc_req->cdb_len = blkvsc_req->cmd_len;
> +	storvsc_req->cdb = blkvsc_req->cmnd;
>  
> -	storvsc_req->SenseBuffer = blkvsc_req->sense_buffer;
> -	storvsc_req->SenseBufferSize = SCSI_SENSE_BUFFERSIZE;
> +	storvsc_req->sense_buffer = blkvsc_req->sense_buffer;
> +	storvsc_req->sense_buffer_size = SCSI_SENSE_BUFFERSIZE;
>  
> -	ret = storvsc_drv_obj->OnIORequest(&blkdev->device_ctx->device_obj,
> +	ret = storvsc_drv_obj->on_io_request(&blkdev->device_ctx->device_obj,
>  					   &blkvsc_req->request);
>  	if (ret == 0)
>  		blkdev->num_outstanding_reqs++;
> @@ -992,8 +992,10 @@ static int blkvsc_do_request(struct block_device_context 
> *blkdev,
>  
>  					blkvsc_req->dev = blkdev;
>  					blkvsc_req->req = req;
> -					blkvsc_req->request.DataBuffer.Offset = bvec->bv_offset;
> -					blkvsc_req->request.DataBuffer.Length = 0;
> +					blkvsc_req->request.data_buffer.Offset
> +						= bvec->bv_offset;
> +					blkvsc_req->request.data_buffer.Length
> +						= 0;
>  
>  					/* Add to the group */
>  					blkvsc_req->group = group;
> @@ -1007,8 +1009,11 @@ static int blkvsc_do_request(struct 
> block_device_context *blkdev,
>  				}
>  
>  				/* Add the curr bvec/segment to the curr blkvsc_req */
> -				blkvsc_req->request.DataBuffer.PfnArray[databuf_idx] = 
> page_to_pfn(bvec->bv_page);
> -				blkvsc_req->request.DataBuffer.Length += bvec->bv_len;
> +				blkvsc_req->request.data_buffer.
> +					PfnArray[databuf_idx]
> +						= page_to_pfn(bvec->bv_page);
> +				blkvsc_req->request.data_buffer.Length
> +					+= bvec->bv_len;
>  
>  				prev_bvec = bvec;
>  
> @@ -1073,7 +1078,7 @@ static int blkvsc_do_request(struct 
> block_device_context *blkdev,
>  static void blkvsc_cmd_completion(struct hv_storvsc_request *request)
>  {
>  	struct blkvsc_request *blkvsc_req =
> -			(struct blkvsc_request *)request->Context;
> +			(struct blkvsc_request *)request->context;
>  	struct block_device_context *blkdev =
>  			(struct block_device_context *)blkvsc_req->dev;
>  	struct scsi_sense_hdr sense_hdr;
> @@ -1083,7 +1088,7 @@ static void blkvsc_cmd_completion(struct 
> hv_storvsc_request *request)
>  
>  	blkdev->num_outstanding_reqs--;
>  
> -	if (blkvsc_req->request.Status)
> +	if (blkvsc_req->request.status)
>  		if (scsi_normalize_sense(blkvsc_req->sense_buffer,
>  					 SCSI_SENSE_BUFFERSIZE, &sense_hdr))
>  			scsi_print_sense_hdr("blkvsc", &sense_hdr);
> @@ -1095,7 +1100,7 @@ static void blkvsc_cmd_completion(struct 
> hv_storvsc_request *request)
>  static void blkvsc_request_completion(struct hv_storvsc_request *request)
>  {
>  	struct blkvsc_request *blkvsc_req =
> -			(struct blkvsc_request *)request->Context;
> +			(struct blkvsc_request *)request->context;
>  	struct block_device_context *blkdev =
>  			(struct block_device_context *)blkvsc_req->dev;
>  	unsigned long flags;
> @@ -1110,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.DataBuffer.Length,
> +		   blkvsc_req->request.data_buffer.Length,
>  		   blkvsc_req->group->outstanding,
>  		   blkdev->num_outstanding_reqs);
>  
> @@ -1137,7 +1142,7 @@ static void blkvsc_request_completion(struct 
> hv_storvsc_request *request)
>  			list_del(&comp_req->req_entry);
>  
>  			if (!__blk_end_request(comp_req->req,
> -				(!comp_req->request.Status ? 0 : -EIO),
> +				(!comp_req->request.status ? 0 : -EIO),
>  				comp_req->sector_count * blkdev->sector_size)) {
>  				/*
>  				 * All the sectors have been xferred ie the
> @@ -1195,7 +1200,7 @@ static int blkvsc_cancel_pending_reqs(struct 
> block_device_context *blkdev)
>  
>  			if (comp_req->req) {
>  				ret = __blk_end_request(comp_req->req,
> -					(!comp_req->request.Status ? 0 : -EIO),
> +					(!comp_req->request.status ? 0 : -EIO),
>  					comp_req->sector_count *
>  					blkdev->sector_size);
>  
> diff --git a/drivers/staging/hv/storvsc.c b/drivers/staging/hv/storvsc.c
> index 96b4ed9..c4346c6 100644
> --- a/drivers/staging/hv/storvsc.c
> +++ b/drivers/staging/hv/storvsc.c
> @@ -370,16 +370,16 @@ static void StorVscOnIOCompletion(struct hv_device 
> *Device,
>  	/* ASSERT(request->OnIOCompletion != NULL); */
>  
>  	/* Copy over the status...etc */
> -	request->Status = VStorPacket->vm_srb.scsi_status;
> +	request->status = VStorPacket->vm_srb.scsi_status;
>  
> -	if (request->Status != 0 || VStorPacket->vm_srb.srb_status != 1) {
> +	if (request->status != 0 || VStorPacket->vm_srb.srb_status != 1) {
>  		DPRINT_WARN(STORVSC,
>  			    "cmd 0x%x scsi status 0x%x srb status 0x%x\n",
> -			    request->Cdb[0], VStorPacket->vm_srb.scsi_status,
> +			    request->cdb[0], VStorPacket->vm_srb.scsi_status,
>  			    VStorPacket->vm_srb.srb_status);
>  	}
>  
> -	if ((request->Status & 0xFF) == 0x02) {
> +	if ((request->status & 0xFF) == 0x02) {
>  		/* CHECK_CONDITION */
>  		if (VStorPacket->vm_srb.srb_status & 0x80) {
>  			/* autosense data available */
> @@ -389,19 +389,19 @@ static void StorVscOnIOCompletion(struct hv_device 
> *Device,
>  
>  			/* ASSERT(VStorPacket->vm_srb.sense_info_length <= */
>  			/* 	request->SenseBufferSize); */
> -			memcpy(request->SenseBuffer,
> +			memcpy(request->sense_buffer,
>  			       VStorPacket->vm_srb.sense_data,
>  			       VStorPacket->vm_srb.sense_info_length);
>  
> -			request->SenseBufferSize =
> +			request->sense_buffer_size =
>  					VStorPacket->vm_srb.sense_info_length;
>  		}
>  	}
>  
>  	/* TODO: */
> -	request->BytesXfer = VStorPacket->vm_srb.data_transfer_length;
> +	request->bytes_xfer = VStorPacket->vm_srb.data_transfer_length;
>  
> -	request->OnIOCompletion(request);
> +	request->on_io_completion(request);
>  
>  	atomic_dec(&storDevice->NumOutstandingRequests);
>  
> @@ -501,7 +501,8 @@ static int StorVscConnectToVsp(struct hv_device *Device)
>  
>  	/* Open the channel */
>  	ret = vmbus_open(Device->channel,
> -			 storDriver->RingBufferSize, storDriver->RingBufferSize,
> +			 storDriver->ring_buffer_size,
> +			 storDriver->ring_buffer_size,
>  			 (void *)&props,
>  			 sizeof(struct vmstorage_channel_properties),
>  			 StorVscOnChannelCallback, Device);
> @@ -551,13 +552,13 @@ static int StorVscOnDeviceAdd(struct hv_device *Device, 
> void *AdditionalInfo)
>  	storChannel->PathId = props->PathId;
>  	storChannel->TargetId = props->TargetId; */
>  
> -	storDevice->PortNumber = deviceInfo->PortNumber;
> +	storDevice->PortNumber = deviceInfo->port_number;
>  	/* Send it back up */
>  	ret = StorVscConnectToVsp(Device);
>  
>  	/* deviceInfo->PortNumber = storDevice->PortNumber; */
> -	deviceInfo->PathId = storDevice->PathId;
> -	deviceInfo->TargetId = storDevice->TargetId;
> +	deviceInfo->path_id = storDevice->PathId;
> +	deviceInfo->target_id = storDevice->TargetId;
>  
>  	DPRINT_DBG(STORVSC, "assigned port %u, path %u target %u\n",
>  		   storDevice->PortNumber, storDevice->PathId,
> @@ -672,7 +673,7 @@ static int StorVscOnIORequest(struct hv_device *Device,
>  	int ret = 0;
>  
>  	requestExtension =
> -		(struct storvsc_request_extension *)Request->Extension;
> +		(struct storvsc_request_extension *)Request->extension;
>  	vstorPacket = &requestExtension->VStorPacket;
>  	storDevice = GetStorDevice(Device);
>  
> @@ -681,8 +682,8 @@ static int StorVscOnIORequest(struct hv_device *Device,
>  		   requestExtension);
>  
>  	DPRINT_DBG(STORVSC, "req %p len %d bus %d, target %d, lun %d cdblen %d",
> -		   Request, Request->DataBuffer.Length, Request->Bus,
> -		   Request->TargetId, Request->LunId, Request->CdbLen);
> +		   Request, Request->data_buffer.Length, Request->bus,
> +		   Request->target_id, Request->lun_id, Request->cdb_len);
>  
>  	if (!storDevice) {
>  		DPRINT_ERR(STORVSC, "unable to get stor device..."
> @@ -702,19 +703,19 @@ static int StorVscOnIORequest(struct hv_device *Device,
>  
>  	vstorPacket->vm_srb.length = sizeof(struct vmscsi_request);
>  
> -	vstorPacket->vm_srb.port_number = Request->Host;
> -	vstorPacket->vm_srb.path_id = Request->Bus;
> -	vstorPacket->vm_srb.target_id = Request->TargetId;
> -	vstorPacket->vm_srb.lun = Request->LunId;
> +	vstorPacket->vm_srb.port_number = Request->host;
> +	vstorPacket->vm_srb.path_id = Request->bus;
> +	vstorPacket->vm_srb.target_id = Request->target_id;
> +	vstorPacket->vm_srb.lun = Request->lun_id;
>  
>  	vstorPacket->vm_srb.sense_info_length = SENSE_BUFFER_SIZE;
>  
>  	/* Copy over the scsi command descriptor block */
> -	vstorPacket->vm_srb.cdb_length = Request->CdbLen;
> -	memcpy(&vstorPacket->vm_srb.cdb, Request->Cdb, Request->CdbLen);
> +	vstorPacket->vm_srb.cdb_length = Request->cdb_len;
> +	memcpy(&vstorPacket->vm_srb.cdb, Request->cdb, Request->cdb_len);
>  
> -	vstorPacket->vm_srb.data_in = Request->Type;
> -	vstorPacket->vm_srb.data_transfer_length = Request->DataBuffer.Length;
> +	vstorPacket->vm_srb.data_in = Request->type;
> +	vstorPacket->vm_srb.data_transfer_length = Request->data_buffer.Length;
>  
>  	vstorPacket->operation = VSTOR_OPERATION_EXECUTE_SRB;
>  
> @@ -728,9 +729,9 @@ static int StorVscOnIORequest(struct hv_device *Device,
>  		   vstorPacket->vm_srb.sense_info_length,
>  		   vstorPacket->vm_srb.cdb_length);
>  
> -	if (requestExtension->Request->DataBuffer.Length) {
> +	if (requestExtension->Request->data_buffer.Length) {
>  		ret = vmbus_sendpacket_multipagebuffer(Device->channel,
> -				&requestExtension->Request->DataBuffer,
> +				&requestExtension->Request->data_buffer,
>  				vstorPacket,
>  				sizeof(struct vstor_packet),
>  				(unsigned long)requestExtension);
> @@ -785,7 +786,7 @@ int StorVscInitialize(struct hv_driver *Driver)
>  	memcpy(&Driver->deviceType, &gStorVscDeviceType,
>  	       sizeof(struct hv_guid));
>  
> -	storDriver->RequestExtSize = sizeof(struct storvsc_request_extension);
> +	storDriver->request_ext_size = sizeof(struct storvsc_request_extension);
>  
>  	/*
>  	 * Divide the ring buffer data size (which is 1 page less
> @@ -793,22 +794,22 @@ int StorVscInitialize(struct hv_driver *Driver)
>  	 * the ring buffer indices) by the max request size (which is
>  	 * vmbus_channel_packet_multipage_buffer + struct vstor_packet + u64)
>  	 */
> -	storDriver->MaxOutstandingRequestsPerChannel =
> -		((storDriver->RingBufferSize - PAGE_SIZE) /
> +	storDriver->max_outstanding_req_per_channel =
> +		((storDriver->ring_buffer_size - PAGE_SIZE) /
>  		  ALIGN_UP(MAX_MULTIPAGE_BUFFER_PACKET +
>  			   sizeof(struct vstor_packet) + sizeof(u64),
>  			   sizeof(u64)));
>  
>  	DPRINT_INFO(STORVSC, "max io %u, currently %u\n",
> -		    storDriver->MaxOutstandingRequestsPerChannel,
> +		    storDriver->max_outstanding_req_per_channel,
>  		    STORVSC_MAX_IO_REQUESTS);
>  
>  	/* Setup the dispatch table */
> -	storDriver->Base.OnDeviceAdd	= StorVscOnDeviceAdd;
> -	storDriver->Base.OnDeviceRemove	= StorVscOnDeviceRemove;
> -	storDriver->Base.OnCleanup	= StorVscOnCleanup;
> +	storDriver->base.OnDeviceAdd	= StorVscOnDeviceAdd;
> +	storDriver->base.OnDeviceRemove	= StorVscOnDeviceRemove;
> +	storDriver->base.OnCleanup	= StorVscOnCleanup;
>  
> -	storDriver->OnIORequest		= StorVscOnIORequest;
> +	storDriver->on_io_request	= StorVscOnIORequest;
>  
>  	return 0;
>  }
> diff --git a/drivers/staging/hv/storvsc_api.h 
> b/drivers/staging/hv/storvsc_api.h
> index 8505a1c..46f031e 100644
> --- a/drivers/staging/hv/storvsc_api.h
> +++ b/drivers/staging/hv/storvsc_api.h
> @@ -53,58 +53,58 @@ enum storvsc_request_type{
>  };
>  
>  struct hv_storvsc_request {
> -	enum storvsc_request_type Type;
> -	u32 Host;
> -	u32 Bus;
> -	u32 TargetId;
> -	u32 LunId;
> -	u8 *Cdb;
> -	u32 CdbLen;
> -	u32 Status;
> -	u32 BytesXfer;
> +	enum storvsc_request_type type;
> +	u32 host;
> +	u32 bus;
> +	u32 target_id;
> +	u32 lun_id;
> +	u8 *cdb;
> +	u32 cdb_len;
> +	u32 status;
> +	u32 bytes_xfer;
>  
> -	unsigned char *SenseBuffer;
> -	u32 SenseBufferSize;
> +	unsigned char *sense_buffer;
> +	u32 sense_buffer_size;
>  
> -	void *Context;
> +	void *context;
>  
> -	void (*OnIOCompletion)(struct hv_storvsc_request *Request);
> +	void (*on_io_completion)(struct hv_storvsc_request *request);
>  
>  	/* This points to the memory after DataBuffer */
> -	void *Extension;
> +	void *extension;
>  
> -	struct hv_multipage_buffer DataBuffer;
> +	struct hv_multipage_buffer data_buffer;
>  };
>  
>  /* Represents the block vsc driver */
>  struct storvsc_driver_object {
>  	/* Must be the first field */
>  	/* Which is a bug FIXME! */
> -	struct hv_driver Base;
> +	struct hv_driver base;
>  
>  	/* Set by caller (in bytes) */
> -	u32 RingBufferSize;
> +	u32 ring_buffer_size;
>  
>  	/* Allocate this much private extension for each I/O request */
> -	u32 RequestExtSize;
> +	u32 request_ext_size;
>  
>  	/* Maximum # of requests in flight per channel/device */
> -	u32 MaxOutstandingRequestsPerChannel;
> +	u32 max_outstanding_req_per_channel;
>  
>  	/* Specific to this driver */
> -	int (*OnIORequest)(struct hv_device *Device,
> -			   struct hv_storvsc_request *Request);
> +	int (*on_io_request)(struct hv_device *device,
> +			   struct hv_storvsc_request *request);
>  };
>  
>  struct storvsc_device_info {
> -	unsigned int PortNumber;
> -	unsigned char PathId;
> -	unsigned char TargetId;
> +	unsigned int port_number;
> +	unsigned char path_id;
> +	unsigned char target_id;
>  };
>  
>  /* Interface */
>  int StorVscInitialize(struct hv_driver *driver);
> -int StorVscOnHostReset(struct hv_device *Device);
> +int StorVscOnHostReset(struct hv_device *device);
>  int BlkVscInitialize(struct hv_driver *driver);
>  
>  #endif /* _STORVSC_API_H_ */
> diff --git a/drivers/staging/hv/storvsc_drv.c 
> b/drivers/staging/hv/storvsc_drv.c
> index defc34a..03695ce 100644
> --- a/drivers/staging/hv/storvsc_drv.c
> +++ b/drivers/staging/hv/storvsc_drv.c
> @@ -141,28 +141,28 @@ static int storvsc_drv_init(int (*drv_init)(struct 
> hv_driver *drv))
>  	struct storvsc_driver_object *storvsc_drv_obj = &g_storvsc_drv.drv_obj;
>  	struct driver_context *drv_ctx = &g_storvsc_drv.drv_ctx;
>  
> -	storvsc_drv_obj->RingBufferSize = storvsc_ringbuffer_size;
> +	storvsc_drv_obj->ring_buffer_size = storvsc_ringbuffer_size;
>  
>  	/* Callback to client driver to complete the initialization */
> -	drv_init(&storvsc_drv_obj->Base);
> +	drv_init(&storvsc_drv_obj->base);
>  
>  	DPRINT_INFO(STORVSC_DRV,
>  		    "request extension size %u, max outstanding reqs %u",
> -		    storvsc_drv_obj->RequestExtSize,
> -		    storvsc_drv_obj->MaxOutstandingRequestsPerChannel);
> +		    storvsc_drv_obj->request_ext_size,
> +		    storvsc_drv_obj->max_outstanding_req_per_channel);
>  
> -	if (storvsc_drv_obj->MaxOutstandingRequestsPerChannel <
> +	if (storvsc_drv_obj->max_outstanding_req_per_channel <
>  	    STORVSC_MAX_IO_REQUESTS) {
>  		DPRINT_ERR(STORVSC_DRV,
>  			   "The number of outstanding io requests (%d) "
>  			   "is larger than that supported (%d) internally.",
>  			   STORVSC_MAX_IO_REQUESTS,
> -			   storvsc_drv_obj->MaxOutstandingRequestsPerChannel);
> +			   storvsc_drv_obj->max_outstanding_req_per_channel);
>  		return -1;
>  	}
>  
> -	drv_ctx->driver.name = storvsc_drv_obj->Base.name;
> -	memcpy(&drv_ctx->class_id, &storvsc_drv_obj->Base.deviceType,
> +	drv_ctx->driver.name = storvsc_drv_obj->base.name;
> +	memcpy(&drv_ctx->class_id, &storvsc_drv_obj->base.deviceType,
>  	       sizeof(struct hv_guid));
>  
>  	drv_ctx->probe = storvsc_probe;
> @@ -207,8 +207,8 @@ static void storvsc_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.OnCleanup)
> +		storvsc_drv_obj->base.OnCleanup(&storvsc_drv_obj->base);
>  
>  	vmbus_child_driver_unregister(drv_ctx);
>  	return;
> @@ -232,7 +232,7 @@ static int storvsc_probe(struct device *device)
>  	struct host_device_context *host_device_ctx;
>  	struct storvsc_device_info device_info;
>  
> -	if (!storvsc_drv_obj->Base.OnDeviceAdd)
> +	if (!storvsc_drv_obj->base.OnDeviceAdd)
>  		return -1;
>  
>  	host = scsi_host_alloc(&scsi_driver,
> @@ -253,7 +253,7 @@ static int storvsc_probe(struct device *device)
>  	host_device_ctx->request_pool =
>  				kmem_cache_create(dev_name(&device_ctx->device),
>  					sizeof(struct storvsc_cmd_request) +
> -					storvsc_drv_obj->RequestExtSize, 0,
> +					storvsc_drv_obj->request_ext_size, 0,
>  					SLAB_HWCACHE_ALIGN, NULL);
>  
>  	if (!host_device_ctx->request_pool) {
> @@ -261,9 +261,9 @@ static int storvsc_probe(struct device *device)
>  		return -ENOMEM;
>  	}
>  
> -	device_info.PortNumber = host->host_no;
> +	device_info.port_number = host->host_no;
>  	/* Call to the vsc driver to add the device */
> -	ret = storvsc_drv_obj->Base.OnDeviceAdd(device_obj,
> +	ret = storvsc_drv_obj->base.OnDeviceAdd(device_obj,
>  						(void *)&device_info);
>  	if (ret != 0) {
>  		DPRINT_ERR(STORVSC_DRV, "unable to add scsi vsc device");
> @@ -273,8 +273,8 @@ static int storvsc_probe(struct device *device)
>  	}
>  
>  	/* host_device_ctx->port = device_info.PortNumber; */
> -	host_device_ctx->path = device_info.PathId;
> -	host_device_ctx->target = device_info.TargetId;
> +	host_device_ctx->path = device_info.path_id;
> +	host_device_ctx->target = device_info.target_id;
>  
>  	/* max # of devices per target */
>  	host->max_lun = STORVSC_MAX_LUNS_PER_TARGET;
> @@ -288,7 +288,7 @@ static int storvsc_probe(struct device *device)
>  	if (ret != 0) {
>  		DPRINT_ERR(STORVSC_DRV, "unable to add scsi host device");
>  
> -		storvsc_drv_obj->Base.OnDeviceRemove(device_obj);
> +		storvsc_drv_obj->base.OnDeviceRemove(device_obj);
>  
>  		kmem_cache_destroy(host_device_ctx->request_pool);
>  		scsi_host_put(host);
> @@ -318,14 +318,14 @@ static int storvsc_remove(struct device *device)
>  			(struct host_device_context *)host->hostdata;
>  
>  
> -	if (!storvsc_drv_obj->Base.OnDeviceRemove)
> +	if (!storvsc_drv_obj->base.OnDeviceRemove)
>  		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.OnDeviceRemove(device_obj);
>  	if (ret != 0) {
>  		/* TODO: */
>  		DPRINT_ERR(STORVSC, "unable to remove vsc device (ret %d)",
> @@ -351,7 +351,7 @@ static int storvsc_remove(struct device *device)
>  static void storvsc_commmand_completion(struct hv_storvsc_request *request)
>  {
>  	struct storvsc_cmd_request *cmd_request =
> -		(struct storvsc_cmd_request *)request->Context;
> +		(struct storvsc_cmd_request *)request->context;
>  	struct scsi_cmnd *scmnd = cmd_request->cmd;
>  	struct host_device_context *host_device_ctx =
>  		(struct host_device_context *)scmnd->device->host->hostdata;
> @@ -376,16 +376,17 @@ static void storvsc_commmand_completion(struct 
> hv_storvsc_request *request)
>  				      cmd_request->bounce_sgl_count);
>  	}
>  
> -	scmnd->result = request->Status;
> +	scmnd->result = request->status;
>  
>  	if (scmnd->result) {
>  		if (scsi_normalize_sense(scmnd->sense_buffer,
> -					 request->SenseBufferSize, &sense_hdr))
> +				request->sense_buffer_size, &sense_hdr))
>  			scsi_print_sense_hdr("storvsc", &sense_hdr);
>  	}
>  
> -	/* ASSERT(request->BytesXfer <= request->DataBuffer.Length); */
> -	scsi_set_resid(scmnd, request->DataBuffer.Length - request->BytesXfer);
> +	/* ASSERT(request->BytesXfer <= request->data_buffer.Length); */
> +	scsi_set_resid(scmnd,
> +		request->data_buffer.Length - request->bytes_xfer);
>  
>  	scsi_done_fn = scmnd->scsi_done;
>  
> @@ -658,42 +659,42 @@ static int storvsc_queuecommand_lck(struct scsi_cmnd 
> *scmnd,
>  
>  	request = &cmd_request->request;
>  
> -	request->Extension =
> +	request->extension =
>  		(void *)((unsigned long)cmd_request + request_size);
>  	DPRINT_DBG(STORVSC_DRV, "req %p size %d ext %d", request, request_size,
> -		   storvsc_drv_obj->RequestExtSize);
> +		   storvsc_drv_obj->request_ext_size);
>  
>  	/* Build the SRB */
>  	switch (scmnd->sc_data_direction) {
>  	case DMA_TO_DEVICE:
> -		request->Type = WRITE_TYPE;
> +		request->type = WRITE_TYPE;
>  		break;
>  	case DMA_FROM_DEVICE:
> -		request->Type = READ_TYPE;
> +		request->type = READ_TYPE;
>  		break;
>  	default:
> -		request->Type = UNKNOWN_TYPE;
> +		request->type = UNKNOWN_TYPE;
>  		break;
>  	}
>  
> -	request->OnIOCompletion = storvsc_commmand_completion;
> -	request->Context = cmd_request;/* scmnd; */
> +	request->on_io_completion = storvsc_commmand_completion;
> +	request->context = cmd_request;/* scmnd; */
>  
>  	/* request->PortId = scmnd->device->channel; */
> -	request->Host = host_device_ctx->port;
> -	request->Bus = scmnd->device->channel;
> -	request->TargetId = scmnd->device->id;
> -	request->LunId = scmnd->device->lun;
> +	request->host = host_device_ctx->port;
> +	request->bus = scmnd->device->channel;
> +	request->target_id = scmnd->device->id;
> +	request->lun_id = scmnd->device->lun;
>  
>  	/* ASSERT(scmnd->cmd_len <= 16); */
> -	request->CdbLen = scmnd->cmd_len;
> -	request->Cdb = scmnd->cmnd;
> +	request->cdb_len = scmnd->cmd_len;
> +	request->cdb = scmnd->cmnd;
>  
> -	request->SenseBuffer = scmnd->sense_buffer;
> -	request->SenseBufferSize = SCSI_SENSE_BUFFERSIZE;
> +	request->sense_buffer = scmnd->sense_buffer;
> +	request->sense_buffer_size = SCSI_SENSE_BUFFERSIZE;
>  
>  
> -	request->DataBuffer.Length = scsi_bufflen(scmnd);
> +	request->data_buffer.Length = scsi_bufflen(scmnd);
>  	if (scsi_sg_count(scmnd)) {
>  		sgl = (struct scatterlist *)scsi_sglist(scmnd);
>  		sg_count = scsi_sg_count(scmnd);
> @@ -734,25 +735,25 @@ static int storvsc_queuecommand_lck(struct scsi_cmnd 
> *scmnd,
>  			sg_count = cmd_request->bounce_sgl_count;
>  		}
>  
> -		request->DataBuffer.Offset = sgl[0].offset;
> +		request->data_buffer.Offset = sgl[0].offset;
>  
>  		for (i = 0; i < sg_count; i++) {
>  			DPRINT_DBG(STORVSC_DRV, "sgl[%d] len %d offset %d\n",
>  				   i, sgl[i].length, sgl[i].offset);
> -			request->DataBuffer.PfnArray[i] =
> +			request->data_buffer.PfnArray[i] =
>  				page_to_pfn(sg_page((&sgl[i])));
>  		}
>  	} else if (scsi_sglist(scmnd)) {
>  		/* ASSERT(scsi_bufflen(scmnd) <= PAGE_SIZE); */
> -		request->DataBuffer.Offset =
> +		request->data_buffer.Offset =
>  			virt_to_phys(scsi_sglist(scmnd)) & (PAGE_SIZE-1);
> -		request->DataBuffer.PfnArray[0] =
> +		request->data_buffer.PfnArray[0] =
>  			virt_to_phys(scsi_sglist(scmnd)) >> PAGE_SHIFT;
>  	}
>  
>  retry_request:
>  	/* Invokes the vsc to start an IO */
> -	ret = storvsc_drv_obj->OnIORequest(&device_ctx->device_obj,
> +	ret = storvsc_drv_obj->on_io_request(&device_ctx->device_obj,
>  					   &cmd_request->request);
>  	if (ret == -1) {
>  		/* no more space */

_______________________________________________
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