rtlwifi: Convert RT_TRACE macro to use ##__VA_ARGS__

Consolidate printks to avoid possible message interleaving
and reduce the object size.

Remove unnecessary RT_TRACE parentheses.

Miscellaneous typo and grammar fixes.
Add missing newlines to formats.
Remove duplicate KERN_DEBUG prefixes.
Coalesce formats.
Align arguments.

$ size drivers/net/wireless/rtlwifi/built-in.o*
   text    data     bss     dec     hex filename
 594841   55333  129680  779854   be64e drivers/net/wireless/rtlwifi/built-in.o.new
 607022   55333  138720  801075   c3933 drivers/net/wireless/rtlwifi/built-in.o.old

Signed-off-by: Joe Perches <joe@perches.com>
Acked-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 87 insertions, 95 deletions

diff --git a/drivers/net/wireless/rtlwifi/rtl8192ce/hw.c b/drivers/net/wireless/rtlwifi/rtl8192ce/hw.c
index 2156378de1e8..4aa228fe96e9 100644
--- a/drivers/net/wireless/rtlwifi/rtl8192ce/hw.c
+++ b/drivers/net/wireless/rtlwifi/rtl8192ce/hw.c
@@ -141,7 +141,7 @@ void rtl92ce_get_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
                 }
         default:
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
-                         ("switch case not process\n"));
+                         "switch case not processed\n");
                 break;
         }
 }
@@ -207,7 +207,7 @@ void rtl92ce_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
                         u8 e_aci;
 
                         RT_TRACE(rtlpriv, COMP_MLME, DBG_LOUD,
-                                 ("HW_VAR_SLOT_TIME %x\n", val[0]));
+                                 "HW_VAR_SLOT_TIME %x\n", val[0]);
 
                         rtl_write_byte(rtlpriv, REG_SLOT, val[0]);
 
@@ -246,8 +246,8 @@ void rtl92ce_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
                                 *val = min_spacing_to_set;
 
                                 RT_TRACE(rtlpriv, COMP_MLME, DBG_LOUD,
-                                         ("Set HW_VAR_AMPDU_MIN_SPACE: %#x\n",
-                                          mac->min_space_cfg));
+                                         "Set HW_VAR_AMPDU_MIN_SPACE: %#x\n",
+                                         mac->min_space_cfg);
 
                                 rtl_write_byte(rtlpriv, REG_AMPDU_MIN_SPACE,
                                                mac->min_space_cfg);
@@ -261,8 +261,8 @@ void rtl92ce_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
                         mac->min_space_cfg |= (density_to_set << 3);
 
                         RT_TRACE(rtlpriv, COMP_MLME, DBG_LOUD,
-                                 ("Set HW_VAR_SHORTGI_DENSITY: %#x\n",
-                                  mac->min_space_cfg));
+                                 "Set HW_VAR_SHORTGI_DENSITY: %#x\n",
+                                 mac->min_space_cfg);
 
                         rtl_write_byte(rtlpriv, REG_AMPDU_MIN_SPACE,
                                        mac->min_space_cfg);
@@ -310,8 +310,8 @@ void rtl92ce_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
                                 }
 
                                 RT_TRACE(rtlpriv, COMP_MLME, DBG_LOUD,
-                                         ("Set HW_VAR_AMPDU_FACTOR: %#x\n",
-                                          factor_toset));
+                                         "Set HW_VAR_AMPDU_FACTOR: %#x\n",
+                                         factor_toset);
                         }
                         break;
                 }
@@ -348,8 +348,8 @@ void rtl92ce_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
                                         break;
                                 default:
                                         RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
-                                                 ("HW_VAR_ACM_CTRL acm set "
-                                                  "failed: eACI is %d\n", acm));
+                                                 "HW_VAR_ACM_CTRL acm set failed: eACI is %d\n",
+                                                 acm);
                                         break;
                                 }
                         } else {
@@ -365,14 +365,14 @@ void rtl92ce_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
                                         break;
                                 default:
                                         RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
-                                                 ("switch case not process\n"));
+                                                 "switch case not processed\n");
                                         break;
                                 }
                         }
 
                         RT_TRACE(rtlpriv, COMP_QOS, DBG_TRACE,
-                                 ("SetHwReg8190pci(): [HW_VAR_ACM_CTRL] "
-                                  "Write 0x%X\n", acm_ctrl));
+                                 "SetHwReg8190pci(): [HW_VAR_ACM_CTRL] Write 0x%X\n",
+                                 acm_ctrl);
                         rtl_write_byte(rtlpriv, REG_ACMHWCTRL, acm_ctrl);
                         break;
                 }
@@ -507,8 +507,8 @@ void rtl92ce_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
 
                 }
         default:
-                RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, ("switch case "
-                                                        "not process\n"));
+                RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
+                         "switch case not processed\n");
                 break;
         }
 }
@@ -530,8 +530,8 @@ static bool _rtl92ce_llt_write(struct ieee80211_hw *hw, u32 address, u32 data)
 
                 if (count > POLLING_LLT_THRESHOLD) {
                         RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
-                                 ("Failed to polling write LLT done at "
-                                  "address %d!\n", address));
+                                 "Failed to polling write LLT done at address %d!\n",
+                                 address);
                         status = false;
                         break;
                 }
@@ -669,18 +669,15 @@ static bool _rtl92ce_init_mac(struct ieee80211_hw *hw)
         udelay(2);
 
         retry = 0;
-        RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, ("reg0xec:%x:%x\n",
-                                                rtl_read_dword(rtlpriv, 0xEC),
-                                                bytetmp));
+        RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "reg0xec:%x:%x\n",
+                 rtl_read_dword(rtlpriv, 0xEC), bytetmp);
 
         while ((bytetmp & BIT(0)) && retry < 1000) {
                 retry++;
                 udelay(50);
                 bytetmp = rtl_read_byte(rtlpriv, REG_APS_FSMCO + 1);
-                RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, ("reg0xec:%x:%x\n",
-                                                        rtl_read_dword(rtlpriv,
-                                                                       0xEC),
-                                                        bytetmp));
+                RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "reg0xec:%x:%x\n",
+                         rtl_read_dword(rtlpriv, 0xEC), bytetmp);
                 udelay(50);
         }
 
@@ -864,13 +861,13 @@ void rtl92ce_enable_hw_security_config(struct ieee80211_hw *hw)
         u8 sec_reg_value;
 
         RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
-                 ("PairwiseEncAlgorithm = %d GroupEncAlgorithm = %d\n",
-                  rtlpriv->sec.pairwise_enc_algorithm,
-                  rtlpriv->sec.group_enc_algorithm));
+                 "PairwiseEncAlgorithm = %d GroupEncAlgorithm = %d\n",
+                 rtlpriv->sec.pairwise_enc_algorithm,
+                 rtlpriv->sec.group_enc_algorithm);
 
         if (rtlpriv->cfg->mod_params->sw_crypto || rtlpriv->sec.use_sw_sec) {
-                RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, ("not open "
-                                                        "hw encryption\n"));
+                RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
+                         "not open hw encryption\n");
                 return;
         }
 
@@ -886,7 +883,7 @@ void rtl92ce_enable_hw_security_config(struct ieee80211_hw *hw)
         rtl_write_byte(rtlpriv, REG_CR + 1, 0x02);
 
         RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
-                 ("The SECR-value %x\n", sec_reg_value));
+                 "The SECR-value %x\n", sec_reg_value);
 
         rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_WPA_CONFIG, &sec_reg_value);
 
@@ -910,7 +907,7 @@ int rtl92ce_hw_init(struct ieee80211_hw *hw)
         rtlpriv->intf_ops->disable_aspm(hw);
         rtstatus = _rtl92ce_init_mac(hw);
         if (rtstatus != true) {
-                RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, ("Init MAC failed\n"));
+                RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Init MAC failed\n");
                 err = 1;
                 return err;
         }
@@ -918,8 +915,7 @@ int rtl92ce_hw_init(struct ieee80211_hw *hw)
         err = rtl92c_download_fw(hw);
         if (err) {
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
-                         ("Failed to download FW. Init HW "
-                          "without FW now..\n"));
+                         "Failed to download FW. Init HW without FW now..\n");
                 err = 1;
                 rtlhal->fw_ready = false;
                 return err;
@@ -968,12 +964,12 @@ int rtl92ce_hw_init(struct ieee80211_hw *hw)
         tmp_u1b = efuse_read_1byte(hw, 0x1FA);
         if (!(tmp_u1b & BIT(0))) {
                 rtl_set_rfreg(hw, RF90_PATH_A, 0x15, 0x0F, 0x05);
-                RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE, ("PA BIAS path A\n"));
+                RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE, "PA BIAS path A\n");
         }
 
         if (!(tmp_u1b & BIT(1)) && is92c) {
                 rtl_set_rfreg(hw, RF90_PATH_B, 0x15, 0x0F, 0x05);
-                RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE, ("PA BIAS path B\n"));
+                RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE, "PA BIAS path B\n");
         }
 
         if (!(tmp_u1b & BIT(4))) {
@@ -982,7 +978,7 @@ int rtl92ce_hw_init(struct ieee80211_hw *hw)
                 rtl_write_byte(rtlpriv, 0x16, tmp_u1b | 0x80);
                 udelay(10);
                 rtl_write_byte(rtlpriv, 0x16, tmp_u1b | 0x90);
-                RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE, ("under 1.5V\n"));
+                RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE, "under 1.5V\n");
         }
         rtl92c_dm_init(hw);
         rtlpci->being_init_adapter = false;
@@ -1008,23 +1004,23 @@ static enum version_8192c _rtl92ce_read_chip_version(struct ieee80211_hw *hw)
         switch (version) {
         case VERSION_B_CHIP_92C:
                 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
-                         ("Chip Version ID: VERSION_B_CHIP_92C.\n"));
+                         "Chip Version ID: VERSION_B_CHIP_92C\n");
                 break;
         case VERSION_B_CHIP_88C:
                 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
-                         ("Chip Version ID: VERSION_B_CHIP_88C.\n"));
+                         "Chip Version ID: VERSION_B_CHIP_88C\n");
                 break;
         case VERSION_A_CHIP_92C:
                 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
-                         ("Chip Version ID: VERSION_A_CHIP_92C.\n"));
+                         "Chip Version ID: VERSION_A_CHIP_92C\n");
                 break;
         case VERSION_A_CHIP_88C:
                 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
-                         ("Chip Version ID: VERSION_A_CHIP_88C.\n"));
+                         "Chip Version ID: VERSION_A_CHIP_88C\n");
                 break;
         default:
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
-                         ("Chip Version ID: Unknown. Bug?\n"));
+                         "Chip Version ID: Unknown. Bug?\n");
                 break;
         }
 
@@ -1041,13 +1037,12 @@ static enum version_8192c _rtl92ce_read_chip_version(struct ieee80211_hw *hw)
         default:
                 rtlphy->rf_type = RF_1T1R;
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
-                         ("ERROR RF_Type is set!!"));
+                         "ERROR RF_Type is set!!\n");
                 break;
         }
 
-        RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
-                 ("Chip RF Type: %s\n", (rtlphy->rf_type == RF_2T2R) ?
-                  "RF_2T2R" : "RF_1T1R"));
+        RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "Chip RF Type: %s\n",
+                 rtlphy->rf_type == RF_2T2R ? "RF_2T2R" : "RF_1T1R");
 
         return version;
 }
@@ -1069,8 +1064,8 @@ static int _rtl92ce_set_media_status(struct ieee80211_hw *hw,
                 _rtl92ce_disable_bcn_sub_func(hw);
         } else {
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
-                         ("Set HW_VAR_MEDIA_STATUS: "
-                          "No such media status(%x).\n", type));
+                         "Set HW_VAR_MEDIA_STATUS: No such media status(%x)\n",
+                         type);
         }
 
         switch (type) {
@@ -1078,27 +1073,27 @@ static int _rtl92ce_set_media_status(struct ieee80211_hw *hw,
                 bt_msr |= MSR_NOLINK;
                 ledaction = LED_CTL_LINK;
                 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
-                         ("Set Network type to NO LINK!\n"));
+                         "Set Network type to NO LINK!\n");
                 break;
         case NL80211_IFTYPE_ADHOC:
                 bt_msr |= MSR_ADHOC;
                 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
-                         ("Set Network type to Ad Hoc!\n"));
+                         "Set Network type to Ad Hoc!\n");
                 break;
         case NL80211_IFTYPE_STATION:
                 bt_msr |= MSR_INFRA;
                 ledaction = LED_CTL_LINK;
                 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
-                         ("Set Network type to STA!\n"));
+                         "Set Network type to STA!\n");
                 break;
         case NL80211_IFTYPE_AP:
                 bt_msr |= MSR_AP;
                 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
-                         ("Set Network type to AP!\n"));
+                         "Set Network type to AP!\n");
                 break;
         default:
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
-                         ("Network type %d not support!\n", type));
+                         "Network type %d not supported!\n", type);
                 return 1;
                 break;
 
@@ -1300,7 +1295,7 @@ void rtl92ce_set_beacon_interval(struct ieee80211_hw *hw)
         u16 bcn_interval = mac->beacon_interval;
 
         RT_TRACE(rtlpriv, COMP_BEACON, DBG_DMESG,
-                 ("beacon_interval:%d\n", bcn_interval));
+                 "beacon_interval:%d\n", bcn_interval);
         rtl92ce_disable_interrupt(hw);
         rtl_write_word(rtlpriv, REG_BCN_INTERVAL, bcn_interval);
         rtl92ce_enable_interrupt(hw);
@@ -1312,8 +1307,8 @@ void rtl92ce_update_interrupt_mask(struct ieee80211_hw *hw,
         struct rtl_priv *rtlpriv = rtl_priv(hw);
         struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
 
-        RT_TRACE(rtlpriv, COMP_INTR, DBG_LOUD,
-                 ("add_msr:%x, rm_msr:%x\n", add_msr, rm_msr));
+        RT_TRACE(rtlpriv, COMP_INTR, DBG_LOUD, "add_msr:%x, rm_msr:%x\n",
+                 add_msr, rm_msr);
 
         if (add_msr)
                 rtlpci->irq_mask[0] |= add_msr;
@@ -1567,7 +1562,7 @@ static void _rtl92ce_read_adapter_info(struct ieee80211_hw *hw)
                        HWSET_MAX_SIZE);
         } else if (rtlefuse->epromtype == EEPROM_93C46) {
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
-                         ("RTL819X Not boot from eeprom, check it !!"));
+                         "RTL819X Not boot from eeprom, check it !!");
         }
 
         RT_PRINT_DATA(rtlpriv, COMP_INIT, DBG_DMESG, "MAP",
@@ -1576,10 +1571,10 @@ static void _rtl92ce_read_adapter_info(struct ieee80211_hw *hw)
         eeprom_id = *((u16 *)&hwinfo[0]);
         if (eeprom_id != RTL8190_EEPROM_ID) {
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
-                         ("EEPROM ID(%#x) is invalid!!\n", eeprom_id));
+                         "EEPROM ID(%#x) is invalid!!\n", eeprom_id);
                 rtlefuse->autoload_failflag = true;
         } else {
-                RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, ("Autoload OK\n"));
+                RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n");
                 rtlefuse->autoload_failflag = false;
         }
 
@@ -1591,8 +1586,7 @@ static void _rtl92ce_read_adapter_info(struct ieee80211_hw *hw)
                 *((u16 *) (&rtlefuse->dev_addr[i])) = usvalue;
         }
 
-        RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
-                 ("%pM\n", rtlefuse->dev_addr));
+        RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "%pM\n", rtlefuse->dev_addr);
 
         _rtl92ce_read_txpower_info_from_hwpg(hw,
                                              rtlefuse->autoload_failflag,
@@ -1608,7 +1602,7 @@ static void _rtl92ce_read_adapter_info(struct ieee80211_hw *hw)
         rtlefuse->eeprom_oemid = *(u8 *)&hwinfo[EEPROM_CUSTOMER_ID];
 
         RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
-                 ("EEPROM Customer ID: 0x%2x\n", rtlefuse->eeprom_oemid));
+                 "EEPROM Customer ID: 0x%2x\n", rtlefuse->eeprom_oemid);
 
         /* set channel paln to world wide 13 */
         rtlefuse->channel_plan = COUNTRY_CODE_WORLD_WIDE_13;
@@ -1662,7 +1656,7 @@ static void _rtl92ce_hal_customized_behavior(struct ieee80211_hw *hw)
                 break;
         }
         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
-                 ("RT Customized ID: 0x%02X\n", rtlhal->oem_id));
+                 "RT Customized ID: 0x%02X\n", rtlhal->oem_id);
 }
 
 void rtl92ce_read_eeprom_info(struct ieee80211_hw *hw)
@@ -1679,22 +1673,22 @@ void rtl92ce_read_eeprom_info(struct ieee80211_hw *hw)
         else
                 rtlpriv->dm.rfpath_rxenable[0] =
                     rtlpriv->dm.rfpath_rxenable[1] = true;
-        RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, ("VersionID = 0x%4x\n",
-                                                rtlhal->version));
+        RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "VersionID = 0x%4x\n",
+                 rtlhal->version);
         tmp_u1b = rtl_read_byte(rtlpriv, REG_9346CR);
         if (tmp_u1b & BIT(4)) {
-                RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, ("Boot from EEPROM\n"));
+                RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "Boot from EEPROM\n");
                 rtlefuse->epromtype = EEPROM_93C46;
         } else {
-                RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, ("Boot from EFUSE\n"));
+                RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "Boot from EFUSE\n");
                 rtlefuse->epromtype = EEPROM_BOOT_EFUSE;
         }
         if (tmp_u1b & BIT(5)) {
-                RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, ("Autoload OK\n"));
+                RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n");
                 rtlefuse->autoload_failflag = false;
                 _rtl92ce_read_adapter_info(hw);
         } else {
-                RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, ("Autoload ERR!!\n"));
+                RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Autoload ERR!!\n");
         }
         _rtl92ce_hal_customized_behavior(hw);
 }
@@ -1790,8 +1784,8 @@ static void rtl92ce_update_hal_rate_table(struct ieee80211_hw *hw,
 
         rtl_write_dword(rtlpriv, REG_ARFR0 + ratr_index * 4, ratr_value);
 
-        RT_TRACE(rtlpriv, COMP_RATR, DBG_DMESG,
-                 ("%x\n", rtl_read_dword(rtlpriv, REG_ARFR0)));
+        RT_TRACE(rtlpriv, COMP_RATR, DBG_DMESG, "%x\n",
+                 rtl_read_dword(rtlpriv, REG_ARFR0));
 }
 
 static void rtl92ce_update_hal_rate_mask(struct ieee80211_hw *hw,
@@ -1919,16 +1913,15 @@ static void rtl92ce_update_hal_rate_mask(struct ieee80211_hw *hw,
                 break;
         }
         RT_TRACE(rtlpriv, COMP_RATR, DBG_DMESG,
-                 ("ratr_bitmap :%x\n", ratr_bitmap));
+                 "ratr_bitmap :%x\n", ratr_bitmap);
         *(u32 *)&rate_mask = EF4BYTE((ratr_bitmap & 0x0fffffff) |
                                      (ratr_index << 28));
         rate_mask[4] = macid | (shortgi ? 0x20 : 0x00) | 0x80;
-        RT_TRACE(rtlpriv, COMP_RATR, DBG_DMESG, ("Rate_index:%x, "
-                                                 "ratr_val:%x, %x:%x:%x:%x:%x\n",
-                                                 ratr_index, ratr_bitmap,
-                                                 rate_mask[0], rate_mask[1],
-                                                 rate_mask[2], rate_mask[3],
-                                                 rate_mask[4]));
+        RT_TRACE(rtlpriv, COMP_RATR, DBG_DMESG,
+                 "Rate_index:%x, ratr_val:%x, %x:%x:%x:%x:%x\n",
+                 ratr_index, ratr_bitmap,
+                 rate_mask[0], rate_mask[1], rate_mask[2], rate_mask[3],
+                 rate_mask[4]);
         rtl92c_fill_h2c_cmd(hw, H2C_RA_MASK, 5, rate_mask);
 
         if (macid != 0)
@@ -1994,7 +1987,7 @@ bool rtl92ce_gpio_radio_on_off_checking(struct ieee80211_hw *hw, u8 *valid)
 
         if ((ppsc->hwradiooff) && (e_rfpowerstate_toset == ERFON)) {
                 RT_TRACE(rtlpriv, COMP_RF, DBG_DMESG,
-                         ("GPIOChangeRF  - HW Radio ON, RF ON\n"));
+                         "GPIOChangeRF  - HW Radio ON, RF ON\n");
 
                 e_rfpowerstate_toset = ERFON;
                 ppsc->hwradiooff = false;
@@ -2002,7 +1995,7 @@ bool rtl92ce_gpio_radio_on_off_checking(struct ieee80211_hw *hw, u8 *valid)
         } else if ((ppsc->hwradiooff == false)
                    && (e_rfpowerstate_toset == ERFOFF)) {
                 RT_TRACE(rtlpriv, COMP_RF, DBG_DMESG,
-                         ("GPIOChangeRF  - HW Radio OFF, RF OFF\n"));
+                         "GPIOChangeRF  - HW Radio OFF, RF OFF\n");
 
                 e_rfpowerstate_toset = ERFOFF;
                 ppsc->hwradiooff = true;
@@ -2053,7 +2046,7 @@ void rtl92ce_set_key(struct ieee80211_hw *hw, u32 key_index,
                 u8 cam_offset = 0;
                 u8 clear_number = 5;
 
-                RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, ("clear_all\n"));
+                RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "clear_all\n");
 
                 for (idx = 0; idx < clear_number; idx++) {
                         rtl_cam_mark_invalid(hw, cam_offset + idx);
@@ -2081,8 +2074,8 @@ void rtl92ce_set_key(struct ieee80211_hw *hw, u32 key_index,
                         enc_algo = CAM_AES;
                         break;
                 default:
-                        RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, ("switch case "
-                                        "not process\n"));
+                        RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
+                                 "switch case not processed\n");
                         enc_algo = CAM_TKIP;
                         break;
                 }
@@ -2100,9 +2093,8 @@ void rtl92ce_set_key(struct ieee80211_hw *hw, u32 key_index,
                                                                  p_macaddr);
                                         if (entry_id >=  TOTAL_CAM_ENTRY) {
                                                 RT_TRACE(rtlpriv, COMP_SEC,
-                                                     DBG_EMERG,
-                                                     ("Can not find free hw"
-                                                     " security cam entry\n"));
+                                                         DBG_EMERG,
+                                                         "Can not find free hw security cam entry\n");
                                                 return;
                                         }
                                 } else {
@@ -2116,22 +2108,22 @@ void rtl92ce_set_key(struct ieee80211_hw *hw, u32 key_index,
 
                 if (rtlpriv->sec.key_len[key_index] == 0) {
                         RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
-                                 ("delete one entry, entry_id is %d\n",
-                                 entry_id));
+                                 "delete one entry, entry_id is %d\n",
+                                 entry_id);
                         if (mac->opmode == NL80211_IFTYPE_AP)
                                 rtl_cam_del_entry(hw, p_macaddr);
                         rtl_cam_delete_one_entry(hw, p_macaddr, entry_id);
                 } else {
                         RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
-                                 ("The insert KEY length is %d\n",
-                                  rtlpriv->sec.key_len[PAIRWISE_KEYIDX]));
+                                 "The insert KEY length is %d\n",
+                                 rtlpriv->sec.key_len[PAIRWISE_KEYIDX]);
                         RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
-                                 ("The insert KEY  is %x %x\n",
-                                  rtlpriv->sec.key_buf[0][0],
-                                  rtlpriv->sec.key_buf[0][1]));
+                                 "The insert KEY is %x %x\n",
+                                 rtlpriv->sec.key_buf[0][0],
+                                 rtlpriv->sec.key_buf[0][1]);
 
                         RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
-                                 ("add one entry\n"));
+                                 "add one entry\n");
                         if (is_pairwise) {
                                 RT_PRINT_DATA(rtlpriv, COMP_SEC, DBG_LOUD,
                                               "Pairwise Key content",
@@ -2140,7 +2132,7 @@ void rtl92ce_set_key(struct ieee80211_hw *hw, u32 key_index,
                                               key_len[PAIRWISE_KEYIDX]);
 
                                 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
-                                         ("set Pairwiase key\n"));
+                                         "set Pairwise key\n");
 
                                 rtl_cam_add_one_entry(hw, macaddr, key_index,
                                                       entry_id, enc_algo,
@@ -2149,7 +2141,7 @@ void rtl92ce_set_key(struct ieee80211_hw *hw, u32 key_index,
                                                       key_buf[key_index]);
                         } else {
                                 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
-                                         ("set group key\n"));
+                                         "set group key\n");
 
                                 if (mac->opmode == NL80211_IFTYPE_ADHOC) {
                                         rtl_cam_add_one_entry(hw,