VM_PKT_DATA_INBAND, 0);
 }
 
-
 static struct netvsc_device *alloc_net_device(void)
 {
        struct netvsc_device *net_device;
        return net_device;
 }
 
-
 static int netvsc_destroy_buf(struct hv_device *device)
 {
        struct nvsp_message *revoke_packet;
                goto cleanup;
        }
 
-
        /* Notify the NetVsp of the gpadl handle */
        init_packet = &net_device->channel_init_pkt;
 
        /* Section count is simply the size divided by the section size.
         */
        net_device->send_section_cnt =
-               net_device->send_buf_size/net_device->send_section_size;
+               net_device->send_buf_size / net_device->send_section_size;
 
        dev_info(&device->device, "Send section size: %d, Section count:%d\n",
                 net_device->send_section_size, net_device->send_section_cnt);
        return ret;
 }
 
-
 /* Negotiate NVSP protocol version */
 static int negotiate_nvsp_ver(struct hv_device *device,
                              struct netvsc_device *net_device,
        return 0;
 }
 
-
 #define RING_AVAIL_PERCENT_HIWATER 20
 #define RING_AVAIL_PERCENT_LOWATER 10
 
                    !net_device_ctx->start_remove &&
                    (hv_ringbuf_avail_percent(&channel->outbound) >
                     RING_AVAIL_PERCENT_HIWATER || queue_sends < 1))
-                               netif_tx_wake_queue(netdev_get_tx_queue(
-                                                   ndev, q_idx));
+                       netif_tx_wake_queue(netdev_get_tx_queue(ndev, q_idx));
        } else {
                netdev_err(ndev, "Unknown send completion packet type- "
                           "%d received!!\n", nvsp_packet->hdr.msg_type);
        }
-
 }
 
 static u32 netvsc_get_next_send_section(struct netvsc_device *net_device)
                /* Pass it to the upper layer */
                status = rndis_filter_receive(device, netvsc_packet, &data,
                                              channel);
-
        }
 
        if (!net_device->mrc[q_idx].buf) {
        rcd->status = status;
 }
 
-
 static void netvsc_send_table(struct hv_device *hdev,
                              struct nvsp_message *nvmsg)
 {
        }
 }
 
-
 void netvsc_channel_cb(void *context)
 {
        int ret;
                                                       ndev,
                                                       request_id,
                                                       desc);
-
-
                        } else {
                                /*
                                 * We are done for this pass.
                kfree(buffer);
 
        netvsc_chk_recv_comp(net_device, channel, q_idx);
-
-       return;
 }
 
 /*
 
 
 #include "hyperv_net.h"
 
-
 #define RING_SIZE_MIN 64
 #define LINKCHANGE_INT (2 * HZ)
 #define NETVSC_HW_FEATURES     (NETIF_F_RXCSUM | \
                        FIELD_SIZEOF(struct sk_buff, cb));
        packet = (struct hv_netvsc_packet *)skb->cb;
 
-
        packet->q_idx = skb_get_queue_mapping(skb);
 
        packet->total_data_buflen = skb->len;
        schedule_delayed_work(&ndev_ctx->dwork, 0);
 }
 
-
 static struct sk_buff *netvsc_alloc_recv_skb(struct net_device *net,
                                struct hv_netvsc_packet *packet,
                                struct ndis_tcp_ip_checksum_info *csum_info,
        return NOTIFY_OK;
 }
 
-
 static int netvsc_vf_down(struct net_device *vf_netdev)
 {
        struct net_device *ndev;
        return NOTIFY_OK;
 }
 
-
 static int netvsc_unregister_vf(struct net_device *vf_netdev)
 {
        struct net_device *ndev;
                return 0;
        }
 
-
        ndev_ctx = netdev_priv(net);
        net_device = ndev_ctx->nvdev;
 
        .remove = netvsc_remove,
 };
 
-
 /*
  * On Hyper-V, every VF interface is matched with a corresponding
  * synthetic interface. The synthetic interface is presented first
 
        for (i = 0; i < HASH_KEYLEN; i++)
                keyp[i] = netvsc_hash_key[i];
 
-
        ret = rndis_filter_send_request(rdev, request);
        if (ret != 0)
                goto cleanup;
        return ret;
 }
 
-
 static int rndis_filter_query_device_link_status(struct rndis_device *dev)
 {
        u32 size = sizeof(u32);
        return ret;
 }
 
-
 static int rndis_filter_init_device(struct rndis_device *dev)
 {
        struct rndis_request *request;
 
        if (request)
                put_rndis_request(dev, request);
-       return;
 }
 
 static int rndis_filter_open_device(struct rndis_device *dev)
 }
 
 int rndis_filter_device_add(struct hv_device *dev,
-                                 void *additional_info)
+                           void *additional_info)
 {
        int ret;
        struct net_device *net = hv_get_drvdata(dev);
        offloads.udp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
        offloads.lso_v2_ipv4 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED;
 
-
        ret = rndis_filter_set_offload_params(net, &offloads);
        if (ret)
                goto err_dev_remv;
        netvsc_device_remove(dev);
 }
 
-
 int rndis_filter_open(struct netvsc_device *nvdev)
 {
        if (!nvdev)