drivers/staging/hv/netvsc.c

   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 #include <linux/kernel.h>
  22 #include <linux/mm.h>
  23 #include <linux/delay.h>
  24 #include <linux/io.h>
  25 #include <linux/slab.h>
  26 #include "osd.h"
  27 #include "logging.h"
  28 #include "netvsc.h"
  29 #include "rndis_filter.h"
  30 #include "channel.h"
  31
  32
  33 /* Globals */
  34 static const char *gDriverName = "netvsc";
  35
  36 /* {F8615163-DF3E-46c5-913F-F2D2F965ED0E} */
  37 static const struct hv_guid gNetVscDeviceType = {
  38         .data = {
  39                 0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46,
  40                 0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E
  41         }
  42 };
  43
  44 static int NetVscOnDeviceAdd(struct hv_device *Device, void *AdditionalInfo);
  45
  46 static int NetVscOnDeviceRemove(struct hv_device *Device);
  47
  48 static void NetVscOnCleanup(struct hv_driver *Driver);
  49
  50 static void NetVscOnChannelCallback(void *context);
  51
  52 static int NetVscInitializeSendBufferWithNetVsp(struct hv_device *Device);
  53
  54 static int NetVscInitializeReceiveBufferWithNetVsp(struct hv_device *Device);
  55
  56 static int NetVscDestroySendBuffer(struct netvsc_device *NetDevice);
  57
  58 static int NetVscDestroyReceiveBuffer(struct netvsc_device *NetDevice);
  59
  60 static int NetVscConnectToVsp(struct hv_device *Device);
  61
  62 static void NetVscOnSendCompletion(struct hv_device *Device,
  63                                    struct vmpacket_descriptor *Packet);
  64
  65 static int NetVscOnSend(struct hv_device *Device,
  66                         struct hv_netvsc_packet *Packet);
  67
  68 static void NetVscOnReceive(struct hv_device *Device,
  69                             struct vmpacket_descriptor *Packet);
  70
  71 static void NetVscOnReceiveCompletion(void *Context);
  72
  73 static void NetVscSendReceiveCompletion(struct hv_device *Device,
  74                                         u64 TransactionId);
  75
  76
  77 static struct netvsc_device *AllocNetDevice(struct hv_device *Device)
  78 {
  79         struct netvsc_device *netDevice;
  80
  81         netDevice = kzalloc(sizeof(struct netvsc_device), GFP_KERNEL);
  82         if (!netDevice)
  83                 return NULL;
  84
  85         /* Set to 2 to allow both inbound and outbound traffic */
  86         atomic_cmpxchg(&netDevice->RefCount, 0, 2);
  87
  88         netDevice->Device = Device;
  89         Device->Extension = netDevice;
  90
  91         return netDevice;
  92 }
  93
  94 static void FreeNetDevice(struct netvsc_device *Device)
  95 {
  96         WARN_ON(atomic_read(&Device->RefCount) == 0);
  97         Device->Device->Extension = NULL;
  98         kfree(Device);
  99 }
 100
 101
 102 /* Get the net device object iff exists and its refcount > 1 */
 103 static struct netvsc_device *GetOutboundNetDevice(struct hv_device *Device)
 104 {
 105         struct netvsc_device *netDevice;
 106
 107         netDevice = Device->Extension;
 108         if (netDevice && atomic_read(&netDevice->RefCount) > 1)
 109                 atomic_inc(&netDevice->RefCount);
 110         else
 111                 netDevice = NULL;
 112
 113         return netDevice;
 114 }
 115
 116 /* Get the net device object iff exists and its refcount > 0 */
 117 static struct netvsc_device *GetInboundNetDevice(struct hv_device *Device)
 118 {
 119         struct netvsc_device *netDevice;
 120
 121         netDevice = Device->Extension;
 122         if (netDevice && atomic_read(&netDevice->RefCount))
 123                 atomic_inc(&netDevice->RefCount);
 124         else
 125                 netDevice = NULL;
 126
 127         return netDevice;
 128 }
 129
 130 static void PutNetDevice(struct hv_device *Device)
 131 {
 132         struct netvsc_device *netDevice;
 133
 134         netDevice = Device->Extension;
 135         /* ASSERT(netDevice); */
 136
 137         atomic_dec(&netDevice->RefCount);
 138 }
 139
 140 static struct netvsc_device *ReleaseOutboundNetDevice(struct hv_device *Device)
 141 {
 142         struct netvsc_device *netDevice;
 143
 144         netDevice = Device->Extension;
 145         if (netDevice == NULL)
 146                 return NULL;
 147
 148         /* Busy wait until the ref drop to 2, then set it to 1 */
 149         while (atomic_cmpxchg(&netDevice->RefCount, 2, 1) != 2)
 150                 udelay(100);
 151
 152         return netDevice;
 153 }
 154
 155 static struct netvsc_device *ReleaseInboundNetDevice(struct hv_device *Device)
 156 {
 157         struct netvsc_device *netDevice;
 158
 159         netDevice = Device->Extension;
 160         if (netDevice == NULL)
 161                 return NULL;
 162
 163         /* Busy wait until the ref drop to 1, then set it to 0 */
 164         while (atomic_cmpxchg(&netDevice->RefCount, 1, 0) != 1)
 165                 udelay(100);
 166
 167         Device->Extension = NULL;
 168         return netDevice;
 169 }
 170
 171 /*
 172  * NetVscInitialize - Main entry point
 173  */
 174 int NetVscInitialize(struct hv_driver *drv)
 175 {
 176         struct netvsc_driver *driver = (struct netvsc_driver *)drv;
 177
 178         DPRINT_DBG(NETVSC, "sizeof(struct hv_netvsc_packet)=%zd, "
 179                    "sizeof(struct nvsp_message)=%zd, "
 180                    "sizeof(struct vmtransfer_page_packet_header)=%zd",
 181                    sizeof(struct hv_netvsc_packet),
 182                    sizeof(struct nvsp_message),
 183                    sizeof(struct vmtransfer_page_packet_header));
 184
 185         /* Make sure we are at least 2 pages since 1 page is used for control */
 186         /* ASSERT(driver->RingBufferSize >= (PAGE_SIZE << 1)); */
 187
 188         drv->name = gDriverName;
 189         memcpy(&drv->deviceType, &gNetVscDeviceType, sizeof(struct hv_guid));
 190
 191         /* Make sure it is set by the caller */
 192         /* FIXME: These probably should still be tested in some way */
 193         /* ASSERT(driver->OnReceiveCallback); */
 194         /* ASSERT(driver->OnLinkStatusChanged); */
 195
 196         /* Setup the dispatch table */
 197         driver->Base.OnDeviceAdd        = NetVscOnDeviceAdd;
 198         driver->Base.OnDeviceRemove     = NetVscOnDeviceRemove;
 199         driver->Base.OnCleanup          = NetVscOnCleanup;
 200
 201         driver->OnSend                  = NetVscOnSend;
 202
 203         RndisFilterInit(driver);
 204         return 0;
 205 }
 206
 207 static int NetVscInitializeReceiveBufferWithNetVsp(struct hv_device *Device)
 208 {
 209         int ret = 0;
 210         struct netvsc_device *netDevice;
 211         struct nvsp_message *initPacket;
 212
 213         netDevice = GetOutboundNetDevice(Device);
 214         if (!netDevice) {
 215                 DPRINT_ERR(NETVSC, "unable to get net device..."
 216                            "device being destroyed?");
 217                 return -1;
 218         }
 219         /* ASSERT(netDevice->ReceiveBufferSize > 0); */
 220         /* page-size grandularity */
 221         /* ASSERT((netDevice->ReceiveBufferSize & (PAGE_SIZE - 1)) == 0); */
 222
 223         netDevice->ReceiveBuffer =
 224                 osd_PageAlloc(netDevice->ReceiveBufferSize >> PAGE_SHIFT);
 225         if (!netDevice->ReceiveBuffer) {
 226                 DPRINT_ERR(NETVSC,
 227                            "unable to allocate receive buffer of size %d",
 228                            netDevice->ReceiveBufferSize);
 229                 ret = -1;
 230                 goto Cleanup;
 231         }
 232         /* page-aligned buffer */
 233         /* ASSERT(((unsigned long)netDevice->ReceiveBuffer & (PAGE_SIZE - 1)) == */
 234         /*      0); */
 235
 236         DPRINT_INFO(NETVSC, "Establishing receive buffer's GPADL...");
 237
 238         /*
 239          * Establish the gpadl handle for this buffer on this
 240          * channel.  Note: This call uses the vmbus connection rather
 241          * than the channel to establish the gpadl handle.
 242          */
 243         ret = vmbus_establish_gpadl(Device->channel, netDevice->ReceiveBuffer,
 244                                     netDevice->ReceiveBufferSize,
 245                                     &netDevice->ReceiveBufferGpadlHandle);
 246         if (ret != 0) {
 247                 DPRINT_ERR(NETVSC,
 248                            "unable to establish receive buffer's gpadl");
 249                 goto Cleanup;
 250         }
 251
 252         /* osd_WaitEventWait(ext->ChannelInitEvent); */
 253
 254         /* Notify the NetVsp of the gpadl handle */
 255         DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendReceiveBuffer...");
 256
 257         initPacket = &netDevice->ChannelInitPacket;
 258
 259         memset(initPacket, 0, sizeof(struct nvsp_message));
 260
 261         initPacket->Header.MessageType = NvspMessage1TypeSendReceiveBuffer;
 262         initPacket->Messages.Version1Messages.SendReceiveBuffer.GpadlHandle = netDevice->ReceiveBufferGpadlHandle;
 263         initPacket->Messages.Version1Messages.SendReceiveBuffer.Id = NETVSC_RECEIVE_BUFFER_ID;
 264
 265         /* Send the gpadl notification request */
 266         ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
 267                                 initPacket,
 268                                 sizeof(struct nvsp_message),
 269                                 (unsigned long)initPacket,
 270                                 VmbusPacketTypeDataInBand,
 271                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 272         if (ret != 0) {
 273                 DPRINT_ERR(NETVSC,
 274                            "unable to send receive buffer's gpadl to netvsp");
 275                 goto Cleanup;
 276         }
 277
 278         osd_WaitEventWait(netDevice->ChannelInitEvent);
 279
 280         /* Check the response */
 281         if (initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Status != NvspStatusSuccess) {
 282                 DPRINT_ERR(NETVSC, "Unable to complete receive buffer "
 283                            "initialzation with NetVsp - status %d",
 284                            initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Status);
 285                 ret = -1;
 286                 goto Cleanup;
 287         }
 288
 289         /* Parse the response */
 290         /* ASSERT(netDevice->ReceiveSectionCount == 0); */
 291         /* ASSERT(netDevice->ReceiveSections == NULL); */
 292
 293         netDevice->ReceiveSectionCount = initPacket->Messages.Version1Messages.SendReceiveBufferComplete.NumSections;
 294
 295         netDevice->ReceiveSections = kmalloc(netDevice->ReceiveSectionCount * sizeof(struct nvsp_1_receive_buffer_section), GFP_KERNEL);
 296         if (netDevice->ReceiveSections == NULL) {
 297                 ret = -1;
 298                 goto Cleanup;
 299         }
 300
 301         memcpy(netDevice->ReceiveSections,
 302                 initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Sections,
 303                 netDevice->ReceiveSectionCount * sizeof(struct nvsp_1_receive_buffer_section));
 304
 305         DPRINT_INFO(NETVSC, "Receive sections info (count %d, offset %d, "
 306                     "endoffset %d, suballoc size %d, num suballocs %d)",
 307                     netDevice->ReceiveSectionCount,
 308                     netDevice->ReceiveSections[0].Offset,
 309                     netDevice->ReceiveSections[0].EndOffset,
 310                     netDevice->ReceiveSections[0].SubAllocationSize,
 311                     netDevice->ReceiveSections[0].NumSubAllocations);
 312
 313         /*
 314          * For 1st release, there should only be 1 section that represents the
 315          * entire receive buffer
 316          */
 317         if (netDevice->ReceiveSectionCount != 1 ||
 318             netDevice->ReceiveSections->Offset != 0) {
 319                 ret = -1;
 320                 goto Cleanup;
 321         }
 322
 323         goto Exit;
 324
 325 Cleanup:
 326         NetVscDestroyReceiveBuffer(netDevice);
 327
 328 Exit:
 329         PutNetDevice(Device);
 330         return ret;
 331 }
 332
 333 static int NetVscInitializeSendBufferWithNetVsp(struct hv_device *Device)
 334 {
 335         int ret = 0;
 336         struct netvsc_device *netDevice;
 337         struct nvsp_message *initPacket;
 338
 339         netDevice = GetOutboundNetDevice(Device);
 340         if (!netDevice) {
 341                 DPRINT_ERR(NETVSC, "unable to get net device..."
 342                            "device being destroyed?");
 343                 return -1;
 344         }
 345         if (netDevice->SendBufferSize <= 0) {
 346                 ret = -EINVAL;
 347                 goto Cleanup;
 348         }
 349
 350         /* page-size grandularity */
 351         /* ASSERT((netDevice->SendBufferSize & (PAGE_SIZE - 1)) == 0); */
 352
 353         netDevice->SendBuffer =
 354                 osd_PageAlloc(netDevice->SendBufferSize >> PAGE_SHIFT);
 355         if (!netDevice->SendBuffer) {
 356                 DPRINT_ERR(NETVSC, "unable to allocate send buffer of size %d",
 357                            netDevice->SendBufferSize);
 358                 ret = -1;
 359                 goto Cleanup;
 360         }
 361         /* page-aligned buffer */
 362         /* ASSERT(((unsigned long)netDevice->SendBuffer & (PAGE_SIZE - 1)) == 0); */
 363
 364         DPRINT_INFO(NETVSC, "Establishing send buffer's GPADL...");
 365
 366         /*
 367          * Establish the gpadl handle for this buffer on this
 368          * channel.  Note: This call uses the vmbus connection rather
 369          * than the channel to establish the gpadl handle.
 370          */
 371         ret = vmbus_establish_gpadl(Device->channel, netDevice->SendBuffer,
 372                                     netDevice->SendBufferSize,
 373                                     &netDevice->SendBufferGpadlHandle);
 374         if (ret != 0) {
 375                 DPRINT_ERR(NETVSC, "unable to establish send buffer's gpadl");
 376                 goto Cleanup;
 377         }
 378
 379         /* osd_WaitEventWait(ext->ChannelInitEvent); */
 380
 381         /* Notify the NetVsp of the gpadl handle */
 382         DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendSendBuffer...");
 383
 384         initPacket = &netDevice->ChannelInitPacket;
 385
 386         memset(initPacket, 0, sizeof(struct nvsp_message));
 387
 388         initPacket->Header.MessageType = NvspMessage1TypeSendSendBuffer;
 389         initPacket->Messages.Version1Messages.SendReceiveBuffer.GpadlHandle = netDevice->SendBufferGpadlHandle;
 390         initPacket->Messages.Version1Messages.SendReceiveBuffer.Id = NETVSC_SEND_BUFFER_ID;
 391
 392         /* Send the gpadl notification request */
 393         ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
 394                                 initPacket, sizeof(struct nvsp_message),
 395                                 (unsigned long)initPacket,
 396                                 VmbusPacketTypeDataInBand,
 397                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 398         if (ret != 0) {
 399                 DPRINT_ERR(NETVSC,
 400                            "unable to send receive buffer's gpadl to netvsp");
 401                 goto Cleanup;
 402         }
 403
 404         osd_WaitEventWait(netDevice->ChannelInitEvent);
 405
 406         /* Check the response */
 407         if (initPacket->Messages.Version1Messages.SendSendBufferComplete.Status != NvspStatusSuccess) {
 408                 DPRINT_ERR(NETVSC, "Unable to complete send buffer "
 409                            "initialzation with NetVsp - status %d",
 410                            initPacket->Messages.Version1Messages.SendSendBufferComplete.Status);
 411                 ret = -1;
 412                 goto Cleanup;
 413         }
 414
 415         netDevice->SendSectionSize = initPacket->Messages.Version1Messages.SendSendBufferComplete.SectionSize;
 416
 417         goto Exit;
 418
 419 Cleanup:
 420         NetVscDestroySendBuffer(netDevice);
 421
 422 Exit:
 423         PutNetDevice(Device);
 424         return ret;
 425 }
 426
 427 static int NetVscDestroyReceiveBuffer(struct netvsc_device *NetDevice)
 428 {
 429         struct nvsp_message *revokePacket;
 430         int ret = 0;
 431
 432         /*
 433          * If we got a section count, it means we received a
 434          * SendReceiveBufferComplete msg (ie sent
 435          * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
 436          * to send a revoke msg here
 437          */
 438         if (NetDevice->ReceiveSectionCount) {
 439                 DPRINT_INFO(NETVSC,
 440                             "Sending NvspMessage1TypeRevokeReceiveBuffer...");
 441
 442                 /* Send the revoke receive buffer */
 443                 revokePacket = &NetDevice->RevokePacket;
 444                 memset(revokePacket, 0, sizeof(struct nvsp_message));
 445
 446                 revokePacket->Header.MessageType = NvspMessage1TypeRevokeReceiveBuffer;
 447                 revokePacket->Messages.Version1Messages.RevokeReceiveBuffer.Id = NETVSC_RECEIVE_BUFFER_ID;
 448
 449                 ret = NetDevice->Device->Driver->VmbusChannelInterface.SendPacket(
 450                                                 NetDevice->Device,
 451                                                 revokePacket,
 452                                                 sizeof(struct nvsp_message),
 453                                                 (unsigned long)revokePacket,
 454                                                 VmbusPacketTypeDataInBand, 0);
 455                 /*
 456                  * If we failed here, we might as well return and
 457                  * have a leak rather than continue and a bugchk
 458                  */
 459                 if (ret != 0) {
 460                         DPRINT_ERR(NETVSC, "unable to send revoke receive "
 461                                    "buffer to netvsp");
 462                         return -1;
 463                 }
 464         }
 465
 466         /* Teardown the gpadl on the vsp end */
 467         if (NetDevice->ReceiveBufferGpadlHandle) {
 468                 DPRINT_INFO(NETVSC, "Tearing down receive buffer's GPADL...");
 469
 470                 ret = vmbus_teardown_gpadl(NetDevice->Device->channel,
 471                                            NetDevice->ReceiveBufferGpadlHandle);
 472
 473                 /* If we failed here, we might as well return and have a leak rather than continue and a bugchk */
 474                 if (ret != 0) {
 475                         DPRINT_ERR(NETVSC,
 476                                    "unable to teardown receive buffer's gpadl");
 477                         return -1;
 478                 }
 479                 NetDevice->ReceiveBufferGpadlHandle = 0;
 480         }
 481
 482         if (NetDevice->ReceiveBuffer) {
 483                 DPRINT_INFO(NETVSC, "Freeing up receive buffer...");
 484
 485                 /* Free up the receive buffer */
 486                 osd_PageFree(NetDevice->ReceiveBuffer,
 487                              NetDevice->ReceiveBufferSize >> PAGE_SHIFT);
 488                 NetDevice->ReceiveBuffer = NULL;
 489         }
 490
 491         if (NetDevice->ReceiveSections) {
 492                 NetDevice->ReceiveSectionCount = 0;
 493                 kfree(NetDevice->ReceiveSections);
 494                 NetDevice->ReceiveSections = NULL;
 495         }
 496
 497         return ret;
 498 }
 499
 500 static int NetVscDestroySendBuffer(struct netvsc_device *NetDevice)
 501 {
 502         struct nvsp_message *revokePacket;
 503         int ret = 0;
 504
 505         /*
 506          * If we got a section count, it means we received a
 507          *  SendReceiveBufferComplete msg (ie sent
 508          *  NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
 509          *  to send a revoke msg here
 510          */
 511         if (NetDevice->SendSectionSize) {
 512                 DPRINT_INFO(NETVSC,
 513                             "Sending NvspMessage1TypeRevokeSendBuffer...");
 514
 515                 /* Send the revoke send buffer */
 516                 revokePacket = &NetDevice->RevokePacket;
 517                 memset(revokePacket, 0, sizeof(struct nvsp_message));
 518
 519                 revokePacket->Header.MessageType = NvspMessage1TypeRevokeSendBuffer;
 520                 revokePacket->Messages.Version1Messages.RevokeSendBuffer.Id = NETVSC_SEND_BUFFER_ID;
 521
 522                 ret = NetDevice->Device->Driver->VmbusChannelInterface.SendPacket(NetDevice->Device,
 523                                         revokePacket,
 524                                         sizeof(struct nvsp_message),
 525                                         (unsigned long)revokePacket,
 526                                         VmbusPacketTypeDataInBand, 0);
 527                 /*
 528                  * If we failed here, we might as well return and have a leak
 529                  * rather than continue and a bugchk
 530                  */
 531                 if (ret != 0) {
 532                         DPRINT_ERR(NETVSC, "unable to send revoke send buffer "
 533                                    "to netvsp");
 534                         return -1;
 535                 }
 536         }
 537
 538         /* Teardown the gpadl on the vsp end */
 539         if (NetDevice->SendBufferGpadlHandle) {
 540                 DPRINT_INFO(NETVSC, "Tearing down send buffer's GPADL...");
 541                 ret = vmbus_teardown_gpadl(NetDevice->Device->channel,
 542                                            NetDevice->SendBufferGpadlHandle);
 543
 544                 /*
 545                  * If we failed here, we might as well return and have a leak
 546                  * rather than continue and a bugchk
 547                  */
 548                 if (ret != 0) {
 549                         DPRINT_ERR(NETVSC, "unable to teardown send buffer's "
 550                                    "gpadl");
 551                         return -1;
 552                 }
 553                 NetDevice->SendBufferGpadlHandle = 0;
 554         }
 555
 556         if (NetDevice->SendBuffer) {
 557                 DPRINT_INFO(NETVSC, "Freeing up send buffer...");
 558
 559                 /* Free up the receive buffer */
 560                 osd_PageFree(NetDevice->SendBuffer,
 561                              NetDevice->SendBufferSize >> PAGE_SHIFT);
 562                 NetDevice->SendBuffer = NULL;
 563         }
 564
 565         return ret;
 566 }
 567
 568
 569 static int NetVscConnectToVsp(struct hv_device *Device)
 570 {
 571         int ret;
 572         struct netvsc_device *netDevice;
 573         struct nvsp_message *initPacket;
 574         int ndisVersion;
 575
 576         netDevice = GetOutboundNetDevice(Device);
 577         if (!netDevice) {
 578                 DPRINT_ERR(NETVSC, "unable to get net device..."
 579                            "device being destroyed?");
 580                 return -1;
 581         }
 582
 583         initPacket = &netDevice->ChannelInitPacket;
 584
 585         memset(initPacket, 0, sizeof(struct nvsp_message));
 586         initPacket->Header.MessageType = NvspMessageTypeInit;
 587         initPacket->Messages.InitMessages.Init.MinProtocolVersion = NVSP_MIN_PROTOCOL_VERSION;
 588         initPacket->Messages.InitMessages.Init.MaxProtocolVersion = NVSP_MAX_PROTOCOL_VERSION;
 589
 590         DPRINT_INFO(NETVSC, "Sending NvspMessageTypeInit...");
 591
 592         /* Send the init request */
 593         ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
 594                                 initPacket,
 595                                 sizeof(struct nvsp_message),
 596                                 (unsigned long)initPacket,
 597                                 VmbusPacketTypeDataInBand,
 598                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 599
 600         if (ret != 0) {
 601                 DPRINT_ERR(NETVSC, "unable to send NvspMessageTypeInit");
 602                 goto Cleanup;
 603         }
 604
 605         osd_WaitEventWait(netDevice->ChannelInitEvent);
 606
 607         /* Now, check the response */
 608         /* ASSERT(initPacket->Messages.InitMessages.InitComplete.MaximumMdlChainLength <= MAX_MULTIPAGE_BUFFER_COUNT); */
 609         DPRINT_INFO(NETVSC, "NvspMessageTypeInit status(%d) max mdl chain (%d)",
 610                 initPacket->Messages.InitMessages.InitComplete.Status,
 611                 initPacket->Messages.InitMessages.InitComplete.MaximumMdlChainLength);
 612
 613         if (initPacket->Messages.InitMessages.InitComplete.Status !=
 614             NvspStatusSuccess) {
 615                 DPRINT_ERR(NETVSC,
 616                         "unable to initialize with netvsp (status 0x%x)",
 617                         initPacket->Messages.InitMessages.InitComplete.Status);
 618                 ret = -1;
 619                 goto Cleanup;
 620         }
 621
 622         if (initPacket->Messages.InitMessages.InitComplete.NegotiatedProtocolVersion != NVSP_PROTOCOL_VERSION_1) {
 623                 DPRINT_ERR(NETVSC, "unable to initialize with netvsp "
 624                            "(version expected 1 got %d)",
 625                            initPacket->Messages.InitMessages.InitComplete.NegotiatedProtocolVersion);
 626                 ret = -1;
 627                 goto Cleanup;
 628         }
 629         DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendNdisVersion...");
 630
 631         /* Send the ndis version */
 632         memset(initPacket, 0, sizeof(struct nvsp_message));
 633
 634         ndisVersion = 0x00050000;
 635
 636         initPacket->Header.MessageType = NvspMessage1TypeSendNdisVersion;
 637         initPacket->Messages.Version1Messages.SendNdisVersion.NdisMajorVersion =
 638                                 (ndisVersion & 0xFFFF0000) >> 16;
 639         initPacket->Messages.Version1Messages.SendNdisVersion.NdisMinorVersion =
 640                                 ndisVersion & 0xFFFF;
 641
 642         /* Send the init request */
 643         ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
 644                                         initPacket,
 645                                         sizeof(struct nvsp_message),
 646                                         (unsigned long)initPacket,
 647                                         VmbusPacketTypeDataInBand, 0);
 648         if (ret != 0) {
 649                 DPRINT_ERR(NETVSC,
 650                            "unable to send NvspMessage1TypeSendNdisVersion");
 651                 ret = -1;
 652                 goto Cleanup;
 653         }
 654         /*
 655          * BUGBUG - We have to wait for the above msg since the
 656          * netvsp uses KMCL which acknowledges packet (completion
 657          * packet) since our Vmbus always set the
 658          * VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED flag
 659          */
 660          /* osd_WaitEventWait(NetVscChannel->ChannelInitEvent); */
 661
 662         /* Post the big receive buffer to NetVSP */
 663         ret = NetVscInitializeReceiveBufferWithNetVsp(Device);
 664         if (ret == 0)
 665                 ret = NetVscInitializeSendBufferWithNetVsp(Device);
 666
 667 Cleanup:
 668         PutNetDevice(Device);
 669         return ret;
 670 }
 671
 672 static void NetVscDisconnectFromVsp(struct netvsc_device *NetDevice)
 673 {
 674         NetVscDestroyReceiveBuffer(NetDevice);
 675         NetVscDestroySendBuffer(NetDevice);
 676 }
 677
 678 /*
 679  * NetVscOnDeviceAdd - Callback when the device belonging to this driver is added
 680  */
 681 static int NetVscOnDeviceAdd(struct hv_device *Device, void *AdditionalInfo)
 682 {
 683         int ret = 0;
 684         int i;
 685         struct netvsc_device *netDevice;
 686         struct hv_netvsc_packet *packet, *pos;
 687         struct netvsc_driver *netDriver =
 688                                 (struct netvsc_driver *)Device->Driver;
 689
 690         netDevice = AllocNetDevice(Device);
 691         if (!netDevice) {
 692                 ret = -1;
 693                 goto Cleanup;
 694         }
 695
 696         DPRINT_DBG(NETVSC, "netvsc channel object allocated - %p", netDevice);
 697
 698         /* Initialize the NetVSC channel extension */
 699         netDevice->ReceiveBufferSize = NETVSC_RECEIVE_BUFFER_SIZE;
 700         spin_lock_init(&netDevice->receive_packet_list_lock);
 701
 702         netDevice->SendBufferSize = NETVSC_SEND_BUFFER_SIZE;
 703
 704         INIT_LIST_HEAD(&netDevice->ReceivePacketList);
 705
 706         for (i = 0; i < NETVSC_RECEIVE_PACKETLIST_COUNT; i++) {
 707                 packet = kzalloc(sizeof(struct hv_netvsc_packet) +
 708                                  (NETVSC_RECEIVE_SG_COUNT *
 709                                   sizeof(struct hv_page_buffer)), GFP_KERNEL);
 710                 if (!packet) {
 711                         DPRINT_DBG(NETVSC, "unable to allocate netvsc pkts "
 712                                    "for receive pool (wanted %d got %d)",
 713                                    NETVSC_RECEIVE_PACKETLIST_COUNT, i);
 714                         break;
 715                 }
 716                 list_add_tail(&packet->ListEntry,
 717                               &netDevice->ReceivePacketList);
 718         }
 719         netDevice->ChannelInitEvent = osd_WaitEventCreate();
 720         if (!netDevice->ChannelInitEvent) {
 721                 ret = -ENOMEM;
 722                 goto Cleanup;
 723         }
 724
 725         /* Open the channel */
 726         ret = Device->Driver->VmbusChannelInterface.Open(Device,
 727                                                 netDriver->RingBufferSize,
 728                                                 netDriver->RingBufferSize,
 729                                                 NULL, 0,
 730                                                 NetVscOnChannelCallback,
 731                                                 Device);
 732
 733         if (ret != 0) {
 734                 DPRINT_ERR(NETVSC, "unable to open channel: %d", ret);
 735                 ret = -1;
 736                 goto Cleanup;
 737         }
 738
 739         /* Channel is opened */
 740         DPRINT_INFO(NETVSC, "*** NetVSC channel opened successfully! ***");
 741
 742         /* Connect with the NetVsp */
 743         ret = NetVscConnectToVsp(Device);
 744         if (ret != 0) {
 745                 DPRINT_ERR(NETVSC, "unable to connect to NetVSP - %d", ret);
 746                 ret = -1;
 747                 goto Close;
 748         }
 749
 750         DPRINT_INFO(NETVSC, "*** NetVSC channel handshake result - %d ***",
 751                     ret);
 752
 753         return ret;
 754
 755 Close:
 756         /* Now, we can close the channel safely */
 757         Device->Driver->VmbusChannelInterface.Close(Device);
 758
 759 Cleanup:
 760
 761         if (netDevice) {
 762                 kfree(netDevice->ChannelInitEvent);
 763
 764                 list_for_each_entry_safe(packet, pos,
 765                                          &netDevice->ReceivePacketList,
 766                                          ListEntry) {
 767                         list_del(&packet->ListEntry);
 768                         kfree(packet);
 769                 }
 770
 771                 ReleaseOutboundNetDevice(Device);
 772                 ReleaseInboundNetDevice(Device);
 773
 774                 FreeNetDevice(netDevice);
 775         }
 776
 777         return ret;
 778 }
 779
 780 /*
 781  * NetVscOnDeviceRemove - Callback when the root bus device is removed
 782  */
 783 static int NetVscOnDeviceRemove(struct hv_device *Device)
 784 {
 785         struct netvsc_device *netDevice;
 786         struct hv_netvsc_packet *netvscPacket, *pos;
 787
 788         DPRINT_INFO(NETVSC, "Disabling outbound traffic on net device (%p)...",
 789                     Device->Extension);
 790
 791         /* Stop outbound traffic ie sends and receives completions */
 792         netDevice = ReleaseOutboundNetDevice(Device);
 793         if (!netDevice) {
 794                 DPRINT_ERR(NETVSC, "No net device present!!");
 795                 return -1;
 796         }
 797
 798         /* Wait for all send completions */
 799         while (atomic_read(&netDevice->NumOutstandingSends)) {
 800                 DPRINT_INFO(NETVSC, "waiting for %d requests to complete...",
 801                             atomic_read(&netDevice->NumOutstandingSends));
 802                 udelay(100);
 803         }
 804
 805         DPRINT_INFO(NETVSC, "Disconnecting from netvsp...");
 806
 807         NetVscDisconnectFromVsp(netDevice);
 808
 809         DPRINT_INFO(NETVSC, "Disabling inbound traffic on net device (%p)...",
 810                     Device->Extension);
 811
 812         /* Stop inbound traffic ie receives and sends completions */
 813         netDevice = ReleaseInboundNetDevice(Device);
 814
 815         /* At this point, no one should be accessing netDevice except in here */
 816         DPRINT_INFO(NETVSC, "net device (%p) safe to remove", netDevice);
 817
 818         /* Now, we can close the channel safely */
 819         Device->Driver->VmbusChannelInterface.Close(Device);
 820
 821         /* Release all resources */
 822         list_for_each_entry_safe(netvscPacket, pos,
 823                                  &netDevice->ReceivePacketList, ListEntry) {
 824                 list_del(&netvscPacket->ListEntry);
 825                 kfree(netvscPacket);
 826         }
 827
 828         kfree(netDevice->ChannelInitEvent);
 829         FreeNetDevice(netDevice);
 830         return 0;
 831 }
 832
 833 /*
 834  * NetVscOnCleanup - Perform any cleanup when the driver is removed
 835  */
 836 static void NetVscOnCleanup(struct hv_driver *drv)
 837 {
 838 }
 839
 840 static void NetVscOnSendCompletion(struct hv_device *Device,
 841                                    struct vmpacket_descriptor *Packet)
 842 {
 843         struct netvsc_device *netDevice;
 844         struct nvsp_message *nvspPacket;
 845         struct hv_netvsc_packet *nvscPacket;
 846
 847         netDevice = GetInboundNetDevice(Device);
 848         if (!netDevice) {
 849                 DPRINT_ERR(NETVSC, "unable to get net device..."
 850                            "device being destroyed?");
 851                 return;
 852         }
 853
 854         nvspPacket = (struct nvsp_message *)((unsigned long)Packet + (Packet->DataOffset8 << 3));
 855
 856         DPRINT_DBG(NETVSC, "send completion packet - type %d",
 857                    nvspPacket->Header.MessageType);
 858
 859         if ((nvspPacket->Header.MessageType == NvspMessageTypeInitComplete) ||
 860             (nvspPacket->Header.MessageType ==
 861              NvspMessage1TypeSendReceiveBufferComplete) ||
 862             (nvspPacket->Header.MessageType ==
 863              NvspMessage1TypeSendSendBufferComplete)) {
 864                 /* Copy the response back */
 865                 memcpy(&netDevice->ChannelInitPacket, nvspPacket,
 866                        sizeof(struct nvsp_message));
 867                 osd_WaitEventSet(netDevice->ChannelInitEvent);
 868         } else if (nvspPacket->Header.MessageType ==
 869                    NvspMessage1TypeSendRNDISPacketComplete) {
 870                 /* Get the send context */
 871                 nvscPacket = (struct hv_netvsc_packet *)(unsigned long)Packet->TransactionId;
 872                 /* ASSERT(nvscPacket); */
 873
 874                 /* Notify the layer above us */
 875                 nvscPacket->Completion.Send.OnSendCompletion(nvscPacket->Completion.Send.SendCompletionContext);
 876
 877                 atomic_dec(&netDevice->NumOutstandingSends);
 878         } else {
 879                 DPRINT_ERR(NETVSC, "Unknown send completion packet type - "
 880                            "%d received!!", nvspPacket->Header.MessageType);
 881         }
 882
 883         PutNetDevice(Device);
 884 }
 885
 886 static int NetVscOnSend(struct hv_device *Device,
 887                         struct hv_netvsc_packet *Packet)
 888 {
 889         struct netvsc_device *netDevice;
 890         int ret = 0;
 891
 892         struct nvsp_message sendMessage;
 893
 894         netDevice = GetOutboundNetDevice(Device);
 895         if (!netDevice) {
 896                 DPRINT_ERR(NETVSC, "net device (%p) shutting down..."
 897                            "ignoring outbound packets", netDevice);
 898                 return -2;
 899         }
 900
 901         sendMessage.Header.MessageType = NvspMessage1TypeSendRNDISPacket;
 902         if (Packet->IsDataPacket) {
 903                 /* 0 is RMC_DATA; */
 904                 sendMessage.Messages.Version1Messages.SendRNDISPacket.ChannelType = 0;
 905         } else {
 906                 /* 1 is RMC_CONTROL; */
 907                 sendMessage.Messages.Version1Messages.SendRNDISPacket.ChannelType = 1;
 908         }
 909
 910         /* Not using send buffer section */
 911         sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionIndex = 0xFFFFFFFF;
 912         sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionSize = 0;
 913
 914         if (Packet->PageBufferCount) {
 915                 ret = vmbus_sendpacket_pagebuffer(Device->channel,
 916                                                   Packet->PageBuffers,
 917                                                   Packet->PageBufferCount,
 918                                                   &sendMessage,
 919                                                   sizeof(struct nvsp_message),
 920                                                   (unsigned long)Packet);
 921         } else {
 922                 ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
 923                                 &sendMessage,
 924                                 sizeof(struct nvsp_message),
 925                                 (unsigned long)Packet,
 926                                 VmbusPacketTypeDataInBand,
 927                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 928
 929         }
 930
 931         if (ret != 0)
 932                 DPRINT_ERR(NETVSC, "Unable to send packet %p ret %d",
 933                            Packet, ret);
 934
 935         atomic_inc(&netDevice->NumOutstandingSends);
 936         PutNetDevice(Device);
 937         return ret;
 938 }
 939
 940 static void NetVscOnReceive(struct hv_device *Device,
 941                             struct vmpacket_descriptor *Packet)
 942 {
 943         struct netvsc_device *netDevice;
 944         struct vmtransfer_page_packet_header *vmxferpagePacket;
 945         struct nvsp_message *nvspPacket;
 946         struct hv_netvsc_packet *netvscPacket = NULL;
 947         unsigned long start;
 948         unsigned long end, endVirtual;
 949         /* struct netvsc_driver *netvscDriver; */
 950         struct xferpage_packet *xferpagePacket = NULL;
 951         int i, j;
 952         int count = 0, bytesRemain = 0;
 953         unsigned long flags;
 954         LIST_HEAD(listHead);
 955
 956         netDevice = GetInboundNetDevice(Device);
 957         if (!netDevice) {
 958                 DPRINT_ERR(NETVSC, "unable to get net device..."
 959                            "device being destroyed?");
 960                 return;
 961         }
 962
 963         /*
 964          * All inbound packets other than send completion should be xfer page
 965          * packet
 966          */
 967         if (Packet->Type != VmbusPacketTypeDataUsingTransferPages) {
 968                 DPRINT_ERR(NETVSC, "Unknown packet type received - %d",
 969                            Packet->Type);
 970                 PutNetDevice(Device);
 971                 return;
 972         }
 973
 974         nvspPacket = (struct nvsp_message *)((unsigned long)Packet +
 975                         (Packet->DataOffset8 << 3));
 976
 977         /* Make sure this is a valid nvsp packet */
 978         if (nvspPacket->Header.MessageType != NvspMessage1TypeSendRNDISPacket) {
 979                 DPRINT_ERR(NETVSC, "Unknown nvsp packet type received - %d",
 980                            nvspPacket->Header.MessageType);
 981                 PutNetDevice(Device);
 982                 return;
 983         }
 984
 985         DPRINT_DBG(NETVSC, "NVSP packet received - type %d",
 986                    nvspPacket->Header.MessageType);
 987
 988         vmxferpagePacket = (struct vmtransfer_page_packet_header *)Packet;
 989
 990         if (vmxferpagePacket->TransferPageSetId != NETVSC_RECEIVE_BUFFER_ID) {
 991                 DPRINT_ERR(NETVSC, "Invalid xfer page set id - "
 992                            "expecting %x got %x", NETVSC_RECEIVE_BUFFER_ID,
 993                            vmxferpagePacket->TransferPageSetId);
 994                 PutNetDevice(Device);
 995                 return;
 996         }
 997
 998         DPRINT_DBG(NETVSC, "xfer page - range count %d",
 999                    vmxferpagePacket->RangeCount);
1000
1001         /*
1002          * Grab free packets (range count + 1) to represent this xfer
1003          * page packet. +1 to represent the xfer page packet itself.
1004          * We grab it here so that we know exactly how many we can
1005          * fulfil
1006          */
1007         spin_lock_irqsave(&netDevice->receive_packet_list_lock, flags);
1008         while (!list_empty(&netDevice->ReceivePacketList)) {
1009                 list_move_tail(netDevice->ReceivePacketList.next, &listHead);
1010                 if (++count == vmxferpagePacket->RangeCount + 1)
1011                         break;
1012         }
1013         spin_unlock_irqrestore(&netDevice->receive_packet_list_lock, flags);
1014
1015         /*
1016          * We need at least 2 netvsc pkts (1 to represent the xfer
1017          * page and at least 1 for the range) i.e. we can handled
1018          * some of the xfer page packet ranges...
1019          */
1020         if (count < 2) {
1021                 DPRINT_ERR(NETVSC, "Got only %d netvsc pkt...needed %d pkts. "
1022                            "Dropping this xfer page packet completely!",
1023                            count, vmxferpagePacket->RangeCount + 1);
1024
1025                 /* Return it to the freelist */
1026                 spin_lock_irqsave(&netDevice->receive_packet_list_lock, flags);
1027                 for (i = count; i != 0; i--) {
1028                         list_move_tail(listHead.next,
1029                                        &netDevice->ReceivePacketList);
1030                 }
1031                 spin_unlock_irqrestore(&netDevice->receive_packet_list_lock,
1032                                        flags);
1033
1034                 NetVscSendReceiveCompletion(Device,
1035                                             vmxferpagePacket->d.TransactionId);
1036
1037                 PutNetDevice(Device);
1038                 return;
1039         }
1040
1041         /* Remove the 1st packet to represent the xfer page packet itself */
1042         xferpagePacket = (struct xferpage_packet *)listHead.next;
1043         list_del(&xferpagePacket->ListEntry);
1044
1045         /* This is how much we can satisfy */
1046         xferpagePacket->Count = count - 1;
1047         /* ASSERT(xferpagePacket->Count > 0 && xferpagePacket->Count <= */
1048         /*      vmxferpagePacket->RangeCount); */
1049
1050         if (xferpagePacket->Count != vmxferpagePacket->RangeCount) {
1051                 DPRINT_INFO(NETVSC, "Needed %d netvsc pkts to satisy this xfer "
1052                             "page...got %d", vmxferpagePacket->RangeCount,
1053                             xferpagePacket->Count);
1054         }
1055
1056         /* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
1057         for (i = 0; i < (count - 1); i++) {
1058                 netvscPacket = (struct hv_netvsc_packet *)listHead.next;
1059                 list_del(&netvscPacket->ListEntry);
1060
1061                 /* Initialize the netvsc packet */
1062                 netvscPacket->XferPagePacket = xferpagePacket;
1063                 netvscPacket->Completion.Recv.OnReceiveCompletion =
1064                                         NetVscOnReceiveCompletion;
1065                 netvscPacket->Completion.Recv.ReceiveCompletionContext =
1066                                         netvscPacket;
1067                 netvscPacket->Device = Device;
1068                 /* Save this so that we can send it back */
1069                 netvscPacket->Completion.Recv.ReceiveCompletionTid =
1070                                         vmxferpagePacket->d.TransactionId;
1071
1072                 netvscPacket->TotalDataBufferLength =
1073                                         vmxferpagePacket->Ranges[i].ByteCount;
1074                 netvscPacket->PageBufferCount = 1;
1075
1076                 /* ASSERT(vmxferpagePacket->Ranges[i].ByteOffset + */
1077                 /*      vmxferpagePacket->Ranges[i].ByteCount < */
1078                 /*      netDevice->ReceiveBufferSize); */
1079
1080                 netvscPacket->PageBuffers[0].Length =
1081                                         vmxferpagePacket->Ranges[i].ByteCount;
1082
1083                 start = virt_to_phys((void *)((unsigned long)netDevice->ReceiveBuffer + vmxferpagePacket->Ranges[i].ByteOffset));
1084
1085                 netvscPacket->PageBuffers[0].Pfn = start >> PAGE_SHIFT;
1086                 endVirtual = (unsigned long)netDevice->ReceiveBuffer
1087                     + vmxferpagePacket->Ranges[i].ByteOffset
1088                     + vmxferpagePacket->Ranges[i].ByteCount - 1;
1089                 end = virt_to_phys((void *)endVirtual);
1090
1091                 /* Calculate the page relative offset */
1092                 netvscPacket->PageBuffers[0].Offset =
1093                         vmxferpagePacket->Ranges[i].ByteOffset & (PAGE_SIZE - 1);
1094                 if ((end >> PAGE_SHIFT) != (start >> PAGE_SHIFT)) {
1095                         /* Handle frame across multiple pages: */
1096                         netvscPacket->PageBuffers[0].Length =
1097                                 (netvscPacket->PageBuffers[0].Pfn << PAGE_SHIFT)
1098                                 + PAGE_SIZE - start;
1099                         bytesRemain = netvscPacket->TotalDataBufferLength -
1100                                         netvscPacket->PageBuffers[0].Length;
1101                         for (j = 1; j < NETVSC_PACKET_MAXPAGE; j++) {
1102                                 netvscPacket->PageBuffers[j].Offset = 0;
1103                                 if (bytesRemain <= PAGE_SIZE) {
1104                                         netvscPacket->PageBuffers[j].Length = bytesRemain;
1105                                         bytesRemain = 0;
1106                                 } else {
1107                                         netvscPacket->PageBuffers[j].Length = PAGE_SIZE;
1108                                         bytesRemain -= PAGE_SIZE;
1109                                 }
1110                                 netvscPacket->PageBuffers[j].Pfn =
1111                                     virt_to_phys((void *)(endVirtual - bytesRemain)) >> PAGE_SHIFT;
1112                                 netvscPacket->PageBufferCount++;
1113                                 if (bytesRemain == 0)
1114                                         break;
1115                         }
1116                         /* ASSERT(bytesRemain == 0); */
1117                 }
1118                 DPRINT_DBG(NETVSC, "[%d] - (abs offset %u len %u) => "
1119                            "(pfn %llx, offset %u, len %u)", i,
1120                            vmxferpagePacket->Ranges[i].ByteOffset,
1121                            vmxferpagePacket->Ranges[i].ByteCount,
1122                            netvscPacket->PageBuffers[0].Pfn,
1123                            netvscPacket->PageBuffers[0].Offset,
1124                            netvscPacket->PageBuffers[0].Length);
1125
1126                 /* Pass it to the upper layer */
1127                 ((struct netvsc_driver *)Device->Driver)->OnReceiveCallback(Device, netvscPacket);
1128
1129                 NetVscOnReceiveCompletion(netvscPacket->Completion.Recv.ReceiveCompletionContext);
1130         }
1131
1132         /* ASSERT(list_empty(&listHead)); */
1133
1134         PutNetDevice(Device);
1135 }
1136
1137 static void NetVscSendReceiveCompletion(struct hv_device *Device,
1138                                         u64 TransactionId)
1139 {
1140         struct nvsp_message recvcompMessage;
1141         int retries = 0;
1142         int ret;
1143
1144         DPRINT_DBG(NETVSC, "Sending receive completion pkt - %llx",
1145                    TransactionId);
1146
1147         recvcompMessage.Header.MessageType =
1148                                 NvspMessage1TypeSendRNDISPacketComplete;
1149
1150         /* FIXME: Pass in the status */
1151         recvcompMessage.Messages.Version1Messages.SendRNDISPacketComplete.Status = NvspStatusSuccess;
1152
1153 retry_send_cmplt:
1154         /* Send the completion */
1155         ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
1156                                         &recvcompMessage,
1157                                         sizeof(struct nvsp_message),
1158                                         TransactionId,
1159                                         VmbusPacketTypeCompletion, 0);
1160         if (ret == 0) {
1161                 /* success */
1162                 /* no-op */
1163         } else if (ret == -1) {
1164                 /* no more room...wait a bit and attempt to retry 3 times */
1165                 retries++;
1166                 DPRINT_ERR(NETVSC, "unable to send receive completion pkt "
1167                            "(tid %llx)...retrying %d", TransactionId, retries);
1168
1169                 if (retries < 4) {
1170                         udelay(100);
1171                         goto retry_send_cmplt;
1172                 } else {
1173                         DPRINT_ERR(NETVSC, "unable to send receive completion "
1174                                   "pkt (tid %llx)...give up retrying",
1175                                   TransactionId);
1176                 }
1177         } else {
1178                 DPRINT_ERR(NETVSC, "unable to send receive completion pkt - "
1179                            "%llx", TransactionId);
1180         }
1181 }
1182
1183 /* Send a receive completion packet to RNDIS device (ie NetVsp) */
1184 static void NetVscOnReceiveCompletion(void *Context)
1185 {
1186         struct hv_netvsc_packet *packet = Context;
1187         struct hv_device *device = (struct hv_device *)packet->Device;
1188         struct netvsc_device *netDevice;
1189         u64 transactionId = 0;
1190         bool fSendReceiveComp = false;
1191         unsigned long flags;
1192
1193         /* ASSERT(packet->XferPagePacket); */
1194
1195         /*
1196          * Even though it seems logical to do a GetOutboundNetDevice() here to
1197          * send out receive completion, we are using GetInboundNetDevice()
1198          * since we may have disable outbound traffic already.
1199          */
1200         netDevice = GetInboundNetDevice(device);
1201         if (!netDevice) {
1202                 DPRINT_ERR(NETVSC, "unable to get net device..."
1203                            "device being destroyed?");
1204                 return;
1205         }
1206
1207         /* Overloading use of the lock. */
1208         spin_lock_irqsave(&netDevice->receive_packet_list_lock, flags);
1209
1210         /* ASSERT(packet->XferPagePacket->Count > 0); */
1211         packet->XferPagePacket->Count--;
1212
1213         /*
1214          * Last one in the line that represent 1 xfer page packet.
1215          * Return the xfer page packet itself to the freelist
1216          */
1217         if (packet->XferPagePacket->Count == 0) {
1218                 fSendReceiveComp = true;
1219                 transactionId = packet->Completion.Recv.ReceiveCompletionTid;
1220                 list_add_tail(&packet->XferPagePacket->ListEntry,
1221                               &netDevice->ReceivePacketList);
1222
1223         }
1224
1225         /* Put the packet back */
1226         list_add_tail(&packet->ListEntry, &netDevice->ReceivePacketList);
1227         spin_unlock_irqrestore(&netDevice->receive_packet_list_lock, flags);
1228
1229         /* Send a receive completion for the xfer page packet */
1230         if (fSendReceiveComp)
1231                 NetVscSendReceiveCompletion(device, transactionId);
1232
1233         PutNetDevice(device);
1234 }
1235
1236 static void NetVscOnChannelCallback(void *Context)
1237 {
1238         int ret;
1239         struct hv_device *device = Context;
1240         struct netvsc_device *netDevice;
1241         u32 bytesRecvd;
1242         u64 requestId;
1243         unsigned char *packet;
1244         struct vmpacket_descriptor *desc;
1245         unsigned char *buffer;
1246         int bufferlen = NETVSC_PACKET_SIZE;
1247
1248         /* ASSERT(device); */
1249
1250         packet = kzalloc(NETVSC_PACKET_SIZE * sizeof(unsigned char),
1251                          GFP_KERNEL);
1252         if (!packet)
1253                 return;
1254         buffer = packet;
1255
1256         netDevice = GetInboundNetDevice(device);
1257         if (!netDevice) {
1258                 DPRINT_ERR(NETVSC, "net device (%p) shutting down..."
1259                            "ignoring inbound packets", netDevice);
1260                 goto out;
1261         }
1262
1263         do {
1264                 ret = vmbus_recvpacket_raw(device->channel, buffer, bufferlen,
1265                                            &bytesRecvd, &requestId);
1266                 if (ret == 0) {
1267                         if (bytesRecvd > 0) {
1268                                 DPRINT_DBG(NETVSC, "receive %d bytes, tid %llx",
1269                                            bytesRecvd, requestId);
1270
1271                                 desc = (struct vmpacket_descriptor *)buffer;
1272                                 switch (desc->Type) {
1273                                 case VmbusPacketTypeCompletion:
1274                                         NetVscOnSendCompletion(device, desc);
1275                                         break;
1276
1277                                 case VmbusPacketTypeDataUsingTransferPages:
1278                                         NetVscOnReceive(device, desc);
1279                                         break;
1280
1281                                 default:
1282                                         DPRINT_ERR(NETVSC,
1283                                                    "unhandled packet type %d, "
1284                                                    "tid %llx len %d\n",
1285                                                    desc->Type, requestId,
1286                                                    bytesRecvd);
1287                                         break;
1288                                 }
1289
1290                                 /* reset */
1291                                 if (bufferlen > NETVSC_PACKET_SIZE) {
1292                                         kfree(buffer);
1293                                         buffer = packet;
1294                                         bufferlen = NETVSC_PACKET_SIZE;
1295                                 }
1296                         } else {
1297                                 /* reset */
1298                                 if (bufferlen > NETVSC_PACKET_SIZE) {
1299                                         kfree(buffer);
1300                                         buffer = packet;
1301                                         bufferlen = NETVSC_PACKET_SIZE;
1302                                 }
1303
1304                                 break;
1305                         }
1306                 } else if (ret == -2) {
1307                         /* Handle large packet */
1308                         buffer = kmalloc(bytesRecvd, GFP_ATOMIC);
1309                         if (buffer == NULL) {
1310                                 /* Try again next time around */
1311                                 DPRINT_ERR(NETVSC,
1312                                            "unable to allocate buffer of size "
1313                                            "(%d)!!", bytesRecvd);
1314                                 break;
1315                         }
1316
1317                         bufferlen = bytesRecvd;
1318                 }
1319         } while (1);
1320
1321         PutNetDevice(device);
1322 out:
1323         kfree(buffer);
1324         return;
1325 }