projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Staging: bcm: remove unneeded NULL check
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / bcm / CmHost.c
CommitLineData
f8942e07
SH		 1/************************************************************
2* CMHOST.C
3* This file contains the routines for handling Connnection
4* Management.
5************************************************************/
6
7//#define CONN_MSG
8#include "headers.h"
9
10typedef enum _E_CLASSIFIER_ACTION
11{
12 eInvalidClassifierAction,
13 eAddClassifier,
14 eReplaceClassifier,
15 eDeleteClassifier
16}E_CLASSIFIER_ACTION;
17
18
19/************************************************************
20* Function - SearchSfid
21*
22* Description - This routinue would search QOS queues having
23* specified SFID as input parameter.
24*
25* Parameters - Adapter: Pointer to the Adapter structure
26* uiSfid : Given SFID for matching
27*
28* Returns - Queue index for this SFID(If matched)
29 Else Invalid Queue Index(If Not matched)
30************************************************************/
31__inline INT SearchSfid(PMINI_ADAPTER Adapter,UINT uiSfid)
32{
33 INT iIndex=0;
34 for(iIndex=(NO_OF_QUEUES-1); iIndex>=0; iIndex--)
35 if(Adapter->PackInfo[iIndex].ulSFID==uiSfid)
36 return iIndex;
37 return NO_OF_QUEUES+1;
38}
39
40/***************************************************************
41* Function - SearchFreeSfid
42*
43* Description - This routinue would search Free available SFID.
44*
45* Parameter - Adapter: Pointer to the Adapter structure
46*
47* Returns - Queue index for the free SFID
48* Else returns Invalid Index.
49****************************************************************/
50__inline INT SearchFreeSfid(PMINI_ADAPTER Adapter)
51{
52 UINT uiIndex=0;
53 for(uiIndex=0; uiIndex < (NO_OF_QUEUES-1); uiIndex++)
54 if(Adapter->PackInfo[uiIndex].ulSFID==0)
55 return uiIndex;
56 return NO_OF_QUEUES+1;
57}
58
59__inline int SearchVcid(PMINI_ADAPTER Adapter,unsigned short usVcid)
60{
61 int iIndex=0;
62 for(iIndex=(NO_OF_QUEUES-1);iIndex>=0;iIndex--)
63 if(Adapter->PackInfo[iIndex].usVCID_Value == usVcid)
64 return iIndex;
65 return NO_OF_QUEUES+1;
66
67}
68
69
70/*
71Function: SearchClsid
72Description: This routinue would search Classifier having specified ClassifierID as input parameter
73Input parameters: PMINI_ADAPTER Adapter - Adapter Context
74 unsigned int uiSfid - The SF in which the classifier is to searched
75 B_UINT16 uiClassifierID - The classifier ID to be searched
76Return: int :Classifier table index of matching entry
77*/
78
79__inline int SearchClsid(PMINI_ADAPTER Adapter,ULONG ulSFID,B_UINT16 uiClassifierID)
80{
81 unsigned int uiClassifierIndex = 0;
82 for(uiClassifierIndex=0;uiClassifierIndex<MAX_CLASSIFIERS;uiClassifierIndex++)
83 {
84 if((Adapter->astClassifierTable[uiClassifierIndex].bUsed) &&
85 (Adapter->astClassifierTable[uiClassifierIndex].uiClassifierRuleIndex == uiClassifierID)&&
86 (Adapter->astClassifierTable[uiClassifierIndex].ulSFID == ulSFID))
87 return uiClassifierIndex;
88 }
89 return MAX_CLASSIFIERS+1;
90}
91
92/**
93@ingroup ctrl_pkt_functions
94This routinue would search Free available Classifier entry in classifier table.
95@return free Classifier Entry index in classifier table for specified SF
96*/
97static __inline int SearchFreeClsid(PMINI_ADAPTER Adapter /**Adapter Context*/
98 )
99{
100 unsigned int uiClassifierIndex = 0;
101 for(uiClassifierIndex=0;uiClassifierIndex<MAX_CLASSIFIERS;uiClassifierIndex++)
102 {
103 if(!Adapter->astClassifierTable[uiClassifierIndex].bUsed)
104 return uiClassifierIndex;
105 }
106 return MAX_CLASSIFIERS+1;
107}
108
109VOID deleteSFBySfid(PMINI_ADAPTER Adapter, UINT uiSearchRuleIndex)
110{
111 //deleting all the packet held in the SF
112 flush_queue(Adapter,uiSearchRuleIndex);
113
114 //Deleting the all classifiers for this SF
115 DeleteAllClassifiersForSF(Adapter,uiSearchRuleIndex);
116
117 //Resetting only MIBS related entries in the SF
118 memset((PVOID)&Adapter->PackInfo[uiSearchRuleIndex], 0, sizeof(S_MIBS_SERVICEFLOW_TABLE));
119}
120
121static inline VOID
122CopyIpAddrToClassifier(S_CLASSIFIER_RULE *pstClassifierEntry ,
123 B_UINT8 u8IpAddressLen , B_UINT8 *pu8IpAddressMaskSrc ,
124 BOOLEAN bIpVersion6 , E_IPADDR_CONTEXT eIpAddrContext)
125{
126 UINT ucLoopIndex=0;
127 UINT nSizeOfIPAddressInBytes = IP_LENGTH_OF_ADDRESS;
128 UCHAR *ptrClassifierIpAddress = NULL;
129 UCHAR *ptrClassifierIpMask = NULL;
130 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
131
132 if(bIpVersion6)
133 {
134 nSizeOfIPAddressInBytes = IPV6_ADDRESS_SIZEINBYTES;
135 }
136 //Destination Ip Address
137 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Ip Address Range Length:0x%X ",
138 u8IpAddressLen);
139 if((bIpVersion6?(IPV6_ADDRESS_SIZEINBYTES * MAX_IP_RANGE_LENGTH * 2):
140 (TOTAL_MASKED_ADDRESS_IN_BYTES)) >= u8IpAddressLen)
141 {
142 /*
143 //checking both the mask and address togethor in Classification.
144 //So length will be : TotalLengthInBytes/nSizeOfIPAddressInBytes * 2
145 //(nSizeOfIPAddressInBytes for address and nSizeOfIPAddressInBytes for mask)
146 */
147 if(eIpAddrContext == eDestIpAddress)
148 {
149 pstClassifierEntry->ucIPDestinationAddressLength =
150 u8IpAddressLen/(nSizeOfIPAddressInBytes * 2);
151 if(bIpVersion6)
152 {
153 ptrClassifierIpAddress =
154 pstClassifierEntry->stDestIpAddress.ucIpv6Address;
155 ptrClassifierIpMask =
156 pstClassifierEntry->stDestIpAddress.ucIpv6Mask;
157 }
158 else
159 {
160 ptrClassifierIpAddress =
161 pstClassifierEntry->stDestIpAddress.ucIpv4Address;
162 ptrClassifierIpMask =
163 pstClassifierEntry->stDestIpAddress.ucIpv4Mask;
164 }
165 }
166 else if(eIpAddrContext == eSrcIpAddress)
167 {
168 pstClassifierEntry->ucIPSourceAddressLength =
169 u8IpAddressLen/(nSizeOfIPAddressInBytes * 2);
170 if(bIpVersion6)
171 {
172 ptrClassifierIpAddress =
173 pstClassifierEntry->stSrcIpAddress.ucIpv6Address;
174 ptrClassifierIpMask =
175 pstClassifierEntry->stSrcIpAddress.ucIpv6Mask;
176 }
177 else
178 {
179 ptrClassifierIpAddress =
180 pstClassifierEntry->stSrcIpAddress.ucIpv4Address;
181 ptrClassifierIpMask =
182 pstClassifierEntry->stSrcIpAddress.ucIpv4Mask;
183 }
184 }
185 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Address Length:0x%X \n",
186 pstClassifierEntry->ucIPDestinationAddressLength);
187 while((u8IpAddressLen>= nSizeOfIPAddressInBytes) &&
188 (ucLoopIndex < MAX_IP_RANGE_LENGTH))
189 {
190 memcpy(ptrClassifierIpAddress +
191 (ucLoopIndex * nSizeOfIPAddressInBytes),
192 (pu8IpAddressMaskSrc+(ucLoopIndex*nSizeOfIPAddressInBytes*2)),
193 nSizeOfIPAddressInBytes);
194 if(!bIpVersion6)
195 {
196 if(eIpAddrContext == eSrcIpAddress)
197 {
198 pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[ucLoopIndex]=
199 ntohl(pstClassifierEntry->stSrcIpAddress.
200 ulIpv4Addr[ucLoopIndex]);
201 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Src Ip Address:0x%luX ",pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[ucLoopIndex]);
202 }
203 else if(eIpAddrContext == eDestIpAddress)
204 {
205 pstClassifierEntry->stDestIpAddress.ulIpv4Addr[ucLoopIndex]= ntohl(pstClassifierEntry->stDestIpAddress.
206 ulIpv4Addr[ucLoopIndex]);
207 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Dest Ip Address:0x%luX ",pstClassifierEntry->stDestIpAddress.ulIpv4Addr[ucLoopIndex]);
208 }
209 }
210 u8IpAddressLen-=nSizeOfIPAddressInBytes;
211 if(u8IpAddressLen >= nSizeOfIPAddressInBytes)
212 {
213 memcpy(ptrClassifierIpMask +
214 (ucLoopIndex * nSizeOfIPAddressInBytes),
215 (pu8IpAddressMaskSrc+nSizeOfIPAddressInBytes +
216 (ucLoopIndex*nSizeOfIPAddressInBytes*2)),
217 nSizeOfIPAddressInBytes);
218 if(!bIpVersion6)
219 {
220 if(eIpAddrContext == eSrcIpAddress)
221 {
222 pstClassifierEntry->stSrcIpAddress.
223 ulIpv4Mask[ucLoopIndex]=
224 ntohl(pstClassifierEntry->stSrcIpAddress.
225 ulIpv4Mask[ucLoopIndex]);
226 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Src Ip Mask Address:0x%luX ",pstClassifierEntry->stSrcIpAddress.ulIpv4Mask[ucLoopIndex]);
227 }
228 else if(eIpAddrContext == eDestIpAddress)
229 {
230 pstClassifierEntry->stDestIpAddress.
231 ulIpv4Mask[ucLoopIndex] =
232 ntohl(pstClassifierEntry->stDestIpAddress.
233 ulIpv4Mask[ucLoopIndex]);
234 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Dest Ip Mask Address:0x%luX ",pstClassifierEntry->stDestIpAddress.ulIpv4Mask[ucLoopIndex]);
235 }
236 }
237 u8IpAddressLen-=nSizeOfIPAddressInBytes;
238 }
239 if(0==u8IpAddressLen)
240 {
241 pstClassifierEntry->bDestIpValid=TRUE;
242 }
243 ucLoopIndex++;
244 }
245 if(bIpVersion6)
246 {
247 //Restore EndianNess of Struct
248 for(ucLoopIndex =0 ; ucLoopIndex < MAX_IP_RANGE_LENGTH * 4 ;
249 ucLoopIndex++)
250 {
251 if(eIpAddrContext == eSrcIpAddress)
252 {
253 pstClassifierEntry->stSrcIpAddress.ulIpv6Addr[ucLoopIndex]=
254 ntohl(pstClassifierEntry->stSrcIpAddress.
255 ulIpv6Addr[ucLoopIndex]);
256 pstClassifierEntry->stSrcIpAddress.ulIpv6Mask[ucLoopIndex]= ntohl(pstClassifierEntry->stSrcIpAddress.
257 ulIpv6Mask[ucLoopIndex]);
258 }
259 else if(eIpAddrContext == eDestIpAddress)
260 {
261 pstClassifierEntry->stDestIpAddress.ulIpv6Addr[ucLoopIndex]= ntohl(pstClassifierEntry->stDestIpAddress.
262 ulIpv6Addr[ucLoopIndex]);
263 pstClassifierEntry->stDestIpAddress.ulIpv6Mask[ucLoopIndex]= ntohl(pstClassifierEntry->stDestIpAddress.
264 ulIpv6Mask[ucLoopIndex]);
265 }
266 }
267 }
268 }
269}
270
271
272void ClearTargetDSXBuffer(PMINI_ADAPTER Adapter,B_UINT16 TID,BOOLEAN bFreeAll)
273{
274 ULONG ulIndex;
275 for(ulIndex=0; ulIndex < Adapter->ulTotalTargetBuffersAvailable; ulIndex++)
276 {
277 if(Adapter->astTargetDsxBuffer[ulIndex].valid)
278 continue;
279 if ((bFreeAll) || (Adapter->astTargetDsxBuffer[ulIndex].tid == TID)){
280 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "ClearTargetDSXBuffer: found tid %d buffer cleared %lx\n",
281 TID, Adapter->astTargetDsxBuffer[ulIndex].ulTargetDsxBuffer);
282 Adapter->astTargetDsxBuffer[ulIndex].valid=1;
283 Adapter->astTargetDsxBuffer[ulIndex].tid=0;
284 Adapter->ulFreeTargetBufferCnt++;
285 }
286 }
287}
288
289/**
290@ingroup ctrl_pkt_functions
291copy classifier rule into the specified SF index
292*/
293static inline VOID CopyClassifierRuleToSF(PMINI_ADAPTER Adapter,stConvergenceSLTypes *psfCSType,UINT uiSearchRuleIndex,UINT nClassifierIndex)
294{
295 S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
296 //VOID *pvPhsContext = NULL;
297 UINT ucLoopIndex=0;
298 //UCHAR ucProtocolLength=0;
299 //ULONG ulPhsStatus;
300
301
302 if(Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value == 0 ||
303 nClassifierIndex > (MAX_CLASSIFIERS-1))
304 return;
305
306
307 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Storing Classifier Rule Index : %X",ntohs(psfCSType->cCPacketClassificationRule.u16PacketClassificationRuleIndex));
308
309 if(nClassifierIndex > MAX_CLASSIFIERS-1)
310 return;
311
312 pstClassifierEntry = &Adapter->astClassifierTable[nClassifierIndex];
313 if(pstClassifierEntry)
314 {
315 //Store if Ipv6
316 pstClassifierEntry->bIpv6Protocol =
317 (Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion == IPV6)?TRUE:FALSE;
318
319 //Destinaiton Port
320 pstClassifierEntry->ucDestPortRangeLength=psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength/4;
321 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Destination Port Range Length:0x%X ",pstClassifierEntry->ucDestPortRangeLength);
322 if( MAX_PORT_RANGE >= psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength)
323 {
324 for(ucLoopIndex=0;ucLoopIndex<(pstClassifierEntry->ucDestPortRangeLength);ucLoopIndex++)
325 {
326 pstClassifierEntry->usDestPortRangeLo[ucLoopIndex] =
327 *((PUSHORT)(psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange+ucLoopIndex));
328 pstClassifierEntry->usDestPortRangeHi[ucLoopIndex] =
329 *((PUSHORT)(psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange+2+ucLoopIndex));
330 pstClassifierEntry->usDestPortRangeLo[ucLoopIndex]=ntohs(pstClassifierEntry->usDestPortRangeLo[ucLoopIndex]);
331 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Destination Port Range Lo:0x%X ",pstClassifierEntry->usDestPortRangeLo[ucLoopIndex]);
332 pstClassifierEntry->usDestPortRangeHi[ucLoopIndex]=ntohs(pstClassifierEntry->usDestPortRangeHi[ucLoopIndex]);
333 }
334 }
335 else
336 {
337 pstClassifierEntry->ucDestPortRangeLength=0;
338 }
339 //Source Port
340 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Source Port Range Length:0x%X ",psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength);
341 if(MAX_PORT_RANGE >=
342 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength)
343 {
344 pstClassifierEntry->ucSrcPortRangeLength =
345 psfCSType->cCPacketClassificationRule.
346 u8ProtocolSourcePortRangeLength/4;
347 for(ucLoopIndex = 0; ucLoopIndex <
348 (pstClassifierEntry->ucSrcPortRangeLength); ucLoopIndex++)
349 {
350 pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex] =
351 *((PUSHORT)(psfCSType->cCPacketClassificationRule.
352 u8ProtocolSourcePortRange+ucLoopIndex));
353 pstClassifierEntry->usSrcPortRangeHi[ucLoopIndex] =
354 *((PUSHORT)(psfCSType->cCPacketClassificationRule.
355 u8ProtocolSourcePortRange+2+ucLoopIndex));
356 pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex] =
357 ntohs(pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex]);
358 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Source Port Range Lo:0x%X ",pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex]);
359 pstClassifierEntry->usSrcPortRangeHi[ucLoopIndex]=ntohs(pstClassifierEntry->usSrcPortRangeHi[ucLoopIndex]);
360 }
361 }
362 //Destination Ip Address and Mask
363 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Ip Destination Parameters : ");
364
365 CopyIpAddrToClassifier(pstClassifierEntry,
366 psfCSType->cCPacketClassificationRule.u8IPDestinationAddressLength,
367 psfCSType->cCPacketClassificationRule.u8IPDestinationAddress,
368 (Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion == IPV6)?
369 TRUE:FALSE, eDestIpAddress);
370
371 //Source Ip Address and Mask
372 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Ip Source Parameters : ");
373
374 CopyIpAddrToClassifier(pstClassifierEntry,
375 psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddressLength,
376 psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddress,
377 (Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion == IPV6)?TRUE:FALSE,
378 eSrcIpAddress);
379
380 //TOS
381 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"TOS Length:0x%X ",psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength);
382 if(3 == psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength)
383 {
384 pstClassifierEntry->ucIPTypeOfServiceLength =
385 psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength;
386 pstClassifierEntry->ucTosLow =
387 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[0];
388 pstClassifierEntry->ucTosHigh =
389 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[1];
390 pstClassifierEntry->ucTosMask =
391 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[2];
392 pstClassifierEntry->bTOSValid = TRUE;
393 }
394 if(psfCSType->cCPacketClassificationRule.u8Protocol == 0)
395 {
396 //we didnt get protocol field filled in by the BS
397 pstClassifierEntry->ucProtocolLength=0;
398 }
399 else
400 {
401 pstClassifierEntry->ucProtocolLength=1;// 1 valid protocol
402 }
403
404 pstClassifierEntry->ucProtocol[0] =
405 psfCSType->cCPacketClassificationRule.u8Protocol;
406
407 pstClassifierEntry->u8ClassifierRulePriority =
408 psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority;
409
410 //store the classifier rule ID and set this classifier entry as valid
411 pstClassifierEntry->ucDirection =
412 Adapter->PackInfo[uiSearchRuleIndex].ucDirection;
413 pstClassifierEntry->uiClassifierRuleIndex = ntohs(psfCSType->
414 cCPacketClassificationRule.u16PacketClassificationRuleIndex);
415 pstClassifierEntry->usVCID_Value =
416 Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value;
417 pstClassifierEntry->ulSFID =
418 Adapter->PackInfo[uiSearchRuleIndex].ulSFID;
419 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Search Index %d Dir: %d, Index: %d, Vcid: %d\n",
420 uiSearchRuleIndex, pstClassifierEntry->ucDirection,
421 pstClassifierEntry->uiClassifierRuleIndex,
422 pstClassifierEntry->usVCID_Value);
423
424 if(psfCSType->cCPacketClassificationRule.u8AssociatedPHSI)
425 {
426 pstClassifierEntry->u8AssociatedPHSI = psfCSType->cCPacketClassificationRule.u8AssociatedPHSI;
427 }
428
429 //Copy ETH CS Parameters
430 pstClassifierEntry->ucEthCSSrcMACLen = (psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddressLength);
431 memcpy(pstClassifierEntry->au8EThCSSrcMAC,psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress,MAC_ADDRESS_SIZE);
432 memcpy(pstClassifierEntry->au8EThCSSrcMACMask,psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress+MAC_ADDRESS_SIZE,MAC_ADDRESS_SIZE);
433 pstClassifierEntry->ucEthCSDestMACLen = (psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
434 memcpy(pstClassifierEntry->au8EThCSDestMAC,psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress,MAC_ADDRESS_SIZE);
435 memcpy(pstClassifierEntry->au8EThCSDestMACMask,psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress+MAC_ADDRESS_SIZE,MAC_ADDRESS_SIZE);
436 pstClassifierEntry->ucEtherTypeLen = (psfCSType->cCPacketClassificationRule.u8EthertypeLength);
437 memcpy(pstClassifierEntry->au8EthCSEtherType,psfCSType->cCPacketClassificationRule.u8Ethertype,NUM_ETHERTYPE_BYTES);
438 memcpy(pstClassifierEntry->usUserPriority, &psfCSType->cCPacketClassificationRule.u16UserPriority, 2);
439 pstClassifierEntry->usVLANID = ntohs(psfCSType->cCPacketClassificationRule.u16VLANID);
440 pstClassifierEntry->usValidityBitMap = ntohs(psfCSType->cCPacketClassificationRule.u16ValidityBitMap);
441
442 pstClassifierEntry->bUsed = TRUE;
443 }
444}
445
446
447/**
448@ingroup ctrl_pkt_functions
449*/
450static inline VOID DeleteClassifierRuleFromSF(PMINI_ADAPTER Adapter,UINT uiSearchRuleIndex,UINT nClassifierIndex)
451{
452 S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
453 B_UINT16 u16PacketClassificationRuleIndex;
454 USHORT usVCID;
455 //VOID *pvPhsContext = NULL;
456 //ULONG ulPhsStatus;
457
458 usVCID = Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value;
459
460 if(nClassifierIndex > MAX_CLASSIFIERS-1)
461 return;
462
463 if(usVCID == 0)
464 return;
465
466 u16PacketClassificationRuleIndex = Adapter->astClassifierTable[nClassifierIndex].uiClassifierRuleIndex;
467
468
469 pstClassifierEntry = &Adapter->astClassifierTable[nClassifierIndex];
470 if(pstClassifierEntry)
471 {
472 pstClassifierEntry->bUsed = FALSE;
473 pstClassifierEntry->uiClassifierRuleIndex = 0;
474 memset(pstClassifierEntry,0,sizeof(S_CLASSIFIER_RULE));
475
476 //Delete the PHS Rule for this classifier
477 PhsDeleteClassifierRule(
478 &Adapter->stBCMPhsContext,
479 usVCID,
480 u16PacketClassificationRuleIndex);
481 }
482}
483
484/**
485@ingroup ctrl_pkt_functions
486*/
487VOID DeleteAllClassifiersForSF(PMINI_ADAPTER Adapter,UINT uiSearchRuleIndex)
488{
489 S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
490 UINT nClassifierIndex;
491 //B_UINT16 u16PacketClassificationRuleIndex;
492 USHORT ulVCID;
493 //VOID *pvPhsContext = NULL;
494 //ULONG ulPhsStatus;
495
496 ulVCID = Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value;
497
498 if(ulVCID == 0)
499 return;
500
501
502 for(nClassifierIndex =0 ; nClassifierIndex < MAX_CLASSIFIERS ; nClassifierIndex++)
503 {
504 if(Adapter->astClassifierTable[nClassifierIndex].usVCID_Value == ulVCID)
505 {
506 pstClassifierEntry = &Adapter->astClassifierTable[nClassifierIndex];
507 if(pstClassifierEntry->bUsed)
508 {
509 DeleteClassifierRuleFromSF(Adapter,uiSearchRuleIndex,nClassifierIndex);
510 }
511 }
512 }
513
514 //Delete All Phs Rules Associated with this SF
515 PhsDeleteSFRules(
516 &Adapter->stBCMPhsContext,
517 ulVCID);
518
519}
520
521
522/**
523This routinue copies the Connection Management
524related data into the Adapter structure.
525@ingroup ctrl_pkt_functions
526*/
527
528static VOID CopyToAdapter( register PMINI_ADAPTER Adapter, /**<Pointer to the Adapter structure*/
529 register pstServiceFlowParamSI psfLocalSet, /**<Pointer to the ServiceFlowParamSI structure*/
530 register UINT uiSearchRuleIndex, /**<Index of Queue, to which this data belongs*/
531 register UCHAR ucDsxType,
532 stLocalSFAddIndicationAlt *pstAddIndication)
533{
534 //UCHAR ucProtocolLength=0;
535 ULONG ulSFID;
536 UINT nClassifierIndex = 0;
537 E_CLASSIFIER_ACTION eClassifierAction = eInvalidClassifierAction;
538 B_UINT16 u16PacketClassificationRuleIndex=0;
539 UINT nIndex=0;
540 stConvergenceSLTypes *psfCSType = NULL;
541 S_PHS_RULE sPhsRule;
542 USHORT uVCID = Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value;
543 UINT UGIValue = 0;
544
545
546 Adapter->PackInfo[uiSearchRuleIndex].bValid=TRUE;
547 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Search Rule Index = %d\n", uiSearchRuleIndex);
548 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"%s: SFID= %x ",__FUNCTION__, ntohl(psfLocalSet->u32SFID));
549 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Updating Queue %d",uiSearchRuleIndex);
550
551 ulSFID = ntohl(psfLocalSet->u32SFID);
552 //Store IP Version used
553 //Get The Version Of IP used (IPv6 or IPv4) from CSSpecification field of SF
554
555 Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = 0;
556 Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport = 0;
557
558 /*Enable IP/ETh CS Support As Required*/
559 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"CopyToAdapter : u8CSSpecification : %X\n",psfLocalSet->u8CSSpecification);
560 switch(psfLocalSet->u8CSSpecification)
561 {
562 case eCSPacketIPV4:
563 {
564 Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = IPV4_CS;
565 break;
566 }
567 case eCSPacketIPV6:
568 {
569 Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = IPV6_CS;
570 break;
571 }
572
573 case eCS802_3PacketEthernet:
574 case eCS802_1QPacketVLAN:
575 {
576 Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport = ETH_CS_802_3;
577 break;
578 }
579
580 case eCSPacketIPV4Over802_1QVLAN:
581 case eCSPacketIPV4Over802_3Ethernet:
582 {
583 Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = IPV4_CS;
584 Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport = ETH_CS_802_3;
585 break;
586 }
587
588 case eCSPacketIPV6Over802_1QVLAN:
589 case eCSPacketIPV6Over802_3Ethernet:
590 {
591 Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = IPV6_CS;
592 Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport = ETH_CS_802_3;
593 break;
594 }
595
596 default:
597 {
598 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Error in value of CS Classification.. setting default to IP CS\n");
599 Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = IPV4_CS;
600 break;
601 }
602 }
603
604 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"CopyToAdapter : Queue No : %X ETH CS Support : %X , IP CS Support : %X \n",
605 uiSearchRuleIndex,
606 Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport,
607 Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport);
608
609 //Store IP Version used
610 //Get The Version Of IP used (IPv6 or IPv4) from CSSpecification field of SF
611 if(Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport == IPV6_CS)
612 {
613 Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion = IPV6;
614 }
615 else
616 {
617 Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion = IPV4;
618 }
619
620 /* To ensure that the ETH CS code doesn't gets executed if the BS doesn't supports ETH CS */
621 if(!Adapter->bETHCSEnabled)
622 Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport = 0;
623
624 if(psfLocalSet->u8ServiceClassNameLength > 0 &&
625 psfLocalSet->u8ServiceClassNameLength < 32)
626 {
627 memcpy(Adapter->PackInfo[uiSearchRuleIndex].ucServiceClassName,
628 psfLocalSet->u8ServiceClassName,
629 psfLocalSet->u8ServiceClassNameLength);
630 }
631 Adapter->PackInfo[uiSearchRuleIndex].u8QueueType =
632 psfLocalSet->u8ServiceFlowSchedulingType;
633
634 if(Adapter->PackInfo[uiSearchRuleIndex].u8QueueType==BE &&
635 Adapter->PackInfo[uiSearchRuleIndex].ucDirection)
636 {
637 Adapter->usBestEffortQueueIndex=uiSearchRuleIndex;
638 }
639
640 Adapter->PackInfo[uiSearchRuleIndex].ulSFID = ntohl(psfLocalSet->u32SFID);
641
642 Adapter->PackInfo[uiSearchRuleIndex].u8TrafficPriority = psfLocalSet->u8TrafficPriority;
643
644 //copy all the classifier in the Service Flow param structure
645 for(nIndex=0; nIndex<psfLocalSet->u8TotalClassifiers; nIndex++)
646 {
647 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Classifier index =%d",nIndex);
648 psfCSType = &psfLocalSet->cConvergenceSLTypes[nIndex];
649 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Classifier index =%d",nIndex);
650
651 if(psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority)
652 {
653 Adapter->PackInfo[uiSearchRuleIndex].bClassifierPriority=TRUE;
654 }
655
656 if(psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority)
657 {
658 Adapter->PackInfo[uiSearchRuleIndex].bClassifierPriority=TRUE;
659 }
660
661
662 if(ucDsxType== DSA_ACK)
663 {
664 eClassifierAction = eAddClassifier;
665 }
666 else if(ucDsxType == DSC_ACK)
667 {
668 switch(psfCSType->u8ClassfierDSCAction)
669 {
670 case 0://DSC Add Classifier
671 {
672 eClassifierAction = eAddClassifier;
673 }
674 break;
675 case 1://DSC Replace Classifier
676 {
677 eClassifierAction = eReplaceClassifier;
678 }
679 break;
680 case 2://DSC Delete Classifier
681 {
682 eClassifierAction = eDeleteClassifier;
683
684 }
685 break;
686 default:
687 {
688 eClassifierAction = eInvalidClassifierAction;
689 }
690 }
691 }
692
693 u16PacketClassificationRuleIndex = ntohs(psfCSType->cCPacketClassificationRule.u16PacketClassificationRuleIndex);
694
695 switch(eClassifierAction)
696 {
697 case eAddClassifier:
698 {
699 //Get a Free Classifier Index From Classifier table for this SF to add the Classifier
700 //Contained in this message
701 nClassifierIndex = SearchClsid(Adapter,ulSFID,u16PacketClassificationRuleIndex);
702
703 if(nClassifierIndex > MAX_CLASSIFIERS)
704 {
705 nClassifierIndex = SearchFreeClsid(Adapter);
706 if(nClassifierIndex > MAX_CLASSIFIERS)
707 {
708 //Failed To get a free Entry
709 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Error Failed To get a free Classifier Entry");
710 break;
711 }
712 //Copy the Classifier Rule for this service flow into our Classifier table maintained per SF.
713 CopyClassifierRuleToSF(Adapter,psfCSType,uiSearchRuleIndex,nClassifierIndex);
714 }
715
716 else
717 {
718 //This Classifier Already Exists and it is invalid to Add Classifier with existing PCRI
719 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"CopyToAdapter : Error The Specified Classifier Already Exists \
720 and attempted To Add Classifier with Same PCRI : 0x%x\n", u16PacketClassificationRuleIndex);
721 }
722 }
723 break;
724
725 case eReplaceClassifier:
726 {
727 //Get the Classifier Index From Classifier table for this SF and replace existing Classifier
728 //with the new classifier Contained in this message
729 nClassifierIndex = SearchClsid(Adapter,ulSFID,u16PacketClassificationRuleIndex);
730 if(nClassifierIndex > MAX_CLASSIFIERS)
731 {
732 //Failed To search the classifier
733 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Error Search for Classifier To be replaced failed");
734 break;
735 }
736 //Copy the Classifier Rule for this service flow into our Classifier table maintained per SF.
737 CopyClassifierRuleToSF(Adapter,psfCSType,uiSearchRuleIndex,nClassifierIndex);
738 }
739 break;
740
741 case eDeleteClassifier:
742 {
743 //Get the Classifier Index From Classifier table for this SF and replace existing Classifier
744 //with the new classifier Contained in this message
745 nClassifierIndex = SearchClsid(Adapter,ulSFID,u16PacketClassificationRuleIndex);
746 if(nClassifierIndex > MAX_CLASSIFIERS)
747 {
748 //Failed To search the classifier
749 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Error Search for Classifier To be deleted failed");
750 break;
751 }
752
753 //Delete This classifier
754 DeleteClassifierRuleFromSF(Adapter,uiSearchRuleIndex,nClassifierIndex);
755 }
756 break;
757
758 default:
759 {
760 //Invalid Action for classifier
761 break;
762 }
763 }
764 }
765
766 //Repeat parsing Classification Entries to process PHS Rules
767 for(nIndex=0; nIndex < psfLocalSet->u8TotalClassifiers; nIndex++)
768 {
769 psfCSType = &psfLocalSet->cConvergenceSLTypes[nIndex];
770
771 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "psfCSType->u8PhsDSCAction : 0x%x\n",
772 psfCSType->u8PhsDSCAction );
773
774 switch (psfCSType->u8PhsDSCAction)
775 {
776 case eDeleteAllPHSRules:
777 {
778 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Deleting All PHS Rules For VCID: 0x%X\n",uVCID);
779
780 //Delete All the PHS rules for this Service flow
781
782 PhsDeleteSFRules(
783 &Adapter->stBCMPhsContext,
784 uVCID);
785
786 break;
787 }
788 case eDeletePHSRule:
789 {
790 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"PHS DSC Action = Delete PHS Rule \n");
791
792 if(psfCSType->cPhsRule.u8PHSI)
793 {
794 PhsDeletePHSRule(
795 &Adapter->stBCMPhsContext,
796 uVCID,
797 psfCSType->cCPacketClassificationRule.u8AssociatedPHSI);
798 }
799 else
800 {
801 //BCM_DEBUG_PRINT(CONN_MSG,("Error CPHSRule.PHSI is ZERO \n"));
802 }
803 break;
804 }
805 default :
806 {
807 if(ucDsxType == DSC_ACK)
808 {
809 //BCM_DEBUG_PRINT(CONN_MSG,("Invalid PHS DSC Action For DSC \n",psfCSType->cPhsRule.u8PHSI));
810 break; //FOr DSC ACK Case PHS DSC Action must be in valid set
811 }
812 }
813 //Proceed To Add PHS rule for DSA_ACK case even if PHS DSC action is unspecified
814 //No Break Here . Intentionally!
815
816 case eAddPHSRule:
817 case eSetPHSRule:
818 {
819 if(psfCSType->cPhsRule.u8PHSI)
820 {
821 //Apply This PHS Rule to all classifiers whose Associated PHSI Match
822 unsigned int uiClassifierIndex = 0;
823 if(pstAddIndication->u8Direction == UPLINK_DIR )
824 {
825 for(uiClassifierIndex=0;uiClassifierIndex<MAX_CLASSIFIERS;uiClassifierIndex++)
826 {
827 if((Adapter->astClassifierTable[uiClassifierIndex].bUsed) &&
828 (Adapter->astClassifierTable[uiClassifierIndex].ulSFID == Adapter->PackInfo[uiSearchRuleIndex].ulSFID) &&
829 (Adapter->astClassifierTable[uiClassifierIndex].u8AssociatedPHSI == psfCSType->cPhsRule.u8PHSI))
830 {
831 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Adding PHS Rule For Classifier : 0x%x cPhsRule.u8PHSI : 0x%x\n",
832 Adapter->astClassifierTable[uiClassifierIndex].uiClassifierRuleIndex,
833 psfCSType->cPhsRule.u8PHSI);
834 //Update The PHS Rule for this classifier as Associated PHSI id defined
835
836 //Copy the PHS Rule
837 sPhsRule.u8PHSI = psfCSType->cPhsRule.u8PHSI;
838 sPhsRule.u8PHSFLength = psfCSType->cPhsRule.u8PHSFLength;
839 sPhsRule.u8PHSMLength = psfCSType->cPhsRule.u8PHSMLength;
840 sPhsRule.u8PHSS = psfCSType->cPhsRule.u8PHSS;
841 sPhsRule.u8PHSV = psfCSType->cPhsRule.u8PHSV;
842 memcpy(sPhsRule.u8PHSF,psfCSType->cPhsRule.u8PHSF,MAX_PHS_LENGTHS);
843 memcpy(sPhsRule.u8PHSM,psfCSType->cPhsRule.u8PHSM,MAX_PHS_LENGTHS);
844 sPhsRule.u8RefCnt = 0;
845 sPhsRule.bUnclassifiedPHSRule = FALSE;
846 sPhsRule.PHSModifiedBytes = 0;
847 sPhsRule.PHSModifiedNumPackets = 0;
848 sPhsRule.PHSErrorNumPackets = 0;
849
850 //bPHSRuleAssociated = TRUE;
851 //Store The PHS Rule for this classifier
852
853 PhsUpdateClassifierRule(
854 &Adapter->stBCMPhsContext,
855 uVCID,
856 Adapter->astClassifierTable[uiClassifierIndex].uiClassifierRuleIndex,
857 &sPhsRule,
858 Adapter->astClassifierTable[uiClassifierIndex].u8AssociatedPHSI);
859
860 //Update PHS Rule For the Classifier
861 if(sPhsRule.u8PHSI)
862 {
863 Adapter->astClassifierTable[uiClassifierIndex].u32PHSRuleID = sPhsRule.u8PHSI;
864 memcpy(&Adapter->astClassifierTable[uiClassifierIndex].sPhsRule,&sPhsRule,sizeof(S_PHS_RULE));
865 }
866
867 }
868 }
869 }
870 else
871 {
872 //Error PHS Rule specified in signaling could not be applied to any classifier
873
874 //Copy the PHS Rule
875 sPhsRule.u8PHSI = psfCSType->cPhsRule.u8PHSI;
876 sPhsRule.u8PHSFLength = psfCSType->cPhsRule.u8PHSFLength;
877 sPhsRule.u8PHSMLength = psfCSType->cPhsRule.u8PHSMLength;
878 sPhsRule.u8PHSS = psfCSType->cPhsRule.u8PHSS;
879 sPhsRule.u8PHSV = psfCSType->cPhsRule.u8PHSV;
880 memcpy(sPhsRule.u8PHSF,psfCSType->cPhsRule.u8PHSF,MAX_PHS_LENGTHS);
881 memcpy(sPhsRule.u8PHSM,psfCSType->cPhsRule.u8PHSM,MAX_PHS_LENGTHS);
882 sPhsRule.u8RefCnt = 0;
883 sPhsRule.bUnclassifiedPHSRule = TRUE;
884 sPhsRule.PHSModifiedBytes = 0;
885 sPhsRule.PHSModifiedNumPackets = 0;
886 sPhsRule.PHSErrorNumPackets = 0;
887 //Store The PHS Rule for this classifier
888
889 /*
890 Passing the argument u8PHSI instead of clsid. Because for DL with no classifier rule,
891 clsid will be zero hence we cant have multiple PHS rules for the same SF.
892 To support multiple PHS rule, passing u8PHSI.
893 */
894
895 PhsUpdateClassifierRule(
896 &Adapter->stBCMPhsContext,
897 uVCID,
898 sPhsRule.u8PHSI,
899 &sPhsRule,
900 sPhsRule.u8PHSI);
901
902 }
903
904 }
905 }
906 break;
907 }
908 }
909
910 if(psfLocalSet->u32MaxSustainedTrafficRate == 0 )
911 {
912 //No Rate Limit . Set Max Sustained Traffic Rate to Maximum
913 Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate =
914 WIMAX_MAX_ALLOWED_RATE;
915
916 }
917 else if (ntohl(psfLocalSet->u32MaxSustainedTrafficRate) >
918 WIMAX_MAX_ALLOWED_RATE)
919 {
920 //Too large Allowed Rate specified. Limiting to Wi Max Allowed rate
921 Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate =
922 WIMAX_MAX_ALLOWED_RATE;
923 }
924 else
925 {
926 Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate =
927 ntohl(psfLocalSet->u32MaxSustainedTrafficRate);
928 }
929
930 Adapter->PackInfo[uiSearchRuleIndex].uiMaxLatency = ntohl(psfLocalSet->u32MaximumLatency);
931
932 if(Adapter->PackInfo[uiSearchRuleIndex].uiMaxLatency == 0) /* 0 should be treated as infinite */
933 Adapter->PackInfo[uiSearchRuleIndex].uiMaxLatency = MAX_LATENCY_ALLOWED;
934
935
936 if(( Adapter->PackInfo[uiSearchRuleIndex].u8QueueType == ERTPS ||
937 Adapter->PackInfo[uiSearchRuleIndex].u8QueueType == UGS ) )
938 UGIValue = ntohs(psfLocalSet->u16UnsolicitedGrantInterval);
939
940 if(UGIValue == 0)
941 UGIValue = DEFAULT_UG_INTERVAL;
942
943 /*
944 For UGI based connections...
945 DEFAULT_UGI_FACTOR*UGIInterval worth of data is the max token count at host...
946 The extra amount of token is to ensure that a large amount of jitter won't have loss in throughput...
947 In case of non-UGI based connection, 200 frames worth of data is the max token count at host...
948 */
949
950 Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize =
951 (DEFAULT_UGI_FACTOR*Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate*UGIValue)/1000;
952
953 if(Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize < WIMAX_MAX_MTU*8)
954 {
955 UINT UGIFactor = 0;
956 /* Special Handling to ensure the biggest size of packet can go out from host to FW as follows:
957 1. Any packet from Host to FW can go out in different packet size.
958 2. So in case the Bucket count is smaller than MTU, the packets of size (Size > TokenCount), will get dropped.
959 3. We can allow packets of MaxSize from Host->FW that can go out from FW in multiple SDUs by fragmentation at Wimax Layer
960 */
961 UGIFactor = (Adapter->PackInfo[uiSearchRuleIndex].uiMaxLatency/UGIValue + 1);
962
963 if(UGIFactor > DEFAULT_UGI_FACTOR)
964 Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize =
965 (UGIFactor*Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate*UGIValue)/1000;
966
967 if(Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize > WIMAX_MAX_MTU*8)
968 Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize = WIMAX_MAX_MTU*8;
969 }
970
971
972 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"LAT: %d, UGI: %d \n", Adapter->PackInfo[uiSearchRuleIndex].uiMaxLatency, UGIValue);
973 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"uiMaxAllowedRate: 0x%x, u32MaxSustainedTrafficRate: 0x%x ,uiMaxBucketSize: 0x%x",
974 Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate,
975 ntohl(psfLocalSet->u32MaxSustainedTrafficRate),
976 Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize);
977
978 //copy the extended SF Parameters to Support MIBS
979 CopyMIBSExtendedSFParameters(Adapter,psfLocalSet,uiSearchRuleIndex);
980
981 //store header suppression enabled flag per SF
982 Adapter->PackInfo[uiSearchRuleIndex].bHeaderSuppressionEnabled =
983 !(psfLocalSet->u8RequesttransmissionPolicy &
984 MASK_DISABLE_HEADER_SUPPRESSION);
985
986 if(Adapter->PackInfo[uiSearchRuleIndex].pstSFIndication)
987 {
988 bcm_kfree(Adapter->PackInfo[uiSearchRuleIndex].pstSFIndication);
989 Adapter->PackInfo[uiSearchRuleIndex].pstSFIndication = NULL;
990 }
991 Adapter->PackInfo[uiSearchRuleIndex].pstSFIndication = pstAddIndication;
992
993 //Re Sort the SF list in PackInfo according to Traffic Priority
994 SortPackInfo(Adapter);
995
996 /* Re Sort the Classifier Rules table and re - arrange
997 according to Classifier Rule Priority */
998 SortClassifiers(Adapter);
999
1000 DumpPhsRules(&Adapter->stBCMPhsContext);
1001
1002 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"%s <=====", __FUNCTION__);
1003}
1004
1005
1006/***********************************************************************
1007* Function - DumpCmControlPacket
1008*
1009* Description - This routinue Dumps the Contents of the AddIndication
1010* Structure in the Connection Management Control Packet
1011*
1012* Parameter - pvBuffer: Pointer to the buffer containing the
1013* AddIndication data.
1014*
1015* Returns - None
1016*************************************************************************/
44a17eff 1017static VOID DumpCmControlPacket(PVOID pvBuffer)
f8942e07
SH		 1018{
1019 UINT uiLoopIndex;
1020 UINT nIndex;
1021 stLocalSFAddIndicationAlt *pstAddIndication;
1022 UINT nCurClassifierCnt;
1023 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
1024
1025 pstAddIndication = (stLocalSFAddIndicationAlt *)pvBuffer;
1026 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "======>");
1027
1028 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8Type : 0x%X",pstAddIndication->u8Type);
1029 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8Direction : 0x%X",pstAddIndication->u8Direction);
1030 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16TID: 0x%X", ntohs(pstAddIndication->u16TID));
1031 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16CID : 0x%X",ntohs(pstAddIndication->u16CID));
1032 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16VCID : 0x%X",ntohs(pstAddIndication->u16VCID));
1033
1034 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " AuthorizedSet--->");
1035
1036 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32SFID : 0x%X",htonl(pstAddIndication->sfAuthorizedSet.u32SFID));
1037 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16CID : 0x%X",htons(pstAddIndication->sfAuthorizedSet.u16CID));
1038 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ServiceClassNameLength : 0x%X",
1039 pstAddIndication->sfAuthorizedSet.u8ServiceClassNameLength);
1040
1041 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ServiceClassName : 0x%X ,0x%X , 0x%X, 0x%X, 0x%X, 0x%X",
1042 pstAddIndication->sfAuthorizedSet.u8ServiceClassName[0],
1043 pstAddIndication->sfAuthorizedSet.u8ServiceClassName[1],
1044 pstAddIndication->sfAuthorizedSet.u8ServiceClassName[2],
1045 pstAddIndication->sfAuthorizedSet.u8ServiceClassName[3],
1046 pstAddIndication->sfAuthorizedSet.u8ServiceClassName[4],
1047 pstAddIndication->sfAuthorizedSet.u8ServiceClassName[5]);
1048
1049 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8MBSService : 0x%X",
1050 pstAddIndication->sfAuthorizedSet.u8MBSService);
1051 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8QosParamSet : 0x%X",
1052 pstAddIndication->sfAuthorizedSet.u8QosParamSet);
1053 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8TrafficPriority : 0x%X, %p",
1054 pstAddIndication->sfAuthorizedSet.u8TrafficPriority, &pstAddIndication->sfAuthorizedSet.u8TrafficPriority);
1055
1056 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MaxSustainedTrafficRate : 0x%X 0x%p",
1057 pstAddIndication->sfAuthorizedSet.u32MaxSustainedTrafficRate,
1058 &pstAddIndication->sfAuthorizedSet.u32MaxSustainedTrafficRate);
1059
1060 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MaxTrafficBurst : 0x%X",
1061 pstAddIndication->sfAuthorizedSet.u32MaxTrafficBurst);
1062 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MinReservedTrafficRate : 0x%X",
1063 pstAddIndication->sfAuthorizedSet.u32MinReservedTrafficRate);
1064#if 0
1065 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MinimumTolerableTrafficRate : 0x%X",
1066 pstAddIndication->sfAuthorizedSet.u32MinimumTolerableTrafficRate);
1067 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32RequesttransmissionPolicy : 0x%X",
1068 pstAddIndication->sfAuthorizedSet.u32RequesttransmissionPolicy);
1069#endif
1070 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificQoSParamLength : 0x%X",
1071 pstAddIndication->sfAuthorizedSet.u8VendorSpecificQoSParamLength);
1072 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificQoSParam : 0x%X",
1073 pstAddIndication->sfAuthorizedSet.u8VendorSpecificQoSParam[0]);
1074 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ServiceFlowSchedulingType : 0x%X",
1075 pstAddIndication->sfAuthorizedSet.u8ServiceFlowSchedulingType);
1076 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32ToleratedJitter : 0x%X",
1077 pstAddIndication->sfAuthorizedSet.u32ToleratedJitter);
1078 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MaximumLatency : 0x%X",
1079 pstAddIndication->sfAuthorizedSet.u32MaximumLatency);
1080 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8FixedLengthVSVariableLengthSDUIndicator: 0x%X",
1081 pstAddIndication->sfAuthorizedSet.u8FixedLengthVSVariableLengthSDUIndicator);
1082
1083 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8SDUSize : 0x%X",
1084 pstAddIndication->sfAuthorizedSet.u8SDUSize);
1085 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16TargetSAID : 0x%X",
1086 pstAddIndication->sfAuthorizedSet.u16TargetSAID);
1087 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ARQEnable : 0x%X",
1088 pstAddIndication->sfAuthorizedSet.u8ARQEnable);
1089 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQWindowSize : 0x%X",
1090 pstAddIndication->sfAuthorizedSet.u16ARQWindowSize);
1091 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQRetryTxTimeOut : 0x%X",
1092 pstAddIndication->sfAuthorizedSet.u16ARQRetryTxTimeOut);
1093 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQRetryRxTimeOut : 0x%X",
1094 pstAddIndication->sfAuthorizedSet.u16ARQRetryRxTimeOut);
1095 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQBlockLifeTime : 0x%X",
1096 pstAddIndication->sfAuthorizedSet.u16ARQBlockLifeTime);
1097 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQSyncLossTimeOut : 0x%X",
1098 pstAddIndication->sfAuthorizedSet.u16ARQSyncLossTimeOut);
1099 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ARQDeliverInOrder : 0x%X",
1100 pstAddIndication->sfAuthorizedSet.u8ARQDeliverInOrder);
1101 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQRxPurgeTimeOut : 0x%X",
1102 pstAddIndication->sfAuthorizedSet.u16ARQRxPurgeTimeOut);
1103 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQBlockSize : 0x%X",
1104 pstAddIndication->sfAuthorizedSet.u16ARQBlockSize);
1105 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8CSSpecification : 0x%X",
1106 pstAddIndication->sfAuthorizedSet.u8CSSpecification);
1107 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8TypeOfDataDeliveryService : 0x%X",
1108 pstAddIndication->sfAuthorizedSet.u8TypeOfDataDeliveryService);
1109 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16SDUInterArrivalTime : 0x%X",
1110 pstAddIndication->sfAuthorizedSet.u16SDUInterArrivalTime);
1111 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16TimeBase : 0x%X",
1112 pstAddIndication->sfAuthorizedSet.u16TimeBase);
1113 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8PagingPreference : 0x%X",
1114 pstAddIndication->sfAuthorizedSet.u8PagingPreference);
1115 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16UnsolicitedPollingInterval : 0x%X",
1116 pstAddIndication->sfAuthorizedSet.u16UnsolicitedPollingInterval);
1117#if 0
1118 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "MBSZoneIdentifierassignmentLength : 0x%X",
1119 pstAddIndication->sfAuthorizedSet.MBSZoneIdentifierassignmentLength);
1120 for(uiLoopIndex=0; uiLoopIndex < MAX_STRING_LEN; uiLoopIndex++)
1121 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "MBSZoneIdentifierassignment : 0x%X",
1122 pstAddIndication->sfAuthorizedSet.MBSZoneIdentifierassignment[uiLoopIndex]);
1123#endif
1124
1125 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "sfAuthorizedSet.u8HARQChannelMapping %x %x %x ",
1126 *(unsigned int*)pstAddIndication->sfAuthorizedSet.u8HARQChannelMapping,
1127 *(unsigned int*)&pstAddIndication->sfAuthorizedSet.u8HARQChannelMapping[4],
1128 *(USHORT*) &pstAddIndication->sfAuthorizedSet.u8HARQChannelMapping[8]);
1129 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8TrafficIndicationPreference : 0x%X",
1130 pstAddIndication->sfAuthorizedSet.u8TrafficIndicationPreference);
1131
1132 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " Total Classifiers Recieved : 0x%X",pstAddIndication->sfAuthorizedSet.u8TotalClassifiers);
1133
1134 nCurClassifierCnt = pstAddIndication->sfAuthorizedSet.u8TotalClassifiers;
1135
1136 if(nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF)
1137 {
1138 nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF;
1139 }
1140 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "pstAddIndication->sfAuthorizedSet.bValid %d", pstAddIndication->sfAuthorizedSet.bValid);
1141 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "pstAddIndication->sfAuthorizedSet.u16MacOverhead %x", pstAddIndication->sfAuthorizedSet.u16MacOverhead);
1142 if(!pstAddIndication->sfAuthorizedSet.bValid)
1143 pstAddIndication->sfAuthorizedSet.bValid=1;
1144 for(nIndex = 0 ; nIndex < nCurClassifierCnt ; nIndex++)
1145 {
1146 stConvergenceSLTypes *psfCSType = NULL;
1147 psfCSType = &pstAddIndication->sfAuthorizedSet.cConvergenceSLTypes[nIndex];
1148
1149 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "psfCSType = %p", psfCSType);
1150 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "CCPacketClassificationRuleSI====>");
1151
1152 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ClassifierRulePriority :0x%X ",
1153 psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority);
1154 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPTypeOfServiceLength :0x%X ",
1155 psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength);
1156
1157 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPTypeOfService[3] :0x%X ,0x%X ,0x%X ",
1158 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[0],
1159 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[1],
1160 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[2]);
1161#if 0
1162
1163 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "u8ProtocolLength :0x%X ",
1164 psfCSType->cCPacketClassificationRule.u8ProtocolLength);
1165#endif
1166
1167 for(uiLoopIndex=0; uiLoopIndex < 1; uiLoopIndex++)
1168 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8Protocol : 0x%02X ",
1169 psfCSType->cCPacketClassificationRule.u8Protocol);
1170
1171 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPMaskedSourceAddressLength :0x%X ",
1172 psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddressLength);
1173
1174 for(uiLoopIndex=0; uiLoopIndex < 32; uiLoopIndex++)
1175 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPMaskedSourceAddress[32] : 0x%02X ",
1176 psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddress[uiLoopIndex]);
1177
1178 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPDestinationAddressLength : 0x%X ",
1179 psfCSType->cCPacketClassificationRule.u8IPDestinationAddressLength);
1180
1181 for(uiLoopIndex=0; uiLoopIndex < 32; uiLoopIndex++)
1182 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPDestinationAddress[32] : 0x%02X ",
1183 psfCSType->cCPacketClassificationRule.u8IPDestinationAddress[uiLoopIndex]);
1184
1185 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ProtocolSourcePortRangeLength:0x%X ",
1186 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength);
1187 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ProtocolSourcePortRange[4]: 0x%02X ,0x%02X ,0x%02X ,0x%02X ",
1188 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[0],
1189 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[1],
1190 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[2],
1191 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[3]);
1192
1193 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ProtocolDestPortRangeLength : 0x%02X ",
1194 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength);
1195 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ProtocolDestPortRange[4]: 0x%02X ,0x%02X ,0x%02X ,0x%02X ",
1196 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[0],
1197 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[1],
1198 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[2],
1199 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[3]);
1200
1201 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8EthernetDestMacAddressLength : 0x%02X ",
1202 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1203
1204 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8EthernetDestMacAddress[6] : 0x %02X %02X %02X %02X %02X %02X",
1205 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[0],
1206 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[1],
1207 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[2],
1208 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[3],
1209 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[4],
1210 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[5]);
1211
1212 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8EthernetSourceMACAddressLength : 0x%02X ",
1213 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1214
1215 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8EthernetSourceMACAddress[6] : 0x %02X %02X %02X %02X %02X %02X",
1216 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[0],
1217 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[1],
1218 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[2],
1219 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[3],
1220 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[4],
1221 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[5]);
1222
1223 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8EthertypeLength : 0x%02X ",
1224 psfCSType->cCPacketClassificationRule.u8EthertypeLength);
1225 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8Ethertype[3] : 0x%02X ,0x%02X ,0x%02X ",
1226 psfCSType->cCPacketClassificationRule.u8Ethertype[0],
1227 psfCSType->cCPacketClassificationRule.u8Ethertype[1],
1228 psfCSType->cCPacketClassificationRule.u8Ethertype[2]);
1229
1230 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16UserPriority : 0x%X ",
1231 psfCSType->cCPacketClassificationRule.u16UserPriority);
1232
1233 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16VLANID : 0x%X ",
1234 psfCSType->cCPacketClassificationRule.u16VLANID);
1235
1236 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8AssociatedPHSI : 0x%02X ",
1237 psfCSType->cCPacketClassificationRule.u8AssociatedPHSI);
1238
1239 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16PacketClassificationRuleIndex : 0x%X ",
1240 psfCSType->cCPacketClassificationRule.u16PacketClassificationRuleIndex);
1241
1242 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificClassifierParamLength : 0x%X ",
1243 psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParamLength);
1244
1245 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificClassifierParam[1] : 0x%X ",
1246 psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParam[0]);
1247#ifdef VERSION_D5
1248 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPv6FlowLableLength :0x%X ",
1249 psfCSType->cCPacketClassificationRule.u8IPv6FlowLableLength);
1250 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPv6FlowLable[6] : 0x %02X %02X %02X %02X %02X %02X ",
1251 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[0],
1252 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[1],
1253 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[2],
1254 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[3],
1255 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[4],
1256 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[5]);
1257#endif
1258 }
1259
1260 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "bValid : 0x%02X",pstAddIndication->sfAuthorizedSet.bValid);
1261
1262 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "AdmittedSet--->");
1263 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32SFID : 0x%X",pstAddIndication->sfAdmittedSet.u32SFID);
1264 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16CID : 0x%X",pstAddIndication->sfAdmittedSet.u16CID);
1265 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ServiceClassNameLength : 0x%X",
1266 pstAddIndication->sfAdmittedSet.u8ServiceClassNameLength);
1267 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ServiceClassName : 0x %02X %02X %02X %02X %02X %02X",
1268 pstAddIndication->sfAdmittedSet.u8ServiceClassName[0],
1269 pstAddIndication->sfAdmittedSet.u8ServiceClassName[1],
1270 pstAddIndication->sfAdmittedSet.u8ServiceClassName[2],
1271 pstAddIndication->sfAdmittedSet.u8ServiceClassName[3],
1272 pstAddIndication->sfAdmittedSet.u8ServiceClassName[4],
1273 pstAddIndication->sfAdmittedSet.u8ServiceClassName[5]);
1274
1275 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8MBSService : 0x%02X",
1276 pstAddIndication->sfAdmittedSet.u8MBSService);
1277 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8QosParamSet : 0x%02X",
1278 pstAddIndication->sfAdmittedSet.u8QosParamSet);
1279 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8TrafficPriority : 0x%02X",
1280 pstAddIndication->sfAdmittedSet.u8TrafficPriority);
1281#if 0
1282 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "u32MaxSustainedTrafficRate : 0x%02X",
1283 ntohl(pstAddIndication->sfAdmittedSet.u32MaxSustainedTrafficRate));
1284 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "u32MinimumTolerableTrafficRate : 0x%X",
1285 pstAddIndication->sfAdmittedSet.u32MinimumTolerableTrafficRate);
1286 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "u32RequesttransmissionPolicy : 0x%X",
1287 pstAddIndication->sfAdmittedSet.u32RequesttransmissionPolicy);
1288#endif
1289 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MaxTrafficBurst : 0x%X",
1290 pstAddIndication->sfAdmittedSet.u32MaxTrafficBurst);
1291 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MinReservedTrafficRate : 0x%X",
1292 pstAddIndication->sfAdmittedSet.u32MinReservedTrafficRate);
1293
1294 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificQoSParamLength : 0x%02X",
1295 pstAddIndication->sfAdmittedSet.u8VendorSpecificQoSParamLength);
1296 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificQoSParam : 0x%02X",
1297 pstAddIndication->sfAdmittedSet.u8VendorSpecificQoSParam[0]);
1298 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ServiceFlowSchedulingType : 0x%02X",
1299 pstAddIndication->sfAdmittedSet.u8ServiceFlowSchedulingType);
1300
1301 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32ToleratedJitter : 0x%X",
1302 pstAddIndication->sfAdmittedSet.u32ToleratedJitter);
1303 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MaximumLatency : 0x%X",
1304 pstAddIndication->sfAdmittedSet.u32MaximumLatency);
1305
1306 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8FixedLengthVSVariableLengthSDUIndicator: 0x%02X",
1307 pstAddIndication->sfAdmittedSet.u8FixedLengthVSVariableLengthSDUIndicator);
1308 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8SDUSize : 0x%02X",
1309 pstAddIndication->sfAdmittedSet.u8SDUSize);
1310 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16TargetSAID : 0x%02X",
1311 pstAddIndication->sfAdmittedSet.u16TargetSAID);
1312 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ARQEnable : 0x%02X",
1313 pstAddIndication->sfAdmittedSet.u8ARQEnable);
1314
1315 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQWindowSize : 0x%X",
1316 pstAddIndication->sfAdmittedSet.u16ARQWindowSize);
1317 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQRetryTxTimeOut : 0x%X",
1318 pstAddIndication->sfAdmittedSet.u16ARQRetryTxTimeOut);
1319 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQRetryRxTimeOut : 0x%X",
1320 pstAddIndication->sfAdmittedSet.u16ARQRetryRxTimeOut);
1321 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQBlockLifeTime : 0x%X",
1322 pstAddIndication->sfAdmittedSet.u16ARQBlockLifeTime);
1323 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQSyncLossTimeOut : 0x%X",
1324 pstAddIndication->sfAdmittedSet.u16ARQSyncLossTimeOut);
1325
1326 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ARQDeliverInOrder : 0x%02X",
1327 pstAddIndication->sfAdmittedSet.u8ARQDeliverInOrder);
1328 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQRxPurgeTimeOut : 0x%X",
1329 pstAddIndication->sfAdmittedSet.u16ARQRxPurgeTimeOut);
1330 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQBlockSize : 0x%X",
1331 pstAddIndication->sfAdmittedSet.u16ARQBlockSize);
1332 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8CSSpecification : 0x%02X",
1333 pstAddIndication->sfAdmittedSet.u8CSSpecification);
1334 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8TypeOfDataDeliveryService : 0x%02X",
1335 pstAddIndication->sfAdmittedSet.u8TypeOfDataDeliveryService);
1336 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16SDUInterArrivalTime : 0x%X",
1337 pstAddIndication->sfAdmittedSet.u16SDUInterArrivalTime);
1338 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16TimeBase : 0x%X",
1339 pstAddIndication->sfAdmittedSet.u16TimeBase);
1340 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8PagingPreference : 0x%X",
1341 pstAddIndication->sfAdmittedSet.u8PagingPreference);
1342#if 0
1343 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "MBSZoneIdentifierassignmentLength : 0x%X",
1344 pstAddIndication->sfAdmittedSet.MBSZoneIdentifierassignmentLength);
1345 for(uiLoopIndex=0; uiLoopIndex < MAX_STRING_LEN; uiLoopIndex++)
1346 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "MBSZoneIdentifierassignment : 0x%X",
1347 pstAddIndication->sfAdmittedSet.MBSZoneIdentifierassignment[uiLoopIndex]);
1348#endif
1349
1350
1351 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8TrafficIndicationPreference : 0x%02X",
1352 pstAddIndication->sfAdmittedSet.u8TrafficIndicationPreference);
1353
1354 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " Total Classifiers Recieved : 0x%X",pstAddIndication->sfAdmittedSet.u8TotalClassifiers);
1355
1356 nCurClassifierCnt = pstAddIndication->sfAdmittedSet.u8TotalClassifiers;
1357
1358 if(nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF)
1359 {
1360 nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF;
1361 }
1362
1363
1364 for(nIndex = 0 ; nIndex < nCurClassifierCnt ; nIndex++)
1365 {
1366
1367 stConvergenceSLTypes *psfCSType = NULL;
1368 psfCSType = &pstAddIndication->sfAdmittedSet.cConvergenceSLTypes[nIndex];
1369
1370 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " CCPacketClassificationRuleSI====>");
1371
1372 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ClassifierRulePriority :0x%02X ",
1373 psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority);
1374 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPTypeOfServiceLength :0x%02X",
1375 psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength);
1376
1377 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPTypeOfService[3] :0x%02X %02X %02X",
1378 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[0],
1379 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[1],
1380 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[2]);
1381#if 0
1382
1383 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ProtocolLength :0x%02X ",
1384 psfCSType->cCPacketClassificationRule.u8ProtocolLength);
1385#endif
1386 for(uiLoopIndex=0; uiLoopIndex < 1; uiLoopIndex++)
1387 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8Protocol: 0x%02X ",
1388 psfCSType->cCPacketClassificationRule.u8Protocol);
1389
1390 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPMaskedSourceAddressLength :0x%02X ",
1391 psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddressLength);
1392
1393 for(uiLoopIndex=0; uiLoopIndex < 32; uiLoopIndex++)
1394 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPMaskedSourceAddress[32] : 0x%02X ",
1395 psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddress[uiLoopIndex]);
1396
1397 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPDestinationAddressLength : 0x%02X ",
1398 psfCSType->cCPacketClassificationRule.u8IPDestinationAddressLength);
1399
1400 for(uiLoopIndex=0; uiLoopIndex < 32; uiLoopIndex++)
1401 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPDestinationAddress[32] : 0x%02X ",
1402 psfCSType->cCPacketClassificationRule.u8IPDestinationAddress[uiLoopIndex]);
1403
1404 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ProtocolSourcePortRangeLength : 0x%02X ",
1405 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength);
1406
1407 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ProtocolSourcePortRange[4] : 0x %02X %02X %02X %02X ",
1408 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[0],
1409 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[1],
1410 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[2],
1411 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[3]);
1412
1413 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ProtocolDestPortRangeLength : 0x%02X ",
1414 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength);
1415
1416 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ProtocolDestPortRange[4] : 0x %02X %02X %02X %02X ",
1417 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[0],
1418 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[1],
1419 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[2],
1420 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[3]);
1421
1422 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8EthernetDestMacAddressLength : 0x%02X ",
1423 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1424
1425 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8EthernetDestMacAddress[6] : 0x %02X %02X %02X %02X %02X %02X",
1426 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[0],
1427 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[1],
1428 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[2],
1429 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[3],
1430 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[4],
1431 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[5]);
1432
1433 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8EthernetSourceMACAddressLength : 0x%02X ",
1434 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1435
1436 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8EthernetSourceMACAddress[6] : 0x %02X %02X %02X %02X %02X %02X",
1437 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[0],
1438 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[1],
1439 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[2],
1440 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[3],
1441 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[4],
1442 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[5]);
1443
1444 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8EthertypeLength : 0x%02X ",
1445 psfCSType->cCPacketClassificationRule.u8EthertypeLength);
1446 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8Ethertype[3] : 0x%02X %02X %02X",
1447 psfCSType->cCPacketClassificationRule.u8Ethertype[0],
1448 psfCSType->cCPacketClassificationRule.u8Ethertype[1],
1449 psfCSType->cCPacketClassificationRule.u8Ethertype[2]);
1450
1451 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16UserPriority : 0x%X ",
1452 psfCSType->cCPacketClassificationRule.u16UserPriority);
1453 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16VLANID : 0x%X ",
1454 psfCSType->cCPacketClassificationRule.u16VLANID);
1455 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8AssociatedPHSI : 0x%02X ",
1456 psfCSType->cCPacketClassificationRule.u8AssociatedPHSI);
1457 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16PacketClassificationRuleIndex : 0x%X ",
1458 psfCSType->cCPacketClassificationRule.u16PacketClassificationRuleIndex);
1459
1460 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificClassifierParamLength : 0x%02X",
1461 psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParamLength);
1462 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificClassifierParam[1] : 0x%02X ",
1463 psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParam[0]);
1464#ifdef VERSION_D5
1465 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPv6FlowLableLength : 0x%X ",
1466 psfCSType->cCPacketClassificationRule.u8IPv6FlowLableLength);
1467 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPv6FlowLable[6] : 0x %02X %02X %02X %02X %02X %02X ",
1468 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[0],
1469 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[1],
1470 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[2],
1471 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[3],
1472 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[4],
1473 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[5]);
1474#endif
1475 }
1476
1477 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "bValid : 0x%X",pstAddIndication->sfAdmittedSet.bValid);
1478
1479 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " ActiveSet--->");
1480 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32SFID : 0x%X",pstAddIndication->sfActiveSet.u32SFID);
1481 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16CID : 0x%X",pstAddIndication->sfActiveSet.u16CID);
1482
1483 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ServiceClassNameLength : 0x%X",
1484 pstAddIndication->sfActiveSet.u8ServiceClassNameLength);
1485
1486 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ServiceClassName : 0x %02X %02X %02X %02X %02X %02X",
1487 pstAddIndication->sfActiveSet.u8ServiceClassName[0],
1488 pstAddIndication->sfActiveSet.u8ServiceClassName[1],
1489 pstAddIndication->sfActiveSet.u8ServiceClassName[2],
1490 pstAddIndication->sfActiveSet.u8ServiceClassName[3],
1491 pstAddIndication->sfActiveSet.u8ServiceClassName[4],
1492 pstAddIndication->sfActiveSet.u8ServiceClassName[5]);
1493
1494 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8MBSService : 0x%02X",
1495 pstAddIndication->sfActiveSet.u8MBSService);
1496 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8QosParamSet : 0x%02X",
1497 pstAddIndication->sfActiveSet.u8QosParamSet);
1498 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8TrafficPriority : 0x%02X",
1499 pstAddIndication->sfActiveSet.u8TrafficPriority);
1500#if 0
1501 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "u32MaxSustainedTrafficRate : 0x%02X",
1502 ntohl(pstAddIndication->sfActiveSet.u32MaxSustainedTrafficRate));
1503#endif
1504 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MaxTrafficBurst : 0x%X",
1505 pstAddIndication->sfActiveSet.u32MaxTrafficBurst);
1506 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MinReservedTrafficRate : 0x%X",
1507 pstAddIndication->sfActiveSet.u32MinReservedTrafficRate);
1508#if 0
1509 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "u32MinimumTolerableTrafficRate : 0x%X",
1510 pstAddIndication->sfActiveSet.u32MinimumTolerableTrafficRate);
1511 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "u32RequesttransmissionPolicy : 0x%X",
1512 pstAddIndication->sfActiveSet.u32RequesttransmissionPolicy);
1513#endif
1514 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificQoSParamLength : 0x%02X",
1515 pstAddIndication->sfActiveSet.u8VendorSpecificQoSParamLength);
1516 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificQoSParam : 0x%02X",
1517 pstAddIndication->sfActiveSet.u8VendorSpecificQoSParam[0]);
1518 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ServiceFlowSchedulingType : 0x%02X",
1519 pstAddIndication->sfActiveSet.u8ServiceFlowSchedulingType);
1520
1521 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32ToleratedJitter : 0x%X",
1522 pstAddIndication->sfActiveSet.u32ToleratedJitter);
1523 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MaximumLatency : 0x%X",
1524 pstAddIndication->sfActiveSet.u32MaximumLatency);
1525
1526 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8FixedLengthVSVariableLengthSDUIndicator: 0x%02X",
1527 pstAddIndication->sfActiveSet.u8FixedLengthVSVariableLengthSDUIndicator);
1528
1529 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8SDUSize : 0x%X",
1530 pstAddIndication->sfActiveSet.u8SDUSize);
1531 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16TargetSAID : 0x%X",
1532 pstAddIndication->sfActiveSet.u16TargetSAID);
1533 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8ARQEnable : 0x%X",
1534 pstAddIndication->sfActiveSet.u8ARQEnable);
1535 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16ARQWindowSize : 0x%X",
1536 pstAddIndication->sfActiveSet.u16ARQWindowSize);
1537 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16ARQRetryTxTimeOut : 0x%X",
1538 pstAddIndication->sfActiveSet.u16ARQRetryTxTimeOut);
1539 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16ARQRetryRxTimeOut : 0x%X",
1540 pstAddIndication->sfActiveSet.u16ARQRetryRxTimeOut);
1541 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16ARQBlockLifeTime : 0x%X",
1542 pstAddIndication->sfActiveSet.u16ARQBlockLifeTime);
1543 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16ARQSyncLossTimeOut : 0x%X",
1544 pstAddIndication->sfActiveSet.u16ARQSyncLossTimeOut);
1545 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8ARQDeliverInOrder : 0x%X",
1546 pstAddIndication->sfActiveSet.u8ARQDeliverInOrder);
1547 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16ARQRxPurgeTimeOut : 0x%X",
1548 pstAddIndication->sfActiveSet.u16ARQRxPurgeTimeOut);
1549 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16ARQBlockSize : 0x%X",
1550 pstAddIndication->sfActiveSet.u16ARQBlockSize);
1551 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8CSSpecification : 0x%X",
1552 pstAddIndication->sfActiveSet.u8CSSpecification);
1553 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8TypeOfDataDeliveryService : 0x%X",
1554 pstAddIndication->sfActiveSet.u8TypeOfDataDeliveryService);
1555 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16SDUInterArrivalTime : 0x%X",
1556 pstAddIndication->sfActiveSet.u16SDUInterArrivalTime);
1557 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16TimeBase : 0x%X",
1558 pstAddIndication->sfActiveSet.u16TimeBase);
1559 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8PagingPreference : 0x%X",
1560 pstAddIndication->sfActiveSet.u8PagingPreference);
1561#if 0
1562 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " MBSZoneIdentifierassignmentLength : 0x%X",
1563 pstAddIndication->sfActiveSet.MBSZoneIdentifierassignmentLength);
1564 for(uiLoopIndex=0; uiLoopIndex < MAX_STRING_LEN; uiLoopIndex++)
1565 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " MBSZoneIdentifierassignment : 0x%X",
1566 pstAddIndication->sfActiveSet.MBSZoneIdentifierassignment[uiLoopIndex]);
1567#endif
1568
1569
1570 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8TrafficIndicationPreference : 0x%X",
1571 pstAddIndication->sfActiveSet.u8TrafficIndicationPreference);
1572
1573 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " Total Classifiers Recieved : 0x%X",pstAddIndication->sfActiveSet.u8TotalClassifiers);
1574
1575 nCurClassifierCnt = pstAddIndication->sfActiveSet.u8TotalClassifiers;
1576
1577 if(nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF)
1578 {
1579 nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF;
1580 }
1581
1582 for(nIndex = 0 ; nIndex < nCurClassifierCnt ; nIndex++)
1583 {
1584
1585 stConvergenceSLTypes *psfCSType = NULL;
1586 psfCSType = &pstAddIndication->sfActiveSet.cConvergenceSLTypes[nIndex];
1587
1588
1589 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " CCPacketClassificationRuleSI====>");
1590
1591 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8ClassifierRulePriority :0x%X ",
1592 psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority);
1593 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8IPTypeOfServiceLength :0x%X ",
1594 psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength);
1595
1596 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8IPTypeOfService[3] :0x%X ,0x%X ,0x%X ",
1597 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[0],
1598 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[1],
1599 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[2]);
1600#if 0
1601
1602 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " u8ProtocolLength :0x%X ",
1603 psfCSType->cCPacketClassificationRule.u8ProtocolLength);
1604#endif
1605 for(uiLoopIndex=0; uiLoopIndex < 1; uiLoopIndex++)
1606 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8Protocol : 0x%X ",
1607 psfCSType->cCPacketClassificationRule.u8Protocol);
1608
1609 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPMaskedSourceAddressLength :0x%X ",
1610 psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddressLength);
1611
1612 for(uiLoopIndex=0; uiLoopIndex < 32; uiLoopIndex++)
1613 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPMaskedSourceAddress[32]:0x%X ",
1614 psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddress[uiLoopIndex]);
1615
1616 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8IPDestinationAddressLength : 0x%02X ",
1617 psfCSType->cCPacketClassificationRule.u8IPDestinationAddressLength);
1618
1619 for(uiLoopIndex=0;uiLoopIndex<32;uiLoopIndex++)
1620 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8IPDestinationAddress[32]:0x%X ",
1621 psfCSType->cCPacketClassificationRule.u8IPDestinationAddress[uiLoopIndex]);
1622
1623 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8ProtocolSourcePortRangeLength:0x%X ",
1624 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength);
1625
1626 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8ProtocolSourcePortRange[4]:0x%X ,0x%X ,0x%X ,0x%X ",
1627 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[0],
1628 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[1],
1629 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[2],
1630 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[3]);
1631
1632 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8ProtocolDestPortRangeLength:0x%X ",
1633 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength);
1634
1635 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8ProtocolDestPortRange[4]:0x%X ,0x%X ,0x%X ,0x%X ",
1636 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[0],
1637 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[1],
1638 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[2],
1639 psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[3]);
1640
1641 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8EthernetDestMacAddressLength:0x%X ",
1642 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1643
1644 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8EthernetDestMacAddress[6]:0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X",
1645 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[0],
1646 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[1],
1647 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[2],
1648 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[3],
1649 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[4],
1650 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[5]);
1651
1652 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8EthernetSourceMACAddressLength:0x%X ",
1653 psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1654
1655 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8EthernetSourceMACAddress[6]:0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X",
1656 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[0],
1657 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[1],
1658 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[2],
1659 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[3],
1660 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[4],
1661 psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[5]);
1662
1663 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8EthertypeLength :0x%X ",
1664 psfCSType->cCPacketClassificationRule.u8EthertypeLength);
1665 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8Ethertype[3] :0x%X ,0x%X ,0x%X ",
1666 psfCSType->cCPacketClassificationRule.u8Ethertype[0],
1667 psfCSType->cCPacketClassificationRule.u8Ethertype[1],
1668 psfCSType->cCPacketClassificationRule.u8Ethertype[2]);
1669 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16UserPriority :0x%X ",
1670 psfCSType->cCPacketClassificationRule.u16UserPriority);
1671 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16VLANID :0x%X ",
1672 psfCSType->cCPacketClassificationRule.u16VLANID);
1673 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8AssociatedPHSI :0x%X ",
1674 psfCSType->cCPacketClassificationRule.u8AssociatedPHSI);
1675 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u16PacketClassificationRuleIndex:0x%X ",
1676 psfCSType->cCPacketClassificationRule.u16PacketClassificationRuleIndex);
1677
1678 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8VendorSpecificClassifierParamLength:0x%X ",
1679 psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParamLength);
1680 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8VendorSpecificClassifierParam[1]:0x%X ",
1681 psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParam[0]);
1682#ifdef VERSION_D5
1683 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8IPv6FlowLableLength :0x%X ",
1684 psfCSType->cCPacketClassificationRule.u8IPv6FlowLableLength);
1685 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " u8IPv6FlowLable[6] :0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X ",
1686 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[0],
1687 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[1],
1688 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[2],
1689 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[3],
1690 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[4],
1691 psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[5]);
1692#endif
1693 }
1694
1695 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " bValid : 0x%X",pstAddIndication->sfActiveSet.bValid);
1696
1697}
1698
1699static inline ULONG RestoreSFParam(PMINI_ADAPTER Adapter, ULONG ulAddrSFParamSet,PUCHAR pucDestBuffer)
1700{
1701 UINT nBytesToRead = sizeof(stServiceFlowParamSI);
1702
1703 if(ulAddrSFParamSet == 0 || NULL == pucDestBuffer)
1704 {
1705 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Got Param address as 0!!");
1706 return 0;
1707 }
1708 ulAddrSFParamSet = ntohl(ulAddrSFParamSet);
3e8acee4 1709 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " RestoreSFParam: Total Words of DSX Message To Read: 0x%zx From Target At : 0x%lx ",
f8942e07 1710 nBytesToRead/sizeof(ULONG),ulAddrSFParamSet);
3e8acee4 1711 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "sizeof(stServiceFlowParamSI) = %zx", sizeof(stServiceFlowParamSI));
f8942e07
SH		 1712
1713 //Read out the SF Param Set At the indicated Location
1714 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "nBytesToRead = %x", nBytesToRead);
1715 if(rdm(Adapter, ulAddrSFParamSet, (PUCHAR)pucDestBuffer, nBytesToRead) < 0)
1716 return STATUS_FAILURE;
1717
1718 return 1;
1719}
1720
1721
1722static __inline ULONG StoreSFParam(PMINI_ADAPTER Adapter,PUCHAR pucSrcBuffer,ULONG ulAddrSFParamSet)
1723{
1724 UINT nBytesToWrite = sizeof(stServiceFlowParamSI);
1725 UINT uiRetVal =0;
1726
1727 if(ulAddrSFParamSet == 0 || NULL == pucSrcBuffer)
1728 {
1729 return 0;
1730 }
3e8acee4 1731 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " StoreSFParam: Total Words of DSX Message To Write: 0x%zX To Target At : 0x%lX ",(nBytesToWrite/sizeof(ULONG)),ulAddrSFParamSet);
f8942e07
SH		 1732
1733 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "WRM with %x bytes",nBytesToWrite);
1734
1735 uiRetVal = wrm(Adapter,ulAddrSFParamSet,(PUCHAR)pucSrcBuffer, nBytesToWrite);
1736 if(uiRetVal < 0) {
1737 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "%s:%d WRM failed",__FUNCTION__, __LINE__);
1738 return uiRetVal;
1739 }
1740 return 1;
1741}
1742
1743ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer,UINT *puBufferLength)
1744{
1745 stLocalSFAddIndicationAlt *pstAddIndicationAlt = NULL;
1746 stLocalSFAddIndication * pstAddIndication = NULL;
1747 stLocalSFDeleteRequest *pstDeletionRequest;
1748 UINT uiSearchRuleIndex;
1749 ULONG ulSFID;
1750
1751 pstAddIndicationAlt = (stLocalSFAddIndicationAlt *)(pvBuffer);
1752
1753 /*
1754 * In case of DSD Req By MS, we should immediately delete this SF so that
1755 * we can stop the further classifying the pkt for this SF.
1756 */
1757 if(pstAddIndicationAlt->u8Type == DSD_REQ)
1758 {
1759 pstDeletionRequest = (stLocalSFDeleteRequest *)pvBuffer;
1760
1761 ulSFID = ntohl(pstDeletionRequest->u32SFID);
1762 uiSearchRuleIndex=SearchSfid(Adapter,ulSFID);
1763
1764 if(uiSearchRuleIndex < NO_OF_QUEUES)
1765 {
1766 deleteSFBySfid(Adapter,uiSearchRuleIndex);
1767 Adapter->u32TotalDSD++;
1768 }
1769 return 1;
1770 }
1771
1772
1773 if( (pstAddIndicationAlt->u8Type == DSD_RSP) ||
1774 (pstAddIndicationAlt->u8Type == DSD_ACK))
1775 {
1776 //No Special handling send the message as it is
1777 return 1;
1778 }
1779 // For DSA_REQ, only upto "psfAuthorizedSet" parameter should be accessed by driver!
1780
1781 pstAddIndication=(stLocalSFAddIndication *)kmalloc(sizeof(*pstAddIndication), GFP_KERNEL);
1782 if(NULL==pstAddIndication)
1783 return 0;
1784
1785 /* AUTHORIZED SET */
1786 pstAddIndication->psfAuthorizedSet = (stServiceFlowParamSI *)
1787 GetNextTargetBufferLocation(Adapter, pstAddIndicationAlt->u16TID);
1788 if(!pstAddIndication->psfAuthorizedSet)
1789 return 0;
1790
1791 if(StoreSFParam(Adapter,(PUCHAR)&pstAddIndicationAlt->sfAuthorizedSet,
1792 (ULONG)pstAddIndication->psfAuthorizedSet)!= 1)
1793 return 0;
1794
9f1c75ac
AB		 1795 /* this can't possibly be right */
1796 pstAddIndication->psfAuthorizedSet = (stServiceFlowParamSI *)ntohl((ULONG)pstAddIndication->psfAuthorizedSet);
f8942e07
SH		 1797
1798 if(pstAddIndicationAlt->u8Type == DSA_REQ)
1799 {
1800 stLocalSFAddRequest AddRequest;
1801
1802 AddRequest.u8Type = pstAddIndicationAlt->u8Type;
1803 AddRequest.eConnectionDir = pstAddIndicationAlt->u8Direction;
1804 AddRequest.u16TID = pstAddIndicationAlt->u16TID;
1805 AddRequest.u16CID = pstAddIndicationAlt->u16CID;
1806 AddRequest.u16VCID = pstAddIndicationAlt->u16VCID;
1807 AddRequest.psfParameterSet =pstAddIndication->psfAuthorizedSet ;
1808 (*puBufferLength) = sizeof(stLocalSFAddRequest);
1809 memcpy(pvBuffer,&AddRequest,sizeof(stLocalSFAddRequest));
1810 return 1;
1811 }
1812
1813 // Since it's not DSA_REQ, we can access all field in pstAddIndicationAlt
1814
1815 //We need to extract the structure from the buffer and pack it differently
1816
1817 pstAddIndication->u8Type = pstAddIndicationAlt->u8Type;
1818 pstAddIndication->eConnectionDir= pstAddIndicationAlt->u8Direction ;
1819 pstAddIndication->u16TID = pstAddIndicationAlt->u16TID;
1820 pstAddIndication->u16CID = pstAddIndicationAlt->u16CID;
1821 pstAddIndication->u16VCID = pstAddIndicationAlt->u16VCID;
1822 pstAddIndication->u8CC = pstAddIndicationAlt->u8CC;
1823
1824 /* ADMITTED SET */
1825 pstAddIndication->psfAdmittedSet = (stServiceFlowParamSI *)
1826 GetNextTargetBufferLocation(Adapter, pstAddIndicationAlt->u16TID);
1827 if(!pstAddIndication->psfAdmittedSet)
1828 return 0;
1829 if(StoreSFParam(Adapter,(PUCHAR)&pstAddIndicationAlt->sfAdmittedSet,(ULONG)pstAddIndication->psfAdmittedSet) != 1)
1830 return 0;
1831
1832 pstAddIndication->psfAdmittedSet = (stServiceFlowParamSI *)ntohl((ULONG)pstAddIndication->psfAdmittedSet);
1833
1834
1835 /* ACTIVE SET */
1836 pstAddIndication->psfActiveSet = (stServiceFlowParamSI *)
1837 GetNextTargetBufferLocation(Adapter, pstAddIndicationAlt->u16TID);
1838 if(!pstAddIndication->psfActiveSet)
1839 return 0;
1840 if(StoreSFParam(Adapter,(PUCHAR)&pstAddIndicationAlt->sfActiveSet,(ULONG)pstAddIndication->psfActiveSet) != 1)
1841 return 0;
1842
1843 pstAddIndication->psfActiveSet = (stServiceFlowParamSI *)ntohl((ULONG)pstAddIndication->psfActiveSet);
1844
1845 (*puBufferLength) = sizeof(stLocalSFAddIndication);
1846 *(stLocalSFAddIndication *)pvBuffer = *pstAddIndication;
1847 bcm_kfree(pstAddIndication);
1848 return 1;
1849}
1850
1851
1852static inline stLocalSFAddIndicationAlt
1853*RestoreCmControlResponseMessage(register PMINI_ADAPTER Adapter,register PVOID pvBuffer)
1854{
1855 ULONG ulStatus=0;
1856 stLocalSFAddIndication *pstAddIndication = NULL;
1857 stLocalSFAddIndicationAlt *pstAddIndicationDest = NULL;
1858 pstAddIndication = (stLocalSFAddIndication *)(pvBuffer);
1859
1860 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "=====>" );
1861 if ((pstAddIndication->u8Type == DSD_REQ) ||
1862 (pstAddIndication->u8Type == DSD_RSP) ||
1863 (pstAddIndication->u8Type == DSD_ACK))
1864 {
1865 return (stLocalSFAddIndicationAlt *)pvBuffer;
1866 }
1867
1868 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Inside RestoreCmControlResponseMessage ");
1869 /*
1870 //Need to Allocate memory to contain the SUPER Large structures
1871 //Our driver cant create these structures on Stack :(
1872 */
1873 pstAddIndicationDest=kmalloc(sizeof(stLocalSFAddIndicationAlt), GFP_KERNEL);
1874
1875 if(pstAddIndicationDest)
1876 {
1877 memset(pstAddIndicationDest,0,sizeof(stLocalSFAddIndicationAlt));
1878 }
1879 else
1880 {
1881 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Failed to allocate memory for SF Add Indication Structure ");
1882 return NULL;
1883 }
1884 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "AddIndication-u8Type : 0x%X",pstAddIndication->u8Type);
1885 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "AddIndication-u8Direction : 0x%X",pstAddIndication->eConnectionDir);
1886 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "AddIndication-u8TID : 0x%X",ntohs(pstAddIndication->u16TID));
1887 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "AddIndication-u8CID : 0x%X",ntohs(pstAddIndication->u16CID));
1888 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "AddIndication-u16VCID : 0x%X",ntohs(pstAddIndication->u16VCID));
9f1c75ac
AB		 1889 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "AddIndication-autorized set loc : %p",pstAddIndication->psfAuthorizedSet);
1890 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "AddIndication-admitted set loc : %p",pstAddIndication->psfAdmittedSet);
1891 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "AddIndication-Active set loc : %p",pstAddIndication->psfActiveSet);
f8942e07
SH		 1892
1893 pstAddIndicationDest->u8Type = pstAddIndication->u8Type;
1894 pstAddIndicationDest->u8Direction = pstAddIndication->eConnectionDir;
1895 pstAddIndicationDest->u16TID = pstAddIndication->u16TID;
1896 pstAddIndicationDest->u16CID = pstAddIndication->u16CID;
1897 pstAddIndicationDest->u16VCID = pstAddIndication->u16VCID;
1898 pstAddIndicationDest->u8CC = pstAddIndication->u8CC;
1899
1900 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Restoring Active Set ");
1901 ulStatus=RestoreSFParam(Adapter,(ULONG)pstAddIndication->psfActiveSet, (PUCHAR)&pstAddIndicationDest->sfActiveSet);
1902 if(ulStatus != 1)
1903 {
1904 goto failed_restore_sf_param;
1905 }
1906 if(pstAddIndicationDest->sfActiveSet.u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF)
1907 pstAddIndicationDest->sfActiveSet.u8TotalClassifiers = MAX_CLASSIFIERS_IN_SF;
1908
1909 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Restoring Admitted Set ");
1910 ulStatus=RestoreSFParam(Adapter,(ULONG)pstAddIndication->psfAdmittedSet,(PUCHAR)&pstAddIndicationDest->sfAdmittedSet);
1911 if(ulStatus != 1)
1912 {
1913 goto failed_restore_sf_param;
1914 }
1915 if(pstAddIndicationDest->sfAdmittedSet.u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF)
1916 pstAddIndicationDest->sfAdmittedSet.u8TotalClassifiers = MAX_CLASSIFIERS_IN_SF;
1917
1918 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Restoring Authorized Set ");
1919 ulStatus=RestoreSFParam(Adapter,(ULONG)pstAddIndication->psfAuthorizedSet,(PUCHAR)&pstAddIndicationDest->sfAuthorizedSet);
1920 if(ulStatus != 1)
1921 {
1922 goto failed_restore_sf_param;
1923 }
1924 if(pstAddIndicationDest->sfAuthorizedSet.u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF)
1925 pstAddIndicationDest->sfAuthorizedSet.u8TotalClassifiers = MAX_CLASSIFIERS_IN_SF;
1926
1927 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Dumping the whole raw packet");
1928 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "============================================================");
3e8acee4 1929 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " pstAddIndicationDest->sfActiveSet size %zx %p", sizeof(*pstAddIndicationDest), pstAddIndicationDest);
f8942e07
SH		 1930 //BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, (unsigned char *)pstAddIndicationDest, sizeof(*pstAddIndicationDest));
1931 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "============================================================");
1932 return pstAddIndicationDest;
1933failed_restore_sf_param:
1934 bcm_kfree(pstAddIndicationDest);
1935 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "<=====" );
1936 return NULL;
1937}
1938
1939ULONG SetUpTargetDsxBuffers(PMINI_ADAPTER Adapter)
1940{
1941 ULONG ulTargetDsxBuffersBase = 0;
1942 ULONG ulCntTargetBuffers;
1943 ULONG ulIndex=0;
1944 int Status;
1945
acedadfa
DC		 1946 if (!Adapter) {
1947 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Adapter was NULL!!!");
1948 return 0;
1949 }
1950
f8942e07
SH		 1951 if(Adapter->astTargetDsxBuffer[0].ulTargetDsxBuffer)
1952 return 1;
1953
3e8acee4 1954 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Size of Each DSX Buffer(Also size of ServiceFlowParamSI): %zx ",sizeof(stServiceFlowParamSI));
f8942e07
SH		 1955 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Reading DSX buffer From Target location %x ",DSX_MESSAGE_EXCHANGE_BUFFER);
1956
1957 Status = rdmalt(Adapter, DSX_MESSAGE_EXCHANGE_BUFFER,
1958 (PUINT)&ulTargetDsxBuffersBase, sizeof(UINT));
1959 if(Status < 0)
1960 {
1961 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "RDM failed!!");
1962 return 0;
1963 }
1964
1965 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Base Address Of DSX Target Buffer : 0x%lx",ulTargetDsxBuffersBase);
1966
1967 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Tgt Buffer is Now %lx :",ulTargetDsxBuffersBase);
1968
1969 ulCntTargetBuffers = DSX_MESSAGE_EXCHANGE_BUFFER_SIZE/sizeof(stServiceFlowParamSI);
1970
1971 Adapter->ulTotalTargetBuffersAvailable =
1972 ulCntTargetBuffers > MAX_TARGET_DSX_BUFFERS ?
1973 MAX_TARGET_DSX_BUFFERS : ulCntTargetBuffers;
1974
1975 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " Total Target DSX Buffer setup %lx ",Adapter->ulTotalTargetBuffersAvailable);
1976
1977 for(ulIndex=0; ulIndex < Adapter->ulTotalTargetBuffersAvailable ; ulIndex++)
1978 {
1979 Adapter->astTargetDsxBuffer[ulIndex].ulTargetDsxBuffer = ulTargetDsxBuffersBase;
1980 Adapter->astTargetDsxBuffer[ulIndex].valid=1;
1981 Adapter->astTargetDsxBuffer[ulIndex].tid=0;
1982 ulTargetDsxBuffersBase+=sizeof(stServiceFlowParamSI);
1983 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " Target DSX Buffer %lx setup at 0x%lx",
1984 ulIndex, Adapter->astTargetDsxBuffer[ulIndex].ulTargetDsxBuffer);
1985 }
1986 Adapter->ulCurrentTargetBuffer = 0;
1987 Adapter->ulFreeTargetBufferCnt = Adapter->ulTotalTargetBuffersAvailable;
1988 return 1;
1989}
1990
1991ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter,B_UINT16 tid)
1992{
1993 ULONG ulTargetDSXBufferAddress;
1994 ULONG ulTargetDsxBufferIndexToUse,ulMaxTry;
1995
1996 if((Adapter->ulTotalTargetBuffersAvailable == 0)||
1997 (Adapter->ulFreeTargetBufferCnt == 0))
1998 {
1999 ClearTargetDSXBuffer(Adapter,tid,FALSE);
2000 return 0;
2001 }
2002
2003 ulTargetDsxBufferIndexToUse = Adapter->ulCurrentTargetBuffer;
2004 ulMaxTry = Adapter->ulTotalTargetBuffersAvailable;
2005 while((ulMaxTry)&&(Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].valid != 1))
2006 {
2007 ulTargetDsxBufferIndexToUse = (ulTargetDsxBufferIndexToUse+1)%
2008 Adapter->ulTotalTargetBuffersAvailable;
2009 ulMaxTry--;
2010 }
2011
2012 if(ulMaxTry==0)
2013 {
2014 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "\n GetNextTargetBufferLocation : Error No Free Target DSX Buffers FreeCnt : %lx ",Adapter->ulFreeTargetBufferCnt);
2015 ClearTargetDSXBuffer(Adapter,tid,FALSE);
2016 return 0;
2017 }
2018
2019
2020 ulTargetDSXBufferAddress =
2021 Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].ulTargetDsxBuffer;
2022 Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].valid=0;
2023 Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].tid=tid;
2024 Adapter->ulFreeTargetBufferCnt--;
2025
2026
2027 ulTargetDsxBufferIndexToUse =
2028 (ulTargetDsxBufferIndexToUse+1)%Adapter->ulTotalTargetBuffersAvailable;
2029 Adapter->ulCurrentTargetBuffer = ulTargetDsxBufferIndexToUse;
2030 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "GetNextTargetBufferLocation :Returning address %lx tid %d\n",
2031 ulTargetDSXBufferAddress,tid);
2032 return ulTargetDSXBufferAddress;
2033}
2034
2035
2036INT AllocAdapterDsxBuffer(PMINI_ADAPTER Adapter)
2037{
2038 /*
2039 //Need to Allocate memory to contain the SUPER Large structures
2040 //Our driver cant create these structures on Stack
2041 */
2042 Adapter->caDsxReqResp=kmalloc(sizeof(stLocalSFAddIndicationAlt)+LEADER_SIZE, GFP_KERNEL);
2043 if(!Adapter->caDsxReqResp)
2044 return -ENOMEM;
2045 return 0;
2046}
2047
2048INT FreeAdapterDsxBuffer(PMINI_ADAPTER Adapter)
2049{
2050 if(Adapter->caDsxReqResp)
2051 {
2052 bcm_kfree(Adapter->caDsxReqResp);
2053 }
2054 return 0;
2055
2056}
2057/**
2058@ingroup ctrl_pkt_functions
2059This routinue would process the Control responses
2060for the Connection Management.
2061@return - Queue index for the free SFID else returns Invalid Index.
2062*/
2063BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter, /**<Pointer to the Adapter structure*/
2064 PVOID pvBuffer /**Starting Address of the Buffer, that contains the AddIndication Data*/
2065 )
2066{
2067 stServiceFlowParamSI *psfLocalSet=NULL;
2068 stLocalSFAddIndicationAlt *pstAddIndication = NULL;
2069 stLocalSFChangeIndicationAlt *pstChangeIndication = NULL;
2070 PLEADER pLeader=NULL;
2071 /*
2072 //Otherwise the message contains a target address from where we need to
2073 //read out the rest of the service flow param structure
2074 */
2075 if((pstAddIndication = RestoreCmControlResponseMessage(Adapter,pvBuffer))
2076 == NULL)
2077 {
2078 ClearTargetDSXBuffer(Adapter,((stLocalSFAddIndication *)pvBuffer)->u16TID, FALSE);
2079 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "Error in restoring Service Flow param structure from DSx message");
2080 return FALSE;
2081 }
2082
2083 DumpCmControlPacket(pstAddIndication);
2084 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "====>");
2085 pLeader = (PLEADER)Adapter->caDsxReqResp;
2086
2087 pLeader->Status =CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ;
2088 pLeader->Vcid = 0;
2089
2090 ClearTargetDSXBuffer(Adapter,pstAddIndication->u16TID,FALSE);
2091 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "### TID RECEIVED %d\n",pstAddIndication->u16TID);
2092 switch(pstAddIndication->u8Type)
2093 {
2094 case DSA_REQ:
2095 {
2096 pLeader->PLength = sizeof(stLocalSFAddIndicationAlt);
2097 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Sending DSA Response....\n");
2098 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSA RESPONSE TO MAC %d", pLeader->PLength );
2099 *((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))
2100 = *pstAddIndication;
2101 ((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSA_RSP;
2102
2103 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " VCID = %x", ntohs(pstAddIndication->u16VCID));
2104 CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
2105 bcm_kfree(pstAddIndication);
2106 }
2107 break;
2108 case DSA_RSP:
2109 {
2110 pLeader->PLength = sizeof(stLocalSFAddIndicationAlt);
2111 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSA ACK TO MAC %d",
2112 pLeader->PLength);
2113 *((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))
2114 = *pstAddIndication;
2115 ((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSA_ACK;
2116
2117 }//no break here..we should go down.
2118 case DSA_ACK:
2119 {
2120 UINT uiSearchRuleIndex=0;
2121 struct timeval tv = {0};
2122 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "VCID:0x%X",
2123 ntohs(pstAddIndication->u16VCID));
2124 uiSearchRuleIndex=SearchFreeSfid(Adapter);
2125 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"uiSearchRuleIndex:0x%X ",
2126 uiSearchRuleIndex);
2127 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Direction:0x%X ",
2128 pstAddIndication->u8Direction);
2129 if((uiSearchRuleIndex< NO_OF_QUEUES) )
2130 {
2131 Adapter->PackInfo[uiSearchRuleIndex].ucDirection =
2132 pstAddIndication->u8Direction;
2133 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "bValid:0x%X ",
2134 pstAddIndication->sfActiveSet.bValid);
2135 if(pstAddIndication->sfActiveSet.bValid==TRUE)
2136 {
2137 Adapter->PackInfo[uiSearchRuleIndex].bActiveSet=TRUE;
2138 }
2139 if(pstAddIndication->sfAuthorizedSet.bValid==TRUE)
2140 {
2141 Adapter->PackInfo[uiSearchRuleIndex].bAuthorizedSet=TRUE;
2142 }
2143 if(pstAddIndication->sfAdmittedSet.bValid==TRUE)
2144 {
2145 Adapter->PackInfo[uiSearchRuleIndex].bAdmittedSet=TRUE;
2146 }
2147 if(FALSE == pstAddIndication->sfActiveSet.bValid)
2148 {
2149 Adapter->PackInfo[uiSearchRuleIndex].bActive = FALSE;
2150 Adapter->PackInfo[uiSearchRuleIndex].bActivateRequestSent = FALSE;
2151 if(pstAddIndication->sfAdmittedSet.bValid)
2152 {
2153 psfLocalSet = &pstAddIndication->sfAdmittedSet;
2154 }
2155 else if(pstAddIndication->sfAuthorizedSet.bValid)
2156 {
2157 psfLocalSet = &pstAddIndication->sfAuthorizedSet;
2158 }
2159 }
2160 else
2161 {
2162 psfLocalSet = &pstAddIndication->sfActiveSet;
2163 Adapter->PackInfo[uiSearchRuleIndex].bActive=TRUE;
2164 }
2165
2166 if(!psfLocalSet)
2167 {
2168 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "No set is valid\n");
2169 Adapter->PackInfo[uiSearchRuleIndex].bActive=FALSE;
2170 Adapter->PackInfo[uiSearchRuleIndex].bValid=FALSE;
2171 Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value=0;
2172 bcm_kfree(pstAddIndication);
2173 }
2174
2175 else if(psfLocalSet->bValid && (pstAddIndication->u8CC == 0))
2176 {
2177 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "DSA ACK");
2178 Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value =
2179 ntohs(pstAddIndication->u16VCID);
2180 Adapter->PackInfo[uiSearchRuleIndex].usCID =
2181 ntohs(pstAddIndication->u16CID);
2182
2183 if(UPLINK_DIR == pstAddIndication->u8Direction)
2184 atomic_set(&Adapter->PackInfo[uiSearchRuleIndex].uiPerSFTxResourceCount, DEFAULT_PERSFCOUNT);
2185 CopyToAdapter(Adapter,psfLocalSet,uiSearchRuleIndex,
2186 DSA_ACK, pstAddIndication);
2187 // don't free pstAddIndication
2188
2189 /* Inside CopyToAdapter, Sorting of all the SFs take place.
2190 Hence any access to the newly added SF through uiSearchRuleIndex is invalid.
2191 SHOULD BE STRICTLY AVOIDED.
2192 */
2193// *(PULONG)(((PUCHAR)pvBuffer)+1)=psfLocalSet->u32SFID;
2194 memcpy((((PUCHAR)pvBuffer)+1), &psfLocalSet->u32SFID, 4);
2195
2196 if(pstAddIndication->sfActiveSet.bValid == TRUE)
2197 {
2198 if(UPLINK_DIR == pstAddIndication->u8Direction)
2199 {
2200 if(!Adapter->LinkUpStatus)
2201 {
2202 netif_carrier_on(Adapter->dev);
2203 netif_start_queue(Adapter->dev);
2204 Adapter->LinkUpStatus = 1;
2205 do_gettimeofday(&tv);
2206
2207 atomic_set(&Adapter->TxPktAvail, 1);
2208 wake_up(&Adapter->tx_packet_wait_queue);
2209 Adapter->liTimeSinceLastNetEntry = tv.tv_sec;
2210 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "============Tx Service Flow Created!");
2211 }
2212 }
2213 }
2214 }
2215
2216 else
2217 {
2218 Adapter->PackInfo[uiSearchRuleIndex].bActive=FALSE;
2219 Adapter->PackInfo[uiSearchRuleIndex].bValid=FALSE;
2220 Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value=0;
2221 bcm_kfree(pstAddIndication);
2222 }
2223 }
2224 else
2225 {
2226 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "DSA ACK did not get valid SFID");
2227 bcm_kfree(pstAddIndication);
2228 return FALSE;
2229 }
2230 }
2231 break;
2232 case DSC_REQ:
2233 {
2234 pLeader->PLength = sizeof(stLocalSFChangeIndicationAlt);
2235 pstChangeIndication = (stLocalSFChangeIndicationAlt*)pstAddIndication;
2236 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSC RESPONSE TO MAC %d", pLeader->PLength);
2237
2238 *((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *pstChangeIndication;
2239 ((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSC_RSP;
2240
2241 CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
2242 bcm_kfree(pstAddIndication);
2243 }
2244 break;
2245 case DSC_RSP:
2246 {
2247 pLeader->PLength = sizeof(stLocalSFChangeIndicationAlt);
2248 pstChangeIndication = (stLocalSFChangeIndicationAlt*)pstAddIndication;
2249 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSC ACK TO MAC %d", pLeader->PLength);
2250 *((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *pstChangeIndication;
2251 ((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSC_ACK;
2252 }
2253 case DSC_ACK:
2254 {
2255 UINT uiSearchRuleIndex=0;
2256
2257 pstChangeIndication = (stLocalSFChangeIndicationAlt *)pstAddIndication;
2258 uiSearchRuleIndex=SearchSfid(Adapter,ntohl(pstChangeIndication->sfActiveSet.u32SFID));
2259 if(uiSearchRuleIndex > NO_OF_QUEUES-1)
2260 {
2261 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "SF doesn't exist for which DSC_ACK is received");
2262 }
2263 if((uiSearchRuleIndex < NO_OF_QUEUES))
2264 {
2265 Adapter->PackInfo[uiSearchRuleIndex].ucDirection = pstChangeIndication->u8Direction;
2266 if(pstChangeIndication->sfActiveSet.bValid==TRUE)
2267 {
2268 Adapter->PackInfo[uiSearchRuleIndex].bActiveSet=TRUE;
2269 }
2270 if(pstChangeIndication->sfAuthorizedSet.bValid==TRUE)
2271 {
2272 Adapter->PackInfo[uiSearchRuleIndex].bAuthorizedSet=TRUE;
2273 }
2274 if(pstChangeIndication->sfAdmittedSet.bValid==TRUE)
2275 {
2276 Adapter->PackInfo[uiSearchRuleIndex].bAdmittedSet=TRUE;
2277 }
2278
2279 if(FALSE==pstChangeIndication->sfActiveSet.bValid)
2280 {
2281 Adapter->PackInfo[uiSearchRuleIndex].bActive = FALSE;
2282 Adapter->PackInfo[uiSearchRuleIndex].bActivateRequestSent = FALSE;
2283 if(pstChangeIndication->sfAdmittedSet.bValid)
2284 {
2285 psfLocalSet = &pstChangeIndication->sfAdmittedSet;
2286 }
2287 else if(pstChangeIndication->sfAuthorizedSet.bValid)
2288 {
2289 psfLocalSet = &pstChangeIndication->sfAuthorizedSet;
2290 }
2291 }
2292
2293 else
2294 {
2295 psfLocalSet = &pstChangeIndication->sfActiveSet;
2296 Adapter->PackInfo[uiSearchRuleIndex].bActive=TRUE;
2297 }
2298 if(psfLocalSet->bValid && (pstChangeIndication->u8CC == 0))
2299 {
2300 Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value =
2301 ntohs(pstChangeIndication->u16VCID);
2302 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "CC field is %d bvalid = %d\n",
2303 pstChangeIndication->u8CC, psfLocalSet->bValid);
2304 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "VCID= %d\n", ntohs(pstChangeIndication->u16VCID));
2305 Adapter->PackInfo[uiSearchRuleIndex].usCID =
2306 ntohs(pstChangeIndication->u16CID);
2307 CopyToAdapter(Adapter,psfLocalSet,uiSearchRuleIndex,
2308 DSC_ACK, pstAddIndication);
2309
2310 *(PULONG)(((PUCHAR)pvBuffer)+1)=psfLocalSet->u32SFID;
2311 }
2312 else if(pstChangeIndication->u8CC == 6)
2313 {
2314 deleteSFBySfid(Adapter,uiSearchRuleIndex);
2315 bcm_kfree(pstAddIndication);
2316 }
2317 }
2318 else
2319 {
2320 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "DSC ACK did not get valid SFID");
2321 bcm_kfree(pstAddIndication);
2322 return FALSE;
2323 }
2324 }
2325 break;
2326 case DSD_REQ:
2327 {
2328 UINT uiSearchRuleIndex;
2329 ULONG ulSFID;
2330
2331 pLeader->PLength = sizeof(stLocalSFDeleteIndication);
2332 *((stLocalSFDeleteIndication*)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *((stLocalSFDeleteIndication*)pstAddIndication);
2333
2334 ulSFID = ntohl(((stLocalSFDeleteIndication*)pstAddIndication)->u32SFID);
2335 uiSearchRuleIndex=SearchSfid(Adapter,ulSFID);
2336 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "DSD - Removing connection %x",uiSearchRuleIndex);
2337
2338 if(uiSearchRuleIndex < NO_OF_QUEUES)
2339 {
2340 //Delete All Classifiers Associated with this SFID
2341 deleteSFBySfid(Adapter,uiSearchRuleIndex);
2342 Adapter->u32TotalDSD++;
2343 }
2344
2345 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSD RESPONSE TO MAC");
2346 ((stLocalSFDeleteIndication*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSD_RSP;
2347 CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
2348 }
2349 case DSD_RSP:
2350 {
2351 //Do nothing as SF has already got Deleted
2352 }
2353 break;
2354 case DSD_ACK:
2355 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "DSD ACK Rcd, let App handle it\n");
2356 break;
2357 default:
2358 bcm_kfree(pstAddIndication);
2359 return FALSE ;
2360 }
2361 return TRUE;
2362}
2363
44a17eff 2364int get_dsx_sf_data_to_application(PMINI_ADAPTER Adapter, UINT uiSFId, void __user *user_buffer)
f8942e07
SH		 2365{
2366 int status = 0;
2367 struct _packet_info *psSfInfo=NULL;
2368 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "status =%d",status);
2369 status = SearchSfid(Adapter, uiSFId);
2370 if(status>NO_OF_QUEUES)
2371 {
2372 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SFID %d not present in queue !!!", uiSFId );
2373 return -EINVAL;
2374 }
2375 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "status =%d",status);
2376 psSfInfo=&Adapter->PackInfo[status];
44a17eff
AB		 2377 if(psSfInfo->pstSFIndication && copy_to_user(user_buffer,
2378 psSfInfo->pstSFIndication, sizeof(stLocalSFAddIndicationAlt)))
f8942e07
SH		 2379 {
2380 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy to user failed SFID %d, present in queue !!!", uiSFId );
2381 status = -EFAULT;
2382 return status;
2383 }
2384 return STATUS_SUCCESS;
2385}
2386
2387VOID OverrideServiceFlowParams(PMINI_ADAPTER Adapter,PUINT puiBuffer)
2388{
2389 B_UINT32 u32NumofSFsinMsg = ntohl(*(puiBuffer + 1));
2390 stIM_SFHostNotify *pHostInfo = NULL;
2391 UINT uiSearchRuleIndex = 0;
2392 ULONG ulSFID = 0;
2393
2394 puiBuffer+=2;
2395
2396 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "u32NumofSFsinMsg: 0x%x\n",u32NumofSFsinMsg);
2397
2398 while(u32NumofSFsinMsg != 0 && u32NumofSFsinMsg < NO_OF_QUEUES)
2399 {
2400 u32NumofSFsinMsg--;
2401 pHostInfo = (stIM_SFHostNotify *)puiBuffer;
2402 puiBuffer = (PUINT)(pHostInfo + 1);
2403
2404 ulSFID = ntohl(pHostInfo->SFID);
2405 uiSearchRuleIndex=SearchSfid(Adapter,ulSFID);
2406 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"SFID: 0x%lx\n",ulSFID);
2407
2408 if(uiSearchRuleIndex >= NO_OF_QUEUES || uiSearchRuleIndex == HiPriority)
2409 {
2410 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"The SFID <%lx> doesn't exist in host entry or is Invalid\n", ulSFID);
2411 continue;
2412 }
2413
2414 if(pHostInfo->RetainSF == FALSE)
2415 {
2416 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Going to Delete SF");
2417 deleteSFBySfid(Adapter,uiSearchRuleIndex);
2418 }
2419 else
2420 {
2421
2422 Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value = ntohs(pHostInfo->VCID);
2423 Adapter->PackInfo[uiSearchRuleIndex].usCID = ntohs(pHostInfo->newCID);
2424 Adapter->PackInfo[uiSearchRuleIndex].bActive=FALSE;
2425
2426 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"pHostInfo->QoSParamSet: 0x%x\n",pHostInfo->QoSParamSet);
2427
2428 if(pHostInfo->QoSParamSet & 0x1)
2429 Adapter->PackInfo[uiSearchRuleIndex].bAuthorizedSet =TRUE;
2430 if(pHostInfo->QoSParamSet & 0x2)
2431 Adapter->PackInfo[uiSearchRuleIndex].bAdmittedSet =TRUE;
2432 if(pHostInfo->QoSParamSet & 0x4)
2433 {
2434 Adapter->PackInfo[uiSearchRuleIndex].bActiveSet =TRUE;
2435 Adapter->PackInfo[uiSearchRuleIndex].bActive=TRUE;
2436 }
2437 }
2438 }
2439}
2440
2441
2442
kernel source for telekom puls (alcatel/mediatek)