Staging: vt6655: remove PVOID definition and use

Signed-off-by: Charles Clément <[e-mail]>
Signed-off-by: Greg Kroah-Hartman <[e-mail]>

drivers/staging/vt6655/IEEE11h.c

···
 -*/
 BOOL
 IEEE11hbMgrRxAction (
-    IN PVOID pMgmtHandle,
-    IN PVOID pRxPacket
+    IN void *pMgmtHandle,
+    IN void *pRxPacket
     )
 {
     PSMgmtObject            pMgmt = (PSMgmtObject) pMgmtHandle;
···
 
 
 BOOL IEEE11hbMSRRepTx (
-    IN PVOID pMgmtHandle
+    IN void *pMgmtHandle
     )
 {
     PSMgmtObject            pMgmt = (PSMgmtObject) pMgmtHandle;

drivers/staging/vt6655/IEEE11h.h

···
 /*---------------------  Export Functions  --------------------------*/
 
 BOOL IEEE11hbMSRRepTx (
-    IN PVOID pMgmtHandle
+    IN void *pMgmtHandle
     );
 
 #endif // __IEEE11h_H__

drivers/staging/vt6655/bssdb.c

···
 
 BOOL
 BSSDBbIsSTAInNodeDB(
-    IN PVOID pMgmtObject,
+    IN void *pMgmtObject,
     IN PBYTE abyDstAddr,
     OUT PUINT puNodeIndex
     )
···
     pMgmt->abyCurrExtSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)pExtSuppRates,
                                             (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates,
                                             uRateLen);
-    RATEvParseMaxRate((PVOID) pDevice,
+    RATEvParseMaxRate((void *)pDevice,
                        (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
                        (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates,
                        TRUE,
···
     pMgmt->sNodeDBTable[0].bActive = TRUE;
     pMgmt->sNodeDBTable[0].bPSEnable = FALSE;
     skb_queue_head_init(&pMgmt->sNodeDBTable[0].sTxPSQueue);
-    RATEvParseMaxRate((PVOID) pDevice,
+    RATEvParseMaxRate((void *)pDevice,
                       (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
                       (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates,
                       TRUE,
···
 */
                 if (ii > 0) {
                     // ii = 0 for multicast node (AP & Adhoc)
-                    RATEvTxRateFallBack((PVOID)pDevice, &(pMgmt->sNodeDBTable[ii]));
+                    RATEvTxRateFallBack((void *)pDevice, &(pMgmt->sNodeDBTable[ii]));
                 }
                 else {
                     // ii = 0 reserved for unicast AP node (Infra STA)
···
 #ifdef	PLICE_DEBUG
 		printk("SecondCallback:Before:TxDataRate is %d\n",pMgmt->sNodeDBTable[0].wTxDataRate);
 #endif
-                        RATEvTxRateFallBack((PVOID)pDevice, &(pMgmt->sNodeDBTable[ii]));
+                        RATEvTxRateFallBack((void *)pDevice, &(pMgmt->sNodeDBTable[ii]));
 #ifdef	PLICE_DEBUG
 		printk("SecondCallback:After:TxDataRate is %d\n",pMgmt->sNodeDBTable[0].wTxDataRate);
 #endif
···
             if (pDevice->bShortSlotTime) {
                 pDevice->bShortSlotTime = FALSE;
                 BBvSetShortSlotTime(pDevice);
-                vUpdateIFS((PVOID)pDevice);
+                vUpdateIFS((void *)pDevice);
             }
         }
         else {
             if (!pDevice->bShortSlotTime) {
                 pDevice->bShortSlotTime = TRUE;
                 BBvSetShortSlotTime(pDevice);
-                vUpdateIFS((PVOID)pDevice);
+                vUpdateIFS((void *)pDevice);
             }
         }
 

drivers/staging/vt6655/card.c

···
  */
 static
 void
-s_vSetRSPINF (PSDevice pDevice, CARD_PHY_TYPE ePHYType, PVOID pvSupportRateIEs, PVOID pvExtSupportRateIEs)
+s_vSetRSPINF (PSDevice pDevice, CARD_PHY_TYPE ePHYType, void *pvSupportRateIEs, void *pvExtSupportRateIEs)
 {
     BYTE  byServ = 0, bySignal = 0; // For CCK
     WORD  wLen = 0;
···
 /*---------------------  Export Variables  --------------------------*/
 
 /*---------------------  Export Functions  --------------------------*/
-BYTE CARDbyGetChannelMapping (PVOID pDeviceHandler, BYTE byChannelNumber, CARD_PHY_TYPE ePhyType)
+BYTE CARDbyGetChannelMapping (void *pDeviceHandler, BYTE byChannelNumber, CARD_PHY_TYPE ePhyType)
 {
     UINT        ii;
 
···
 }
 
 
-BYTE CARDbyGetChannelNumber (PVOID pDeviceHandler, BYTE byChannelIndex)
+BYTE CARDbyGetChannelNumber (void *pDeviceHandler, BYTE byChannelIndex)
 {
 //    PSDevice    pDevice = (PSDevice) pDeviceHandler;
     return(sChannelTbl[byChannelIndex].byChannelNumber);
···
  * Return Value: TRUE if succeeded; FALSE if failed.
  *
  */
-BOOL CARDbSetChannel (PVOID pDeviceHandler, UINT uConnectionChannel)
+BOOL CARDbSetChannel (void *pDeviceHandler, UINT uConnectionChannel)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
     BOOL        bResult = TRUE;
···
  *
  */
 /*
-BOOL CARDbSendPacket (PVOID pDeviceHandler, PVOID pPacket, CARD_PKT_TYPE ePktType, UINT uLength)
+BOOL CARDbSendPacket (void *pDeviceHandler, void *pPacket, CARD_PKT_TYPE ePktType, UINT uLength)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
     if (ePktType == PKT_TYPE_802_11_MNG) {
···
  * Return Value: TRUE if short preamble; otherwise FALSE
  *
  */
-BOOL CARDbIsShortPreamble (PVOID pDeviceHandler)
+BOOL CARDbIsShortPreamble (void *pDeviceHandler)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
     if (pDevice->byPreambleType == 0) {
···
  * Return Value: TRUE if short slot time; otherwise FALSE
  *
  */
-BOOL CARDbIsShorSlotTime (PVOID pDeviceHandler)
+BOOL CARDbIsShorSlotTime (void *pDeviceHandler)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
     return(pDevice->bShortSlotTime);
···
  * Return Value: None.
  *
  */
-BOOL CARDbSetPhyParameter (PVOID pDeviceHandler, CARD_PHY_TYPE ePHYType, WORD wCapInfo, BYTE byERPField, PVOID pvSupportRateIEs, PVOID pvExtSupportRateIEs)
+BOOL CARDbSetPhyParameter (void *pDeviceHandler, CARD_PHY_TYPE ePHYType, WORD wCapInfo, BYTE byERPField, void *pvSupportRateIEs, void *pvExtSupportRateIEs)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
     BYTE        byCWMaxMin = 0;
···
  * Return Value: none
  *
  */
-BOOL CARDbUpdateTSF (PVOID pDeviceHandler, BYTE byRxRate, QWORD qwBSSTimestamp, QWORD qwLocalTSF)
+BOOL CARDbUpdateTSF (void *pDeviceHandler, BYTE byRxRate, QWORD qwBSSTimestamp, QWORD qwLocalTSF)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
     QWORD       qwTSFOffset;
···
  * Return Value: TRUE if succeed; otherwise FALSE
  *
  */
-BOOL CARDbSetBeaconPeriod (PVOID pDeviceHandler, WORD wBeaconInterval)
+BOOL CARDbSetBeaconPeriod (void *pDeviceHandler, WORD wBeaconInterval)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
     UINT        uBeaconInterval = 0;
···
  * Return Value: TRUE if all data packet complete; otherwise FALSE.
  *
  */
-BOOL CARDbStopTxPacket (PVOID pDeviceHandler, CARD_PKT_TYPE ePktType)
+BOOL CARDbStopTxPacket (void *pDeviceHandler, CARD_PKT_TYPE ePktType)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 
···
  * Return Value: TRUE if success; FALSE if failed.
  *
  */
-BOOL CARDbStartTxPacket (PVOID pDeviceHandler, CARD_PKT_TYPE ePktType)
+BOOL CARDbStartTxPacket (void *pDeviceHandler, CARD_PKT_TYPE ePktType)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 
···
  * Return Value: TRUE if success; FALSE if failed.
  *
  */
-BOOL CARDbSetBSSID(PVOID pDeviceHandler, PBYTE pbyBSSID, CARD_OP_MODE eOPMode)
+BOOL CARDbSetBSSID(void *pDeviceHandler, PBYTE pbyBSSID, CARD_OP_MODE eOPMode)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 
···
  *
  */
 BOOL CARDbSetTxDataRate(
-    PVOID   pDeviceHandler,
+    void *pDeviceHandler,
     WORD    wDataRate
     )
 {
···
 -*/
 BOOL
 CARDbPowerDown(
-    PVOID   pDeviceHandler
+    void *pDeviceHandler
     )
 {
     PSDevice        pDevice = (PSDevice)pDeviceHandler;
···
  * Return Value: TRUE if success; otherwise FALSE
  *
  */
-BOOL CARDbRadioPowerOff (PVOID pDeviceHandler)
+BOOL CARDbRadioPowerOff (void *pDeviceHandler)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
     BOOL        bResult = TRUE;
···
  * Return Value: TRUE if success; otherwise FALSE
  *
  */
-BOOL CARDbRadioPowerOn (PVOID pDeviceHandler)
+BOOL CARDbRadioPowerOn (void *pDeviceHandler)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
     BOOL        bResult = TRUE;
···
 
 
 
-BOOL CARDbRemoveKey (PVOID pDeviceHandler, PBYTE pbyBSSID)
+BOOL CARDbRemoveKey (void *pDeviceHandler, PBYTE pbyBSSID)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 
···
 -*/
 BOOL
 CARDbAdd_PMKID_Candidate (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN PBYTE            pbyBSSID,
     IN BOOL             bRSNCapExist,
     IN WORD             wRSNCap
···
     return TRUE;
 }
 
-PVOID
+void *
 CARDpGetCurrentAddress (
-    IN PVOID            pDeviceHandler
+    IN void *pDeviceHandler
     )
 {
     PSDevice            pDevice = (PSDevice) pDeviceHandler;
···
 
 
 
-void CARDvInitChannelTable (PVOID pDeviceHandler)
+void CARDvInitChannelTable (void *pDeviceHandler)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
     BOOL        bMultiBand = FALSE;
···
 -*/
 BOOL
 CARDbStartMeasure (
-    IN PVOID            pDeviceHandler,
-    IN PVOID            pvMeasureEIDs,
+    IN void *pDeviceHandler,
+    IN void *pvMeasureEIDs,
     IN UINT             uNumOfMeasureEIDs
     )
 {
···
 -*/
 BOOL
 CARDbChannelSwitch (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN BYTE             byMode,
     IN BYTE             byNewChannel,
     IN BYTE             byCount
···
 -*/
 BOOL
 CARDbSetQuiet (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN BOOL             bResetQuiet,
     IN BYTE             byQuietCount,
     IN BYTE             byQuietPeriod,
···
 -*/
 BOOL
 CARDbStartQuiet (
-    IN PVOID            pDeviceHandler
+    IN void *pDeviceHandler
     )
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
···
 -*/
 void
 CARDvSetCountryInfo (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN CARD_PHY_TYPE    ePHYType,
-    IN PVOID            pIE
+    IN void *pIE
     )
 {
     PSDevice            pDevice = (PSDevice) pDeviceHandler;
···
 -*/
 void
 CARDvSetPowerConstraint (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN BYTE             byChannel,
     IN I8               byPower
     )
···
 -*/
 void
 CARDvGetPowerCapability (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     OUT PBYTE           pbyMinPower,
     OUT PBYTE           pbyMaxPower
     )
···
 -*/
 BYTE
 CARDbySetSupportChannels (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN OUT PBYTE        pbyIEs
     )
 {
···
 -*/
 I8
 CARDbyGetTransmitPower (
-    IN PVOID            pDeviceHandler
+    IN void *pDeviceHandler
     )
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
···
 
 void
 CARDvSetCountryIE(
-    IN PVOID        pDeviceHandler,
-    IN PVOID        pIE
+    IN void *pDeviceHandler,
+    IN void *pIE
     )
 {
     PSDevice            pDevice = (PSDevice) pDeviceHandler;
···
 
 BOOL
 CARDbGetChannelMapInfo(
-    IN PVOID        pDeviceHandler,
+    IN void *pDeviceHandler,
     IN UINT         uChannelIndex,
     OUT PBYTE       pbyChannelNumber,
     OUT PBYTE       pbyMap
···
 
 void
 CARDvSetChannelMapInfo(
-    IN PVOID        pDeviceHandler,
+    IN void *pDeviceHandler,
     IN UINT         uChannelIndex,
     IN BYTE         byMap
     )
···
 
 void
 CARDvClearChannelMapInfo(
-    IN PVOID        pDeviceHandler
+    IN void *pDeviceHandler
     )
 {
 //    PSDevice    pDevice = (PSDevice) pDeviceHandler;
···
 
 BYTE
 CARDbyAutoChannelSelect(
-    IN PVOID        pDeviceHandler,
+    IN void *pDeviceHandler,
     CARD_PHY_TYPE   ePHYType
     )
 {
···
 //xxx
 void
 CARDvSafeResetTx (
-    IN PVOID    pDeviceHandler
+    IN void *pDeviceHandler
     )
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
···
 -*/
 void
 CARDvSafeResetRx (
-    IN PVOID    pDeviceHandler
+    IN void *pDeviceHandler
     )
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
···
  * Return Value: response Control frame rate
  *
  */
-WORD CARDwGetCCKControlRate(PVOID pDeviceHandler, WORD wRateIdx)
+WORD CARDwGetCCKControlRate(void *pDeviceHandler, WORD wRateIdx)
 {
     PSDevice    pDevice = (PSDevice) pDeviceHandler;
     UINT ui = (UINT)wRateIdx;
···
  * Return Value: response Control frame rate
  *
  */
-WORD CARDwGetOFDMControlRate (PVOID pDeviceHandler, WORD wRateIdx)
+WORD CARDwGetOFDMControlRate (void *pDeviceHandler, WORD wRateIdx)
 {
     PSDevice pDevice = (PSDevice) pDeviceHandler;
     UINT ui = (UINT)wRateIdx;
 
     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BASIC RATE: %X\n", pDevice->wBasicRate);
 
-    if (!CARDbIsOFDMinBasicRate((PVOID)pDevice)) {
+    if (!CARDbIsOFDMinBasicRate((void *)pDevice)) {
         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"CARDwGetOFDMControlRate:(NO OFDM) %d\n", wRateIdx);
         if (wRateIdx > RATE_24M)
             wRateIdx = RATE_24M;
···
  * Return Value: None.
  *
  */
-void CARDvSetRSPINF (PVOID pDeviceHandler, CARD_PHY_TYPE ePHYType)
+void CARDvSetRSPINF (void *pDeviceHandler, CARD_PHY_TYPE ePHYType)
 {
     PSDevice pDevice = (PSDevice) pDeviceHandler;
     BYTE  byServ = 0x00, bySignal = 0x00; //For CCK
···
     //RSPINF_b_1
     BBvCaculateParameter(pDevice,
                          14,
-                         CARDwGetCCKControlRate((PVOID)pDevice, RATE_1M),
+                         CARDwGetCCKControlRate((void *)pDevice, RATE_1M),
                          PK_TYPE_11B,
                          &wLen,
                          &byServ,
···
     ///RSPINF_b_2
     BBvCaculateParameter(pDevice,
                          14,
-                         CARDwGetCCKControlRate((PVOID)pDevice, RATE_2M),
+                         CARDwGetCCKControlRate((void *)pDevice, RATE_2M),
                          PK_TYPE_11B,
                          &wLen,
                          &byServ,
···
     //RSPINF_b_5
     BBvCaculateParameter(pDevice,
                          14,
-                         CARDwGetCCKControlRate((PVOID)pDevice, RATE_5M),
+                         CARDwGetCCKControlRate((void *)pDevice, RATE_5M),
                          PK_TYPE_11B,
                          &wLen,
                          &byServ,
···
     //RSPINF_b_11
     BBvCaculateParameter(pDevice,
                          14,
-                         CARDwGetCCKControlRate((PVOID)pDevice, RATE_11M),
+                         CARDwGetCCKControlRate((void *)pDevice, RATE_11M),
                          PK_TYPE_11B,
                          &wLen,
                          &byServ,
···
                               &byRsvTime);
     VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_24, MAKEWORD(byTxRate,byRsvTime));
     //RSPINF_a_36
-    s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((PVOID)pDevice, RATE_36M),
+    s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_36M),
                               ePHYType,
                               &byTxRate,
                               &byRsvTime);
     VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_36, MAKEWORD(byTxRate,byRsvTime));
     //RSPINF_a_48
-    s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((PVOID)pDevice, RATE_48M),
+    s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_48M),
                               ePHYType,
                               &byTxRate,
                               &byRsvTime);
     VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_48, MAKEWORD(byTxRate,byRsvTime));
     //RSPINF_a_54
-    s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((PVOID)pDevice, RATE_54M),
+    s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M),
                               ePHYType,
                               &byTxRate,
                               &byRsvTime);
     VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_54, MAKEWORD(byTxRate,byRsvTime));
 
     //RSPINF_a_72
-    s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((PVOID)pDevice, RATE_54M),
+    s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M),
                               ePHYType,
                               &byTxRate,
                               &byRsvTime);
···
  * Return Value: None.
  *
  */
-void vUpdateIFS (PVOID pDeviceHandler)
+void vUpdateIFS (void *pDeviceHandler)
 {
     //Set SIFS, DIFS, EIFS, SlotTime, CwMin
     PSDevice pDevice = (PSDevice) pDeviceHandler;
···
     VNSvOutPortB(pDevice->PortOffset + MAC_REG_CWMAXMIN0, (BYTE)byMaxMin);
 }
 
-void CARDvUpdateBasicTopRate (PVOID pDeviceHandler)
+void CARDvUpdateBasicTopRate (void *pDeviceHandler)
 {
     PSDevice pDevice = (PSDevice) pDeviceHandler;
     BYTE byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
···
  * Return Value: TRUE if succeeded; FALSE if failed.
  *
  */
-BOOL CARDbAddBasicRate (PVOID pDeviceHandler, WORD wRateIdx)
+BOOL CARDbAddBasicRate (void *pDeviceHandler, WORD wRateIdx)
 {
     PSDevice pDevice = (PSDevice) pDeviceHandler;
     WORD wRate = (WORD)(1<<wRateIdx);
···
     pDevice->wBasicRate |= wRate;
 
     //Determines the highest basic rate.
-    CARDvUpdateBasicTopRate((PVOID)pDevice);
+    CARDvUpdateBasicTopRate((void *)pDevice);
 
     return(TRUE);
 }
 
-BOOL CARDbIsOFDMinBasicRate (PVOID pDeviceHandler)
+BOOL CARDbIsOFDMinBasicRate (void *pDeviceHandler)
 {
     PSDevice pDevice = (PSDevice) pDeviceHandler;
     int ii;
···
     return FALSE;
 }
 
-BYTE CARDbyGetPktType (PVOID pDeviceHandler)
+BYTE CARDbyGetPktType (void *pDeviceHandler)
 {
     PSDevice pDevice = (PSDevice) pDeviceHandler;
 
     if (pDevice->byBBType == BB_TYPE_11A || pDevice->byBBType == BB_TYPE_11B) {
         return (BYTE)pDevice->byBBType;
     }
-    else if (CARDbIsOFDMinBasicRate((PVOID)pDevice)) {
+    else if (CARDbIsOFDMinBasicRate((void *)pDevice)) {
         return PK_TYPE_11GA;
     }
     else {
···
  * Return Value: none
  *
  */
-BOOL CARDbSoftwareReset (PVOID pDeviceHandler)
+BOOL CARDbSoftwareReset (void *pDeviceHandler)
 {
     PSDevice pDevice = (PSDevice) pDeviceHandler;
 

drivers/staging/vt6655/card.h

···
 /*---------------------  Export Functions  --------------------------*/
 
 BOOL ChannelValid(UINT CountryCode, UINT ChannelIndex);
-void CARDvSetRSPINF(PVOID pDeviceHandler, CARD_PHY_TYPE ePHYType);
-void vUpdateIFS(PVOID pDeviceHandler);
-void CARDvUpdateBasicTopRate(PVOID pDeviceHandler);
-BOOL CARDbAddBasicRate(PVOID pDeviceHandler, WORD wRateIdx);
-BOOL CARDbIsOFDMinBasicRate(PVOID pDeviceHandler);
+void CARDvSetRSPINF(void *pDeviceHandler, CARD_PHY_TYPE ePHYType);
+void vUpdateIFS(void *pDeviceHandler);
+void CARDvUpdateBasicTopRate(void *pDeviceHandler);
+BOOL CARDbAddBasicRate(void *pDeviceHandler, WORD wRateIdx);
+BOOL CARDbIsOFDMinBasicRate(void *pDeviceHandler);
 void CARDvSetLoopbackMode(DWORD_PTR dwIoBase, WORD wLoopbackMode);
-BOOL CARDbSoftwareReset(PVOID pDeviceHandler);
+BOOL CARDbSoftwareReset(void *pDeviceHandler);
 void CARDvSetFirstNextTBTT(DWORD_PTR dwIoBase, WORD wBeaconInterval);
 void CARDvUpdateNextTBTT(DWORD_PTR dwIoBase, QWORD qwTSF, WORD wBeaconInterval);
 BOOL CARDbGetCurrentTSF(DWORD_PTR dwIoBase, PQWORD pqwCurrTSF);
 QWORD CARDqGetNextTBTT(QWORD qwTSF, WORD wBeaconInterval);
 QWORD CARDqGetTSFOffset(BYTE byRxRate, QWORD qwTSF1, QWORD qwTSF2);
-BOOL CARDbSetTxPower(PVOID pDeviceHandler, ULONG ulTxPower);
-BYTE CARDbyGetPktType(PVOID pDeviceHandler);
-void CARDvSafeResetTx(PVOID pDeviceHandler);
-void CARDvSafeResetRx(PVOID pDeviceHandler);
+BOOL CARDbSetTxPower(void *pDeviceHandler, ULONG ulTxPower);
+BYTE CARDbyGetPktType(void *pDeviceHandler);
+void CARDvSafeResetTx(void *pDeviceHandler);
+void CARDvSafeResetRx(void *pDeviceHandler);
 
 //xxx
-BOOL CARDbRadioPowerOff(PVOID pDeviceHandler);
-BOOL CARDbRadioPowerOn(PVOID pDeviceHandler);
-BOOL CARDbSetChannel(PVOID pDeviceHandler, UINT uConnectionChannel);
-//BOOL CARDbSendPacket(PVOID pDeviceHandler, PVOID pPacket, CARD_PKT_TYPE ePktType, UINT uLength);
-BOOL CARDbIsShortPreamble(PVOID pDeviceHandler);
-BOOL CARDbIsShorSlotTime(PVOID pDeviceHandler);
-BOOL CARDbSetPhyParameter(PVOID pDeviceHandler, CARD_PHY_TYPE ePHYType, WORD wCapInfo, BYTE byERPField, PVOID pvSupportRateIEs, PVOID pvExtSupportRateIEs);
-BOOL CARDbUpdateTSF(PVOID pDeviceHandler, BYTE byRxRate, QWORD qwBSSTimestamp, QWORD qwLocalTSF);
-BOOL CARDbStopTxPacket(PVOID pDeviceHandler, CARD_PKT_TYPE ePktType);
-BOOL CARDbStartTxPacket(PVOID pDeviceHandler, CARD_PKT_TYPE ePktType);
-BOOL CARDbSetBeaconPeriod(PVOID pDeviceHandler, WORD wBeaconInterval);
-BOOL CARDbSetBSSID(PVOID pDeviceHandler, PBYTE pbyBSSID, CARD_OP_MODE eOPMode);
+BOOL CARDbRadioPowerOff(void *pDeviceHandler);
+BOOL CARDbRadioPowerOn(void *pDeviceHandler);
+BOOL CARDbSetChannel(void *pDeviceHandler, UINT uConnectionChannel);
+//BOOL CARDbSendPacket(void *pDeviceHandler, void *pPacket, CARD_PKT_TYPE ePktType, UINT uLength);
+BOOL CARDbIsShortPreamble(void *pDeviceHandler);
+BOOL CARDbIsShorSlotTime(void *pDeviceHandler);
+BOOL CARDbSetPhyParameter(void *pDeviceHandler, CARD_PHY_TYPE ePHYType, WORD wCapInfo, BYTE byERPField, void *pvSupportRateIEs, void *pvExtSupportRateIEs);
+BOOL CARDbUpdateTSF(void *pDeviceHandler, BYTE byRxRate, QWORD qwBSSTimestamp, QWORD qwLocalTSF);
+BOOL CARDbStopTxPacket(void *pDeviceHandler, CARD_PKT_TYPE ePktType);
+BOOL CARDbStartTxPacket(void *pDeviceHandler, CARD_PKT_TYPE ePktType);
+BOOL CARDbSetBeaconPeriod(void *pDeviceHandler, WORD wBeaconInterval);
+BOOL CARDbSetBSSID(void *pDeviceHandler, PBYTE pbyBSSID, CARD_OP_MODE eOPMode);
 
 BOOL
 CARDbPowerDown(
-    PVOID   pDeviceHandler
+    void *pDeviceHandler
     );
 
 BOOL CARDbSetTxDataRate(
-    PVOID   pDeviceHandler,
+    void *pDeviceHandler,
     WORD    wDataRate
     );
 
 
-BOOL CARDbRemoveKey (PVOID pDeviceHandler, PBYTE pbyBSSID);
+BOOL CARDbRemoveKey (void *pDeviceHandler, PBYTE pbyBSSID);
 
 BOOL
 CARDbAdd_PMKID_Candidate (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN PBYTE            pbyBSSID,
     IN BOOL             bRSNCapExist,
     IN WORD             wRSNCap
     );
 
-PVOID
+void *
 CARDpGetCurrentAddress (
-    IN PVOID            pDeviceHandler
+    IN void *pDeviceHandler
     );
 
 
-void CARDvInitChannelTable(PVOID pDeviceHandler);
-BYTE CARDbyGetChannelMapping(PVOID pDeviceHandler, BYTE byChannelNumber, CARD_PHY_TYPE ePhyType);
+void CARDvInitChannelTable(void *pDeviceHandler);
+BYTE CARDbyGetChannelMapping(void *pDeviceHandler, BYTE byChannelNumber, CARD_PHY_TYPE ePhyType);
 
 BOOL
 CARDbStartMeasure (
-    IN PVOID            pDeviceHandler,
-    IN PVOID            pvMeasureEIDs,
+    IN void *pDeviceHandler,
+    IN void *pvMeasureEIDs,
     IN UINT             uNumOfMeasureEIDs
     );
 
 BOOL
 CARDbChannelSwitch (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN BYTE             byMode,
     IN BYTE             byNewChannel,
     IN BYTE             byCount
···
 
 BOOL
 CARDbSetQuiet (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN BOOL             bResetQuiet,
     IN BYTE             byQuietCount,
     IN BYTE             byQuietPeriod,
···
 
 BOOL
 CARDbStartQuiet (
-    IN PVOID            pDeviceHandler
+    IN void *pDeviceHandler
     );
 
 void
 CARDvSetCountryInfo (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN CARD_PHY_TYPE    ePHYType,
-    IN PVOID            pIE
+    IN void *pIE
     );
 
 void
 CARDvSetPowerConstraint (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN BYTE             byChannel,
     IN I8               byPower
     );
 
 void
 CARDvGetPowerCapability (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     OUT PBYTE           pbyMinPower,
     OUT PBYTE           pbyMaxPower
     );
 
 BYTE
 CARDbySetSupportChannels (
-    IN PVOID            pDeviceHandler,
+    IN void *pDeviceHandler,
     IN OUT PBYTE        pbyIEs
     );
 
 I8
 CARDbyGetTransmitPower (
-    IN PVOID            pDeviceHandler
+    IN void *pDeviceHandler
     );
 
 BOOL
···
 
 void
 CARDvSetCountryIE(
-    IN PVOID        pDeviceHandler,
-    IN PVOID        pIE
+    IN void *pDeviceHandler,
+    IN void *pIE
     );
 
 BOOL
 CARDbGetChannelMapInfo(
-    IN PVOID        pDeviceHandler,
+    IN void *pDeviceHandler,
     IN UINT         uChannelIndex,
     OUT PBYTE       pbyChannelNumber,
     OUT PBYTE       pbyMap
···
 
 void
 CARDvSetChannelMapInfo(
-    IN PVOID        pDeviceHandler,
+    IN void *pDeviceHandler,
     IN UINT         uChannelIndex,
     IN BYTE         byMap
     );
 
 void
 CARDvClearChannelMapInfo(
-    IN PVOID        pDeviceHandler
+    IN void *pDeviceHandler
     );
 
 BYTE
 CARDbyAutoChannelSelect(
-    IN PVOID        pDeviceHandler,
+    IN void *pDeviceHandler,
     CARD_PHY_TYPE   ePHYType
     );
 
-BYTE CARDbyGetChannelNumber(PVOID pDeviceHandler, BYTE byChannelIndex);
+BYTE CARDbyGetChannelNumber(void *pDeviceHandler, BYTE byChannelIndex);
 
 #endif // __CARD_H__
 

drivers/staging/vt6655/datarate.c

···
 -*/
 void
 RATEvParseMaxRate (
-    IN PVOID pDeviceHandler,
+    IN void *pDeviceHandler,
     IN PWLAN_IE_SUPP_RATES pItemRates,
     IN PWLAN_IE_SUPP_RATES pItemExtRates,
     IN BOOL bUpdateBasicRate,
···
         if (WLAN_MGMT_IS_BASICRATE(byRate) &&
             (bUpdateBasicRate == TRUE))  {
             // Add to basic rate set, update pDevice->byTopCCKBasicRate and pDevice->byTopOFDMBasicRate
-            CARDbAddBasicRate((PVOID)pDevice, wGetRateIdx(byRate));
+            CARDbAddBasicRate((void *)pDevice, wGetRateIdx(byRate));
             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ParseMaxRate AddBasicRate: %d\n", wGetRateIdx(byRate));
         }
         byRate = (BYTE)(pItemRates->abyRates[ii]&0x7F);
···
             // select highest basic rate
             if (WLAN_MGMT_IS_BASICRATE(pItemExtRates->abyRates[ii])) {
             	// Add to basic rate set, update pDevice->byTopCCKBasicRate and pDevice->byTopOFDMBasicRate
-                CARDbAddBasicRate((PVOID)pDevice, wGetRateIdx(byRate));
+                CARDbAddBasicRate((void *)pDevice, wGetRateIdx(byRate));
                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ParseMaxRate AddBasicRate: %d\n", wGetRateIdx(byRate));
             }
             byRate = (BYTE)(pItemExtRates->abyRates[ii]&0x7F);
···
         }
     } //if(pItemExtRates != NULL)
 
-    if ((pDevice->byPacketType == PK_TYPE_11GB) && CARDbIsOFDMinBasicRate((PVOID)pDevice)) {
+    if ((pDevice->byPacketType == PK_TYPE_11GB) && CARDbIsOFDMinBasicRate((void *)pDevice)) {
         pDevice->byPacketType = PK_TYPE_11GA;
     }
 
···
     else
        *pwMaxBasicRate = pDevice->byTopOFDMBasicRate;
     if (wOldBasicRate != pDevice->wBasicRate)
-        CARDvSetRSPINF((PVOID)pDevice, pDevice->eCurrentPHYType);
+        CARDvSetRSPINF((void *)pDevice, pDevice->eCurrentPHYType);
 
      DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Exit ParseMaxRate\n");
 }
···
 
 void
 RATEvTxRateFallBack (
-    IN PVOID pDeviceHandler,
+    IN void *pDeviceHandler,
     IN PKnownNodeDB psNodeDBTable
     )
 {

drivers/staging/vt6655/datarate.h

···
 
 void
 RATEvParseMaxRate(
-    IN PVOID pDeviceHandler,
+    IN void *pDeviceHandler,
     IN PWLAN_IE_SUPP_RATES pItemRates,
     IN PWLAN_IE_SUPP_RATES pItemExtRates,
     IN BOOL bUpdateBasicRate,
···
 
 void
 RATEvTxRateFallBack(
-    IN PVOID pDeviceHandler,
+    IN void *pDeviceHandler,
     IN PKnownNodeDB psNodeDBTable
     );
 

drivers/staging/vt6655/device_main.c

···
             pDevice->abyOFDMPwrTbl[ii+CB_MAX_CHANNEL_24G+1] = SROMbyReadEmbedded(pDevice->PortOffset, (BYTE)(ii + EEP_OFS_OFDMA_PWR_TBL));
             pDevice->abyOFDMDefaultPwr[ii+CB_MAX_CHANNEL_24G+1] = SROMbyReadEmbedded(pDevice->PortOffset, (BYTE)(ii + EEP_OFS_OFDMA_PWR_dBm));
         }
-        CARDvInitChannelTable((PVOID)pDevice);
+        CARDvInitChannelTable((void *)pDevice);
 
 
         if (pDevice->byLocalID > REV_ID_VT3253_B1) {
···
     //Enable the chip specified capbilities
     pDevice->flags = pDevice->sOpts.flags | (pChip_info->flags & 0xFF000000UL);
     pDevice->tx_80211 = device_dma0_tx_80211;
-    pDevice->sMgmtObj.pAdapter = (PVOID)pDevice;
+    pDevice->sMgmtObj.pAdapter = (void *)pDevice;
     pDevice->pMgmt = &(pDevice->sMgmtObj);
 
     dev->irq                = pcid->irq;
···
         unregister_netdev(dev);
 
     if (pDevice->PortOffset)
-        iounmap((PVOID)pDevice->PortOffset);
+        iounmap((void *)pDevice->PortOffset);
 
     if (pDevice->pcid)
         pci_release_regions(pDevice->pcid);
···
 
         dev_kfree_skb(pRDInfo->skb);
 
-        kfree((PVOID)pDesc->pRDInfo);
+        kfree((void *)pDesc->pRDInfo);
     }
 
 }
···
 
         dev_kfree_skb(pRDInfo->skb);
 
-        kfree((PVOID)pDesc->pRDInfo);
+        kfree((void *)pDesc->pRDInfo);
     }
 
 }
···
         if (pTDInfo->skb)
             dev_kfree_skb(pTDInfo->skb);
 
-        kfree((PVOID)pDesc->pTDInfo);
+        kfree((void *)pDesc->pTDInfo);
     }
 }
 
···
         if (pTDInfo->skb)
             dev_kfree_skb(pTDInfo->skb);
 
-        kfree((PVOID)pDesc->pTDInfo);
+        kfree((void *)pDesc->pTDInfo);
     }
 
 }

drivers/staging/vt6655/dpc.c

···
 
 //PLICE_DEBUG ->
 
-void	MngWorkItem(PVOID Context)
+void	MngWorkItem(void *Context)
 {
 	PSRxMgmtPacket			pRxMgmtPacket;
 	PSDevice	pDevice =  (PSDevice) Context;

drivers/staging/vt6655/dpc.h

···
     IN  PSRxDesc pCurrRD
     );
 
-void	MngWorkItem(PVOID Context);
+void	MngWorkItem(void *Context);
 
 #endif // __RXTX_H__
 

drivers/staging/vt6655/key.c

···
     for (i=0;i<MAX_KEY_TABLE;i++) {
         pTable->KeyTable[i].bInUse = FALSE;
         pTable->KeyTable[i].PairwiseKey.bKeyValid = FALSE;
-        pTable->KeyTable[i].PairwiseKey.pvKeyTable = (PVOID)&pTable->KeyTable[i];
+        pTable->KeyTable[i].PairwiseKey.pvKeyTable = (void *)&pTable->KeyTable[i];
         for (jj=0; jj < MAX_GROUP_KEY; jj++) {
             pTable->KeyTable[i].GroupKey[jj].bKeyValid = FALSE;
-            pTable->KeyTable[i].GroupKey[jj].pvKeyTable = (PVOID)&pTable->KeyTable[i];
+            pTable->KeyTable[i].GroupKey[jj].pvKeyTable = (void *)&pTable->KeyTable[i];
         }
         pTable->KeyTable[i].wKeyCtl = 0;
         pTable->KeyTable[i].dwGTKeyIndex = 0;

drivers/staging/vt6655/key.h

···
     BYTE        byCipherSuite;
     BYTE        byReserved0;
     DWORD       dwKeyIndex;
-    PVOID       pvKeyTable;
+    void *pvKeyTable;
 } SKeyItem, *PSKeyItem; //64
 
 typedef struct tagSKeyTable

drivers/staging/vt6655/rxtx.c

···
 s_vFillRTSHead(
     IN PSDevice         pDevice,
     IN BYTE             byPktType,
-    IN PVOID            pvRTS,
+    IN void *           pvRTS,
     IN UINT             cbFrameLength,
     IN BOOL             bNeedAck,
     IN BOOL             bDisCRC,
···
 s_vGenerateTxParameter(
     IN PSDevice         pDevice,
     IN  BYTE            byPktType,
-    IN PVOID            pTxBufHead,
-    IN PVOID            pvRrvTime,
-    IN PVOID            pvRTS,
-    IN PVOID            pvCTS,
+    IN void *           pTxBufHead,
+    IN void *           pvRrvTime,
+    IN void *           pvRTS,
+    IN void *           pvCTS,
     IN UINT             cbFrameSize,
     IN BOOL             bNeedACK,
     IN UINT             uDMAIdx,
···
     IN PSDevice pDevice,
     IN PBYTE    pbyBuffer,
     IN UINT     uTxType,
-    IN PVOID    pvtdCurr,
+    IN void *   pvtdCurr,
     IN WORD     wFragType,
     IN UINT     cbReqCount
     );
···
 s_uFillDataHead (
     IN PSDevice pDevice,
     IN BYTE     byPktType,
-    IN PVOID    pTxDataHead,
+    IN void *   pTxDataHead,
     IN UINT     cbFrameLength,
     IN UINT     uDMAIdx,
     IN BOOL     bNeedAck,
···
 s_uFillDataHead (
     IN PSDevice pDevice,
     IN BYTE     byPktType,
-    IN PVOID    pTxDataHead,
+    IN void *   pTxDataHead,
     IN UINT     cbFrameLength,
     IN UINT     uDMAIdx,
     IN BOOL     bNeedAck,
···
 s_vFillRTSHead (
     IN PSDevice         pDevice,
     IN BYTE             byPktType,
-    IN PVOID            pvRTS,
+    IN void *           pvRTS,
     IN UINT             cbFrameLength,
     IN BOOL             bNeedAck,
     IN BOOL             bDisCRC,
···
     IN PSDevice pDevice,
     IN UINT     uDMAIdx,
     IN BYTE     byPktType,
-    IN PVOID    pvCTS,
+    IN void *   pvCTS,
     IN UINT     cbFrameLength,
     IN BOOL     bNeedAck,
     IN BOOL     bDisCRC,
···
 s_vGenerateTxParameter (
     IN PSDevice         pDevice,
     IN BYTE             byPktType,
-    IN PVOID            pTxBufHead,
-    IN PVOID            pvRrvTime,
-    IN PVOID            pvRTS,
-    IN PVOID            pvCTS,
+    IN void *           pTxBufHead,
+    IN void *           pvRrvTime,
+    IN void *           pvRTS,
+    IN void *           pvCTS,
     IN UINT             cbFrameSize,
     IN BOOL             bNeedACK,
     IN UINT             uDMAIdx,
···
     IN PSDevice pDevice,
     IN PBYTE    pbyBuffer,
     IN UINT     uTxType,
-    IN PVOID    pvtdCurr,
+    IN void *   pvtdCurr,
     IN WORD     wFragType,
     IN UINT     cbReqCount
     )
···
     PSTxBufHead    psTxBufHd = (PSTxBufHead) pbyTxBufferAddr;
 //    UINT           tmpDescIdx;
     UINT           cbHeaderLength = 0;
-    PVOID          pvRrvTime;
+    void *         pvRrvTime;
     PSMICHDRHead   pMICHDR;
-    PVOID          pvRTS;
-    PVOID          pvCTS;
-    PVOID          pvTxDataHd;
+    void *         pvRTS;
+    void *         pvCTS;
+    void *         pvTxDataHd;
     WORD           wTxBufSize;   // FFinfo size
     UINT           uTotalCopyLength = 0;
     BYTE           byFBOption = AUTO_FB_NONE;
···
             }
         } // Auto Fall Back
     }
-    memset((PVOID)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderLength - wTxBufSize));
+    memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderLength - wTxBufSize));
 
 //////////////////////////////////////////////////////////////////
     if ((bNeedEncrypt == TRUE) && (pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {
···
 
 
                 //Fill FIFO,RrvTime,RTS,and CTS
-                s_vGenerateTxParameter(pDevice, byPktType, (PVOID)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
+                s_vGenerateTxParameter(pDevice, byPktType, (void *)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
                                        cbFragmentSize, bNeedACK, uDMAIdx, psEthHeader, pDevice->wCurrentRate);
                 //Fill DataHead
                 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFragmentSize, uDMAIdx, bNeedACK,
···
                 //if (pDevice->bAES) {
                 //    s_vFillMICHDR(pDevice, (PBYTE)pMICHDR, pbyMacHdr, (WORD)cbFragPayloadSize);
                 //}
-                //cbReqCount += s_uDoEncryption(pDevice, psEthHeader, (PVOID)psTxBufHd, byKeySel,
+                //cbReqCount += s_uDoEncryption(pDevice, psEthHeader, (void *)psTxBufHd, byKeySel,
                 //                                pbyPayloadHead, (WORD)cbFragPayloadSize, uDMAIdx);
 
 
···
 
                 uLength = cbHeaderLength + cbMACHdLen + uPadding + cbIVlen + cb802_1_H_len;
                 //copy TxBufferHeader + MacHeader to desc
-                memcpy(pbyBuffer, (PVOID)psTxBufHd, uLength);
+                memcpy(pbyBuffer, (void *)psTxBufHd, uLength);
 
                 // Copy the Packet into a tx Buffer
                 memcpy((pbyBuffer + uLength), (pPacket + 14), (cbFragPayloadSize - cb802_1_H_len));
···
                 //4.Set Sequence Control
                 //5.Get S/W generate FCS
                 //--------------------
-                s_vFillFragParameter(pDevice, pbyBuffer, uDMAIdx, (PVOID)ptdCurr, wFragType, cbReqCount);
+                s_vFillFragParameter(pDevice, pbyBuffer, uDMAIdx, (void *)ptdCurr, wFragType, cbReqCount);
 
                 ptdCurr->pTDInfo->dwReqCount = cbReqCount - uPadding;
                 ptdCurr->pTDInfo->dwHeaderLength = cbHeaderLength;
···
                 wFragType = FRAGCTL_ENDFRAG;
 
                 //Fill FIFO,RrvTime,RTS,and CTS
-                s_vGenerateTxParameter(pDevice, byPktType, (PVOID)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
+                s_vGenerateTxParameter(pDevice, byPktType, (void *)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
                                        cbLastFragmentSize, bNeedACK, uDMAIdx, psEthHeader, pDevice->wCurrentRate);
                 //Fill DataHead
                 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbLastFragmentSize, uDMAIdx, bNeedACK,
···
                 uLength = cbHeaderLength + cbMACHdLen + uPadding + cbIVlen;
 
                 //copy TxBufferHeader + MacHeader to desc
-                memcpy(pbyBuffer, (PVOID)psTxBufHd, uLength);
+                memcpy(pbyBuffer, (void *)psTxBufHd, uLength);
 
                 // Copy the Packet into a tx Buffer
                 if (bMIC2Frag == FALSE) {
···
                 //--------------------
 
 
-                s_vFillFragParameter(pDevice, pbyBuffer, uDMAIdx, (PVOID)ptdCurr, wFragType, cbReqCount);
+                s_vFillFragParameter(pDevice, pbyBuffer, uDMAIdx, (void *)ptdCurr, wFragType, cbReqCount);
 
                 ptdCurr->pTDInfo->dwReqCount = cbReqCount - uPadding;
                 ptdCurr->pTDInfo->dwHeaderLength = cbHeaderLength;
···
                 wFragType = FRAGCTL_MIDFRAG;
 
                 //Fill FIFO,RrvTime,RTS,and CTS
-                s_vGenerateTxParameter(pDevice, byPktType, (PVOID)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
+                s_vGenerateTxParameter(pDevice, byPktType, (void *)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
                                        cbFragmentSize, bNeedACK, uDMAIdx, psEthHeader, pDevice->wCurrentRate);
                 //Fill DataHead
                 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFragmentSize, uDMAIdx, bNeedACK,
···
                 //if (pDevice->bAES) {
                 //    s_vFillMICHDR(pDevice, (PBYTE)pMICHDR, pbyMacHdr, (WORD)cbFragPayloadSize);
                 //}
-                //cbReqCount += s_uDoEncryption(pDevice, psEthHeader, (PVOID)psTxBufHd, byKeySel,
+                //cbReqCount += s_uDoEncryption(pDevice, psEthHeader, (void *)psTxBufHd, byKeySel,
                 //                              pbyPayloadHead, (WORD)cbFragPayloadSize, uDMAIdx);
 
 
···
                 uLength = cbHeaderLength + cbMACHdLen + uPadding + cbIVlen;
 
                 //copy TxBufferHeader + MacHeader to desc
-                memcpy(pbyBuffer, (PVOID)psTxBufHd, uLength);
+                memcpy(pbyBuffer, (void *)psTxBufHd, uLength);
 
                 // Copy the Packet into a tx Buffer
                 memcpy((pbyBuffer + uLength),
···
                 //5.Get S/W generate FCS
                 //--------------------
 
-                s_vFillFragParameter(pDevice, pbyBuffer, uDMAIdx, (PVOID)ptdCurr, wFragType, cbReqCount);
+                s_vFillFragParameter(pDevice, pbyBuffer, uDMAIdx, (void *)ptdCurr, wFragType, cbReqCount);
 
                 ptdCurr->pTDInfo->dwReqCount = cbReqCount - uPadding;
                 ptdCurr->pTDInfo->dwHeaderLength = cbHeaderLength;
···
         psTxBufHd->wFragCtl |= (WORD)wFragType;
 
         //Fill FIFO,RrvTime,RTS,and CTS
-        s_vGenerateTxParameter(pDevice, byPktType, (PVOID)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
+        s_vGenerateTxParameter(pDevice, byPktType, (void *)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
                                cbFrameSize, bNeedACK, uDMAIdx, psEthHeader, pDevice->wCurrentRate);
         //Fill DataHead
         uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFrameSize, uDMAIdx, bNeedACK,
···
         uLength = cbHeaderLength + cbMACHdLen + uPadding + cbIVlen + cb802_1_H_len;
 
         //copy TxBufferHeader + MacHeader to desc
-        memcpy(pbyBuffer, (PVOID)psTxBufHd, uLength);
+        memcpy(pbyBuffer, (void *)psTxBufHd, uLength);
 
         // Copy the Packet into a tx Buffer
         memcpy((pbyBuffer + uLength),
···
     PSTxDesc        pFrstTD;
     BYTE            byPktType;
     PBYTE           pbyTxBufferAddr;
-    PVOID           pvRTS;
+    void *          pvRTS;
     PSCTS           pCTS;
-    PVOID           pvTxDataHd;
+    void *          pvTxDataHd;
     UINT            uDuration;
     UINT            cbReqCount;
     PS802_11Header  pMACHeader;
···
     WORD            wTxBufSize;
     UINT            cbMacHdLen;
     SEthernetHeader sEthHeader;
-    PVOID           pvRrvTime;
-    PVOID           pMICHDR;
+    void *          pvRrvTime;
+    void *          pMICHDR;
     PSMgmtObject    pMgmt = pDevice->pMgmt;
     WORD            wCurrentRate = RATE_1M;
 
···
         cbHeaderSize = wTxBufSize + sizeof(SRrvTime_ab) + sizeof(STxDataHead_ab);
     }
 
-    memset((PVOID)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderSize - wTxBufSize));
+    memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderSize - wTxBufSize));
 
     memcpy(&(sEthHeader.abyDstAddr[0]), &(pPacket->p80211Header->sA3.abyAddr1[0]), U_ETHER_ADDR_LEN);
     memcpy(&(sEthHeader.abySrcAddr[0]), &(pPacket->p80211Header->sA3.abyAddr2[0]), U_ETHER_ADDR_LEN);
···
     PSTxDesc        pFrstTD;
     BYTE            byPktType;
     PBYTE           pbyTxBufferAddr;
-    PVOID           pvRTS;
-    PVOID           pvCTS;
-    PVOID           pvTxDataHd;
+    void *          pvRTS;
+    void *          pvCTS;
+    void *          pvTxDataHd;
     UINT            uDuration;
     UINT            cbReqCount;
     PS802_11Header  pMACHeader;
···
     WORD            wTxBufSize;
     UINT            cbMacHdLen;
     SEthernetHeader sEthHeader;
-    PVOID           pvRrvTime;
-    PVOID           pMICHDR;
+    void *          pvRrvTime;
+    void *          pMICHDR;
     PSMgmtObject    pMgmt = pDevice->pMgmt;
     WORD            wCurrentRate = RATE_1M;
     PUWLAN_80211HDR  p80211Header;
···
 
     }
 
-    memset((PVOID)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderSize - wTxBufSize));
+    memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderSize - wTxBufSize));
     memcpy(&(sEthHeader.abyDstAddr[0]), &(p80211Header->sA3.abyAddr1[0]), U_ETHER_ADDR_LEN);
     memcpy(&(sEthHeader.abySrcAddr[0]), &(p80211Header->sA3.abyAddr2[0]), U_ETHER_ADDR_LEN);
     //=========================

drivers/staging/vt6655/ttype.h

···
 
 typedef QWORD *          PQWORD;
 
-typedef void *           PVOID;
-
-// handle declaration
-#ifdef STRICT
 typedef void *HANDLE;
-#else
-typedef PVOID HANDLE;
-#endif
 
 #endif // __TTYPE_H__

drivers/staging/vt6655/vntwifi.c

···
 -*/
 void
 VNTWIFIvSetOPMode (
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     IN WMAC_CONFIG_MODE eOPMode
     )
 {
···
 -*/
 void
 VNTWIFIvSetIBSSParameter (
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     IN WORD  wBeaconPeriod,
     IN WORD  wATIMWindow,
     IN UINT  uChannel
···
 -*/
 PWLAN_IE_SSID
 VNTWIFIpGetCurrentSSID (
-    IN PVOID pMgmtHandle
+    IN void *pMgmtHandle
     )
 {
     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
···
 -*/
 UINT
 VNTWIFIpGetCurrentChannel (
-    IN PVOID pMgmtHandle
+    IN void *pMgmtHandle
     )
 {
     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
···
 -*/
 WORD
 VNTWIFIwGetAssocID (
-    IN PVOID pMgmtHandle
+    IN void *pMgmtHandle
     )
 {
     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
···
 -*/
 void
 VNTWIFIvSetAuthenticationMode (
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     IN WMAC_AUTHENTICATION_MODE eAuthMode
     )
 {
···
 -*/
 void
 VNTWIFIvSetEncryptionMode (
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     IN WMAC_ENCRYPTION_MODE eEncryptionMode
     )
 {
···
 
 BOOL
 VNTWIFIbConfigPhyMode (
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     IN CARD_PHY_TYPE ePhyType
     )
 {
···
 
 void
 VNTWIFIbGetConfigPhyMode (
-    IN  PVOID pMgmtHandle,
-    OUT PVOID pePhyType
+    IN  void *pMgmtHandle,
+    OUT void *pePhyType
     )
 {
     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
···
 
 void
 VNTWIFIvQueryBSSList (
-    IN PVOID    pMgmtHandle,
+    IN void *pMgmtHandle,
     OUT PUINT   puBSSCount,
-    OUT PVOID   *pvFirstBSS
+    OUT void **pvFirstBSS
     )
 {
     UINT            ii = 0;
···
 
 void
 VNTWIFIvGetNextBSS (
-    IN PVOID            pMgmtHandle,
-    IN PVOID            pvCurrentBSS,
-    OUT PVOID           *pvNextBSS
+    IN void *pMgmtHandle,
+    IN void *pvCurrentBSS,
+    OUT void **pvNextBSS
     )
 {
     PKnownBSS       pBSS = (PKnownBSS) pvCurrentBSS;
···
 -*/
 void
 VNTWIFIvUpdateNodeTxCounter(
-    IN PVOID    pMgmtHandle,
+    IN void *pMgmtHandle,
     IN PBYTE    pbyDestAddress,
     IN BOOL     bTxOk,
     IN WORD     wRate,
···
 
 void
 VNTWIFIvGetTxRate(
-    IN PVOID    pMgmtHandle,
+    IN void *pMgmtHandle,
     IN PBYTE    pbyDestAddress,
     OUT PWORD   pwTxDataRate,
     OUT PBYTE   pbyACKRate,
···
 
 BYTE
 VNTWIFIbyGetKeyCypher(
-    IN PVOID    pMgmtHandle,
+    IN void *pMgmtHandle,
     IN BOOL     bGroupKey
     )
 {
···
 /*
 BOOL
 VNTWIFIbInit(
-    IN PVOID    pAdapterHandler,
-    OUT PVOID   *pMgmtHandler
+    IN void *pAdapterHandler,
+    OUT void **pMgmtHandler
     )
 {
 
···
     }
 
     memset(pMgmt, 0, sizeof(SMgmtObject));
-    pMgmt->pAdapter = (PVOID) pAdapterHandler;
+    pMgmt->pAdapter = (void *) pAdapterHandler;
 
     // should initial MAC address abyMACAddr
     for(ii=0;ii<WLAN_BSSID_LEN;ii++) {
···
 
 BOOL
 VNTWIFIbSetPMKIDCache (
-    IN PVOID pMgmtObject,
+    IN void *pMgmtObject,
     IN ULONG ulCount,
-    IN PVOID pPMKIDInfo
+    IN void *pPMKIDInfo
     )
 {
     PSMgmtObject    pMgmt = (PSMgmtObject) pMgmtObject;
···
 
 WORD
 VNTWIFIwGetMaxSupportRate(
-    IN PVOID pMgmtObject
+    IN void *pMgmtObject
     )
 {
     WORD wRate = RATE_54M;
···
 
 void
 VNTWIFIvSet11h (
-    IN PVOID pMgmtObject,
+    IN void *pMgmtObject,
     IN BOOL  b11hEnable
     )
 {
···
 
 BOOL
 VNTWIFIbMeasureReport(
-    IN PVOID pMgmtObject,
+    IN void *pMgmtObject,
     IN BOOL  bEndOfReport,
-    IN PVOID pvMeasureEID,
+    IN void *pvMeasureEID,
     IN BYTE  byReportMode,
     IN BYTE  byBasicMap,
     IN BYTE  byCCAFraction,
···
 
 BOOL
 VNTWIFIbChannelSwitch(
-    IN PVOID pMgmtObject,
+    IN void *pMgmtObject,
     IN BYTE  byNewChannel
     )
 {
···
 /*
 BOOL
 VNTWIFIbRadarPresent(
-    IN PVOID pMgmtObject,
+    IN void *pMgmtObject,
     IN BYTE  byChannel
     )
 {

drivers/staging/vt6655/vntwifi.h

···
 
 void
 VNTWIFIvSetIBSSParameter (
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     IN WORD  wBeaconPeriod,
     IN WORD  wATIMWindow,
     IN UINT  uChannel
···
 
 void
 VNTWIFIvSetOPMode (
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     IN WMAC_CONFIG_MODE eOPMode
     );
 
 PWLAN_IE_SSID
 VNTWIFIpGetCurrentSSID(
-    IN PVOID pMgmtHandle
+    IN void *pMgmtHandle
     );
 
 UINT
 VNTWIFIpGetCurrentChannel(
-    IN PVOID pMgmtHandle
+    IN void *pMgmtHandle
     );
 
 WORD
 VNTWIFIwGetAssocID (
-    IN PVOID pMgmtHandle
+    IN void *pMgmtHandle
     );
 
 BYTE
···
 
 void
 VNTWIFIvSetAuthenticationMode (
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     IN WMAC_AUTHENTICATION_MODE eAuthMode
     );
 
 void
 VNTWIFIvSetEncryptionMode (
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     IN WMAC_ENCRYPTION_MODE eEncryptionMode
     );
 
 
 BOOL
 VNTWIFIbConfigPhyMode(
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     IN CARD_PHY_TYPE ePhyType
     );
 
 void
 VNTWIFIbGetConfigPhyMode(
-    IN  PVOID pMgmtHandle,
-    OUT PVOID pePhyType
+    IN  void *pMgmtHandle,
+    OUT void *pePhyType
     );
 
 void
 VNTWIFIvQueryBSSList(
-    IN PVOID    pMgmtHandle,
+    IN void *pMgmtHandle,
     OUT PUINT   puBSSCount,
-    OUT PVOID   *pvFirstBSS
+    OUT void **pvFirstBSS
     );
 
 
···
 
 void
 VNTWIFIvGetNextBSS (
-    IN PVOID            pMgmtHandle,
-    IN PVOID            pvCurrentBSS,
-    OUT PVOID           *pvNextBSS
+    IN void *pMgmtHandle,
+    IN void *pvCurrentBSS,
+    OUT void **pvNextBSS
     );
 
 
 
 void
 VNTWIFIvUpdateNodeTxCounter(
-    IN PVOID    pMgmtHandle,
+    IN void *pMgmtHandle,
     IN PBYTE    pbyDestAddress,
     IN BOOL     bTxOk,
     IN WORD     wRate,
···
 
 void
 VNTWIFIvGetTxRate(
-    IN PVOID    pMgmtHandle,
+    IN void *pMgmtHandle,
     IN PBYTE    pbyDestAddress,
     OUT PWORD   pwTxDataRate,
     OUT PBYTE   pbyACKRate,
···
 /*
 BOOL
 VNTWIFIbInit(
-    IN PVOID    pAdapterHandler,
-    OUT PVOID   *pMgmtHandler
+    IN void *pAdapterHandler,
+    OUT void **pMgmtHandler
     );
 */
 
 BYTE
 VNTWIFIbyGetKeyCypher(
-    IN PVOID    pMgmtHandle,
+    IN void *pMgmtHandle,
     IN BOOL     bGroupKey
     );
 
···
 
 BOOL
 VNTWIFIbSetPMKIDCache (
-    IN PVOID pMgmtObject,
+    IN void *pMgmtObject,
     IN ULONG ulCount,
-    IN PVOID pPMKIDInfo
+    IN void *pPMKIDInfo
     );
 
 BOOL
 VNTWIFIbCommandRunning (
-    IN PVOID pMgmtObject
+    IN void *pMgmtObject
     );
 
 WORD
 VNTWIFIwGetMaxSupportRate(
-    IN PVOID pMgmtObject
+    IN void *pMgmtObject
     );
 
 // for 802.11h
 void
 VNTWIFIvSet11h (
-    IN PVOID pMgmtObject,
+    IN void *pMgmtObject,
     IN BOOL  b11hEnable
     );
 
 BOOL
 VNTWIFIbMeasureReport(
-    IN PVOID pMgmtObject,
+    IN void *pMgmtObject,
     IN BOOL  bEndOfReport,
-    IN PVOID pvMeasureEID,
+    IN void *pvMeasureEID,
     IN BYTE  byReportMode,
     IN BYTE  byBasicMap,
     IN BYTE  byCCAFraction,
···
 
 BOOL
 VNTWIFIbChannelSwitch(
-    IN PVOID pMgmtObject,
+    IN void *pMgmtObject,
     IN BYTE  byNewChannel
     );
 /*
 BOOL
 VNTWIFIbRadarPresent(
-    IN PVOID pMgmtObject,
+    IN void *pMgmtObject,
     IN BYTE  byChannel
     );
 */

drivers/staging/vt6655/wmgr.c

···
         }
 
 
-        RATEvParseMaxRate((PVOID)pDevice,
+        RATEvParseMaxRate((void *)pDevice,
                            (PWLAN_IE_SUPP_RATES)abyCurrSuppRates,
                            (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRates,
                            FALSE, // do not change our basic rate
···
         }
 
 
-        RATEvParseMaxRate((PVOID)pDevice,
+        RATEvParseMaxRate((void *)pDevice,
                           (PWLAN_IE_SUPP_RATES)abyCurrSuppRates,
                           (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRates,
                            FALSE, // do not change our basic rate
···
             pMgmt->abyCurrExtSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)pBSSList->abyExtSuppRates,
                                                     (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates,
                                                     uRateLen);
-            RATEvParseMaxRate( (PVOID)pDevice,
+            RATEvParseMaxRate( (void *)pDevice,
                                (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
                                (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates,
                                TRUE,
···
                 pMgmt->abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pSuppRates,
                                                         (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
                                                         WLAN_RATES_MAXLEN_11B);
-                RATEvParseMaxRate( (PVOID)pDevice,
+                RATEvParseMaxRate( (void *)pDevice,
                                    (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
                                    NULL,
                                    TRUE,
···
                 pMgmt->abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pSuppRates,
                                                         (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
                                                         WLAN_RATES_MAXLEN_11B);
-                RATEvParseMaxRate( (PVOID)pDevice,
+                RATEvParseMaxRate( (void *)pDevice,
                                    (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
                                    NULL,
                                    TRUE,
···
 
     // set basic rate
 
-    RATEvParseMaxRate((PVOID)pDevice, (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
+    RATEvParseMaxRate((void *)pDevice, (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
                       (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates, TRUE,
                       &wMaxBasicRate, &wMaxSuppRate, &wSuppRate,
                       &byTopCCKBasicRate, &byTopOFDMBasicRate);
···
                 }
             }
 
-            RATEvParseMaxRate((PVOID)pDevice, pItemRates, pItemExtRates, TRUE,
+            RATEvParseMaxRate((void *)pDevice, pItemRates, pItemExtRates, TRUE,
                               &wMaxBasicRate, &wMaxSuppRate, &wSuppRate,
                               &byTopCCKBasicRate, &byTopOFDMBasicRate);
 
···
                                                     (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
                                                     WLAN_RATES_MAXLEN_11B);
             // set basic rate
-            RATEvParseMaxRate((PVOID)pDevice, (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
+            RATEvParseMaxRate((void *)pDevice, (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
                               NULL, TRUE, &wMaxBasicRate, &wMaxSuppRate, &wSuppRate,
                               &byTopCCKBasicRate, &byTopOFDMBasicRate);
 
···
     pDevice->byPreambleType = 0;
     pDevice->wBasicRate = 0;
     // Set Basic Rate
-    CARDbAddBasicRate((PVOID)pDevice, RATE_1M);
+    CARDbAddBasicRate((void *)pDevice, RATE_1M);
     // calculate TSF offset
     // TSF Offset = Received Timestamp TSF - Marked Local's TSF
     CARDbUpdateTSF(pDevice, pCurr->byRxRate, pCurr->qwBSSTimestamp, pCurr->qwLocalTSF);

drivers/staging/vt6655/wmgr.h

···
 typedef struct tagSMgmtObject
 {
 
-    PVOID                   pAdapter;
+    void *                   pAdapter;
     // MAC address
     BYTE                    abyMACAddr[WLAN_ADDR_LEN];
 

drivers/staging/vt6655/wpa2.c

···
 -*/
 UINT
 WPA2uSetIEs(
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     OUT PWLAN_IE_RSN pRSNIEs
     )
 {

drivers/staging/vt6655/wpa2.h

···
 
 UINT
 WPA2uSetIEs(
-    IN PVOID pMgmtHandle,
+    IN void *pMgmtHandle,
     OUT PWLAN_IE_RSN pRSNIEs
     );