uwb: use dev_dbg() for debug messages

Instead of the home-grown d_fnstart(), d_fnend() and d_printf() macros,
use dev_dbg() or remove the message entirely.

Signed-off-by: David Vrabel <david.vrabel@csr.com>

7 files changed, 96 insertions, 429 deletions

diff --git a/drivers/usb/wusbcore/crypto.c b/drivers/usb/wusbcore/crypto.c
index 0ca860305feb..9d9128ac8c8e 100644
--- a/drivers/usb/wusbcore/crypto.c
+++ b/drivers/usb/wusbcore/crypto.c
@@ -51,7 +51,6 @@
 #include <linux/uwb.h>
 #include <linux/usb/wusb.h>
 #include <linux/scatterlist.h>
-#define D_LOCAL 0
 #include <linux/uwb/debug.h>
 
 static int debug_crypto_verify = 0;
@@ -207,9 +206,6 @@ static int wusb_ccm_mac(struct crypto_blkcipher *tfm_cbc,
         const u8 bzero[16] = { 0 };
         size_t zero_padding;
 
-        d_fnstart(3, NULL, "(tfm_cbc %p, tfm_aes %p, mic %p, "
-                  "n %p, a %p, b %p, blen %zu)\n",
-                  tfm_cbc, tfm_aes, mic, n, a, b, blen);
         /*
          * These checks should be compile time optimized out
          * ensure @a fills b1's mac_header and following fields
@@ -251,16 +247,6 @@ static int wusb_ccm_mac(struct crypto_blkcipher *tfm_cbc,
         b1.la = cpu_to_be16(blen + 14);
         memcpy(&b1.mac_header, a, sizeof(*a));
 
-        d_printf(4, NULL, "I: B0 (%zu bytes)\n", sizeof(b0));
-        d_dump(4, NULL, &b0, sizeof(b0));
-        d_printf(4, NULL, "I: B1 (%zu bytes)\n", sizeof(b1));
-        d_dump(4, NULL, &b1, sizeof(b1));
-        d_printf(4, NULL, "I: B (%zu bytes)\n", blen);
-        d_dump(4, NULL, b, blen);
-        d_printf(4, NULL, "I: B 0-padding (%zu bytes)\n", zero_padding);
-        d_printf(4, NULL, "D: IV before crypto (%zu)\n", ivsize);
-        d_dump(4, NULL, iv, ivsize);
-
         sg_init_table(sg, ARRAY_SIZE(sg));
         sg_set_buf(&sg[0], &b0, sizeof(b0));
         sg_set_buf(&sg[1], &b1, sizeof(b1));
@@ -277,8 +263,6 @@ static int wusb_ccm_mac(struct crypto_blkcipher *tfm_cbc,
                        result);
                 goto error_cbc_crypt;
         }
-        d_printf(4, NULL, "D: MIC tag\n");
-        d_dump(4, NULL, iv, ivsize);
 
         /* Now we crypt the MIC Tag (*iv) with Ax -- values per WUSB1.0[6.5]
          * The procedure is to AES crypt the A0 block and XOR the MIC
@@ -293,17 +277,10 @@ static int wusb_ccm_mac(struct crypto_blkcipher *tfm_cbc,
         ax.counter = 0;
         crypto_cipher_encrypt_one(tfm_aes, (void *)&ax, (void *)&ax);
         bytewise_xor(mic, &ax, iv, 8);
-        d_printf(4, NULL, "D: CTR[MIC]\n");
-        d_dump(4, NULL, &ax, 8);
-        d_printf(4, NULL, "D: CCM-MIC tag\n");
-        d_dump(4, NULL, mic, 8);
         result = 8;
 error_cbc_crypt:
         kfree(dst_buf);
 error_dst_buf:
-        d_fnend(3, NULL, "(tfm_cbc %p, tfm_aes %p, mic %p, "
-                "n %p, a %p, b %p, blen %zu)\n",
-                tfm_cbc, tfm_aes, mic, n, a, b, blen);
         return result;
 }
 
@@ -325,10 +302,6 @@ ssize_t wusb_prf(void *out, size_t out_size,
         u64 sfn = 0;
         __le64 sfn_le;
 
-        d_fnstart(3, NULL, "(out %p, out_size %zu, key %p, _n %p, "
-                  "a %p, b %p, blen %zu, len %zu)\n", out, out_size,
-                  key, _n, a, b, blen, len);
-
         tfm_cbc = crypto_alloc_blkcipher("cbc(aes)", 0, CRYPTO_ALG_ASYNC);
         if (IS_ERR(tfm_cbc)) {
                 result = PTR_ERR(tfm_cbc);
@@ -370,9 +343,6 @@ error_alloc_aes:
 error_setkey_cbc:
         crypto_free_blkcipher(tfm_cbc);
 error_alloc_cbc:
-        d_fnend(3, NULL, "(out %p, out_size %zu, key %p, _n %p, "
-                "a %p, b %p, blen %zu, len %zu) = %d\n", out, out_size,
-                key, _n, a, b, blen, len, (int)bytes);
         return result;
 }
 
diff --git a/drivers/usb/wusbcore/dev-sysfs.c b/drivers/usb/wusbcore/dev-sysfs.c
index 7897a19652e5..101834576236 100644
--- a/drivers/usb/wusbcore/dev-sysfs.c
+++ b/drivers/usb/wusbcore/dev-sysfs.c
@@ -28,10 +28,6 @@
 #include <linux/workqueue.h>
 #include "wusbhc.h"
 
-#undef D_LOCAL
-#define D_LOCAL 4
-#include <linux/uwb/debug.h>
-
 static ssize_t wusb_disconnect_store(struct device *dev,
                                      struct device_attribute *attr,
                                      const char *buf, size_t size)
diff --git a/drivers/usb/wusbcore/devconnect.c b/drivers/usb/wusbcore/devconnect.c
index 26cbc89ea281..e2e7e4bc8463 100644
--- a/drivers/usb/wusbcore/devconnect.c
+++ b/drivers/usb/wusbcore/devconnect.c
@@ -91,10 +91,6 @@
 #include <linux/workqueue.h>
 #include "wusbhc.h"
 
-#undef D_LOCAL
-#define D_LOCAL 1
-#include <linux/uwb/debug.h>
-
 static void wusbhc_devconnect_acked_work(struct work_struct *work);
 
 static void wusb_dev_free(struct wusb_dev *wusb_dev)
@@ -234,6 +230,7 @@ static struct wusb_dev *wusbhc_cack_add(struct wusbhc *wusbhc,
         list_add_tail(&wusb_dev->cack_node, &wusbhc->cack_list);
         wusbhc->cack_count++;
         wusbhc_fill_cack_ie(wusbhc);
+
         return wusb_dev;
 }
 
@@ -244,12 +241,9 @@ static struct wusb_dev *wusbhc_cack_add(struct wusbhc *wusbhc,
  */
 static void wusbhc_cack_rm(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 {
-        struct device *dev = wusbhc->dev;
-        d_fnstart(3, dev, "(wusbhc %p wusb_dev %p)\n", wusbhc, wusb_dev);
         list_del_init(&wusb_dev->cack_node);
         wusbhc->cack_count--;
         wusbhc_fill_cack_ie(wusbhc);
-        d_fnend(3, dev, "(wusbhc %p wusb_dev %p) = void\n", wusbhc, wusb_dev);
 }
 
 /*
@@ -257,14 +251,11 @@ static void wusbhc_cack_rm(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 static
 void wusbhc_devconnect_acked(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 {
-        struct device *dev = wusbhc->dev;
-        d_fnstart(3, dev, "(wusbhc %p wusb_dev %p)\n", wusbhc, wusb_dev);
         wusbhc_cack_rm(wusbhc, wusb_dev);
         if (wusbhc->cack_count)
                 wusbhc_mmcie_set(wusbhc, 0, 0, &wusbhc->cack_ie.hdr);
         else
                 wusbhc_mmcie_rm(wusbhc, &wusbhc->cack_ie.hdr);
-        d_fnend(3, dev, "(wusbhc %p wusb_dev %p) = void\n", wusbhc, wusb_dev);
 }
 
 static void wusbhc_devconnect_acked_work(struct work_struct *work)
@@ -314,7 +305,6 @@ void wusbhc_devconnect_ack(struct wusbhc *wusbhc, struct wusb_dn_connect *dnc,
         struct wusb_port *port;
         unsigned idx, devnum;
 
-        d_fnstart(3, dev, "(%p, %p, %s)\n", wusbhc, dnc, pr_cdid);
         mutex_lock(&wusbhc->mutex);
 
         /* Check we are not handling it already */
@@ -367,7 +357,6 @@ void wusbhc_devconnect_ack(struct wusbhc *wusbhc, struct wusb_dn_connect *dnc,
          */
 error_unlock:
         mutex_unlock(&wusbhc->mutex);
-        d_fnend(3, dev, "(%p, %p, %s) = void\n", wusbhc, dnc, pr_cdid);
         return;
 
 }
@@ -390,10 +379,8 @@ error_unlock:
 static void __wusbhc_dev_disconnect(struct wusbhc *wusbhc,
                                     struct wusb_port *port)
 {
-        struct device *dev = wusbhc->dev;
         struct wusb_dev *wusb_dev = port->wusb_dev;
 
-        d_fnstart(3, dev, "(wusbhc %p, port %p)\n", wusbhc, port);
         port->status &= ~(USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE
                           | USB_PORT_STAT_SUSPEND | USB_PORT_STAT_RESET
                           | USB_PORT_STAT_LOW_SPEED | USB_PORT_STAT_HIGH_SPEED);
@@ -410,7 +397,6 @@ static void __wusbhc_dev_disconnect(struct wusbhc *wusbhc,
          * section 6.2.11.2). */
         wusbhc_gtk_rekey(wusbhc);
 
-        d_fnend(3, dev, "(wusbhc %p, port %p) = void\n", wusbhc, port);
         /* The Wireless USB part has forgotten about the device already; now
          * khubd's timer will pick up the disconnection and remove the USB
          * device from the system
@@ -535,10 +521,6 @@ static struct wusb_dev *wusbhc_find_dev_by_addr(struct wusbhc *wusbhc, u8 addr)
  */
 static void wusbhc_handle_dn_alive(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 {
-        struct device *dev = wusbhc->dev;
-
-        d_printf(2, dev, "DN ALIVE: device 0x%02x pong\n", wusb_dev->addr);
-
         mutex_lock(&wusbhc->mutex);
         wusb_dev->entry_ts = jiffies;
         __wusbhc_keep_alive(wusbhc);
@@ -571,11 +553,10 @@ static void wusbhc_handle_dn_connect(struct wusbhc *wusbhc,
                 "no-beacon"
         };
 
-        d_fnstart(3, dev, "(%p, %p, %zu)\n", wusbhc, dn_hdr, size);
         if (size < sizeof(*dnc)) {
                 dev_err(dev, "DN CONNECT: short notification (%zu < %zu)\n",
                         size, sizeof(*dnc));
-                goto out;
+                return;
         }
 
         dnc = container_of(dn_hdr, struct wusb_dn_connect, hdr);
@@ -587,10 +568,6 @@ static void wusbhc_handle_dn_connect(struct wusbhc *wusbhc,
                  wusb_dn_connect_new_connection(dnc) ? "connect" : "reconnect");
         /* ACK the connect */
         wusbhc_devconnect_ack(wusbhc, dnc, pr_cdid);
-out:
-        d_fnend(3, dev, "(%p, %p, %zu) = void\n",
-                wusbhc, dn_hdr, size);
-        return;
 }
 
 /*
@@ -631,19 +608,17 @@ void wusbhc_handle_dn(struct wusbhc *wusbhc, u8 srcaddr,
         struct device *dev = wusbhc->dev;
         struct wusb_dev *wusb_dev;
 
-        d_fnstart(3, dev, "(%p, %p)\n", wusbhc, dn_hdr);
-
         if (size < sizeof(struct wusb_dn_hdr)) {
                 dev_err(dev, "DN data shorter than DN header (%d < %d)\n",
                         (int)size, (int)sizeof(struct wusb_dn_hdr));
-                goto out;
+                return;
         }
 
         wusb_dev = wusbhc_find_dev_by_addr(wusbhc, srcaddr);
         if (wusb_dev == NULL && dn_hdr->bType != WUSB_DN_CONNECT) {
                 dev_dbg(dev, "ignoring DN %d from unconnected device %02x\n",
                         dn_hdr->bType, srcaddr);
-                goto out;
+                return;
         }
 
         switch (dn_hdr->bType) {
@@ -668,9 +643,6 @@ void wusbhc_handle_dn(struct wusbhc *wusbhc, u8 srcaddr,
                 dev_warn(dev, "unknown DN %u (%d octets) from %u\n",
                          dn_hdr->bType, (int)size, srcaddr);
         }
-out:
-        d_fnend(3, dev, "(%p, %p) = void\n", wusbhc, dn_hdr);
-        return;
 }
 EXPORT_SYMBOL_GPL(wusbhc_handle_dn);
 
@@ -700,59 +672,30 @@ void __wusbhc_dev_disable(struct wusbhc *wusbhc, u8 port_idx)
         struct wusb_dev *wusb_dev;
         struct wuie_disconnect *ie;
 
-        d_fnstart(3, dev, "(%p, %u)\n", wusbhc, port_idx);
-        result = 0;
         wusb_dev = wusb_port_by_idx(wusbhc, port_idx)->wusb_dev;
         if (wusb_dev == NULL) {
                 /* reset no device? ignore */
                 dev_dbg(dev, "DISCONNECT: no device at port %u, ignoring\n",
                         port_idx);
-                goto error;
+                return;
         }
         __wusbhc_dev_disconnect(wusbhc, wusb_port_by_idx(wusbhc, port_idx));
 
-        result = -ENOMEM;
         ie = kzalloc(sizeof(*ie), GFP_KERNEL);
         if (ie == NULL)
-                goto error;
+                return;
         ie->hdr.bLength = sizeof(*ie);
         ie->hdr.bIEIdentifier = WUIE_ID_DEVICE_DISCONNECT;
         ie->bDeviceAddress = wusb_dev->addr;
         result = wusbhc_mmcie_set(wusbhc, 0, 0, &ie->hdr);
-        if (result < 0) {
+        if (result < 0)
                 dev_err(dev, "DISCONNECT: can't set MMC: %d\n", result);
-                goto error_kfree;
+        else {
+                /* At least 6 MMCs, assuming at least 1 MMC per zone. */
+                msleep(7*4);
+                wusbhc_mmcie_rm(wusbhc, &ie->hdr);
         }
-
-        /* 120ms, hopefully 6 MMCs */
-        msleep(100);
-        wusbhc_mmcie_rm(wusbhc, &ie->hdr);
-error_kfree:
         kfree(ie);
-error:
-        d_fnend(3, dev, "(%p, %u) = %d\n", wusbhc, port_idx, result);
-        return;
-}
-
-static void wusb_cap_descr_printf(const unsigned level, struct device *dev,
-                                  const struct usb_wireless_cap_descriptor *wcd)
-{
-        d_printf(level, dev,
-                 "WUSB Capability Descriptor\n"
-                 "  bDevCapabilityType          0x%02x\n"
-                 "  bmAttributes                0x%02x\n"
-                 "  wPhyRates                   0x%04x\n"
-                 "  bmTFITXPowerInfo            0x%02x\n"
-                 "  bmFFITXPowerInfo            0x%02x\n"
-                 "  bmBandGroup                 0x%04x\n"
-                 "  bReserved                   0x%02x\n",
-                 wcd->bDevCapabilityType,
-                 wcd->bmAttributes,
-                 le16_to_cpu(wcd->wPHYRates),
-                 wcd->bmTFITXPowerInfo,
-                 wcd->bmFFITXPowerInfo,
-                 wcd->bmBandGroup,
-                 wcd->bReserved);
 }
 
 /*
@@ -795,8 +738,6 @@ static int wusb_dev_bos_grok(struct usb_device *usb_dev,
                 }
                 cap_size = cap_hdr->bLength;
                 cap_type = cap_hdr->bDevCapabilityType;
-                d_printf(4, dev, "BOS Capability: 0x%02x (%zu bytes)\n",
-                         cap_type, cap_size);
                 if (cap_size == 0)
                         break;
                 if (cap_size > top - itr) {
@@ -808,7 +749,6 @@ static int wusb_dev_bos_grok(struct usb_device *usb_dev,
                         result = -EBADF;
                         goto error_bad_cap;
                 }
-                d_dump(3, dev, itr, cap_size);
                 switch (cap_type) {
                 case USB_CAP_TYPE_WIRELESS_USB:
                         if (cap_size != sizeof(*wusb_dev->wusb_cap_descr))
@@ -816,10 +756,8 @@ static int wusb_dev_bos_grok(struct usb_device *usb_dev,
                                         "descriptor is %zu bytes vs %zu "
                                         "needed\n", cap_size,
                                         sizeof(*wusb_dev->wusb_cap_descr));
-                        else {
+                        else
                                 wusb_dev->wusb_cap_descr = itr;
-                                wusb_cap_descr_printf(3, dev, itr);
-                        }
                         break;
                 default:
                         dev_err(dev, "BUG? Unknown BOS capability 0x%02x "
@@ -884,9 +822,7 @@ static int wusb_dev_bos_add(struct usb_device *usb_dev,
                         "%zu bytes): %zd\n", desc_size, result);
                 goto error_get_descriptor;
         }
-        d_printf(2, dev, "Got BOS descriptor %zd bytes, %u capabilities\n",
-                 result, bos->bNumDeviceCaps);
-        d_dump(2, dev, bos, result);
+
         result = wusb_dev_bos_grok(usb_dev, wusb_dev, bos, result);
         if (result < 0)
                 goto error_bad_bos;
@@ -952,8 +888,6 @@ static void wusb_dev_add_ncb(struct usb_device *usb_dev)
         if (usb_dev->wusb == 0 || usb_dev->devnum == 1)
                 return;         /* skip non wusb and wusb RHs */
 
-        d_fnstart(3, dev, "(usb_dev %p)\n", usb_dev);
-
         wusbhc = wusbhc_get_by_usb_dev(usb_dev);
         if (wusbhc == NULL)
                 goto error_nodev;
@@ -983,7 +917,6 @@ out:
         wusb_dev_put(wusb_dev);
         wusbhc_put(wusbhc);
 error_nodev:
-        d_fnend(3, dev, "(usb_dev %p) = void\n", usb_dev);
         return;
 
         wusb_dev_sysfs_rm(wusb_dev);
@@ -1070,11 +1003,10 @@ EXPORT_SYMBOL_GPL(__wusb_dev_get_by_usb_dev);
 
 void wusb_dev_destroy(struct kref *_wusb_dev)
 {
-        struct wusb_dev *wusb_dev
-                = container_of(_wusb_dev, struct wusb_dev, refcnt);
+        struct wusb_dev *wusb_dev = container_of(_wusb_dev, struct wusb_dev, refcnt);
+
         list_del_init(&wusb_dev->cack_node);
         wusb_dev_free(wusb_dev);
-        d_fnend(1, NULL, "%s (wusb_dev %p) = void\n", __func__, wusb_dev);
 }
 EXPORT_SYMBOL_GPL(wusb_dev_destroy);
 
@@ -1086,8 +1018,6 @@ EXPORT_SYMBOL_GPL(wusb_dev_destroy);
  */
 int wusbhc_devconnect_create(struct wusbhc *wusbhc)
 {
-        d_fnstart(3, wusbhc->dev, "(wusbhc %p)\n", wusbhc);
-
         wusbhc->keep_alive_ie.hdr.bIEIdentifier = WUIE_ID_KEEP_ALIVE;
         wusbhc->keep_alive_ie.hdr.bLength = sizeof(wusbhc->keep_alive_ie.hdr);
         INIT_DELAYED_WORK(&wusbhc->keep_alive_timer, wusbhc_keep_alive_run);
@@ -1096,7 +1026,6 @@ int wusbhc_devconnect_create(struct wusbhc *wusbhc)
         wusbhc->cack_ie.hdr.bLength = sizeof(wusbhc->cack_ie.hdr);
         INIT_LIST_HEAD(&wusbhc->cack_list);
 
-        d_fnend(3, wusbhc->dev, "(wusbhc %p) = void\n", wusbhc);
         return 0;
 }
 
@@ -1105,8 +1034,7 @@ int wusbhc_devconnect_create(struct wusbhc *wusbhc)
  */
 void wusbhc_devconnect_destroy(struct wusbhc *wusbhc)
 {
-        d_fnstart(3, wusbhc->dev, "(wusbhc %p)\n", wusbhc);
-        d_fnend(3, wusbhc->dev, "(wusbhc %p) = void\n", wusbhc);
+        /* no op */
 }
 
 /*
diff --git a/drivers/usb/wusbcore/rh.c b/drivers/usb/wusbcore/rh.c
index 1c733192ec2a..95c6fa3bf6b2 100644
--- a/drivers/usb/wusbcore/rh.c
+++ b/drivers/usb/wusbcore/rh.c
@@ -71,9 +71,6 @@
  */
 #include "wusbhc.h"
 
-#define D_LOCAL 0
-#include <linux/uwb/debug.h>
-
 /*
  * Reset a fake port
  *
@@ -142,7 +139,6 @@ int wusbhc_rh_status_data(struct usb_hcd *usb_hcd, char *_buf)
         size_t cnt, size;
         unsigned long *buf = (unsigned long *) _buf;
 
-        d_fnstart(1, wusbhc->dev, "(wusbhc %p)\n", wusbhc);
         /* WE DON'T LOCK, see comment */
         size = wusbhc->ports_max + 1 /* hub bit */;
         size = (size + 8 - 1) / 8;      /* round to bytes */
@@ -151,8 +147,6 @@ int wusbhc_rh_status_data(struct usb_hcd *usb_hcd, char *_buf)
                         set_bit(cnt + 1, buf);
                 else
                         clear_bit(cnt + 1, buf);
-        d_fnend(1, wusbhc->dev, "(wusbhc %p) %u, buffer:\n", wusbhc, (int)size);
-        d_dump(1, wusbhc->dev, _buf, size);
         return size;
 }
 EXPORT_SYMBOL_GPL(wusbhc_rh_status_data);
@@ -201,9 +195,7 @@ static int wusbhc_rh_get_hub_descr(struct wusbhc *wusbhc, u16 wValue,
 static int wusbhc_rh_clear_hub_feat(struct wusbhc *wusbhc, u16 feature)
 {
         int result;
-        struct device *dev = wusbhc->dev;
 
-        d_fnstart(4, dev, "(%p, feature 0x%04u)\n", wusbhc, feature);
         switch (feature) {
         case C_HUB_LOCAL_POWER:
                 /* FIXME: maybe plug bit 0 to the power input status,
@@ -215,7 +207,6 @@ static int wusbhc_rh_clear_hub_feat(struct wusbhc *wusbhc, u16 feature)
         default:
                 result = -EPIPE;
         }
-        d_fnend(4, dev, "(%p, feature 0x%04u), %d\n", wusbhc, feature, result);
         return result;
 }
 
@@ -242,14 +233,10 @@ static int wusbhc_rh_get_hub_status(struct wusbhc *wusbhc, u32 *buf,
 static int wusbhc_rh_set_port_feat(struct wusbhc *wusbhc, u16 feature,
                                    u8 selector, u8 port_idx)
 {
-        int result = -EINVAL;
         struct device *dev = wusbhc->dev;
 
-        d_fnstart(4, dev, "(feat 0x%04u, selector 0x%u, port_idx %d)\n",
-                  feature, selector, port_idx);
-
         if (port_idx > wusbhc->ports_max)
-                goto error;
+                return -EINVAL;
 
         switch (feature) {
                 /* According to USB2.0[11.24.2.13]p2, these features
@@ -259,35 +246,27 @@ static int wusbhc_rh_set_port_feat(struct wusbhc *wusbhc, u16 feature,
         case USB_PORT_FEAT_C_SUSPEND:
         case USB_PORT_FEAT_C_CONNECTION:
         case USB_PORT_FEAT_C_RESET:
-                result = 0;
-                break;
-
+                return 0;
         case USB_PORT_FEAT_POWER:
                 /* No such thing, but we fake it works */
                 mutex_lock(&wusbhc->mutex);
                 wusb_port_by_idx(wusbhc, port_idx)->status |= USB_PORT_STAT_POWER;
                 mutex_unlock(&wusbhc->mutex);
-                result = 0;
-                break;
+                return 0;
         case USB_PORT_FEAT_RESET:
-                result = wusbhc_rh_port_reset(wusbhc, port_idx);
-                break;
+                return wusbhc_rh_port_reset(wusbhc, port_idx);
         case USB_PORT_FEAT_ENABLE:
         case USB_PORT_FEAT_SUSPEND:
                 dev_err(dev, "(port_idx %d) set feat %d/%d UNIMPLEMENTED\n",
                         port_idx, feature, selector);
-                result = -ENOSYS;
-                break;
+                return -ENOSYS;
         default:
                 dev_err(dev, "(port_idx %d) set feat %d/%d UNKNOWN\n",
                         port_idx, feature, selector);
-                result = -EPIPE;
-                break;
+                return -EPIPE;
         }
-error:
-        d_fnend(4, dev, "(feat 0x%04u, selector 0x%u, port_idx %d) = %d\n",
-                feature, selector, port_idx, result);
-        return result;
+
+        return 0;
 }
 
 /*
@@ -298,17 +277,13 @@ error:
 static int wusbhc_rh_clear_port_feat(struct wusbhc *wusbhc, u16 feature,
                                      u8 selector, u8 port_idx)
 {
-        int result = -EINVAL;
+        int result = 0;
         struct device *dev = wusbhc->dev;
 
-        d_fnstart(4, dev, "(wusbhc %p feat 0x%04x selector %d port_idx %d)\n",
-                  wusbhc, feature, selector, port_idx);
-
         if (port_idx > wusbhc->ports_max)
-                goto error;
+                return -EINVAL;
 
         mutex_lock(&wusbhc->mutex);
-        result = 0;
         switch (feature) {
         case USB_PORT_FEAT_POWER:       /* fake port always on */
                 /* According to USB2.0[11.24.2.7.1.4], no need to implement? */
@@ -328,10 +303,8 @@ static int wusbhc_rh_clear_port_feat(struct wusbhc *wusbhc, u16 feature,
                 break;
         case USB_PORT_FEAT_SUSPEND:
         case USB_PORT_FEAT_C_SUSPEND:
-        case 0xffff:            /* ??? FIXME */
                 dev_err(dev, "(port_idx %d) Clear feat %d/%d UNIMPLEMENTED\n",
                         port_idx, feature, selector);
-                /* dump_stack(); */
                 result = -ENOSYS;
                 break;
         default:
@@ -341,9 +314,7 @@ static int wusbhc_rh_clear_port_feat(struct wusbhc *wusbhc, u16 feature,
                 break;
         }
         mutex_unlock(&wusbhc->mutex);
-error:
-        d_fnend(4, dev, "(wusbhc %p feat 0x%04x selector %d port_idx %d) = "
-                "%d\n", wusbhc, feature, selector, port_idx, result);
+
         return result;
 }
 
@@ -355,22 +326,17 @@ error:
 static int wusbhc_rh_get_port_status(struct wusbhc *wusbhc, u16 port_idx,
                                      u32 *_buf, u16 wLength)
 {
-        int result = -EINVAL;
         u16 *buf = (u16 *) _buf;
 
-        d_fnstart(1, wusbhc->dev, "(wusbhc %p port_idx %u wLength %u)\n",
-                  wusbhc, port_idx, wLength);
         if (port_idx > wusbhc->ports_max)
-                goto error;
+                return -EINVAL;
+
         mutex_lock(&wusbhc->mutex);
         buf[0] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->status);
         buf[1] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->change);
-        result = 0;
         mutex_unlock(&wusbhc->mutex);
-error:
-        d_fnend(1, wusbhc->dev, "(wusbhc %p) = %d, buffer:\n", wusbhc, result);
-        d_dump(1, wusbhc->dev, _buf, wLength);
-        return result;
+
+        return 0;
 }
 
 /*
diff --git a/drivers/usb/wusbcore/security.c b/drivers/usb/wusbcore/security.c
index ac00640bba64..f4aa28eca70d 100644
--- a/drivers/usb/wusbcore/security.c
+++ b/drivers/usb/wusbcore/security.c
@@ -27,19 +27,6 @@
 #include <linux/random.h>
 #include "wusbhc.h"
 
-/*
- * DEBUG & SECURITY WARNING!!!!
- *
- * If you enable this past 1, the debug code will weaken the
- * cryptographic safety of the system (on purpose, for debugging).
- *
- * Weaken means:
- *   we print secret keys and intermediate values all the way,
- */
-#undef D_LOCAL
-#define D_LOCAL 2
-#include <linux/uwb/debug.h>
-
 static void wusbhc_set_gtk_callback(struct urb *urb);
 static void wusbhc_gtk_rekey_done_work(struct work_struct *work);
 
@@ -219,7 +206,6 @@ int wusb_dev_sec_add(struct wusbhc *wusbhc,
         const void *itr, *top;
         char buf[64];
 
-        d_fnstart(3, dev, "(usb_dev %p, wusb_dev %p)\n", usb_dev, wusb_dev);
         result = usb_get_descriptor(usb_dev, USB_DT_SECURITY,
                                     0, &secd, sizeof(secd));
         if (result < sizeof(secd)) {
@@ -228,8 +214,6 @@ int wusb_dev_sec_add(struct wusbhc *wusbhc,
                 goto error_secd;
         }
         secd_size = le16_to_cpu(secd.wTotalLength);
-        d_printf(5, dev, "got %d bytes of sec descriptor, total is %d\n",
-                 result, secd_size);
         secd_buf = kmalloc(secd_size, GFP_KERNEL);
         if (secd_buf == NULL) {
                 dev_err(dev, "Can't allocate space for security descriptors\n");
@@ -242,7 +226,6 @@ int wusb_dev_sec_add(struct wusbhc *wusbhc,
                         "not enough data: %d\n", result);
                 goto error_secd_all;
         }
-        d_printf(5, dev, "got %d bytes of sec descriptors\n", result);
         bytes = 0;
         itr = secd_buf + sizeof(secd);
         top = secd_buf + result;
@@ -279,14 +262,12 @@ int wusb_dev_sec_add(struct wusbhc *wusbhc,
                 goto error_no_ccm1;
         }
         wusb_dev->ccm1_etd = *ccm1_etd;
-        dev_info(dev, "supported encryption: %s; using %s (0x%02x/%02x)\n",
-                 buf, wusb_et_name(ccm1_etd->bEncryptionType),
-                 ccm1_etd->bEncryptionValue, ccm1_etd->bAuthKeyIndex);
+        dev_dbg(dev, "supported encryption: %s; using %s (0x%02x/%02x)\n",
+                buf, wusb_et_name(ccm1_etd->bEncryptionType),
+                ccm1_etd->bEncryptionValue, ccm1_etd->bAuthKeyIndex);
         result = 0;
         kfree(secd_buf);
 out:
-        d_fnend(3, dev, "(usb_dev %p, wusb_dev %p) = %d\n",
-                usb_dev, wusb_dev, result);
         return result;
 
 
@@ -303,32 +284,6 @@ void wusb_dev_sec_rm(struct wusb_dev *wusb_dev)
         /* Nothing so far */
 }
 
-static void hs_printk(unsigned level, struct device *dev,
-                      struct usb_handshake *hs)
-{
-        d_printf(level, dev,
-                 "  bMessageNumber: %u\n"
-                 "  bStatus:        %u\n"
-                 "  tTKID:          %02x %02x %02x\n"
-                 "  CDID:           %02x %02x %02x %02x %02x %02x %02x %02x\n"
-                 "                  %02x %02x %02x %02x %02x %02x %02x %02x\n"
-                 "  nonce:          %02x %02x %02x %02x %02x %02x %02x %02x\n"
-                 "                  %02x %02x %02x %02x %02x %02x %02x %02x\n"
-                 "  MIC:            %02x %02x %02x %02x %02x %02x %02x %02x\n",
-                 hs->bMessageNumber, hs->bStatus,
-                 hs->tTKID[2], hs->tTKID[1], hs->tTKID[0],
-                 hs->CDID[0], hs->CDID[1], hs->CDID[2], hs->CDID[3],
-                 hs->CDID[4], hs->CDID[5], hs->CDID[6], hs->CDID[7],
-                 hs->CDID[8], hs->CDID[9], hs->CDID[10], hs->CDID[11],
-                 hs->CDID[12], hs->CDID[13], hs->CDID[14], hs->CDID[15],
-                 hs->nonce[0], hs->nonce[1], hs->nonce[2], hs->nonce[3],
-                 hs->nonce[4], hs->nonce[5], hs->nonce[6], hs->nonce[7],
-                 hs->nonce[8], hs->nonce[9], hs->nonce[10], hs->nonce[11],
-                 hs->nonce[12], hs->nonce[13], hs->nonce[14], hs->nonce[15],
-                 hs->MIC[0], hs->MIC[1], hs->MIC[2], hs->MIC[3],
-                 hs->MIC[4], hs->MIC[5], hs->MIC[6], hs->MIC[7]);
-}
-
 /**
  * Update the address of an unauthenticated WUSB device
  *
@@ -421,9 +376,6 @@ int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
         get_random_bytes(&hs[0].nonce, sizeof(hs[0].nonce));
         memset(hs[0].MIC, 0, sizeof(hs[0].MIC));        /* Per WUSB1.0[T7-22] */
 
-        d_printf(1, dev, "I: sending hs1:\n");
-        hs_printk(2, dev, &hs[0]);
-
         result = usb_control_msg(
                 usb_dev, usb_sndctrlpipe(usb_dev, 0),
                 USB_REQ_SET_HANDSHAKE,
@@ -444,8 +396,6 @@ int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
                 dev_err(dev, "Handshake2: request failed: %d\n", result);
                 goto error_hs2;
         }
-        d_printf(1, dev, "got HS2:\n");
-        hs_printk(2, dev, &hs[1]);
 
         result = -EINVAL;
         if (hs[1].bMessageNumber != 2) {
@@ -486,10 +436,6 @@ int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
                         result);
                 goto error_hs2;
         }
-        d_printf(2, dev, "KCK:\n");
-        d_dump(2, dev, keydvt_out.kck, sizeof(keydvt_out.kck));
-        d_printf(2, dev, "PTK:\n");
-        d_dump(2, dev, keydvt_out.ptk, sizeof(keydvt_out.ptk));
 
         /* Compute MIC and verify it */
         result = wusb_oob_mic(mic, keydvt_out.kck, &ccm_n, &hs[1]);
@@ -499,8 +445,6 @@ int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
                 goto error_hs2;
         }
 
-        d_printf(2, dev, "MIC:\n");
-        d_dump(2, dev, mic, sizeof(mic));
         if (memcmp(hs[1].MIC, mic, sizeof(hs[1].MIC))) {
                 dev_err(dev, "Handshake2 failed: MIC mismatch\n");
                 goto error_hs2;
@@ -520,9 +464,6 @@ int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
                 goto error_hs2;
         }
 
-        d_printf(1, dev, "I: sending hs3:\n");
-        hs_printk(2, dev, &hs[2]);
-
         result = usb_control_msg(
                 usb_dev, usb_sndctrlpipe(usb_dev, 0),
                 USB_REQ_SET_HANDSHAKE,
@@ -533,14 +474,11 @@ int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
                 goto error_hs3;
         }
 
-        d_printf(1, dev, "I: turning on encryption on host for device\n");
-        d_dump(2, dev, keydvt_out.ptk, sizeof(keydvt_out.ptk));
         result = wusbhc->set_ptk(wusbhc, wusb_dev->port_idx, tkid,
                                  keydvt_out.ptk, sizeof(keydvt_out.ptk));
         if (result < 0)
                 goto error_wusbhc_set_ptk;
 
-        d_printf(1, dev, "I: setting a GTK\n");
         result = wusb_dev_set_gtk(wusbhc, wusb_dev);
         if (result < 0) {
                 dev_err(dev, "Set GTK for device: request failed: %d\n",
@@ -550,13 +488,12 @@ int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
 
         /* Update the device's address from unauth to auth */
         if (usb_dev->authenticated == 0) {
-                d_printf(1, dev, "I: updating addres to auth from non-auth\n");
                 result = wusb_dev_update_address(wusbhc, wusb_dev);
                 if (result < 0)
                         goto error_dev_update_address;
         }
         result = 0;
-        d_printf(1, dev, "I: 4way handshke done, device authenticated\n");
+        dev_info(dev, "device authenticated\n");
 
 error_dev_update_address:
 error_wusbhc_set_gtk:
@@ -569,10 +506,8 @@ error_hs1:
         memset(&keydvt_in, 0, sizeof(keydvt_in));
         memset(&ccm_n, 0, sizeof(ccm_n));
         memset(mic, 0, sizeof(mic));
-        if (result < 0) {
-                /* error path */
+        if (result < 0)
                 wusb_dev_set_encryption(usb_dev, 0);
-        }
 error_dev_set_encryption:
         kfree(hs);
 error_kzalloc:
diff --git a/drivers/usb/wusbcore/wa-rpipe.c b/drivers/usb/wusbcore/wa-rpipe.c
index f18e4aae66e9..7369655f69cd 100644
--- a/drivers/usb/wusbcore/wa-rpipe.c
+++ b/drivers/usb/wusbcore/wa-rpipe.c
@@ -60,13 +60,10 @@
 #include <linux/init.h>
 #include <asm/atomic.h>
 #include <linux/bitmap.h>
+
 #include "wusbhc.h"
 #include "wa-hc.h"
 
-#define D_LOCAL 0
-#include <linux/uwb/debug.h>
-
-
 static int __rpipe_get_descr(struct wahc *wa,
                              struct usb_rpipe_descriptor *descr, u16 index)
 {
@@ -76,7 +73,6 @@ static int __rpipe_get_descr(struct wahc *wa,
         /* Get the RPIPE descriptor -- we cannot use the usb_get_descriptor()
          * function because the arguments are different.
          */
-        d_printf(1, dev, "rpipe %u: get descr\n", index);
         result = usb_control_msg(
                 wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
                 USB_REQ_GET_DESCRIPTOR,
@@ -115,7 +111,6 @@ static int __rpipe_set_descr(struct wahc *wa,
         /* we cannot use the usb_get_descriptor() function because the
          * arguments are different.
          */
-        d_printf(1, dev, "rpipe %u: set descr\n", index);
         result = usb_control_msg(
                 wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
                 USB_REQ_SET_DESCRIPTOR,
@@ -174,13 +169,12 @@ void rpipe_destroy(struct kref *_rpipe)
 {
         struct wa_rpipe *rpipe = container_of(_rpipe, struct wa_rpipe, refcnt);
         u8 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
-        d_fnstart(1, NULL, "(rpipe %p %u)\n", rpipe, index);
+
         if (rpipe->ep)
                 rpipe->ep->hcpriv = NULL;
         rpipe_put_idx(rpipe->wa, index);
         wa_put(rpipe->wa);
         kfree(rpipe);
-        d_fnend(1, NULL, "(rpipe %p %u)\n", rpipe, index);
 }
 EXPORT_SYMBOL_GPL(rpipe_destroy);
 
@@ -202,7 +196,6 @@ static int rpipe_get_idle(struct wa_rpipe **prpipe, struct wahc *wa, u8 crs,
         struct wa_rpipe *rpipe;
         struct device *dev = &wa->usb_iface->dev;
 
-        d_fnstart(3, dev, "(wa %p crs 0x%02x)\n", wa, crs);
         rpipe = kzalloc(sizeof(*rpipe), gfp);
         if (rpipe == NULL)
                 return -ENOMEM;
@@ -223,14 +216,12 @@ static int rpipe_get_idle(struct wa_rpipe **prpipe, struct wahc *wa, u8 crs,
         }
         *prpipe = NULL;
         kfree(rpipe);
-        d_fnend(3, dev, "(wa %p crs 0x%02x) = -ENXIO\n", wa, crs);
         return -ENXIO;
 
 found:
         set_bit(rpipe_idx, wa->rpipe_bm);
         rpipe->wa = wa_get(wa);
         *prpipe = rpipe;
-        d_fnstart(3, dev, "(wa %p crs 0x%02x) = 0\n", wa, crs);
         return 0;
 }
 
@@ -239,7 +230,6 @@ static int __rpipe_reset(struct wahc *wa, unsigned index)
         int result;
         struct device *dev = &wa->usb_iface->dev;
 
-        d_printf(1, dev, "rpipe %u: reset\n", index);
         result = usb_control_msg(
                 wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
                 USB_REQ_RPIPE_RESET,
@@ -276,7 +266,6 @@ static struct usb_wireless_ep_comp_descriptor *rpipe_epc_find(
         struct usb_descriptor_header *hdr;
         struct usb_wireless_ep_comp_descriptor *epcd;
 
-        d_fnstart(3, dev, "(ep %p)\n", ep);
         if (ep->desc.bEndpointAddress == 0) {
                 epcd = &epc0;
                 goto out;
@@ -310,7 +299,6 @@ static struct usb_wireless_ep_comp_descriptor *rpipe_epc_find(
                 itr_size -= hdr->bDescriptorType;
         }
 out:
-        d_fnend(3, dev, "(ep %p) = %p\n", ep, epcd);
         return epcd;
 }
 
@@ -329,8 +317,6 @@ static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa,
         struct usb_wireless_ep_comp_descriptor *epcd;
         u8 unauth;
 
-        d_fnstart(3, dev, "(rpipe %p wa %p ep %p, urb %p)\n",
-                    rpipe, wa, ep, urb);
         epcd = rpipe_epc_find(dev, ep);
         if (epcd == NULL) {
                 dev_err(dev, "ep 0x%02x: can't find companion descriptor\n",
@@ -350,10 +336,12 @@ static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa,
         /* FIXME: use maximum speed as supported or recommended by device */
         rpipe->descr.bSpeed = usb_pipeendpoint(urb->pipe) == 0 ?
                 UWB_PHY_RATE_53 : UWB_PHY_RATE_200;
-        d_printf(2, dev, "addr %u (0x%02x) rpipe #%u ep# %u speed %d\n",
-                 urb->dev->devnum, urb->dev->devnum | unauth,
-                 le16_to_cpu(rpipe->descr.wRPipeIndex),
-                 usb_pipeendpoint(urb->pipe), rpipe->descr.bSpeed);
+
+        dev_dbg(dev, "addr %u (0x%02x) rpipe #%u ep# %u speed %d\n",
+                urb->dev->devnum, urb->dev->devnum | unauth,
+                le16_to_cpu(rpipe->descr.wRPipeIndex),
+                usb_pipeendpoint(urb->pipe), rpipe->descr.bSpeed);
+
         /* see security.c:wusb_update_address() */
         if (unlikely(urb->dev->devnum == 0x80))
                 rpipe->descr.bDeviceAddress = 0;
@@ -384,8 +372,6 @@ static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa,
         }
         result = 0;
 error:
-        d_fnend(3, dev, "(rpipe %p wa %p ep %p urb %p) = %d\n",
-                  rpipe, wa, ep, urb, result);
         return result;
 }
 
@@ -405,8 +391,6 @@ static int rpipe_check_aim(const struct wa_rpipe *rpipe, const struct wahc *wa,
         u8 unauth = (usb_dev->wusb && !usb_dev->authenticated) ? 0x80 : 0;
         u8 portnum = wusb_port_no_to_idx(urb->dev->portnum);
 
-        d_fnstart(3, dev, "(rpipe %p wa %p ep %p, urb %p)\n",
-                    rpipe, wa, ep, urb);
 #define AIM_CHECK(rdf, val, text)                                       \
         do {                                                            \
                 if (rpipe->descr.rdf != (val)) {                        \
@@ -451,8 +435,6 @@ int rpipe_get_by_ep(struct wahc *wa, struct usb_host_endpoint *ep,
         struct wa_rpipe *rpipe;
         u8 eptype;
 
-        d_fnstart(3, dev, "(wa %p ep %p urb %p gfp 0x%08x)\n", wa, ep, urb,
-                  gfp);
         mutex_lock(&wa->rpipe_mutex);
         rpipe = ep->hcpriv;
         if (rpipe != NULL) {
@@ -462,9 +444,9 @@ int rpipe_get_by_ep(struct wahc *wa, struct usb_host_endpoint *ep,
                                 goto error;
                 }
                 __rpipe_get(rpipe);
-                d_printf(2, dev, "ep 0x%02x: reusing rpipe %u\n",
-                         ep->desc.bEndpointAddress,
-                         le16_to_cpu(rpipe->descr.wRPipeIndex));
+                dev_dbg(dev, "ep 0x%02x: reusing rpipe %u\n",
+                        ep->desc.bEndpointAddress,
+                        le16_to_cpu(rpipe->descr.wRPipeIndex));
         } else {
                 /* hmm, assign idle rpipe, aim it */
                 result = -ENOBUFS;
@@ -480,14 +462,12 @@ int rpipe_get_by_ep(struct wahc *wa, struct usb_host_endpoint *ep,
                 ep->hcpriv = rpipe;
                 rpipe->ep = ep;
                 __rpipe_get(rpipe);     /* for caching into ep->hcpriv */
-                d_printf(2, dev, "ep 0x%02x: using rpipe %u\n",
-                         ep->desc.bEndpointAddress,
-                         le16_to_cpu(rpipe->descr.wRPipeIndex));
+                dev_dbg(dev, "ep 0x%02x: using rpipe %u\n",
+                        ep->desc.bEndpointAddress,
+                        le16_to_cpu(rpipe->descr.wRPipeIndex));
         }
-        d_dump(4, dev, &rpipe->descr, sizeof(rpipe->descr));
 error:
         mutex_unlock(&wa->rpipe_mutex);
-        d_fnend(3, dev, "(wa %p ep %p urb %p gfp 0x%08x)\n", wa, ep, urb, gfp);
         return result;
 }
 
@@ -507,7 +487,7 @@ int wa_rpipes_create(struct wahc *wa)
 void wa_rpipes_destroy(struct wahc *wa)
 {
         struct device *dev = &wa->usb_iface->dev;
-        d_fnstart(3, dev, "(wa %p)\n", wa);
+
         if (!bitmap_empty(wa->rpipe_bm, wa->rpipes)) {
                 char buf[256];
                 WARN_ON(1);
@@ -515,7 +495,6 @@ void wa_rpipes_destroy(struct wahc *wa)
                 dev_err(dev, "BUG: pipes not released on exit: %s\n", buf);
         }
         kfree(wa->rpipe_bm);
-        d_fnend(3, dev, "(wa %p)\n", wa);
 }
 
 /*
@@ -530,33 +509,20 @@ void wa_rpipes_destroy(struct wahc *wa)
  */
 void rpipe_ep_disable(struct wahc *wa, struct usb_host_endpoint *ep)
 {
-        struct device *dev = &wa->usb_iface->dev;
         struct wa_rpipe *rpipe;
-        d_fnstart(2, dev, "(wa %p ep %p)\n", wa, ep);
+
         mutex_lock(&wa->rpipe_mutex);
         rpipe = ep->hcpriv;
         if (rpipe != NULL) {
-                unsigned rc = atomic_read(&rpipe->refcnt.refcount);
-                int result;
                 u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
 
-                if (rc != 1)
-                        d_printf(1, dev, "(wa %p ep %p) rpipe %p refcnt %u\n",
-                                 wa, ep, rpipe, rc);
-
-                d_printf(1, dev, "rpipe %u: abort\n", index);
-                result = usb_control_msg(
+                usb_control_msg(
                         wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
                         USB_REQ_RPIPE_ABORT,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                         0, index, NULL, 0, 1000 /* FIXME: arbitrary */);
-                if (result < 0 && result != -ENODEV /* dev is gone */)
-                        d_printf(1, dev, "(wa %p rpipe %u): abort failed: %d\n",
-                                 wa, index, result);
                 rpipe_put(rpipe);
         }
         mutex_unlock(&wa->rpipe_mutex);
-        d_fnend(2, dev, "(wa %p ep %p)\n", wa, ep);
-        return;
 }
 EXPORT_SYMBOL_GPL(rpipe_ep_disable);
diff --git a/drivers/usb/wusbcore/wa-xfer.c b/drivers/usb/wusbcore/wa-xfer.c
index c038635d1c64..238a96aee3a1 100644
--- a/drivers/usb/wusbcore/wa-xfer.c
+++ b/drivers/usb/wusbcore/wa-xfer.c
@@ -82,13 +82,10 @@
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/hash.h>
+
 #include "wa-hc.h"
 #include "wusbhc.h"
 
-#undef D_LOCAL
-#define D_LOCAL 0 /* 0 disabled, > 0 different levels... */
-#include <linux/uwb/debug.h>
-
 enum {
         WA_SEGS_MAX = 255,
 };
@@ -180,7 +177,6 @@ static void wa_xfer_destroy(struct kref *_xfer)
                 }
         }
         kfree(xfer);
-        d_printf(2, NULL, "xfer %p destroyed\n", xfer);
 }
 
 static void wa_xfer_get(struct wa_xfer *xfer)
@@ -190,10 +186,7 @@ static void wa_xfer_get(struct wa_xfer *xfer)
 
 static void wa_xfer_put(struct wa_xfer *xfer)
 {
-        d_fnstart(3, NULL, "(xfer %p) -- ref count bef put %d\n",
-                    xfer, atomic_read(&xfer->refcnt.refcount));
         kref_put(&xfer->refcnt, wa_xfer_destroy);
-        d_fnend(3, NULL, "(xfer %p) = void\n", xfer);
 }
 
 /*
@@ -209,7 +202,7 @@ static void wa_xfer_put(struct wa_xfer *xfer)
 static void wa_xfer_giveback(struct wa_xfer *xfer)
 {
         unsigned long flags;
-        d_fnstart(3, NULL, "(xfer %p)\n", xfer);
+
         spin_lock_irqsave(&xfer->wa->xfer_list_lock, flags);
         list_del_init(&xfer->list_node);
         spin_unlock_irqrestore(&xfer->wa->xfer_list_lock, flags);
@@ -217,7 +210,6 @@ static void wa_xfer_giveback(struct wa_xfer *xfer)
         wusbhc_giveback_urb(xfer->wa->wusb, xfer->urb, xfer->result);
         wa_put(xfer->wa);
         wa_xfer_put(xfer);
-        d_fnend(3, NULL, "(xfer %p) = void\n", xfer);
 }
 
 /*
@@ -227,13 +219,10 @@ static void wa_xfer_giveback(struct wa_xfer *xfer)
  */
 static void wa_xfer_completion(struct wa_xfer *xfer)
 {
-        d_fnstart(3, NULL, "(xfer %p)\n", xfer);
         if (xfer->wusb_dev)
                 wusb_dev_put(xfer->wusb_dev);
         rpipe_put(xfer->ep->hcpriv);
         wa_xfer_giveback(xfer);
-        d_fnend(3, NULL, "(xfer %p) = void\n", xfer);
-        return;
 }
 
 /*
@@ -243,12 +232,12 @@ static void wa_xfer_completion(struct wa_xfer *xfer)
  */
 static unsigned __wa_xfer_is_done(struct wa_xfer *xfer)
 {
+        struct device *dev = &xfer->wa->usb_iface->dev;
         unsigned result, cnt;
         struct wa_seg *seg;
         struct urb *urb = xfer->urb;
         unsigned found_short = 0;
 
-        d_fnstart(3, NULL, "(xfer %p)\n", xfer);
         result = xfer->segs_done == xfer->segs_submitted;
         if (result == 0)
                 goto out;
@@ -258,10 +247,8 @@ static unsigned __wa_xfer_is_done(struct wa_xfer *xfer)
                 switch (seg->status) {
                 case WA_SEG_DONE:
                         if (found_short && seg->result > 0) {
-                                if (printk_ratelimit())
-                                        printk(KERN_ERR "xfer %p#%u: bad short "
-                                               "segments (%zu)\n", xfer, cnt,
-                                               seg->result);
+                                dev_dbg(dev, "xfer %p#%u: bad short segments (%zu)\n",
+                                        xfer, cnt, seg->result);
                                 urb->status = -EINVAL;
                                 goto out;
                         }
@@ -269,36 +256,30 @@ static unsigned __wa_xfer_is_done(struct wa_xfer *xfer)
                         if (seg->result < xfer->seg_size
                             && cnt != xfer->segs-1)
                                 found_short = 1;
-                        d_printf(2, NULL, "xfer %p#%u: DONE short %d "
-                                 "result %zu urb->actual_length %d\n",
-                                 xfer, seg->index, found_short, seg->result,
-                                 urb->actual_length);
+                        dev_dbg(dev, "xfer %p#%u: DONE short %d "
+                                "result %zu urb->actual_length %d\n",
+                                xfer, seg->index, found_short, seg->result,
+                                urb->actual_length);
                         break;
                 case WA_SEG_ERROR:
                         xfer->result = seg->result;
-                        d_printf(2, NULL, "xfer %p#%u: ERROR result %zu\n",
-                                 xfer, seg->index, seg->result);
+                        dev_dbg(dev, "xfer %p#%u: ERROR result %zu\n",
+                                xfer, seg->index, seg->result);
                         goto out;
                 case WA_SEG_ABORTED:
-                        WARN_ON(urb->status != -ECONNRESET
-                                && urb->status != -ENOENT);
-                        d_printf(2, NULL, "xfer %p#%u ABORTED: result %d\n",
-                                 xfer, seg->index, urb->status);
+                        dev_dbg(dev, "xfer %p#%u ABORTED: result %d\n",
+                                xfer, seg->index, urb->status);
                         xfer->result = urb->status;
                         goto out;
                 default:
-                        /* if (printk_ratelimit()) */
-                                printk(KERN_ERR "xfer %p#%u: "
-                                       "is_done bad state %d\n",
-                                       xfer, cnt, seg->status);
+                        dev_warn(dev, "xfer %p#%u: is_done bad state %d\n",
+                                 xfer, cnt, seg->status);
                         xfer->result = -EINVAL;
-                        WARN_ON(1);
                         goto out;
                 }
         }
         xfer->result = 0;
 out:
-        d_fnend(3, NULL, "(xfer %p) = void\n", xfer);
         return result;
 }
 
@@ -424,8 +405,6 @@ static ssize_t __wa_xfer_setup_sizes(struct wa_xfer *xfer,
         struct urb *urb = xfer->urb;
         struct wa_rpipe *rpipe = xfer->ep->hcpriv;
 
-        d_fnstart(3, dev, "(xfer %p [rpipe %p] urb %p)\n",
-                  xfer, rpipe, urb);
         switch (rpipe->descr.bmAttribute & 0x3) {
         case USB_ENDPOINT_XFER_CONTROL:
                 *pxfer_type = WA_XFER_TYPE_CTL;
@@ -472,12 +451,10 @@ static ssize_t __wa_xfer_setup_sizes(struct wa_xfer *xfer,
         if (xfer->segs == 0 && *pxfer_type == WA_XFER_TYPE_CTL)
                 xfer->segs = 1;
 error:
-        d_fnend(3, dev, "(xfer %p [rpipe %p] urb %p) = %d\n",
-                xfer, rpipe, urb, (int)result);
         return result;
 }
 
-/** Fill in the common request header and xfer-type specific data. */
+/* Fill in the common request header and xfer-type specific data. */
 static void __wa_xfer_setup_hdr0(struct wa_xfer *xfer,
                                  struct wa_xfer_hdr *xfer_hdr0,
                                  enum wa_xfer_type xfer_type,
@@ -534,14 +511,13 @@ static void wa_seg_dto_cb(struct urb *urb)
         unsigned rpipe_ready = 0;
         u8 done = 0;
 
-        d_fnstart(3, NULL, "(urb %p [%d])\n", urb, urb->status);
         switch (urb->status) {
         case 0:
                 spin_lock_irqsave(&xfer->lock, flags);
                 wa = xfer->wa;
                 dev = &wa->usb_iface->dev;
-                d_printf(2, dev, "xfer %p#%u: data out done (%d bytes)\n",
-                           xfer, seg->index, urb->actual_length);
+                dev_dbg(dev, "xfer %p#%u: data out done (%d bytes)\n",
+                        xfer, seg->index, urb->actual_length);
                 if (seg->status < WA_SEG_PENDING)
                         seg->status = WA_SEG_PENDING;
                 seg->result = urb->actual_length;
@@ -555,9 +531,8 @@ static void wa_seg_dto_cb(struct urb *urb)
                 wa = xfer->wa;
                 dev = &wa->usb_iface->dev;
                 rpipe = xfer->ep->hcpriv;
-                if (printk_ratelimit())
-                        dev_err(dev, "xfer %p#%u: data out error %d\n",
-                                xfer, seg->index, urb->status);
+                dev_dbg(dev, "xfer %p#%u: data out error %d\n",
+                        xfer, seg->index, urb->status);
                 if (edc_inc(&wa->nep_edc, EDC_MAX_ERRORS,
                             EDC_ERROR_TIMEFRAME)){
                         dev_err(dev, "DTO: URB max acceptable errors "
@@ -578,7 +553,6 @@ static void wa_seg_dto_cb(struct urb *urb)
                 if (rpipe_ready)
                         wa_xfer_delayed_run(rpipe);
         }
-        d_fnend(3, NULL, "(urb %p [%d]) = void\n", urb, urb->status);
 }
 
 /*
@@ -610,14 +584,12 @@ static void wa_seg_cb(struct urb *urb)
         unsigned rpipe_ready;
         u8 done = 0;
 
-        d_fnstart(3, NULL, "(urb %p [%d])\n", urb, urb->status);
         switch (urb->status) {
         case 0:
                 spin_lock_irqsave(&xfer->lock, flags);
                 wa = xfer->wa;
                 dev = &wa->usb_iface->dev;
-                d_printf(2, dev, "xfer %p#%u: request done\n",
-                           xfer, seg->index);
+                dev_dbg(dev, "xfer %p#%u: request done\n", xfer, seg->index);
                 if (xfer->is_inbound && seg->status < WA_SEG_PENDING)
                         seg->status = WA_SEG_PENDING;
                 spin_unlock_irqrestore(&xfer->lock, flags);
@@ -652,7 +624,6 @@ static void wa_seg_cb(struct urb *urb)
                 if (rpipe_ready)
                         wa_xfer_delayed_run(rpipe);
         }
-        d_fnend(3, NULL, "(urb %p [%d]) = void\n", urb, urb->status);
 }
 
 /*
@@ -750,9 +721,6 @@ static int __wa_xfer_setup(struct wa_xfer *xfer, struct urb *urb)
         size_t xfer_hdr_size, cnt, transfer_size;
         struct wa_xfer_hdr *xfer_hdr0, *xfer_hdr;
 
-        d_fnstart(3, dev, "(xfer %p [rpipe %p] urb %p)\n",
-                  xfer, xfer->ep->hcpriv, urb);
-
         result = __wa_xfer_setup_sizes(xfer, &xfer_type);
         if (result < 0)
                 goto error_setup_sizes;
@@ -788,8 +756,6 @@ static int __wa_xfer_setup(struct wa_xfer *xfer, struct urb *urb)
         result = 0;
 error_setup_segs:
 error_setup_sizes:
-        d_fnend(3, dev, "(xfer %p [rpipe %p] urb %p) = %d\n",
-                xfer, xfer->ep->hcpriv, urb, result);
         return result;
 }
 
@@ -843,9 +809,6 @@ static void wa_xfer_delayed_run(struct wa_rpipe *rpipe)
         struct wa_xfer *xfer;
         unsigned long flags;
 
-        d_fnstart(1, dev, "(rpipe #%d) %d segments available\n",
-                  le16_to_cpu(rpipe->descr.wRPipeIndex),
-                  atomic_read(&rpipe->segs_available));
         spin_lock_irqsave(&rpipe->seg_lock, flags);
         while (atomic_read(&rpipe->segs_available) > 0
               && !list_empty(&rpipe->seg_list)) {
@@ -854,10 +817,8 @@ static void wa_xfer_delayed_run(struct wa_rpipe *rpipe)
                 list_del(&seg->list_node);
                 xfer = seg->xfer;
                 result = __wa_seg_submit(rpipe, xfer, seg);
-                d_printf(1, dev, "xfer %p#%u submitted from delayed "
-                         "[%d segments available] %d\n",
-                         xfer, seg->index,
-                         atomic_read(&rpipe->segs_available), result);
+                dev_dbg(dev, "xfer %p#%u submitted from delayed [%d segments available] %d\n",
+                        xfer, seg->index, atomic_read(&rpipe->segs_available), result);
                 if (unlikely(result < 0)) {
                         spin_unlock_irqrestore(&rpipe->seg_lock, flags);
                         spin_lock_irqsave(&xfer->lock, flags);
@@ -868,10 +829,6 @@ static void wa_xfer_delayed_run(struct wa_rpipe *rpipe)
                 }
         }
         spin_unlock_irqrestore(&rpipe->seg_lock, flags);
-        d_fnend(1, dev, "(rpipe #%d) = void, %d segments available\n",
-                le16_to_cpu(rpipe->descr.wRPipeIndex),
-                atomic_read(&rpipe->segs_available));
-
 }
 
 /*
@@ -894,9 +851,6 @@ static int __wa_xfer_submit(struct wa_xfer *xfer)
         u8 available;
         u8 empty;
 
-        d_fnstart(3, dev, "(xfer %p [rpipe %p])\n",
-                  xfer, xfer->ep->hcpriv);
-
         spin_lock_irqsave(&wa->xfer_list_lock, flags);
         list_add_tail(&xfer->list_node, &wa->xfer_list);
         spin_unlock_irqrestore(&wa->xfer_list_lock, flags);
@@ -908,30 +862,24 @@ static int __wa_xfer_submit(struct wa_xfer *xfer)
                 available = atomic_read(&rpipe->segs_available);
                 empty = list_empty(&rpipe->seg_list);
                 seg = xfer->seg[cnt];
-                d_printf(2, dev, "xfer %p#%u: available %u empty %u (%s)\n",
-                         xfer, cnt, available, empty,
-                         available == 0 || !empty ? "delayed" : "submitted");
+                dev_dbg(dev, "xfer %p#%u: available %u empty %u (%s)\n",
+                        xfer, cnt, available, empty,
+                        available == 0 || !empty ? "delayed" : "submitted");
                 if (available == 0 || !empty) {
-                        d_printf(1, dev, "xfer %p#%u: delayed\n", xfer, cnt);
+                        dev_dbg(dev, "xfer %p#%u: delayed\n", xfer, cnt);
                         seg->status = WA_SEG_DELAYED;
                         list_add_tail(&seg->list_node, &rpipe->seg_list);
                 } else {
                         result = __wa_seg_submit(rpipe, xfer, seg);
-                        if (result < 0)
+                        if (result < 0) {
+                                __wa_xfer_abort(xfer);
                                 goto error_seg_submit;
+                        }
                 }
                 xfer->segs_submitted++;
         }
-        spin_unlock_irqrestore(&rpipe->seg_lock, flags);
-        d_fnend(3, dev, "(xfer %p [rpipe %p]) = void\n", xfer,
-                xfer->ep->hcpriv);
-        return result;
-
 error_seg_submit:
-        __wa_xfer_abort(xfer);
         spin_unlock_irqrestore(&rpipe->seg_lock, flags);
-        d_fnend(3, dev, "(xfer %p [rpipe %p]) = void\n", xfer,
-                xfer->ep->hcpriv);
         return result;
 }
 
@@ -964,11 +912,9 @@ static void wa_urb_enqueue_b(struct wa_xfer *xfer)
         struct urb *urb = xfer->urb;
         struct wahc *wa = xfer->wa;
         struct wusbhc *wusbhc = wa->wusb;
-        struct device *dev = &wa->usb_iface->dev;
         struct wusb_dev *wusb_dev;
         unsigned done;
 
-        d_fnstart(3, dev, "(wa %p urb %p)\n", wa, urb);
         result = rpipe_get_by_ep(wa, xfer->ep, urb, xfer->gfp);
         if (result < 0)
                 goto error_rpipe_get;
@@ -997,7 +943,6 @@ static void wa_urb_enqueue_b(struct wa_xfer *xfer)
         if (result < 0)
                 goto error_xfer_submit;
         spin_unlock_irqrestore(&xfer->lock, flags);
-        d_fnend(3, dev, "(wa %p urb %p) = void\n", wa, urb);
         return;
 
         /* this is basically wa_xfer_completion() broken up wa_xfer_giveback()
@@ -1015,7 +960,6 @@ error_dev_gone:
 error_rpipe_get:
         xfer->result = result;
         wa_xfer_giveback(xfer);
-        d_fnend(3, dev, "(wa %p urb %p) = (void) %d\n", wa, urb, result);
         return;
 
 error_xfer_submit:
@@ -1024,8 +968,6 @@ error_xfer_submit:
         spin_unlock_irqrestore(&xfer->lock, flags);
         if (done)
                 wa_xfer_completion(xfer);
-        d_fnend(3, dev, "(wa %p urb %p) = (void) %d\n", wa, urb, result);
-        return;
 }
 
 /*
@@ -1041,11 +983,9 @@ error_xfer_submit:
 void wa_urb_enqueue_run(struct work_struct *ws)
 {
         struct wahc *wa = container_of(ws, struct wahc, xfer_work);
-        struct device *dev = &wa->usb_iface->dev;
         struct wa_xfer *xfer, *next;
         struct urb *urb;
 
-        d_fnstart(3, dev, "(wa %p)\n", wa);
         spin_lock_irq(&wa->xfer_list_lock);
         list_for_each_entry_safe(xfer, next, &wa->xfer_delayed_list,
                                  list_node) {
@@ -1059,7 +999,6 @@ void wa_urb_enqueue_run(struct work_struct *ws)
                 spin_lock_irq(&wa->xfer_list_lock);
         }
         spin_unlock_irq(&wa->xfer_list_lock);
-        d_fnend(3, dev, "(wa %p) = void\n", wa);
 }
 EXPORT_SYMBOL_GPL(wa_urb_enqueue_run);
 
@@ -1084,9 +1023,6 @@ int wa_urb_enqueue(struct wahc *wa, struct usb_host_endpoint *ep,
         unsigned long my_flags;
         unsigned cant_sleep = irqs_disabled() | in_atomic();
 
-        d_fnstart(3, dev, "(wa %p ep %p urb %p [%d] gfp 0x%x)\n",
-                  wa, ep, urb, urb->transfer_buffer_length, gfp);
-
         if (urb->transfer_buffer == NULL
             && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
             && urb->transfer_buffer_length != 0) {
@@ -1108,11 +1044,13 @@ int wa_urb_enqueue(struct wahc *wa, struct usb_host_endpoint *ep,
         xfer->gfp = gfp;
         xfer->ep = ep;
         urb->hcpriv = xfer;
-        d_printf(2, dev, "xfer %p urb %p pipe 0x%02x [%d bytes] %s %s %s\n",
-                 xfer, urb, urb->pipe, urb->transfer_buffer_length,
-                 urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP ? "dma" : "nodma",
-                 urb->pipe & USB_DIR_IN ? "inbound" : "outbound",
-                 cant_sleep ? "deferred" : "inline");
+
+        dev_dbg(dev, "xfer %p urb %p pipe 0x%02x [%d bytes] %s %s %s\n",
+                xfer, urb, urb->pipe, urb->transfer_buffer_length,
+                urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP ? "dma" : "nodma",
+                urb->pipe & USB_DIR_IN ? "inbound" : "outbound",
+                cant_sleep ? "deferred" : "inline");
+
         if (cant_sleep) {
                 usb_get_urb(urb);
                 spin_lock_irqsave(&wa->xfer_list_lock, my_flags);
@@ -1122,15 +1060,11 @@ int wa_urb_enqueue(struct wahc *wa, struct usb_host_endpoint *ep,
         } else {
                 wa_urb_enqueue_b(xfer);
         }
-        d_fnend(3, dev, "(wa %p ep %p urb %p [%d] gfp 0x%x) = 0\n",
-                wa, ep, urb, urb->transfer_buffer_length, gfp);
         return 0;
 
 error_dequeued:
         kfree(xfer);
 error_kmalloc:
-        d_fnend(3, dev, "(wa %p ep %p urb %p [%d] gfp 0x%x) = %d\n",
-                wa, ep, urb, urb->transfer_buffer_length, gfp, result);
         return result;
 }
 EXPORT_SYMBOL_GPL(wa_urb_enqueue);
@@ -1155,7 +1089,6 @@ EXPORT_SYMBOL_GPL(wa_urb_enqueue);
  */
 int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
 {
-        struct device *dev = &wa->usb_iface->dev;
         unsigned long flags, flags2;
         struct wa_xfer *xfer;
         struct wa_seg *seg;
@@ -1163,9 +1096,6 @@ int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
         unsigned cnt;
         unsigned rpipe_ready = 0;
 
-        d_fnstart(3, dev, "(wa %p, urb %p)\n", wa, urb);
-
-        d_printf(1, dev, "xfer %p urb %p: aborting\n", urb->hcpriv, urb);
         xfer = urb->hcpriv;
         if (xfer == NULL) {
                 /* NOthing setup yet enqueue will see urb->status !=
@@ -1234,13 +1164,11 @@ int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
         wa_xfer_completion(xfer);
         if (rpipe_ready)
                 wa_xfer_delayed_run(rpipe);
-        d_fnend(3, dev, "(wa %p, urb %p) = 0\n", wa, urb);
         return 0;
 
 out_unlock:
         spin_unlock_irqrestore(&xfer->lock, flags);
 out:
-        d_fnend(3, dev, "(wa %p, urb %p) = 0\n", wa, urb);
         return 0;
 
 dequeue_delayed:
@@ -1250,7 +1178,6 @@ dequeue_delayed:
         spin_unlock_irqrestore(&xfer->lock, flags);
         wa_xfer_giveback(xfer);
         usb_put_urb(urb);               /* we got a ref in enqueue() */
-        d_fnend(3, dev, "(wa %p, urb %p) = 0\n", wa, urb);
         return 0;
 }
 EXPORT_SYMBOL_GPL(wa_urb_dequeue);
@@ -1326,7 +1253,6 @@ static void wa_xfer_result_chew(struct wahc *wa, struct wa_xfer *xfer)
         u8 usb_status;
         unsigned rpipe_ready = 0;
 
-        d_fnstart(3, dev, "(wa %p xfer %p)\n", wa, xfer);
         spin_lock_irqsave(&xfer->lock, flags);
         seg_idx = xfer_result->bTransferSegment & 0x7f;
         if (unlikely(seg_idx >= xfer->segs))
@@ -1334,8 +1260,8 @@ static void wa_xfer_result_chew(struct wahc *wa, struct wa_xfer *xfer)
         seg = xfer->seg[seg_idx];
         rpipe = xfer->ep->hcpriv;
         usb_status = xfer_result->bTransferStatus;
-        d_printf(2, dev, "xfer %p#%u: bTransferStatus 0x%02x (seg %u)\n",
-                 xfer, seg_idx, usb_status, seg->status);
+        dev_dbg(dev, "xfer %p#%u: bTransferStatus 0x%02x (seg %u)\n",
+                xfer, seg_idx, usb_status, seg->status);
         if (seg->status == WA_SEG_ABORTED
             || seg->status == WA_SEG_ERROR)     /* already handled */
                 goto segment_aborted;
@@ -1391,10 +1317,8 @@ static void wa_xfer_result_chew(struct wahc *wa, struct wa_xfer *xfer)
                 wa_xfer_completion(xfer);
         if (rpipe_ready)
                 wa_xfer_delayed_run(rpipe);
-        d_fnend(3, dev, "(wa %p xfer %p) = void\n", wa, xfer);
         return;
 
-
 error_submit_buf_in:
         if (edc_inc(&wa->dti_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {
                 dev_err(dev, "DTI: URB max acceptable errors "
@@ -1416,11 +1340,8 @@ error_complete:
                 wa_xfer_completion(xfer);
         if (rpipe_ready)
                 wa_xfer_delayed_run(rpipe);
-        d_fnend(3, dev, "(wa %p xfer %p) = void [segment/DTI-submit error]\n",
-                wa, xfer);
         return;
 
-
 error_bad_seg:
         spin_unlock_irqrestore(&xfer->lock, flags);
         wa_urb_dequeue(wa, xfer->urb);
@@ -1431,17 +1352,11 @@ error_bad_seg:
                         "exceeded, resetting device\n");
                 wa_reset_all(wa);
         }
-        d_fnend(3, dev, "(wa %p xfer %p) = void [bad seg]\n", wa, xfer);
         return;
 
-
 segment_aborted:
         /* nothing to do, as the aborter did the completion */
         spin_unlock_irqrestore(&xfer->lock, flags);
-        d_fnend(3, dev, "(wa %p xfer %p) = void [segment aborted]\n",
-                wa, xfer);
-        return;
-
 }
 
 /*
@@ -1465,15 +1380,14 @@ static void wa_buf_in_cb(struct urb *urb)
         unsigned long flags;
         u8 done = 0;
 
-        d_fnstart(3, NULL, "(urb %p [%d])\n", urb, urb->status);
         switch (urb->status) {
         case 0:
                 spin_lock_irqsave(&xfer->lock, flags);
                 wa = xfer->wa;
                 dev = &wa->usb_iface->dev;
                 rpipe = xfer->ep->hcpriv;
-                d_printf(2, dev, "xfer %p#%u: data in done (%zu bytes)\n",
-                           xfer, seg->index, (size_t)urb->actual_length);
+                dev_dbg(dev, "xfer %p#%u: data in done (%zu bytes)\n",
+                        xfer, seg->index, (size_t)urb->actual_length);
                 seg->status = WA_SEG_DONE;
                 seg->result = urb->actual_length;
                 xfer->segs_done++;
@@ -1514,7 +1428,6 @@ static void wa_buf_in_cb(struct urb *urb)
                 if (rpipe_ready)
                         wa_xfer_delayed_run(rpipe);
         }
-        d_fnend(3, NULL, "(urb %p [%d]) = void\n", urb, urb->status);
 }
 
 /*
@@ -1553,14 +1466,12 @@ static void wa_xfer_result_cb(struct urb *urb)
         struct wa_xfer *xfer;
         u8 usb_status;
 
-        d_fnstart(3, dev, "(%p)\n", wa);
         BUG_ON(wa->dti_urb != urb);
         switch (wa->dti_urb->status) {
         case 0:
                 /* We have a xfer result buffer; check it */
-                d_printf(2, dev, "DTI: xfer result %d bytes at %p\n",
-                           urb->actual_length, urb->transfer_buffer);
-                d_dump(3, dev, urb->transfer_buffer, urb->actual_length);
+                dev_dbg(dev, "DTI: xfer result %d bytes at %p\n",
+                        urb->actual_length, urb->transfer_buffer);
                 if (wa->dti_urb->actual_length != sizeof(*xfer_result)) {
                         dev_err(dev, "DTI Error: xfer result--bad size "
                                 "xfer result (%d bytes vs %zu needed)\n",
@@ -1622,7 +1533,6 @@ static void wa_xfer_result_cb(struct urb *urb)
                 wa_reset_all(wa);
         }
 out:
-        d_fnend(3, dev, "(%p) = void\n", wa);
         return;
 }
 
@@ -1653,7 +1563,6 @@ void wa_handle_notif_xfer(struct wahc *wa, struct wa_notif_hdr *notif_hdr)
         struct wa_notif_xfer *notif_xfer;
         const struct usb_endpoint_descriptor *dti_epd = wa->dti_epd;
 
-        d_fnstart(4, dev, "(%p, %p)\n", wa, notif_hdr);
         notif_xfer = container_of(notif_hdr, struct wa_notif_xfer, hdr);
         BUG_ON(notif_hdr->bNotifyType != WA_NOTIF_TRANSFER);
 
@@ -1693,7 +1602,6 @@ void wa_handle_notif_xfer(struct wahc *wa, struct wa_notif_hdr *notif_hdr)
                 goto error_dti_urb_submit;
         }
 out:
-        d_fnend(4, dev, "(%p, %p) = void\n", wa, notif_hdr);
         return;
 
 error_dti_urb_submit:
@@ -1704,6 +1612,4 @@ error_buf_in_urb_alloc:
 error_dti_urb_alloc:
 error:
         wa_reset_all(wa);
-        d_fnend(4, dev, "(%p, %p) = void\n", wa, notif_hdr);
-        return;
 }