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