Linux Audio

Check our new training course

Loading...
Note: File does not exist in v3.1.
  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
 35static 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
 54static 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
 65static 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
 78get_in_err:
 79	return net_device;
 80}
 81
 82
 83static 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
152static 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
253cleanup:
254	netvsc_destroy_recv_buf(net_device);
255
256exit:
257	return ret;
258}
259
260
261/* Negotiate NVSP protocol version */
262static 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
310static 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
375cleanup:
376	return ret;
377}
378
379static 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 */
387int 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 */
437static 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
447static 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
501int 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
572static 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
588retry_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) */
617static 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
670static 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
803static 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 */
880int 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
943close:
944	/* Now, we can close the channel safely */
945	vmbus_close(device->channel);
946
947cleanup:
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}