Pileus Git - ~andy/linux/blob - drivers/staging/hv/RndisFilter.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/highmem.h>
  23 #include <linux/io.h>
  24 #include "osd.h"
  25 #include "logging.h"
  26 #include "NetVscApi.h"
  27 #include "RndisFilter.h"
  28
  29 /* Data types */
  30 struct rndis_filter_driver_object {
  31         /* The original driver */
  32         struct netvsc_driver InnerDriver;
  33 };
  34
  35 enum rndis_device_state {
  36         RNDIS_DEV_UNINITIALIZED = 0,
  37         RNDIS_DEV_INITIALIZING,
  38         RNDIS_DEV_INITIALIZED,
  39         RNDIS_DEV_DATAINITIALIZED,
  40 };
  41
  42 struct rndis_device {
  43         struct netvsc_device *NetDevice;
  44
  45         enum rndis_device_state State;
  46         u32 LinkStatus;
  47         atomic_t NewRequestId;
  48
  49         spinlock_t request_lock;
  50         LIST_ENTRY RequestList;
  51
  52         unsigned char HwMacAddr[HW_MACADDR_LEN];
  53 };
  54
  55 struct rndis_request {
  56         LIST_ENTRY ListEntry;
  57         struct osd_waitevent *WaitEvent;
  58
  59         /*
  60          * FIXME: We assumed a fixed size response here. If we do ever need to
  61          * handle a bigger response, we can either define a max response
  62          * message or add a response buffer variable above this field
  63          */
  64         struct rndis_message ResponseMessage;
  65
  66         /* Simplify allocation by having a netvsc packet inline */
  67         struct hv_netvsc_packet Packet;
  68         struct hv_page_buffer Buffer;
  69         /* FIXME: We assumed a fixed size request here. */
  70         struct rndis_message RequestMessage;
  71 };
  72
  73
  74 struct rndis_filter_packet {
  75         void *CompletionContext;
  76         void (*OnCompletion)(void *context);
  77         struct rndis_message Message;
  78 };
  79
  80
  81 static int RndisFilterOnDeviceAdd(struct hv_device *Device,
  82                                   void *AdditionalInfo);
  83
  84 static int RndisFilterOnDeviceRemove(struct hv_device *Device);
  85
  86 static void RndisFilterOnCleanup(struct hv_driver *Driver);
  87
  88 static int RndisFilterOnOpen(struct hv_device *Device);
  89
  90 static int RndisFilterOnClose(struct hv_device *Device);
  91
  92 static int RndisFilterOnSend(struct hv_device *Device,
  93                              struct hv_netvsc_packet *Packet);
  94
  95 static void RndisFilterOnSendCompletion(void *Context);
  96
  97 static void RndisFilterOnSendRequestCompletion(void *Context);
  98
  99
 100 /* The one and only */
 101 static struct rndis_filter_driver_object gRndisFilter;
 102
 103 static struct rndis_device *GetRndisDevice(void)
 104 {
 105         struct rndis_device *device;
 106
 107         device = kzalloc(sizeof(struct rndis_device), GFP_KERNEL);
 108         if (!device)
 109                 return NULL;
 110
 111         spin_lock_init(&device->request_lock);
 112
 113         INITIALIZE_LIST_HEAD(&device->RequestList);
 114
 115         device->State = RNDIS_DEV_UNINITIALIZED;
 116
 117         return device;
 118 }
 119
 120 static struct rndis_request *GetRndisRequest(struct rndis_device *Device,
 121                                              u32 MessageType,
 122                                              u32 MessageLength)
 123 {
 124         struct rndis_request *request;
 125         struct rndis_message *rndisMessage;
 126         struct rndis_set_request *set;
 127         unsigned long flags;
 128
 129         request = kzalloc(sizeof(struct rndis_request), GFP_KERNEL);
 130         if (!request)
 131                 return NULL;
 132
 133         request->WaitEvent = osd_WaitEventCreate();
 134         if (!request->WaitEvent) {
 135                 kfree(request);
 136                 return NULL;
 137         }
 138
 139         rndisMessage = &request->RequestMessage;
 140         rndisMessage->NdisMessageType = MessageType;
 141         rndisMessage->MessageLength = MessageLength;
 142
 143         /*
 144          * Set the request id. This field is always after the rndis header for
 145          * request/response packet types so we just used the SetRequest as a
 146          * template
 147          */
 148         set = &rndisMessage->Message.SetRequest;
 149         set->RequestId = atomic_inc_return(&Device->NewRequestId);
 150
 151         /* Add to the request list */
 152         spin_lock_irqsave(&Device->request_lock, flags);
 153         INSERT_TAIL_LIST(&Device->RequestList, &request->ListEntry);
 154         spin_unlock_irqrestore(&Device->request_lock, flags);
 155
 156         return request;
 157 }
 158
 159 static void PutRndisRequest(struct rndis_device *Device,
 160                             struct rndis_request *Request)
 161 {
 162         unsigned long flags;
 163
 164         spin_lock_irqsave(&Device->request_lock, flags);
 165         REMOVE_ENTRY_LIST(&Request->ListEntry);
 166         spin_unlock_irqrestore(&Device->request_lock, flags);
 167
 168         kfree(Request->WaitEvent);
 169         kfree(Request);
 170 }
 171
 172 static void DumpRndisMessage(struct rndis_message *RndisMessage)
 173 {
 174         switch (RndisMessage->NdisMessageType) {
 175         case REMOTE_NDIS_PACKET_MSG:
 176                 DPRINT_DBG(NETVSC, "REMOTE_NDIS_PACKET_MSG (len %u, "
 177                            "data offset %u data len %u, # oob %u, "
 178                            "oob offset %u, oob len %u, pkt offset %u, "
 179                            "pkt len %u",
 180                            RndisMessage->MessageLength,
 181                            RndisMessage->Message.Packet.DataOffset,
 182                            RndisMessage->Message.Packet.DataLength,
 183                            RndisMessage->Message.Packet.NumOOBDataElements,
 184                            RndisMessage->Message.Packet.OOBDataOffset,
 185                            RndisMessage->Message.Packet.OOBDataLength,
 186                            RndisMessage->Message.Packet.PerPacketInfoOffset,
 187                            RndisMessage->Message.Packet.PerPacketInfoLength);
 188                 break;
 189
 190         case REMOTE_NDIS_INITIALIZE_CMPLT:
 191                 DPRINT_DBG(NETVSC, "REMOTE_NDIS_INITIALIZE_CMPLT "
 192                         "(len %u, id 0x%x, status 0x%x, major %d, minor %d, "
 193                         "device flags %d, max xfer size 0x%x, max pkts %u, "
 194                         "pkt aligned %u)",
 195                         RndisMessage->MessageLength,
 196                         RndisMessage->Message.InitializeComplete.RequestId,
 197                         RndisMessage->Message.InitializeComplete.Status,
 198                         RndisMessage->Message.InitializeComplete.MajorVersion,
 199                         RndisMessage->Message.InitializeComplete.MinorVersion,
 200                         RndisMessage->Message.InitializeComplete.DeviceFlags,
 201                         RndisMessage->Message.InitializeComplete.MaxTransferSize,
 202                         RndisMessage->Message.InitializeComplete.MaxPacketsPerMessage,
 203                         RndisMessage->Message.InitializeComplete.PacketAlignmentFactor);
 204                 break;
 205
 206         case REMOTE_NDIS_QUERY_CMPLT:
 207                 DPRINT_DBG(NETVSC, "REMOTE_NDIS_QUERY_CMPLT "
 208                         "(len %u, id 0x%x, status 0x%x, buf len %u, "
 209                         "buf offset %u)",
 210                         RndisMessage->MessageLength,
 211                         RndisMessage->Message.QueryComplete.RequestId,
 212                         RndisMessage->Message.QueryComplete.Status,
 213                         RndisMessage->Message.QueryComplete.InformationBufferLength,
 214                         RndisMessage->Message.QueryComplete.InformationBufferOffset);
 215                 break;
 216
 217         case REMOTE_NDIS_SET_CMPLT:
 218                 DPRINT_DBG(NETVSC,
 219                         "REMOTE_NDIS_SET_CMPLT (len %u, id 0x%x, status 0x%x)",
 220                         RndisMessage->MessageLength,
 221                         RndisMessage->Message.SetComplete.RequestId,
 222                         RndisMessage->Message.SetComplete.Status);
 223                 break;
 224
 225         case REMOTE_NDIS_INDICATE_STATUS_MSG:
 226                 DPRINT_DBG(NETVSC, "REMOTE_NDIS_INDICATE_STATUS_MSG "
 227                         "(len %u, status 0x%x, buf len %u, buf offset %u)",
 228                         RndisMessage->MessageLength,
 229                         RndisMessage->Message.IndicateStatus.Status,
 230                         RndisMessage->Message.IndicateStatus.StatusBufferLength,
 231                         RndisMessage->Message.IndicateStatus.StatusBufferOffset);
 232                 break;
 233
 234         default:
 235                 DPRINT_DBG(NETVSC, "0x%x (len %u)",
 236                         RndisMessage->NdisMessageType,
 237                         RndisMessage->MessageLength);
 238                 break;
 239         }
 240 }
 241
 242 static int RndisFilterSendRequest(struct rndis_device *Device,
 243                                   struct rndis_request *Request)
 244 {
 245         int ret;
 246         struct hv_netvsc_packet *packet;
 247
 248         DPRINT_ENTER(NETVSC);
 249
 250         /* Setup the packet to send it */
 251         packet = &Request->Packet;
 252
 253         packet->IsDataPacket = false;
 254         packet->TotalDataBufferLength = Request->RequestMessage.MessageLength;
 255         packet->PageBufferCount = 1;
 256
 257         packet->PageBuffers[0].Pfn = virt_to_phys(&Request->RequestMessage) >>
 258                                         PAGE_SHIFT;
 259         packet->PageBuffers[0].Length = Request->RequestMessage.MessageLength;
 260         packet->PageBuffers[0].Offset =
 261                 (unsigned long)&Request->RequestMessage & (PAGE_SIZE - 1);
 262
 263         packet->Completion.Send.SendCompletionContext = Request;/* packet; */
 264         packet->Completion.Send.OnSendCompletion =
 265                 RndisFilterOnSendRequestCompletion;
 266         packet->Completion.Send.SendCompletionTid = (unsigned long)Device;
 267
 268         ret = gRndisFilter.InnerDriver.OnSend(Device->NetDevice->Device, packet);
 269         DPRINT_EXIT(NETVSC);
 270         return ret;
 271 }
 272
 273 static void RndisFilterReceiveResponse(struct rndis_device *Device,
 274                                        struct rndis_message *Response)
 275 {
 276         LIST_ENTRY *anchor;
 277         LIST_ENTRY *curr;
 278         struct rndis_request *request = NULL;
 279         bool found = false;
 280         unsigned long flags;
 281
 282         DPRINT_ENTER(NETVSC);
 283
 284         spin_lock_irqsave(&Device->request_lock, flags);
 285         ITERATE_LIST_ENTRIES(anchor, curr, &Device->RequestList) {
 286                 request = CONTAINING_RECORD(curr, struct rndis_request,
 287                                             ListEntry);
 288
 289                 /*
 290                  * All request/response message contains RequestId as the 1st
 291                  * field
 292                  */
 293                 if (request->RequestMessage.Message.InitializeRequest.RequestId
 294                     == Response->Message.InitializeComplete.RequestId) {
 295                         DPRINT_DBG(NETVSC, "found rndis request for "
 296                                 "this response (id 0x%x req type 0x%x res "
 297                                 "type 0x%x)",
 298                                 request->RequestMessage.Message.InitializeRequest.RequestId,
 299                                 request->RequestMessage.NdisMessageType,
 300                                 Response->NdisMessageType);
 301
 302                         found = true;
 303                         break;
 304                 }
 305         }
 306         spin_unlock_irqrestore(&Device->request_lock, flags);
 307
 308         if (found) {
 309                 if (Response->MessageLength <= sizeof(struct rndis_message)) {
 310                         memcpy(&request->ResponseMessage, Response,
 311                                Response->MessageLength);
 312                 } else {
 313                         DPRINT_ERR(NETVSC, "rndis response buffer overflow "
 314                                   "detected (size %u max %zu)",
 315                                   Response->MessageLength,
 316                                   sizeof(struct rndis_filter_packet));
 317
 318                         if (Response->NdisMessageType ==
 319                             REMOTE_NDIS_RESET_CMPLT) {
 320                                 /* does not have a request id field */
 321                                 request->ResponseMessage.Message.ResetComplete.Status = STATUS_BUFFER_OVERFLOW;
 322                         } else {
 323                                 request->ResponseMessage.Message.InitializeComplete.Status = STATUS_BUFFER_OVERFLOW;
 324                         }
 325                 }
 326
 327                 osd_WaitEventSet(request->WaitEvent);
 328         } else {
 329                 DPRINT_ERR(NETVSC, "no rndis request found for this response "
 330                            "(id 0x%x res type 0x%x)",
 331                            Response->Message.InitializeComplete.RequestId,
 332                            Response->NdisMessageType);
 333         }
 334
 335         DPRINT_EXIT(NETVSC);
 336 }
 337
 338 static void RndisFilterReceiveIndicateStatus(struct rndis_device *Device,
 339                                              struct rndis_message *Response)
 340 {
 341         struct rndis_indicate_status *indicate =
 342                         &Response->Message.IndicateStatus;
 343
 344         if (indicate->Status == RNDIS_STATUS_MEDIA_CONNECT) {
 345                 gRndisFilter.InnerDriver.OnLinkStatusChanged(Device->NetDevice->Device, 1);
 346         } else if (indicate->Status == RNDIS_STATUS_MEDIA_DISCONNECT) {
 347                 gRndisFilter.InnerDriver.OnLinkStatusChanged(Device->NetDevice->Device, 0);
 348         } else {
 349                 /*
 350                  * TODO:
 351                  */
 352         }
 353 }
 354
 355 static void RndisFilterReceiveData(struct rndis_device *Device,
 356                                    struct rndis_message *Message,
 357                                    struct hv_netvsc_packet *Packet)
 358 {
 359         struct rndis_packet *rndisPacket;
 360         u32 dataOffset;
 361
 362         DPRINT_ENTER(NETVSC);
 363
 364         /* empty ethernet frame ?? */
 365         ASSERT(Packet->PageBuffers[0].Length >
 366                 RNDIS_MESSAGE_SIZE(struct rndis_packet));
 367
 368         rndisPacket = &Message->Message.Packet;
 369
 370         /*
 371          * FIXME: Handle multiple rndis pkt msgs that maybe enclosed in this
 372          * netvsc packet (ie TotalDataBufferLength != MessageLength)
 373          */
 374
 375         /* Remove the rndis header and pass it back up the stack */
 376         dataOffset = RNDIS_HEADER_SIZE + rndisPacket->DataOffset;
 377
 378         Packet->TotalDataBufferLength -= dataOffset;
 379         Packet->PageBuffers[0].Offset += dataOffset;
 380         Packet->PageBuffers[0].Length -= dataOffset;
 381
 382         Packet->IsDataPacket = true;
 383
 384         gRndisFilter.InnerDriver.OnReceiveCallback(Device->NetDevice->Device,
 385                                                    Packet);
 386
 387         DPRINT_EXIT(NETVSC);
 388 }
 389
 390 static int RndisFilterOnReceive(struct hv_device *Device,
 391                                 struct hv_netvsc_packet *Packet)
 392 {
 393         struct netvsc_device *netDevice = Device->Extension;
 394         struct rndis_device *rndisDevice;
 395         struct rndis_message rndisMessage;
 396         struct rndis_message *rndisHeader;
 397
 398         DPRINT_ENTER(NETVSC);
 399
 400         ASSERT(netDevice);
 401         /* Make sure the rndis device state is initialized */
 402         if (!netDevice->Extension) {
 403                 DPRINT_ERR(NETVSC, "got rndis message but no rndis device..."
 404                           "dropping this message!");
 405                 DPRINT_EXIT(NETVSC);
 406                 return -1;
 407         }
 408
 409         rndisDevice = (struct rndis_device *)netDevice->Extension;
 410         if (rndisDevice->State == RNDIS_DEV_UNINITIALIZED) {
 411                 DPRINT_ERR(NETVSC, "got rndis message but rndis device "
 412                            "uninitialized...dropping this message!");
 413                 DPRINT_EXIT(NETVSC);
 414                 return -1;
 415         }
 416
 417         rndisHeader = (struct rndis_message *)kmap_atomic(
 418                         pfn_to_page(Packet->PageBuffers[0].Pfn), KM_IRQ0);
 419
 420         rndisHeader = (void *)((unsigned long)rndisHeader +
 421                         Packet->PageBuffers[0].Offset);
 422
 423         /* Make sure we got a valid rndis message */
 424         /*
 425          * FIXME: There seems to be a bug in set completion msg where its
 426          * MessageLength is 16 bytes but the ByteCount field in the xfer page
 427          * range shows 52 bytes
 428          * */
 429 #if 0
 430         if (Packet->TotalDataBufferLength != rndisHeader->MessageLength) {
 431                 kunmap_atomic(rndisHeader - Packet->PageBuffers[0].Offset,
 432                               KM_IRQ0);
 433
 434                 DPRINT_ERR(NETVSC, "invalid rndis message? (expected %u "
 435                            "bytes got %u)...dropping this message!",
 436                            rndisHeader->MessageLength,
 437                            Packet->TotalDataBufferLength);
 438                 DPRINT_EXIT(NETVSC);
 439                 return -1;
 440         }
 441 #endif
 442
 443         if ((rndisHeader->NdisMessageType != REMOTE_NDIS_PACKET_MSG) &&
 444             (rndisHeader->MessageLength > sizeof(struct rndis_message))) {
 445                 DPRINT_ERR(NETVSC, "incoming rndis message buffer overflow "
 446                            "detected (got %u, max %zu)...marking it an error!",
 447                            rndisHeader->MessageLength,
 448                            sizeof(struct rndis_message));
 449         }
 450
 451         memcpy(&rndisMessage, rndisHeader,
 452                 (rndisHeader->MessageLength > sizeof(struct rndis_message)) ?
 453                         sizeof(struct rndis_message) :
 454                         rndisHeader->MessageLength);
 455
 456         kunmap_atomic(rndisHeader - Packet->PageBuffers[0].Offset, KM_IRQ0);
 457
 458         DumpRndisMessage(&rndisMessage);
 459
 460         switch (rndisMessage.NdisMessageType) {
 461         case REMOTE_NDIS_PACKET_MSG:
 462                 /* data msg */
 463                 RndisFilterReceiveData(rndisDevice, &rndisMessage, Packet);
 464                 break;
 465
 466         case REMOTE_NDIS_INITIALIZE_CMPLT:
 467         case REMOTE_NDIS_QUERY_CMPLT:
 468         case REMOTE_NDIS_SET_CMPLT:
 469         /* case REMOTE_NDIS_RESET_CMPLT: */
 470         /* case REMOTE_NDIS_KEEPALIVE_CMPLT: */
 471                 /* completion msgs */
 472                 RndisFilterReceiveResponse(rndisDevice, &rndisMessage);
 473                 break;
 474
 475         case REMOTE_NDIS_INDICATE_STATUS_MSG:
 476                 /* notification msgs */
 477                 RndisFilterReceiveIndicateStatus(rndisDevice, &rndisMessage);
 478                 break;
 479         default:
 480                 DPRINT_ERR(NETVSC, "unhandled rndis message (type %u len %u)",
 481                            rndisMessage.NdisMessageType,
 482                            rndisMessage.MessageLength);
 483                 break;
 484         }
 485
 486         DPRINT_EXIT(NETVSC);
 487         return 0;
 488 }
 489
 490 static int RndisFilterQueryDevice(struct rndis_device *Device, u32 Oid,
 491                                   void *Result, u32 *ResultSize)
 492 {
 493         struct rndis_request *request;
 494         u32 inresultSize = *ResultSize;
 495         struct rndis_query_request *query;
 496         struct rndis_query_complete *queryComplete;
 497         int ret = 0;
 498
 499         DPRINT_ENTER(NETVSC);
 500
 501         ASSERT(Result);
 502
 503         *ResultSize = 0;
 504         request = GetRndisRequest(Device, REMOTE_NDIS_QUERY_MSG,
 505                         RNDIS_MESSAGE_SIZE(struct rndis_query_request));
 506         if (!request) {
 507                 ret = -1;
 508                 goto Cleanup;
 509         }
 510
 511         /* Setup the rndis query */
 512         query = &request->RequestMessage.Message.QueryRequest;
 513         query->Oid = Oid;
 514         query->InformationBufferOffset = sizeof(struct rndis_query_request);
 515         query->InformationBufferLength = 0;
 516         query->DeviceVcHandle = 0;
 517
 518         ret = RndisFilterSendRequest(Device, request);
 519         if (ret != 0)
 520                 goto Cleanup;
 521
 522         osd_WaitEventWait(request->WaitEvent);
 523
 524         /* Copy the response back */
 525         queryComplete = &request->ResponseMessage.Message.QueryComplete;
 526
 527         if (queryComplete->InformationBufferLength > inresultSize) {
 528                 ret = -1;
 529                 goto Cleanup;
 530         }
 531
 532         memcpy(Result,
 533                (void *)((unsigned long)queryComplete +
 534                          queryComplete->InformationBufferOffset),
 535                queryComplete->InformationBufferLength);
 536
 537         *ResultSize = queryComplete->InformationBufferLength;
 538
 539 Cleanup:
 540         if (request)
 541                 PutRndisRequest(Device, request);
 542         DPRINT_EXIT(NETVSC);
 543
 544         return ret;
 545 }
 546
 547 static int RndisFilterQueryDeviceMac(struct rndis_device *Device)
 548 {
 549         u32 size = HW_MACADDR_LEN;
 550
 551         return RndisFilterQueryDevice(Device,
 552                                       RNDIS_OID_802_3_PERMANENT_ADDRESS,
 553                                       Device->HwMacAddr, &size);
 554 }
 555
 556 static int RndisFilterQueryDeviceLinkStatus(struct rndis_device *Device)
 557 {
 558         u32 size = sizeof(u32);
 559
 560         return RndisFilterQueryDevice(Device,
 561                                       RNDIS_OID_GEN_MEDIA_CONNECT_STATUS,
 562                                       &Device->LinkStatus, &size);
 563 }
 564
 565 static int RndisFilterSetPacketFilter(struct rndis_device *Device,
 566                                       u32 NewFilter)
 567 {
 568         struct rndis_request *request;
 569         struct rndis_set_request *set;
 570         struct rndis_set_complete *setComplete;
 571         u32 status;
 572         int ret;
 573
 574         DPRINT_ENTER(NETVSC);
 575
 576         ASSERT(RNDIS_MESSAGE_SIZE(struct rndis_set_request) + sizeof(u32) <=
 577                 sizeof(struct rndis_message));
 578
 579         request = GetRndisRequest(Device, REMOTE_NDIS_SET_MSG,
 580                         RNDIS_MESSAGE_SIZE(struct rndis_set_request) +
 581                         sizeof(u32));
 582         if (!request) {
 583                 ret = -1;
 584                 goto Cleanup;
 585         }
 586
 587         /* Setup the rndis set */
 588         set = &request->RequestMessage.Message.SetRequest;
 589         set->Oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
 590         set->InformationBufferLength = sizeof(u32);
 591         set->InformationBufferOffset = sizeof(struct rndis_set_request);
 592
 593         memcpy((void *)(unsigned long)set + sizeof(struct rndis_set_request),
 594                &NewFilter, sizeof(u32));
 595
 596         ret = RndisFilterSendRequest(Device, request);
 597         if (ret != 0)
 598                 goto Cleanup;
 599
 600         ret = osd_WaitEventWaitEx(request->WaitEvent, 2000/*2sec*/);
 601         if (!ret) {
 602                 ret = -1;
 603                 DPRINT_ERR(NETVSC, "timeout before we got a set response...");
 604                 /*
 605                  * We cant deallocate the request since we may still receive a
 606                  * send completion for it.
 607                  */
 608                 goto Exit;
 609         } else {
 610                 if (ret > 0)
 611                         ret = 0;
 612                 setComplete = &request->ResponseMessage.Message.SetComplete;
 613                 status = setComplete->Status;
 614         }
 615
 616 Cleanup:
 617         if (request)
 618                 PutRndisRequest(Device, request);
 619 Exit:
 620         DPRINT_EXIT(NETVSC);
 621
 622         return ret;
 623 }
 624
 625 int RndisFilterInit(struct netvsc_driver *Driver)
 626 {
 627         DPRINT_ENTER(NETVSC);
 628
 629         DPRINT_DBG(NETVSC, "sizeof(struct rndis_filter_packet) == %zd",
 630                    sizeof(struct rndis_filter_packet));
 631
 632         Driver->RequestExtSize = sizeof(struct rndis_filter_packet);
 633         Driver->AdditionalRequestPageBufferCount = 1; /* For rndis header */
 634
 635         /* Driver->Context = rndisDriver; */
 636
 637         memset(&gRndisFilter, 0, sizeof(struct rndis_filter_driver_object));
 638
 639         /*rndisDriver->Driver = Driver;
 640
 641         ASSERT(Driver->OnLinkStatusChanged);
 642         rndisDriver->OnLinkStatusChanged = Driver->OnLinkStatusChanged;*/
 643
 644         /* Save the original dispatch handlers before we override it */
 645         gRndisFilter.InnerDriver.Base.OnDeviceAdd = Driver->Base.OnDeviceAdd;
 646         gRndisFilter.InnerDriver.Base.OnDeviceRemove =
 647                                         Driver->Base.OnDeviceRemove;
 648         gRndisFilter.InnerDriver.Base.OnCleanup = Driver->Base.OnCleanup;
 649
 650         ASSERT(Driver->OnSend);
 651         ASSERT(Driver->OnReceiveCallback);
 652         gRndisFilter.InnerDriver.OnSend = Driver->OnSend;
 653         gRndisFilter.InnerDriver.OnReceiveCallback = Driver->OnReceiveCallback;
 654         gRndisFilter.InnerDriver.OnLinkStatusChanged =
 655                                         Driver->OnLinkStatusChanged;
 656
 657         /* Override */
 658         Driver->Base.OnDeviceAdd = RndisFilterOnDeviceAdd;
 659         Driver->Base.OnDeviceRemove = RndisFilterOnDeviceRemove;
 660         Driver->Base.OnCleanup = RndisFilterOnCleanup;
 661         Driver->OnSend = RndisFilterOnSend;
 662         Driver->OnOpen = RndisFilterOnOpen;
 663         Driver->OnClose = RndisFilterOnClose;
 664         /* Driver->QueryLinkStatus = RndisFilterQueryDeviceLinkStatus; */
 665         Driver->OnReceiveCallback = RndisFilterOnReceive;
 666
 667         DPRINT_EXIT(NETVSC);
 668
 669         return 0;
 670 }
 671
 672 static int RndisFilterInitDevice(struct rndis_device *Device)
 673 {
 674         struct rndis_request *request;
 675         struct rndis_initialize_request *init;
 676         struct rndis_initialize_complete *initComplete;
 677         u32 status;
 678         int ret;
 679
 680         DPRINT_ENTER(NETVSC);
 681
 682         request = GetRndisRequest(Device, REMOTE_NDIS_INITIALIZE_MSG,
 683                         RNDIS_MESSAGE_SIZE(struct rndis_initialize_request));
 684         if (!request) {
 685                 ret = -1;
 686                 goto Cleanup;
 687         }
 688
 689         /* Setup the rndis set */
 690         init = &request->RequestMessage.Message.InitializeRequest;
 691         init->MajorVersion = RNDIS_MAJOR_VERSION;
 692         init->MinorVersion = RNDIS_MINOR_VERSION;
 693         /* FIXME: Use 1536 - rounded ethernet frame size */
 694         init->MaxTransferSize = 2048;
 695
 696         Device->State = RNDIS_DEV_INITIALIZING;
 697
 698         ret = RndisFilterSendRequest(Device, request);
 699         if (ret != 0) {
 700                 Device->State = RNDIS_DEV_UNINITIALIZED;
 701                 goto Cleanup;
 702         }
 703
 704         osd_WaitEventWait(request->WaitEvent);
 705
 706         initComplete = &request->ResponseMessage.Message.InitializeComplete;
 707         status = initComplete->Status;
 708         if (status == RNDIS_STATUS_SUCCESS) {
 709                 Device->State = RNDIS_DEV_INITIALIZED;
 710                 ret = 0;
 711         } else {
 712                 Device->State = RNDIS_DEV_UNINITIALIZED;
 713                 ret = -1;
 714         }
 715
 716 Cleanup:
 717         if (request)
 718                 PutRndisRequest(Device, request);
 719         DPRINT_EXIT(NETVSC);
 720
 721         return ret;
 722 }
 723
 724 static void RndisFilterHaltDevice(struct rndis_device *Device)
 725 {
 726         struct rndis_request *request;
 727         struct rndis_halt_request *halt;
 728
 729         DPRINT_ENTER(NETVSC);
 730
 731         /* Attempt to do a rndis device halt */
 732         request = GetRndisRequest(Device, REMOTE_NDIS_HALT_MSG,
 733                                 RNDIS_MESSAGE_SIZE(struct rndis_halt_request));
 734         if (!request)
 735                 goto Cleanup;
 736
 737         /* Setup the rndis set */
 738         halt = &request->RequestMessage.Message.HaltRequest;
 739         halt->RequestId = atomic_inc_return(&Device->NewRequestId);
 740
 741         /* Ignore return since this msg is optional. */
 742         RndisFilterSendRequest(Device, request);
 743
 744         Device->State = RNDIS_DEV_UNINITIALIZED;
 745
 746 Cleanup:
 747         if (request)
 748                 PutRndisRequest(Device, request);
 749         DPRINT_EXIT(NETVSC);
 750         return;
 751 }
 752
 753 static int RndisFilterOpenDevice(struct rndis_device *Device)
 754 {
 755         int ret;
 756
 757         DPRINT_ENTER(NETVSC);
 758
 759         if (Device->State != RNDIS_DEV_INITIALIZED)
 760                 return 0;
 761
 762         ret = RndisFilterSetPacketFilter(Device,
 763                                          NDIS_PACKET_TYPE_BROADCAST |
 764                                          NDIS_PACKET_TYPE_DIRECTED);
 765         if (ret == 0)
 766                 Device->State = RNDIS_DEV_DATAINITIALIZED;
 767
 768         DPRINT_EXIT(NETVSC);
 769         return ret;
 770 }
 771
 772 static int RndisFilterCloseDevice(struct rndis_device *Device)
 773 {
 774         int ret;
 775
 776         DPRINT_ENTER(NETVSC);
 777
 778         if (Device->State != RNDIS_DEV_DATAINITIALIZED)
 779                 return 0;
 780
 781         ret = RndisFilterSetPacketFilter(Device, 0);
 782         if (ret == 0)
 783                 Device->State = RNDIS_DEV_INITIALIZED;
 784
 785         DPRINT_EXIT(NETVSC);
 786
 787         return ret;
 788 }
 789
 790 static int RndisFilterOnDeviceAdd(struct hv_device *Device,
 791                                   void *AdditionalInfo)
 792 {
 793         int ret;
 794         struct netvsc_device *netDevice;
 795         struct rndis_device *rndisDevice;
 796         struct netvsc_device_info *deviceInfo = AdditionalInfo;
 797
 798         DPRINT_ENTER(NETVSC);
 799
 800         rndisDevice = GetRndisDevice();
 801         if (!rndisDevice) {
 802                 DPRINT_EXIT(NETVSC);
 803                 return -1;
 804         }
 805
 806         DPRINT_DBG(NETVSC, "rndis device object allocated - %p", rndisDevice);
 807
 808         /*
 809          * Let the inner driver handle this first to create the netvsc channel
 810          * NOTE! Once the channel is created, we may get a receive callback
 811          * (RndisFilterOnReceive()) before this call is completed
 812          */
 813         ret = gRndisFilter.InnerDriver.Base.OnDeviceAdd(Device, AdditionalInfo);
 814         if (ret != 0) {
 815                 kfree(rndisDevice);
 816                 DPRINT_EXIT(NETVSC);
 817                 return ret;
 818         }
 819
 820
 821         /* Initialize the rndis device */
 822         netDevice = Device->Extension;
 823         ASSERT(netDevice);
 824         ASSERT(netDevice->Device);
 825
 826         netDevice->Extension = rndisDevice;
 827         rndisDevice->NetDevice = netDevice;
 828
 829         /* Send the rndis initialization message */
 830         ret = RndisFilterInitDevice(rndisDevice);
 831         if (ret != 0) {
 832                 /*
 833                  * TODO: If rndis init failed, we will need to shut down the
 834                  * channel
 835                  */
 836         }
 837
 838         /* Get the mac address */
 839         ret = RndisFilterQueryDeviceMac(rndisDevice);
 840         if (ret != 0) {
 841                 /*
 842                  * TODO: shutdown rndis device and the channel
 843                  */
 844         }
 845
 846         DPRINT_INFO(NETVSC, "Device 0x%p mac addr %02x%02x%02x%02x%02x%02x",
 847                     rndisDevice,
 848                     rndisDevice->HwMacAddr[0],
 849                     rndisDevice->HwMacAddr[1],
 850                     rndisDevice->HwMacAddr[2],
 851                     rndisDevice->HwMacAddr[3],
 852                     rndisDevice->HwMacAddr[4],
 853                     rndisDevice->HwMacAddr[5]);
 854
 855         memcpy(deviceInfo->MacAddr, rndisDevice->HwMacAddr, HW_MACADDR_LEN);
 856
 857         RndisFilterQueryDeviceLinkStatus(rndisDevice);
 858
 859         deviceInfo->LinkState = rndisDevice->LinkStatus;
 860         DPRINT_INFO(NETVSC, "Device 0x%p link state %s", rndisDevice,
 861                     ((deviceInfo->LinkState) ? ("down") : ("up")));
 862
 863         DPRINT_EXIT(NETVSC);
 864
 865         return ret;
 866 }
 867
 868 static int RndisFilterOnDeviceRemove(struct hv_device *Device)
 869 {
 870         struct netvsc_device *netDevice = Device->Extension;
 871         struct rndis_device *rndisDevice = netDevice->Extension;
 872
 873         DPRINT_ENTER(NETVSC);
 874
 875         /* Halt and release the rndis device */
 876         RndisFilterHaltDevice(rndisDevice);
 877
 878         kfree(rndisDevice);
 879         netDevice->Extension = NULL;
 880
 881         /* Pass control to inner driver to remove the device */
 882         gRndisFilter.InnerDriver.Base.OnDeviceRemove(Device);
 883
 884         DPRINT_EXIT(NETVSC);
 885
 886         return 0;
 887 }
 888
 889 static void RndisFilterOnCleanup(struct hv_driver *Driver)
 890 {
 891         DPRINT_ENTER(NETVSC);
 892
 893         DPRINT_EXIT(NETVSC);
 894 }
 895
 896 static int RndisFilterOnOpen(struct hv_device *Device)
 897 {
 898         int ret;
 899         struct netvsc_device *netDevice = Device->Extension;
 900
 901         DPRINT_ENTER(NETVSC);
 902
 903         ASSERT(netDevice);
 904         ret = RndisFilterOpenDevice(netDevice->Extension);
 905
 906         DPRINT_EXIT(NETVSC);
 907
 908         return ret;
 909 }
 910
 911 static int RndisFilterOnClose(struct hv_device *Device)
 912 {
 913         int ret;
 914         struct netvsc_device *netDevice = Device->Extension;
 915
 916         DPRINT_ENTER(NETVSC);
 917
 918         ASSERT(netDevice);
 919         ret = RndisFilterCloseDevice(netDevice->Extension);
 920
 921         DPRINT_EXIT(NETVSC);
 922
 923         return ret;
 924 }
 925
 926 static int RndisFilterOnSend(struct hv_device *Device,
 927                              struct hv_netvsc_packet *Packet)
 928 {
 929         int ret;
 930         struct rndis_filter_packet *filterPacket;
 931         struct rndis_message *rndisMessage;
 932         struct rndis_packet *rndisPacket;
 933         u32 rndisMessageSize;
 934
 935         DPRINT_ENTER(NETVSC);
 936
 937         /* Add the rndis header */
 938         filterPacket = (struct rndis_filter_packet *)Packet->Extension;
 939         ASSERT(filterPacket);
 940
 941         memset(filterPacket, 0, sizeof(struct rndis_filter_packet));
 942
 943         rndisMessage = &filterPacket->Message;
 944         rndisMessageSize = RNDIS_MESSAGE_SIZE(struct rndis_packet);
 945
 946         rndisMessage->NdisMessageType = REMOTE_NDIS_PACKET_MSG;
 947         rndisMessage->MessageLength = Packet->TotalDataBufferLength +
 948                                       rndisMessageSize;
 949
 950         rndisPacket = &rndisMessage->Message.Packet;
 951         rndisPacket->DataOffset = sizeof(struct rndis_packet);
 952         rndisPacket->DataLength = Packet->TotalDataBufferLength;
 953
 954         Packet->IsDataPacket = true;
 955         Packet->PageBuffers[0].Pfn = virt_to_phys(rndisMessage) >> PAGE_SHIFT;
 956         Packet->PageBuffers[0].Offset =
 957                         (unsigned long)rndisMessage & (PAGE_SIZE-1);
 958         Packet->PageBuffers[0].Length = rndisMessageSize;
 959
 960         /* Save the packet send completion and context */
 961         filterPacket->OnCompletion = Packet->Completion.Send.OnSendCompletion;
 962         filterPacket->CompletionContext =
 963                                 Packet->Completion.Send.SendCompletionContext;
 964
 965         /* Use ours */
 966         Packet->Completion.Send.OnSendCompletion = RndisFilterOnSendCompletion;
 967         Packet->Completion.Send.SendCompletionContext = filterPacket;
 968
 969         ret = gRndisFilter.InnerDriver.OnSend(Device, Packet);
 970         if (ret != 0) {
 971                 /*
 972                  * Reset the completion to originals to allow retries from
 973                  * above
 974                  */
 975                 Packet->Completion.Send.OnSendCompletion =
 976                                 filterPacket->OnCompletion;
 977                 Packet->Completion.Send.SendCompletionContext =
 978                                 filterPacket->CompletionContext;
 979         }
 980
 981         DPRINT_EXIT(NETVSC);
 982
 983         return ret;
 984 }
 985
 986 static void RndisFilterOnSendCompletion(void *Context)
 987 {
 988         struct rndis_filter_packet *filterPacket = Context;
 989
 990         DPRINT_ENTER(NETVSC);
 991
 992         /* Pass it back to the original handler */
 993         filterPacket->OnCompletion(filterPacket->CompletionContext);
 994
 995         DPRINT_EXIT(NETVSC);
 996 }
 997
 998
 999 static void RndisFilterOnSendRequestCompletion(void *Context)
1000 {
1001         DPRINT_ENTER(NETVSC);
1002
1003         /* Noop */
1004         DPRINT_EXIT(NETVSC);
1005 }