RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
                                 "set pairwise key\n");
                        if (!sta) {
-                               RT_ASSERT(false, ("pairwise key withnot"
-                                                 "mac_addr\n"));
+                               RT_ASSERT(false,
+                                         "pairwise key without mac_addr\n");
 
                                err = -EOPNOTSUPP;
                                goto out_unlock;
 
        DBGP_TYPE_MAX
 };
 
-#define RT_ASSERT(_exp, fmt)                                           \
+#define RT_ASSERT(_exp, fmt, ...)                                      \
 do {                                                                   \
        if (!(_exp)) {                                                  \
-               printk(KERN_DEBUG "%s:%s(): ",                          \
-                      KBUILD_MODNAME, __func__);                       \
-               printk fmt;                                             \
+               printk(KERN_DEBUG KBUILD_MODNAME ":%s(): " fmt,         \
+                      __func__, ##__VA_ARGS__);                        \
        }                                                               \
 } while (0)
 
 
 
        err = pci_enable_device(pdev);
        if (err) {
-               RT_ASSERT(false,
-                         ("%s : Cannot enable new PCI device\n",
-                          pci_name(pdev)));
+               RT_ASSERT(false, "%s : Cannot enable new PCI device\n",
+                         pci_name(pdev));
                return err;
        }
 
        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
-                       RT_ASSERT(false, ("Unable to obtain 32bit DMA "
-                                         "for consistent allocations\n"));
+                       RT_ASSERT(false,
+                                 "Unable to obtain 32bit DMA for consistent allocations\n");
                        pci_disable_device(pdev);
                        return -ENOMEM;
                }
                                sizeof(struct rtl_priv), &rtl_ops);
        if (!hw) {
                RT_ASSERT(false,
-                         ("%s : ieee80211 alloc failed\n", pci_name(pdev)));
+                         "%s : ieee80211 alloc failed\n", pci_name(pdev));
                err = -ENOMEM;
                goto fail1;
        }
        /* MEM map */
        err = pci_request_regions(pdev, KBUILD_MODNAME);
        if (err) {
-               RT_ASSERT(false, ("Can't obtain PCI resources\n"));
+               RT_ASSERT(false, "Can't obtain PCI resources\n");
                return err;
        }
 
                        (unsigned long)pci_iomap(pdev,
                        rtlpriv->cfg->bar_id, pmem_len);
        if (rtlpriv->io.pci_mem_start == 0) {
-               RT_ASSERT(false, ("Can't map PCI mem\n"));
+               RT_ASSERT(false, "Can't map PCI mem\n");
                goto fail2;
        }
 
 
        u32 tmp_cmdbuf[2];
 
        if (rtlhal->fw_ready == false) {
-               RT_ASSERT(false, ("return H2C cmd because of Fw "
-                                 "download fail!!!\n"));
+               RT_ASSERT(false,
+                         "return H2C cmd because of Fw download fail!!!\n");
                return;
        }
 
        while (u1b_tmp & BIT(2)) {
                delay--;
                if (delay == 0) {
-                       RT_ASSERT(false, ("8051 reset fail.\n"));
+                       RT_ASSERT(false, "8051 reset fail\n");
                        break;
                }
                udelay(50);
 
 u32 _rtl92c_phy_fw_rf_serial_read(struct ieee80211_hw *hw,
                                  enum radio_path rfpath, u32 offset)
 {
-       RT_ASSERT(false, ("deprecated!\n"));
+       RT_ASSERT(false, "deprecated!\n");
        return 0;
 
 }
                                    enum radio_path rfpath, u32 offset,
                                    u32 data)
 {
-       RT_ASSERT(false, ("deprecated!\n"));
+       RT_ASSERT(false, "deprecated!\n");
 }
 EXPORT_SYMBOL(_rtl92c_phy_fw_rf_serial_write);
 
        if (rtlphy->set_bwmode_inprogress)
                return 0;
        RT_ASSERT((rtlphy->current_channel <= 14),
-                 ("WIRELESS_MODE_G but channel>14"));
+                 "WIRELESS_MODE_G but channel>14\n");
        rtlphy->sw_chnl_inprogress = true;
        rtlphy->sw_chnl_stage = 0;
        rtlphy->sw_chnl_step = 0;
        struct swchnlcmd *pcmd;
 
        if (cmdtable == NULL) {
-               RT_ASSERT(false, ("cmdtable cannot be NULL.\n"));
+               RT_ASSERT(false, "cmdtable cannot be NULL\n");
                return false;
        }
 
        rfdependcmdcnt = 0;
 
        RT_ASSERT((channel >= 1 && channel <= 14),
-                 ("illegal channel for Zebra: %d\n", channel));
+                 "invalid channel for Zebra: %d\n", channel);
 
        _rtl92c_phy_set_sw_chnl_cmdarray(rfdependcmd, rfdependcmdcnt++,
                                         MAX_RFDEPENDCMD_CNT, CMDID_RF_WRITEREG,
 
                rtl_write_dword(rtlpriv, REG_EDCA_VO_PARAM, 0x2f3222);
                break;
        default:
-               RT_ASSERT(false, ("invalid aci: %d !\n", aci));
+               RT_ASSERT(false, "invalid aci: %d !\n", aci);
                break;
        }
 }
 
 
        ret = pci_register_driver(&rtl92ce_driver);
        if (ret)
-               RT_ASSERT(false, (": No device found\n"));
+               RT_ASSERT(false, "No device found\n");
 
        return ret;
 }
 
                        SET_TX_DESC_NEXT_DESC_ADDRESS(pdesc, *(u32 *) val);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR txdesc :%d"
-                                         " not process\n", desc_name));
+                       RT_ASSERT(false, "ERR txdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        } else {
                        SET_RX_DESC_EOR(pdesc, 1);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR rxdesc :%d "
-                                         "not process\n", desc_name));
+                       RT_ASSERT(false, "ERR rxdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        }
                        ret = GET_TX_DESC_TX_BUFFER_ADDRESS(p_desc);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR txdesc :%d "
-                                         "not process\n", desc_name));
+                       RT_ASSERT(false, "ERR txdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        } else {
                        ret = GET_RX_DESC_PKT_LEN(pdesc);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR rxdesc :%d "
-                                         "not process\n", desc_name));
+                       RT_ASSERT(false, "ERR rxdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        }
 
                                                u4b_ac_param);
                                break;
                        default:
-                               RT_ASSERT(false, ("SetHwReg8185(): invalid"
-                                         " aci: %d !\n", e_aci));
+                               RT_ASSERT(false,
+                                         "SetHwReg8185(): invalid aci: %d !\n",
+                                         e_aci);
                                break;
                        }
                        if (rtlusb->acm_method != eAcmWay2_SW)
 
                rtl_write_dword(rtlpriv, REG_EDCA_VO_PARAM, u4b_ac_param);
                break;
        default:
-               RT_ASSERT(false, ("invalid aci: %d !\n", aci));
+               RT_ASSERT(false, "invalid aci: %d !\n", aci);
                break;
        }
 }
 
                break;
        default:
                hw_queue_index = RTL_TXQ_BE;
-               RT_ASSERT(false, ("QSLT_BE queue, skb_queue:%d\n",
-                         mac80211_queue_index));
+               RT_ASSERT(false, "QSLT_BE queue, skb_queue:%d\n",
+                         mac80211_queue_index);
                break;
        }
 out:
 
                udelay(50);
                u1b_tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
        }
-       RT_ASSERT((delay > 0), ("8051 reset failed!\n"));
+       RT_ASSERT((delay > 0), "8051 reset failed!\n");
        RT_TRACE(rtlpriv, COMP_FW, DBG_DMESG,
                 "=====> 8051 reset success (%d)\n", delay);
 }
        u32 tmp_cmdbuf[2];
 
        if (rtlhal->fw_ready == false) {
-               RT_ASSERT(false, ("return H2C cmd because of Fw "
-                                 "download fail!!!\n"));
+               RT_ASSERT(false,
+                         "return H2C cmd because of Fw download fail!!!\n");
                return;
        }
        memset(tmp_cmdbuf, 0, 8);
 
                rtl_write_dword(rtlpriv, REG_EDCA_VO_PARAM, 0x2f3222);
                break;
        default:
-               RT_ASSERT(false, ("invalid aci: %d !\n", aci));
+               RT_ASSERT(false, "invalid aci: %d !\n", aci);
                break;
        }
 }
 
        struct swchnlcmd *pcmd;
 
        if (cmdtable == NULL) {
-               RT_ASSERT(false, ("cmdtable cannot be NULL.\n"));
+               RT_ASSERT(false, "cmdtable cannot be NULL\n");
                return false;
        }
        if (cmdtableidx >= cmdtablesz)
                 * 5G and 2.4G band. */
                if (channel <= 14)
                        return 0;
-               RT_ASSERT((channel > 14), ("5G but channel<=14"));
+               RT_ASSERT((channel > 14), "5G but channel<=14\n");
                break;
        case BAND_ON_2_4G:
                /* Get first channel error when change between
                 * 5G and 2.4G band. */
                if (channel > 14)
                        return 0;
-               RT_ASSERT((channel <= 14), ("2G but channel>14"));
+               RT_ASSERT((channel <= 14), "2G but channel>14\n");
                break;
        default:
-               RT_ASSERT(false,
-                         ("Invalid WirelessMode(%#x)!!\n",
-                          rtlpriv->mac80211.mode));
+               RT_ASSERT(false, "Invalid WirelessMode(%#x)!!\n",
+                         rtlpriv->mac80211.mode);
                break;
        }
        rtlphy->sw_chnl_inprogress = true;
                        }
                }
                if (i == 200)
-                       RT_ASSERT(false, ("Another mac power off over time\n"));
+                       RT_ASSERT(false, "Another mac power off over time\n");
        }
 }
 
 
 
        ret = pci_register_driver(&rtl92de_driver);
        if (ret)
-               RT_ASSERT(false, (": No device found\n"));
+               RT_ASSERT(false, "No device found\n");
        return ret;
 }
 
 
                        SET_TX_DESC_NEXT_DESC_ADDRESS(pdesc, *(u32 *) val);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR txdesc :%d"
-                                         " not process\n", desc_name));
+                       RT_ASSERT(false, "ERR txdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        } else {
                        SET_RX_DESC_EOR(pdesc, 1);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR rxdesc :%d "
-                                         "not process\n", desc_name));
+                       RT_ASSERT(false, "ERR rxdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        }
                        ret = GET_TX_DESC_TX_BUFFER_ADDRESS(p_desc);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR txdesc :%d "
-                                         "not process\n", desc_name));
+                       RT_ASSERT(false, "ERR txdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        } else {
                        ret = GET_RX_DESC_PKT_LEN(pdesc);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR rxdesc :%d "
-                                         "not process\n", desc_name));
+                       RT_ASSERT(false, "ERR rxdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        }
 
                rtl_write_dword(rtlpriv, EDCAPARA_VO, 0x2f3222);
                break;
        default:
-               RT_ASSERT(false, ("invalid aci: %d !\n", aci));
+               RT_ASSERT(false, "invalid aci: %d !\n", aci);
                break;
        }
 }
 
        struct swchnlcmd *pcmd;
 
        if (cmdtable == NULL) {
-               RT_ASSERT(false, ("cmdtable cannot be NULL.\n"));
+               RT_ASSERT(false, "cmdtable cannot be NULL\n");
                return false;
        }
 
        rfdependcmdcnt = 0;
 
        RT_ASSERT((channel >= 1 && channel <= 14),
-                 ("illegal channel for Zebra: %d\n", channel));
+                 "invalid channel for Zebra: %d\n", channel);
 
        _rtl92s_phy_set_sw_chnl_cmdarray(rfdependcmd, rfdependcmdcnt++,
                                         MAX_RFDEPENDCMD_CNT, CMDID_RF_WRITEREG,
 
 
        ret = pci_register_driver(&rtl92se_driver);
        if (ret)
-               RT_ASSERT(false, (": No device found\n"));
+               RT_ASSERT(false, "No device found\n");
 
        return ret;
 }
 
                        SET_TX_DESC_NEXT_DESC_ADDRESS(pdesc, *(u32 *) val);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR txdesc :%d not process\n",
-                                 desc_name));
+                       RT_ASSERT(false, "ERR txdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        } else {
                        SET_RX_STATUS_DESC_EOR(pdesc, 1);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR rxdesc :%d not process\n",
-                                 desc_name));
+                       RT_ASSERT(false, "ERR rxdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        }
                        ret = GET_TX_DESC_TX_BUFFER_ADDRESS(desc);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR txdesc :%d not process\n",
-                                 desc_name));
+                       RT_ASSERT(false, "ERR txdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        } else {
                        ret = GET_RX_STATUS_DESC_PKT_LEN(desc);
                        break;
                default:
-                       RT_ASSERT(false, ("ERR rxdesc :%d not process\n",
-                                 desc_name));
+                       RT_ASSERT(false, "ERR rxdesc :%d not process\n",
+                                 desc_name);
                        break;
                }
        }
 
        hw = ieee80211_alloc_hw(sizeof(struct rtl_priv) +
                                sizeof(struct rtl_usb_priv), &rtl_ops);
        if (!hw) {
-               RT_ASSERT(false, ("%s : ieee80211 alloc failed\n", __func__));
+               RT_ASSERT(false, "ieee80211 alloc failed\n");
                return -ENOMEM;
        }
        rtlpriv = hw->priv;