]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/staging/bcm/CmHost.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
staging/bcm: fix printk format warnings
[net-next-2.6.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*************************************************************************/
1017VOID DumpCmControlPacket(PVOID pvBuffer)
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
1795 pstAddIndication->psfAuthorizedSet = (stServiceFlowParamSI *)
1796 ntohl((ULONG)pstAddIndication->psfAuthorizedSet);
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));
1889 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "AddIndication-autorized set loc : 0x%x",ntohl(pstAddIndication->psfAuthorizedSet));
1890 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "AddIndication-admitted set loc : 0x%x",ntohl(pstAddIndication->psfAdmittedSet));
1891 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "AddIndication-Active set loc : 0x%x",ntohl(pstAddIndication->psfActiveSet));
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
1946 if(Adapter->astTargetDsxBuffer[0].ulTargetDsxBuffer)
1947 return 1;
1948
1949 if(NULL == Adapter)
1950 {
1951 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Adapter was NULL!!!");
1952 return 0;
1953 }
1954
3e8acee4 1955 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		 1956 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Reading DSX buffer From Target location %x ",DSX_MESSAGE_EXCHANGE_BUFFER);
1957
1958 Status = rdmalt(Adapter, DSX_MESSAGE_EXCHANGE_BUFFER,
1959 (PUINT)&ulTargetDsxBuffersBase, sizeof(UINT));
1960 if(Status < 0)
1961 {
1962 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "RDM failed!!");
1963 return 0;
1964 }
1965
1966 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Base Address Of DSX Target Buffer : 0x%lx",ulTargetDsxBuffersBase);
1967
1968 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Tgt Buffer is Now %lx :",ulTargetDsxBuffersBase);
1969
1970 ulCntTargetBuffers = DSX_MESSAGE_EXCHANGE_BUFFER_SIZE/sizeof(stServiceFlowParamSI);
1971
1972 Adapter->ulTotalTargetBuffersAvailable =
1973 ulCntTargetBuffers > MAX_TARGET_DSX_BUFFERS ?
1974 MAX_TARGET_DSX_BUFFERS : ulCntTargetBuffers;
1975
1976 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " Total Target DSX Buffer setup %lx ",Adapter->ulTotalTargetBuffersAvailable);
1977
1978 for(ulIndex=0; ulIndex < Adapter->ulTotalTargetBuffersAvailable ; ulIndex++)
1979 {
1980 Adapter->astTargetDsxBuffer[ulIndex].ulTargetDsxBuffer = ulTargetDsxBuffersBase;
1981 Adapter->astTargetDsxBuffer[ulIndex].valid=1;
1982 Adapter->astTargetDsxBuffer[ulIndex].tid=0;
1983 ulTargetDsxBuffersBase+=sizeof(stServiceFlowParamSI);
1984 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " Target DSX Buffer %lx setup at 0x%lx",
1985 ulIndex, Adapter->astTargetDsxBuffer[ulIndex].ulTargetDsxBuffer);
1986 }
1987 Adapter->ulCurrentTargetBuffer = 0;
1988 Adapter->ulFreeTargetBufferCnt = Adapter->ulTotalTargetBuffersAvailable;
1989 return 1;
1990}
1991
1992ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter,B_UINT16 tid)
1993{
1994 ULONG ulTargetDSXBufferAddress;
1995 ULONG ulTargetDsxBufferIndexToUse,ulMaxTry;
1996
1997 if((Adapter->ulTotalTargetBuffersAvailable == 0)||
1998 (Adapter->ulFreeTargetBufferCnt == 0))
1999 {
2000 ClearTargetDSXBuffer(Adapter,tid,FALSE);
2001 return 0;
2002 }
2003
2004 ulTargetDsxBufferIndexToUse = Adapter->ulCurrentTargetBuffer;
2005 ulMaxTry = Adapter->ulTotalTargetBuffersAvailable;
2006 while((ulMaxTry)&&(Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].valid != 1))
2007 {
2008 ulTargetDsxBufferIndexToUse = (ulTargetDsxBufferIndexToUse+1)%
2009 Adapter->ulTotalTargetBuffersAvailable;
2010 ulMaxTry--;
2011 }
2012
2013 if(ulMaxTry==0)
2014 {
2015 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "\n GetNextTargetBufferLocation : Error No Free Target DSX Buffers FreeCnt : %lx ",Adapter->ulFreeTargetBufferCnt);
2016 ClearTargetDSXBuffer(Adapter,tid,FALSE);
2017 return 0;
2018 }
2019
2020
2021 ulTargetDSXBufferAddress =
2022 Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].ulTargetDsxBuffer;
2023 Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].valid=0;
2024 Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].tid=tid;
2025 Adapter->ulFreeTargetBufferCnt--;
2026
2027
2028 ulTargetDsxBufferIndexToUse =
2029 (ulTargetDsxBufferIndexToUse+1)%Adapter->ulTotalTargetBuffersAvailable;
2030 Adapter->ulCurrentTargetBuffer = ulTargetDsxBufferIndexToUse;
2031 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "GetNextTargetBufferLocation :Returning address %lx tid %d\n",
2032 ulTargetDSXBufferAddress,tid);
2033 return ulTargetDSXBufferAddress;
2034}
2035
2036
2037INT AllocAdapterDsxBuffer(PMINI_ADAPTER Adapter)
2038{
2039 /*
2040 //Need to Allocate memory to contain the SUPER Large structures
2041 //Our driver cant create these structures on Stack
2042 */
2043 Adapter->caDsxReqResp=kmalloc(sizeof(stLocalSFAddIndicationAlt)+LEADER_SIZE, GFP_KERNEL);
2044 if(!Adapter->caDsxReqResp)
2045 return -ENOMEM;
2046 return 0;
2047}
2048
2049INT FreeAdapterDsxBuffer(PMINI_ADAPTER Adapter)
2050{
2051 if(Adapter->caDsxReqResp)
2052 {
2053 bcm_kfree(Adapter->caDsxReqResp);
2054 }
2055 return 0;
2056
2057}
2058/**
2059@ingroup ctrl_pkt_functions
2060This routinue would process the Control responses
2061for the Connection Management.
2062@return - Queue index for the free SFID else returns Invalid Index.
2063*/
2064BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter, /**<Pointer to the Adapter structure*/
2065 PVOID pvBuffer /**Starting Address of the Buffer, that contains the AddIndication Data*/
2066 )
2067{
2068 stServiceFlowParamSI *psfLocalSet=NULL;
2069 stLocalSFAddIndicationAlt *pstAddIndication = NULL;
2070 stLocalSFChangeIndicationAlt *pstChangeIndication = NULL;
2071 PLEADER pLeader=NULL;
2072 /*
2073 //Otherwise the message contains a target address from where we need to
2074 //read out the rest of the service flow param structure
2075 */
2076 if((pstAddIndication = RestoreCmControlResponseMessage(Adapter,pvBuffer))
2077 == NULL)
2078 {
2079 ClearTargetDSXBuffer(Adapter,((stLocalSFAddIndication *)pvBuffer)->u16TID, FALSE);
2080 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "Error in restoring Service Flow param structure from DSx message");
2081 return FALSE;
2082 }
2083
2084 DumpCmControlPacket(pstAddIndication);
2085 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "====>");
2086 pLeader = (PLEADER)Adapter->caDsxReqResp;
2087
2088 pLeader->Status =CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ;
2089 pLeader->Vcid = 0;
2090
2091 ClearTargetDSXBuffer(Adapter,pstAddIndication->u16TID,FALSE);
2092 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "### TID RECEIVED %d\n",pstAddIndication->u16TID);
2093 switch(pstAddIndication->u8Type)
2094 {
2095 case DSA_REQ:
2096 {
2097 pLeader->PLength = sizeof(stLocalSFAddIndicationAlt);
2098 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Sending DSA Response....\n");
2099 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSA RESPONSE TO MAC %d", pLeader->PLength );
2100 *((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))
2101 = *pstAddIndication;
2102 ((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSA_RSP;
2103
2104 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " VCID = %x", ntohs(pstAddIndication->u16VCID));
2105 CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
2106 bcm_kfree(pstAddIndication);
2107 }
2108 break;
2109 case DSA_RSP:
2110 {
2111 pLeader->PLength = sizeof(stLocalSFAddIndicationAlt);
2112 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSA ACK TO MAC %d",
2113 pLeader->PLength);
2114 *((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))
2115 = *pstAddIndication;
2116 ((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSA_ACK;
2117
2118 }//no break here..we should go down.
2119 case DSA_ACK:
2120 {
2121 UINT uiSearchRuleIndex=0;
2122 struct timeval tv = {0};
2123 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "VCID:0x%X",
2124 ntohs(pstAddIndication->u16VCID));
2125 uiSearchRuleIndex=SearchFreeSfid(Adapter);
2126 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"uiSearchRuleIndex:0x%X ",
2127 uiSearchRuleIndex);
2128 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Direction:0x%X ",
2129 pstAddIndication->u8Direction);
2130 if((uiSearchRuleIndex< NO_OF_QUEUES) )
2131 {
2132 Adapter->PackInfo[uiSearchRuleIndex].ucDirection =
2133 pstAddIndication->u8Direction;
2134 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "bValid:0x%X ",
2135 pstAddIndication->sfActiveSet.bValid);
2136 if(pstAddIndication->sfActiveSet.bValid==TRUE)
2137 {
2138 Adapter->PackInfo[uiSearchRuleIndex].bActiveSet=TRUE;
2139 }
2140 if(pstAddIndication->sfAuthorizedSet.bValid==TRUE)
2141 {
2142 Adapter->PackInfo[uiSearchRuleIndex].bAuthorizedSet=TRUE;
2143 }
2144 if(pstAddIndication->sfAdmittedSet.bValid==TRUE)
2145 {
2146 Adapter->PackInfo[uiSearchRuleIndex].bAdmittedSet=TRUE;
2147 }
2148 if(FALSE == pstAddIndication->sfActiveSet.bValid)
2149 {
2150 Adapter->PackInfo[uiSearchRuleIndex].bActive = FALSE;
2151 Adapter->PackInfo[uiSearchRuleIndex].bActivateRequestSent = FALSE;
2152 if(pstAddIndication->sfAdmittedSet.bValid)
2153 {
2154 psfLocalSet = &pstAddIndication->sfAdmittedSet;
2155 }
2156 else if(pstAddIndication->sfAuthorizedSet.bValid)
2157 {
2158 psfLocalSet = &pstAddIndication->sfAuthorizedSet;
2159 }
2160 }
2161 else
2162 {
2163 psfLocalSet = &pstAddIndication->sfActiveSet;
2164 Adapter->PackInfo[uiSearchRuleIndex].bActive=TRUE;
2165 }
2166
2167 if(!psfLocalSet)
2168 {
2169 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "No set is valid\n");
2170 Adapter->PackInfo[uiSearchRuleIndex].bActive=FALSE;
2171 Adapter->PackInfo[uiSearchRuleIndex].bValid=FALSE;
2172 Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value=0;
2173 bcm_kfree(pstAddIndication);
2174 }
2175
2176 else if(psfLocalSet->bValid && (pstAddIndication->u8CC == 0))
2177 {
2178 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "DSA ACK");
2179 Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value =
2180 ntohs(pstAddIndication->u16VCID);
2181 Adapter->PackInfo[uiSearchRuleIndex].usCID =
2182 ntohs(pstAddIndication->u16CID);
2183
2184 if(UPLINK_DIR == pstAddIndication->u8Direction)
2185 atomic_set(&Adapter->PackInfo[uiSearchRuleIndex].uiPerSFTxResourceCount, DEFAULT_PERSFCOUNT);
2186 CopyToAdapter(Adapter,psfLocalSet,uiSearchRuleIndex,
2187 DSA_ACK, pstAddIndication);
2188 // don't free pstAddIndication
2189
2190 /* Inside CopyToAdapter, Sorting of all the SFs take place.
2191 Hence any access to the newly added SF through uiSearchRuleIndex is invalid.
2192 SHOULD BE STRICTLY AVOIDED.
2193 */
2194// *(PULONG)(((PUCHAR)pvBuffer)+1)=psfLocalSet->u32SFID;
2195 memcpy((((PUCHAR)pvBuffer)+1), &psfLocalSet->u32SFID, 4);
2196
2197 if(pstAddIndication->sfActiveSet.bValid == TRUE)
2198 {
2199 if(UPLINK_DIR == pstAddIndication->u8Direction)
2200 {
2201 if(!Adapter->LinkUpStatus)
2202 {
2203 netif_carrier_on(Adapter->dev);
2204 netif_start_queue(Adapter->dev);
2205 Adapter->LinkUpStatus = 1;
2206 do_gettimeofday(&tv);
2207
2208 atomic_set(&Adapter->TxPktAvail, 1);
2209 wake_up(&Adapter->tx_packet_wait_queue);
2210 Adapter->liTimeSinceLastNetEntry = tv.tv_sec;
2211 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "============Tx Service Flow Created!");
2212 }
2213 }
2214 }
2215 }
2216
2217 else
2218 {
2219 Adapter->PackInfo[uiSearchRuleIndex].bActive=FALSE;
2220 Adapter->PackInfo[uiSearchRuleIndex].bValid=FALSE;
2221 Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value=0;
2222 bcm_kfree(pstAddIndication);
2223 }
2224 }
2225 else
2226 {
2227 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "DSA ACK did not get valid SFID");
2228 bcm_kfree(pstAddIndication);
2229 return FALSE;
2230 }
2231 }
2232 break;
2233 case DSC_REQ:
2234 {
2235 pLeader->PLength = sizeof(stLocalSFChangeIndicationAlt);
2236 pstChangeIndication = (stLocalSFChangeIndicationAlt*)pstAddIndication;
2237 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSC RESPONSE TO MAC %d", pLeader->PLength);
2238
2239 *((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *pstChangeIndication;
2240 ((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSC_RSP;
2241
2242 CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
2243 bcm_kfree(pstAddIndication);
2244 }
2245 break;
2246 case DSC_RSP:
2247 {
2248 pLeader->PLength = sizeof(stLocalSFChangeIndicationAlt);
2249 pstChangeIndication = (stLocalSFChangeIndicationAlt*)pstAddIndication;
2250 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSC ACK TO MAC %d", pLeader->PLength);
2251 *((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *pstChangeIndication;
2252 ((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSC_ACK;
2253 }
2254 case DSC_ACK:
2255 {
2256 UINT uiSearchRuleIndex=0;
2257
2258 pstChangeIndication = (stLocalSFChangeIndicationAlt *)pstAddIndication;
2259 uiSearchRuleIndex=SearchSfid(Adapter,ntohl(pstChangeIndication->sfActiveSet.u32SFID));
2260 if(uiSearchRuleIndex > NO_OF_QUEUES-1)
2261 {
2262 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "SF doesn't exist for which DSC_ACK is received");
2263 }
2264 if((uiSearchRuleIndex < NO_OF_QUEUES))
2265 {
2266 Adapter->PackInfo[uiSearchRuleIndex].ucDirection = pstChangeIndication->u8Direction;
2267 if(pstChangeIndication->sfActiveSet.bValid==TRUE)
2268 {
2269 Adapter->PackInfo[uiSearchRuleIndex].bActiveSet=TRUE;
2270 }
2271 if(pstChangeIndication->sfAuthorizedSet.bValid==TRUE)
2272 {
2273 Adapter->PackInfo[uiSearchRuleIndex].bAuthorizedSet=TRUE;
2274 }
2275 if(pstChangeIndication->sfAdmittedSet.bValid==TRUE)
2276 {
2277 Adapter->PackInfo[uiSearchRuleIndex].bAdmittedSet=TRUE;
2278 }
2279
2280 if(FALSE==pstChangeIndication->sfActiveSet.bValid)
2281 {
2282 Adapter->PackInfo[uiSearchRuleIndex].bActive = FALSE;
2283 Adapter->PackInfo[uiSearchRuleIndex].bActivateRequestSent = FALSE;
2284 if(pstChangeIndication->sfAdmittedSet.bValid)
2285 {
2286 psfLocalSet = &pstChangeIndication->sfAdmittedSet;
2287 }
2288 else if(pstChangeIndication->sfAuthorizedSet.bValid)
2289 {
2290 psfLocalSet = &pstChangeIndication->sfAuthorizedSet;
2291 }
2292 }
2293
2294 else
2295 {
2296 psfLocalSet = &pstChangeIndication->sfActiveSet;
2297 Adapter->PackInfo[uiSearchRuleIndex].bActive=TRUE;
2298 }
2299 if(psfLocalSet->bValid && (pstChangeIndication->u8CC == 0))
2300 {
2301 Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value =
2302 ntohs(pstChangeIndication->u16VCID);
2303 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "CC field is %d bvalid = %d\n",
2304 pstChangeIndication->u8CC, psfLocalSet->bValid);
2305 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "VCID= %d\n", ntohs(pstChangeIndication->u16VCID));
2306 Adapter->PackInfo[uiSearchRuleIndex].usCID =
2307 ntohs(pstChangeIndication->u16CID);
2308 CopyToAdapter(Adapter,psfLocalSet,uiSearchRuleIndex,
2309 DSC_ACK, pstAddIndication);
2310
2311 *(PULONG)(((PUCHAR)pvBuffer)+1)=psfLocalSet->u32SFID;
2312 }
2313 else if(pstChangeIndication->u8CC == 6)
2314 {
2315 deleteSFBySfid(Adapter,uiSearchRuleIndex);
2316 bcm_kfree(pstAddIndication);
2317 }
2318 }
2319 else
2320 {
2321 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "DSC ACK did not get valid SFID");
2322 bcm_kfree(pstAddIndication);
2323 return FALSE;
2324 }
2325 }
2326 break;
2327 case DSD_REQ:
2328 {
2329 UINT uiSearchRuleIndex;
2330 ULONG ulSFID;
2331
2332 pLeader->PLength = sizeof(stLocalSFDeleteIndication);
2333 *((stLocalSFDeleteIndication*)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *((stLocalSFDeleteIndication*)pstAddIndication);
2334
2335 ulSFID = ntohl(((stLocalSFDeleteIndication*)pstAddIndication)->u32SFID);
2336 uiSearchRuleIndex=SearchSfid(Adapter,ulSFID);
2337 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "DSD - Removing connection %x",uiSearchRuleIndex);
2338
2339 if(uiSearchRuleIndex < NO_OF_QUEUES)
2340 {
2341 //Delete All Classifiers Associated with this SFID
2342 deleteSFBySfid(Adapter,uiSearchRuleIndex);
2343 Adapter->u32TotalDSD++;
2344 }
2345
2346 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSD RESPONSE TO MAC");
2347 ((stLocalSFDeleteIndication*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSD_RSP;
2348 CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
2349 }
2350 case DSD_RSP:
2351 {
2352 //Do nothing as SF has already got Deleted
2353 }
2354 break;
2355 case DSD_ACK:
2356 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "DSD ACK Rcd, let App handle it\n");
2357 break;
2358 default:
2359 bcm_kfree(pstAddIndication);
2360 return FALSE ;
2361 }
2362 return TRUE;
2363}
2364
2365int get_dsx_sf_data_to_application(PMINI_ADAPTER Adapter, UINT uiSFId, PUCHAR user_buffer)
2366{
2367 int status = 0;
2368 struct _packet_info *psSfInfo=NULL;
2369 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "status =%d",status);
2370 status = SearchSfid(Adapter, uiSFId);
2371 if(status>NO_OF_QUEUES)
2372 {
2373 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SFID %d not present in queue !!!", uiSFId );
2374 return -EINVAL;
2375 }
2376 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "status =%d",status);
2377 psSfInfo=&Adapter->PackInfo[status];
2378 if(psSfInfo->pstSFIndication && copy_to_user((PCHAR)user_buffer,
2379 (PCHAR)psSfInfo->pstSFIndication, sizeof(stLocalSFAddIndicationAlt)))
2380 {
2381 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy to user failed SFID %d, present in queue !!!", uiSFId );
2382 status = -EFAULT;
2383 return status;
2384 }
2385 return STATUS_SUCCESS;
2386}
2387
2388VOID OverrideServiceFlowParams(PMINI_ADAPTER Adapter,PUINT puiBuffer)
2389{
2390 B_UINT32 u32NumofSFsinMsg = ntohl(*(puiBuffer + 1));
2391 stIM_SFHostNotify *pHostInfo = NULL;
2392 UINT uiSearchRuleIndex = 0;
2393 ULONG ulSFID = 0;
2394
2395 puiBuffer+=2;
2396
2397 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "u32NumofSFsinMsg: 0x%x\n",u32NumofSFsinMsg);
2398
2399 while(u32NumofSFsinMsg != 0 && u32NumofSFsinMsg < NO_OF_QUEUES)
2400 {
2401 u32NumofSFsinMsg--;
2402 pHostInfo = (stIM_SFHostNotify *)puiBuffer;
2403 puiBuffer = (PUINT)(pHostInfo + 1);
2404
2405 ulSFID = ntohl(pHostInfo->SFID);
2406 uiSearchRuleIndex=SearchSfid(Adapter,ulSFID);
2407 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"SFID: 0x%lx\n",ulSFID);
2408
2409 if(uiSearchRuleIndex >= NO_OF_QUEUES || uiSearchRuleIndex == HiPriority)
2410 {
2411 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);
2412 continue;
2413 }
2414
2415 if(pHostInfo->RetainSF == FALSE)
2416 {
2417 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Going to Delete SF");
2418 deleteSFBySfid(Adapter,uiSearchRuleIndex);
2419 }
2420 else
2421 {
2422
2423 Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value = ntohs(pHostInfo->VCID);
2424 Adapter->PackInfo[uiSearchRuleIndex].usCID = ntohs(pHostInfo->newCID);
2425 Adapter->PackInfo[uiSearchRuleIndex].bActive=FALSE;
2426
2427 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"pHostInfo->QoSParamSet: 0x%x\n",pHostInfo->QoSParamSet);
2428
2429 if(pHostInfo->QoSParamSet & 0x1)
2430 Adapter->PackInfo[uiSearchRuleIndex].bAuthorizedSet =TRUE;
2431 if(pHostInfo->QoSParamSet & 0x2)
2432 Adapter->PackInfo[uiSearchRuleIndex].bAdmittedSet =TRUE;
2433 if(pHostInfo->QoSParamSet & 0x4)
2434 {
2435 Adapter->PackInfo[uiSearchRuleIndex].bActiveSet =TRUE;
2436 Adapter->PackInfo[uiSearchRuleIndex].bActive=TRUE;
2437 }
2438 }
2439 }
2440}
2441
2442
2443
Clone of davem's net-next-2.6 tree