Merge commit 'v3.5-rc5' into next

5 files changed, 104 insertions, 75 deletions

diff --git a/drivers/input/tablet/acecad.c b/drivers/input/tablet/acecad.c
index f8b0b1df9138..e062ec899ca1 100644
--- a/drivers/input/tablet/acecad.c
+++ b/drivers/input/tablet/acecad.c
@@ -51,6 +51,7 @@ struct usb_acecad {
         char name[128];
         char phys[64];
         struct usb_device *usbdev;
+        struct usb_interface *intf;
         struct input_dev *input;
         struct urb *irq;
 
@@ -63,6 +64,7 @@ static void usb_acecad_irq(struct urb *urb)
         struct usb_acecad *acecad = urb->context;
         unsigned char *data = acecad->data;
         struct input_dev *dev = acecad->input;
+        struct usb_interface *intf = acecad->intf;
         int prox, status;
 
         switch (urb->status) {
@@ -73,10 +75,12 @@ static void usb_acecad_irq(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __func__, urb->status);
+                dev_dbg(&intf->dev, "%s - urb shutting down with status: %d\n",
+                        __func__, urb->status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__, urb->status);
+                dev_dbg(&intf->dev, "%s - nonzero urb status received: %d\n",
+                        __func__, urb->status);
                 goto resubmit;
         }
 
@@ -105,8 +109,10 @@ static void usb_acecad_irq(struct urb *urb)
 resubmit:
         status = usb_submit_urb(urb, GFP_ATOMIC);
         if (status)
-                err("can't resubmit intr, %s-%s/input0, status %d",
-                        acecad->usbdev->bus->bus_name, acecad->usbdev->devpath, status);
+                dev_err(&intf->dev,
+                        "can't resubmit intr, %s-%s/input0, status %d\n",
+                        acecad->usbdev->bus->bus_name,
+                        acecad->usbdev->devpath, status);
 }
 
 static int usb_acecad_open(struct input_dev *dev)
@@ -168,6 +174,7 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
         }
 
         acecad->usbdev = dev;
+        acecad->intf = intf;
         acecad->input = input_dev;
 
         if (dev->manufacturer)
diff --git a/drivers/input/tablet/aiptek.c b/drivers/input/tablet/aiptek.c
index a33d3470c47a..ee83c3904ee8 100644
--- a/drivers/input/tablet/aiptek.c
+++ b/drivers/input/tablet/aiptek.c
@@ -309,6 +309,7 @@ struct aiptek_settings {
 struct aiptek {
         struct input_dev *inputdev;             /* input device struct           */
         struct usb_device *usbdev;              /* usb device struct             */
+        struct usb_interface *intf;             /* usb interface struct          */
         struct urb *urb;                        /* urb for incoming reports      */
         dma_addr_t data_dma;                    /* our dma stuffage              */
         struct aiptek_features features;        /* tablet's array of features    */
@@ -435,6 +436,7 @@ static void aiptek_irq(struct urb *urb)
         struct aiptek *aiptek = urb->context;
         unsigned char *data = aiptek->data;
         struct input_dev *inputdev = aiptek->inputdev;
+        struct usb_interface *intf = aiptek->intf;
         int jitterable = 0;
         int retval, macro, x, y, z, left, right, middle, p, dv, tip, bs, pck;
 
@@ -447,13 +449,13 @@ static void aiptek_irq(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* This urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
-                    __func__, urb->status);
+                dev_dbg(&intf->dev, "%s - urb shutting down with status: %d\n",
+                        __func__, urb->status);
                 return;
 
         default:
-                dbg("%s - nonzero urb status received: %d",
-                    __func__, urb->status);
+                dev_dbg(&intf->dev, "%s - nonzero urb status received: %d\n",
+                        __func__, urb->status);
                 goto exit;
         }
 
@@ -785,7 +787,7 @@ static void aiptek_irq(struct urb *urb)
                                  1 | AIPTEK_REPORT_TOOL_UNKNOWN);
                 input_sync(inputdev);
         } else {
-                dbg("Unknown report %d", data[0]);
+                dev_dbg(&intf->dev, "Unknown report %d\n", data[0]);
         }
 
         /* Jitter may occur when the user presses a button on the stlyus
@@ -811,8 +813,9 @@ static void aiptek_irq(struct urb *urb)
 exit:
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval != 0) {
-                err("%s - usb_submit_urb failed with result %d",
-                    __func__, retval);
+                dev_err(&intf->dev,
+                        "%s - usb_submit_urb failed with result %d\n",
+                        __func__, retval);
         }
 }
 
@@ -912,8 +915,9 @@ aiptek_command(struct aiptek *aiptek, unsigned char command, unsigned char data)
 
         if ((ret =
              aiptek_set_report(aiptek, 3, 2, buf, sizeof_buf)) != sizeof_buf) {
-                dbg("aiptek_program: failed, tried to send: 0x%02x 0x%02x",
-                    command, data);
+                dev_dbg(&aiptek->intf->dev,
+                        "aiptek_program: failed, tried to send: 0x%02x 0x%02x\n",
+                        command, data);
         }
         kfree(buf);
         return ret < 0 ? ret : 0;
@@ -947,8 +951,9 @@ aiptek_query(struct aiptek *aiptek, unsigned char command, unsigned char data)
 
         if ((ret =
              aiptek_get_report(aiptek, 3, 2, buf, sizeof_buf)) != sizeof_buf) {
-                dbg("aiptek_query failed: returned 0x%02x 0x%02x 0x%02x",
-                    buf[0], buf[1], buf[2]);
+                dev_dbg(&aiptek->intf->dev,
+                        "aiptek_query failed: returned 0x%02x 0x%02x 0x%02x\n",
+                        buf[0], buf[1], buf[2]);
                 ret = -EIO;
         } else {
                 ret = get_unaligned_le16(buf + 1);
@@ -1726,6 +1731,7 @@ aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id)
 
         aiptek->inputdev = inputdev;
         aiptek->usbdev = usbdev;
+        aiptek->intf = intf;
         aiptek->ifnum = intf->altsetting[0].desc.bInterfaceNumber;
         aiptek->inDelay = 0;
         aiptek->endDelay = 0;
diff --git a/drivers/input/tablet/gtco.c b/drivers/input/tablet/gtco.c
index 89a297801dce..29e01ab6859f 100644
--- a/drivers/input/tablet/gtco.c
+++ b/drivers/input/tablet/gtco.c
@@ -2,8 +2,6 @@
 
 GTCO digitizer USB driver
 
-Use the err() and dbg() macros from usb.h for system logging
-
 TO CHECK:  Is pressure done right on report 5?
 
 Copyright (C) 2006  GTCO CalComp
@@ -108,6 +106,7 @@ struct gtco {
 
         struct input_dev  *inputdevice; /* input device struct pointer  */
         struct usb_device *usbdev; /* the usb device for this device */
+        struct usb_interface *intf;     /* the usb interface for this device */
         struct urb        *urbinfo;      /* urb for incoming reports      */
         dma_addr_t        buf_dma;  /* dma addr of the data buffer*/
         unsigned char *   buffer;   /* databuffer for reports */
@@ -202,6 +201,7 @@ struct hid_descriptor
 static void parse_hid_report_descriptor(struct gtco *device, char * report,
                                         int length)
 {
+        struct device *ddev = &device->intf->dev;
         int   x, i = 0;
 
         /* Tag primitive vars */
@@ -228,7 +228,7 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
         char  indentstr[10] = "";
 
 
-        dbg("======>>>>>>PARSE<<<<<<======");
+        dev_dbg(ddev, "======>>>>>>PARSE<<<<<<======\n");
 
         /* Walk  this report and pull out the info we need */
         while (i < length) {
@@ -277,11 +277,11 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
                                 else if (data == 3)
                                         strcpy(globtype, "Var|Const");
 
-                                dbg("::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits",
-                                    globalval[TAG_GLOB_REPORT_ID], inputnum,
-                                    globalval[TAG_GLOB_LOG_MAX], globalval[TAG_GLOB_LOG_MAX],
-                                    globalval[TAG_GLOB_LOG_MIN], globalval[TAG_GLOB_LOG_MIN],
-                                    globalval[TAG_GLOB_REPORT_SZ] * globalval[TAG_GLOB_REPORT_CNT]);
+                                dev_dbg(ddev, "::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits\n",
+                                        globalval[TAG_GLOB_REPORT_ID], inputnum,
+                                        globalval[TAG_GLOB_LOG_MAX], globalval[TAG_GLOB_LOG_MAX],
+                                        globalval[TAG_GLOB_LOG_MIN], globalval[TAG_GLOB_LOG_MIN],
+                                        globalval[TAG_GLOB_REPORT_SZ] * globalval[TAG_GLOB_REPORT_CNT]);
 
 
                                 /*
@@ -292,7 +292,7 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
                                  */
                                 switch (inputnum) {
                                 case 0:  /* X coord */
-                                        dbg("GER: X Usage: 0x%x", usage);
+                                        dev_dbg(ddev, "GER: X Usage: 0x%x\n", usage);
                                         if (device->max_X == 0) {
                                                 device->max_X = globalval[TAG_GLOB_LOG_MAX];
                                                 device->min_X = globalval[TAG_GLOB_LOG_MIN];
@@ -300,7 +300,7 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
                                         break;
 
                                 case 1:  /* Y coord */
-                                        dbg("GER: Y Usage: 0x%x", usage);
+                                        dev_dbg(ddev, "GER: Y Usage: 0x%x\n", usage);
                                         if (device->max_Y == 0) {
                                                 device->max_Y = globalval[TAG_GLOB_LOG_MAX];
                                                 device->min_Y = globalval[TAG_GLOB_LOG_MIN];
@@ -350,10 +350,10 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
                                 maintype = 'S';
 
                                 if (data == 0) {
-                                        dbg("======>>>>>> Physical");
+                                        dev_dbg(ddev, "======>>>>>> Physical\n");
                                         strcpy(globtype, "Physical");
                                 } else
-                                        dbg("======>>>>>>");
+                                        dev_dbg(ddev, "======>>>>>>\n");
 
                                 /* Indent the debug output */
                                 indent++;
@@ -368,7 +368,7 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
                                 break;
 
                         case TAG_MAIN_COL_END:
-                                dbg("<<<<<<======");
+                                dev_dbg(ddev, "<<<<<<======\n");
                                 maintype = 'E';
                                 indent--;
                                 for (x = 0; x < indent; x++)
@@ -384,18 +384,18 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
 
                         switch (size) {
                         case 1:
-                                dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
-                                    indentstr, tag, maintype, size, globtype, data);
+                                dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
+                                        indentstr, tag, maintype, size, globtype, data);
                                 break;
 
                         case 2:
-                                dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
-                                    indentstr, tag, maintype, size, globtype, data16);
+                                dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
+                                        indentstr, tag, maintype, size, globtype, data16);
                                 break;
 
                         case 4:
-                                dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
-                                    indentstr, tag, maintype, size, globtype, data32);
+                                dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
+                                        indentstr, tag, maintype, size, globtype, data32);
                                 break;
                         }
                         break;
@@ -465,26 +465,26 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
                         if (tag < TAG_GLOB_MAX) {
                                 switch (size) {
                                 case 1:
-                                        dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
-                                            indentstr, globtype, tag, size, data);
+                                        dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
+                                                indentstr, globtype, tag, size, data);
                                         globalval[tag] = data;
                                         break;
 
                                 case 2:
-                                        dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
-                                            indentstr, globtype, tag, size, data16);
+                                        dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
+                                                indentstr, globtype, tag, size, data16);
                                         globalval[tag] = data16;
                                         break;
 
                                 case 4:
-                                        dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
-                                            indentstr, globtype, tag, size, data32);
+                                        dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
+                                                indentstr, globtype, tag, size, data32);
                                         globalval[tag] = data32;
                                         break;
                                 }
                         } else {
-                                dbg("%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d ",
-                                    indentstr, tag, size);
+                                dev_dbg(ddev, "%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d\n",
+                                        indentstr, tag, size);
                         }
                         break;
 
@@ -511,18 +511,18 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
 
                         switch (size) {
                         case 1:
-                                dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
-                                    indentstr, tag, globtype, size, data);
+                                dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
+                                        indentstr, tag, globtype, size, data);
                                 break;
 
                         case 2:
-                                dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
-                                    indentstr, tag, globtype, size, data16);
+                                dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
+                                        indentstr, tag, globtype, size, data16);
                                 break;
 
                         case 4:
-                                dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
-                                    indentstr, tag, globtype, size, data32);
+                                dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
+                                        indentstr, tag, globtype, size, data32);
                                 break;
                         }
 
@@ -714,8 +714,9 @@ static void gtco_urb_callback(struct urb *urbinfo)
                                  * the rest as 0
                                  */
                                 val = device->buffer[5] & MASK_BUTTON;
-                                dbg("======>>>>>>REPORT 1: val 0x%X(%d)",
-                                    val, val);
+                                dev_dbg(&device->intf->dev,
+                                        "======>>>>>>REPORT 1: val 0x%X(%d)\n",
+                                        val, val);
 
                                 /*
                                  * We don't apply any meaning to the button
@@ -808,7 +809,8 @@ static void gtco_urb_callback(struct urb *urbinfo)
  resubmit:
         rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
         if (rc != 0)
-                err("usb_submit_urb failed rc=0x%x", rc);
+                dev_err(&device->intf->dev,
+                        "usb_submit_urb failed rc=0x%x\n", rc);
 }
 
 /*
@@ -838,7 +840,7 @@ static int gtco_probe(struct usb_interface *usbinterface,
         gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
         input_dev = input_allocate_device();
         if (!gtco || !input_dev) {
-                err("No more memory");
+                dev_err(&usbinterface->dev, "No more memory\n");
                 error = -ENOMEM;
                 goto err_free_devs;
         }
@@ -848,12 +850,13 @@ static int gtco_probe(struct usb_interface *usbinterface,
 
         /* Save interface information */
         gtco->usbdev = usb_get_dev(interface_to_usbdev(usbinterface));
+        gtco->intf = usbinterface;
 
         /* Allocate some data for incoming reports */
         gtco->buffer = usb_alloc_coherent(gtco->usbdev, REPORT_MAX_SIZE,
                                           GFP_KERNEL, &gtco->buf_dma);
         if (!gtco->buffer) {
-                err("No more memory for us buffers");
+                dev_err(&usbinterface->dev, "No more memory for us buffers\n");
                 error = -ENOMEM;
                 goto err_free_devs;
         }
@@ -861,7 +864,7 @@ static int gtco_probe(struct usb_interface *usbinterface,
         /* Allocate URB for reports */
         gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
         if (!gtco->urbinfo) {
-                err("Failed to allocate URB");
+                dev_err(&usbinterface->dev, "Failed to allocate URB\n");
                 error = -ENOMEM;
                 goto err_free_buf;
         }
@@ -873,14 +876,14 @@ static int gtco_probe(struct usb_interface *usbinterface,
         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
 
         /* Some debug */
-        dbg("gtco # interfaces: %d", usbinterface->num_altsetting);
-        dbg("num endpoints:     %d", usbinterface->cur_altsetting->desc.bNumEndpoints);
-        dbg("interface class:   %d", usbinterface->cur_altsetting->desc.bInterfaceClass);
-        dbg("endpoint: attribute:0x%x type:0x%x", endpoint->bmAttributes, endpoint->bDescriptorType);
+        dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
+        dev_dbg(&usbinterface->dev, "num endpoints:     %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
+        dev_dbg(&usbinterface->dev, "interface class:   %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
+        dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
         if (usb_endpoint_xfer_int(endpoint))
-                dbg("endpoint: we have interrupt endpoint\n");
+                dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
 
-        dbg("endpoint extra len:%d ", usbinterface->altsetting[0].extralen);
+        dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
 
         /*
          * Find the HID descriptor so we can find out the size of the
@@ -888,17 +891,19 @@ static int gtco_probe(struct usb_interface *usbinterface,
          */
         if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
                                      HID_DEVICE_TYPE, &hid_desc) != 0){
-                err("Can't retrieve exta USB descriptor to get hid report descriptor length");
+                dev_err(&usbinterface->dev,
+                        "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
                 error = -EIO;
                 goto err_free_urb;
         }
 
-        dbg("Extra descriptor success: type:%d  len:%d",
-            hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
+        dev_dbg(&usbinterface->dev,
+                "Extra descriptor success: type:%d  len:%d\n",
+                hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
 
         report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
         if (!report) {
-                err("No more memory for report");
+                dev_err(&usbinterface->dev, "No more memory for report\n");
                 error = -ENOMEM;
                 goto err_free_urb;
         }
@@ -915,7 +920,7 @@ static int gtco_probe(struct usb_interface *usbinterface,
                                          le16_to_cpu(hid_desc->wDescriptorLength),
                                          5000); /* 5 secs */
 
-                dbg("usb_control_msg result: %d", result);
+                dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
                 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
                         parse_hid_report_descriptor(gtco, report, result);
                         break;
@@ -926,8 +931,9 @@ static int gtco_probe(struct usb_interface *usbinterface,
 
         /* If we didn't get the report, fail */
         if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
-                err("Failed to get HID Report Descriptor of size: %d",
-                    hid_desc->wDescriptorLength);
+                dev_err(&usbinterface->dev,
+                        "Failed to get HID Report Descriptor of size: %d\n",
+                        hid_desc->wDescriptorLength);
                 error = -EIO;
                 goto err_free_urb;
         }
diff --git a/drivers/input/tablet/kbtab.c b/drivers/input/tablet/kbtab.c
index 85a5b40333ac..3fba74b9b602 100644
--- a/drivers/input/tablet/kbtab.c
+++ b/drivers/input/tablet/kbtab.c
@@ -33,6 +33,7 @@ struct kbtab {
         dma_addr_t data_dma;
         struct input_dev *dev;
         struct usb_device *usbdev;
+        struct usb_interface *intf;
         struct urb *irq;
         char phys[32];
 };
@@ -53,10 +54,14 @@ static void kbtab_irq(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __func__, urb->status);
+                dev_dbg(&kbtab->intf->dev,
+                        "%s - urb shutting down with status: %d\n",
+                        __func__, urb->status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__, urb->status);
+                dev_dbg(&kbtab->intf->dev,
+                        "%s - nonzero urb status received: %d\n",
+                        __func__, urb->status);
                 goto exit;
         }
 
@@ -80,8 +85,9 @@ static void kbtab_irq(struct urb *urb)
  exit:
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
-                err("%s - usb_submit_urb failed with result %d",
-                     __func__, retval);
+                dev_err(&kbtab->intf->dev,
+                        "%s - usb_submit_urb failed with result %d\n",
+                        __func__, retval);
 }
 
 static struct usb_device_id kbtab_ids[] = {
@@ -131,6 +137,7 @@ static int kbtab_probe(struct usb_interface *intf, const struct usb_device_id *i
                 goto fail2;
 
         kbtab->usbdev = dev;
+        kbtab->intf = intf;
         kbtab->dev = input_dev;
 
         usb_make_path(dev, kbtab->phys, sizeof(kbtab->phys));
diff --git a/drivers/input/tablet/wacom_sys.c b/drivers/input/tablet/wacom_sys.c
index c24ab5468e02..9a854e2d15dc 100644
--- a/drivers/input/tablet/wacom_sys.c
+++ b/drivers/input/tablet/wacom_sys.c
@@ -100,6 +100,7 @@ static int wacom_set_report(struct usb_interface *intf, u8 type, u8 id,
 static void wacom_sys_irq(struct urb *urb)
 {
         struct wacom *wacom = urb->context;
+        struct device *dev = &wacom->intf->dev;
         int retval;
 
         switch (urb->status) {
@@ -110,10 +111,12 @@ static void wacom_sys_irq(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __func__, urb->status);
+                dev_dbg(dev, "%s - urb shutting down with status: %d\n",
+                        __func__, urb->status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__, urb->status);
+                dev_dbg(dev, "%s - nonzero urb status received: %d\n",
+                        __func__, urb->status);
                 goto exit;
         }
 
@@ -123,8 +126,8 @@ static void wacom_sys_irq(struct urb *urb)
         usb_mark_last_busy(wacom->usbdev);
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
-                err ("%s - usb_submit_urb failed with result %d",
-                     __func__, retval);
+                dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
+                        __func__, retval);
 }
 
 static int wacom_open(struct input_dev *dev)