u8 rssi_step;
        u8 rssi;
 
-       scan = rtw_flag_check(rtwdev, RTW_FLAG_SCANNING);
+       scan = test_bit(RTW_FLAG_SCANNING, rtwdev->flags);
        coex_stat->wl_connected = !!rtwdev->sta_cnt;
-       coex_stat->wl_gl_busy = rtw_flag_check(rtwdev, RTW_FLAG_BUSY_TRAFFIC);
+       coex_stat->wl_gl_busy = test_bit(RTW_FLAG_BUSY_TRAFFIC, rtwdev->flags);
 
        if (stats->tx_throughput > stats->rx_throughput)
                coex_stat->wl_tput_dir = COEX_WL_TPUT_TX;
 
        rtwdev->h2c.last_box_num = 0;
        rtwdev->h2c.seq = 0;
 
-       rtw_flag_set(rtwdev, RTW_FLAG_FW_RUNNING);
+       set_bit(RTW_FLAG_FW_RUNNING, rtwdev->flags);
 
        return 0;
 
 
        struct rtw_dev *rtwdev = hw->priv;
        struct rtw_tx_pkt_info pkt_info = {0};
 
-       if (!rtw_flag_check(rtwdev, RTW_FLAG_RUNNING))
+       if (!test_bit(RTW_FLAG_RUNNING, rtwdev->flags))
                goto out;
 
        rtw_tx_pkt_info_update(rtwdev, &pkt_info, control, skb);
 
        rtw_coex_scan_notify(rtwdev, COEX_SCAN_START);
 
-       rtw_flag_set(rtwdev, RTW_FLAG_DIG_DISABLE);
-       rtw_flag_set(rtwdev, RTW_FLAG_SCANNING);
+       set_bit(RTW_FLAG_DIG_DISABLE, rtwdev->flags);
+       set_bit(RTW_FLAG_SCANNING, rtwdev->flags);
 
        mutex_unlock(&rtwdev->mutex);
 }
 
        mutex_lock(&rtwdev->mutex);
 
-       rtw_flag_clear(rtwdev, RTW_FLAG_SCANNING);
-       rtw_flag_clear(rtwdev, RTW_FLAG_DIG_DISABLE);
+       clear_bit(RTW_FLAG_SCANNING, rtwdev->flags);
+       clear_bit(RTW_FLAG_DIG_DISABLE, rtwdev->flags);
 
        ether_addr_copy(rtwvif->mac_addr, vif->addr);
        config |= PORT_SET_MAC_ADDR;
 
        struct rtw_dev *rtwdev = container_of(work, struct rtw_dev,
                                              watch_dog_work.work);
        struct rtw_watch_dog_iter_data data = {};
-       bool busy_traffic = rtw_flag_check(rtwdev, RTW_FLAG_BUSY_TRAFFIC);
+       bool busy_traffic = test_bit(RTW_FLAG_BUSY_TRAFFIC, rtwdev->flags);
 
-       if (!rtw_flag_check(rtwdev, RTW_FLAG_RUNNING))
+       if (!test_bit(RTW_FLAG_RUNNING, rtwdev->flags))
                return;
 
        ieee80211_queue_delayed_work(rtwdev->hw, &rtwdev->watch_dog_work,
                                     RTW_WATCH_DOG_DELAY_TIME);
 
        if (rtwdev->stats.tx_cnt > 100 || rtwdev->stats.rx_cnt > 100)
-               rtw_flag_set(rtwdev, RTW_FLAG_BUSY_TRAFFIC);
+               set_bit(RTW_FLAG_BUSY_TRAFFIC, rtwdev->flags);
        else
-               rtw_flag_clear(rtwdev, RTW_FLAG_BUSY_TRAFFIC);
+               clear_bit(RTW_FLAG_BUSY_TRAFFIC, rtwdev->flags);
 
-       if (busy_traffic != rtw_flag_check(rtwdev, RTW_FLAG_BUSY_TRAFFIC))
+       if (busy_traffic != test_bit(RTW_FLAG_BUSY_TRAFFIC, rtwdev->flags))
                rtw_coex_wl_status_change_notify(rtwdev);
 
        /* reset tx/rx statictics */
            data.rtwvif && !data.active && data.assoc_cnt == 1)
                rtw_enter_lps(rtwdev, data.rtwvif);
 
-       if (rtw_flag_check(rtwdev, RTW_FLAG_SCANNING))
+       if (test_bit(RTW_FLAG_SCANNING, rtwdev->flags))
                return;
 
        rtw_phy_dynamic_mechanism(rtwdev);
        if (hal->current_band_type == RTW_BAND_5G) {
                rtw_coex_switchband_notify(rtwdev, COEX_SWITCH_TO_5G);
        } else {
-               if (rtw_flag_check(rtwdev, RTW_FLAG_SCANNING))
+               if (test_bit(RTW_FLAG_SCANNING, rtwdev->flags))
                        rtw_coex_switchband_notify(rtwdev, COEX_SWITCH_TO_24G);
                else
                        rtw_coex_switchband_notify(rtwdev, COEX_SWITCH_TO_24G_NOFORSCAN);
        ieee80211_queue_delayed_work(rtwdev->hw, &rtwdev->watch_dog_work,
                                     RTW_WATCH_DOG_DELAY_TIME);
 
-       rtw_flag_set(rtwdev, RTW_FLAG_RUNNING);
+       set_bit(RTW_FLAG_RUNNING, rtwdev->flags);
 
        return 0;
 }
 {
        struct rtw_coex *coex = &rtwdev->coex;
 
-       rtw_flag_clear(rtwdev, RTW_FLAG_RUNNING);
-       rtw_flag_clear(rtwdev, RTW_FLAG_FW_RUNNING);
+       clear_bit(RTW_FLAG_RUNNING, rtwdev->flags);
+       clear_bit(RTW_FLAG_FW_RUNNING, rtwdev->flags);
 
        cancel_delayed_work_sync(&rtwdev->watch_dog_work);
        cancel_delayed_work_sync(&coex->bt_relink_work);
 
 
 #include "hci.h"
 
-static inline bool rtw_flag_check(struct rtw_dev *rtwdev, enum rtw_flags flag)
-{
-       return test_bit(flag, rtwdev->flags);
-}
-
-static inline void rtw_flag_clear(struct rtw_dev *rtwdev, enum rtw_flags flag)
-{
-       clear_bit(flag, rtwdev->flags);
-}
-
-static inline void rtw_flag_set(struct rtw_dev *rtwdev, enum rtw_flags flag)
-{
-       set_bit(flag, rtwdev->flags);
-}
-
 static inline bool rtw_is_assoc(struct rtw_dev *rtwdev)
 {
        return !!rtwdev->sta_cnt;
 
        u8 step[3];
        bool linked;
 
-       if (rtw_flag_check(rtwdev, RTW_FLAG_DIG_DISABLE))
+       if (test_bit(RTW_FLAG_DIG_DISABLE, rtwdev->flags))
                return;
 
        if (rtw_phy_dig_check_damping(dm_info))
 
                rtw_err(rtwdev, "leave idle state failed\n");
 
        rtw_set_channel(rtwdev);
-       rtw_flag_clear(rtwdev, RTW_FLAG_INACTIVE_PS);
+       clear_bit(RTW_FLAG_INACTIVE_PS, rtwdev->flags);
 
        return ret;
 }
 
 int rtw_enter_ips(struct rtw_dev *rtwdev)
 {
-       rtw_flag_set(rtwdev, RTW_FLAG_INACTIVE_PS);
+       set_bit(RTW_FLAG_INACTIVE_PS, rtwdev->flags);
 
        rtw_coex_ips_notify(rtwdev, COEX_IPS_ENTER);
 
        conf->smart_ps = 0;
 
        rtw_fw_set_pwr_mode(rtwdev);
-       rtw_flag_clear(rtwdev, RTW_FLAG_LEISURE_PS);
+       clear_bit(RTW_FLAG_LEISURE_PS, rtwdev->flags);
 
        rtw_coex_lps_notify(rtwdev, COEX_LPS_DISABLE);
 }
        rtw_coex_lps_notify(rtwdev, COEX_LPS_ENABLE);
 
        rtw_fw_set_pwr_mode(rtwdev);
-       rtw_flag_set(rtwdev, RTW_FLAG_LEISURE_PS);
+       set_bit(RTW_FLAG_LEISURE_PS, rtwdev->flags);
 }
 
 void rtw_lps_work(struct work_struct *work)
 
 bool rtw_in_lps(struct rtw_dev *rtwdev)
 {
-       return rtw_flag_check(rtwdev, RTW_FLAG_LEISURE_PS);
+       return test_bit(RTW_FLAG_LEISURE_PS, rtwdev->flags);
 }
 
 void rtw_enter_lps(struct rtw_dev *rtwdev, struct rtw_vif *rtwvif)