30 // |
30 // |
31 // --------------------------------------------------------------------------- |
31 // --------------------------------------------------------------------------- |
32 // |
32 // |
33 void RFrameXferBlockBase::KeInitialize() |
33 void RFrameXferBlockBase::KeInitialize() |
34 { |
34 { |
35 iRxDataChunk = NULL; |
35 iThisAddrKernelSpace = reinterpret_cast<TUint32>(this); |
36 |
|
37 for ( TUint32 i = 0; i < KMaxCompletedRxBufs; ++i ) |
|
38 { |
|
39 iRxCompletedBuffers[i] = 0; |
|
40 } |
|
41 |
36 |
42 for ( TUint j = 0; j < TDataBuffer::KFrameTypeMax; ++j ) |
37 for ( TUint j = 0; j < TDataBuffer::KFrameTypeMax; ++j ) |
43 { |
38 { |
44 iTxOffset[j] = 0; |
39 iTxOffset[j] = 0; |
45 } |
40 } |
46 |
|
47 iNumOfCompleted = 0; |
|
48 iCurrentRxBuffer = 0; |
|
49 iFirstRxBufferToFree = 0; |
|
50 } |
|
51 |
|
52 // --------------------------------------------------------------------------- |
|
53 // |
|
54 // --------------------------------------------------------------------------- |
|
55 // |
|
56 void RFrameXferBlockBase::KeRxComplete( |
|
57 const TUint32* aRxCompletionBuffersArray, |
|
58 TUint32 aNumOfCompleted ) |
|
59 { |
|
60 if ( aNumOfCompleted > KMaxCompletedRxBufs ) |
|
61 { |
|
62 os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ ); |
|
63 } |
|
64 |
|
65 assign( aRxCompletionBuffersArray, iRxCompletedBuffers, aNumOfCompleted ); |
|
66 iNumOfCompleted = aNumOfCompleted; |
|
67 iCurrentRxBuffer = 0; |
|
68 iFirstRxBufferToFree = 0; |
|
69 |
|
70 for ( TUint i = 0; i < iNumOfCompleted; ++i ) |
|
71 { |
|
72 TraceDump( RX_FRAME, |
|
73 (("WLANLDD: RFrameXferBlockBase::KeRxComplete: completed offset addr: 0x%08x"), |
|
74 iRxCompletedBuffers[i]) ); |
|
75 } |
|
76 } |
|
77 |
|
78 // --------------------------------------------------------------------------- |
|
79 // |
|
80 // --------------------------------------------------------------------------- |
|
81 // |
|
82 void RFrameXferBlockBase::KeGetHandledRxBuffers( |
|
83 const TUint32*& aRxHandledBuffersArray, |
|
84 TUint32& aNumOfHandled ) |
|
85 { |
|
86 TUint32 numHandled ( iCurrentRxBuffer - iFirstRxBufferToFree ); |
|
87 |
|
88 // make sure that if an Rx buffer is currently being processed by the user |
|
89 // side client, that buffer is not regarded as being already handled |
|
90 numHandled = numHandled ? numHandled - 1 : numHandled; |
|
91 |
|
92 if ( numHandled ) |
|
93 { |
|
94 aRxHandledBuffersArray = &(iRxCompletedBuffers[iFirstRxBufferToFree]); |
|
95 aNumOfHandled = numHandled; |
|
96 |
|
97 iFirstRxBufferToFree += numHandled; |
|
98 } |
|
99 } |
|
100 |
|
101 // --------------------------------------------------------------------------- |
|
102 // |
|
103 // --------------------------------------------------------------------------- |
|
104 // |
|
105 void RFrameXferBlockBase::KeAllUserSideRxBuffersFreed() |
|
106 { |
|
107 iFirstRxBufferToFree = 0; |
|
108 // need to reset also the current index, so that the difference of these |
|
109 // two indexes is zero, and it then correctly indicates, that there are no |
|
110 // Rx buffers which could be freed incrementally |
|
111 iCurrentRxBuffer = 0; |
|
112 } |
41 } |
113 |
42 |
114 // --------------------------------------------------------------------------- |
43 // --------------------------------------------------------------------------- |
115 // |
44 // |
116 // --------------------------------------------------------------------------- |
45 // --------------------------------------------------------------------------- |
131 (("WLANLDD: RFrameXferBlockBase::KeSetTxOffsets: offset: %d"), |
60 (("WLANLDD: RFrameXferBlockBase::KeSetTxOffsets: offset: %d"), |
132 iTxOffset[i]) ); |
61 iTxOffset[i]) ); |
133 } |
62 } |
134 } |
63 } |
135 |
64 |
136 // ----------------------------------------------------------------------------- |
65 // --------------------------------------------------------------------------- |
137 // |
66 // |
138 // ----------------------------------------------------------------------------- |
67 // --------------------------------------------------------------------------- |
139 // |
68 // |
140 void RFrameXferBlockProtocolStack::Initialise() |
69 void RFrameXferBlock::Initialize( TUint32 aTxBufLength ) |
|
70 { |
|
71 // perform base class initialization first |
|
72 KeInitialize(); |
|
73 |
|
74 iTxDataBuffer = NULL; |
|
75 iTxBufLength = aTxBufLength; |
|
76 |
|
77 iRxQueueFront = NULL; |
|
78 iRxQueueRear = NULL; |
|
79 } |
|
80 |
|
81 // ----------------------------------------------------------------------------- |
|
82 // |
|
83 // ----------------------------------------------------------------------------- |
|
84 // |
|
85 void RFrameXferBlock::AddRxFrame( TDataBuffer* aFrame ) |
|
86 { |
|
87 if ( aFrame ) |
|
88 { |
|
89 aFrame->iNext = NULL; |
|
90 |
|
91 TraceDump( RX_FRAME, |
|
92 (("WLANLDD: RFrameXferBlock::AddRxFrame: " |
|
93 "add to queue metahdr addr: 0x%08x"), |
|
94 aFrame)); |
|
95 |
|
96 if ( iRxQueueRear ) |
|
97 { |
|
98 iRxQueueRear->iNext = aFrame; |
|
99 iRxQueueRear = aFrame; |
|
100 } |
|
101 else |
|
102 { |
|
103 iRxQueueFront = aFrame; |
|
104 iRxQueueRear = aFrame; |
|
105 } |
|
106 } |
|
107 } |
|
108 |
|
109 // ----------------------------------------------------------------------------- |
|
110 // Note! This method is executed in the context of the user mode client |
|
111 // thread, but in supervisor mode |
|
112 // ----------------------------------------------------------------------------- |
|
113 // |
|
114 TDataBuffer* RFrameXferBlock::GetRxFrame() |
|
115 { |
|
116 TDataBuffer* aPacketInKernSpace( NULL ); |
|
117 |
|
118 if ( iRxQueueFront ) |
|
119 { |
|
120 aPacketInKernSpace = iRxQueueFront; |
|
121 |
|
122 TraceDump( RX_FRAME, |
|
123 (("WLANLDD: RFrameXferBlock::GetRxFrame: " |
|
124 "krn metahdr addr: 0x%08x"), |
|
125 reinterpret_cast<TUint32>(aPacketInKernSpace))); |
|
126 |
|
127 iRxQueueFront = iRxQueueFront->iNext; |
|
128 |
|
129 if ( !iRxQueueFront ) |
|
130 { |
|
131 // the queue became empty |
|
132 iRxQueueRear = NULL; |
|
133 } |
|
134 |
|
135 return reinterpret_cast<TDataBuffer*>( |
|
136 reinterpret_cast<TUint8*>(aPacketInKernSpace) |
|
137 - iUserToKernAddrOffset); |
|
138 } |
|
139 else |
|
140 { |
|
141 // the Rx queue is empty |
|
142 TraceDump( RX_FRAME, |
|
143 (("WLANLDD: RFrameXferBlock::GetRxFrame: " |
|
144 "no frames available"))); |
|
145 |
|
146 // return NULL |
|
147 return aPacketInKernSpace; |
|
148 } |
|
149 } |
|
150 |
|
151 // ----------------------------------------------------------------------------- |
|
152 // |
|
153 // ----------------------------------------------------------------------------- |
|
154 // |
|
155 TBool RFrameXferBlock::RxFrameAvailable() const |
|
156 { |
|
157 return reinterpret_cast<TBool>( iRxQueueFront ); |
|
158 } |
|
159 |
|
160 // ----------------------------------------------------------------------------- |
|
161 // |
|
162 // ----------------------------------------------------------------------------- |
|
163 // |
|
164 void RFrameXferBlockProtocolStack::Initialize() |
141 { |
165 { |
142 // perform base class initialization |
166 // perform base class initialization |
143 KeInitialize(); |
167 KeInitialize(); |
144 |
|
145 iThisAddrKernelSpace = reinterpret_cast<TUint32>(this); |
|
146 |
168 |
147 iVoiceTxQueue.DoInit(); |
169 iVoiceTxQueue.DoInit(); |
148 iVideoTxQueue.DoInit(); |
170 iVideoTxQueue.DoInit(); |
149 iBestEffortTxQueue.DoInit(); |
171 iBestEffortTxQueue.DoInit(); |
150 iBackgroundTxQueue.DoInit(); |
172 iBackgroundTxQueue.DoInit(); |
159 iDataBuffers[i].SetLength( 0 ); |
181 iDataBuffers[i].SetLength( 0 ); |
160 iDataBuffers[i].SetUserPriority( 0 ); |
182 iDataBuffers[i].SetUserPriority( 0 ); |
161 |
183 |
162 iFreeQueue.PutPacket( &iDataBuffers[i] ); |
184 iFreeQueue.PutPacket( &iDataBuffers[i] ); |
163 } |
185 } |
164 } |
186 |
165 |
187 iVoiceRxQueueFront = NULL; |
166 // ----------------------------------------------------------------------------- |
188 iVoiceRxQueueRear = NULL; |
167 // |
189 |
|
190 iVideoRxQueueFront = NULL; |
|
191 iVideoRxQueueRear = NULL; |
|
192 |
|
193 iBestEffortRxQueueFront = NULL; |
|
194 iBestEffortRxQueueRear = NULL; |
|
195 |
|
196 iBackgroundRxQueueFront = NULL; |
|
197 iBackgroundRxQueueRear = NULL; |
|
198 } |
|
199 |
|
200 // ----------------------------------------------------------------------------- |
|
201 // Note! This method is executed in the context of the user mode client |
|
202 // thread, but in supervisor mode |
168 // ----------------------------------------------------------------------------- |
203 // ----------------------------------------------------------------------------- |
169 // |
204 // |
170 TDataBuffer* RFrameXferBlockProtocolStack::AllocTxBuffer( |
205 TDataBuffer* RFrameXferBlockProtocolStack::AllocTxBuffer( |
171 const TUint8* aTxBuf, |
206 const TUint8* aTxBuf, |
172 TUint16 aBufLength ) |
207 TUint16 aBufLength ) |
207 |
242 |
208 return packet; |
243 return packet; |
209 } |
244 } |
210 |
245 |
211 // ----------------------------------------------------------------------------- |
246 // ----------------------------------------------------------------------------- |
212 // |
247 // Note! This method is executed in the context of the user mode client |
|
248 // thread, but in supervisor mode |
213 // ----------------------------------------------------------------------------- |
249 // ----------------------------------------------------------------------------- |
214 // |
250 // |
215 TBool RFrameXferBlockProtocolStack::AddTxFrame( |
251 TBool RFrameXferBlockProtocolStack::AddTxFrame( |
216 TDataBuffer* aPacketInUserSpace, |
252 TDataBuffer* aPacketInUserSpace, |
217 TDataBuffer*& aPacketInKernSpace, |
253 TDataBuffer*& aPacketInKernSpace, |
218 TBool aUserDataTxEnabled ) |
254 TBool aUserDataTxEnabled ) |
219 { |
255 { |
220 TBool ret( ETrue ); |
256 TBool ret( ETrue ); |
221 aPacketInKernSpace = NULL; |
257 aPacketInKernSpace = NULL; |
|
258 |
|
259 if ( !aPacketInUserSpace ) |
|
260 { |
|
261 #ifndef NDEBUG |
|
262 os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ ); |
|
263 #endif |
|
264 return ETrue; |
|
265 } |
|
266 |
222 TDataBuffer* metaHdrInKernSpace ( reinterpret_cast<TDataBuffer*>( |
267 TDataBuffer* metaHdrInKernSpace ( reinterpret_cast<TDataBuffer*>( |
223 reinterpret_cast<TUint8*>(aPacketInUserSpace) + iUserToKernAddrOffset) ); |
268 reinterpret_cast<TUint8*>(aPacketInUserSpace) + iUserToKernAddrOffset) ); |
224 |
269 |
225 TraceDump( NWSA_TX_DETAILS, |
270 TraceDump( NWSA_TX_DETAILS, |
226 (("WLANLDD: RFrameXferBlockProtocolStack::AddTxFrame: user metahdr addr: 0x%08x"), |
271 (("WLANLDD: RFrameXferBlockProtocolStack::AddTxFrame: user metahdr addr: 0x%08x"), |
453 |
498 |
454 // ----------------------------------------------------------------------------- |
499 // ----------------------------------------------------------------------------- |
455 // |
500 // |
456 // ----------------------------------------------------------------------------- |
501 // ----------------------------------------------------------------------------- |
457 // |
502 // |
|
503 void RFrameXferBlockProtocolStack::AddRxFrame( TDataBuffer* aFrame ) |
|
504 { |
|
505 if ( !aFrame ) |
|
506 { |
|
507 #ifndef NDEBUG |
|
508 os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ ); |
|
509 #endif |
|
510 return; |
|
511 } |
|
512 |
|
513 aFrame->iNext = NULL; |
|
514 |
|
515 if ( aFrame->UserPriority() == 7 || aFrame->UserPriority() == 6 ) |
|
516 { |
|
517 TraceDump( RX_FRAME, |
|
518 (("WLANLDD: RFrameXferBlockProtocolStack::AddRxFrame: " |
|
519 "add to VO queue metahdr addr: 0x%08x"), |
|
520 aFrame)); |
|
521 |
|
522 if ( iVoiceRxQueueRear ) |
|
523 { |
|
524 iVoiceRxQueueRear->iNext = aFrame; |
|
525 iVoiceRxQueueRear = aFrame; |
|
526 } |
|
527 else |
|
528 { |
|
529 iVoiceRxQueueFront = aFrame; |
|
530 iVoiceRxQueueRear = aFrame; |
|
531 } |
|
532 } |
|
533 else if ( aFrame->UserPriority() == 5 || aFrame->UserPriority() == 4 ) |
|
534 { |
|
535 TraceDump( RX_FRAME, |
|
536 (("WLANLDD: RFrameXferBlockProtocolStack::AddRxFrame: " |
|
537 "add to VI queue metahdr addr: 0x%08x"), |
|
538 aFrame)); |
|
539 |
|
540 if ( iVideoRxQueueRear ) |
|
541 { |
|
542 iVideoRxQueueRear->iNext = aFrame; |
|
543 iVideoRxQueueRear = aFrame; |
|
544 } |
|
545 else |
|
546 { |
|
547 iVideoRxQueueFront = aFrame; |
|
548 iVideoRxQueueRear = aFrame; |
|
549 } |
|
550 } |
|
551 else if ( aFrame->UserPriority() == 2 || aFrame->UserPriority() == 1 ) |
|
552 { |
|
553 TraceDump( RX_FRAME, |
|
554 (("WLANLDD: RFrameXferBlockProtocolStack::AddRxFrame: " |
|
555 "add to BG queue metahdr addr: 0x%08x"), |
|
556 aFrame)); |
|
557 |
|
558 if ( iBackgroundRxQueueRear ) |
|
559 { |
|
560 iBackgroundRxQueueRear->iNext = aFrame; |
|
561 iBackgroundRxQueueRear = aFrame; |
|
562 } |
|
563 else |
|
564 { |
|
565 iBackgroundRxQueueFront = aFrame; |
|
566 iBackgroundRxQueueRear = aFrame; |
|
567 } |
|
568 } |
|
569 else |
|
570 { |
|
571 // user priority is 3 or 0 or invalid |
|
572 |
|
573 TraceDump( RX_FRAME, |
|
574 (("WLANLDD: RFrameXferBlockProtocolStack::AddRxFrame: " |
|
575 "add to BE queue metahdr addr: 0x%08x"), |
|
576 aFrame)); |
|
577 |
|
578 if ( iBestEffortRxQueueRear ) |
|
579 { |
|
580 iBestEffortRxQueueRear->iNext = aFrame; |
|
581 iBestEffortRxQueueRear = aFrame; |
|
582 } |
|
583 else |
|
584 { |
|
585 iBestEffortRxQueueFront = aFrame; |
|
586 iBestEffortRxQueueRear = aFrame; |
|
587 } |
|
588 } |
|
589 } |
|
590 |
|
591 // ----------------------------------------------------------------------------- |
|
592 // Note! This method is executed in the context of the user mode client |
|
593 // thread, but in supervisor mode |
|
594 // ----------------------------------------------------------------------------- |
|
595 // |
|
596 TDataBuffer* RFrameXferBlockProtocolStack::GetRxFrame() |
|
597 { |
|
598 TDataBuffer* aPacketInKernSpace( NULL ); |
|
599 |
|
600 if ( iVoiceRxQueueFront ) |
|
601 { |
|
602 aPacketInKernSpace = iVoiceRxQueueFront; |
|
603 |
|
604 TraceDump( RX_FRAME, |
|
605 (("WLANLDD: RFrameXferBlockProtocolStack::GetRxFrame: from VO " |
|
606 "queue; krn metahdr addr: 0x%08x"), |
|
607 reinterpret_cast<TUint32>(aPacketInKernSpace))); |
|
608 |
|
609 iVoiceRxQueueFront = iVoiceRxQueueFront->iNext; |
|
610 |
|
611 if ( !iVoiceRxQueueFront ) |
|
612 { |
|
613 // the queue became empty |
|
614 iVoiceRxQueueRear = NULL; |
|
615 } |
|
616 } |
|
617 else if ( iVideoRxQueueFront ) |
|
618 { |
|
619 aPacketInKernSpace = iVideoRxQueueFront; |
|
620 |
|
621 TraceDump( RX_FRAME, |
|
622 (("WLANLDD: RFrameXferBlockProtocolStack::GetRxFrame: from VI " |
|
623 "queue; krn metahdr addr: 0x%08x"), |
|
624 reinterpret_cast<TUint32>(aPacketInKernSpace))); |
|
625 |
|
626 iVideoRxQueueFront = iVideoRxQueueFront->iNext; |
|
627 |
|
628 if ( !iVideoRxQueueFront ) |
|
629 { |
|
630 // the queue became empty |
|
631 iVideoRxQueueRear = NULL; |
|
632 } |
|
633 } |
|
634 else if ( iBestEffortRxQueueFront ) |
|
635 { |
|
636 aPacketInKernSpace = iBestEffortRxQueueFront; |
|
637 |
|
638 TraceDump( RX_FRAME, |
|
639 (("WLANLDD: RFrameXferBlockProtocolStack::GetRxFrame: from BE " |
|
640 "queue; krn metahdr addr: 0x%08x"), |
|
641 reinterpret_cast<TUint32>(aPacketInKernSpace))); |
|
642 |
|
643 iBestEffortRxQueueFront = iBestEffortRxQueueFront->iNext; |
|
644 |
|
645 if ( !iBestEffortRxQueueFront ) |
|
646 { |
|
647 // the queue became empty |
|
648 iBestEffortRxQueueRear = NULL; |
|
649 } |
|
650 } |
|
651 else if ( iBackgroundRxQueueFront ) |
|
652 { |
|
653 aPacketInKernSpace = iBackgroundRxQueueFront; |
|
654 |
|
655 TraceDump( RX_FRAME, |
|
656 (("WLANLDD: RFrameXferBlockProtocolStack::GetRxFrame: from BG " |
|
657 "queue; krn metahdr addr: 0x%08x"), |
|
658 reinterpret_cast<TUint32>(aPacketInKernSpace))); |
|
659 |
|
660 iBackgroundRxQueueFront = iBackgroundRxQueueFront->iNext; |
|
661 |
|
662 if ( !iBackgroundRxQueueFront ) |
|
663 { |
|
664 // the queue became empty |
|
665 iBackgroundRxQueueRear = NULL; |
|
666 } |
|
667 } |
|
668 else |
|
669 { |
|
670 // all Rx queues are empty; no action |
|
671 } |
|
672 |
|
673 if ( aPacketInKernSpace ) |
|
674 { |
|
675 return reinterpret_cast<TDataBuffer*>( |
|
676 reinterpret_cast<TUint8*>(aPacketInKernSpace) |
|
677 - iUserToKernAddrOffset); |
|
678 } |
|
679 else |
|
680 { |
|
681 TraceDump( RX_FRAME, |
|
682 (("WLANLDD: RFrameXferBlockProtocolStack::GetRxFrame: " |
|
683 "no frames available"))); |
|
684 |
|
685 // return NULL |
|
686 return aPacketInKernSpace; |
|
687 } |
|
688 } |
|
689 |
|
690 // ----------------------------------------------------------------------------- |
|
691 // |
|
692 // ----------------------------------------------------------------------------- |
|
693 // |
458 TBool RFrameXferBlockProtocolStack::TxPossible( |
694 TBool RFrameXferBlockProtocolStack::TxPossible( |
459 const TWhaTxQueueState& aWhaTxQueueState, |
695 const TWhaTxQueueState& aWhaTxQueueState, |
460 TQueueId& aQueueId ) |
696 TQueueId& aQueueId ) |
461 { |
697 { |
462 TBool txPossible ( ETrue ); |
698 TBool txPossible ( ETrue ); |