From 53d21fdbf4d38dcfe27173d746acf74ea1a19958 Mon Sep 17 00:00:00 2001 From: Haiyang Zhang Date: Fri, 10 Dec 2010 12:03:59 -0800 Subject: [PATCH] staging: hv: Convert camel cased struct fields in netvsc.h to lower cases Signed-off-by: Haiyang Zhang Signed-off-by: Hank Janssen Signed-off-by: Greg Kroah-Hartman --- drivers/staging/hv/netvsc.c | 340 +++++++++++++++--------------- drivers/staging/hv/netvsc.h | 164 +++++++------- drivers/staging/hv/netvsc_api.h | 2 +- drivers/staging/hv/rndis_filter.c | 22 +- 4 files changed, 265 insertions(+), 263 deletions(-) diff --git a/drivers/staging/hv/netvsc.c b/drivers/staging/hv/netvsc.c index d678bf5329ef..df9cd131e953 100644 --- a/drivers/staging/hv/netvsc.c +++ b/drivers/staging/hv/netvsc.c @@ -83,9 +83,9 @@ static struct netvsc_device *alloc_net_device(struct hv_device *device) return NULL; /* Set to 2 to allow both inbound and outbound traffic */ - atomic_cmpxchg(&net_device->RefCount, 0, 2); + atomic_cmpxchg(&net_device->refcnt, 0, 2); - net_device->Device = device; + net_device->dev = device; device->Extension = net_device; return net_device; @@ -93,8 +93,8 @@ static struct netvsc_device *alloc_net_device(struct hv_device *device) static void free_net_device(struct netvsc_device *device) { - WARN_ON(atomic_read(&device->RefCount) == 0); - device->Device->Extension = NULL; + WARN_ON(atomic_read(&device->refcnt) == 0); + device->dev->Extension = NULL; kfree(device); } @@ -105,8 +105,8 @@ static struct netvsc_device *get_outbound_net_device(struct hv_device *device) struct netvsc_device *net_device; net_device = device->Extension; - if (net_device && atomic_read(&net_device->RefCount) > 1) - atomic_inc(&net_device->RefCount); + if (net_device && atomic_read(&net_device->refcnt) > 1) + atomic_inc(&net_device->refcnt); else net_device = NULL; @@ -119,8 +119,8 @@ static struct netvsc_device *get_inbound_net_device(struct hv_device *device) struct netvsc_device *net_device; net_device = device->Extension; - if (net_device && atomic_read(&net_device->RefCount)) - atomic_inc(&net_device->RefCount); + if (net_device && atomic_read(&net_device->refcnt)) + atomic_inc(&net_device->refcnt); else net_device = NULL; @@ -134,7 +134,7 @@ static void put_net_device(struct hv_device *device) net_device = device->Extension; /* ASSERT(netDevice); */ - atomic_dec(&net_device->RefCount); + atomic_dec(&net_device->refcnt); } static struct netvsc_device *release_outbound_net_device( @@ -147,7 +147,7 @@ static struct netvsc_device *release_outbound_net_device( return NULL; /* Busy wait until the ref drop to 2, then set it to 1 */ - while (atomic_cmpxchg(&net_device->RefCount, 2, 1) != 2) + while (atomic_cmpxchg(&net_device->refcnt, 2, 1) != 2) udelay(100); return net_device; @@ -163,7 +163,7 @@ static struct netvsc_device *release_inbound_net_device( return NULL; /* Busy wait until the ref drop to 1, then set it to 0 */ - while (atomic_cmpxchg(&net_device->RefCount, 1, 0) != 1) + while (atomic_cmpxchg(&net_device->refcnt, 1, 0) != 1) udelay(100); device->Extension = NULL; @@ -222,12 +222,12 @@ static int netvsc_init_recv_buf(struct hv_device *device) /* page-size grandularity */ /* ASSERT((netDevice->ReceiveBufferSize & (PAGE_SIZE - 1)) == 0); */ - net_device->ReceiveBuffer = - osd_page_alloc(net_device->ReceiveBufferSize >> PAGE_SHIFT); - if (!net_device->ReceiveBuffer) { + net_device->recv_buf = + osd_page_alloc(net_device->recv_buf_size >> PAGE_SHIFT); + if (!net_device->recv_buf) { DPRINT_ERR(NETVSC, "unable to allocate receive buffer of size %d", - net_device->ReceiveBufferSize); + net_device->recv_buf_size); ret = -1; goto Cleanup; } @@ -242,9 +242,9 @@ static int netvsc_init_recv_buf(struct hv_device *device) * channel. Note: This call uses the vmbus connection rather * than the channel to establish the gpadl handle. */ - ret = vmbus_establish_gpadl(device->channel, net_device->ReceiveBuffer, - net_device->ReceiveBufferSize, - &net_device->ReceiveBufferGpadlHandle); + ret = vmbus_establish_gpadl(device->channel, net_device->recv_buf, + net_device->recv_buf_size, + &net_device->recv_buf_gpadl_handle); if (ret != 0) { DPRINT_ERR(NETVSC, "unable to establish receive buffer's gpadl"); @@ -256,15 +256,15 @@ static int netvsc_init_recv_buf(struct hv_device *device) /* Notify the NetVsp of the gpadl handle */ DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendReceiveBuffer..."); - init_packet = &net_device->ChannelInitPacket; + init_packet = &net_device->channel_init_pkt; memset(init_packet, 0, sizeof(struct nvsp_message)); - init_packet->Header.MessageType = NvspMessage1TypeSendReceiveBuffer; - init_packet->Messages.Version1Messages.SendReceiveBuffer. - GpadlHandle = net_device->ReceiveBufferGpadlHandle; - init_packet->Messages.Version1Messages. - SendReceiveBuffer.Id = NETVSC_RECEIVE_BUFFER_ID; + init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_RECV_BUF; + init_packet->msg.v1_msg.send_recv_buf. + gpadl_handle = net_device->recv_buf_gpadl_handle; + init_packet->msg.v1_msg. + send_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID; /* Send the gpadl notification request */ ret = vmbus_sendpacket(device->channel, init_packet, @@ -278,15 +278,15 @@ static int netvsc_init_recv_buf(struct hv_device *device) goto Cleanup; } - osd_waitevent_wait(net_device->ChannelInitEvent); + osd_waitevent_wait(net_device->channel_init_event); /* Check the response */ - if (init_packet->Messages.Version1Messages. - SendReceiveBufferComplete.Status != NvspStatusSuccess) { + if (init_packet->msg.v1_msg. + send_recv_buf_complete.status != NVSP_STAT_SUCCESS) { DPRINT_ERR(NETVSC, "Unable to complete receive buffer " "initialzation with NetVsp - status %d", - init_packet->Messages.Version1Messages. - SendReceiveBufferComplete.Status); + init_packet->msg.v1_msg. + send_recv_buf_complete.status); ret = -1; goto Cleanup; } @@ -295,36 +295,36 @@ static int netvsc_init_recv_buf(struct hv_device *device) /* ASSERT(netDevice->ReceiveSectionCount == 0); */ /* ASSERT(netDevice->ReceiveSections == NULL); */ - net_device->ReceiveSectionCount = init_packet->Messages. - Version1Messages.SendReceiveBufferComplete.NumSections; + net_device->recv_section_cnt = init_packet->msg. + v1_msg.send_recv_buf_complete.num_sections; - net_device->ReceiveSections = kmalloc(net_device->ReceiveSectionCount + net_device->recv_section = kmalloc(net_device->recv_section_cnt * sizeof(struct nvsp_1_receive_buffer_section), GFP_KERNEL); - if (net_device->ReceiveSections == NULL) { + if (net_device->recv_section == NULL) { ret = -1; goto Cleanup; } - memcpy(net_device->ReceiveSections, - init_packet->Messages.Version1Messages. - SendReceiveBufferComplete.Sections, - net_device->ReceiveSectionCount * + memcpy(net_device->recv_section, + init_packet->msg.v1_msg. + send_recv_buf_complete.sections, + net_device->recv_section_cnt * sizeof(struct nvsp_1_receive_buffer_section)); DPRINT_INFO(NETVSC, "Receive sections info (count %d, offset %d, " "endoffset %d, suballoc size %d, num suballocs %d)", - net_device->ReceiveSectionCount, - net_device->ReceiveSections[0].Offset, - net_device->ReceiveSections[0].EndOffset, - net_device->ReceiveSections[0].SubAllocationSize, - net_device->ReceiveSections[0].NumSubAllocations); + net_device->recv_section_cnt, + net_device->recv_section[0].offset, + net_device->recv_section[0].end_offset, + net_device->recv_section[0].sub_alloc_size, + net_device->recv_section[0].num_sub_allocs); /* * For 1st release, there should only be 1 section that represents the * entire receive buffer */ - if (net_device->ReceiveSectionCount != 1 || - net_device->ReceiveSections->Offset != 0) { + if (net_device->recv_section_cnt != 1 || + net_device->recv_section->offset != 0) { ret = -1; goto Cleanup; } @@ -351,7 +351,7 @@ static int netvsc_init_send_buf(struct hv_device *device) "device being destroyed?"); return -1; } - if (net_device->SendBufferSize <= 0) { + if (net_device->send_buf_size <= 0) { ret = -EINVAL; goto Cleanup; } @@ -359,11 +359,11 @@ static int netvsc_init_send_buf(struct hv_device *device) /* page-size grandularity */ /* ASSERT((netDevice->SendBufferSize & (PAGE_SIZE - 1)) == 0); */ - net_device->SendBuffer = - osd_page_alloc(net_device->SendBufferSize >> PAGE_SHIFT); - if (!net_device->SendBuffer) { + net_device->send_buf = + osd_page_alloc(net_device->send_buf_size >> PAGE_SHIFT); + if (!net_device->send_buf) { DPRINT_ERR(NETVSC, "unable to allocate send buffer of size %d", - net_device->SendBufferSize); + net_device->send_buf_size); ret = -1; goto Cleanup; } @@ -377,9 +377,9 @@ static int netvsc_init_send_buf(struct hv_device *device) * channel. Note: This call uses the vmbus connection rather * than the channel to establish the gpadl handle. */ - ret = vmbus_establish_gpadl(device->channel, net_device->SendBuffer, - net_device->SendBufferSize, - &net_device->SendBufferGpadlHandle); + ret = vmbus_establish_gpadl(device->channel, net_device->send_buf, + net_device->send_buf_size, + &net_device->send_buf_gpadl_handle); if (ret != 0) { DPRINT_ERR(NETVSC, "unable to establish send buffer's gpadl"); goto Cleanup; @@ -390,14 +390,14 @@ static int netvsc_init_send_buf(struct hv_device *device) /* Notify the NetVsp of the gpadl handle */ DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendSendBuffer..."); - init_packet = &net_device->ChannelInitPacket; + init_packet = &net_device->channel_init_pkt; memset(init_packet, 0, sizeof(struct nvsp_message)); - init_packet->Header.MessageType = NvspMessage1TypeSendSendBuffer; - init_packet->Messages.Version1Messages.SendReceiveBuffer. - GpadlHandle = net_device->SendBufferGpadlHandle; - init_packet->Messages.Version1Messages.SendReceiveBuffer.Id = + init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_SEND_BUF; + init_packet->msg.v1_msg.send_recv_buf. + gpadl_handle = net_device->send_buf_gpadl_handle; + init_packet->msg.v1_msg.send_recv_buf.id = NETVSC_SEND_BUFFER_ID; /* Send the gpadl notification request */ @@ -412,21 +412,21 @@ static int netvsc_init_send_buf(struct hv_device *device) goto Cleanup; } - osd_waitevent_wait(net_device->ChannelInitEvent); + osd_waitevent_wait(net_device->channel_init_event); /* Check the response */ - if (init_packet->Messages.Version1Messages. - SendSendBufferComplete.Status != NvspStatusSuccess) { + if (init_packet->msg.v1_msg. + send_send_buf_complete.status != NVSP_STAT_SUCCESS) { DPRINT_ERR(NETVSC, "Unable to complete send buffer " "initialzation with NetVsp - status %d", - init_packet->Messages.Version1Messages. - SendSendBufferComplete.Status); + init_packet->msg.v1_msg. + send_send_buf_complete.status); ret = -1; goto Cleanup; } - net_device->SendSectionSize = init_packet-> - Messages.Version1Messages.SendSendBufferComplete.SectionSize; + net_device->send_section_size = init_packet-> + msg.v1_msg.send_send_buf_complete.section_size; goto Exit; @@ -449,20 +449,20 @@ static int netvsc_destroy_recv_buf(struct netvsc_device *net_device) * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need * to send a revoke msg here */ - if (net_device->ReceiveSectionCount) { + if (net_device->recv_section_cnt) { DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeRevokeReceiveBuffer..."); /* Send the revoke receive buffer */ - revoke_packet = &net_device->RevokePacket; + revoke_packet = &net_device->revoke_packet; memset(revoke_packet, 0, sizeof(struct nvsp_message)); - revoke_packet->Header.MessageType = - NvspMessage1TypeRevokeReceiveBuffer; - revoke_packet->Messages.Version1Messages. - RevokeReceiveBuffer.Id = NETVSC_RECEIVE_BUFFER_ID; + revoke_packet->hdr.msg_type = + NVSP_MSG1_TYPE_REVOKE_RECV_BUF; + revoke_packet->msg.v1_msg. + revoke_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID; - ret = vmbus_sendpacket(net_device->Device->channel, + ret = vmbus_sendpacket(net_device->dev->channel, revoke_packet, sizeof(struct nvsp_message), (unsigned long)revoke_packet, @@ -479,11 +479,11 @@ static int netvsc_destroy_recv_buf(struct netvsc_device *net_device) } /* Teardown the gpadl on the vsp end */ - if (net_device->ReceiveBufferGpadlHandle) { + if (net_device->recv_buf_gpadl_handle) { DPRINT_INFO(NETVSC, "Tearing down receive buffer's GPADL..."); - ret = vmbus_teardown_gpadl(net_device->Device->channel, - net_device->ReceiveBufferGpadlHandle); + ret = vmbus_teardown_gpadl(net_device->dev->channel, + net_device->recv_buf_gpadl_handle); /* If we failed here, we might as well return and have a leak rather than continue and a bugchk */ if (ret != 0) { @@ -491,22 +491,22 @@ static int netvsc_destroy_recv_buf(struct netvsc_device *net_device) "unable to teardown receive buffer's gpadl"); return -1; } - net_device->ReceiveBufferGpadlHandle = 0; + net_device->recv_buf_gpadl_handle = 0; } - if (net_device->ReceiveBuffer) { + if (net_device->recv_buf) { DPRINT_INFO(NETVSC, "Freeing up receive buffer..."); /* Free up the receive buffer */ - osd_page_free(net_device->ReceiveBuffer, - net_device->ReceiveBufferSize >> PAGE_SHIFT); - net_device->ReceiveBuffer = NULL; + osd_page_free(net_device->recv_buf, + net_device->recv_buf_size >> PAGE_SHIFT); + net_device->recv_buf = NULL; } - if (net_device->ReceiveSections) { - net_device->ReceiveSectionCount = 0; - kfree(net_device->ReceiveSections); - net_device->ReceiveSections = NULL; + if (net_device->recv_section) { + net_device->recv_section_cnt = 0; + kfree(net_device->recv_section); + net_device->recv_section = NULL; } return ret; @@ -523,20 +523,20 @@ static int netvsc_destroy_send_buf(struct netvsc_device *net_device) * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need * to send a revoke msg here */ - if (net_device->SendSectionSize) { + if (net_device->send_section_size) { DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeRevokeSendBuffer..."); /* Send the revoke send buffer */ - revoke_packet = &net_device->RevokePacket; + revoke_packet = &net_device->revoke_packet; memset(revoke_packet, 0, sizeof(struct nvsp_message)); - revoke_packet->Header.MessageType = - NvspMessage1TypeRevokeSendBuffer; - revoke_packet->Messages.Version1Messages. - RevokeSendBuffer.Id = NETVSC_SEND_BUFFER_ID; + revoke_packet->hdr.msg_type = + NVSP_MSG1_TYPE_REVOKE_SEND_BUF; + revoke_packet->msg.v1_msg. + revoke_send_buf.id = NETVSC_SEND_BUFFER_ID; - ret = vmbus_sendpacket(net_device->Device->channel, + ret = vmbus_sendpacket(net_device->dev->channel, revoke_packet, sizeof(struct nvsp_message), (unsigned long)revoke_packet, @@ -553,10 +553,10 @@ static int netvsc_destroy_send_buf(struct netvsc_device *net_device) } /* Teardown the gpadl on the vsp end */ - if (net_device->SendBufferGpadlHandle) { + if (net_device->send_buf_gpadl_handle) { DPRINT_INFO(NETVSC, "Tearing down send buffer's GPADL..."); - ret = vmbus_teardown_gpadl(net_device->Device->channel, - net_device->SendBufferGpadlHandle); + ret = vmbus_teardown_gpadl(net_device->dev->channel, + net_device->send_buf_gpadl_handle); /* * If we failed here, we might as well return and have a leak @@ -567,16 +567,16 @@ static int netvsc_destroy_send_buf(struct netvsc_device *net_device) "gpadl"); return -1; } - net_device->SendBufferGpadlHandle = 0; + net_device->send_buf_gpadl_handle = 0; } - if (net_device->SendBuffer) { + if (net_device->send_buf) { DPRINT_INFO(NETVSC, "Freeing up send buffer..."); /* Free up the receive buffer */ - osd_page_free(net_device->SendBuffer, - net_device->SendBufferSize >> PAGE_SHIFT); - net_device->SendBuffer = NULL; + osd_page_free(net_device->send_buf, + net_device->send_buf_size >> PAGE_SHIFT); + net_device->send_buf = NULL; } return ret; @@ -597,13 +597,13 @@ static int netvsc_connect_vsp(struct hv_device *device) return -1; } - init_packet = &net_device->ChannelInitPacket; + init_packet = &net_device->channel_init_pkt; memset(init_packet, 0, sizeof(struct nvsp_message)); - init_packet->Header.MessageType = NvspMessageTypeInit; - init_packet->Messages.InitMessages.Init.MinProtocolVersion = + init_packet->hdr.msg_type = NVSP_MSG_TYPE_INIT; + init_packet->msg.init_msg.init.min_protocol_ver = NVSP_MIN_PROTOCOL_VERSION; - init_packet->Messages.InitMessages.Init.MaxProtocolVersion = + init_packet->msg.init_msg.init.max_protocol_ver = NVSP_MAX_PROTOCOL_VERSION; DPRINT_INFO(NETVSC, "Sending NvspMessageTypeInit..."); @@ -620,30 +620,30 @@ static int netvsc_connect_vsp(struct hv_device *device) goto Cleanup; } - osd_waitevent_wait(net_device->ChannelInitEvent); + osd_waitevent_wait(net_device->channel_init_event); /* Now, check the response */ /* ASSERT(initPacket->Messages.InitMessages.InitComplete.MaximumMdlChainLength <= MAX_MULTIPAGE_BUFFER_COUNT); */ DPRINT_INFO(NETVSC, "NvspMessageTypeInit status(%d) max mdl chain (%d)", - init_packet->Messages.InitMessages.InitComplete.Status, - init_packet->Messages.InitMessages. - InitComplete.MaximumMdlChainLength); + init_packet->msg.init_msg.init_complete.status, + init_packet->msg.init_msg. + init_complete.max_mdl_chain_len); - if (init_packet->Messages.InitMessages.InitComplete.Status != - NvspStatusSuccess) { + if (init_packet->msg.init_msg.init_complete.status != + NVSP_STAT_SUCCESS) { DPRINT_ERR(NETVSC, "unable to initialize with netvsp (status 0x%x)", - init_packet->Messages.InitMessages.InitComplete.Status); + init_packet->msg.init_msg.init_complete.status); ret = -1; goto Cleanup; } - if (init_packet->Messages.InitMessages.InitComplete. - NegotiatedProtocolVersion != NVSP_PROTOCOL_VERSION_1) { + if (init_packet->msg.init_msg.init_complete. + negotiated_protocol_ver != NVSP_PROTOCOL_VERSION_1) { DPRINT_ERR(NETVSC, "unable to initialize with netvsp " "(version expected 1 got %d)", - init_packet->Messages.InitMessages. - InitComplete.NegotiatedProtocolVersion); + init_packet->msg.init_msg. + init_complete.negotiated_protocol_ver); ret = -1; goto Cleanup; } @@ -654,12 +654,12 @@ static int netvsc_connect_vsp(struct hv_device *device) ndis_version = 0x00050000; - init_packet->Header.MessageType = NvspMessage1TypeSendNdisVersion; - init_packet->Messages.Version1Messages. - SendNdisVersion.NdisMajorVersion = + init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_NDIS_VER; + init_packet->msg.v1_msg. + send_ndis_ver.ndis_major_ver = (ndis_version & 0xFFFF0000) >> 16; - init_packet->Messages.Version1Messages. - SendNdisVersion.NdisMinorVersion = + init_packet->msg.v1_msg. + send_ndis_ver.ndis_minor_ver = ndis_version & 0xFFFF; /* Send the init request */ @@ -719,12 +719,12 @@ static int netvsc_device_add(struct hv_device *device, void *additional_info) DPRINT_DBG(NETVSC, "netvsc channel object allocated - %p", net_device); /* Initialize the NetVSC channel extension */ - net_device->ReceiveBufferSize = NETVSC_RECEIVE_BUFFER_SIZE; - spin_lock_init(&net_device->receive_packet_list_lock); + net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE; + spin_lock_init(&net_device->recv_pkt_list_lock); - net_device->SendBufferSize = NETVSC_SEND_BUFFER_SIZE; + net_device->send_buf_size = NETVSC_SEND_BUFFER_SIZE; - INIT_LIST_HEAD(&net_device->ReceivePacketList); + INIT_LIST_HEAD(&net_device->recv_pkt_list); for (i = 0; i < NETVSC_RECEIVE_PACKETLIST_COUNT; i++) { packet = kzalloc(sizeof(struct hv_netvsc_packet) + @@ -737,10 +737,10 @@ static int netvsc_device_add(struct hv_device *device, void *additional_info) break; } list_add_tail(&packet->list_ent, - &net_device->ReceivePacketList); + &net_device->recv_pkt_list); } - net_device->ChannelInitEvent = osd_waitevent_create(); - if (!net_device->ChannelInitEvent) { + net_device->channel_init_event = osd_waitevent_create(); + if (!net_device->channel_init_event) { ret = -ENOMEM; goto Cleanup; } @@ -779,10 +779,10 @@ close: Cleanup: if (net_device) { - kfree(net_device->ChannelInitEvent); + kfree(net_device->channel_init_event); list_for_each_entry_safe(packet, pos, - &net_device->ReceivePacketList, + &net_device->recv_pkt_list, list_ent) { list_del(&packet->list_ent); kfree(packet); @@ -816,9 +816,9 @@ static int netvsc_device_remove(struct hv_device *device) } /* Wait for all send completions */ - while (atomic_read(&net_device->NumOutstandingSends)) { + while (atomic_read(&net_device->num_outstanding_sends)) { DPRINT_INFO(NETVSC, "waiting for %d requests to complete...", - atomic_read(&net_device->NumOutstandingSends)); + atomic_read(&net_device->num_outstanding_sends)); udelay(100); } @@ -840,12 +840,12 @@ static int netvsc_device_remove(struct hv_device *device) /* Release all resources */ list_for_each_entry_safe(netvsc_packet, pos, - &net_device->ReceivePacketList, list_ent) { + &net_device->recv_pkt_list, list_ent) { list_del(&netvsc_packet->list_ent); kfree(netvsc_packet); } - kfree(net_device->ChannelInitEvent); + kfree(net_device->channel_init_event); free_net_device(net_device); return 0; } @@ -875,19 +875,19 @@ static void netvsc_send_completion(struct hv_device *device, (packet->DataOffset8 << 3)); DPRINT_DBG(NETVSC, "send completion packet - type %d", - nvsp_packet->Header.MessageType); + nvsp_packet->hdr.msg_type); - if ((nvsp_packet->Header.MessageType == NvspMessageTypeInitComplete) || - (nvsp_packet->Header.MessageType == - NvspMessage1TypeSendReceiveBufferComplete) || - (nvsp_packet->Header.MessageType == - NvspMessage1TypeSendSendBufferComplete)) { + if ((nvsp_packet->hdr.msg_type == NVSP_MSG_TYPE_INIT_COMPLETE) || + (nvsp_packet->hdr.msg_type == + NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE) || + (nvsp_packet->hdr.msg_type == + NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE)) { /* Copy the response back */ - memcpy(&net_device->ChannelInitPacket, nvsp_packet, + memcpy(&net_device->channel_init_pkt, nvsp_packet, sizeof(struct nvsp_message)); - osd_waitevent_set(net_device->ChannelInitEvent); - } else if (nvsp_packet->Header.MessageType == - NvspMessage1TypeSendRNDISPacketComplete) { + osd_waitevent_set(net_device->channel_init_event); + } else if (nvsp_packet->hdr.msg_type == + NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE) { /* Get the send context */ nvsc_packet = (struct hv_netvsc_packet *)(unsigned long) packet->TransactionId; @@ -897,10 +897,10 @@ static void netvsc_send_completion(struct hv_device *device, nvsc_packet->completion.send.send_completion( nvsc_packet->completion.send.send_completion_ctx); - atomic_dec(&net_device->NumOutstandingSends); + atomic_dec(&net_device->num_outstanding_sends); } else { DPRINT_ERR(NETVSC, "Unknown send completion packet type - " - "%d received!!", nvsp_packet->Header.MessageType); + "%d received!!", nvsp_packet->hdr.msg_type); } put_net_device(device); @@ -921,18 +921,19 @@ static int netvsc_send(struct hv_device *device, return -2; } - sendMessage.Header.MessageType = NvspMessage1TypeSendRNDISPacket; + sendMessage.hdr.msg_type = NVSP_MSG1_TYPE_SEND_RNDIS_PKT; if (packet->is_data_pkt) { /* 0 is RMC_DATA; */ - sendMessage.Messages.Version1Messages.SendRNDISPacket.ChannelType = 0; + sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 0; } else { /* 1 is RMC_CONTROL; */ - sendMessage.Messages.Version1Messages.SendRNDISPacket.ChannelType = 1; + sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 1; } /* Not using send buffer section */ - sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionIndex = 0xFFFFFFFF; - sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionSize = 0; + sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_index = + 0xFFFFFFFF; + sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_size = 0; if (packet->page_buf_cnt) { ret = vmbus_sendpacket_pagebuffer(device->channel, @@ -954,7 +955,7 @@ static int netvsc_send(struct hv_device *device, DPRINT_ERR(NETVSC, "Unable to send packet %p ret %d", packet, ret); - atomic_inc(&net_device->NumOutstandingSends); + atomic_inc(&net_device->num_outstanding_sends); put_net_device(device); return ret; } @@ -997,16 +998,16 @@ static void netvsc_receive(struct hv_device *device, (packet->DataOffset8 << 3)); /* Make sure this is a valid nvsp packet */ - if (nvsp_packet->Header.MessageType != - NvspMessage1TypeSendRNDISPacket) { + if (nvsp_packet->hdr.msg_type != + NVSP_MSG1_TYPE_SEND_RNDIS_PKT) { DPRINT_ERR(NETVSC, "Unknown nvsp packet type received - %d", - nvsp_packet->Header.MessageType); + nvsp_packet->hdr.msg_type); put_net_device(device); return; } DPRINT_DBG(NETVSC, "NVSP packet received - type %d", - nvsp_packet->Header.MessageType); + nvsp_packet->hdr.msg_type); vmxferpage_packet = (struct vmtransfer_page_packet_header *)packet; @@ -1027,13 +1028,13 @@ static void netvsc_receive(struct hv_device *device, * We grab it here so that we know exactly how many we can * fulfil */ - spin_lock_irqsave(&net_device->receive_packet_list_lock, flags); - while (!list_empty(&net_device->ReceivePacketList)) { - list_move_tail(net_device->ReceivePacketList.next, &listHead); + spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags); + while (!list_empty(&net_device->recv_pkt_list)) { + list_move_tail(net_device->recv_pkt_list.next, &listHead); if (++count == vmxferpage_packet->RangeCount + 1) break; } - spin_unlock_irqrestore(&net_device->receive_packet_list_lock, flags); + spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags); /* * We need at least 2 netvsc pkts (1 to represent the xfer @@ -1046,12 +1047,12 @@ static void netvsc_receive(struct hv_device *device, count, vmxferpage_packet->RangeCount + 1); /* Return it to the freelist */ - spin_lock_irqsave(&net_device->receive_packet_list_lock, flags); + spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags); for (i = count; i != 0; i--) { list_move_tail(listHead.next, - &net_device->ReceivePacketList); + &net_device->recv_pkt_list); } - spin_unlock_irqrestore(&net_device->receive_packet_list_lock, + spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags); netvsc_send_recv_completion(device, @@ -1104,10 +1105,10 @@ static void netvsc_receive(struct hv_device *device, vmxferpage_packet->Ranges[i].ByteCount; start = virt_to_phys((void *)((unsigned long)net_device-> - ReceiveBuffer + vmxferpage_packet->Ranges[i].ByteOffset)); + recv_buf + vmxferpage_packet->Ranges[i].ByteOffset)); netvsc_packet->page_buf[0].Pfn = start >> PAGE_SHIFT; - end_virtual = (unsigned long)net_device->ReceiveBuffer + end_virtual = (unsigned long)net_device->recv_buf + vmxferpage_packet->Ranges[i].ByteOffset + vmxferpage_packet->Ranges[i].ByteCount - 1; end = virt_to_phys((void *)end_virtual); @@ -1175,11 +1176,12 @@ static void netvsc_send_recv_completion(struct hv_device *device, DPRINT_DBG(NETVSC, "Sending receive completion pkt - %llx", transaction_id); - recvcompMessage.Header.MessageType = - NvspMessage1TypeSendRNDISPacketComplete; + recvcompMessage.hdr.msg_type = + NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE; /* FIXME: Pass in the status */ - recvcompMessage.Messages.Version1Messages.SendRNDISPacketComplete.Status = NvspStatusSuccess; + recvcompMessage.msg.v1_msg.send_rndis_pkt_complete.status = + NVSP_STAT_SUCCESS; retry_send_cmplt: /* Send the completion */ @@ -1234,7 +1236,7 @@ static void netvsc_receive_completion(void *context) } /* Overloading use of the lock. */ - spin_lock_irqsave(&net_device->receive_packet_list_lock, flags); + spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags); /* ASSERT(packet->XferPagePacket->Count > 0); */ packet->xfer_page_pkt->count--; @@ -1247,13 +1249,13 @@ static void netvsc_receive_completion(void *context) fsend_receive_comp = true; transaction_id = packet->completion.recv.recv_completion_tid; list_add_tail(&packet->xfer_page_pkt->list_ent, - &net_device->ReceivePacketList); + &net_device->recv_pkt_list); } /* Put the packet back */ - list_add_tail(&packet->list_ent, &net_device->ReceivePacketList); - spin_unlock_irqrestore(&net_device->receive_packet_list_lock, flags); + list_add_tail(&packet->list_ent, &net_device->recv_pkt_list); + spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags); /* Send a receive completion for the xfer page packet */ if (fsend_receive_comp) diff --git a/drivers/staging/hv/netvsc.h b/drivers/staging/hv/netvsc.h index c71dce5b3f7c..932a77ccdc04 100644 --- a/drivers/staging/hv/netvsc.h +++ b/drivers/staging/hv/netvsc.h @@ -38,48 +38,48 @@ #define NVSP_MAX_PROTOCOL_VERSION NVSP_PROTOCOL_VERSION_1 enum { - NvspMessageTypeNone = 0, + NVSP_MSG_TYPE_NONE = 0, /* Init Messages */ - NvspMessageTypeInit = 1, - NvspMessageTypeInitComplete = 2, + NVSP_MSG_TYPE_INIT = 1, + NVSP_MSG_TYPE_INIT_COMPLETE = 2, - NvspVersionMessageStart = 100, + NVSP_VERSION_MSG_START = 100, /* Version 1 Messages */ - NvspMessage1TypeSendNdisVersion = NvspVersionMessageStart, + NVSP_MSG1_TYPE_SEND_NDIS_VER = NVSP_VERSION_MSG_START, - NvspMessage1TypeSendReceiveBuffer, - NvspMessage1TypeSendReceiveBufferComplete, - NvspMessage1TypeRevokeReceiveBuffer, + NVSP_MSG1_TYPE_SEND_RECV_BUF, + NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE, + NVSP_MSG1_TYPE_REVOKE_RECV_BUF, - NvspMessage1TypeSendSendBuffer, - NvspMessage1TypeSendSendBufferComplete, - NvspMessage1TypeRevokeSendBuffer, + NVSP_MSG1_TYPE_SEND_SEND_BUF, + NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE, + NVSP_MSG1_TYPE_REVOKE_SEND_BUF, - NvspMessage1TypeSendRNDISPacket, - NvspMessage1TypeSendRNDISPacketComplete, + NVSP_MSG1_TYPE_SEND_RNDIS_PKT, + NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE, /* * This should be set to the number of messages for the version with * the maximum number of messages. */ - NvspNumMessagePerVersion = 9, + NVSP_NUM_MSG_PER_VERSION = 9, }; enum { - NvspStatusNone = 0, - NvspStatusSuccess, - NvspStatusFailure, - NvspStatusProtocolVersionRangeTooNew, - NvspStatusProtocolVersionRangeTooOld, - NvspStatusInvalidRndisPacket, - NvspStatusBusy, - NvspStatusMax, + NVSP_STAT_NONE = 0, + NVSP_STAT_SUCCESS, + NVSP_STAT_FAIL, + NVSP_STAT_PROTOCOL_TOO_NEW, + NVSP_STAT_PROTOCOL_TOO_OLD, + NVSP_STAT_INVALID_RNDIS_PKT, + NVSP_STAT_BUSY, + NVSP_STAT_MAX, }; struct nvsp_message_header { - u32 MessageType; + u32 msg_type; }; /* Init Messages */ @@ -90,8 +90,8 @@ struct nvsp_message_header { * versioning (i.e. this message will be the same for ever). */ struct nvsp_message_init { - u32 MinProtocolVersion; - u32 MaxProtocolVersion; + u32 min_protocol_ver; + u32 max_protocol_ver; } __attribute__((packed)); /* @@ -100,14 +100,14 @@ struct nvsp_message_init { * (i.e. this message will be the same for ever). */ struct nvsp_message_init_complete { - u32 NegotiatedProtocolVersion; - u32 MaximumMdlChainLength; - u32 Status; + u32 negotiated_protocol_ver; + u32 max_mdl_chain_len; + u32 status; } __attribute__((packed)); union nvsp_message_init_uber { - struct nvsp_message_init Init; - struct nvsp_message_init_complete InitComplete; + struct nvsp_message_init init; + struct nvsp_message_init_complete init_complete; } __attribute__((packed)); /* Version 1 Messages */ @@ -117,8 +117,8 @@ union nvsp_message_init_uber { * can use this information when handling OIDs sent by the VSC. */ struct nvsp_1_message_send_ndis_version { - u32 NdisMajorVersion; - u32 NdisMinorVersion; + u32 ndis_major_ver; + u32 ndis_minor_ver; } __attribute__((packed)); /* @@ -126,15 +126,15 @@ struct nvsp_1_message_send_ndis_version { * can then use the receive buffer to send data to the VSC. */ struct nvsp_1_message_send_receive_buffer { - u32 GpadlHandle; - u16 Id; + u32 gpadl_handle; + u16 id; } __attribute__((packed)); struct nvsp_1_receive_buffer_section { - u32 Offset; - u32 SubAllocationSize; - u32 NumSubAllocations; - u32 EndOffset; + u32 offset; + u32 sub_alloc_size; + u32 num_sub_allocs; + u32 end_offset; } __attribute__((packed)); /* @@ -143,8 +143,8 @@ struct nvsp_1_receive_buffer_section { * buffer. */ struct nvsp_1_message_send_receive_buffer_complete { - u32 Status; - u32 NumSections; + u32 status; + u32 num_sections; /* * The receive buffer is split into two parts, a large suballocation @@ -165,7 +165,7 @@ struct nvsp_1_message_send_receive_buffer_complete { * LargeOffset SmallOffset */ - struct nvsp_1_receive_buffer_section Sections[1]; + struct nvsp_1_receive_buffer_section sections[1]; } __attribute__((packed)); /* @@ -174,7 +174,7 @@ struct nvsp_1_message_send_receive_buffer_complete { * again. */ struct nvsp_1_message_revoke_receive_buffer { - u16 Id; + u16 id; }; /* @@ -182,8 +182,8 @@ struct nvsp_1_message_revoke_receive_buffer { * can then use the send buffer to send data to the VSP. */ struct nvsp_1_message_send_send_buffer { - u32 GpadlHandle; - u16 Id; + u32 gpadl_handle; + u16 id; } __attribute__((packed)); /* @@ -192,7 +192,7 @@ struct nvsp_1_message_send_send_buffer { * buffer. */ struct nvsp_1_message_send_send_buffer_complete { - u32 Status; + u32 status; /* * The VSC gets to choose the size of the send buffer and the VSP gets @@ -200,7 +200,7 @@ struct nvsp_1_message_send_send_buffer_complete { * dynamic reconfigurations when the cost of GPA-direct buffers * decreases. */ - u32 SectionSize; + u32 section_size; } __attribute__((packed)); /* @@ -208,7 +208,7 @@ struct nvsp_1_message_send_send_buffer_complete { * completes this transaction, the vsp should never use the send buffer again. */ struct nvsp_1_message_revoke_send_buffer { - u16 Id; + u16 id; }; /* @@ -221,7 +221,7 @@ struct nvsp_1_message_send_rndis_packet { * channels of communication. However, the Network VSP only has one. * Therefore, the channel travels with the RNDIS packet. */ - u32 ChannelType; + u32 channel_type; /* * This field is used to send part or all of the data through a send @@ -229,8 +229,8 @@ struct nvsp_1_message_send_rndis_packet { * index is 0xFFFFFFFF, then the send buffer is not being used and all * of the data was sent through other VMBus mechanisms. */ - u32 SendBufferSectionIndex; - u32 SendBufferSectionSize; + u32 send_buf_section_index; + u32 send_buf_section_size; } __attribute__((packed)); /* @@ -239,35 +239,35 @@ struct nvsp_1_message_send_rndis_packet { * message cannot use any resources associated with the original RNDIS packet. */ struct nvsp_1_message_send_rndis_packet_complete { - u32 Status; + u32 status; }; union nvsp_1_message_uber { - struct nvsp_1_message_send_ndis_version SendNdisVersion; + struct nvsp_1_message_send_ndis_version send_ndis_ver; - struct nvsp_1_message_send_receive_buffer SendReceiveBuffer; + struct nvsp_1_message_send_receive_buffer send_recv_buf; struct nvsp_1_message_send_receive_buffer_complete - SendReceiveBufferComplete; - struct nvsp_1_message_revoke_receive_buffer RevokeReceiveBuffer; + send_recv_buf_complete; + struct nvsp_1_message_revoke_receive_buffer revoke_recv_buf; - struct nvsp_1_message_send_send_buffer SendSendBuffer; - struct nvsp_1_message_send_send_buffer_complete SendSendBufferComplete; - struct nvsp_1_message_revoke_send_buffer RevokeSendBuffer; + struct nvsp_1_message_send_send_buffer send_send_buf; + struct nvsp_1_message_send_send_buffer_complete send_send_buf_complete; + struct nvsp_1_message_revoke_send_buffer revoke_send_buf; - struct nvsp_1_message_send_rndis_packet SendRNDISPacket; + struct nvsp_1_message_send_rndis_packet send_rndis_pkt; struct nvsp_1_message_send_rndis_packet_complete - SendRNDISPacketComplete; + send_rndis_pkt_complete; } __attribute__((packed)); union nvsp_all_messages { - union nvsp_message_init_uber InitMessages; - union nvsp_1_message_uber Version1Messages; + union nvsp_message_init_uber init_msg; + union nvsp_1_message_uber v1_msg; } __attribute__((packed)); /* ALL Messages */ struct nvsp_message { - struct nvsp_message_header Header; - union nvsp_all_messages Messages; + struct nvsp_message_header hdr; + union nvsp_all_messages msg; } __attribute__((packed)); @@ -293,39 +293,39 @@ struct nvsp_message { /* Per netvsc channel-specific */ struct netvsc_device { - struct hv_device *Device; + struct hv_device *dev; - atomic_t RefCount; - atomic_t NumOutstandingSends; + atomic_t refcnt; + atomic_t num_outstanding_sends; /* * List of free preallocated hv_netvsc_packet to represent receive * packet */ - struct list_head ReceivePacketList; - spinlock_t receive_packet_list_lock; + struct list_head recv_pkt_list; + spinlock_t recv_pkt_list_lock; /* Send buffer allocated by us but manages by NetVSP */ - void *SendBuffer; - u32 SendBufferSize; - u32 SendBufferGpadlHandle; - u32 SendSectionSize; + void *send_buf; + u32 send_buf_size; + u32 send_buf_gpadl_handle; + u32 send_section_size; /* Receive buffer allocated by us but manages by NetVSP */ - void *ReceiveBuffer; - u32 ReceiveBufferSize; - u32 ReceiveBufferGpadlHandle; - u32 ReceiveSectionCount; - struct nvsp_1_receive_buffer_section *ReceiveSections; + void *recv_buf; + u32 recv_buf_size; + u32 recv_buf_gpadl_handle; + u32 recv_section_cnt; + struct nvsp_1_receive_buffer_section *recv_section; /* Used for NetVSP initialization protocol */ - struct osd_waitevent *ChannelInitEvent; - struct nvsp_message ChannelInitPacket; + struct osd_waitevent *channel_init_event; + struct nvsp_message channel_init_pkt; - struct nvsp_message RevokePacket; + struct nvsp_message revoke_packet; /* unsigned char HwMacAddr[HW_MACADDR_LEN]; */ /* Holds rndis device info */ - void *Extension; + void *extension; }; #endif /* _NETVSC_H_ */ diff --git a/drivers/staging/hv/netvsc_api.h b/drivers/staging/hv/netvsc_api.h index ac40db56e1fa..b4bed3636594 100644 --- a/drivers/staging/hv/netvsc_api.h +++ b/drivers/staging/hv/netvsc_api.h @@ -95,7 +95,7 @@ struct netvsc_driver { */ int (*recv_cb)(struct hv_device *dev, struct hv_netvsc_packet *packet); - void (*link_status_change)(struct hv_device *dev, u32 Status); + void (*link_status_change)(struct hv_device *dev, u32 status); /* Specific to this driver */ int (*send)(struct hv_device *dev, struct hv_netvsc_packet *packet); diff --git a/drivers/staging/hv/rndis_filter.c b/drivers/staging/hv/rndis_filter.c index dffcc0397917..63d24c6fadf0 100644 --- a/drivers/staging/hv/rndis_filter.c +++ b/drivers/staging/hv/rndis_filter.c @@ -266,7 +266,7 @@ static int rndis_filter_send_request(struct rndis_device *dev, rndis_filter_send_request_completion; packet->completion.send.send_completion_tid = (unsigned long)dev; - ret = rndis_filter.inner_drv.send(dev->net_dev->Device, packet); + ret = rndis_filter.inner_drv.send(dev->net_dev->dev, packet); return ret; } @@ -338,10 +338,10 @@ static void rndis_filter_receive_indicate_status(struct rndis_device *dev, if (indicate->Status == RNDIS_STATUS_MEDIA_CONNECT) { rndis_filter.inner_drv.link_status_change( - dev->net_dev->Device, 1); + dev->net_dev->dev, 1); } else if (indicate->Status == RNDIS_STATUS_MEDIA_DISCONNECT) { rndis_filter.inner_drv.link_status_change( - dev->net_dev->Device, 0); + dev->net_dev->dev, 0); } else { /* * TODO: @@ -376,7 +376,7 @@ static void rndis_filter_receive_data(struct rndis_device *dev, pkt->is_data_pkt = true; - rndis_filter.inner_drv.recv_cb(dev->net_dev->Device, + rndis_filter.inner_drv.recv_cb(dev->net_dev->dev, pkt); } @@ -392,13 +392,13 @@ static int rndis_filter_receive(struct hv_device *dev, return -EINVAL; /* Make sure the rndis device state is initialized */ - if (!net_dev->Extension) { + if (!net_dev->extension) { DPRINT_ERR(NETVSC, "got rndis message but no rndis device..." "dropping this message!"); return -1; } - rndis_dev = (struct rndis_device *)net_dev->Extension; + rndis_dev = (struct rndis_device *)net_dev->extension; if (rndis_dev->state == RNDIS_DEV_UNINITIALIZED) { DPRINT_ERR(NETVSC, "got rndis message but rndis device " "uninitialized...dropping this message!"); @@ -782,7 +782,7 @@ static int rndis_filte_device_add(struct hv_device *dev, /* ASSERT(netDevice); */ /* ASSERT(netDevice->Device); */ - netDevice->Extension = rndisDevice; + netDevice->extension = rndisDevice; rndisDevice->net_dev = netDevice; /* Send the rndis initialization message */ @@ -819,13 +819,13 @@ static int rndis_filte_device_add(struct hv_device *dev, static int rndis_filter_device_remove(struct hv_device *dev) { struct netvsc_device *net_dev = dev->Extension; - struct rndis_device *rndis_dev = net_dev->Extension; + struct rndis_device *rndis_dev = net_dev->extension; /* Halt and release the rndis device */ rndis_filter_halt_device(rndis_dev); kfree(rndis_dev); - net_dev->Extension = NULL; + net_dev->extension = NULL; /* Pass control to inner driver to remove the device */ rndis_filter.inner_drv.base.OnDeviceRemove(dev); @@ -844,7 +844,7 @@ int rndis_filter_open(struct hv_device *dev) if (!netDevice) return -EINVAL; - return rndis_filter_open_device(netDevice->Extension); + return rndis_filter_open_device(netDevice->extension); } int rndis_filter_close(struct hv_device *dev) @@ -854,7 +854,7 @@ int rndis_filter_close(struct hv_device *dev) if (!netDevice) return -EINVAL; - return rndis_filter_close_device(netDevice->Extension); + return rndis_filter_close_device(netDevice->extension); } static int rndis_filter_send(struct hv_device *dev, -- 2.20.1