xref: /linux/drivers/net/hyperv/netvsc.c (revision 00a6d7b6762c27d441e9ac8faff36384bc0fc180)
1 /*
2  * Copyright (c) 2009, Microsoft Corporation.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License along with
14  * this program; if not, see <http://www.gnu.org/licenses/>.
15  *
16  * Authors:
17  *   Haiyang Zhang <haiyangz@microsoft.com>
18  *   Hank Janssen  <hjanssen@microsoft.com>
19  */
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21 
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/wait.h>
25 #include <linux/mm.h>
26 #include <linux/delay.h>
27 #include <linux/io.h>
28 #include <linux/slab.h>
29 #include <linux/netdevice.h>
30 #include <linux/if_ether.h>
31 
32 #include "hyperv_net.h"
33 
34 
35 static struct netvsc_device *alloc_net_device(struct hv_device *device)
36 {
37 	struct netvsc_device *net_device;
38 	struct net_device *ndev = hv_get_drvdata(device);
39 
40 	net_device = kzalloc(sizeof(struct netvsc_device), GFP_KERNEL);
41 	if (!net_device)
42 		return NULL;
43 
44 	init_waitqueue_head(&net_device->wait_drain);
45 	net_device->start_remove = false;
46 	net_device->destroy = false;
47 	net_device->dev = device;
48 	net_device->ndev = ndev;
49 
50 	hv_set_drvdata(device, net_device);
51 	return net_device;
52 }
53 
54 static struct netvsc_device *get_outbound_net_device(struct hv_device *device)
55 {
56 	struct netvsc_device *net_device;
57 
58 	net_device = hv_get_drvdata(device);
59 	if (net_device && net_device->destroy)
60 		net_device = NULL;
61 
62 	return net_device;
63 }
64 
65 static struct netvsc_device *get_inbound_net_device(struct hv_device *device)
66 {
67 	struct netvsc_device *net_device;
68 
69 	net_device = hv_get_drvdata(device);
70 
71 	if (!net_device)
72 		goto get_in_err;
73 
74 	if (net_device->destroy &&
75 		atomic_read(&net_device->num_outstanding_sends) == 0)
76 		net_device = NULL;
77 
78 get_in_err:
79 	return net_device;
80 }
81 
82 
83 static int netvsc_destroy_recv_buf(struct netvsc_device *net_device)
84 {
85 	struct nvsp_message *revoke_packet;
86 	int ret = 0;
87 	struct net_device *ndev = net_device->ndev;
88 
89 	/*
90 	 * If we got a section count, it means we received a
91 	 * SendReceiveBufferComplete msg (ie sent
92 	 * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
93 	 * to send a revoke msg here
94 	 */
95 	if (net_device->recv_section_cnt) {
96 		/* Send the revoke receive buffer */
97 		revoke_packet = &net_device->revoke_packet;
98 		memset(revoke_packet, 0, sizeof(struct nvsp_message));
99 
100 		revoke_packet->hdr.msg_type =
101 			NVSP_MSG1_TYPE_REVOKE_RECV_BUF;
102 		revoke_packet->msg.v1_msg.
103 		revoke_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
104 
105 		ret = vmbus_sendpacket(net_device->dev->channel,
106 				       revoke_packet,
107 				       sizeof(struct nvsp_message),
108 				       (unsigned long)revoke_packet,
109 				       VM_PKT_DATA_INBAND, 0);
110 		/*
111 		 * If we failed here, we might as well return and
112 		 * have a leak rather than continue and a bugchk
113 		 */
114 		if (ret != 0) {
115 			netdev_err(ndev, "unable to send "
116 				"revoke receive buffer to netvsp\n");
117 			return ret;
118 		}
119 	}
120 
121 	/* Teardown the gpadl on the vsp end */
122 	if (net_device->recv_buf_gpadl_handle) {
123 		ret = vmbus_teardown_gpadl(net_device->dev->channel,
124 			   net_device->recv_buf_gpadl_handle);
125 
126 		/* If we failed here, we might as well return and have a leak
127 		 * rather than continue and a bugchk
128 		 */
129 		if (ret != 0) {
130 			netdev_err(ndev,
131 				   "unable to teardown receive buffer's gpadl\n");
132 			return ret;
133 		}
134 		net_device->recv_buf_gpadl_handle = 0;
135 	}
136 
137 	if (net_device->recv_buf) {
138 		/* Free up the receive buffer */
139 		vfree(net_device->recv_buf);
140 		net_device->recv_buf = NULL;
141 	}
142 
143 	if (net_device->recv_section) {
144 		net_device->recv_section_cnt = 0;
145 		kfree(net_device->recv_section);
146 		net_device->recv_section = NULL;
147 	}
148 
149 	return ret;
150 }
151 
152 static int netvsc_init_recv_buf(struct hv_device *device)
153 {
154 	int ret = 0;
155 	int t;
156 	struct netvsc_device *net_device;
157 	struct nvsp_message *init_packet;
158 	struct net_device *ndev;
159 
160 	net_device = get_outbound_net_device(device);
161 	if (!net_device)
162 		return -ENODEV;
163 	ndev = net_device->ndev;
164 
165 	net_device->recv_buf = vzalloc(net_device->recv_buf_size);
166 	if (!net_device->recv_buf) {
167 		netdev_err(ndev, "unable to allocate receive "
168 			"buffer of size %d\n", net_device->recv_buf_size);
169 		ret = -ENOMEM;
170 		goto cleanup;
171 	}
172 
173 	/*
174 	 * Establish the gpadl handle for this buffer on this
175 	 * channel.  Note: This call uses the vmbus connection rather
176 	 * than the channel to establish the gpadl handle.
177 	 */
178 	ret = vmbus_establish_gpadl(device->channel, net_device->recv_buf,
179 				    net_device->recv_buf_size,
180 				    &net_device->recv_buf_gpadl_handle);
181 	if (ret != 0) {
182 		netdev_err(ndev,
183 			"unable to establish receive buffer's gpadl\n");
184 		goto cleanup;
185 	}
186 
187 
188 	/* Notify the NetVsp of the gpadl handle */
189 	init_packet = &net_device->channel_init_pkt;
190 
191 	memset(init_packet, 0, sizeof(struct nvsp_message));
192 
193 	init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_RECV_BUF;
194 	init_packet->msg.v1_msg.send_recv_buf.
195 		gpadl_handle = net_device->recv_buf_gpadl_handle;
196 	init_packet->msg.v1_msg.
197 		send_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
198 
199 	/* Send the gpadl notification request */
200 	ret = vmbus_sendpacket(device->channel, init_packet,
201 			       sizeof(struct nvsp_message),
202 			       (unsigned long)init_packet,
203 			       VM_PKT_DATA_INBAND,
204 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
205 	if (ret != 0) {
206 		netdev_err(ndev,
207 			"unable to send receive buffer's gpadl to netvsp\n");
208 		goto cleanup;
209 	}
210 
211 	t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
212 	BUG_ON(t == 0);
213 
214 
215 	/* Check the response */
216 	if (init_packet->msg.v1_msg.
217 	    send_recv_buf_complete.status != NVSP_STAT_SUCCESS) {
218 		netdev_err(ndev, "Unable to complete receive buffer "
219 			   "initialization with NetVsp - status %d\n",
220 			   init_packet->msg.v1_msg.
221 			   send_recv_buf_complete.status);
222 		ret = -EINVAL;
223 		goto cleanup;
224 	}
225 
226 	/* Parse the response */
227 
228 	net_device->recv_section_cnt = init_packet->msg.
229 		v1_msg.send_recv_buf_complete.num_sections;
230 
231 	net_device->recv_section = kmemdup(
232 		init_packet->msg.v1_msg.send_recv_buf_complete.sections,
233 		net_device->recv_section_cnt *
234 		sizeof(struct nvsp_1_receive_buffer_section),
235 		GFP_KERNEL);
236 	if (net_device->recv_section == NULL) {
237 		ret = -EINVAL;
238 		goto cleanup;
239 	}
240 
241 	/*
242 	 * For 1st release, there should only be 1 section that represents the
243 	 * entire receive buffer
244 	 */
245 	if (net_device->recv_section_cnt != 1 ||
246 	    net_device->recv_section->offset != 0) {
247 		ret = -EINVAL;
248 		goto cleanup;
249 	}
250 
251 	goto exit;
252 
253 cleanup:
254 	netvsc_destroy_recv_buf(net_device);
255 
256 exit:
257 	return ret;
258 }
259 
260 
261 /* Negotiate NVSP protocol version */
262 static int negotiate_nvsp_ver(struct hv_device *device,
263 			      struct netvsc_device *net_device,
264 			      struct nvsp_message *init_packet,
265 			      u32 nvsp_ver)
266 {
267 	int ret, t;
268 
269 	memset(init_packet, 0, sizeof(struct nvsp_message));
270 	init_packet->hdr.msg_type = NVSP_MSG_TYPE_INIT;
271 	init_packet->msg.init_msg.init.min_protocol_ver = nvsp_ver;
272 	init_packet->msg.init_msg.init.max_protocol_ver = nvsp_ver;
273 
274 	/* Send the init request */
275 	ret = vmbus_sendpacket(device->channel, init_packet,
276 			       sizeof(struct nvsp_message),
277 			       (unsigned long)init_packet,
278 			       VM_PKT_DATA_INBAND,
279 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
280 
281 	if (ret != 0)
282 		return ret;
283 
284 	t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
285 
286 	if (t == 0)
287 		return -ETIMEDOUT;
288 
289 	if (init_packet->msg.init_msg.init_complete.status !=
290 	    NVSP_STAT_SUCCESS)
291 		return -EINVAL;
292 
293 	if (nvsp_ver == NVSP_PROTOCOL_VERSION_1)
294 		return 0;
295 
296 	/* NVSPv2 only: Send NDIS config */
297 	memset(init_packet, 0, sizeof(struct nvsp_message));
298 	init_packet->hdr.msg_type = NVSP_MSG2_TYPE_SEND_NDIS_CONFIG;
299 	init_packet->msg.v2_msg.send_ndis_config.mtu = net_device->ndev->mtu;
300 	init_packet->msg.v2_msg.send_ndis_config.capability.ieee8021q = 1;
301 
302 	ret = vmbus_sendpacket(device->channel, init_packet,
303 				sizeof(struct nvsp_message),
304 				(unsigned long)init_packet,
305 				VM_PKT_DATA_INBAND, 0);
306 
307 	return ret;
308 }
309 
310 static int netvsc_connect_vsp(struct hv_device *device)
311 {
312 	int ret;
313 	struct netvsc_device *net_device;
314 	struct nvsp_message *init_packet;
315 	int ndis_version;
316 	struct net_device *ndev;
317 	u32 ver_list[] = { NVSP_PROTOCOL_VERSION_1, NVSP_PROTOCOL_VERSION_2,
318 		NVSP_PROTOCOL_VERSION_4, NVSP_PROTOCOL_VERSION_5 };
319 	int i, num_ver = 4; /* number of different NVSP versions */
320 
321 	net_device = get_outbound_net_device(device);
322 	if (!net_device)
323 		return -ENODEV;
324 	ndev = net_device->ndev;
325 
326 	init_packet = &net_device->channel_init_pkt;
327 
328 	/* Negotiate the latest NVSP protocol supported */
329 	for (i = num_ver - 1; i >= 0; i--)
330 		if (negotiate_nvsp_ver(device, net_device, init_packet,
331 				       ver_list[i])  == 0) {
332 			net_device->nvsp_version = ver_list[i];
333 			break;
334 		}
335 
336 	if (i < 0) {
337 		ret = -EPROTO;
338 		goto cleanup;
339 	}
340 
341 	pr_debug("Negotiated NVSP version:%x\n", net_device->nvsp_version);
342 
343 	/* Send the ndis version */
344 	memset(init_packet, 0, sizeof(struct nvsp_message));
345 
346 	if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_4)
347 		ndis_version = 0x00060001;
348 	else
349 		ndis_version = 0x0006001e;
350 
351 	init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_NDIS_VER;
352 	init_packet->msg.v1_msg.
353 		send_ndis_ver.ndis_major_ver =
354 				(ndis_version & 0xFFFF0000) >> 16;
355 	init_packet->msg.v1_msg.
356 		send_ndis_ver.ndis_minor_ver =
357 				ndis_version & 0xFFFF;
358 
359 	/* Send the init request */
360 	ret = vmbus_sendpacket(device->channel, init_packet,
361 				sizeof(struct nvsp_message),
362 				(unsigned long)init_packet,
363 				VM_PKT_DATA_INBAND, 0);
364 	if (ret != 0)
365 		goto cleanup;
366 
367 	/* Post the big receive buffer to NetVSP */
368 	if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_2)
369 		net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE_LEGACY;
370 	else
371 		net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE;
372 
373 	ret = netvsc_init_recv_buf(device);
374 
375 cleanup:
376 	return ret;
377 }
378 
379 static void netvsc_disconnect_vsp(struct netvsc_device *net_device)
380 {
381 	netvsc_destroy_recv_buf(net_device);
382 }
383 
384 /*
385  * netvsc_device_remove - Callback when the root bus device is removed
386  */
387 int netvsc_device_remove(struct hv_device *device)
388 {
389 	struct netvsc_device *net_device;
390 	struct hv_netvsc_packet *netvsc_packet, *pos;
391 	unsigned long flags;
392 
393 	net_device = hv_get_drvdata(device);
394 
395 	netvsc_disconnect_vsp(net_device);
396 
397 	/*
398 	 * Since we have already drained, we don't need to busy wait
399 	 * as was done in final_release_stor_device()
400 	 * Note that we cannot set the ext pointer to NULL until
401 	 * we have drained - to drain the outgoing packets, we need to
402 	 * allow incoming packets.
403 	 */
404 
405 	spin_lock_irqsave(&device->channel->inbound_lock, flags);
406 	hv_set_drvdata(device, NULL);
407 	spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
408 
409 	/*
410 	 * At this point, no one should be accessing net_device
411 	 * except in here
412 	 */
413 	dev_notice(&device->device, "net device safe to remove\n");
414 
415 	/* Now, we can close the channel safely */
416 	vmbus_close(device->channel);
417 
418 	/* Release all resources */
419 	list_for_each_entry_safe(netvsc_packet, pos,
420 				 &net_device->recv_pkt_list, list_ent) {
421 		list_del(&netvsc_packet->list_ent);
422 		kfree(netvsc_packet);
423 	}
424 
425 	kfree(net_device);
426 	return 0;
427 }
428 
429 
430 #define RING_AVAIL_PERCENT_HIWATER 20
431 #define RING_AVAIL_PERCENT_LOWATER 10
432 
433 /*
434  * Get the percentage of available bytes to write in the ring.
435  * The return value is in range from 0 to 100.
436  */
437 static inline u32 hv_ringbuf_avail_percent(
438 		struct hv_ring_buffer_info *ring_info)
439 {
440 	u32 avail_read, avail_write;
441 
442 	hv_get_ringbuffer_availbytes(ring_info, &avail_read, &avail_write);
443 
444 	return avail_write * 100 / ring_info->ring_datasize;
445 }
446 
447 static void netvsc_send_completion(struct netvsc_device *net_device,
448 				   struct hv_device *device,
449 				   struct vmpacket_descriptor *packet)
450 {
451 	struct nvsp_message *nvsp_packet;
452 	struct hv_netvsc_packet *nvsc_packet;
453 	struct net_device *ndev;
454 
455 	ndev = net_device->ndev;
456 
457 	nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
458 			(packet->offset8 << 3));
459 
460 	if ((nvsp_packet->hdr.msg_type == NVSP_MSG_TYPE_INIT_COMPLETE) ||
461 	    (nvsp_packet->hdr.msg_type ==
462 	     NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE) ||
463 	    (nvsp_packet->hdr.msg_type ==
464 	     NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE)) {
465 		/* Copy the response back */
466 		memcpy(&net_device->channel_init_pkt, nvsp_packet,
467 		       sizeof(struct nvsp_message));
468 		complete(&net_device->channel_init_wait);
469 	} else if (nvsp_packet->hdr.msg_type ==
470 		   NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE) {
471 		int num_outstanding_sends;
472 
473 		/* Get the send context */
474 		nvsc_packet = (struct hv_netvsc_packet *)(unsigned long)
475 			packet->trans_id;
476 
477 		/* Notify the layer above us */
478 		if (nvsc_packet)
479 			nvsc_packet->completion.send.send_completion(
480 				nvsc_packet->completion.send.
481 				send_completion_ctx);
482 
483 		num_outstanding_sends =
484 			atomic_dec_return(&net_device->num_outstanding_sends);
485 
486 		if (net_device->destroy && num_outstanding_sends == 0)
487 			wake_up(&net_device->wait_drain);
488 
489 		if (netif_queue_stopped(ndev) && !net_device->start_remove &&
490 			(hv_ringbuf_avail_percent(&device->channel->outbound)
491 			> RING_AVAIL_PERCENT_HIWATER ||
492 			num_outstanding_sends < 1))
493 				netif_wake_queue(ndev);
494 	} else {
495 		netdev_err(ndev, "Unknown send completion packet type- "
496 			   "%d received!!\n", nvsp_packet->hdr.msg_type);
497 	}
498 
499 }
500 
501 int netvsc_send(struct hv_device *device,
502 			struct hv_netvsc_packet *packet)
503 {
504 	struct netvsc_device *net_device;
505 	int ret = 0;
506 	struct nvsp_message sendMessage;
507 	struct net_device *ndev;
508 	u64 req_id;
509 
510 	net_device = get_outbound_net_device(device);
511 	if (!net_device)
512 		return -ENODEV;
513 	ndev = net_device->ndev;
514 
515 	sendMessage.hdr.msg_type = NVSP_MSG1_TYPE_SEND_RNDIS_PKT;
516 	if (packet->is_data_pkt) {
517 		/* 0 is RMC_DATA; */
518 		sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 0;
519 	} else {
520 		/* 1 is RMC_CONTROL; */
521 		sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 1;
522 	}
523 
524 	/* Not using send buffer section */
525 	sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_index =
526 		0xFFFFFFFF;
527 	sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_size = 0;
528 
529 	if (packet->completion.send.send_completion)
530 		req_id = (ulong)packet;
531 	else
532 		req_id = 0;
533 
534 	if (packet->page_buf_cnt) {
535 		ret = vmbus_sendpacket_pagebuffer(device->channel,
536 						  packet->page_buf,
537 						  packet->page_buf_cnt,
538 						  &sendMessage,
539 						  sizeof(struct nvsp_message),
540 						  req_id);
541 	} else {
542 		ret = vmbus_sendpacket(device->channel, &sendMessage,
543 				sizeof(struct nvsp_message),
544 				req_id,
545 				VM_PKT_DATA_INBAND,
546 				VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
547 	}
548 
549 	if (ret == 0) {
550 		atomic_inc(&net_device->num_outstanding_sends);
551 		if (hv_ringbuf_avail_percent(&device->channel->outbound) <
552 			RING_AVAIL_PERCENT_LOWATER) {
553 			netif_stop_queue(ndev);
554 			if (atomic_read(&net_device->
555 				num_outstanding_sends) < 1)
556 				netif_wake_queue(ndev);
557 		}
558 	} else if (ret == -EAGAIN) {
559 		netif_stop_queue(ndev);
560 		if (atomic_read(&net_device->num_outstanding_sends) < 1) {
561 			netif_wake_queue(ndev);
562 			ret = -ENOSPC;
563 		}
564 	} else {
565 		netdev_err(ndev, "Unable to send packet %p ret %d\n",
566 			   packet, ret);
567 	}
568 
569 	return ret;
570 }
571 
572 static void netvsc_send_recv_completion(struct hv_device *device,
573 					struct netvsc_device *net_device,
574 					u64 transaction_id, u32 status)
575 {
576 	struct nvsp_message recvcompMessage;
577 	int retries = 0;
578 	int ret;
579 	struct net_device *ndev;
580 
581 	ndev = net_device->ndev;
582 
583 	recvcompMessage.hdr.msg_type =
584 				NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE;
585 
586 	recvcompMessage.msg.v1_msg.send_rndis_pkt_complete.status = status;
587 
588 retry_send_cmplt:
589 	/* Send the completion */
590 	ret = vmbus_sendpacket(device->channel, &recvcompMessage,
591 			       sizeof(struct nvsp_message), transaction_id,
592 			       VM_PKT_COMP, 0);
593 	if (ret == 0) {
594 		/* success */
595 		/* no-op */
596 	} else if (ret == -EAGAIN) {
597 		/* no more room...wait a bit and attempt to retry 3 times */
598 		retries++;
599 		netdev_err(ndev, "unable to send receive completion pkt"
600 			" (tid %llx)...retrying %d\n", transaction_id, retries);
601 
602 		if (retries < 4) {
603 			udelay(100);
604 			goto retry_send_cmplt;
605 		} else {
606 			netdev_err(ndev, "unable to send receive "
607 				"completion pkt (tid %llx)...give up retrying\n",
608 				transaction_id);
609 		}
610 	} else {
611 		netdev_err(ndev, "unable to send receive "
612 			"completion pkt - %llx\n", transaction_id);
613 	}
614 }
615 
616 /* Send a receive completion packet to RNDIS device (ie NetVsp) */
617 static void netvsc_receive_completion(void *context)
618 {
619 	struct hv_netvsc_packet *packet = context;
620 	struct hv_device *device = packet->device;
621 	struct netvsc_device *net_device;
622 	u64 transaction_id = 0;
623 	bool fsend_receive_comp = false;
624 	unsigned long flags;
625 	struct net_device *ndev;
626 	u32 status = NVSP_STAT_NONE;
627 
628 	/*
629 	 * Even though it seems logical to do a GetOutboundNetDevice() here to
630 	 * send out receive completion, we are using GetInboundNetDevice()
631 	 * since we may have disable outbound traffic already.
632 	 */
633 	net_device = get_inbound_net_device(device);
634 	if (!net_device)
635 		return;
636 	ndev = net_device->ndev;
637 
638 	/* Overloading use of the lock. */
639 	spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
640 
641 	if (packet->status != NVSP_STAT_SUCCESS)
642 		packet->xfer_page_pkt->status = NVSP_STAT_FAIL;
643 
644 	packet->xfer_page_pkt->count--;
645 
646 	/*
647 	 * Last one in the line that represent 1 xfer page packet.
648 	 * Return the xfer page packet itself to the freelist
649 	 */
650 	if (packet->xfer_page_pkt->count == 0) {
651 		fsend_receive_comp = true;
652 		transaction_id = packet->completion.recv.recv_completion_tid;
653 		status = packet->xfer_page_pkt->status;
654 		list_add_tail(&packet->xfer_page_pkt->list_ent,
655 			      &net_device->recv_pkt_list);
656 
657 	}
658 
659 	/* Put the packet back */
660 	list_add_tail(&packet->list_ent, &net_device->recv_pkt_list);
661 	spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags);
662 
663 	/* Send a receive completion for the xfer page packet */
664 	if (fsend_receive_comp)
665 		netvsc_send_recv_completion(device, net_device, transaction_id,
666 					status);
667 
668 }
669 
670 static void netvsc_receive(struct netvsc_device *net_device,
671 			struct hv_device *device,
672 			struct vmpacket_descriptor *packet)
673 {
674 	struct vmtransfer_page_packet_header *vmxferpage_packet;
675 	struct nvsp_message *nvsp_packet;
676 	struct hv_netvsc_packet *netvsc_packet = NULL;
677 	/* struct netvsc_driver *netvscDriver; */
678 	struct xferpage_packet *xferpage_packet = NULL;
679 	int i;
680 	int count = 0;
681 	unsigned long flags;
682 	struct net_device *ndev;
683 
684 	LIST_HEAD(listHead);
685 
686 	ndev = net_device->ndev;
687 
688 	/*
689 	 * All inbound packets other than send completion should be xfer page
690 	 * packet
691 	 */
692 	if (packet->type != VM_PKT_DATA_USING_XFER_PAGES) {
693 		netdev_err(ndev, "Unknown packet type received - %d\n",
694 			   packet->type);
695 		return;
696 	}
697 
698 	nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
699 			(packet->offset8 << 3));
700 
701 	/* Make sure this is a valid nvsp packet */
702 	if (nvsp_packet->hdr.msg_type !=
703 	    NVSP_MSG1_TYPE_SEND_RNDIS_PKT) {
704 		netdev_err(ndev, "Unknown nvsp packet type received-"
705 			" %d\n", nvsp_packet->hdr.msg_type);
706 		return;
707 	}
708 
709 	vmxferpage_packet = (struct vmtransfer_page_packet_header *)packet;
710 
711 	if (vmxferpage_packet->xfer_pageset_id != NETVSC_RECEIVE_BUFFER_ID) {
712 		netdev_err(ndev, "Invalid xfer page set id - "
713 			   "expecting %x got %x\n", NETVSC_RECEIVE_BUFFER_ID,
714 			   vmxferpage_packet->xfer_pageset_id);
715 		return;
716 	}
717 
718 	/*
719 	 * Grab free packets (range count + 1) to represent this xfer
720 	 * page packet. +1 to represent the xfer page packet itself.
721 	 * We grab it here so that we know exactly how many we can
722 	 * fulfil
723 	 */
724 	spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
725 	while (!list_empty(&net_device->recv_pkt_list)) {
726 		list_move_tail(net_device->recv_pkt_list.next, &listHead);
727 		if (++count == vmxferpage_packet->range_cnt + 1)
728 			break;
729 	}
730 	spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags);
731 
732 	/*
733 	 * We need at least 2 netvsc pkts (1 to represent the xfer
734 	 * page and at least 1 for the range) i.e. we can handled
735 	 * some of the xfer page packet ranges...
736 	 */
737 	if (count < 2) {
738 		netdev_err(ndev, "Got only %d netvsc pkt...needed "
739 			"%d pkts. Dropping this xfer page packet completely!\n",
740 			count, vmxferpage_packet->range_cnt + 1);
741 
742 		/* Return it to the freelist */
743 		spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
744 		for (i = count; i != 0; i--) {
745 			list_move_tail(listHead.next,
746 				       &net_device->recv_pkt_list);
747 		}
748 		spin_unlock_irqrestore(&net_device->recv_pkt_list_lock,
749 				       flags);
750 
751 		netvsc_send_recv_completion(device, net_device,
752 					    vmxferpage_packet->d.trans_id,
753 					    NVSP_STAT_FAIL);
754 
755 		return;
756 	}
757 
758 	/* Remove the 1st packet to represent the xfer page packet itself */
759 	xferpage_packet = (struct xferpage_packet *)listHead.next;
760 	list_del(&xferpage_packet->list_ent);
761 	xferpage_packet->status = NVSP_STAT_SUCCESS;
762 
763 	/* This is how much we can satisfy */
764 	xferpage_packet->count = count - 1;
765 
766 	if (xferpage_packet->count != vmxferpage_packet->range_cnt) {
767 		netdev_err(ndev, "Needed %d netvsc pkts to satisfy "
768 			"this xfer page...got %d\n",
769 			vmxferpage_packet->range_cnt, xferpage_packet->count);
770 	}
771 
772 	/* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
773 	for (i = 0; i < (count - 1); i++) {
774 		netvsc_packet = (struct hv_netvsc_packet *)listHead.next;
775 		list_del(&netvsc_packet->list_ent);
776 
777 		/* Initialize the netvsc packet */
778 		netvsc_packet->status = NVSP_STAT_SUCCESS;
779 		netvsc_packet->xfer_page_pkt = xferpage_packet;
780 		netvsc_packet->completion.recv.recv_completion =
781 					netvsc_receive_completion;
782 		netvsc_packet->completion.recv.recv_completion_ctx =
783 					netvsc_packet;
784 		netvsc_packet->device = device;
785 		/* Save this so that we can send it back */
786 		netvsc_packet->completion.recv.recv_completion_tid =
787 					vmxferpage_packet->d.trans_id;
788 
789 		netvsc_packet->data = (void *)((unsigned long)net_device->
790 			recv_buf + vmxferpage_packet->ranges[i].byte_offset);
791 		netvsc_packet->total_data_buflen =
792 					vmxferpage_packet->ranges[i].byte_count;
793 
794 		/* Pass it to the upper layer */
795 		rndis_filter_receive(device, netvsc_packet);
796 
797 		netvsc_receive_completion(netvsc_packet->
798 				completion.recv.recv_completion_ctx);
799 	}
800 
801 }
802 
803 static void netvsc_channel_cb(void *context)
804 {
805 	int ret;
806 	struct hv_device *device = context;
807 	struct netvsc_device *net_device;
808 	u32 bytes_recvd;
809 	u64 request_id;
810 	struct vmpacket_descriptor *desc;
811 	unsigned char *buffer;
812 	int bufferlen = NETVSC_PACKET_SIZE;
813 	struct net_device *ndev;
814 
815 	net_device = get_inbound_net_device(device);
816 	if (!net_device)
817 		return;
818 	ndev = net_device->ndev;
819 	buffer = net_device->cb_buffer;
820 
821 	do {
822 		ret = vmbus_recvpacket_raw(device->channel, buffer, bufferlen,
823 					   &bytes_recvd, &request_id);
824 		if (ret == 0) {
825 			if (bytes_recvd > 0) {
826 				desc = (struct vmpacket_descriptor *)buffer;
827 				switch (desc->type) {
828 				case VM_PKT_COMP:
829 					netvsc_send_completion(net_device,
830 								device, desc);
831 					break;
832 
833 				case VM_PKT_DATA_USING_XFER_PAGES:
834 					netvsc_receive(net_device,
835 							device, desc);
836 					break;
837 
838 				default:
839 					netdev_err(ndev,
840 						   "unhandled packet type %d, "
841 						   "tid %llx len %d\n",
842 						   desc->type, request_id,
843 						   bytes_recvd);
844 					break;
845 				}
846 
847 			} else {
848 				/*
849 				 * We are done for this pass.
850 				 */
851 				break;
852 			}
853 
854 		} else if (ret == -ENOBUFS) {
855 			if (bufferlen > NETVSC_PACKET_SIZE)
856 				kfree(buffer);
857 			/* Handle large packet */
858 			buffer = kmalloc(bytes_recvd, GFP_ATOMIC);
859 			if (buffer == NULL) {
860 				/* Try again next time around */
861 				netdev_err(ndev,
862 					   "unable to allocate buffer of size "
863 					   "(%d)!!\n", bytes_recvd);
864 				break;
865 			}
866 
867 			bufferlen = bytes_recvd;
868 		}
869 	} while (1);
870 
871 	if (bufferlen > NETVSC_PACKET_SIZE)
872 		kfree(buffer);
873 	return;
874 }
875 
876 /*
877  * netvsc_device_add - Callback when the device belonging to this
878  * driver is added
879  */
880 int netvsc_device_add(struct hv_device *device, void *additional_info)
881 {
882 	int ret = 0;
883 	int i;
884 	int ring_size =
885 	((struct netvsc_device_info *)additional_info)->ring_size;
886 	struct netvsc_device *net_device;
887 	struct hv_netvsc_packet *packet, *pos;
888 	struct net_device *ndev;
889 
890 	net_device = alloc_net_device(device);
891 	if (!net_device) {
892 		ret = -ENOMEM;
893 		goto cleanup;
894 	}
895 
896 	/*
897 	 * Coming into this function, struct net_device * is
898 	 * registered as the driver private data.
899 	 * In alloc_net_device(), we register struct netvsc_device *
900 	 * as the driver private data and stash away struct net_device *
901 	 * in struct netvsc_device *.
902 	 */
903 	ndev = net_device->ndev;
904 
905 	/* Initialize the NetVSC channel extension */
906 	spin_lock_init(&net_device->recv_pkt_list_lock);
907 
908 	INIT_LIST_HEAD(&net_device->recv_pkt_list);
909 
910 	for (i = 0; i < NETVSC_RECEIVE_PACKETLIST_COUNT; i++) {
911 		packet = kzalloc(sizeof(struct hv_netvsc_packet), GFP_KERNEL);
912 		if (!packet)
913 			break;
914 
915 		list_add_tail(&packet->list_ent,
916 			      &net_device->recv_pkt_list);
917 	}
918 	init_completion(&net_device->channel_init_wait);
919 
920 	/* Open the channel */
921 	ret = vmbus_open(device->channel, ring_size * PAGE_SIZE,
922 			 ring_size * PAGE_SIZE, NULL, 0,
923 			 netvsc_channel_cb, device);
924 
925 	if (ret != 0) {
926 		netdev_err(ndev, "unable to open channel: %d\n", ret);
927 		goto cleanup;
928 	}
929 
930 	/* Channel is opened */
931 	pr_info("hv_netvsc channel opened successfully\n");
932 
933 	/* Connect with the NetVsp */
934 	ret = netvsc_connect_vsp(device);
935 	if (ret != 0) {
936 		netdev_err(ndev,
937 			"unable to connect to NetVSP - %d\n", ret);
938 		goto close;
939 	}
940 
941 	return ret;
942 
943 close:
944 	/* Now, we can close the channel safely */
945 	vmbus_close(device->channel);
946 
947 cleanup:
948 
949 	if (net_device) {
950 		list_for_each_entry_safe(packet, pos,
951 					 &net_device->recv_pkt_list,
952 					 list_ent) {
953 			list_del(&packet->list_ent);
954 			kfree(packet);
955 		}
956 
957 		kfree(net_device);
958 	}
959 
960 	return ret;
961 }
962