ath: Convert ath_print(.., ATH_DBG_FATAL to ath_err

So these errors are always emitted at KERN_ERR level.
Remove ARRAY_SIZE casts, use printf type %zu

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

diff --git a/drivers/net/wireless/ath/ath9k/ahb.c b/drivers/net/wireless/ath/ath9k/ahb.c
index 1a984b0..25a6e44 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/ahb.c
+++ b/drivers/net/wireless/ath/ath9k/ahb.c
@@ -35,10 +35,9 @@ static bool ath_ahb_eeprom_read(struct ath_common *common, u32 off, u16 *data)
 
        pdata = (struct ath9k_platform_data *) pdev->dev.platform_data;
        if (off >= (ARRAY_SIZE(pdata->eeprom_data))) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "%s: flash read failed, offset %08x "
-                         "is out of range\n",
-                         __func__, off);
+               ath_err(common,
+                       "%s: flash read failed, offset %08x is out of range\n",
+                       __func__, off);
                return false;
        }
 

diff --git a/drivers/net/wireless/ath/ath9k/ar5008_phy.c b/drivers/net/wireless/ath/ath9k/ar5008_phy.c
index 06e34d2..9af9f23 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/ar5008_phy.c
+++ b/drivers/net/wireless/ath/ath9k/ar5008_phy.c
@@ -173,8 +173,7 @@ static int ar5008_hw_set_channel(struct ath_hw *ah, struct ath9k_channel *chan)
                        channelSel = ((freq - 704) * 2 - 3040) / 10;
                        bModeSynth = 1;
                } else {
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "Invalid channel %u MHz\n", freq);
+                       ath_err(common, "Invalid channel %u MHz\n", freq);
                        return -EINVAL;
                }
 
@@ -206,8 +205,7 @@ static int ar5008_hw_set_channel(struct ath_hw *ah, struct ath9k_channel *chan)
                channelSel = ath9k_hw_reverse_bits((freq - 4800) / 5, 8);
                aModeRefSel = ath9k_hw_reverse_bits(1, 2);
        } else {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Invalid channel %u MHz\n", freq);
+               ath_err(common, "Invalid channel %u MHz\n", freq);
                return -EINVAL;
        }
 
@@ -448,8 +446,7 @@ static int ar5008_hw_rf_alloc_ext_banks(struct ath_hw *ah)
 #define ATH_ALLOC_BANK(bank, size) do { \
                bank = kzalloc((sizeof(u32) * size), GFP_KERNEL); \
                if (!bank) { \
-                       ath_print(common, ATH_DBG_FATAL, \
-                                 "Cannot allocate RF banks\n"); \
+                       ath_err(common, "Cannot allocate RF banks\n"); \
                        return -ENOMEM; \
                } \
        } while (0);
@@ -879,8 +876,7 @@ static int ar5008_hw_process_ini(struct ath_hw *ah,
 
        /* Write analog registers */
        if (!ath9k_hw_set_rf_regs(ah, chan, freqIndex)) {
-               ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                         "ar5416SetRfRegs failed\n");
+               ath_err(ath9k_hw_common(ah), "ar5416SetRfRegs failed\n");
                return -EIO;
        }
 

diff --git a/drivers/net/wireless/ath/ath9k/ar9002_hw.c b/drivers/net/wireless/ath/ath9k/ar9002_hw.c
index 48261b7..7d5cb20 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/ar9002_hw.c
+++ b/drivers/net/wireless/ath/ath9k/ar9002_hw.c
@@ -494,9 +494,9 @@ int ar9002_hw_rf_claim(struct ath_hw *ah)
        case AR_RAD2122_SREV_MAJOR:
                break;
        default:
-               ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                         "Radio Chip Rev 0x%02X not supported\n",
-                         val & AR_RADIO_SREV_MAJOR);
+               ath_err(ath9k_hw_common(ah),
+                       "Radio Chip Rev 0x%02X not supported\n",
+                       val & AR_RADIO_SREV_MAJOR);
                return -EOPNOTSUPP;
        }
 

diff --git a/drivers/net/wireless/ath/ath9k/beacon.c b/drivers/net/wireless/ath/ath9k/beacon.c
index 47bedd8..70019e9 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/beacon.c
+++ b/drivers/net/wireless/ath/ath9k/beacon.c
@@ -46,8 +46,8 @@ int ath_beaconq_config(struct ath_softc *sc)
        }
 
        if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to update h/w beacon queue parameters\n");
+               ath_err(common,
+                       "Unable to update h/w beacon queue parameters\n");
                return 0;
        } else {
                ath9k_hw_resettxqueue(ah, sc->beacon.beaconq);
@@ -189,8 +189,7 @@ static struct ath_buf *ath_beacon_generate(struct ieee80211_hw *hw,
                dev_kfree_skb_any(skb);
                bf->bf_mpdu = NULL;
                bf->bf_buf_addr = 0;
-               ath_print(common, ATH_DBG_FATAL,
-                         "dma_mapping_error on beaconing\n");
+               ath_err(common, "dma_mapping_error on beaconing\n");
                return NULL;
        }
 
@@ -324,8 +323,7 @@ int ath_beacon_alloc(struct ath_wiphy *aphy, struct ieee80211_vif *vif)
                dev_kfree_skb_any(skb);
                bf->bf_mpdu = NULL;
                bf->bf_buf_addr = 0;
-               ath_print(common, ATH_DBG_FATAL,
-                         "dma_mapping_error on beacon alloc\n");
+               ath_err(common, "dma_mapping_error on beacon alloc\n");
                return -ENOMEM;
        }
 
@@ -469,8 +467,8 @@ void ath_beacon_tasklet(unsigned long data)
                 * are still pending on the queue.
                 */
                if (!ath9k_hw_stoptxdma(ah, sc->beacon.beaconq)) {
-                       ath_print(common, ATH_DBG_FATAL,
-                               "beacon queue %u did not stop?\n", sc->beacon.beaconq);
+                       ath_err(common, "beacon queue %u did not stop?\n",
+                               sc->beacon.beaconq);
                }
 
                /* NB: cabq traffic should already be queued and primed */

diff --git a/drivers/net/wireless/ath/ath9k/eeprom_4k.c b/drivers/net/wireless/ath/ath9k/eeprom_4k.c
index c2481b3..f74692d 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/eeprom_4k.c
+++ b/drivers/net/wireless/ath/ath9k/eeprom_4k.c
@@ -69,8 +69,7 @@ static int ath9k_hw_4k_check_eeprom(struct ath_hw *ah)
        if (!ath9k_hw_use_flash(ah)) {
                if (!ath9k_hw_nvram_read(common, AR5416_EEPROM_MAGIC_OFFSET,
                                         &magic)) {
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "Reading Magic # failed\n");
+                       ath_err(common, "Reading Magic # failed\n");
                        return false;
                }
 
@@ -90,9 +89,8 @@ static int ath9k_hw_4k_check_eeprom(struct ath_hw *ah)
                                        eepdata++;
                                }
                        } else {
-                               ath_print(common, ATH_DBG_FATAL,
-                                         "Invalid EEPROM Magic. "
-                                         "endianness mismatch.\n");
+                               ath_err(common,
+                                       "Invalid EEPROM Magic. endianness mismatch.\n");
                                return -EINVAL;
                        }
                }
@@ -163,9 +161,8 @@ static int ath9k_hw_4k_check_eeprom(struct ath_hw *ah)
 
        if (sum != 0xffff || ah->eep_ops->get_eeprom_ver(ah) != AR5416_EEP_VER ||
            ah->eep_ops->get_eeprom_rev(ah) < AR5416_EEP_NO_BACK_VER) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
-                         sum, ah->eep_ops->get_eeprom_ver(ah));
+               ath_err(common, "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
+                       sum, ah->eep_ops->get_eeprom_ver(ah));
                return -EINVAL;
        }
 

diff --git a/drivers/net/wireless/ath/ath9k/eeprom_9287.c b/drivers/net/wireless/ath/ath9k/eeprom_9287.c
index bcb9ed3..9308b68 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/eeprom_9287.c
+++ b/drivers/net/wireless/ath/ath9k/eeprom_9287.c
@@ -72,8 +72,7 @@ static int ath9k_hw_ar9287_check_eeprom(struct ath_hw *ah)
        if (!ath9k_hw_use_flash(ah)) {
                if (!ath9k_hw_nvram_read(common, AR5416_EEPROM_MAGIC_OFFSET,
                                         &magic)) {
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "Reading Magic # failed\n");
+                       ath_err(common, "Reading Magic # failed\n");
                        return false;
                }
 
@@ -93,9 +92,8 @@ static int ath9k_hw_ar9287_check_eeprom(struct ath_hw *ah)
                                        eepdata++;
                                }
                        } else {
-                               ath_print(common, ATH_DBG_FATAL,
-                                         "Invalid EEPROM Magic. "
-                                         "Endianness mismatch.\n");
+                               ath_err(common,
+                                       "Invalid EEPROM Magic. Endianness mismatch.\n");
                                return -EINVAL;
                        }
                }
@@ -160,9 +158,8 @@ static int ath9k_hw_ar9287_check_eeprom(struct ath_hw *ah)
 
        if (sum != 0xffff || ah->eep_ops->get_eeprom_ver(ah) != AR9287_EEP_VER
            || ah->eep_ops->get_eeprom_rev(ah) < AR5416_EEP_NO_BACK_VER) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
-                          sum, ah->eep_ops->get_eeprom_ver(ah));
+               ath_err(common, "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
+                       sum, ah->eep_ops->get_eeprom_ver(ah));
                return -EINVAL;
        }
 

diff --git a/drivers/net/wireless/ath/ath9k/eeprom_def.c b/drivers/net/wireless/ath/ath9k/eeprom_def.c
index 45f70b2..864a877 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/eeprom_def.c
+++ b/drivers/net/wireless/ath/ath9k/eeprom_def.c
@@ -96,8 +96,8 @@ static bool ath9k_hw_def_fill_eeprom(struct ath_hw *ah)
        for (addr = 0; addr < SIZE_EEPROM_DEF; addr++) {
                if (!ath9k_hw_nvram_read(common, addr + ar5416_eep_start_loc,
                                         eep_data)) {
-                       ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                                 "Unable to read eeprom region\n");
+                       ath_err(ath9k_hw_common(ah),
+                               "Unable to read eeprom region\n");
                        return false;
                }
                eep_data++;
@@ -117,7 +117,7 @@ static int ath9k_hw_def_check_eeprom(struct ath_hw *ah)
        int i, addr, size;
 
        if (!ath9k_hw_nvram_read(common, AR5416_EEPROM_MAGIC_OFFSET, &magic)) {
-               ath_print(common, ATH_DBG_FATAL, "Reading Magic # failed\n");
+               ath_err(common, "Reading Magic # failed\n");
                return false;
        }
 
@@ -139,9 +139,8 @@ static int ath9k_hw_def_check_eeprom(struct ath_hw *ah)
                                        eepdata++;
                                }
                        } else {
-                               ath_print(common, ATH_DBG_FATAL,
-                                         "Invalid EEPROM Magic. "
-                                         "Endianness mismatch.\n");
+                               ath_err(common,
+                                       "Invalid EEPROM Magic. Endianness mismatch.\n");
                                return -EINVAL;
                        }
                }
@@ -216,8 +215,7 @@ static int ath9k_hw_def_check_eeprom(struct ath_hw *ah)
 
        if (sum != 0xffff || ah->eep_ops->get_eeprom_ver(ah) != AR5416_EEP_VER ||
            ah->eep_ops->get_eeprom_rev(ah) < AR5416_EEP_NO_BACK_VER) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
+               ath_err(common, "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
                        sum, ah->eep_ops->get_eeprom_ver(ah));
                return -EINVAL;
        }

diff --git a/drivers/net/wireless/ath/ath9k/gpio.c b/drivers/net/wireless/ath/ath9k/gpio.c
index 6a1a482..2b1b583 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/gpio.c
+++ b/drivers/net/wireless/ath/ath9k/gpio.c
@@ -103,8 +103,8 @@ static int ath_register_led(struct ath_softc *sc, struct ath_led *led,
 
        ret = led_classdev_register(wiphy_dev(sc->hw->wiphy), &led->led_cdev);
        if (ret)
-               ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                         "Failed to register led:%s", led->name);
+               ath_err(ath9k_hw_common(sc->sc_ah),
+                       "Failed to register led:%s", led->name);
        else
                led->registered = 1;
        return ret;

diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_beacon.c b/drivers/net/wireless/ath/ath9k/htc_drv_beacon.c
index 1b72aa4..dd9514e 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/htc_drv_beacon.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_beacon.c
@@ -246,8 +246,8 @@ void ath9k_htc_beaconq_config(struct ath9k_htc_priv *priv)
        qi.tqi_cwmax = qi_be.tqi_cwmax;
 
        if (!ath9k_hw_set_txq_props(ah, priv->beaconq, &qi)) {
-               ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                         "Unable to update beacon queue %u!\n", qnum);
+               ath_err(ath9k_hw_common(ah),
+                       "Unable to update beacon queue %u!\n", qnum);
        } else {
                ath9k_hw_resettxqueue(ah, priv->beaconq);
        }

diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_init.c b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
index 071d0c9..20b32f6 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/htc_drv_init.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
@@ -495,37 +495,31 @@ static int ath9k_init_queues(struct ath9k_htc_priv *priv)
 
        priv->beaconq = ath9k_hw_beaconq_setup(priv->ah);
        if (priv->beaconq == -1) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to setup BEACON xmit queue\n");
+               ath_err(common, "Unable to setup BEACON xmit queue\n");
                goto err;
        }
 
        priv->cabq = ath9k_htc_cabq_setup(priv);
        if (priv->cabq == -1) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to setup CAB xmit queue\n");
+               ath_err(common, "Unable to setup CAB xmit queue\n");
                goto err;
        }
 
        if (!ath9k_htc_txq_setup(priv, WME_AC_BE)) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to setup xmit queue for BE traffic\n");
+               ath_err(common, "Unable to setup xmit queue for BE traffic\n");
                goto err;
        }
 
        if (!ath9k_htc_txq_setup(priv, WME_AC_BK)) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to setup xmit queue for BK traffic\n");
+               ath_err(common, "Unable to setup xmit queue for BK traffic\n");
                goto err;
        }
        if (!ath9k_htc_txq_setup(priv, WME_AC_VI)) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to setup xmit queue for VI traffic\n");
+               ath_err(common, "Unable to setup xmit queue for VI traffic\n");
                goto err;
        }
        if (!ath9k_htc_txq_setup(priv, WME_AC_VO)) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to setup xmit queue for VO traffic\n");
+               ath_err(common, "Unable to setup xmit queue for VO traffic\n");
                goto err;
        }
 
@@ -670,16 +664,15 @@ static int ath9k_init_priv(struct ath9k_htc_priv *priv,
 
        ret = ath9k_hw_init(ah);
        if (ret) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to initialize hardware; "
-                         "initialization status: %d\n", ret);
+               ath_err(common,
+                       "Unable to initialize hardware; initialization status: %d\n",
+                       ret);
                goto err_hw;
        }
 
        ret = ath9k_htc_init_debug(ah);
        if (ret) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to create debugfs files\n");
+               ath_err(common, "Unable to create debugfs files\n");
                goto err_debug;
        }
 

diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_main.c b/drivers/net/wireless/ath/ath9k/htc_drv_main.c
index 8266ce1..a8007af 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/htc_drv_main.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_main.c
@@ -152,9 +152,9 @@ static int ath9k_htc_set_channel(struct ath9k_htc_priv *priv,
        caldata = &priv->caldata[channel->hw_value];
        ret = ath9k_hw_reset(ah, hchan, caldata, fastcc);
        if (ret) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to reset channel (%u Mhz) "
-                         "reset status %d\n", channel->center_freq, ret);
+               ath_err(common,
+                       "Unable to reset channel (%u Mhz) reset status %d\n",
+                       channel->center_freq, ret);
                goto err;
        }
 
@@ -263,8 +263,9 @@ static int ath9k_htc_add_station(struct ath9k_htc_priv *priv,
        WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta);
        if (ret) {
                if (sta)
-                       ath_print(common, ATH_DBG_FATAL,
-                         "Unable to add station entry for: %pM\n", sta->addr);
+                       ath_err(common,
+                               "Unable to add station entry for: %pM\n",
+                               sta->addr);
                return ret;
        }
 
@@ -296,9 +297,9 @@ static int ath9k_htc_remove_station(struct ath9k_htc_priv *priv,
        WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx);
        if (ret) {
                if (sta)
-                       ath_print(common, ATH_DBG_FATAL,
-                         "Unable to remove station entry for: %pM\n",
-                         sta->addr);
+                       ath_err(common,
+                               "Unable to remove station entry for: %pM\n",
+                               sta->addr);
                return ret;
        }
 
@@ -390,8 +391,8 @@ static int ath9k_htc_send_rate_cmd(struct ath9k_htc_priv *priv,
 
        WMI_CMD_BUF(WMI_RC_RATE_UPDATE_CMDID, trate);
        if (ret) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to initialize Rate information on target\n");
+               ath_err(common,
+                       "Unable to initialize Rate information on target\n");
        }
 
        return ret;
@@ -895,8 +896,8 @@ static int ath9k_register_led(struct ath9k_htc_priv *priv, struct ath_led *led,
 
        ret = led_classdev_register(wiphy_dev(priv->hw->wiphy), &led->led_cdev);
        if (ret)
-               ath_print(ath9k_hw_common(priv->ah), ATH_DBG_FATAL,
-                         "Failed to register led:%s", led->name);
+               ath_err(ath9k_hw_common(priv->ah),
+                       "Failed to register led:%s", led->name);
        else
                led->registered = 1;
 
@@ -1024,9 +1025,9 @@ static void ath9k_htc_radio_enable(struct ieee80211_hw *hw)
        /* Reset the HW */
        ret = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
        if (ret) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to reset hardware; reset status %d "
-                         "(freq %u MHz)\n", ret, ah->curchan->channel);
+               ath_err(common,
+                       "Unable to reset hardware; reset status %d (freq %u MHz)\n",
+                       ret, ah->curchan->channel);
        }
 
        ath_update_txpow(priv);
@@ -1087,9 +1088,9 @@ static void ath9k_htc_radio_disable(struct ieee80211_hw *hw)
        /* Reset the HW */
        ret = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
        if (ret) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to reset hardware; reset status %d "
-                         "(freq %u MHz)\n", ret, ah->curchan->channel);
+               ath_err(common,
+                       "Unable to reset hardware; reset status %d (freq %u MHz)\n",
+                       ret, ah->curchan->channel);
        }
 
        /* Disable the PHY */
@@ -1175,9 +1176,9 @@ static int ath9k_htc_start(struct ieee80211_hw *hw)
        ath9k_hw_htc_resetinit(ah);
        ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
        if (ret) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to reset hardware; reset status %d "
-                         "(freq %u MHz)\n", ret, curchan->center_freq);
+               ath_err(common,
+                       "Unable to reset hardware; reset status %d (freq %u MHz)\n",
+                       ret, curchan->center_freq);
                mutex_unlock(&priv->mutex);
                return ret;
        }
@@ -1243,8 +1244,7 @@ static void ath9k_htc_stop(struct ieee80211_hw *hw)
        /* Remove monitor interface here */
        if (ah->opmode == NL80211_IFTYPE_MONITOR) {
                if (ath9k_htc_remove_monitor_interface(priv))
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "Unable to remove monitor interface\n");
+                       ath_err(common, "Unable to remove monitor interface\n");
                else
                        ath_print(common, ATH_DBG_CONFIG,
                                  "Monitor interface removed\n");
@@ -1298,7 +1298,7 @@ static int ath9k_htc_add_interface(struct ieee80211_hw *hw,
                hvif.opmode = cpu_to_be32(HTC_M_IBSS);
                break;
        default:
-               ath_print(common, ATH_DBG_FATAL,
+               ath_err(common,
                        "Interface type %d not yet supported\n", vif->type);
                ret = -EOPNOTSUPP;
                goto out;
@@ -1405,8 +1405,7 @@ static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
                                          hw->conf.channel_type);
 
                if (ath9k_htc_set_channel(priv, hw, &priv->ah->channels[pos]) < 0) {
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "Unable to set channel\n");
+                       ath_err(common, "Unable to set channel\n");
                        mutex_unlock(&priv->mutex);
                        return -EINVAL;
                }
@@ -1426,8 +1425,7 @@ static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
        if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
                if (conf->flags & IEEE80211_CONF_MONITOR) {
                        if (ath9k_htc_add_monitor_interface(priv))
-                               ath_print(common, ATH_DBG_FATAL,
-                                         "Failed to set monitor mode\n");
+                               ath_err(common, "Failed to set monitor mode\n");
                        else
                                ath_print(common, ATH_DBG_CONFIG,
                                          "HW opmode set to Monitor mode\n");
@@ -1552,7 +1550,7 @@ static int ath9k_htc_conf_tx(struct ieee80211_hw *hw, u16 queue,
 
        ret = ath_htc_txq_update(priv, qnum, &qi);
        if (ret) {
-               ath_print(common, ATH_DBG_FATAL, "TXQ Update failed\n");
+               ath_err(common, "TXQ Update failed\n");
                goto out;
        }
 
@@ -1764,8 +1762,7 @@ static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw,
                spin_unlock_bh(&priv->tx_lock);
                break;
        default:
-               ath_print(ath9k_hw_common(priv->ah), ATH_DBG_FATAL,
-                         "Unknown AMPDU action\n");
+               ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
        }
 
        return ret;

diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c b/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
index 7795867..5bef41f 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
@@ -69,8 +69,8 @@ int ath_htc_txq_update(struct ath9k_htc_priv *priv, int qnum,
        qi.tqi_readyTime = qinfo->tqi_readyTime;
 
        if (!ath9k_hw_set_txq_props(ah, qnum, &qi)) {
-               ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                         "Unable to update hardware queue %u!\n", qnum);
+               ath_err(ath9k_hw_common(ah),
+                       "Unable to update hardware queue %u!\n", qnum);
                error = -EIO;
        } else {
                ath9k_hw_resettxqueue(ah, qnum);
@@ -296,8 +296,7 @@ void ath9k_htc_txep(void *drv_priv, struct sk_buff *skb,
                   (ep_id == priv->data_vo_ep)) {
                skb_pull(skb, sizeof(struct tx_frame_hdr));
        } else {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unsupported TX EPID: %d\n", ep_id);
+               ath_err(common, "Unsupported TX EPID: %d\n", ep_id);
                dev_kfree_skb_any(skb);
                return;
        }
@@ -337,9 +336,8 @@ bool ath9k_htc_txq_setup(struct ath9k_htc_priv *priv, int subtype)
                return false;
 
        if (qnum >= ARRAY_SIZE(priv->hwq_map)) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "qnum %u out of range, max %u!\n",
-                         qnum, (unsigned int)ARRAY_SIZE(priv->hwq_map));
+               ath_err(common, "qnum %u out of range, max %zu!\n",
+                       qnum, ARRAY_SIZE(priv->hwq_map));
                ath9k_hw_releasetxqueue(ah, qnum);
                return false;
        }
@@ -490,8 +488,7 @@ static bool ath9k_rx_prepare(struct ath9k_htc_priv *priv,
        __le16 fc;
 
        if (skb->len <= HTC_RX_FRAME_HEADER_SIZE) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Corrupted RX frame, dropping\n");
+               ath_err(common, "Corrupted RX frame, dropping\n");
                goto rx_next;
        }
 
@@ -499,10 +496,9 @@ static bool ath9k_rx_prepare(struct ath9k_htc_priv *priv,
 
        if (be16_to_cpu(rxstatus->rs_datalen) -
            (skb->len - HTC_RX_FRAME_HEADER_SIZE) != 0) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Corrupted RX data len, dropping "
-                         "(dlen: %d, skblen: %d)\n",
-                         rxstatus->rs_datalen, skb->len);
+               ath_err(common,
+                       "Corrupted RX data len, dropping (dlen: %d, skblen: %d)\n",
+                       rxstatus->rs_datalen, skb->len);
                goto rx_next;
        }
 
@@ -728,8 +724,7 @@ int ath9k_rx_init(struct ath9k_htc_priv *priv)
        for (i = 0; i < ATH9K_HTC_RXBUF; i++) {
                rxbuf = kzalloc(sizeof(struct ath9k_htc_rxbuf), GFP_KERNEL);
                if (rxbuf == NULL) {
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "Unable to allocate RX buffers\n");
+                       ath_err(common, "Unable to allocate RX buffers\n");
                        goto err;
                }
                list_add_tail(&rxbuf->list, &priv->rx.rxbuf);

diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c
index 9b1ee7f..00ecbfa 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/hw.c
+++ b/drivers/net/wireless/ath/ath9k/hw.c
@@ -211,8 +211,8 @@ u16 ath9k_hw_computetxtime(struct ath_hw *ah,
                }
                break;
        default:
-               ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                         "Unknown phy %u (rate ix %u)\n", phy, rateix);
+               ath_err(ath9k_hw_common(ah),
+                       "Unknown phy %u (rate ix %u)\n", phy, rateix);
                txTime = 0;
                break;
        }
@@ -331,11 +331,9 @@ static bool ath9k_hw_chip_test(struct ath_hw *ah)
                        REG_WRITE(ah, addr, wrData);
                        rdData = REG_READ(ah, addr);
                        if (rdData != wrData) {
-                               ath_print(common, ATH_DBG_FATAL,
-                                         "address test failed "
-                                         "addr: 0x%08x - wr:0x%08x != "
-                                         "rd:0x%08x\n",
-                                         addr, wrData, rdData);
+                               ath_err(common,
+                                       "address test failed addr: 0x%08x - wr:0x%08x != rd:0x%08x\n",
+                                       addr, wrData, rdData);
                                return false;
                        }
                }
@@ -344,11 +342,9 @@ static bool ath9k_hw_chip_test(struct ath_hw *ah)
                        REG_WRITE(ah, addr, wrData);
                        rdData = REG_READ(ah, addr);
                        if (wrData != rdData) {
-                               ath_print(common, ATH_DBG_FATAL,
-                                         "address test failed "
-                                         "addr: 0x%08x - wr:0x%08x != "
-                                         "rd:0x%08x\n",
-                                         addr, wrData, rdData);
+                               ath_err(common,
+                                       "address test failed addr: 0x%08x - wr:0x%08x != rd:0x%08x\n",
+                                       addr, wrData, rdData);
                                return false;
                        }
                }
@@ -476,9 +472,8 @@ static int ath9k_hw_post_init(struct ath_hw *ah)
 
        ecode = ath9k_hw_rf_alloc_ext_banks(ah);
        if (ecode) {
-               ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                         "Failed allocating banks for "
-                         "external radio\n");
+               ath_err(ath9k_hw_common(ah),
+                       "Failed allocating banks for external radio\n");
                ath9k_hw_rf_free_ext_banks(ah);
                return ecode;
        }
@@ -509,8 +504,7 @@ static int __ath9k_hw_init(struct ath_hw *ah)
                ah->hw_version.macVersion = AR_SREV_VERSION_9100;
 
        if (!ath9k_hw_set_reset_reg(ah, ATH9K_RESET_POWER_ON)) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Couldn't reset chip\n");
+               ath_err(common, "Couldn't reset chip\n");
                return -EIO;
        }
 
@@ -520,7 +514,7 @@ static int __ath9k_hw_init(struct ath_hw *ah)
        ath9k_hw_attach_ops(ah);
 
        if (!ath9k_hw_setpower(ah, ATH9K_PM_AWAKE)) {
-               ath_print(common, ATH_DBG_FATAL, "Couldn't wakeup chip\n");
+               ath_err(common, "Couldn't wakeup chip\n");
                return -EIO;
        }
 
@@ -545,10 +539,9 @@ static int __ath9k_hw_init(struct ath_hw *ah)
                ah->config.max_txtrig_level = MAX_TX_FIFO_THRESHOLD;
 
        if (!ath9k_hw_macversion_supported(ah)) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Mac Chip Rev 0x%02x.%x is not supported by "
-                         "this driver\n", ah->hw_version.macVersion,
-                         ah->hw_version.macRev);
+               ath_err(common,
+                       "Mac Chip Rev 0x%02x.%x is not supported by this driver\n",
+                       ah->hw_version.macVersion, ah->hw_version.macRev);
                return -EOPNOTSUPP;
        }
 
@@ -594,8 +587,7 @@ static int __ath9k_hw_init(struct ath_hw *ah)
 
        r = ath9k_hw_init_macaddr(ah);
        if (r) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Failed to initialize MAC address\n");
+               ath_err(common, "Failed to initialize MAC address\n");
                return r;
        }
 
@@ -633,17 +625,16 @@ int ath9k_hw_init(struct ath_hw *ah)
        default:
                if (common->bus_ops->ath_bus_type == ATH_USB)
                        break;
-               ath_print(common, ATH_DBG_FATAL,
-                         "Hardware device ID 0x%04x not supported\n",
-                         ah->hw_version.devid);
+               ath_err(common, "Hardware device ID 0x%04x not supported\n",
+                       ah->hw_version.devid);
                return -EOPNOTSUPP;
        }
 
        ret = __ath9k_hw_init(ah);
        if (ret) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to initialize hardware; "
-                         "initialization status: %d\n", ret);
+               ath_err(common,
+                       "Unable to initialize hardware; initialization status: %d\n",
+                       ret);
                return ret;
        }
 
@@ -1145,8 +1136,7 @@ static bool ath9k_hw_channel_change(struct ath_hw *ah,
        }
 
        if (!ath9k_hw_rfbus_req(ah)) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Could not kill baseband RX\n");
+               ath_err(common, "Could not kill baseband RX\n");
                return false;
        }
 
@@ -1154,8 +1144,7 @@ static bool ath9k_hw_channel_change(struct ath_hw *ah,
 
        r = ath9k_hw_rf_set_freq(ah, chan);
        if (r) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Failed to set channel\n");
+               ath_err(common, "Failed to set channel\n");
                return false;
        }
        ath9k_hw_set_clockrate(ah);
@@ -1287,7 +1276,7 @@ int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan,
        }
 
        if (!ath9k_hw_chip_reset(ah, chan)) {
-               ath_print(common, ATH_DBG_FATAL, "Chip reset failed\n");
+               ath_err(common, "Chip reset failed\n");
                return -EINVAL;
        }
 
@@ -1568,9 +1557,9 @@ static bool ath9k_hw_set_power_awake(struct ath_hw *ah, int setChip)
                                    AR_RTC_FORCE_WAKE_EN);
                }
                if (i == 0) {
-                       ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                                 "Failed to wakeup in %uus\n",
-                                 POWER_UP_TIME / 20);
+                       ath_err(ath9k_hw_common(ah),
+                               "Failed to wakeup in %uus\n",
+                               POWER_UP_TIME / 20);
                        return false;
                }
        }
@@ -1609,8 +1598,7 @@ bool ath9k_hw_setpower(struct ath_hw *ah, enum ath9k_power_mode mode)
                ath9k_set_power_network_sleep(ah, setChip);
                break;
        default:
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unknown power mode %u\n", mode);
+               ath_err(common, "Unknown power mode %u\n", mode);
                return false;
        }
        ah->power_mode = mode;
@@ -1801,8 +1789,8 @@ int ath9k_hw_fill_cap_info(struct ath_hw *ah)
 
        eeval = ah->eep_ops->get_eeprom(ah, EEP_OP_MODE);
        if ((eeval & (AR5416_OPFLAGS_11G | AR5416_OPFLAGS_11A)) == 0) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "no band has been marked as supported in EEPROM.\n");
+               ath_err(common,
+                       "no band has been marked as supported in EEPROM\n");
                return -EINVAL;
        }
 
@@ -2348,9 +2336,9 @@ struct ath_gen_timer *ath_gen_timer_alloc(struct ath_hw *ah,
        timer = kzalloc(sizeof(struct ath_gen_timer), GFP_KERNEL);
 
        if (timer == NULL) {
-               ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                         "Failed to allocate memory"
-                         "for hw timer[%d]\n", timer_index);
+               ath_err(ath9k_hw_common(ah),
+                       "Failed to allocate memory for hw timer[%d]\n",
+                       timer_index);
                return NULL;
        }
 

diff --git a/drivers/net/wireless/ath/ath9k/init.c b/drivers/net/wireless/ath/ath9k/init.c
index 918308a..2b519b3 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/init.c
+++ b/drivers/net/wireless/ath/ath9k/init.c
@@ -283,8 +283,7 @@ int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
 
        /* ath_desc must be a multiple of DWORDs */
        if ((desc_len % 4) != 0) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "ath_desc not DWORD aligned\n");
+               ath_err(common, "ath_desc not DWORD aligned\n");
                BUG_ON((desc_len % 4) != 0);
                error = -ENOMEM;
                goto fail;
@@ -736,8 +735,7 @@ int ath9k_init_device(u16 devid, struct ath_softc *sc, u16 subsysid,
 
        error = ath9k_init_debug(ah);
        if (error) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to create debugfs files\n");
+               ath_err(common, "Unable to create debugfs files\n");
                goto error_world;
        }
 

diff --git a/drivers/net/wireless/ath/ath9k/mac.c b/drivers/net/wireless/ath/ath9k/mac.c
index b04b37b..b96e750 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/mac.c
+++ b/drivers/net/wireless/ath/ath9k/mac.c
@@ -204,9 +204,8 @@ bool ath9k_hw_stoptxdma(struct ath_hw *ah, u32 q)
                wait = wait_time;
                while (ath9k_hw_numtxpending(ah, q)) {
                        if ((--wait) == 0) {
-                               ath_print(common, ATH_DBG_FATAL,
-                                         "Failed to stop TX DMA in 100 "
-                                         "msec after killing last frame\n");
+                               ath_err(common,
+                                       "Failed to stop TX DMA in 100 msec after killing last frame\n");
                                break;
                        }
                        udelay(ATH9K_TIME_QUANTUM);
@@ -368,14 +367,12 @@ int ath9k_hw_setuptxqueue(struct ath_hw *ah, enum ath9k_tx_queue type,
                            ATH9K_TX_QUEUE_INACTIVE)
                                break;
                if (q == pCap->total_queues) {
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "No available TX queue\n");
+                       ath_err(common, "No available TX queue\n");
                        return -1;
                }
                break;
        default:
-               ath_print(common, ATH_DBG_FATAL,
-                         "Invalid TX queue type: %u\n", type);
+               ath_err(common, "Invalid TX queue type: %u\n", type);
                return -1;
        }
 
@@ -383,8 +380,7 @@ int ath9k_hw_setuptxqueue(struct ath_hw *ah, enum ath9k_tx_queue type,
 
        qi = &ah->txq[q];
        if (qi->tqi_type != ATH9K_TX_QUEUE_INACTIVE) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "TX queue: %u already active\n", q);
+               ath_err(common, "TX queue: %u already active\n", q);
                return -1;
        }
        memset(qi, 0, sizeof(struct ath9k_tx_queue_info));
@@ -735,9 +731,9 @@ bool ath9k_hw_setrxabort(struct ath_hw *ah, bool set)
                                     AR_DIAG_RX_ABORT));
 
                        reg = REG_READ(ah, AR_OBS_BUS_1);
-                       ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                                 "RX failed to go idle in 10 ms RXSM=0x%x\n",
-                                 reg);
+                       ath_err(ath9k_hw_common(ah),
+                               "RX failed to go idle in 10 ms RXSM=0x%x\n",
+                               reg);
 
                        return false;
                }
@@ -791,12 +787,11 @@ bool ath9k_hw_stopdmarecv(struct ath_hw *ah)
        }
 
        if (i == 0) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "DMA failed to stop in %d ms "
-                         "AR_CR=0x%08x AR_DIAG_SW=0x%08x\n",
-                         AH_RX_STOP_DMA_TIMEOUT / 1000,
-                         REG_READ(ah, AR_CR),
-                         REG_READ(ah, AR_DIAG_SW));
+               ath_err(common,
+                       "DMA failed to stop in %d ms AR_CR=0x%08x AR_DIAG_SW=0x%08x\n",
+                       AH_RX_STOP_DMA_TIMEOUT / 1000,
+                       REG_READ(ah, AR_CR),
+                       REG_READ(ah, AR_DIAG_SW));
                return false;
        } else {
                return true;

diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index f026a03..c7a7abf 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -268,16 +268,14 @@ int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
 
        r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
        if (r) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to reset channel (%u MHz), "
-                         "reset status %d\n",
-                         channel->center_freq, r);
+               ath_err(common,
+                       "Unable to reset channel (%u MHz), reset status %d\n",
+                       channel->center_freq, r);
                goto ps_restore;
        }
 
        if (ath_startrecv(sc) != 0) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to restart recv logic\n");
+               ath_err(common, "Unable to restart recv logic\n");
                r = -EIO;
                goto ps_restore;
        }
@@ -892,16 +890,14 @@ void ath_radio_enable(struct ath_softc *sc, struct ieee80211_hw *hw)
 
        r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
        if (r) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to reset channel (%u MHz), "
-                         "reset status %d\n",
-                         channel->center_freq, r);
+               ath_err(common,
+                       "Unable to reset channel (%u MHz), reset status %d\n",
+                       channel->center_freq, r);
        }
 
        ath_update_txpow(sc);
        if (ath_startrecv(sc) != 0) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to restart recv logic\n");
+               ath_err(common, "Unable to restart recv logic\n");
                spin_unlock_bh(&sc->sc_pcu_lock);
                return;
        }
@@ -955,10 +951,9 @@ void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw)
 
        r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
        if (r) {
-               ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                         "Unable to reset channel (%u MHz), "
-                         "reset status %d\n",
-                         channel->center_freq, r);
+               ath_err(ath9k_hw_common(sc->sc_ah),
+                       "Unable to reset channel (%u MHz), reset status %d\n",
+                       channel->center_freq, r);
        }
 
        ath9k_hw_phy_disable(ah);
@@ -993,12 +988,11 @@ int ath_reset(struct ath_softc *sc, bool retry_tx)
 
        r = ath9k_hw_reset(ah, sc->sc_ah->curchan, ah->caldata, false);
        if (r)
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to reset hardware; reset status %d\n", r);
+               ath_err(common,
+                       "Unable to reset hardware; reset status %d\n", r);
 
        if (ath_startrecv(sc) != 0)
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to start recv logic\n");
+               ath_err(common, "Unable to start recv logic\n");
 
        /*
         * We may be doing a reset in response to a request
@@ -1116,10 +1110,9 @@ static int ath9k_start(struct ieee80211_hw *hw)
        spin_lock_bh(&sc->sc_pcu_lock);
        r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
        if (r) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to reset hardware; reset status %d "
-                         "(freq %u MHz)\n", r,
-                         curchan->center_freq);
+               ath_err(common,
+                       "Unable to reset hardware; reset status %d (freq %u MHz)\n",
+                       r, curchan->center_freq);
                spin_unlock_bh(&sc->sc_pcu_lock);
                goto mutex_unlock;
        }
@@ -1138,8 +1131,7 @@ static int ath9k_start(struct ieee80211_hw *hw)
         * here except setup the interrupt mask.
         */
        if (ath_startrecv(sc) != 0) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Unable to start recv logic\n");
+               ath_err(common, "Unable to start recv logic\n");
                r = -EIO;
                spin_unlock_bh(&sc->sc_pcu_lock);
                goto mutex_unlock;
@@ -1378,8 +1370,8 @@ static int ath9k_add_interface(struct ieee80211_hw *hw,
                ic_opmode = vif->type;
                break;
        default:
-               ath_print(common, ATH_DBG_FATAL,
-                       "Interface type %d not yet supported\n", vif->type);
+               ath_err(common, "Interface type %d not yet supported\n",
+                       vif->type);
                ret = -EOPNOTSUPP;
                goto out;
        }
@@ -1650,8 +1642,7 @@ static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
                }
 
                if (ath_set_channel(sc, hw, &sc->sc_ah->channels[pos]) < 0) {
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "Unable to set channel\n");
+                       ath_err(common, "Unable to set channel\n");
                        mutex_unlock(&sc->mutex);
                        return -EINVAL;
                }
@@ -1775,7 +1766,7 @@ static int ath9k_conf_tx(struct ieee80211_hw *hw, u16 queue,
 
        ret = ath_txq_update(sc, txq->axq_qnum, &qi);
        if (ret)
-               ath_print(common, ATH_DBG_FATAL, "TXQ Update failed\n");
+               ath_err(common, "TXQ Update failed\n");
 
        if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)
                if (queue == WME_AC_BE && !ret)
@@ -2024,8 +2015,7 @@ static int ath9k_ampdu_action(struct ieee80211_hw *hw,
                ath9k_ps_restore(sc);
                break;
        default:
-               ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                         "Unknown AMPDU action\n");
+               ath_err(ath9k_hw_common(sc->sc_ah), "Unknown AMPDU action\n");
        }
 
        local_bh_enable();

diff --git a/drivers/net/wireless/ath/ath9k/pci.c b/drivers/net/wireless/ath/ath9k/pci.c
index 09f69a9..71339da 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/pci.c
+++ b/drivers/net/wireless/ath/ath9k/pci.c
@@ -59,10 +59,9 @@ static bool ath_pci_eeprom_read(struct ath_common *common, u32 off, u16 *data)
 
        if (pdata) {
                if (off >= (ARRAY_SIZE(pdata->eeprom_data))) {
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "%s: eeprom read failed, offset %08x "
-                                 "is out of range\n",
-                                 __func__, off);
+                       ath_err(common,
+                               "%s: eeprom read failed, offset %08x is out of range\n",
+                               __func__, off);
                }
 
                *data = pdata->eeprom_data[off];

diff --git a/drivers/net/wireless/ath/ath9k/rc.c b/drivers/net/wireless/ath/ath9k/rc.c
index 3e6ea3b..d8dcaab 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/rc.c
+++ b/drivers/net/wireless/ath/ath9k/rc.c
@@ -1576,8 +1576,8 @@ static void *ath_rate_alloc_sta(void *priv, struct ieee80211_sta *sta, gfp_t gfp
 
        rate_priv = kzalloc(sizeof(struct ath_rate_priv), gfp);
        if (!rate_priv) {
-               ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                         "Unable to allocate private rc structure\n");
+               ath_err(ath9k_hw_common(sc->sc_ah),
+                       "Unable to allocate private rc structure\n");
                return NULL;
        }
 

diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c
index 262c815..c477be0 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/recv.c
+++ b/drivers/net/wireless/ath/ath9k/recv.c
@@ -269,7 +269,7 @@ static int ath_rx_edma_init(struct ath_softc *sc, int nbufs)
                                dev_kfree_skb_any(skb);
                                bf->bf_mpdu = NULL;
                                bf->bf_buf_addr = 0;
-                               ath_print(common, ATH_DBG_FATAL,
+                               ath_err(common,
                                        "dma_mapping_error() on RX init\n");
                                error = -ENOMEM;
                                goto rx_init_fail;
@@ -335,9 +335,9 @@ int ath_rx_init(struct ath_softc *sc, int nbufs)
                error = ath_descdma_setup(sc, &sc->rx.rxdma, &sc->rx.rxbuf,
                                "rx", nbufs, 1, 0);
                if (error != 0) {
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "failed to allocate rx descriptors: %d\n",
-                                 error);
+                       ath_err(common,
+                               "failed to allocate rx descriptors: %d\n",
+                               error);
                        goto err;
                }
 
@@ -358,8 +358,8 @@ int ath_rx_init(struct ath_softc *sc, int nbufs)
                                dev_kfree_skb_any(skb);
                                bf->bf_mpdu = NULL;
                                bf->bf_buf_addr = 0;
-                               ath_print(common, ATH_DBG_FATAL,
-                                         "dma_mapping_error() on RX init\n");
+                               ath_err(common,
+                                       "dma_mapping_error() on RX init\n");
                                error = -ENOMEM;
                                goto err;
                        }
@@ -1725,8 +1725,7 @@ int ath_rx_tasklet(struct ath_softc *sc, int flush, bool hp)
                        dev_kfree_skb_any(requeue_skb);
                        bf->bf_mpdu = NULL;
                        bf->bf_buf_addr = 0;
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "dma_mapping_error() on RX\n");
+                       ath_err(common, "dma_mapping_error() on RX\n");
                        ath_rx_send_to_mac80211(hw, sc, skb, rxs);
                        break;
                }

diff --git a/drivers/net/wireless/ath/ath9k/xmit.c b/drivers/net/wireless/ath/ath9k/xmit.c
index 821d367..d26449c 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/xmit.c
+++ b/drivers/net/wireless/ath/ath9k/xmit.c
@@ -985,9 +985,8 @@ struct ath_txq *ath_txq_setup(struct ath_softc *sc, int qtype, int subtype)
                return NULL;
        }
        if (qnum >= ARRAY_SIZE(sc->tx.txq)) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "qnum %u out of range, max %u!\n",
-                         qnum, (unsigned int)ARRAY_SIZE(sc->tx.txq));
+               ath_err(common, "qnum %u out of range, max %zu!\n",
+                       qnum, ARRAY_SIZE(sc->tx.txq));
                ath9k_hw_releasetxqueue(ah, qnum);
                return NULL;
        }
@@ -1038,8 +1037,8 @@ int ath_txq_update(struct ath_softc *sc, int qnum,
        qi.tqi_readyTime = qinfo->tqi_readyTime;
 
        if (!ath9k_hw_set_txq_props(ah, qnum, &qi)) {
-               ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                         "Unable to update hardware queue %u!\n", qnum);
+               ath_err(ath9k_hw_common(sc->sc_ah),
+                       "Unable to update hardware queue %u!\n", qnum);
                error = -EIO;
        } else {
                ath9k_hw_resettxqueue(ah, qnum);
@@ -1197,14 +1196,13 @@ void ath_drain_all_txq(struct ath_softc *sc, bool retry_tx)
        if (npend) {
                int r;
 
-               ath_print(common, ATH_DBG_FATAL,
-                         "Failed to stop TX DMA. Resetting hardware!\n");
+               ath_err(common, "Failed to stop TX DMA. Resetting hardware!\n");
 
                r = ath9k_hw_reset(ah, sc->sc_ah->curchan, ah->caldata, false);
                if (r)
-                       ath_print(common, ATH_DBG_FATAL,
-                                 "Unable to reset hardware; reset status %d\n",
-                                 r);
+                       ath_err(common,
+                               "Unable to reset hardware; reset status %d\n",
+                               r);
        }
 
        for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
@@ -1663,8 +1661,8 @@ static struct ath_buf *ath_tx_setup_buffer(struct ieee80211_hw *hw,
        if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) {
                bf->bf_mpdu = NULL;
                bf->bf_buf_addr = 0;
-               ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                         "dma_mapping_error() on TX\n");
+               ath_err(ath9k_hw_common(sc->sc_ah),
+                       "dma_mapping_error() on TX\n");
                ath_tx_return_buffer(sc, bf);
                return NULL;
        }
@@ -2260,16 +2258,16 @@ int ath_tx_init(struct ath_softc *sc, int nbufs)
        error = ath_descdma_setup(sc, &sc->tx.txdma, &sc->tx.txbuf,
                                  "tx", nbufs, 1, 1);
        if (error != 0) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Failed to allocate tx descriptors: %d\n", error);
+               ath_err(common,
+                       "Failed to allocate tx descriptors: %d\n", error);
                goto err;
        }
 
        error = ath_descdma_setup(sc, &sc->beacon.bdma, &sc->beacon.bbuf,
                                  "beacon", ATH_BCBUF, 1, 1);
        if (error != 0) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "Failed to allocate beacon descriptors: %d\n", error);
+               ath_err(common,
+                       "Failed to allocate beacon descriptors: %d\n", error);
                goto err;
        }
 

diff --git a/drivers/net/wireless/ath/key.c b/drivers/net/wireless/ath/key.c
index 62e3dac..3a47695 100644 (file)
--- a/drivers/net/wireless/ath/key.c
+++ b/drivers/net/wireless/ath/key.c
@@ -37,8 +37,7 @@ bool ath_hw_keyreset(struct ath_common *common, u16 entry)
        void *ah = common->ah;
 
        if (entry >= common->keymax) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "keychache entry %u out of range\n", entry);
+               ath_err(common, "keycache entry %u out of range\n", entry);
                return false;
        }
 
@@ -75,8 +74,7 @@ static bool ath_hw_keysetmac(struct ath_common *common,
        void *ah = common->ah;
 
        if (entry >= common->keymax) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "keychache entry %u out of range\n", entry);
+               ath_err(common, "keycache entry %u out of range\n", entry);
                return false;
        }
 
@@ -117,8 +115,7 @@ static bool ath_hw_set_keycache_entry(struct ath_common *common, u16 entry,
        u32 keyType;
 
        if (entry >= common->keymax) {
-               ath_print(common, ATH_DBG_FATAL,
-                         "keycache entry %u out of range\n", entry);
+               ath_err(common, "keycache entry %u out of range\n", entry);
                return false;
        }
 
@@ -159,8 +156,7 @@ static bool ath_hw_set_keycache_entry(struct ath_common *common, u16 entry,
                keyType = AR_KEYTABLE_TYPE_CLR;
                break;
        default:
-               ath_print(common, ATH_DBG_FATAL,
-                         "cipher %u not supported\n", k->kv_type);
+               ath_err(common, "cipher %u not supported\n", k->kv_type);
                return false;
        }
 
@@ -341,8 +337,7 @@ static int ath_setkey_tkip(struct ath_common *common, u16 keyix, const u8 *key,
        memcpy(hk->kv_mic, key_txmic, sizeof(hk->kv_mic));
        if (!ath_hw_set_keycache_entry(common, keyix, hk, NULL)) {
                /* TX MIC entry failed. No need to proceed further */
-               ath_print(common, ATH_DBG_FATAL,
-                         "Setting TX MIC Key Failed\n");
+               ath_err(common, "Setting TX MIC Key Failed\n");
                return 0;
        }