HID: Add and use hid_<level>: dev_<level> equivalents

Neaten current uses of dev_<level> by adding and using
hid specific hid_<level> macros.

Convert existing uses of dev_<level> uses to hid_<level>.
Convert hid-pidff printk uses to hid_<level>.

Remove err_hid and use hid_err instead.

Add missing newlines to logging messages where necessary.
Coalesce format strings.

Add and use pr_fmt(fmt) KBUILD_MODNAME ": " fmt

Other miscellaneous changes:

Add const struct hid_device * argument to hid-core functions
extract() and implement() so hid_<level> can be used by them.
Fix bad indentation in hid-core hid_input_field function
that calls extract() function above.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>

4 files changed, 115 insertions, 123 deletions

diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 5489eab3a6bd..276758f53ab5 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -136,10 +136,10 @@ static void hid_reset(struct work_struct *work)
                         hid_io_error(hid);
                 break;
         default:
-                err_hid("can't reset device, %s-%s/input%d, status %d",
-                                hid_to_usb_dev(hid)->bus->bus_name,
-                                hid_to_usb_dev(hid)->devpath,
-                                usbhid->ifnum, rc);
+                hid_err(hid, "can't reset device, %s-%s/input%d, status %d\n",
+                        hid_to_usb_dev(hid)->bus->bus_name,
+                        hid_to_usb_dev(hid)->devpath,
+                        usbhid->ifnum, rc);
                 /* FALLTHROUGH */
         case -EHOSTUNREACH:
         case -ENODEV:
@@ -278,18 +278,18 @@ static void hid_irq_in(struct urb *urb)
                 hid_io_error(hid);
                 return;
         default:                /* error */
-                dev_warn(&urb->dev->dev, "input irq status %d  "
-                                "received\n", urb->status);
+                hid_warn(urb->dev, "input irq status %d received\n",
+                         urb->status);
         }
 
         status = usb_submit_urb(urb, GFP_ATOMIC);
         if (status) {
                 clear_bit(HID_IN_RUNNING, &usbhid->iofl);
                 if (status != -EPERM) {
-                        err_hid("can't resubmit intr, %s-%s/input%d, status %d",
-                                        hid_to_usb_dev(hid)->bus->bus_name,
-                                        hid_to_usb_dev(hid)->devpath,
-                                        usbhid->ifnum, status);
+                        hid_err(hid, "can't resubmit intr, %s-%s/input%d, status %d\n",
+                                hid_to_usb_dev(hid)->bus->bus_name,
+                                hid_to_usb_dev(hid)->devpath,
+                                usbhid->ifnum, status);
                         hid_io_error(hid);
                 }
         }
@@ -313,7 +313,7 @@ static int hid_submit_out(struct hid_device *hid)
                 dbg_hid("submitting out urb\n");
 
                 if (usb_submit_urb(usbhid->urbout, GFP_ATOMIC)) {
-                        err_hid("usb_submit_urb(out) failed");
+                        hid_err(hid, "usb_submit_urb(out) failed\n");
                         return -1;
                 }
                 usbhid->last_out = jiffies;
@@ -375,7 +375,7 @@ static int hid_submit_ctrl(struct hid_device *hid)
                         usbhid->cr->wValue, usbhid->cr->wIndex, usbhid->cr->wLength);
 
                 if (usb_submit_urb(usbhid->urbctrl, GFP_ATOMIC)) {
-                        err_hid("usb_submit_urb(ctrl) failed");
+                        hid_err(hid, "usb_submit_urb(ctrl) failed\n");
                         return -1;
                 }
                 usbhid->last_ctrl = jiffies;
@@ -413,8 +413,8 @@ static void hid_irq_out(struct urb *urb)
         case -ENOENT:
                 break;
         default:                /* error */
-                dev_warn(&urb->dev->dev, "output irq status %d "
-                                "received\n", urb->status);
+                hid_warn(urb->dev, "output irq status %d received\n",
+                         urb->status);
         }
 
         spin_lock_irqsave(&usbhid->lock, flags);
@@ -466,8 +466,7 @@ static void hid_ctrl(struct urb *urb)
         case -EPIPE:            /* report not available */
                 break;
         default:                /* error */
-                dev_warn(&urb->dev->dev, "ctrl urb status %d "
-                                "received\n", status);
+                hid_warn(urb->dev, "ctrl urb status %d received\n", status);
         }
 
         if (unplug)
@@ -501,13 +500,13 @@ static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *re
 
         if (usbhid->urbout && dir == USB_DIR_OUT && report->type == HID_OUTPUT_REPORT) {
                 if ((head = (usbhid->outhead + 1) & (HID_OUTPUT_FIFO_SIZE - 1)) == usbhid->outtail) {
-                        dev_warn(&hid->dev, "output queue full\n");
+                        hid_warn(hid, "output queue full\n");
                         return;
                 }
 
                 usbhid->out[usbhid->outhead].raw_report = kmalloc(len, GFP_ATOMIC);
                 if (!usbhid->out[usbhid->outhead].raw_report) {
-                        dev_warn(&hid->dev, "output queueing failed\n");
+                        hid_warn(hid, "output queueing failed\n");
                         return;
                 }
                 hid_output_report(report, usbhid->out[usbhid->outhead].raw_report);
@@ -532,14 +531,14 @@ static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *re
         }
 
         if ((head = (usbhid->ctrlhead + 1) & (HID_CONTROL_FIFO_SIZE - 1)) == usbhid->ctrltail) {
-                dev_warn(&hid->dev, "control queue full\n");
+                hid_warn(hid, "control queue full\n");
                 return;
         }
 
         if (dir == USB_DIR_OUT) {
                 usbhid->ctrl[usbhid->ctrlhead].raw_report = kmalloc(len, GFP_ATOMIC);
                 if (!usbhid->ctrl[usbhid->ctrlhead].raw_report) {
-                        dev_warn(&hid->dev, "control queueing failed\n");
+                        hid_warn(hid, "control queueing failed\n");
                         return;
                 }
                 hid_output_report(report, usbhid->ctrl[usbhid->ctrlhead].raw_report);
@@ -590,7 +589,7 @@ static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, un
                 return -1;
 
         if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
-                dev_warn(&dev->dev, "event field not found\n");
+                hid_warn(dev, "event field not found\n");
                 return -1;
         }
 
@@ -722,7 +721,7 @@ void usbhid_init_reports(struct hid_device *hid)
         }
 
         if (err)
-                dev_warn(&hid->dev, "timeout initializing reports\n");
+                hid_warn(hid, "timeout initializing reports\n");
 }
 
 /*
@@ -1140,8 +1139,7 @@ static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *
                 if (usb_endpoint_is_int_in(&interface->endpoint[n].desc))
                         has_in++;
         if (!has_in) {
-                dev_err(&intf->dev, "couldn't find an input interrupt "
-                                "endpoint\n");
+                hid_err(intf, "couldn't find an input interrupt endpoint\n");
                 return -ENODEV;
         }
 
@@ -1213,7 +1211,7 @@ static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *
         ret = hid_add_device(hid);
         if (ret) {
                 if (ret != -ENODEV)
-                        dev_err(&intf->dev, "can't add hid device: %d\n", ret);
+                        hid_err(intf, "can't add hid device: %d\n", ret);
                 goto err_free;
         }
 
diff --git a/drivers/hid/usbhid/hid-pidff.c b/drivers/hid/usbhid/hid-pidff.c
index ef381d79cfa8..f91c136821f7 100644
--- a/drivers/hid/usbhid/hid-pidff.c
+++ b/drivers/hid/usbhid/hid-pidff.c
@@ -22,7 +22,7 @@
 
 /* #define DEBUG */
 
-#define debug(format, arg...) pr_debug("hid-pidff: " format "\n" , ## arg)
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/input.h>
 #include <linux/slab.h>
@@ -220,7 +220,7 @@ static int pidff_rescale_signed(int i, struct hid_field *field)
 static void pidff_set(struct pidff_usage *usage, u16 value)
 {
         usage->value[0] = pidff_rescale(value, 0xffff, usage->field);
-        debug("calculated from %d to %d", value, usage->value[0]);
+        pr_debug("calculated from %d to %d\n", value, usage->value[0]);
 }
 
 static void pidff_set_signed(struct pidff_usage *usage, s16 value)
@@ -235,7 +235,7 @@ static void pidff_set_signed(struct pidff_usage *usage, s16 value)
                         usage->value[0] =
                             pidff_rescale(value, 0x7fff, usage->field);
         }
-        debug("calculated from %d to %d", value, usage->value[0]);
+        pr_debug("calculated from %d to %d\n", value, usage->value[0]);
 }
 
 /*
@@ -259,8 +259,9 @@ static void pidff_set_envelope_report(struct pidff_device *pidff,
         pidff->set_envelope[PID_ATTACK_TIME].value[0] = envelope->attack_length;
         pidff->set_envelope[PID_FADE_TIME].value[0] = envelope->fade_length;
 
-        debug("attack %u => %d", envelope->attack_level,
-              pidff->set_envelope[PID_ATTACK_LEVEL].value[0]);
+        hid_dbg(pidff->hid, "attack %u => %d\n",
+                envelope->attack_level,
+                pidff->set_envelope[PID_ATTACK_LEVEL].value[0]);
 
         usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_ENVELOPE],
                           USB_DIR_OUT);
@@ -466,33 +467,33 @@ static int pidff_request_effect_upload(struct pidff_device *pidff, int efnum)
         pidff->create_new_effect_type->value[0] = efnum;
         usbhid_submit_report(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT],
                           USB_DIR_OUT);
-        debug("create_new_effect sent, type: %d", efnum);
+        hid_dbg(pidff->hid, "create_new_effect sent, type: %d\n", efnum);
 
         pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0;
         pidff->block_load_status->value[0] = 0;
         usbhid_wait_io(pidff->hid);
 
         for (j = 0; j < 60; j++) {
-                debug("pid_block_load requested");
+                hid_dbg(pidff->hid, "pid_block_load requested\n");
                 usbhid_submit_report(pidff->hid, pidff->reports[PID_BLOCK_LOAD],
                                   USB_DIR_IN);
                 usbhid_wait_io(pidff->hid);
                 if (pidff->block_load_status->value[0] ==
                     pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) {
-                        debug("device reported free memory: %d bytes",
-                              pidff->block_load[PID_RAM_POOL_AVAILABLE].value ?
-                                pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1);
+                        hid_dbg(pidff->hid, "device reported free memory: %d bytes\n",
+                                 pidff->block_load[PID_RAM_POOL_AVAILABLE].value ?
+                                 pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1);
                         return 0;
                 }
                 if (pidff->block_load_status->value[0] ==
                     pidff->status_id[PID_BLOCK_LOAD_FULL]) {
-                        debug("not enough memory free: %d bytes",
-                              pidff->block_load[PID_RAM_POOL_AVAILABLE].value ?
+                        hid_dbg(pidff->hid, "not enough memory free: %d bytes\n",
+                                pidff->block_load[PID_RAM_POOL_AVAILABLE].value ?
                                 pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1);
                         return -ENOSPC;
                 }
         }
-        printk(KERN_ERR "hid-pidff: pid_block_load failed 60 times\n");
+        hid_err(pidff->hid, "pid_block_load failed 60 times\n");
         return -EIO;
 }
 
@@ -546,7 +547,8 @@ static int pidff_erase_effect(struct input_dev *dev, int effect_id)
         struct pidff_device *pidff = dev->ff->private;
         int pid_id = pidff->pid_id[effect_id];
 
-        debug("starting to erase %d/%d", effect_id, pidff->pid_id[effect_id]);
+        hid_dbg(pidff->hid, "starting to erase %d/%d\n",
+                effect_id, pidff->pid_id[effect_id]);
         /* Wait for the queue to clear. We do not want a full fifo to
            prevent the effect removal. */
         usbhid_wait_io(pidff->hid);
@@ -604,8 +606,7 @@ static int pidff_upload_effect(struct input_dev *dev, struct ff_effect *effect,
                                 type_id = PID_SAW_DOWN;
                                 break;
                         default:
-                                printk(KERN_ERR
-                                       "hid-pidff: invalid waveform\n");
+                                hid_err(pidff->hid, "invalid waveform\n");
                                 return -EINVAL;
                         }
 
@@ -696,7 +697,7 @@ static int pidff_upload_effect(struct input_dev *dev, struct ff_effect *effect,
                 break;
 
         default:
-                printk(KERN_ERR "hid-pidff: invalid type\n");
+                hid_err(pidff->hid, "invalid type\n");
                 return -EINVAL;
         }
 
@@ -704,7 +705,7 @@ static int pidff_upload_effect(struct input_dev *dev, struct ff_effect *effect,
                 pidff->pid_id[effect->id] =
                     pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];
 
-        debug("uploaded");
+        hid_dbg(pidff->hid, "uploaded\n");
 
         return 0;
 }
@@ -770,14 +771,14 @@ static int pidff_find_fields(struct pidff_usage *usage, const u8 *table,
                 for (i = 0; i < report->maxfield; i++) {
                         if (report->field[i]->maxusage !=
                             report->field[i]->report_count) {
-                                debug("maxusage and report_count do not match, "
-                                      "skipping");
+                                pr_debug("maxusage and report_count do not match, skipping\n");
                                 continue;
                         }
                         for (j = 0; j < report->field[i]->maxusage; j++) {
                                 if (report->field[i]->usage[j].hid ==
                                     (HID_UP_PID | table[k])) {
-                                        debug("found %d at %d->%d", k, i, j);
+                                        pr_debug("found %d at %d->%d\n",
+                                                 k, i, j);
                                         usage[k].field = report->field[i];
                                         usage[k].value =
                                                 &report->field[i]->value[j];
@@ -789,7 +790,7 @@ static int pidff_find_fields(struct pidff_usage *usage, const u8 *table,
                                 break;
                 }
                 if (!found && strict) {
-                        debug("failed to locate %d", k);
+                        pr_debug("failed to locate %d\n", k);
                         return -1;
                 }
         }
@@ -826,8 +827,8 @@ static void pidff_find_reports(struct hid_device *hid, int report_type,
                         continue;
                 ret = pidff_check_usage(report->field[0]->logical);
                 if (ret != -1) {
-                        debug("found usage 0x%02x from field->logical",
-                              pidff_reports[ret]);
+                        hid_dbg(hid, "found usage 0x%02x from field->logical\n",
+                                pidff_reports[ret]);
                         pidff->reports[ret] = report;
                         continue;
                 }
@@ -845,8 +846,9 @@ static void pidff_find_reports(struct hid_device *hid, int report_type,
                         continue;
                 ret = pidff_check_usage(hid->collection[i - 1].usage);
                 if (ret != -1 && !pidff->reports[ret]) {
-                        debug("found usage 0x%02x from collection array",
-                              pidff_reports[ret]);
+                        hid_dbg(hid,
+                                "found usage 0x%02x from collection array\n",
+                                pidff_reports[ret]);
                         pidff->reports[ret] = report;
                 }
         }
@@ -861,7 +863,7 @@ static int pidff_reports_ok(struct pidff_device *pidff)
 
         for (i = 0; i <= PID_REQUIRED_REPORTS; i++) {
                 if (!pidff->reports[i]) {
-                        debug("%d missing", i);
+                        hid_dbg(pidff->hid, "%d missing\n", i);
                         return 0;
                 }
         }
@@ -884,8 +886,7 @@ static struct hid_field *pidff_find_special_field(struct hid_report *report,
                             report->field[i]->logical_minimum == 1)
                                 return report->field[i];
                         else {
-                                printk(KERN_ERR "hid-pidff: logical_minimum "
-                                        "is not 1 as it should be\n");
+                                pr_err("logical_minimum is not 1 as it should be\n");
                                 return NULL;
                         }
                 }
@@ -924,7 +925,7 @@ static int pidff_find_special_keys(int *keys, struct hid_field *fld,
  */
 static int pidff_find_special_fields(struct pidff_device *pidff)
 {
-        debug("finding special fields");
+        hid_dbg(pidff->hid, "finding special fields\n");
 
         pidff->create_new_effect_type =
                 pidff_find_special_field(pidff->reports[PID_CREATE_NEW_EFFECT],
@@ -945,32 +946,30 @@ static int pidff_find_special_fields(struct pidff_device *pidff)
                 pidff_find_special_field(pidff->reports[PID_EFFECT_OPERATION],
                                          0x78, 1);
 
-        debug("search done");
+        hid_dbg(pidff->hid, "search done\n");
 
         if (!pidff->create_new_effect_type || !pidff->set_effect_type) {
-                printk(KERN_ERR "hid-pidff: effect lists not found\n");
+                hid_err(pidff->hid, "effect lists not found\n");
                 return -1;
         }
 
         if (!pidff->effect_direction) {
-                printk(KERN_ERR "hid-pidff: direction field not found\n");
+                hid_err(pidff->hid, "direction field not found\n");
                 return -1;
         }
 
         if (!pidff->device_control) {
-                printk(KERN_ERR "hid-pidff: device control field not found\n");
+                hid_err(pidff->hid, "device control field not found\n");
                 return -1;
         }
 
         if (!pidff->block_load_status) {
-                printk(KERN_ERR
-                       "hid-pidff: block load status field not found\n");
+                hid_err(pidff->hid, "block load status field not found\n");
                 return -1;
         }
 
         if (!pidff->effect_operation_status) {
-                printk(KERN_ERR
-                       "hid-pidff: effect operation field not found\n");
+                hid_err(pidff->hid, "effect operation field not found\n");
                 return -1;
         }
 
@@ -982,23 +981,22 @@ static int pidff_find_special_fields(struct pidff_device *pidff)
 
         if (!PIDFF_FIND_SPECIAL_KEYS(type_id, create_new_effect_type,
                                      effect_types)) {
-                printk(KERN_ERR "hid-pidff: no effect types found\n");
+                hid_err(pidff->hid, "no effect types found\n");
                 return -1;
         }
 
         if (PIDFF_FIND_SPECIAL_KEYS(status_id, block_load_status,
                                     block_load_status) !=
                         sizeof(pidff_block_load_status)) {
-                printk(KERN_ERR
-                       "hidpidff: block load status identifiers not found\n");
+                hid_err(pidff->hid,
+                        "block load status identifiers not found\n");
                 return -1;
         }
 
         if (PIDFF_FIND_SPECIAL_KEYS(operation_id, effect_operation_status,
                                     effect_operation_status) !=
                         sizeof(pidff_effect_operation_status)) {
-                printk(KERN_ERR
-                       "hidpidff: effect operation identifiers not found\n");
+                hid_err(pidff->hid, "effect operation identifiers not found\n");
                 return -1;
         }
 
@@ -1017,8 +1015,8 @@ static int pidff_find_effects(struct pidff_device *pidff,
                 int pidff_type = pidff->type_id[i];
                 if (pidff->set_effect_type->usage[pidff_type].hid !=
                     pidff->create_new_effect_type->usage[pidff_type].hid) {
-                        printk(KERN_ERR "hid-pidff: "
-                               "effect type number %d is invalid\n", i);
+                        hid_err(pidff->hid,
+                                "effect type number %d is invalid\n", i);
                         return -1;
                 }
         }
@@ -1073,27 +1071,23 @@ static int pidff_init_fields(struct pidff_device *pidff, struct input_dev *dev)
         int envelope_ok = 0;
 
         if (PIDFF_FIND_FIELDS(set_effect, PID_SET_EFFECT, 1)) {
-                printk(KERN_ERR
-                       "hid-pidff: unknown set_effect report layout\n");
+                hid_err(pidff->hid, "unknown set_effect report layout\n");
                 return -ENODEV;
         }
 
         PIDFF_FIND_FIELDS(block_load, PID_BLOCK_LOAD, 0);
         if (!pidff->block_load[PID_EFFECT_BLOCK_INDEX].value) {
-                printk(KERN_ERR
-                       "hid-pidff: unknown pid_block_load report layout\n");
+                hid_err(pidff->hid, "unknown pid_block_load report layout\n");
                 return -ENODEV;
         }
 
         if (PIDFF_FIND_FIELDS(effect_operation, PID_EFFECT_OPERATION, 1)) {
-                printk(KERN_ERR
-                       "hid-pidff: unknown effect_operation report layout\n");
+                hid_err(pidff->hid, "unknown effect_operation report layout\n");
                 return -ENODEV;
         }
 
         if (PIDFF_FIND_FIELDS(block_free, PID_BLOCK_FREE, 1)) {
-                printk(KERN_ERR
-                       "hid-pidff: unknown pid_block_free report layout\n");
+                hid_err(pidff->hid, "unknown pid_block_free report layout\n");
                 return -ENODEV;
         }
 
@@ -1105,27 +1099,26 @@ static int pidff_init_fields(struct pidff_device *pidff, struct input_dev *dev)
 
         if (!envelope_ok) {
                 if (test_and_clear_bit(FF_CONSTANT, dev->ffbit))
-                        printk(KERN_WARNING "hid-pidff: "
-                               "has constant effect but no envelope\n");
+                        hid_warn(pidff->hid,
+                                 "has constant effect but no envelope\n");
                 if (test_and_clear_bit(FF_RAMP, dev->ffbit))
-                        printk(KERN_WARNING "hid-pidff: "
-                                "has ramp effect but no envelope\n");
+                        hid_warn(pidff->hid,
+                                 "has ramp effect but no envelope\n");
 
                 if (test_and_clear_bit(FF_PERIODIC, dev->ffbit))
-                        printk(KERN_WARNING "hid-pidff: "
-                                "has periodic effect but no envelope\n");
+                        hid_warn(pidff->hid,
+                                 "has periodic effect but no envelope\n");
         }
 
         if (test_bit(FF_CONSTANT, dev->ffbit) &&
             PIDFF_FIND_FIELDS(set_constant, PID_SET_CONSTANT, 1)) {
-                printk(KERN_WARNING
-                       "hid-pidff: unknown constant effect layout\n");
+                hid_warn(pidff->hid, "unknown constant effect layout\n");
                 clear_bit(FF_CONSTANT, dev->ffbit);
         }
 
         if (test_bit(FF_RAMP, dev->ffbit) &&
             PIDFF_FIND_FIELDS(set_ramp, PID_SET_RAMP, 1)) {
-                printk(KERN_WARNING "hid-pidff: unknown ramp effect layout\n");
+                hid_warn(pidff->hid, "unknown ramp effect layout\n");
                 clear_bit(FF_RAMP, dev->ffbit);
         }
 
@@ -1134,8 +1127,7 @@ static int pidff_init_fields(struct pidff_device *pidff, struct input_dev *dev)
              test_bit(FF_FRICTION, dev->ffbit) ||
              test_bit(FF_INERTIA, dev->ffbit)) &&
             PIDFF_FIND_FIELDS(set_condition, PID_SET_CONDITION, 1)) {
-                printk(KERN_WARNING
-                       "hid-pidff: unknown condition effect layout\n");
+                hid_warn(pidff->hid, "unknown condition effect layout\n");
                 clear_bit(FF_SPRING, dev->ffbit);
                 clear_bit(FF_DAMPER, dev->ffbit);
                 clear_bit(FF_FRICTION, dev->ffbit);
@@ -1144,8 +1136,7 @@ static int pidff_init_fields(struct pidff_device *pidff, struct input_dev *dev)
 
         if (test_bit(FF_PERIODIC, dev->ffbit) &&
             PIDFF_FIND_FIELDS(set_periodic, PID_SET_PERIODIC, 1)) {
-                printk(KERN_WARNING
-                       "hid-pidff: unknown periodic effect layout\n");
+                hid_warn(pidff->hid, "unknown periodic effect layout\n");
                 clear_bit(FF_PERIODIC, dev->ffbit);
         }
 
@@ -1184,12 +1175,12 @@ static void pidff_reset(struct pidff_device *pidff)
         if (pidff->pool[PID_SIMULTANEOUS_MAX].value) {
                 while (pidff->pool[PID_SIMULTANEOUS_MAX].value[0] < 2) {
                         if (i++ > 20) {
-                                printk(KERN_WARNING "hid-pidff: device reports "
-                                       "%d simultaneous effects\n",
-                                       pidff->pool[PID_SIMULTANEOUS_MAX].value[0]);
+                                hid_warn(pidff->hid,
+                                         "device reports %d simultaneous effects\n",
+                                         pidff->pool[PID_SIMULTANEOUS_MAX].value[0]);
                                 break;
                         }
-                        debug("pid_pool requested again");
+                        hid_dbg(pidff->hid, "pid_pool requested again\n");
                         usbhid_submit_report(hid, pidff->reports[PID_POOL],
                                           USB_DIR_IN);
                         usbhid_wait_io(hid);
@@ -1215,7 +1206,7 @@ static int pidff_check_autocenter(struct pidff_device *pidff,
 
         error = pidff_request_effect_upload(pidff, 1);
         if (error) {
-                printk(KERN_ERR "hid-pidff: upload request failed\n");
+                hid_err(pidff->hid, "upload request failed\n");
                 return error;
         }
 
@@ -1224,8 +1215,8 @@ static int pidff_check_autocenter(struct pidff_device *pidff,
                 pidff_autocenter(pidff, 0xffff);
                 set_bit(FF_AUTOCENTER, dev->ffbit);
         } else {
-                printk(KERN_NOTICE "hid-pidff: "
-                       "device has unknown autocenter control method\n");
+                hid_notice(pidff->hid,
+                           "device has unknown autocenter control method\n");
         }
 
         pidff_erase_pid(pidff,
@@ -1248,10 +1239,10 @@ int hid_pidff_init(struct hid_device *hid)
         int max_effects;
         int error;
 
-        debug("starting pid init");
+        hid_dbg(hid, "starting pid init\n");
 
         if (list_empty(&hid->report_enum[HID_OUTPUT_REPORT].report_list)) {
-                debug("not a PID device, no output report");
+                hid_dbg(hid, "not a PID device, no output report\n");
                 return -ENODEV;
         }
 
@@ -1265,7 +1256,7 @@ int hid_pidff_init(struct hid_device *hid)
         pidff_find_reports(hid, HID_FEATURE_REPORT, pidff);
 
         if (!pidff_reports_ok(pidff)) {
-                debug("reports not ok, aborting");
+                hid_dbg(hid, "reports not ok, aborting\n");
                 error = -ENODEV;
                 goto fail;
         }
@@ -1278,8 +1269,8 @@ int hid_pidff_init(struct hid_device *hid)
 
         if (test_bit(FF_GAIN, dev->ffbit)) {
                 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], 0xffff);
-                usbhid_submit_report(pidff->hid, pidff->reports[PID_DEVICE_GAIN],
-                                  USB_DIR_OUT);
+                usbhid_submit_report(hid, pidff->reports[PID_DEVICE_GAIN],
+                                     USB_DIR_OUT);
         }
 
         error = pidff_check_autocenter(pidff, dev);
@@ -1290,23 +1281,23 @@ int hid_pidff_init(struct hid_device *hid)
             pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_maximum -
             pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum +
             1;
-        debug("max effects is %d", max_effects);
+        hid_dbg(hid, "max effects is %d\n", max_effects);
 
         if (max_effects > PID_EFFECTS_MAX)
                 max_effects = PID_EFFECTS_MAX;
 
         if (pidff->pool[PID_SIMULTANEOUS_MAX].value)
-                debug("max simultaneous effects is %d",
-                      pidff->pool[PID_SIMULTANEOUS_MAX].value[0]);
+                hid_dbg(hid, "max simultaneous effects is %d\n",
+                        pidff->pool[PID_SIMULTANEOUS_MAX].value[0]);
 
         if (pidff->pool[PID_RAM_POOL_SIZE].value)
-                debug("device memory size is %d bytes",
-                      pidff->pool[PID_RAM_POOL_SIZE].value[0]);
+                hid_dbg(hid, "device memory size is %d bytes\n",
+                        pidff->pool[PID_RAM_POOL_SIZE].value[0]);
 
         if (pidff->pool[PID_DEVICE_MANAGED_POOL].value &&
             pidff->pool[PID_DEVICE_MANAGED_POOL].value[0] == 0) {
-                printk(KERN_NOTICE "hid-pidff: "
-                       "device does not support device managed pool\n");
+                hid_notice(hid,
+                           "device does not support device managed pool\n");
                 goto fail;
         }
 
@@ -1322,8 +1313,7 @@ int hid_pidff_init(struct hid_device *hid)
         ff->set_autocenter = pidff_set_autocenter;
         ff->playback = pidff_playback;
 
-        printk(KERN_INFO "Force feedback for USB HID PID devices by "
-               "Anssi Hannula <anssi.hannula@gmail.com>\n");
+        hid_info(dev, "Force feedback for USB HID PID devices by Anssi Hannula <anssi.hannula@gmail.com>\n");
 
         return 0;
 
diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c
index a9935f6709f7..fb78f75d49a9 100644
--- a/drivers/hid/usbhid/hiddev.c
+++ b/drivers/hid/usbhid/hiddev.c
@@ -906,7 +906,7 @@ int hiddev_connect(struct hid_device *hid, unsigned int force)
         hiddev->exist = 1;
         retval = usb_register_dev(usbhid->intf, &hiddev_class);
         if (retval) {
-                err_hid("Not able to get a minor for this device.");
+                hid_err(hid, "Not able to get a minor for this device\n");
                 hid->hiddev = NULL;
                 kfree(hiddev);
                 return -1;
diff --git a/drivers/hid/usbhid/usbkbd.c b/drivers/hid/usbhid/usbkbd.c
index a948605564fb..065817329f03 100644
--- a/drivers/hid/usbhid/usbkbd.c
+++ b/drivers/hid/usbhid/usbkbd.c
@@ -24,6 +24,8 @@
  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/module.h>
@@ -104,16 +106,18 @@ static void usb_kbd_irq(struct urb *urb)
                         if (usb_kbd_keycode[kbd->old[i]])
                                 input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0);
                         else
-                                dev_info(&urb->dev->dev,
-                                                "Unknown key (scancode %#x) released.\n", kbd->old[i]);
+                                hid_info(urb->dev,
+                                         "Unknown key (scancode %#x) released.\n",
+                                         kbd->old[i]);
                 }
 
                 if (kbd->new[i] > 3 && memscan(kbd->old + 2, kbd->new[i], 6) == kbd->old + 8) {
                         if (usb_kbd_keycode[kbd->new[i]])
                                 input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1);
                         else
-                                dev_info(&urb->dev->dev,
-                                                "Unknown key (scancode %#x) released.\n", kbd->new[i]);
+                                hid_info(urb->dev,
+                                         "Unknown key (scancode %#x) released.\n",
+                                         kbd->new[i]);
                 }
         }
 
@@ -124,9 +128,9 @@ static void usb_kbd_irq(struct urb *urb)
 resubmit:
         i = usb_submit_urb (urb, GFP_ATOMIC);
         if (i)
-                err_hid ("can't resubmit intr, %s-%s/input0, status %d",
-                                kbd->usbdev->bus->bus_name,
-                                kbd->usbdev->devpath, i);
+                hid_err(urb->dev, "can't resubmit intr, %s-%s/input0, status %d",
+                        kbd->usbdev->bus->bus_name,
+                        kbd->usbdev->devpath, i);
 }
 
 static int usb_kbd_event(struct input_dev *dev, unsigned int type,
@@ -150,7 +154,7 @@ static int usb_kbd_event(struct input_dev *dev, unsigned int type,
         *(kbd->leds) = kbd->newleds;
         kbd->led->dev = kbd->usbdev;
         if (usb_submit_urb(kbd->led, GFP_ATOMIC))
-                err_hid("usb_submit_urb(leds) failed");
+                pr_err("usb_submit_urb(leds) failed\n");
 
         return 0;
 }
@@ -160,7 +164,7 @@ static void usb_kbd_led(struct urb *urb)
         struct usb_kbd *kbd = urb->context;
 
         if (urb->status)
-                dev_warn(&urb->dev->dev, "led urb status %d received\n",
+                hid_warn(urb->dev, "led urb status %d received\n",
                          urb->status);
 
         if (*(kbd->leds) == kbd->newleds)
@@ -169,7 +173,7 @@ static void usb_kbd_led(struct urb *urb)
         *(kbd->leds) = kbd->newleds;
         kbd->led->dev = kbd->usbdev;
         if (usb_submit_urb(kbd->led, GFP_ATOMIC))
-                err_hid("usb_submit_urb(leds) failed");
+                hid_err(urb->dev, "usb_submit_urb(leds) failed\n");
 }
 
 static int usb_kbd_open(struct input_dev *dev)