staging: hv: Remove camel case variables in channel.c

Rename camel case variables in channel.c and changed them to
lowercase.

Signed-off-by: Haiyang Zhang <haiyangz@microsoft.com>
Signed-off-by: Hank Janssen <hjanssen@microsoft.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

1 files changed, 387 insertions, 380 deletions

diff --git a/drivers/staging/hv/channel.c b/drivers/staging/hv/channel.c
index 37b7b4c0232..103748818fd 100644
--- a/drivers/staging/hv/channel.c
+++ b/drivers/staging/hv/channel.c
@@ -28,10 +28,10 @@
 
 /* Internal routines */
 static int VmbusChannelCreateGpadlHeader(
-        void *Kbuffer,  /* must be phys and virt contiguous */
-        u32 Size,       /* page-size multiple */
-        struct vmbus_channel_msginfo **msgInfo,
-        u32 *MessageCount);
+        void *kbuffer,  /* must be phys and virt contiguous */
+        u32 size,       /* page-size multiple */
+        struct vmbus_channel_msginfo **msginfo,
+        u32 *messagecount);
 static void DumpVmbusChannel(struct vmbus_channel *channel);
 static void VmbusChannelSetEvent(struct vmbus_channel *channel);
 
@@ -70,25 +70,25 @@ static void DumpMonitorPage(struct hv_monitor_page *MonitorPage)
  * VmbusChannelSetEvent - Trigger an event notification on the specified
  * channel.
  */
-static void VmbusChannelSetEvent(struct vmbus_channel *Channel)
+static void VmbusChannelSetEvent(struct vmbus_channel *channel)
 {
-        struct hv_monitor_page *monitorPage;
+        struct hv_monitor_page *monitorpage;
 
-        if (Channel->OfferMsg.MonitorAllocated) {
+        if (channel->OfferMsg.MonitorAllocated) {
                 /* Each u32 represents 32 channels */
-                set_bit(Channel->OfferMsg.ChildRelId & 31,
+                set_bit(channel->OfferMsg.ChildRelId & 31,
                         (unsigned long *) gVmbusConnection.SendInterruptPage +
-                        (Channel->OfferMsg.ChildRelId >> 5));
+                        (channel->OfferMsg.ChildRelId >> 5));
 
-                monitorPage = gVmbusConnection.MonitorPages;
-                monitorPage++; /* Get the child to parent monitor page */
+                monitorpage = gVmbusConnection.MonitorPages;
+                monitorpage++; /* Get the child to parent monitor page */
 
-                set_bit(Channel->MonitorBit,
-                        (unsigned long *)&monitorPage->TriggerGroup
-                                        [Channel->MonitorGroup].Pending);
+                set_bit(channel->MonitorBit,
+                        (unsigned long *)&monitorpage->TriggerGroup
+                                        [channel->MonitorGroup].Pending);
 
         } else {
-                VmbusSetEvent(Channel->OfferMsg.ChildRelId);
+                VmbusSetEvent(channel->OfferMsg.ChildRelId);
         }
 }
 
@@ -117,54 +117,54 @@ static void VmbusChannelClearEvent(struct vmbus_channel *channel)
 /*
  * VmbusChannelGetDebugInfo -Retrieve various channel debug info
  */
-void VmbusChannelGetDebugInfo(struct vmbus_channel *Channel,
-                              struct vmbus_channel_debug_info *DebugInfo)
+void VmbusChannelGetDebugInfo(struct vmbus_channel *channel,
+                              struct vmbus_channel_debug_info *debuginfo)
 {
-        struct hv_monitor_page *monitorPage;
-        u8 monitorGroup = (u8)Channel->OfferMsg.MonitorId / 32;
-        u8 monitorOffset = (u8)Channel->OfferMsg.MonitorId % 32;
+        struct hv_monitor_page *monitorpage;
+        u8 monitor_group = (u8)channel->OfferMsg.MonitorId / 32;
+        u8 monitor_offset = (u8)channel->OfferMsg.MonitorId % 32;
         /* u32 monitorBit       = 1 << monitorOffset; */
 
-        DebugInfo->RelId = Channel->OfferMsg.ChildRelId;
-        DebugInfo->State = Channel->State;
-        memcpy(&DebugInfo->InterfaceType,
-               &Channel->OfferMsg.Offer.InterfaceType, sizeof(struct hv_guid));
-        memcpy(&DebugInfo->InterfaceInstance,
-               &Channel->OfferMsg.Offer.InterfaceInstance,
+        debuginfo->RelId = channel->OfferMsg.ChildRelId;
+        debuginfo->State = channel->State;
+        memcpy(&debuginfo->InterfaceType,
+               &channel->OfferMsg.Offer.InterfaceType, sizeof(struct hv_guid));
+        memcpy(&debuginfo->InterfaceInstance,
+               &channel->OfferMsg.Offer.InterfaceInstance,
                sizeof(struct hv_guid));
 
-        monitorPage = (struct hv_monitor_page *)gVmbusConnection.MonitorPages;
+        monitorpage = (struct hv_monitor_page *)gVmbusConnection.MonitorPages;
 
-        DebugInfo->MonitorId = Channel->OfferMsg.MonitorId;
+        debuginfo->MonitorId = channel->OfferMsg.MonitorId;
 
-        DebugInfo->ServerMonitorPending =
-                        monitorPage->TriggerGroup[monitorGroup].Pending;
-        DebugInfo->ServerMonitorLatency =
-                        monitorPage->Latency[monitorGroup][monitorOffset];
-        DebugInfo->ServerMonitorConnectionId =
-                        monitorPage->Parameter[monitorGroup]
-                                              [monitorOffset].ConnectionId.u.Id;
+        debuginfo->ServerMonitorPending =
+                        monitorpage->TriggerGroup[monitor_group].Pending;
+        debuginfo->ServerMonitorLatency =
+                        monitorpage->Latency[monitor_group][monitor_offset];
+        debuginfo->ServerMonitorConnectionId =
+                        monitorpage->Parameter[monitor_group]
+                                        [monitor_offset].ConnectionId.u.Id;
 
-        monitorPage++;
+        monitorpage++;
 
-        DebugInfo->ClientMonitorPending =
-                        monitorPage->TriggerGroup[monitorGroup].Pending;
-        DebugInfo->ClientMonitorLatency =
-                        monitorPage->Latency[monitorGroup][monitorOffset];
-        DebugInfo->ClientMonitorConnectionId =
-                        monitorPage->Parameter[monitorGroup]
-                                              [monitorOffset].ConnectionId.u.Id;
+        debuginfo->ClientMonitorPending =
+                        monitorpage->TriggerGroup[monitor_group].Pending;
+        debuginfo->ClientMonitorLatency =
+                        monitorpage->Latency[monitor_group][monitor_offset];
+        debuginfo->ClientMonitorConnectionId =
+                        monitorpage->Parameter[monitor_group]
+                                        [monitor_offset].ConnectionId.u.Id;
 
-        RingBufferGetDebugInfo(&Channel->Inbound, &DebugInfo->Inbound);
-        RingBufferGetDebugInfo(&Channel->Outbound, &DebugInfo->Outbound);
+        RingBufferGetDebugInfo(&channel->Inbound, &debuginfo->Inbound);
+        RingBufferGetDebugInfo(&channel->Outbound, &debuginfo->Outbound);
 }
 
 /*
  * VmbusChannelOpen - Open the specified channel.
  */
-int VmbusChannelOpen(struct vmbus_channel *NewChannel, u32 SendRingBufferSize,
-                     u32 RecvRingBufferSize, void *UserData, u32 UserDataLen,
-                     void (*OnChannelCallback)(void *context), void *Context)
+int VmbusChannelOpen(struct vmbus_channel *newchannel, u32 send_ringbuffer_size,
+                     u32 recv_ringbuffer_size, void *userdata, u32 userdatalen,
+                     void (*onchannelcallback)(void *context), void *context)
 {
         struct vmbus_channel_open_channel *openMsg;
         struct vmbus_channel_msginfo *openInfo = NULL;
@@ -176,30 +176,30 @@ int VmbusChannelOpen(struct vmbus_channel *NewChannel, u32 SendRingBufferSize,
         /* ASSERT(!(SendRingBufferSize & (PAGE_SIZE - 1))); */
         /* ASSERT(!(RecvRingBufferSize & (PAGE_SIZE - 1))); */
 
-        NewChannel->OnChannelCallback = OnChannelCallback;
-        NewChannel->ChannelCallbackContext = Context;
+        newchannel->OnChannelCallback = onchannelcallback;
+        newchannel->ChannelCallbackContext = context;
 
         /* Allocate the ring buffer */
-        out = osd_PageAlloc((SendRingBufferSize + RecvRingBufferSize)
+        out = osd_PageAlloc((send_ringbuffer_size + recv_ringbuffer_size)
                              >> PAGE_SHIFT);
         if (!out)
                 return -ENOMEM;
 
         /* ASSERT(((unsigned long)out & (PAGE_SIZE-1)) == 0); */
 
-        in = (void *)((unsigned long)out + SendRingBufferSize);
+        in = (void *)((unsigned long)out + send_ringbuffer_size);
 
-        NewChannel->RingBufferPages = out;
-        NewChannel->RingBufferPageCount = (SendRingBufferSize +
-                                           RecvRingBufferSize) >> PAGE_SHIFT;
+        newchannel->RingBufferPages = out;
+        newchannel->RingBufferPageCount = (send_ringbuffer_size +
+                                           recv_ringbuffer_size) >> PAGE_SHIFT;
 
-        ret = RingBufferInit(&NewChannel->Outbound, out, SendRingBufferSize);
+        ret = RingBufferInit(&newchannel->Outbound, out, send_ringbuffer_size);
         if (ret != 0) {
                 err = ret;
                 goto errorout;
         }
 
-        ret = RingBufferInit(&NewChannel->Inbound, in, RecvRingBufferSize);
+        ret = RingBufferInit(&newchannel->Inbound, in, recv_ringbuffer_size);
         if (ret != 0) {
                 err = ret;
                 goto errorout;
@@ -208,15 +208,15 @@ int VmbusChannelOpen(struct vmbus_channel *NewChannel, u32 SendRingBufferSize,
 
         /* Establish the gpadl for the ring buffer */
         DPRINT_DBG(VMBUS, "Establishing ring buffer's gpadl for channel %p...",
-                   NewChannel);
+                   newchannel);
 
-        NewChannel->RingBufferGpadlHandle = 0;
+        newchannel->RingBufferGpadlHandle = 0;
 
-        ret = VmbusChannelEstablishGpadl(NewChannel,
-                                         NewChannel->Outbound.RingBuffer,
-                                         SendRingBufferSize +
-                                         RecvRingBufferSize,
-                                         &NewChannel->RingBufferGpadlHandle);
+        ret = VmbusChannelEstablishGpadl(newchannel,
+                                         newchannel->Outbound.RingBuffer,
+                                         send_ringbuffer_size +
+                                         recv_ringbuffer_size,
+                                         &newchannel->RingBufferGpadlHandle);
 
         if (ret != 0) {
                 err = ret;
@@ -225,13 +225,13 @@ int VmbusChannelOpen(struct vmbus_channel *NewChannel, u32 SendRingBufferSize,
 
         DPRINT_DBG(VMBUS, "channel %p <relid %d gpadl 0x%x send ring %p "
                    "size %d recv ring %p size %d, downstreamoffset %d>",
-                   NewChannel, NewChannel->OfferMsg.ChildRelId,
-                   NewChannel->RingBufferGpadlHandle,
-                   NewChannel->Outbound.RingBuffer,
-                   NewChannel->Outbound.RingSize,
-                   NewChannel->Inbound.RingBuffer,
-                   NewChannel->Inbound.RingSize,
-                   SendRingBufferSize);
+                   newchannel, newchannel->OfferMsg.ChildRelId,
+                   newchannel->RingBufferGpadlHandle,
+                   newchannel->Outbound.RingBuffer,
+                   newchannel->Outbound.RingSize,
+                   newchannel->Inbound.RingBuffer,
+                   newchannel->Inbound.RingSize,
+                   send_ringbuffer_size);
 
         /* Create and init the channel open message */
         openInfo = kmalloc(sizeof(*openInfo) +
@@ -250,20 +250,20 @@ int VmbusChannelOpen(struct vmbus_channel *NewChannel, u32 SendRingBufferSize,
 
         openMsg = (struct vmbus_channel_open_channel *)openInfo->Msg;
         openMsg->Header.MessageType = ChannelMessageOpenChannel;
-        openMsg->OpenId = NewChannel->OfferMsg.ChildRelId; /* FIXME */
-        openMsg->ChildRelId = NewChannel->OfferMsg.ChildRelId;
-        openMsg->RingBufferGpadlHandle = NewChannel->RingBufferGpadlHandle;
-        openMsg->DownstreamRingBufferPageOffset = SendRingBufferSize >>
+        openMsg->OpenId = newchannel->OfferMsg.ChildRelId; /* FIXME */
+        openMsg->ChildRelId = newchannel->OfferMsg.ChildRelId;
+        openMsg->RingBufferGpadlHandle = newchannel->RingBufferGpadlHandle;
+        openMsg->DownstreamRingBufferPageOffset = send_ringbuffer_size >>
                                                   PAGE_SHIFT;
         openMsg->ServerContextAreaGpadlHandle = 0; /* TODO */
 
-        if (UserDataLen > MAX_USER_DEFINED_BYTES) {
+        if (userdatalen > MAX_USER_DEFINED_BYTES) {
                 err = -EINVAL;
                 goto errorout;
         }
 
-        if (UserDataLen)
-                memcpy(openMsg->UserData, UserData, UserDataLen);
+        if (userdatalen)
+                memcpy(openMsg->UserData, userdata, userdatalen);
 
         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
         list_add_tail(&openInfo->MsgListEntry,
@@ -283,10 +283,10 @@ int VmbusChannelOpen(struct vmbus_channel *NewChannel, u32 SendRingBufferSize,
         osd_WaitEventWait(openInfo->WaitEvent);
 
         if (openInfo->Response.OpenResult.Status == 0)
-                DPRINT_INFO(VMBUS, "channel <%p> open success!!", NewChannel);
+                DPRINT_INFO(VMBUS, "channel <%p> open success!!", newchannel);
         else
                 DPRINT_INFO(VMBUS, "channel <%p> open failed - %d!!",
-                            NewChannel, openInfo->Response.OpenResult.Status);
+                            newchannel, openInfo->Response.OpenResult.Status);
 
 Cleanup:
         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
@@ -298,9 +298,9 @@ Cleanup:
         return 0;
 
 errorout:
-        RingBufferCleanup(&NewChannel->Outbound);
-        RingBufferCleanup(&NewChannel->Inbound);
-        osd_PageFree(out, (SendRingBufferSize + RecvRingBufferSize)
+        RingBufferCleanup(&newchannel->Outbound);
+        RingBufferCleanup(&newchannel->Inbound);
+        osd_PageFree(out, (send_ringbuffer_size + recv_ringbuffer_size)
                      >> PAGE_SHIFT);
         kfree(openInfo);
         return err;
@@ -310,289 +310,292 @@ errorout:
  * DumpGpadlBody - Dump the gpadl body message to the console for
  * debugging purposes.
  */
-static void DumpGpadlBody(struct vmbus_channel_gpadl_body *Gpadl, u32 Len)
+static void DumpGpadlBody(struct vmbus_channel_gpadl_body *gpadl, u32 len)
 {
         int i;
-        int pfnCount;
+        int pfncount;
 
-        pfnCount = (Len - sizeof(struct vmbus_channel_gpadl_body)) /
+        pfncount = (len - sizeof(struct vmbus_channel_gpadl_body)) /
                    sizeof(u64);
-        DPRINT_DBG(VMBUS, "gpadl body - len %d pfn count %d", Len, pfnCount);
+        DPRINT_DBG(VMBUS, "gpadl body - len %d pfn count %d", len, pfncount);
 
-        for (i = 0; i < pfnCount; i++)
+        for (i = 0; i < pfncount; i++)
                 DPRINT_DBG(VMBUS, "gpadl body  - %d) pfn %llu",
-                           i, Gpadl->Pfn[i]);
+                           i, gpadl->Pfn[i]);
 }
 
 /*
  * DumpGpadlHeader - Dump the gpadl header message to the console for
  * debugging purposes.
  */
-static void DumpGpadlHeader(struct vmbus_channel_gpadl_header *Gpadl)
+static void DumpGpadlHeader(struct vmbus_channel_gpadl_header *gpadl)
 {
         int i, j;
-        int pageCount;
+        int pagecount;
 
         DPRINT_DBG(VMBUS,
                    "gpadl header - relid %d, range count %d, range buflen %d",
-                   Gpadl->ChildRelId, Gpadl->RangeCount, Gpadl->RangeBufLen);
-        for (i = 0; i < Gpadl->RangeCount; i++) {
-                pageCount = Gpadl->Range[i].ByteCount >> PAGE_SHIFT;
-                pageCount = (pageCount > 26) ? 26 : pageCount;
+                   gpadl->ChildRelId, gpadl->RangeCount, gpadl->RangeBufLen);
+        for (i = 0; i < gpadl->RangeCount; i++) {
+                pagecount = gpadl->Range[i].ByteCount >> PAGE_SHIFT;
+                pagecount = (pagecount > 26) ? 26 : pagecount;
 
                 DPRINT_DBG(VMBUS, "gpadl range %d - len %d offset %d "
-                           "page count %d", i, Gpadl->Range[i].ByteCount,
-                           Gpadl->Range[i].ByteOffset, pageCount);
+                           "page count %d", i, gpadl->Range[i].ByteCount,
+                           gpadl->Range[i].ByteOffset, pagecount);
 
-                for (j = 0; j < pageCount; j++)
+                for (j = 0; j < pagecount; j++)
                         DPRINT_DBG(VMBUS, "%d) pfn %llu", j,
-                                   Gpadl->Range[i].PfnArray[j]);
+                                   gpadl->Range[i].PfnArray[j]);
         }
 }
 
 /*
  * VmbusChannelCreateGpadlHeader - Creates a gpadl for the specified buffer
  */
-static int VmbusChannelCreateGpadlHeader(void *Kbuffer, u32 Size,
-                                         struct vmbus_channel_msginfo **MsgInfo,
-                                         u32 *MessageCount)
+static int VmbusChannelCreateGpadlHeader(void *kbuffer, u32 size,
+                                         struct vmbus_channel_msginfo **msginfo,
+                                         u32 *messagecount)
 {
         int i;
-        int pageCount;
+        int pagecount;
         unsigned long long pfn;
-        struct vmbus_channel_gpadl_header *gpaHeader;
-        struct vmbus_channel_gpadl_body *gpadlBody;
-        struct vmbus_channel_msginfo *msgHeader;
-        struct vmbus_channel_msginfo *msgBody = NULL;
-        u32 msgSize;
+        struct vmbus_channel_gpadl_header *gpadl_header;
+        struct vmbus_channel_gpadl_body *gpadl_body;
+        struct vmbus_channel_msginfo *msgheader;
+        struct vmbus_channel_msginfo *msgbody = NULL;
+        u32 msgsize;
 
-        int pfnSum, pfnCount, pfnLeft, pfnCurr, pfnSize;
+        int pfnsum, pfncount, pfnleft, pfncurr, pfnsize;
 
         /* ASSERT((kbuffer & (PAGE_SIZE-1)) == 0); */
         /* ASSERT((Size & (PAGE_SIZE-1)) == 0); */
 
-        pageCount = Size >> PAGE_SHIFT;
-        pfn = virt_to_phys(Kbuffer) >> PAGE_SHIFT;
+        pagecount = size >> PAGE_SHIFT;
+        pfn = virt_to_phys(kbuffer) >> PAGE_SHIFT;
 
         /* do we need a gpadl body msg */
-        pfnSize = MAX_SIZE_CHANNEL_MESSAGE -
+        pfnsize = MAX_SIZE_CHANNEL_MESSAGE -
                   sizeof(struct vmbus_channel_gpadl_header) -
                   sizeof(struct gpa_range);
-        pfnCount = pfnSize / sizeof(u64);
+        pfncount = pfnsize / sizeof(u64);
 
-        if (pageCount > pfnCount) {
+        if (pagecount > pfncount) {
                 /* we need a gpadl body */
                 /* fill in the header */
-                msgSize = sizeof(struct vmbus_channel_msginfo) +
+                msgsize = sizeof(struct vmbus_channel_msginfo) +
                           sizeof(struct vmbus_channel_gpadl_header) +
-                          sizeof(struct gpa_range) + pfnCount * sizeof(u64);
-                msgHeader =  kzalloc(msgSize, GFP_KERNEL);
-                if (!msgHeader)
+                          sizeof(struct gpa_range) + pfncount * sizeof(u64);
+                msgheader =  kzalloc(msgsize, GFP_KERNEL);
+                if (!msgheader)
                         goto nomem;
 
-                INIT_LIST_HEAD(&msgHeader->SubMsgList);
-                msgHeader->MessageSize = msgSize;
+                INIT_LIST_HEAD(&msgheader->SubMsgList);
+                msgheader->MessageSize = msgsize;
 
-                gpaHeader = (struct vmbus_channel_gpadl_header *)msgHeader->Msg;
-                gpaHeader->RangeCount = 1;
-                gpaHeader->RangeBufLen = sizeof(struct gpa_range) +
-                                         pageCount * sizeof(u64);
-                gpaHeader->Range[0].ByteOffset = 0;
-                gpaHeader->Range[0].ByteCount = Size;
-                for (i = 0; i < pfnCount; i++)
-                        gpaHeader->Range[0].PfnArray[i] = pfn+i;
-                *MsgInfo = msgHeader;
-                *MessageCount = 1;
+                gpadl_header = (struct vmbus_channel_gpadl_header *)
+                        msgheader->Msg;
+                gpadl_header->RangeCount = 1;
+                gpadl_header->RangeBufLen = sizeof(struct gpa_range) +
+                                         pagecount * sizeof(u64);
+                gpadl_header->Range[0].ByteOffset = 0;
+                gpadl_header->Range[0].ByteCount = size;
+                for (i = 0; i < pfncount; i++)
+                        gpadl_header->Range[0].PfnArray[i] = pfn+i;
+                *msginfo = msgheader;
+                *messagecount = 1;
 
-                pfnSum = pfnCount;
-                pfnLeft = pageCount - pfnCount;
+                pfnsum = pfncount;
+                pfnleft = pagecount - pfncount;
 
                 /* how many pfns can we fit */
-                pfnSize = MAX_SIZE_CHANNEL_MESSAGE -
+                pfnsize = MAX_SIZE_CHANNEL_MESSAGE -
                           sizeof(struct vmbus_channel_gpadl_body);
-                pfnCount = pfnSize / sizeof(u64);
+                pfncount = pfnsize / sizeof(u64);
 
                 /* fill in the body */
-                while (pfnLeft) {
-                        if (pfnLeft > pfnCount)
-                                pfnCurr = pfnCount;
+                while (pfnleft) {
+                        if (pfnleft > pfncount)
+                                pfncurr = pfncount;
                         else
-                                pfnCurr = pfnLeft;
+                                pfncurr = pfnleft;
 
-                        msgSize = sizeof(struct vmbus_channel_msginfo) +
+                        msgsize = sizeof(struct vmbus_channel_msginfo) +
                                   sizeof(struct vmbus_channel_gpadl_body) +
-                                  pfnCurr * sizeof(u64);
-                        msgBody = kzalloc(msgSize, GFP_KERNEL);
+                                  pfncurr * sizeof(u64);
+                        msgbody = kzalloc(msgsize, GFP_KERNEL);
                         /* FIXME: we probably need to more if this fails */
-                        if (!msgBody)
+                        if (!msgbody)
                                 goto nomem;
-                        msgBody->MessageSize = msgSize;
-                        (*MessageCount)++;
-                        gpadlBody =
-                                (struct vmbus_channel_gpadl_body *)msgBody->Msg;
+                        msgbody->MessageSize = msgsize;
+                        (*messagecount)++;
+                        gpadl_body =
+                                (struct vmbus_channel_gpadl_body *)msgbody->Msg;
 
                         /*
                          * FIXME:
                          * Gpadl is u32 and we are using a pointer which could
                          * be 64-bit
                          */
-                        /* gpadlBody->Gpadl = kbuffer; */
-                        for (i = 0; i < pfnCurr; i++)
-                                gpadlBody->Pfn[i] = pfn + pfnSum + i;
+                        /* gpadl_body->Gpadl = kbuffer; */
+                        for (i = 0; i < pfncurr; i++)
+                                gpadl_body->Pfn[i] = pfn + pfnsum + i;
 
                         /* add to msg header */
-                        list_add_tail(&msgBody->MsgListEntry,
-                                      &msgHeader->SubMsgList);
-                        pfnSum += pfnCurr;
-                        pfnLeft -= pfnCurr;
+                        list_add_tail(&msgbody->MsgListEntry,
+                                      &msgheader->SubMsgList);
+                        pfnsum += pfncurr;
+                        pfnleft -= pfncurr;
                 }
         } else {
                 /* everything fits in a header */
-                msgSize = sizeof(struct vmbus_channel_msginfo) +
+                msgsize = sizeof(struct vmbus_channel_msginfo) +
                           sizeof(struct vmbus_channel_gpadl_header) +
-                          sizeof(struct gpa_range) + pageCount * sizeof(u64);
-                msgHeader = kzalloc(msgSize, GFP_KERNEL);
-                if (msgHeader == NULL)
+                          sizeof(struct gpa_range) + pagecount * sizeof(u64);
+                msgheader = kzalloc(msgsize, GFP_KERNEL);
+                if (msgheader == NULL)
                         goto nomem;
-                msgHeader->MessageSize = msgSize;
-
-                gpaHeader = (struct vmbus_channel_gpadl_header *)msgHeader->Msg;
-                gpaHeader->RangeCount = 1;
-                gpaHeader->RangeBufLen = sizeof(struct gpa_range) +
-                                         pageCount * sizeof(u64);
-                gpaHeader->Range[0].ByteOffset = 0;
-                gpaHeader->Range[0].ByteCount = Size;
-                for (i = 0; i < pageCount; i++)
-                        gpaHeader->Range[0].PfnArray[i] = pfn+i;
-
-                *MsgInfo = msgHeader;
-                *MessageCount = 1;
+                msgheader->MessageSize = msgsize;
+
+                gpadl_header = (struct vmbus_channel_gpadl_header *)
+                        msgheader->Msg;
+                gpadl_header->RangeCount = 1;
+                gpadl_header->RangeBufLen = sizeof(struct gpa_range) +
+                                         pagecount * sizeof(u64);
+                gpadl_header->Range[0].ByteOffset = 0;
+                gpadl_header->Range[0].ByteCount = size;
+                for (i = 0; i < pagecount; i++)
+                        gpadl_header->Range[0].PfnArray[i] = pfn+i;
+
+                *msginfo = msgheader;
+                *messagecount = 1;
         }
 
         return 0;
 nomem:
-        kfree(msgHeader);
-        kfree(msgBody);
+        kfree(msgheader);
+        kfree(msgbody);
         return -ENOMEM;
 }
 
 /*
  * VmbusChannelEstablishGpadl - Estabish a GPADL for the specified buffer
  *
- * @Channel: a channel
- * @Kbuffer: from kmalloc
- * @Size: page-size multiple
- * @GpadlHandle: some funky thing
+ * @channel: a channel
+ * @kbuffer: from kmalloc
+ * @size: page-size multiple
+ * @gpadl_handle: some funky thing
  */
-int VmbusChannelEstablishGpadl(struct vmbus_channel *Channel, void *Kbuffer,
-                               u32 Size, u32 *GpadlHandle)
+int VmbusChannelEstablishGpadl(struct vmbus_channel *channel, void *kbuffer,
+                               u32 size, u32 *gpadl_handle)
 {
-        struct vmbus_channel_gpadl_header *gpadlMsg;
-        struct vmbus_channel_gpadl_body *gpadlBody;
+        struct vmbus_channel_gpadl_header *gpadlmsg;
+        struct vmbus_channel_gpadl_body *gpadl_body;
         /* struct vmbus_channel_gpadl_created *gpadlCreated; */
-        struct vmbus_channel_msginfo *msgInfo = NULL;
-        struct vmbus_channel_msginfo *subMsgInfo;
-        u32 msgCount;
+        struct vmbus_channel_msginfo *msginfo = NULL;
+        struct vmbus_channel_msginfo *submsginfo;
+        u32 msgcount;
         struct list_head *curr;
-        u32 nextGpadlHandle;
+        u32 next_gpadl_handle;
         unsigned long flags;
         int ret = 0;
 
-        nextGpadlHandle = atomic_read(&gVmbusConnection.NextGpadlHandle);
+        next_gpadl_handle = atomic_read(&gVmbusConnection.NextGpadlHandle);
         atomic_inc(&gVmbusConnection.NextGpadlHandle);
 
-        ret = VmbusChannelCreateGpadlHeader(Kbuffer, Size, &msgInfo, &msgCount);
+        ret = VmbusChannelCreateGpadlHeader(kbuffer, size, &msginfo, &msgcount);
         if (ret)
                 return ret;
 
-        msgInfo->WaitEvent = osd_WaitEventCreate();
-        if (!msgInfo->WaitEvent) {
+        msginfo->WaitEvent = osd_WaitEventCreate();
+        if (!msginfo->WaitEvent) {
                 ret = -ENOMEM;
                 goto Cleanup;
         }
 
-        gpadlMsg = (struct vmbus_channel_gpadl_header *)msgInfo->Msg;
-        gpadlMsg->Header.MessageType = ChannelMessageGpadlHeader;
-        gpadlMsg->ChildRelId = Channel->OfferMsg.ChildRelId;
-        gpadlMsg->Gpadl = nextGpadlHandle;
+        gpadlmsg = (struct vmbus_channel_gpadl_header *)msginfo->Msg;
+        gpadlmsg->Header.MessageType = ChannelMessageGpadlHeader;
+        gpadlmsg->ChildRelId = channel->OfferMsg.ChildRelId;
+        gpadlmsg->Gpadl = next_gpadl_handle;
 
-        DumpGpadlHeader(gpadlMsg);
+        DumpGpadlHeader(gpadlmsg);
 
         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
-        list_add_tail(&msgInfo->MsgListEntry,
+        list_add_tail(&msginfo->MsgListEntry,
                       &gVmbusConnection.ChannelMsgList);
 
         spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);
         DPRINT_DBG(VMBUS, "buffer %p, size %d msg cnt %d",
-                   Kbuffer, Size, msgCount);
+                   kbuffer, size, msgcount);
 
         DPRINT_DBG(VMBUS, "Sending GPADL Header - len %zd",
-                   msgInfo->MessageSize - sizeof(*msgInfo));
+                   msginfo->MessageSize - sizeof(*msginfo));
 
-        ret = VmbusPostMessage(gpadlMsg, msgInfo->MessageSize -
-                               sizeof(*msgInfo));
+        ret = VmbusPostMessage(gpadlmsg, msginfo->MessageSize -
+                               sizeof(*msginfo));
         if (ret != 0) {
                 DPRINT_ERR(VMBUS, "Unable to open channel - %d", ret);
                 goto Cleanup;
         }
 
-        if (msgCount > 1) {
-                list_for_each(curr, &msgInfo->SubMsgList) {
+        if (msgcount > 1) {
+                list_for_each(curr, &msginfo->SubMsgList) {
 
                         /* FIXME: should this use list_entry() instead ? */
-                        subMsgInfo = (struct vmbus_channel_msginfo *)curr;
-                        gpadlBody =
-                             (struct vmbus_channel_gpadl_body *)subMsgInfo->Msg;
+                        submsginfo = (struct vmbus_channel_msginfo *)curr;
+                        gpadl_body =
+                             (struct vmbus_channel_gpadl_body *)submsginfo->Msg;
 
-                        gpadlBody->Header.MessageType = ChannelMessageGpadlBody;
-                        gpadlBody->Gpadl = nextGpadlHandle;
+                        gpadl_body->Header.MessageType =
+                                ChannelMessageGpadlBody;
+                        gpadl_body->Gpadl = next_gpadl_handle;
 
                         DPRINT_DBG(VMBUS, "Sending GPADL Body - len %zd",
-                                   subMsgInfo->MessageSize -
-                                   sizeof(*subMsgInfo));
-
-                        DumpGpadlBody(gpadlBody, subMsgInfo->MessageSize -
-                                      sizeof(*subMsgInfo));
-                        ret = VmbusPostMessage(gpadlBody,
-                                               subMsgInfo->MessageSize -
-                                               sizeof(*subMsgInfo));
+                                   submsginfo->MessageSize -
+                                   sizeof(*submsginfo));
+
+                        DumpGpadlBody(gpadl_body, submsginfo->MessageSize -
+                                      sizeof(*submsginfo));
+                        ret = VmbusPostMessage(gpadl_body,
+                                               submsginfo->MessageSize -
+                                               sizeof(*submsginfo));
                         if (ret != 0)
                                 goto Cleanup;
 
                 }
         }
-        osd_WaitEventWait(msgInfo->WaitEvent);
+        osd_WaitEventWait(msginfo->WaitEvent);
 
         /* At this point, we received the gpadl created msg */
         DPRINT_DBG(VMBUS, "Received GPADL created "
                    "(relid %d, status %d handle %x)",
-                   Channel->OfferMsg.ChildRelId,
-                   msgInfo->Response.GpadlCreated.CreationStatus,
-                   gpadlMsg->Gpadl);
+                   channel->OfferMsg.ChildRelId,
+                   msginfo->Response.GpadlCreated.CreationStatus,
+                   gpadlmsg->Gpadl);
 
-        *GpadlHandle = gpadlMsg->Gpadl;
+        *gpadl_handle = gpadlmsg->Gpadl;
 
 Cleanup:
         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
-        list_del(&msgInfo->MsgListEntry);
+        list_del(&msginfo->MsgListEntry);
         spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);
 
-        kfree(msgInfo->WaitEvent);
-        kfree(msgInfo);
+        kfree(msginfo->WaitEvent);
+        kfree(msginfo);
         return ret;
 }
 
 /*
  * VmbusChannelTeardownGpadl -Teardown the specified GPADL handle
  */
-int VmbusChannelTeardownGpadl(struct vmbus_channel *Channel, u32 GpadlHandle)
+int VmbusChannelTeardownGpadl(struct vmbus_channel *channel, u32 gpadl_handle)
 {
         struct vmbus_channel_gpadl_teardown *msg;
         struct vmbus_channel_msginfo *info;
         unsigned long flags;
         int ret;
 
-        /* ASSERT(GpadlHandle != 0); */
+        /* ASSERT(gpadl_handle != 0); */
 
         info = kmalloc(sizeof(*info) +
                        sizeof(struct vmbus_channel_gpadl_teardown), GFP_KERNEL);
@@ -608,8 +611,8 @@ int VmbusChannelTeardownGpadl(struct vmbus_channel *Channel, u32 GpadlHandle)
         msg = (struct vmbus_channel_gpadl_teardown *)info->Msg;
 
         msg->Header.MessageType = ChannelMessageGpadlTeardown;
-        msg->ChildRelId = Channel->OfferMsg.ChildRelId;
-        msg->Gpadl = GpadlHandle;
+        msg->ChildRelId = channel->OfferMsg.ChildRelId;
+        msg->Gpadl = gpadl_handle;
 
         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
         list_add_tail(&info->MsgListEntry,
@@ -638,7 +641,7 @@ int VmbusChannelTeardownGpadl(struct vmbus_channel *Channel, u32 GpadlHandle)
 /*
  * VmbusChannelClose - Close the specified channel
  */
-void VmbusChannelClose(struct vmbus_channel *Channel)
+void VmbusChannelClose(struct vmbus_channel *channel)
 {
         struct vmbus_channel_close_channel *msg;
         struct vmbus_channel_msginfo *info;
@@ -646,8 +649,8 @@ void VmbusChannelClose(struct vmbus_channel *Channel)
         int ret;
 
         /* Stop callback and cancel the timer asap */
-        Channel->OnChannelCallback = NULL;
-        del_timer_sync(&Channel->poll_timer);
+        channel->OnChannelCallback = NULL;
+        del_timer_sync(&channel->poll_timer);
 
         /* Send a closing message */
         info = kmalloc(sizeof(*info) +
@@ -661,7 +664,7 @@ void VmbusChannelClose(struct vmbus_channel *Channel)
 
         msg = (struct vmbus_channel_close_channel *)info->Msg;
         msg->Header.MessageType = ChannelMessageCloseChannel;
-        msg->ChildRelId = Channel->OfferMsg.ChildRelId;
+        msg->ChildRelId = channel->OfferMsg.ChildRelId;
 
         ret = VmbusPostMessage(msg, sizeof(struct vmbus_channel_close_channel));
         if (ret != 0) {
@@ -670,17 +673,17 @@ void VmbusChannelClose(struct vmbus_channel *Channel)
         }
 
         /* Tear down the gpadl for the channel's ring buffer */
-        if (Channel->RingBufferGpadlHandle)
-                VmbusChannelTeardownGpadl(Channel,
-                                          Channel->RingBufferGpadlHandle);
+        if (channel->RingBufferGpadlHandle)
+                VmbusChannelTeardownGpadl(channel,
+                                          channel->RingBufferGpadlHandle);
 
         /* TODO: Send a msg to release the childRelId */
 
         /* Cleanup the ring buffers for this channel */
-        RingBufferCleanup(&Channel->Outbound);
-        RingBufferCleanup(&Channel->Inbound);
+        RingBufferCleanup(&channel->Outbound);
+        RingBufferCleanup(&channel->Inbound);
 
-        osd_PageFree(Channel->RingBufferPages, Channel->RingBufferPageCount);
+        osd_PageFree(channel->RingBufferPages, channel->RingBufferPageCount);
 
         kfree(info);
 
@@ -690,65 +693,66 @@ void VmbusChannelClose(struct vmbus_channel *Channel)
          * caller will free the channel
          */
 
-        if (Channel->State == CHANNEL_OPEN_STATE) {
+        if (channel->State == CHANNEL_OPEN_STATE) {
                 spin_lock_irqsave(&gVmbusConnection.channel_lock, flags);
-                list_del(&Channel->ListEntry);
+                list_del(&channel->ListEntry);
                 spin_unlock_irqrestore(&gVmbusConnection.channel_lock, flags);
 
-                FreeVmbusChannel(Channel);
+                FreeVmbusChannel(channel);
         }
 }
 
 /**
  * VmbusChannelSendPacket() - Send the specified buffer on the given channel
- * @Channel: Pointer to vmbus_channel structure.
- * @Buffer: Pointer to the buffer you want to receive the data into.
- * @BufferLen: Maximum size of what the the buffer will hold
- * @RequestId: Identifier of the request
- * @vmbus_packet_type: Type of packet that is being send e.g. negotiate, time
+ * @channel: Pointer to vmbus_channel structure.
+ * @buffer: Pointer to the buffer you want to receive the data into.
+ * @bufferlen: Maximum size of what the the buffer will hold
+ * @requestid: Identifier of the request
+ * @type: Type of packet that is being send e.g. negotiate, time
  * packet etc.
  *
- * Sends data in @Buffer directly to hyper-v via the vmbus
+ * Sends data in @buffer directly to hyper-v via the vmbus
  * This will send the data unparsed to hyper-v.
  *
  * Mainly used by Hyper-V drivers.
  */
-int VmbusChannelSendPacket(struct vmbus_channel *Channel, const void *Buffer,
-                           u32 BufferLen, u64 RequestId,
-                           enum vmbus_packet_type Type, u32 Flags)
+int VmbusChannelSendPacket(struct vmbus_channel *channel, const void *buffer,
+                           u32 bufferlen, u64 requestid,
+                           enum vmbus_packet_type type, u32 flags)
 {
         struct vmpacket_descriptor desc;
-        u32 packetLen = sizeof(struct vmpacket_descriptor) + BufferLen;
-        u32 packetLenAligned = ALIGN_UP(packetLen, sizeof(u64));
-        struct scatterlist bufferList[3];
-        u64 alignedData = 0;
+        u32 packetlen = sizeof(struct vmpacket_descriptor) + bufferlen;
+        u32 packetlen_aligned = ALIGN_UP(packetlen, sizeof(u64));
+        struct scatterlist bufferlist[3];
+        u64 aligned_data = 0;
         int ret;
 
         DPRINT_DBG(VMBUS, "channel %p buffer %p len %d",
-                   Channel, Buffer, BufferLen);
+                   channel, buffer, bufferlen);
 
-        DumpVmbusChannel(Channel);
+        DumpVmbusChannel(channel);
 
         /* ASSERT((packetLenAligned - packetLen) < sizeof(u64)); */
 
         /* Setup the descriptor */
-        desc.Type = Type; /* VmbusPacketTypeDataInBand; */
-        desc.Flags = Flags; /* VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED; */
+        desc.Type = type; /* VmbusPacketTypeDataInBand; */
+        desc.Flags = flags; /* VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED; */
         /* in 8-bytes granularity */
         desc.DataOffset8 = sizeof(struct vmpacket_descriptor) >> 3;
-        desc.Length8 = (u16)(packetLenAligned >> 3);
-        desc.TransactionId = RequestId;
+        desc.Length8 = (u16)(packetlen_aligned >> 3);
+        desc.TransactionId = requestid;
 
-        sg_init_table(bufferList, 3);
-        sg_set_buf(&bufferList[0], &desc, sizeof(struct vmpacket_descriptor));
-        sg_set_buf(&bufferList[1], Buffer, BufferLen);
-        sg_set_buf(&bufferList[2], &alignedData, packetLenAligned - packetLen);
+        sg_init_table(bufferlist, 3);
+        sg_set_buf(&bufferlist[0], &desc, sizeof(struct vmpacket_descriptor));
+        sg_set_buf(&bufferlist[1], buffer, bufferlen);
+        sg_set_buf(&bufferlist[2], &aligned_data,
+                   packetlen_aligned - packetlen);
 
-        ret = RingBufferWrite(&Channel->Outbound, bufferList, 3);
+        ret = RingBufferWrite(&channel->Outbound, bufferlist, 3);
 
         /* TODO: We should determine if this is optional */
-        if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
-                VmbusChannelSetEvent(Channel);
+        if (ret == 0 && !GetRingBufferInterruptMask(&channel->Outbound))
+                VmbusChannelSetEvent(channel);
 
         return ret;
 }
@@ -758,61 +762,62 @@ EXPORT_SYMBOL(VmbusChannelSendPacket);
  * VmbusChannelSendPacketPageBuffer - Send a range of single-page buffer
  * packets using a GPADL Direct packet type.
  */
-int VmbusChannelSendPacketPageBuffer(struct vmbus_channel *Channel,
-                                     struct hv_page_buffer PageBuffers[],
-                                     u32 PageCount, void *Buffer, u32 BufferLen,
-                                     u64 RequestId)
+int VmbusChannelSendPacketPageBuffer(struct vmbus_channel *channel,
+                                     struct hv_page_buffer pagebuffers[],
+                                     u32 pagecount, void *buffer, u32 bufferlen,
+                                     u64 requestid)
 {
         int ret;
         int i;
         struct vmbus_channel_packet_page_buffer desc;
-        u32 descSize;
-        u32 packetLen;
-        u32 packetLenAligned;
-        struct scatterlist bufferList[3];
-        u64 alignedData = 0;
+        u32 descsize;
+        u32 packetlen;
+        u32 packetlen_aligned;
+        struct scatterlist bufferlist[3];
+        u64 aligned_data = 0;
 
-        if (PageCount > MAX_PAGE_BUFFER_COUNT)
+        if (pagecount > MAX_PAGE_BUFFER_COUNT)
                 return -EINVAL;
 
-        DumpVmbusChannel(Channel);
+        DumpVmbusChannel(channel);
 
         /*
          * Adjust the size down since vmbus_channel_packet_page_buffer is the
          * largest size we support
          */
-        descSize = sizeof(struct vmbus_channel_packet_page_buffer) -
-                          ((MAX_PAGE_BUFFER_COUNT - PageCount) *
+        descsize = sizeof(struct vmbus_channel_packet_page_buffer) -
+                          ((MAX_PAGE_BUFFER_COUNT - pagecount) *
                           sizeof(struct hv_page_buffer));
-        packetLen = descSize + BufferLen;
-        packetLenAligned = ALIGN_UP(packetLen, sizeof(u64));
+        packetlen = descsize + bufferlen;
+        packetlen_aligned = ALIGN_UP(packetlen, sizeof(u64));
 
         /* ASSERT((packetLenAligned - packetLen) < sizeof(u64)); */
 
         /* Setup the descriptor */
         desc.type = VmbusPacketTypeDataUsingGpaDirect;
         desc.flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
-        desc.dataoffset8 = descSize >> 3; /* in 8-bytes grandularity */
-        desc.length8 = (u16)(packetLenAligned >> 3);
-        desc.transactionid = RequestId;
-        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.dataoffset8 = descsize >> 3; /* in 8-bytes grandularity */
+        desc.length8 = (u16)(packetlen_aligned >> 3);
+        desc.transactionid = requestid;
+        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;
         }
 
-        sg_init_table(bufferList, 3);
-        sg_set_buf(&bufferList[0], &desc, descSize);
-        sg_set_buf(&bufferList[1], Buffer, BufferLen);
-        sg_set_buf(&bufferList[2], &alignedData, packetLenAligned - packetLen);
+        sg_init_table(bufferlist, 3);
+        sg_set_buf(&bufferlist[0], &desc, descsize);
+        sg_set_buf(&bufferlist[1], buffer, bufferlen);
+        sg_set_buf(&bufferlist[2], &aligned_data,
+                packetlen_aligned - packetlen);
 
-        ret = RingBufferWrite(&Channel->Outbound, bufferList, 3);
+        ret = RingBufferWrite(&channel->Outbound, bufferlist, 3);
 
         /* TODO: We should determine if this is optional */
-        if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
-                VmbusChannelSetEvent(Channel);
+        if (ret == 0 && !GetRingBufferInterruptMask(&channel->Outbound))
+                VmbusChannelSetEvent(channel);
 
         return ret;
 }
@@ -821,64 +826,66 @@ int VmbusChannelSendPacketPageBuffer(struct vmbus_channel *Channel,
  * VmbusChannelSendPacketMultiPageBuffer - Send a multi-page buffer packet
  * using a GPADL Direct packet type.
  */
-int VmbusChannelSendPacketMultiPageBuffer(struct vmbus_channel *Channel,
-                                struct hv_multipage_buffer *MultiPageBuffer,
-                                void *Buffer, u32 BufferLen, u64 RequestId)
+int VmbusChannelSendPacketMultiPageBuffer(struct vmbus_channel *channel,
+                                struct hv_multipage_buffer *multi_pagebuffer,
+                                void *buffer, u32 bufferlen, u64 requestid)
 {
         int ret;
         struct vmbus_channel_packet_multipage_buffer desc;
-        u32 descSize;
-        u32 packetLen;
-        u32 packetLenAligned;
-        struct scatterlist bufferList[3];
-        u64 alignedData = 0;
-        u32 PfnCount = NUM_PAGES_SPANNED(MultiPageBuffer->Offset,
-                                         MultiPageBuffer->Length);
+        u32 descsize;
+        u32 packetlen;
+        u32 packetlen_aligned;
+        struct scatterlist bufferlist[3];
+        u64 aligned_data = 0;
+        u32 pfncount = NUM_PAGES_SPANNED(multi_pagebuffer->Offset,
+                                         multi_pagebuffer->Length);
 
-        DumpVmbusChannel(Channel);
+        DumpVmbusChannel(channel);
 
         DPRINT_DBG(VMBUS, "data buffer - offset %u len %u pfn count %u",
-                   MultiPageBuffer->Offset, MultiPageBuffer->Length, PfnCount);
+                multi_pagebuffer->Offset,
+                multi_pagebuffer->Length, pfncount);
 
-        if ((PfnCount < 0) || (PfnCount > MAX_MULTIPAGE_BUFFER_COUNT))
+        if ((pfncount < 0) || (pfncount > MAX_MULTIPAGE_BUFFER_COUNT))
                 return -EINVAL;
 
         /*
          * Adjust the size down since vmbus_channel_packet_multipage_buffer is
          * the largest size we support
          */
-        descSize = sizeof(struct vmbus_channel_packet_multipage_buffer) -
-                          ((MAX_MULTIPAGE_BUFFER_COUNT - PfnCount) *
+        descsize = sizeof(struct vmbus_channel_packet_multipage_buffer) -
+                          ((MAX_MULTIPAGE_BUFFER_COUNT - pfncount) *
                           sizeof(u64));
-        packetLen = descSize + BufferLen;
-        packetLenAligned = ALIGN_UP(packetLen, sizeof(u64));
+        packetlen = descsize + bufferlen;
+        packetlen_aligned = ALIGN_UP(packetlen, sizeof(u64));
 
         /* ASSERT((packetLenAligned - packetLen) < sizeof(u64)); */
 
         /* Setup the descriptor */
         desc.type = VmbusPacketTypeDataUsingGpaDirect;
         desc.flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
-        desc.dataoffset8 = descSize >> 3; /* in 8-bytes grandularity */
-        desc.length8 = (u16)(packetLenAligned >> 3);
-        desc.transactionid = RequestId;
+        desc.dataoffset8 = descsize >> 3; /* in 8-bytes grandularity */
+        desc.length8 = (u16)(packetlen_aligned >> 3);
+        desc.transactionid = requestid;
         desc.rangecount = 1;
 
-        desc.range.Length = MultiPageBuffer->Length;
-        desc.range.Offset = MultiPageBuffer->Offset;
+        desc.range.Length = multi_pagebuffer->Length;
+        desc.range.Offset = multi_pagebuffer->Offset;
 
-        memcpy(desc.range.PfnArray, MultiPageBuffer->PfnArray,
-               PfnCount * sizeof(u64));
+        memcpy(desc.range.PfnArray, multi_pagebuffer->PfnArray,
+               pfncount * sizeof(u64));
 
-        sg_init_table(bufferList, 3);
-        sg_set_buf(&bufferList[0], &desc, descSize);
-        sg_set_buf(&bufferList[1], Buffer, BufferLen);
-        sg_set_buf(&bufferList[2], &alignedData, packetLenAligned - packetLen);
+        sg_init_table(bufferlist, 3);
+        sg_set_buf(&bufferlist[0], &desc, descsize);
+        sg_set_buf(&bufferlist[1], buffer, bufferlen);
+        sg_set_buf(&bufferlist[2], &aligned_data,
+                packetlen_aligned - packetlen);
 
-        ret = RingBufferWrite(&Channel->Outbound, bufferList, 3);
+        ret = RingBufferWrite(&channel->Outbound, bufferlist, 3);
 
         /* TODO: We should determine if this is optional */
-        if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
-                VmbusChannelSetEvent(Channel);
+        if (ret == 0 && !GetRingBufferInterruptMask(&channel->Outbound))
+                VmbusChannelSetEvent(channel);
 
         return ret;
 }
@@ -886,35 +893,35 @@ int VmbusChannelSendPacketMultiPageBuffer(struct vmbus_channel *Channel,
 
 /**
  * VmbusChannelRecvPacket() - Retrieve the user packet on the specified channel
- * @Channel: Pointer to vmbus_channel structure.
- * @Buffer: Pointer to the buffer you want to receive the data into.
- * @BufferLen: Maximum size of what the the buffer will hold
- * @BufferActualLen: The actual size of the data after it was received
- * @RequestId: Identifier of the request
+ * @channel: Pointer to vmbus_channel structure.
+ * @buffer: Pointer to the buffer you want to receive the data into.
+ * @bufferlen: Maximum size of what the the buffer will hold
+ * @buffer_actual_len: The actual size of the data after it was received
+ * @requestid: Identifier of the request
  *
  * Receives directly from the hyper-v vmbus and puts the data it received
  * into Buffer. This will receive the data unparsed from hyper-v.
  *
  * Mainly used by Hyper-V drivers.
  */
-int VmbusChannelRecvPacket(struct vmbus_channel *Channel, void *Buffer,
-                           u32 BufferLen, u32 *BufferActualLen, u64 *RequestId)
+int VmbusChannelRecvPacket(struct vmbus_channel *channel, void *buffer,
+                        u32 bufferlen, u32 *buffer_actual_len, u64 *requestid)
 {
         struct vmpacket_descriptor desc;
-        u32 packetLen;
-        u32 userLen;
+        u32 packetlen;
+        u32 userlen;
         int ret;
         unsigned long flags;
 
-        *BufferActualLen = 0;
-        *RequestId = 0;
+        *buffer_actual_len = 0;
+        *requestid = 0;
 
-        spin_lock_irqsave(&Channel->inbound_lock, flags);
+        spin_lock_irqsave(&channel->inbound_lock, flags);
 
-        ret = RingBufferPeek(&Channel->Inbound, &desc,
+        ret = RingBufferPeek(&channel->Inbound, &desc,
                              sizeof(struct vmpacket_descriptor));
         if (ret != 0) {
-                spin_unlock_irqrestore(&Channel->inbound_lock, flags);
+                spin_unlock_irqrestore(&channel->inbound_lock, flags);
 
                 /* DPRINT_DBG(VMBUS, "nothing to read!!"); */
                 return 0;
@@ -922,32 +929,32 @@ int VmbusChannelRecvPacket(struct vmbus_channel *Channel, void *Buffer,
 
         /* VmbusChannelClearEvent(Channel); */
 
-        packetLen = desc.Length8 << 3;
-        userLen = packetLen - (desc.DataOffset8 << 3);
+        packetlen = desc.Length8 << 3;
+        userlen = packetlen - (desc.DataOffset8 << 3);
         /* ASSERT(userLen > 0); */
 
         DPRINT_DBG(VMBUS, "packet received on channel %p relid %d <type %d "
                    "flag %d tid %llx pktlen %d datalen %d> ",
-                   Channel, Channel->OfferMsg.ChildRelId, desc.Type,
-                   desc.Flags, desc.TransactionId, packetLen, userLen);
+                   channel, channel->OfferMsg.ChildRelId, desc.Type,
+                   desc.Flags, desc.TransactionId, packetlen, userlen);
 
-        *BufferActualLen = userLen;
+        *buffer_actual_len = userlen;
 
-        if (userLen > BufferLen) {
-                spin_unlock_irqrestore(&Channel->inbound_lock, flags);
+        if (userlen > bufferlen) {
+                spin_unlock_irqrestore(&channel->inbound_lock, flags);
 
                 DPRINT_ERR(VMBUS, "buffer too small - got %d needs %d",
-                           BufferLen, userLen);
+                           bufferlen, userlen);
                 return -1;
         }
 
-        *RequestId = desc.TransactionId;
+        *requestid = desc.TransactionId;
 
         /* Copy over the packet to the user buffer */
-        ret = RingBufferRead(&Channel->Inbound, Buffer, userLen,
+        ret = RingBufferRead(&channel->Inbound, buffer, userlen,
                              (desc.DataOffset8 << 3));
 
-        spin_unlock_irqrestore(&Channel->inbound_lock, flags);
+        spin_unlock_irqrestore(&channel->inbound_lock, flags);
 
         return 0;
 }
@@ -956,25 +963,25 @@ EXPORT_SYMBOL(VmbusChannelRecvPacket);
 /*
  * VmbusChannelRecvPacketRaw - Retrieve the raw packet on the specified channel
  */
-int VmbusChannelRecvPacketRaw(struct vmbus_channel *Channel, void *Buffer,
-                              u32 BufferLen, u32 *BufferActualLen,
-                              u64 *RequestId)
+int VmbusChannelRecvPacketRaw(struct vmbus_channel *channel, void *buffer,
+                              u32 bufferlen, u32 *buffer_actual_len,
+                              u64 *requestid)
 {
         struct vmpacket_descriptor desc;
-        u32 packetLen;
-        u32 userLen;
+        u32 packetlen;
+        u32 userlen;
         int ret;
         unsigned long flags;
 
-        *BufferActualLen = 0;
-        *RequestId = 0;
+        *buffer_actual_len = 0;
+        *requestid = 0;
 
-        spin_lock_irqsave(&Channel->inbound_lock, flags);
+        spin_lock_irqsave(&channel->inbound_lock, flags);
 
-        ret = RingBufferPeek(&Channel->Inbound, &desc,
+        ret = RingBufferPeek(&channel->Inbound, &desc,
                              sizeof(struct vmpacket_descriptor));
         if (ret != 0) {
-                spin_unlock_irqrestore(&Channel->inbound_lock, flags);
+                spin_unlock_irqrestore(&channel->inbound_lock, flags);
 
                 /* DPRINT_DBG(VMBUS, "nothing to read!!"); */
                 return 0;
@@ -982,44 +989,44 @@ int VmbusChannelRecvPacketRaw(struct vmbus_channel *Channel, void *Buffer,
 
         /* VmbusChannelClearEvent(Channel); */
 
-        packetLen = desc.Length8 << 3;
-        userLen = packetLen - (desc.DataOffset8 << 3);
+        packetlen = desc.Length8 << 3;
+        userlen = packetlen - (desc.DataOffset8 << 3);
 
         DPRINT_DBG(VMBUS, "packet received on channel %p relid %d <type %d "
                    "flag %d tid %llx pktlen %d datalen %d> ",
-                   Channel, Channel->OfferMsg.ChildRelId, desc.Type,
-                   desc.Flags, desc.TransactionId, packetLen, userLen);
+                   channel, channel->OfferMsg.ChildRelId, desc.Type,
+                   desc.Flags, desc.TransactionId, packetlen, userlen);
 
-        *BufferActualLen = packetLen;
+        *buffer_actual_len = packetlen;
 
-        if (packetLen > BufferLen) {
-                spin_unlock_irqrestore(&Channel->inbound_lock, flags);
+        if (packetlen > bufferlen) {
+                spin_unlock_irqrestore(&channel->inbound_lock, flags);
 
                 DPRINT_ERR(VMBUS, "buffer too small - needed %d bytes but "
-                           "got space for only %d bytes", packetLen, BufferLen);
+                           "got space for only %d bytes", packetlen, bufferlen);
                 return -2;
         }
 
-        *RequestId = desc.TransactionId;
+        *requestid = desc.TransactionId;
 
         /* Copy over the entire packet to the user buffer */
-        ret = RingBufferRead(&Channel->Inbound, Buffer, packetLen, 0);
+        ret = RingBufferRead(&channel->Inbound, buffer, packetlen, 0);
 
-        spin_unlock_irqrestore(&Channel->inbound_lock, flags);
+        spin_unlock_irqrestore(&channel->inbound_lock, flags);
         return 0;
 }
 
 /*
  * VmbusChannelOnChannelEvent - Channel event callback
  */
-void VmbusChannelOnChannelEvent(struct vmbus_channel *Channel)
+void VmbusChannelOnChannelEvent(struct vmbus_channel *channel)
 {
-        DumpVmbusChannel(Channel);
+        DumpVmbusChannel(channel);
         /* ASSERT(Channel->OnChannelCallback); */
 
-        Channel->OnChannelCallback(Channel->ChannelCallbackContext);
+        channel->OnChannelCallback(channel->ChannelCallbackContext);
 
-        mod_timer(&Channel->poll_timer, jiffies + usecs_to_jiffies(100));
+        mod_timer(&channel->poll_timer, jiffies + usecs_to_jiffies(100));
 }
 
 /*
@@ -1036,9 +1043,9 @@ void VmbusChannelOnTimer(unsigned long data)
 /*
  * DumpVmbusChannel - Dump vmbus channel info to the console
  */
-static void DumpVmbusChannel(struct vmbus_channel *Channel)
+static void DumpVmbusChannel(struct vmbus_channel *channel)
 {
-        DPRINT_DBG(VMBUS, "Channel (%d)", Channel->OfferMsg.ChildRelId);
-        DumpRingInfo(&Channel->Outbound, "Outbound ");
-        DumpRingInfo(&Channel->Inbound, "Inbound ");
+        DPRINT_DBG(VMBUS, "Channel (%d)", channel->OfferMsg.ChildRelId);
+        DumpRingInfo(&channel->Outbound, "Outbound ");
+        DumpRingInfo(&channel->Inbound, "Inbound ");
 }