2 * Copyright (c) 2009, Microsoft Corporation.
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.
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
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.
18 * Haiyang Zhang <haiyangz@microsoft.com>
19 * Hank Janssen <hjanssen@microsoft.com>
21 #include <linux/kernel.h>
22 #include <linux/highmem.h>
26 #include "NetVscApi.h"
27 #include "RndisFilter.h"
30 struct rndis_filter_driver_object {
31 /* The original driver */
32 struct netvsc_driver InnerDriver;
35 enum rndis_device_state {
36 RNDIS_DEV_UNINITIALIZED = 0,
37 RNDIS_DEV_INITIALIZING,
38 RNDIS_DEV_INITIALIZED,
39 RNDIS_DEV_DATAINITIALIZED,
43 struct netvsc_device *NetDevice;
45 enum rndis_device_state State;
47 atomic_t NewRequestId;
49 spinlock_t request_lock;
50 struct list_head RequestList;
52 unsigned char HwMacAddr[HW_MACADDR_LEN];
55 struct rndis_request {
56 struct list_head ListEntry;
57 struct osd_waitevent *WaitEvent;
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
64 struct rndis_message ResponseMessage;
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;
74 struct rndis_filter_packet {
75 void *CompletionContext;
76 void (*OnCompletion)(void *context);
77 struct rndis_message Message;
81 static int RndisFilterOnDeviceAdd(struct hv_device *Device,
82 void *AdditionalInfo);
84 static int RndisFilterOnDeviceRemove(struct hv_device *Device);
86 static void RndisFilterOnCleanup(struct hv_driver *Driver);
88 static int RndisFilterOnOpen(struct hv_device *Device);
90 static int RndisFilterOnClose(struct hv_device *Device);
92 static int RndisFilterOnSend(struct hv_device *Device,
93 struct hv_netvsc_packet *Packet);
95 static void RndisFilterOnSendCompletion(void *Context);
97 static void RndisFilterOnSendRequestCompletion(void *Context);
100 /* The one and only */
101 static struct rndis_filter_driver_object gRndisFilter;
103 static struct rndis_device *GetRndisDevice(void)
105 struct rndis_device *device;
107 device = kzalloc(sizeof(struct rndis_device), GFP_KERNEL);
111 spin_lock_init(&device->request_lock);
113 INIT_LIST_HEAD(&device->RequestList);
115 device->State = RNDIS_DEV_UNINITIALIZED;
120 static struct rndis_request *GetRndisRequest(struct rndis_device *Device,
124 struct rndis_request *request;
125 struct rndis_message *rndisMessage;
126 struct rndis_set_request *set;
129 request = kzalloc(sizeof(struct rndis_request), GFP_KERNEL);
133 request->WaitEvent = osd_WaitEventCreate();
134 if (!request->WaitEvent) {
139 rndisMessage = &request->RequestMessage;
140 rndisMessage->NdisMessageType = MessageType;
141 rndisMessage->MessageLength = MessageLength;
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
148 set = &rndisMessage->Message.SetRequest;
149 set->RequestId = atomic_inc_return(&Device->NewRequestId);
151 /* Add to the request list */
152 spin_lock_irqsave(&Device->request_lock, flags);
153 list_add_tail(&request->ListEntry, &Device->RequestList);
154 spin_unlock_irqrestore(&Device->request_lock, flags);
159 static void PutRndisRequest(struct rndis_device *Device,
160 struct rndis_request *Request)
164 spin_lock_irqsave(&Device->request_lock, flags);
165 list_del(&Request->ListEntry);
166 spin_unlock_irqrestore(&Device->request_lock, flags);
168 kfree(Request->WaitEvent);
172 static void DumpRndisMessage(struct rndis_message *RndisMessage)
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, "
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);
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, "
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);
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, "
210 RndisMessage->MessageLength,
211 RndisMessage->Message.QueryComplete.RequestId,
212 RndisMessage->Message.QueryComplete.Status,
213 RndisMessage->Message.QueryComplete.InformationBufferLength,
214 RndisMessage->Message.QueryComplete.InformationBufferOffset);
217 case REMOTE_NDIS_SET_CMPLT:
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);
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);
235 DPRINT_DBG(NETVSC, "0x%x (len %u)",
236 RndisMessage->NdisMessageType,
237 RndisMessage->MessageLength);
242 static int RndisFilterSendRequest(struct rndis_device *Device,
243 struct rndis_request *Request)
246 struct hv_netvsc_packet *packet;
248 DPRINT_ENTER(NETVSC);
250 /* Setup the packet to send it */
251 packet = &Request->Packet;
253 packet->IsDataPacket = false;
254 packet->TotalDataBufferLength = Request->RequestMessage.MessageLength;
255 packet->PageBufferCount = 1;
257 packet->PageBuffers[0].Pfn = virt_to_phys(&Request->RequestMessage) >>
259 packet->PageBuffers[0].Length = Request->RequestMessage.MessageLength;
260 packet->PageBuffers[0].Offset =
261 (unsigned long)&Request->RequestMessage & (PAGE_SIZE - 1);
263 packet->Completion.Send.SendCompletionContext = Request;/* packet; */
264 packet->Completion.Send.OnSendCompletion =
265 RndisFilterOnSendRequestCompletion;
266 packet->Completion.Send.SendCompletionTid = (unsigned long)Device;
268 ret = gRndisFilter.InnerDriver.OnSend(Device->NetDevice->Device, packet);
273 static void RndisFilterReceiveResponse(struct rndis_device *Device,
274 struct rndis_message *Response)
276 struct rndis_request *request = NULL;
280 DPRINT_ENTER(NETVSC);
282 spin_lock_irqsave(&Device->request_lock, flags);
283 list_for_each_entry(request, &Device->RequestList, ListEntry) {
285 * All request/response message contains RequestId as the 1st
288 if (request->RequestMessage.Message.InitializeRequest.RequestId
289 == Response->Message.InitializeComplete.RequestId) {
290 DPRINT_DBG(NETVSC, "found rndis request for "
291 "this response (id 0x%x req type 0x%x res "
293 request->RequestMessage.Message.InitializeRequest.RequestId,
294 request->RequestMessage.NdisMessageType,
295 Response->NdisMessageType);
301 spin_unlock_irqrestore(&Device->request_lock, flags);
304 if (Response->MessageLength <= sizeof(struct rndis_message)) {
305 memcpy(&request->ResponseMessage, Response,
306 Response->MessageLength);
308 DPRINT_ERR(NETVSC, "rndis response buffer overflow "
309 "detected (size %u max %zu)",
310 Response->MessageLength,
311 sizeof(struct rndis_filter_packet));
313 if (Response->NdisMessageType ==
314 REMOTE_NDIS_RESET_CMPLT) {
315 /* does not have a request id field */
316 request->ResponseMessage.Message.ResetComplete.Status = STATUS_BUFFER_OVERFLOW;
318 request->ResponseMessage.Message.InitializeComplete.Status = STATUS_BUFFER_OVERFLOW;
322 osd_WaitEventSet(request->WaitEvent);
324 DPRINT_ERR(NETVSC, "no rndis request found for this response "
325 "(id 0x%x res type 0x%x)",
326 Response->Message.InitializeComplete.RequestId,
327 Response->NdisMessageType);
333 static void RndisFilterReceiveIndicateStatus(struct rndis_device *Device,
334 struct rndis_message *Response)
336 struct rndis_indicate_status *indicate =
337 &Response->Message.IndicateStatus;
339 if (indicate->Status == RNDIS_STATUS_MEDIA_CONNECT) {
340 gRndisFilter.InnerDriver.OnLinkStatusChanged(Device->NetDevice->Device, 1);
341 } else if (indicate->Status == RNDIS_STATUS_MEDIA_DISCONNECT) {
342 gRndisFilter.InnerDriver.OnLinkStatusChanged(Device->NetDevice->Device, 0);
350 static void RndisFilterReceiveData(struct rndis_device *Device,
351 struct rndis_message *Message,
352 struct hv_netvsc_packet *Packet)
354 struct rndis_packet *rndisPacket;
357 DPRINT_ENTER(NETVSC);
359 /* empty ethernet frame ?? */
360 ASSERT(Packet->PageBuffers[0].Length >
361 RNDIS_MESSAGE_SIZE(struct rndis_packet));
363 rndisPacket = &Message->Message.Packet;
366 * FIXME: Handle multiple rndis pkt msgs that maybe enclosed in this
367 * netvsc packet (ie TotalDataBufferLength != MessageLength)
370 /* Remove the rndis header and pass it back up the stack */
371 dataOffset = RNDIS_HEADER_SIZE + rndisPacket->DataOffset;
373 Packet->TotalDataBufferLength -= dataOffset;
374 Packet->PageBuffers[0].Offset += dataOffset;
375 Packet->PageBuffers[0].Length -= dataOffset;
377 Packet->IsDataPacket = true;
379 gRndisFilter.InnerDriver.OnReceiveCallback(Device->NetDevice->Device,
385 static int RndisFilterOnReceive(struct hv_device *Device,
386 struct hv_netvsc_packet *Packet)
388 struct netvsc_device *netDevice = Device->Extension;
389 struct rndis_device *rndisDevice;
390 struct rndis_message rndisMessage;
391 struct rndis_message *rndisHeader;
393 DPRINT_ENTER(NETVSC);
396 /* Make sure the rndis device state is initialized */
397 if (!netDevice->Extension) {
398 DPRINT_ERR(NETVSC, "got rndis message but no rndis device..."
399 "dropping this message!");
404 rndisDevice = (struct rndis_device *)netDevice->Extension;
405 if (rndisDevice->State == RNDIS_DEV_UNINITIALIZED) {
406 DPRINT_ERR(NETVSC, "got rndis message but rndis device "
407 "uninitialized...dropping this message!");
412 rndisHeader = (struct rndis_message *)kmap_atomic(
413 pfn_to_page(Packet->PageBuffers[0].Pfn), KM_IRQ0);
415 rndisHeader = (void *)((unsigned long)rndisHeader +
416 Packet->PageBuffers[0].Offset);
418 /* Make sure we got a valid rndis message */
420 * FIXME: There seems to be a bug in set completion msg where its
421 * MessageLength is 16 bytes but the ByteCount field in the xfer page
422 * range shows 52 bytes
425 if (Packet->TotalDataBufferLength != rndisHeader->MessageLength) {
426 kunmap_atomic(rndisHeader - Packet->PageBuffers[0].Offset,
429 DPRINT_ERR(NETVSC, "invalid rndis message? (expected %u "
430 "bytes got %u)...dropping this message!",
431 rndisHeader->MessageLength,
432 Packet->TotalDataBufferLength);
438 if ((rndisHeader->NdisMessageType != REMOTE_NDIS_PACKET_MSG) &&
439 (rndisHeader->MessageLength > sizeof(struct rndis_message))) {
440 DPRINT_ERR(NETVSC, "incoming rndis message buffer overflow "
441 "detected (got %u, max %zu)...marking it an error!",
442 rndisHeader->MessageLength,
443 sizeof(struct rndis_message));
446 memcpy(&rndisMessage, rndisHeader,
447 (rndisHeader->MessageLength > sizeof(struct rndis_message)) ?
448 sizeof(struct rndis_message) :
449 rndisHeader->MessageLength);
451 kunmap_atomic(rndisHeader - Packet->PageBuffers[0].Offset, KM_IRQ0);
453 DumpRndisMessage(&rndisMessage);
455 switch (rndisMessage.NdisMessageType) {
456 case REMOTE_NDIS_PACKET_MSG:
458 RndisFilterReceiveData(rndisDevice, &rndisMessage, Packet);
461 case REMOTE_NDIS_INITIALIZE_CMPLT:
462 case REMOTE_NDIS_QUERY_CMPLT:
463 case REMOTE_NDIS_SET_CMPLT:
464 /* case REMOTE_NDIS_RESET_CMPLT: */
465 /* case REMOTE_NDIS_KEEPALIVE_CMPLT: */
466 /* completion msgs */
467 RndisFilterReceiveResponse(rndisDevice, &rndisMessage);
470 case REMOTE_NDIS_INDICATE_STATUS_MSG:
471 /* notification msgs */
472 RndisFilterReceiveIndicateStatus(rndisDevice, &rndisMessage);
475 DPRINT_ERR(NETVSC, "unhandled rndis message (type %u len %u)",
476 rndisMessage.NdisMessageType,
477 rndisMessage.MessageLength);
485 static int RndisFilterQueryDevice(struct rndis_device *Device, u32 Oid,
486 void *Result, u32 *ResultSize)
488 struct rndis_request *request;
489 u32 inresultSize = *ResultSize;
490 struct rndis_query_request *query;
491 struct rndis_query_complete *queryComplete;
494 DPRINT_ENTER(NETVSC);
499 request = GetRndisRequest(Device, REMOTE_NDIS_QUERY_MSG,
500 RNDIS_MESSAGE_SIZE(struct rndis_query_request));
506 /* Setup the rndis query */
507 query = &request->RequestMessage.Message.QueryRequest;
509 query->InformationBufferOffset = sizeof(struct rndis_query_request);
510 query->InformationBufferLength = 0;
511 query->DeviceVcHandle = 0;
513 ret = RndisFilterSendRequest(Device, request);
517 osd_WaitEventWait(request->WaitEvent);
519 /* Copy the response back */
520 queryComplete = &request->ResponseMessage.Message.QueryComplete;
522 if (queryComplete->InformationBufferLength > inresultSize) {
528 (void *)((unsigned long)queryComplete +
529 queryComplete->InformationBufferOffset),
530 queryComplete->InformationBufferLength);
532 *ResultSize = queryComplete->InformationBufferLength;
536 PutRndisRequest(Device, request);
542 static int RndisFilterQueryDeviceMac(struct rndis_device *Device)
544 u32 size = HW_MACADDR_LEN;
546 return RndisFilterQueryDevice(Device,
547 RNDIS_OID_802_3_PERMANENT_ADDRESS,
548 Device->HwMacAddr, &size);
551 static int RndisFilterQueryDeviceLinkStatus(struct rndis_device *Device)
553 u32 size = sizeof(u32);
555 return RndisFilterQueryDevice(Device,
556 RNDIS_OID_GEN_MEDIA_CONNECT_STATUS,
557 &Device->LinkStatus, &size);
560 static int RndisFilterSetPacketFilter(struct rndis_device *Device,
563 struct rndis_request *request;
564 struct rndis_set_request *set;
565 struct rndis_set_complete *setComplete;
569 DPRINT_ENTER(NETVSC);
571 ASSERT(RNDIS_MESSAGE_SIZE(struct rndis_set_request) + sizeof(u32) <=
572 sizeof(struct rndis_message));
574 request = GetRndisRequest(Device, REMOTE_NDIS_SET_MSG,
575 RNDIS_MESSAGE_SIZE(struct rndis_set_request) +
582 /* Setup the rndis set */
583 set = &request->RequestMessage.Message.SetRequest;
584 set->Oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
585 set->InformationBufferLength = sizeof(u32);
586 set->InformationBufferOffset = sizeof(struct rndis_set_request);
588 memcpy((void *)(unsigned long)set + sizeof(struct rndis_set_request),
589 &NewFilter, sizeof(u32));
591 ret = RndisFilterSendRequest(Device, request);
595 ret = osd_WaitEventWaitEx(request->WaitEvent, 2000/*2sec*/);
598 DPRINT_ERR(NETVSC, "timeout before we got a set response...");
600 * We cant deallocate the request since we may still receive a
601 * send completion for it.
607 setComplete = &request->ResponseMessage.Message.SetComplete;
608 status = setComplete->Status;
613 PutRndisRequest(Device, request);
620 int RndisFilterInit(struct netvsc_driver *Driver)
622 DPRINT_ENTER(NETVSC);
624 DPRINT_DBG(NETVSC, "sizeof(struct rndis_filter_packet) == %zd",
625 sizeof(struct rndis_filter_packet));
627 Driver->RequestExtSize = sizeof(struct rndis_filter_packet);
628 Driver->AdditionalRequestPageBufferCount = 1; /* For rndis header */
630 /* Driver->Context = rndisDriver; */
632 memset(&gRndisFilter, 0, sizeof(struct rndis_filter_driver_object));
634 /*rndisDriver->Driver = Driver;
636 ASSERT(Driver->OnLinkStatusChanged);
637 rndisDriver->OnLinkStatusChanged = Driver->OnLinkStatusChanged;*/
639 /* Save the original dispatch handlers before we override it */
640 gRndisFilter.InnerDriver.Base.OnDeviceAdd = Driver->Base.OnDeviceAdd;
641 gRndisFilter.InnerDriver.Base.OnDeviceRemove =
642 Driver->Base.OnDeviceRemove;
643 gRndisFilter.InnerDriver.Base.OnCleanup = Driver->Base.OnCleanup;
645 ASSERT(Driver->OnSend);
646 ASSERT(Driver->OnReceiveCallback);
647 gRndisFilter.InnerDriver.OnSend = Driver->OnSend;
648 gRndisFilter.InnerDriver.OnReceiveCallback = Driver->OnReceiveCallback;
649 gRndisFilter.InnerDriver.OnLinkStatusChanged =
650 Driver->OnLinkStatusChanged;
653 Driver->Base.OnDeviceAdd = RndisFilterOnDeviceAdd;
654 Driver->Base.OnDeviceRemove = RndisFilterOnDeviceRemove;
655 Driver->Base.OnCleanup = RndisFilterOnCleanup;
656 Driver->OnSend = RndisFilterOnSend;
657 Driver->OnOpen = RndisFilterOnOpen;
658 Driver->OnClose = RndisFilterOnClose;
659 /* Driver->QueryLinkStatus = RndisFilterQueryDeviceLinkStatus; */
660 Driver->OnReceiveCallback = RndisFilterOnReceive;
667 static int RndisFilterInitDevice(struct rndis_device *Device)
669 struct rndis_request *request;
670 struct rndis_initialize_request *init;
671 struct rndis_initialize_complete *initComplete;
675 DPRINT_ENTER(NETVSC);
677 request = GetRndisRequest(Device, REMOTE_NDIS_INITIALIZE_MSG,
678 RNDIS_MESSAGE_SIZE(struct rndis_initialize_request));
684 /* Setup the rndis set */
685 init = &request->RequestMessage.Message.InitializeRequest;
686 init->MajorVersion = RNDIS_MAJOR_VERSION;
687 init->MinorVersion = RNDIS_MINOR_VERSION;
688 /* FIXME: Use 1536 - rounded ethernet frame size */
689 init->MaxTransferSize = 2048;
691 Device->State = RNDIS_DEV_INITIALIZING;
693 ret = RndisFilterSendRequest(Device, request);
695 Device->State = RNDIS_DEV_UNINITIALIZED;
699 osd_WaitEventWait(request->WaitEvent);
701 initComplete = &request->ResponseMessage.Message.InitializeComplete;
702 status = initComplete->Status;
703 if (status == RNDIS_STATUS_SUCCESS) {
704 Device->State = RNDIS_DEV_INITIALIZED;
707 Device->State = RNDIS_DEV_UNINITIALIZED;
713 PutRndisRequest(Device, request);
719 static void RndisFilterHaltDevice(struct rndis_device *Device)
721 struct rndis_request *request;
722 struct rndis_halt_request *halt;
724 DPRINT_ENTER(NETVSC);
726 /* Attempt to do a rndis device halt */
727 request = GetRndisRequest(Device, REMOTE_NDIS_HALT_MSG,
728 RNDIS_MESSAGE_SIZE(struct rndis_halt_request));
732 /* Setup the rndis set */
733 halt = &request->RequestMessage.Message.HaltRequest;
734 halt->RequestId = atomic_inc_return(&Device->NewRequestId);
736 /* Ignore return since this msg is optional. */
737 RndisFilterSendRequest(Device, request);
739 Device->State = RNDIS_DEV_UNINITIALIZED;
743 PutRndisRequest(Device, request);
748 static int RndisFilterOpenDevice(struct rndis_device *Device)
752 DPRINT_ENTER(NETVSC);
754 if (Device->State != RNDIS_DEV_INITIALIZED)
757 ret = RndisFilterSetPacketFilter(Device,
758 NDIS_PACKET_TYPE_BROADCAST |
759 NDIS_PACKET_TYPE_DIRECTED);
761 Device->State = RNDIS_DEV_DATAINITIALIZED;
767 static int RndisFilterCloseDevice(struct rndis_device *Device)
771 DPRINT_ENTER(NETVSC);
773 if (Device->State != RNDIS_DEV_DATAINITIALIZED)
776 ret = RndisFilterSetPacketFilter(Device, 0);
778 Device->State = RNDIS_DEV_INITIALIZED;
785 static int RndisFilterOnDeviceAdd(struct hv_device *Device,
786 void *AdditionalInfo)
789 struct netvsc_device *netDevice;
790 struct rndis_device *rndisDevice;
791 struct netvsc_device_info *deviceInfo = AdditionalInfo;
793 DPRINT_ENTER(NETVSC);
795 rndisDevice = GetRndisDevice();
801 DPRINT_DBG(NETVSC, "rndis device object allocated - %p", rndisDevice);
804 * Let the inner driver handle this first to create the netvsc channel
805 * NOTE! Once the channel is created, we may get a receive callback
806 * (RndisFilterOnReceive()) before this call is completed
808 ret = gRndisFilter.InnerDriver.Base.OnDeviceAdd(Device, AdditionalInfo);
816 /* Initialize the rndis device */
817 netDevice = Device->Extension;
819 ASSERT(netDevice->Device);
821 netDevice->Extension = rndisDevice;
822 rndisDevice->NetDevice = netDevice;
824 /* Send the rndis initialization message */
825 ret = RndisFilterInitDevice(rndisDevice);
828 * TODO: If rndis init failed, we will need to shut down the
833 /* Get the mac address */
834 ret = RndisFilterQueryDeviceMac(rndisDevice);
837 * TODO: shutdown rndis device and the channel
841 DPRINT_INFO(NETVSC, "Device 0x%p mac addr %02x%02x%02x%02x%02x%02x",
843 rndisDevice->HwMacAddr[0],
844 rndisDevice->HwMacAddr[1],
845 rndisDevice->HwMacAddr[2],
846 rndisDevice->HwMacAddr[3],
847 rndisDevice->HwMacAddr[4],
848 rndisDevice->HwMacAddr[5]);
850 memcpy(deviceInfo->MacAddr, rndisDevice->HwMacAddr, HW_MACADDR_LEN);
852 RndisFilterQueryDeviceLinkStatus(rndisDevice);
854 deviceInfo->LinkState = rndisDevice->LinkStatus;
855 DPRINT_INFO(NETVSC, "Device 0x%p link state %s", rndisDevice,
856 ((deviceInfo->LinkState) ? ("down") : ("up")));
863 static int RndisFilterOnDeviceRemove(struct hv_device *Device)
865 struct netvsc_device *netDevice = Device->Extension;
866 struct rndis_device *rndisDevice = netDevice->Extension;
868 DPRINT_ENTER(NETVSC);
870 /* Halt and release the rndis device */
871 RndisFilterHaltDevice(rndisDevice);
874 netDevice->Extension = NULL;
876 /* Pass control to inner driver to remove the device */
877 gRndisFilter.InnerDriver.Base.OnDeviceRemove(Device);
884 static void RndisFilterOnCleanup(struct hv_driver *Driver)
886 DPRINT_ENTER(NETVSC);
891 static int RndisFilterOnOpen(struct hv_device *Device)
894 struct netvsc_device *netDevice = Device->Extension;
896 DPRINT_ENTER(NETVSC);
899 ret = RndisFilterOpenDevice(netDevice->Extension);
906 static int RndisFilterOnClose(struct hv_device *Device)
909 struct netvsc_device *netDevice = Device->Extension;
911 DPRINT_ENTER(NETVSC);
914 ret = RndisFilterCloseDevice(netDevice->Extension);
921 static int RndisFilterOnSend(struct hv_device *Device,
922 struct hv_netvsc_packet *Packet)
925 struct rndis_filter_packet *filterPacket;
926 struct rndis_message *rndisMessage;
927 struct rndis_packet *rndisPacket;
928 u32 rndisMessageSize;
930 DPRINT_ENTER(NETVSC);
932 /* Add the rndis header */
933 filterPacket = (struct rndis_filter_packet *)Packet->Extension;
934 ASSERT(filterPacket);
936 memset(filterPacket, 0, sizeof(struct rndis_filter_packet));
938 rndisMessage = &filterPacket->Message;
939 rndisMessageSize = RNDIS_MESSAGE_SIZE(struct rndis_packet);
941 rndisMessage->NdisMessageType = REMOTE_NDIS_PACKET_MSG;
942 rndisMessage->MessageLength = Packet->TotalDataBufferLength +
945 rndisPacket = &rndisMessage->Message.Packet;
946 rndisPacket->DataOffset = sizeof(struct rndis_packet);
947 rndisPacket->DataLength = Packet->TotalDataBufferLength;
949 Packet->IsDataPacket = true;
950 Packet->PageBuffers[0].Pfn = virt_to_phys(rndisMessage) >> PAGE_SHIFT;
951 Packet->PageBuffers[0].Offset =
952 (unsigned long)rndisMessage & (PAGE_SIZE-1);
953 Packet->PageBuffers[0].Length = rndisMessageSize;
955 /* Save the packet send completion and context */
956 filterPacket->OnCompletion = Packet->Completion.Send.OnSendCompletion;
957 filterPacket->CompletionContext =
958 Packet->Completion.Send.SendCompletionContext;
961 Packet->Completion.Send.OnSendCompletion = RndisFilterOnSendCompletion;
962 Packet->Completion.Send.SendCompletionContext = filterPacket;
964 ret = gRndisFilter.InnerDriver.OnSend(Device, Packet);
967 * Reset the completion to originals to allow retries from
970 Packet->Completion.Send.OnSendCompletion =
971 filterPacket->OnCompletion;
972 Packet->Completion.Send.SendCompletionContext =
973 filterPacket->CompletionContext;
981 static void RndisFilterOnSendCompletion(void *Context)
983 struct rndis_filter_packet *filterPacket = Context;
985 DPRINT_ENTER(NETVSC);
987 /* Pass it back to the original handler */
988 filterPacket->OnCompletion(filterPacket->CompletionContext);
994 static void RndisFilterOnSendRequestCompletion(void *Context)
996 DPRINT_ENTER(NETVSC);