staging: hv: Convert camel cased struct fields in netvsc_api.h to lower cases (72a2f5bd) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/staging/hv/netvsc.c

+52 −52

Original line number	Diff line number	Diff line
		@@ -196,11 +196,11 @@ int netvsc_initialize(struct hv_driver *drv)
		/* ASSERT(driver->OnLinkStatusChanged); */

		/* Setup the dispatch table */
		driver->Base.OnDeviceAdd = netvsc_device_add;
		driver->Base.OnDeviceRemove = netvsc_device_remove;
		driver->Base.OnCleanup = netvsc_cleanup;
		driver->base.OnDeviceAdd = netvsc_device_add;
		driver->base.OnDeviceRemove = netvsc_device_remove;
		driver->base.OnCleanup = netvsc_cleanup;

		driver->OnSend = netvsc_send;
		driver->send = netvsc_send;

		rndis_filter_init(driver);
		return 0;
		@@ -736,7 +736,7 @@ static int netvsc_device_add(struct hv_device device, void additional_info)
		NETVSC_RECEIVE_PACKETLIST_COUNT, i);
		break;
		}
		list_add_tail(&packet->ListEntry,
		list_add_tail(&packet->list_ent,
		&net_device->ReceivePacketList);
		}
		net_device->ChannelInitEvent = osd_waitevent_create();
		@@ -746,8 +746,8 @@ static int netvsc_device_add(struct hv_device device, void additional_info)
		}

		/* Open the channel */
		ret = vmbus_open(device->channel, net_driver->RingBufferSize,
		net_driver->RingBufferSize, NULL, 0,
		ret = vmbus_open(device->channel, net_driver->ring_buf_size,
		net_driver->ring_buf_size, NULL, 0,
		netvsc_channel_cb, device);

		if (ret != 0) {
		@@ -783,8 +783,8 @@ Cleanup:

		list_for_each_entry_safe(packet, pos,
		&net_device->ReceivePacketList,
		ListEntry) {
		list_del(&packet->ListEntry);
		list_ent) {
		list_del(&packet->list_ent);
		kfree(packet);
		}

		@@ -840,8 +840,8 @@ static int netvsc_device_remove(struct hv_device *device)

		/* Release all resources */
		list_for_each_entry_safe(netvsc_packet, pos,
		&net_device->ReceivePacketList, ListEntry) {
		list_del(&netvsc_packet->ListEntry);
		&net_device->ReceivePacketList, list_ent) {
		list_del(&netvsc_packet->list_ent);
		kfree(netvsc_packet);
		}

		@@ -894,8 +894,8 @@ static void netvsc_send_completion(struct hv_device *device,
		/* ASSERT(nvscPacket); */

		/* Notify the layer above us */
		nvsc_packet->Completion.Send.OnSendCompletion(
		nvsc_packet->Completion.Send.SendCompletionContext);
		nvsc_packet->completion.send.send_completion(
		nvsc_packet->completion.send.send_completion_ctx);

		atomic_dec(&net_device->NumOutstandingSends);
		} else {
		@@ -922,7 +922,7 @@ static int netvsc_send(struct hv_device *device,
		}

		sendMessage.Header.MessageType = NvspMessage1TypeSendRNDISPacket;
		if (packet->IsDataPacket) {
		if (packet->is_data_pkt) {
		/* 0 is RMC_DATA; */
		sendMessage.Messages.Version1Messages.SendRNDISPacket.ChannelType = 0;
		} else {
		@@ -934,10 +934,10 @@ static int netvsc_send(struct hv_device *device,
		sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionIndex = 0xFFFFFFFF;
		sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionSize = 0;

		if (packet->PageBufferCount) {
		if (packet->page_buf_cnt) {
		ret = vmbus_sendpacket_pagebuffer(device->channel,
		packet->PageBuffers,
		packet->PageBufferCount,
		packet->page_buf,
		packet->page_buf_cnt,
		&sendMessage,
		sizeof(struct nvsp_message),
		(unsigned long)packet);
		@@ -1063,82 +1063,82 @@ static void netvsc_receive(struct hv_device *device,

		/* Remove the 1st packet to represent the xfer page packet itself */
		xferpage_packet = (struct xferpage_packet *)listHead.next;
		list_del(&xferpage_packet->ListEntry);
		list_del(&xferpage_packet->list_ent);

		/* This is how much we can satisfy */
		xferpage_packet->Count = count - 1;
		xferpage_packet->count = count - 1;
		/* ASSERT(xferpagePacket->Count > 0 && xferpagePacket->Count <= */
		/* vmxferpagePacket->RangeCount); */

		if (xferpage_packet->Count != vmxferpage_packet->RangeCount) {
		if (xferpage_packet->count != vmxferpage_packet->RangeCount) {
		DPRINT_INFO(NETVSC, "Needed %d netvsc pkts to satisy this xfer "
		"page...got %d", vmxferpage_packet->RangeCount,
		xferpage_packet->Count);
		xferpage_packet->count);
		}

		/* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
		for (i = 0; i < (count - 1); i++) {
		netvsc_packet = (struct hv_netvsc_packet *)listHead.next;
		list_del(&netvsc_packet->ListEntry);
		list_del(&netvsc_packet->list_ent);

		/* Initialize the netvsc packet */
		netvsc_packet->XferPagePacket = xferpage_packet;
		netvsc_packet->Completion.Recv.OnReceiveCompletion =
		netvsc_packet->xfer_page_pkt = xferpage_packet;
		netvsc_packet->completion.recv.recv_completion =
		netvsc_receive_completion;
		netvsc_packet->Completion.Recv.ReceiveCompletionContext =
		netvsc_packet->completion.recv.recv_completion_ctx =
		netvsc_packet;
		netvsc_packet->Device = device;
		netvsc_packet->device = device;
		/* Save this so that we can send it back */
		netvsc_packet->Completion.Recv.ReceiveCompletionTid =
		netvsc_packet->completion.recv.recv_completion_tid =
		vmxferpage_packet->d.TransactionId;

		netvsc_packet->TotalDataBufferLength =
		netvsc_packet->total_data_buflen =
		vmxferpage_packet->Ranges[i].ByteCount;
		netvsc_packet->PageBufferCount = 1;
		netvsc_packet->page_buf_cnt = 1;

		/* ASSERT(vmxferpagePacket->Ranges[i].ByteOffset + */
		/* vmxferpagePacket->Ranges[i].ByteCount < */
		/* netDevice->ReceiveBufferSize); */

		netvsc_packet->PageBuffers[0].Length =
		netvsc_packet->page_buf[0].Length =
		vmxferpage_packet->Ranges[i].ByteCount;

		start = virt_to_phys((void *)((unsigned long)net_device->
		ReceiveBuffer + vmxferpage_packet->Ranges[i].ByteOffset));

		netvsc_packet->PageBuffers[0].Pfn = start >> PAGE_SHIFT;
		netvsc_packet->page_buf[0].Pfn = start >> PAGE_SHIFT;
		end_virtual = (unsigned long)net_device->ReceiveBuffer
		+ vmxferpage_packet->Ranges[i].ByteOffset
		+ vmxferpage_packet->Ranges[i].ByteCount - 1;
		end = virt_to_phys((void *)end_virtual);

		/* Calculate the page relative offset */
		netvsc_packet->PageBuffers[0].Offset =
		netvsc_packet->page_buf[0].Offset =
		vmxferpage_packet->Ranges[i].ByteOffset &
		(PAGE_SIZE - 1);
		if ((end >> PAGE_SHIFT) != (start >> PAGE_SHIFT)) {
		/* Handle frame across multiple pages: */
		netvsc_packet->PageBuffers[0].Length =
		(netvsc_packet->PageBuffers[0].Pfn <<
		netvsc_packet->page_buf[0].Length =
		(netvsc_packet->page_buf[0].Pfn <<
		PAGE_SHIFT)
		+ PAGE_SIZE - start;
		bytes_remain = netvsc_packet->TotalDataBufferLength -
		netvsc_packet->PageBuffers[0].Length;
		bytes_remain = netvsc_packet->total_data_buflen -
		netvsc_packet->page_buf[0].Length;
		for (j = 1; j < NETVSC_PACKET_MAXPAGE; j++) {
		netvsc_packet->PageBuffers[j].Offset = 0;
		netvsc_packet->page_buf[j].Offset = 0;
		if (bytes_remain <= PAGE_SIZE) {
		netvsc_packet->PageBuffers[j].Length =
		netvsc_packet->page_buf[j].Length =
		bytes_remain;
		bytes_remain = 0;
		} else {
		netvsc_packet->PageBuffers[j].Length =
		netvsc_packet->page_buf[j].Length =
		PAGE_SIZE;
		bytes_remain -= PAGE_SIZE;
		}
		netvsc_packet->PageBuffers[j].Pfn =
		netvsc_packet->page_buf[j].Pfn =
		virt_to_phys((void *)(end_virtual -
		bytes_remain)) >> PAGE_SHIFT;
		netvsc_packet->PageBufferCount++;
		netvsc_packet->page_buf_cnt++;
		if (bytes_remain == 0)
		break;
		}
		@@ -1148,16 +1148,16 @@ static void netvsc_receive(struct hv_device *device,
		"(pfn %llx, offset %u, len %u)", i,
		vmxferpage_packet->Ranges[i].ByteOffset,
		vmxferpage_packet->Ranges[i].ByteCount,
		netvsc_packet->PageBuffers[0].Pfn,
		netvsc_packet->PageBuffers[0].Offset,
		netvsc_packet->PageBuffers[0].Length);
		netvsc_packet->page_buf[0].Pfn,
		netvsc_packet->page_buf[0].Offset,
		netvsc_packet->page_buf[0].Length);

		/* Pass it to the upper layer */
		((struct netvsc_driver *)device->Driver)->
		OnReceiveCallback(device, netvsc_packet);
		recv_cb(device, netvsc_packet);

		netvsc_receive_completion(netvsc_packet->
		Completion.Recv.ReceiveCompletionContext);
		completion.recv.recv_completion_ctx);
		}

		/* ASSERT(list_empty(&listHead)); */
		@@ -1213,7 +1213,7 @@ retry_send_cmplt:
		static void netvsc_receive_completion(void *context)
		{
		struct hv_netvsc_packet *packet = context;
		struct hv_device device = (struct hv_device )packet->Device;
		struct hv_device device = (struct hv_device )packet->device;
		struct netvsc_device *net_device;
		u64 transaction_id = 0;
		bool fsend_receive_comp = false;
		@@ -1237,22 +1237,22 @@ static void netvsc_receive_completion(void *context)
		spin_lock_irqsave(&net_device->receive_packet_list_lock, flags);

		/* ASSERT(packet->XferPagePacket->Count > 0); */
		packet->XferPagePacket->Count--;
		packet->xfer_page_pkt->count--;

		/*
		* Last one in the line that represent 1 xfer page packet.
		* Return the xfer page packet itself to the freelist
		*/
		if (packet->XferPagePacket->Count == 0) {
		if (packet->xfer_page_pkt->count == 0) {
		fsend_receive_comp = true;
		transaction_id = packet->Completion.Recv.ReceiveCompletionTid;
		list_add_tail(&packet->XferPagePacket->ListEntry,
		transaction_id = packet->completion.recv.recv_completion_tid;
		list_add_tail(&packet->xfer_page_pkt->list_ent,
		&net_device->ReceivePacketList);

		}

		/* Put the packet back */
		list_add_tail(&packet->ListEntry, &net_device->ReceivePacketList);
		list_add_tail(&packet->list_ent, &net_device->ReceivePacketList);
		spin_unlock_irqrestore(&net_device->receive_packet_list_lock, flags);

		/* Send a receive completion for the xfer page packet */

drivers/staging/hv/netvsc_api.h

+29 −29

Original line number	Diff line number	Diff line
		@@ -32,10 +32,10 @@ struct hv_netvsc_packet;

		/* Represent the xfer page packet which contains 1 or more netvsc packet */
		struct xferpage_packet {
		struct list_head ListEntry;
		struct list_head list_ent;

		/* # of netvsc packets this xfer packet contains */
		u32 Count;
		u32 count;
		};

		/* The number of pages which are enough to cover jumbo frame buffer. */
		@@ -47,65 +47,65 @@ struct xferpage_packet {
		*/
		struct hv_netvsc_packet {
		/* Bookkeeping stuff */
		struct list_head ListEntry;
		struct list_head list_ent;

		struct hv_device *Device;
		bool IsDataPacket;
		struct hv_device *device;
		bool is_data_pkt;

		/*
		* Valid only for receives when we break a xfer page packet
		* into multiple netvsc packets
		*/
		struct xferpage_packet *XferPagePacket;
		struct xferpage_packet *xfer_page_pkt;

		union {
		struct{
		u64 ReceiveCompletionTid;
		void *ReceiveCompletionContext;
		void (OnReceiveCompletion)(void context);
		} Recv;
		u64 recv_completion_tid;
		void *recv_completion_ctx;
		void (recv_completion)(void context);
		} recv;
		struct{
		u64 SendCompletionTid;
		void *SendCompletionContext;
		void (OnSendCompletion)(void context);
		} Send;
		} Completion;
		u64 send_completion_tid;
		void *send_completion_ctx;
		void (send_completion)(void context);
		} send;
		} completion;

		/* This points to the memory after PageBuffers */
		void *Extension;
		/* This points to the memory after page_buf */
		void *extension;

		u32 TotalDataBufferLength;
		u32 total_data_buflen;
		/* Points to the send/receive buffer where the ethernet frame is */
		u32 PageBufferCount;
		struct hv_page_buffer PageBuffers[NETVSC_PACKET_MAXPAGE];
		u32 page_buf_cnt;
		struct hv_page_buffer page_buf[NETVSC_PACKET_MAXPAGE];
		};

		/* Represents the net vsc driver */
		struct netvsc_driver {
		/* Must be the first field */
		/* Which is a bug FIXME! */
		struct hv_driver Base;
		struct hv_driver base;

		u32 RingBufferSize;
		u32 RequestExtSize;
		u32 ring_buf_size;
		u32 req_ext_size;

		/*
		* This is set by the caller to allow us to callback when we
		* receive a packet from the "wire"
		*/
		int (OnReceiveCallback)(struct hv_device dev,
		int (recv_cb)(struct hv_device dev,
		struct hv_netvsc_packet *packet);
		void (OnLinkStatusChanged)(struct hv_device dev, u32 Status);
		void (link_status_change)(struct hv_device dev, u32 Status);

		/* Specific to this driver */
		int (OnSend)(struct hv_device dev, struct hv_netvsc_packet *packet);
		int (send)(struct hv_device dev, struct hv_netvsc_packet *packet);

		void *Context;
		void *ctx;
		};

		struct netvsc_device_info {
		unsigned char MacAddr[6];
		bool LinkState; /* 0 - link up, 1 - link down */
		unsigned char mac_adr[6];
		bool link_state; /* 0 - link up, 1 - link down */
		};

		/* Interface */

drivers/staging/hv/netvsc_drv.c

+37 −37

Original line number	Diff line number	Diff line
		@@ -115,7 +115,7 @@ static void netvsc_xmit_completion(void *context)
		{
		struct hv_netvsc_packet packet = (struct hv_netvsc_packet )context;
		struct sk_buff skb = (struct sk_buff )
		(unsigned long)packet->Completion.Send.SendCompletionTid;
		(unsigned long)packet->completion.send.send_completion_tid;

		kfree(packet);

		@@ -154,7 +154,7 @@ static int netvsc_start_xmit(struct sk_buff skb, struct net_device net)
		/* Allocate a netvsc packet based on # of frags. */
		packet = kzalloc(sizeof(struct hv_netvsc_packet) +
		(num_pages * sizeof(struct hv_page_buffer)) +
		net_drv_obj->RequestExtSize, GFP_ATOMIC);
		net_drv_obj->req_ext_size, GFP_ATOMIC);
		if (!packet) {
		/* out of memory, silently drop packet */
		DPRINT_ERR(NETVSC_DRV, "unable to allocate hv_netvsc_packet");
		@@ -164,40 +164,40 @@ static int netvsc_start_xmit(struct sk_buff skb, struct net_device net)
		return NETDEV_TX_OK;
		}

		packet->Extension = (void *)(unsigned long)packet +
		packet->extension = (void *)(unsigned long)packet +
		sizeof(struct hv_netvsc_packet) +
		(num_pages * sizeof(struct hv_page_buffer));

		/* Setup the rndis header */
		packet->PageBufferCount = num_pages;
		packet->page_buf_cnt = num_pages;

		/* TODO: Flush all write buffers/ memory fence ??? */
		/* wmb(); */

		/* Initialize it from the skb */
		packet->TotalDataBufferLength = skb->len;
		packet->total_data_buflen = skb->len;

		/* Start filling in the page buffers starting after RNDIS buffer. */
		packet->PageBuffers[1].Pfn = virt_to_phys(skb->data) >> PAGE_SHIFT;
		packet->PageBuffers[1].Offset
		packet->page_buf[1].Pfn = virt_to_phys(skb->data) >> PAGE_SHIFT;
		packet->page_buf[1].Offset
		= (unsigned long)skb->data & (PAGE_SIZE - 1);
		packet->PageBuffers[1].Length = skb_headlen(skb);
		packet->page_buf[1].Length = skb_headlen(skb);

		/* Additional fragments are after SKB data */
		for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
		skb_frag_t *f = &skb_shinfo(skb)->frags[i];

		packet->PageBuffers[i+2].Pfn = page_to_pfn(f->page);
		packet->PageBuffers[i+2].Offset = f->page_offset;
		packet->PageBuffers[i+2].Length = f->size;
		packet->page_buf[i+2].Pfn = page_to_pfn(f->page);
		packet->page_buf[i+2].Offset = f->page_offset;
		packet->page_buf[i+2].Length = f->size;
		}

		/* Set the completion routine */
		packet->Completion.Send.OnSendCompletion = netvsc_xmit_completion;
		packet->Completion.Send.SendCompletionContext = packet;
		packet->Completion.Send.SendCompletionTid = (unsigned long)skb;
		packet->completion.send.send_completion = netvsc_xmit_completion;
		packet->completion.send.send_completion_ctx = packet;
		packet->completion.send.send_completion_tid = (unsigned long)skb;

		ret = net_drv_obj->OnSend(&net_device_ctx->device_ctx->device_obj,
		ret = net_drv_obj->send(&net_device_ctx->device_ctx->device_obj,
		packet);
		if (ret == 0) {
		net->stats.tx_bytes += skb->len;
		@@ -263,7 +263,7 @@ static int netvsc_recv_callback(struct hv_device *device_obj,
		}

		/* Allocate a skb - TODO direct I/O to pages? */
		skb = netdev_alloc_skb_ip_align(net, packet->TotalDataBufferLength);
		skb = netdev_alloc_skb_ip_align(net, packet->total_data_buflen);
		if (unlikely(!skb)) {
		++net->stats.rx_dropped;
		return 0;
		@@ -276,17 +276,17 @@ static int netvsc_recv_callback(struct hv_device *device_obj,
		* Copy to skb. This copy is needed here since the memory pointed by
		* hv_netvsc_packet cannot be deallocated
		*/
		for (i = 0; i < packet->PageBufferCount; i++) {
		data = kmap_atomic(pfn_to_page(packet->PageBuffers[i].Pfn),
		for (i = 0; i < packet->page_buf_cnt; i++) {
		data = kmap_atomic(pfn_to_page(packet->page_buf[i].Pfn),
		KM_IRQ1);
		data = (void *)(unsigned long)data +
		packet->PageBuffers[i].Offset;
		packet->page_buf[i].Offset;

		memcpy(skb_put(skb, packet->PageBuffers[i].Length), data,
		packet->PageBuffers[i].Length);
		memcpy(skb_put(skb, packet->page_buf[i].Length), data,
		packet->page_buf[i].Length);

		kunmap_atomic((void *)((unsigned long)data -
		packet->PageBuffers[i].Offset), KM_IRQ1);
		packet->page_buf[i].Offset), KM_IRQ1);
		}

		local_irq_restore(flags);
		@@ -349,7 +349,7 @@ static int netvsc_probe(struct device *device)
		struct netvsc_device_info device_info;
		int ret;

		if (!net_drv_obj->Base.OnDeviceAdd)
		if (!net_drv_obj->base.OnDeviceAdd)
		return -1;

		net = alloc_etherdev(sizeof(struct net_device_context));
		@@ -366,7 +366,7 @@ static int netvsc_probe(struct device *device)
		dev_set_drvdata(device, net);

		/* Notify the netvsc driver of the new device */
		ret = net_drv_obj->Base.OnDeviceAdd(device_obj, &device_info);
		ret = net_drv_obj->base.OnDeviceAdd(device_obj, &device_info);
		if (ret != 0) {
		free_netdev(net);
		dev_set_drvdata(device, NULL);
		@@ -385,10 +385,10 @@ static int netvsc_probe(struct device *device)
		* out of sync with the device's link status
		*/
		if (!netif_carrier_ok(net))
		if (!device_info.LinkState)
		if (!device_info.link_state)
		netif_carrier_on(net);

		memcpy(net->dev_addr, device_info.MacAddr, ETH_ALEN);
		memcpy(net->dev_addr, device_info.mac_adr, ETH_ALEN);

		net->netdev_ops = &device_ops;

		@@ -401,7 +401,7 @@ static int netvsc_probe(struct device *device)
		ret = register_netdev(net);
		if (ret != 0) {
		/* Remove the device and release the resource */
		net_drv_obj->Base.OnDeviceRemove(device_obj);
		net_drv_obj->base.OnDeviceRemove(device_obj);
		free_netdev(net);
		}

		@@ -425,7 +425,7 @@ static int netvsc_remove(struct device *device)
		return 0;
		}

		if (!net_drv_obj->Base.OnDeviceRemove)
		if (!net_drv_obj->base.OnDeviceRemove)
		return -1;

		/* Stop outbound asap */
		@@ -438,7 +438,7 @@ static int netvsc_remove(struct device *device)
		* Call to the vsc driver to let it know that the device is being
		* removed
		*/
		ret = net_drv_obj->Base.OnDeviceRemove(device_obj);
		ret = net_drv_obj->base.OnDeviceRemove(device_obj);
		if (ret != 0) {
		/* TODO: */
		DPRINT_ERR(NETVSC, "unable to remove vsc device (ret %d)", ret);
		@@ -484,8 +484,8 @@ static void netvsc_drv_exit(void)
		device_unregister(current_dev);
		}

		if (netvsc_drv_obj->Base.OnCleanup)
		netvsc_drv_obj->Base.OnCleanup(&netvsc_drv_obj->Base);
		if (netvsc_drv_obj->base.OnCleanup)
		netvsc_drv_obj->base.OnCleanup(&netvsc_drv_obj->base);

		vmbus_child_driver_unregister(drv_ctx);

		@@ -498,15 +498,15 @@ static int netvsc_drv_init(int (drv_init)(struct hv_driver drv))
		struct driver_context *drv_ctx = &g_netvsc_drv.drv_ctx;
		int ret;

		net_drv_obj->RingBufferSize = ring_size * PAGE_SIZE;
		net_drv_obj->OnReceiveCallback = netvsc_recv_callback;
		net_drv_obj->OnLinkStatusChanged = netvsc_linkstatus_callback;
		net_drv_obj->ring_buf_size = ring_size * PAGE_SIZE;
		net_drv_obj->recv_cb = netvsc_recv_callback;
		net_drv_obj->link_status_change = netvsc_linkstatus_callback;

		/* Callback to client driver to complete the initialization */
		drv_init(&net_drv_obj->Base);
		drv_init(&net_drv_obj->base);

		drv_ctx->driver.name = net_drv_obj->Base.name;
		memcpy(&drv_ctx->class_id, &net_drv_obj->Base.deviceType,
		drv_ctx->driver.name = net_drv_obj->base.name;
		memcpy(&drv_ctx->class_id, &net_drv_obj->base.deviceType,
		sizeof(struct hv_guid));

		drv_ctx->probe = netvsc_probe;

drivers/staging/hv/rndis_filter.c

+56 −56

File changed.

Preview size limit exceeded, changes collapsed.