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