{
        #ifdef DBG_EXPIRATION_CHK
        DBG_871X(
-               "sta:"MAC_FMT", rssi:%d, rx:"STA_PKTS_FMT", expire_to:%u, %s%ssq_len:%u\n"
+               "sta:%pM, rssi:%d, rx:"STA_PKTS_FMT", expire_to:%u, %s%ssq_len:%u\n"
                , MAC_ARG(psta->hwaddr)
                , psta->rssi_stat.UndecoratedSmoothedPWDB
                /*  STA_RX_PKTS_ARG(psta) */
                                        psta->expire_to = pstapriv->expire_to;
                                        psta->state |= WIFI_STA_ALIVE_CHK_STATE;
 
-                                       /* DBG_871X("alive chk, sta:" MAC_FMT " is at ps mode!\n", MAC_ARG(psta->hwaddr)); */
+                                       /* DBG_871X("alive chk, sta:%pM is at ps mode!\n", MAC_ARG(psta->hwaddr)); */
 
                                        /* to update bcn with tim_bitmap for this station */
                                        pstapriv->tim_bitmap |= BIT(psta->aid);
                        list_del_init(&psta->asoc_list);
                        pstapriv->asoc_list_cnt--;
                        DBG_871X(
-                               "asoc expire "MAC_FMT", state = 0x%x\n",
+                               "asoc expire %pM, state = 0x%x\n",
                                MAC_ARG(psta->hwaddr),
                                psta->state
                        );
                                ) / 2)
                        ) {
                                DBG_871X(
-                                       "%s sta:"MAC_FMT", sleepq_len:%u, free_xmitframe_cnt:%u, asoc_list_cnt:%u, clear sleep_q\n",
+                                       "%s sta:%pM, sleepq_len:%u, free_xmitframe_cnt:%u, asoc_list_cnt:%u, clear sleep_q\n",
                                        __func__,
                                        MAC_ARG(psta->hwaddr),
                                        psta->sleepq_len,
                        psta->keep_alive_trycnt++;
                        if (ret == _SUCCESS) {
                                DBG_871X(
-                                       "asoc check, sta(" MAC_FMT ") is alive\n",
+                                       "asoc check, sta(%pM) is alive\n",
                                        MAC_ARG(psta->hwaddr)
                                        );
                                psta->expire_to = pstapriv->expire_to;
                        }
 
                        psta->keep_alive_trycnt = 0;
-                       DBG_871X(
-                               "asoc expire "MAC_FMT", state = 0x%x\n",
-                               MAC_ARG(psta->hwaddr),
-                               psta->state);
+                       DBG_871X("asoc expire %pM, state = 0x%x\n", MAC_ARG(psta->hwaddr),
+                                psta->state);
                        spin_lock_bh(&pstapriv->asoc_list_lock);
                        if (list_empty(&psta->asoc_list) == false) {
                                list_del_init(&psta->asoc_list);
        struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
        struct __queue  *pacl_node_q = &pacl_list->acl_node_q;
 
-       DBG_871X(
-               "%s(acl_num =%d) =" MAC_FMT "\n",
-               __func__,
-               pacl_list->num,
-               MAC_ARG(addr)
-       );
+       DBG_871X("%s(acl_num =%d) =%pM\n", __func__, pacl_list->num, MAC_ARG(addr));
 
        if ((NUM_ACL - 1) < pacl_list->num)
                return (-1);
        struct __queue  *pacl_node_q = &pacl_list->acl_node_q;
        u8 baddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };    /* Baddr is used for clearing acl_list */
 
-       DBG_871X(
-               "%s(acl_num =%d) =" MAC_FMT "\n",
-               __func__,
-               pacl_list->num,
-               MAC_ARG(addr)
-       );
+       DBG_871X("%s(acl_num =%d) =%pM\n", __func__, pacl_list->num, MAC_ARG(addr));
 
        spin_lock_bh(&(pacl_node_q->lock));
 
        if (psta->flags & WLAN_STA_HT) {
                u16 ht_capab = le16_to_cpu(psta->htpriv.ht_cap.cap_info);
 
-               DBG_871X("HT: STA " MAC_FMT " HT Capabilities "
+               DBG_871X("HT: STA %pM HT Capabilities "
                           "Info: 0x%04x\n", MAC_ARG(psta->hwaddr), ht_capab);
 
                if (psta->no_ht_set) {
                                psta->no_ht_gf_set = 1;
                                pmlmepriv->num_sta_ht_no_gf++;
                        }
-                       DBG_871X("%s STA " MAC_FMT " - no "
+                       DBG_871X("%s STA %pM - no "
                                   "greenfield, num of non-gf stations %d\n",
                                   __func__, MAC_ARG(psta->hwaddr),
                                   pmlmepriv->num_sta_ht_no_gf);
                                psta->ht_20mhz_set = 1;
                                pmlmepriv->num_sta_ht_20mhz++;
                        }
-                       DBG_871X("%s STA " MAC_FMT " - 20 MHz HT, "
+                       DBG_871X("%s STA %pM - 20 MHz HT, "
                                   "num of 20MHz HT STAs %d\n",
                                   __func__, MAC_ARG(psta->hwaddr),
                                   pmlmepriv->num_sta_ht_20mhz);
                        pmlmepriv->num_sta_no_ht++;
                }
                if (pmlmepriv->htpriv.ht_option == true) {
-                       DBG_871X("%s STA " MAC_FMT
-                                  " - no HT, num of non-HT stations %d\n",
+                       DBG_871X("%s STA %pM - no HT, num of non-HT stations %d\n",
                                   __func__, MAC_ARG(psta->hwaddr),
                                   pmlmepriv->num_sta_no_ht);
                }
 
 
        if (!enqueue) {
                while ((cam_id = rtw_camid_search(padapter, sta->hwaddr, -1)) >= 0) {
-                       DBG_871X_LEVEL(_drv_always_, "clear key for addr:"MAC_FMT", camid:%d\n", MAC_ARG(sta->hwaddr), cam_id);
+                       DBG_871X_LEVEL(_drv_always_, "clear key for addr:%pM, camid:%d\n", MAC_ARG(sta->hwaddr), cam_id);
                        clear_cam_entry(padapter, cam_id);
                        rtw_camid_free(padapter, cam_id);
                }
 
                }
        }
 
-       DBG_871X("rtw_macaddr_cfg MAC Address  = "MAC_FMT"\n", MAC_ARG(mac_addr));
+       DBG_871X("rtw_macaddr_cfg MAC Address  = %pM\n", MAC_ARG(mac_addr));
 }
 
 static int rtw_get_cipher_info(struct wlan_network *pnetwork)
 
                                goto release_mlme_lock;/* it means driver is in WIFI_ADHOC_MASTER_STATE, we needn't create bss again. */
                } else {
                        RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("Set BSSID not the same bssid\n"));
-                       RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("set_bssid ="MAC_FMT"\n", MAC_ARG(bssid)));
-                       RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("cur_bssid ="MAC_FMT"\n", MAC_ARG(pmlmepriv->cur_network.network.MacAddress)));
+                       RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("set_bssid =%pM\n", MAC_ARG(bssid)));
+                       RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("cur_bssid =%pM\n", MAC_ARG(pmlmepriv->cur_network.network.MacAddress)));
 
                        rtw_disassoc_cmd(padapter, 0, true);
 
 
 
        #if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) && 1
        if (strcmp(dst->Ssid.Ssid, DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) == 0) {
-               DBG_871X(FUNC_ADPT_FMT" %s("MAC_FMT", ch%u) ss_ori:%3u, sq_ori:%3u, rssi_ori:%3ld, ss_smp:%3u, sq_smp:%3u, rssi_smp:%3ld\n"
+               DBG_871X(FUNC_ADPT_FMT" %s(%pM, ch%u) ss_ori:%3u, sq_ori:%3u, rssi_ori:%3ld, ss_smp:%3u, sq_smp:%3u, rssi_smp:%3ld\n"
                        , FUNC_ADPT_ARG(padapter)
                        , src->Ssid.Ssid, MAC_ARG(src->MacAddress), src->Configuration.DSConfig
                        , ss_ori, sq_ori, rssi_ori
 
        #if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) && 1
        if (strcmp(dst->Ssid.Ssid, DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) == 0) {
-               DBG_871X(FUNC_ADPT_FMT" %s("MAC_FMT"), SignalStrength:%u, SignalQuality:%u, RawRSSI:%ld\n"
+               DBG_871X(FUNC_ADPT_FMT" %s(%pM), SignalStrength:%u, SignalQuality:%u, RawRSSI:%ld\n"
                        , FUNC_ADPT_ARG(padapter)
                        , dst->Ssid.Ssid, MAC_ARG(dst->MacAddress), dst->PhyInfo.SignalStrength, dst->PhyInfo.SignalQuality, dst->Rssi);
        }
        struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
 
        RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+rtw_free_assoc_resources\n"));
-       RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("tgt_network->network.MacAddress ="MAC_FMT" ssid =%s\n",
+       RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("tgt_network->network.MacAddress =%pM ssid =%s\n",
                MAC_ARG(tgt_network->network.MacAddress), tgt_network->network.Ssid.Ssid));
 
        if (check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_AP_STATE)) {
 
        DBG_871X("%s\n", __func__);
 
-       RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("\nfw_state:%x, BSSID:"MAC_FMT"\n"
+       RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("\nfw_state:%x, BSSID:%pM\n"
                , get_fwstate(pmlmepriv), MAC_ARG(pnetwork->network.MacAddress)));
 
        /*  why not use ptarget_wlan?? */
        else
                mac_id = pstadel->mac_id;
 
-       DBG_871X("%s(mac_id =%d) =" MAC_FMT "\n", __func__, mac_id, MAC_ARG(pstadel->macaddr));
+       DBG_871X("%s(mac_id =%d) =%pM\n", __func__, mac_id, MAC_ARG(pstadel->macaddr));
 
        if (mac_id >= 0) {
                u16 media_status;
        if (rtw_is_desired_network(adapter, competitor) == false)
                goto exit;
 
-       DBG_871X("roam candidate:%s %s("MAC_FMT", ch%3u) rssi:%d, age:%5d\n",
+       DBG_871X("roam candidate:%s %s(%pM, ch%3u) rssi:%d, age:%5d\n",
                (competitor == mlme->cur_network_scanned)?"*":" ",
                competitor->network.Ssid.Ssid,
                MAC_ARG(competitor->network.MacAddress),
 
                mlme->pscanned = get_next(mlme->pscanned);
 
-               DBG_871X("%s("MAC_FMT", ch%u) rssi:%d\n"
+               DBG_871X("%s(%pM, ch%u) rssi:%d\n"
                        , pnetwork->network.Ssid.Ssid
                        , MAC_ARG(pnetwork->network.MacAddress)
                        , pnetwork->network.Configuration.DSConfig
                ret = _FAIL;
                goto exit;
        } else {
-               DBG_871X("%s: candidate: %s("MAC_FMT", ch:%u)\n", __func__,
+               DBG_871X("%s: candidate: %s(%pM, ch:%u)\n", __func__,
                        candidate->network.Ssid.Ssid, MAC_ARG(candidate->network.MacAddress),
                        candidate->network.Configuration.DSConfig);
 
        if (updated) {
                DBG_871X("[by_bssid:%u][assoc_ssid:%s]"
                        "[to_roam:%u] "
-                       "new candidate: %s("MAC_FMT", ch%u) rssi:%d\n",
+                       "new candidate: %s(%pM, ch%u) rssi:%d\n",
                        mlme->assoc_by_bssid,
                        mlme->assoc_ssid.Ssid,
                        rtw_to_roam(adapter),
 
                pmlmepriv->pscanned = get_next(pmlmepriv->pscanned);
 
-               DBG_871X("%s("MAC_FMT", ch%u) rssi:%d\n"
+               DBG_871X("%s(%pM, ch%u) rssi:%d\n"
                        , pnetwork->network.Ssid.Ssid
                        , MAC_ARG(pnetwork->network.MacAddress)
                        , pnetwork->network.Configuration.DSConfig
                ret = _FAIL;
                goto exit;
        } else {
-               DBG_871X("%s: candidate: %s("MAC_FMT", ch:%u)\n", __func__,
+               DBG_871X("%s: candidate: %s(%pM, ch:%u)\n", __func__,
                        candidate->network.Ssid.Ssid, MAC_ARG(candidate->network.MacAddress),
                        candidate->network.Configuration.DSConfig);
                goto candidate_exist;
        int do_join_r;
 
        if (0 < rtw_to_roam(padapter)) {
-               DBG_871X("roaming from %s("MAC_FMT"), length:%d\n",
+               DBG_871X("roaming from %s(%pM), length:%d\n",
                                cur_network->network.Ssid.Ssid, MAC_ARG(cur_network->network.MacAddress),
                                cur_network->network.Ssid.SsidLength);
                memcpy(&pmlmepriv->assoc_ssid, &cur_network->network.Ssid, sizeof(struct ndis_802_11_ssid));
 
                        goto _non_rc_device;
 
                if (memcmp(p+6, get_sa(pframe), ETH_ALEN)) {
-                       DBG_871X("%s, do rc pairing ("MAC_FMT"), but mac addr mismatch!("MAC_FMT")\n", __func__,
+                       DBG_871X("%s, do rc pairing (%pM), but mac addr mismatch!(%pM)\n", __func__,
                                MAC_ARG(get_sa(pframe)), MAC_ARG(p+6));
 
                        goto _non_rc_device;
                }
 
-               DBG_871X("%s, got the pairing device("MAC_FMT")\n", __func__,  MAC_ARG(get_sa(pframe)));
+               DBG_871X("%s, got the pairing device(%pM)\n", __func__,  MAC_ARG(get_sa(pframe)));
 
                /* new a station */
                psta = rtw_get_stainfo(pstapriv, get_sa(pframe));
                if (psta == NULL) {
                        /*  allocate a new one */
-                       DBG_871X("going to alloc stainfo for rc ="MAC_FMT"\n",  MAC_ARG(get_sa(pframe)));
+                       DBG_871X("going to alloc stainfo for rc =%pM\n",  MAC_ARG(get_sa(pframe)));
                        psta = rtw_alloc_stainfo(pstapriv, get_sa(pframe));
                        if (!psta) {
                                /* TODO: */
        if (p && ielen > 0) {
                if ((*(p + 1 + ielen) == 0x2D) && (*(p + 2 + ielen) != 0x2D)) {
                        /* Invalid value 0x2D is detected in Extended Supported Rates (ESR) IE. Try to fix the IE length to avoid failed Beacon parsing. */
-                       DBG_871X("[WIFIDBG] Error in ESR IE is detected in Beacon of BSSID:"MAC_FMT". Fix the length of ESR IE to avoid failed Beacon parsing.\n", MAC_ARG(GetAddr3Ptr(pframe)));
+                       DBG_871X("[WIFIDBG] Error in ESR IE is detected in Beacon of BSSID:%pM. Fix the length of ESR IE to avoid failed Beacon parsing.\n", MAC_ARG(GetAddr3Ptr(pframe)));
                        *(p + 1) = ielen - 1;
                }
        }
        if (pstat == NULL) {
 
                /*  allocate a new one */
-               DBG_871X("going to alloc stainfo for sa ="MAC_FMT"\n",  MAC_ARG(sa));
+               DBG_871X("going to alloc stainfo for sa =%pM\n",  MAC_ARG(sa));
                pstat = rtw_alloc_stainfo(pstapriv, sa);
                if (pstat == NULL) {
                        DBG_871X(" Exceed the upper limit of supported clients...\n");
        /* now parse all ieee802_11 ie to point to elems */
        if (rtw_ieee802_11_parse_elems(pos, left, &elems, 1) == ParseFailed ||
            !elems.ssid) {
-               DBG_871X("STA " MAC_FMT " sent invalid association request\n",
+               DBG_871X("STA %pM sent invalid association request\n",
                       MAC_ARG(pstat->hwaddr));
                status = _STATS_FAILURE_;
                goto OnAssocReqFail;
                int copy_len;
 
                if (psecuritypriv->wpa_psk == 0) {
-                       DBG_871X("STA " MAC_FMT ": WPA/RSN IE in association "
+                       DBG_871X("STA %pM: WPA/RSN IE in association "
                        "request, but AP don't support WPA/RSN\n", MAC_ARG(pstat->hwaddr));
 
                        status = WLAN_STATUS_INVALID_IE;
        if ((pstat->flags & WLAN_STA_HT) &&
                    ((pstat->wpa2_pairwise_cipher&WPA_CIPHER_TKIP) ||
                      (pstat->wpa_pairwise_cipher&WPA_CIPHER_TKIP))) {
-               DBG_871X("HT: " MAC_FMT " tried to "
-                                  "use TKIP with HT association\n", MAC_ARG(pstat->hwaddr));
+               DBG_871X("HT: %pM tried to use TKIP with HT association\n", MAC_ARG(pstat->hwaddr));
 
                /* status = WLAN_STATUS_CIPHER_REJECTED_PER_POLICY; */
                /* goto OnAssocReqFail; */
                /* EID[1] + EID_LEN[1] + RC_OUI[4] + MAC[6] + PairingID[2] + ChannelNum[2] */
                u16 cu_ch = (u16)cur_network->Configuration.DSConfig;
 
-               DBG_871X("%s, reply rc(pid = 0x%x) device "MAC_FMT" in ch =%d\n", __func__,
+               DBG_871X("%s, reply rc(pid = 0x%x) device %pM in ch =%d\n", __func__,
                        psta->pid, MAC_ARG(psta->hwaddr), cu_ch);
 
                /* append vendor specific ie */
 
        if (try_cnt && wait_ms) {
                if (da)
-                       DBG_871X(FUNC_ADPT_FMT" to "MAC_FMT", ch:%u%s, %d/%d in %u ms\n",
+                       DBG_871X(FUNC_ADPT_FMT" to %pM, ch:%u%s, %d/%d in %u ms\n",
                                FUNC_ADPT_ARG(padapter), MAC_ARG(da), rtw_get_oper_ch(padapter),
                                ret == _SUCCESS?", acked":"", i, try_cnt, (i + 1) * wait_ms);
                else
                else
                        rtw_hal_macid_wakeup(padapter, psta->mac_id);
        } else {
-               DBG_871X(FUNC_ADPT_FMT ": Can't find sta info for " MAC_FMT ", skip macid %s!!\n",
+               DBG_871X(FUNC_ADPT_FMT ": Can't find sta info for %pM, skip macid %s!!\n",
                        FUNC_ADPT_ARG(padapter), MAC_ARG(da), power_mode?"sleep":"wakeup");
                rtw_warn_on(1);
        }
 
        if (try_cnt && wait_ms) {
                if (da)
-                       DBG_871X(FUNC_ADPT_FMT" to "MAC_FMT", ch:%u%s, %d/%d in %u ms\n",
+                       DBG_871X(FUNC_ADPT_FMT" to %pM, ch:%u%s, %d/%d in %u ms\n",
                                FUNC_ADPT_ARG(padapter), MAC_ARG(da), rtw_get_oper_ch(padapter),
                                ret == _SUCCESS?", acked":"", i, try_cnt, (i + 1) * wait_ms);
                else
 
        if (try_cnt && wait_ms) {
                if (da)
-                       DBG_871X(FUNC_ADPT_FMT" to "MAC_FMT", ch:%u%s, %d/%d in %u ms\n",
+                       DBG_871X(FUNC_ADPT_FMT" to %pM, ch:%u%s, %d/%d in %u ms\n",
                                FUNC_ADPT_ARG(padapter), MAC_ARG(da), rtw_get_oper_ch(padapter),
                                ret == _SUCCESS?", acked":"", i, try_cnt, (i + 1) * wait_ms);
                else
        int ret = _FAIL;
        __le16 le_tmp;
 
-       /* DBG_871X("%s to "MAC_FMT"\n", __func__, MAC_ARG(da)); */
+       /* DBG_871X("%s to %pM\n", __func__, MAC_ARG(da)); */
 
        pmgntframe = alloc_mgtxmitframe(pxmitpriv);
        if (pmgntframe == NULL) {
 
 int issue_deauth(struct adapter *padapter, unsigned char *da, unsigned short reason)
 {
-       DBG_871X("%s to "MAC_FMT"\n", __func__, MAC_ARG(da));
+       DBG_871X("%s to %pM\n", __func__, MAC_ARG(da));
        return _issue_deauth(padapter, da, reason, false);
 }
 
 
        if (try_cnt && wait_ms) {
                if (da)
-                       DBG_871X(FUNC_ADPT_FMT" to "MAC_FMT", ch:%u%s, %d/%d in %u ms\n",
+                       DBG_871X(FUNC_ADPT_FMT" to %pM, ch:%u%s, %d/%d in %u ms\n",
                                FUNC_ADPT_ARG(padapter), MAC_ARG(da), rtw_get_oper_ch(padapter),
                                ret == _SUCCESS?", acked":"", i, try_cnt, (i + 1) * wait_ms);
                else
 
        #if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) & 1
        if (strcmp(bssid->Ssid.Ssid, DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) == 0) {
-               DBG_871X("Receiving %s("MAC_FMT", DSConfig:%u) from ch%u with ss:%3u, sq:%3u, RawRSSI:%3ld\n"
+               DBG_871X("Receiving %s(%pM, DSConfig:%u) from ch%u with ss:%3u, sq:%3u, RawRSSI:%3ld\n"
                        , bssid->Ssid.Ssid, MAC_ARG(bssid->MacAddress), bssid->Configuration.DSConfig
                        , rtw_get_oper_ch(padapter)
                        , bssid->PhyInfo.SignalStrength, bssid->PhyInfo.SignalQuality, bssid->Rssi
                if ((pmlmeinfo->state&0x03) == WIFI_FW_STATION_STATE) {
                        rtw_hal_get_def_var(padapter, HAL_DEF_UNDERCORATEDSMOOTHEDPWDB, &UndecoratedSmoothedPWDB);
 
-                       DBG_871X("AP[" MAC_FMT "] - UndecoratedSmoothedPWDB:%d\n",
+                       DBG_871X("AP[%pM] - UndecoratedSmoothedPWDB:%d\n",
                                MAC_ARG(padapter->mlmepriv.cur_network.network.MacAddress), UndecoratedSmoothedPWDB);
                } else if ((pmlmeinfo->state&0x03) == _HW_STATE_AP_) {
                        struct list_head        *phead, *plist;
                                psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
                                plist = get_next(plist);
 
-                               DBG_871X("STA[" MAC_FMT "]:UndecoratedSmoothedPWDB:%d\n",
+                               DBG_871X("STA[%pM]:UndecoratedSmoothedPWDB:%d\n",
                                        MAC_ARG(psta->hwaddr), psta->rssi_stat.UndecoratedSmoothedPWDB);
                        }
                        spin_unlock_bh(&pstapriv->asoc_list_lock);
 
                ctrl = BIT(15) | BIT6 | ((pparm->algorithm) << 2) | pparm->keyid;
                write_cam(padapter, cam_id, ctrl, addr, pparm->key);
-               DBG_871X_LEVEL(_drv_always_, "set group key camid:%d, addr:"MAC_FMT", kid:%d, type:%s\n"
+               DBG_871X_LEVEL(_drv_always_, "set group key camid:%d, addr:%pM, kid:%d, type:%s\n"
                        , cam_id, MAC_ARG(addr), pparm->keyid, security_type_str(pparm->algorithm));
        }
 
 
        psta = rtw_get_stainfo(pstapriv, pparm->addr);
        if (!psta) {
-               DBG_871X_LEVEL(_drv_always_, "%s sta:"MAC_FMT" not found\n", __func__, MAC_ARG(pparm->addr));
+               DBG_871X_LEVEL(_drv_always_, "%s sta:%pM not found\n", __func__, MAC_ARG(pparm->addr));
                ret = H2C_REJECTED;
                goto exit;
        }
 write_to_cam:
        if (pparm->algorithm == _NO_PRIVACY_) {
                while ((cam_id = rtw_camid_search(padapter, pparm->addr, -1)) >= 0) {
-                       DBG_871X_LEVEL(_drv_always_, "clear key for addr:"MAC_FMT", camid:%d\n", MAC_ARG(pparm->addr), cam_id);
+                       DBG_871X_LEVEL(_drv_always_, "clear key for addr:%pM, camid:%d\n", MAC_ARG(pparm->addr), cam_id);
                        clear_cam_entry(padapter, cam_id);
                        rtw_camid_free(padapter, cam_id);
                }
        } else {
-               DBG_871X_LEVEL(_drv_always_, "set pairwise key camid:%d, addr:"MAC_FMT", kid:%d, type:%s\n",
+               DBG_871X_LEVEL(_drv_always_, "set pairwise key camid:%d, addr:%pM, kid:%d, type:%s\n",
                        cam_id, MAC_ARG(pparm->addr), pparm->keyid, security_type_str(pparm->algorithm));
                ctrl = BIT(15) | ((pparm->algorithm) << 2) | pparm->keyid;
                write_cam(padapter, cam_id, ctrl, pparm->addr, pparm->key);
 
                if (!memcmp(myhwaddr, pattrib->src, ETH_ALEN)) {
                        RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, (" SA ==myself\n"));
                        #ifdef DBG_RX_DROP_FRAME
-                       DBG_871X("DBG_RX_DROP_FRAME %s SA ="MAC_FMT", myhwaddr ="MAC_FMT"\n",
+                       DBG_871X("DBG_RX_DROP_FRAME %s SA =%pM, myhwaddr =%pM\n",
                                __func__, MAC_ARG(pattrib->src), MAC_ARG(myhwaddr));
                        #endif
                        ret = _FAIL;
                /*  da should be for me */
                if ((memcmp(myhwaddr, pattrib->dst, ETH_ALEN)) && (!bmcast)) {
                        RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
-                               (" ap2sta_data_frame:  compare DA fail; DA ="MAC_FMT"\n", MAC_ARG(pattrib->dst)));
+                               (" ap2sta_data_frame:  compare DA fail; DA =%pM\n", MAC_ARG(pattrib->dst)));
                        #ifdef DBG_RX_DROP_FRAME
-                       DBG_871X("DBG_RX_DROP_FRAME %s DA ="MAC_FMT"\n", __func__, MAC_ARG(pattrib->dst));
+                       DBG_871X("DBG_RX_DROP_FRAME %s DA =%pM\n", __func__, MAC_ARG(pattrib->dst));
                        #endif
                        ret = _FAIL;
                        goto exit;
                     !memcmp(mybssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) ||
                     (memcmp(pattrib->bssid, mybssid, ETH_ALEN))) {
                        RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
-                               (" ap2sta_data_frame:  compare BSSID fail ; BSSID ="MAC_FMT"\n", MAC_ARG(pattrib->bssid)));
-                       RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("mybssid ="MAC_FMT"\n", MAC_ARG(mybssid)));
+                               (" ap2sta_data_frame:  compare BSSID fail ; BSSID =%pM\n", MAC_ARG(pattrib->bssid)));
+                       RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("mybssid =%pM\n", MAC_ARG(mybssid)));
                        #ifdef DBG_RX_DROP_FRAME
-                       DBG_871X("DBG_RX_DROP_FRAME %s BSSID ="MAC_FMT", mybssid ="MAC_FMT"\n",
+                       DBG_871X("DBG_RX_DROP_FRAME %s BSSID =%pM, mybssid =%pM\n",
                                __func__, MAC_ARG(pattrib->bssid), MAC_ARG(mybssid));
                        DBG_871X("this adapter = %d, buddy adapter = %d\n", adapter->adapter_type, adapter->pbuddystruct adapter->adapter_type);
                        #endif
 
                        if (!bmcast) {
-                               DBG_871X("issue_deauth to the nonassociated ap =" MAC_FMT " for the reason(7)\n", MAC_ARG(pattrib->bssid));
+                               DBG_871X("issue_deauth to the nonassociated ap =%pM for the reason(7)\n", MAC_ARG(pattrib->bssid));
                                issue_deauth(adapter, pattrib->bssid, WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
                        }
 
                                if (jiffies_to_msecs(jiffies - send_issue_deauth_time) > 10000 || send_issue_deauth_time == 0) {
                                        send_issue_deauth_time = jiffies;
 
-                                       DBG_871X("issue_deauth to the ap =" MAC_FMT " for the reason(7)\n", MAC_ARG(pattrib->bssid));
+                                       DBG_871X("issue_deauth to the ap =%pM for the reason(7)\n", MAC_ARG(pattrib->bssid));
 
                                        issue_deauth(adapter, pattrib->bssid, WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
                                }
                *psta = rtw_get_stainfo(pstapriv, pattrib->src);
                if (!*psta) {
                        RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, ("can't get psta under AP_MODE; drop pkt\n"));
-                       DBG_871X("issue_deauth to sta =" MAC_FMT " for the reason(7)\n", MAC_ARG(pattrib->src));
+                       DBG_871X("issue_deauth to sta =%pM for the reason(7)\n", MAC_ARG(pattrib->src));
 
                        issue_deauth(adapter, pattrib->src, WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
 
                        ret = RTW_RX_HANDLED;
                        goto exit;
                }
-               DBG_871X("issue_deauth to sta =" MAC_FMT " for the reason(7)\n", MAC_ARG(pattrib->src));
+               DBG_871X("issue_deauth to sta =%pM for the reason(7)\n", MAC_ARG(pattrib->src));
                issue_deauth(adapter, pattrib->src, WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
                ret = RTW_RX_HANDLED;
                goto exit;
 
                        rx_pid = *(u16 *)(ptr+rmv_len+2);
 
-                       DBG_871X("wlan rx(pid = 0x%x): sta("MAC_FMT") pid = 0x%x\n",
+                       DBG_871X("wlan rx(pid = 0x%x): sta(%pM) pid = 0x%x\n",
                                rx_pid, MAC_ARG(psta->hwaddr), psta->pid);
 
                        if (rx_pid == psta->pid) {
 
        }
 
        if (addr)
-               DBG_871X(FUNC_ADPT_FMT" addr:"MAC_FMT" kid:%d, return cam_id:%d\n"
+               DBG_871X(FUNC_ADPT_FMT" addr:%pM kid:%d, return cam_id:%d\n"
                         , FUNC_ADPT_ARG(adapter), MAC_ARG(addr), kid, cam_id);
        else
                DBG_871X(FUNC_ADPT_FMT" addr:%p kid:%d, return cam_id:%d\n"
 
                if (i == TOTAL_CAM_ENTRY) {
                        if (sta)
-                               DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" pairwise key with "MAC_FMT" id:%u no room\n"
+                               DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" pairwise key with %pM id:%u no room\n"
                                , FUNC_ADPT_ARG(adapter), MAC_ARG(sta->hwaddr), kid);
                        else
                                DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" group key id:%u no room\n"
        }
 
        if (memcmp(cur_network->network.MacAddress, pbssid, 6)) {
-               DBG_871X("Oops: rtw_check_network_encrypt linked but recv other bssid bcn\n" MAC_FMT MAC_FMT,
+               DBG_871X("Oops: rtw_check_network_encrypt linked but recv other bssid bcn %pM %pM\n",
                                MAC_ARG(pbssid), MAC_ARG(cur_network->network.MacAddress));
                return true;
        }
 
                psta = rtw_get_stainfo(pstapriv, pattrib->ra);
                if (!psta)      { /*  if we cannot get psta => drop the pkt */
                        DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_ucast_sta);
-                       RT_TRACE(_module_rtl871x_xmit_c_, _drv_alert_, ("\nupdate_attrib => get sta_info fail, ra:" MAC_FMT"\n", MAC_ARG(pattrib->ra)));
+                       RT_TRACE(_module_rtl871x_xmit_c_, _drv_alert_, ("\nupdate_attrib => get sta_info fail, ra:%pM\n", MAC_ARG(pattrib->ra)));
                        #ifdef DBG_TX_DROP_FRAME
-                       DBG_871X("DBG_TX_DROP_FRAME %s get sta_info fail, ra:" MAC_FMT"\n", __func__, MAC_ARG(pattrib->ra));
+                       DBG_871X("DBG_TX_DROP_FRAME %s get sta_info fail, ra:%pM\n", __func__, MAC_ARG(pattrib->ra));
                        #endif
                        res = _FAIL;
                        goto exit;
        if (!psta) {
                /*  if we cannot get psta => drop the pkt */
                DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_sta);
-               RT_TRACE(_module_rtl871x_xmit_c_, _drv_alert_, ("\nupdate_attrib => get sta_info fail, ra:" MAC_FMT "\n", MAC_ARG(pattrib->ra)));
+               RT_TRACE(_module_rtl871x_xmit_c_, _drv_alert_, ("\nupdate_attrib => get sta_info fail, ra:%pM\n", MAC_ARG(pattrib->ra)));
                #ifdef DBG_TX_DROP_FRAME
-               DBG_871X("DBG_TX_DROP_FRAME %s get sta_info fail, ra:" MAC_FMT"\n", __func__, MAC_ARG(pattrib->ra));
+               DBG_871X("DBG_TX_DROP_FRAME %s get sta_info fail, ra:%pM\n", __func__, MAC_ARG(pattrib->ra));
                #endif
                res = _FAIL;
                goto exit;
 
        if (!(psta->state & _FW_LINKED)) {
                DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_link);
-               DBG_871X("%s, psta("MAC_FMT")->state(0x%x) != _FW_LINKED\n", __func__, MAC_ARG(psta->hwaddr), psta->state);
+               DBG_871X("%s, psta(%pM)->state(0x%x) != _FW_LINKED\n", __func__, MAC_ARG(psta->hwaddr), psta->state);
                return _FAIL;
        }
 
 
        {
                SET_ARP_PKT_TARGET_MAC_ADDR(pARPRspPkt, get_my_bssid(&(pmlmeinfo->network)));
                SET_ARP_PKT_TARGET_IP_ADDR(pARPRspPkt, pIPAddress);
-               DBG_871X("%s Target Mac Addr:" MAC_FMT "\n", __func__, MAC_ARG(get_my_bssid(&(pmlmeinfo->network))));
+               DBG_871X("%s Target Mac Addr:%pM\n", __func__, MAC_ARG(get_my_bssid(&(pmlmeinfo->network))));
                DBG_871X("%s Target IP Addr" IP_FMT "\n", __func__, IP_ARG(pIPAddress));
        }
 
        memcpy(pwlanhdr->addr2, mac, ETH_ALEN);
        memcpy(pwlanhdr->addr3, bssid, ETH_ALEN);
 
-       DBG_871X("%s FW Mac Addr:" MAC_FMT "\n", __func__, MAC_ARG(mac));
+       DBG_871X("%s FW Mac Addr:%pM\n", __func__, MAC_ARG(mac));
        DBG_871X("%s FW IP Addr" IP_FMT "\n", __func__, IP_ARG(StaAddr));
 
        SetSeqNum(pwlanhdr, 0);
 
 
 #define DEFAULT_MAX_SCAN_AGE (15 * HZ)
 #define DEFAULT_FTS 2346
-#define MAC_FMT "%pM"
 #define MAC_ARG(x) (x)
 #define IP_FMT "%pI4"
 #define IP_ARG(x) (x)
 
 
 #define _RND(sz, r) ((((sz)+((r)-1))/(r))*(r))
 
-#ifndef MAC_FMT
-#define MAC_FMT "%pM"
-#endif
 #ifndef MAC_ARG
 #define MAC_ARG(x) (x)
 #endif
 
                                /* DBG_871X(FUNC_ADPT_FMT" inform success !!\n", FUNC_ADPT_ARG(padapter)); */
                        }
                } else {
-                       DBG_871X("scanned: %s("MAC_FMT"), cur: %s("MAC_FMT")\n",
+                       DBG_871X("scanned: %s(%pM), cur: %s(%pM)\n",
                                scanned->network.Ssid.Ssid, MAC_ARG(scanned->network.MacAddress),
                                pnetwork->Ssid.Ssid, MAC_ARG(pnetwork->MacAddress)
                        );
        }
 
 #ifdef DEBUG_CFG80211
-       DBG_871X(FUNC_NDEV_FMT" mac ="MAC_FMT"\n", FUNC_NDEV_ARG(ndev), MAC_ARG(mac));
+       DBG_871X(FUNC_NDEV_FMT" mac =%pM\n", FUNC_NDEV_ARG(ndev), MAC_ARG(mac));
 #endif
 
        /* for infra./P2PClient mode */
                struct wlan_network  *cur_network = &(pmlmepriv->cur_network);
 
                if (memcmp((u8 *)mac, cur_network->network.MacAddress, ETH_ALEN)) {
-                       DBG_871X("%s, mismatch bssid ="MAC_FMT"\n", __func__, MAC_ARG(cur_network->network.MacAddress));
+                       DBG_871X("%s, mismatch bssid =%pM\n", __func__, MAC_ARG(cur_network->network.MacAddress));
                        ret = -ENOENT;
                        goto exit;
                }
 
 
        if (sme->bssid)
-               DBG_8192C("bssid ="MAC_FMT"\n", MAC_ARG(sme->bssid));
+               DBG_8192C("bssid =%pM\n", MAC_ARG(sme->bssid));
 
 
        if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true) {
                        goto fail;
                }
 
-               DBG_8192C("RTW_Tx:da ="MAC_FMT" via "FUNC_NDEV_FMT"\n",
+               DBG_8192C("RTW_Tx:da =%pM via "FUNC_NDEV_FMT"\n",
                        MAC_ARG(GetAddr1Ptr(buf)), FUNC_NDEV_ARG(ndev));
                if (category == RTW_WLAN_CATEGORY_PUBLIC)
                        DBG_871X("RTW_Tx:%s\n", action_public_str(action));
        }
 
 
-       DBG_8192C("free sta macaddr =" MAC_FMT "\n", MAC_ARG(mac));
+       DBG_8192C("free sta macaddr =%pM\n", MAC_ARG(mac));
 
        if (mac[0] == 0xff && mac[1] == 0xff &&
            mac[2] == 0xff && mac[3] == 0xff &&
                goto exit;
        }
 
-       DBG_8192C("RTW_Tx:tx_ch =%d, da ="MAC_FMT"\n", tx_ch, MAC_ARG(GetAddr1Ptr(buf)));
+       DBG_8192C("RTW_Tx:tx_ch =%d, da =%pM\n", tx_ch, MAC_ARG(GetAddr1Ptr(buf)));
        if (category == RTW_WLAN_CATEGORY_PUBLIC)
                DBG_871X("RTW_Tx:%s\n", action_public_str(action));
        else
 
 
 
                if (!memcmp(bssid, pnetwork->network.MacAddress, ETH_ALEN)) { /* BSSID match, then check if supporting wpa/wpa2 */
-                       DBG_871X("BSSID:" MAC_FMT "\n", MAC_ARG(bssid));
+                       DBG_871X("BSSID:%pM\n", MAC_ARG(bssid));
 
                        pbuf = rtw_get_wpa_ie(&pnetwork->network.IEs[12], &wpa_ielen, pnetwork->network.IELength-12);
                        if (pbuf && (wpa_ielen > 0)) {
                                                struct recv_reorder_ctrl *preorder_ctrl;
 
                                                DBG_871X("SSID =%s\n", cur_network->network.Ssid.Ssid);
-                                               DBG_871X("sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
+                                               DBG_871X("sta's macaddr:%pM\n", MAC_ARG(psta->hwaddr));
                                                DBG_871X("cur_channel =%d, cur_bwmode =%d, cur_ch_offset =%d\n", pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
                                                DBG_871X("rtsen =%d, cts2slef =%d\n", psta->rtsen, psta->cts2self);
                                                DBG_871X("state = 0x%x, aid =%d, macid =%d, raid =%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
                                                }
 
                                        } else {
-                                               DBG_871X("can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
+                                               DBG_871X("can't get sta's macaddr, cur_network's macaddr:%pM\n", MAC_ARG(cur_network->network.MacAddress));
                                        }
                                        break;
                                case 0x06:
                                                                plist = get_next(plist);
 
                                                                if (extra_arg == psta->aid) {
-                                                                       DBG_871X("sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
+                                                                       DBG_871X("sta's macaddr:%pM\n", MAC_ARG(psta->hwaddr));
                                                                        DBG_871X("rtsen =%d, cts2slef =%d\n", psta->rtsen, psta->cts2self);
                                                                        DBG_871X("state = 0x%x, aid =%d, macid =%d, raid =%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
                                                                        DBG_871X("qos_en =%d, ht_en =%d, init_rate =%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
        struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
        struct sta_priv *pstapriv = &padapter->stapriv;
 
-       DBG_871X("rtw_add_sta(aid =%d) =" MAC_FMT "\n", param->u.add_sta.aid, MAC_ARG(param->sta_addr));
+       DBG_871X("rtw_add_sta(aid =%d) =%pM\n", param->u.add_sta.aid, MAC_ARG(param->sta_addr));
 
        if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
                return -EINVAL;
        struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
        struct sta_priv *pstapriv = &padapter->stapriv;
 
-       DBG_871X("rtw_del_sta =" MAC_FMT "\n", MAC_ARG(param->sta_addr));
+       DBG_871X("rtw_del_sta =%pM\n", MAC_ARG(param->sta_addr));
 
        if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
                return -EINVAL;
        struct ieee_param_ex *param_ex = (struct ieee_param_ex *)param;
        struct sta_data *psta_data = (struct sta_data *)param_ex->data;
 
-       DBG_871X("rtw_ioctl_get_sta_info, sta_addr: " MAC_FMT "\n", MAC_ARG(param_ex->sta_addr));
+       DBG_871X("rtw_ioctl_get_sta_info, sta_addr: %pM\n", MAC_ARG(param_ex->sta_addr));
 
        if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
                return -EINVAL;
        struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
        struct sta_priv *pstapriv = &padapter->stapriv;
 
-       DBG_871X("rtw_get_sta_wpaie, sta_addr: " MAC_FMT "\n", MAC_ARG(param->sta_addr));
+       DBG_871X("rtw_get_sta_wpaie, sta_addr: %pM\n", MAC_ARG(param->sta_addr));
 
        if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
                return -EINVAL;
 
                goto error_register_netdev;
        }
 
-       DBG_871X("%s, MAC Address (if%d) = " MAC_FMT "\n", __func__, (padapter->iface_id + 1), MAC_ARG(pnetdev->dev_addr));
+       DBG_871X("%s, MAC Address (if%d) = %pM\n", __func__, (padapter->iface_id + 1), MAC_ARG(pnetdev->dev_addr));
 
        return ret;
 
                        goto netdev_open_error;
                }
 
-               DBG_871X("MAC Address = " MAC_FMT "\n", MAC_ARG(pnetdev->dev_addr));
+               DBG_871X("MAC Address = %pM\n", MAC_ARG(pnetdev->dev_addr));
 
                status = rtw_start_drv_threads(padapter);
                if (status == _FAIL) {
        if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
                if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)
                        && check_fwstate(pmlmepriv, _FW_LINKED)) {
-                       DBG_871X("%s %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n", __func__,
+                       DBG_871X("%s %s(%pM), length:%d assoc_ssid.length:%d\n", __func__,
                                        pmlmepriv->cur_network.network.Ssid.Ssid,
                                        MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
                                        pmlmepriv->cur_network.network.Ssid.SsidLength,
                padapter->HalFunc.SetHwRegHandler(padapter, HW_VAR_WOWLAN, (u8 *)&poidparam);
                if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
                        if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED)) {
-                               DBG_871X("%s %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n", __func__,
+                               DBG_871X("%s %s(%pM), length:%d assoc_ssid.length:%d\n", __func__,
                                                pmlmepriv->cur_network.network.Ssid.Ssid,
                                                MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
                                                pmlmepriv->cur_network.network.Ssid.SsidLength,
 
 
                rx_pid = *(u16*)(skb->data+ETH_HLEN);
 
-               DBG_871X("eth rx(pid = 0x%x): sta("MAC_FMT") pid = 0x%x\n",
+               DBG_871X("eth rx(pid = 0x%x): sta(%pM) pid = 0x%x\n",
                        rx_pid, MAC_ARG(psta->hwaddr), psta->pid);
 
                if (rx_pid == psta->pid) {