Linux Audio

Check our new training course

Loading...
v4.6
   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#include <linux/vmalloc.h>
  32#include <asm/sync_bitops.h>
  33
  34#include "hyperv_net.h"
  35
  36
  37static struct netvsc_device *alloc_net_device(struct hv_device *device)
  38{
  39	struct netvsc_device *net_device;
  40	struct net_device *ndev = hv_get_drvdata(device);
  41
  42	net_device = kzalloc(sizeof(struct netvsc_device), GFP_KERNEL);
  43	if (!net_device)
  44		return NULL;
  45
  46	net_device->cb_buffer = kzalloc(NETVSC_PACKET_SIZE, GFP_KERNEL);
  47	if (!net_device->cb_buffer) {
  48		kfree(net_device);
  49		return NULL;
  50	}
  51
  52	init_waitqueue_head(&net_device->wait_drain);
  53	net_device->start_remove = false;
  54	net_device->destroy = false;
  55	net_device->dev = device;
  56	net_device->ndev = ndev;
  57	net_device->max_pkt = RNDIS_MAX_PKT_DEFAULT;
  58	net_device->pkt_align = RNDIS_PKT_ALIGN_DEFAULT;
  59
  60	hv_set_drvdata(device, net_device);
  61	return net_device;
  62}
  63
  64static void free_netvsc_device(struct netvsc_device *nvdev)
  65{
  66	kfree(nvdev->cb_buffer);
  67	kfree(nvdev);
  68}
  69
  70static struct netvsc_device *get_outbound_net_device(struct hv_device *device)
  71{
  72	struct netvsc_device *net_device;
  73
  74	net_device = hv_get_drvdata(device);
  75	if (net_device && net_device->destroy)
  76		net_device = NULL;
  77
  78	return net_device;
  79}
  80
  81static struct netvsc_device *get_inbound_net_device(struct hv_device *device)
  82{
  83	struct netvsc_device *net_device;
  84
  85	net_device = hv_get_drvdata(device);
  86
  87	if (!net_device)
  88		goto get_in_err;
  89
  90	if (net_device->destroy &&
  91		atomic_read(&net_device->num_outstanding_sends) == 0)
  92		net_device = NULL;
  93
  94get_in_err:
  95	return net_device;
  96}
  97
  98
  99static int netvsc_destroy_buf(struct netvsc_device *net_device)
 100{
 101	struct nvsp_message *revoke_packet;
 102	int ret = 0;
 103	struct net_device *ndev = net_device->ndev;
 104
 105	/*
 106	 * If we got a section count, it means we received a
 107	 * SendReceiveBufferComplete msg (ie sent
 108	 * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
 109	 * to send a revoke msg here
 110	 */
 111	if (net_device->recv_section_cnt) {
 112		/* Send the revoke receive buffer */
 113		revoke_packet = &net_device->revoke_packet;
 114		memset(revoke_packet, 0, sizeof(struct nvsp_message));
 115
 116		revoke_packet->hdr.msg_type =
 117			NVSP_MSG1_TYPE_REVOKE_RECV_BUF;
 118		revoke_packet->msg.v1_msg.
 119		revoke_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
 120
 121		ret = vmbus_sendpacket(net_device->dev->channel,
 122				       revoke_packet,
 123				       sizeof(struct nvsp_message),
 124				       (unsigned long)revoke_packet,
 125				       VM_PKT_DATA_INBAND, 0);
 126		/*
 127		 * If we failed here, we might as well return and
 128		 * have a leak rather than continue and a bugchk
 129		 */
 130		if (ret != 0) {
 131			netdev_err(ndev, "unable to send "
 132				"revoke receive buffer to netvsp\n");
 133			return ret;
 134		}
 135	}
 136
 137	/* Teardown the gpadl on the vsp end */
 138	if (net_device->recv_buf_gpadl_handle) {
 139		ret = vmbus_teardown_gpadl(net_device->dev->channel,
 140			   net_device->recv_buf_gpadl_handle);
 141
 142		/* If we failed here, we might as well return and have a leak
 143		 * rather than continue and a bugchk
 144		 */
 145		if (ret != 0) {
 146			netdev_err(ndev,
 147				   "unable to teardown receive buffer's gpadl\n");
 148			return ret;
 149		}
 150		net_device->recv_buf_gpadl_handle = 0;
 151	}
 152
 153	if (net_device->recv_buf) {
 154		/* Free up the receive buffer */
 155		vfree(net_device->recv_buf);
 
 156		net_device->recv_buf = NULL;
 157	}
 158
 159	if (net_device->recv_section) {
 160		net_device->recv_section_cnt = 0;
 161		kfree(net_device->recv_section);
 162		net_device->recv_section = NULL;
 163	}
 164
 165	/* Deal with the send buffer we may have setup.
 166	 * If we got a  send section size, it means we received a
 167	 * NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE msg (ie sent
 168	 * NVSP_MSG1_TYPE_SEND_SEND_BUF msg) therefore, we need
 169	 * to send a revoke msg here
 170	 */
 171	if (net_device->send_section_size) {
 172		/* Send the revoke receive buffer */
 173		revoke_packet = &net_device->revoke_packet;
 174		memset(revoke_packet, 0, sizeof(struct nvsp_message));
 175
 176		revoke_packet->hdr.msg_type =
 177			NVSP_MSG1_TYPE_REVOKE_SEND_BUF;
 178		revoke_packet->msg.v1_msg.revoke_send_buf.id =
 179			NETVSC_SEND_BUFFER_ID;
 180
 181		ret = vmbus_sendpacket(net_device->dev->channel,
 182				       revoke_packet,
 183				       sizeof(struct nvsp_message),
 184				       (unsigned long)revoke_packet,
 185				       VM_PKT_DATA_INBAND, 0);
 186		/* If we failed here, we might as well return and
 187		 * have a leak rather than continue and a bugchk
 188		 */
 189		if (ret != 0) {
 190			netdev_err(ndev, "unable to send "
 191				   "revoke send buffer to netvsp\n");
 192			return ret;
 193		}
 194	}
 195	/* Teardown the gpadl on the vsp end */
 196	if (net_device->send_buf_gpadl_handle) {
 197		ret = vmbus_teardown_gpadl(net_device->dev->channel,
 198					   net_device->send_buf_gpadl_handle);
 199
 200		/* If we failed here, we might as well return and have a leak
 201		 * rather than continue and a bugchk
 202		 */
 203		if (ret != 0) {
 204			netdev_err(ndev,
 205				   "unable to teardown send buffer's gpadl\n");
 206			return ret;
 207		}
 208		net_device->send_buf_gpadl_handle = 0;
 209	}
 210	if (net_device->send_buf) {
 211		/* Free up the send buffer */
 212		vfree(net_device->send_buf);
 213		net_device->send_buf = NULL;
 214	}
 215	kfree(net_device->send_section_map);
 216
 217	return ret;
 218}
 219
 220static int netvsc_init_buf(struct hv_device *device)
 221{
 222	int ret = 0;
 223	unsigned long t;
 224	struct netvsc_device *net_device;
 225	struct nvsp_message *init_packet;
 226	struct net_device *ndev;
 227	int node;
 228
 229	net_device = get_outbound_net_device(device);
 230	if (!net_device)
 231		return -ENODEV;
 232	ndev = net_device->ndev;
 233
 234	node = cpu_to_node(device->channel->target_cpu);
 235	net_device->recv_buf = vzalloc_node(net_device->recv_buf_size, node);
 236	if (!net_device->recv_buf)
 237		net_device->recv_buf = vzalloc(net_device->recv_buf_size);
 238
 239	if (!net_device->recv_buf) {
 240		netdev_err(ndev, "unable to allocate receive "
 241			"buffer of size %d\n", net_device->recv_buf_size);
 242		ret = -ENOMEM;
 243		goto cleanup;
 244	}
 245
 246	/*
 247	 * Establish the gpadl handle for this buffer on this
 248	 * channel.  Note: This call uses the vmbus connection rather
 249	 * than the channel to establish the gpadl handle.
 250	 */
 251	ret = vmbus_establish_gpadl(device->channel, net_device->recv_buf,
 252				    net_device->recv_buf_size,
 253				    &net_device->recv_buf_gpadl_handle);
 254	if (ret != 0) {
 255		netdev_err(ndev,
 256			"unable to establish receive buffer's gpadl\n");
 257		goto cleanup;
 258	}
 259
 260
 261	/* Notify the NetVsp of the gpadl handle */
 262	init_packet = &net_device->channel_init_pkt;
 263
 264	memset(init_packet, 0, sizeof(struct nvsp_message));
 265
 266	init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_RECV_BUF;
 267	init_packet->msg.v1_msg.send_recv_buf.
 268		gpadl_handle = net_device->recv_buf_gpadl_handle;
 269	init_packet->msg.v1_msg.
 270		send_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
 271
 272	/* Send the gpadl notification request */
 273	ret = vmbus_sendpacket(device->channel, init_packet,
 274			       sizeof(struct nvsp_message),
 275			       (unsigned long)init_packet,
 276			       VM_PKT_DATA_INBAND,
 277			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 278	if (ret != 0) {
 279		netdev_err(ndev,
 280			"unable to send receive buffer's gpadl to netvsp\n");
 281		goto cleanup;
 282	}
 283
 284	t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
 285	BUG_ON(t == 0);
 286
 287
 288	/* Check the response */
 289	if (init_packet->msg.v1_msg.
 290	    send_recv_buf_complete.status != NVSP_STAT_SUCCESS) {
 291		netdev_err(ndev, "Unable to complete receive buffer "
 292			   "initialization with NetVsp - status %d\n",
 293			   init_packet->msg.v1_msg.
 294			   send_recv_buf_complete.status);
 295		ret = -EINVAL;
 296		goto cleanup;
 297	}
 298
 299	/* Parse the response */
 300
 301	net_device->recv_section_cnt = init_packet->msg.
 302		v1_msg.send_recv_buf_complete.num_sections;
 303
 304	net_device->recv_section = kmemdup(
 305		init_packet->msg.v1_msg.send_recv_buf_complete.sections,
 306		net_device->recv_section_cnt *
 307		sizeof(struct nvsp_1_receive_buffer_section),
 308		GFP_KERNEL);
 309	if (net_device->recv_section == NULL) {
 310		ret = -EINVAL;
 311		goto cleanup;
 312	}
 313
 314	/*
 315	 * For 1st release, there should only be 1 section that represents the
 316	 * entire receive buffer
 317	 */
 318	if (net_device->recv_section_cnt != 1 ||
 319	    net_device->recv_section->offset != 0) {
 320		ret = -EINVAL;
 321		goto cleanup;
 322	}
 323
 324	/* Now setup the send buffer.
 325	 */
 326	net_device->send_buf = vzalloc_node(net_device->send_buf_size, node);
 327	if (!net_device->send_buf)
 328		net_device->send_buf = vzalloc(net_device->send_buf_size);
 329	if (!net_device->send_buf) {
 330		netdev_err(ndev, "unable to allocate send "
 331			   "buffer of size %d\n", net_device->send_buf_size);
 332		ret = -ENOMEM;
 333		goto cleanup;
 334	}
 335
 336	/* Establish the gpadl handle for this buffer on this
 337	 * channel.  Note: This call uses the vmbus connection rather
 338	 * than the channel to establish the gpadl handle.
 339	 */
 340	ret = vmbus_establish_gpadl(device->channel, net_device->send_buf,
 341				    net_device->send_buf_size,
 342				    &net_device->send_buf_gpadl_handle);
 343	if (ret != 0) {
 344		netdev_err(ndev,
 345			   "unable to establish send buffer's gpadl\n");
 346		goto cleanup;
 347	}
 348
 349	/* Notify the NetVsp of the gpadl handle */
 350	init_packet = &net_device->channel_init_pkt;
 351	memset(init_packet, 0, sizeof(struct nvsp_message));
 352	init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_SEND_BUF;
 353	init_packet->msg.v1_msg.send_send_buf.gpadl_handle =
 354		net_device->send_buf_gpadl_handle;
 355	init_packet->msg.v1_msg.send_send_buf.id = NETVSC_SEND_BUFFER_ID;
 356
 357	/* Send the gpadl notification request */
 358	ret = vmbus_sendpacket(device->channel, init_packet,
 359			       sizeof(struct nvsp_message),
 360			       (unsigned long)init_packet,
 361			       VM_PKT_DATA_INBAND,
 362			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 363	if (ret != 0) {
 364		netdev_err(ndev,
 365			   "unable to send send buffer's gpadl to netvsp\n");
 366		goto cleanup;
 367	}
 368
 369	t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
 370	BUG_ON(t == 0);
 371
 372	/* Check the response */
 373	if (init_packet->msg.v1_msg.
 374	    send_send_buf_complete.status != NVSP_STAT_SUCCESS) {
 375		netdev_err(ndev, "Unable to complete send buffer "
 376			   "initialization with NetVsp - status %d\n",
 377			   init_packet->msg.v1_msg.
 378			   send_send_buf_complete.status);
 379		ret = -EINVAL;
 380		goto cleanup;
 381	}
 382
 383	/* Parse the response */
 384	net_device->send_section_size = init_packet->msg.
 385				v1_msg.send_send_buf_complete.section_size;
 386
 387	/* Section count is simply the size divided by the section size.
 388	 */
 389	net_device->send_section_cnt =
 390		net_device->send_buf_size/net_device->send_section_size;
 391
 392	dev_info(&device->device, "Send section size: %d, Section count:%d\n",
 393		 net_device->send_section_size, net_device->send_section_cnt);
 394
 395	/* Setup state for managing the send buffer. */
 396	net_device->map_words = DIV_ROUND_UP(net_device->send_section_cnt,
 397					     BITS_PER_LONG);
 398
 399	net_device->send_section_map =
 400		kzalloc(net_device->map_words * sizeof(ulong), GFP_KERNEL);
 401	if (net_device->send_section_map == NULL) {
 402		ret = -ENOMEM;
 403		goto cleanup;
 404	}
 405
 406	goto exit;
 407
 408cleanup:
 409	netvsc_destroy_buf(net_device);
 410
 411exit:
 412	return ret;
 413}
 414
 415
 416/* Negotiate NVSP protocol version */
 417static int negotiate_nvsp_ver(struct hv_device *device,
 418			      struct netvsc_device *net_device,
 419			      struct nvsp_message *init_packet,
 420			      u32 nvsp_ver)
 421{
 422	int ret;
 423	unsigned long t;
 424
 425	memset(init_packet, 0, sizeof(struct nvsp_message));
 426	init_packet->hdr.msg_type = NVSP_MSG_TYPE_INIT;
 427	init_packet->msg.init_msg.init.min_protocol_ver = nvsp_ver;
 428	init_packet->msg.init_msg.init.max_protocol_ver = nvsp_ver;
 429
 430	/* Send the init request */
 431	ret = vmbus_sendpacket(device->channel, init_packet,
 432			       sizeof(struct nvsp_message),
 433			       (unsigned long)init_packet,
 434			       VM_PKT_DATA_INBAND,
 435			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 436
 437	if (ret != 0)
 438		return ret;
 439
 440	t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
 441
 442	if (t == 0)
 443		return -ETIMEDOUT;
 444
 445	if (init_packet->msg.init_msg.init_complete.status !=
 446	    NVSP_STAT_SUCCESS)
 447		return -EINVAL;
 448
 449	if (nvsp_ver == NVSP_PROTOCOL_VERSION_1)
 450		return 0;
 451
 452	/* NVSPv2 or later: Send NDIS config */
 453	memset(init_packet, 0, sizeof(struct nvsp_message));
 454	init_packet->hdr.msg_type = NVSP_MSG2_TYPE_SEND_NDIS_CONFIG;
 455	init_packet->msg.v2_msg.send_ndis_config.mtu = net_device->ndev->mtu +
 456						       ETH_HLEN;
 457	init_packet->msg.v2_msg.send_ndis_config.capability.ieee8021q = 1;
 458
 459	if (nvsp_ver >= NVSP_PROTOCOL_VERSION_5)
 460		init_packet->msg.v2_msg.send_ndis_config.capability.sriov = 1;
 461
 462	ret = vmbus_sendpacket(device->channel, init_packet,
 463				sizeof(struct nvsp_message),
 464				(unsigned long)init_packet,
 465				VM_PKT_DATA_INBAND, 0);
 466
 467	return ret;
 468}
 469
 470static int netvsc_connect_vsp(struct hv_device *device)
 471{
 472	int ret;
 473	struct netvsc_device *net_device;
 474	struct nvsp_message *init_packet;
 475	int ndis_version;
 476	struct net_device *ndev;
 477	u32 ver_list[] = { NVSP_PROTOCOL_VERSION_1, NVSP_PROTOCOL_VERSION_2,
 478		NVSP_PROTOCOL_VERSION_4, NVSP_PROTOCOL_VERSION_5 };
 479	int i, num_ver = 4; /* number of different NVSP versions */
 480
 481	net_device = get_outbound_net_device(device);
 482	if (!net_device)
 483		return -ENODEV;
 484	ndev = net_device->ndev;
 485
 486	init_packet = &net_device->channel_init_pkt;
 487
 488	/* Negotiate the latest NVSP protocol supported */
 489	for (i = num_ver - 1; i >= 0; i--)
 490		if (negotiate_nvsp_ver(device, net_device, init_packet,
 491				       ver_list[i])  == 0) {
 492			net_device->nvsp_version = ver_list[i];
 493			break;
 494		}
 495
 496	if (i < 0) {
 497		ret = -EPROTO;
 498		goto cleanup;
 499	}
 500
 501	pr_debug("Negotiated NVSP version:%x\n", net_device->nvsp_version);
 502
 503	/* Send the ndis version */
 504	memset(init_packet, 0, sizeof(struct nvsp_message));
 505
 506	if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_4)
 507		ndis_version = 0x00060001;
 508	else
 509		ndis_version = 0x0006001e;
 510
 511	init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_NDIS_VER;
 512	init_packet->msg.v1_msg.
 513		send_ndis_ver.ndis_major_ver =
 514				(ndis_version & 0xFFFF0000) >> 16;
 515	init_packet->msg.v1_msg.
 516		send_ndis_ver.ndis_minor_ver =
 517				ndis_version & 0xFFFF;
 518
 519	/* Send the init request */
 520	ret = vmbus_sendpacket(device->channel, init_packet,
 521				sizeof(struct nvsp_message),
 522				(unsigned long)init_packet,
 523				VM_PKT_DATA_INBAND, 0);
 524	if (ret != 0)
 525		goto cleanup;
 526
 527	/* Post the big receive buffer to NetVSP */
 528	if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_2)
 529		net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE_LEGACY;
 530	else
 531		net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE;
 532	net_device->send_buf_size = NETVSC_SEND_BUFFER_SIZE;
 533
 534	ret = netvsc_init_buf(device);
 535
 536cleanup:
 537	return ret;
 538}
 539
 540static void netvsc_disconnect_vsp(struct netvsc_device *net_device)
 541{
 542	netvsc_destroy_buf(net_device);
 543}
 544
 545/*
 546 * netvsc_device_remove - Callback when the root bus device is removed
 547 */
 548int netvsc_device_remove(struct hv_device *device)
 549{
 550	struct netvsc_device *net_device;
 
 551	unsigned long flags;
 552
 553	net_device = hv_get_drvdata(device);
 
 
 
 
 
 
 
 554
 555	netvsc_disconnect_vsp(net_device);
 556
 557	/*
 558	 * Since we have already drained, we don't need to busy wait
 559	 * as was done in final_release_stor_device()
 560	 * Note that we cannot set the ext pointer to NULL until
 561	 * we have drained - to drain the outgoing packets, we need to
 562	 * allow incoming packets.
 563	 */
 564
 565	spin_lock_irqsave(&device->channel->inbound_lock, flags);
 566	hv_set_drvdata(device, NULL);
 567	spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
 568
 569	/*
 570	 * At this point, no one should be accessing net_device
 571	 * except in here
 572	 */
 573	dev_notice(&device->device, "net device safe to remove\n");
 574
 575	/* Now, we can close the channel safely */
 576	vmbus_close(device->channel);
 577
 578	/* Release all resources */
 579	vfree(net_device->sub_cb_buf);
 580	free_netvsc_device(net_device);
 
 
 
 
 
 581	return 0;
 582}
 583
 584
 585#define RING_AVAIL_PERCENT_HIWATER 20
 586#define RING_AVAIL_PERCENT_LOWATER 10
 587
 588/*
 589 * Get the percentage of available bytes to write in the ring.
 590 * The return value is in range from 0 to 100.
 591 */
 592static inline u32 hv_ringbuf_avail_percent(
 593		struct hv_ring_buffer_info *ring_info)
 594{
 595	u32 avail_read, avail_write;
 596
 597	hv_get_ringbuffer_availbytes(ring_info, &avail_read, &avail_write);
 598
 599	return avail_write * 100 / ring_info->ring_datasize;
 600}
 601
 602static inline void netvsc_free_send_slot(struct netvsc_device *net_device,
 603					 u32 index)
 604{
 605	sync_change_bit(index, net_device->send_section_map);
 606}
 607
 608static void netvsc_send_completion(struct netvsc_device *net_device,
 609				   struct vmbus_channel *incoming_channel,
 610				   struct hv_device *device,
 611				   struct vmpacket_descriptor *packet)
 612{
 
 613	struct nvsp_message *nvsp_packet;
 614	struct hv_netvsc_packet *nvsc_packet;
 615	struct net_device *ndev;
 616	u32 send_index;
 617	struct sk_buff *skb;
 618
 
 
 
 619	ndev = net_device->ndev;
 620
 621	nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
 622			(packet->offset8 << 3));
 623
 624	if ((nvsp_packet->hdr.msg_type == NVSP_MSG_TYPE_INIT_COMPLETE) ||
 625	    (nvsp_packet->hdr.msg_type ==
 626	     NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE) ||
 627	    (nvsp_packet->hdr.msg_type ==
 628	     NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE) ||
 629	    (nvsp_packet->hdr.msg_type ==
 630	     NVSP_MSG5_TYPE_SUBCHANNEL)) {
 631		/* Copy the response back */
 632		memcpy(&net_device->channel_init_pkt, nvsp_packet,
 633		       sizeof(struct nvsp_message));
 634		complete(&net_device->channel_init_wait);
 635	} else if (nvsp_packet->hdr.msg_type ==
 636		   NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE) {
 637		int num_outstanding_sends;
 638		u16 q_idx = 0;
 639		struct vmbus_channel *channel = device->channel;
 640		int queue_sends;
 641
 642		/* Get the send context */
 643		skb = (struct sk_buff *)(unsigned long)packet->trans_id;
 
 644
 645		/* Notify the layer above us */
 646		if (skb) {
 647			nvsc_packet = (struct hv_netvsc_packet *) skb->cb;
 648			send_index = nvsc_packet->send_buf_index;
 649			if (send_index != NETVSC_INVALID_INDEX)
 650				netvsc_free_send_slot(net_device, send_index);
 651			q_idx = nvsc_packet->q_idx;
 652			channel = incoming_channel;
 653			dev_kfree_skb_any(skb);
 654		}
 655
 656		num_outstanding_sends =
 657			atomic_dec_return(&net_device->num_outstanding_sends);
 658		queue_sends = atomic_dec_return(&net_device->
 659						queue_sends[q_idx]);
 660
 661		if (net_device->destroy && num_outstanding_sends == 0)
 662			wake_up(&net_device->wait_drain);
 663
 664		if (netif_tx_queue_stopped(netdev_get_tx_queue(ndev, q_idx)) &&
 665		    !net_device->start_remove &&
 666		    (hv_ringbuf_avail_percent(&channel->outbound) >
 667		     RING_AVAIL_PERCENT_HIWATER || queue_sends < 1))
 668				netif_tx_wake_queue(netdev_get_tx_queue(
 669						    ndev, q_idx));
 670	} else {
 671		netdev_err(ndev, "Unknown send completion packet type- "
 672			   "%d received!!\n", nvsp_packet->hdr.msg_type);
 673	}
 674
 675}
 676
 677static u32 netvsc_get_next_send_section(struct netvsc_device *net_device)
 678{
 679	unsigned long index;
 680	u32 max_words = net_device->map_words;
 681	unsigned long *map_addr = (unsigned long *)net_device->send_section_map;
 682	u32 section_cnt = net_device->send_section_cnt;
 683	int ret_val = NETVSC_INVALID_INDEX;
 684	int i;
 685	int prev_val;
 686
 687	for (i = 0; i < max_words; i++) {
 688		if (!~(map_addr[i]))
 689			continue;
 690		index = ffz(map_addr[i]);
 691		prev_val = sync_test_and_set_bit(index, &map_addr[i]);
 692		if (prev_val)
 693			continue;
 694		if ((index + (i * BITS_PER_LONG)) >= section_cnt)
 695			break;
 696		ret_val = (index + (i * BITS_PER_LONG));
 697		break;
 698	}
 699	return ret_val;
 700}
 701
 702static u32 netvsc_copy_to_send_buf(struct netvsc_device *net_device,
 703				   unsigned int section_index,
 704				   u32 pend_size,
 705				   struct hv_netvsc_packet *packet,
 706				   struct rndis_message *rndis_msg,
 707				   struct hv_page_buffer **pb,
 708				   struct sk_buff *skb)
 709{
 710	char *start = net_device->send_buf;
 711	char *dest = start + (section_index * net_device->send_section_size)
 712		     + pend_size;
 713	int i;
 714	bool is_data_pkt = (skb != NULL) ? true : false;
 715	bool xmit_more = (skb != NULL) ? skb->xmit_more : false;
 716	u32 msg_size = 0;
 717	u32 padding = 0;
 718	u32 remain = packet->total_data_buflen % net_device->pkt_align;
 719	u32 page_count = packet->cp_partial ? packet->rmsg_pgcnt :
 720		packet->page_buf_cnt;
 721
 722	/* Add padding */
 723	if (is_data_pkt && xmit_more && remain &&
 724	    !packet->cp_partial) {
 725		padding = net_device->pkt_align - remain;
 726		rndis_msg->msg_len += padding;
 727		packet->total_data_buflen += padding;
 728	}
 729
 730	for (i = 0; i < page_count; i++) {
 731		char *src = phys_to_virt((*pb)[i].pfn << PAGE_SHIFT);
 732		u32 offset = (*pb)[i].offset;
 733		u32 len = (*pb)[i].len;
 734
 735		memcpy(dest, (src + offset), len);
 736		msg_size += len;
 737		dest += len;
 738	}
 739
 740	if (padding) {
 741		memset(dest, 0, padding);
 742		msg_size += padding;
 743	}
 744
 745	return msg_size;
 746}
 747
 748static inline int netvsc_send_pkt(
 749	struct hv_netvsc_packet *packet,
 750	struct netvsc_device *net_device,
 751	struct hv_page_buffer **pb,
 752	struct sk_buff *skb)
 753{
 754	struct nvsp_message nvmsg;
 755	u16 q_idx = packet->q_idx;
 756	struct vmbus_channel *out_channel = net_device->chn_table[q_idx];
 757	struct net_device *ndev = net_device->ndev;
 758	u64 req_id;
 759	int ret;
 760	struct hv_page_buffer *pgbuf;
 761	u32 ring_avail = hv_ringbuf_avail_percent(&out_channel->outbound);
 762	bool xmit_more = (skb != NULL) ? skb->xmit_more : false;
 763
 764	nvmsg.hdr.msg_type = NVSP_MSG1_TYPE_SEND_RNDIS_PKT;
 765	if (skb != NULL) {
 766		/* 0 is RMC_DATA; */
 767		nvmsg.msg.v1_msg.send_rndis_pkt.channel_type = 0;
 768	} else {
 769		/* 1 is RMC_CONTROL; */
 770		nvmsg.msg.v1_msg.send_rndis_pkt.channel_type = 1;
 771	}
 772
 773	nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_index =
 774		packet->send_buf_index;
 775	if (packet->send_buf_index == NETVSC_INVALID_INDEX)
 776		nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_size = 0;
 777	else
 778		nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_size =
 779			packet->total_data_buflen;
 780
 781	req_id = (ulong)skb;
 782
 783	if (out_channel->rescind)
 784		return -ENODEV;
 785
 786	/*
 787	 * It is possible that once we successfully place this packet
 788	 * on the ringbuffer, we may stop the queue. In that case, we want
 789	 * to notify the host independent of the xmit_more flag. We don't
 790	 * need to be precise here; in the worst case we may signal the host
 791	 * unnecessarily.
 792	 */
 793	if (ring_avail < (RING_AVAIL_PERCENT_LOWATER + 1))
 794		xmit_more = false;
 795
 796	if (packet->page_buf_cnt) {
 797		pgbuf = packet->cp_partial ? (*pb) +
 798			packet->rmsg_pgcnt : (*pb);
 799		ret = vmbus_sendpacket_pagebuffer_ctl(out_channel,
 800						      pgbuf,
 801						      packet->page_buf_cnt,
 802						      &nvmsg,
 803						      sizeof(struct nvsp_message),
 804						      req_id,
 805						      VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED,
 806						      !xmit_more);
 807	} else {
 808		ret = vmbus_sendpacket_ctl(out_channel, &nvmsg,
 809					   sizeof(struct nvsp_message),
 810					   req_id,
 811					   VM_PKT_DATA_INBAND,
 812					   VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED,
 813					   !xmit_more);
 814	}
 815
 816	if (ret == 0) {
 817		atomic_inc(&net_device->num_outstanding_sends);
 818		atomic_inc(&net_device->queue_sends[q_idx]);
 819
 820		if (ring_avail < RING_AVAIL_PERCENT_LOWATER) {
 821			netif_tx_stop_queue(netdev_get_tx_queue(ndev, q_idx));
 822
 823			if (atomic_read(&net_device->
 824				queue_sends[q_idx]) < 1)
 825				netif_tx_wake_queue(netdev_get_tx_queue(
 826						    ndev, q_idx));
 827		}
 828	} else if (ret == -EAGAIN) {
 829		netif_tx_stop_queue(netdev_get_tx_queue(
 830				    ndev, q_idx));
 831		if (atomic_read(&net_device->queue_sends[q_idx]) < 1) {
 832			netif_tx_wake_queue(netdev_get_tx_queue(
 833					    ndev, q_idx));
 834			ret = -ENOSPC;
 835		}
 836	} else {
 837		netdev_err(ndev, "Unable to send packet %p ret %d\n",
 838			   packet, ret);
 839	}
 840
 841	return ret;
 842}
 843
 844/* Move packet out of multi send data (msd), and clear msd */
 845static inline void move_pkt_msd(struct hv_netvsc_packet **msd_send,
 846				struct sk_buff **msd_skb,
 847				struct multi_send_data *msdp)
 848{
 849	*msd_skb = msdp->skb;
 850	*msd_send = msdp->pkt;
 851	msdp->skb = NULL;
 852	msdp->pkt = NULL;
 853	msdp->count = 0;
 854}
 855
 856int netvsc_send(struct hv_device *device,
 857		struct hv_netvsc_packet *packet,
 858		struct rndis_message *rndis_msg,
 859		struct hv_page_buffer **pb,
 860		struct sk_buff *skb)
 861{
 862	struct netvsc_device *net_device;
 863	int ret = 0, m_ret = 0;
 864	struct vmbus_channel *out_channel;
 865	u16 q_idx = packet->q_idx;
 866	u32 pktlen = packet->total_data_buflen, msd_len = 0;
 867	unsigned int section_index = NETVSC_INVALID_INDEX;
 868	struct multi_send_data *msdp;
 869	struct hv_netvsc_packet *msd_send = NULL, *cur_send = NULL;
 870	struct sk_buff *msd_skb = NULL;
 871	bool try_batch;
 872	bool xmit_more = (skb != NULL) ? skb->xmit_more : false;
 873
 874	net_device = get_outbound_net_device(device);
 875	if (!net_device)
 876		return -ENODEV;
 877
 878	out_channel = net_device->chn_table[q_idx];
 879
 880	packet->send_buf_index = NETVSC_INVALID_INDEX;
 881	packet->cp_partial = false;
 882
 883	/* Send control message directly without accessing msd (Multi-Send
 884	 * Data) field which may be changed during data packet processing.
 885	 */
 886	if (!skb) {
 887		cur_send = packet;
 888		goto send_now;
 889	}
 890
 891	msdp = &net_device->msd[q_idx];
 892
 893	/* batch packets in send buffer if possible */
 894	if (msdp->pkt)
 895		msd_len = msdp->pkt->total_data_buflen;
 896
 897	try_batch = (skb != NULL) && msd_len > 0 && msdp->count <
 898		    net_device->max_pkt;
 899
 900	if (try_batch && msd_len + pktlen + net_device->pkt_align <
 901	    net_device->send_section_size) {
 902		section_index = msdp->pkt->send_buf_index;
 903
 904	} else if (try_batch && msd_len + packet->rmsg_size <
 905		   net_device->send_section_size) {
 906		section_index = msdp->pkt->send_buf_index;
 907		packet->cp_partial = true;
 908
 909	} else if ((skb != NULL) && pktlen + net_device->pkt_align <
 910		   net_device->send_section_size) {
 911		section_index = netvsc_get_next_send_section(net_device);
 912		if (section_index != NETVSC_INVALID_INDEX) {
 913			move_pkt_msd(&msd_send, &msd_skb, msdp);
 914			msd_len = 0;
 915		}
 916	}
 917
 918	if (section_index != NETVSC_INVALID_INDEX) {
 919		netvsc_copy_to_send_buf(net_device,
 920					section_index, msd_len,
 921					packet, rndis_msg, pb, skb);
 922
 923		packet->send_buf_index = section_index;
 924
 925		if (packet->cp_partial) {
 926			packet->page_buf_cnt -= packet->rmsg_pgcnt;
 927			packet->total_data_buflen = msd_len + packet->rmsg_size;
 928		} else {
 929			packet->page_buf_cnt = 0;
 930			packet->total_data_buflen += msd_len;
 931		}
 932
 933		if (msdp->skb)
 934			dev_kfree_skb_any(msdp->skb);
 935
 936		if (xmit_more && !packet->cp_partial) {
 937			msdp->skb = skb;
 938			msdp->pkt = packet;
 939			msdp->count++;
 940		} else {
 941			cur_send = packet;
 942			msdp->skb = NULL;
 943			msdp->pkt = NULL;
 944			msdp->count = 0;
 945		}
 946	} else {
 947		move_pkt_msd(&msd_send, &msd_skb, msdp);
 948		cur_send = packet;
 949	}
 950
 951	if (msd_send) {
 952		m_ret = netvsc_send_pkt(msd_send, net_device, NULL, msd_skb);
 953
 954		if (m_ret != 0) {
 955			netvsc_free_send_slot(net_device,
 956					      msd_send->send_buf_index);
 957			dev_kfree_skb_any(msd_skb);
 958		}
 959	}
 960
 961send_now:
 962	if (cur_send)
 963		ret = netvsc_send_pkt(cur_send, net_device, pb, skb);
 964
 965	if (ret != 0 && section_index != NETVSC_INVALID_INDEX)
 966		netvsc_free_send_slot(net_device, section_index);
 967
 968	return ret;
 969}
 970
 971static void netvsc_send_recv_completion(struct hv_device *device,
 972					struct vmbus_channel *channel,
 973					struct netvsc_device *net_device,
 974					u64 transaction_id, u32 status)
 975{
 976	struct nvsp_message recvcompMessage;
 977	int retries = 0;
 978	int ret;
 979	struct net_device *ndev;
 
 980
 981	ndev = net_device->ndev;
 982
 983	recvcompMessage.hdr.msg_type =
 984				NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE;
 985
 986	recvcompMessage.msg.v1_msg.send_rndis_pkt_complete.status = status;
 
 
 987
 988retry_send_cmplt:
 989	/* Send the completion */
 990	ret = vmbus_sendpacket(channel, &recvcompMessage,
 991			       sizeof(struct nvsp_message), transaction_id,
 992			       VM_PKT_COMP, 0);
 993	if (ret == 0) {
 994		/* success */
 995		/* no-op */
 996	} else if (ret == -EAGAIN) {
 997		/* no more room...wait a bit and attempt to retry 3 times */
 998		retries++;
 999		netdev_err(ndev, "unable to send receive completion pkt"
1000			" (tid %llx)...retrying %d\n", transaction_id, retries);
1001
1002		if (retries < 4) {
1003			udelay(100);
1004			goto retry_send_cmplt;
1005		} else {
1006			netdev_err(ndev, "unable to send receive "
1007				"completion pkt (tid %llx)...give up retrying\n",
1008				transaction_id);
1009		}
1010	} else {
1011		netdev_err(ndev, "unable to send receive "
1012			"completion pkt - %llx\n", transaction_id);
1013	}
1014}
1015
1016static void netvsc_receive(struct netvsc_device *net_device,
1017			struct vmbus_channel *channel,
1018			struct hv_device *device,
1019			struct vmpacket_descriptor *packet)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1020{
 
1021	struct vmtransfer_page_packet_header *vmxferpage_packet;
1022	struct nvsp_message *nvsp_packet;
1023	struct hv_netvsc_packet nv_pkt;
1024	struct hv_netvsc_packet *netvsc_packet = &nv_pkt;
1025	u32 status = NVSP_STAT_SUCCESS;
1026	int i;
1027	int count = 0;
 
1028	struct net_device *ndev;
1029	void *data;
1030
 
 
 
 
 
1031	ndev = net_device->ndev;
1032
1033	/*
1034	 * All inbound packets other than send completion should be xfer page
1035	 * packet
1036	 */
1037	if (packet->type != VM_PKT_DATA_USING_XFER_PAGES) {
1038		netdev_err(ndev, "Unknown packet type received - %d\n",
1039			   packet->type);
1040		return;
1041	}
1042
1043	nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
1044			(packet->offset8 << 3));
1045
1046	/* Make sure this is a valid nvsp packet */
1047	if (nvsp_packet->hdr.msg_type !=
1048	    NVSP_MSG1_TYPE_SEND_RNDIS_PKT) {
1049		netdev_err(ndev, "Unknown nvsp packet type received-"
1050			" %d\n", nvsp_packet->hdr.msg_type);
1051		return;
1052	}
1053
1054	vmxferpage_packet = (struct vmtransfer_page_packet_header *)packet;
1055
1056	if (vmxferpage_packet->xfer_pageset_id != NETVSC_RECEIVE_BUFFER_ID) {
1057		netdev_err(ndev, "Invalid xfer page set id - "
1058			   "expecting %x got %x\n", NETVSC_RECEIVE_BUFFER_ID,
1059			   vmxferpage_packet->xfer_pageset_id);
1060		return;
1061	}
1062
1063	count = vmxferpage_packet->range_cnt;
1064
1065	/* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
1066	for (i = 0; i < count; i++) {
1067		/* Initialize the netvsc packet */
1068		data = (void *)((unsigned long)net_device->
1069			recv_buf + vmxferpage_packet->ranges[i].byte_offset);
1070		netvsc_packet->total_data_buflen =
1071					vmxferpage_packet->ranges[i].byte_count;
1072
1073		/* Pass it to the upper layer */
1074		status = rndis_filter_receive(device, netvsc_packet, &data,
1075					      channel);
1076
1077	}
 
1078
1079	netvsc_send_recv_completion(device, channel, net_device,
1080				    vmxferpage_packet->d.trans_id, status);
1081}
1082
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1083
1084static void netvsc_send_table(struct hv_device *hdev,
1085			      struct nvsp_message *nvmsg)
1086{
1087	struct netvsc_device *nvscdev;
1088	struct net_device *ndev;
1089	int i;
1090	u32 count, *tab;
1091
1092	nvscdev = get_outbound_net_device(hdev);
1093	if (!nvscdev)
1094		return;
1095	ndev = nvscdev->ndev;
1096
1097	count = nvmsg->msg.v5_msg.send_table.count;
1098	if (count != VRSS_SEND_TAB_SIZE) {
1099		netdev_err(ndev, "Received wrong send-table size:%u\n", count);
1100		return;
 
 
 
 
 
 
 
1101	}
1102
1103	tab = (u32 *)((unsigned long)&nvmsg->msg.v5_msg.send_table +
1104		      nvmsg->msg.v5_msg.send_table.offset);
 
 
1105
1106	for (i = 0; i < count; i++)
1107		nvscdev->send_table[i] = tab[i];
1108}
 
 
 
 
 
 
 
1109
1110static void netvsc_send_vf(struct netvsc_device *nvdev,
1111			   struct nvsp_message *nvmsg)
1112{
1113	nvdev->vf_alloc = nvmsg->msg.v4_msg.vf_assoc.allocated;
1114	nvdev->vf_serial = nvmsg->msg.v4_msg.vf_assoc.serial;
1115}
1116
1117static inline void netvsc_receive_inband(struct hv_device *hdev,
1118					 struct netvsc_device *nvdev,
1119					 struct nvsp_message *nvmsg)
1120{
1121	switch (nvmsg->hdr.msg_type) {
1122	case NVSP_MSG5_TYPE_SEND_INDIRECTION_TABLE:
1123		netvsc_send_table(hdev, nvmsg);
1124		break;
1125
1126	case NVSP_MSG4_TYPE_SEND_VF_ASSOCIATION:
1127		netvsc_send_vf(nvdev, nvmsg);
1128		break;
1129	}
 
1130}
1131
1132void netvsc_channel_cb(void *context)
1133{
1134	int ret;
1135	struct vmbus_channel *channel = (struct vmbus_channel *)context;
1136	struct hv_device *device;
1137	struct netvsc_device *net_device;
1138	u32 bytes_recvd;
1139	u64 request_id;
 
1140	struct vmpacket_descriptor *desc;
1141	unsigned char *buffer;
1142	int bufferlen = NETVSC_PACKET_SIZE;
1143	struct net_device *ndev;
1144	struct nvsp_message *nvmsg;
1145
1146	if (channel->primary_channel != NULL)
1147		device = channel->primary_channel->device_obj;
1148	else
1149		device = channel->device_obj;
 
1150
1151	net_device = get_inbound_net_device(device);
1152	if (!net_device)
1153		return;
1154	ndev = net_device->ndev;
1155	buffer = get_per_channel_state(channel);
1156
1157	do {
1158		ret = vmbus_recvpacket_raw(channel, buffer, bufferlen,
1159					   &bytes_recvd, &request_id);
1160		if (ret == 0) {
1161			if (bytes_recvd > 0) {
1162				desc = (struct vmpacket_descriptor *)buffer;
1163				nvmsg = (struct nvsp_message *)((unsigned long)
1164					 desc + (desc->offset8 << 3));
1165				switch (desc->type) {
1166				case VM_PKT_COMP:
1167					netvsc_send_completion(net_device,
1168								channel,
1169								device, desc);
1170					break;
1171
1172				case VM_PKT_DATA_USING_XFER_PAGES:
1173					netvsc_receive(net_device, channel,
1174						       device, desc);
1175					break;
1176
1177				case VM_PKT_DATA_INBAND:
1178					netvsc_receive_inband(device,
1179							      net_device,
1180							      nvmsg);
1181					break;
1182
1183				default:
1184					netdev_err(ndev,
1185						   "unhandled packet type %d, "
1186						   "tid %llx len %d\n",
1187						   desc->type, request_id,
1188						   bytes_recvd);
1189					break;
1190				}
1191
 
 
 
 
 
 
1192			} else {
1193				/*
1194				 * We are done for this pass.
1195				 */
 
 
 
 
1196				break;
1197			}
1198
1199		} else if (ret == -ENOBUFS) {
1200			if (bufferlen > NETVSC_PACKET_SIZE)
1201				kfree(buffer);
1202			/* Handle large packet */
1203			buffer = kmalloc(bytes_recvd, GFP_ATOMIC);
1204			if (buffer == NULL) {
1205				/* Try again next time around */
1206				netdev_err(ndev,
1207					   "unable to allocate buffer of size "
1208					   "(%d)!!\n", bytes_recvd);
1209				break;
1210			}
1211
1212			bufferlen = bytes_recvd;
1213		}
1214	} while (1);
1215
1216	if (bufferlen > NETVSC_PACKET_SIZE)
1217		kfree(buffer);
1218	return;
1219}
1220
1221/*
1222 * netvsc_device_add - Callback when the device belonging to this
1223 * driver is added
1224 */
1225int netvsc_device_add(struct hv_device *device, void *additional_info)
1226{
1227	int ret = 0;
 
1228	int ring_size =
1229	((struct netvsc_device_info *)additional_info)->ring_size;
1230	struct netvsc_device *net_device;
 
1231	struct net_device *ndev;
1232
1233	net_device = alloc_net_device(device);
1234	if (!net_device)
1235		return -ENOMEM;
1236
1237	net_device->ring_size = ring_size;
1238
1239	/*
1240	 * Coming into this function, struct net_device * is
1241	 * registered as the driver private data.
1242	 * In alloc_net_device(), we register struct netvsc_device *
1243	 * as the driver private data and stash away struct net_device *
1244	 * in struct netvsc_device *.
1245	 */
1246	ndev = net_device->ndev;
1247
1248	/* Add netvsc_device context to netvsc_device */
1249	net_device->nd_ctx = netdev_priv(ndev);
1250
1251	/* Initialize the NetVSC channel extension */
1252	init_completion(&net_device->channel_init_wait);
 
 
 
 
 
 
 
 
 
 
1253
1254	set_per_channel_state(device->channel, net_device->cb_buffer);
 
 
 
1255
1256	/* Open the channel */
1257	ret = vmbus_open(device->channel, ring_size * PAGE_SIZE,
1258			 ring_size * PAGE_SIZE, NULL, 0,
1259			 netvsc_channel_cb, device->channel);
1260
1261	if (ret != 0) {
1262		netdev_err(ndev, "unable to open channel: %d\n", ret);
1263		goto cleanup;
1264	}
1265
1266	/* Channel is opened */
1267	pr_info("hv_netvsc channel opened successfully\n");
1268
1269	net_device->chn_table[0] = device->channel;
1270
1271	/* Connect with the NetVsp */
1272	ret = netvsc_connect_vsp(device);
1273	if (ret != 0) {
1274		netdev_err(ndev,
1275			"unable to connect to NetVSP - %d\n", ret);
1276		goto close;
1277	}
1278
1279	return ret;
1280
1281close:
1282	/* Now, we can close the channel safely */
1283	vmbus_close(device->channel);
1284
1285cleanup:
1286	free_netvsc_device(net_device);
 
 
 
 
 
 
 
 
 
 
1287
1288	return ret;
1289}
v3.5.6
  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, write to the Free Software Foundation, Inc., 59 Temple
 15 * Place - Suite 330, Boston, MA 02111-1307 USA.
 16 *
 17 * Authors:
 18 *   Haiyang Zhang <haiyangz@microsoft.com>
 19 *   Hank Janssen  <hjanssen@microsoft.com>
 20 */
 21#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 22
 23#include <linux/kernel.h>
 24#include <linux/sched.h>
 25#include <linux/wait.h>
 26#include <linux/mm.h>
 27#include <linux/delay.h>
 28#include <linux/io.h>
 29#include <linux/slab.h>
 30#include <linux/netdevice.h>
 31#include <linux/if_ether.h>
 
 
 32
 33#include "hyperv_net.h"
 34
 35
 36static struct netvsc_device *alloc_net_device(struct hv_device *device)
 37{
 38	struct netvsc_device *net_device;
 39	struct net_device *ndev = hv_get_drvdata(device);
 40
 41	net_device = kzalloc(sizeof(struct netvsc_device), GFP_KERNEL);
 42	if (!net_device)
 43		return NULL;
 44
 
 
 
 
 
 
 45	init_waitqueue_head(&net_device->wait_drain);
 46	net_device->start_remove = false;
 47	net_device->destroy = false;
 48	net_device->dev = device;
 49	net_device->ndev = ndev;
 
 
 50
 51	hv_set_drvdata(device, net_device);
 52	return net_device;
 53}
 54
 
 
 
 
 
 
 55static struct netvsc_device *get_outbound_net_device(struct hv_device *device)
 56{
 57	struct netvsc_device *net_device;
 58
 59	net_device = hv_get_drvdata(device);
 60	if (net_device && net_device->destroy)
 61		net_device = NULL;
 62
 63	return net_device;
 64}
 65
 66static struct netvsc_device *get_inbound_net_device(struct hv_device *device)
 67{
 68	struct netvsc_device *net_device;
 69
 70	net_device = hv_get_drvdata(device);
 71
 72	if (!net_device)
 73		goto get_in_err;
 74
 75	if (net_device->destroy &&
 76		atomic_read(&net_device->num_outstanding_sends) == 0)
 77		net_device = NULL;
 78
 79get_in_err:
 80	return net_device;
 81}
 82
 83
 84static int netvsc_destroy_recv_buf(struct netvsc_device *net_device)
 85{
 86	struct nvsp_message *revoke_packet;
 87	int ret = 0;
 88	struct net_device *ndev = net_device->ndev;
 89
 90	/*
 91	 * If we got a section count, it means we received a
 92	 * SendReceiveBufferComplete msg (ie sent
 93	 * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
 94	 * to send a revoke msg here
 95	 */
 96	if (net_device->recv_section_cnt) {
 97		/* Send the revoke receive buffer */
 98		revoke_packet = &net_device->revoke_packet;
 99		memset(revoke_packet, 0, sizeof(struct nvsp_message));
100
101		revoke_packet->hdr.msg_type =
102			NVSP_MSG1_TYPE_REVOKE_RECV_BUF;
103		revoke_packet->msg.v1_msg.
104		revoke_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
105
106		ret = vmbus_sendpacket(net_device->dev->channel,
107				       revoke_packet,
108				       sizeof(struct nvsp_message),
109				       (unsigned long)revoke_packet,
110				       VM_PKT_DATA_INBAND, 0);
111		/*
112		 * If we failed here, we might as well return and
113		 * have a leak rather than continue and a bugchk
114		 */
115		if (ret != 0) {
116			netdev_err(ndev, "unable to send "
117				"revoke receive buffer to netvsp\n");
118			return ret;
119		}
120	}
121
122	/* Teardown the gpadl on the vsp end */
123	if (net_device->recv_buf_gpadl_handle) {
124		ret = vmbus_teardown_gpadl(net_device->dev->channel,
125			   net_device->recv_buf_gpadl_handle);
126
127		/* If we failed here, we might as well return and have a leak
128		 * rather than continue and a bugchk
129		 */
130		if (ret != 0) {
131			netdev_err(ndev,
132				   "unable to teardown receive buffer's gpadl\n");
133			return ret;
134		}
135		net_device->recv_buf_gpadl_handle = 0;
136	}
137
138	if (net_device->recv_buf) {
139		/* Free up the receive buffer */
140		free_pages((unsigned long)net_device->recv_buf,
141			get_order(net_device->recv_buf_size));
142		net_device->recv_buf = NULL;
143	}
144
145	if (net_device->recv_section) {
146		net_device->recv_section_cnt = 0;
147		kfree(net_device->recv_section);
148		net_device->recv_section = NULL;
149	}
150
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
151	return ret;
152}
153
154static int netvsc_init_recv_buf(struct hv_device *device)
155{
156	int ret = 0;
157	int t;
158	struct netvsc_device *net_device;
159	struct nvsp_message *init_packet;
160	struct net_device *ndev;
 
161
162	net_device = get_outbound_net_device(device);
163	if (!net_device)
164		return -ENODEV;
165	ndev = net_device->ndev;
166
167	net_device->recv_buf =
168		(void *)__get_free_pages(GFP_KERNEL|__GFP_ZERO,
169				get_order(net_device->recv_buf_size));
 
 
170	if (!net_device->recv_buf) {
171		netdev_err(ndev, "unable to allocate receive "
172			"buffer of size %d\n", net_device->recv_buf_size);
173		ret = -ENOMEM;
174		goto cleanup;
175	}
176
177	/*
178	 * Establish the gpadl handle for this buffer on this
179	 * channel.  Note: This call uses the vmbus connection rather
180	 * than the channel to establish the gpadl handle.
181	 */
182	ret = vmbus_establish_gpadl(device->channel, net_device->recv_buf,
183				    net_device->recv_buf_size,
184				    &net_device->recv_buf_gpadl_handle);
185	if (ret != 0) {
186		netdev_err(ndev,
187			"unable to establish receive buffer's gpadl\n");
188		goto cleanup;
189	}
190
191
192	/* Notify the NetVsp of the gpadl handle */
193	init_packet = &net_device->channel_init_pkt;
194
195	memset(init_packet, 0, sizeof(struct nvsp_message));
196
197	init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_RECV_BUF;
198	init_packet->msg.v1_msg.send_recv_buf.
199		gpadl_handle = net_device->recv_buf_gpadl_handle;
200	init_packet->msg.v1_msg.
201		send_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
202
203	/* Send the gpadl notification request */
204	ret = vmbus_sendpacket(device->channel, init_packet,
205			       sizeof(struct nvsp_message),
206			       (unsigned long)init_packet,
207			       VM_PKT_DATA_INBAND,
208			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
209	if (ret != 0) {
210		netdev_err(ndev,
211			"unable to send receive buffer's gpadl to netvsp\n");
212		goto cleanup;
213	}
214
215	t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
216	BUG_ON(t == 0);
217
218
219	/* Check the response */
220	if (init_packet->msg.v1_msg.
221	    send_recv_buf_complete.status != NVSP_STAT_SUCCESS) {
222		netdev_err(ndev, "Unable to complete receive buffer "
223			   "initialization with NetVsp - status %d\n",
224			   init_packet->msg.v1_msg.
225			   send_recv_buf_complete.status);
226		ret = -EINVAL;
227		goto cleanup;
228	}
229
230	/* Parse the response */
231
232	net_device->recv_section_cnt = init_packet->msg.
233		v1_msg.send_recv_buf_complete.num_sections;
234
235	net_device->recv_section = kmemdup(
236		init_packet->msg.v1_msg.send_recv_buf_complete.sections,
237		net_device->recv_section_cnt *
238		sizeof(struct nvsp_1_receive_buffer_section),
239		GFP_KERNEL);
240	if (net_device->recv_section == NULL) {
241		ret = -EINVAL;
242		goto cleanup;
243	}
244
245	/*
246	 * For 1st release, there should only be 1 section that represents the
247	 * entire receive buffer
248	 */
249	if (net_device->recv_section_cnt != 1 ||
250	    net_device->recv_section->offset != 0) {
251		ret = -EINVAL;
252		goto cleanup;
253	}
254
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
255	goto exit;
256
257cleanup:
258	netvsc_destroy_recv_buf(net_device);
259
260exit:
261	return ret;
262}
263
264
265/* Negotiate NVSP protocol version */
266static int negotiate_nvsp_ver(struct hv_device *device,
267			      struct netvsc_device *net_device,
268			      struct nvsp_message *init_packet,
269			      u32 nvsp_ver)
270{
271	int ret, t;
 
272
273	memset(init_packet, 0, sizeof(struct nvsp_message));
274	init_packet->hdr.msg_type = NVSP_MSG_TYPE_INIT;
275	init_packet->msg.init_msg.init.min_protocol_ver = nvsp_ver;
276	init_packet->msg.init_msg.init.max_protocol_ver = nvsp_ver;
277
278	/* Send the init request */
279	ret = vmbus_sendpacket(device->channel, init_packet,
280			       sizeof(struct nvsp_message),
281			       (unsigned long)init_packet,
282			       VM_PKT_DATA_INBAND,
283			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
284
285	if (ret != 0)
286		return ret;
287
288	t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
289
290	if (t == 0)
291		return -ETIMEDOUT;
292
293	if (init_packet->msg.init_msg.init_complete.status !=
294	    NVSP_STAT_SUCCESS)
295		return -EINVAL;
296
297	if (nvsp_ver != NVSP_PROTOCOL_VERSION_2)
298		return 0;
299
300	/* NVSPv2 only: Send NDIS config */
301	memset(init_packet, 0, sizeof(struct nvsp_message));
302	init_packet->hdr.msg_type = NVSP_MSG2_TYPE_SEND_NDIS_CONFIG;
303	init_packet->msg.v2_msg.send_ndis_config.mtu = net_device->ndev->mtu;
 
304	init_packet->msg.v2_msg.send_ndis_config.capability.ieee8021q = 1;
305
 
 
 
306	ret = vmbus_sendpacket(device->channel, init_packet,
307				sizeof(struct nvsp_message),
308				(unsigned long)init_packet,
309				VM_PKT_DATA_INBAND, 0);
310
311	return ret;
312}
313
314static int netvsc_connect_vsp(struct hv_device *device)
315{
316	int ret;
317	struct netvsc_device *net_device;
318	struct nvsp_message *init_packet;
319	int ndis_version;
320	struct net_device *ndev;
 
 
 
321
322	net_device = get_outbound_net_device(device);
323	if (!net_device)
324		return -ENODEV;
325	ndev = net_device->ndev;
326
327	init_packet = &net_device->channel_init_pkt;
328
329	/* Negotiate the latest NVSP protocol supported */
330	if (negotiate_nvsp_ver(device, net_device, init_packet,
331			       NVSP_PROTOCOL_VERSION_2) == 0) {
332		net_device->nvsp_version = NVSP_PROTOCOL_VERSION_2;
333	} else if (negotiate_nvsp_ver(device, net_device, init_packet,
334				    NVSP_PROTOCOL_VERSION_1) == 0) {
335		net_device->nvsp_version = NVSP_PROTOCOL_VERSION_1;
336	} else {
 
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	ndis_version = 0x00050001;
 
 
 
347
348	init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_NDIS_VER;
349	init_packet->msg.v1_msg.
350		send_ndis_ver.ndis_major_ver =
351				(ndis_version & 0xFFFF0000) >> 16;
352	init_packet->msg.v1_msg.
353		send_ndis_ver.ndis_minor_ver =
354				ndis_version & 0xFFFF;
355
356	/* Send the init request */
357	ret = vmbus_sendpacket(device->channel, init_packet,
358				sizeof(struct nvsp_message),
359				(unsigned long)init_packet,
360				VM_PKT_DATA_INBAND, 0);
361	if (ret != 0)
362		goto cleanup;
363
364	/* Post the big receive buffer to NetVSP */
365	ret = netvsc_init_recv_buf(device);
 
 
 
 
 
 
366
367cleanup:
368	return ret;
369}
370
371static void netvsc_disconnect_vsp(struct netvsc_device *net_device)
372{
373	netvsc_destroy_recv_buf(net_device);
374}
375
376/*
377 * netvsc_device_remove - Callback when the root bus device is removed
378 */
379int netvsc_device_remove(struct hv_device *device)
380{
381	struct netvsc_device *net_device;
382	struct hv_netvsc_packet *netvsc_packet, *pos;
383	unsigned long flags;
384
385	net_device = hv_get_drvdata(device);
386	spin_lock_irqsave(&device->channel->inbound_lock, flags);
387	net_device->destroy = true;
388	spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
389
390	/* Wait for all send completions */
391	wait_event(net_device->wait_drain,
392		   atomic_read(&net_device->num_outstanding_sends) == 0);
393
394	netvsc_disconnect_vsp(net_device);
395
396	/*
397	 * Since we have already drained, we don't need to busy wait
398	 * as was done in final_release_stor_device()
399	 * Note that we cannot set the ext pointer to NULL until
400	 * we have drained - to drain the outgoing packets, we need to
401	 * allow incoming packets.
402	 */
403
404	spin_lock_irqsave(&device->channel->inbound_lock, flags);
405	hv_set_drvdata(device, NULL);
406	spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
407
408	/*
409	 * At this point, no one should be accessing net_device
410	 * except in here
411	 */
412	dev_notice(&device->device, "net device safe to remove\n");
413
414	/* Now, we can close the channel safely */
415	vmbus_close(device->channel);
416
417	/* Release all resources */
418	list_for_each_entry_safe(netvsc_packet, pos,
419				 &net_device->recv_pkt_list, list_ent) {
420		list_del(&netvsc_packet->list_ent);
421		kfree(netvsc_packet);
422	}
423
424	kfree(net_device);
425	return 0;
426}
427
428
429#define RING_AVAIL_PERCENT_HIWATER 20
430#define RING_AVAIL_PERCENT_LOWATER 10
431
432/*
433 * Get the percentage of available bytes to write in the ring.
434 * The return value is in range from 0 to 100.
435 */
436static inline u32 hv_ringbuf_avail_percent(
437		struct hv_ring_buffer_info *ring_info)
438{
439	u32 avail_read, avail_write;
440
441	hv_get_ringbuffer_availbytes(ring_info, &avail_read, &avail_write);
442
443	return avail_write * 100 / ring_info->ring_datasize;
444}
445
446static void netvsc_send_completion(struct hv_device *device,
 
 
 
 
 
 
 
 
447				   struct vmpacket_descriptor *packet)
448{
449	struct netvsc_device *net_device;
450	struct nvsp_message *nvsp_packet;
451	struct hv_netvsc_packet *nvsc_packet;
452	struct net_device *ndev;
 
 
453
454	net_device = get_inbound_net_device(device);
455	if (!net_device)
456		return;
457	ndev = net_device->ndev;
458
459	nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
460			(packet->offset8 << 3));
461
462	if ((nvsp_packet->hdr.msg_type == NVSP_MSG_TYPE_INIT_COMPLETE) ||
463	    (nvsp_packet->hdr.msg_type ==
464	     NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE) ||
465	    (nvsp_packet->hdr.msg_type ==
466	     NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE)) {
 
 
467		/* Copy the response back */
468		memcpy(&net_device->channel_init_pkt, nvsp_packet,
469		       sizeof(struct nvsp_message));
470		complete(&net_device->channel_init_wait);
471	} else if (nvsp_packet->hdr.msg_type ==
472		   NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE) {
473		int num_outstanding_sends;
 
 
 
474
475		/* Get the send context */
476		nvsc_packet = (struct hv_netvsc_packet *)(unsigned long)
477			packet->trans_id;
478
479		/* Notify the layer above us */
480		nvsc_packet->completion.send.send_completion(
481			nvsc_packet->completion.send.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
509	net_device = get_outbound_net_device(device);
510	if (!net_device)
511		return -ENODEV;
512	ndev = net_device->ndev;
 
 
 
 
 
 
 
 
 
 
 
513
514	sendMessage.hdr.msg_type = NVSP_MSG1_TYPE_SEND_RNDIS_PKT;
515	if (packet->is_data_pkt) {
516		/* 0 is RMC_DATA; */
517		sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 0;
518	} else {
519		/* 1 is RMC_CONTROL; */
520		sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 1;
521	}
522
523	/* Not using send buffer section */
524	sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_index =
525		0xFFFFFFFF;
526	sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_size = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
527
528	if (packet->page_buf_cnt) {
529		ret = vmbus_sendpacket_pagebuffer(device->channel,
530						  packet->page_buf,
531						  packet->page_buf_cnt,
532						  &sendMessage,
533						  sizeof(struct nvsp_message),
534						  (unsigned long)packet);
 
 
 
 
535	} else {
536		ret = vmbus_sendpacket(device->channel, &sendMessage,
537				sizeof(struct nvsp_message),
538				(unsigned long)packet,
539				VM_PKT_DATA_INBAND,
540				VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
541
542	}
543
544	if (ret == 0) {
545		atomic_inc(&net_device->num_outstanding_sends);
546		if (hv_ringbuf_avail_percent(&device->channel->outbound) <
547			RING_AVAIL_PERCENT_LOWATER) {
548			netif_stop_queue(ndev);
 
 
549			if (atomic_read(&net_device->
550				num_outstanding_sends) < 1)
551				netif_wake_queue(ndev);
 
552		}
553	} else if (ret == -EAGAIN) {
554		netif_stop_queue(ndev);
555		if (atomic_read(&net_device->num_outstanding_sends) < 1) {
556			netif_wake_queue(ndev);
 
 
557			ret = -ENOSPC;
558		}
559	} else {
560		netdev_err(ndev, "Unable to send packet %p ret %d\n",
561			   packet, ret);
562	}
563
564	return ret;
565}
566
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
567static void netvsc_send_recv_completion(struct hv_device *device,
568					u64 transaction_id)
 
 
569{
570	struct nvsp_message recvcompMessage;
571	int retries = 0;
572	int ret;
573	struct net_device *ndev;
574	struct netvsc_device *net_device = hv_get_drvdata(device);
575
576	ndev = net_device->ndev;
577
578	recvcompMessage.hdr.msg_type =
579				NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE;
580
581	/* FIXME: Pass in the status */
582	recvcompMessage.msg.v1_msg.send_rndis_pkt_complete.status =
583		NVSP_STAT_SUCCESS;
584
585retry_send_cmplt:
586	/* Send the completion */
587	ret = vmbus_sendpacket(device->channel, &recvcompMessage,
588			       sizeof(struct nvsp_message), transaction_id,
589			       VM_PKT_COMP, 0);
590	if (ret == 0) {
591		/* success */
592		/* no-op */
593	} else if (ret == -EAGAIN) {
594		/* no more room...wait a bit and attempt to retry 3 times */
595		retries++;
596		netdev_err(ndev, "unable to send receive completion pkt"
597			" (tid %llx)...retrying %d\n", transaction_id, retries);
598
599		if (retries < 4) {
600			udelay(100);
601			goto retry_send_cmplt;
602		} else {
603			netdev_err(ndev, "unable to send receive "
604				"completion pkt (tid %llx)...give up retrying\n",
605				transaction_id);
606		}
607	} else {
608		netdev_err(ndev, "unable to send receive "
609			"completion pkt - %llx\n", transaction_id);
610	}
611}
612
613/* Send a receive completion packet to RNDIS device (ie NetVsp) */
614static void netvsc_receive_completion(void *context)
615{
616	struct hv_netvsc_packet *packet = context;
617	struct hv_device *device = (struct hv_device *)packet->device;
618	struct netvsc_device *net_device;
619	u64 transaction_id = 0;
620	bool fsend_receive_comp = false;
621	unsigned long flags;
622	struct net_device *ndev;
623
624	/*
625	 * Even though it seems logical to do a GetOutboundNetDevice() here to
626	 * send out receive completion, we are using GetInboundNetDevice()
627	 * since we may have disable outbound traffic already.
628	 */
629	net_device = get_inbound_net_device(device);
630	if (!net_device)
631		return;
632	ndev = net_device->ndev;
633
634	/* Overloading use of the lock. */
635	spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
636
637	packet->xfer_page_pkt->count--;
638
639	/*
640	 * Last one in the line that represent 1 xfer page packet.
641	 * Return the xfer page packet itself to the freelist
642	 */
643	if (packet->xfer_page_pkt->count == 0) {
644		fsend_receive_comp = true;
645		transaction_id = packet->completion.recv.recv_completion_tid;
646		list_add_tail(&packet->xfer_page_pkt->list_ent,
647			      &net_device->recv_pkt_list);
648
649	}
650
651	/* Put the packet back */
652	list_add_tail(&packet->list_ent, &net_device->recv_pkt_list);
653	spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags);
654
655	/* Send a receive completion for the xfer page packet */
656	if (fsend_receive_comp)
657		netvsc_send_recv_completion(device, transaction_id);
658
659}
660
661static void netvsc_receive(struct hv_device *device,
662			    struct vmpacket_descriptor *packet)
663{
664	struct netvsc_device *net_device;
665	struct vmtransfer_page_packet_header *vmxferpage_packet;
666	struct nvsp_message *nvsp_packet;
667	struct hv_netvsc_packet *netvsc_packet = NULL;
668	/* struct netvsc_driver *netvscDriver; */
669	struct xferpage_packet *xferpage_packet = NULL;
670	int i;
671	int count = 0;
672	unsigned long flags;
673	struct net_device *ndev;
 
674
675	LIST_HEAD(listHead);
676
677	net_device = get_inbound_net_device(device);
678	if (!net_device)
679		return;
680	ndev = net_device->ndev;
681
682	/*
683	 * All inbound packets other than send completion should be xfer page
684	 * packet
685	 */
686	if (packet->type != VM_PKT_DATA_USING_XFER_PAGES) {
687		netdev_err(ndev, "Unknown packet type received - %d\n",
688			   packet->type);
689		return;
690	}
691
692	nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
693			(packet->offset8 << 3));
694
695	/* Make sure this is a valid nvsp packet */
696	if (nvsp_packet->hdr.msg_type !=
697	    NVSP_MSG1_TYPE_SEND_RNDIS_PKT) {
698		netdev_err(ndev, "Unknown nvsp packet type received-"
699			" %d\n", nvsp_packet->hdr.msg_type);
700		return;
701	}
702
703	vmxferpage_packet = (struct vmtransfer_page_packet_header *)packet;
704
705	if (vmxferpage_packet->xfer_pageset_id != NETVSC_RECEIVE_BUFFER_ID) {
706		netdev_err(ndev, "Invalid xfer page set id - "
707			   "expecting %x got %x\n", NETVSC_RECEIVE_BUFFER_ID,
708			   vmxferpage_packet->xfer_pageset_id);
709		return;
710	}
711
712	/*
713	 * Grab free packets (range count + 1) to represent this xfer
714	 * page packet. +1 to represent the xfer page packet itself.
715	 * We grab it here so that we know exactly how many we can
716	 * fulfil
717	 */
718	spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
719	while (!list_empty(&net_device->recv_pkt_list)) {
720		list_move_tail(net_device->recv_pkt_list.next, &listHead);
721		if (++count == vmxferpage_packet->range_cnt + 1)
722			break;
 
 
 
723	}
724	spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags);
725
726	/*
727	 * We need at least 2 netvsc pkts (1 to represent the xfer
728	 * page and at least 1 for the range) i.e. we can handled
729	 * some of the xfer page packet ranges...
730	 */
731	if (count < 2) {
732		netdev_err(ndev, "Got only %d netvsc pkt...needed "
733			"%d pkts. Dropping this xfer page packet completely!\n",
734			count, vmxferpage_packet->range_cnt + 1);
735
736		/* Return it to the freelist */
737		spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
738		for (i = count; i != 0; i--) {
739			list_move_tail(listHead.next,
740				       &net_device->recv_pkt_list);
741		}
742		spin_unlock_irqrestore(&net_device->recv_pkt_list_lock,
743				       flags);
744
745		netvsc_send_recv_completion(device,
746					    vmxferpage_packet->d.trans_id);
 
 
 
 
 
747
 
 
748		return;
749	}
750
751	/* Remove the 1st packet to represent the xfer page packet itself */
752	xferpage_packet = (struct xferpage_packet *)listHead.next;
753	list_del(&xferpage_packet->list_ent);
754
755	/* This is how much we can satisfy */
756	xferpage_packet->count = count - 1;
757
758	if (xferpage_packet->count != vmxferpage_packet->range_cnt) {
759		netdev_err(ndev, "Needed %d netvsc pkts to satisfy "
760			"this xfer page...got %d\n",
761			vmxferpage_packet->range_cnt, xferpage_packet->count);
762	}
763
764	/* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
765	for (i = 0; i < (count - 1); i++) {
766		netvsc_packet = (struct hv_netvsc_packet *)listHead.next;
767		list_del(&netvsc_packet->list_ent);
768
769		/* Initialize the netvsc packet */
770		netvsc_packet->xfer_page_pkt = xferpage_packet;
771		netvsc_packet->completion.recv.recv_completion =
772					netvsc_receive_completion;
773		netvsc_packet->completion.recv.recv_completion_ctx =
774					netvsc_packet;
775		netvsc_packet->device = device;
776		/* Save this so that we can send it back */
777		netvsc_packet->completion.recv.recv_completion_tid =
778					vmxferpage_packet->d.trans_id;
779
780		netvsc_packet->data = (void *)((unsigned long)net_device->
781			recv_buf + vmxferpage_packet->ranges[i].byte_offset);
782		netvsc_packet->total_data_buflen =
783					vmxferpage_packet->ranges[i].byte_count;
 
 
784
785		/* Pass it to the upper layer */
786		rndis_filter_receive(device, netvsc_packet);
787
788		netvsc_receive_completion(netvsc_packet->
789				completion.recv.recv_completion_ctx);
 
 
 
 
 
 
 
790	}
791
792}
793
794static void netvsc_channel_cb(void *context)
795{
796	int ret;
797	struct hv_device *device = context;
 
798	struct netvsc_device *net_device;
799	u32 bytes_recvd;
800	u64 request_id;
801	unsigned char *packet;
802	struct vmpacket_descriptor *desc;
803	unsigned char *buffer;
804	int bufferlen = NETVSC_PACKET_SIZE;
805	struct net_device *ndev;
 
806
807	packet = kzalloc(NETVSC_PACKET_SIZE * sizeof(unsigned char),
808			 GFP_ATOMIC);
809	if (!packet)
810		return;
811	buffer = packet;
812
813	net_device = get_inbound_net_device(device);
814	if (!net_device)
815		goto out;
816	ndev = net_device->ndev;
 
817
818	do {
819		ret = vmbus_recvpacket_raw(device->channel, buffer, bufferlen,
820					   &bytes_recvd, &request_id);
821		if (ret == 0) {
822			if (bytes_recvd > 0) {
823				desc = (struct vmpacket_descriptor *)buffer;
 
 
824				switch (desc->type) {
825				case VM_PKT_COMP:
826					netvsc_send_completion(device, desc);
 
 
827					break;
828
829				case VM_PKT_DATA_USING_XFER_PAGES:
830					netvsc_receive(device, desc);
 
 
 
 
 
 
 
831					break;
832
833				default:
834					netdev_err(ndev,
835						   "unhandled packet type %d, "
836						   "tid %llx len %d\n",
837						   desc->type, request_id,
838						   bytes_recvd);
839					break;
840				}
841
842				/* reset */
843				if (bufferlen > NETVSC_PACKET_SIZE) {
844					kfree(buffer);
845					buffer = packet;
846					bufferlen = NETVSC_PACKET_SIZE;
847				}
848			} else {
849				/* reset */
850				if (bufferlen > NETVSC_PACKET_SIZE) {
851					kfree(buffer);
852					buffer = packet;
853					bufferlen = NETVSC_PACKET_SIZE;
854				}
855
856				break;
857			}
 
858		} else if (ret == -ENOBUFS) {
 
 
859			/* Handle large packet */
860			buffer = kmalloc(bytes_recvd, GFP_ATOMIC);
861			if (buffer == NULL) {
862				/* Try again next time around */
863				netdev_err(ndev,
864					   "unable to allocate buffer of size "
865					   "(%d)!!\n", bytes_recvd);
866				break;
867			}
868
869			bufferlen = bytes_recvd;
870		}
871	} while (1);
872
873out:
874	kfree(buffer);
875	return;
876}
877
878/*
879 * netvsc_device_add - Callback when the device belonging to this
880 * driver is added
881 */
882int netvsc_device_add(struct hv_device *device, void *additional_info)
883{
884	int ret = 0;
885	int i;
886	int ring_size =
887	((struct netvsc_device_info *)additional_info)->ring_size;
888	struct netvsc_device *net_device;
889	struct hv_netvsc_packet *packet, *pos;
890	struct net_device *ndev;
891
892	net_device = alloc_net_device(device);
893	if (!net_device) {
894		ret = -ENOMEM;
895		goto cleanup;
896	}
897
898	/*
899	 * Coming into this function, struct net_device * is
900	 * registered as the driver private data.
901	 * In alloc_net_device(), we register struct netvsc_device *
902	 * as the driver private data and stash away struct net_device *
903	 * in struct netvsc_device *.
904	 */
905	ndev = net_device->ndev;
906
 
 
 
907	/* Initialize the NetVSC channel extension */
908	net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE;
909	spin_lock_init(&net_device->recv_pkt_list_lock);
910
911	INIT_LIST_HEAD(&net_device->recv_pkt_list);
912
913	for (i = 0; i < NETVSC_RECEIVE_PACKETLIST_COUNT; i++) {
914		packet = kzalloc(sizeof(struct hv_netvsc_packet) +
915				 (NETVSC_RECEIVE_SG_COUNT *
916				  sizeof(struct hv_page_buffer)), GFP_KERNEL);
917		if (!packet)
918			break;
919
920		list_add_tail(&packet->list_ent,
921			      &net_device->recv_pkt_list);
922	}
923	init_completion(&net_device->channel_init_wait);
924
925	/* Open the channel */
926	ret = vmbus_open(device->channel, ring_size * PAGE_SIZE,
927			 ring_size * PAGE_SIZE, NULL, 0,
928			 netvsc_channel_cb, device);
929
930	if (ret != 0) {
931		netdev_err(ndev, "unable to open channel: %d\n", ret);
932		goto cleanup;
933	}
934
935	/* Channel is opened */
936	pr_info("hv_netvsc channel opened successfully\n");
937
 
 
938	/* Connect with the NetVsp */
939	ret = netvsc_connect_vsp(device);
940	if (ret != 0) {
941		netdev_err(ndev,
942			"unable to connect to NetVSP - %d\n", ret);
943		goto close;
944	}
945
946	return ret;
947
948close:
949	/* Now, we can close the channel safely */
950	vmbus_close(device->channel);
951
952cleanup:
953
954	if (net_device) {
955		list_for_each_entry_safe(packet, pos,
956					 &net_device->recv_pkt_list,
957					 list_ent) {
958			list_del(&packet->list_ent);
959			kfree(packet);
960		}
961
962		kfree(net_device);
963	}
964
965	return ret;
966}