drivers/staging/hv/NetVsc.c

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