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