//
 #ifdef TO_DO_LIST
        if (Adapter->ResetProgress == RESET_TYPE_NORESET) {
-               if (pMgntInfo->RegRfOff == TRUE) { /* User disable RF via registry. */
+               if (pMgntInfo->RegRfOff == true) { /* User disable RF via registry. */
                        RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RegRfOff ----------\n"));
                        MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_SW);
                        // Those actions will be discard in MgntActSet_RF_State because of the same state
                u8 tmpvalue;
                read_nic_byte(dev, 0x301, &tmpvalue);
                if (tmpvalue == 0x03) {
-                       priv->bDcut = TRUE;
+                       priv->bDcut = true;
                        RT_TRACE(COMP_POWER_TRACKING, "D-cut\n");
                } else {
-                       priv->bDcut = FALSE;
+                       priv->bDcut = false;
                        RT_TRACE(COMP_POWER_TRACKING, "C-cut\n");
                }
                dm_initialize_txpower_tracking(dev);
 
-               if (priv->bDcut == TRUE) {
+               if (priv->bDcut == true) {
                        u32 i, TempCCk;
                        u32 tmpRegA = rtl8192_QueryBBReg(dev, rOFDM0_XATxIQImbalance, bMaskDWord);
                        for (i = 0; i < TxBBGainTableLength; i++) {
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
        u16             RegTxCounter;
-       bool            bStuck = FALSE;
+       bool            bStuck = false;
        read_nic_word(dev, 0x128, &RegTxCounter);
        RT_TRACE(COMP_RESET, "%s():RegTxCounter is %d,TxCounter is %d\n", __func__, RegTxCounter, priv->TxCounter);
        if (priv->TxCounter == RegTxCounter)
-               bStuck = TRUE;
+               bStuck = true;
 
        priv->TxCounter = RegTxCounter;
 
 {
        u16     RegRxCounter;
        struct r8192_priv *priv = ieee80211_priv(dev);
-       bool bStuck = FALSE;
+       bool bStuck = false;
        static u8       rx_chk_cnt;
        read_nic_word(dev, 0x130, &RegRxCounter);
        RT_TRACE(COMP_RESET, "%s(): RegRxCounter is %d,RxCounter is %d\n", __func__, RegRxCounter, priv->RxCounter);
        }
 
        if (priv->RxCounter == RegRxCounter)
-               bStuck = TRUE;
+               bStuck = true;
 
        priv->RxCounter = RegRxCounter;
 
 static RESET_TYPE RxCheckStuck(struct net_device *dev)
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
-       bool        bRxCheck = FALSE;
+       bool        bRxCheck = false;
 
        if (priv->IrpPendingCount > 1)
-               bRxCheck = TRUE;
+               bRxCheck = true;
 
        if (bRxCheck) {
                if (HalRxCheckStuck819xUsb(dev)) {
        struct net_device *dev = info->dev;
        struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
        bool bpacket_match_bssid, bpacket_toself;
-       bool bPacketBeacon = FALSE, bToSelfBA = FALSE;
+       bool bPacketBeacon = false, bToSelfBA = false;
        static struct ieee80211_rx_stats  previous_stats;
        struct ieee80211_hdr_3addr *hdr;//by amy
        u16 fc, type;
 
 static void dm_TXPowerTrackingCallback_TSSI(struct net_device *dev)
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
-       bool                                            bHighpowerstate, viviflag = FALSE;
+       bool                                            bHighpowerstate, viviflag = false;
        DCMD_TXCMD_T                    tx_cmd;
        u8                                              powerlevelOFDM24G;
        int                                             i = 0, j = 0, k = 0;
                        /* check if the report value is right */
                        for (k = 0; k < 5; k++) {
                                if (tmp_report[k] <= 20) {
-                                       viviflag = TRUE;
+                                       viviflag = true;
                                        break;
                                }
                        }
-                       if (viviflag == TRUE) {
+                       if (viviflag == true) {
                                write_nic_byte(dev, 0x1ba, 0);
-                               viviflag = FALSE;
+                               viviflag = false;
                                RT_TRACE(COMP_POWER_TRACKING, "we filtered the data\n");
                                for (k = 0; k < 5; k++)
                                        tmp_report[k] = 0;
                                delta = TSSI_13dBm - Avg_TSSI_Meas_from_driver;
 
                        if (delta <= E_FOR_TX_POWER_TRACK) {
-                               priv->ieee80211->bdynamic_txpower_enable = TRUE;
+                               priv->ieee80211->bdynamic_txpower_enable = true;
                                write_nic_byte(dev, 0x1ba, 0);
                                RT_TRACE(COMP_POWER_TRACKING, "tx power track is done\n");
                                RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex = %d\n", priv->rfa_txpowertrackingindex);
 
                        if (priv->cck_present_attentuation > -1 && priv->cck_present_attentuation < 23) {
                                if (priv->ieee80211->current_network.channel == 14 && !priv->bcck_in_ch14) {
-                                       priv->bcck_in_ch14 = TRUE;
+                                       priv->bcck_in_ch14 = true;
                                        dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
                                } else if (priv->ieee80211->current_network.channel != 14 && priv->bcck_in_ch14) {
-                                       priv->bcck_in_ch14 = FALSE;
+                                       priv->bcck_in_ch14 = false;
                                        dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
                                } else
                                        dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
                        RT_TRACE(COMP_POWER_TRACKING, "priv->cck_present_attentuation = %d\n", priv->cck_present_attentuation);
 
                        if (priv->cck_present_attentuation_difference <= -12 || priv->cck_present_attentuation_difference >= 24) {
-                               priv->ieee80211->bdynamic_txpower_enable = TRUE;
+                               priv->ieee80211->bdynamic_txpower_enable = true;
                                write_nic_byte(dev, 0x1ba, 0);
                                RT_TRACE(COMP_POWER_TRACKING, "tx power track--->limited\n");
                                return;
                        break;
                }
        }
-       priv->ieee80211->bdynamic_txpower_enable = TRUE;
+       priv->ieee80211->bdynamic_txpower_enable = true;
        write_nic_byte(dev, 0x1ba, 0);
 }
 
                                break;
                        }
                }
-               priv->btxpower_trackingInit = TRUE;
+               priv->btxpower_trackingInit = true;
                /*pHalData->TXPowercount = 0;*/
                return;
        }
                tmpCCKindex = tmpCCK20Mindex;
 
        if (priv->ieee80211->current_network.channel == 14 && !priv->bcck_in_ch14) {
-               priv->bcck_in_ch14 = TRUE;
+               priv->bcck_in_ch14 = true;
                CCKSwingNeedUpdate = 1;
        } else if (priv->ieee80211->current_network.channel != 14 && priv->bcck_in_ch14) {
-               priv->bcck_in_ch14 = FALSE;
+               priv->bcck_in_ch14 = false;
                CCKSwingNeedUpdate = 1;
        }
 
        struct r8192_priv *priv = container_of(dwork, struct r8192_priv, txpower_tracking_wq);
        struct net_device *dev = priv->ieee80211->dev;
 
-       if (priv->bDcut == TRUE)
+       if (priv->bDcut == true)
                dm_TXPowerTrackingCallback_TSSI(dev);
        else
                dm_TXPowerTrackingCallback_ThermalMeter(dev);
        priv->cck_txbbgain_ch14_table[22].ccktxbb_valuearray[6] = 0x00;
        priv->cck_txbbgain_ch14_table[22].ccktxbb_valuearray[7] = 0x00;
 
-       priv->btxpower_tracking = TRUE;
+       priv->btxpower_tracking = true;
        priv->txpower_count       = 0;
-       priv->btxpower_trackingInit = FALSE;
+       priv->btxpower_trackingInit = false;
 
 }
 
         * 3-wire by driver causes RF to go into a wrong state.
         */
        if (priv->ieee80211->FwRWRF)
-               priv->btxpower_tracking = TRUE;
+               priv->btxpower_tracking = true;
        else
-               priv->btxpower_tracking = FALSE;
+               priv->btxpower_tracking = false;
        priv->txpower_count       = 0;
-       priv->btxpower_trackingInit = FALSE;
+       priv->btxpower_trackingInit = false;
 }
 
 void dm_initialize_txpower_tracking(struct net_device *dev)
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
 
-       if (priv->bDcut == TRUE)
+       if (priv->bDcut == true)
                dm_InitializeTXPowerTracking_TSSI(dev);
        else
                dm_InitializeTXPowerTracking_ThermalMeter(dev);
 #ifdef RTL8190P
        dm_CheckTXPowerTracking_TSSI(dev);
 #else
-       if (priv->bDcut == TRUE)
+       if (priv->bDcut == true)
                dm_CheckTXPowerTracking_TSSI(dev);
        else
                dm_CheckTXPowerTracking_ThermalMeter(dev);
 {      /*  dm_CCKTxPowerAdjust */
        struct r8192_priv *priv = ieee80211_priv(dev);
 
-       if (priv->bDcut == TRUE)
+       if (priv->bDcut == true)
                dm_CCKTxPowerAdjust_TSSI(dev, binch14);
        else
                dm_CCKTxPowerAdjust_ThermalMeter(dev, binch14);
 {
        struct r8192_priv *priv = ieee80211_priv((struct net_device *)dev);
 
-       priv->ieee80211->bCTSToSelfEnable = TRUE;
+       priv->ieee80211->bCTSToSelfEnable = true;
        priv->ieee80211->CTSToSelfTH = CTSToSelfTHVal;
 }
 
        unsigned long                                           curTxOkCnt = 0;
        unsigned long                                           curRxOkCnt = 0;
 
-       if (priv->ieee80211->bCTSToSelfEnable != TRUE) {
+       if (priv->ieee80211->bCTSToSelfEnable != true) {
                pHTInfo->IOTAction &= ~HT_IOT_ACT_FORCED_CTS2SELF;
                return;
        }
 
 
 CPUCheckMainCodeOKAndTurnOnCPU_Fail:
        RT_TRACE(COMP_ERR, "ERR in %s()\n", __func__);
-       rt_status = FALSE;
+       rt_status = false;
        return rt_status;
 }
 
 bool init_firmware(struct net_device *dev)
 {
        struct r8192_priv       *priv = ieee80211_priv(dev);
-       bool                    rt_status = TRUE;
+       bool                    rt_status = true;
 
        u32                     file_length = 0;
        u8                      *mapped_file = NULL;
                if (rst_opt == OPT_SYSTEM_RESET)
                        release_firmware(fw_entry);
 
-               if (rt_status != TRUE)
+               if (rt_status != true)
                        goto download_firmware_fail;
 
                switch (init_step) {
 
                        /* Check Put Code OK and Turn On CPU */
                        rt_status = CPUcheck_maincodeok_turnonCPU(dev);
-                       if (rt_status != TRUE) {
+                       if (rt_status != true) {
                                RT_TRACE(COMP_ERR, "CPUcheck_maincodeok_turnonCPU fail!\n");
                                goto download_firmware_fail;
                        }
                        mdelay(1);
 
                        rt_status = CPUcheck_firmware_ready(dev);
-                       if (rt_status != TRUE) {
+                       if (rt_status != true) {
                                RT_TRACE(COMP_ERR, "CPUcheck_firmware_ready fail(%d)!\n",rt_status);
                                goto download_firmware_fail;
                        }
 
 download_firmware_fail:
        RT_TRACE(COMP_ERR, "ERR in %s()\n", __func__);
-       rt_status = FALSE;
+       rt_status = false;
        return rt_status;
 
 }