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