![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to send.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / sonic|
Return to send.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / sonic |
1.1 root 1: /*++
2:
3: Copyright (c) 1990-1992 Microsoft Corporation
4:
5: Module Name:
6:
7: send.c
8:
9: Abstract:
10:
11: This file contains the code for putting a packet through the
12: staged allocation for transmission.
13:
14: This is a process of
15:
16: 1) Calculating the what would need to be done to the
17: packet so that the packet can be transmitted on the hardware.
18:
19: 2) Potentially allocating adapter buffers and copying user data
20: to those buffers so that the packet data is transmitted under
21: the hardware constraints.
22:
23: 3) Allocating enough hardware ring entries so that the packet
24: can be transmitted.
25:
26: 4) Relinquish thos ring entries to the hardware.
27:
28: The overall structure and most of the code is taken from
29: the Lance driver by Tony Ercolano.
30:
31: Author:
32:
33: Anthony V. Ercolano (Tonye) 12-Sept-1990
34: Adam Barr (adamba) 16-Nov-1990
35:
36: Environment:
37:
38: Kernel Mode - Or whatever is the equivalent.
39:
40: Revision History:
41:
42:
43: --*/
44:
45:
46: #include <ndis.h>
47:
48: #include <efilter.h>
49: #include <sonichrd.h>
50: #include <sonicsft.h>
51:
52:
53:
54: //
55: // This macro will poke the sonic hardware into noticing that
56: // there is a packet available for transmit.
57: //
58:
59: #define START_TRANSMIT(_Adapter) \
60: SONIC_WRITE_PORT(_Adapter, SONIC_COMMAND, SONIC_CR_TRANSMIT_PACKETS)
61:
62:
63: STATIC
64: BOOLEAN
65: DeterminePacketAddressing(
66: IN PNDIS_PACKET Packet
67: );
68:
69: STATIC
70: VOID
71: StagedAllocation(
72: IN PSONIC_ADAPTER Adapter
73: );
74:
75: STATIC
76: VOID
77: AssignPacketToDescriptor(
78: IN PSONIC_ADAPTER Adapter,
79: IN PNDIS_PACKET Packet,
80: IN UINT DescriptorIndex
81: );
82:
83: STATIC
84: VOID
85: RelinquishPacket(
86: IN PSONIC_ADAPTER Adapter,
87: IN PNDIS_PACKET Packet,
88: IN UINT RingIndex
89: );
90:
91: STATIC
92: VOID
93: CalculatePacketConstraints(
94: IN PSONIC_ADAPTER Adapter,
95: IN PNDIS_PACKET Packet
96: );
97:
98: STATIC
99: BOOLEAN
100: ConstrainPacket(
101: IN PSONIC_ADAPTER Adapter,
102: IN PNDIS_PACKET Packet
103: );
104:
105:
106: #ifdef CHECK_DUP_SENDS
107:
108: #define PACKET_LIST_SIZE 20
109:
110: PNDIS_PACKET SonicPacketList[PACKET_LIST_SIZE];
111: UINT SonicPacketListSize = 0;
112:
113: VOID
114: SonicAddPacketToList(
115: PSONIC_ADAPTER Adapter,
116: PNDIS_PACKET NewPacket
117: )
118: {
119: INT i;
120:
121: for (i=0; i<SonicPacketListSize; i++) {
122:
123: if (SonicPacketList[i] == NewPacket) {
124:
125: DbgPrint("SONIC: dup send of %lx\n", NewPacket);
126:
127: }
128:
129: }
130:
131: SonicPacketList[SonicPacketListSize] = NewPacket;
132: ++SonicPacketListSize;
133:
134: }
135:
136: VOID
137: SonicRemovePacketFromList(
138: PSONIC_ADAPTER Adapter,
139: PNDIS_PACKET OldPacket
140: )
141: {
142: INT i;
143:
144: for (i=0; i<SonicPacketListSize; i++) {
145:
146: if (SonicPacketList[i] == OldPacket) {
147:
148: break;
149:
150: }
151:
152: }
153:
154: if (i == SonicPacketListSize) {
155:
156: DbgPrint("SONIC: bad remove of %lx\n", OldPacket);
157:
158: } else {
159:
160: --SonicPacketListSize;
161: SonicPacketList[i] = SonicPacketList[SonicPacketListSize];
162:
163: }
164:
165: }
166: #endif // CHECK_DUP_SENDS
167:
168:
169: extern
170: NDIS_STATUS
171: SonicSend(
172: IN NDIS_HANDLE MacBindingHandle,
173: IN PNDIS_PACKET Packet
174: )
175:
176: /*++
177:
178: Routine Description:
179:
180: The SonicSend request instructs a MAC to transmit a packet through
181: the adapter onto the medium.
182:
183: Arguments:
184:
185: MacBindingHandle - The context value returned by the MAC when the
186: adapter was opened. In reality, it is a pointer to SONIC_OPEN.
187:
188: Packet - A pointer to a descriptor for the packet that is to be
189: transmitted.
190:
191: Return Value:
192:
193: The function value is the status of the operation.
194:
195: --*/
196:
197: {
198:
199: //
200: // Holds the status that should be returned to the caller.
201: //
202: NDIS_STATUS StatusToReturn = NDIS_STATUS_PENDING;
203:
204: //
205: // Pointer to the adapter.
206: //
207: PSONIC_ADAPTER Adapter;
208:
209:
210: Adapter = PSONIC_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
211:
212: NdisAcquireSpinLock(&Adapter->Lock);
213:
214: if (Adapter->Removed) {
215:
216: NdisReleaseSpinLock(&Adapter->Lock);
217:
218: return(NDIS_STATUS_FAILURE);
219:
220: }
221:
222: Adapter->References++;
223:
224: if (!Adapter->ResetInProgress) {
225:
226: PSONIC_OPEN Open;
227: PSONIC_PACKET_RESERVED Reserved;
228:
229: Open = PSONIC_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
230:
231: if (!Open->BindingShuttingDown) {
232:
233: //
234: // Increment the references on the open while we are
235: // accessing it in the interface.
236: //
237:
238: #ifdef CHECK_DUP_SENDS
239: SonicAddPacketToList(Adapter, Packet);
240: #endif
241:
242: Open->References++;
243:
244: //
245: // Check to see if the packet should even make it out to
246: // the media. The primary reason this shouldn't *actually*
247: // be sent is if the destination is equal to the source
248: // address.
249: //
250: // If it doesn't need to be placed on the wire then we can
251: // simply put it onto the loopback queue.
252: //
253:
254: Reserved = PSONIC_RESERVED_FROM_PACKET(Packet);
255:
256: ASSERT(sizeof(SONIC_PACKET_RESERVED) <=
257: sizeof(Packet->MacReserved));
258:
259: Reserved->MacBindingHandle = MacBindingHandle;
260:
261: if (DeterminePacketAddressing(Packet)) {
262:
263: //
264: // The packet needs to be placed out on the wire.
265: //
266: //
267: // Determine if and how much adapter space would need to be allocated
268: // to meet hardware constraints.
269: //
270:
271: CalculatePacketConstraints(
272: Adapter,
273: Packet
274: );
275:
276: //
277: // Put on the send stage queue.
278: //
279:
280: if (!Adapter->LastSendStagePacket) {
281:
282: Adapter->FirstSendStagePacket = Packet;
283:
284: } else {
285:
286: PSONIC_RESERVED_FROM_PACKET(Adapter->LastSendStagePacket)->Next = Packet;
287:
288: }
289:
290: Adapter->LastSendStagePacket = Packet;
291:
292: ++Adapter->GeneralOptional[GO_TRANSMIT_QUEUE_LENGTH - GO_ARRAY_START];
293:
294: Reserved->Next = NULL;
295:
296: //
297: // Only try to push it through the send stage queue
298: // if somebody else isn't already doing it and
299: // there is some hope of moving some packets
300: // ahead.
301: //
302:
303: while ((!Adapter->AlreadyProcessingSendStage) &&
304: Adapter->FirstSendStagePacket &&
305: Adapter->SendStageOpen) {
306:
307: SonicStagedAllocation(Adapter);
308:
309: }
310:
311: } else {
312:
313: //
314: // It is a packet directed to ourselves. Put it directly
315: // on the loopback queue.
316: //
317:
318: SonicPutPacketOnLoopBack(
319: Adapter,
320: Packet,
321: TRUE
322: );
323:
324:
325: //
326: // Tally statistics now; assume that loopback
327: // always "succeeds". These packets are always
328: // directed (to us), so add to those counts.
329: //
330:
331: ++Adapter->GeneralMandatory[GM_TRANSMIT_GOOD];
332:
333: ++Adapter->GeneralOptionalFrameCount[GO_DIRECTED_TRANSMITS];
334:
335: SonicAddUlongToLargeInteger(
336: &Adapter->GeneralOptionalByteCount[GO_DIRECTED_TRANSMITS],
337: Reserved->PacketLength);
338:
339:
340: }
341:
342:
343: } else {
344:
345: StatusToReturn = NDIS_STATUS_CLOSING;
346:
347: }
348:
349: } else {
350:
351: StatusToReturn = NDIS_STATUS_RESET_IN_PROGRESS;
352:
353: }
354:
355:
356: //
357: // This macro assumes it is called with the lock held,
358: // and releases it.
359: //
360:
361: SONIC_DO_DEFERRED(Adapter);
362: return StatusToReturn;
363: }
364:
365: STATIC
366: BOOLEAN
367: DeterminePacketAddressing(
368: IN PNDIS_PACKET Packet
369: )
370:
371: /*++
372:
373: Routine Description:
374:
375: Calculates the packet type for this packet. It also determines
376: if this packet should go out on the wire.
377:
378: Arguments:
379:
380: Packet - Packet whose source and destination addresses are tested.
381:
382: Return Value:
383:
384: Returns FALSE if the source is equal to the destination.
385:
386:
387: --*/
388:
389: {
390: //
391: // MacReserved section of the packet.
392: //
393: PSONIC_PACKET_RESERVED Reserved = PSONIC_RESERVED_FROM_PACKET(Packet);
394:
395: //
396: // Hold the first Ndis buffer;
397: //
398: PNDIS_BUFFER FirstBuffer;
399:
400: //
401: // Holds the address of the data in the first buffer
402: //
403: PVOID BufferVirtualAddress;
404:
405: //
406: // Number of bytes in the first buffer.
407: //
408: UINT BufferLength;
409:
410: //
411: // Holds result of address check
412: //
413: UINT Result;
414:
415: NdisQueryPacket(
416: Packet,
417: NULL,
418: NULL,
419: &FirstBuffer,
420: NULL
421: );
422:
423: //
424: // Get VA of first buffer
425: //
426:
427: NdisQueryBuffer(
428: FirstBuffer,
429: &BufferVirtualAddress,
430: &BufferLength
431: );
432:
433: //
434: // Ndis spec says that the ethernet header must be in the first
435: // buffer.
436: //
437:
438: ASSERT(BufferLength >= 14);
439:
440: if (ETH_IS_MULTICAST(BufferVirtualAddress)) {
441:
442: if (ETH_IS_BROADCAST(BufferVirtualAddress)) {
443:
444: Reserved->PacketType = SONIC_BROADCAST;
445:
446: } else {
447:
448: Reserved->PacketType = SONIC_MULTICAST;
449:
450: }
451:
452: } else {
453:
454: Reserved->PacketType = SONIC_DIRECTED;
455:
456: ETH_COMPARE_NETWORK_ADDRESSES(
457: ((PUCHAR)BufferVirtualAddress) + ETH_LENGTH_OF_ADDRESS,
458: (PUCHAR)BufferVirtualAddress,
459: &Result
460: );
461:
462: if (!Result) {
463:
464: Reserved->PacketType = SONIC_LOOPBACK;
465:
466: }
467:
468: }
469:
470: //
471: // If the two addresses are equal then the
472: // packet shouldn't go out on the wire.
473: //
474:
475: return ((Reserved->PacketType == SONIC_LOOPBACK) ? FALSE : TRUE);
476:
477: }
478:
479: extern
480: VOID
481: SonicStagedAllocation(
482: IN PSONIC_ADAPTER Adapter
483: )
484:
485: /*++
486:
487: Routine Description:
488:
489: This routine attempts to take a packet through a stage of allocation.
490:
491: NOTE : It is called with the lock held and returns with the lock held.
492:
493: NOTE : It is called with the stage open, a packet on the queue and
494: no one already processing the stage.
495:
496: Arguments:
497:
498: Adapter - The adapter that the packets are coming through.
499:
500: Return Value:
501:
502: None.
503:
504: --*/
505:
506: {
507: //
508: // Holds whether the packet has been constrained
509: // to the hardware requirements.
510: //
511: BOOLEAN SuitableForHardware;
512:
513: //
514: // Packet to process
515: //
516: PNDIS_PACKET FirstPacket = Adapter->FirstSendStagePacket;
517:
518: //
519: // MacReserved section of the packet.
520: //
521: PSONIC_PACKET_RESERVED Reserved = PSONIC_RESERVED_FROM_PACKET(FirstPacket);
522:
523: //
524: // If we successfully acquire some ring entries, this
525: // is the index of the first one.
526: //
527: UINT DescriptorIndex;
528:
529: ASSERT(Adapter->SendStageOpen &&
530: !Adapter->AlreadyProcessingSendStage &&
531: Adapter->FirstSendStagePacket
532: );
533:
534:
535: //
536: // We look to see if there are enough ring entries.
537: // If there aren't then stage will close.
538: //
539:
540: if (Adapter->NumberOfAvailableDescriptors > 1) {
541:
542: DescriptorIndex = Adapter->AllocateableDescriptor - Adapter->TransmitDescriptorArea;
543:
544: if (Adapter->AllocateableDescriptor == Adapter->LastTransmitDescriptor) {
545:
546: Adapter->AllocateableDescriptor = Adapter->TransmitDescriptorArea;
547:
548: } else {
549:
550: ++(Adapter->AllocateableDescriptor);
551:
552: }
553:
554: --(Adapter->NumberOfAvailableDescriptors);
555:
556: if (Reserved->UsedSonicBuffer == TRUE) {
557:
558: //
559: // ConstrainPacket returns FALSE if an adapter buffer
560: // is needed and none is available such that the
561: // spinlock will not have been release. It will also close
562: // stage in that case.
563: //
564: // If it did use an adapter buffer it will release the spinlock
565: // to do the copy to the buffer.
566: //
567:
568: Adapter->AlreadyProcessingSendStage = TRUE;
569:
570: SuitableForHardware = ConstrainPacket(
571: Adapter,
572: FirstPacket
573: );
574:
575: Adapter->AlreadyProcessingSendStage = FALSE;
576:
577: if (!SuitableForHardware) {
578:
579: //
580: // Return transmit descriptor
581: //
582:
583: Adapter->AllocateableDescriptor = Adapter->TransmitDescriptorArea +
584: DescriptorIndex;
585:
586:
587: ++(Adapter->NumberOfAvailableDescriptors);
588:
589: return;
590:
591:
592: }
593:
594: }
595:
596: //
597: // Remove packet from wait queue and put it on transmit complete queue.
598: //
599:
600: if (Adapter->LastSendStagePacket == FirstPacket) {
601:
602: Adapter->FirstSendStagePacket = NULL;
603: Adapter->LastSendStagePacket = NULL;
604:
605: } else {
606:
607: Adapter->FirstSendStagePacket = Reserved->Next;
608:
609: }
610:
611: if (Adapter->FirstFinishTransmit == NULL) {
612:
613: Adapter->FirstFinishTransmit = FirstPacket;
614:
615: } else {
616:
617: PSONIC_RESERVED_FROM_PACKET(Adapter->LastFinishTransmit)->Next = FirstPacket;
618:
619: }
620:
621: Adapter->LastFinishTransmit = FirstPacket;
622:
623: Reserved->Next = NULL;
624:
625: --Adapter->GeneralOptional[GO_TRANSMIT_QUEUE_LENGTH - GO_ARRAY_START];
626:
627: //
628: // We have the number of buffers that we need.
629: // We assign all of the buffers to the ring entries.
630: //
631:
632: AssignPacketToDescriptor(
633: Adapter,
634: FirstPacket,
635: DescriptorIndex
636: );
637:
638: RelinquishPacket(
639: Adapter,
640: FirstPacket,
641: DescriptorIndex
642: );
643:
644: } else {
645:
646: Adapter->SendStageOpen = FALSE;
647:
648: }
649:
650: }
651:
652: STATIC
653: BOOLEAN
654: ConstrainPacket(
655: IN PSONIC_ADAPTER Adapter,
656: IN PNDIS_PACKET Packet
657: )
658:
659: /*++
660:
661: Routine Description:
662:
663: Given a packet and necessary attempt to acquire adapter
664: buffer resources so that the packet meets sonic hardware
665: contraints. If a buffer is needed and is not available then
666: stage is closed.
667:
668: The constraints are that the packet must have SONIC_MAX_FRAGMENTS
669: or fewer physical pieces and no piece may be less than
670: SONIC_MIN_PIECE_SIZE bytes. The first constraint is based on
671: the size of the SONIC_TRANSMIT_DESCRIPTOR, and the second
672: is to prevent underflow in the Silo.
673:
674: If a packet violates either of the constraints then it
675: will be copied in its entirety into an adapter buffer.
676:
677: NOTE: Called with lock held!!
678:
679: Arguments:
680:
681: Adapter - The adapter the packet is coming through.
682:
683: Packet - The packet whose buffers are to be constrained.
684: The packet reserved section is filled with information
685: detailing how the packet needs to be adjusted.
686:
687: Return Value:
688:
689: Returns TRUE if the packet is suitable for the hardware.
690:
691: --*/
692:
693: {
694:
695: //
696: // Pointer to the reserved section of the packet to be contrained.
697: //
698: PSONIC_PACKET_RESERVED Reserved = PSONIC_RESERVED_FROM_PACKET(Packet);
699:
700: //
701: // Holds the adapter buffer index available for allocation.
702: //
703: INT SonicBuffersIndex;
704:
705: //
706: // Points to a successfully allocated adapter buffer descriptor.
707: //
708: PSONIC_BUFFER_DESCRIPTOR BufferDescriptor;
709:
710: //
711: // Will point into the virtual address space addressed
712: // by the adapter buffer if one was successfully allocated.
713: //
714: PCHAR CurrentDestination;
715:
716: //
717: // Will hold the total amount of data copied to the
718: // adapter buffer.
719: //
720: UINT TotalDataMoved = 0;
721:
722: //
723: // Will point to the current source buffer.
724: //
725: PNDIS_BUFFER SourceBuffer;
726:
727: //
728: // Points to the virtual address of the source buffers data.
729: //
730: PVOID SourceData;
731:
732: //
733: // Will point to the number of bytes of data in the source
734: // buffer.
735: //
736: UINT SourceLength;
737:
738: //
739: // Simple iteration variable.
740: //
741: INT i;
742:
743: if (Reserved->PacketLength <= SONIC_SMALL_BUFFER_SIZE) {
744:
745: i = 1;
746:
747: } else if (Reserved->PacketLength <= SONIC_MEDIUM_BUFFER_SIZE) {
748:
749: i = 2;
750:
751: } else {
752:
753: i = 3;
754:
755: }
756:
757:
758: for (
759: ;
760: i <= 3;
761: i++
762: ) {
763:
764: if ((SonicBuffersIndex = Adapter->SonicBufferListHeads[i]) != -1) {
765:
766: BufferDescriptor = Adapter->SonicBuffers + SonicBuffersIndex;
767: Adapter->SonicBufferListHeads[i] = BufferDescriptor->Next;
768: break;
769:
770: }
771:
772: }
773:
774: if (SonicBuffersIndex == -1) {
775:
776: //
777: // Nothing available for the packet.
778: //
779:
780: Adapter->SendStageOpen = FALSE;
781:
782: return FALSE;
783:
784: }
785:
786: NdisReleaseSpinLock(&Adapter->Lock);
787:
788: //
789: // Save the list head index in the buffer descriptor
790: // to permit easy deallocation later.
791: //
792:
793: BufferDescriptor->Next = i;
794:
795: //
796: // Fill in the adapter buffer with the data from the users
797: // buffers.
798: //
799:
800: CurrentDestination = BufferDescriptor->VirtualSonicBuffer;
801:
802: NdisQueryPacket(
803: Packet,
804: NULL,
805: NULL,
806: &SourceBuffer,
807: NULL
808: );
809:
810: while (SourceBuffer) {
811:
812: NdisQueryBuffer(
813: SourceBuffer,
814: &SourceData,
815: &SourceLength
816: );
817:
818: SONIC_MOVE_MEMORY(
819: CurrentDestination,
820: SourceData,
821: SourceLength
822: );
823:
824: CurrentDestination = (PCHAR)CurrentDestination + SourceLength;
825:
826: TotalDataMoved += SourceLength;
827:
828: NdisGetNextBuffer(
829: SourceBuffer,
830: &SourceBuffer
831: );
832:
833: }
834:
835: //
836: // If the packet is less then the minimum size then we
837: // need to zero out the rest of the packet.
838: //
839:
840: if (TotalDataMoved < SONIC_MIN_PACKET_SIZE) {
841:
842: SONIC_ZERO_MEMORY(
843: CurrentDestination,
844: SONIC_MIN_PACKET_SIZE - TotalDataMoved
845: );
846:
847: BufferDescriptor->DataLength = SONIC_MIN_PACKET_SIZE;
848:
849: } else {
850:
851: BufferDescriptor->DataLength = TotalDataMoved;
852:
853: }
854:
855: NdisAcquireSpinLock(&Adapter->Lock);
856:
857: //
858: // We need to save in the packet which adapter buffer descriptor
859: // it is using so that we can deallocate it later.
860: //
861:
862: Reserved->SonicBuffersIndex = SonicBuffersIndex;
863:
864: return TRUE;
865: }
866:
867: STATIC
868: VOID
869: CalculatePacketConstraints(
870: IN PSONIC_ADAPTER Adapter,
871: IN PNDIS_PACKET Packet
872: )
873:
874: /*++
875:
876: Routine Description:
877:
878: Given a packet calculate how the packet will have to be
879: adjusted to meet with hardware constraints.
880:
881: The constraints are that the packet must have SONIC_MAX_FRAGMENTS
882: or fewer physical pieces and no piece may be less than
883: SONIC_MIN_FRAGMENT_SIZE bytes. The first constraint is based on
884: the size of the SONIC_TRANSMIT_DESCRIPTOR, and the second
885: is to prevent underflow in the Silo.
886:
887: If the packet is found to violate the constraints, then
888: UsedSonicBuffer will be set to TRUE. This will cause the entire packet to
889: be copied into the adapter buffer (which is guaranteed
890: to be physically contiguous).
891:
892: Note: This is called with the lock held! Merely for convience to
893: reduce the number of times we acquire and release the spinlock.
894:
895: Arguments:
896:
897: Adapter - The adapter the packet is coming through.
898:
899: Packet - The packet whose buffers are to be reallocated.
900: The packet reserved section is filled with information
901: detailing how the packet needs to be adjusted.
902:
903: Return Value:
904:
905: None.
906:
907: --*/
908:
909: {
910:
911: //
912: // Points to the MacReserved portion of the packet.
913: //
914: PSONIC_PACKET_RESERVED Reserved = PSONIC_RESERVED_FROM_PACKET(Packet);
915:
916: //
917: // The number of physical buffers in the entire packet.
918: //
919: UINT PacketPhysicalSegments;
920:
921: //
922: // Points to the current ndis buffer being walked.
923: //
924: PNDIS_BUFFER CurrentBuffer;
925:
926: //
927: // The virtual address of the current ndis buffer.
928: //
929: PVOID BufferVirtualAddress;
930:
931: //
932: // The length in bytes of the current ndis buffer.
933: //
934: UINT BufferVirtualLength;
935:
936: //
937: // The total amount of data contained within the ndis packet.
938: //
939: UINT PacketVirtualLength;
940:
941: //
942: // The number of physical buffers in a single buffer.
943: //
944: UINT BufferPhysicalSegments;
945:
946: //
947: // TRUE once we find a constraint violation
948: //
949: BOOLEAN ViolatedConstraints = FALSE;
950:
951: #ifndef NO_CHIP_FIXUP
952: //
953: // Used to keep track of the total number of fragments
954: // that the packet will occupy when assigned to a
955: // transmit descriptor (may be more than PacketPhysicalSegments
956: // if we have to worry about packets starting or ending
957: // on non-longword boundaries.
958: //
959: UINT TotalTransmitSegments = 0;
960: #endif
961:
962:
963:
964: //
965: // Get the first buffer in the packet.
966: //
967:
968: NdisQueryPacket(
969: Packet,
970: &PacketPhysicalSegments,
971: NULL,
972: &CurrentBuffer,
973: &PacketVirtualLength
974: );
975:
976: //
977: // Save this value for later
978: //
979:
980: Reserved->PacketLength = PacketVirtualLength;
981:
982: //
983: // We only allow SONIC_MAX_FRAGMENTS physical pieces.
984: //
985:
986: if (PacketPhysicalSegments > SONIC_MAX_FRAGMENTS) {
987: ViolatedConstraints = TRUE;
988: goto DoneExamining;
989: }
990:
991: //
992: // For short packets we can only allow SONIC_MAX_FRAGMENTS-1
993: // (to allow for the blank padding buffer). Also, we can't
994: // allow the padding itself to be less than the minimum
995: // fragment size.
996: //
997:
998: if (PacketVirtualLength < SONIC_MIN_PACKET_SIZE &&
999: ((PacketPhysicalSegments > (SONIC_MAX_FRAGMENTS-1)) ||
1000: (PacketVirtualLength >
1001: (SONIC_MIN_PACKET_SIZE - SONIC_MIN_FRAGMENT_SIZE)))) {
1002: ViolatedConstraints = TRUE;
1003: goto DoneExamining;
1004: }
1005:
1006:
1007: //
1008: // Now loop making sure no fragment is less than
1009: // SONIC_MIN_FRAGMENT_SIZE bytes.
1010: //
1011:
1012: while (CurrentBuffer) {
1013:
1014: NdisQueryBuffer(
1015: CurrentBuffer,
1016: &BufferVirtualAddress,
1017: &BufferVirtualLength
1018: );
1019:
1020:
1021: //
1022: // See if there is only one piece in the buffer.
1023: //
1024:
1025: NdisGetBufferPhysicalArraySize(
1026: CurrentBuffer,
1027: &BufferPhysicalSegments
1028: );
1029:
1030: if (BufferPhysicalSegments == 1) {
1031:
1032: //
1033: // Only one piece, make sure it is large enough.
1034: //
1035:
1036: if (BufferVirtualLength < SONIC_MIN_FRAGMENT_SIZE) {
1037: ViolatedConstraints = TRUE;
1038: goto DoneExamining;
1039: }
1040:
1041: #ifndef NO_CHIP_FIXUP
1042:
1043: //
1044: // See if the beginning AND end of this piece are
1045: // not longword-aligned.
1046: //
1047:
1048: if (((ULONG)BufferVirtualAddress & 0x03) &&
1049: (((ULONG)BufferVirtualAddress + BufferVirtualLength) & 0x03)) {
1050:
1051: //
1052: // Now see if this piece is large enough to
1053: // be split into two.
1054: //
1055:
1056: if (BufferVirtualLength >
1057: (UINT)(4 - ((ULONG)BufferVirtualAddress & 0x03) +
1058: (2*SONIC_MIN_FRAGMENT_SIZE))) {
1059:
1060: //
1061: // Have enough to let the first fragment be
1062: // SONIC_MIN_FRAGMENT_SIZE plus the extra
1063: // few bytes at the beginning, and the
1064: // second piece SONIC_MIN_FRAGMENT_SIZE.
1065: //
1066:
1067: TotalTransmitSegments += 2;
1068:
1069: } else {
1070:
1071: ViolatedConstraints = TRUE;
1072: goto DoneExamining;
1073:
1074: }
1075:
1076: } else {
1077:
1078: //
1079: // This piece won't have to be split, so
1080: // just count it as one.
1081: //
1082:
1083: TotalTransmitSegments += 1;
1084:
1085: }
1086:
1087: #endif
1088:
1089: } else {
1090:
1091: //
1092: // Multiple pieces. We assume that the relevant low bits
1093: // will be the same in a physical and virtual address, so
1094: // we can check using the virtual address whether a
1095: // physical segment may be too short (we are being over-
1096: // cautious here, but this allows us to avoid actually
1097: // querying the physical addresses here.
1098: //
1099:
1100: //
1101: // See if this buffer starts less than MIN_FRAGMENT_SIZE
1102: // bytes before a page boundary.
1103: //
1104:
1105: if (PAGE_SIZE - ((ULONG)BufferVirtualAddress & (PAGE_SIZE-1)) <
1106: SONIC_MIN_FRAGMENT_SIZE) {
1107: ViolatedConstraints = TRUE;
1108: goto DoneExamining;
1109: }
1110:
1111: //
1112: // See if this buffer ends less than MIN_FRAGMENT_SIZE
1113: // bytes after a page boundary.
1114: //
1115:
1116: if (((ULONG)BufferVirtualAddress + BufferVirtualLength) & (PAGE_SIZE-1) <
1117: SONIC_MIN_FRAGMENT_SIZE) {
1118: ViolatedConstraints = TRUE;
1119: goto DoneExamining;
1120: }
1121:
1122: #ifndef NO_CHIP_FIXUP
1123:
1124: //
1125: // Add the number of fragments in this piece.
1126: // We assume that physical gaps will always be
1127: // on at least a 4 byte boundary, so we won't
1128: // need to split this piece.
1129: //
1130:
1131: TotalTransmitSegments += BufferPhysicalSegments;
1132:
1133: #endif
1134:
1135: }
1136:
1137:
1138: NdisGetNextBuffer(
1139: CurrentBuffer,
1140: &CurrentBuffer
1141: );
1142:
1143: }
1144:
1145:
1146: #ifndef NO_CHIP_FIXUP
1147:
1148: //
1149: // If the packet is short, we have to allow for the
1150: // padding fragment at the end.
1151: //
1152:
1153: if (PacketVirtualLength < SONIC_MIN_PACKET_SIZE) {
1154:
1155: TotalTransmitSegments += 1;
1156:
1157: }
1158:
1159: #endif
1160:
1161:
1162: DoneExamining: ;
1163:
1164: #ifndef NO_CHIP_FIXUP
1165: if (ViolatedConstraints || (TotalTransmitSegments > SONIC_MAX_FRAGMENTS)) {
1166: #else
1167: if (ViolatedConstraints) {
1168: #endif
1169:
1170: Reserved->UsedSonicBuffer = TRUE;
1171:
1172: } else {
1173:
1174: Reserved->UsedSonicBuffer = FALSE;
1175:
1176: }
1177:
1178: }
1179:
1180: STATIC
1181: VOID
1182: AssignPacketToDescriptor(
1183: IN PSONIC_ADAPTER Adapter,
1184: IN PNDIS_PACKET Packet,
1185: IN UINT DescriptorIndex
1186: )
1187:
1188: /*++
1189:
1190: Routine Description:
1191:
1192: Given a packet and a ring index, assign all of the buffers
1193: in the packet to ring entries.
1194:
1195: NOTE : Called with lock held!!
1196:
1197: Arguments:
1198:
1199: Adapter - The adapter that the packets are coming through.
1200:
1201: Packet - The packet whose buffers are to be assigned
1202: ring entries.
1203:
1204: DescriptorIndex - The index of the start of the ring entries to
1205: be assigned buffers.
1206:
1207: Return Value:
1208:
1209: None.
1210:
1211: --*/
1212:
1213: {
1214:
1215: //
1216: // Points to the reserved portion of the packet.
1217: //
1218: PSONIC_PACKET_RESERVED Reserved = PSONIC_RESERVED_FROM_PACKET(Packet);
1219:
1220: //
1221: // Pointer to the ring entry to be filled with buffer information.
1222: //
1223: PSONIC_TRANSMIT_DESCRIPTOR TransmitDescriptor = Adapter->TransmitDescriptorArea
1224: + DescriptorIndex;
1225:
1226: //
1227: // Pointer to the ring to packet entry that records the info about
1228: // this packet.
1229: //
1230: PSONIC_DESCRIPTOR_TO_PACKET DescriptorToPacket = Adapter->DescriptorToPacket + DescriptorIndex;
1231:
1232: //
1233: // The total amount of data in the ndis packet.
1234: //
1235: UINT TotalDataLength;
1236:
1237: //
1238: // Points to the current ndis buffer being walked.
1239: //
1240: PNDIS_BUFFER CurrentBuffer;
1241:
1242: //
1243: // The number of physical segments in this buffer.
1244: //
1245: UINT BufferPhysicalSegments;
1246:
1247: //
1248: // An array to hold the physical segments.
1249: //
1250: NDIS_PHYSICAL_ADDRESS_UNIT PhysicalSegmentArray[SONIC_MAX_FRAGMENTS];
1251:
1252: //
1253: // We record the owning packet information in the ring packet packet
1254: // structure.
1255: //
1256:
1257:
1258: DescriptorToPacket->OwningPacket = Packet;
1259: DescriptorToPacket->UsedSonicBuffer = (BOOLEAN)
1260: Reserved->UsedSonicBuffer;
1261: DescriptorToPacket->SonicBuffersIndex =
1262: Reserved->SonicBuffersIndex;
1263:
1264:
1265: //
1266: // First initialize the fields that don't depend on
1267: // how many fragments there are in the packet.
1268: //
1269:
1270: TransmitDescriptor->TransmitStatus = 0;
1271:
1272: //
1273: // Set the programmable interrupt if it has been a long
1274: // time since transmit complete interrupts were processed.
1275: //
1276:
1277: if (Adapter->PacketsSinceLastInterrupt >=
1278: (SONIC_NUMBER_OF_TRANSMIT_DESCRIPTORS/2)) {
1279:
1280: TransmitDescriptor->TransmitConfiguration = (UINT)SONIC_TCR_PROG_INTERRUPT;
1281: Adapter->PacketsSinceLastInterrupt = 0;
1282:
1283: } else {
1284:
1285: TransmitDescriptor->TransmitConfiguration = 0;
1286: ++Adapter->PacketsSinceLastInterrupt;
1287:
1288: }
1289:
1290:
1291: //
1292: // Now check to see if the packet has been copied into an
1293: // adapter buffer.
1294: //
1295:
1296: if (Reserved->UsedSonicBuffer) {
1297:
1298: //
1299: // Points to the adapter buffer descriptor allocated
1300: // for this packet.
1301: //
1302: PSONIC_BUFFER_DESCRIPTOR BufferDescriptor;
1303:
1304: BufferDescriptor = Adapter->SonicBuffers
1305: + Reserved->SonicBuffersIndex;
1306:
1307: TransmitDescriptor->FragmentCount = 1;
1308: TransmitDescriptor->PacketSize = (UINT)BufferDescriptor->DataLength;
1309:
1310: SONIC_SET_TRANSMIT_FRAGMENT_ADDRESS(
1311: &(TransmitDescriptor->Fragments[0]),
1312: NdisGetPhysicalAddressLow(BufferDescriptor->PhysicalSonicBuffer)
1313: );
1314:
1315: SONIC_SET_TRANSMIT_FRAGMENT_LENGTH(
1316: &(TransmitDescriptor->Fragments[0]),
1317: BufferDescriptor->DataLength
1318: );
1319:
1320:
1321: //
1322: // This sets end-of-list for this descriptor.
1323: //
1324:
1325: SONIC_SET_TRANSMIT_LINK(
1326: &(TransmitDescriptor->Fragments[1]),
1327: TransmitDescriptor->Link
1328: );
1329:
1330: DescriptorToPacket->LinkPointer = (SONIC_PHYSICAL_ADDRESS *)
1331: &(TransmitDescriptor->Fragments[1]);
1332:
1333:
1334: //
1335: // Flush the buffer that contains the packet.
1336: //
1337:
1338: SONIC_FLUSH_WRITE_BUFFER(BufferDescriptor->FlushBuffer);
1339:
1340: } else {
1341:
1342: //
1343: // The total length of the packet (including padding)
1344: //
1345: UINT TotalPacketLength;
1346:
1347: //
1348: // Which fragment we are filling;
1349: //
1350: UINT CurFragment;
1351:
1352: //
1353: // Which map register we use for this buffer.
1354: //
1355: UINT CurMapRegister;
1356:
1357: //
1358: // Simple iteration variable.
1359: //
1360: UINT i;
1361:
1362:
1363: CurFragment = 0;
1364: CurMapRegister = DescriptorIndex * SONIC_MAX_FRAGMENTS;
1365:
1366: NdisQueryPacket(
1367: Packet,
1368: NULL,
1369: NULL,
1370: &CurrentBuffer,
1371: &TotalDataLength
1372: );
1373:
1374:
1375: while (CurrentBuffer) {
1376:
1377: NdisStartBufferPhysicalMapping(
1378: Adapter->NdisAdapterHandle,
1379: CurrentBuffer,
1380: CurMapRegister,
1381: TRUE,
1382: PhysicalSegmentArray,
1383: &BufferPhysicalSegments
1384: );
1385:
1386: ++CurMapRegister;
1387:
1388: //
1389: // Put the physical segments for this buffer into
1390: // the transmit descriptors.
1391: //
1392:
1393: for (i=0; i<BufferPhysicalSegments; i++) {
1394:
1395: ASSERT (NdisGetPhysicalAddressHigh(PhysicalSegmentArray[i].PhysicalAddress) == 0);
1396:
1397: SONIC_SET_TRANSMIT_FRAGMENT_ADDRESS(
1398: &(TransmitDescriptor->Fragments[CurFragment]),
1399: NdisGetPhysicalAddressLow(PhysicalSegmentArray[i].PhysicalAddress)
1400: );
1401:
1402: SONIC_SET_TRANSMIT_FRAGMENT_LENGTH(
1403: &(TransmitDescriptor->Fragments[CurFragment]),
1404: PhysicalSegmentArray[i].Length
1405: );
1406:
1407: ++CurFragment;
1408:
1409: #ifndef NO_CHIP_FIXUP
1410:
1411: //
1412: // If the fragment starts and ends not on a longword
1413: // boundary, split it into two fragments, the first
1414: // being SONIC_MIN_FRAGMENT_SIZE plus the extra bits
1415: // at the beginning, the other the rest.
1416: //
1417:
1418: if ((NdisGetPhysicalAddressLow(PhysicalSegmentArray[i].PhysicalAddress) & 0x03) &&
1419: ((NdisGetPhysicalAddressLow(PhysicalSegmentArray[i].PhysicalAddress) + PhysicalSegmentArray[i].Length) & 0x03)) {
1420:
1421: UINT FirstSegmentLength;
1422:
1423: FirstSegmentLength = (4 - ((NdisGetPhysicalAddressLow(PhysicalSegmentArray[i].PhysicalAddress) & 0x03))) +
1424: SONIC_MIN_FRAGMENT_SIZE;
1425:
1426: SONIC_SET_TRANSMIT_FRAGMENT_LENGTH(
1427: &(TransmitDescriptor->Fragments[CurFragment-1]),
1428: FirstSegmentLength
1429: );
1430:
1431: SONIC_SET_TRANSMIT_FRAGMENT_ADDRESS(
1432: &(TransmitDescriptor->Fragments[CurFragment]),
1433: SONIC_GET_TRANSMIT_FRAGMENT_ADDRESS(
1434: &(TransmitDescriptor->Fragments[CurFragment-1])) +
1435: FirstSegmentLength
1436: );
1437:
1438: SONIC_SET_TRANSMIT_FRAGMENT_LENGTH(
1439: &(TransmitDescriptor->Fragments[CurFragment]),
1440: PhysicalSegmentArray[i].Length - FirstSegmentLength
1441: );
1442:
1443: ++CurFragment;
1444:
1445: }
1446: #endif
1447: }
1448:
1449:
1450: SONIC_FLUSH_WRITE_BUFFER (CurrentBuffer);
1451:
1452: NdisGetNextBuffer(
1453: CurrentBuffer,
1454: &CurrentBuffer
1455: );
1456:
1457: }
1458:
1459: if (TotalDataLength < SONIC_MIN_PACKET_SIZE) {
1460:
1461: SONIC_SET_TRANSMIT_FRAGMENT_ADDRESS(
1462: &(TransmitDescriptor->Fragments[CurFragment]),
1463: NdisGetPhysicalAddressLow(Adapter->BlankBufferAddress)
1464: );
1465:
1466: SONIC_SET_TRANSMIT_FRAGMENT_LENGTH(
1467: &(TransmitDescriptor->Fragments[CurFragment]),
1468: SONIC_MIN_PACKET_SIZE - TotalDataLength
1469: );
1470:
1471: //
1472: // Note that BlankBuffer has already been flushed.
1473: //
1474:
1475: ++CurFragment;
1476:
1477: TotalPacketLength = SONIC_MIN_PACKET_SIZE;
1478:
1479: } else {
1480:
1481: TotalPacketLength = TotalDataLength;
1482:
1483: }
1484:
1485: //
1486: // Make sure we didn't mess up and use up too
1487: // many fragments.
1488: //
1489: ASSERT(CurFragment <= SONIC_MAX_FRAGMENTS);
1490:
1491: TransmitDescriptor->FragmentCount = (UINT)CurFragment;
1492: TransmitDescriptor->PacketSize = (UINT)TotalPacketLength;
1493:
1494:
1495: //
1496: // This sets end-of-list for this descriptor.
1497: //
1498:
1499: SONIC_SET_TRANSMIT_LINK(
1500: &(TransmitDescriptor->Fragments[CurFragment]),
1501: TransmitDescriptor->Link
1502: );
1503:
1504: DescriptorToPacket->LinkPointer = (SONIC_PHYSICAL_ADDRESS *)
1505: &(TransmitDescriptor->Fragments[CurFragment]);
1506:
1507: }
1508:
1509: if (DescriptorIndex == (Adapter->NumberOfTransmitDescriptors-1)) {
1510:
1511: Adapter->DescriptorToPacket->PrevLinkPointer = DescriptorToPacket->LinkPointer;
1512:
1513: } else {
1514:
1515: (DescriptorToPacket+1)->PrevLinkPointer = DescriptorToPacket->LinkPointer;
1516:
1517: }
1518:
1519: Reserved->DescriptorIndex = DescriptorIndex;
1520:
1521: }
1522:
1523: STATIC
1524: VOID
1525: RelinquishPacket(
1526: IN PSONIC_ADAPTER Adapter,
1527: IN PNDIS_PACKET Packet,
1528: IN UINT RingIndex
1529: )
1530:
1531: /*++
1532:
1533: Routine Description:
1534:
1535: Relinquish the ring entries owned by the packet to the chip.
1536: We also update the first uncommitted ring pointer.
1537:
1538: NOTE: Called with the lock held!!
1539:
1540: Arguments:
1541:
1542: Adapter - The adapter that points to the ring entry structures.
1543:
1544: Packet - The packet contains the ring index of the ring
1545: entry for the packet.
1546:
1547: RingIndex - Holds the index of the ring entry used
1548: by this packet.
1549:
1550: Return Value:
1551:
1552: None.
1553:
1554: --*/
1555:
1556: {
1557:
1558: //
1559: // Holds the previous link pointer, where we turn off
1560: // end-of-list.
1561: //
1562:
1563: PSONIC_PHYSICAL_ADDRESS PrevLinkPointer;
1564:
1565: #ifdef NDIS_NT
1566:
1567: //
1568: // NOTE: We have to raise the IRQL to POWER_LEVEL around the
1569: // calls to SONIC_REMOVE_END_OF_LIST and START_TRANSMIT.
1570: // This is to prevent a delay between these two instructions.
1571: // If a delay happens right after SONIC_REMOVE_END_OF_LIST, the
1572: // Sonic could transmit the packet and stop, then the call
1573: // to START_TRANSMIT would cause it to retransmit all the
1574: // packets in the descriptor ring.
1575: //
1576: KIRQL OldIrql;
1577:
1578: #endif
1579:
1580:
1581: PrevLinkPointer = Adapter->DescriptorToPacket[RingIndex].PrevLinkPointer;
1582:
1583: #ifdef NDIS_NT
1584:
1585: //
1586: // See NOTE above.
1587: //
1588:
1589: KeRaiseIrql(POWER_LEVEL, &OldIrql);
1590:
1591: #endif
1592:
1593:
1594: //
1595: // Turn off END_OF_LIST for the last one.
1596: //
1597:
1598: SONIC_REMOVE_END_OF_LIST(PrevLinkPointer);
1599:
1600: //
1601: // This turns on the correct bit in the SONIC_CONTROL
1602: // register.
1603: //
1604:
1605: START_TRANSMIT(Adapter);
1606:
1607:
1608: #ifdef NDIS_NT
1609:
1610: //
1611: // See NOTE above.
1612: //
1613:
1614: KeLowerIrql(OldIrql);
1615:
1616: #endif
1617:
1618: //
1619: // We want FirstUncommittedDescriptor to point to right after us.
1620: //
1621:
1622: if (RingIndex == (Adapter->NumberOfTransmitDescriptors-1)) {
1623:
1624: Adapter->FirstUncommittedDescriptor = Adapter->TransmitDescriptorArea;
1625:
1626: } else {
1627:
1628: Adapter->FirstUncommittedDescriptor =
1629: Adapter->TransmitDescriptorArea + (RingIndex + 1);
1630:
1631: }
1632:
1633: }
1634:
1635:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.