rt2x00: Use more current logging styles, shrink object size
authorJoe Perches <joe@perches.com>
Fri, 19 Apr 2013 15:33:40 +0000 (08:33 -0700)
committerJohn W. Linville <linville@tuxdriver.com>
Mon, 22 Apr 2013 19:20:26 +0000 (15:20 -0400)
Reduce object space ~2% using more current logging styles.

Neaten and simplify logging macros.
Use wiphy_<level> where appropriate.
Coalesce formats.

Convert ERROR/WARNING/INFO macros to rt2x00_<level>
Convert EEPROM to rt2x00_eeprom_dbg
Convert PROBE_ERROR to rt2x00_probe_err
Convert DEBUG to rt2x00_dbg
Convert EEPROM to rt2x00_eeprom_dbg

$ size drivers/net/wireless/rt2x00/built-in.o*
   text    data     bss     dec     hex filename
 245639   71696   69584  386919   5e767 drivers/net/wireless/rt2x00/built-in.o.new
 240609   70096   68944  379649   5cb01 drivers/net/wireless/rt2x00/built-in.o.new.nodyndbg
 240609   70096   68944  379649   5cb01 drivers/net/wireless/rt2x00/built-in.o.new.no_rt2x00_debug
 249198   70096   70352  389646   5f20e drivers/net/wireless/rt2x00/built-in.o.old
 249198   70096   70352  389646   5f20e drivers/net/wireless/rt2x00/built-in.o.old.nodyndbg
 244222   70096   69712  384030   5dc1e drivers/net/wireless/rt2x00/built-in.o.old.no_rt2x00_debug

Signed-off-by: Joe Perches <joe@perches.com>
Acked-by: Gertjan van Wingerde <gwingerde@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
19 files changed:
drivers/net/wireless/rt2x00/rt2400pci.c
drivers/net/wireless/rt2x00/rt2500pci.c
drivers/net/wireless/rt2x00/rt2500usb.c
drivers/net/wireless/rt2x00/rt2800lib.c
drivers/net/wireless/rt2x00/rt2800pci.c
drivers/net/wireless/rt2x00/rt2800usb.c
drivers/net/wireless/rt2x00/rt2x00.h
drivers/net/wireless/rt2x00/rt2x00debug.c
drivers/net/wireless/rt2x00/rt2x00dev.c
drivers/net/wireless/rt2x00/rt2x00firmware.c
drivers/net/wireless/rt2x00/rt2x00leds.c
drivers/net/wireless/rt2x00/rt2x00mac.c
drivers/net/wireless/rt2x00/rt2x00mmio.c
drivers/net/wireless/rt2x00/rt2x00pci.c
drivers/net/wireless/rt2x00/rt2x00queue.c
drivers/net/wireless/rt2x00/rt2x00soc.c
drivers/net/wireless/rt2x00/rt2x00usb.c
drivers/net/wireless/rt2x00/rt61pci.c
drivers/net/wireless/rt2x00/rt73usb.c

index d1b10d4572306d8e970cc317470874bc3ceab23c..f7143733d7e95eaeba3a5f8ea8c2aff80c350334 100644 (file)
@@ -920,7 +920,7 @@ static int rt2400pci_wait_bbp_ready(struct rt2x00_dev *rt2x00dev)
                udelay(REGISTER_BUSY_DELAY);
        }
 
-       ERROR(rt2x00dev, "BBP register access failed, aborting.\n");
+       rt2x00_err(rt2x00dev, "BBP register access failed, aborting\n");
        return -EACCES;
 }
 
@@ -1093,8 +1093,8 @@ static int rt2400pci_set_device_state(struct rt2x00_dev *rt2x00dev,
        }
 
        if (unlikely(retval))
-               ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n",
-                     state, retval);
+               rt2x00_err(rt2x00dev, "Device failed to enter state %d (%d)\n",
+                          state, retval);
 
        return retval;
 }
@@ -1188,7 +1188,7 @@ static void rt2400pci_write_beacon(struct queue_entry *entry,
        rt2x00mmio_register_write(rt2x00dev, CSR14, reg);
 
        if (rt2x00queue_map_txskb(entry)) {
-               ERROR(rt2x00dev, "Fail to map beacon, aborting\n");
+               rt2x00_err(rt2x00dev, "Fail to map beacon, aborting\n");
                goto out;
        }
        /*
@@ -1464,12 +1464,12 @@ static int rt2400pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
        mac = rt2x00_eeprom_addr(rt2x00dev, EEPROM_MAC_ADDR_0);
        if (!is_valid_ether_addr(mac)) {
                eth_random_addr(mac);
-               EEPROM(rt2x00dev, "MAC: %pM\n", mac);
+               rt2x00_eeprom_dbg(rt2x00dev, "MAC: %pM\n", mac);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &word);
        if (word == 0xffff) {
-               ERROR(rt2x00dev, "Invalid EEPROM data detected.\n");
+               rt2x00_err(rt2x00dev, "Invalid EEPROM data detected\n");
                return -EINVAL;
        }
 
@@ -1496,7 +1496,7 @@ static int rt2400pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
                        rt2x00_get_field32(reg, CSR0_REVISION));
 
        if (!rt2x00_rf(rt2x00dev, RF2420) && !rt2x00_rf(rt2x00dev, RF2421)) {
-               ERROR(rt2x00dev, "Invalid RF chipset detected.\n");
+               rt2x00_err(rt2x00dev, "Invalid RF chipset detected\n");
                return -ENODEV;
        }
 
index 9ba14570fcfdfc995e9da8885433a3e75e3d163e..77e45b223d158348b958a7b5a88b84cecfc6f3a2 100644 (file)
@@ -1058,7 +1058,7 @@ static int rt2500pci_wait_bbp_ready(struct rt2x00_dev *rt2x00dev)
                udelay(REGISTER_BUSY_DELAY);
        }
 
-       ERROR(rt2x00dev, "BBP register access failed, aborting.\n");
+       rt2x00_err(rt2x00dev, "BBP register access failed, aborting\n");
        return -EACCES;
 }
 
@@ -1246,8 +1246,8 @@ static int rt2500pci_set_device_state(struct rt2x00_dev *rt2x00dev,
        }
 
        if (unlikely(retval))
-               ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n",
-                     state, retval);
+               rt2x00_err(rt2x00dev, "Device failed to enter state %d (%d)\n",
+                          state, retval);
 
        return retval;
 }
@@ -1340,7 +1340,7 @@ static void rt2500pci_write_beacon(struct queue_entry *entry,
        rt2x00mmio_register_write(rt2x00dev, CSR14, reg);
 
        if (rt2x00queue_map_txskb(entry)) {
-               ERROR(rt2x00dev, "Fail to map beacon, aborting\n");
+               rt2x00_err(rt2x00dev, "Fail to map beacon, aborting\n");
                goto out;
        }
 
@@ -1590,7 +1590,7 @@ static int rt2500pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
        mac = rt2x00_eeprom_addr(rt2x00dev, EEPROM_MAC_ADDR_0);
        if (!is_valid_ether_addr(mac)) {
                eth_random_addr(mac);
-               EEPROM(rt2x00dev, "MAC: %pM\n", mac);
+               rt2x00_eeprom_dbg(rt2x00dev, "MAC: %pM\n", mac);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &word);
@@ -1606,7 +1606,7 @@ static int rt2500pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_ANTENNA_HARDWARE_RADIO, 0);
                rt2x00_set_field16(&word, EEPROM_ANTENNA_RF_TYPE, RF2522);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_ANTENNA, word);
-               EEPROM(rt2x00dev, "Antenna: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Antenna: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &word);
@@ -1615,7 +1615,7 @@ static int rt2500pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_NIC_DYN_BBP_TUNE, 0);
                rt2x00_set_field16(&word, EEPROM_NIC_CCK_TX_POWER, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_NIC, word);
-               EEPROM(rt2x00dev, "NIC: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "NIC: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_CALIBRATE_OFFSET, &word);
@@ -1623,7 +1623,8 @@ static int rt2500pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_CALIBRATE_OFFSET_RSSI,
                                   DEFAULT_RSSI_OFFSET);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_CALIBRATE_OFFSET, word);
-               EEPROM(rt2x00dev, "Calibrate offset: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Calibrate offset: 0x%04x\n",
+                                 word);
        }
 
        return 0;
@@ -1654,7 +1655,7 @@ static int rt2500pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
            !rt2x00_rf(rt2x00dev, RF2525) &&
            !rt2x00_rf(rt2x00dev, RF2525E) &&
            !rt2x00_rf(rt2x00dev, RF5222)) {
-               ERROR(rt2x00dev, "Invalid RF chipset detected.\n");
+               rt2x00_err(rt2x00dev, "Invalid RF chipset detected\n");
                return -ENODEV;
        }
 
index 6b2e1e431dd2fc579d1a2710b2b68ecfd47f043e..a7f7b365eff476c7f74e33660ea3c850882413f7 100644 (file)
@@ -134,8 +134,8 @@ static int rt2500usb_regbusy_read(struct rt2x00_dev *rt2x00dev,
                udelay(REGISTER_BUSY_DELAY);
        }
 
-       ERROR(rt2x00dev, "Indirect register access failed: "
-             "offset=0x%.08x, value=0x%.08x\n", offset, *reg);
+       rt2x00_err(rt2x00dev, "Indirect register access failed: offset=0x%.08x, value=0x%.08x\n",
+                  offset, *reg);
        *reg = ~0;
 
        return 0;
@@ -916,7 +916,7 @@ static int rt2500usb_wait_bbp_ready(struct rt2x00_dev *rt2x00dev)
                udelay(REGISTER_BUSY_DELAY);
        }
 
-       ERROR(rt2x00dev, "BBP register access failed, aborting.\n");
+       rt2x00_err(rt2x00dev, "BBP register access failed, aborting\n");
        return -EACCES;
 }
 
@@ -1069,8 +1069,8 @@ static int rt2500usb_set_device_state(struct rt2x00_dev *rt2x00dev,
        }
 
        if (unlikely(retval))
-               ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n",
-                     state, retval);
+               rt2x00_err(rt2x00dev, "Device failed to enter state %d (%d)\n",
+                          state, retval);
 
        return retval;
 }
@@ -1353,7 +1353,7 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
        mac = rt2x00_eeprom_addr(rt2x00dev, EEPROM_MAC_ADDR_0);
        if (!is_valid_ether_addr(mac)) {
                eth_random_addr(mac);
-               EEPROM(rt2x00dev, "MAC: %pM\n", mac);
+               rt2x00_eeprom_dbg(rt2x00dev, "MAC: %pM\n", mac);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &word);
@@ -1369,7 +1369,7 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_ANTENNA_HARDWARE_RADIO, 0);
                rt2x00_set_field16(&word, EEPROM_ANTENNA_RF_TYPE, RF2522);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_ANTENNA, word);
-               EEPROM(rt2x00dev, "Antenna: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Antenna: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &word);
@@ -1378,7 +1378,7 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_NIC_DYN_BBP_TUNE, 0);
                rt2x00_set_field16(&word, EEPROM_NIC_CCK_TX_POWER, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_NIC, word);
-               EEPROM(rt2x00dev, "NIC: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "NIC: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_CALIBRATE_OFFSET, &word);
@@ -1386,14 +1386,15 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_CALIBRATE_OFFSET_RSSI,
                                   DEFAULT_RSSI_OFFSET);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_CALIBRATE_OFFSET, word);
-               EEPROM(rt2x00dev, "Calibrate offset: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Calibrate offset: 0x%04x\n",
+                                 word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE, &word);
        if (word == 0xffff) {
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_THRESHOLD, 45);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE, word);
-               EEPROM(rt2x00dev, "BBPtune: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "BBPtune: 0x%04x\n", word);
        }
 
        /*
@@ -1408,7 +1409,7 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_VGCUPPER, 0x40);
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_VGCLOWER, bbp);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_VGC, word);
-               EEPROM(rt2x00dev, "BBPtune vgc: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "BBPtune vgc: 0x%04x\n", word);
        } else {
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_VGCLOWER, bbp);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_VGC, word);
@@ -1419,7 +1420,7 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_R17_LOW, 0x48);
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_R17_HIGH, 0x41);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_R17, word);
-               EEPROM(rt2x00dev, "BBPtune r17: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "BBPtune r17: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R24, &word);
@@ -1427,7 +1428,7 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_R24_LOW, 0x40);
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_R24_HIGH, 0x80);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_R24, word);
-               EEPROM(rt2x00dev, "BBPtune r24: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "BBPtune r24: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R25, &word);
@@ -1435,7 +1436,7 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_R25_LOW, 0x40);
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_R25_HIGH, 0x50);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_R25, word);
-               EEPROM(rt2x00dev, "BBPtune r25: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "BBPtune r25: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R61, &word);
@@ -1443,7 +1444,7 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_R61_LOW, 0x60);
                rt2x00_set_field16(&word, EEPROM_BBPTUNE_R61_HIGH, 0x6d);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_R61, word);
-               EEPROM(rt2x00dev, "BBPtune r61: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "BBPtune r61: 0x%04x\n", word);
        }
 
        return 0;
@@ -1468,7 +1469,7 @@ static int rt2500usb_init_eeprom(struct rt2x00_dev *rt2x00dev)
        rt2x00_set_chip(rt2x00dev, RT2570, value, reg);
 
        if (((reg & 0xfff0) != 0) || ((reg & 0x0000000f) == 0)) {
-               ERROR(rt2x00dev, "Invalid RT chipset detected.\n");
+               rt2x00_err(rt2x00dev, "Invalid RT chipset detected\n");
                return -ENODEV;
        }
 
@@ -1478,7 +1479,7 @@ static int rt2500usb_init_eeprom(struct rt2x00_dev *rt2x00dev)
            !rt2x00_rf(rt2x00dev, RF2525) &&
            !rt2x00_rf(rt2x00dev, RF2525E) &&
            !rt2x00_rf(rt2x00dev, RF5222)) {
-               ERROR(rt2x00dev, "Invalid RF chipset detected.\n");
+               rt2x00_err(rt2x00dev, "Invalid RF chipset detected\n");
                return -ENODEV;
        }
 
index 830560775a44783eb583fd52bcbde7127635ddd1..b52d70c75e1ab7dd3bc7d5a6a699281c6928ec62 100644 (file)
@@ -80,7 +80,7 @@ static inline bool rt2800_is_305x_soc(struct rt2x00_dev *rt2x00dev)
            rt2x00_rf(rt2x00dev, RF3022))
                return true;
 
-       WARNING(rt2x00dev, "Unknown RF chipset on rt305x\n");
+       rt2x00_warn(rt2x00dev, "Unknown RF chipset on rt305x\n");
        return false;
 }
 
@@ -328,7 +328,7 @@ int rt2800_wait_csr_ready(struct rt2x00_dev *rt2x00dev)
                msleep(1);
        }
 
-       ERROR(rt2x00dev, "Unstable hardware.\n");
+       rt2x00_err(rt2x00dev, "Unstable hardware\n");
        return -EBUSY;
 }
 EXPORT_SYMBOL_GPL(rt2800_wait_csr_ready);
@@ -351,7 +351,7 @@ int rt2800_wait_wpdma_ready(struct rt2x00_dev *rt2x00dev)
                msleep(10);
        }
 
-       ERROR(rt2x00dev, "WPDMA TX/RX busy [0x%08x].\n", reg);
+       rt2x00_err(rt2x00dev, "WPDMA TX/RX busy [0x%08x]\n", reg);
        return -EACCES;
 }
 EXPORT_SYMBOL_GPL(rt2800_wait_wpdma_ready);
@@ -512,7 +512,7 @@ int rt2800_load_firmware(struct rt2x00_dev *rt2x00dev,
        }
 
        if (i == REGISTER_BUSY_COUNT) {
-               ERROR(rt2x00dev, "PBF system register not ready.\n");
+               rt2x00_err(rt2x00dev, "PBF system register not ready\n");
                return -EBUSY;
        }
 
@@ -811,7 +811,7 @@ void rt2800_write_beacon(struct queue_entry *entry, struct txentry_desc *txdesc)
         */
        padding_len = roundup(entry->skb->len, 4) - entry->skb->len;
        if (padding_len && skb_pad(entry->skb, padding_len)) {
-               ERROR(rt2x00dev, "Failure padding beacon, aborting\n");
+               rt2x00_err(rt2x00dev, "Failure padding beacon, aborting\n");
                /* skb freed by skb_pad() on failure */
                entry->skb = NULL;
                rt2800_register_write(rt2x00dev, BCN_TIME_CFG, orig_reg);
@@ -3869,7 +3869,7 @@ static int rt2800_wait_bbp_rf_ready(struct rt2x00_dev *rt2x00dev)
                udelay(REGISTER_BUSY_DELAY);
        }
 
-       ERROR(rt2x00dev, "BBP/RF register access failed, aborting.\n");
+       rt2x00_err(rt2x00dev, "BBP/RF register access failed, aborting\n");
        return -EACCES;
 }
 
@@ -3893,7 +3893,7 @@ static int rt2800_wait_bbp_ready(struct rt2x00_dev *rt2x00dev)
                udelay(REGISTER_BUSY_DELAY);
        }
 
-       ERROR(rt2x00dev, "BBP register access failed, aborting.\n");
+       rt2x00_err(rt2x00dev, "BBP register access failed, aborting\n");
        return -EACCES;
 }
 
@@ -5353,7 +5353,7 @@ static int rt2800_validate_eeprom(struct rt2x00_dev *rt2x00dev)
        mac = rt2x00_eeprom_addr(rt2x00dev, EEPROM_MAC_ADDR_0);
        if (!is_valid_ether_addr(mac)) {
                eth_random_addr(mac);
-               EEPROM(rt2x00dev, "MAC: %pM\n", mac);
+               rt2x00_eeprom_dbg(rt2x00dev, "MAC: %pM\n", mac);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC_CONF0, &word);
@@ -5362,7 +5362,7 @@ static int rt2800_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_NIC_CONF0_TXPATH, 1);
                rt2x00_set_field16(&word, EEPROM_NIC_CONF0_RF_TYPE, RF2820);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_NIC_CONF0, word);
-               EEPROM(rt2x00dev, "Antenna: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Antenna: 0x%04x\n", word);
        } else if (rt2x00_rt(rt2x00dev, RT2860) ||
                   rt2x00_rt(rt2x00dev, RT2872)) {
                /*
@@ -5391,14 +5391,14 @@ static int rt2800_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_NIC_CONF1_BT_COEXIST, 0);
                rt2x00_set_field16(&word, EEPROM_NIC_CONF1_DAC_TEST, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_NIC_CONF1, word);
-               EEPROM(rt2x00dev, "NIC: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "NIC: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_FREQ, &word);
        if ((word & 0x00ff) == 0x00ff) {
                rt2x00_set_field16(&word, EEPROM_FREQ_OFFSET, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_FREQ, word);
-               EEPROM(rt2x00dev, "Freq: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Freq: 0x%04x\n", word);
        }
        if ((word & 0xff00) == 0xff00) {
                rt2x00_set_field16(&word, EEPROM_FREQ_LED_MODE,
@@ -5408,7 +5408,7 @@ static int rt2800_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_eeprom_write(rt2x00dev, EEPROM_LED_AG_CONF, 0x5555);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_LED_ACT_CONF, 0x2221);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_LED_POLARITY, 0xa9f8);
-               EEPROM(rt2x00dev, "Led Mode: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Led Mode: 0x%04x\n", word);
        }
 
        /*
@@ -5514,7 +5514,8 @@ static int rt2800_init_eeprom(struct rt2x00_dev *rt2x00dev)
        case RF5592:
                break;
        default:
-               ERROR(rt2x00dev, "Invalid RF chipset 0x%04x detected.\n", rf);
+               rt2x00_err(rt2x00dev, "Invalid RF chipset 0x%04x detected\n",
+                          rf);
                return -ENODEV;
        }
 
@@ -6103,9 +6104,8 @@ static int rt2800_probe_rt(struct rt2x00_dev *rt2x00dev)
        case RT5592:
                break;
        default:
-               ERROR(rt2x00dev,
-                     "Invalid RT chipset 0x%04x, rev %04x detected.\n",
-                     rt, rev);
+               rt2x00_err(rt2x00dev, "Invalid RT chipset 0x%04x, rev %04x detected\n",
+                          rt, rev);
                return -ENODEV;
        }
 
@@ -6364,7 +6364,8 @@ int rt2800_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
        case IEEE80211_AMPDU_TX_OPERATIONAL:
                break;
        default:
-               WARNING((struct rt2x00_dev *)hw->priv, "Unknown AMPDU action\n");
+               rt2x00_warn((struct rt2x00_dev *)hw->priv,
+                           "Unknown AMPDU action\n");
        }
 
        return ret;
index d540ce944cc1f18e7c90e21b99b309325d8ae32c..6f4a861af336cc22ac1461dceb7dc4eef7deb45d 100644 (file)
@@ -84,7 +84,7 @@ static void rt2800pci_mcu_status(struct rt2x00_dev *rt2x00dev, const u8 token)
        }
 
        if (i == 200)
-               ERROR(rt2x00dev, "MCU request failed, no response from hardware\n");
+               rt2x00_err(rt2x00dev, "MCU request failed, no response from hardware\n");
 
        rt2x00mmio_register_write(rt2x00dev, H2M_MAILBOX_STATUS, ~0);
        rt2x00mmio_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0);
@@ -616,8 +616,8 @@ static int rt2800pci_set_device_state(struct rt2x00_dev *rt2x00dev,
        }
 
        if (unlikely(retval))
-               ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n",
-                     state, retval);
+               rt2x00_err(rt2x00dev, "Device failed to enter state %d (%d)\n",
+                          state, retval);
 
        return retval;
 }
@@ -843,8 +843,8 @@ static bool rt2800pci_txdone(struct rt2x00_dev *rt2x00dev)
                         * Unknown queue, this shouldn't happen. Just drop
                         * this tx status.
                         */
-                       WARNING(rt2x00dev, "Got TX status report with "
-                                          "unexpected pid %u, dropping\n", qid);
+                       rt2x00_warn(rt2x00dev, "Got TX status report with unexpected pid %u, dropping\n",
+                                   qid);
                        break;
                }
 
@@ -854,8 +854,8 @@ static bool rt2800pci_txdone(struct rt2x00_dev *rt2x00dev)
                         * The queue is NULL, this shouldn't happen. Stop
                         * processing here and drop the tx status
                         */
-                       WARNING(rt2x00dev, "Got TX status for an unavailable "
-                                          "queue %u, dropping\n", qid);
+                       rt2x00_warn(rt2x00dev, "Got TX status for an unavailable queue %u, dropping\n",
+                                   qid);
                        break;
                }
 
@@ -864,8 +864,8 @@ static bool rt2800pci_txdone(struct rt2x00_dev *rt2x00dev)
                         * The queue is empty. Stop processing here
                         * and drop the tx status.
                         */
-                       WARNING(rt2x00dev, "Got TX status for an empty "
-                                          "queue %u, dropping\n", qid);
+                       rt2x00_warn(rt2x00dev, "Got TX status for an empty queue %u, dropping\n",
+                                   qid);
                        break;
                }
 
@@ -883,9 +883,8 @@ static bool rt2800pci_txdone(struct rt2x00_dev *rt2x00dev)
                        if (!rt2x00queue_for_each_entry(queue, Q_INDEX_DONE,
                                                        Q_INDEX, &status,
                                                        rt2800pci_txdone_match_first)) {
-                               WARNING(rt2x00dev, "No frame found for TX "
-                                                  "status on queue %u, dropping\n",
-                                                  qid);
+                               rt2x00_warn(rt2x00dev, "No frame found for TX status on queue %u, dropping\n",
+                                           qid);
                                break;
                        }
                }
@@ -1022,8 +1021,7 @@ static void rt2800pci_txstatus_interrupt(struct rt2x00_dev *rt2x00dev)
                        break;
 
                if (!kfifo_put(&rt2x00dev->txstatus_fifo, &status)) {
-                       WARNING(rt2x00dev, "TX status FIFO overrun,"
-                               "drop tx status report.\n");
+                       rt2x00_warn(rt2x00dev, "TX status FIFO overrun, drop tx status report\n");
                        break;
                }
        }
index 0cb6bbee7f32eeb2748f071099e83a8586523bcc..ac854d75bd6cb33bd32f86e199b10e57b775d3ce 100644 (file)
@@ -128,9 +128,9 @@ static inline bool rt2800usb_entry_txstatus_timeout(struct queue_entry *entry)
 
        tout = time_after(jiffies, entry->last_action + msecs_to_jiffies(100));
        if (unlikely(tout))
-               WARNING(entry->queue->rt2x00dev,
-                       "TX status timeout for entry %d in queue %d\n",
-                       entry->entry_idx, entry->queue->qid);
+               rt2x00_warn(entry->queue->rt2x00dev,
+                           "TX status timeout for entry %d in queue %d\n",
+                           entry->entry_idx, entry->queue->qid);
        return tout;
 
 }
@@ -154,7 +154,8 @@ static bool rt2800usb_tx_sta_fifo_read_completed(struct rt2x00_dev *rt2x00dev,
        bool valid;
 
        if (urb_status) {
-               WARNING(rt2x00dev, "TX status read failed %d\n", urb_status);
+               rt2x00_warn(rt2x00dev, "TX status read failed %d\n",
+                           urb_status);
 
                goto stop_reading;
        }
@@ -162,7 +163,7 @@ static bool rt2800usb_tx_sta_fifo_read_completed(struct rt2x00_dev *rt2x00dev,
        valid = rt2x00_get_field32(tx_status, TX_STA_FIFO_VALID);
        if (valid) {
                if (!kfifo_put(&rt2x00dev->txstatus_fifo, &tx_status))
-                       WARNING(rt2x00dev, "TX status FIFO overrun\n");
+                       rt2x00_warn(rt2x00dev, "TX status FIFO overrun\n");
 
                queue_work(rt2x00dev->workqueue, &rt2x00dev->txdone_work);
 
@@ -269,7 +270,7 @@ static int rt2800usb_write_firmware(struct rt2x00_dev *rt2x00dev,
                                             0, USB_MODE_FIRMWARE,
                                             REGISTER_TIMEOUT_FIRMWARE);
        if (status < 0) {
-               ERROR(rt2x00dev, "Failed to write Firmware to device.\n");
+               rt2x00_err(rt2x00dev, "Failed to write Firmware to device\n");
                return status;
        }
 
@@ -392,8 +393,8 @@ static int rt2800usb_set_device_state(struct rt2x00_dev *rt2x00dev,
        }
 
        if (unlikely(retval))
-               ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n",
-                     state, retval);
+               rt2x00_err(rt2x00dev, "Device failed to enter state %d (%d)\n",
+                          state, retval);
 
        return retval;
 }
@@ -408,8 +409,7 @@ static void rt2800usb_watchdog(struct rt2x00_dev *rt2x00dev)
 
        rt2x00usb_register_read(rt2x00dev, TXRXQ_PCNT, &reg);
        if (rt2x00_get_field32(reg, TXRXQ_PCNT_TX0Q)) {
-               WARNING(rt2x00dev, "TX HW queue 0 timed out,"
-                       " invoke forced kick\n");
+               rt2x00_warn(rt2x00dev, "TX HW queue 0 timed out, invoke forced kick\n");
 
                rt2x00usb_register_write(rt2x00dev, PBF_CFG, 0xf40012);
 
@@ -424,8 +424,7 @@ static void rt2800usb_watchdog(struct rt2x00_dev *rt2x00dev)
 
        rt2x00usb_register_read(rt2x00dev, TXRXQ_PCNT, &reg);
        if (rt2x00_get_field32(reg, TXRXQ_PCNT_TX1Q)) {
-               WARNING(rt2x00dev, "TX HW queue 1 timed out,"
-                       " invoke forced kick\n");
+               rt2x00_warn(rt2x00dev, "TX HW queue 1 timed out, invoke forced kick\n");
 
                rt2x00usb_register_write(rt2x00dev, PBF_CFG, 0xf4000a);
 
@@ -540,9 +539,9 @@ rt2800usb_txdone_entry_check(struct queue_entry *entry, u32 reg)
        tx_pid  = rt2x00_get_field32(word, TXWI_W1_PACKETID);
 
        if (wcid != tx_wcid || ack != tx_ack || (!is_agg && pid != tx_pid)) {
-               DEBUG(entry->queue->rt2x00dev,
-                     "TX status report missed for queue %d entry %d\n",
-                     entry->queue->qid, entry->entry_idx);
+               rt2x00_dbg(entry->queue->rt2x00dev,
+                          "TX status report missed for queue %d entry %d\n",
+                          entry->queue->qid, entry->entry_idx);
                return TXDONE_UNKNOWN;
        }
 
@@ -566,8 +565,8 @@ static void rt2800usb_txdone(struct rt2x00_dev *rt2x00dev)
                queue = rt2x00queue_get_tx_queue(rt2x00dev, qid);
 
                if (unlikely(rt2x00queue_empty(queue))) {
-                       WARNING(rt2x00dev, "Got TX status for an empty "
-                                          "queue %u, dropping\n", qid);
+                       rt2x00_warn(rt2x00dev, "Got TX status for an empty queue %u, dropping\n",
+                                   qid);
                        break;
                }
 
@@ -575,8 +574,8 @@ static void rt2800usb_txdone(struct rt2x00_dev *rt2x00dev)
 
                if (unlikely(test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) ||
                             !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags))) {
-                       WARNING(rt2x00dev, "Data pending for entry %u "
-                                          "in queue %u\n", entry->entry_idx, qid);
+                       rt2x00_warn(rt2x00dev, "Data pending for entry %u in queue %u\n",
+                                   entry->entry_idx, qid);
                        break;
                }
 
@@ -677,8 +676,8 @@ static void rt2800usb_fill_rxdone(struct queue_entry *entry,
         */
        if (unlikely(rx_pkt_len == 0 ||
                        rx_pkt_len > entry->queue->data_size)) {
-               ERROR(entry->queue->rt2x00dev,
-                       "Bad frame size %d, forcing to 0\n", rx_pkt_len);
+               rt2x00_err(entry->queue->rt2x00dev,
+                          "Bad frame size %d, forcing to 0\n", rx_pkt_len);
                return;
        }
 
index 0d02d16ca1662e96d6b57fb75a738888ee4b209f..7510723a8c378389b93b90001efe088118f045bb 100644 (file)
 #define DRV_VERSION    "2.3.0"
 #define DRV_PROJECT    "http://rt2x00.serialmonkey.com"
 
-/*
- * Debug definitions.
+/* Debug definitions.
  * Debug output has to be enabled during compile time.
  */
-#define DEBUG_PRINTK_MSG(__dev, __kernlvl, __lvl, __msg, __args...)    \
-       printk(__kernlvl "%s -> %s: %s - " __msg,                       \
-              wiphy_name((__dev)->hw->wiphy), __func__, __lvl, ##__args)
-
-#define DEBUG_PRINTK_PROBE(__kernlvl, __lvl, __msg, __args...) \
-       printk(__kernlvl "%s -> %s: %s - " __msg,               \
-              KBUILD_MODNAME, __func__, __lvl, ##__args)
-
 #ifdef CONFIG_RT2X00_DEBUG
-#define DEBUG_PRINTK(__dev, __kernlvl, __lvl, __msg, __args...)        \
-       DEBUG_PRINTK_MSG(__dev, __kernlvl, __lvl, __msg, ##__args)
-#else
-#define DEBUG_PRINTK(__dev, __kernlvl, __lvl, __msg, __args...)        \
-       do { } while (0)
+#define DEBUG
 #endif /* CONFIG_RT2X00_DEBUG */
 
-/*
- * Various debug levels.
- * The debug levels PANIC and ERROR both indicate serious problems,
- * for this reason they should never be ignored.
- * The special ERROR_PROBE message is for messages that are generated
- * when the rt2x00_dev is not yet initialized.
+/* Utility printing macros
+ * rt2x00_probe_err is for messages when rt2x00_dev is uninitialized
  */
-#define PANIC(__dev, __msg, __args...) \
-       DEBUG_PRINTK_MSG(__dev, KERN_CRIT, "Panic", __msg, ##__args)
-#define ERROR(__dev, __msg, __args...) \
-       DEBUG_PRINTK_MSG(__dev, KERN_ERR, "Error", __msg, ##__args)
-#define ERROR_PROBE(__msg, __args...) \
-       DEBUG_PRINTK_PROBE(KERN_ERR, "Error", __msg, ##__args)
-#define WARNING(__dev, __msg, __args...) \
-       DEBUG_PRINTK_MSG(__dev, KERN_WARNING, "Warning", __msg, ##__args)
-#define INFO(__dev, __msg, __args...) \
-       DEBUG_PRINTK_MSG(__dev, KERN_INFO, "Info", __msg, ##__args)
-#define DEBUG(__dev, __msg, __args...) \
-       DEBUG_PRINTK(__dev, KERN_DEBUG, "Debug", __msg, ##__args)
-#define EEPROM(__dev, __msg, __args...) \
-       DEBUG_PRINTK(__dev, KERN_DEBUG, "EEPROM recovery", __msg, ##__args)
+#define rt2x00_probe_err(fmt, ...)                                     \
+       printk(KERN_ERR KBUILD_MODNAME ": %s: Error - " fmt,            \
+              __func__, ##__VA_ARGS__)
+#define rt2x00_err(dev, fmt, ...)                                      \
+       wiphy_err((dev)->hw->wiphy, "%s: Error - " fmt,                 \
+                 __func__, ##__VA_ARGS__)
+#define rt2x00_warn(dev, fmt, ...)                                     \
+       wiphy_warn((dev)->hw->wiphy, "%s: Warning - " fmt,              \
+                  __func__, ##__VA_ARGS__)
+#define rt2x00_info(dev, fmt, ...)                                     \
+       wiphy_info((dev)->hw->wiphy, "%s: Info - " fmt,                 \
+                  __func__, ##__VA_ARGS__)
+
+/* Various debug levels */
+#define rt2x00_dbg(dev, fmt, ...)                                      \
+       wiphy_dbg((dev)->hw->wiphy, "%s: Debug - " fmt,                 \
+                 __func__, ##__VA_ARGS__)
+#define rt2x00_eeprom_dbg(dev, fmt, ...)                               \
+       wiphy_dbg((dev)->hw->wiphy, "%s: EEPROM recovery - " fmt,       \
+                 __func__, ##__VA_ARGS__)
 
 /*
  * Duration calculations
@@ -1101,9 +1090,9 @@ static inline void rt2x00_set_chip(struct rt2x00_dev *rt2x00dev,
        rt2x00dev->chip.rf = rf;
        rt2x00dev->chip.rev = rev;
 
-       INFO(rt2x00dev,
-            "Chipset detected - rt: %04x, rf: %04x, rev: %04x.\n",
-            rt2x00dev->chip.rt, rt2x00dev->chip.rf, rt2x00dev->chip.rev);
+       rt2x00_info(rt2x00dev, "Chipset detected - rt: %04x, rf: %04x, rev: %04x\n",
+                   rt2x00dev->chip.rt, rt2x00dev->chip.rf,
+                   rt2x00dev->chip.rev);
 }
 
 static inline void rt2x00_set_rt(struct rt2x00_dev *rt2x00dev,
@@ -1112,15 +1101,16 @@ static inline void rt2x00_set_rt(struct rt2x00_dev *rt2x00dev,
        rt2x00dev->chip.rt = rt;
        rt2x00dev->chip.rev = rev;
 
-       INFO(rt2x00dev, "RT chipset %04x, rev %04x detected\n",
-            rt2x00dev->chip.rt, rt2x00dev->chip.rev);
+       rt2x00_info(rt2x00dev, "RT chipset %04x, rev %04x detected\n",
+                   rt2x00dev->chip.rt, rt2x00dev->chip.rev);
 }
 
 static inline void rt2x00_set_rf(struct rt2x00_dev *rt2x00dev, const u16 rf)
 {
        rt2x00dev->chip.rf = rf;
 
-       INFO(rt2x00dev, "RF chipset %04x detected\n", rt2x00dev->chip.rf);
+       rt2x00_info(rt2x00dev, "RF chipset %04x detected\n",
+                   rt2x00dev->chip.rf);
 }
 
 static inline bool rt2x00_rt(struct rt2x00_dev *rt2x00dev, const u16 rt)
index 3bb8cafbac593b394c166c0c0f3817a93a9a7a41..fe7a7f63a9edc2cf75c0a2caa2f6b8ffe02234aa 100644 (file)
@@ -174,7 +174,7 @@ void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev,
        do_gettimeofday(&timestamp);
 
        if (skb_queue_len(&intf->frame_dump_skbqueue) > 20) {
-               DEBUG(rt2x00dev, "txrx dump queue length exceeded.\n");
+               rt2x00_dbg(rt2x00dev, "txrx dump queue length exceeded\n");
                return;
        }
 
@@ -185,7 +185,7 @@ void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev,
        skbcopy = alloc_skb(sizeof(*dump_hdr) + skbdesc->desc_len + data_len,
                            GFP_ATOMIC);
        if (!skbcopy) {
-               DEBUG(rt2x00dev, "Failed to copy skb for dump.\n");
+               rt2x00_dbg(rt2x00dev, "Failed to copy skb for dump\n");
                return;
        }
 
@@ -657,7 +657,7 @@ void rt2x00debug_register(struct rt2x00_dev *rt2x00dev)
 
        intf = kzalloc(sizeof(struct rt2x00debug_intf), GFP_KERNEL);
        if (!intf) {
-               ERROR(rt2x00dev, "Failed to allocate debug handler.\n");
+               rt2x00_err(rt2x00dev, "Failed to allocate debug handler\n");
                return;
        }
 
@@ -760,7 +760,7 @@ void rt2x00debug_register(struct rt2x00_dev *rt2x00dev)
 
 exit:
        rt2x00debug_deregister(rt2x00dev);
-       ERROR(rt2x00dev, "Failed to register debug handler.\n");
+       rt2x00_err(rt2x00dev, "Failed to register debug handler\n");
 }
 
 void rt2x00debug_deregister(struct rt2x00_dev *rt2x00dev)
index 189744db65e073ec96ff396d7ae8fee46a3c3fcd..90dc14336980c2bcc344a4c5e97d8e4033fa9d95 100644 (file)
@@ -171,7 +171,7 @@ static void rt2x00lib_autowakeup(struct work_struct *work)
                return;
 
        if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_AWAKE))
-               ERROR(rt2x00dev, "Device failed to wakeup.\n");
+               rt2x00_err(rt2x00dev, "Device failed to wakeup\n");
        clear_bit(CONFIG_POWERSAVING, &rt2x00dev->flags);
 }
 
@@ -673,9 +673,8 @@ static int rt2x00lib_rxdone_read_signal(struct rt2x00_dev *rt2x00dev,
                break;
        }
 
-       WARNING(rt2x00dev, "Frame received with unrecognized signal, "
-               "mode=0x%.4x, signal=0x%.4x, type=%d.\n",
-               rxdesc->rate_mode, signal, type);
+       rt2x00_warn(rt2x00dev, "Frame received with unrecognized signal, mode=0x%.4x, signal=0x%.4x, type=%d\n",
+                   rxdesc->rate_mode, signal, type);
        return 0;
 }
 
@@ -720,8 +719,8 @@ void rt2x00lib_rxdone(struct queue_entry *entry, gfp_t gfp)
         */
        if (unlikely(rxdesc.size == 0 ||
                     rxdesc.size > entry->queue->data_size)) {
-               ERROR(rt2x00dev, "Wrong frame size %d max %d.\n",
-                       rxdesc.size, entry->queue->data_size);
+               rt2x00_err(rt2x00dev, "Wrong frame size %d max %d\n",
+                          rxdesc.size, entry->queue->data_size);
                dev_kfree_skb(entry->skb);
                goto renew_skb;
        }
@@ -1006,7 +1005,7 @@ static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
 
  exit_free_channels:
        kfree(channels);
-       ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
+       rt2x00_err(rt2x00dev, "Allocation ieee80211 modes failed\n");
        return -ENOMEM;
 }
 
@@ -1337,7 +1336,7 @@ int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
         */
        retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
        if (retval) {
-               ERROR(rt2x00dev, "Failed to allocate device.\n");
+               rt2x00_err(rt2x00dev, "Failed to allocate device\n");
                goto exit;
        }
 
@@ -1353,7 +1352,7 @@ int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
         */
        retval = rt2x00lib_probe_hw(rt2x00dev);
        if (retval) {
-               ERROR(rt2x00dev, "Failed to initialize hw.\n");
+               rt2x00_err(rt2x00dev, "Failed to initialize hw\n");
                goto exit;
        }
 
@@ -1451,7 +1450,7 @@ EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);
 #ifdef CONFIG_PM
 int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
 {
-       DEBUG(rt2x00dev, "Going to sleep.\n");
+       rt2x00_dbg(rt2x00dev, "Going to sleep\n");
 
        /*
         * Prevent mac80211 from accessing driver while suspended.
@@ -1482,8 +1481,7 @@ int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
         * device is as good as disabled.
         */
        if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP))
-               WARNING(rt2x00dev, "Device failed to enter sleep state, "
-                       "continue suspending.\n");
+               rt2x00_warn(rt2x00dev, "Device failed to enter sleep state, continue suspending\n");
 
        return 0;
 }
@@ -1491,7 +1489,7 @@ EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
 
 int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
 {
-       DEBUG(rt2x00dev, "Waking up.\n");
+       rt2x00_dbg(rt2x00dev, "Waking up\n");
 
        /*
         * Restore/enable extra components.
index f316aad30612d53ac70e22874740f02a09091273..1b4254b4272d089c23c53af030d289f7bbd49c52 100644 (file)
@@ -42,28 +42,28 @@ static int rt2x00lib_request_firmware(struct rt2x00_dev *rt2x00dev)
         */
        fw_name = rt2x00dev->ops->lib->get_firmware_name(rt2x00dev);
        if (!fw_name) {
-               ERROR(rt2x00dev,
-                     "Invalid firmware filename.\n"
-                     "Please file bug report to %s.\n", DRV_PROJECT);
+               rt2x00_err(rt2x00dev,
+                          "Invalid firmware filename\n"
+                          "Please file bug report to %s\n", DRV_PROJECT);
                return -EINVAL;
        }
 
-       INFO(rt2x00dev, "Loading firmware file '%s'.\n", fw_name);
+       rt2x00_info(rt2x00dev, "Loading firmware file '%s'\n", fw_name);
 
        retval = request_firmware(&fw, fw_name, device);
        if (retval) {
-               ERROR(rt2x00dev, "Failed to request Firmware.\n");
+               rt2x00_err(rt2x00dev, "Failed to request Firmware\n");
                return retval;
        }
 
        if (!fw || !fw->size || !fw->data) {
-               ERROR(rt2x00dev, "Failed to read Firmware.\n");
+               rt2x00_err(rt2x00dev, "Failed to read Firmware\n");
                release_firmware(fw);
                return -ENOENT;
        }
 
-       INFO(rt2x00dev, "Firmware detected - version: %d.%d.\n",
-            fw->data[fw->size - 4], fw->data[fw->size - 3]);
+       rt2x00_info(rt2x00dev, "Firmware detected - version: %d.%d\n",
+                   fw->data[fw->size - 4], fw->data[fw->size - 3]);
        snprintf(rt2x00dev->hw->wiphy->fw_version,
                        sizeof(rt2x00dev->hw->wiphy->fw_version), "%d.%d",
                        fw->data[fw->size - 4], fw->data[fw->size - 3]);
@@ -73,15 +73,14 @@ static int rt2x00lib_request_firmware(struct rt2x00_dev *rt2x00dev)
        case FW_OK:
                break;
        case FW_BAD_CRC:
-               ERROR(rt2x00dev, "Firmware checksum error.\n");
+               rt2x00_err(rt2x00dev, "Firmware checksum error\n");
                goto exit;
        case FW_BAD_LENGTH:
-               ERROR(rt2x00dev,
-                     "Invalid firmware file length (len=%zu)\n", fw->size);
+               rt2x00_err(rt2x00dev, "Invalid firmware file length (len=%zu)\n",
+                          fw->size);
                goto exit;
        case FW_BAD_VERSION:
-               ERROR(rt2x00dev,
-                     "Current firmware does not support detected chipset.\n");
+               rt2x00_err(rt2x00dev, "Current firmware does not support detected chipset\n");
                goto exit;
        }
 
index 8679d781a2647e766b1558a31a6b65ff785c962f..997a6c89e66e4f44567cd9c04b99f86a0aae3a6d 100644 (file)
@@ -113,7 +113,7 @@ static int rt2x00leds_register_led(struct rt2x00_dev *rt2x00dev,
 
        retval = led_classdev_register(device, &led->led_dev);
        if (retval) {
-               ERROR(rt2x00dev, "Failed to register led handler.\n");
+               rt2x00_err(rt2x00dev, "Failed to register led handler\n");
                return retval;
        }
 
index 9161c02d8ff9719f9a6702efec55fdc86b6401f2..f883802f350585322338ed7683e065bb85349ff3 100644 (file)
@@ -46,7 +46,7 @@ static int rt2x00mac_tx_rts_cts(struct rt2x00_dev *rt2x00dev,
 
        skb = dev_alloc_skb(data_length + rt2x00dev->hw->extra_tx_headroom);
        if (unlikely(!skb)) {
-               WARNING(rt2x00dev, "Failed to create RTS/CTS frame.\n");
+               rt2x00_warn(rt2x00dev, "Failed to create RTS/CTS frame\n");
                return -ENOMEM;
        }
 
@@ -93,7 +93,7 @@ static int rt2x00mac_tx_rts_cts(struct rt2x00_dev *rt2x00dev,
        retval = rt2x00queue_write_tx_frame(queue, skb, true);
        if (retval) {
                dev_kfree_skb_any(skb);
-               WARNING(rt2x00dev, "Failed to send RTS/CTS frame.\n");
+               rt2x00_warn(rt2x00dev, "Failed to send RTS/CTS frame\n");
        }
 
        return retval;
@@ -126,9 +126,9 @@ void rt2x00mac_tx(struct ieee80211_hw *hw,
 
        queue = rt2x00queue_get_tx_queue(rt2x00dev, qid);
        if (unlikely(!queue)) {
-               ERROR(rt2x00dev,
-                     "Attempt to send packet over invalid queue %d.\n"
-                     "Please file bug report to %s.\n", qid, DRV_PROJECT);
+               rt2x00_err(rt2x00dev,
+                          "Attempt to send packet over invalid queue %d\n"
+                          "Please file bug report to %s\n", qid, DRV_PROJECT);
                goto exit_free_skb;
        }
 
@@ -731,9 +731,10 @@ int rt2x00mac_conf_tx(struct ieee80211_hw *hw,
        queue->aifs = params->aifs;
        queue->txop = params->txop;
 
-       DEBUG(rt2x00dev,
-             "Configured TX queue %d - CWmin: %d, CWmax: %d, Aifs: %d, TXop: %d.\n",
-             queue_idx, queue->cw_min, queue->cw_max, queue->aifs, queue->txop);
+       rt2x00_dbg(rt2x00dev,
+                  "Configured TX queue %d - CWmin: %d, CWmax: %d, Aifs: %d, TXop: %d\n",
+                  queue_idx, queue->cw_min, queue->cw_max, queue->aifs,
+                  queue->txop);
 
        return 0;
 }
index 06c766930b1532b287af20bcfea29527c2cee223..64b06c6abe586d1fda61f79688de66ec12800a16 100644 (file)
@@ -175,8 +175,8 @@ int rt2x00mmio_initialize(struct rt2x00_dev *rt2x00dev)
                             rt2x00dev->ops->lib->irq_handler,
                             IRQF_SHARED, rt2x00dev->name, rt2x00dev);
        if (status) {
-               ERROR(rt2x00dev, "IRQ %d allocation failed (error %d).\n",
-                     rt2x00dev->irq, status);
+               rt2x00_err(rt2x00dev, "IRQ %d allocation failed (error %d)\n",
+                          rt2x00dev->irq, status);
                goto exit;
        }
 
index e87865e331139148c86a19b6efccf6efdaa329e2..dc49e525ae5e55e9a090308b80122998e08857d8 100644 (file)
@@ -68,7 +68,7 @@ static int rt2x00pci_alloc_reg(struct rt2x00_dev *rt2x00dev)
        return 0;
 
 exit:
-       ERROR_PROBE("Failed to allocate registers.\n");
+       rt2x00_probe_err("Failed to allocate registers\n");
 
        rt2x00pci_free_reg(rt2x00dev);
 
@@ -84,30 +84,30 @@ int rt2x00pci_probe(struct pci_dev *pci_dev, const struct rt2x00_ops *ops)
 
        retval = pci_enable_device(pci_dev);
        if (retval) {
-               ERROR_PROBE("Enable device failed.\n");
+               rt2x00_probe_err("Enable device failed\n");
                return retval;
        }
 
        retval = pci_request_regions(pci_dev, pci_name(pci_dev));
        if (retval) {
-               ERROR_PROBE("PCI request regions failed.\n");
+               rt2x00_probe_err("PCI request regions failed\n");
                goto exit_disable_device;
        }
 
        pci_set_master(pci_dev);
 
        if (pci_set_mwi(pci_dev))
-               ERROR_PROBE("MWI not available.\n");
+               rt2x00_probe_err("MWI not available\n");
 
        if (dma_set_mask(&pci_dev->dev, DMA_BIT_MASK(32))) {
-               ERROR_PROBE("PCI DMA not supported.\n");
+               rt2x00_probe_err("PCI DMA not supported\n");
                retval = -EIO;
                goto exit_release_regions;
        }
 
        hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
        if (!hw) {
-               ERROR_PROBE("Failed to allocate hardware.\n");
+               rt2x00_probe_err("Failed to allocate hardware\n");
                retval = -ENOMEM;
                goto exit_release_regions;
        }
@@ -207,7 +207,7 @@ int rt2x00pci_resume(struct pci_dev *pci_dev)
 
        if (pci_set_power_state(pci_dev, PCI_D0) ||
            pci_enable_device(pci_dev)) {
-               ERROR(rt2x00dev, "Failed to resume device.\n");
+               rt2x00_err(rt2x00dev, "Failed to resume device\n");
                return -EIO;
        }
 
index d2f894ef3a2dd9a260c101279253f2fec480bc67..2c12311467a99cd634c7b204eaccc36eb75d2aaa 100644 (file)
@@ -532,10 +532,10 @@ static int rt2x00queue_write_tx_data(struct queue_entry *entry,
         */
        if (unlikely(rt2x00dev->ops->lib->get_entry_state &&
                     rt2x00dev->ops->lib->get_entry_state(entry))) {
-               ERROR(rt2x00dev,
-                     "Corrupt queue %d, accessing entry which is not ours.\n"
-                     "Please file bug report to %s.\n",
-                     entry->queue->qid, DRV_PROJECT);
+               rt2x00_err(rt2x00dev,
+                          "Corrupt queue %d, accessing entry which is not ours\n"
+                          "Please file bug report to %s\n",
+                          entry->queue->qid, DRV_PROJECT);
                return -EINVAL;
        }
 
@@ -699,8 +699,8 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
        spin_lock(&queue->tx_lock);
 
        if (unlikely(rt2x00queue_full(queue))) {
-               ERROR(queue->rt2x00dev,
-                     "Dropping frame due to full tx queue %d.\n", queue->qid);
+               rt2x00_err(queue->rt2x00dev, "Dropping frame due to full tx queue %d\n",
+                          queue->qid);
                ret = -ENOBUFS;
                goto out;
        }
@@ -709,10 +709,10 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
 
        if (unlikely(test_and_set_bit(ENTRY_OWNER_DEVICE_DATA,
                                      &entry->flags))) {
-               ERROR(queue->rt2x00dev,
-                     "Arrived at non-free entry in the non-full queue %d.\n"
-                     "Please file bug report to %s.\n",
-                     queue->qid, DRV_PROJECT);
+               rt2x00_err(queue->rt2x00dev,
+                          "Arrived at non-free entry in the non-full queue %d\n"
+                          "Please file bug report to %s\n",
+                          queue->qid, DRV_PROJECT);
                ret = -EINVAL;
                goto out;
        }
@@ -843,9 +843,9 @@ bool rt2x00queue_for_each_entry(struct data_queue *queue,
        unsigned int i;
 
        if (unlikely(start >= Q_INDEX_MAX || end >= Q_INDEX_MAX)) {
-               ERROR(queue->rt2x00dev,
-                     "Entry requested from invalid index range (%d - %d)\n",
-                     start, end);
+               rt2x00_err(queue->rt2x00dev,
+                          "Entry requested from invalid index range (%d - %d)\n",
+                          start, end);
                return true;
        }
 
@@ -892,8 +892,8 @@ struct queue_entry *rt2x00queue_get_entry(struct data_queue *queue,
        unsigned long irqflags;
 
        if (unlikely(index >= Q_INDEX_MAX)) {
-               ERROR(queue->rt2x00dev,
-                     "Entry requested from invalid index type (%d)\n", index);
+               rt2x00_err(queue->rt2x00dev, "Entry requested from invalid index type (%d)\n",
+                          index);
                return NULL;
        }
 
@@ -913,8 +913,8 @@ void rt2x00queue_index_inc(struct queue_entry *entry, enum queue_index index)
        unsigned long irqflags;
 
        if (unlikely(index >= Q_INDEX_MAX)) {
-               ERROR(queue->rt2x00dev,
-                     "Index change on invalid index type (%d)\n", index);
+               rt2x00_err(queue->rt2x00dev,
+                          "Index change on invalid index type (%d)\n", index);
                return;
        }
 
@@ -1074,7 +1074,8 @@ void rt2x00queue_flush_queue(struct data_queue *queue, bool drop)
         * The queue flush has failed...
         */
        if (unlikely(!rt2x00queue_empty(queue)))
-               WARNING(queue->rt2x00dev, "Queue %d failed to flush\n", queue->qid);
+               rt2x00_warn(queue->rt2x00dev, "Queue %d failed to flush\n",
+                           queue->qid);
 
        /*
         * Restore the queue to the previous status
@@ -1264,7 +1265,7 @@ int rt2x00queue_initialize(struct rt2x00_dev *rt2x00dev)
        return 0;
 
 exit:
-       ERROR(rt2x00dev, "Queue entries allocation failed.\n");
+       rt2x00_err(rt2x00dev, "Queue entries allocation failed\n");
 
        rt2x00queue_uninitialize(rt2x00dev);
 
@@ -1316,7 +1317,7 @@ int rt2x00queue_allocate(struct rt2x00_dev *rt2x00dev)
 
        queue = kcalloc(rt2x00dev->data_queues, sizeof(*queue), GFP_KERNEL);
        if (!queue) {
-               ERROR(rt2x00dev, "Queue allocation failed.\n");
+               rt2x00_err(rt2x00dev, "Queue allocation failed\n");
                return -ENOMEM;
        }
 
index 2aa5c38022f3b7d663eaf2c8d565fc88c8ce1afb..9271a5fce0a81347fbf6327732009bc6136443ee 100644 (file)
@@ -68,7 +68,7 @@ static int rt2x00soc_alloc_reg(struct rt2x00_dev *rt2x00dev)
        return 0;
 
 exit:
-       ERROR_PROBE("Failed to allocate registers.\n");
+       rt2x00_probe_err("Failed to allocate registers\n");
        rt2x00soc_free_reg(rt2x00dev);
 
        return -ENOMEM;
@@ -82,7 +82,7 @@ int rt2x00soc_probe(struct platform_device *pdev, const struct rt2x00_ops *ops)
 
        hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
        if (!hw) {
-               ERROR_PROBE("Failed to allocate hardware.\n");
+               rt2x00_probe_err("Failed to allocate hardware\n");
                return -ENOMEM;
        }
 
index 5e50d4ff9d210b4d22c59d4c624b0a473badee89..88289873c0cfd754790192e670c6e13bb5736933 100644 (file)
@@ -70,9 +70,9 @@ int rt2x00usb_vendor_request(struct rt2x00_dev *rt2x00dev,
                }
        }
 
-       ERROR(rt2x00dev,
-             "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n",
-             request, offset, status);
+       rt2x00_err(rt2x00dev,
+                  "Vendor Request 0x%02x failed for offset 0x%04x with error %d\n",
+                  request, offset, status);
 
        return status;
 }
@@ -91,7 +91,7 @@ int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev *rt2x00dev,
         * Check for Cache availability.
         */
        if (unlikely(!rt2x00dev->csr.cache || buffer_length > CSR_CACHE_SIZE)) {
-               ERROR(rt2x00dev, "CSR cache not available.\n");
+               rt2x00_err(rt2x00dev, "CSR cache not available\n");
                return -ENOMEM;
        }
 
@@ -157,8 +157,8 @@ int rt2x00usb_regbusy_read(struct rt2x00_dev *rt2x00dev,
                udelay(REGISTER_BUSY_DELAY);
        }
 
-       ERROR(rt2x00dev, "Indirect register access failed: "
-             "offset=0x%.08x, value=0x%.08x\n", offset, *reg);
+       rt2x00_err(rt2x00dev, "Indirect register access failed: offset=0x%.08x, value=0x%.08x\n",
+                  offset, *reg);
        *reg = ~0;
 
        return 0;
@@ -307,7 +307,7 @@ static bool rt2x00usb_kick_tx_entry(struct queue_entry *entry, void *data)
        status = skb_padto(entry->skb, length);
        if (unlikely(status)) {
                /* TODO: report something more appropriate than IO_FAILED. */
-               WARNING(rt2x00dev, "TX SKB padding error, out of memory\n");
+               rt2x00_warn(rt2x00dev, "TX SKB padding error, out of memory\n");
                set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
                rt2x00lib_dmadone(entry);
 
@@ -520,8 +520,8 @@ EXPORT_SYMBOL_GPL(rt2x00usb_flush_queue);
 
 static void rt2x00usb_watchdog_tx_dma(struct data_queue *queue)
 {
-       WARNING(queue->rt2x00dev, "TX queue %d DMA timed out,"
-               " invoke forced forced reset\n", queue->qid);
+       rt2x00_warn(queue->rt2x00dev, "TX queue %d DMA timed out, invoke forced forced reset\n",
+                   queue->qid);
 
        rt2x00queue_flush_queue(queue, true);
 }
@@ -622,7 +622,7 @@ static int rt2x00usb_find_endpoints(struct rt2x00_dev *rt2x00dev)
         * At least 1 endpoint for RX and 1 endpoint for TX must be available.
         */
        if (!rt2x00dev->rx->usb_endpoint || !rt2x00dev->tx->usb_endpoint) {
-               ERROR(rt2x00dev, "Bulk-in/Bulk-out endpoints not found\n");
+               rt2x00_err(rt2x00dev, "Bulk-in/Bulk-out endpoints not found\n");
                return -EPIPE;
        }
 
@@ -775,7 +775,7 @@ static int rt2x00usb_alloc_reg(struct rt2x00_dev *rt2x00dev)
        return 0;
 
 exit:
-       ERROR_PROBE("Failed to allocate registers.\n");
+       rt2x00_probe_err("Failed to allocate registers\n");
 
        rt2x00usb_free_reg(rt2x00dev);
 
@@ -795,7 +795,7 @@ int rt2x00usb_probe(struct usb_interface *usb_intf,
 
        hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
        if (!hw) {
-               ERROR_PROBE("Failed to allocate hardware.\n");
+               rt2x00_probe_err("Failed to allocate hardware\n");
                retval = -ENOMEM;
                goto exit_put_device;
        }
index fc99258ae777ee3afef2fcdbd59983a066112e6c..0dc8180e251bf0c1ff33e917db2f94bf15d7c927 100644 (file)
@@ -1309,7 +1309,7 @@ static int rt61pci_load_firmware(struct rt2x00_dev *rt2x00dev,
        }
 
        if (!reg) {
-               ERROR(rt2x00dev, "Unstable hardware.\n");
+               rt2x00_err(rt2x00dev, "Unstable hardware\n");
                return -EBUSY;
        }
 
@@ -1348,7 +1348,7 @@ static int rt61pci_load_firmware(struct rt2x00_dev *rt2x00dev,
        }
 
        if (i == 100) {
-               ERROR(rt2x00dev, "MCU Control register not ready.\n");
+               rt2x00_err(rt2x00dev, "MCU Control register not ready\n");
                return -EBUSY;
        }
 
@@ -1658,7 +1658,7 @@ static int rt61pci_wait_bbp_ready(struct rt2x00_dev *rt2x00dev)
                udelay(REGISTER_BUSY_DELAY);
        }
 
-       ERROR(rt2x00dev, "BBP register access failed, aborting.\n");
+       rt2x00_err(rt2x00dev, "BBP register access failed, aborting\n");
        return -EACCES;
 }
 
@@ -1859,8 +1859,8 @@ static int rt61pci_set_device_state(struct rt2x00_dev *rt2x00dev,
        }
 
        if (unlikely(retval))
-               ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n",
-                     state, retval);
+               rt2x00_err(rt2x00dev, "Device failed to enter state %d (%d)\n",
+                          state, retval);
 
        return retval;
 }
@@ -1999,7 +1999,7 @@ static void rt61pci_write_beacon(struct queue_entry *entry,
         */
        padding_len = roundup(entry->skb->len, 4) - entry->skb->len;
        if (padding_len && skb_pad(entry->skb, padding_len)) {
-               ERROR(rt2x00dev, "Failure padding beacon, aborting\n");
+               rt2x00_err(rt2x00dev, "Failure padding beacon, aborting\n");
                /* skb freed by skb_pad() on failure */
                entry->skb = NULL;
                rt2x00mmio_register_write(rt2x00dev, TXRX_CSR9, orig_reg);
@@ -2210,9 +2210,8 @@ static void rt61pci_txdone(struct rt2x00_dev *rt2x00dev)
                        /* Catch up.
                         * Just report any entries we missed as failed.
                         */
-                       WARNING(rt2x00dev,
-                               "TX status report missed for entry %d\n",
-                               entry_done->entry_idx);
+                       rt2x00_warn(rt2x00dev, "TX status report missed for entry %d\n",
+                                   entry_done->entry_idx);
 
                        rt2x00lib_txdone_noinfo(entry_done, TXDONE_UNKNOWN);
                        entry_done = rt2x00queue_get_entry(queue, Q_INDEX_DONE);
@@ -2419,7 +2418,7 @@ static int rt61pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
        mac = rt2x00_eeprom_addr(rt2x00dev, EEPROM_MAC_ADDR_0);
        if (!is_valid_ether_addr(mac)) {
                eth_random_addr(mac);
-               EEPROM(rt2x00dev, "MAC: %pM\n", mac);
+               rt2x00_eeprom_dbg(rt2x00dev, "MAC: %pM\n", mac);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &word);
@@ -2434,7 +2433,7 @@ static int rt61pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_ANTENNA_HARDWARE_RADIO, 0);
                rt2x00_set_field16(&word, EEPROM_ANTENNA_RF_TYPE, RF5225);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_ANTENNA, word);
-               EEPROM(rt2x00dev, "Antenna: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Antenna: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &word);
@@ -2447,7 +2446,7 @@ static int rt61pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_NIC_CARDBUS_ACCEL, 0);
                rt2x00_set_field16(&word, EEPROM_NIC_EXTERNAL_LNA_A, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_NIC, word);
-               EEPROM(rt2x00dev, "NIC: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "NIC: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_LED, &word);
@@ -2455,7 +2454,7 @@ static int rt61pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_LED_LED_MODE,
                                   LED_MODE_DEFAULT);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_LED, word);
-               EEPROM(rt2x00dev, "Led: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Led: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_FREQ, &word);
@@ -2463,7 +2462,7 @@ static int rt61pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_FREQ_OFFSET, 0);
                rt2x00_set_field16(&word, EEPROM_FREQ_SEQ, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_FREQ, word);
-               EEPROM(rt2x00dev, "Freq: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Freq: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_OFFSET_BG, &word);
@@ -2471,7 +2470,7 @@ static int rt61pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_RSSI_OFFSET_BG_1, 0);
                rt2x00_set_field16(&word, EEPROM_RSSI_OFFSET_BG_2, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_RSSI_OFFSET_BG, word);
-               EEPROM(rt2x00dev, "RSSI OFFSET BG: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "RSSI OFFSET BG: 0x%04x\n", word);
        } else {
                value = rt2x00_get_field16(word, EEPROM_RSSI_OFFSET_BG_1);
                if (value < -10 || value > 10)
@@ -2487,7 +2486,7 @@ static int rt61pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_RSSI_OFFSET_A_1, 0);
                rt2x00_set_field16(&word, EEPROM_RSSI_OFFSET_A_2, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_RSSI_OFFSET_A, word);
-               EEPROM(rt2x00dev, "RSSI OFFSET A: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "RSSI OFFSET A: 0x%04x\n", word);
        } else {
                value = rt2x00_get_field16(word, EEPROM_RSSI_OFFSET_A_1);
                if (value < -10 || value > 10)
@@ -2524,7 +2523,7 @@ static int rt61pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
            !rt2x00_rf(rt2x00dev, RF5325) &&
            !rt2x00_rf(rt2x00dev, RF2527) &&
            !rt2x00_rf(rt2x00dev, RF2529)) {
-               ERROR(rt2x00dev, "Invalid RF chipset detected.\n");
+               rt2x00_err(rt2x00dev, "Invalid RF chipset detected\n");
                return -ENODEV;
        }
 
index a3387b146bb5f77c17ff1e247a6a203d1781faf2..377e09bb0b812cb9c269678a3b6f55696140e48d 100644 (file)
@@ -1122,7 +1122,7 @@ static int rt73usb_load_firmware(struct rt2x00_dev *rt2x00dev,
        }
 
        if (!reg) {
-               ERROR(rt2x00dev, "Unstable hardware.\n");
+               rt2x00_err(rt2x00dev, "Unstable hardware\n");
                return -EBUSY;
        }
 
@@ -1139,7 +1139,7 @@ static int rt73usb_load_firmware(struct rt2x00_dev *rt2x00dev,
                                             0, USB_MODE_FIRMWARE,
                                             REGISTER_TIMEOUT_FIRMWARE);
        if (status < 0) {
-               ERROR(rt2x00dev, "Failed to write Firmware to device.\n");
+               rt2x00_err(rt2x00dev, "Failed to write Firmware to device\n");
                return status;
        }
 
@@ -1305,7 +1305,7 @@ static int rt73usb_wait_bbp_ready(struct rt2x00_dev *rt2x00dev)
                udelay(REGISTER_BUSY_DELAY);
        }
 
-       ERROR(rt2x00dev, "BBP register access failed, aborting.\n");
+       rt2x00_err(rt2x00dev, "BBP register access failed, aborting\n");
        return -EACCES;
 }
 
@@ -1443,8 +1443,8 @@ static int rt73usb_set_device_state(struct rt2x00_dev *rt2x00dev,
        }
 
        if (unlikely(retval))
-               ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n",
-                     state, retval);
+               rt2x00_err(rt2x00dev, "Device failed to enter state %d (%d)\n",
+                          state, retval);
 
        return retval;
 }
@@ -1567,7 +1567,7 @@ static void rt73usb_write_beacon(struct queue_entry *entry,
         */
        padding_len = roundup(entry->skb->len, 4) - entry->skb->len;
        if (padding_len && skb_pad(entry->skb, padding_len)) {
-               ERROR(rt2x00dev, "Failure padding beacon, aborting\n");
+               rt2x00_err(rt2x00dev, "Failure padding beacon, aborting\n");
                /* skb freed by skb_pad() on failure */
                entry->skb = NULL;
                rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, orig_reg);
@@ -1771,7 +1771,7 @@ static int rt73usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
        mac = rt2x00_eeprom_addr(rt2x00dev, EEPROM_MAC_ADDR_0);
        if (!is_valid_ether_addr(mac)) {
                eth_random_addr(mac);
-               EEPROM(rt2x00dev, "MAC: %pM\n", mac);
+               rt2x00_eeprom_dbg(rt2x00dev, "MAC: %pM\n", mac);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &word);
@@ -1786,14 +1786,14 @@ static int rt73usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_ANTENNA_HARDWARE_RADIO, 0);
                rt2x00_set_field16(&word, EEPROM_ANTENNA_RF_TYPE, RF5226);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_ANTENNA, word);
-               EEPROM(rt2x00dev, "Antenna: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Antenna: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &word);
        if (word == 0xffff) {
                rt2x00_set_field16(&word, EEPROM_NIC_EXTERNAL_LNA, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_NIC, word);
-               EEPROM(rt2x00dev, "NIC: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "NIC: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_LED, &word);
@@ -1809,7 +1809,7 @@ static int rt73usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_LED_LED_MODE,
                                   LED_MODE_DEFAULT);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_LED, word);
-               EEPROM(rt2x00dev, "Led: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Led: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_FREQ, &word);
@@ -1817,7 +1817,7 @@ static int rt73usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_FREQ_OFFSET, 0);
                rt2x00_set_field16(&word, EEPROM_FREQ_SEQ, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_FREQ, word);
-               EEPROM(rt2x00dev, "Freq: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "Freq: 0x%04x\n", word);
        }
 
        rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_OFFSET_BG, &word);
@@ -1825,7 +1825,7 @@ static int rt73usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_RSSI_OFFSET_BG_1, 0);
                rt2x00_set_field16(&word, EEPROM_RSSI_OFFSET_BG_2, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_RSSI_OFFSET_BG, word);
-               EEPROM(rt2x00dev, "RSSI OFFSET BG: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "RSSI OFFSET BG: 0x%04x\n", word);
        } else {
                value = rt2x00_get_field16(word, EEPROM_RSSI_OFFSET_BG_1);
                if (value < -10 || value > 10)
@@ -1841,7 +1841,7 @@ static int rt73usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
                rt2x00_set_field16(&word, EEPROM_RSSI_OFFSET_A_1, 0);
                rt2x00_set_field16(&word, EEPROM_RSSI_OFFSET_A_2, 0);
                rt2x00_eeprom_write(rt2x00dev, EEPROM_RSSI_OFFSET_A, word);
-               EEPROM(rt2x00dev, "RSSI OFFSET A: 0x%04x\n", word);
+               rt2x00_eeprom_dbg(rt2x00dev, "RSSI OFFSET A: 0x%04x\n", word);
        } else {
                value = rt2x00_get_field16(word, EEPROM_RSSI_OFFSET_A_1);
                if (value < -10 || value > 10)
@@ -1875,7 +1875,7 @@ static int rt73usb_init_eeprom(struct rt2x00_dev *rt2x00dev)
                        value, rt2x00_get_field32(reg, MAC_CSR0_REVISION));
 
        if (!rt2x00_rt(rt2x00dev, RT2573) || (rt2x00_rev(rt2x00dev) == 0)) {
-               ERROR(rt2x00dev, "Invalid RT chipset detected.\n");
+               rt2x00_err(rt2x00dev, "Invalid RT chipset detected\n");
                return -ENODEV;
        }
 
@@ -1883,7 +1883,7 @@ static int rt73usb_init_eeprom(struct rt2x00_dev *rt2x00dev)
            !rt2x00_rf(rt2x00dev, RF2528) &&
            !rt2x00_rf(rt2x00dev, RF5225) &&
            !rt2x00_rf(rt2x00dev, RF2527)) {
-               ERROR(rt2x00dev, "Invalid RF chipset detected.\n");
+               rt2x00_err(rt2x00dev, "Invalid RF chipset detected\n");
                return -ENODEV;
        }