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>
23 #include <linux/delay.h>
25 #include <linux/slab.h>
29 #include "rndis_filter.h"
34 static const char *gDriverName
= "netvsc";
36 /* {F8615163-DF3E-46c5-913F-F2D2F965ED0E} */
37 static const struct hv_guid gNetVscDeviceType
= {
39 0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46,
40 0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E
44 static int NetVscOnDeviceAdd(struct hv_device
*Device
, void *AdditionalInfo
);
46 static int NetVscOnDeviceRemove(struct hv_device
*Device
);
48 static void NetVscOnCleanup(struct hv_driver
*Driver
);
50 static void NetVscOnChannelCallback(void *context
);
52 static int NetVscInitializeSendBufferWithNetVsp(struct hv_device
*Device
);
54 static int NetVscInitializeReceiveBufferWithNetVsp(struct hv_device
*Device
);
56 static int NetVscDestroySendBuffer(struct netvsc_device
*NetDevice
);
58 static int NetVscDestroyReceiveBuffer(struct netvsc_device
*NetDevice
);
60 static int NetVscConnectToVsp(struct hv_device
*Device
);
62 static void NetVscOnSendCompletion(struct hv_device
*Device
,
63 struct vmpacket_descriptor
*Packet
);
65 static int NetVscOnSend(struct hv_device
*Device
,
66 struct hv_netvsc_packet
*Packet
);
68 static void NetVscOnReceive(struct hv_device
*Device
,
69 struct vmpacket_descriptor
*Packet
);
71 static void NetVscOnReceiveCompletion(void *Context
);
73 static void NetVscSendReceiveCompletion(struct hv_device
*Device
,
77 static struct netvsc_device
*AllocNetDevice(struct hv_device
*Device
)
79 struct netvsc_device
*netDevice
;
81 netDevice
= kzalloc(sizeof(struct netvsc_device
), GFP_KERNEL
);
85 /* Set to 2 to allow both inbound and outbound traffic */
86 atomic_cmpxchg(&netDevice
->RefCount
, 0, 2);
88 netDevice
->Device
= Device
;
89 Device
->Extension
= netDevice
;
94 static void FreeNetDevice(struct netvsc_device
*Device
)
96 WARN_ON(atomic_read(&Device
->RefCount
) == 0);
97 Device
->Device
->Extension
= NULL
;
102 /* Get the net device object iff exists and its refcount > 1 */
103 static struct netvsc_device
*GetOutboundNetDevice(struct hv_device
*Device
)
105 struct netvsc_device
*netDevice
;
107 netDevice
= Device
->Extension
;
108 if (netDevice
&& atomic_read(&netDevice
->RefCount
) > 1)
109 atomic_inc(&netDevice
->RefCount
);
116 /* Get the net device object iff exists and its refcount > 0 */
117 static struct netvsc_device
*GetInboundNetDevice(struct hv_device
*Device
)
119 struct netvsc_device
*netDevice
;
121 netDevice
= Device
->Extension
;
122 if (netDevice
&& atomic_read(&netDevice
->RefCount
))
123 atomic_inc(&netDevice
->RefCount
);
130 static void PutNetDevice(struct hv_device
*Device
)
132 struct netvsc_device
*netDevice
;
134 netDevice
= Device
->Extension
;
135 /* ASSERT(netDevice); */
137 atomic_dec(&netDevice
->RefCount
);
140 static struct netvsc_device
*ReleaseOutboundNetDevice(struct hv_device
*Device
)
142 struct netvsc_device
*netDevice
;
144 netDevice
= Device
->Extension
;
145 if (netDevice
== NULL
)
148 /* Busy wait until the ref drop to 2, then set it to 1 */
149 while (atomic_cmpxchg(&netDevice
->RefCount
, 2, 1) != 2)
155 static struct netvsc_device
*ReleaseInboundNetDevice(struct hv_device
*Device
)
157 struct netvsc_device
*netDevice
;
159 netDevice
= Device
->Extension
;
160 if (netDevice
== NULL
)
163 /* Busy wait until the ref drop to 1, then set it to 0 */
164 while (atomic_cmpxchg(&netDevice
->RefCount
, 1, 0) != 1)
167 Device
->Extension
= NULL
;
172 * NetVscInitialize - Main entry point
174 int NetVscInitialize(struct hv_driver
*drv
)
176 struct netvsc_driver
*driver
= (struct netvsc_driver
*)drv
;
178 DPRINT_DBG(NETVSC
, "sizeof(struct hv_netvsc_packet)=%zd, "
179 "sizeof(struct nvsp_message)=%zd, "
180 "sizeof(struct vmtransfer_page_packet_header)=%zd",
181 sizeof(struct hv_netvsc_packet
),
182 sizeof(struct nvsp_message
),
183 sizeof(struct vmtransfer_page_packet_header
));
185 /* Make sure we are at least 2 pages since 1 page is used for control */
186 /* ASSERT(driver->RingBufferSize >= (PAGE_SIZE << 1)); */
188 drv
->name
= gDriverName
;
189 memcpy(&drv
->deviceType
, &gNetVscDeviceType
, sizeof(struct hv_guid
));
191 /* Make sure it is set by the caller */
192 /* FIXME: These probably should still be tested in some way */
193 /* ASSERT(driver->OnReceiveCallback); */
194 /* ASSERT(driver->OnLinkStatusChanged); */
196 /* Setup the dispatch table */
197 driver
->Base
.OnDeviceAdd
= NetVscOnDeviceAdd
;
198 driver
->Base
.OnDeviceRemove
= NetVscOnDeviceRemove
;
199 driver
->Base
.OnCleanup
= NetVscOnCleanup
;
201 driver
->OnSend
= NetVscOnSend
;
203 RndisFilterInit(driver
);
207 static int NetVscInitializeReceiveBufferWithNetVsp(struct hv_device
*Device
)
210 struct netvsc_device
*netDevice
;
211 struct nvsp_message
*initPacket
;
213 netDevice
= GetOutboundNetDevice(Device
);
215 DPRINT_ERR(NETVSC
, "unable to get net device..."
216 "device being destroyed?");
219 /* ASSERT(netDevice->ReceiveBufferSize > 0); */
220 /* page-size grandularity */
221 /* ASSERT((netDevice->ReceiveBufferSize & (PAGE_SIZE - 1)) == 0); */
223 netDevice
->ReceiveBuffer
=
224 osd_page_alloc(netDevice
->ReceiveBufferSize
>> PAGE_SHIFT
);
225 if (!netDevice
->ReceiveBuffer
) {
227 "unable to allocate receive buffer of size %d",
228 netDevice
->ReceiveBufferSize
);
232 /* page-aligned buffer */
233 /* ASSERT(((unsigned long)netDevice->ReceiveBuffer & (PAGE_SIZE - 1)) == */
236 DPRINT_INFO(NETVSC
, "Establishing receive buffer's GPADL...");
239 * Establish the gpadl handle for this buffer on this
240 * channel. Note: This call uses the vmbus connection rather
241 * than the channel to establish the gpadl handle.
243 ret
= vmbus_establish_gpadl(Device
->channel
, netDevice
->ReceiveBuffer
,
244 netDevice
->ReceiveBufferSize
,
245 &netDevice
->ReceiveBufferGpadlHandle
);
248 "unable to establish receive buffer's gpadl");
252 /* osd_waitevent_wait(ext->ChannelInitEvent); */
254 /* Notify the NetVsp of the gpadl handle */
255 DPRINT_INFO(NETVSC
, "Sending NvspMessage1TypeSendReceiveBuffer...");
257 initPacket
= &netDevice
->ChannelInitPacket
;
259 memset(initPacket
, 0, sizeof(struct nvsp_message
));
261 initPacket
->Header
.MessageType
= NvspMessage1TypeSendReceiveBuffer
;
262 initPacket
->Messages
.Version1Messages
.SendReceiveBuffer
.GpadlHandle
= netDevice
->ReceiveBufferGpadlHandle
;
263 initPacket
->Messages
.Version1Messages
.SendReceiveBuffer
.Id
= NETVSC_RECEIVE_BUFFER_ID
;
265 /* Send the gpadl notification request */
266 ret
= vmbus_sendpacket(Device
->channel
, initPacket
,
267 sizeof(struct nvsp_message
),
268 (unsigned long)initPacket
,
269 VmbusPacketTypeDataInBand
,
270 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
);
273 "unable to send receive buffer's gpadl to netvsp");
277 osd_waitevent_wait(netDevice
->ChannelInitEvent
);
279 /* Check the response */
280 if (initPacket
->Messages
.Version1Messages
.SendReceiveBufferComplete
.Status
!= NvspStatusSuccess
) {
281 DPRINT_ERR(NETVSC
, "Unable to complete receive buffer "
282 "initialzation with NetVsp - status %d",
283 initPacket
->Messages
.Version1Messages
.SendReceiveBufferComplete
.Status
);
288 /* Parse the response */
289 /* ASSERT(netDevice->ReceiveSectionCount == 0); */
290 /* ASSERT(netDevice->ReceiveSections == NULL); */
292 netDevice
->ReceiveSectionCount
= initPacket
->Messages
.Version1Messages
.SendReceiveBufferComplete
.NumSections
;
294 netDevice
->ReceiveSections
= kmalloc(netDevice
->ReceiveSectionCount
* sizeof(struct nvsp_1_receive_buffer_section
), GFP_KERNEL
);
295 if (netDevice
->ReceiveSections
== NULL
) {
300 memcpy(netDevice
->ReceiveSections
,
301 initPacket
->Messages
.Version1Messages
.SendReceiveBufferComplete
.Sections
,
302 netDevice
->ReceiveSectionCount
* sizeof(struct nvsp_1_receive_buffer_section
));
304 DPRINT_INFO(NETVSC
, "Receive sections info (count %d, offset %d, "
305 "endoffset %d, suballoc size %d, num suballocs %d)",
306 netDevice
->ReceiveSectionCount
,
307 netDevice
->ReceiveSections
[0].Offset
,
308 netDevice
->ReceiveSections
[0].EndOffset
,
309 netDevice
->ReceiveSections
[0].SubAllocationSize
,
310 netDevice
->ReceiveSections
[0].NumSubAllocations
);
313 * For 1st release, there should only be 1 section that represents the
314 * entire receive buffer
316 if (netDevice
->ReceiveSectionCount
!= 1 ||
317 netDevice
->ReceiveSections
->Offset
!= 0) {
325 NetVscDestroyReceiveBuffer(netDevice
);
328 PutNetDevice(Device
);
332 static int NetVscInitializeSendBufferWithNetVsp(struct hv_device
*Device
)
335 struct netvsc_device
*netDevice
;
336 struct nvsp_message
*initPacket
;
338 netDevice
= GetOutboundNetDevice(Device
);
340 DPRINT_ERR(NETVSC
, "unable to get net device..."
341 "device being destroyed?");
344 if (netDevice
->SendBufferSize
<= 0) {
349 /* page-size grandularity */
350 /* ASSERT((netDevice->SendBufferSize & (PAGE_SIZE - 1)) == 0); */
352 netDevice
->SendBuffer
=
353 osd_page_alloc(netDevice
->SendBufferSize
>> PAGE_SHIFT
);
354 if (!netDevice
->SendBuffer
) {
355 DPRINT_ERR(NETVSC
, "unable to allocate send buffer of size %d",
356 netDevice
->SendBufferSize
);
360 /* page-aligned buffer */
361 /* ASSERT(((unsigned long)netDevice->SendBuffer & (PAGE_SIZE - 1)) == 0); */
363 DPRINT_INFO(NETVSC
, "Establishing send buffer's GPADL...");
366 * Establish the gpadl handle for this buffer on this
367 * channel. Note: This call uses the vmbus connection rather
368 * than the channel to establish the gpadl handle.
370 ret
= vmbus_establish_gpadl(Device
->channel
, netDevice
->SendBuffer
,
371 netDevice
->SendBufferSize
,
372 &netDevice
->SendBufferGpadlHandle
);
374 DPRINT_ERR(NETVSC
, "unable to establish send buffer's gpadl");
378 /* osd_waitevent_wait(ext->ChannelInitEvent); */
380 /* Notify the NetVsp of the gpadl handle */
381 DPRINT_INFO(NETVSC
, "Sending NvspMessage1TypeSendSendBuffer...");
383 initPacket
= &netDevice
->ChannelInitPacket
;
385 memset(initPacket
, 0, sizeof(struct nvsp_message
));
387 initPacket
->Header
.MessageType
= NvspMessage1TypeSendSendBuffer
;
388 initPacket
->Messages
.Version1Messages
.SendReceiveBuffer
.GpadlHandle
= netDevice
->SendBufferGpadlHandle
;
389 initPacket
->Messages
.Version1Messages
.SendReceiveBuffer
.Id
= NETVSC_SEND_BUFFER_ID
;
391 /* Send the gpadl notification request */
392 ret
= vmbus_sendpacket(Device
->channel
, initPacket
,
393 sizeof(struct nvsp_message
),
394 (unsigned long)initPacket
,
395 VmbusPacketTypeDataInBand
,
396 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
);
399 "unable to send receive buffer's gpadl to netvsp");
403 osd_waitevent_wait(netDevice
->ChannelInitEvent
);
405 /* Check the response */
406 if (initPacket
->Messages
.Version1Messages
.SendSendBufferComplete
.Status
!= NvspStatusSuccess
) {
407 DPRINT_ERR(NETVSC
, "Unable to complete send buffer "
408 "initialzation with NetVsp - status %d",
409 initPacket
->Messages
.Version1Messages
.SendSendBufferComplete
.Status
);
414 netDevice
->SendSectionSize
= initPacket
->Messages
.Version1Messages
.SendSendBufferComplete
.SectionSize
;
419 NetVscDestroySendBuffer(netDevice
);
422 PutNetDevice(Device
);
426 static int NetVscDestroyReceiveBuffer(struct netvsc_device
*NetDevice
)
428 struct nvsp_message
*revokePacket
;
432 * If we got a section count, it means we received a
433 * SendReceiveBufferComplete msg (ie sent
434 * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
435 * to send a revoke msg here
437 if (NetDevice
->ReceiveSectionCount
) {
439 "Sending NvspMessage1TypeRevokeReceiveBuffer...");
441 /* Send the revoke receive buffer */
442 revokePacket
= &NetDevice
->RevokePacket
;
443 memset(revokePacket
, 0, sizeof(struct nvsp_message
));
445 revokePacket
->Header
.MessageType
= NvspMessage1TypeRevokeReceiveBuffer
;
446 revokePacket
->Messages
.Version1Messages
.RevokeReceiveBuffer
.Id
= NETVSC_RECEIVE_BUFFER_ID
;
448 ret
= vmbus_sendpacket(NetDevice
->Device
->channel
, revokePacket
,
449 sizeof(struct nvsp_message
),
450 (unsigned long)revokePacket
,
451 VmbusPacketTypeDataInBand
, 0);
453 * If we failed here, we might as well return and
454 * have a leak rather than continue and a bugchk
457 DPRINT_ERR(NETVSC
, "unable to send revoke receive "
463 /* Teardown the gpadl on the vsp end */
464 if (NetDevice
->ReceiveBufferGpadlHandle
) {
465 DPRINT_INFO(NETVSC
, "Tearing down receive buffer's GPADL...");
467 ret
= vmbus_teardown_gpadl(NetDevice
->Device
->channel
,
468 NetDevice
->ReceiveBufferGpadlHandle
);
470 /* If we failed here, we might as well return and have a leak rather than continue and a bugchk */
473 "unable to teardown receive buffer's gpadl");
476 NetDevice
->ReceiveBufferGpadlHandle
= 0;
479 if (NetDevice
->ReceiveBuffer
) {
480 DPRINT_INFO(NETVSC
, "Freeing up receive buffer...");
482 /* Free up the receive buffer */
483 osd_page_free(NetDevice
->ReceiveBuffer
,
484 NetDevice
->ReceiveBufferSize
>> PAGE_SHIFT
);
485 NetDevice
->ReceiveBuffer
= NULL
;
488 if (NetDevice
->ReceiveSections
) {
489 NetDevice
->ReceiveSectionCount
= 0;
490 kfree(NetDevice
->ReceiveSections
);
491 NetDevice
->ReceiveSections
= NULL
;
497 static int NetVscDestroySendBuffer(struct netvsc_device
*NetDevice
)
499 struct nvsp_message
*revokePacket
;
503 * If we got a section count, it means we received a
504 * SendReceiveBufferComplete msg (ie sent
505 * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
506 * to send a revoke msg here
508 if (NetDevice
->SendSectionSize
) {
510 "Sending NvspMessage1TypeRevokeSendBuffer...");
512 /* Send the revoke send buffer */
513 revokePacket
= &NetDevice
->RevokePacket
;
514 memset(revokePacket
, 0, sizeof(struct nvsp_message
));
516 revokePacket
->Header
.MessageType
= NvspMessage1TypeRevokeSendBuffer
;
517 revokePacket
->Messages
.Version1Messages
.RevokeSendBuffer
.Id
= NETVSC_SEND_BUFFER_ID
;
519 ret
= vmbus_sendpacket(NetDevice
->Device
->channel
, revokePacket
,
520 sizeof(struct nvsp_message
),
521 (unsigned long)revokePacket
,
522 VmbusPacketTypeDataInBand
, 0);
524 * If we failed here, we might as well return and have a leak
525 * rather than continue and a bugchk
528 DPRINT_ERR(NETVSC
, "unable to send revoke send buffer "
534 /* Teardown the gpadl on the vsp end */
535 if (NetDevice
->SendBufferGpadlHandle
) {
536 DPRINT_INFO(NETVSC
, "Tearing down send buffer's GPADL...");
537 ret
= vmbus_teardown_gpadl(NetDevice
->Device
->channel
,
538 NetDevice
->SendBufferGpadlHandle
);
541 * If we failed here, we might as well return and have a leak
542 * rather than continue and a bugchk
545 DPRINT_ERR(NETVSC
, "unable to teardown send buffer's "
549 NetDevice
->SendBufferGpadlHandle
= 0;
552 if (NetDevice
->SendBuffer
) {
553 DPRINT_INFO(NETVSC
, "Freeing up send buffer...");
555 /* Free up the receive buffer */
556 osd_page_free(NetDevice
->SendBuffer
,
557 NetDevice
->SendBufferSize
>> PAGE_SHIFT
);
558 NetDevice
->SendBuffer
= NULL
;
565 static int NetVscConnectToVsp(struct hv_device
*Device
)
568 struct netvsc_device
*netDevice
;
569 struct nvsp_message
*initPacket
;
572 netDevice
= GetOutboundNetDevice(Device
);
574 DPRINT_ERR(NETVSC
, "unable to get net device..."
575 "device being destroyed?");
579 initPacket
= &netDevice
->ChannelInitPacket
;
581 memset(initPacket
, 0, sizeof(struct nvsp_message
));
582 initPacket
->Header
.MessageType
= NvspMessageTypeInit
;
583 initPacket
->Messages
.InitMessages
.Init
.MinProtocolVersion
= NVSP_MIN_PROTOCOL_VERSION
;
584 initPacket
->Messages
.InitMessages
.Init
.MaxProtocolVersion
= NVSP_MAX_PROTOCOL_VERSION
;
586 DPRINT_INFO(NETVSC
, "Sending NvspMessageTypeInit...");
588 /* Send the init request */
589 ret
= vmbus_sendpacket(Device
->channel
, initPacket
,
590 sizeof(struct nvsp_message
),
591 (unsigned long)initPacket
,
592 VmbusPacketTypeDataInBand
,
593 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
);
596 DPRINT_ERR(NETVSC
, "unable to send NvspMessageTypeInit");
600 osd_waitevent_wait(netDevice
->ChannelInitEvent
);
602 /* Now, check the response */
603 /* ASSERT(initPacket->Messages.InitMessages.InitComplete.MaximumMdlChainLength <= MAX_MULTIPAGE_BUFFER_COUNT); */
604 DPRINT_INFO(NETVSC
, "NvspMessageTypeInit status(%d) max mdl chain (%d)",
605 initPacket
->Messages
.InitMessages
.InitComplete
.Status
,
606 initPacket
->Messages
.InitMessages
.InitComplete
.MaximumMdlChainLength
);
608 if (initPacket
->Messages
.InitMessages
.InitComplete
.Status
!=
611 "unable to initialize with netvsp (status 0x%x)",
612 initPacket
->Messages
.InitMessages
.InitComplete
.Status
);
617 if (initPacket
->Messages
.InitMessages
.InitComplete
.NegotiatedProtocolVersion
!= NVSP_PROTOCOL_VERSION_1
) {
618 DPRINT_ERR(NETVSC
, "unable to initialize with netvsp "
619 "(version expected 1 got %d)",
620 initPacket
->Messages
.InitMessages
.InitComplete
.NegotiatedProtocolVersion
);
624 DPRINT_INFO(NETVSC
, "Sending NvspMessage1TypeSendNdisVersion...");
626 /* Send the ndis version */
627 memset(initPacket
, 0, sizeof(struct nvsp_message
));
629 ndisVersion
= 0x00050000;
631 initPacket
->Header
.MessageType
= NvspMessage1TypeSendNdisVersion
;
632 initPacket
->Messages
.Version1Messages
.SendNdisVersion
.NdisMajorVersion
=
633 (ndisVersion
& 0xFFFF0000) >> 16;
634 initPacket
->Messages
.Version1Messages
.SendNdisVersion
.NdisMinorVersion
=
635 ndisVersion
& 0xFFFF;
637 /* Send the init request */
638 ret
= vmbus_sendpacket(Device
->channel
, initPacket
,
639 sizeof(struct nvsp_message
),
640 (unsigned long)initPacket
,
641 VmbusPacketTypeDataInBand
, 0);
644 "unable to send NvspMessage1TypeSendNdisVersion");
649 * BUGBUG - We have to wait for the above msg since the
650 * netvsp uses KMCL which acknowledges packet (completion
651 * packet) since our Vmbus always set the
652 * VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED flag
654 /* osd_waitevent_wait(NetVscChannel->ChannelInitEvent); */
656 /* Post the big receive buffer to NetVSP */
657 ret
= NetVscInitializeReceiveBufferWithNetVsp(Device
);
659 ret
= NetVscInitializeSendBufferWithNetVsp(Device
);
662 PutNetDevice(Device
);
666 static void NetVscDisconnectFromVsp(struct netvsc_device
*NetDevice
)
668 NetVscDestroyReceiveBuffer(NetDevice
);
669 NetVscDestroySendBuffer(NetDevice
);
673 * NetVscOnDeviceAdd - Callback when the device belonging to this driver is added
675 static int NetVscOnDeviceAdd(struct hv_device
*Device
, void *AdditionalInfo
)
679 struct netvsc_device
*netDevice
;
680 struct hv_netvsc_packet
*packet
, *pos
;
681 struct netvsc_driver
*netDriver
=
682 (struct netvsc_driver
*)Device
->Driver
;
684 netDevice
= AllocNetDevice(Device
);
690 DPRINT_DBG(NETVSC
, "netvsc channel object allocated - %p", netDevice
);
692 /* Initialize the NetVSC channel extension */
693 netDevice
->ReceiveBufferSize
= NETVSC_RECEIVE_BUFFER_SIZE
;
694 spin_lock_init(&netDevice
->receive_packet_list_lock
);
696 netDevice
->SendBufferSize
= NETVSC_SEND_BUFFER_SIZE
;
698 INIT_LIST_HEAD(&netDevice
->ReceivePacketList
);
700 for (i
= 0; i
< NETVSC_RECEIVE_PACKETLIST_COUNT
; i
++) {
701 packet
= kzalloc(sizeof(struct hv_netvsc_packet
) +
702 (NETVSC_RECEIVE_SG_COUNT
*
703 sizeof(struct hv_page_buffer
)), GFP_KERNEL
);
705 DPRINT_DBG(NETVSC
, "unable to allocate netvsc pkts "
706 "for receive pool (wanted %d got %d)",
707 NETVSC_RECEIVE_PACKETLIST_COUNT
, i
);
710 list_add_tail(&packet
->ListEntry
,
711 &netDevice
->ReceivePacketList
);
713 netDevice
->ChannelInitEvent
= osd_waitevent_create();
714 if (!netDevice
->ChannelInitEvent
) {
719 /* Open the channel */
720 ret
= vmbus_open(Device
->channel
, netDriver
->RingBufferSize
,
721 netDriver
->RingBufferSize
, NULL
, 0,
722 NetVscOnChannelCallback
, Device
);
725 DPRINT_ERR(NETVSC
, "unable to open channel: %d", ret
);
730 /* Channel is opened */
731 DPRINT_INFO(NETVSC
, "*** NetVSC channel opened successfully! ***");
733 /* Connect with the NetVsp */
734 ret
= NetVscConnectToVsp(Device
);
736 DPRINT_ERR(NETVSC
, "unable to connect to NetVSP - %d", ret
);
741 DPRINT_INFO(NETVSC
, "*** NetVSC channel handshake result - %d ***",
747 /* Now, we can close the channel safely */
748 vmbus_close(Device
->channel
);
753 kfree(netDevice
->ChannelInitEvent
);
755 list_for_each_entry_safe(packet
, pos
,
756 &netDevice
->ReceivePacketList
,
758 list_del(&packet
->ListEntry
);
762 ReleaseOutboundNetDevice(Device
);
763 ReleaseInboundNetDevice(Device
);
765 FreeNetDevice(netDevice
);
772 * NetVscOnDeviceRemove - Callback when the root bus device is removed
774 static int NetVscOnDeviceRemove(struct hv_device
*Device
)
776 struct netvsc_device
*netDevice
;
777 struct hv_netvsc_packet
*netvscPacket
, *pos
;
779 DPRINT_INFO(NETVSC
, "Disabling outbound traffic on net device (%p)...",
782 /* Stop outbound traffic ie sends and receives completions */
783 netDevice
= ReleaseOutboundNetDevice(Device
);
785 DPRINT_ERR(NETVSC
, "No net device present!!");
789 /* Wait for all send completions */
790 while (atomic_read(&netDevice
->NumOutstandingSends
)) {
791 DPRINT_INFO(NETVSC
, "waiting for %d requests to complete...",
792 atomic_read(&netDevice
->NumOutstandingSends
));
796 DPRINT_INFO(NETVSC
, "Disconnecting from netvsp...");
798 NetVscDisconnectFromVsp(netDevice
);
800 DPRINT_INFO(NETVSC
, "Disabling inbound traffic on net device (%p)...",
803 /* Stop inbound traffic ie receives and sends completions */
804 netDevice
= ReleaseInboundNetDevice(Device
);
806 /* At this point, no one should be accessing netDevice except in here */
807 DPRINT_INFO(NETVSC
, "net device (%p) safe to remove", netDevice
);
809 /* Now, we can close the channel safely */
810 vmbus_close(Device
->channel
);
812 /* Release all resources */
813 list_for_each_entry_safe(netvscPacket
, pos
,
814 &netDevice
->ReceivePacketList
, ListEntry
) {
815 list_del(&netvscPacket
->ListEntry
);
819 kfree(netDevice
->ChannelInitEvent
);
820 FreeNetDevice(netDevice
);
825 * NetVscOnCleanup - Perform any cleanup when the driver is removed
827 static void NetVscOnCleanup(struct hv_driver
*drv
)
831 static void NetVscOnSendCompletion(struct hv_device
*Device
,
832 struct vmpacket_descriptor
*Packet
)
834 struct netvsc_device
*netDevice
;
835 struct nvsp_message
*nvspPacket
;
836 struct hv_netvsc_packet
*nvscPacket
;
838 netDevice
= GetInboundNetDevice(Device
);
840 DPRINT_ERR(NETVSC
, "unable to get net device..."
841 "device being destroyed?");
845 nvspPacket
= (struct nvsp_message
*)((unsigned long)Packet
+ (Packet
->DataOffset8
<< 3));
847 DPRINT_DBG(NETVSC
, "send completion packet - type %d",
848 nvspPacket
->Header
.MessageType
);
850 if ((nvspPacket
->Header
.MessageType
== NvspMessageTypeInitComplete
) ||
851 (nvspPacket
->Header
.MessageType
==
852 NvspMessage1TypeSendReceiveBufferComplete
) ||
853 (nvspPacket
->Header
.MessageType
==
854 NvspMessage1TypeSendSendBufferComplete
)) {
855 /* Copy the response back */
856 memcpy(&netDevice
->ChannelInitPacket
, nvspPacket
,
857 sizeof(struct nvsp_message
));
858 osd_waitevent_set(netDevice
->ChannelInitEvent
);
859 } else if (nvspPacket
->Header
.MessageType
==
860 NvspMessage1TypeSendRNDISPacketComplete
) {
861 /* Get the send context */
862 nvscPacket
= (struct hv_netvsc_packet
*)(unsigned long)Packet
->TransactionId
;
863 /* ASSERT(nvscPacket); */
865 /* Notify the layer above us */
866 nvscPacket
->Completion
.Send
.OnSendCompletion(nvscPacket
->Completion
.Send
.SendCompletionContext
);
868 atomic_dec(&netDevice
->NumOutstandingSends
);
870 DPRINT_ERR(NETVSC
, "Unknown send completion packet type - "
871 "%d received!!", nvspPacket
->Header
.MessageType
);
874 PutNetDevice(Device
);
877 static int NetVscOnSend(struct hv_device
*Device
,
878 struct hv_netvsc_packet
*Packet
)
880 struct netvsc_device
*netDevice
;
883 struct nvsp_message sendMessage
;
885 netDevice
= GetOutboundNetDevice(Device
);
887 DPRINT_ERR(NETVSC
, "net device (%p) shutting down..."
888 "ignoring outbound packets", netDevice
);
892 sendMessage
.Header
.MessageType
= NvspMessage1TypeSendRNDISPacket
;
893 if (Packet
->IsDataPacket
) {
895 sendMessage
.Messages
.Version1Messages
.SendRNDISPacket
.ChannelType
= 0;
897 /* 1 is RMC_CONTROL; */
898 sendMessage
.Messages
.Version1Messages
.SendRNDISPacket
.ChannelType
= 1;
901 /* Not using send buffer section */
902 sendMessage
.Messages
.Version1Messages
.SendRNDISPacket
.SendBufferSectionIndex
= 0xFFFFFFFF;
903 sendMessage
.Messages
.Version1Messages
.SendRNDISPacket
.SendBufferSectionSize
= 0;
905 if (Packet
->PageBufferCount
) {
906 ret
= vmbus_sendpacket_pagebuffer(Device
->channel
,
908 Packet
->PageBufferCount
,
910 sizeof(struct nvsp_message
),
911 (unsigned long)Packet
);
913 ret
= vmbus_sendpacket(Device
->channel
, &sendMessage
,
914 sizeof(struct nvsp_message
),
915 (unsigned long)Packet
,
916 VmbusPacketTypeDataInBand
,
917 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
);
922 DPRINT_ERR(NETVSC
, "Unable to send packet %p ret %d",
925 atomic_inc(&netDevice
->NumOutstandingSends
);
926 PutNetDevice(Device
);
930 static void NetVscOnReceive(struct hv_device
*Device
,
931 struct vmpacket_descriptor
*Packet
)
933 struct netvsc_device
*netDevice
;
934 struct vmtransfer_page_packet_header
*vmxferpagePacket
;
935 struct nvsp_message
*nvspPacket
;
936 struct hv_netvsc_packet
*netvscPacket
= NULL
;
938 unsigned long end
, endVirtual
;
939 /* struct netvsc_driver *netvscDriver; */
940 struct xferpage_packet
*xferpagePacket
= NULL
;
942 int count
= 0, bytesRemain
= 0;
946 netDevice
= GetInboundNetDevice(Device
);
948 DPRINT_ERR(NETVSC
, "unable to get net device..."
949 "device being destroyed?");
954 * All inbound packets other than send completion should be xfer page
957 if (Packet
->Type
!= VmbusPacketTypeDataUsingTransferPages
) {
958 DPRINT_ERR(NETVSC
, "Unknown packet type received - %d",
960 PutNetDevice(Device
);
964 nvspPacket
= (struct nvsp_message
*)((unsigned long)Packet
+
965 (Packet
->DataOffset8
<< 3));
967 /* Make sure this is a valid nvsp packet */
968 if (nvspPacket
->Header
.MessageType
!= NvspMessage1TypeSendRNDISPacket
) {
969 DPRINT_ERR(NETVSC
, "Unknown nvsp packet type received - %d",
970 nvspPacket
->Header
.MessageType
);
971 PutNetDevice(Device
);
975 DPRINT_DBG(NETVSC
, "NVSP packet received - type %d",
976 nvspPacket
->Header
.MessageType
);
978 vmxferpagePacket
= (struct vmtransfer_page_packet_header
*)Packet
;
980 if (vmxferpagePacket
->TransferPageSetId
!= NETVSC_RECEIVE_BUFFER_ID
) {
981 DPRINT_ERR(NETVSC
, "Invalid xfer page set id - "
982 "expecting %x got %x", NETVSC_RECEIVE_BUFFER_ID
,
983 vmxferpagePacket
->TransferPageSetId
);
984 PutNetDevice(Device
);
988 DPRINT_DBG(NETVSC
, "xfer page - range count %d",
989 vmxferpagePacket
->RangeCount
);
992 * Grab free packets (range count + 1) to represent this xfer
993 * page packet. +1 to represent the xfer page packet itself.
994 * We grab it here so that we know exactly how many we can
997 spin_lock_irqsave(&netDevice
->receive_packet_list_lock
, flags
);
998 while (!list_empty(&netDevice
->ReceivePacketList
)) {
999 list_move_tail(netDevice
->ReceivePacketList
.next
, &listHead
);
1000 if (++count
== vmxferpagePacket
->RangeCount
+ 1)
1003 spin_unlock_irqrestore(&netDevice
->receive_packet_list_lock
, flags
);
1006 * We need at least 2 netvsc pkts (1 to represent the xfer
1007 * page and at least 1 for the range) i.e. we can handled
1008 * some of the xfer page packet ranges...
1011 DPRINT_ERR(NETVSC
, "Got only %d netvsc pkt...needed %d pkts. "
1012 "Dropping this xfer page packet completely!",
1013 count
, vmxferpagePacket
->RangeCount
+ 1);
1015 /* Return it to the freelist */
1016 spin_lock_irqsave(&netDevice
->receive_packet_list_lock
, flags
);
1017 for (i
= count
; i
!= 0; i
--) {
1018 list_move_tail(listHead
.next
,
1019 &netDevice
->ReceivePacketList
);
1021 spin_unlock_irqrestore(&netDevice
->receive_packet_list_lock
,
1024 NetVscSendReceiveCompletion(Device
,
1025 vmxferpagePacket
->d
.TransactionId
);
1027 PutNetDevice(Device
);
1031 /* Remove the 1st packet to represent the xfer page packet itself */
1032 xferpagePacket
= (struct xferpage_packet
*)listHead
.next
;
1033 list_del(&xferpagePacket
->ListEntry
);
1035 /* This is how much we can satisfy */
1036 xferpagePacket
->Count
= count
- 1;
1037 /* ASSERT(xferpagePacket->Count > 0 && xferpagePacket->Count <= */
1038 /* vmxferpagePacket->RangeCount); */
1040 if (xferpagePacket
->Count
!= vmxferpagePacket
->RangeCount
) {
1041 DPRINT_INFO(NETVSC
, "Needed %d netvsc pkts to satisy this xfer "
1042 "page...got %d", vmxferpagePacket
->RangeCount
,
1043 xferpagePacket
->Count
);
1046 /* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
1047 for (i
= 0; i
< (count
- 1); i
++) {
1048 netvscPacket
= (struct hv_netvsc_packet
*)listHead
.next
;
1049 list_del(&netvscPacket
->ListEntry
);
1051 /* Initialize the netvsc packet */
1052 netvscPacket
->XferPagePacket
= xferpagePacket
;
1053 netvscPacket
->Completion
.Recv
.OnReceiveCompletion
=
1054 NetVscOnReceiveCompletion
;
1055 netvscPacket
->Completion
.Recv
.ReceiveCompletionContext
=
1057 netvscPacket
->Device
= Device
;
1058 /* Save this so that we can send it back */
1059 netvscPacket
->Completion
.Recv
.ReceiveCompletionTid
=
1060 vmxferpagePacket
->d
.TransactionId
;
1062 netvscPacket
->TotalDataBufferLength
=
1063 vmxferpagePacket
->Ranges
[i
].ByteCount
;
1064 netvscPacket
->PageBufferCount
= 1;
1066 /* ASSERT(vmxferpagePacket->Ranges[i].ByteOffset + */
1067 /* vmxferpagePacket->Ranges[i].ByteCount < */
1068 /* netDevice->ReceiveBufferSize); */
1070 netvscPacket
->PageBuffers
[0].Length
=
1071 vmxferpagePacket
->Ranges
[i
].ByteCount
;
1073 start
= virt_to_phys((void *)((unsigned long)netDevice
->ReceiveBuffer
+ vmxferpagePacket
->Ranges
[i
].ByteOffset
));
1075 netvscPacket
->PageBuffers
[0].Pfn
= start
>> PAGE_SHIFT
;
1076 endVirtual
= (unsigned long)netDevice
->ReceiveBuffer
1077 + vmxferpagePacket
->Ranges
[i
].ByteOffset
1078 + vmxferpagePacket
->Ranges
[i
].ByteCount
- 1;
1079 end
= virt_to_phys((void *)endVirtual
);
1081 /* Calculate the page relative offset */
1082 netvscPacket
->PageBuffers
[0].Offset
=
1083 vmxferpagePacket
->Ranges
[i
].ByteOffset
& (PAGE_SIZE
- 1);
1084 if ((end
>> PAGE_SHIFT
) != (start
>> PAGE_SHIFT
)) {
1085 /* Handle frame across multiple pages: */
1086 netvscPacket
->PageBuffers
[0].Length
=
1087 (netvscPacket
->PageBuffers
[0].Pfn
<< PAGE_SHIFT
)
1088 + PAGE_SIZE
- start
;
1089 bytesRemain
= netvscPacket
->TotalDataBufferLength
-
1090 netvscPacket
->PageBuffers
[0].Length
;
1091 for (j
= 1; j
< NETVSC_PACKET_MAXPAGE
; j
++) {
1092 netvscPacket
->PageBuffers
[j
].Offset
= 0;
1093 if (bytesRemain
<= PAGE_SIZE
) {
1094 netvscPacket
->PageBuffers
[j
].Length
= bytesRemain
;
1097 netvscPacket
->PageBuffers
[j
].Length
= PAGE_SIZE
;
1098 bytesRemain
-= PAGE_SIZE
;
1100 netvscPacket
->PageBuffers
[j
].Pfn
=
1101 virt_to_phys((void *)(endVirtual
- bytesRemain
)) >> PAGE_SHIFT
;
1102 netvscPacket
->PageBufferCount
++;
1103 if (bytesRemain
== 0)
1106 /* ASSERT(bytesRemain == 0); */
1108 DPRINT_DBG(NETVSC
, "[%d] - (abs offset %u len %u) => "
1109 "(pfn %llx, offset %u, len %u)", i
,
1110 vmxferpagePacket
->Ranges
[i
].ByteOffset
,
1111 vmxferpagePacket
->Ranges
[i
].ByteCount
,
1112 netvscPacket
->PageBuffers
[0].Pfn
,
1113 netvscPacket
->PageBuffers
[0].Offset
,
1114 netvscPacket
->PageBuffers
[0].Length
);
1116 /* Pass it to the upper layer */
1117 ((struct netvsc_driver
*)Device
->Driver
)->OnReceiveCallback(Device
, netvscPacket
);
1119 NetVscOnReceiveCompletion(netvscPacket
->Completion
.Recv
.ReceiveCompletionContext
);
1122 /* ASSERT(list_empty(&listHead)); */
1124 PutNetDevice(Device
);
1127 static void NetVscSendReceiveCompletion(struct hv_device
*Device
,
1130 struct nvsp_message recvcompMessage
;
1134 DPRINT_DBG(NETVSC
, "Sending receive completion pkt - %llx",
1137 recvcompMessage
.Header
.MessageType
=
1138 NvspMessage1TypeSendRNDISPacketComplete
;
1140 /* FIXME: Pass in the status */
1141 recvcompMessage
.Messages
.Version1Messages
.SendRNDISPacketComplete
.Status
= NvspStatusSuccess
;
1144 /* Send the completion */
1145 ret
= vmbus_sendpacket(Device
->channel
, &recvcompMessage
,
1146 sizeof(struct nvsp_message
), TransactionId
,
1147 VmbusPacketTypeCompletion
, 0);
1151 } else if (ret
== -1) {
1152 /* no more room...wait a bit and attempt to retry 3 times */
1154 DPRINT_ERR(NETVSC
, "unable to send receive completion pkt "
1155 "(tid %llx)...retrying %d", TransactionId
, retries
);
1159 goto retry_send_cmplt
;
1161 DPRINT_ERR(NETVSC
, "unable to send receive completion "
1162 "pkt (tid %llx)...give up retrying",
1166 DPRINT_ERR(NETVSC
, "unable to send receive completion pkt - "
1167 "%llx", TransactionId
);
1171 /* Send a receive completion packet to RNDIS device (ie NetVsp) */
1172 static void NetVscOnReceiveCompletion(void *Context
)
1174 struct hv_netvsc_packet
*packet
= Context
;
1175 struct hv_device
*device
= (struct hv_device
*)packet
->Device
;
1176 struct netvsc_device
*netDevice
;
1177 u64 transactionId
= 0;
1178 bool fSendReceiveComp
= false;
1179 unsigned long flags
;
1181 /* ASSERT(packet->XferPagePacket); */
1184 * Even though it seems logical to do a GetOutboundNetDevice() here to
1185 * send out receive completion, we are using GetInboundNetDevice()
1186 * since we may have disable outbound traffic already.
1188 netDevice
= GetInboundNetDevice(device
);
1190 DPRINT_ERR(NETVSC
, "unable to get net device..."
1191 "device being destroyed?");
1195 /* Overloading use of the lock. */
1196 spin_lock_irqsave(&netDevice
->receive_packet_list_lock
, flags
);
1198 /* ASSERT(packet->XferPagePacket->Count > 0); */
1199 packet
->XferPagePacket
->Count
--;
1202 * Last one in the line that represent 1 xfer page packet.
1203 * Return the xfer page packet itself to the freelist
1205 if (packet
->XferPagePacket
->Count
== 0) {
1206 fSendReceiveComp
= true;
1207 transactionId
= packet
->Completion
.Recv
.ReceiveCompletionTid
;
1208 list_add_tail(&packet
->XferPagePacket
->ListEntry
,
1209 &netDevice
->ReceivePacketList
);
1213 /* Put the packet back */
1214 list_add_tail(&packet
->ListEntry
, &netDevice
->ReceivePacketList
);
1215 spin_unlock_irqrestore(&netDevice
->receive_packet_list_lock
, flags
);
1217 /* Send a receive completion for the xfer page packet */
1218 if (fSendReceiveComp
)
1219 NetVscSendReceiveCompletion(device
, transactionId
);
1221 PutNetDevice(device
);
1224 static void NetVscOnChannelCallback(void *Context
)
1227 struct hv_device
*device
= Context
;
1228 struct netvsc_device
*netDevice
;
1231 unsigned char *packet
;
1232 struct vmpacket_descriptor
*desc
;
1233 unsigned char *buffer
;
1234 int bufferlen
= NETVSC_PACKET_SIZE
;
1236 /* ASSERT(device); */
1238 packet
= kzalloc(NETVSC_PACKET_SIZE
* sizeof(unsigned char),
1244 netDevice
= GetInboundNetDevice(device
);
1246 DPRINT_ERR(NETVSC
, "net device (%p) shutting down..."
1247 "ignoring inbound packets", netDevice
);
1252 ret
= vmbus_recvpacket_raw(device
->channel
, buffer
, bufferlen
,
1253 &bytesRecvd
, &requestId
);
1255 if (bytesRecvd
> 0) {
1256 DPRINT_DBG(NETVSC
, "receive %d bytes, tid %llx",
1257 bytesRecvd
, requestId
);
1259 desc
= (struct vmpacket_descriptor
*)buffer
;
1260 switch (desc
->Type
) {
1261 case VmbusPacketTypeCompletion
:
1262 NetVscOnSendCompletion(device
, desc
);
1265 case VmbusPacketTypeDataUsingTransferPages
:
1266 NetVscOnReceive(device
, desc
);
1271 "unhandled packet type %d, "
1272 "tid %llx len %d\n",
1273 desc
->Type
, requestId
,
1279 if (bufferlen
> NETVSC_PACKET_SIZE
) {
1282 bufferlen
= NETVSC_PACKET_SIZE
;
1286 if (bufferlen
> NETVSC_PACKET_SIZE
) {
1289 bufferlen
= NETVSC_PACKET_SIZE
;
1294 } else if (ret
== -2) {
1295 /* Handle large packet */
1296 buffer
= kmalloc(bytesRecvd
, GFP_ATOMIC
);
1297 if (buffer
== NULL
) {
1298 /* Try again next time around */
1300 "unable to allocate buffer of size "
1301 "(%d)!!", bytesRecvd
);
1305 bufferlen
= bytesRecvd
;
1309 PutNetDevice(device
);