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