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
);