Staging: bcm: Alter name, datatype, and default value of iterator variables.

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

This patch renames variables used in iteration
statements with i, changes the datatype to int,
and removes any default value.

Signed-off-by: Kevin McKinney <klmckinney1@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

authored by

Kevin McKinney and committed by

Greg Kroah-Hartman 14 years ago 5cf4d6b9 ce4bbc2a

+84 -84

1 changed file

expand all

drivers

staging

bcm

CmHost.c

+84 -84

drivers/staging/bcm/CmHost.c

··· 30 30 ************************************************************/ 31 31 int SearchSfid(PMINI_ADAPTER Adapter, UINT uiSfid) 32 32 { 33 - int iIndex = 0; 33 + int i; 34 34 35 - for (iIndex = (NO_OF_QUEUES-1); iIndex >= 0; iIndex--) 36 - if (Adapter->PackInfo[iIndex].ulSFID == uiSfid) 37 - return iIndex; 35 + for (i = (NO_OF_QUEUES-1); i >= 0; i--) 36 + if (Adapter->PackInfo[i].ulSFID == uiSfid) 37 + return i; 38 38 39 39 return NO_OF_QUEUES+1; 40 40 } ··· 51 51 ****************************************************************/ 52 52 static int SearchFreeSfid(PMINI_ADAPTER Adapter) 53 53 { 54 - UINT uiIndex = 0; 54 + int i; 55 55 56 - for (uiIndex = 0; uiIndex < (NO_OF_QUEUES-1); uiIndex++) 57 - if (Adapter->PackInfo[uiIndex].ulSFID == 0) 58 - return uiIndex; 56 + for (i = 0; i < (NO_OF_QUEUES-1); i++) 57 + if (Adapter->PackInfo[i].ulSFID == 0) 58 + return i; 59 59 60 60 return NO_OF_QUEUES+1; 61 61 } ··· 70 70 */ 71 71 static int SearchClsid(PMINI_ADAPTER Adapter, ULONG ulSFID, B_UINT16 uiClassifierID) 72 72 { 73 - unsigned int uiClassifierIndex = 0; 73 + int i; 74 74 75 - for (uiClassifierIndex = 0; uiClassifierIndex < MAX_CLASSIFIERS; uiClassifierIndex++) { 76 - if ((Adapter->astClassifierTable[uiClassifierIndex].bUsed) && 77 - (Adapter->astClassifierTable[uiClassifierIndex].uiClassifierRuleIndex == uiClassifierID) && 78 - (Adapter->astClassifierTable[uiClassifierIndex].ulSFID == ulSFID)) 79 - return uiClassifierIndex; 75 + for (i = 0; i < MAX_CLASSIFIERS; i++) { 76 + if ((Adapter->astClassifierTable[i].bUsed) && 77 + (Adapter->astClassifierTable[i].uiClassifierRuleIndex == uiClassifierID) && 78 + (Adapter->astClassifierTable[i].ulSFID == ulSFID)) 79 + return i; 80 80 } 81 81 82 82 return MAX_CLASSIFIERS+1; ··· 89 89 */ 90 90 static int SearchFreeClsid(PMINI_ADAPTER Adapter /**Adapter Context*/) 91 91 { 92 - unsigned int uiClassifierIndex = 0; 92 + int i; 93 93 94 - for (uiClassifierIndex = 0; uiClassifierIndex < MAX_CLASSIFIERS; uiClassifierIndex++) { 95 - if (!Adapter->astClassifierTable[uiClassifierIndex].bUsed) 96 - return uiClassifierIndex; 94 + for (i = 0; i < MAX_CLASSIFIERS; i++) { 95 + if (!Adapter->astClassifierTable[i].bUsed) 96 + return i; 97 97 } 98 98 99 99 return MAX_CLASSIFIERS+1; ··· 116 116 B_UINT8 u8IpAddressLen, B_UINT8 *pu8IpAddressMaskSrc, 117 117 BOOLEAN bIpVersion6, E_IPADDR_CONTEXT eIpAddrContext) 118 118 { 119 - UINT ucLoopIndex = 0; 119 + int i = 0; 120 120 UINT nSizeOfIPAddressInBytes = IP_LENGTH_OF_ADDRESS; 121 121 UCHAR *ptrClassifierIpAddress = NULL; 122 122 UCHAR *ptrClassifierIpMask = NULL; ··· 154 154 } 155 155 } 156 156 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Address Length:0x%X\n", pstClassifierEntry->ucIPDestinationAddressLength); 157 - while ((u8IpAddressLen >= nSizeOfIPAddressInBytes) && (ucLoopIndex < MAX_IP_RANGE_LENGTH)) { 157 + while ((u8IpAddressLen >= nSizeOfIPAddressInBytes) && (i < MAX_IP_RANGE_LENGTH)) { 158 158 memcpy(ptrClassifierIpAddress + 159 - (ucLoopIndex * nSizeOfIPAddressInBytes), 160 - (pu8IpAddressMaskSrc+(ucLoopIndex*nSizeOfIPAddressInBytes*2)), 159 + (i * nSizeOfIPAddressInBytes), 160 + (pu8IpAddressMaskSrc+(i*nSizeOfIPAddressInBytes*2)), 161 161 nSizeOfIPAddressInBytes); 162 162 163 163 if (!bIpVersion6) { 164 164 if (eIpAddrContext == eSrcIpAddress) { 165 - pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[ucLoopIndex] = ntohl(pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[ucLoopIndex]); 165 + pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[i] = ntohl(pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[i]); 166 166 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Src Ip Address:0x%luX ", 167 - pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[ucLoopIndex]); 167 + pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[i]); 168 168 } else if (eIpAddrContext == eDestIpAddress) { 169 - pstClassifierEntry->stDestIpAddress.ulIpv4Addr[ucLoopIndex] = ntohl(pstClassifierEntry->stDestIpAddress.ulIpv4Addr[ucLoopIndex]); 169 + pstClassifierEntry->stDestIpAddress.ulIpv4Addr[i] = ntohl(pstClassifierEntry->stDestIpAddress.ulIpv4Addr[i]); 170 170 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Dest Ip Address:0x%luX ", 171 - pstClassifierEntry->stDestIpAddress.ulIpv4Addr[ucLoopIndex]); 171 + pstClassifierEntry->stDestIpAddress.ulIpv4Addr[i]); 172 172 } 173 173 } 174 174 u8IpAddressLen -= nSizeOfIPAddressInBytes; 175 175 if (u8IpAddressLen >= nSizeOfIPAddressInBytes) { 176 176 memcpy(ptrClassifierIpMask + 177 - (ucLoopIndex * nSizeOfIPAddressInBytes), 177 + (i * nSizeOfIPAddressInBytes), 178 178 (pu8IpAddressMaskSrc+nSizeOfIPAddressInBytes + 179 - (ucLoopIndex*nSizeOfIPAddressInBytes*2)), 179 + (i*nSizeOfIPAddressInBytes*2)), 180 180 nSizeOfIPAddressInBytes); 181 181 182 182 if (!bIpVersion6) { 183 183 if (eIpAddrContext == eSrcIpAddress) { 184 - pstClassifierEntry->stSrcIpAddress.ulIpv4Mask[ucLoopIndex] = 185 - ntohl(pstClassifierEntry->stSrcIpAddress.ulIpv4Mask[ucLoopIndex]); 184 + pstClassifierEntry->stSrcIpAddress.ulIpv4Mask[i] = 185 + ntohl(pstClassifierEntry->stSrcIpAddress.ulIpv4Mask[i]); 186 186 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Src Ip Mask Address:0x%luX ", 187 - pstClassifierEntry->stSrcIpAddress.ulIpv4Mask[ucLoopIndex]); 187 + pstClassifierEntry->stSrcIpAddress.ulIpv4Mask[i]); 188 188 } else if (eIpAddrContext == eDestIpAddress) { 189 - pstClassifierEntry->stDestIpAddress.ulIpv4Mask[ucLoopIndex] = 190 - ntohl(pstClassifierEntry->stDestIpAddress.ulIpv4Mask[ucLoopIndex]); 189 + pstClassifierEntry->stDestIpAddress.ulIpv4Mask[i] = 190 + ntohl(pstClassifierEntry->stDestIpAddress.ulIpv4Mask[i]); 191 191 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Dest Ip Mask Address:0x%luX ", 192 - pstClassifierEntry->stDestIpAddress.ulIpv4Mask[ucLoopIndex]); 192 + pstClassifierEntry->stDestIpAddress.ulIpv4Mask[i]); 193 193 } 194 194 } 195 195 u8IpAddressLen -= nSizeOfIPAddressInBytes; ··· 197 197 if (u8IpAddressLen == 0) 198 198 pstClassifierEntry->bDestIpValid = TRUE; 199 199 200 - ucLoopIndex++; 200 + i++; 201 201 } 202 202 if (bIpVersion6) { 203 203 /* Restore EndianNess of Struct */ 204 - for (ucLoopIndex = 0; ucLoopIndex < MAX_IP_RANGE_LENGTH * 4; ucLoopIndex++) { 204 + for (i = 0; i < MAX_IP_RANGE_LENGTH * 4; i++) { 205 205 if (eIpAddrContext == eSrcIpAddress) { 206 - pstClassifierEntry->stSrcIpAddress.ulIpv6Addr[ucLoopIndex] = ntohl(pstClassifierEntry->stSrcIpAddress.ulIpv6Addr[ucLoopIndex]); 207 - pstClassifierEntry->stSrcIpAddress.ulIpv6Mask[ucLoopIndex] = ntohl(pstClassifierEntry->stSrcIpAddress.ulIpv6Mask[ucLoopIndex]); 206 + pstClassifierEntry->stSrcIpAddress.ulIpv6Addr[i] = ntohl(pstClassifierEntry->stSrcIpAddress.ulIpv6Addr[i]); 207 + pstClassifierEntry->stSrcIpAddress.ulIpv6Mask[i] = ntohl(pstClassifierEntry->stSrcIpAddress.ulIpv6Mask[i]); 208 208 } else if (eIpAddrContext == eDestIpAddress) { 209 - pstClassifierEntry->stDestIpAddress.ulIpv6Addr[ucLoopIndex] = ntohl(pstClassifierEntry->stDestIpAddress.ulIpv6Addr[ucLoopIndex]); 210 - pstClassifierEntry->stDestIpAddress.ulIpv6Mask[ucLoopIndex] = ntohl(pstClassifierEntry->stDestIpAddress.ulIpv6Mask[ucLoopIndex]); 209 + pstClassifierEntry->stDestIpAddress.ulIpv6Addr[i] = ntohl(pstClassifierEntry->stDestIpAddress.ulIpv6Addr[i]); 210 + pstClassifierEntry->stDestIpAddress.ulIpv6Mask[i] = ntohl(pstClassifierEntry->stDestIpAddress.ulIpv6Mask[i]); 211 211 } 212 212 } 213 213 } ··· 216 216 217 217 void ClearTargetDSXBuffer(PMINI_ADAPTER Adapter, B_UINT16 TID, BOOLEAN bFreeAll) 218 218 { 219 - ULONG ulIndex; 219 + int i; 220 220 221 - for (ulIndex = 0; ulIndex < Adapter->ulTotalTargetBuffersAvailable; ulIndex++) { 222 - if (Adapter->astTargetDsxBuffer[ulIndex].valid) 221 + for (i = 0; i < Adapter->ulTotalTargetBuffersAvailable; i++) { 222 + if (Adapter->astTargetDsxBuffer[i].valid) 223 223 continue; 224 224 225 - if ((bFreeAll) || (Adapter->astTargetDsxBuffer[ulIndex].tid == TID)) { 225 + if ((bFreeAll) || (Adapter->astTargetDsxBuffer[i].tid == TID)) { 226 226 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "ClearTargetDSXBuffer: found tid %d buffer cleared %lx\n", 227 - TID, Adapter->astTargetDsxBuffer[ulIndex].ulTargetDsxBuffer); 228 - Adapter->astTargetDsxBuffer[ulIndex].valid = 1; 229 - Adapter->astTargetDsxBuffer[ulIndex].tid = 0; 227 + TID, Adapter->astTargetDsxBuffer[i].ulTargetDsxBuffer); 228 + Adapter->astTargetDsxBuffer[i].valid = 1; 229 + Adapter->astTargetDsxBuffer[i].tid = 0; 230 230 Adapter->ulFreeTargetBufferCnt++; 231 231 } 232 232 } ··· 240 240 { 241 241 S_CLASSIFIER_RULE *pstClassifierEntry = NULL; 242 242 /* VOID *pvPhsContext = NULL; */ 243 - UINT ucLoopIndex = 0; 243 + int i; 244 244 /* UCHAR ucProtocolLength=0; */ 245 245 /* ULONG ulPhsStatus; */ 246 246 ··· 264 264 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Destination Port Range Length:0x%X ", pstClassifierEntry->ucDestPortRangeLength); 265 265 266 266 if (psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength <= MAX_PORT_RANGE) { 267 - for (ucLoopIndex = 0; ucLoopIndex < (pstClassifierEntry->ucDestPortRangeLength); ucLoopIndex++) { 268 - pstClassifierEntry->usDestPortRangeLo[ucLoopIndex] = *((PUSHORT)(psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange+ucLoopIndex)); 269 - pstClassifierEntry->usDestPortRangeHi[ucLoopIndex] = 270 - *((PUSHORT)(psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange+2+ucLoopIndex)); 271 - pstClassifierEntry->usDestPortRangeLo[ucLoopIndex] = ntohs(pstClassifierEntry->usDestPortRangeLo[ucLoopIndex]); 267 + for (i = 0; i < (pstClassifierEntry->ucDestPortRangeLength); i++) { 268 + pstClassifierEntry->usDestPortRangeLo[i] = *((PUSHORT)(psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange+i)); 269 + pstClassifierEntry->usDestPortRangeHi[i] = 270 + *((PUSHORT)(psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange+2+i)); 271 + pstClassifierEntry->usDestPortRangeLo[i] = ntohs(pstClassifierEntry->usDestPortRangeLo[i]); 272 272 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Destination Port Range Lo:0x%X ", 273 - pstClassifierEntry->usDestPortRangeLo[ucLoopIndex]); 274 - pstClassifierEntry->usDestPortRangeHi[ucLoopIndex] = ntohs(pstClassifierEntry->usDestPortRangeHi[ucLoopIndex]); 273 + pstClassifierEntry->usDestPortRangeLo[i]); 274 + pstClassifierEntry->usDestPortRangeHi[i] = ntohs(pstClassifierEntry->usDestPortRangeHi[i]); 275 275 } 276 276 } else { 277 277 pstClassifierEntry->ucDestPortRangeLength = 0; ··· 282 282 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength); 283 283 if (psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength <= MAX_PORT_RANGE) { 284 284 pstClassifierEntry->ucSrcPortRangeLength = psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength/4; 285 - for (ucLoopIndex = 0; ucLoopIndex < (pstClassifierEntry->ucSrcPortRangeLength); ucLoopIndex++) { 286 - pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex] = 285 + for (i = 0; i < (pstClassifierEntry->ucSrcPortRangeLength); i++) { 286 + pstClassifierEntry->usSrcPortRangeLo[i] = 287 287 *((PUSHORT)(psfCSType->cCPacketClassificationRule. 288 - u8ProtocolSourcePortRange+ucLoopIndex)); 289 - pstClassifierEntry->usSrcPortRangeHi[ucLoopIndex] = 288 + u8ProtocolSourcePortRange+i)); 289 + pstClassifierEntry->usSrcPortRangeHi[i] = 290 290 *((PUSHORT)(psfCSType->cCPacketClassificationRule. 291 - u8ProtocolSourcePortRange+2+ucLoopIndex)); 292 - pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex] = 293 - ntohs(pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex]); 291 + u8ProtocolSourcePortRange+2+i)); 292 + pstClassifierEntry->usSrcPortRangeLo[i] = 293 + ntohs(pstClassifierEntry->usSrcPortRangeLo[i]); 294 294 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Source Port Range Lo:0x%X ", 295 - pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex]); 296 - pstClassifierEntry->usSrcPortRangeHi[ucLoopIndex] = ntohs(pstClassifierEntry->usSrcPortRangeHi[ucLoopIndex]); 295 + pstClassifierEntry->usSrcPortRangeLo[i]); 296 + pstClassifierEntry->usSrcPortRangeHi[i] = ntohs(pstClassifierEntry->usSrcPortRangeHi[i]); 297 297 } 298 298 } 299 299 /* Destination Ip Address and Mask */ ··· 399 399 VOID DeleteAllClassifiersForSF(PMINI_ADAPTER Adapter, UINT uiSearchRuleIndex) 400 400 { 401 401 S_CLASSIFIER_RULE *pstClassifierEntry = NULL; 402 - UINT nClassifierIndex; 402 + int i; 403 403 /* B_UINT16 u16PacketClassificationRuleIndex; */ 404 404 USHORT ulVCID; 405 405 /* VOID *pvPhsContext = NULL; */ ··· 410 410 if (ulVCID == 0) 411 411 return; 412 412 413 - for (nClassifierIndex = 0; nClassifierIndex < MAX_CLASSIFIERS; nClassifierIndex++) { 414 - if (Adapter->astClassifierTable[nClassifierIndex].usVCID_Value == ulVCID) { 415 - pstClassifierEntry = &Adapter->astClassifierTable[nClassifierIndex]; 413 + for (i = 0; i < MAX_CLASSIFIERS; i++) { 414 + if (Adapter->astClassifierTable[i].usVCID_Value == ulVCID) { 415 + pstClassifierEntry = &Adapter->astClassifierTable[i]; 416 416 417 417 if (pstClassifierEntry->bUsed) 418 - DeleteClassifierRuleFromSF(Adapter, uiSearchRuleIndex, nClassifierIndex); 418 + DeleteClassifierRuleFromSF(Adapter, uiSearchRuleIndex, i); 419 419 } 420 420 } 421 421 ··· 439 439 UINT nClassifierIndex = 0; 440 440 enum E_CLASSIFIER_ACTION eClassifierAction = eInvalidClassifierAction; 441 441 B_UINT16 u16PacketClassificationRuleIndex = 0; 442 - UINT nIndex = 0; 442 + int i; 443 443 stConvergenceSLTypes *psfCSType = NULL; 444 444 S_PHS_RULE sPhsRule; 445 445 USHORT uVCID = Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value; ··· 527 527 Adapter->PackInfo[uiSearchRuleIndex].u8TrafficPriority = psfLocalSet->u8TrafficPriority; 528 528 529 529 /* copy all the classifier in the Service Flow param structure */ 530 - for (nIndex = 0; nIndex < psfLocalSet->u8TotalClassifiers; nIndex++) { 531 - BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Classifier index =%d", nIndex); 532 - psfCSType = &psfLocalSet->cConvergenceSLTypes[nIndex]; 533 - BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Classifier index =%d", nIndex); 530 + for (i = 0; i < psfLocalSet->u8TotalClassifiers; i++) { 531 + BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Classifier index =%d", i); 532 + psfCSType = &psfLocalSet->cConvergenceSLTypes[i]; 533 + BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Classifier index =%d", i); 534 534 535 535 if (psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority) 536 536 Adapter->PackInfo[uiSearchRuleIndex].bClassifierPriority = TRUE; ··· 628 628 } 629 629 630 630 /* Repeat parsing Classification Entries to process PHS Rules */ 631 - for (nIndex = 0; nIndex < psfLocalSet->u8TotalClassifiers; nIndex++) { 632 - psfCSType = &psfLocalSet->cConvergenceSLTypes[nIndex]; 631 + for (i = 0; i < psfLocalSet->u8TotalClassifiers; i++) { 632 + psfCSType = &psfLocalSet->cConvergenceSLTypes[i]; 633 633 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "psfCSType->u8PhsDSCAction : 0x%x\n", psfCSType->u8PhsDSCAction); 634 634 635 635 switch (psfCSType->u8PhsDSCAction) { ··· 832 832 *************************************************************************/ 833 833 static VOID DumpCmControlPacket(PVOID pvBuffer) 834 834 { 835 - UINT uiLoopIndex; 836 - UINT nIndex; 835 + int uiLoopIndex; 836 + int nIndex; 837 837 stLocalSFAddIndicationAlt *pstAddIndication; 838 838 UINT nCurClassifierCnt; 839 839 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev); ··· 1542 1542 { 1543 1543 ULONG ulTargetDsxBuffersBase = 0; 1544 1544 ULONG ulCntTargetBuffers; 1545 - ULONG ulIndex = 0; 1545 + ULONG i; 1546 1546 int Status; 1547 1547 1548 1548 if (!Adapter) { ··· 1572 1572 1573 1573 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " Total Target DSX Buffer setup %lx ", Adapter->ulTotalTargetBuffersAvailable); 1574 1574 1575 - for (ulIndex = 0; ulIndex < Adapter->ulTotalTargetBuffersAvailable; ulIndex++) { 1576 - Adapter->astTargetDsxBuffer[ulIndex].ulTargetDsxBuffer = ulTargetDsxBuffersBase; 1577 - Adapter->astTargetDsxBuffer[ulIndex].valid = 1; 1578 - Adapter->astTargetDsxBuffer[ulIndex].tid = 0; 1575 + for (i = 0; i < Adapter->ulTotalTargetBuffersAvailable; i++) { 1576 + Adapter->astTargetDsxBuffer[i].ulTargetDsxBuffer = ulTargetDsxBuffersBase; 1577 + Adapter->astTargetDsxBuffer[i].valid = 1; 1578 + Adapter->astTargetDsxBuffer[i].tid = 0; 1579 1579 ulTargetDsxBuffersBase += sizeof(stServiceFlowParamSI); 1580 1580 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " Target DSX Buffer %lx setup at 0x%lx", 1581 - ulIndex, Adapter->astTargetDsxBuffer[ulIndex].ulTargetDsxBuffer); 1581 + i, Adapter->astTargetDsxBuffer[i].ulTargetDsxBuffer); 1582 1582 } 1583 1583 Adapter->ulCurrentTargetBuffer = 0; 1584 1584 Adapter->ulFreeTargetBufferCnt = Adapter->ulTotalTargetBuffersAvailable;