LXR linux/drivers/staging/bcm/CmHost.c

   1/************************************************************
   2 * CMHOST.C
   3 * This file contains the routines for handling Connection
   4 * Management.
   5 ************************************************************/
   6
   7#include "headers.h"
   8
   9enum E_CLASSIFIER_ACTION {
  10        eInvalidClassifierAction,
  11        eAddClassifier,
  12        eReplaceClassifier,
  13        eDeleteClassifier
  14};
  15
  16static 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 ************************************************************/
  30int 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 ****************************************************************/
  51static 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 */
  70static 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 */
  89static int SearchFreeClsid(struct bcm_mini_adapter *Adapter /**Adapter Context*/)
  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
 101static 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(struct bcm_mibs_table));
 111}
 112
 113static inline VOID
 114CopyIpAddrToClassifier(struct bcm_classifier_rule *pstClassifierEntry,
 115                B_UINT8 u8IpAddressLen, B_UINT8 *pu8IpAddressMaskSrc,
 116                BOOLEAN bIpVersion6, enum bcm_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
 216void 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 */
 238static 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 */
 367static 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 */
 398VOID 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 */
 430static 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                        struct bcm_add_indication_alt *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        struct bcm_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(struct bcm_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 *************************************************************************/
 832static VOID DumpCmControlPacket(PVOID pvBuffer)
 833{
 834        int uiLoopIndex;
 835        int nIndex;
 836        struct bcm_add_indication_alt *pstAddIndication;
 837        UINT nCurClassifierCnt;
 838        struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
 839
 840        pstAddIndication = (struct bcm_add_indication_alt *)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
1301static 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
1318static 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
1334ULONG StoreCmControlResponseMessage(struct bcm_mini_adapter *Adapter, PVOID pvBuffer, UINT *puBufferLength)
1335{
1336        struct bcm_add_indication_alt *pstAddIndicationAlt = NULL;
1337        struct bcm_add_indication *pstAddIndication = NULL;
1338        struct bcm_del_request *pstDeletionRequest;
1339        UINT uiSearchRuleIndex;
1340        ULONG ulSFID;
1341
1342        pstAddIndicationAlt = (struct bcm_add_indication_alt *)(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
1448static inline struct bcm_add_indication_alt
1449*RestoreCmControlResponseMessage(register struct bcm_mini_adapter *Adapter, register PVOID pvBuffer)
1450{
1451        ULONG ulStatus = 0;
1452        struct bcm_add_indication *pstAddIndication = NULL;
1453        struct bcm_add_indication_alt *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 (struct bcm_add_indication_alt *)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(struct bcm_add_indication_alt), GFP_KERNEL);
1468
1469        if (pstAddIndicationDest) {
1470                memset(pstAddIndicationDest, 0, sizeof(struct bcm_add_indication_alt));
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;
1521failed_restore_sf_param:
1522        kfree(pstAddIndicationDest);
1523        BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "<=====");
1524        return NULL;
1525}
1526
1527ULONG 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
1574static ULONG GetNextTargetBufferLocation(struct bcm_mini_adapter *Adapter, B_UINT16 tid)
1575{
1576        ULONG dsx_buf;
1577        ULONG idx, max_try;
1578
1579        if ((Adapter->ulTotalTargetBuffersAvailable == 0) || (Adapter->ulFreeTargetBufferCnt == 0)) {
1580                ClearTargetDSXBuffer(Adapter, tid, FALSE);
1581                return 0;
1582        }
1583
1584        idx = Adapter->ulCurrentTargetBuffer;
1585        max_try = Adapter->ulTotalTargetBuffersAvailable;
1586        while ((max_try) && (Adapter->astTargetDsxBuffer[idx].valid != 1)) {
1587                idx = (idx+1) % Adapter->ulTotalTargetBuffersAvailable;
1588                max_try--;
1589        }
1590
1591        if (max_try == 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        dsx_buf = Adapter->astTargetDsxBuffer[idx].ulTargetDsxBuffer;
1598        Adapter->astTargetDsxBuffer[idx].valid = 0;
1599        Adapter->astTargetDsxBuffer[idx].tid = tid;
1600        Adapter->ulFreeTargetBufferCnt--;
1601        idx = (idx+1)%Adapter->ulTotalTargetBuffersAvailable;
1602        Adapter->ulCurrentTargetBuffer = idx;
1603        BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "GetNextTargetBufferLocation :Returning address %lx tid %d\n", dsx_buf, tid);
1604
1605        return dsx_buf;
1606}
1607
1608int 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(struct bcm_add_indication_alt)+LEADER_SIZE, GFP_KERNEL);
1615        if (!Adapter->caDsxReqResp)
1616                return -ENOMEM;
1617
1618        return 0;
1619}
1620
1621int 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 */
1633BOOLEAN 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        struct bcm_add_indication_alt *pstAddIndication = NULL;
1638        struct bcm_change_indication *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(struct bcm_add_indication_alt);
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                *((struct bcm_add_indication_alt *)&(Adapter->caDsxReqResp[LEADER_SIZE]))
1668                        = *pstAddIndication;
1669                ((struct bcm_add_indication_alt *)&(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(struct bcm_add_indication_alt);
1679                BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSA ACK TO MAC %d",
1680                                pLeader->PLength);
1681                *((struct bcm_add_indication_alt *)&(Adapter->caDsxReqResp[LEADER_SIZE]))
1682                        = *pstAddIndication;
1683                ((struct bcm_add_indication_alt *)&(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(struct bcm_change_indication);
1777                pstChangeIndication = (struct bcm_change_indication *)pstAddIndication;
1778                BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSC RESPONSE TO MAC %d", pLeader->PLength);
1779
1780                *((struct bcm_change_indication *)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *pstChangeIndication;
1781                ((struct bcm_change_indication *)&(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(struct bcm_change_indication);
1790                pstChangeIndication = (struct bcm_change_indication *)pstAddIndication;
1791                BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSC ACK TO MAC %d", pLeader->PLength);
1792                *((struct bcm_change_indication *)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *pstChangeIndication;
1793                ((struct bcm_change_indication *)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSC_ACK;
1794        }
1795        case DSC_ACK:
1796        {
1797                UINT uiSearchRuleIndex = 0;
1798
1799                pstChangeIndication = (struct bcm_change_indication *)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
1891int 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(struct bcm_add_indication_alt))) {
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
1913VOID 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}
1958