[PATCH 07/34] staging: bcm: Add space after comma

Joe Perches joe at perches.com
Tue Jan 10 16:54:01 UTC 2012


Separate function arguments and array values for readability.

git diff -w shows no change.

Signed-off-by: Joe Perches <joe at perches.com>
---
 drivers/staging/bcm/Adapter.h                  |    4 +-
 drivers/staging/bcm/CmHost.c                   |  152 ++--
 drivers/staging/bcm/CmHost.h                   |    6 +-
 drivers/staging/bcm/DDRInit.c                  | 1330 ++++++++++++------------
 drivers/staging/bcm/Debug.h                    |    4 +-
 drivers/staging/bcm/IPv6Protocol.c             |   26 +-
 drivers/staging/bcm/IPv6ProtocolHdr.h          |    6 +-
 drivers/staging/bcm/InterfaceDld.c             |    4 +-
 drivers/staging/bcm/InterfaceIdleMode.c        |   24 +-
 drivers/staging/bcm/InterfaceRx.c              |    8 +-
 drivers/staging/bcm/InterfaceTx.c              |    2 +-
 drivers/staging/bcm/Ioctl.h                    |   12 +-
 drivers/staging/bcm/LeakyBucket.c              |    4 +-
 drivers/staging/bcm/Misc.c                     |    4 +-
 drivers/staging/bcm/PHSModule.c                |  134 ++--
 drivers/staging/bcm/PHSModule.h                |   14 +-
 drivers/staging/bcm/Prototypes.h               |   32 +-
 drivers/staging/bcm/Qos.c                      |   62 +-
 drivers/staging/bcm/Queue.h                    |    2 +-
 drivers/staging/bcm/Transmit.c                 |    2 +-
 drivers/staging/bcm/cntrl_SignalingInterface.h |    4 +-
 drivers/staging/bcm/led_control.h              |    8 +-
 drivers/staging/bcm/nvm.c                      |  434 ++++----
 drivers/staging/bcm/nvm.h                      |    4 +-
 drivers/staging/bcm/target_params.h            |    4 +-
 drivers/staging/bcm/vendorspecificextn.c       |    2 +-
 drivers/staging/bcm/vendorspecificextn.h       |    2 +-
 27 files changed, 1145 insertions(+), 1145 deletions(-)

diff --git a/drivers/staging/bcm/Adapter.h b/drivers/staging/bcm/Adapter.h
index 50faa44..f752b02 100644
--- a/drivers/staging/bcm/Adapter.h
+++ b/drivers/staging/bcm/Adapter.h
@@ -347,9 +347,9 @@ typedef struct _STTARGETDSXBUFFER {
 	BOOLEAN valid;
 }STTARGETDSXBUFFER, *PSTTARGETDSXBUFFER;
 
-typedef INT (*FP_FLASH_WRITE)(struct _MINI_ADAPTER*,UINT,PVOID);
+typedef INT (*FP_FLASH_WRITE)(struct _MINI_ADAPTER*, UINT, PVOID);
 
-typedef INT (*FP_FLASH_WRITE_STATUS)(struct _MINI_ADAPTER*,UINT,PVOID);
+typedef INT (*FP_FLASH_WRITE_STATUS)(struct _MINI_ADAPTER*, UINT, PVOID);
 
 /**
    Driver adapter data structure
diff --git a/drivers/staging/bcm/CmHost.c b/drivers/staging/bcm/CmHost.c
index dd5b307..22b125e 100644
--- a/drivers/staging/bcm/CmHost.c
+++ b/drivers/staging/bcm/CmHost.c
@@ -16,7 +16,7 @@ typedef enum _E_CLASSIFIER_ACTION
 	eDeleteClassifier
 }E_CLASSIFIER_ACTION;
 
-static ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter,B_UINT16 tid);
+static ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter, B_UINT16 tid);
 
 /************************************************************
  * Function	  -	SearchSfid
@@ -30,7 +30,7 @@ static ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter,B_UINT16 tid);
  * Returns	  - Queue index for this SFID(If matched)
 				Else Invalid Queue Index(If Not matched)
 ************************************************************/
-INT SearchSfid(PMINI_ADAPTER Adapter,UINT uiSfid)
+INT SearchSfid(PMINI_ADAPTER Adapter, UINT uiSfid)
 {
 	INT	iIndex=0;
 	for (iIndex = (NO_OF_QUEUES - 1); iIndex >= 0; iIndex--)
@@ -68,7 +68,7 @@ static INT SearchFreeSfid(PMINI_ADAPTER Adapter)
   Return:					int :Classifier table index of matching entry
 */
 
-static int SearchClsid(PMINI_ADAPTER Adapter,ULONG ulSFID,B_UINT16  uiClassifierID)
+static int SearchClsid(PMINI_ADAPTER Adapter, ULONG ulSFID, B_UINT16  uiClassifierID)
 {
 	unsigned int uiClassifierIndex = 0;
 	for (uiClassifierIndex = 0; uiClassifierIndex < MAX_CLASSIFIERS; uiClassifierIndex++) {
@@ -99,10 +99,10 @@ static int SearchFreeClsid(PMINI_ADAPTER Adapter /**Adapter Context*/
 static VOID deleteSFBySfid(PMINI_ADAPTER Adapter, UINT uiSearchRuleIndex)
 {
 	//deleting all the packet held in the SF
-	flush_queue(Adapter,uiSearchRuleIndex);
+	flush_queue(Adapter, uiSearchRuleIndex);
 
 	//Deleting the all classifiers for this SF
-	DeleteAllClassifiersForSF(Adapter,uiSearchRuleIndex);
+	DeleteAllClassifiersForSF(Adapter, uiSearchRuleIndex);
 
 	//Resetting only MIBS related entries in the SF
 	memset((PVOID)&Adapter->PackInfo[uiSearchRuleIndex], 0, sizeof(S_MIBS_SERVICEFLOW_TABLE));
@@ -239,7 +239,7 @@ CopyIpAddrToClassifier(S_CLASSIFIER_RULE *pstClassifierEntry ,
 }
 
 
-void ClearTargetDSXBuffer(PMINI_ADAPTER Adapter,B_UINT16 TID,BOOLEAN bFreeAll)
+void ClearTargetDSXBuffer(PMINI_ADAPTER Adapter, B_UINT16 TID, BOOLEAN bFreeAll)
 {
 	ULONG ulIndex;
 	for (ulIndex = 0; ulIndex < Adapter->ulTotalTargetBuffersAvailable; ulIndex++) {
@@ -259,7 +259,7 @@ void ClearTargetDSXBuffer(PMINI_ADAPTER Adapter,B_UINT16 TID,BOOLEAN bFreeAll)
    @ingroup ctrl_pkt_functions
    copy classifier rule into the specified SF index
 */
-static inline VOID CopyClassifierRuleToSF(PMINI_ADAPTER Adapter,stConvergenceSLTypes  *psfCSType,UINT uiSearchRuleIndex,UINT nClassifierIndex)
+static inline VOID CopyClassifierRuleToSF(PMINI_ADAPTER Adapter, stConvergenceSLTypes *psfCSType, UINT uiSearchRuleIndex, UINT nClassifierIndex)
 {
 	S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
 	//VOID *pvPhsContext = NULL;
@@ -401,13 +401,13 @@ static inline VOID CopyClassifierRuleToSF(PMINI_ADAPTER Adapter,stConvergenceSLT
 
 		//Copy ETH CS Parameters
 		pstClassifierEntry->ucEthCSSrcMACLen = (psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddressLength);
-		memcpy(pstClassifierEntry->au8EThCSSrcMAC,psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress,MAC_ADDRESS_SIZE);
-		memcpy(pstClassifierEntry->au8EThCSSrcMACMask,psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress+MAC_ADDRESS_SIZE,MAC_ADDRESS_SIZE);
+		memcpy(pstClassifierEntry->au8EThCSSrcMAC, psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress, MAC_ADDRESS_SIZE);
+		memcpy(pstClassifierEntry->au8EThCSSrcMACMask, psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress+MAC_ADDRESS_SIZE, MAC_ADDRESS_SIZE);
 		pstClassifierEntry->ucEthCSDestMACLen = (psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
-		memcpy(pstClassifierEntry->au8EThCSDestMAC,psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress,MAC_ADDRESS_SIZE);
-		memcpy(pstClassifierEntry->au8EThCSDestMACMask,psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress+MAC_ADDRESS_SIZE,MAC_ADDRESS_SIZE);
+		memcpy(pstClassifierEntry->au8EThCSDestMAC, psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress, MAC_ADDRESS_SIZE);
+		memcpy(pstClassifierEntry->au8EThCSDestMACMask, psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress+MAC_ADDRESS_SIZE, MAC_ADDRESS_SIZE);
 		pstClassifierEntry->ucEtherTypeLen = (psfCSType->cCPacketClassificationRule.u8EthertypeLength);
-		memcpy(pstClassifierEntry->au8EthCSEtherType,psfCSType->cCPacketClassificationRule.u8Ethertype,NUM_ETHERTYPE_BYTES);
+		memcpy(pstClassifierEntry->au8EthCSEtherType, psfCSType->cCPacketClassificationRule.u8Ethertype, NUM_ETHERTYPE_BYTES);
 		memcpy(pstClassifierEntry->usUserPriority, &psfCSType->cCPacketClassificationRule.u16UserPriority, 2);
 		pstClassifierEntry->usVLANID = ntohs(psfCSType->cCPacketClassificationRule.u16VLANID);
 		pstClassifierEntry->usValidityBitMap = ntohs(psfCSType->cCPacketClassificationRule.u16ValidityBitMap);
@@ -420,7 +420,7 @@ static inline VOID CopyClassifierRuleToSF(PMINI_ADAPTER Adapter,stConvergenceSLT
 /**
    @ingroup ctrl_pkt_functions
 */
-static inline VOID DeleteClassifierRuleFromSF(PMINI_ADAPTER Adapter,UINT uiSearchRuleIndex,UINT nClassifierIndex)
+static inline VOID DeleteClassifierRuleFromSF(PMINI_ADAPTER Adapter, UINT uiSearchRuleIndex, UINT nClassifierIndex)
 {
 	S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
 	B_UINT16  u16PacketClassificationRuleIndex;
@@ -443,7 +443,7 @@ static inline VOID DeleteClassifierRuleFromSF(PMINI_ADAPTER Adapter,UINT uiSearc
 	if (pstClassifierEntry) {
 		pstClassifierEntry->bUsed = FALSE;
 		pstClassifierEntry->uiClassifierRuleIndex = 0;
-		memset(pstClassifierEntry,0,sizeof(S_CLASSIFIER_RULE));
+		memset(pstClassifierEntry, 0, sizeof(S_CLASSIFIER_RULE));
 
 		//Delete the PHS Rule for this classifier
 		PhsDeleteClassifierRule(
@@ -456,7 +456,7 @@ static inline VOID DeleteClassifierRuleFromSF(PMINI_ADAPTER Adapter,UINT uiSearc
 /**
    @ingroup ctrl_pkt_functions
 */
-VOID DeleteAllClassifiersForSF(PMINI_ADAPTER Adapter,UINT uiSearchRuleIndex)
+VOID DeleteAllClassifiersForSF(PMINI_ADAPTER Adapter, UINT uiSearchRuleIndex)
 {
 	S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
 	UINT nClassifierIndex;
@@ -475,7 +475,7 @@ VOID DeleteAllClassifiersForSF(PMINI_ADAPTER Adapter,UINT uiSearchRuleIndex)
 		if (Adapter->astClassifierTable[nClassifierIndex].usVCID_Value == ulVCID) {
 			pstClassifierEntry = &Adapter->astClassifierTable[nClassifierIndex];
 			if (pstClassifierEntry->bUsed) {
-				DeleteClassifierRuleFromSF(Adapter,uiSearchRuleIndex,nClassifierIndex);
+				DeleteClassifierRuleFromSF(Adapter, uiSearchRuleIndex, nClassifierIndex);
 			}
 		}
 	}
@@ -656,7 +656,7 @@ static VOID CopyToAdapter( register PMINI_ADAPTER Adapter,		/**<Pointer to the A
 		case eAddClassifier: {
 			//Get a Free Classifier Index From Classifier table for this SF to add the Classifier
 			//Contained in this message
-			nClassifierIndex = SearchClsid(Adapter,ulSFID,u16PacketClassificationRuleIndex);
+			nClassifierIndex = SearchClsid(Adapter, ulSFID, u16PacketClassificationRuleIndex);
 
 			if (nClassifierIndex > MAX_CLASSIFIERS) {
 				nClassifierIndex = SearchFreeClsid(Adapter);
@@ -667,7 +667,7 @@ static VOID CopyToAdapter( register PMINI_ADAPTER Adapter,		/**<Pointer to the A
 					break;
 				}
 				//Copy the Classifier Rule for this service flow into our Classifier table maintained per SF.
-				CopyClassifierRuleToSF(Adapter,psfCSType,uiSearchRuleIndex,nClassifierIndex);
+				CopyClassifierRuleToSF(Adapter, psfCSType, uiSearchRuleIndex, nClassifierIndex);
 			}
 
 			else {
@@ -682,7 +682,7 @@ static VOID CopyToAdapter( register PMINI_ADAPTER Adapter,		/**<Pointer to the A
 		case eReplaceClassifier: {
 			//Get the Classifier Index From Classifier table for this SF and replace existing  Classifier
 			//with the new classifier Contained in this message
-			nClassifierIndex = SearchClsid(Adapter,ulSFID,u16PacketClassificationRuleIndex);
+			nClassifierIndex = SearchClsid(Adapter, ulSFID, u16PacketClassificationRuleIndex);
 			if (nClassifierIndex > MAX_CLASSIFIERS) {
 				//Failed To search the classifier
 				bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL,
@@ -690,14 +690,14 @@ static VOID CopyToAdapter( register PMINI_ADAPTER Adapter,		/**<Pointer to the A
 				break;
 			}
 			//Copy the Classifier Rule for this service flow into our Classifier table maintained per SF.
-			CopyClassifierRuleToSF(Adapter,psfCSType,uiSearchRuleIndex,nClassifierIndex);
+			CopyClassifierRuleToSF(Adapter, psfCSType, uiSearchRuleIndex, nClassifierIndex);
 		}
 		break;
 
 		case eDeleteClassifier: {
 			//Get the Classifier Index From Classifier table for this SF and replace existing  Classifier
 			//with the new classifier Contained in this message
-			nClassifierIndex = SearchClsid(Adapter,ulSFID,u16PacketClassificationRuleIndex);
+			nClassifierIndex = SearchClsid(Adapter, ulSFID, u16PacketClassificationRuleIndex);
 			if (nClassifierIndex > MAX_CLASSIFIERS) {
 				//Failed To search the classifier
 				bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL,
@@ -706,7 +706,7 @@ static VOID CopyToAdapter( register PMINI_ADAPTER Adapter,		/**<Pointer to the A
 			}
 
 			//Delete This classifier
-			DeleteClassifierRuleFromSF(Adapter,uiSearchRuleIndex,nClassifierIndex);
+			DeleteClassifierRuleFromSF(Adapter, uiSearchRuleIndex, nClassifierIndex);
 		}
 		break;
 
@@ -784,8 +784,8 @@ static VOID CopyToAdapter( register PMINI_ADAPTER Adapter,		/**<Pointer to the A
 							sPhsRule.u8PHSMLength = psfCSType->cPhsRule.u8PHSMLength;
 							sPhsRule.u8PHSS = psfCSType->cPhsRule.u8PHSS;
 							sPhsRule.u8PHSV = psfCSType->cPhsRule.u8PHSV;
-							memcpy(sPhsRule.u8PHSF,psfCSType->cPhsRule.u8PHSF,MAX_PHS_LENGTHS);
-							memcpy(sPhsRule.u8PHSM,psfCSType->cPhsRule.u8PHSM,MAX_PHS_LENGTHS);
+							memcpy(sPhsRule.u8PHSF, psfCSType->cPhsRule.u8PHSF, MAX_PHS_LENGTHS);
+							memcpy(sPhsRule.u8PHSM, psfCSType->cPhsRule.u8PHSM, MAX_PHS_LENGTHS);
 							sPhsRule.u8RefCnt = 0;
 							sPhsRule.bUnclassifiedPHSRule = FALSE;
 							sPhsRule.PHSModifiedBytes = 0;
@@ -805,7 +805,7 @@ static VOID CopyToAdapter( register PMINI_ADAPTER Adapter,		/**<Pointer to the A
 							//Update PHS Rule For the Classifier
 							if (sPhsRule.u8PHSI) {
 								Adapter->astClassifierTable[uiClassifierIndex].u32PHSRuleID = sPhsRule.u8PHSI;
-								memcpy(&Adapter->astClassifierTable[uiClassifierIndex].sPhsRule,&sPhsRule,sizeof(S_PHS_RULE));
+								memcpy(&Adapter->astClassifierTable[uiClassifierIndex].sPhsRule, &sPhsRule, sizeof(S_PHS_RULE));
 							}
 
 						}
@@ -819,8 +819,8 @@ static VOID CopyToAdapter( register PMINI_ADAPTER Adapter,		/**<Pointer to the A
 					sPhsRule.u8PHSMLength = psfCSType->cPhsRule.u8PHSMLength;
 					sPhsRule.u8PHSS = psfCSType->cPhsRule.u8PHSS;
 					sPhsRule.u8PHSV = psfCSType->cPhsRule.u8PHSV;
-					memcpy(sPhsRule.u8PHSF,psfCSType->cPhsRule.u8PHSF,MAX_PHS_LENGTHS);
-					memcpy(sPhsRule.u8PHSM,psfCSType->cPhsRule.u8PHSM,MAX_PHS_LENGTHS);
+					memcpy(sPhsRule.u8PHSF, psfCSType->cPhsRule.u8PHSF, MAX_PHS_LENGTHS);
+					memcpy(sPhsRule.u8PHSM, psfCSType->cPhsRule.u8PHSM, MAX_PHS_LENGTHS);
 					sPhsRule.u8RefCnt = 0;
 					sPhsRule.bUnclassifiedPHSRule = TRUE;
 					sPhsRule.PHSModifiedBytes = 0;
@@ -908,13 +908,13 @@ static VOID CopyToAdapter( register PMINI_ADAPTER Adapter,		/**<Pointer to the A
 	bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL, "LAT: %d, UGI: %d\n",
 		Adapter->PackInfo[uiSearchRuleIndex].uiMaxLatency, UGIValue);
 	bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL,
-		"uiMaxAllowedRate: 0x%x, u32MaxSustainedTrafficRate: 0x%x ,uiMaxBucketSize: 0x%x\n",
+		"uiMaxAllowedRate: 0x%x, u32MaxSustainedTrafficRate: 0x%x, uiMaxBucketSize: 0x%x\n",
 		Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate,
 		ntohl(psfLocalSet->u32MaxSustainedTrafficRate),
 		Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize);
 
 	//copy the extended SF Parameters to Support MIBS
-	CopyMIBSExtendedSFParameters(Adapter,psfLocalSet,uiSearchRuleIndex);
+	CopyMIBSExtendedSFParameters(Adapter, psfLocalSet, uiSearchRuleIndex);
 
 	//store header suppression enabled flag per SF
 	Adapter->PackInfo[uiSearchRuleIndex].bHeaderSuppressionEnabled =
@@ -984,7 +984,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 		pstAddIndication->sfAuthorizedSet.u8ServiceClassNameLength);
 
 	bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-		"u8ServiceClassName		: 0x%X ,0x%X , 0x%X, 0x%X, 0x%X, 0x%X\n",
+		"u8ServiceClassName		: 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X\n",
 		pstAddIndication->sfAuthorizedSet.u8ServiceClassName[0],
 		pstAddIndication->sfAuthorizedSet.u8ServiceClassName[1],
 		pstAddIndication->sfAuthorizedSet.u8ServiceClassName[2],
@@ -1127,7 +1127,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 			psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength);
 
 		bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-			"u8IPTypeOfService[3]			:0x%X ,0x%X ,0x%X\n",
+			"u8IPTypeOfService[3]			:0x%X, 0x%X, 0x%X\n",
 			psfCSType->cCPacketClassificationRule.u8IPTypeOfService[0],
 			psfCSType->cCPacketClassificationRule.u8IPTypeOfService[1],
 			psfCSType->cCPacketClassificationRule.u8IPTypeOfService[2]);
@@ -1159,7 +1159,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 			"u8ProtocolSourcePortRangeLength:0x%X\n",
 			psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength);
 		bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-			"u8ProtocolSourcePortRange[4]: 0x%02X ,0x%02X ,0x%02X ,0x%02X\n",
+			"u8ProtocolSourcePortRange[4]: 0x%02X, 0x%02X, 0x%02X, 0x%02X\n",
 			psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[0],
 			psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[1],
 			psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[2],
@@ -1169,7 +1169,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 			"u8ProtocolDestPortRangeLength : 0x%02X\n",
 			psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength);
 		bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-			"u8ProtocolDestPortRange[4]: 0x%02X ,0x%02X ,0x%02X ,0x%02X\n",
+			"u8ProtocolDestPortRange[4]: 0x%02X, 0x%02X, 0x%02X, 0x%02X\n",
 			psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[0],
 			psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[1],
 			psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[2],
@@ -1205,7 +1205,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 			"u8EthertypeLength	: 0x%02X\n",
 			psfCSType->cCPacketClassificationRule.u8EthertypeLength);
 		bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-			"u8Ethertype[3] : 0x%02X ,0x%02X ,0x%02X\n",
+			"u8Ethertype[3] : 0x%02X, 0x%02X, 0x%02X\n",
 			psfCSType->cCPacketClassificationRule.u8Ethertype[0],
 			psfCSType->cCPacketClassificationRule.u8Ethertype[1],
 			psfCSType->cCPacketClassificationRule.u8Ethertype[2]);
@@ -1650,7 +1650,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 			psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength);
 
 		bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-			"u8IPTypeOfService[3]			:0x%X ,0x%X ,0x%X\n",
+			"u8IPTypeOfService[3]			:0x%X, 0x%X, 0x%X\n",
 			psfCSType->cCPacketClassificationRule.u8IPTypeOfService[0],
 			psfCSType->cCPacketClassificationRule.u8IPTypeOfService[1],
 			psfCSType->cCPacketClassificationRule.u8IPTypeOfService[2]);
@@ -1682,7 +1682,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 			psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength);
 
 		bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-			"u8ProtocolSourcePortRange[4]:0x%X ,0x%X ,0x%X ,0x%X\n",
+			"u8ProtocolSourcePortRange[4]:0x%X, 0x%X, 0x%X, 0x%X\n",
 			psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[0],
 			psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[1],
 			psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[2],
@@ -1693,7 +1693,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 			psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength);
 
 		bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-			"u8ProtocolDestPortRange[4]:0x%X ,0x%X ,0x%X ,0x%X\n",
+			"u8ProtocolDestPortRange[4]:0x%X, 0x%X, 0x%X, 0x%X\n",
 			psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[0],
 			psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[1],
 			psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[2],
@@ -1704,7 +1704,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 			psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
 
 		bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-			"u8EthernetDestMacAddress[6]:0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X\n",
+			"u8EthernetDestMacAddress[6]:0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X\n",
 			psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[0],
 			psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[1],
 			psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[2],
@@ -1717,7 +1717,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 			psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
 
 		bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-			"u8EthernetSourceMACAddress[6]:0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X\n",
+			"u8EthernetSourceMACAddress[6]:0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X\n",
 			psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[0],
 			psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[1],
 			psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[2],
@@ -1729,7 +1729,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 			"u8EthertypeLength              :0x%X\n",
 			psfCSType->cCPacketClassificationRule.u8EthertypeLength);
 		bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-			"u8Ethertype[3]                 :0x%X ,0x%X ,0x%X\n",
+			"u8Ethertype[3]                 :0x%X, 0x%X, 0x%X\n",
 			psfCSType->cCPacketClassificationRule.u8Ethertype[0],
 			psfCSType->cCPacketClassificationRule.u8Ethertype[1],
 			psfCSType->cCPacketClassificationRule.u8Ethertype[2]);
@@ -1757,7 +1757,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 			"u8IPv6FlowLabelLength				:0x%X\n",
 			psfCSType->cCPacketClassificationRule.u8IPv6FlowLableLength);
 		bcm_dbg(Adapter, OTHERS, DUMP_CONTROL, ALL,
-			"u8IPv6FlowLabel[6]	    :0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X\n",
+			"u8IPv6FlowLabel[6]	    :0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X\n",
 			psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[0],
 			psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[1],
 			psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[2],
@@ -1773,7 +1773,7 @@ static VOID DumpCmControlPacket(PVOID pvBuffer)
 
 }
 
-static inline ULONG RestoreSFParam(PMINI_ADAPTER Adapter, ULONG ulAddrSFParamSet,PUCHAR pucDestBuffer)
+static inline ULONG RestoreSFParam(PMINI_ADAPTER Adapter, ULONG ulAddrSFParamSet, PUCHAR pucDestBuffer)
 {
 	UINT  nBytesToRead = sizeof(stServiceFlowParamSI);
 
@@ -1792,7 +1792,7 @@ static inline ULONG RestoreSFParam(PMINI_ADAPTER Adapter, ULONG ulAddrSFParamSet
 }
 
 
-static ULONG StoreSFParam(PMINI_ADAPTER Adapter,PUCHAR pucSrcBuffer,ULONG  ulAddrSFParamSet)
+static ULONG StoreSFParam(PMINI_ADAPTER Adapter, PUCHAR pucSrcBuffer, ULONG  ulAddrSFParamSet)
 {
 	UINT	nBytesToWrite = sizeof(stServiceFlowParamSI);
 	int ret = 0;
@@ -1810,7 +1810,7 @@ static ULONG StoreSFParam(PMINI_ADAPTER Adapter,PUCHAR pucSrcBuffer,ULONG  ulAdd
 	return 1;
 }
 
-ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer,UINT *puBufferLength)
+ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter, PVOID pvBuffer, UINT *puBufferLength)
 {
 	stLocalSFAddIndicationAlt *pstAddIndicationAlt = NULL;
 	stLocalSFAddIndication *  pstAddIndication = NULL;
@@ -1828,10 +1828,10 @@ ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer,UINT *p
 		pstDeletionRequest = (stLocalSFDeleteRequest *)pvBuffer;
 
 		ulSFID = ntohl(pstDeletionRequest->u32SFID);
-		uiSearchRuleIndex=SearchSfid(Adapter,ulSFID);
+		uiSearchRuleIndex=SearchSfid(Adapter, ulSFID);
 
 		if (uiSearchRuleIndex < NO_OF_QUEUES) {
-			deleteSFBySfid(Adapter,uiSearchRuleIndex);
+			deleteSFBySfid(Adapter, uiSearchRuleIndex);
 			Adapter->u32TotalDSD++;
 		}
 		return 1;
@@ -1855,7 +1855,7 @@ ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer,UINT *p
 	if (!pstAddIndication->psfAuthorizedSet)
 		return 0;
 
-	if (StoreSFParam(Adapter,(PUCHAR)&pstAddIndicationAlt->sfAuthorizedSet,
+	if (StoreSFParam(Adapter, (PUCHAR)&pstAddIndicationAlt->sfAuthorizedSet,
 			(ULONG)pstAddIndication->psfAuthorizedSet)!= 1)
 		return 0;
 
@@ -1872,7 +1872,7 @@ ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer,UINT *p
 		AddRequest.u16VCID = pstAddIndicationAlt->u16VCID;
 		AddRequest.psfParameterSet =pstAddIndication->psfAuthorizedSet ;
 		(*puBufferLength) = sizeof(stLocalSFAddRequest);
-		memcpy(pvBuffer,&AddRequest,sizeof(stLocalSFAddRequest));
+		memcpy(pvBuffer,&AddRequest, sizeof(stLocalSFAddRequest));
 		return 1;
 	}
 
@@ -1892,7 +1892,7 @@ ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer,UINT *p
 		GetNextTargetBufferLocation(Adapter, pstAddIndicationAlt->u16TID);
 	if (!pstAddIndication->psfAdmittedSet)
 		return 0;
-	if (StoreSFParam(Adapter,(PUCHAR)&pstAddIndicationAlt->sfAdmittedSet,(ULONG)pstAddIndication->psfAdmittedSet) != 1)
+	if (StoreSFParam(Adapter, (PUCHAR)&pstAddIndicationAlt->sfAdmittedSet, (ULONG)pstAddIndication->psfAdmittedSet) != 1)
 		return 0;
 
 	pstAddIndication->psfAdmittedSet = (stServiceFlowParamSI *)ntohl((ULONG)pstAddIndication->psfAdmittedSet);
@@ -1903,7 +1903,7 @@ ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer,UINT *p
 		GetNextTargetBufferLocation(Adapter, pstAddIndicationAlt->u16TID);
 	if (!pstAddIndication->psfActiveSet)
 		return 0;
-	if (StoreSFParam(Adapter,(PUCHAR)&pstAddIndicationAlt->sfActiveSet,(ULONG)pstAddIndication->psfActiveSet) != 1)
+	if (StoreSFParam(Adapter, (PUCHAR)&pstAddIndicationAlt->sfActiveSet, (ULONG)pstAddIndication->psfActiveSet) != 1)
 		return 0;
 
 	pstAddIndication->psfActiveSet = (stServiceFlowParamSI *)ntohl((ULONG)pstAddIndication->psfActiveSet);
@@ -1916,7 +1916,7 @@ ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer,UINT *p
 
 
 static inline stLocalSFAddIndicationAlt
-*RestoreCmControlResponseMessage(register PMINI_ADAPTER Adapter,register PVOID pvBuffer)
+*RestoreCmControlResponseMessage(register PMINI_ADAPTER Adapter, register PVOID pvBuffer)
 {
 	ULONG ulStatus=0;
 	stLocalSFAddIndication *pstAddIndication = NULL;
@@ -1939,7 +1939,7 @@ static inline stLocalSFAddIndicationAlt
 	pstAddIndicationDest=kmalloc(sizeof(stLocalSFAddIndicationAlt), GFP_KERNEL);
 
 	if (pstAddIndicationDest) {
-		memset(pstAddIndicationDest,0,sizeof(stLocalSFAddIndicationAlt));
+		memset(pstAddIndicationDest, 0, sizeof(stLocalSFAddIndicationAlt));
 	} else {
 		bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL,
 			"Failed to allocate memory for SF Add Indication Structure\n");
@@ -1976,7 +1976,7 @@ static inline stLocalSFAddIndicationAlt
 	pstAddIndicationDest->u8CC = pstAddIndication->u8CC;
 
 	bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL, "Restoring Active Set\n");
-	ulStatus=RestoreSFParam(Adapter,(ULONG)pstAddIndication->psfActiveSet, (PUCHAR)&pstAddIndicationDest->sfActiveSet);
+	ulStatus=RestoreSFParam(Adapter, (ULONG)pstAddIndication->psfActiveSet, (PUCHAR)&pstAddIndicationDest->sfActiveSet);
 	if (ulStatus != 1) {
 		goto failed_restore_sf_param;
 	}
@@ -1984,7 +1984,7 @@ static inline stLocalSFAddIndicationAlt
 		pstAddIndicationDest->sfActiveSet.u8TotalClassifiers = MAX_CLASSIFIERS_IN_SF;
 
 	bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL, "Restoring Admitted Set\n");
-	ulStatus=RestoreSFParam(Adapter,(ULONG)pstAddIndication->psfAdmittedSet,(PUCHAR)&pstAddIndicationDest->sfAdmittedSet);
+	ulStatus=RestoreSFParam(Adapter, (ULONG)pstAddIndication->psfAdmittedSet, (PUCHAR)&pstAddIndicationDest->sfAdmittedSet);
 	if (ulStatus != 1) {
 		goto failed_restore_sf_param;
 	}
@@ -1992,7 +1992,7 @@ static inline stLocalSFAddIndicationAlt
 		pstAddIndicationDest->sfAdmittedSet.u8TotalClassifiers = MAX_CLASSIFIERS_IN_SF;
 
 	bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL, "Restoring Authorized Set\n");
-	ulStatus=RestoreSFParam(Adapter,(ULONG)pstAddIndication->psfAuthorizedSet,(PUCHAR)&pstAddIndicationDest->sfAuthorizedSet);
+	ulStatus=RestoreSFParam(Adapter, (ULONG)pstAddIndication->psfAuthorizedSet, (PUCHAR)&pstAddIndicationDest->sfAuthorizedSet);
 	if (ulStatus != 1) {
 		goto failed_restore_sf_param;
 	}
@@ -2006,7 +2006,7 @@ static inline stLocalSFAddIndicationAlt
 	bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL,
 		"pstAddIndicationDest->sfActiveSet size  %zx %p\n",
 		sizeof(*pstAddIndicationDest), pstAddIndicationDest);
-	//BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, (unsigned char *)pstAddIndicationDest, sizeof(*pstAddIndicationDest));
+	//BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, (unsigned char *)pstAddIndicationDest, sizeof(*pstAddIndicationDest));
 	bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL,
 		"============================================================\n");
 	return pstAddIndicationDest;
@@ -2077,14 +2077,14 @@ ULONG SetUpTargetDsxBuffers(PMINI_ADAPTER Adapter)
 	return 1;
 }
 
-static ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter,B_UINT16 tid)
+static ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter, B_UINT16 tid)
 {
 	ULONG  ulTargetDSXBufferAddress;
-	ULONG  ulTargetDsxBufferIndexToUse,ulMaxTry;
+	ULONG  ulTargetDsxBufferIndexToUse, ulMaxTry;
 
 	if ((Adapter->ulTotalTargetBuffersAvailable == 0)||
 	   (Adapter->ulFreeTargetBufferCnt == 0)) {
-		ClearTargetDSXBuffer(Adapter,tid,FALSE);
+		ClearTargetDSXBuffer(Adapter, tid, FALSE);
 		return 0;
 	}
 
@@ -2099,7 +2099,7 @@ static ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter,B_UINT16 tid)
 	if (ulMaxTry==0) {
 		pr_info("GetNextTargetBufferLocation : Error No Free Target DSX Buffers FreeCnt : %lx\n",
 			Adapter->ulFreeTargetBufferCnt);
-		ClearTargetDSXBuffer(Adapter,tid,FALSE);
+		ClearTargetDSXBuffer(Adapter, tid, FALSE);
 		return 0;
 	}
 
@@ -2115,7 +2115,7 @@ static ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter,B_UINT16 tid)
 		(ulTargetDsxBufferIndexToUse+1)%Adapter->ulTotalTargetBuffersAvailable;
 	Adapter->ulCurrentTargetBuffer = ulTargetDsxBufferIndexToUse;
 	pr_info("GetNextTargetBufferLocation :Returning address %lx tid %d\n",
-		ulTargetDSXBufferAddress,tid);
+		ulTargetDSXBufferAddress, tid);
 	return ulTargetDSXBufferAddress;
 }
 
@@ -2156,9 +2156,9 @@ BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter,  /**<Pointer to the Adap
 	//Otherwise the message contains a target address from where we need to
 	//read out the rest of the service flow param structure
 	*/
-	if ((pstAddIndication = RestoreCmControlResponseMessage(Adapter,pvBuffer))
+	if ((pstAddIndication = RestoreCmControlResponseMessage(Adapter, pvBuffer))
 	   == NULL) {
-		ClearTargetDSXBuffer(Adapter,((stLocalSFAddIndication *)pvBuffer)->u16TID, FALSE);
+		ClearTargetDSXBuffer(Adapter, ((stLocalSFAddIndication *)pvBuffer)->u16TID, FALSE);
 		pr_info("Error in restoring Service Flow param structure from DSx message\n");
 		return FALSE;
 	}
@@ -2170,7 +2170,7 @@ BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter,  /**<Pointer to the Adap
 	pLeader->Status =CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ;
 	pLeader->Vcid = 0;
 
-	ClearTargetDSXBuffer(Adapter,pstAddIndication->u16TID,FALSE);
+	ClearTargetDSXBuffer(Adapter, pstAddIndication->u16TID, FALSE);
 	pr_info("### TID RECEIVED %d\n", pstAddIndication->u16TID);
 	switch (pstAddIndication->u8Type) {
 	case DSA_REQ: {
@@ -2186,7 +2186,7 @@ BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter,  /**<Pointer to the Adap
 
 		bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL, "VCID = %x\n",
 			ntohs(pstAddIndication->u16VCID));
-		CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
+		CopyBufferToControlPacket(Adapter, (PVOID)Adapter->caDsxReqResp);
 		kfree(pstAddIndication);
 	}
 	break;
@@ -2258,7 +2258,7 @@ BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter,  /**<Pointer to the Adap
 
 				if (UPLINK_DIR == pstAddIndication->u8Direction)
 					atomic_set(&Adapter->PackInfo[uiSearchRuleIndex].uiPerSFTxResourceCount, DEFAULT_PERSFCOUNT);
-				CopyToAdapter(Adapter,psfLocalSet,uiSearchRuleIndex,
+				CopyToAdapter(Adapter, psfLocalSet, uiSearchRuleIndex,
 					      DSA_ACK, pstAddIndication);
 				// don't free pstAddIndication
 
@@ -2308,7 +2308,7 @@ BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter,  /**<Pointer to the Adap
 		*((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *pstChangeIndication;
 		((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSC_RSP;
 
-		CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
+		CopyBufferToControlPacket(Adapter, (PVOID)Adapter->caDsxReqResp);
 		kfree(pstAddIndication);
 	}
 	break;
@@ -2325,7 +2325,7 @@ BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter,  /**<Pointer to the Adap
 		UINT uiSearchRuleIndex=0;
 
 		pstChangeIndication = (stLocalSFChangeIndicationAlt *)pstAddIndication;
-		uiSearchRuleIndex=SearchSfid(Adapter,ntohl(pstChangeIndication->sfActiveSet.u32SFID));
+		uiSearchRuleIndex=SearchSfid(Adapter, ntohl(pstChangeIndication->sfActiveSet.u32SFID));
 		if (uiSearchRuleIndex > NO_OF_QUEUES-1) {
 			pr_info("SF doesn't exist for which DSC_ACK is received\n");
 		}
@@ -2365,12 +2365,12 @@ BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter,  /**<Pointer to the Adap
 					ntohs(pstChangeIndication->u16VCID));
 				Adapter->PackInfo[uiSearchRuleIndex].usCID =
 					ntohs(pstChangeIndication->u16CID);
-				CopyToAdapter(Adapter,psfLocalSet,uiSearchRuleIndex,
+				CopyToAdapter(Adapter, psfLocalSet, uiSearchRuleIndex,
 					      DSC_ACK, pstAddIndication);
 
 				*(PULONG)(((PUCHAR)pvBuffer)+1)=psfLocalSet->u32SFID;
 			} else if (pstChangeIndication->u8CC == 6) {
-				deleteSFBySfid(Adapter,uiSearchRuleIndex);
+				deleteSFBySfid(Adapter, uiSearchRuleIndex);
 				kfree(pstAddIndication);
 			}
 		} else {
@@ -2388,21 +2388,21 @@ BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter,  /**<Pointer to the Adap
 		*((stLocalSFDeleteIndication*)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *((stLocalSFDeleteIndication*)pstAddIndication);
 
 		ulSFID = ntohl(((stLocalSFDeleteIndication*)pstAddIndication)->u32SFID);
-		uiSearchRuleIndex=SearchSfid(Adapter,ulSFID);
+		uiSearchRuleIndex=SearchSfid(Adapter, ulSFID);
 		bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL,
 			"DSD - Removing connection %x\n",
 			uiSearchRuleIndex);
 
 		if (uiSearchRuleIndex < NO_OF_QUEUES) {
 			//Delete All Classifiers Associated with this SFID
-			deleteSFBySfid(Adapter,uiSearchRuleIndex);
+			deleteSFBySfid(Adapter, uiSearchRuleIndex);
 			Adapter->u32TotalDSD++;
 		}
 
 		bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL,
 			"SENDING DSD RESPONSE TO MAC\n");
 		((stLocalSFDeleteIndication*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSD_RSP;
-		CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
+		CopyBufferToControlPacket(Adapter, (PVOID)Adapter->caDsxReqResp);
 	}
 	case DSD_RSP: {
 		//Do nothing as SF has already got Deleted
@@ -2442,7 +2442,7 @@ int get_dsx_sf_data_to_application(PMINI_ADAPTER Adapter, UINT uiSFId, void __us
 	return STATUS_SUCCESS;
 }
 
-VOID OverrideServiceFlowParams(PMINI_ADAPTER Adapter,PUINT puiBuffer)
+VOID OverrideServiceFlowParams(PMINI_ADAPTER Adapter, PUINT puiBuffer)
 {
 	B_UINT32 u32NumofSFsinMsg    = ntohl(*(puiBuffer + 1));
 	stIM_SFHostNotify *pHostInfo = NULL;
@@ -2460,7 +2460,7 @@ VOID OverrideServiceFlowParams(PMINI_ADAPTER Adapter,PUINT puiBuffer)
 		puiBuffer = (PUINT)(pHostInfo + 1);
 
 		ulSFID = ntohl(pHostInfo->SFID);
-		uiSearchRuleIndex=SearchSfid(Adapter,ulSFID);
+		uiSearchRuleIndex=SearchSfid(Adapter, ulSFID);
 		bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL,
 			"SFID: 0x%lx\n", ulSFID);
 
@@ -2474,7 +2474,7 @@ VOID OverrideServiceFlowParams(PMINI_ADAPTER Adapter,PUINT puiBuffer)
 		if (pHostInfo->RetainSF == FALSE) {
 			bcm_dbg(Adapter, OTHERS, CONN_MSG, ALL,
 				"Going to Delete SF\n");
-			deleteSFBySfid(Adapter,uiSearchRuleIndex);
+			deleteSFBySfid(Adapter, uiSearchRuleIndex);
 		} else {
 
 			Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value = ntohs(pHostInfo->VCID);
diff --git a/drivers/staging/bcm/CmHost.h b/drivers/staging/bcm/CmHost.h
index 96f2987..2a7a8a9 100644
--- a/drivers/staging/bcm/CmHost.h
+++ b/drivers/staging/bcm/CmHost.h
@@ -18,7 +18,7 @@
 #define _CM_HOST_H
 
 #pragma once
-#pragma pack (push,4)
+#pragma pack (push, 4)
 
 #define  DSX_MESSAGE_EXCHANGE_BUFFER        0xBF60AC84 // This contains the pointer
 #define  DSX_MESSAGE_EXCHANGE_BUFFER_SIZE   72000 // 24 K Bytes
@@ -148,14 +148,14 @@ typedef struct stLocalSFChangeIndicationAlt{
 
 }stLocalSFChangeIndicationAlt;
 
-ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer,UINT *puBufferLength);
+ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter, PVOID pvBuffer, UINT *puBufferLength);
 
 INT AllocAdapterDsxBuffer(PMINI_ADAPTER Adapter);
 
 INT FreeAdapterDsxBuffer(PMINI_ADAPTER Adapter);
 ULONG SetUpTargetDsxBuffers(PMINI_ADAPTER Adapter);
 
-BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer);
+BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter, PVOID pvBuffer);
 
 
 #pragma pack (pop)
diff --git a/drivers/staging/bcm/DDRInit.c b/drivers/staging/bcm/DDRInit.c
index f4742e6..1789d08 100644
--- a/drivers/staging/bcm/DDRInit.c
+++ b/drivers/staging/bcm/DDRInit.c
@@ -8,526 +8,526 @@
 //DDR INIT-133Mhz
 #define T3_SKIP_CLOCK_PROGRAM_DUMP_133MHZ 12  //index for 0x0F007000
 static DDR_SET_NODE asT3_DDRSetting133MHz[]= {//      # DPLL Clock Setting
-	{0x0F000800,0x00007212},
-	{0x0f000820,0x07F13FFF},
-	{0x0f000810,0x00000F95},
-	{0x0f000860,0x00000000},
-	{0x0f000880,0x000003DD},
+	{0x0F000800, 0x00007212},
+	{0x0f000820, 0x07F13FFF},
+	{0x0f000810, 0x00000F95},
+	{0x0f000860, 0x00000000},
+	{0x0f000880, 0x000003DD},
 	// Changed source for X-bar and MIPS clock to APLL
-	{0x0f000840,0x0FFF1B00},
-	{0x0f000870,0x00000002},
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0F00a084,0x1Cffffff},
-	{0x0F00a080,0x1C000000},
-	{0x0F00a04C,0x0000000C},
+	{0x0f000840, 0x0FFF1B00},
+	{0x0f000870, 0x00000002},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0F00a084, 0x1Cffffff},
+	{0x0F00a080, 0x1C000000},
+	{0x0F00a04C, 0x0000000C},
 	//Memcontroller Default values
-	{0x0F007000,0x00010001},
-	{0x0F007004,0x01010100},
-	{0x0F007008,0x01000001},
-	{0x0F00700c,0x00000000},
-	{0x0F007010,0x01000000},
-	{0x0F007014,0x01000100},
-	{0x0F007018,0x01000000},
-	{0x0F00701c,0x01020001},// POP - 0x00020001 Normal 0x01020001
-	{0x0F007020,0x04030107}, //Normal - 0x04030107 POP - 0x05030107
-	{0x0F007024,0x02000007},
-	{0x0F007028,0x02020202},
-	{0x0F00702c,0x0206060a},//ROB- 0x0205050a,//0x0206060a
-	{0x0F007030,0x05000000},
-	{0x0F007034,0x00000003},
-	{0x0F007038,0x110a0200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
-	{0x0F00703C,0x02101010},//ROB - 0x02101010,//0x02101018},
-	{0x0F007040,0x45751200},//ROB - 0x45751200,//0x450f1200},
-	{0x0F007044,0x110a0d00},//ROB - 0x110a0d00//0x111f0d00
-	{0x0F007048,0x081b0306},
-	{0x0F00704c,0x00000000},
-	{0x0F007050,0x0000001c},
-	{0x0F007054,0x00000000},
-	{0x0F007058,0x00000000},
-	{0x0F00705c,0x00000000},
-	{0x0F007060,0x0010246c},
-	{0x0F007064,0x00000010},
-	{0x0F007068,0x00000000},
-	{0x0F00706c,0x00000001},
-	{0x0F007070,0x00007000},
-	{0x0F007074,0x00000000},
-	{0x0F007078,0x00000000},
-	{0x0F00707C,0x00000000},
-	{0x0F007080,0x00000000},
-	{0x0F007084,0x00000000},
+	{0x0F007000, 0x00010001},
+	{0x0F007004, 0x01010100},
+	{0x0F007008, 0x01000001},
+	{0x0F00700c, 0x00000000},
+	{0x0F007010, 0x01000000},
+	{0x0F007014, 0x01000100},
+	{0x0F007018, 0x01000000},
+	{0x0F00701c, 0x01020001},// POP - 0x00020001 Normal 0x01020001
+	{0x0F007020, 0x04030107}, //Normal - 0x04030107 POP - 0x05030107
+	{0x0F007024, 0x02000007},
+	{0x0F007028, 0x02020202},
+	{0x0F00702c, 0x0206060a},//ROB- 0x0205050a,//0x0206060a
+	{0x0F007030, 0x05000000},
+	{0x0F007034, 0x00000003},
+	{0x0F007038, 0x110a0200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
+	{0x0F00703C, 0x02101010},//ROB - 0x02101010,//0x02101018},
+	{0x0F007040, 0x45751200},//ROB - 0x45751200,//0x450f1200},
+	{0x0F007044, 0x110a0d00},//ROB - 0x110a0d00//0x111f0d00
+	{0x0F007048, 0x081b0306},
+	{0x0F00704c, 0x00000000},
+	{0x0F007050, 0x0000001c},
+	{0x0F007054, 0x00000000},
+	{0x0F007058, 0x00000000},
+	{0x0F00705c, 0x00000000},
+	{0x0F007060, 0x0010246c},
+	{0x0F007064, 0x00000010},
+	{0x0F007068, 0x00000000},
+	{0x0F00706c, 0x00000001},
+	{0x0F007070, 0x00007000},
+	{0x0F007074, 0x00000000},
+	{0x0F007078, 0x00000000},
+	{0x0F00707C, 0x00000000},
+	{0x0F007080, 0x00000000},
+	{0x0F007084, 0x00000000},
 	//# Enable BW improvement within memory controller
-	{0x0F007094,0x00000104},
+	{0x0F007094, 0x00000104},
 	//# Enable 2 ports within X-bar
-	{0x0F00A000,0x00000016},
+	{0x0F00A000, 0x00000016},
 	//# Enable start bit within memory controller
-	{0x0F007018,0x01010000}
+	{0x0F007018, 0x01010000}
 };
 //80Mhz
 #define T3_SKIP_CLOCK_PROGRAM_DUMP_80MHZ 10  //index for 0x0F007000
 static DDR_SET_NODE asT3_DDRSetting80MHz[]= {//   # DPLL Clock Setting
-	{0x0f000810,0x00000F95},
-	{0x0f000820,0x07f1ffff},
-	{0x0f000860,0x00000000},
-	{0x0f000880,0x000003DD},
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0F00a084,0x1Cffffff},
-	{0x0F00a080,0x1C000000},
-	{0x0F00a000,0x00000016},
-	{0x0F00a04C,0x0000000C},
+	{0x0f000810, 0x00000F95},
+	{0x0f000820, 0x07f1ffff},
+	{0x0f000860, 0x00000000},
+	{0x0f000880, 0x000003DD},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0F00a084, 0x1Cffffff},
+	{0x0F00a080, 0x1C000000},
+	{0x0F00a000, 0x00000016},
+	{0x0F00a04C, 0x0000000C},
 	//Memcontroller Default values
-	{0x0F007000,0x00010001},
-	{0x0F007004,0x01000000},
-	{0x0F007008,0x01000001},
-	{0x0F00700c,0x00000000},
-	{0x0F007010,0x01000000},
-	{0x0F007014,0x01000100},
-	{0x0F007018,0x01000000},
-	{0x0F00701c,0x01020000},
-	{0x0F007020,0x04020107},
-	{0x0F007024,0x00000007},
-	{0x0F007028,0x02020201},
-	{0x0F00702c,0x0204040a},
-	{0x0F007030,0x04000000},
-	{0x0F007034,0x00000002},
-	{0x0F007038,0x1F060200},
-	{0x0F00703C,0x1C22221F},
-	{0x0F007040,0x8A006600},
-	{0x0F007044,0x221a0800},
-	{0x0F007048,0x02690204},
-	{0x0F00704c,0x00000000},
-	{0x0F007050,0x0000001c},
-	{0x0F007054,0x00000000},
-	{0x0F007058,0x00000000},
-	{0x0F00705c,0x00000000},
-	{0x0F007060,0x000A15D6},
-	{0x0F007064,0x0000000A},
-	{0x0F007068,0x00000000},
-	{0x0F00706c,0x00000001},
-	{0x0F007070,0x00004000},
-	{0x0F007074,0x00000000},
-	{0x0F007078,0x00000000},
-	{0x0F00707C,0x00000000},
-	{0x0F007080,0x00000000},
-	{0x0F007084,0x00000000},
-	{0x0F007094,0x00000104},
+	{0x0F007000, 0x00010001},
+	{0x0F007004, 0x01000000},
+	{0x0F007008, 0x01000001},
+	{0x0F00700c, 0x00000000},
+	{0x0F007010, 0x01000000},
+	{0x0F007014, 0x01000100},
+	{0x0F007018, 0x01000000},
+	{0x0F00701c, 0x01020000},
+	{0x0F007020, 0x04020107},
+	{0x0F007024, 0x00000007},
+	{0x0F007028, 0x02020201},
+	{0x0F00702c, 0x0204040a},
+	{0x0F007030, 0x04000000},
+	{0x0F007034, 0x00000002},
+	{0x0F007038, 0x1F060200},
+	{0x0F00703C, 0x1C22221F},
+	{0x0F007040, 0x8A006600},
+	{0x0F007044, 0x221a0800},
+	{0x0F007048, 0x02690204},
+	{0x0F00704c, 0x00000000},
+	{0x0F007050, 0x0000001c},
+	{0x0F007054, 0x00000000},
+	{0x0F007058, 0x00000000},
+	{0x0F00705c, 0x00000000},
+	{0x0F007060, 0x000A15D6},
+	{0x0F007064, 0x0000000A},
+	{0x0F007068, 0x00000000},
+	{0x0F00706c, 0x00000001},
+	{0x0F007070, 0x00004000},
+	{0x0F007074, 0x00000000},
+	{0x0F007078, 0x00000000},
+	{0x0F00707C, 0x00000000},
+	{0x0F007080, 0x00000000},
+	{0x0F007084, 0x00000000},
+	{0x0F007094, 0x00000104},
 	//# Enable start bit within memory controller
-	{0x0F007018,0x01010000}
+	{0x0F007018, 0x01010000}
 };
 //100Mhz
 #define T3_SKIP_CLOCK_PROGRAM_DUMP_100MHZ 13  //index for 0x0F007000
 static DDR_SET_NODE asT3_DDRSetting100MHz[]= {//  # DPLL Clock Setting
-	{0x0F000800,0x00007008},
-	{0x0f000810,0x00000F95},
-	{0x0f000820,0x07F13E3F},
-	{0x0f000860,0x00000000},
-	{0x0f000880,0x000003DD},
+	{0x0F000800, 0x00007008},
+	{0x0f000810, 0x00000F95},
+	{0x0f000820, 0x07F13E3F},
+	{0x0f000860, 0x00000000},
+	{0x0f000880, 0x000003DD},
 	// Changed source for X-bar and MIPS clock to APLL
-	//0x0f000840,0x0FFF1800,
-	{0x0f000840,0x0FFF1B00},
-	{0x0f000870,0x00000002},
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0F00a084,0x1Cffffff},
-	{0x0F00a080,0x1C000000},
-	{0x0F00a04C,0x0000000C},
+	//0x0f000840, 0x0FFF1800,
+	{0x0f000840, 0x0FFF1B00},
+	{0x0f000870, 0x00000002},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0F00a084, 0x1Cffffff},
+	{0x0F00a080, 0x1C000000},
+	{0x0F00a04C, 0x0000000C},
 	//# Enable 2 ports within X-bar
-	{0x0F00A000,0x00000016},
+	{0x0F00A000, 0x00000016},
 	//Memcontroller Default values
-	{0x0F007000,0x00010001},
-	{0x0F007004,0x01010100},
-	{0x0F007008,0x01000001},
-	{0x0F00700c,0x00000000},
-	{0x0F007010,0x01000000},
-	{0x0F007014,0x01000100},
-	{0x0F007018,0x01000000},
-	{0x0F00701c,0x01020001}, // POP - 0x00020000 Normal 0x01020000
-	{0x0F007020,0x04020107},//Normal - 0x04030107 POP - 0x05030107
-	{0x0F007024,0x00000007},
-	{0x0F007028,0x01020201},
-	{0x0F00702c,0x0204040A},
-	{0x0F007030,0x06000000},
-	{0x0F007034,0x00000004},
-	{0x0F007038,0x20080200},
-	{0x0F00703C,0x02030320},
-	{0x0F007040,0x6E7F1200},
-	{0x0F007044,0x01190A00},
-	{0x0F007048,0x06120305},//0x02690204 // 0x06120305
-	{0x0F00704c,0x00000000},
-	{0x0F007050,0x0000001C},
-	{0x0F007054,0x00000000},
-	{0x0F007058,0x00000000},
-	{0x0F00705c,0x00000000},
-	{0x0F007060,0x00082ED6},
-	{0x0F007064,0x0000000A},
-	{0x0F007068,0x00000000},
-	{0x0F00706c,0x00000001},
-	{0x0F007070,0x00005000},
-	{0x0F007074,0x00000000},
-	{0x0F007078,0x00000000},
-	{0x0F00707C,0x00000000},
-	{0x0F007080,0x00000000},
-	{0x0F007084,0x00000000},
+	{0x0F007000, 0x00010001},
+	{0x0F007004, 0x01010100},
+	{0x0F007008, 0x01000001},
+	{0x0F00700c, 0x00000000},
+	{0x0F007010, 0x01000000},
+	{0x0F007014, 0x01000100},
+	{0x0F007018, 0x01000000},
+	{0x0F00701c, 0x01020001}, // POP - 0x00020000 Normal 0x01020000
+	{0x0F007020, 0x04020107},//Normal - 0x04030107 POP - 0x05030107
+	{0x0F007024, 0x00000007},
+	{0x0F007028, 0x01020201},
+	{0x0F00702c, 0x0204040A},
+	{0x0F007030, 0x06000000},
+	{0x0F007034, 0x00000004},
+	{0x0F007038, 0x20080200},
+	{0x0F00703C, 0x02030320},
+	{0x0F007040, 0x6E7F1200},
+	{0x0F007044, 0x01190A00},
+	{0x0F007048, 0x06120305},//0x02690204 // 0x06120305
+	{0x0F00704c, 0x00000000},
+	{0x0F007050, 0x0000001C},
+	{0x0F007054, 0x00000000},
+	{0x0F007058, 0x00000000},
+	{0x0F00705c, 0x00000000},
+	{0x0F007060, 0x00082ED6},
+	{0x0F007064, 0x0000000A},
+	{0x0F007068, 0x00000000},
+	{0x0F00706c, 0x00000001},
+	{0x0F007070, 0x00005000},
+	{0x0F007074, 0x00000000},
+	{0x0F007078, 0x00000000},
+	{0x0F00707C, 0x00000000},
+	{0x0F007080, 0x00000000},
+	{0x0F007084, 0x00000000},
 	//# Enable BW improvement within memory controller
-	{0x0F007094,0x00000104},
+	{0x0F007094, 0x00000104},
 	//# Enable start bit within memory controller
-	{0x0F007018,0x01010000}
+	{0x0F007018, 0x01010000}
 };
 
 //Net T3B DDR Settings
 //DDR INIT-133Mhz
 static DDR_SET_NODE asDPLL_266MHZ[] = {
-	{0x0F000800,0x00007212},
-	{0x0f000820,0x07F13FFF},
-	{0x0f000810,0x00000F95},
-	{0x0f000860,0x00000000},
-	{0x0f000880,0x000003DD},
+	{0x0F000800, 0x00007212},
+	{0x0f000820, 0x07F13FFF},
+	{0x0f000810, 0x00000F95},
+	{0x0f000860, 0x00000000},
+	{0x0f000880, 0x000003DD},
 	// Changed source for X-bar and MIPS clock to APLL
-	{0x0f000840,0x0FFF1B00},
-	{0x0f000870,0x00000002}
+	{0x0f000840, 0x0FFF1B00},
+	{0x0f000870, 0x00000002}
 };
 
 #define T3B_SKIP_CLOCK_PROGRAM_DUMP_133MHZ 11  //index for 0x0F007000
 static DDR_SET_NODE asT3B_DDRSetting133MHz[] = {//      # DPLL Clock Setting
-	{0x0f000810,0x00000F95},
-	{0x0f000810,0x00000F95},
-	{0x0f000810,0x00000F95},
-	{0x0f000820,0x07F13652},
-	{0x0f000840,0x0FFF0800},
+	{0x0f000810, 0x00000F95},
+	{0x0f000810, 0x00000F95},
+	{0x0f000810, 0x00000F95},
+	{0x0f000820, 0x07F13652},
+	{0x0f000840, 0x0FFF0800},
 	// Changed source for X-bar and MIPS clock to APLL
-	{0x0f000880,0x000003DD},
-	{0x0f000860,0x00000000},
+	{0x0f000880, 0x000003DD},
+	{0x0f000860, 0x00000000},
 	// Changed source for X-bar and MIPS clock to APLL
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0F00a084,0x1Cffffff},
-	{0x0F00a080,0x1C000000},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0F00a084, 0x1Cffffff},
+	{0x0F00a080, 0x1C000000},
 	//# Enable 2 ports within X-bar
-	{0x0F00A000,0x00000016},
+	{0x0F00A000, 0x00000016},
 	//Memcontroller Default values
-	{0x0F007000,0x00010001},
-	{0x0F007004,0x01010100},
-	{0x0F007008,0x01000001},
-	{0x0F00700c,0x00000000},
-	{0x0F007010,0x01000000},
-	{0x0F007014,0x01000100},
-	{0x0F007018,0x01000000},
-	{0x0F00701c,0x01020001},// POP - 0x00020001 Normal 0x01020001
-	{0x0F007020,0x04030107}, //Normal - 0x04030107 POP - 0x05030107
-	{0x0F007024,0x02000007},
-	{0x0F007028,0x02020202},
-	{0x0F00702c,0x0206060a},//ROB- 0x0205050a,//0x0206060a
-	{0x0F007030,0x05000000},
-	{0x0F007034,0x00000003},
-	{0x0F007038,0x130a0200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
-	{0x0F00703C,0x02101012},//ROB - 0x02101010,//0x02101018},
-	{0x0F007040,0x457D1200},//ROB - 0x45751200,//0x450f1200},
-	{0x0F007044,0x11130d00},//ROB - 0x110a0d00//0x111f0d00
-	{0x0F007048,0x040D0306},
-	{0x0F00704c,0x00000000},
-	{0x0F007050,0x0000001c},
-	{0x0F007054,0x00000000},
-	{0x0F007058,0x00000000},
-	{0x0F00705c,0x00000000},
-	{0x0F007060,0x0010246c},
-	{0x0F007064,0x00000012},
-	{0x0F007068,0x00000000},
-	{0x0F00706c,0x00000001},
-	{0x0F007070,0x00007000},
-	{0x0F007074,0x00000000},
-	{0x0F007078,0x00000000},
-	{0x0F00707C,0x00000000},
-	{0x0F007080,0x00000000},
-	{0x0F007084,0x00000000},
+	{0x0F007000, 0x00010001},
+	{0x0F007004, 0x01010100},
+	{0x0F007008, 0x01000001},
+	{0x0F00700c, 0x00000000},
+	{0x0F007010, 0x01000000},
+	{0x0F007014, 0x01000100},
+	{0x0F007018, 0x01000000},
+	{0x0F00701c, 0x01020001},// POP - 0x00020001 Normal 0x01020001
+	{0x0F007020, 0x04030107}, //Normal - 0x04030107 POP - 0x05030107
+	{0x0F007024, 0x02000007},
+	{0x0F007028, 0x02020202},
+	{0x0F00702c, 0x0206060a},//ROB- 0x0205050a,//0x0206060a
+	{0x0F007030, 0x05000000},
+	{0x0F007034, 0x00000003},
+	{0x0F007038, 0x130a0200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
+	{0x0F00703C, 0x02101012},//ROB - 0x02101010,//0x02101018},
+	{0x0F007040, 0x457D1200},//ROB - 0x45751200,//0x450f1200},
+	{0x0F007044, 0x11130d00},//ROB - 0x110a0d00//0x111f0d00
+	{0x0F007048, 0x040D0306},
+	{0x0F00704c, 0x00000000},
+	{0x0F007050, 0x0000001c},
+	{0x0F007054, 0x00000000},
+	{0x0F007058, 0x00000000},
+	{0x0F00705c, 0x00000000},
+	{0x0F007060, 0x0010246c},
+	{0x0F007064, 0x00000012},
+	{0x0F007068, 0x00000000},
+	{0x0F00706c, 0x00000001},
+	{0x0F007070, 0x00007000},
+	{0x0F007074, 0x00000000},
+	{0x0F007078, 0x00000000},
+	{0x0F00707C, 0x00000000},
+	{0x0F007080, 0x00000000},
+	{0x0F007084, 0x00000000},
 	//# Enable BW improvement within memory controller
-	{0x0F007094,0x00000104},
+	{0x0F007094, 0x00000104},
 	//# Enable start bit within memory controller
-	{0x0F007018,0x01010000},
+	{0x0F007018, 0x01010000},
 };
 
 #define T3B_SKIP_CLOCK_PROGRAM_DUMP_80MHZ 9  //index for 0x0F007000
 static DDR_SET_NODE asT3B_DDRSetting80MHz[] = {//       # DPLL Clock Setting
-	{0x0f000810,0x00000F95},
-	{0x0f000820,0x07F13FFF},
-	{0x0f000840,0x0FFF1F00},
-	{0x0f000880,0x000003DD},
-	{0x0f000860,0x00000000},
+	{0x0f000810, 0x00000F95},
+	{0x0f000820, 0x07F13FFF},
+	{0x0f000840, 0x0FFF1F00},
+	{0x0f000880, 0x000003DD},
+	{0x0f000860, 0x00000000},
 
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0F00a084,0x1Cffffff},
-	{0x0F00a080,0x1C000000},
-	{0x0F00a000,0x00000016},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0F00a084, 0x1Cffffff},
+	{0x0F00a080, 0x1C000000},
+	{0x0F00a000, 0x00000016},
 	//Memcontroller Default values
-	{0x0F007000,0x00010001},
-	{0x0F007004,0x01000000},
-	{0x0F007008,0x01000001},
-	{0x0F00700c,0x00000000},
-	{0x0F007010,0x01000000},
-	{0x0F007014,0x01000100},
-	{0x0F007018,0x01000000},
-	{0x0F00701c,0x01020000},
-	{0x0F007020,0x04020107},
-	{0x0F007024,0x00000007},
-	{0x0F007028,0x02020201},
-	{0x0F00702c,0x0204040a},
-	{0x0F007030,0x04000000},
-	{0x0F007034,0x02000002},
-	{0x0F007038,0x1F060202},
-	{0x0F00703C,0x1C22221F},
-	{0x0F007040,0x8A006600},
-	{0x0F007044,0x221a0800},
-	{0x0F007048,0x02690204},
-	{0x0F00704c,0x00000000},
-	{0x0F007050,0x0100001c},
-	{0x0F007054,0x00000000},
-	{0x0F007058,0x00000000},
-	{0x0F00705c,0x00000000},
-	{0x0F007060,0x000A15D6},
-	{0x0F007064,0x0000000A},
-	{0x0F007068,0x00000000},
-	{0x0F00706c,0x00000001},
-	{0x0F007070,0x00004000},
-	{0x0F007074,0x00000000},
-	{0x0F007078,0x00000000},
-	{0x0F00707C,0x00000000},
-	{0x0F007080,0x00000000},
-	{0x0F007084,0x00000000},
-	{0x0F007094,0x00000104},
+	{0x0F007000, 0x00010001},
+	{0x0F007004, 0x01000000},
+	{0x0F007008, 0x01000001},
+	{0x0F00700c, 0x00000000},
+	{0x0F007010, 0x01000000},
+	{0x0F007014, 0x01000100},
+	{0x0F007018, 0x01000000},
+	{0x0F00701c, 0x01020000},
+	{0x0F007020, 0x04020107},
+	{0x0F007024, 0x00000007},
+	{0x0F007028, 0x02020201},
+	{0x0F00702c, 0x0204040a},
+	{0x0F007030, 0x04000000},
+	{0x0F007034, 0x02000002},
+	{0x0F007038, 0x1F060202},
+	{0x0F00703C, 0x1C22221F},
+	{0x0F007040, 0x8A006600},
+	{0x0F007044, 0x221a0800},
+	{0x0F007048, 0x02690204},
+	{0x0F00704c, 0x00000000},
+	{0x0F007050, 0x0100001c},
+	{0x0F007054, 0x00000000},
+	{0x0F007058, 0x00000000},
+	{0x0F00705c, 0x00000000},
+	{0x0F007060, 0x000A15D6},
+	{0x0F007064, 0x0000000A},
+	{0x0F007068, 0x00000000},
+	{0x0F00706c, 0x00000001},
+	{0x0F007070, 0x00004000},
+	{0x0F007074, 0x00000000},
+	{0x0F007078, 0x00000000},
+	{0x0F00707C, 0x00000000},
+	{0x0F007080, 0x00000000},
+	{0x0F007084, 0x00000000},
+	{0x0F007094, 0x00000104},
 	//# Enable start bit within memory controller
-	{0x0F007018,0x01010000}
+	{0x0F007018, 0x01010000}
 };
 
 //100Mhz
 #define T3B_SKIP_CLOCK_PROGRAM_DUMP_100MHZ 9  //index for 0x0F007000
 static DDR_SET_NODE asT3B_DDRSetting100MHz[] = {//      # DPLL Clock Setting
-	{0x0f000810,0x00000F95},
-	{0x0f000820,0x07F1369B},
-	{0x0f000840,0x0FFF0800},
-	{0x0f000880,0x000003DD},
-	{0x0f000860,0x00000000},
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0F00a084,0x1Cffffff},
-	{0x0F00a080,0x1C000000},
+	{0x0f000810, 0x00000F95},
+	{0x0f000820, 0x07F1369B},
+	{0x0f000840, 0x0FFF0800},
+	{0x0f000880, 0x000003DD},
+	{0x0f000860, 0x00000000},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0F00a084, 0x1Cffffff},
+	{0x0F00a080, 0x1C000000},
 	//# Enable 2 ports within X-bar
-	{0x0F00A000,0x00000016},
+	{0x0F00A000, 0x00000016},
 	//Memcontroller Default values
-	{0x0F007000,0x00010001},
-	{0x0F007004,0x01010100},
-	{0x0F007008,0x01000001},
-	{0x0F00700c,0x00000000},
-	{0x0F007010,0x01000000},
-	{0x0F007014,0x01000100},
-	{0x0F007018,0x01000000},
-	{0x0F00701c,0x01020000}, // POP - 0x00020000 Normal 0x01020000
-	{0x0F007020,0x04020107},//Normal - 0x04030107 POP - 0x05030107
-	{0x0F007024,0x00000007},
-	{0x0F007028,0x01020201},
-	{0x0F00702c,0x0204040A},
-	{0x0F007030,0x06000000},
-	{0x0F007034,0x02000004},
-	{0x0F007038,0x20080200},
-	{0x0F00703C,0x02030320},
-	{0x0F007040,0x6E7F1200},
-	{0x0F007044,0x01190A00},
-	{0x0F007048,0x06120305},//0x02690204 // 0x06120305
-	{0x0F00704c,0x00000000},
-	{0x0F007050,0x0100001C},
-	{0x0F007054,0x00000000},
-	{0x0F007058,0x00000000},
-	{0x0F00705c,0x00000000},
-	{0x0F007060,0x00082ED6},
-	{0x0F007064,0x0000000A},
-	{0x0F007068,0x00000000},
-	{0x0F00706c,0x00000001},
-	{0x0F007070,0x00005000},
-	{0x0F007074,0x00000000},
-	{0x0F007078,0x00000000},
-	{0x0F00707C,0x00000000},
-	{0x0F007080,0x00000000},
-	{0x0F007084,0x00000000},
+	{0x0F007000, 0x00010001},
+	{0x0F007004, 0x01010100},
+	{0x0F007008, 0x01000001},
+	{0x0F00700c, 0x00000000},
+	{0x0F007010, 0x01000000},
+	{0x0F007014, 0x01000100},
+	{0x0F007018, 0x01000000},
+	{0x0F00701c, 0x01020000}, // POP - 0x00020000 Normal 0x01020000
+	{0x0F007020, 0x04020107},//Normal - 0x04030107 POP - 0x05030107
+	{0x0F007024, 0x00000007},
+	{0x0F007028, 0x01020201},
+	{0x0F00702c, 0x0204040A},
+	{0x0F007030, 0x06000000},
+	{0x0F007034, 0x02000004},
+	{0x0F007038, 0x20080200},
+	{0x0F00703C, 0x02030320},
+	{0x0F007040, 0x6E7F1200},
+	{0x0F007044, 0x01190A00},
+	{0x0F007048, 0x06120305},//0x02690204 // 0x06120305
+	{0x0F00704c, 0x00000000},
+	{0x0F007050, 0x0100001C},
+	{0x0F007054, 0x00000000},
+	{0x0F007058, 0x00000000},
+	{0x0F00705c, 0x00000000},
+	{0x0F007060, 0x00082ED6},
+	{0x0F007064, 0x0000000A},
+	{0x0F007068, 0x00000000},
+	{0x0F00706c, 0x00000001},
+	{0x0F007070, 0x00005000},
+	{0x0F007074, 0x00000000},
+	{0x0F007078, 0x00000000},
+	{0x0F00707C, 0x00000000},
+	{0x0F007080, 0x00000000},
+	{0x0F007084, 0x00000000},
 	//# Enable BW improvement within memory controller
-	{0x0F007094,0x00000104},
+	{0x0F007094, 0x00000104},
 	//# Enable start bit within memory controller
-	{0x0F007018,0x01010000}
+	{0x0F007018, 0x01010000}
 };
 
 
 #define T3LP_SKIP_CLOCK_PROGRAM_DUMP_133MHZ 9  //index for 0x0F007000
 static DDR_SET_NODE asT3LP_DDRSetting133MHz[]= {//	# DPLL Clock Setting
-	{0x0f000820,0x03F1365B},
-	{0x0f000810,0x00002F95},
-	{0x0f000880,0x000003DD},
+	{0x0f000820, 0x03F1365B},
+	{0x0f000810, 0x00002F95},
+	{0x0f000880, 0x000003DD},
 	// Changed source for X-bar and MIPS clock to APLL
-	{0x0f000840,0x0FFF0000},
-	{0x0f000860,0x00000000},
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0F00a084,0x1Cffffff},
-	{0x0F00a080,0x1C000000},
-	{0x0F00A000,0x00000016},
+	{0x0f000840, 0x0FFF0000},
+	{0x0f000860, 0x00000000},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0F00a084, 0x1Cffffff},
+	{0x0F00a080, 0x1C000000},
+	{0x0F00A000, 0x00000016},
 	//Memcontroller Default values
-	{0x0F007000,0x00010001},
-	{0x0F007004,0x01010100},
-	{0x0F007008,0x01000001},
-	{0x0F00700c,0x00000000},
-	{0x0F007010,0x01000000},
-	{0x0F007014,0x01000100},
-	{0x0F007018,0x01000000},
-	{0x0F00701c,0x01020001},// POP - 0x00020001 Normal 0x01020001
-	{0x0F007020,0x04030107}, //Normal - 0x04030107 POP - 0x05030107
-	{0x0F007024,0x02000007},
-	{0x0F007028,0x02020200},
-	{0x0F00702c,0x0206060a},//ROB- 0x0205050a,//0x0206060a
-	{0x0F007030,0x05000000},
-	{0x0F007034,0x00000003},
-	{0x0F007038,0x200a0200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
-	{0x0F00703C,0x02101020},//ROB - 0x02101010,//0x02101018,
-	{0x0F007040,0x45711200},//ROB - 0x45751200,//0x450f1200,
-	{0x0F007044,0x110D0D00},//ROB - 0x110a0d00//0x111f0d00
-	{0x0F007048,0x04080306},
-	{0x0F00704c,0x00000000},
-	{0x0F007050,0x0100001c},
-	{0x0F007054,0x00000000},
-	{0x0F007058,0x00000000},
-	{0x0F00705c,0x00000000},
-	{0x0F007060,0x0010245F},
-	{0x0F007064,0x00000010},
-	{0x0F007068,0x00000000},
-	{0x0F00706c,0x00000001},
-	{0x0F007070,0x00007000},
-	{0x0F007074,0x00000000},
-	{0x0F007078,0x00000000},
-	{0x0F00707C,0x00000000},
-	{0x0F007080,0x00000000},
-	{0x0F007084,0x00000000},
-	{0x0F007088,0x01000001},
-	{0x0F00708c,0x00000101},
-	{0x0F007090,0x00000000},
+	{0x0F007000, 0x00010001},
+	{0x0F007004, 0x01010100},
+	{0x0F007008, 0x01000001},
+	{0x0F00700c, 0x00000000},
+	{0x0F007010, 0x01000000},
+	{0x0F007014, 0x01000100},
+	{0x0F007018, 0x01000000},
+	{0x0F00701c, 0x01020001},// POP - 0x00020001 Normal 0x01020001
+	{0x0F007020, 0x04030107}, //Normal - 0x04030107 POP - 0x05030107
+	{0x0F007024, 0x02000007},
+	{0x0F007028, 0x02020200},
+	{0x0F00702c, 0x0206060a},//ROB- 0x0205050a,//0x0206060a
+	{0x0F007030, 0x05000000},
+	{0x0F007034, 0x00000003},
+	{0x0F007038, 0x200a0200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
+	{0x0F00703C, 0x02101020},//ROB - 0x02101010,//0x02101018,
+	{0x0F007040, 0x45711200},//ROB - 0x45751200,//0x450f1200,
+	{0x0F007044, 0x110D0D00},//ROB - 0x110a0d00//0x111f0d00
+	{0x0F007048, 0x04080306},
+	{0x0F00704c, 0x00000000},
+	{0x0F007050, 0x0100001c},
+	{0x0F007054, 0x00000000},
+	{0x0F007058, 0x00000000},
+	{0x0F00705c, 0x00000000},
+	{0x0F007060, 0x0010245F},
+	{0x0F007064, 0x00000010},
+	{0x0F007068, 0x00000000},
+	{0x0F00706c, 0x00000001},
+	{0x0F007070, 0x00007000},
+	{0x0F007074, 0x00000000},
+	{0x0F007078, 0x00000000},
+	{0x0F00707C, 0x00000000},
+	{0x0F007080, 0x00000000},
+	{0x0F007084, 0x00000000},
+	{0x0F007088, 0x01000001},
+	{0x0F00708c, 0x00000101},
+	{0x0F007090, 0x00000000},
 	//# Enable BW improvement within memory controller
-	{0x0F007094,0x00040000},
-	{0x0F007098,0x00000000},
-	{0x0F0070c8,0x00000104},
+	{0x0F007094, 0x00040000},
+	{0x0F007098, 0x00000000},
+	{0x0F0070c8, 0x00000104},
 	//# Enable 2 ports within X-bar
 	//# Enable start bit within memory controller
-	{0x0F007018,0x01010000}
+	{0x0F007018, 0x01010000}
 };
 
 #define T3LP_SKIP_CLOCK_PROGRAM_DUMP_100MHZ 11  //index for 0x0F007000
 static DDR_SET_NODE asT3LP_DDRSetting100MHz[]= {//	# DPLL Clock Setting
-	{0x0f000810,0x00002F95},
-	{0x0f000820,0x03F1369B},
-	{0x0f000840,0x0fff0000},
-	{0x0f000860,0x00000000},
-	{0x0f000880,0x000003DD},
+	{0x0f000810, 0x00002F95},
+	{0x0f000820, 0x03F1369B},
+	{0x0f000840, 0x0fff0000},
+	{0x0f000860, 0x00000000},
+	{0x0f000880, 0x000003DD},
 	// Changed source for X-bar and MIPS clock to APLL
-	{0x0f000840,0x0FFF0000},
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0F00a084,0x1Cffffff},
-	{0x0F00a080,0x1C000000},
+	{0x0f000840, 0x0FFF0000},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0F00a084, 0x1Cffffff},
+	{0x0F00a080, 0x1C000000},
 	//Memcontroller Default values
-	{0x0F007000,0x00010001},
-	{0x0F007004,0x01010100},
-	{0x0F007008,0x01000001},
-	{0x0F00700c,0x00000000},
-	{0x0F007010,0x01000000},
-	{0x0F007014,0x01000100},
-	{0x0F007018,0x01000000},
-	{0x0F00701c,0x01020000},// POP - 0x00020001 Normal 0x01020001
-	{0x0F007020,0x04020107}, //Normal - 0x04030107 POP - 0x05030107
-	{0x0F007024,0x00000007},
-	{0x0F007028,0x01020200},
-	{0x0F00702c,0x0204040a},//ROB- 0x0205050a,//0x0206060a
-	{0x0F007030,0x06000000},
-	{0x0F007034,0x00000004},
-	{0x0F007038,0x1F080200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
-	{0x0F00703C,0x0203031F},//ROB - 0x02101010,//0x02101018,
-	{0x0F007040,0x6e001200},//ROB - 0x45751200,//0x450f1200,
-	{0x0F007044,0x011a0a00},//ROB - 0x110a0d00//0x111f0d00
-	{0x0F007048,0x03000305},
-	{0x0F00704c,0x00000000},
-	{0x0F007050,0x0100001c},
-	{0x0F007054,0x00000000},
-	{0x0F007058,0x00000000},
-	{0x0F00705c,0x00000000},
-	{0x0F007060,0x00082ED6},
-	{0x0F007064,0x0000000A},
-	{0x0F007068,0x00000000},
-	{0x0F00706c,0x00000001},
-	{0x0F007070,0x00005000},
-	{0x0F007074,0x00000000},
-	{0x0F007078,0x00000000},
-	{0x0F00707C,0x00000000},
-	{0x0F007080,0x00000000},
-	{0x0F007084,0x00000000},
-	{0x0F007088,0x01000001},
-	{0x0F00708c,0x00000101},
-	{0x0F007090,0x00000000},
-	{0x0F007094,0x00010000},
-	{0x0F007098,0x00000000},
-	{0x0F0070C8,0x00000104},
+	{0x0F007000, 0x00010001},
+	{0x0F007004, 0x01010100},
+	{0x0F007008, 0x01000001},
+	{0x0F00700c, 0x00000000},
+	{0x0F007010, 0x01000000},
+	{0x0F007014, 0x01000100},
+	{0x0F007018, 0x01000000},
+	{0x0F00701c, 0x01020000},// POP - 0x00020001 Normal 0x01020001
+	{0x0F007020, 0x04020107}, //Normal - 0x04030107 POP - 0x05030107
+	{0x0F007024, 0x00000007},
+	{0x0F007028, 0x01020200},
+	{0x0F00702c, 0x0204040a},//ROB- 0x0205050a,//0x0206060a
+	{0x0F007030, 0x06000000},
+	{0x0F007034, 0x00000004},
+	{0x0F007038, 0x1F080200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
+	{0x0F00703C, 0x0203031F},//ROB - 0x02101010,//0x02101018,
+	{0x0F007040, 0x6e001200},//ROB - 0x45751200,//0x450f1200,
+	{0x0F007044, 0x011a0a00},//ROB - 0x110a0d00//0x111f0d00
+	{0x0F007048, 0x03000305},
+	{0x0F00704c, 0x00000000},
+	{0x0F007050, 0x0100001c},
+	{0x0F007054, 0x00000000},
+	{0x0F007058, 0x00000000},
+	{0x0F00705c, 0x00000000},
+	{0x0F007060, 0x00082ED6},
+	{0x0F007064, 0x0000000A},
+	{0x0F007068, 0x00000000},
+	{0x0F00706c, 0x00000001},
+	{0x0F007070, 0x00005000},
+	{0x0F007074, 0x00000000},
+	{0x0F007078, 0x00000000},
+	{0x0F00707C, 0x00000000},
+	{0x0F007080, 0x00000000},
+	{0x0F007084, 0x00000000},
+	{0x0F007088, 0x01000001},
+	{0x0F00708c, 0x00000101},
+	{0x0F007090, 0x00000000},
+	{0x0F007094, 0x00010000},
+	{0x0F007098, 0x00000000},
+	{0x0F0070C8, 0x00000104},
 	//# Enable 2 ports within X-bar
-	{0x0F00A000,0x00000016},
+	{0x0F00A000, 0x00000016},
 	//# Enable start bit within memory controller
-	{0x0F007018,0x01010000}
+	{0x0F007018, 0x01010000}
 };
 
 #define T3LP_SKIP_CLOCK_PROGRAM_DUMP_80MHZ 9  //index for 0x0F007000
 static DDR_SET_NODE asT3LP_DDRSetting80MHz[]= {//	# DPLL Clock Setting
-	{0x0f000820,0x07F13FFF},
-	{0x0f000810,0x00002F95},
-	{0x0f000860,0x00000000},
-	{0x0f000880,0x000003DD},
-	{0x0f000840,0x0FFF1F00},
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0F00a084,0x1Cffffff},
-	{0x0F00a080,0x1C000000},
-	{0x0F00A000,0x00000016},
-	{0x0f007000,0x00010001},
-	{0x0f007004,0x01000000},
-	{0x0f007008,0x01000001},
-	{0x0f00700c,0x00000000},
-	{0x0f007010,0x01000000},
-	{0x0f007014,0x01000100},
-	{0x0f007018,0x01000000},
-	{0x0f00701c,0x01020000},
-	{0x0f007020,0x04020107},
-	{0x0f007024,0x00000007},
-	{0x0f007028,0x02020200},
-	{0x0f00702c,0x0204040a},
-	{0x0f007030,0x04000000},
-	{0x0f007034,0x00000002},
-	{0x0f007038,0x1d060200},
-	{0x0f00703c,0x1c22221d},
-	{0x0f007040,0x8A116600},
-	{0x0f007044,0x222d0800},
-	{0x0f007048,0x02690204},
-	{0x0f00704c,0x00000000},
-	{0x0f007050,0x0100001c},
-	{0x0f007054,0x00000000},
-	{0x0f007058,0x00000000},
-	{0x0f00705c,0x00000000},
-	{0x0f007060,0x000A15D6},
-	{0x0f007064,0x0000000A},
-	{0x0f007068,0x00000000},
-	{0x0f00706c,0x00000001},
-	{0x0f007070,0x00004000},
-	{0x0f007074,0x00000000},
-	{0x0f007078,0x00000000},
-	{0x0f00707c,0x00000000},
-	{0x0f007080,0x00000000},
-	{0x0f007084,0x00000000},
-	{0x0f007088,0x01000001},
-	{0x0f00708c,0x00000101},
-	{0x0f007090,0x00000000},
-	{0x0f007094,0x00010000},
-	{0x0f007098,0x00000000},
-	{0x0F0070C8,0x00000104},
-	{0x0F007018,0x01010000}
+	{0x0f000820, 0x07F13FFF},
+	{0x0f000810, 0x00002F95},
+	{0x0f000860, 0x00000000},
+	{0x0f000880, 0x000003DD},
+	{0x0f000840, 0x0FFF1F00},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0F00a084, 0x1Cffffff},
+	{0x0F00a080, 0x1C000000},
+	{0x0F00A000, 0x00000016},
+	{0x0f007000, 0x00010001},
+	{0x0f007004, 0x01000000},
+	{0x0f007008, 0x01000001},
+	{0x0f00700c, 0x00000000},
+	{0x0f007010, 0x01000000},
+	{0x0f007014, 0x01000100},
+	{0x0f007018, 0x01000000},
+	{0x0f00701c, 0x01020000},
+	{0x0f007020, 0x04020107},
+	{0x0f007024, 0x00000007},
+	{0x0f007028, 0x02020200},
+	{0x0f00702c, 0x0204040a},
+	{0x0f007030, 0x04000000},
+	{0x0f007034, 0x00000002},
+	{0x0f007038, 0x1d060200},
+	{0x0f00703c, 0x1c22221d},
+	{0x0f007040, 0x8A116600},
+	{0x0f007044, 0x222d0800},
+	{0x0f007048, 0x02690204},
+	{0x0f00704c, 0x00000000},
+	{0x0f007050, 0x0100001c},
+	{0x0f007054, 0x00000000},
+	{0x0f007058, 0x00000000},
+	{0x0f00705c, 0x00000000},
+	{0x0f007060, 0x000A15D6},
+	{0x0f007064, 0x0000000A},
+	{0x0f007068, 0x00000000},
+	{0x0f00706c, 0x00000001},
+	{0x0f007070, 0x00004000},
+	{0x0f007074, 0x00000000},
+	{0x0f007078, 0x00000000},
+	{0x0f00707c, 0x00000000},
+	{0x0f007080, 0x00000000},
+	{0x0f007084, 0x00000000},
+	{0x0f007088, 0x01000001},
+	{0x0f00708c, 0x00000101},
+	{0x0f007090, 0x00000000},
+	{0x0f007094, 0x00010000},
+	{0x0f007098, 0x00000000},
+	{0x0F0070C8, 0x00000104},
+	{0x0F007018, 0x01010000}
 };
 
 
@@ -538,237 +538,237 @@ static DDR_SET_NODE asT3LP_DDRSetting80MHz[]= {//	# DPLL Clock Setting
 #define T3LPB_SKIP_CLOCK_PROGRAM_DUMP_160MHZ 7  //index for 0x0F007000
 static DDR_SET_NODE asT3LPB_DDRSetting160MHz[]= {//	# DPLL Clock Setting
 
-	{0x0f000820,0x03F137DB},
-	{0x0f000810,0x01842795},
-	{0x0f000860,0x00000000},
-	{0x0f000880,0x000003DD},
-	{0x0f000840,0x0FFF0400},
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0f003050,0x00000021},//this is flash/eeprom clock divisor which set the flash clock to 20 MHz
-	{0x0F00a084,0x1Cffffff},//Now dump from her in internal memory
-	{0x0F00a080,0x1C000000},
-	{0x0F00A000,0x00000016},
-	{0x0f007000,0x00010001},
-	{0x0f007004,0x01000001},
-	{0x0f007008,0x01000101},
-	{0x0f00700c,0x00000000},
-	{0x0f007010,0x01000100},
-	{0x0f007014,0x01000100},
-	{0x0f007018,0x01000000},
-	{0x0f00701c,0x01020000},
-	{0x0f007020,0x04030107},
-	{0x0f007024,0x02000007},
-	{0x0f007028,0x02020200},
-	{0x0f00702c,0x0206060a},
-	{0x0f007030,0x050d0d00},
-	{0x0f007034,0x00000003},
-	{0x0f007038,0x170a0200},
-	{0x0f00703c,0x02101012},
-	{0x0f007040,0x45161200},
-	{0x0f007044,0x11250c00},
-	{0x0f007048,0x04da0307},
-	{0x0f00704c,0x00000000},
-	{0x0f007050,0x0000001c},
-	{0x0f007054,0x00000000},
-	{0x0f007058,0x00000000},
-	{0x0f00705c,0x00000000},
-	{0x0f007060,0x00142bb6},
-	{0x0f007064,0x20430014},
-	{0x0f007068,0x00000000},
-	{0x0f00706c,0x00000001},
-	{0x0f007070,0x00009000},
-	{0x0f007074,0x00000000},
-	{0x0f007078,0x00000000},
-	{0x0f00707c,0x00000000},
-	{0x0f007080,0x00000000},
-	{0x0f007084,0x00000000},
-	{0x0f007088,0x01000001},
-	{0x0f00708c,0x00000101},
-	{0x0f007090,0x00000000},
-	{0x0f007094,0x00040000},
-	{0x0f007098,0x00000000},
-	{0x0F0070C8,0x00000104},
-	{0x0F007018,0x01010000}
+	{0x0f000820, 0x03F137DB},
+	{0x0f000810, 0x01842795},
+	{0x0f000860, 0x00000000},
+	{0x0f000880, 0x000003DD},
+	{0x0f000840, 0x0FFF0400},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0f003050, 0x00000021},//this is flash/eeprom clock divisor which set the flash clock to 20 MHz
+	{0x0F00a084, 0x1Cffffff},//Now dump from her in internal memory
+	{0x0F00a080, 0x1C000000},
+	{0x0F00A000, 0x00000016},
+	{0x0f007000, 0x00010001},
+	{0x0f007004, 0x01000001},
+	{0x0f007008, 0x01000101},
+	{0x0f00700c, 0x00000000},
+	{0x0f007010, 0x01000100},
+	{0x0f007014, 0x01000100},
+	{0x0f007018, 0x01000000},
+	{0x0f00701c, 0x01020000},
+	{0x0f007020, 0x04030107},
+	{0x0f007024, 0x02000007},
+	{0x0f007028, 0x02020200},
+	{0x0f00702c, 0x0206060a},
+	{0x0f007030, 0x050d0d00},
+	{0x0f007034, 0x00000003},
+	{0x0f007038, 0x170a0200},
+	{0x0f00703c, 0x02101012},
+	{0x0f007040, 0x45161200},
+	{0x0f007044, 0x11250c00},
+	{0x0f007048, 0x04da0307},
+	{0x0f00704c, 0x00000000},
+	{0x0f007050, 0x0000001c},
+	{0x0f007054, 0x00000000},
+	{0x0f007058, 0x00000000},
+	{0x0f00705c, 0x00000000},
+	{0x0f007060, 0x00142bb6},
+	{0x0f007064, 0x20430014},
+	{0x0f007068, 0x00000000},
+	{0x0f00706c, 0x00000001},
+	{0x0f007070, 0x00009000},
+	{0x0f007074, 0x00000000},
+	{0x0f007078, 0x00000000},
+	{0x0f00707c, 0x00000000},
+	{0x0f007080, 0x00000000},
+	{0x0f007084, 0x00000000},
+	{0x0f007088, 0x01000001},
+	{0x0f00708c, 0x00000101},
+	{0x0f007090, 0x00000000},
+	{0x0f007094, 0x00040000},
+	{0x0f007098, 0x00000000},
+	{0x0F0070C8, 0x00000104},
+	{0x0F007018, 0x01010000}
 };
 
 
 #define T3LPB_SKIP_CLOCK_PROGRAM_DUMP_133MHZ 7  //index for 0x0F007000
 static DDR_SET_NODE asT3LPB_DDRSetting133MHz[]= {//	# DPLL Clock Setting
-	{0x0f000820,0x03F1365B},
-	{0x0f000810,0x00002F95},
-	{0x0f000880,0x000003DD},
+	{0x0f000820, 0x03F1365B},
+	{0x0f000810, 0x00002F95},
+	{0x0f000880, 0x000003DD},
 	// Changed source for X-bar and MIPS clock to APLL
-	{0x0f000840,0x0FFF0000},
-	{0x0f000860,0x00000000},
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0f003050,0x00000021},//flash/eeprom clock divisor which set the flash clock to 20 MHz
-	{0x0F00a084,0x1Cffffff},//dump from here in internal memory
-	{0x0F00a080,0x1C000000},
-	{0x0F00A000,0x00000016},
+	{0x0f000840, 0x0FFF0000},
+	{0x0f000860, 0x00000000},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0f003050, 0x00000021},//flash/eeprom clock divisor which set the flash clock to 20 MHz
+	{0x0F00a084, 0x1Cffffff},//dump from here in internal memory
+	{0x0F00a080, 0x1C000000},
+	{0x0F00A000, 0x00000016},
 	//Memcontroller Default values
-	{0x0F007000,0x00010001},
-	{0x0F007004,0x01010100},
-	{0x0F007008,0x01000001},
-	{0x0F00700c,0x00000000},
-	{0x0F007010,0x01000000},
-	{0x0F007014,0x01000100},
-	{0x0F007018,0x01000000},
-	{0x0F00701c,0x01020001},// POP - 0x00020001 Normal 0x01020001
-	{0x0F007020,0x04030107}, //Normal - 0x04030107 POP - 0x05030107
-	{0x0F007024,0x02000007},
-	{0x0F007028,0x02020200},
-	{0x0F00702c,0x0206060a},//ROB- 0x0205050a,//0x0206060a
-	{0x0F007030,0x05000000},
-	{0x0F007034,0x00000003},
-	{0x0F007038,0x190a0200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
-	{0x0F00703C,0x02101017},//ROB - 0x02101010,//0x02101018,
-	{0x0F007040,0x45171200},//ROB - 0x45751200,//0x450f1200,
-	{0x0F007044,0x11290D00},//ROB - 0x110a0d00//0x111f0d00
-	{0x0F007048,0x04080306},
-	{0x0F00704c,0x00000000},
-	{0x0F007050,0x0100001c},
-	{0x0F007054,0x00000000},
-	{0x0F007058,0x00000000},
-	{0x0F00705c,0x00000000},
-	{0x0F007060,0x0010245F},
-	{0x0F007064,0x00000010},
-	{0x0F007068,0x00000000},
-	{0x0F00706c,0x00000001},
-	{0x0F007070,0x00007000},
-	{0x0F007074,0x00000000},
-	{0x0F007078,0x00000000},
-	{0x0F00707C,0x00000000},
-	{0x0F007080,0x00000000},
-	{0x0F007084,0x00000000},
-	{0x0F007088,0x01000001},
-	{0x0F00708c,0x00000101},
-	{0x0F007090,0x00000000},
+	{0x0F007000, 0x00010001},
+	{0x0F007004, 0x01010100},
+	{0x0F007008, 0x01000001},
+	{0x0F00700c, 0x00000000},
+	{0x0F007010, 0x01000000},
+	{0x0F007014, 0x01000100},
+	{0x0F007018, 0x01000000},
+	{0x0F00701c, 0x01020001},// POP - 0x00020001 Normal 0x01020001
+	{0x0F007020, 0x04030107}, //Normal - 0x04030107 POP - 0x05030107
+	{0x0F007024, 0x02000007},
+	{0x0F007028, 0x02020200},
+	{0x0F00702c, 0x0206060a},//ROB- 0x0205050a,//0x0206060a
+	{0x0F007030, 0x05000000},
+	{0x0F007034, 0x00000003},
+	{0x0F007038, 0x190a0200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
+	{0x0F00703C, 0x02101017},//ROB - 0x02101010,//0x02101018,
+	{0x0F007040, 0x45171200},//ROB - 0x45751200,//0x450f1200,
+	{0x0F007044, 0x11290D00},//ROB - 0x110a0d00//0x111f0d00
+	{0x0F007048, 0x04080306},
+	{0x0F00704c, 0x00000000},
+	{0x0F007050, 0x0100001c},
+	{0x0F007054, 0x00000000},
+	{0x0F007058, 0x00000000},
+	{0x0F00705c, 0x00000000},
+	{0x0F007060, 0x0010245F},
+	{0x0F007064, 0x00000010},
+	{0x0F007068, 0x00000000},
+	{0x0F00706c, 0x00000001},
+	{0x0F007070, 0x00007000},
+	{0x0F007074, 0x00000000},
+	{0x0F007078, 0x00000000},
+	{0x0F00707C, 0x00000000},
+	{0x0F007080, 0x00000000},
+	{0x0F007084, 0x00000000},
+	{0x0F007088, 0x01000001},
+	{0x0F00708c, 0x00000101},
+	{0x0F007090, 0x00000000},
 	//# Enable BW improvement within memory controller
-	{0x0F007094,0x00040000},
-	{0x0F007098,0x00000000},
-	{0x0F0070c8,0x00000104},
+	{0x0F007094, 0x00040000},
+	{0x0F007098, 0x00000000},
+	{0x0F0070c8, 0x00000104},
 	//# Enable 2 ports within X-bar
 	//# Enable start bit within memory controller
-	{0x0F007018,0x01010000}
+	{0x0F007018, 0x01010000}
 };
 
 #define T3LPB_SKIP_CLOCK_PROGRAM_DUMP_100MHZ 8  //index for 0x0F007000
 static DDR_SET_NODE asT3LPB_DDRSetting100MHz[]= {//	# DPLL Clock Setting
-	{0x0f000810,0x00002F95},
-	{0x0f000820,0x03F1369B},
-	{0x0f000840,0x0fff0000},
-	{0x0f000860,0x00000000},
-	{0x0f000880,0x000003DD},
+	{0x0f000810, 0x00002F95},
+	{0x0f000820, 0x03F1369B},
+	{0x0f000840, 0x0fff0000},
+	{0x0f000860, 0x00000000},
+	{0x0f000880, 0x000003DD},
 	// Changed source for X-bar and MIPS clock to APLL
-	{0x0f000840,0x0FFF0000},
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0f003050,0x00000021},//flash/eeprom clock divisor which set the flash clock to 20 MHz
-	{0x0F00a084,0x1Cffffff}, //dump from here in internal memory
-	{0x0F00a080,0x1C000000},
+	{0x0f000840, 0x0FFF0000},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0f003050, 0x00000021},//flash/eeprom clock divisor which set the flash clock to 20 MHz
+	{0x0F00a084, 0x1Cffffff}, //dump from here in internal memory
+	{0x0F00a080, 0x1C000000},
 	//Memcontroller Default values
-	{0x0F007000,0x00010001},
-	{0x0F007004,0x01010100},
-	{0x0F007008,0x01000001},
-	{0x0F00700c,0x00000000},
-	{0x0F007010,0x01000000},
-	{0x0F007014,0x01000100},
-	{0x0F007018,0x01000000},
-	{0x0F00701c,0x01020000},// POP - 0x00020001 Normal 0x01020001
-	{0x0F007020,0x04020107}, //Normal - 0x04030107 POP - 0x05030107
-	{0x0F007024,0x00000007},
-	{0x0F007028,0x01020200},
-	{0x0F00702c,0x0204040a},//ROB- 0x0205050a,//0x0206060a
-	{0x0F007030,0x06000000},
-	{0x0F007034,0x00000004},
-	{0x0F007038,0x1F080200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
-	{0x0F00703C,0x0203031F},//ROB - 0x02101010,//0x02101018,
-	{0x0F007040,0x6e001200},//ROB - 0x45751200,//0x450f1200,
-	{0x0F007044,0x011a0a00},//ROB - 0x110a0d00//0x111f0d00
-	{0x0F007048,0x03000305},
-	{0x0F00704c,0x00000000},
-	{0x0F007050,0x0100001c},
-	{0x0F007054,0x00000000},
-	{0x0F007058,0x00000000},
-	{0x0F00705c,0x00000000},
-	{0x0F007060,0x00082ED6},
-	{0x0F007064,0x0000000A},
-	{0x0F007068,0x00000000},
-	{0x0F00706c,0x00000001},
-	{0x0F007070,0x00005000},
-	{0x0F007074,0x00000000},
-	{0x0F007078,0x00000000},
-	{0x0F00707C,0x00000000},
-	{0x0F007080,0x00000000},
-	{0x0F007084,0x00000000},
-	{0x0F007088,0x01000001},
-	{0x0F00708c,0x00000101},
-	{0x0F007090,0x00000000},
-	{0x0F007094,0x00010000},
-	{0x0F007098,0x00000000},
-	{0x0F0070C8,0x00000104},
+	{0x0F007000, 0x00010001},
+	{0x0F007004, 0x01010100},
+	{0x0F007008, 0x01000001},
+	{0x0F00700c, 0x00000000},
+	{0x0F007010, 0x01000000},
+	{0x0F007014, 0x01000100},
+	{0x0F007018, 0x01000000},
+	{0x0F00701c, 0x01020000},// POP - 0x00020001 Normal 0x01020001
+	{0x0F007020, 0x04020107}, //Normal - 0x04030107 POP - 0x05030107
+	{0x0F007024, 0x00000007},
+	{0x0F007028, 0x01020200},
+	{0x0F00702c, 0x0204040a},//ROB- 0x0205050a,//0x0206060a
+	{0x0F007030, 0x06000000},
+	{0x0F007034, 0x00000004},
+	{0x0F007038, 0x1F080200},//ROB - 0x110a0200,//0x180a0200,// 0x1f0a0200
+	{0x0F00703C, 0x0203031F},//ROB - 0x02101010,//0x02101018,
+	{0x0F007040, 0x6e001200},//ROB - 0x45751200,//0x450f1200,
+	{0x0F007044, 0x011a0a00},//ROB - 0x110a0d00//0x111f0d00
+	{0x0F007048, 0x03000305},
+	{0x0F00704c, 0x00000000},
+	{0x0F007050, 0x0100001c},
+	{0x0F007054, 0x00000000},
+	{0x0F007058, 0x00000000},
+	{0x0F00705c, 0x00000000},
+	{0x0F007060, 0x00082ED6},
+	{0x0F007064, 0x0000000A},
+	{0x0F007068, 0x00000000},
+	{0x0F00706c, 0x00000001},
+	{0x0F007070, 0x00005000},
+	{0x0F007074, 0x00000000},
+	{0x0F007078, 0x00000000},
+	{0x0F00707C, 0x00000000},
+	{0x0F007080, 0x00000000},
+	{0x0F007084, 0x00000000},
+	{0x0F007088, 0x01000001},
+	{0x0F00708c, 0x00000101},
+	{0x0F007090, 0x00000000},
+	{0x0F007094, 0x00010000},
+	{0x0F007098, 0x00000000},
+	{0x0F0070C8, 0x00000104},
 	//# Enable 2 ports within X-bar
-	{0x0F00A000,0x00000016},
+	{0x0F00A000, 0x00000016},
 	//# Enable start bit within memory controller
-	{0x0F007018,0x01010000}
+	{0x0F007018, 0x01010000}
 };
 
 #define T3LPB_SKIP_CLOCK_PROGRAM_DUMP_80MHZ 7  //index for 0x0F007000
 static DDR_SET_NODE asT3LPB_DDRSetting80MHz[]= {//	# DPLL Clock Setting
-	{0x0f000820,0x07F13FFF},
-	{0x0f000810,0x00002F95},
-	{0x0f000860,0x00000000},
-	{0x0f000880,0x000003DD},
-	{0x0f000840,0x0FFF1F00},
-	{0x0F00a044,0x1fffffff},
-	{0x0F00a040,0x1f000000},
-	{0x0f003050,0x00000021},//flash/eeprom clock divisor which set the flash clock to 20 MHz
-	{0x0F00a084,0x1Cffffff},// dump from here in internal memory
-	{0x0F00a080,0x1C000000},
-	{0x0F00A000,0x00000016},
-	{0x0f007000,0x00010001},
-	{0x0f007004,0x01000000},
-	{0x0f007008,0x01000001},
-	{0x0f00700c,0x00000000},
-	{0x0f007010,0x01000000},
-	{0x0f007014,0x01000100},
-	{0x0f007018,0x01000000},
-	{0x0f00701c,0x01020000},
-	{0x0f007020,0x04020107},
-	{0x0f007024,0x00000007},
-	{0x0f007028,0x02020200},
-	{0x0f00702c,0x0204040a},
-	{0x0f007030,0x04000000},
-	{0x0f007034,0x00000002},
-	{0x0f007038,0x1d060200},
-	{0x0f00703c,0x1c22221d},
-	{0x0f007040,0x8A116600},
-	{0x0f007044,0x222d0800},
-	{0x0f007048,0x02690204},
-	{0x0f00704c,0x00000000},
-	{0x0f007050,0x0100001c},
-	{0x0f007054,0x00000000},
-	{0x0f007058,0x00000000},
-	{0x0f00705c,0x00000000},
-	{0x0f007060,0x000A15D6},
-	{0x0f007064,0x0000000A},
-	{0x0f007068,0x00000000},
-	{0x0f00706c,0x00000001},
-	{0x0f007070,0x00004000},
-	{0x0f007074,0x00000000},
-	{0x0f007078,0x00000000},
-	{0x0f00707c,0x00000000},
-	{0x0f007080,0x00000000},
-	{0x0f007084,0x00000000},
-	{0x0f007088,0x01000001},
-	{0x0f00708c,0x00000101},
-	{0x0f007090,0x00000000},
-	{0x0f007094,0x00010000},
-	{0x0f007098,0x00000000},
-	{0x0F0070C8,0x00000104},
-	{0x0F007018,0x01010000}
+	{0x0f000820, 0x07F13FFF},
+	{0x0f000810, 0x00002F95},
+	{0x0f000860, 0x00000000},
+	{0x0f000880, 0x000003DD},
+	{0x0f000840, 0x0FFF1F00},
+	{0x0F00a044, 0x1fffffff},
+	{0x0F00a040, 0x1f000000},
+	{0x0f003050, 0x00000021},//flash/eeprom clock divisor which set the flash clock to 20 MHz
+	{0x0F00a084, 0x1Cffffff},// dump from here in internal memory
+	{0x0F00a080, 0x1C000000},
+	{0x0F00A000, 0x00000016},
+	{0x0f007000, 0x00010001},
+	{0x0f007004, 0x01000000},
+	{0x0f007008, 0x01000001},
+	{0x0f00700c, 0x00000000},
+	{0x0f007010, 0x01000000},
+	{0x0f007014, 0x01000100},
+	{0x0f007018, 0x01000000},
+	{0x0f00701c, 0x01020000},
+	{0x0f007020, 0x04020107},
+	{0x0f007024, 0x00000007},
+	{0x0f007028, 0x02020200},
+	{0x0f00702c, 0x0204040a},
+	{0x0f007030, 0x04000000},
+	{0x0f007034, 0x00000002},
+	{0x0f007038, 0x1d060200},
+	{0x0f00703c, 0x1c22221d},
+	{0x0f007040, 0x8A116600},
+	{0x0f007044, 0x222d0800},
+	{0x0f007048, 0x02690204},
+	{0x0f00704c, 0x00000000},
+	{0x0f007050, 0x0100001c},
+	{0x0f007054, 0x00000000},
+	{0x0f007058, 0x00000000},
+	{0x0f00705c, 0x00000000},
+	{0x0f007060, 0x000A15D6},
+	{0x0f007064, 0x0000000A},
+	{0x0f007068, 0x00000000},
+	{0x0f00706c, 0x00000001},
+	{0x0f007070, 0x00004000},
+	{0x0f007074, 0x00000000},
+	{0x0f007078, 0x00000000},
+	{0x0f00707c, 0x00000000},
+	{0x0f007080, 0x00000000},
+	{0x0f007084, 0x00000000},
+	{0x0f007088, 0x01000001},
+	{0x0f00708c, 0x00000101},
+	{0x0f007090, 0x00000000},
+	{0x0f007094, 0x00010000},
+	{0x0f007098, 0x00000000},
+	{0x0F0070C8, 0x00000104},
+	{0x0F007018, 0x01010000}
 };
 
 
@@ -820,7 +820,7 @@ int ddr_init(MINI_ADAPTER *Adapter)
 		if ( (Adapter->chip_id !=  BCS220_2) &&
 		    (Adapter->chip_id !=  BCS220_2BC) &&
 		    (Adapter->chip_id != BCS220_3) ) {
-			retval= rdmalt(Adapter,(UINT)0x0f000830, &uiResetValue, sizeof(uiResetValue));
+			retval= rdmalt(Adapter, (UINT)0x0f000830, &uiResetValue, sizeof(uiResetValue));
 			if (retval < 0) {
 				bcm_dbg(Adapter, CMHOST, RDM, ALL,
 					"%s:%d RDM failed\n",
@@ -828,7 +828,7 @@ int ddr_init(MINI_ADAPTER *Adapter)
 				return retval;
 			}
 			uiResetValue |= 0x44;
-			retval = wrmalt(Adapter,(UINT)0x0f000830, &uiResetValue, sizeof(uiResetValue));
+			retval = wrmalt(Adapter, (UINT)0x0f000830, &uiResetValue, sizeof(uiResetValue));
 			if (retval < 0) {
 				bcm_dbg(Adapter, CMHOST, WRM, ALL,
 					"%s:%d WRM failed\n",
@@ -1010,14 +1010,14 @@ int ddr_init(MINI_ADAPTER *Adapter)
 		 * we will change this when we will have internal PMU.
 		 */
 		if (Adapter->PmuMode == HYBRID_MODE_7C) {
-			retval = rdmalt(Adapter,(UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
+			retval = rdmalt(Adapter, (UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
 			if (retval < 0) {
 				bcm_dbg(Adapter, CMHOST, RDM, ALL,
 					"%s:%d RDM failed\n",
 					__func__, __LINE__);
 				return retval;
 			}
-			retval = rdmalt(Adapter,(UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
+			retval = rdmalt(Adapter, (UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
 			if (retval < 0) {
 				bcm_dbg(Adapter, CMHOST, RDM, ALL,
 					"%s:%d RDM failed\n",
@@ -1032,13 +1032,13 @@ int ddr_init(MINI_ADAPTER *Adapter)
 					__func__, __LINE__);
 				return retval;
 			}
-			retval = rdmalt(Adapter,(UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
+			retval = rdmalt(Adapter, (UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
 			if (retval < 0) {
 				pr_info("%s:%d RDM failed\n",
 					__func__, __LINE__);
 				return retval;
 			}
-			retval = rdmalt(Adapter,(UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
+			retval = rdmalt(Adapter, (UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
 			if (retval < 0) {
 				bcm_dbg(Adapter, CMHOST, RDM, ALL,
 					"%s:%d RDM failed\n",
@@ -1055,14 +1055,14 @@ int ddr_init(MINI_ADAPTER *Adapter)
 			}
 		} else if (Adapter->PmuMode == HYBRID_MODE_6 ) {
 
-			retval = rdmalt(Adapter,(UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
+			retval = rdmalt(Adapter, (UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
 			if (retval < 0) {
 				bcm_dbg(Adapter, CMHOST, RDM, ALL,
 					"%s:%d RDM failed\n",
 					__func__, __LINE__);
 				return retval;
 			}
-			retval = rdmalt(Adapter,(UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
+			retval = rdmalt(Adapter, (UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
 			if (retval < 0) {
 				bcm_dbg(Adapter, CMHOST, RDM, ALL,
 					"%s:%d RDM failed\n",
@@ -1077,14 +1077,14 @@ int ddr_init(MINI_ADAPTER *Adapter)
 					__func__, __LINE__);
 				return retval;
 			}
-			retval = rdmalt(Adapter,(UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
+			retval = rdmalt(Adapter, (UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
 			if (retval < 0) {
 				bcm_dbg(Adapter, CMHOST, RDM, ALL,
 					"%s:%d RDM failed\n",
 					__func__, __LINE__);
 				return retval;
 			}
-			retval = rdmalt(Adapter,(UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
+			retval = rdmalt(Adapter, (UINT)0x0f000c00, &uiResetValue, sizeof(uiResetValue));
 			if (retval < 0) {
 				bcm_dbg(Adapter, CMHOST, RDM, ALL,
 					"%s:%d RDM failed\n",
diff --git a/drivers/staging/bcm/Debug.h b/drivers/staging/bcm/Debug.h
index eb22835..ac539c6 100644
--- a/drivers/staging/bcm/Debug.h
+++ b/drivers/staging/bcm/Debug.h
@@ -29,7 +29,7 @@
 /*-----------------BEGIN SUBTYPEs---------------------------------------*/
 
 /*-SUBTYPEs for TX :  TYPE is DBG_TYPE_TX -----//
-  Transmit.c ,Arp.c, LeakyBucket.c, And Qos.c
+  Transmit.c, Arp.c, LeakyBucket.c, And Qos.c
   total 17 macros */
 // Transmit.c
 #define TX			1
@@ -92,7 +92,7 @@
 
 //-SUBTYPEs for ----OTHER ROUTINES------------------
 //------------OTHERS  :  TYPE is DBG_TYPE_OTHER -----//
-// HaltnReset,CheckForHang,PnP,Misc,CmHost
+// HaltnReset, CheckForHang, PnP, Misc, CmHost
 // total 12 macros
 #define OTHERS 1
 // ??ISR.C
diff --git a/drivers/staging/bcm/IPv6Protocol.c b/drivers/staging/bcm/IPv6Protocol.c
index 48f6d41..1642dff 100644
--- a/drivers/staging/bcm/IPv6Protocol.c
+++ b/drivers/staging/bcm/IPv6Protocol.c
@@ -1,10 +1,10 @@
 #include "headers.h"
 
-static BOOLEAN MatchSrcIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule,IPV6Header *pstIpv6Header);
-static BOOLEAN MatchDestIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule,IPV6Header *pstIpv6Header);
+static BOOLEAN MatchSrcIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule, IPV6Header *pstIpv6Header);
+static BOOLEAN MatchDestIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule, IPV6Header *pstIpv6Header);
 static VOID DumpIpv6Header(IPV6Header *pstIpv6Header);
 
-static UCHAR * GetNextIPV6ChainedHeader(UCHAR **ppucPayload,UCHAR *pucNextHeader,BOOLEAN *bParseDone,USHORT *pusPayloadLength)
+static UCHAR * GetNextIPV6ChainedHeader(UCHAR **ppucPayload, UCHAR *pucNextHeader, BOOLEAN *bParseDone, USHORT *pusPayloadLength)
 {
 	UCHAR *pucRetHeaderPtr = NULL;
 	UCHAR *pucPayloadPtr = NULL;
@@ -124,7 +124,7 @@ static UCHAR * GetNextIPV6ChainedHeader(UCHAR **ppucPayload,UCHAR *pucNextHeader
 }
 
 
-static UCHAR GetIpv6ProtocolPorts(UCHAR *pucPayload,USHORT *pusSrcPort,USHORT *pusDestPort,USHORT usPayloadLength,UCHAR ucNextHeader)
+static UCHAR GetIpv6ProtocolPorts(UCHAR *pucPayload, USHORT *pusSrcPort, USHORT *pusDestPort, USHORT usPayloadLength, UCHAR ucNextHeader)
 {
 	UCHAR *pIpv6HdrScanContext = pucPayload;
 	BOOLEAN bDone = FALSE;
@@ -194,16 +194,16 @@ USHORT	IpVersion6(PMINI_ADAPTER Adapter, /**< Pointer to the driver control stru
 			break;
 		}
 
-		bClassificationSucceed=MatchSrcIpv6Address(pstClassifierRule,pstIpv6Header);
+		bClassificationSucceed=MatchSrcIpv6Address(pstClassifierRule, pstIpv6Header);
 		if (!bClassificationSucceed)
 			break;
 
-		bClassificationSucceed=MatchDestIpv6Address(pstClassifierRule,pstIpv6Header);
+		bClassificationSucceed=MatchDestIpv6Address(pstClassifierRule, pstIpv6Header);
 		if (!bClassificationSucceed)
 			break;
 
 		//Match the protocol type.For IPv6 the next protocol at end of Chain of IPv6 prot headers
-		bClassificationSucceed=MatchProtocol(pstClassifierRule,ucNextProtocolAboveIP);
+		bClassificationSucceed=MatchProtocol(pstClassifierRule, ucNextProtocolAboveIP);
 		if (!bClassificationSucceed)
 			break;
 		bcm_dbg(Adapter, TX, IPV6_DBG, ALL, "IPv6 Protocol Matched\n");
@@ -212,7 +212,7 @@ USHORT	IpVersion6(PMINI_ADAPTER Adapter, /**< Pointer to the driver control stru
 			//Match Src Port
 			bcm_dbg(Adapter, TX, IPV6_DBG, ALL,
 				"IPv6 Source Port:%x\n", ntohs(ushSrcPort));
-			bClassificationSucceed=MatchSrcPort(pstClassifierRule,ntohs(ushSrcPort));
+			bClassificationSucceed=MatchSrcPort(pstClassifierRule, ntohs(ushSrcPort));
 			if (!bClassificationSucceed)
 				break;
 
@@ -223,7 +223,7 @@ USHORT	IpVersion6(PMINI_ADAPTER Adapter, /**< Pointer to the driver control stru
 			bcm_dbg(Adapter, TX, IPV6_DBG, ALL,
 				"IPv6 Destination Port:%x\n",
 				ntohs(ushDestPort));
-			bClassificationSucceed=MatchDestPort(pstClassifierRule,ntohs(ushDestPort));
+			bClassificationSucceed=MatchDestPort(pstClassifierRule, ntohs(ushDestPort));
 			if (!bClassificationSucceed)
 				break;
 			bcm_dbg(Adapter, TX, IPV6_DBG, ALL,
@@ -233,7 +233,7 @@ USHORT	IpVersion6(PMINI_ADAPTER Adapter, /**< Pointer to the driver control stru
 
 	if (TRUE==bClassificationSucceed) {
 		INT iMatchedSFQueueIndex = 0;
-		iMatchedSFQueueIndex = SearchSfid(Adapter,pstClassifierRule->ulSFID);
+		iMatchedSFQueueIndex = SearchSfid(Adapter, pstClassifierRule->ulSFID);
 		if (iMatchedSFQueueIndex >= NO_OF_QUEUES) {
 			bClassificationSucceed = FALSE;
 		} else {
@@ -247,7 +247,7 @@ USHORT	IpVersion6(PMINI_ADAPTER Adapter, /**< Pointer to the driver control stru
 }
 
 
-static BOOLEAN MatchSrcIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule,IPV6Header *pstIpv6Header)
+static BOOLEAN MatchSrcIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule, IPV6Header *pstIpv6Header)
 {
 	UINT uiLoopIndex=0;
 	UINT  uiIpv6AddIndex=0;
@@ -299,7 +299,7 @@ static BOOLEAN MatchSrcIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule,IPV6Head
 	return FALSE;
 }
 
-static BOOLEAN MatchDestIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule,IPV6Header *pstIpv6Header)
+static BOOLEAN MatchDestIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule, IPV6Header *pstIpv6Header)
 {
 	UINT uiLoopIndex=0;
 	UINT  uiIpv6AddIndex=0;
@@ -374,7 +374,7 @@ static VOID DumpIpv6Header(IPV6Header *pstIpv6Header)
 	bcm_dbg(Adapter, TX, IPV6_DBG, ALL, "Version : %x\n", ucVersion);
 	ucPrio = pstIpv6Header->ucVersionPrio & 0x0f;
 	bcm_dbg(Adapter, TX, IPV6_DBG, ALL, "Priority : %x\n", ucPrio);
-	//bcm_dbg(Adapter, TX, IPV6_DBG, ALL, "Flow Label : %x\n",(pstIpv6Header->ucVersionPrio &0xf0);
+	//bcm_dbg(Adapter, TX, IPV6_DBG, ALL, "Flow Label : %x\n", (pstIpv6Header->ucVersionPrio &0xf0);
 	bcm_dbg(Adapter, TX, IPV6_DBG, ALL,
 		"Payload Length : %x\n", ntohs(pstIpv6Header->usPayloadLength));
 	bcm_dbg(Adapter, TX, IPV6_DBG, ALL,
diff --git a/drivers/staging/bcm/IPv6ProtocolHdr.h b/drivers/staging/bcm/IPv6ProtocolHdr.h
index d9cc055..bae8ea9 100644
--- a/drivers/staging/bcm/IPv6ProtocolHdr.h
+++ b/drivers/staging/bcm/IPv6ProtocolHdr.h
@@ -101,9 +101,9 @@ USHORT	IpVersion6(PMINI_ADAPTER Adapter, /**< Pointer to the driver control stru
 
 VOID DumpIpv6Address(ULONG *puIpv6Address);
 
-extern BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort);
-extern BOOLEAN MatchDestPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort);
-extern BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucProtocol);
+extern BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule, USHORT ushSrcPort);
+extern BOOLEAN MatchDestPort(S_CLASSIFIER_RULE *pstClassifierRule, USHORT ushSrcPort);
+extern BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule, UCHAR ucProtocol);
 
 
 #endif
diff --git a/drivers/staging/bcm/InterfaceDld.c b/drivers/staging/bcm/InterfaceDld.c
index 049b46e..314082a 100644
--- a/drivers/staging/bcm/InterfaceDld.c
+++ b/drivers/staging/bcm/InterfaceDld.c
@@ -4,7 +4,7 @@ int InterfaceFileDownload(PVOID arg, struct file *flp, unsigned int on_chip_loc)
 {
 	/* unsigned int reg = 0; */
 	mm_segment_t oldfs = {0};
-	int errno = 0, len = 0; /* ,is_config_file = 0 */
+	int errno = 0, len = 0; /* , is_config_file = 0 */
 	loff_t pos = 0;
 	PS_INTERFACE_ADAPTER psIntfAdapter = (PS_INTERFACE_ADAPTER)arg;
 	/* PMINI_ADAPTER Adapter = psIntfAdapter->psAdapter; */
@@ -33,7 +33,7 @@ int InterfaceFileDownload(PVOID arg, struct file *flp, unsigned int on_chip_loc)
 			}
 			break;
 		}
-		/* BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_INITEXIT, MP_INIT,
+		/* BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_INITEXIT, MP_INIT,
 		 *			  DBG_LVL_ALL, buff,
 		 *			  MAX_TRANSFER_CTRL_BYTE_USB);
 		 */
diff --git a/drivers/staging/bcm/InterfaceIdleMode.c b/drivers/staging/bcm/InterfaceIdleMode.c
index 34de302..3b4a45c 100644
--- a/drivers/staging/bcm/InterfaceIdleMode.c
+++ b/drivers/staging/bcm/InterfaceIdleMode.c
@@ -58,7 +58,7 @@ int InterfaceIdleModeRespond(PMINI_ADAPTER Adapter, unsigned int* puiBuffer)
 			bcm_dbg(Adapter, OTHERS, IDLE_MODE, ALL,
 				"Got IDLE MODE WAKE UP Response From F/W\n");
 
-			status = wrmalt (Adapter,SW_ABORT_IDLEMODE_LOC, &uiRegRead, sizeof(uiRegRead));
+			status = wrmalt (Adapter, SW_ABORT_IDLEMODE_LOC, &uiRegRead, sizeof(uiRegRead));
 			if (status) {
 				pr_info("wrm failed while clearing Idle Mode Reg\n");
 				return status;
@@ -66,7 +66,7 @@ int InterfaceIdleModeRespond(PMINI_ADAPTER Adapter, unsigned int* puiBuffer)
 
 			if (Adapter->ulPowerSaveMode == DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING) {
 				uiRegRead = 0x00000000 ;
-				status = wrmalt (Adapter,DEBUG_INTERRUPT_GENERATOR_REGISTOR, &uiRegRead, sizeof(uiRegRead));
+				status = wrmalt (Adapter, DEBUG_INTERRUPT_GENERATOR_REGISTOR, &uiRegRead, sizeof(uiRegRead));
 				if (status) {
 					pr_info("wrm failed while clearing Idle Mode	Reg\n");
 					return status;
@@ -125,7 +125,7 @@ int InterfaceIdleModeRespond(PMINI_ADAPTER Adapter, unsigned int* puiBuffer)
 
 				uiRegRead |= (1<<17);
 
-				status = wrmalt (Adapter,HPM_CONFIG_MSW, &uiRegRead, sizeof(uiRegRead));
+				status = wrmalt(Adapter, HPM_CONFIG_MSW, &uiRegRead, sizeof(uiRegRead));
 				if (status) {
 					pr_info("wrm failed while clearing Idle Mode Reg\n");
 					return status;
@@ -137,7 +137,7 @@ int InterfaceIdleModeRespond(PMINI_ADAPTER Adapter, unsigned int* puiBuffer)
 	} else if (ntohl(*puiBuffer) == IDLE_MODE_SF_UPDATE_MSG) {
 		bcm_dbg(Adapter, OTHERS, IDLE_MODE, ALL,
 			"OverRiding Service Flow Params\n");
-		OverrideServiceFlowParams(Adapter,puiBuffer);
+		OverrideServiceFlowParams(Adapter, puiBuffer);
 	}
 	return status;
 }
@@ -147,10 +147,10 @@ static int InterfaceAbortIdlemode(PMINI_ADAPTER Adapter, unsigned int Pattern)
 	int	status = STATUS_SUCCESS;
 	unsigned int value;
 	unsigned int chip_id ;
-	unsigned long timeout = 0 ,itr = 0;
+	unsigned long timeout = 0 , itr = 0;
 
 	int	lenwritten = 0;
-	unsigned char aucAbortPattern[8]={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+	unsigned char aucAbortPattern[8]={0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 	PS_INTERFACE_ADAPTER psInterfaceAdapter = Adapter->pvInterfaceAdapter;
 
 	//Abort Bus suspend if its already suspended
@@ -169,7 +169,7 @@ static int InterfaceAbortIdlemode(PMINI_ADAPTER Adapter, unsigned int Pattern)
 		bcm_dbg(Adapter, OTHERS, IDLE_MODE, ALL,
 			"Writing pattern<%d> to SW_ABORT_IDLEMODE_LOC\n",
 			Pattern);
-		status = wrmalt(Adapter,SW_ABORT_IDLEMODE_LOC, &Pattern, sizeof(Pattern));
+		status = wrmalt(Adapter, SW_ABORT_IDLEMODE_LOC, &Pattern, sizeof(Pattern));
 		if (status) {
 			bcm_dbg(Adapter, OTHERS, IDLE_MODE, ALL,
 				"WRM to Register SW_ABORT_IDLEMODE_LOC failed..\n");
@@ -179,7 +179,7 @@ static int InterfaceAbortIdlemode(PMINI_ADAPTER Adapter, unsigned int Pattern)
 
 	if (Adapter->ulPowerSaveMode == DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING) {
 		value = 0x80000000;
-		status = wrmalt(Adapter,DEBUG_INTERRUPT_GENERATOR_REGISTOR, &value, sizeof(value));
+		status = wrmalt(Adapter, DEBUG_INTERRUPT_GENERATOR_REGISTOR, &value, sizeof(value));
 		if (status) {
 			bcm_dbg(Adapter, OTHERS, IDLE_MODE, ALL,
 				"WRM to DEBUG_INTERRUPT_GENERATOR_REGISTOR Register failed\n");
@@ -229,7 +229,7 @@ static int InterfaceAbortIdlemode(PMINI_ADAPTER Adapter, unsigned int Pattern)
 				itr);
 		}
 
-		status = wrmalt(Adapter,SW_ABORT_IDLEMODE_LOC, &Pattern, sizeof(status));
+		status = wrmalt(Adapter, SW_ABORT_IDLEMODE_LOC, &Pattern, sizeof(status));
 		if (status) {
 			pr_info("WRM to Register SW_ABORT_IDLEMODE_LOC failed..\n");
 			return status;
@@ -262,7 +262,7 @@ void InterfaceHandleShutdownModeWakeup(PMINI_ADAPTER Adapter)
 	if (Adapter->ulPowerSaveMode == DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING) {
 		// clear idlemode interrupt.
 		uiRegVal = 0;
-		Status =wrmalt(Adapter,DEBUG_INTERRUPT_GENERATOR_REGISTOR, &uiRegVal, sizeof(uiRegVal));
+		Status = wrmalt(Adapter, DEBUG_INTERRUPT_GENERATOR_REGISTOR, &uiRegVal, sizeof(uiRegVal));
 		if (Status) {
 			pr_info("WRM to DEBUG_INTERRUPT_GENERATOR_REGISTOR Failed with err :%d\n",
 				Status);
@@ -273,7 +273,7 @@ void InterfaceHandleShutdownModeWakeup(PMINI_ADAPTER Adapter)
 	else {
 
 		//clear Interrupt EP registers.
-		bytes = rdmalt(Adapter,DEVICE_INT_OUT_EP_REG0, &uiRegVal, sizeof(uiRegVal));
+		bytes = rdmalt(Adapter, DEVICE_INT_OUT_EP_REG0, &uiRegVal, sizeof(uiRegVal));
 		if (bytes < 0) {
 			Status = bytes;
 			pr_info("RDM of DEVICE_INT_OUT_EP_REG0 failed with Err :%d\n",
@@ -281,7 +281,7 @@ void InterfaceHandleShutdownModeWakeup(PMINI_ADAPTER Adapter)
 			return;
 		}
 
-		bytes = rdmalt(Adapter,DEVICE_INT_OUT_EP_REG1, &uiRegVal, sizeof(uiRegVal));
+		bytes = rdmalt(Adapter, DEVICE_INT_OUT_EP_REG1, &uiRegVal, sizeof(uiRegVal));
 		if (bytes < 0) {
 			Status = bytes;
 			pr_info("RDM of DEVICE_INT_OUT_EP_REG1 failed with Err :%d\n",
diff --git a/drivers/staging/bcm/InterfaceRx.c b/drivers/staging/bcm/InterfaceRx.c
index 178e8d9..b743c91 100644
--- a/drivers/staging/bcm/InterfaceRx.c
+++ b/drivers/staging/bcm/InterfaceRx.c
@@ -1,6 +1,6 @@
 #include "headers.h"
 
-static int SearchVcid(PMINI_ADAPTER Adapter,unsigned short usVcid)
+static int SearchVcid(PMINI_ADAPTER Adapter, unsigned short usVcid)
 {
 	int iIndex=0;
 
@@ -101,7 +101,7 @@ static void read_bulk_callback(struct urb *urb)
 		return;
 	}
 
-	QueueIndex = SearchVcid( Adapter,pLeader->Vcid);
+	QueueIndex = SearchVcid( Adapter, pLeader->Vcid);
 	if (QueueIndex < NO_OF_QUEUES) {
 		bHeaderSupressionEnabled =
 			Adapter->PackInfo[QueueIndex].bHeaderSuppressionEnabled;
@@ -126,7 +126,7 @@ static void read_bulk_callback(struct urb *urb)
 		skb->len = pLeader->PLength + sizeof(USHORT);
 
 		spin_lock(&Adapter->control_queue_lock);
-		ENQUEUEPACKET(Adapter->RxControlHead,Adapter->RxControlTail,skb);
+		ENQUEUEPACKET(Adapter->RxControlHead, Adapter->RxControlTail, skb);
 		spin_unlock(&Adapter->control_queue_lock);
 
 		atomic_inc(&Adapter->cntrlpktCnt);
@@ -153,7 +153,7 @@ static void read_bulk_callback(struct urb *urb)
 			/* Moving ahead by ETH_HLEN to the data ptr as received from FW */
 			skb_pull(skb, ETH_HLEN);
 			PHSReceive(Adapter, pLeader->Vcid, skb, &skb->len,
-				   NULL,bHeaderSupressionEnabled);
+				   NULL, bHeaderSupressionEnabled);
 
 			if (!Adapter->PackInfo[QueueIndex].bEthCSSupport) {
 				skb_push(skb, ETH_HLEN);
diff --git a/drivers/staging/bcm/InterfaceTx.c b/drivers/staging/bcm/InterfaceTx.c
index a52f45e..61b288b 100644
--- a/drivers/staging/bcm/InterfaceTx.c
+++ b/drivers/staging/bcm/InterfaceTx.c
@@ -140,7 +140,7 @@ static int TransmitTcb(PS_INTERFACE_ADAPTER psIntfAdapter, PUSB_TCB pTcb, PVOID
 
 	bcm_dbg(psIntfAdapter->psAdapter, TX, NEXT_SEND, ALL,
 		"Sending Bulk out packet\n");
-	//For T3B,INT OUT end point will be used as bulk out end point
+	//For T3B, INT OUT end point will be used as bulk out end point
 	if ((psIntfAdapter->psAdapter->chip_id == T3B) && (psIntfAdapter->bHighSpeedDevice == TRUE)) {
 		usb_fill_int_urb(urb, psIntfAdapter->udev,
 				 psIntfAdapter->sBulkOut.bulk_out_pipe,
diff --git a/drivers/staging/bcm/Ioctl.h b/drivers/staging/bcm/Ioctl.h
index 5b728d7..7146786 100644
--- a/drivers/staging/bcm/Ioctl.h
+++ b/drivers/staging/bcm/Ioctl.h
@@ -40,7 +40,7 @@ typedef struct stUserThreadReq {
 
 //1.Control code for CONTROL MESSAGES
 
-#define IOCTL_SEND_CONTROL_MESSAGE		_IOW(BCM_IOCTL,	0x801,int)
+#define IOCTL_SEND_CONTROL_MESSAGE		_IOW(BCM_IOCTL,	0x801, int)
 
 //2.Control code to write a particular value to a particular register
 #define IOCTL_BCM_REGISTER_WRITE		_IOW(BCM_IOCTL, 0x802, int)
@@ -98,7 +98,7 @@ typedef struct stUserThreadReq {
 
 #define IOCTL_CINR_LEVEL_REQ			_IOW(BCM_IOCTL, 0x817, char)
 
-#define IOCTL_WTM_CONTROL_REQ			_IOW(BCM_IOCTL, 0x817,char)
+#define IOCTL_WTM_CONTROL_REQ			_IOW(BCM_IOCTL, 0x817, char)
 
 #define IOCTL_BE_BUCKET_SIZE			_IOW(BCM_IOCTL, 0x818, unsigned long)
 
@@ -156,13 +156,13 @@ typedef struct stUserThreadReq {
 
 #define IOCTL_BCM_FLASH2X_SECTION_WRITE		_IOW(BCM_IOCTL, 0x866, int)
 
-#define IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP	_IOR(BCM_IOCTL,0x867, int)
+#define IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP	_IOR(BCM_IOCTL, 0x867, int)
 
-#define IOCTL_BCM_SET_ACTIVE_SECTION		_IOW(BCM_IOCTL,0x868, int)
+#define IOCTL_BCM_SET_ACTIVE_SECTION		_IOW(BCM_IOCTL, 0x868, int)
 
-#define	IOCTL_BCM_IDENTIFY_ACTIVE_SECTION	_IO(BCM_IOCTL,0x869)
+#define	IOCTL_BCM_IDENTIFY_ACTIVE_SECTION	_IO(BCM_IOCTL, 0x869)
 
-#define IOCTL_BCM_COPY_SECTION			_IOW(BCM_IOCTL, 0x870,int)
+#define IOCTL_BCM_COPY_SECTION			_IOW(BCM_IOCTL, 0x870, int)
 
 #define	IOCTL_BCM_GET_FLASH_CS_INFO		_IOR(BCM_IOCTL, 0x871, int)
 
diff --git a/drivers/staging/bcm/LeakyBucket.c b/drivers/staging/bcm/LeakyBucket.c
index c18dcc8..3c4a266 100644
--- a/drivers/staging/bcm/LeakyBucket.c
+++ b/drivers/staging/bcm/LeakyBucket.c
@@ -112,7 +112,7 @@ static INT SendPacketFromQueue(PMINI_ADAPTER Adapter,/**<Logical Adapter*/
 			       struct sk_buff*  Packet)	/**<Pointer to the packet to be sent*/
 {
 	INT	Status=STATUS_FAILURE;
-	UINT uiIndex =0,PktLen = 0;
+	UINT uiIndex =0, PktLen = 0;
 
 	bcm_dbg(Adapter, TX, SEND_QUEUE, ALL, "=====>\n");
 	if (!Adapter || !Packet || !psSF) {
@@ -194,7 +194,7 @@ static VOID CheckAndSendPacketFromIndex(PMINI_ADAPTER Adapter, PacketInfo *psSF)
 					"Allowed bytes %d\n",
 					(iPacketLen >> 3));
 
-				DEQUEUEPACKET(psSF->FirstTxQueue,psSF->LastTxQueue);
+				DEQUEUEPACKET(psSF->FirstTxQueue, psSF->LastTxQueue);
 				psSF->uiCurrentBytesOnHost -= (QueuePacket->len);
 				psSF->uiCurrentPacketsOnHost--;
 				atomic_dec(&Adapter->TotalPacketCount);
diff --git a/drivers/staging/bcm/Misc.c b/drivers/staging/bcm/Misc.c
index 10b33a4..3c3b8e3 100644
--- a/drivers/staging/bcm/Misc.c
+++ b/drivers/staging/bcm/Misc.c
@@ -879,7 +879,7 @@ VOID DumpPackInfo(PMINI_ADAPTER Adapter)
 		bcm_dbg(Adapter, OTHERS, DUMP_INFO, ALL,
 			"uiPerSFTxResourceCount:%X\n",
 			atomic_read(&Adapter->PackInfo[uiLoopIndex].uiPerSFTxResourceCount));
-		/* DumpDebug(DUMP_INFO,("bCSSupport:%X\n",Adapter->PackInfo[uiLoopIndex].bCSSupport)); */
+		/* DumpDebug(DUMP_INFO, ("bCSSupport:%X\n", Adapter->PackInfo[uiLoopIndex].bCSSupport)); */
 		bcm_dbg(Adapter, OTHERS, DUMP_INFO, ALL,
 			"CurrQueueDepthOnTarget: %x\n",
 			Adapter->PackInfo[uiLoopIndex].uiCurrentQueueDepthOnTarget);
@@ -954,7 +954,7 @@ VOID DumpPackInfo(PMINI_ADAPTER Adapter)
 /* bcm_dbg(Adapter, OTHERS, DUMP_INFO, ALL, "bHeaderSuppressionEnabled :%X\n", Adapter->PackInfo[uiLoopIndex].bHeaderSuppressionEnabled);
  * bcm_dbg(Adapter, OTHERS, DUMP_INFO, ALL, "uiTotalTxBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiTotalTxBytes);
  * bcm_dbg(Adapter, OTHERS, DUMP_INFO, ALL, "uiTotalRxBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiTotalRxBytes);
- *		DumpDebug(DUMP_INFO,("				uiRanOutOfResCount:%X\n",Adapter->PackInfo[uiLoopIndex].uiRanOutOfResCount));
+ *		DumpDebug(DUMP_INFO, ("				uiRanOutOfResCount:%X\n", Adapter->PackInfo[uiLoopIndex].uiRanOutOfResCount));
  */
 	}
 
diff --git a/drivers/staging/bcm/PHSModule.c b/drivers/staging/bcm/PHSModule.c
index 6d2959a..6deaeac 100644
--- a/drivers/staging/bcm/PHSModule.c
+++ b/drivers/staging/bcm/PHSModule.c
@@ -1,32 +1,32 @@
 #include "headers.h"
 
-static UINT CreateSFToClassifierRuleMapping(B_UINT16 uiVcid,B_UINT16  uiClsId,S_SERVICEFLOW_TABLE *psServiceFlowTable,S_PHS_RULE *psPhsRule,B_UINT8 u8AssociatedPHSI);
+static UINT CreateSFToClassifierRuleMapping(B_UINT16 uiVcid, B_UINT16  uiClsId, S_SERVICEFLOW_TABLE *psServiceFlowTable, S_PHS_RULE *psPhsRule, B_UINT8 u8AssociatedPHSI);
 
-static UINT CreateClassiferToPHSRuleMapping(B_UINT16 uiVcid,B_UINT16  uiClsId,S_SERVICEFLOW_ENTRY *pstServiceFlowEntry,S_PHS_RULE *psPhsRule,B_UINT8 u8AssociatedPHSI);
+static UINT CreateClassiferToPHSRuleMapping(B_UINT16 uiVcid, B_UINT16  uiClsId, S_SERVICEFLOW_ENTRY *pstServiceFlowEntry, S_PHS_RULE *psPhsRule, B_UINT8 u8AssociatedPHSI);
 
-static UINT CreateClassifierPHSRule(B_UINT16  uiClsId,S_CLASSIFIER_TABLE *psaClassifiertable ,S_PHS_RULE *psPhsRule,E_CLASSIFIER_ENTRY_CONTEXT eClsContext,B_UINT8 u8AssociatedPHSI);
+static UINT CreateClassifierPHSRule(B_UINT16  uiClsId, S_CLASSIFIER_TABLE *psaClassifiertable , S_PHS_RULE *psPhsRule, E_CLASSIFIER_ENTRY_CONTEXT eClsContext, B_UINT8 u8AssociatedPHSI);
 
-static UINT UpdateClassifierPHSRule(B_UINT16  uiClsId,S_CLASSIFIER_ENTRY *pstClassifierEntry,S_CLASSIFIER_TABLE *psaClassifiertable ,S_PHS_RULE *psPhsRule,B_UINT8 u8AssociatedPHSI);
+static UINT UpdateClassifierPHSRule(B_UINT16  uiClsId, S_CLASSIFIER_ENTRY *pstClassifierEntry, S_CLASSIFIER_TABLE *psaClassifiertable , S_PHS_RULE *psPhsRule, B_UINT8 u8AssociatedPHSI);
 
 static BOOLEAN ValidatePHSRuleComplete(S_PHS_RULE *psPhsRule);
 
-static BOOLEAN DerefPhsRule(B_UINT16  uiClsId,S_CLASSIFIER_TABLE *psaClassifiertable,S_PHS_RULE *pstPhsRule);
+static BOOLEAN DerefPhsRule(B_UINT16  uiClsId, S_CLASSIFIER_TABLE *psaClassifiertable, S_PHS_RULE *pstPhsRule);
 
-static UINT GetClassifierEntry(S_CLASSIFIER_TABLE *pstClassifierTable,B_UINT32 uiClsid,E_CLASSIFIER_ENTRY_CONTEXT eClsContext, S_CLASSIFIER_ENTRY **ppstClassifierEntry);
+static UINT GetClassifierEntry(S_CLASSIFIER_TABLE *pstClassifierTable, B_UINT32 uiClsid, E_CLASSIFIER_ENTRY_CONTEXT eClsContext, S_CLASSIFIER_ENTRY **ppstClassifierEntry);
 
-static UINT GetPhsRuleEntry(S_CLASSIFIER_TABLE *pstClassifierTable,B_UINT32 uiPHSI,E_CLASSIFIER_ENTRY_CONTEXT eClsContext,S_PHS_RULE **ppstPhsRule);
+static UINT GetPhsRuleEntry(S_CLASSIFIER_TABLE *pstClassifierTable, B_UINT32 uiPHSI, E_CLASSIFIER_ENTRY_CONTEXT eClsContext, S_PHS_RULE **ppstPhsRule);
 
 static void free_phs_serviceflow_rules(S_SERVICEFLOW_TABLE *psServiceFlowRulesTable);
 
-static int phs_compress(S_PHS_RULE   *phs_members,unsigned char *in_buf,
-			unsigned char *out_buf,unsigned int *header_size,UINT *new_header_size );
+static int phs_compress(S_PHS_RULE   *phs_members, unsigned char *in_buf,
+			unsigned char *out_buf, unsigned int *header_size, UINT *new_header_size );
 
 
-static int verify_suppress_phsf(unsigned char *in_buffer,unsigned char *out_buffer,
-				unsigned char *phsf,unsigned char *phsm,unsigned int phss,unsigned int phsv,UINT *new_header_size );
+static int verify_suppress_phsf(unsigned char *in_buffer, unsigned char *out_buffer,
+				unsigned char *phsf, unsigned char *phsm, unsigned int phss, unsigned int phsv, UINT *new_header_size );
 
-static int phs_decompress(unsigned char *in_buf,unsigned char *out_buf,\
-			  S_PHS_RULE   *phs_rules,UINT *header_size);
+static int phs_decompress(unsigned char *in_buf, unsigned char *out_buf,\
+			  S_PHS_RULE   *phs_rules, UINT *header_size);
 
 
 static ULONG PhsCompress(void* pvContext,
@@ -232,7 +232,7 @@ int PHSReceive(PMINI_ADAPTER Adapter,
 
 	bcm_dbg(Adapter, OTHERS, PHS_RECEIVE, ALL,
 		"Supressed PktHdrLen : 0x%x Restored PktHdrLen : 0x%x\n",
-		nTotalsupressedPktHdrBytes,nStandardPktHdrLen);
+		nTotalsupressedPktHdrBytes, nStandardPktHdrLen);
 
 	if (ulPhsStatus != STATUS_PHS_COMPRESSED) {
 		skb_pull(packet, 1);
@@ -258,11 +258,11 @@ int PHSReceive(PMINI_ADAPTER Adapter,
 	return STATUS_SUCCESS;
 }
 
-void DumpFullPacket(UCHAR *pBuf,UINT nPktLen)
+void DumpFullPacket(UCHAR *pBuf, UINT nPktLen)
 {
 	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 	bcm_dbg(Adapter, TX, IPV4_DBG, ALL, "Dumping Data Packet\n");
-	BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,pBuf,nPktLen);
+	BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, pBuf, nPktLen);
 }
 
 //-----------------------------------------------------------------------------
@@ -278,7 +278,7 @@ void DumpFullPacket(UCHAR *pBuf,UINT nPktLen)
 // TRUE(1)	-If allocation of memory was success full.
 // FALSE	-If allocation of memory fails.
 //-----------------------------------------------------------------------------
-int phs_init(PPHS_DEVICE_EXTENSION pPhsdeviceExtension,PMINI_ADAPTER Adapter)
+int phs_init(PPHS_DEVICE_EXTENSION pPhsdeviceExtension, PMINI_ADAPTER Adapter)
 {
 	int i;
 	S_SERVICEFLOW_TABLE *pstServiceFlowTable;
@@ -440,7 +440,7 @@ ULONG PhsUpdateClassifierRule(IN void* pvContext,
 
   --*/
 
-ULONG PhsDeletePHSRule(IN void* pvContext,IN B_UINT16 uiVcid,IN B_UINT8 u8PHSI)
+ULONG PhsDeletePHSRule(IN void* pvContext, IN B_UINT16 uiVcid, IN B_UINT8 u8PHSI)
 {
 	ULONG lStatus =0;
 	UINT nSFIndex =0, nClsidIndex =0 ;
@@ -457,7 +457,7 @@ ULONG PhsDeletePHSRule(IN void* pvContext,IN B_UINT16 uiVcid,IN B_UINT8 u8PHSI)
 
 		//Retrieve the SFID Entry Index for requested Service Flow
 		nSFIndex = GetServiceFlowEntry(pDeviceExtension
-					       ->pstServiceFlowPhsRulesTable,uiVcid,&pstServiceFlowEntry);
+					       ->pstServiceFlowPhsRulesTable, uiVcid,&pstServiceFlowEntry);
 
 		if (nSFIndex == PHS_INVALID_TABLE_INDEX) {
 			bcm_dbg(Adapter, OTHERS, PHS_DISPATCH, ALL,
@@ -489,7 +489,7 @@ ULONG PhsDeletePHSRule(IN void* pvContext,IN B_UINT16 uiVcid,IN B_UINT8 u8PHSI)
   PhsDeleteClassifierRule
 
   Routine Description:
-  Exported function to Delete a PHS Rule for the SFID,CLSID Pair.
+  Exported function to Delete a PHS Rule for the SFID, CLSID Pair.
 
   Arguments:
   IN void* pvContext - PHS Driver Specific Context
@@ -502,7 +502,7 @@ ULONG PhsDeletePHSRule(IN void* pvContext,IN B_UINT16 uiVcid,IN B_UINT8 u8PHSI)
   >0 Error.
 
   --*/
-ULONG PhsDeleteClassifierRule(IN void* pvContext,IN B_UINT16 uiVcid ,IN B_UINT16  uiClsId)
+ULONG PhsDeleteClassifierRule(IN void* pvContext, IN B_UINT16 uiVcid , IN B_UINT16  uiClsId)
 {
 	ULONG lStatus =0;
 	UINT nSFIndex =0, nClsidIndex =0 ;
@@ -535,7 +535,7 @@ ULONG PhsDeleteClassifierRule(IN void* pvContext,IN B_UINT16 uiVcid ,IN B_UINT16
 		}
 
 		nClsidIndex = GetClassifierEntry(pstServiceFlowEntry->pstClassifierTable,
-						 uiClsId,eOldClassifierRuleContext,&pstClassifierEntry);
+						 uiClsId, eOldClassifierRuleContext,&pstClassifierEntry);
 
 		if ((nClsidIndex != PHS_INVALID_TABLE_INDEX) && (!pstClassifierEntry->bUnclassifiedPHSRule)) {
 			kfree(pstClassifierEntry->pstPhsRule);
@@ -561,7 +561,7 @@ ULONG PhsDeleteClassifierRule(IN void* pvContext,IN B_UINT16 uiVcid ,IN B_UINT16
   >0 Error.
 
   --*/
-ULONG PhsDeleteSFRules(IN void* pvContext,IN B_UINT16 uiVcid)
+ULONG PhsDeleteSFRules(IN void* pvContext, IN B_UINT16 uiVcid)
 {
 
 	ULONG lStatus =0;
@@ -683,7 +683,7 @@ ULONG PhsCompress(IN void* pvContext,
 	}
 
 	nClsidIndex = GetClassifierEntry(pstServiceFlowEntry->pstClassifierTable,
-					 uiClsId,eActiveClassifierRuleContext,&pstClassifierEntry);
+					 uiClsId, eActiveClassifierRuleContext,&pstClassifierEntry);
 
 	if (nClsidIndex == PHS_INVALID_TABLE_INDEX) {
 		bcm_dbg(Adapter, OTHERS, PHS_SEND, ALL,
@@ -693,7 +693,7 @@ ULONG PhsCompress(IN void* pvContext,
 	}
 
 
-	//get rule from SF id,Cls ID pair and proceed
+	//get rule from SF id, Cls ID pair and proceed
 	pstPhsRule =  pstClassifierEntry->pstPhsRule;
 
 	if (!ValidatePHSRuleComplete(pstPhsRule)) {
@@ -704,8 +704,8 @@ ULONG PhsCompress(IN void* pvContext,
 	}
 
 	//Compress Packet
-	lStatus = phs_compress(pstPhsRule,(PUCHAR)pvInputBuffer,
-			       (PUCHAR)pvOutputBuffer, pOldHeaderSize,pNewHeaderSize);
+	lStatus = phs_compress(pstPhsRule, (PUCHAR)pvInputBuffer,
+			       (PUCHAR)pvOutputBuffer, pOldHeaderSize, pNewHeaderSize);
 
 	if (lStatus == STATUS_PHS_COMPRESSED) {
 		pstPhsRule->PHSModifiedBytes += *pOldHeaderSize - *pNewHeaderSize - 1;
@@ -776,12 +776,12 @@ ULONG PhsDeCompress(IN void* pvContext,
 		return ERR_SF_MATCH_FAIL;
 	}
 
-	nPhsRuleIndex = GetPhsRuleEntry(pstServiceFlowEntry->pstClassifierTable,phsi,
+	nPhsRuleIndex = GetPhsRuleEntry(pstServiceFlowEntry->pstClassifierTable, phsi,
 					eActiveClassifierRuleContext,&pstPhsRule);
 	if (nPhsRuleIndex == PHS_INVALID_TABLE_INDEX) {
 		//Phs Rule does not exist in  active rules table. Lets try in the old rules table.
 		nPhsRuleIndex = GetPhsRuleEntry(pstServiceFlowEntry->pstClassifierTable,
-						phsi,eOldClassifierRuleContext,&pstPhsRule);
+						phsi, eOldClassifierRuleContext,&pstPhsRule);
 		if (nPhsRuleIndex == PHS_INVALID_TABLE_INDEX) {
 			return ERR_PHSRULE_MATCH_FAIL;
 		}
@@ -789,7 +789,7 @@ ULONG PhsDeCompress(IN void* pvContext,
 	}
 
 	*pInHeaderSize = phs_decompress((PUCHAR)pvInputBuffer,
-					(PUCHAR)pvOutputBuffer,pstPhsRule,pOutHeaderSize);
+					(PUCHAR)pvOutputBuffer, pstPhsRule, pOutHeaderSize);
 
 	pstPhsRule->PHSModifiedBytes += *pOutHeaderSize - *pInHeaderSize - 1;
 
@@ -812,7 +812,7 @@ ULONG PhsDeCompress(IN void* pvContext,
 
 static void free_phs_serviceflow_rules(S_SERVICEFLOW_TABLE *psServiceFlowRulesTable)
 {
-	int i,j;
+	int i, j;
 	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 
 	bcm_dbg(Adapter, OTHERS, PHS_DISPATCH, ALL, "=======>\n");
@@ -883,7 +883,7 @@ static BOOLEAN ValidatePHSRuleComplete(IN S_PHS_RULE *psPhsRule)
 }
 
 UINT GetServiceFlowEntry(IN S_SERVICEFLOW_TABLE *psServiceFlowTable,
-			 IN B_UINT16 uiVcid,S_SERVICEFLOW_ENTRY **ppstServiceFlowEntry)
+			 IN B_UINT16 uiVcid, S_SERVICEFLOW_ENTRY **ppstServiceFlowEntry)
 {
 	int  i;
 	for (i = 0; i < MAX_SERVICEFLOWS; i++) {
@@ -901,7 +901,7 @@ UINT GetServiceFlowEntry(IN S_SERVICEFLOW_TABLE *psServiceFlowTable,
 
 
 UINT GetClassifierEntry(IN S_CLASSIFIER_TABLE *pstClassifierTable,
-			IN B_UINT32 uiClsid,E_CLASSIFIER_ENTRY_CONTEXT eClsContext,
+			IN B_UINT32 uiClsid, E_CLASSIFIER_ENTRY_CONTEXT eClsContext,
 			OUT S_CLASSIFIER_ENTRY **ppstClassifierEntry)
 {
 	int  i;
@@ -928,7 +928,7 @@ UINT GetClassifierEntry(IN S_CLASSIFIER_TABLE *pstClassifierTable,
 }
 
 static UINT GetPhsRuleEntry(IN S_CLASSIFIER_TABLE *pstClassifierTable,
-			    IN B_UINT32 uiPHSI,E_CLASSIFIER_ENTRY_CONTEXT eClsContext,
+			    IN B_UINT32 uiPHSI, E_CLASSIFIER_ENTRY_CONTEXT eClsContext,
 			    OUT S_PHS_RULE **ppstPhsRule)
 {
 	int  i;
@@ -952,8 +952,8 @@ static UINT GetPhsRuleEntry(IN S_CLASSIFIER_TABLE *pstClassifierTable,
 	return PHS_INVALID_TABLE_INDEX;
 }
 
-UINT CreateSFToClassifierRuleMapping(IN B_UINT16 uiVcid,IN B_UINT16  uiClsId,
-				     IN S_SERVICEFLOW_TABLE *psServiceFlowTable,S_PHS_RULE *psPhsRule,
+UINT CreateSFToClassifierRuleMapping(IN B_UINT16 uiVcid, IN B_UINT16  uiClsId,
+				     IN S_SERVICEFLOW_TABLE *psServiceFlowTable, S_PHS_RULE *psPhsRule,
 				     B_UINT8 u8AssociatedPHSI)
 {
 
@@ -974,8 +974,8 @@ UINT CreateSFToClassifierRuleMapping(IN B_UINT16 uiVcid,IN B_UINT16  uiClsId,
 
 
 	psaClassifiertable = psServiceFlowTable->stSFList[iSfIndex].pstClassifierTable;
-	uiStatus = CreateClassifierPHSRule(uiClsId,psaClassifiertable,psPhsRule,
-					   eActiveClassifierRuleContext,u8AssociatedPHSI);
+	uiStatus = CreateClassifierPHSRule(uiClsId, psaClassifiertable, psPhsRule,
+					   eActiveClassifierRuleContext, u8AssociatedPHSI);
 	if (uiStatus == PHS_SUCCESS) {
 		//Add entry at free index to the SF
 		psServiceFlowTable->stSFList[iSfIndex].bUsed = TRUE;
@@ -987,8 +987,8 @@ UINT CreateSFToClassifierRuleMapping(IN B_UINT16 uiVcid,IN B_UINT16  uiClsId,
 }
 
 UINT CreateClassiferToPHSRuleMapping(IN B_UINT16 uiVcid,
-				     IN B_UINT16  uiClsId,IN S_SERVICEFLOW_ENTRY *pstServiceFlowEntry,
-				     S_PHS_RULE *psPhsRule,B_UINT8 u8AssociatedPHSI)
+				     IN B_UINT16  uiClsId, IN S_SERVICEFLOW_ENTRY *pstServiceFlowEntry,
+				     S_PHS_RULE *psPhsRule, B_UINT8 u8AssociatedPHSI)
 {
 	S_CLASSIFIER_ENTRY *pstClassifierEntry = NULL;
 	UINT uiStatus =PHS_SUCCESS;
@@ -1001,7 +1001,7 @@ UINT CreateClassiferToPHSRuleMapping(IN B_UINT16 uiVcid,
 
 	/* Check if the supplied Classifier already exists */
 	nClassifierIndex =GetClassifierEntry(
-		pstServiceFlowEntry->pstClassifierTable,uiClsId,
+		pstServiceFlowEntry->pstClassifierTable, uiClsId,
 		eActiveClassifierRuleContext,&pstClassifierEntry);
 	if (nClassifierIndex == PHS_INVALID_TABLE_INDEX) {
 		/*
@@ -1009,8 +1009,8 @@ UINT CreateClassiferToPHSRuleMapping(IN B_UINT16 uiVcid,
 		  Add new entry to associate PHS Rule to the Classifier
 		*/
 
-		uiStatus = CreateClassifierPHSRule(uiClsId,psaClassifiertable,
-						   psPhsRule,eActiveClassifierRuleContext,u8AssociatedPHSI);
+		uiStatus = CreateClassifierPHSRule(uiClsId, psaClassifiertable,
+						   psPhsRule, eActiveClassifierRuleContext, u8AssociatedPHSI);
 		return uiStatus;
 	}
 
@@ -1069,8 +1069,8 @@ UINT CreateClassiferToPHSRuleMapping(IN B_UINT16 uiVcid,
 }
 
 static UINT CreateClassifierPHSRule(IN B_UINT16  uiClsId,
-				    S_CLASSIFIER_TABLE *psaClassifiertable ,S_PHS_RULE *psPhsRule,
-				    E_CLASSIFIER_ENTRY_CONTEXT eClsContext,B_UINT8 u8AssociatedPHSI)
+				    S_CLASSIFIER_TABLE *psaClassifiertable , S_PHS_RULE *psPhsRule,
+				    E_CLASSIFIER_ENTRY_CONTEXT eClsContext, B_UINT8 u8AssociatedPHSI)
 {
 	UINT iClassifierIndex = 0;
 	BOOLEAN bFreeEntryFound = FALSE;
@@ -1140,7 +1140,7 @@ static UINT CreateClassifierPHSRule(IN B_UINT16  uiClsId,
 
 	if (eClsContext == eOldClassifierRuleContext) {
 		if (psClassifierRules->pstPhsRule == NULL) {
-			psClassifierRules->pstPhsRule = kmalloc(sizeof(S_PHS_RULE),GFP_KERNEL);
+			psClassifierRules->pstPhsRule = kmalloc(sizeof(S_PHS_RULE), GFP_KERNEL);
 
 			if (NULL == psClassifierRules->pstPhsRule)
 				return ERR_PHSRULE_MEMALLOC_FAIL;
@@ -1155,8 +1155,8 @@ static UINT CreateClassifierPHSRule(IN B_UINT16  uiClsId,
 		memcpy(psClassifierRules->pstPhsRule,
 		       psPhsRule, sizeof(S_PHS_RULE));
 	} else {
-		nStatus = UpdateClassifierPHSRule(uiClsId,psClassifierRules,
-						  psaClassifiertable,psPhsRule,u8AssociatedPHSI);
+		nStatus = UpdateClassifierPHSRule(uiClsId, psClassifierRules,
+						  psaClassifiertable, psPhsRule, u8AssociatedPHSI);
 	}
 	return nStatus;
 }
@@ -1164,7 +1164,7 @@ static UINT CreateClassifierPHSRule(IN B_UINT16  uiClsId,
 
 static UINT UpdateClassifierPHSRule(IN B_UINT16  uiClsId,
 				    IN S_CLASSIFIER_ENTRY *pstClassifierEntry,
-				    S_CLASSIFIER_TABLE *psaClassifiertable ,S_PHS_RULE *psPhsRule,
+				    S_CLASSIFIER_TABLE *psaClassifiertable , S_PHS_RULE *psPhsRule,
 				    B_UINT8 u8AssociatedPHSI)
 {
 	S_PHS_RULE *pstAddPhsRule = NULL;
@@ -1178,7 +1178,7 @@ static UINT UpdateClassifierPHSRule(IN B_UINT16  uiClsId,
 					 pstClassifierEntry->pstPhsRule);
 
 	//Step 2 Search if there is a PHS Rule with u8AssociatedPHSI in Classifier table for this SF
-	nPhsRuleIndex =GetPhsRuleEntry(psaClassifiertable,u8AssociatedPHSI,
+	nPhsRuleIndex =GetPhsRuleEntry(psaClassifiertable, u8AssociatedPHSI,
 				       eActiveClassifierRuleContext, &pstAddPhsRule);
 	if (PHS_INVALID_TABLE_INDEX == nPhsRuleIndex) {
 		bcm_dbg(Adapter, OTHERS, PHS_DISPATCH, ALL,
@@ -1219,7 +1219,7 @@ static UINT UpdateClassifierPHSRule(IN B_UINT16  uiClsId,
 
 }
 
-static BOOLEAN DerefPhsRule(IN B_UINT16  uiClsId,S_CLASSIFIER_TABLE *psaClassifiertable,S_PHS_RULE *pstPhsRule)
+static BOOLEAN DerefPhsRule(IN B_UINT16  uiClsId, S_CLASSIFIER_TABLE *psaClassifiertable, S_PHS_RULE *pstPhsRule)
 {
 	if (pstPhsRule==NULL)
 		return FALSE;
@@ -1228,7 +1228,7 @@ static BOOLEAN DerefPhsRule(IN B_UINT16  uiClsId,S_CLASSIFIER_TABLE *psaClassifi
 	if (0==pstPhsRule->u8RefCnt) {
 		/*if (pstPhsRule->u8PHSI)
 		//Store the currently active rule into the old rules list
-		CreateClassifierPHSRule(uiClsId,psaClassifiertable,pstPhsRule,eOldClassifierRuleContext,pstPhsRule->u8PHSI);*/
+		CreateClassifierPHSRule(uiClsId, psaClassifiertable, pstPhsRule, eOldClassifierRuleContext, pstPhsRule->u8PHSI);*/
 		return TRUE;
 	} else {
 		return FALSE;
@@ -1237,7 +1237,7 @@ static BOOLEAN DerefPhsRule(IN B_UINT16  uiClsId,S_CLASSIFIER_TABLE *psaClassifi
 
 void DumpPhsRules(PPHS_DEVICE_EXTENSION pDeviceExtension)
 {
-	int i,j,k,l;
+	int i, j, k, l;
 	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 	bcm_dbg(Adapter, OTHERS, DUMP_INFO, ALL, "Dumping PHS Rules :\n");
 	for (i = 0; i < MAX_SERVICEFLOWS; i++) {
@@ -1327,12 +1327,12 @@ void DumpPhsRules(PPHS_DEVICE_EXTENSION pDeviceExtension)
 //	0	-If PHS rule is NULL.If PHSI is 0 indicateing packet as uncompressed.
 //-----------------------------------------------------------------------------
 
-int phs_decompress(unsigned char *in_buf,unsigned char *out_buf,
-		   S_PHS_RULE   *decomp_phs_rules,UINT *header_size)
+int phs_decompress(unsigned char *in_buf, unsigned char *out_buf,
+		   S_PHS_RULE   *decomp_phs_rules, UINT *header_size)
 {
-	int phss,size=0;
+	int phss, size=0;
 	S_PHS_RULE   *tmp_memb;
-	int bit,i=0;
+	int bit, i=0;
 	unsigned char *phsf,*phsm;
 	int in_buf_len = *header_size-1;
 	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
@@ -1346,7 +1346,7 @@ int phs_decompress(unsigned char *in_buf,unsigned char *out_buf,
 
 	tmp_memb = decomp_phs_rules;
 	//bcm_dbg(Adapter, OTHERS, PHS_RECEIVE, ALL,
-	//"DECOMP:In phs_decompress PHSI 1  %d\n",phsi));
+	//"DECOMP:In phs_decompress PHSI 1  %d\n", phsi));
 	//*header_size = tmp_memb->u8PHSFLength;
 	phss         = tmp_memb->u8PHSS;
 	phsf         = tmp_memb->u8PHSF;
@@ -1355,7 +1355,7 @@ int phs_decompress(unsigned char *in_buf,unsigned char *out_buf,
 	if (phss > MAX_PHS_LENGTHS)
 		phss = MAX_PHS_LENGTHS;
 	//bcm_dbg(Adapter, OTHERS, PHS_RECEIVE, ALL,
-	//"\nDECOMP:In phs_decompress PHSI  %d phss %d index %d\n", phsi,phss,index));
+	//"\nDECOMP:In phs_decompress PHSI  %d phss %d index %d\n", phsi, phss, index));
 	while ((phss > 0) && (size < in_buf_len)) {
 		bit =  ((*phsm << i)& SUPPRESS);
 
@@ -1409,8 +1409,8 @@ int phs_decompress(unsigned char *in_buf,unsigned char *out_buf,
 //	size-The number of bytes copied into the output buffer i.e dynamic fields
 //	0	-If PHS rule is NULL.If PHSV field is not set.If the verification fails.
 //-----------------------------------------------------------------------------
-static int phs_compress(S_PHS_RULE  *phs_rule,unsigned char *in_buf
-			,unsigned char *out_buf,UINT *header_size,UINT *new_header_size)
+static int phs_compress(S_PHS_RULE  *phs_rule, unsigned char *in_buf
+			, unsigned char *out_buf, UINT *header_size, UINT *new_header_size)
 {
 	unsigned char *old_addr = out_buf;
 	int supress = 0;
@@ -1430,8 +1430,8 @@ static int phs_compress(S_PHS_RULE  *phs_rule,unsigned char *in_buf
 	}
 	//To copy PHSI
 	out_buf++;
-	supress = verify_suppress_phsf(in_buf,out_buf,phs_rule->u8PHSF,
-				       phs_rule->u8PHSM, phs_rule->u8PHSS, phs_rule->u8PHSV,new_header_size);
+	supress = verify_suppress_phsf(in_buf, out_buf, phs_rule->u8PHSF,
+				       phs_rule->u8PHSM, phs_rule->u8PHSS, phs_rule->u8PHSV, new_header_size);
 
 	if (supress == STATUS_PHS_COMPRESSED) {
 		*old_addr = (unsigned char)phs_rule->u8PHSI;
@@ -1466,12 +1466,12 @@ static int phs_compress(S_PHS_RULE  *phs_rule,unsigned char *in_buf
 //	0	-Packet has failed the verification.
 //-----------------------------------------------------------------------------
 
-static int verify_suppress_phsf(unsigned char *in_buffer,unsigned char *out_buffer,
-				unsigned char *phsf,unsigned char *phsm,unsigned int phss,
-				unsigned int phsv,UINT* new_header_size)
+static int verify_suppress_phsf(unsigned char *in_buffer, unsigned char *out_buffer,
+				unsigned char *phsf, unsigned char *phsm, unsigned int phss,
+				unsigned int phsv, UINT* new_header_size)
 {
 	unsigned int size=0;
-	int bit,i=0;
+	int bit, i=0;
 	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 	bcm_dbg(Adapter, OTHERS, PHS_SEND, ALL,
 		"COMP:In verify_phsf PHSM - 0x%X\n", *phsm);
diff --git a/drivers/staging/bcm/PHSModule.h b/drivers/staging/bcm/PHSModule.h
index 652f444..7331d54 100644
--- a/drivers/staging/bcm/PHSModule.h
+++ b/drivers/staging/bcm/PHSModule.h
@@ -20,28 +20,28 @@ int PHSReceive(PMINI_ADAPTER Adapter,
 
 void DumpDataPacketHeader(PUCHAR pPkt);
 
-void DumpFullPacket(UCHAR *pBuf,UINT nPktLen);
+void DumpFullPacket(UCHAR *pBuf, UINT nPktLen);
 
 void DumpPhsRules(PPHS_DEVICE_EXTENSION pDeviceExtension);
 
 
-int phs_init(PPHS_DEVICE_EXTENSION pPhsdeviceExtension,PMINI_ADAPTER Adapter);
+int phs_init(PPHS_DEVICE_EXTENSION pPhsdeviceExtension, PMINI_ADAPTER Adapter);
 
 int PhsCleanup(PPHS_DEVICE_EXTENSION pPHSDeviceExt);
 
 //Utility Functions
-ULONG PhsUpdateClassifierRule(void* pvContext,B_UINT16 uiVcid,B_UINT16 uiClsId,S_PHS_RULE *psPhsRule,B_UINT8  u8AssociatedPHSI );
+ULONG PhsUpdateClassifierRule(void* pvContext, B_UINT16 uiVcid, B_UINT16 uiClsId, S_PHS_RULE *psPhsRule, B_UINT8  u8AssociatedPHSI );
 
-ULONG PhsDeletePHSRule(void* pvContext,B_UINT16 uiVcid,B_UINT8 u8PHSI);
+ULONG PhsDeletePHSRule(void* pvContext, B_UINT16 uiVcid, B_UINT8 u8PHSI);
 
-ULONG PhsDeleteClassifierRule(void* pvContext, B_UINT16 uiVcid ,B_UINT16  uiClsId);
+ULONG PhsDeleteClassifierRule(void* pvContext, B_UINT16 uiVcid , B_UINT16  uiClsId);
 
-ULONG PhsDeleteSFRules(void* pvContext,B_UINT16 uiVcid) ;
+ULONG PhsDeleteSFRules(void* pvContext, B_UINT16 uiVcid) ;
 
 
 BOOLEAN ValidatePHSRule(S_PHS_RULE *psPhsRule);
 
-UINT GetServiceFlowEntry(S_SERVICEFLOW_TABLE *psServiceFlowTable,B_UINT16 uiVcid,S_SERVICEFLOW_ENTRY **ppstServiceFlowEntry);
+UINT GetServiceFlowEntry(S_SERVICEFLOW_TABLE *psServiceFlowTable, B_UINT16 uiVcid, S_SERVICEFLOW_ENTRY **ppstServiceFlowEntry);
 
 
 void DumpPhsRules(PPHS_DEVICE_EXTENSION pDeviceExtension);
diff --git a/drivers/staging/bcm/Prototypes.h b/drivers/staging/bcm/Prototypes.h
index 90e795c..4325664 100644
--- a/drivers/staging/bcm/Prototypes.h
+++ b/drivers/staging/bcm/Prototypes.h
@@ -3,13 +3,13 @@
 
 VOID LinkControlResponseMessage(PMINI_ADAPTER Adapter, PUCHAR pucBuffer);
 
-VOID StatisticsResponse(PMINI_ADAPTER Adapter,PVOID pvBuffer);
+VOID StatisticsResponse(PMINI_ADAPTER Adapter, PVOID pvBuffer);
 
-VOID IdleModeResponse(PMINI_ADAPTER Adapter,PUINT puiBuffer);
+VOID IdleModeResponse(PMINI_ADAPTER Adapter, PUINT puiBuffer);
 
 int control_packet_handler	(PMINI_ADAPTER Adapter);
 
-VOID DeleteAllClassifiersForSF(PMINI_ADAPTER Adapter,UINT uiSearchRuleIndex);
+VOID DeleteAllClassifiersForSF(PMINI_ADAPTER Adapter, UINT uiSearchRuleIndex);
 
 VOID flush_all_queues(PMINI_ADAPTER Adapter);
 
@@ -29,13 +29,13 @@ VOID flush_all_queues(PMINI_ADAPTER Adapter);
 
 VOID PruneQueueAllSF(PMINI_ADAPTER Adapter);
 
-INT SearchSfid(PMINI_ADAPTER Adapter,UINT uiSfid);
+INT SearchSfid(PMINI_ADAPTER Adapter, UINT uiSfid);
 
-USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb);
+USHORT ClassifyPacket(PMINI_ADAPTER Adapter, struct sk_buff* skb);
 
-BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort);
-BOOLEAN MatchDestPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort);
-BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucProtocol);
+BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule, USHORT ushSrcPort);
+BOOLEAN MatchDestPort(S_CLASSIFIER_RULE *pstClassifierRule, USHORT ushSrcPort);
+BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule, UCHAR ucProtocol);
 
 
 INT SetupNextSend(PMINI_ADAPTER Adapter, /**<Logical Adapter*/
@@ -101,17 +101,17 @@ VOID ResetCounters(PMINI_ADAPTER Adapter);
 
 int InitLedSettings(PMINI_ADAPTER Adapter);
 
-S_CLASSIFIER_RULE *GetFragIPClsEntry(PMINI_ADAPTER Adapter,USHORT usIpIdentification,ULONG SrcIP);
+S_CLASSIFIER_RULE *GetFragIPClsEntry(PMINI_ADAPTER Adapter, USHORT usIpIdentification, ULONG SrcIP);
 
-void AddFragIPClsEntry(PMINI_ADAPTER Adapter,PS_FRAGMENTED_PACKET_INFO psFragPktInfo);
+void AddFragIPClsEntry(PMINI_ADAPTER Adapter, PS_FRAGMENTED_PACKET_INFO psFragPktInfo);
 
-void DelFragIPClsEntry(PMINI_ADAPTER Adapter,USHORT usIpIdentification,ULONG SrcIp);
+void DelFragIPClsEntry(PMINI_ADAPTER Adapter, USHORT usIpIdentification, ULONG SrcIp);
 
 void update_per_cid_rx (PMINI_ADAPTER Adapter);
 
 void update_per_sf_desc_cnts( PMINI_ADAPTER Adapter);
 
-void ClearTargetDSXBuffer(PMINI_ADAPTER Adapter,B_UINT16 TID,BOOLEAN bFreeAll);
+void ClearTargetDSXBuffer(PMINI_ADAPTER Adapter, B_UINT16 TID, BOOLEAN bFreeAll);
 
 
 void flush_queue(PMINI_ADAPTER Adapter, UINT iQIndex);
@@ -128,7 +128,7 @@ INT BeceemEEPROMBulkRead(
 
 
 
-INT WriteBeceemEEPROM(PMINI_ADAPTER Adapter,UINT uiEEPROMOffset, UINT uiData);
+INT WriteBeceemEEPROM(PMINI_ADAPTER Adapter, UINT uiEEPROMOffset, UINT uiData);
 
 INT PropagateCalParamsFromFlashToMemory(PMINI_ADAPTER Adapter);
 
@@ -141,7 +141,7 @@ INT BeceemEEPROMBulkWrite(
 	BOOLEAN bVerify);
 
 
-INT ReadBeceemEEPROM(PMINI_ADAPTER Adapter,UINT dwAddress, UINT *pdwData);
+INT ReadBeceemEEPROM(PMINI_ADAPTER Adapter, UINT dwAddress, UINT *pdwData);
 
 
 INT BeceemNVMRead(
@@ -160,7 +160,7 @@ INT BeceemNVMWrite(
 
 INT BcmInitNVM(PMINI_ADAPTER Adapter);
 
-INT BcmUpdateSectorSize(PMINI_ADAPTER Adapter,UINT uiSectorSize);
+INT BcmUpdateSectorSize(PMINI_ADAPTER Adapter, UINT uiSectorSize);
 BOOLEAN IsSectionExistInFlash(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL section);
 
 INT BcmGetFlash2xSectionalBitMap(PMINI_ADAPTER Adapter, PFLASH2X_BITMAP psFlash2xBitMap);
@@ -201,7 +201,7 @@ INT	BcmCopySection(PMINI_ADAPTER Adapter,
 BOOLEAN IsNonCDLessDevice(PMINI_ADAPTER Adapter);
 
 
-VOID OverrideServiceFlowParams(PMINI_ADAPTER Adapter,PUINT puiBuffer);
+VOID OverrideServiceFlowParams(PMINI_ADAPTER Adapter, PUINT puiBuffer);
 
 int wrmaltWithLock (PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t sSize);
 int rdmaltWithLock (PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t sSize);
diff --git a/drivers/staging/bcm/Qos.c b/drivers/staging/bcm/Qos.c
index 964df89..afaabfd 100644
--- a/drivers/staging/bcm/Qos.c
+++ b/drivers/staging/bcm/Qos.c
@@ -4,8 +4,8 @@
 */
 #include "headers.h"
 
-static void EThCSGetPktInfo(PMINI_ADAPTER Adapter,PVOID pvEthPayload,PS_ETHCS_PKT_INFO pstEthCsPktInfo);
-static BOOLEAN EThCSClassifyPkt(PMINI_ADAPTER Adapter,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo,S_CLASSIFIER_RULE *pstClassifierRule, B_UINT8 EthCSCupport);
+static void EThCSGetPktInfo(PMINI_ADAPTER Adapter, PVOID pvEthPayload, PS_ETHCS_PKT_INFO pstEthCsPktInfo);
+static BOOLEAN EThCSClassifyPkt(PMINI_ADAPTER Adapter, struct sk_buff* skb, PS_ETHCS_PKT_INFO pstEthCsPktInfo, S_CLASSIFIER_RULE *pstClassifierRule, B_UINT8 EthCSCupport);
 
 static USHORT	IpVersion4(PMINI_ADAPTER Adapter, struct iphdr *iphd,
 			   S_CLASSIFIER_RULE *pstClassifierRule );
@@ -24,7 +24,7 @@ static VOID PruneQueue(PMINI_ADAPTER Adapter, INT iIndex);
  *
  * Returns     - TRUE(If address matches) else FAIL .
  *********************************************************************/
-BOOLEAN MatchSrcIpAddress(S_CLASSIFIER_RULE *pstClassifierRule,ULONG ulSrcIP)
+BOOLEAN MatchSrcIpAddress(S_CLASSIFIER_RULE *pstClassifierRule, ULONG ulSrcIP)
 {
 	UCHAR	ucLoopIndex=0;
 
@@ -60,7 +60,7 @@ BOOLEAN MatchSrcIpAddress(S_CLASSIFIER_RULE *pstClassifierRule,ULONG ulSrcIP)
  *
  * Returns     - TRUE(If address matches) else FAIL .
  *********************************************************************/
-BOOLEAN MatchDestIpAddress(S_CLASSIFIER_RULE *pstClassifierRule,ULONG ulDestIP)
+BOOLEAN MatchDestIpAddress(S_CLASSIFIER_RULE *pstClassifierRule, ULONG ulDestIP)
 {
 	UCHAR	ucLoopIndex=0;
 	PMINI_ADAPTER	Adapter = GET_BCM_ADAPTER(gblpnetdev);
@@ -96,7 +96,7 @@ BOOLEAN MatchDestIpAddress(S_CLASSIFIER_RULE *pstClassifierRule,ULONG ulDestIP)
  *
  * Returns     - TRUE(If address matches) else FAIL.
  **************************************************************************/
-BOOLEAN MatchTos(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucTypeOfService)
+BOOLEAN MatchTos(S_CLASSIFIER_RULE *pstClassifierRule, UCHAR ucTypeOfService)
 {
 
 	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
@@ -121,7 +121,7 @@ BOOLEAN MatchTos(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucTypeOfService)
  *
  * Returns     - TRUE(If address matches) else FAIL.
  ****************************************************************************/
-BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucProtocol)
+BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule, UCHAR ucProtocol)
 {
 	UCHAR	ucLoopIndex=0;
 	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
@@ -150,7 +150,7 @@ BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucProtocol)
  *
  * Returns     - TRUE(If address matches) else FAIL.
  ***************************************************************************/
-BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort)
+BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule, USHORT ushSrcPort)
 {
 	UCHAR	ucLoopIndex=0;
 
@@ -181,7 +181,7 @@ BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort)
  *
  * Returns     - TRUE(If address matches) else FAIL.
  ***************************************************************************/
-BOOLEAN MatchDestPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushDestPort)
+BOOLEAN MatchDestPort(S_CLASSIFIER_RULE *pstClassifierRule, USHORT ushDestPort)
 {
 	UCHAR	ucLoopIndex=0;
 	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
@@ -261,7 +261,7 @@ static USHORT	IpVersion4(PMINI_ADAPTER Adapter,
 		bcm_dbg(Adapter, TX, IPV4_DBG, ALL, "TOS Matched\n");
 
 		if (FALSE == (bClassificationSucceed =
-			     MatchProtocol(pstClassifierRule,iphd->protocol)))
+			     MatchProtocol(pstClassifierRule, iphd->protocol)))
 			break;
 		bcm_dbg(Adapter, TX, IPV4_DBG, ALL, "Protocol Matched\n");
 
@@ -291,7 +291,7 @@ static USHORT	IpVersion4(PMINI_ADAPTER Adapter,
 
 	if (TRUE==bClassificationSucceed) {
 		INT iMatchedSFQueueIndex = 0;
-		iMatchedSFQueueIndex = SearchSfid(Adapter,pstClassifierRule->ulSFID);
+		iMatchedSFQueueIndex = SearchSfid(Adapter, pstClassifierRule->ulSFID);
 		if (iMatchedSFQueueIndex >= NO_OF_QUEUES) {
 			bClassificationSucceed = FALSE;
 		} else {
@@ -442,7 +442,7 @@ VOID flush_all_queues(PMINI_ADAPTER Adapter)
 	bcm_dbg(Adapter, OTHERS, DUMP_INFO, ALL, "<=====\n");
 }
 
-USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
+USHORT ClassifyPacket(PMINI_ADAPTER Adapter, struct sk_buff* skb)
 {
 	INT			uiLoopIndex=0;
 	S_CLASSIFIER_RULE *pstClassifierRule = NULL;
@@ -451,7 +451,7 @@ USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
 	struct iphdr		*pIpHeader = NULL;
 	INT	  uiSfIndex=0;
 	USHORT	usIndex=Adapter->usBestEffortQueueIndex;
-	BOOLEAN	bFragmentedPkt=FALSE,bClassificationSucceed=FALSE;
+	BOOLEAN	bFragmentedPkt=FALSE, bClassificationSucceed=FALSE;
 	USHORT	usCurrFragment =0;
 
 	PTCP_HEADER pTcpHeader;
@@ -460,7 +460,7 @@ USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
 
 	pvEThPayload = skb->data;
 	*((UINT32*) (skb->cb) +SKB_CB_TCPACK_OFFSET ) = 0;
-	EThCSGetPktInfo(Adapter,pvEThPayload,&stEthCsPktInfo);
+	EThCSGetPktInfo(Adapter, pvEThPayload,&stEthCsPktInfo);
 
 	switch (stEthCsPktInfo.eNwpktEthFrameType) {
 	case eEth802LLCFrame: {
@@ -504,7 +504,7 @@ USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
 
 		if (bFragmentedPkt) {
 			//Fragmented  Packet. Get Frag Classifier Entry.
-			pstClassifierRule = GetFragIPClsEntry(Adapter,pIpHeader->id, pIpHeader->saddr);
+			pstClassifierRule = GetFragIPClsEntry(Adapter, pIpHeader->id, pIpHeader->saddr);
 			if (pstClassifierRule) {
 				bcm_dbg(Adapter, TX, IPV4_DBG, ALL,
 					"It is next Fragmented pkt\n");
@@ -514,7 +514,7 @@ USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
 				//Fragmented Last packet . Remove Frag Classifier Entry
 				bcm_dbg(Adapter, TX, IPV4_DBG, ALL,
 					"This is the last fragmented Pkt\n");
-				DelFragIPClsEntry(Adapter,pIpHeader->id, pIpHeader->saddr);
+				DelFragIPClsEntry(Adapter, pIpHeader->id, pIpHeader->saddr);
 			}
 		}
 	}
@@ -541,7 +541,7 @@ USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
 
 			pstClassifierRule = &Adapter->astClassifierTable[uiLoopIndex];
 
-			uiSfIndex = SearchSfid(Adapter,pstClassifierRule->ulSFID);
+			uiSfIndex = SearchSfid(Adapter, pstClassifierRule->ulSFID);
 			if (uiSfIndex >= NO_OF_QUEUES) {
 				bcm_dbg(Adapter, TX, IPV4_DBG, ALL,
 					"Queue Not Valid. SearchSfid for this classifier Failed\n");
@@ -563,7 +563,7 @@ USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
 					"Performing ETH CS Classification on Classifier Rule ID : %x Service Flow ID : %lx\n",
 					pstClassifierRule->uiClassifierRuleIndex,
 					Adapter->PackInfo[uiSfIndex].ulSFID);
-				bClassificationSucceed = EThCSClassifyPkt(Adapter,skb,&stEthCsPktInfo,pstClassifierRule, Adapter->PackInfo[uiSfIndex].bEthCSSupport);
+				bClassificationSucceed = EThCSClassifyPkt(Adapter, skb,&stEthCsPktInfo, pstClassifierRule, Adapter->PackInfo[uiSfIndex].bEthCSSupport);
 
 				if (!bClassificationSucceed) {
 					bcm_dbg(Adapter, TX, IPV4_DBG, ALL,
@@ -595,12 +595,12 @@ USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
 				}
 				bcm_dbg(Adapter, TX, IPV4_DBG, ALL,
 					"Dump IP Header :\n");
-				DumpFullPacket((PUCHAR)pIpHeader,20);
+				DumpFullPacket((PUCHAR)pIpHeader, 20);
 
 				if (stEthCsPktInfo.eNwpktIPFrameType == eIPv4Packet)
-					bClassificationSucceed = IpVersion4(Adapter,pIpHeader,pstClassifierRule);
+					bClassificationSucceed = IpVersion4(Adapter, pIpHeader, pstClassifierRule);
 				else if (stEthCsPktInfo.eNwpktIPFrameType == eIPv6Packet)
-					bClassificationSucceed = IpVersion6(Adapter,pIpHeader,pstClassifierRule);
+					bClassificationSucceed = IpVersion6(Adapter, pIpHeader, pstClassifierRule);
 			}
 
 		}while (0);
@@ -650,7 +650,7 @@ USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
 		return INVALID_QUEUE_INDEX;
 }
 
-static BOOLEAN EthCSMatchSrcMACAddress(S_CLASSIFIER_RULE *pstClassifierRule,PUCHAR Mac)
+static BOOLEAN EthCSMatchSrcMACAddress(S_CLASSIFIER_RULE *pstClassifierRule, PUCHAR Mac)
 {
 	UINT i=0;
 	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
@@ -669,7 +669,7 @@ static BOOLEAN EthCSMatchSrcMACAddress(S_CLASSIFIER_RULE *pstClassifierRule,PUCH
 	return TRUE;
 }
 
-static BOOLEAN EthCSMatchDestMACAddress(S_CLASSIFIER_RULE *pstClassifierRule,PUCHAR Mac)
+static BOOLEAN EthCSMatchDestMACAddress(S_CLASSIFIER_RULE *pstClassifierRule, PUCHAR Mac)
 {
 	UINT i=0;
 	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
@@ -688,7 +688,7 @@ static BOOLEAN EthCSMatchDestMACAddress(S_CLASSIFIER_RULE *pstClassifierRule,PUC
 	return TRUE;
 }
 
-static BOOLEAN EthCSMatchEThTypeSAP(S_CLASSIFIER_RULE *pstClassifierRule,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo)
+static BOOLEAN EthCSMatchEThTypeSAP(S_CLASSIFIER_RULE *pstClassifierRule, struct sk_buff* skb, PS_ETHCS_PKT_INFO pstEthCsPktInfo)
 {
 	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 	if ((pstClassifierRule->ucEtherTypeLen==0)||
@@ -706,7 +706,7 @@ static BOOLEAN EthCSMatchEThTypeSAP(S_CLASSIFIER_RULE *pstClassifierRule,struct
 			pstClassifierRule->au8EthCSEtherType[1],
 			pstClassifierRule->au8EthCSEtherType[2]);
 
-		if (memcmp(&pstEthCsPktInfo->usEtherType,&pstClassifierRule->au8EthCSEtherType[1],2)==0)
+		if (memcmp(&pstEthCsPktInfo->usEtherType,&pstClassifierRule->au8EthCSEtherType[1], 2)==0)
 			return TRUE;
 		else
 			return FALSE;
@@ -732,7 +732,7 @@ static BOOLEAN EthCSMatchEThTypeSAP(S_CLASSIFIER_RULE *pstClassifierRule,struct
 
 }
 
-static BOOLEAN EthCSMatchVLANRules(S_CLASSIFIER_RULE *pstClassifierRule,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo)
+static BOOLEAN EthCSMatchVLANRules(S_CLASSIFIER_RULE *pstClassifierRule, struct sk_buff* skb, PS_ETHCS_PKT_INFO pstEthCsPktInfo)
 {
 	BOOLEAN bClassificationSucceed = FALSE;
 	USHORT usVLANID;
@@ -788,24 +788,24 @@ static BOOLEAN EthCSMatchVLANRules(S_CLASSIFIER_RULE *pstClassifierRule,struct s
 }
 
 
-static BOOLEAN EThCSClassifyPkt(PMINI_ADAPTER Adapter,struct sk_buff* skb,
+static BOOLEAN EThCSClassifyPkt(PMINI_ADAPTER Adapter, struct sk_buff* skb,
 				PS_ETHCS_PKT_INFO pstEthCsPktInfo,
 				S_CLASSIFIER_RULE *pstClassifierRule,
 				B_UINT8 EthCSCupport)
 {
 	BOOLEAN bClassificationSucceed = FALSE;
-	bClassificationSucceed = EthCSMatchSrcMACAddress(pstClassifierRule,((ETH_HEADER_STRUC *)(skb->data))->au8SourceAddress);
+	bClassificationSucceed = EthCSMatchSrcMACAddress(pstClassifierRule, ((ETH_HEADER_STRUC *)(skb->data))->au8SourceAddress);
 	if (!bClassificationSucceed)
 		return FALSE;
 	bcm_dbg(Adapter, TX, IPV4_DBG, ALL, "ETH CS SrcMAC Matched\n");
 
-	bClassificationSucceed = EthCSMatchDestMACAddress(pstClassifierRule,((ETH_HEADER_STRUC*)(skb->data))->au8DestinationAddress);
+	bClassificationSucceed = EthCSMatchDestMACAddress(pstClassifierRule, ((ETH_HEADER_STRUC*)(skb->data))->au8DestinationAddress);
 	if (!bClassificationSucceed)
 		return FALSE;
 	bcm_dbg(Adapter, TX, IPV4_DBG, ALL, "ETH CS DestMAC Matched\n");
 
 	//classify on ETHType/802.2SAP TLV
-	bClassificationSucceed = EthCSMatchEThTypeSAP(pstClassifierRule,skb,pstEthCsPktInfo);
+	bClassificationSucceed = EthCSMatchEThTypeSAP(pstClassifierRule, skb, pstEthCsPktInfo);
 	if (!bClassificationSucceed)
 		return FALSE;
 
@@ -814,7 +814,7 @@ static BOOLEAN EThCSClassifyPkt(PMINI_ADAPTER Adapter,struct sk_buff* skb,
 
 	//classify on 802.1VLAN Header Parameters
 
-	bClassificationSucceed = EthCSMatchVLANRules(pstClassifierRule,skb,pstEthCsPktInfo);
+	bClassificationSucceed = EthCSMatchVLANRules(pstClassifierRule, skb, pstEthCsPktInfo);
 	if (!bClassificationSucceed)
 		return FALSE;
 	bcm_dbg(Adapter, TX, IPV4_DBG, ALL,
@@ -823,7 +823,7 @@ static BOOLEAN EThCSClassifyPkt(PMINI_ADAPTER Adapter,struct sk_buff* skb,
 	return bClassificationSucceed;
 }
 
-static void EThCSGetPktInfo(PMINI_ADAPTER Adapter,PVOID pvEthPayload,
+static void EThCSGetPktInfo(PMINI_ADAPTER Adapter, PVOID pvEthPayload,
 			    PS_ETHCS_PKT_INFO pstEthCsPktInfo)
 {
 	USHORT u16Etype = ntohs(((ETH_HEADER_STRUC*)pvEthPayload)->u16Etype);
diff --git a/drivers/staging/bcm/Queue.h b/drivers/staging/bcm/Queue.h
index b387283..e184b11 100644
--- a/drivers/staging/bcm/Queue.h
+++ b/drivers/staging/bcm/Queue.h
@@ -6,7 +6,7 @@
 
 
 
-#define ENQUEUEPACKET(_Head, _Tail,_Packet)		\
+#define ENQUEUEPACKET(_Head, _Tail, _Packet)		\
 	do						\
 	{                                               \
 		if (!_Head) {                           \
diff --git a/drivers/staging/bcm/Transmit.c b/drivers/staging/bcm/Transmit.c
index 5b33d12..274213b 100644
--- a/drivers/staging/bcm/Transmit.c
+++ b/drivers/staging/bcm/Transmit.c
@@ -130,7 +130,7 @@ INT SetupNextSend(PMINI_ADAPTER Adapter,  struct sk_buff *Packet, USHORT Vcid)
 	if (Adapter->PackInfo[QueueIndex].bEthCSSupport) {
 		Leader.PLength = Packet->len;
 		if (skb_headroom(Packet) < LEADER_SIZE) {
-			if ((status = skb_cow(Packet,LEADER_SIZE))) {
+			if ((status = skb_cow(Packet, LEADER_SIZE))) {
 				bcm_dbg(Adapter, TX, NEXT_SEND, ALL,
 					"bcm_transmit : Failed To Increase headRoom\n");
 				goto errExit;
diff --git a/drivers/staging/bcm/cntrl_SignalingInterface.h b/drivers/staging/bcm/cntrl_SignalingInterface.h
index 3145d7d..942787f 100644
--- a/drivers/staging/bcm/cntrl_SignalingInterface.h
+++ b/drivers/staging/bcm/cntrl_SignalingInterface.h
@@ -101,7 +101,7 @@ struct _stCPacketClassificationRuleSI{
 	B_UINT8							u8ClassifierActionRule;
 	B_UINT16							u16ValidityBitMap;
 };
-typedef struct _stCPacketClassificationRuleSI CCPacketClassificationRuleSI,stCPacketClassificationRuleSI, *pstCPacketClassificationRuleSI;
+typedef struct _stCPacketClassificationRuleSI CCPacketClassificationRuleSI, stCPacketClassificationRuleSI, *pstCPacketClassificationRuleSI;
 
 /// \brief class CPhsRuleSI
 typedef struct _stPhsRuleSI {
@@ -141,7 +141,7 @@ struct _stConvergenceSLTypes{
 	/// \brief class CPhsRuleSI
 	struct _stPhsRuleSI		cPhsRule;
 };
-typedef struct _stConvergenceSLTypes stConvergenceSLTypes,CConvergenceSLTypes, *pstConvergenceSLTypes;
+typedef struct _stConvergenceSLTypes stConvergenceSLTypes, CConvergenceSLTypes, *pstConvergenceSLTypes;
 
 
 /// \brief structure CServiceFlowParamSI
diff --git a/drivers/staging/bcm/led_control.h b/drivers/staging/bcm/led_control.h
index 1a7d4df..51b5c35e 100644
--- a/drivers/staging/bcm/led_control.h
+++ b/drivers/staging/bcm/led_control.h
@@ -29,15 +29,15 @@
 #define TURN_ON_LED(GPIO, index) do{					\
 		UINT gpio_val = GPIO;					\
 		(Adapter->LEDInfo.LEDState[index].BitPolarity == 1) ?	\
-			wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_SET_REG, &gpio_val ,sizeof(gpio_val)) : \
-			wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_CLR_REG, &gpio_val, sizeof(gpio_val)); \
+			wrmaltWithLock(Adapter, BCM_GPIO_OUTPUT_SET_REG, &gpio_val , sizeof(gpio_val)) : \
+			wrmaltWithLock(Adapter, BCM_GPIO_OUTPUT_CLR_REG, &gpio_val, sizeof(gpio_val)); \
 	}while (0);
 
 #define TURN_OFF_LED(GPIO, index)  do {					\
 		UINT gpio_val = GPIO;					\
 		(Adapter->LEDInfo.LEDState[index].BitPolarity == 1) ?	\
-			wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_CLR_REG,&gpio_val ,sizeof(gpio_val)) : \
-			wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_SET_REG,&gpio_val ,sizeof(gpio_val)); \
+			wrmaltWithLock(Adapter, BCM_GPIO_OUTPUT_CLR_REG,&gpio_val , sizeof(gpio_val)) : \
+			wrmaltWithLock(Adapter, BCM_GPIO_OUTPUT_SET_REG,&gpio_val , sizeof(gpio_val)); \
 	}while (0);
 
 #define B_ULONG32 unsigned long
diff --git a/drivers/staging/bcm/nvm.c b/drivers/staging/bcm/nvm.c
index a3012d4a..5cf902f 100644
--- a/drivers/staging/bcm/nvm.c
+++ b/drivers/staging/bcm/nvm.c
@@ -49,7 +49,7 @@ static INT BeceemFlashBulkWrite(
 
 static INT GetFlashBaseAddr(PMINI_ADAPTER Adapter);
 
-static INT ReadBeceemEEPROMBulk(PMINI_ADAPTER Adapter,UINT dwAddress, UINT *pdwData, UINT dwNumData);
+static INT ReadBeceemEEPROMBulk(PMINI_ADAPTER Adapter, UINT dwAddress, UINT *pdwData, UINT dwNumData);
 
 // Procedure:	ReadEEPROMStatusRegister
 //
@@ -326,15 +326,15 @@ INT BeceemEEPROMBulkRead(
 	if (uiOffset%MAX_RW_SIZE&& uiBytesRemaining) {
 		uiTempOffset = uiOffset - (uiOffset%MAX_RW_SIZE);
 		uiExtraBytes = uiOffset-uiTempOffset;
-		ReadBeceemEEPROMBulk(Adapter,uiTempOffset,(PUINT)&uiData[0],4);
+		ReadBeceemEEPROMBulk(Adapter, uiTempOffset, (PUINT)&uiData[0], 4);
 		if (uiBytesRemaining >= (MAX_RW_SIZE - uiExtraBytes)) {
-			memcpy(pBuffer,(((PUCHAR)&uiData[0])+uiExtraBytes),MAX_RW_SIZE - uiExtraBytes);
+			memcpy(pBuffer, (((PUCHAR)&uiData[0])+uiExtraBytes), MAX_RW_SIZE - uiExtraBytes);
 
 			uiBytesRemaining -= (MAX_RW_SIZE - uiExtraBytes);
 			uiIndex += (MAX_RW_SIZE - uiExtraBytes);
 			uiOffset += (MAX_RW_SIZE - uiExtraBytes);
 		} else {
-			memcpy(pBuffer,(((PUCHAR)&uiData[0])+uiExtraBytes),uiBytesRemaining);
+			memcpy(pBuffer, (((PUCHAR)&uiData[0])+uiExtraBytes), uiBytesRemaining);
 			uiIndex += uiBytesRemaining;
 			uiOffset += uiBytesRemaining;
 			uiBytesRemaining = 0;
@@ -353,8 +353,8 @@ INT BeceemEEPROMBulkRead(
 			/* For the requests more than or equal to 16 bytes, use bulk
 			 * read function to make the access faster.
 			 * We read 4 Dwords of data */
-			if (0 == ReadBeceemEEPROMBulk(Adapter,uiOffset,&uiData[0],4)) {
-				memcpy(pcBuff+uiIndex,&uiData[0],MAX_RW_SIZE);
+			if (0 == ReadBeceemEEPROMBulk(Adapter, uiOffset,&uiData[0], 4)) {
+				memcpy(pcBuff+uiIndex,&uiData[0], MAX_RW_SIZE);
 				uiOffset += MAX_RW_SIZE;
 				uiBytesRemaining -= MAX_RW_SIZE;
 				uiIndex += MAX_RW_SIZE;
@@ -363,8 +363,8 @@ INT BeceemEEPROMBulkRead(
 				mdelay(3);//sleep for a while before retry...
 			}
 		} else if (uiBytesRemaining >= 4) {
-			if (0 == ReadBeceemEEPROM(Adapter,uiOffset,&uiData[0])) {
-				memcpy(pcBuff+uiIndex,&uiData[0],4);
+			if (0 == ReadBeceemEEPROM(Adapter, uiOffset,&uiData[0])) {
+				memcpy(pcBuff+uiIndex,&uiData[0], 4);
 				uiOffset += 4;
 				uiBytesRemaining -= 4;
 				uiIndex +=4;
@@ -376,8 +376,8 @@ INT BeceemEEPROMBulkRead(
 		{ // Handle the reads less than 4 bytes...
 			PUCHAR pCharBuff = (PUCHAR)pBuffer;
 			pCharBuff += uiIndex;
-			if (0 == ReadBeceemEEPROM(Adapter,uiOffset,&uiData[0])) {
-				memcpy(pCharBuff,&uiData[0],uiBytesRemaining);//copy only bytes requested.
+			if (0 == ReadBeceemEEPROM(Adapter, uiOffset,&uiData[0])) {
+				memcpy(pCharBuff,&uiData[0], uiBytesRemaining);//copy only bytes requested.
 				uiBytesRemaining = 0;
 			} else {
 				uiFailureRetries++;
@@ -426,18 +426,18 @@ static INT BeceemFlashBulkRead(
 	//Adding flash Base address
 //	uiOffset = uiOffset + GetFlashBaseAddr(Adapter);
 #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
-	Status = bcmflash_raw_read((uiOffset/FLASH_PART_SIZE),(uiOffset % FLASH_PART_SIZE),( unsigned char *)pBuffer,uiNumBytes);
+	Status = bcmflash_raw_read((uiOffset/FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), ( unsigned char *)pBuffer, uiNumBytes);
 	return Status;
 #endif
 
 	Adapter->SelectedChip = RESET_CHIP_SELECT;
 
 	if (uiOffset % MAX_RW_SIZE) {
-		BcmDoChipSelect(Adapter,uiOffset);
+		BcmDoChipSelect(Adapter, uiOffset);
 		uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
 
 		uiBytesToRead = MAX_RW_SIZE - (uiOffset%MAX_RW_SIZE);
-		uiBytesToRead = MIN(uiNumBytes,uiBytesToRead);
+		uiBytesToRead = MIN(uiNumBytes, uiBytesToRead);
 
 		bytes = rdm(Adapter, uiPartOffset, (PCHAR)pBuffer+uiIndex, uiBytesToRead);
 		if (bytes < 0) {
@@ -452,10 +452,10 @@ static INT BeceemFlashBulkRead(
 	}
 
 	while (uiNumBytes) {
-		BcmDoChipSelect(Adapter,uiOffset);
+		BcmDoChipSelect(Adapter, uiOffset);
 		uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
 
-		uiBytesToRead = MIN(uiNumBytes,MAX_RW_SIZE);
+		uiBytesToRead = MIN(uiNumBytes, MAX_RW_SIZE);
 
 		bytes = rdm(Adapter, uiPartOffset, (PCHAR)pBuffer+uiIndex, uiBytesToRead);
 		if (bytes < 0) {
@@ -515,17 +515,17 @@ static UINT BcmGetEEPROMSize(PMINI_ADAPTER Adapter)
 	UINT uiIndex = 0;
 
 //
-// if EEPROM is present and already Calibrated,it will have
+// if EEPROM is present and already Calibrated, it will have
 // 'BECM' string at 0th offset.
 //	To find the EEPROM size read the possible boundaries of the
-// EEPROM like 4K,8K etc..accessing the EEPROM beyond its size will
+// EEPROM like 4K, 8K etc..accessing the EEPROM beyond its size will
 // result in wrap around. So when we get the End of the EEPROM we will
 // get 'BECM' string which is indeed at offset 0.
 //
-	BeceemEEPROMBulkRead(Adapter,&uiData,0x0,4);
+	BeceemEEPROMBulkRead(Adapter,&uiData, 0x0, 4);
 	if (uiData == BECM) {
 		for (uiIndex = 2; uiIndex <= 256; uiIndex *= 2) {
-			BeceemEEPROMBulkRead(Adapter,&uiData,uiIndex*1024,4);
+			BeceemEEPROMBulkRead(Adapter,&uiData, uiIndex*1024, 4);
 			if (uiData == BECM) {
 				return uiIndex*1024;
 			}
@@ -536,10 +536,10 @@ static UINT BcmGetEEPROMSize(PMINI_ADAPTER Adapter)
 //
 
 		uiData = 0xBABEFACE;
-		if (0 == BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&uiData,0,4,TRUE)) {
+		if (0 == BeceemEEPROMBulkWrite(Adapter, (PUCHAR)&uiData, 0, 4, TRUE)) {
 			uiData = 0;
 			for (uiIndex = 2; uiIndex <= 256; uiIndex *= 2) {
-				BeceemEEPROMBulkRead(Adapter,&uiData,uiIndex*1024,4);
+				BeceemEEPROMBulkRead(Adapter,&uiData, uiIndex*1024, 4);
 				if (uiData == 0xBABEFACE) {
 					return uiIndex*1024;
 				}
@@ -650,13 +650,13 @@ static INT flashByteWrite(
 		return STATUS_SUCCESS;
 	}
 
-//	DumpDebug(NVM_RW,("flashWrite ====>\n"));
+//	DumpDebug(NVM_RW, ("flashWrite ====>\n"));
 	value = (FLASH_CMD_WRITE_ENABLE << 24);
 	if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG,&value, sizeof(value)) < 0) {
 		pr_info("Write enable in FLASH_SPI_CMDQ_REG register fails\n");
 		return STATUS_FAILURE;
 	}
-	if (wrm(Adapter,FLASH_SPI_WRITEQ_REG, (PCHAR)&ulData, 4) < 0 ) {
+	if (wrm(Adapter, FLASH_SPI_WRITEQ_REG, (PCHAR)&ulData, 4) < 0 ) {
 		pr_info("DATA Write on FLASH_SPI_WRITEQ_REG fails\n");
 		return STATUS_FAILURE;
 	}
@@ -726,7 +726,7 @@ static INT flashWrite(
 	INT  iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; //3
 
 	UINT value;
-	UINT uiErasePattern[4] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF};
+	UINT uiErasePattern[4] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
 	int bytes;
 //
 // need not write 0xFFFFFFFF because write requires an erase and erase will
@@ -813,14 +813,14 @@ static INT flashByteWriteStatus(
 		return STATUS_SUCCESS;
 	}
 
-	//	DumpDebug(NVM_RW,("flashWrite ====>\n"));
+	//	DumpDebug(NVM_RW, ("flashWrite ====>\n"));
 
 	value = (FLASH_CMD_WRITE_ENABLE << 24);
 	if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG,&value, sizeof(value)) < 0) {
 		pr_info("Write enable in FLASH_SPI_CMDQ_REG register fails\n");
 		return STATUS_SUCCESS;
 	}
-	if (wrm(Adapter,FLASH_SPI_WRITEQ_REG, (PCHAR)&ulData, 4) < 0) {
+	if (wrm(Adapter, FLASH_SPI_WRITEQ_REG, (PCHAR)&ulData, 4) < 0) {
 		pr_info("DATA Write on FLASH_SPI_WRITEQ_REG fails\n");
 		return STATUS_FAILURE;
 	}
@@ -883,14 +883,14 @@ static INT flashWriteStatus(
 	INT  iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; //3
 	//UINT uiReadBack = 0;
 	UINT value;
-	UINT uiErasePattern[4] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF};
+	UINT uiErasePattern[4] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
 	int bytes;
 
 //
 // need not write 0xFFFFFFFF because write requires an erase and erase will
 // make whole sector 0xFFFFFFFF.
 //
-	if (!memcmp(pData,uiErasePattern,MAX_RW_SIZE)) {
+	if (!memcmp(pData, uiErasePattern, MAX_RW_SIZE)) {
 		return 0;
 	}
 
@@ -949,7 +949,7 @@ static INT flashWriteStatus(
 //
 //-----------------------------------------------------------------------------
 
-static VOID BcmRestoreBlockProtectStatus(PMINI_ADAPTER Adapter,ULONG ulWriteStatus)
+static VOID BcmRestoreBlockProtectStatus(PMINI_ADAPTER Adapter, ULONG ulWriteStatus)
 {
 	UINT value;
 	value = (FLASH_CMD_WRITE_ENABLE<< 24);
@@ -972,7 +972,7 @@ static VOID BcmRestoreBlockProtectStatus(PMINI_ADAPTER Adapter,ULONG ulWriteStat
 //		ULONG   - Status value before UnProtect.
 //
 //-----------------------------------------------------------------------------
-static ULONG BcmFlashUnProtectBlock(PMINI_ADAPTER Adapter,UINT uiOffset, UINT uiLength)
+static ULONG BcmFlashUnProtectBlock(PMINI_ADAPTER Adapter, UINT uiOffset, UINT uiLength)
 {
 	ULONG ulStatus      = 0;
 	ULONG ulWriteStatus = 0;
@@ -1029,14 +1029,14 @@ static ULONG BcmFlashUnProtectBlock(PMINI_ADAPTER Adapter,UINT uiOffset, UINT ui
 			} else if ((uiOffset+uiLength) <= 0xF0000) {
 				//
 				// Offset comes below Upper 1/16. Only upper 1/16 can be protected.
-				// Set BP0 and Clear BP2,BP1.
+				// Set BP0 and Clear BP2, BP1.
 				//
 				ulWriteStatus |= (0x1<<2);
 				ulWriteStatus &= ~(0x3<<3);
 			} else {
 				//
 				// Unblock all.
-				// Clear BP2,BP1 and BP0.
+				// Clear BP2, BP1 and BP0.
 				//
 				ulWriteStatus &= ~(0x7<<2);
 			}
@@ -1092,7 +1092,7 @@ static INT BeceemFlashBulkWrite(
 	UINT uiPartOffset			= 0;
 
 #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
-	Status = bcmflash_raw_write((uiOffset/FLASH_PART_SIZE),(uiOffset % FLASH_PART_SIZE),( unsigned char *)pBuffer,uiNumBytes);
+	Status = bcmflash_raw_write((uiOffset/FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), ( unsigned char *)pBuffer, uiNumBytes);
 	return Status;
 #endif
 
@@ -1147,7 +1147,7 @@ static INT BeceemFlashBulkWrite(
 		*/
 		uiPartOffset = (uiSectAlignAddr & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
 
-		BcmDoChipSelect(Adapter,uiSectAlignAddr);
+		BcmDoChipSelect(Adapter, uiSectAlignAddr);
 
 		if (0 != BeceemFlashBulkRead(Adapter,
 					    (PUINT)pTempBuff,
@@ -1164,23 +1164,23 @@ static INT BeceemFlashBulkWrite(
 		  (tv1.tv_sec *1000 + tv1.tv_usec/1000));
 		*/
 
-		ulStatus = BcmFlashUnProtectBlock(Adapter,uiSectAlignAddr,Adapter->uiSectorSize);
+		ulStatus = BcmFlashUnProtectBlock(Adapter, uiSectAlignAddr, Adapter->uiSectorSize);
 
 
 		if (uiNumSectTobeRead > 1) {
 
-			memcpy(&pTempBuff[uiCurrSectOffsetAddr],pcBuffer,uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr));
+			memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr));
 			pcBuffer += ((uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr)));
 			uiNumBytes -= (uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr));
 		} else {
-			memcpy(&pTempBuff[uiCurrSectOffsetAddr],pcBuffer,uiNumBytes);
+			memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiNumBytes);
 		}
 
 		if (IsFlash2x(Adapter)) {
-			SaveHeaderIfPresent(Adapter,(PUCHAR)pTempBuff,uiOffsetFromSectStart);
+			SaveHeaderIfPresent(Adapter, (PUCHAR)pTempBuff, uiOffsetFromSectStart);
 		}
 
-		FlashSectorErase(Adapter,uiPartOffset,1);
+		FlashSectorErase(Adapter, uiPartOffset, 1);
 		//do_gettimeofday(&te);
 		/*
 		  pr_info("Total time taken by Erase :%ld ms\n",
@@ -1192,7 +1192,7 @@ static INT BeceemFlashBulkWrite(
 				Status = -1;
 				goto BeceemFlashBulkWrite_EXIT;
 			}
-			if (STATUS_SUCCESS != (*Adapter->fpFlashWrite)(Adapter,uiPartOffset+uiIndex,(&pTempBuff[uiIndex]))) {
+			if (STATUS_SUCCESS != (*Adapter->fpFlashWrite)(Adapter, uiPartOffset+uiIndex, (&pTempBuff[uiIndex]))) {
 				Status = -1;
 				goto BeceemFlashBulkWrite_EXIT;
 			}
@@ -1205,20 +1205,20 @@ static INT BeceemFlashBulkWrite(
 		  (te.tv_sec *1000 + te.tv_usec/1000));
 		*/
 		for (uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex += MAX_RW_SIZE) {
-			if (STATUS_SUCCESS == BeceemFlashBulkRead(Adapter,(PUINT)ucReadBk,uiOffsetFromSectStart+uiIndex,MAX_RW_SIZE)) {
+			if (STATUS_SUCCESS == BeceemFlashBulkRead(Adapter, (PUINT)ucReadBk, uiOffsetFromSectStart+uiIndex, MAX_RW_SIZE)) {
 				if (Adapter->ulFlashWriteSize == 1) {
 					UINT uiReadIndex = 0;
 					for (uiReadIndex = 0; uiReadIndex < 16; uiReadIndex++) {
 						if (ucReadBk[uiReadIndex] != pTempBuff[uiIndex+uiReadIndex]) {
-							if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter,uiPartOffset+uiIndex+uiReadIndex,&pTempBuff[uiIndex+uiReadIndex])) {
+							if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter, uiPartOffset+uiIndex+uiReadIndex,&pTempBuff[uiIndex+uiReadIndex])) {
 								Status = STATUS_FAILURE;
 								goto BeceemFlashBulkWrite_EXIT;
 							}
 						}
 					}
 				} else {
-					if (memcmp(ucReadBk,&pTempBuff[uiIndex],MAX_RW_SIZE)) {
-						if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter,uiPartOffset+uiIndex,&pTempBuff[uiIndex])) {
+					if (memcmp(ucReadBk,&pTempBuff[uiIndex], MAX_RW_SIZE)) {
+						if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter, uiPartOffset+uiIndex,&pTempBuff[uiIndex])) {
 							Status = STATUS_FAILURE;
 							goto BeceemFlashBulkWrite_EXIT;
 						}
@@ -1234,7 +1234,7 @@ static INT BeceemFlashBulkWrite(
 		*/
 
 		if (ulStatus) {
-			BcmRestoreBlockProtectStatus(Adapter,ulStatus);
+			BcmRestoreBlockProtectStatus(Adapter, ulStatus);
 			ulStatus = 0;
 		}
 
@@ -1257,7 +1257,7 @@ static INT BeceemFlashBulkWrite(
 //
 BeceemFlashBulkWrite_EXIT:
 	if (ulStatus) {
-		BcmRestoreBlockProtectStatus(Adapter,ulStatus);
+		BcmRestoreBlockProtectStatus(Adapter, ulStatus);
 	}
 
 	kfree(pTempBuff);
@@ -1336,7 +1336,7 @@ static INT BeceemFlashBulkWriteStatus(
 		index = 0;
 		uiTemp = uiNumSectTobeRead ;
 		while (uiTemp) {
-			if (IsOffsetWritable(Adapter,uiOffsetFromSectStart + index * Adapter->uiSectorSize ) == FALSE) {
+			if (IsOffsetWritable(Adapter, uiOffsetFromSectStart + index * Adapter->uiSectorSize ) == FALSE) {
 				pr_info("Sector Starting at offset <0X%x> is not writable\n",
 					uiOffsetFromSectStart +
 					index * Adapter->uiSectorSize);
@@ -1352,7 +1352,7 @@ static INT BeceemFlashBulkWriteStatus(
 	while (uiNumSectTobeRead) {
 		uiPartOffset = (uiSectAlignAddr & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
 
-		BcmDoChipSelect(Adapter,uiSectAlignAddr);
+		BcmDoChipSelect(Adapter, uiSectAlignAddr);
 		if (0 != BeceemFlashBulkRead(Adapter,
 					    (PUINT)pTempBuff,
 					    uiOffsetFromSectStart,
@@ -1361,22 +1361,22 @@ static INT BeceemFlashBulkWriteStatus(
 			goto BeceemFlashBulkWriteStatus_EXIT;
 		}
 
-		ulStatus = BcmFlashUnProtectBlock(Adapter,uiOffsetFromSectStart,Adapter->uiSectorSize);
+		ulStatus = BcmFlashUnProtectBlock(Adapter, uiOffsetFromSectStart, Adapter->uiSectorSize);
 
 		if (uiNumSectTobeRead > 1) {
 
-			memcpy(&pTempBuff[uiCurrSectOffsetAddr],pcBuffer,uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr));
+			memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr));
 			pcBuffer += ((uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr)));
 			uiNumBytes -= (uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr));
 		} else {
-			memcpy(&pTempBuff[uiCurrSectOffsetAddr],pcBuffer,uiNumBytes);
+			memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiNumBytes);
 		}
 
 		if (IsFlash2x(Adapter)) {
-			SaveHeaderIfPresent(Adapter,(PUCHAR)pTempBuff,uiOffsetFromSectStart);
+			SaveHeaderIfPresent(Adapter, (PUCHAR)pTempBuff, uiOffsetFromSectStart);
 		}
 
-		FlashSectorErase(Adapter,uiPartOffset,1);
+		FlashSectorErase(Adapter, uiPartOffset, 1);
 
 		for (uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex +=Adapter->ulFlashWriteSize)
 
@@ -1386,7 +1386,7 @@ static INT BeceemFlashBulkWriteStatus(
 				goto BeceemFlashBulkWriteStatus_EXIT;
 			}
 
-			if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter,uiPartOffset+uiIndex,&pTempBuff[uiIndex])) {
+			if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter, uiPartOffset+uiIndex,&pTempBuff[uiIndex])) {
 				Status = -1;
 				goto BeceemFlashBulkWriteStatus_EXIT;
 			}
@@ -1395,8 +1395,8 @@ static INT BeceemFlashBulkWriteStatus(
 		if (bVerify) {
 			for (uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex += MAX_RW_SIZE) {
 
-				if (STATUS_SUCCESS == BeceemFlashBulkRead(Adapter,(PUINT)ucReadBk,uiOffsetFromSectStart+uiIndex,MAX_RW_SIZE)) {
-					if (memcmp(ucReadBk,&pTempBuff[uiIndex],MAX_RW_SIZE)) {
+				if (STATUS_SUCCESS == BeceemFlashBulkRead(Adapter, (PUINT)ucReadBk, uiOffsetFromSectStart+uiIndex, MAX_RW_SIZE)) {
+					if (memcmp(ucReadBk,&pTempBuff[uiIndex], MAX_RW_SIZE)) {
 						Status = STATUS_FAILURE;
 						goto BeceemFlashBulkWriteStatus_EXIT;
 					}
@@ -1407,7 +1407,7 @@ static INT BeceemFlashBulkWriteStatus(
 		}
 
 		if (ulStatus) {
-			BcmRestoreBlockProtectStatus(Adapter,ulStatus);
+			BcmRestoreBlockProtectStatus(Adapter, ulStatus);
 			ulStatus = 0;
 		}
 
@@ -1422,7 +1422,7 @@ static INT BeceemFlashBulkWriteStatus(
 //
 BeceemFlashBulkWriteStatus_EXIT:
 	if (ulStatus) {
-		BcmRestoreBlockProtectStatus(Adapter,ulStatus);
+		BcmRestoreBlockProtectStatus(Adapter, ulStatus);
 	}
 
 	kfree(pTempBuff);
@@ -1458,7 +1458,7 @@ INT PropagateCalParamsFromEEPROMToMemory(PMINI_ADAPTER Adapter)
 		return -1;
 	}
 
-	if (0 != BeceemEEPROMBulkRead(Adapter,&uiEepromSize,EEPROM_SIZE_OFFSET,4)) {
+	if (0 != BeceemEEPROMBulkRead(Adapter,&uiEepromSize, EEPROM_SIZE_OFFSET, 4)) {
 
 		kfree(pBuff);
 		return -1;
@@ -1471,19 +1471,19 @@ INT PropagateCalParamsFromEEPROMToMemory(PMINI_ADAPTER Adapter)
 	}
 
 
-	uiBytesToCopy = MIN(BUFFER_4K,uiEepromSize);
+	uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
 
 	while (uiBytesToCopy) {
-		if (0 != BeceemEEPROMBulkRead(Adapter,(PUINT)pBuff,uiCalStartAddr,uiBytesToCopy)) {
+		if (0 != BeceemEEPROMBulkRead(Adapter, (PUINT)pBuff, uiCalStartAddr, uiBytesToCopy)) {
 			Status = -1;
 			break;
 		}
-		wrm(Adapter,uiMemoryLoc,(PCHAR)(((PULONG)pBuff)+uiIndex),uiBytesToCopy);
+		wrm(Adapter, uiMemoryLoc, (PCHAR)(((PULONG)pBuff)+uiIndex), uiBytesToCopy);
 		uiMemoryLoc += uiBytesToCopy;
 		uiEepromSize -= uiBytesToCopy;
 		uiCalStartAddr += uiBytesToCopy;
 		uiIndex += uiBytesToCopy/4;
-		uiBytesToCopy = MIN(BUFFER_4K,uiEepromSize);
+		uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
 
 	}
 	value = 0xbeadbead;
@@ -1526,7 +1526,7 @@ INT PropagateCalParamsFromFlashToMemory(PMINI_ADAPTER Adapter)
 	value = 0xbeadbead;
 	wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8, &value, sizeof(value));
 
-	if (0 != BeceemNVMRead(Adapter,&uiEepromSize,EEPROM_SIZE_OFFSET, 4)) {
+	if (0 != BeceemNVMRead(Adapter,&uiEepromSize, EEPROM_SIZE_OFFSET, 4)) {
 		return -1;
 	}
 	uiEepromSize = ntohl(uiEepromSize);
@@ -1545,17 +1545,17 @@ INT PropagateCalParamsFromFlashToMemory(PMINI_ADAPTER Adapter)
 	if ( pBuff == NULL )
 		return -1;
 
-	if (0 != BeceemNVMRead(Adapter,(PUINT)pBuff,uiCalStartAddr, uiEepromSize)) {
+	if (0 != BeceemNVMRead(Adapter, (PUINT)pBuff, uiCalStartAddr, uiEepromSize)) {
 		kfree(pBuff);
 		return -1;
 	}
 
 	pPtr = pBuff;
 
-	uiBytesToCopy = MIN(BUFFER_4K,uiEepromSize);
+	uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
 
 	while (uiBytesToCopy) {
-		Status = wrm(Adapter,uiMemoryLoc,(PCHAR)pPtr,uiBytesToCopy);
+		Status = wrm(Adapter, uiMemoryLoc, (PCHAR)pPtr, uiBytesToCopy);
 		if (Status) {
 			pr_info("wrm failed with status :%d\n", Status);
 			break;
@@ -1564,7 +1564,7 @@ INT PropagateCalParamsFromFlashToMemory(PMINI_ADAPTER Adapter)
 		pPtr += uiBytesToCopy;
 		uiEepromSize -= uiBytesToCopy;
 		uiMemoryLoc += uiBytesToCopy;
-		uiBytesToCopy = MIN(BUFFER_4K,uiEepromSize);
+		uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
 	}
 
 	kfree(pBuff);
@@ -1605,15 +1605,15 @@ static INT BeceemEEPROMReadBackandVerify(
 
 		if (uiNumBytes >= MAX_RW_SIZE)
 		{// for the requests more than or equal to MAX_RW_SIZE bytes, use bulk read function to make the access faster.
-			BeceemEEPROMBulkRead(Adapter,&auiData[0],uiOffset,MAX_RW_SIZE);
+			BeceemEEPROMBulkRead(Adapter,&auiData[0], uiOffset, MAX_RW_SIZE);
 
-			if (memcmp(&pBuffer[uiIndex],&auiData[0],MAX_RW_SIZE)) {
+			if (memcmp(&pBuffer[uiIndex],&auiData[0], MAX_RW_SIZE)) {
 				// re-write
-				BeceemEEPROMBulkWrite(Adapter,(PUCHAR)(pBuffer+uiIndex),uiOffset,MAX_RW_SIZE,FALSE);
+				BeceemEEPROMBulkWrite(Adapter, (PUCHAR)(pBuffer+uiIndex), uiOffset, MAX_RW_SIZE, FALSE);
 				mdelay(3);
-				BeceemEEPROMBulkRead(Adapter,&auiData[0],uiOffset,MAX_RW_SIZE);
+				BeceemEEPROMBulkRead(Adapter,&auiData[0], uiOffset, MAX_RW_SIZE);
 
-				if (memcmp(&pBuffer[uiIndex],&auiData[0],MAX_RW_SIZE)) {
+				if (memcmp(&pBuffer[uiIndex],&auiData[0], MAX_RW_SIZE)) {
 					return -1;
 				}
 			}
@@ -1622,12 +1622,12 @@ static INT BeceemEEPROMReadBackandVerify(
 			uiIndex += 4;
 
 		} else if (uiNumBytes >= 4) {
-			BeceemEEPROMBulkRead(Adapter,&uiData,uiOffset,4);
+			BeceemEEPROMBulkRead(Adapter,&uiData, uiOffset, 4);
 			if (uiData != pBuffer[uiIndex]) {
 				//re-write
-				BeceemEEPROMBulkWrite(Adapter,(PUCHAR)(pBuffer+uiIndex),uiOffset,4,FALSE);
+				BeceemEEPROMBulkWrite(Adapter, (PUCHAR)(pBuffer+uiIndex), uiOffset, 4, FALSE);
 				mdelay(3);
-				BeceemEEPROMBulkRead(Adapter,&uiData,uiOffset,4);
+				BeceemEEPROMBulkRead(Adapter,&uiData, uiOffset, 4);
 				if (uiData != pBuffer[uiIndex]) {
 					return -1;
 				}
@@ -1639,8 +1639,8 @@ static INT BeceemEEPROMReadBackandVerify(
 		} else
 		{ // Handle the reads less than 4 bytes...
 			uiData = 0;
-			memcpy(&uiData,((PUCHAR)pBuffer)+(uiIndex*sizeof(UINT)),uiNumBytes);
-			BeceemEEPROMBulkRead(Adapter,&uiRdbk,uiOffset,4);
+			memcpy(&uiData, ((PUCHAR)pBuffer)+(uiIndex*sizeof(UINT)), uiNumBytes);
+			BeceemEEPROMBulkRead(Adapter,&uiRdbk, uiOffset, 4);
 
 			if (memcmp(&uiData, &uiRdbk, uiNumBytes))
 				return -1;
@@ -1833,10 +1833,10 @@ INT BeceemEEPROMBulkWrite(
 		uiExtraBytes = uiOffset-uiTempOffset;
 
 
-		BeceemEEPROMBulkRead(Adapter,&uiData[0],uiTempOffset,MAX_RW_SIZE);
+		BeceemEEPROMBulkRead(Adapter,&uiData[0], uiTempOffset, MAX_RW_SIZE);
 
 		if (uiBytesToCopy >= (16 -uiExtraBytes)) {
-			memcpy((((PUCHAR)&uiData[0])+uiExtraBytes),pBuffer,MAX_RW_SIZE- uiExtraBytes);
+			memcpy((((PUCHAR)&uiData[0])+uiExtraBytes), pBuffer, MAX_RW_SIZE- uiExtraBytes);
 
 			if ( STATUS_FAILURE == BeceemEEPROMWritePage( Adapter, uiData, uiTempOffset ) )
 				return STATUS_FAILURE;
@@ -1845,7 +1845,7 @@ INT BeceemEEPROMBulkWrite(
 			uiIndex += (MAX_RW_SIZE - uiExtraBytes);
 			uiOffset += (MAX_RW_SIZE - uiExtraBytes);
 		} else {
-			memcpy((((PUCHAR)&uiData[0])+uiExtraBytes),pBuffer,uiBytesToCopy);
+			memcpy((((PUCHAR)&uiData[0])+uiExtraBytes), pBuffer, uiBytesToCopy);
 
 			if ( STATUS_FAILURE == BeceemEEPROMWritePage( Adapter, uiData, uiTempOffset ) )
 				return STATUS_FAILURE;
@@ -1875,8 +1875,8 @@ INT BeceemEEPROMBulkWrite(
 			//
 			// To program non 16byte aligned data, read 16byte and then update.
 			//
-			BeceemEEPROMBulkRead(Adapter,&uiData[0],uiOffset,16);
-			memcpy(&uiData[0],pBuffer+uiIndex,uiBytesToCopy);
+			BeceemEEPROMBulkRead(Adapter,&uiData[0], uiOffset, 16);
+			memcpy(&uiData[0], pBuffer+uiIndex, uiBytesToCopy);
 
 
 			if ( STATUS_FAILURE == BeceemEEPROMWritePage( Adapter, uiData, uiOffset ) )
@@ -1918,12 +1918,12 @@ INT BeceemNVMRead(
 
 	if (Adapter->eNVMType == NVM_FLASH) {
 		if (Adapter->bFlashRawRead == FALSE) {
-			if (IsSectionExistInVendorInfo(Adapter,Adapter->eActiveDSD))
-				return vendorextnReadSection(Adapter,(PUCHAR)pBuffer,Adapter->eActiveDSD,uiOffset,uiNumBytes);
+			if (IsSectionExistInVendorInfo(Adapter, Adapter->eActiveDSD))
+				return vendorextnReadSection(Adapter, (PUCHAR)pBuffer, Adapter->eActiveDSD, uiOffset, uiNumBytes);
 			uiOffset = uiOffset+ Adapter->ulFlashCalStart ;
 		}
 #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
-		Status = bcmflash_raw_read((uiOffset/FLASH_PART_SIZE),(uiOffset % FLASH_PART_SIZE),( unsigned char *)pBuffer,uiNumBytes);
+		Status = bcmflash_raw_read((uiOffset/FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), ( unsigned char *)pBuffer, uiNumBytes);
 #else
 
 		rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
@@ -1979,13 +1979,13 @@ INT BeceemNVMWrite(
 	UINT uiFlashOffset = 0;
 
 	if (Adapter->eNVMType == NVM_FLASH) {
-		if (IsSectionExistInVendorInfo(Adapter,Adapter->eActiveDSD))
-			Status = vendorextnWriteSection(Adapter,(PUCHAR)pBuffer,Adapter->eActiveDSD,uiOffset,uiNumBytes,bVerify);
+		if (IsSectionExistInVendorInfo(Adapter, Adapter->eActiveDSD))
+			Status = vendorextnWriteSection(Adapter, (PUCHAR)pBuffer, Adapter->eActiveDSD, uiOffset, uiNumBytes, bVerify);
 		else {
 			uiFlashOffset = uiOffset + Adapter->ulFlashCalStart;
 
 #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
-			Status = bcmflash_raw_write((uiFlashOffset/FLASH_PART_SIZE), (uiFlashOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer,uiNumBytes);
+			Status = bcmflash_raw_write((uiFlashOffset/FLASH_PART_SIZE), (uiFlashOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer, uiNumBytes);
 #else
 			rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
 			value = 0;
@@ -2013,11 +2013,11 @@ INT BeceemNVMWrite(
 			uiMemoryLoc += (uiOffset - EEPROM_CALPARAM_START);
 			while (uiNumBytes) {
 				if (uiNumBytes > BUFFER_4K) {
-					wrm(Adapter,(uiMemoryLoc+uiIndex),(PCHAR)(pBuffer+(uiIndex/4)),BUFFER_4K);
+					wrm(Adapter, (uiMemoryLoc+uiIndex), (PCHAR)(pBuffer+(uiIndex/4)), BUFFER_4K);
 					uiNumBytes -= BUFFER_4K;
 					uiIndex += BUFFER_4K;
 				} else {
-					wrm(Adapter,uiMemoryLoc+uiIndex,(PCHAR)(pBuffer+(uiIndex/4)),uiNumBytes);
+					wrm(Adapter, uiMemoryLoc+uiIndex, (PCHAR)(pBuffer+(uiIndex/4)), uiNumBytes);
 					uiNumBytes = 0;
 					break;
 				}
@@ -2031,11 +2031,11 @@ INT BeceemNVMWrite(
 				uiOffset += (EEPROM_CALPARAM_START - uiOffset);
 				while (uiNumBytes) {
 					if (uiNumBytes > BUFFER_4K) {
-						wrm(Adapter,uiMemoryLoc+uiIndex,(PCHAR )&pcBuffer[ulBytesTobeSkipped+uiIndex],BUFFER_4K);
+						wrm(Adapter, uiMemoryLoc+uiIndex, (PCHAR )&pcBuffer[ulBytesTobeSkipped+uiIndex], BUFFER_4K);
 						uiNumBytes -= BUFFER_4K;
 						uiIndex += BUFFER_4K;
 					} else {
-						wrm(Adapter,uiMemoryLoc+uiIndex,(PCHAR)&pcBuffer[ulBytesTobeSkipped+uiIndex],uiNumBytes);
+						wrm(Adapter, uiMemoryLoc+uiIndex, (PCHAR)&pcBuffer[ulBytesTobeSkipped+uiIndex], uiNumBytes);
 						uiNumBytes = 0;
 						break;
 					}
@@ -2045,7 +2045,7 @@ INT BeceemNVMWrite(
 		}
 
 		// restore the values.
-		wrmalt(Adapter,0x0f000C80,&uiTemp, sizeof(uiTemp));
+		wrmalt(Adapter, 0x0f000C80,&uiTemp, sizeof(uiTemp));
 	} else if (Adapter->eNVMType == NVM_EEPROM) {
 		Status = BeceemEEPROMBulkWrite(Adapter,
 					       (PUCHAR)pBuffer,
@@ -2053,7 +2053,7 @@ INT BeceemNVMWrite(
 					       uiNumBytes,
 					       bVerify);
 		if (bVerify) {
-			Status = BeceemEEPROMReadBackandVerify(Adapter,(PUINT)pBuffer,uiOffset,uiNumBytes);
+			Status = BeceemEEPROMReadBackandVerify(Adapter, (PUINT)pBuffer, uiOffset, uiNumBytes);
 		}
 	} else {
 		Status = -1;
@@ -2075,7 +2075,7 @@ INT BeceemNVMWrite(
 //		<FAILURE>			- if failed.
 //-----------------------------------------------------------------------------
 
-INT BcmUpdateSectorSize(PMINI_ADAPTER Adapter,UINT uiSectorSize)
+INT BcmUpdateSectorSize(PMINI_ADAPTER Adapter, UINT uiSectorSize)
 {
 	INT Status = -1;
 	FLASH_CS_INFO sFlashCsInfo = {0};
@@ -2095,7 +2095,7 @@ INT BcmUpdateSectorSize(PMINI_ADAPTER Adapter,UINT uiSectorSize)
 //
 // Before updating the sector size in the reserved area, check if already present.
 //
-	BeceemFlashBulkRead(Adapter,(PUINT)&sFlashCsInfo,Adapter->ulFlashControlSectionStart,sizeof(sFlashCsInfo));
+	BeceemFlashBulkRead(Adapter, (PUINT)&sFlashCsInfo, Adapter->ulFlashControlSectionStart, sizeof(sFlashCsInfo));
 	uiSectorSig = ntohl(sFlashCsInfo.FlashSectorSizeSig);
 	uiCurrentSectorSize = ntohl(sFlashCsInfo.FlashSectorSize);
 
@@ -2235,7 +2235,7 @@ static INT BcmInitEEPROMQueues(PMINI_ADAPTER Adapter)
 //-----------------------------------------------------------------------------
 // Procedure:	BcmInitNVM
 //
-// Description: Initialization of NVM, EEPROM size,FLASH size, sector size etc.
+// Description: Initialization of NVM, EEPROM size, FLASH size, sector size etc.
 //
 // Arguments:
 //		Adapter    - ptr to Adapter object instance
@@ -2383,7 +2383,7 @@ INT BcmDeAllocFlashCSStructure(PMINI_ADAPTER psAdapter)
 	return STATUS_SUCCESS ;
 }
 
-static INT	BcmDumpFlash2XCSStructure(PFLASH2X_CS_INFO psFlash2xCSInfo,PMINI_ADAPTER Adapter)
+static INT	BcmDumpFlash2XCSStructure(PFLASH2X_CS_INFO psFlash2xCSInfo, PMINI_ADAPTER Adapter)
 {
 	UINT Index = 0;
 	bcm_dbg(Adapter, OTHERS, NVM_RW, ALL,
@@ -2721,8 +2721,8 @@ static INT BcmGetFlashCSInfo(PMINI_ADAPTER Adapter)
 
 	Adapter->uiFlashBaseAdd = 0;
 	Adapter->ulFlashCalStart = 0;
-	memset(Adapter->psFlashCSInfo, 0 ,sizeof(FLASH_CS_INFO));
-	memset(Adapter->psFlash2xCSInfo, 0 ,sizeof(FLASH2X_CS_INFO));
+	memset(Adapter->psFlashCSInfo, 0 , sizeof(FLASH_CS_INFO));
+	memset(Adapter->psFlash2xCSInfo, 0 , sizeof(FLASH2X_CS_INFO));
 
 	if (!Adapter->bDDRInitDone) {
 		{
@@ -2734,7 +2734,7 @@ static INT BcmGetFlashCSInfo(PMINI_ADAPTER Adapter)
 
 	// Reading first 8 Bytes to get the Flash Layout
 	// MagicNumber(4 bytes) +FlashLayoutMinorVersion(2 Bytes) +FlashLayoutMajorVersion(2 Bytes)
-	BeceemFlashBulkRead(Adapter,(PUINT)Adapter->psFlashCSInfo,Adapter->ulFlashControlSectionStart,8);
+	BeceemFlashBulkRead(Adapter, (PUINT)Adapter->psFlashCSInfo, Adapter->ulFlashControlSectionStart, 8);
 
 	Adapter->psFlashCSInfo->FlashLayoutVersion =  ntohl(Adapter->psFlashCSInfo->FlashLayoutVersion);
 	bcm_dbg(Adapter, OTHERS, NVM_RW, ALL, "Flash Layout Version :%X\n",
@@ -2755,7 +2755,7 @@ static INT BcmGetFlashCSInfo(PMINI_ADAPTER Adapter)
 		"FLASH LAYOUT MAJOR VERSION :%X\n", uiFlashLayoutMajorVersion);
 
 	if (uiFlashLayoutMajorVersion < FLASH_2X_MAJOR_NUMBER) {
-		BeceemFlashBulkRead(Adapter,(PUINT)Adapter->psFlashCSInfo,Adapter->ulFlashControlSectionStart,sizeof(FLASH_CS_INFO));
+		BeceemFlashBulkRead(Adapter, (PUINT)Adapter->psFlashCSInfo, Adapter->ulFlashControlSectionStart, sizeof(FLASH_CS_INFO));
 		ConvertEndianOfCSStructure(Adapter->psFlashCSInfo);
 		Adapter->ulFlashCalStart = (Adapter->psFlashCSInfo->OffsetFromZeroForCalibrationStart);
 
@@ -2784,13 +2784,13 @@ static INT BcmGetFlashCSInfo(PMINI_ADAPTER Adapter)
 
 
 	} else {
-		if (BcmFlash2xBulkRead(Adapter,(PUINT)Adapter->psFlash2xCSInfo,NO_SECTION_VAL,
-				      Adapter->ulFlashControlSectionStart,sizeof(FLASH2X_CS_INFO))) {
+		if (BcmFlash2xBulkRead(Adapter, (PUINT)Adapter->psFlash2xCSInfo, NO_SECTION_VAL,
+				      Adapter->ulFlashControlSectionStart, sizeof(FLASH2X_CS_INFO))) {
 			pr_info("Unable to read CS structure\n");
 			return STATUS_FAILURE;
 		}
 		ConvertEndianOf2XCSStructure(Adapter->psFlash2xCSInfo);
-		BcmDumpFlash2XCSStructure(Adapter->psFlash2xCSInfo,Adapter);
+		BcmDumpFlash2XCSStructure(Adapter->psFlash2xCSInfo, Adapter);
 		if ((FLASH_CONTROL_STRUCT_SIGNATURE == Adapter->psFlash2xCSInfo->MagicNumber) &&
 		   (SCSI_FIRMWARE_MINOR_VERSION <= MINOR_VERSION(Adapter->psFlash2xCSInfo->SCSIFirmwareVersion)) &&
 		   (FLASH_SECTOR_SIZE_SIG == Adapter->psFlash2xCSInfo->FlashSectorSizeSig) &&
@@ -2845,7 +2845,7 @@ static NVM_TYPE BcmGetNvmType(PMINI_ADAPTER Adapter)
 {
 	UINT uiData = 0;
 
-	BeceemEEPROMBulkRead(Adapter,&uiData,0x0,4);
+	BeceemEEPROMBulkRead(Adapter,&uiData, 0x0, 4);
 	if (uiData == BECM) {
 		return NVM_EEPROM;
 	}
@@ -2854,7 +2854,7 @@ static NVM_TYPE BcmGetNvmType(PMINI_ADAPTER Adapter)
 	//
 	BcmGetFlashCSInfo(Adapter);
 
-	BeceemFlashBulkRead(Adapter,&uiData,0x0 + Adapter->ulFlashCalStart,4);
+	BeceemFlashBulkRead(Adapter,&uiData, 0x0 + Adapter->ulFlashCalStart, 4);
 	if (uiData == BECM) {
 		return NVM_FLASH;
 	}
@@ -2894,7 +2894,7 @@ INT BcmGetSectionValStartOffset(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlas
 
 	SectStartOffset = INVALID_OFFSET ;
 
-	if (IsSectionExistInVendorInfo(Adapter,eFlashSectionVal)) {
+	if (IsSectionExistInVendorInfo(Adapter, eFlashSectionVal)) {
 		return Adapter->psFlash2xVendorInfo->VendorSection[eFlashSectionVal].OffsetFromZeroForSectionStart;
 	}
 
@@ -2979,7 +2979,7 @@ INT BcmGetSectionValEndOffset(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2
 	INT SectEndOffset = 0 ;
 	SectEndOffset = INVALID_OFFSET;
 
-	if (IsSectionExistInVendorInfo(Adapter,eFlash2xSectionVal)) {
+	if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal)) {
 		return Adapter->psFlash2xVendorInfo->VendorSection[eFlash2xSectionVal].OffsetFromZeroForSectionEnd;
 	}
 
@@ -3086,7 +3086,7 @@ INT BcmFlash2xBulkRead(
 	if (eFlash2xSectionVal == NO_SECTION_VAL)
 		SectionStartOffset = 0;
 	else
-		SectionStartOffset = BcmGetSectionValStartOffset(Adapter,eFlash2xSectionVal);
+		SectionStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectionVal);
 
 	if (SectionStartOffset == STATUS_FAILURE ) {
 		pr_info("This Section<%d> does not exixt in Flash 2.x Map\n",
@@ -3094,8 +3094,8 @@ INT BcmFlash2xBulkRead(
 		return -EINVAL;
 	}
 
-	if (IsSectionExistInVendorInfo(Adapter,eFlash2xSectionVal))
-		return vendorextnReadSection(Adapter,(PUCHAR)pBuffer, eFlash2xSectionVal, uiOffsetWithinSectionVal, uiNumBytes);
+	if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
+		return vendorextnReadSection(Adapter, (PUCHAR)pBuffer, eFlash2xSectionVal, uiOffsetWithinSectionVal, uiNumBytes);
 
 	//calculating  the absolute offset from FLASH;
 	uiAbsoluteOffset = uiOffsetWithinSectionVal + SectionStartOffset;
@@ -3103,7 +3103,7 @@ INT BcmFlash2xBulkRead(
 	value = 0;
 	wrmalt(Adapter, 0x0f000C80,&value, sizeof(value));
 
-	Status= BeceemFlashBulkRead(Adapter, pBuffer,uiAbsoluteOffset,uiNumBytes) ;
+	Status= BeceemFlashBulkRead(Adapter, pBuffer, uiAbsoluteOffset, uiNumBytes) ;
 
 	wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
 	if (Status) {
@@ -3152,7 +3152,7 @@ INT BcmFlash2xBulkWrite(
 	if (eFlash2xSectVal == NO_SECTION_VAL)
 		FlashSectValStartOffset = 0;
 	else
-		FlashSectValStartOffset = BcmGetSectionValStartOffset(Adapter,eFlash2xSectVal);
+		FlashSectValStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectVal);
 
 	if (FlashSectValStartOffset == STATUS_FAILURE ) {
 		pr_info("This Section<%d> does not exixt in Flash Map 2.x\n",
@@ -3160,7 +3160,7 @@ INT BcmFlash2xBulkWrite(
 		return -EINVAL;
 	}
 
-	if (IsSectionExistInVendorInfo(Adapter,eFlash2xSectVal))
+	if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectVal))
 		return vendorextnWriteSection(Adapter, (PUCHAR)pBuffer, eFlash2xSectVal, uiOffset, uiNumBytes, bVerify);
 
 	//calculating  the absolute offset from FLASH;
@@ -3170,7 +3170,7 @@ INT BcmFlash2xBulkWrite(
 	value = 0;
 	wrmalt(Adapter, 0x0f000C80,&value, sizeof(value));
 
-	Status = BeceemFlashBulkWrite(Adapter, pBuffer,uiOffset,uiNumBytes,bVerify);
+	Status = BeceemFlashBulkWrite(Adapter, pBuffer, uiOffset, uiNumBytes, bVerify);
 
 	wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
 	if (Status) {
@@ -3208,13 +3208,13 @@ static INT BcmGetActiveDSD(PMINI_ADAPTER Adapter)
 			Adapter->eActiveDSD);
 	if (Adapter->eActiveDSD == 0) {
 		//if No DSD gets Active, Make Active the DSD with WR  permission
-		if (IsSectionWritable(Adapter,DSD2)) {
+		if (IsSectionWritable(Adapter, DSD2)) {
 			Adapter->eActiveDSD = DSD2;
 			Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start;
-		} else if (IsSectionWritable(Adapter,DSD1)) {
+		} else if (IsSectionWritable(Adapter, DSD1)) {
 			Adapter->eActiveDSD = DSD1;
 			Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start;
-		} else if (IsSectionWritable(Adapter,DSD0)) {
+		} else if (IsSectionWritable(Adapter, DSD0)) {
 			Adapter->eActiveDSD = DSD0;
 			Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart;
 		}
@@ -3372,7 +3372,7 @@ INT BcmGetFlash2xSectionalBitMap(PMINI_ADAPTER Adapter, PFLASH2X_BITMAP psFlash2
 		psFlash2xBitMap->ISO_IMAGE2= psFlash2xBitMap->ISO_IMAGE2 | FLASH2X_SECTION_PRESENT;
 
 
-		if (ReadISOSignature(Adapter,ISO_IMAGE2)== ISO_IMAGE_MAGIC_NUMBER)
+		if (ReadISOSignature(Adapter, ISO_IMAGE2)== ISO_IMAGE_MAGIC_NUMBER)
 			psFlash2xBitMap->ISO_IMAGE2 |= FLASH2X_SECTION_VALID;
 
 
@@ -3394,7 +3394,7 @@ INT BcmGetFlash2xSectionalBitMap(PMINI_ADAPTER Adapter, PFLASH2X_BITMAP psFlash2
 		//Setting the 0th Bit representing the Section is present or not.
 		psFlash2xBitMap->ISO_IMAGE1 = psFlash2xBitMap->ISO_IMAGE1 | FLASH2X_SECTION_PRESENT;
 
-		if (ReadISOSignature(Adapter,ISO_IMAGE1) == ISO_IMAGE_MAGIC_NUMBER)
+		if (ReadISOSignature(Adapter, ISO_IMAGE1) == ISO_IMAGE_MAGIC_NUMBER)
 			psFlash2xBitMap->ISO_IMAGE1 |= FLASH2X_SECTION_VALID;
 
 		//	Calculation for extrating the Access permission
@@ -3416,7 +3416,7 @@ INT BcmGetFlash2xSectionalBitMap(PMINI_ADAPTER Adapter, PFLASH2X_BITMAP psFlash2
 		//Setting the 0th Bit representing the Section is present or not.
 		psFlash2xBitMap->DSD2= psFlash2xBitMap->DSD2 | FLASH2X_SECTION_PRESENT;
 
-		if (ReadDSDSignature(Adapter,DSD2)== DSD_IMAGE_MAGIC_NUMBER)
+		if (ReadDSDSignature(Adapter, DSD2)== DSD_IMAGE_MAGIC_NUMBER)
 			psFlash2xBitMap->DSD2 |= FLASH2X_SECTION_VALID;
 
 		//Calculation for extrating the Access permission
@@ -3440,7 +3440,7 @@ INT BcmGetFlash2xSectionalBitMap(PMINI_ADAPTER Adapter, PFLASH2X_BITMAP psFlash2
 		psFlash2xBitMap->DSD1= psFlash2xBitMap->DSD1 | FLASH2X_SECTION_PRESENT;
 
 
-		if (ReadDSDSignature(Adapter,DSD1)== DSD_IMAGE_MAGIC_NUMBER)
+		if (ReadDSDSignature(Adapter, DSD1)== DSD_IMAGE_MAGIC_NUMBER)
 			psFlash2xBitMap->DSD1 |= FLASH2X_SECTION_VALID;
 
 		//Calculation for extrating the Access permission
@@ -3463,7 +3463,7 @@ INT BcmGetFlash2xSectionalBitMap(PMINI_ADAPTER Adapter, PFLASH2X_BITMAP psFlash2
 		//Setting the 0th Bit representing the Section is present or not.
 		psFlash2xBitMap->DSD0 = psFlash2xBitMap->DSD0 | FLASH2X_SECTION_PRESENT;
 
-		if (ReadDSDSignature(Adapter,DSD0) == DSD_IMAGE_MAGIC_NUMBER)
+		if (ReadDSDSignature(Adapter, DSD0) == DSD_IMAGE_MAGIC_NUMBER)
 			psFlash2xBitMap->DSD0 |= FLASH2X_SECTION_VALID;
 
 		//Setting Access permission
@@ -3614,7 +3614,7 @@ INT BcmSetActiveSection(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectV
 
 
 
-	Status = IsSectionWritable(Adapter,eFlash2xSectVal) ;
+	Status = IsSectionWritable(Adapter, eFlash2xSectVal) ;
 	if (Status != TRUE ) {
 		pr_info("Provided Section <%d> is not writable\n",
 			eFlash2xSectVal);
@@ -3625,7 +3625,7 @@ INT BcmSetActiveSection(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectV
 	switch (eFlash2xSectVal) {
 	case ISO_IMAGE1 :
 	case ISO_IMAGE2	:
-		if (ReadISOSignature(Adapter,eFlash2xSectVal)== ISO_IMAGE_MAGIC_NUMBER ) {
+		if (ReadISOSignature(Adapter, eFlash2xSectVal)== ISO_IMAGE_MAGIC_NUMBER ) {
 			HighestPriISO = getHighestPriISO(Adapter);
 
 			if (HighestPriISO == eFlash2xSectVal	) {
@@ -3638,7 +3638,7 @@ INT BcmSetActiveSection(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectV
 
 			SectImagePriority = ReadISOPriority(Adapter, HighestPriISO) + 1;
 
-			if ((SectImagePriority <= 0) && IsSectionWritable(Adapter,HighestPriISO)) {
+			if ((SectImagePriority <= 0) && IsSectionWritable(Adapter, HighestPriISO)) {
 				// This is a SPECIAL Case which will only happen if the current highest priority ISO has priority value = 0x7FFFFFFF.
 				// We will write 1 to the current Highest priority ISO And then shall increase the priority of the requested ISO
 				// by user
@@ -3694,7 +3694,7 @@ INT BcmSetActiveSection(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectV
 	case DSD0 :
 	case DSD1 :
 	case DSD2 :
-		if (ReadDSDSignature(Adapter,eFlash2xSectVal)== DSD_IMAGE_MAGIC_NUMBER) {
+		if (ReadDSDSignature(Adapter, eFlash2xSectVal)== DSD_IMAGE_MAGIC_NUMBER) {
 			HighestPriDSD = getHighestPriDSD(Adapter);
 
 			if ((HighestPriDSD == eFlash2xSectVal)) {
@@ -3804,7 +3804,7 @@ INT BcmCopyISO(PMINI_ADAPTER Adapter, FLASH2X_COPY_SECTION sCopySectStrut)
 {
 
 	PCHAR Buff = NULL;
-	FLASH2X_SECTION_VAL eISOReadPart = 0,eISOWritePart = 0;
+	FLASH2X_SECTION_VAL eISOReadPart = 0, eISOWritePart = 0;
 	UINT uiReadOffsetWithinPart = 0, uiWriteOffsetWithinPart = 0;
 	UINT uiTotalDataToCopy = 0;
 	BOOLEAN IsThisHeaderSector = FALSE ;
@@ -3814,7 +3814,7 @@ INT BcmCopyISO(PMINI_ADAPTER Adapter, FLASH2X_COPY_SECTION sCopySectStrut)
 	UINT SigBuff[MAX_RW_SIZE];
 	UINT i = 0;
 
-	if (ReadISOSignature(Adapter,sCopySectStrut.SrcSection) != ISO_IMAGE_MAGIC_NUMBER) {
+	if (ReadISOSignature(Adapter, sCopySectStrut.SrcSection) != ISO_IMAGE_MAGIC_NUMBER) {
 		pr_info("error as Source ISO Section does not have valid signature\n");
 		return STATUS_FAILURE;
 	}
@@ -3822,7 +3822,7 @@ INT BcmCopyISO(PMINI_ADAPTER Adapter, FLASH2X_COPY_SECTION sCopySectStrut)
 	Status = BcmFlash2xBulkRead(Adapter,
 				    &ISOLength,
 				    sCopySectStrut.SrcSection,
-				    0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER,ISOImageSize),
+				    0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImageSize),
 				    4);
 
 	if (Status) {
@@ -3879,7 +3879,7 @@ INT BcmCopyISO(PMINI_ADAPTER Adapter, FLASH2X_COPY_SECTION sCopySectStrut)
 
 		uiTotalDataToCopy = ISOLength;
 
-		CorruptISOSig(Adapter,ISO_IMAGE2);
+		CorruptISOSig(Adapter, ISO_IMAGE2);
 
 		while (uiTotalDataToCopy) {
 			if (uiTotalDataToCopy == Adapter->uiSectorSize) {
@@ -3999,7 +3999,7 @@ INT BcmCopyISO(PMINI_ADAPTER Adapter, FLASH2X_COPY_SECTION sCopySectStrut)
 
 		uiTotalDataToCopy = ISOLength;
 
-		CorruptISOSig(Adapter,ISO_IMAGE1);
+		CorruptISOSig(Adapter, ISO_IMAGE1);
 
 		while (uiTotalDataToCopy) {
 			if (uiTotalDataToCopy == Adapter->uiSectorSize) {
@@ -4145,7 +4145,7 @@ INT BcmFlash2xWriteSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlashSectionV
 		return STATUS_SUCCESS;
 	}
 	if (Adapter->bAllDSDWriteAllow == FALSE) {
-		if (IsSectionWritable(Adapter,eFlashSectionVal) == FALSE) {
+		if (IsSectionWritable(Adapter, eFlashSectionVal) == FALSE) {
 			pr_info("Section is not Writable...Hence can't Write signature\n");
 			return SECTOR_IS_NOT_WRITABLE;
 		}
@@ -4154,9 +4154,9 @@ INT BcmFlash2xWriteSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlashSectionV
 		uiSignature = htonl(DSD_IMAGE_MAGIC_NUMBER) ;
 		uiOffset = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader ;
 
-		uiOffset += FIELD_OFFSET_IN_HEADER(PDSD_HEADER,DSDImageMagicNumber);
+		uiOffset += FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImageMagicNumber);
 
-		if ((ReadDSDSignature(Adapter,eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN) {
+		if ((ReadDSDSignature(Adapter, eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN) {
 			pr_info("Corrupted Pattern is not there. Hence won't write sig\n");
 			return STATUS_FAILURE;
 		}
@@ -4164,8 +4164,8 @@ INT BcmFlash2xWriteSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlashSectionV
 	} else if ((eFlashSectionVal == ISO_IMAGE1) || (eFlashSectionVal == ISO_IMAGE2)) {
 		uiSignature = htonl(ISO_IMAGE_MAGIC_NUMBER);
 		//uiOffset = 0;
-		uiOffset = FIELD_OFFSET_IN_HEADER(PISO_HEADER,ISOImageMagicNumber);
-		if ((ReadISOSignature(Adapter,eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN) {
+		uiOffset = FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImageMagicNumber);
+		if ((ReadISOSignature(Adapter, eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN) {
 			pr_info("Corrupted Pattern is not there. Hence won't write sig\n");
 			return STATUS_FAILURE;
 		}
@@ -4180,7 +4180,7 @@ INT BcmFlash2xWriteSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlashSectionV
 
 	Adapter->bHeaderChangeAllowed = TRUE;
 	Adapter->bSigCorrupted = FALSE;
-	BcmFlash2xBulkWrite(Adapter, &uiSignature,eFlashSectionVal,uiOffset,SIGNATURE_SIZE,TRUE);
+	BcmFlash2xBulkWrite(Adapter, &uiSignature, eFlashSectionVal, uiOffset, SIGNATURE_SIZE, TRUE);
 	Adapter->bHeaderChangeAllowed = FALSE;
 
 
@@ -4204,30 +4204,30 @@ INT	validateFlash2xReadWrite(PMINI_ADAPTER Adapter, PFLASH2X_READWRITE psFlash2x
 	UINT uiSectEndOffset = 0;
 	uiNumOfBytes = psFlash2xReadWrite->numOfBytes;
 
-	if (IsSectionExistInFlash(Adapter,psFlash2xReadWrite->Section) != TRUE) {
+	if (IsSectionExistInFlash(Adapter, psFlash2xReadWrite->Section) != TRUE) {
 		pr_info("Section<%x> does not exixt in Flash\n",
 			psFlash2xReadWrite->Section);
 		return FALSE;
 	}
-	uiSectStartOffset = BcmGetSectionValStartOffset(Adapter,psFlash2xReadWrite->Section);
+	uiSectStartOffset = BcmGetSectionValStartOffset(Adapter, psFlash2xReadWrite->Section);
 	bcm_dbg(Adapter, OTHERS, NVM_RW, ALL,
-		"Start offset :%x ,section :%d\n",
+		"Start offset :%x, section :%d\n",
 		uiSectStartOffset, psFlash2xReadWrite->Section);
 	if ((psFlash2xReadWrite->Section == ISO_IMAGE1) ||(psFlash2xReadWrite->Section == ISO_IMAGE2)) {
 		if (psFlash2xReadWrite->Section == ISO_IMAGE1) {
-			uiSectEndOffset = BcmGetSectionValEndOffset(Adapter,ISO_IMAGE1) -
-				BcmGetSectionValStartOffset(Adapter,ISO_IMAGE1)+
-				BcmGetSectionValEndOffset(Adapter,ISO_IMAGE1_PART2) -
-				BcmGetSectionValStartOffset(Adapter,ISO_IMAGE1_PART2)+
-				BcmGetSectionValEndOffset(Adapter,ISO_IMAGE1_PART3) -
-				BcmGetSectionValStartOffset(Adapter,ISO_IMAGE1_PART3);
+			uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1) -
+				BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1)+
+				BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1_PART2) -
+				BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1_PART2)+
+				BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1_PART3) -
+				BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1_PART3);
 		} else if (psFlash2xReadWrite->Section == ISO_IMAGE2) {
-			uiSectEndOffset = BcmGetSectionValEndOffset(Adapter,ISO_IMAGE2) -
-				BcmGetSectionValStartOffset(Adapter,ISO_IMAGE2)+
-				BcmGetSectionValEndOffset(Adapter,ISO_IMAGE2_PART2) -
-				BcmGetSectionValStartOffset(Adapter,ISO_IMAGE2_PART2)+
-				BcmGetSectionValEndOffset(Adapter,ISO_IMAGE2_PART3) -
-				BcmGetSectionValStartOffset(Adapter,ISO_IMAGE2_PART3);
+			uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2) -
+				BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2)+
+				BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2_PART2) -
+				BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2_PART2)+
+				BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2_PART3) -
+				BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2_PART3);
 
 		}
 
@@ -4238,7 +4238,7 @@ INT	validateFlash2xReadWrite(PMINI_ADAPTER Adapter, PFLASH2X_READWRITE psFlash2x
 		bcm_dbg(Adapter, OTHERS, NVM_RW, ALL,
 			"Total size of the ISO Image :%x\n", uiSectEndOffset);
 	} else
-		uiSectEndOffset   = BcmGetSectionValEndOffset(Adapter,psFlash2xReadWrite->Section);
+		uiSectEndOffset   = BcmGetSectionValEndOffset(Adapter, psFlash2xReadWrite->Section);
 	bcm_dbg(Adapter, OTHERS, NVM_RW, ALL,
 		"End offset :%x\n", uiSectEndOffset);
 
@@ -4349,22 +4349,22 @@ INT	BcmCopySection(PMINI_ADAPTER Adapter,
 	//if offset zero means have to copy complete secton
 
 	if (numOfBytes == 0) {
-		numOfBytes = BcmGetSectionValEndOffset(Adapter,SrcSection)
-			- BcmGetSectionValStartOffset(Adapter,SrcSection);
+		numOfBytes = BcmGetSectionValEndOffset(Adapter, SrcSection)
+			- BcmGetSectionValStartOffset(Adapter, SrcSection);
 
 		bcm_dbg(Adapter, OTHERS, NVM_RW, ALL,
 			"Section Size :0x%x\n", numOfBytes);
 	}
 
-	if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter,SrcSection)
-	   - BcmGetSectionValStartOffset(Adapter,SrcSection)) {
+	if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter, SrcSection)
+	   - BcmGetSectionValStartOffset(Adapter, SrcSection)) {
 		pr_info("Input parameters going beyond the section offS: %x numB: %x of Source Section\n",
 			offset, numOfBytes);
 		return -EINVAL;
 	}
 
-	if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter,DstSection)
-	   - BcmGetSectionValStartOffset(Adapter,DstSection)) {
+	if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter, DstSection)
+	   - BcmGetSectionValStartOffset(Adapter, DstSection)) {
 		pr_info("Input parameters going beyond the section offS: %x numB: %x of Destination Section\n",
 			offset, numOfBytes);
 		return -EINVAL;
@@ -4395,13 +4395,13 @@ INT	BcmCopySection(PMINI_ADAPTER Adapter,
 
 	do
 	{
-		Status = BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, SrcSection , offset,BytesToBeCopied);
+		Status = BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, SrcSection , offset, BytesToBeCopied);
 		if (Status) {
 			pr_info("Read failed at offset :%d for NOB :%d\n",
 				SrcSection, BytesToBeCopied);
 			break;
 		}
-		Status = BcmFlash2xBulkWrite(Adapter,(PUINT)pBuff,DstSection,offset,BytesToBeCopied,FALSE);
+		Status = BcmFlash2xBulkWrite(Adapter, (PUINT)pBuff, DstSection, offset, BytesToBeCopied, FALSE);
 		if (Status) {
 			pr_info("Write failed at offset :%d for NOB :%d\n",
 				DstSection, BytesToBeCopied);
@@ -4435,7 +4435,7 @@ INT	BcmCopySection(PMINI_ADAPTER Adapter,
 
 INT SaveHeaderIfPresent(PMINI_ADAPTER Adapter, PUCHAR pBuff, UINT uiOffset)
 {
-	UINT offsetToProtect = 0,HeaderSizeToProtect =0;
+	UINT offsetToProtect = 0, HeaderSizeToProtect =0;
 	BOOLEAN bHasHeader = FALSE ;
 	PUCHAR pTempBuff =NULL;
 	UINT uiSectAlignAddr = 0;
@@ -4445,9 +4445,9 @@ INT SaveHeaderIfPresent(PMINI_ADAPTER Adapter, PUCHAR pBuff, UINT uiOffset)
 	uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
 
 
-	if ((uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter,DSD2)- Adapter->uiSectorSize)||
-	   (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter,DSD1)- Adapter->uiSectorSize)||
-	   (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter,DSD0)- Adapter->uiSectorSize)) {
+	if ((uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD2)- Adapter->uiSectorSize)||
+	   (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD1)- Adapter->uiSectorSize)||
+	   (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD0)- Adapter->uiSectorSize)) {
 
 		//offset from the sector boundary having the header map
 		offsetToProtect = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader % Adapter->uiSectorSize;
@@ -4455,8 +4455,8 @@ INT SaveHeaderIfPresent(PMINI_ADAPTER Adapter, PUCHAR pBuff, UINT uiOffset)
 		bHasHeader = TRUE ;
 	}
 
-	if (uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter,ISO_IMAGE1) ||
-	   uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter,ISO_IMAGE2)) {
+	if (uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1) ||
+	   uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2)) {
 		offsetToProtect = 0;
 		HeaderSizeToProtect = sizeof(ISO_HEADER);
 		bHasHeader = TRUE;
@@ -4469,15 +4469,15 @@ INT SaveHeaderIfPresent(PMINI_ADAPTER Adapter, PUCHAR pBuff, UINT uiOffset)
 			return -ENOMEM;
 		}
 		//Read header
-		BeceemFlashBulkRead(Adapter,(PUINT)pTempBuff,(uiSectAlignAddr + offsetToProtect),HeaderSizeToProtect);
-		BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,pTempBuff ,HeaderSizeToProtect);
+		BeceemFlashBulkRead(Adapter, (PUINT)pTempBuff, (uiSectAlignAddr + offsetToProtect), HeaderSizeToProtect);
+		BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pTempBuff , HeaderSizeToProtect);
 		//Replace Buffer content with Header
-		memcpy(pBuff +offsetToProtect,pTempBuff,HeaderSizeToProtect);
+		memcpy(pBuff +offsetToProtect, pTempBuff, HeaderSizeToProtect);
 
 		kfree(pTempBuff);
 	}
 	if (bHasHeader && Adapter->bSigCorrupted) {
-		sig = *((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(PDSD_HEADER,DSDImageMagicNumber)));
+		sig = *((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImageMagicNumber)));
 		sig = ntohl(sig);
 		if ((sig & 0xFF000000) != CORRUPTED_PATTERN) {
 			bcm_dbg(Adapter, OTHERS, NVM_RW, ALL,
@@ -4487,7 +4487,7 @@ INT SaveHeaderIfPresent(PMINI_ADAPTER Adapter, PUCHAR pBuff, UINT uiOffset)
 		}
 		bcm_dbg(Adapter, OTHERS, NVM_RW, ALL,
 			"Corrupted sig is :%X\n", sig);
-		*((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(PDSD_HEADER,DSDImageMagicNumber)))= htonl(DSD_IMAGE_MAGIC_NUMBER);
+		*((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImageMagicNumber)))= htonl(DSD_IMAGE_MAGIC_NUMBER);
 		bcm_dbg(Adapter, OTHERS, NVM_RW, ALL,
 			"Restoring the signature in Header Write only\n");
 		Adapter->bSigCorrupted = FALSE;
@@ -4569,10 +4569,10 @@ static INT BcmDoChipSelect(PMINI_ADAPTER Adapter, UINT offset)
 	FlashConfig &= 0xFFFFCFFF;
 	FlashConfig = (FlashConfig | (PartNum<<CHIP_SELECT_BIT12)); //00
 
-	wrmalt(Adapter,FLASH_GPIO_CONFIG_REG, &GPIOConfig, 4);
+	wrmalt(Adapter, FLASH_GPIO_CONFIG_REG, &GPIOConfig, 4);
 	udelay(100);
 
-	wrmalt(Adapter,FLASH_CONFIG_REG, &FlashConfig, 4);
+	wrmalt(Adapter, FLASH_CONFIG_REG, &FlashConfig, 4);
 	udelay(100);
 
 	return STATUS_SUCCESS;
@@ -4594,7 +4594,7 @@ INT ReadDSDSignature(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL dsd)
 	BcmFlash2xBulkRead(Adapter,
 			   &uiDSDsig,
 			   dsd,
-			   Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(PDSD_HEADER,DSDImageMagicNumber),
+			   Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImageMagicNumber),
 			   SIGNATURE_SIZE);
 
 	uiDSDsig = ntohl(uiDSDsig);
@@ -4609,8 +4609,8 @@ INT ReadDSDPriority(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL dsd)
 	unsigned int uiDSDPri = STATUS_FAILURE;
 	//DSD_HEADER dsdHeader = {0};
 	//priOffsetInMap = (PUCHAR)&(dsdHeader.DSDImagePriority) -(PUCHAR)&dsdHeader;
-	if (IsSectionWritable(Adapter,dsd)) {
-		if (ReadDSDSignature(Adapter,dsd)== DSD_IMAGE_MAGIC_NUMBER) {
+	if (IsSectionWritable(Adapter, dsd)) {
+		if (ReadDSDSignature(Adapter, dsd)== DSD_IMAGE_MAGIC_NUMBER) {
 			BcmFlash2xBulkRead(Adapter,
 					   &uiDSDPri,
 					   dsd,
@@ -4631,19 +4631,19 @@ FLASH2X_SECTION_VAL getHighestPriDSD(PMINI_ADAPTER Adapter)
 	INT  DsdPri= 0 ;
 	FLASH2X_SECTION_VAL HighestPriDSD = 0 ;
 
-	if (IsSectionWritable(Adapter,DSD2)) {
-		DSDHighestPri = ReadDSDPriority(Adapter,DSD2);
+	if (IsSectionWritable(Adapter, DSD2)) {
+		DSDHighestPri = ReadDSDPriority(Adapter, DSD2);
 		HighestPriDSD = DSD2 ;
 	}
-	if (IsSectionWritable(Adapter,DSD1)) {
-		DsdPri = ReadDSDPriority(Adapter,DSD1);
+	if (IsSectionWritable(Adapter, DSD1)) {
+		DsdPri = ReadDSDPriority(Adapter, DSD1);
 		if (DSDHighestPri  < DsdPri) {
 			DSDHighestPri = DsdPri ;
 			HighestPriDSD = DSD1;
 		}
 	}
-	if (IsSectionWritable(Adapter,DSD0)) {
-		DsdPri = ReadDSDPriority(Adapter,DSD0);
+	if (IsSectionWritable(Adapter, DSD0)) {
+		DsdPri = ReadDSDPriority(Adapter, DSD0);
 		if (DSDHighestPri  < DsdPri) {
 			DSDHighestPri = DsdPri ;
 			HighestPriDSD = DSD0;
@@ -4672,7 +4672,7 @@ INT ReadISOSignature(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL iso)
 	BcmFlash2xBulkRead(Adapter,
 			   &uiISOsig,
 			   iso,
-			   0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER,ISOImageMagicNumber),
+			   0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImageMagicNumber),
 			   SIGNATURE_SIZE);
 
 	uiISOsig = ntohl(uiISOsig);
@@ -4685,8 +4685,8 @@ INT ReadISOPriority(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL iso)
 {
 
 	unsigned int ISOPri = STATUS_FAILURE;
-	if (IsSectionWritable(Adapter,iso)) {
-		if (ReadISOSignature(Adapter,iso)== ISO_IMAGE_MAGIC_NUMBER) {
+	if (IsSectionWritable(Adapter, iso)) {
+		if (ReadISOSignature(Adapter, iso)== ISO_IMAGE_MAGIC_NUMBER) {
 			BcmFlash2xBulkRead(Adapter,
 					   &ISOPri,
 					   iso,
@@ -4707,12 +4707,12 @@ FLASH2X_SECTION_VAL getHighestPriISO(PMINI_ADAPTER Adapter)
 	INT  ISOPri= 0 ;
 	FLASH2X_SECTION_VAL HighestPriISO = NO_SECTION_VAL ;
 
-	if (IsSectionWritable(Adapter,ISO_IMAGE2)) {
-		ISOHighestPri = ReadISOPriority(Adapter,ISO_IMAGE2);
+	if (IsSectionWritable(Adapter, ISO_IMAGE2)) {
+		ISOHighestPri = ReadISOPriority(Adapter, ISO_IMAGE2);
 		HighestPriISO = ISO_IMAGE2 ;
 	}
-	if (IsSectionWritable(Adapter,ISO_IMAGE1)) {
-		ISOPri = ReadISOPriority(Adapter,ISO_IMAGE1);
+	if (IsSectionWritable(Adapter, ISO_IMAGE1)) {
+		ISOPri = ReadISOPriority(Adapter, ISO_IMAGE1);
 		if (ISOHighestPri  < ISOPri) {
 			ISOHighestPri = ISOPri ;
 			HighestPriISO = ISO_IMAGE1;
@@ -4747,30 +4747,30 @@ INT WriteToFlashWithoutSectorErase(PMINI_ADAPTER Adapter,
 		return STATUS_FAILURE;
 	}
 
-	uiStartOffset = BcmGetSectionValStartOffset(Adapter,eFlash2xSectionVal);
+	uiStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectionVal);
 
-	if (IsSectionExistInVendorInfo(Adapter,eFlash2xSectionVal)) {
+	if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal)) {
 		return vendorextnWriteSectionWithoutErase(Adapter, pcBuff, eFlash2xSectionVal, uiOffset, uiNumBytes);
 	}
 
 	uiOffset = uiOffset + uiStartOffset;
 
 #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
-	Status = bcmflash_raw_writenoerase((uiOffset/FLASH_PART_SIZE),(uiOffset % FLASH_PART_SIZE), pcBuff,uiNumBytes);
+	Status = bcmflash_raw_writenoerase((uiOffset/FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), pcBuff, uiNumBytes);
 #else
 	rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
 	value = 0;
 	wrmalt(Adapter, 0x0f000C80,&value, sizeof(value));
 
 	Adapter->SelectedChip = RESET_CHIP_SELECT;
-	BcmDoChipSelect(Adapter,uiOffset);
+	BcmDoChipSelect(Adapter, uiOffset);
 	uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
 
 	for (i = 0; i < uiNumBytes; i += Adapter->ulFlashWriteSize) {
 		if (Adapter->ulFlashWriteSize == BYTE_WRITE_SUPPORT)
-			Status = flashByteWrite(Adapter,uiPartOffset, pcBuff);
+			Status = flashByteWrite(Adapter, uiPartOffset, pcBuff);
 		else
-			Status = flashWrite(Adapter,uiPartOffset, pcBuff);
+			Status = flashWrite(Adapter, uiPartOffset, pcBuff);
 
 		if (Status != STATUS_SUCCESS)
 			break;
@@ -4844,21 +4844,21 @@ INT IsSectionWritable(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL Section)
 {
 	INT offset = STATUS_FAILURE;
 	INT Status = FALSE;
-	if (IsSectionExistInFlash(Adapter,Section) == FALSE) {
+	if (IsSectionExistInFlash(Adapter, Section) == FALSE) {
 		pr_info("Section <%d> does not exist\n", Section);
 		return FALSE;
 	}
-	offset = BcmGetSectionValStartOffset(Adapter,Section);
+	offset = BcmGetSectionValStartOffset(Adapter, Section);
 	if (offset == INVALID_OFFSET) {
 		pr_info("Section<%d> does not exist\n", Section);
 		return FALSE;
 	}
 
-	if (IsSectionExistInVendorInfo(Adapter,Section)) {
+	if (IsSectionExistInVendorInfo(Adapter, Section)) {
 		return !(Adapter->psFlash2xVendorInfo->VendorSection[Section].AccessFlags & FLASH2X_SECTION_RO);
 	}
 
-	Status = IsOffsetWritable(Adapter,offset);
+	Status = IsOffsetWritable(Adapter, offset);
 	return Status ;
 }
 
@@ -4874,7 +4874,7 @@ static INT CorruptDSDSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSect
 	Adapter->bSigCorrupted = FALSE;
 
 	if (Adapter->bAllDSDWriteAllow == FALSE) {
-		if (IsSectionWritable(Adapter,eFlash2xSectionVal) != TRUE) {
+		if (IsSectionWritable(Adapter, eFlash2xSectionVal) != TRUE) {
 			pr_info("Section is not Writable...Hence can't Corrupt signature\n");
 			return SECTOR_IS_NOT_WRITABLE;
 		}
@@ -4889,12 +4889,12 @@ static INT CorruptDSDSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSect
 	uiOffset = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(DSD_HEADER);
 	uiOffset -= MAX_RW_SIZE ;
 
-	BcmFlash2xBulkRead(Adapter, (PUINT)pBuff,eFlash2xSectionVal,uiOffset,MAX_RW_SIZE);
+	BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, eFlash2xSectionVal, uiOffset, MAX_RW_SIZE);
 
 
 	sig = *((PUINT)(pBuff +12));
 	sig =ntohl(sig);
-	BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,pBuff,MAX_RW_SIZE);
+	BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pBuff, MAX_RW_SIZE);
 	//Now corrupting the sig by corrupting 4th last Byte.
 	*(pBuff + 12) = 0;
 
@@ -4902,17 +4902,17 @@ static INT CorruptDSDSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSect
 		Adapter->bSigCorrupted = TRUE;
 		if (Adapter->ulFlashWriteSize == BYTE_WRITE_SUPPORT) {
 			uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize -1);
-			BlockStatus = BcmFlashUnProtectBlock(Adapter,uiSectAlignAddr,Adapter->uiSectorSize);
+			BlockStatus = BcmFlashUnProtectBlock(Adapter, uiSectAlignAddr, Adapter->uiSectorSize);
 
-			WriteToFlashWithoutSectorErase(Adapter,(PUINT)(pBuff + 12),eFlash2xSectionVal,
-						       (uiOffset + 12),BYTE_WRITE_SUPPORT);
+			WriteToFlashWithoutSectorErase(Adapter, (PUINT)(pBuff + 12), eFlash2xSectionVal,
+						       (uiOffset + 12), BYTE_WRITE_SUPPORT);
 			if (BlockStatus) {
-				BcmRestoreBlockProtectStatus(Adapter,BlockStatus);
+				BcmRestoreBlockProtectStatus(Adapter, BlockStatus);
 				BlockStatus = 0;
 			}
 		} else {
-			WriteToFlashWithoutSectorErase(Adapter,(PUINT)pBuff,eFlash2xSectionVal,
-						       uiOffset ,MAX_RW_SIZE);
+			WriteToFlashWithoutSectorErase(Adapter, (PUINT)pBuff, eFlash2xSectionVal,
+						       uiOffset , MAX_RW_SIZE);
 		}
 	} else {
 		pr_info("BCM Signature is not present in header\n");
@@ -4934,7 +4934,7 @@ static INT CorruptISOSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSect
 
 	Adapter->bSigCorrupted = FALSE;
 
-	if (IsSectionWritable(Adapter,eFlash2xSectionVal) != TRUE) {
+	if (IsSectionWritable(Adapter, eFlash2xSectionVal) != TRUE) {
 		pr_info("Section is not Writable...Hence can't Corrupt signature\n");
 		return SECTOR_IS_NOT_WRITABLE;
 	}
@@ -4947,7 +4947,7 @@ static INT CorruptISOSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSect
 
 	uiOffset = 0;
 
-	BcmFlash2xBulkRead(Adapter, (PUINT)pBuff,eFlash2xSectionVal,uiOffset, MAX_RW_SIZE);
+	BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, eFlash2xSectionVal, uiOffset, MAX_RW_SIZE);
 
 	sig = *((PUINT)pBuff);
 	sig =ntohl(sig);
@@ -4957,8 +4957,8 @@ static INT CorruptISOSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSect
 
 	if (sig == ISO_IMAGE_MAGIC_NUMBER) {
 		Adapter->bSigCorrupted = TRUE;
-		WriteToFlashWithoutSectorErase(Adapter,(PUINT)pBuff,eFlash2xSectionVal,
-					       uiOffset ,Adapter->ulFlashWriteSize);
+		WriteToFlashWithoutSectorErase(Adapter, (PUINT)pBuff, eFlash2xSectionVal,
+					       uiOffset , Adapter->ulFlashWriteSize);
 	} else {
 		pr_info("BCM Signature is not present in header\n");
 		kfree(pBuff);
@@ -4966,7 +4966,7 @@ static INT CorruptISOSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSect
 	}
 
 	bcm_dbg(Adapter, OTHERS, NVM_RW, ALL, "Corrupted the signature\n");
-	BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,pBuff,MAX_RW_SIZE);
+	BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pBuff, MAX_RW_SIZE);
 
 	kfree(pBuff);
 	return STATUS_SUCCESS ;
diff --git a/drivers/staging/bcm/nvm.h b/drivers/staging/bcm/nvm.h
index 75c8c86..d8b45ec 100644
--- a/drivers/staging/bcm/nvm.h
+++ b/drivers/staging/bcm/nvm.h
@@ -6,7 +6,7 @@
 //	 NVM.h
 //
 // Abstract:
-//	This file has the prototypes,preprocessors and definitions various NVM libraries.
+//	This file has the prototypes, preprocessors and definitions various NVM libraries.
 //
 //
 // Revision History:
@@ -396,6 +396,6 @@ typedef struct _ISO_HEADER {
 #define DEFAULT_BUFF_SIZE 0x10000
 
 
-#define FIELD_OFFSET_IN_HEADER(HeaderPointer,Field) ((PUCHAR)&((HeaderPointer)(NULL))->Field - (PUCHAR)(NULL))
+#define FIELD_OFFSET_IN_HEADER(HeaderPointer, Field) ((PUCHAR)&((HeaderPointer)(NULL))->Field - (PUCHAR)(NULL))
 
 #endif
diff --git a/drivers/staging/bcm/target_params.h b/drivers/staging/bcm/target_params.h
index ae9792a..1c8b1b8 100644
--- a/drivers/staging/bcm/target_params.h
+++ b/drivers/staging/bcm/target_params.h
@@ -52,7 +52,7 @@ typedef struct _TARGET_PARAMS {
 	B_UINT32  m_u32PhyParameter2;
 	B_UINT32  m_u32PhyParameter3;
 
-	B_UINT32	  m_u32TestOptions; // in eval mode only; lower 16bits = basic cid for testing; then bit 16 is test cqich,bit 17  test init rang; bit 18 test periodic rang and bit 19 is test harq ack/nack
+	B_UINT32	  m_u32TestOptions; // in eval mode only; lower 16bits = basic cid for testing; then bit 16 is test cqich, bit 17  test init rang; bit 18 test periodic rang and bit 19 is test harq ack/nack
 
 	B_UINT32 m_u32MaxMACDataperDLFrame;
 	B_UINT32 m_u32MaxMACDataperULFrame;
@@ -75,6 +75,6 @@ typedef struct _TARGET_PARAMS {
 	//bit 16-31 Band AMC Data configuration: Bit 16 = 1 – Band AMC 2x3 support.
 	B_UINT32 m_u32BandAMCEnable;
 
-} stTargetParams,TARGET_PARAMS,*PTARGET_PARAMS, STARGETPARAMS, *PSTARGETPARAMS;
+} stTargetParams, TARGET_PARAMS,*PTARGET_PARAMS, STARGETPARAMS, *PSTARGETPARAMS;
 
 #endif
diff --git a/drivers/staging/bcm/vendorspecificextn.c b/drivers/staging/bcm/vendorspecificextn.c
index 59b87f6..98a9e13 100644
--- a/drivers/staging/bcm/vendorspecificextn.c
+++ b/drivers/staging/bcm/vendorspecificextn.c
@@ -11,7 +11,7 @@
 //		STATUS_SUCCESS/STATUS_FAILURE
 //
 //-----------------------------------------------------------------------------
-INT vendorextnGetSectionInfo(PVOID  pContext,PFLASH2X_VENDORSPECIFIC_INFO pVendorInfo)
+INT vendorextnGetSectionInfo(PVOID  pContext, PFLASH2X_VENDORSPECIFIC_INFO pVendorInfo)
 {
 	return STATUS_FAILURE;
 }
diff --git a/drivers/staging/bcm/vendorspecificextn.h b/drivers/staging/bcm/vendorspecificextn.h
index f41c51b..8112a47 100644
--- a/drivers/staging/bcm/vendorspecificextn.h
+++ b/drivers/staging/bcm/vendorspecificextn.h
@@ -4,7 +4,7 @@
 
 #define CONTINUE_COMMON_PATH 0xFFFF
 
-INT vendorextnGetSectionInfo(PVOID  pContext,PFLASH2X_VENDORSPECIFIC_INFO pVendorInfo);
+INT vendorextnGetSectionInfo(PVOID  pContext, PFLASH2X_VENDORSPECIFIC_INFO pVendorInfo);
 INT vendorextnExit(PMINI_ADAPTER Adapter);
 INT vendorextnInit(PMINI_ADAPTER Adapter);
 INT vendorextnIoctl(PMINI_ADAPTER Adapter, UINT cmd, ULONG arg);
-- 
1.7.8.111.gad25c.dirty




More information about the devel mailing list