iwlwifi: log as error when error detected

A lot of error conditions in testmode log as IWL_DEBUG_INFO which is not
logged by default. Change it

Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>

diff --git a/drivers/net/wireless/iwlwifi/iwl-testmode.c b/drivers/net/wireless/iwlwifi/iwl-testmode.c
index df7ab332c833a38e41e5dc213d8a1221792b3cd2..e42e0768880b1a52967cffa694600604c992f3cf 100644 (file)
--- a/drivers/net/wireless/iwlwifi/iwl-testmode.c
+++ b/drivers/net/wireless/iwlwifi/iwl-testmode.c
@@ -172,7 +172,7 @@ static void iwl_testmode_ucode_rx_pkt(struct iwl_priv *priv,
        skb = cfg80211_testmode_alloc_event_skb(hw->wiphy, 20 + length,
                                                                GFP_ATOMIC);
        if (skb == NULL) {
-               IWL_DEBUG_INFO(priv,
+               IWL_ERR(priv,
                         "Run out of memory for messages to user space ?\n");
                return;
        }
@@ -183,7 +183,7 @@ static void iwl_testmode_ucode_rx_pkt(struct iwl_priv *priv,
 
 nla_put_failure:
        kfree_skb(skb);
-       IWL_DEBUG_INFO(priv, "Ouch, overran buffer, check allocation!\n");
+       IWL_ERR(priv, "Ouch, overran buffer, check allocation!\n");
 }
 
 void iwl_testmode_init(struct iwl_priv *priv)
@@ -252,8 +252,7 @@ static int iwl_testmode_ucode(struct ieee80211_hw *hw, struct nlattr **tb)
 
        if (!tb[IWL_TM_ATTR_UCODE_CMD_ID] ||
            !tb[IWL_TM_ATTR_UCODE_CMD_DATA]) {
-               IWL_DEBUG_INFO(priv,
-                       "Error finding ucode command mandatory fields\n");
+               IWL_ERR(priv, "Missing ucode command mandatory fields\n");
                return -ENOMSG;
        }
 
@@ -295,7 +294,7 @@ static int iwl_testmode_reg(struct ieee80211_hw *hw, struct nlattr **tb)
        int status = 0;
 
        if (!tb[IWL_TM_ATTR_REG_OFFSET]) {
-               IWL_DEBUG_INFO(priv, "Error finding register offset\n");
+               IWL_ERR(priv, "Missing register offset\n");
                return -ENOMSG;
        }
        ofs = nla_get_u32(tb[IWL_TM_ATTR_REG_OFFSET]);
@@ -309,7 +308,7 @@ static int iwl_testmode_reg(struct ieee80211_hw *hw, struct nlattr **tb)
                cmd == IWL_TM_CMD_APP2DEV_DIRECT_REG_WRITE32 ||
                cmd == IWL_TM_CMD_APP2DEV_DIRECT_REG_WRITE8) &&
                (ofs >= FH_MEM_UPPER_BOUND)) {
-               IWL_DEBUG_INFO(priv, "offset out of segment (0x0 - 0x%x)\n",
+               IWL_ERR(priv, "offset out of segment (0x0 - 0x%x)\n",
                        FH_MEM_UPPER_BOUND);
                return -EINVAL;
        }
@@ -321,19 +320,17 @@ static int iwl_testmode_reg(struct ieee80211_hw *hw, struct nlattr **tb)
 
                skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 20);
                if (!skb) {
-                       IWL_DEBUG_INFO(priv, "Error allocating memory\n");
+                       IWL_ERR(priv, "Memory allocation fail\n");
                        return -ENOMEM;
                }
                NLA_PUT_U32(skb, IWL_TM_ATTR_REG_VALUE32, val32);
                status = cfg80211_testmode_reply(skb);
                if (status < 0)
-                       IWL_DEBUG_INFO(priv,
-                                      "Error sending msg : %d\n", status);
+                       IWL_ERR(priv, "Error sending msg : %d\n", status);
                break;
        case IWL_TM_CMD_APP2DEV_DIRECT_REG_WRITE32:
                if (!tb[IWL_TM_ATTR_REG_VALUE32]) {
-                       IWL_DEBUG_INFO(priv,
-                                      "Error finding value to write\n");
+                       IWL_ERR(priv, "Missing value to write\n");
                        return -ENOMSG;
                } else {
                        val32 = nla_get_u32(tb[IWL_TM_ATTR_REG_VALUE32]);
@@ -343,7 +340,7 @@ static int iwl_testmode_reg(struct ieee80211_hw *hw, struct nlattr **tb)
                break;
        case IWL_TM_CMD_APP2DEV_DIRECT_REG_WRITE8:
                if (!tb[IWL_TM_ATTR_REG_VALUE8]) {
-                       IWL_DEBUG_INFO(priv, "Error finding value to write\n");
+                       IWL_ERR(priv, "Missing value to write\n");
                        return -ENOMSG;
                } else {
                        val8 = nla_get_u8(tb[IWL_TM_ATTR_REG_VALUE8]);
@@ -357,19 +354,17 @@ static int iwl_testmode_reg(struct ieee80211_hw *hw, struct nlattr **tb)
 
                skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 20);
                if (!skb) {
-                       IWL_DEBUG_INFO(priv, "Error allocating memory\n");
+                       IWL_ERR(priv, "Memory allocation fail\n");
                        return -ENOMEM;
                }
                NLA_PUT_U32(skb, IWL_TM_ATTR_REG_VALUE32, val32);
                status = cfg80211_testmode_reply(skb);
                if (status < 0)
-                       IWL_DEBUG_INFO(priv,
-                                       "Error sending msg : %d\n", status);
+                       IWL_ERR(priv, "Error sending msg : %d\n", status);
                break;
        case IWL_TM_CMD_APP2DEV_INDIRECT_REG_WRITE32:
                if (!tb[IWL_TM_ATTR_REG_VALUE32]) {
-                       IWL_DEBUG_INFO(priv,
-                                       "Error finding value to write\n");
+                       IWL_ERR(priv, "Missing value to write\n");
                        return -ENOMSG;
                } else {
                        val32 = nla_get_u32(tb[IWL_TM_ATTR_REG_VALUE32]);
@@ -378,7 +373,7 @@ static int iwl_testmode_reg(struct ieee80211_hw *hw, struct nlattr **tb)
                }
                break;
        default:
-               IWL_DEBUG_INFO(priv, "Unknown testmode register command ID\n");
+               IWL_ERR(priv, "Unknown testmode register command ID\n");
                return -ENOSYS;
        }
 
@@ -400,14 +395,13 @@ static int iwl_testmode_cfg_init_calib(struct iwl_priv *priv)
                                      NULL, NULL);
        ret = iwl_init_alive_start(trans(priv));
        if (ret) {
-               IWL_DEBUG_INFO(priv,
-                       "Error configuring init calibration: %d\n", ret);
+               IWL_ERR(priv, "Fail init calibration: %d\n", ret);
                goto cfg_init_calib_error;
        }
 
        ret = iwl_wait_notification(priv->shrd, &calib_wait, 2 * HZ);
        if (ret)
-               IWL_DEBUG_INFO(priv, "Error detecting"
+               IWL_ERR(priv, "Error detecting"
                        " CALIBRATION_COMPLETE_NOTIFICATION: %d\n", ret);
        return ret;
 
@@ -448,8 +442,7 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
                skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
                                                        rsp_data_len + 20);
                if (!skb) {
-                       IWL_DEBUG_INFO(priv,
-                                      "Error allocating memory\n");
+                       IWL_ERR(priv, "Memory allocation fail\n");
                        return -ENOMEM;
                }
                NLA_PUT_U32(skb, IWL_TM_ATTR_COMMAND,
@@ -458,15 +451,13 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
                        rsp_data_len, rsp_data_ptr);
                status = cfg80211_testmode_reply(skb);
                if (status < 0)
-                       IWL_DEBUG_INFO(priv, "Error sending msg : %d\n",
-                                      status);
+                       IWL_ERR(priv, "Error sending msg : %d\n", status);
                break;
 
        case IWL_TM_CMD_APP2DEV_LOAD_INIT_FW:
                status = iwl_load_ucode_wait_alive(trans, IWL_UCODE_INIT);
                if (status)
-                       IWL_DEBUG_INFO(priv,
-                               "Error loading init ucode: %d\n", status);
+                       IWL_ERR(priv, "Error loading init ucode: %d\n", status);
                break;
 
        case IWL_TM_CMD_APP2DEV_CFG_INIT_CALIB:
@@ -477,13 +468,13 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
        case IWL_TM_CMD_APP2DEV_LOAD_RUNTIME_FW:
                status = iwl_load_ucode_wait_alive(trans, IWL_UCODE_REGULAR);
                if (status) {
-                       IWL_DEBUG_INFO(priv,
+                       IWL_ERR(priv,
                                "Error loading runtime ucode: %d\n", status);
                        break;
                }
                status = iwl_alive_start(priv);
                if (status)
-                       IWL_DEBUG_INFO(priv,
+                       IWL_ERR(priv,
                                "Error starting the device: %d\n", status);
                break;
 
@@ -492,13 +483,13 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
                iwl_trans_stop_device(trans);
                status = iwl_load_ucode_wait_alive(trans, IWL_UCODE_WOWLAN);
                if (status) {
-                       IWL_DEBUG_INFO(priv,
+                       IWL_ERR(priv,
                                "Error loading WOWLAN ucode: %d\n", status);
                        break;
                }
                status = iwl_alive_start(priv);
                if (status)
-                       IWL_DEBUG_INFO(priv,
+                       IWL_ERR(priv,
                                "Error starting the device: %d\n", status);
                break;
 
@@ -507,8 +498,7 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
                        skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
                                cfg(priv)->base_params->eeprom_size + 20);
                        if (!skb) {
-                               IWL_DEBUG_INFO(priv,
-                                      "Error allocating memory\n");
+                               IWL_ERR(priv, "Memory allocation fail\n");
                                return -ENOMEM;
                        }
                        NLA_PUT_U32(skb, IWL_TM_ATTR_COMMAND,
@@ -518,17 +508,15 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
                                priv->shrd->eeprom);
                        status = cfg80211_testmode_reply(skb);
                        if (status < 0)
-                               IWL_DEBUG_INFO(priv,
-                                              "Error sending msg : %d\n",
-                                              status);
+                               IWL_ERR(priv, "Error sending msg : %d\n",
+                                       status);
                } else
                        return -EFAULT;
                break;
 
        case IWL_TM_CMD_APP2DEV_FIXRATE_REQ:
                if (!tb[IWL_TM_ATTR_FIXRATE]) {
-                       IWL_DEBUG_INFO(priv,
-                                      "Error finding fixrate setting\n");
+                       IWL_ERR(priv, "Missing fixrate setting\n");
                        return -ENOMSG;
                }
                priv->tm_fixed_rate = nla_get_u32(tb[IWL_TM_ATTR_FIXRATE]);
@@ -539,14 +527,13 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
 
                skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 20);
                if (!skb) {
-                       IWL_DEBUG_INFO(priv, "Error allocating memory\n");
+                       IWL_ERR(priv, "Memory allocation fail\n");
                        return -ENOMEM;
                }
                NLA_PUT_U32(skb, IWL_TM_ATTR_FW_VERSION, priv->ucode_ver);
                status = cfg80211_testmode_reply(skb);
                if (status < 0)
-                       IWL_DEBUG_INFO(priv,
-                                       "Error sending msg : %d\n", status);
+                       IWL_ERR(priv, "Error sending msg : %d\n", status);
                break;
 
        case IWL_TM_CMD_APP2DEV_GET_DEVICE_ID:
@@ -555,20 +542,19 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
 
                skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 20);
                if (!skb) {
-                       IWL_DEBUG_INFO(priv, "Error allocating memory\n");
+                       IWL_ERR(priv, "Memory allocation fail\n");
                        return -ENOMEM;
                }
                NLA_PUT_U32(skb, IWL_TM_ATTR_DEVICE_ID, devid);
                status = cfg80211_testmode_reply(skb);
                if (status < 0)
-                       IWL_DEBUG_INFO(priv,
-                                       "Error sending msg : %d\n", status);
+                       IWL_ERR(priv, "Error sending msg : %d\n", status);
                break;
 
        case IWL_TM_CMD_APP2DEV_GET_FW_INFO:
                skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 20 + 8);
                if (!skb) {
-                       IWL_DEBUG_INFO(priv, "Error allocating memory\n");
+                       IWL_ERR(priv, "Memory allocation fail\n");
                        return -ENOMEM;
                }
                switch (priv->shrd->ucode_type) {
@@ -585,10 +571,10 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
                        data_size = trans(priv)->ucode_wowlan.data.len;
                        break;
                case IWL_UCODE_NONE:
-                       IWL_DEBUG_INFO(priv, "The uCode has not been loaded\n");
+                       IWL_ERR(priv, "No uCode has not been loaded\n");
                        break;
                default:
-                       IWL_DEBUG_INFO(priv, "Unsupported uCode type\n");
+                       IWL_ERR(priv, "Unsupported uCode type\n");
                        break;
                }
                NLA_PUT_U32(skb, IWL_TM_ATTR_FW_TYPE, priv->shrd->ucode_type);
@@ -596,12 +582,11 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
                NLA_PUT_U32(skb, IWL_TM_ATTR_FW_DATA_SIZE, data_size);
                status = cfg80211_testmode_reply(skb);
                if (status < 0)
-                       IWL_DEBUG_INFO(priv,
-                                       "Error sending msg : %d\n", status);
+                       IWL_ERR(priv, "Error sending msg : %d\n", status);
                break;
 
        default:
-               IWL_DEBUG_INFO(priv, "Unknown testmode driver command ID\n");
+               IWL_ERR(priv, "Unknown testmode driver command ID\n");
                return -ENOSYS;
        }
        return status;
@@ -664,8 +649,7 @@ static int iwl_testmode_trace(struct ieee80211_hw *hw, struct nlattr **tb)
                skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
                        sizeof(priv->testmode_trace.dma_addr) + 20);
                if (!skb) {
-                       IWL_DEBUG_INFO(priv,
-                               "Error allocating memory\n");
+                       IWL_ERR(priv, "Memory allocation fail\n");
                        iwl_trace_cleanup(priv);
                        return -ENOMEM;
                }
@@ -674,9 +658,7 @@ static int iwl_testmode_trace(struct ieee80211_hw *hw, struct nlattr **tb)
                        (u64 *)&priv->testmode_trace.dma_addr);
                status = cfg80211_testmode_reply(skb);
                if (status < 0) {
-                       IWL_DEBUG_INFO(priv,
-                                      "Error sending msg : %d\n",
-                                      status);
+                       IWL_ERR(priv, "Error sending msg : %d\n", status);
                }
                priv->testmode_trace.num_chunks =
                        DIV_ROUND_UP(priv->testmode_trace.buff_size,
@@ -687,7 +669,7 @@ static int iwl_testmode_trace(struct ieee80211_hw *hw, struct nlattr **tb)
                iwl_trace_cleanup(priv);
                break;
        default:
-               IWL_DEBUG_INFO(priv, "Unknown testmode mem command ID\n");
+               IWL_ERR(priv, "Unknown testmode mem command ID\n");
                return -ENOSYS;
        }
        return status;
@@ -752,7 +734,7 @@ static int iwl_testmode_ownership(struct ieee80211_hw *hw, struct nlattr **tb)
        u8 owner;
 
        if (!tb[IWL_TM_ATTR_UCODE_OWNER]) {
-               IWL_DEBUG_INFO(priv, "Error finding ucode owner\n");
+               IWL_ERR(priv, "Missing ucode owner\n");
                return -ENOMSG;
        }
 
@@ -760,7 +742,7 @@ static int iwl_testmode_ownership(struct ieee80211_hw *hw, struct nlattr **tb)
        if ((owner == IWL_OWNERSHIP_DRIVER) || (owner == IWL_OWNERSHIP_TM))
                priv->shrd->ucode_owner = owner;
        else {
-               IWL_DEBUG_INFO(priv, "Invalid owner\n");
+               IWL_ERR(priv, "Invalid owner\n");
                return -EINVAL;
        }
        return 0;
@@ -791,12 +773,12 @@ static int iwl_testmode_sram(struct ieee80211_hw *hw, struct nlattr **tb)
                return -EBUSY;
 
        if (!tb[IWL_TM_ATTR_SRAM_ADDR]) {
-               IWL_DEBUG_INFO(priv, "Error finding SRAM offset address\n");
+               IWL_ERR(priv, "Missing SRAM offset address\n");
                return -ENOMSG;
        }
        ofs = nla_get_u32(tb[IWL_TM_ATTR_SRAM_ADDR]);
        if (!tb[IWL_TM_ATTR_SRAM_SIZE]) {
-               IWL_DEBUG_INFO(priv, "Error finding size for SRAM reading\n");
+               IWL_ERR(priv, "Missing size for SRAM reading\n");
                return -ENOMSG;
        }
        size = nla_get_u32(tb[IWL_TM_ATTR_SRAM_SIZE]);
@@ -811,10 +793,10 @@ static int iwl_testmode_sram(struct ieee80211_hw *hw, struct nlattr **tb)
                maxsize = trans(priv)->ucode_wowlan.data.len;
                break;
        case IWL_UCODE_NONE:
-               IWL_ERR(priv, "Error, uCode does not been loaded\n");
+               IWL_ERR(priv, "uCode does not been loaded\n");
                return -ENOSYS;
        default:
-               IWL_ERR(priv, "Error, unsupported uCode type\n");
+               IWL_ERR(priv, "unsupported uCode type\n");
                return -ENOSYS;
        }
        if ((ofs + size) > (maxsize + SRAM_DATA_SEG_OFFSET)) {
@@ -825,7 +807,7 @@ static int iwl_testmode_sram(struct ieee80211_hw *hw, struct nlattr **tb)
        priv->testmode_sram.buff_addr =
                kmalloc(priv->testmode_sram.buff_size, GFP_KERNEL);
        if (priv->testmode_sram.buff_addr == NULL) {
-               IWL_ERR(priv, "Error allocating memory\n");
+               IWL_ERR(priv, "Memory allocation fail\n");
                return -ENOMEM;
        }
        _iwl_read_targ_mem_words(trans(priv), ofs,
@@ -898,14 +880,13 @@ int iwlagn_mac_testmode_cmd(struct ieee80211_hw *hw, void *data, int len)
        result = nla_parse(tb, IWL_TM_ATTR_MAX - 1, data, len,
                        iwl_testmode_gnl_msg_policy);
        if (result != 0) {
-               IWL_DEBUG_INFO(priv,
-                              "Error parsing the gnl message : %d\n", result);
+               IWL_ERR(priv, "Error parsing the gnl message : %d\n", result);
                return result;
        }
 
        /* IWL_TM_ATTR_COMMAND is absolutely mandatory */
        if (!tb[IWL_TM_ATTR_COMMAND]) {
-               IWL_DEBUG_INFO(priv, "Error finding testmode command type\n");
+               IWL_ERR(priv, "Missing testmode command type\n");
                return -ENOMSG;
        }
        /* in case multiple accesses to the device happens */
@@ -956,7 +937,7 @@ int iwlagn_mac_testmode_cmd(struct ieee80211_hw *hw, void *data, int len)
                break;
 
        default:
-               IWL_DEBUG_INFO(priv, "Unknown testmode command\n");
+               IWL_ERR(priv, "Unknown testmode command\n");
                result = -ENOSYS;
                break;
        }
@@ -981,15 +962,14 @@ int iwlagn_mac_testmode_dump(struct ieee80211_hw *hw, struct sk_buff *skb,
                result = nla_parse(tb, IWL_TM_ATTR_MAX - 1, data, len,
                                iwl_testmode_gnl_msg_policy);
                if (result) {
-                       IWL_DEBUG_INFO(priv,
-                              "Error parsing the gnl message : %d\n", result);
+                       IWL_ERR(priv,
+                               "Error parsing the gnl message : %d\n", result);
                        return result;
                }
 
                /* IWL_TM_ATTR_COMMAND is absolutely mandatory */
                if (!tb[IWL_TM_ATTR_COMMAND]) {
-                       IWL_DEBUG_INFO(priv,
-                               "Error finding testmode command type\n");
+                       IWL_ERR(priv, "Missing testmode command type\n");
                        return -ENOMSG;
                }
                cmd = nla_get_u32(tb[IWL_TM_ATTR_COMMAND]);